nicoty/exercism_solutions_archive - Change KOISBSJ3KKEP44EXD6CC3NVTTQLLOBZDONMHTVLGOSTDXUD6SJTQC

35: Refactor WIP solution for Rust track exercise "Sum of Multiples".

Created by Aaw9nJhsNmfzFih9mKyNw9mV8CgERXJkRa1kK1Kx3LQH on October 9, 2021

KOISBSJ3KKEP44EXD6CC3NVTTQLLOBZDONMHTVLGOSTDXUD6SJTQC

Dependencies

In channels

main

Change contents

Replacement in rust/sum-of-multiples/src/lib.rs at line 1 [4.2029]

B:BD[4.2029] → [2.809:847]

mod error_a {
	use std::{error, fmt};

[4.2029]

[2.847]

//! Finds the sum of all the unique multiples of particular numbers up to but not including a specified number.
use std::{error, fmt};

Replacement in rust/sum-of-multiples/src/lib.rs at line 4 [4.2029]

B:BD[2.848] → [2.848:957]

	#[derive(Debug)]
	pub enum CreationError<A> {
		SubsetBiggerThanSet { set: Vec<A>, subset_size: usize },
	}

[2.848]

[2.957]

#[derive(Debug)]
/// Possible error from struct creation.
enum CreationError<A> {
	SubsetBiggerThanSet { set: Vec<A>, subset_size: usize },
}

Replacement in rust/sum-of-multiples/src/lib.rs at line 10 [4.2029]

B:BD[2.958] → [2.958:1277]

	impl<A: std::fmt::Debug> fmt::Display for CreationError<A> {
		fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
			match self {
				CreationError::SubsetBiggerThanSet { set, subset_size } => write!(
					f,
					"Subset can't be bigger than set.\nset: {:?}\nsubset_size: {:?}",
					set, subset_size
				),
			}

[2.958]

[2.1277]

impl<A: std::fmt::Debug> fmt::Display for CreationError<A> {
	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
		match self {
			CreationError::SubsetBiggerThanSet { set, subset_size } => write!(
				f,
				"Subset can't be bigger than set.\nset: {:?}\nsubset_size: {:?}",
				set, subset_size
			),

Deletion in rust/sum-of-multiples/src/lib.rs at line 20 [4.2029]
B:BD[2.1284] → [2.1284:1348]
```
	impl<A: std::fmt::Debug> error::Error for CreationError<A> {}
```

Replacement in rust/sum-of-multiples/src/lib.rs at line 22 [4.2029]

B:BD[2.1351] → [2.1351:1406]

mod combinations {
	use crate::error_a::CreationError;

[2.1351]

[2.1406]

impl<A: std::fmt::Debug> error::Error for CreationError<A> {}

Replacement in rust/sum-of-multiples/src/lib.rs at line 24 [4.2029]

B:BD[2.1407] → [2.1407:1471]

	#[derive(PartialEq)]
	enum State {
		A,
		B,
		C,
		D,
		E,
	}

[2.1407]

[2.1471]

#[derive(PartialEq)]
/// Represents the possible states of a state machine.
enum State {
	A,
	B,
	C,
	D,
	E,
}

Replacement in rust/sum-of-multiples/src/lib.rs at line 34 [4.2029]

B:BD[2.1472] → [2.1472:1625]

	pub struct CombinationsWithoutReplacement<'a, A>
	where
		A: Clone,
	{
		set: &'a [A],
		subset_indices: Vec<usize>,
		index: usize,
		state: State,
	}

[2.1472]

[2.1625]

/// Generates combinations of elements of a set without replacement/repetition of the elements.
/// Implements the [Revolving Door algorithm](http://math0.wvstateu.edu/~baker/cs405/code/RevolvingDoor.html).
struct CombinationsWithoutReplacement<'a, A>
where
	A: Clone,
{
	set: &'a [A],
	subset_indices: Vec<usize>,
	index: usize,
	state: State,
}

Replacement in rust/sum-of-multiples/src/lib.rs at line 46 [4.2029]

B:BD[2.1626] → [2.1626:2263]

	impl<A> CombinationsWithoutReplacement<'_, A>
	where
		A: Clone,
	{
		// R1: Initialise
		pub fn new(
			set: &[A],
			subset_size: usize,
		) -> Result<CombinationsWithoutReplacement<A>, CreationError<A>> {
			if set.len() < subset_size {
				Err(CreationError::SubsetBiggerThanSet {
					set: set.to_owned(),
					subset_size,
				})
			} else {
				Ok(CombinationsWithoutReplacement {
					set,
					subset_indices: {
						let mut a: Vec<usize> = Vec::with_capacity(subset_size + 1);
						for b in 0..subset_size {
							a.push(b);
						}
						a.push(set.len());
						a
					},
					index: 0,
					state: State::A,
				})
			}

[2.1626]

[2.2263]

impl<A> CombinationsWithoutReplacement<'_, A>
where
	A: Clone,
{
	// R1: Initialise
	/// # Arguments
	///
	/// * `set`: Set to generate combinations of.
	/// * `subset_size`: Size of subsets containing the combinations to output.
	fn new(
		set: &[A],
		subset_size: usize,
	) -> Result<CombinationsWithoutReplacement<A>, CreationError<A>> {
		if set.len() < subset_size {
			Err(CreationError::SubsetBiggerThanSet {
				set: set.to_owned(),
				subset_size,
			})
		} else {
			Ok(CombinationsWithoutReplacement {
				set,
				subset_indices: {
					let mut a: Vec<usize> = Vec::with_capacity(subset_size + 1);
					for b in 0..subset_size {
						a.push(b);
					}
					a.push(set.len());
					a
				},
				index: 0,
				state: State::A,
			})

Insertion in rust/sum-of-multiples/src/lib.rs at line 79 [4.2029]
[2.2267]
[2.2267]
```
	}
```

Replacement in rust/sum-of-multiples/src/lib.rs at line 81 [4.2029]

B:BD[2.2268] → [2.2268:2623]

		// R2: State::A
		fn visit(&mut self) -> Option<Vec<A>> {
			match self.subset_indices.len() - 1 {
				0 => Some(vec![]),
				1 => {
					self.index += 1;
					if self.index > self.set.len() {
						self.state = State::E;
						None
					} else {
						Some(vec![self.set[self.index - 1].clone()])
					}
				}
				index if index == self.set.len() => {

[2.2268]

[2.2623]

	// R2: State::A
	fn visit(&mut self) -> Option<Vec<A>> {
		match self.subset_indices.len() - 1 {
			0 => Some(vec![]),
			1 => {
				self.index += 1;
				if self.index > self.set.len() {

Replacement in rust/sum-of-multiples/src/lib.rs at line 89 [4.2029]

B:BD[2.2651] → [2.2651:2883]

					Some(self.set.to_vec())
				}
				_ => {
					self.state = State::B;
					Some(
						self.subset_indices[0..self.subset_indices.len() - 1]
							.iter()
							.map(|index| self.set[*index].clone())
							.collect(),
					)

[2.2651]

[2.2883]

					None
				} else {
					Some(vec![self.set[self.index - 1].clone()])

Insertion in rust/sum-of-multiples/src/lib.rs at line 93 [4.2029]

[2.2889]

			}
			index if index == self.set.len() => {
				self.state = State::E;
				Some(self.set.to_vec())
			}
			_ => {
				self.state = State::B;
				Some(
					self.subset_indices[0..self.subset_indices.len() - 1]
						.iter()
						.map(|&index| self.set[index].clone())
						.collect(),
				)

Insertion in rust/sum-of-multiples/src/lib.rs at line 108 [4.2029]
[2.2898]
[2.2898]
```
	}
```

Replacement in rust/sum-of-multiples/src/lib.rs at line 110 [4.2029]

B:BD[2.2899] → [2.2899:3261]

		// R3: State::B
		fn easy_cases(&mut self) {
			if (self.subset_indices.len() - 1) & 1 == 1 {
				if self.subset_indices[0] + 1 < self.subset_indices[1] {
					self.subset_indices[0] += 1;
					self.state = State::A;
				} else {
					self.index = 1;
					self.state = State::C;
				}
			} else if self.subset_indices[0] > 0 {
				self.subset_indices[0] -= 1;

[2.2899]

[2.3261]

	// R3: State::B
	fn easy_cases(&mut self) {
		if (self.subset_indices.len() - 1) & 1 == 1 {
			if self.subset_indices[0] + 1 < self.subset_indices[1] {
				self.subset_indices[0] += 1;

Replacement in rust/sum-of-multiples/src/lib.rs at line 118 [4.2029]
B:BD[2.3320] → [2.3320:3347]
```
				self.state = State::D;
```
[2.3320]
[2.3347]
```
				self.state = State::C;
```

Insertion in rust/sum-of-multiples/src/lib.rs at line 120 [4.2029]

[2.3352]

		} else if self.subset_indices[0] > 0 {
			self.subset_indices[0] -= 1;
			self.state = State::A;
		} else {
			self.index = 1;
			self.state = State::D;

Insertion in rust/sum-of-multiples/src/lib.rs at line 127 [4.2029]
[2.3356]
[2.3356]
```
	}
```

Replacement in rust/sum-of-multiples/src/lib.rs at line 129 [4.2029]

B:BD[2.3357] → [2.3357:3696]

		// R4: State::C
		fn try_to_decrease_at_index(&mut self) {
			if self.subset_indices[self.index] > self.index {
				self.subset_indices[self.index] = self.subset_indices[self.index - 1];
				self.subset_indices[self.index - 1] = self.index - 1;
				self.state = State::A;
			} else {
				self.index += 1;
				self.state = State::D;
			}

[2.3357]

[2.3696]

	// R4: State::C
	fn try_to_decrease_at_index(&mut self) {
		if self.subset_indices[self.index] > self.index {
			self.subset_indices[self.index] = self.subset_indices[self.index - 1];
			self.subset_indices[self.index - 1] = self.index - 1;
			self.state = State::A;
		} else {
			self.index += 1;
			self.state = State::D;

Insertion in rust/sum-of-multiples/src/lib.rs at line 139 [4.2029]
[2.3700]
[2.3700]
```
	}
```

Replacement in rust/sum-of-multiples/src/lib.rs at line 141 [4.2029]

B:BD[2.3701] → [2.3701:3988]

		// R5: State::D
		fn try_to_increase_at_index(&mut self) {
			if self.subset_indices[self.index] + 1 < self.subset_indices[self.index + 1] {
				self.subset_indices[self.index - 1] = self.subset_indices[self.index];
				self.subset_indices[self.index] += 1;
				self.state = State::A;

[2.3701]

[2.3988]

	// R5: State::D
	fn try_to_increase_at_index(&mut self) {
		if self.subset_indices[self.index] + 1 < self.subset_indices[self.index + 1] {
			self.subset_indices[self.index - 1] = self.subset_indices[self.index];
			self.subset_indices[self.index] += 1;
			self.state = State::A;
		} else {
			self.index += 1;
			if self.index < (self.subset_indices.len() - 1) {
				self.state = State::C;

Replacement in rust/sum-of-multiples/src/lib.rs at line 152 [4.2029]

B:BD[2.4000] → [2.4000:4162]

				self.index += 1;
				if self.index < (self.subset_indices.len() - 1) {
					self.state = State::C;
				} else {
					// End
					self.state = State::E;
				}

[2.4000]

[2.4162]

				// End
				self.state = State::E;

Insertion in rust/sum-of-multiples/src/lib.rs at line 157 [4.2029]
[2.4174]
[2.4174]
```
}
```

Replacement in rust/sum-of-multiples/src/lib.rs at line 159 [4.2029]

B:BD[2.4175] → [2.4175:4279]

	impl<A> Iterator for CombinationsWithoutReplacement<'_, A>
	where
		A: Clone,
	{
		type Item = Vec<A>;

[2.4175]

[2.4279]

impl<A> Iterator for CombinationsWithoutReplacement<'_, A>
where
	A: Clone,
{
	type Item = Vec<A>;

Replacement in rust/sum-of-multiples/src/lib.rs at line 165 [4.2029]

B:BD[2.4280] → [2.4280:4663]

		fn next(&mut self) -> Option<Self::Item> {
			match self.state {
				State::A => self.visit(),
				State::E => None,
				_ => {
					while self.state != State::A && self.state != State::E {
						match self.state {
							State::B => self.easy_cases(),
							State::C => self.try_to_decrease_at_index(),
							State::D => self.try_to_increase_at_index(),
							_ => (),
						}

[2.4280]

[2.4663]

	fn next(&mut self) -> Option<Self::Item> {
		match self.state {
			State::A => self.visit(),
			State::E => None,
			_ => {
				while self.state != State::A && self.state != State::E {
					match self.state {
						State::B => self.easy_cases(),
						State::C => self.try_to_decrease_at_index(),
						State::D => self.try_to_increase_at_index(),
						_ => (),

Deletion in rust/sum-of-multiples/src/lib.rs at line 177 [4.2029]
B:BD[2.4670] → [2.4670:4687]
```
					self.next()
```
Insertion in rust/sum-of-multiples/src/lib.rs at line 178 [4.2029]
[2.4693]
[2.4693]
```
				self.next()
```
Replacement in rust/sum-of-multiples/src/lib.rs at line 184 [4.2029]
B:BD[2.4708] → [2.4708:4748]
```
mod num_traits {
	pub trait Unsigned {}
```
[2.4708]
[2.4748]
```
trait Unsigned {}
impl Unsigned for u32 {}
```

Replacement in rust/sum-of-multiples/src/lib.rs at line 188 [4.2029]

B:BD[2.4749] → [2.4749:4775]

	impl Unsigned for u32 {}

[2.4749]

[2.4775]

#[derive(Debug)]
/// Returns the multiples of a number up to but not including a specified limit.
struct UnsignedMultiples<A>
where
	A: Copy + Unsigned,
{
	factor: A,
	limit: A,
	out: A,

Replacement in rust/sum-of-multiples/src/lib.rs at line 199 [4.2029]

B:BD[2.4778] → [2.4778:5141]

mod multiples {
	use crate::num_traits::Unsigned;
	#[derive(Debug)]
	pub struct UnsignedMultiples<A>
	where
		A: Copy + Unsigned,
	{
		factor: A,
		limit: A,
		out: A,
	}
	impl<A> UnsignedMultiples<A>
	where
		A: Copy + Unsigned,
	{
		pub fn new(factor: A, limit: A) -> UnsignedMultiples<A> {
			UnsignedMultiples {
				factor,
				limit,
				out: factor,
			}

[2.4778]

[2.5141]

impl<A> UnsignedMultiples<A>
where
	A: Copy + Unsigned,
{
	/// # Arguments
	///
	/// * `factor`: Number to generate multiples of.
	/// * `limit`: Number at which no more multiples will be generated.
	fn new(factor: A, limit: A) -> UnsignedMultiples<A> {
		UnsignedMultiples {
			factor,
			limit,
			out: factor,

Insertion in rust/sum-of-multiples/src/lib.rs at line 214 [4.2029]
[2.5148]
[2.5148]
```
}
```

Replacement in rust/sum-of-multiples/src/lib.rs at line 216 [4.2029]

B:BD[2.5149] → [2.5149:5306]

	impl<A> Iterator for UnsignedMultiples<A>
	where
		A: core::ops::AddAssign + core::ops::Sub<Output = A> + Copy + PartialOrd + Unsigned,
	{
		type Item = A;

[2.5149]

[2.5306]

impl<A> Iterator for UnsignedMultiples<A>
where
	A: core::ops::AddAssign + core::ops::Sub<Output = A> + Copy + PartialOrd + Unsigned,
{
	type Item = A;

Replacement in rust/sum-of-multiples/src/lib.rs at line 222 [4.2029]

B:BD[2.5307] → [2.5307:5470]

		fn next(&mut self) -> Option<Self::Item> {
			if self.out < self.limit {
				self.out += self.factor;
				Some(self.out - self.factor)
			} else {
				None
			}

[2.5307]

[2.5470]

	fn next(&mut self) -> Option<Self::Item> {
		if self.out < self.limit {
			let out = self.out;
			self.out += self.factor;
			Some(out)
		} else {
			None

Deletion in rust/sum-of-multiples/src/lib.rs at line 232 [4.2029]

B:BD[2.5479] → [2.5479:5598]


use crate::{
	combinations::CombinationsWithoutReplacement, error_a::CreationError,
	multiples::UnsignedMultiples,
};

Insertion in rust/sum-of-multiples/src/lib.rs at line 251 [4.2029]

[2.6385]

[4.2030]

/// Finds the sum of all the unique multiples of particular numbers up to but not including a specified number.

Replacement in rust/sum-of-multiples/src/lib.rs at line 253 [4.2029]

B:BD[4.2092] → [2.6386:6409]

	let factors = factors

[4.2092]

[2.6409]

	let mut factors = factors.to_vec();
	factors.sort_unstable();
	let mut done: Vec<u32> = Vec::with_capacity(factors.len());
	let mut out: Vec<u32> = Vec::with_capacity(factors.len());
	factors

Replacement in rust/sum-of-multiples/src/lib.rs at line 260 [4.2029]

B:BD[2.6431] → [2.6431:6515]

		.filter(|factor| *factor != 0)
		.collect::<Vec<u32>>();
	if factors.is_empty() {

[2.6431]

[2.6515]

		.filter(|&factor| factor != 0)
		.for_each(|factor| {
			if done.iter().all(|&done_factor| factor % done_factor != 0) {
				out.push(factor);
			}
			done.push(factor);
		});
	if out.is_empty() {

Replacement in rust/sum-of-multiples/src/lib.rs at line 270 [4.2029]
B:BD[2.6529] → [2.6529:6577]
```
		sum_of_multiples_go(&factors, limit).unwrap()
```
[2.6529]
[2.6577]
```
		sum_of_multiples_go(&out, limit).unwrap()
```
Insertion in rust/nth-prime/src/lib.rs at line 1 [5.452]
[5.452]
[6.128]
```
use std::convert::TryInto;
```

Insertion in rust/nth-prime/src/lib.rs at line 9 [5.452]

[3.54]

[7.0]


TODO:
* Use bases 2, 3, 5, 7 for wheel factorisation.
* Implement segmented sieve algorithm.
* Multi-thread with Mutex and lazy_static.
* Use bitbox from bitvec for bit compression.

Insertion in rust/nth-prime/src/lib.rs at line 16 [5.452]
[7.3]
[5.453]

Replacement in rust/nth-prime/src/lib.rs at line 31 [5.452]

B:BD[7.264] → [3.55:309]

	// Approximated size of the list required using the inverse of an approximation of the prime-counting function, halved (as we're only interested in odd numbers).
	let list_size = (corrected_n * (corrected_n * corrected_n.ln()).ln() / 2.0) as usize + 1;

[7.264]

[6.984]

	// Approximated size of the list required using the inverse of an approximation of the prime-counting function, halved (as we're only interested in odd numbers). Lossy cast.
	let list_size = (corrected_n * (corrected_n * corrected_n.ln()).ln() / 2.0).ceil() as usize;

Replacement in rust/nth-prime/src/lib.rs at line 39 [5.452]

B:BD[6.1133] → [6.1133:1175]

		(list_size as f64).sqrt() as usize + 1,

[6.1133]

[3.310]

		// Lossy cast.
		(list_size as f64).sqrt().ceil() as usize,

Replacement in rust/nth-prime/src/lib.rs at line 49 [5.452]

B:BD[6.1291] → [8.826:887]

B:BD[8.887] → [3.362:397]

				// Might panic if values greater than u32::MAX are cast.
				return (index * 2 + 1) as u32;

[6.1291]

[9.26]

				// Might panic if values greater than u32::MAX are converted.
				return (index * 2 + 1).try_into().unwrap();

Replacement in rust/nth-prime/src/lib.rs at line 61 [5.452]

B:BD[9.124] → [8.951:1012]

B:BD[8.1012] → [3.575:610]

				// Might panic if values greater than u32::MAX are cast.
				return (index * 2 + 1) as u32;

[9.124]

[10.574]

				// Might panic if values greater than u32::MAX are converted.
				return (index * 2 + 1).try_into().unwrap();