Playground/euler
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Run cargo fmt

Browse Source
This commit is contained in:
Fabian Schmidt 2024-11-18 08:41:59 +01:00
parent 5378beb5af
commit 14b8764ee5
23 changed files with 258 additions and 158 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

110
src/bin/problem_11.rs
View File

@ -1,38 +1,87 @@
fn main() { fn main() {
let grid = get_grid(); let grid = get_grid();
let greatests = [find_h(grid.clone()), find_v(grid.clone()), find_diag_lr(grid.clone()), find_diag_rl(grid)]; let greatests = [
find_h(grid.clone()),
find_v(grid.clone()),
find_diag_lr(grid.clone()),
find_diag_rl(grid),
];
println!("{}", greatests.iter().max().unwrap()); println!("{}", greatests.iter().max().unwrap());
} }
fn get_grid() -> Vec<Vec<usize>> { fn get_grid() -> Vec<Vec<usize>> {
vec![ vec![
vec![08, 02, 22, 97, 38, 15, 00, 40, 00, 75, 04, 05, 07, 78, 52, 12, 50, 77, 91, 08], vec![
vec![49, 49, 99, 40, 17, 81, 18, 57, 60, 87, 17, 40, 98, 43, 69, 48, 04, 56, 62, 00], 08, 02, 22, 97, 38, 15, 00, 40, 00, 75, 04, 05, 07, 78, 52, 12, 50, 77, 91, 08,
vec![81, 49, 31, 73, 55, 79, 14, 29, 93, 71, 40, 67, 53, 88, 30, 03, 49, 13, 36, 65], ],
vec![52, 70, 95, 23, 04, 60, 11, 42, 69, 24, 68, 56, 01, 32, 56, 71, 37, 02, 36, 91], vec![
vec![22, 31, 16, 71, 51, 67, 63, 89, 41, 92, 36, 54, 22, 40, 40, 28, 66, 33, 13, 80], 49, 49, 99, 40, 17, 81, 18, 57, 60, 87, 17, 40, 98, 43, 69, 48, 04, 56, 62, 00,
vec![24, 47, 32, 60, 99, 03, 45, 02, 44, 75, 33, 53, 78, 36, 84, 20, 35, 17, 12, 50], ],
vec![32, 98, 81, 28, 64, 23, 67, 10, 26, 38, 40, 67, 59, 54, 70, 66, 18, 38, 64, 70], vec![
vec![67, 26, 20, 68, 02, 62, 12, 20, 95, 63, 94, 39, 63, 08, 40, 91, 66, 49, 94, 21], 81, 49, 31, 73, 55, 79, 14, 29, 93, 71, 40, 67, 53, 88, 30, 03, 49, 13, 36, 65,
vec![24, 55, 58, 05, 66, 73, 99, 26, 97, 17, 78, 78, 96, 83, 14, 88, 34, 89, 63, 72], ],
vec![21, 36, 23, 09, 75, 00, 76, 44, 20, 45, 35, 14, 00, 61, 33, 97, 34, 31, 33, 95], vec![
vec![78, 17, 53, 28, 22, 75, 31, 67, 15, 94, 03, 80, 04, 62, 16, 14, 09, 53, 56, 92], 52, 70, 95, 23, 04, 60, 11, 42, 69, 24, 68, 56, 01, 32, 56, 71, 37, 02, 36, 91,
vec![16, 39, 05, 42, 96, 35, 31, 47, 55, 58, 88, 24, 00, 17, 54, 24, 36, 29, 85, 57], ],
vec![86, 56, 00, 48, 35, 71, 89, 07, 05, 44, 44, 37, 44, 60, 21, 58, 51, 54, 17, 58], vec![
vec![19, 80, 81, 68, 05, 94, 47, 69, 28, 73, 92, 13, 86, 52, 17, 77, 04, 89, 55, 40], 22, 31, 16, 71, 51, 67, 63, 89, 41, 92, 36, 54, 22, 40, 40, 28, 66, 33, 13, 80,
vec![04, 52, 08, 83, 97, 35, 99, 16, 07, 97, 57, 32, 16, 26, 26, 79, 33, 27, 98, 66], ],
vec![88, 36, 68, 87, 57, 62, 20, 72, 03, 46, 33, 67, 46, 55, 12, 32, 63, 93, 53, 69], vec![
vec![04, 42, 16, 73, 38, 25, 39, 11, 24, 94, 72, 18, 08, 46, 29, 32, 40, 62, 76, 36], 24, 47, 32, 60, 99, 03, 45, 02, 44, 75, 33, 53, 78, 36, 84, 20, 35, 17, 12, 50,
vec![20, 69, 36, 41, 72, 30, 23, 88, 34, 62, 99, 69, 82, 67, 59, 85, 74, 04, 36, 16], ],
vec![20, 73, 35, 29, 78, 31, 90, 01, 74, 31, 49, 71, 48, 86, 81, 16, 23, 57, 05, 54], vec![
vec![01, 70, 54, 71, 83, 51, 54, 69, 16, 92, 33, 48, 61, 43, 52, 01, 89, 19, 67, 48], 32, 98, 81, 28, 64, 23, 67, 10, 26, 38, 40, 67, 59, 54, 70, 66, 18, 38, 64, 70,
],
vec![
67, 26, 20, 68, 02, 62, 12, 20, 95, 63, 94, 39, 63, 08, 40, 91, 66, 49, 94, 21,
],
vec![
24, 55, 58, 05, 66, 73, 99, 26, 97, 17, 78, 78, 96, 83, 14, 88, 34, 89, 63, 72,
],
vec![
21, 36, 23, 09, 75, 00, 76, 44, 20, 45, 35, 14, 00, 61, 33, 97, 34, 31, 33, 95,
],
vec![
78, 17, 53, 28, 22, 75, 31, 67, 15, 94, 03, 80, 04, 62, 16, 14, 09, 53, 56, 92,
],
vec![
16, 39, 05, 42, 96, 35, 31, 47, 55, 58, 88, 24, 00, 17, 54, 24, 36, 29, 85, 57,
],
vec![
86, 56, 00, 48, 35, 71, 89, 07, 05, 44, 44, 37, 44, 60, 21, 58, 51, 54, 17, 58,
],
vec![
19, 80, 81, 68, 05, 94, 47, 69, 28, 73, 92, 13, 86, 52, 17, 77, 04, 89, 55, 40,
],
vec![
04, 52, 08, 83, 97, 35, 99, 16, 07, 97, 57, 32, 16, 26, 26, 79, 33, 27, 98, 66,
],
vec![
88, 36, 68, 87, 57, 62, 20, 72, 03, 46, 33, 67, 46, 55, 12, 32, 63, 93, 53, 69,
],
vec![
04, 42, 16, 73, 38, 25, 39, 11, 24, 94, 72, 18, 08, 46, 29, 32, 40, 62, 76, 36,
],
vec![
20, 69, 36, 41, 72, 30, 23, 88, 34, 62, 99, 69, 82, 67, 59, 85, 74, 04, 36, 16,
],
vec![
20, 73, 35, 29, 78, 31, 90, 01, 74, 31, 49, 71, 48, 86, 81, 16, 23, 57, 05, 54,
],
vec![
01, 70, 54, 71, 83, 51, 54, 69, 16, 92, 33, 48, 61, 43, 52, 01, 89, 19, 67, 48,
],
] ]
} }
fn find_h(grid: Vec<Vec<usize>>) -> usize { fn find_h(grid: Vec<Vec<usize>>) -> usize {
let mut greatest = 0; let mut greatest = 0;
for line in grid { for line in grid {
let greatest_in_line = line.windows(4).map(|nums| { nums.iter().product::<usize>() }).max().unwrap(); let greatest_in_line = line
.windows(4)
.map(|nums| nums.iter().product::<usize>())
.max()
.unwrap();
if greatest_in_line > greatest { if greatest_in_line > greatest {
greatest = greatest_in_line; greatest = greatest_in_line;
} }
@ -45,7 +94,10 @@ fn find_v(grid: Vec<Vec<usize>>) -> usize {
let side_len = grid.len(); let side_len = grid.len();
for line_quadruplets in grid.windows(4) { for line_quadruplets in grid.windows(4) {
for idx in 0..side_len { for idx in 0..side_len {
let prod = line_quadruplets[0][idx] * line_quadruplets[1][idx] * line_quadruplets[2][idx] * line_quadruplets[3][idx]; let prod = line_quadruplets[0][idx]
* line_quadruplets[1][idx]
* line_quadruplets[2][idx]
* line_quadruplets[3][idx];
if prod > greatest { if prod > greatest {
greatest = prod; greatest = prod;
} }
@ -58,8 +110,11 @@ fn find_diag_lr(grid: Vec<Vec<usize>>) -> usize {
let mut greatest = 0; let mut greatest = 0;
let side_len = grid.len(); let side_len = grid.len();
for line_quadruplets in grid.windows(4) { for line_quadruplets in grid.windows(4) {
for idx in 0..side_len-3 { for idx in 0..side_len - 3 {
let prod = line_quadruplets[0][idx] * line_quadruplets[1][idx+1] * line_quadruplets[2][idx+2] * line_quadruplets[3][idx+3]; let prod = line_quadruplets[0][idx]
* line_quadruplets[1][idx + 1]
* line_quadruplets[2][idx + 2]
* line_quadruplets[3][idx + 3];
if prod > greatest { if prod > greatest {
greatest = prod; greatest = prod;
} }
@ -73,7 +128,10 @@ fn find_diag_rl(grid: Vec<Vec<usize>>) -> usize {
let side_len = grid.len(); let side_len = grid.len();
for line_quadruplets in grid.windows(4) { for line_quadruplets in grid.windows(4) {
for idx in 3..side_len { for idx in 3..side_len {
let prod = line_quadruplets[0][idx] * line_quadruplets[1][idx-1] * line_quadruplets[2][idx-2] * line_quadruplets[3][idx-3]; let prod = line_quadruplets[0][idx]
* line_quadruplets[1][idx - 1]
* line_quadruplets[2][idx - 2]
* line_quadruplets[3][idx - 3];
if prod > greatest { if prod > greatest {
greatest = prod; greatest = prod;
} }

2
src/bin/problem_12.rs
View File

@ -7,7 +7,7 @@ fn main() {
println!("{triangular_num}"); println!("{triangular_num}");
break; break;
} }
n +=1; n += 1;
} }
} }

3
src/bin/problem_14.rs
View File

@ -10,7 +10,7 @@ fn collatz_seq(start: usize) -> Vec<usize> {
if curr == 1 { if curr == 1 {
break; break;
} }
if curr % 2 == 0{ if curr % 2 == 0 {
curr /= 2; curr /= 2;
} else { } else {
curr = 3 * curr + 1; curr = 3 * curr + 1;
@ -32,4 +32,3 @@ fn find_longest(max_start: usize) -> usize {
biggest.0 biggest.0
} }

6
src/bin/problem_15.rs
View File

@ -3,8 +3,8 @@ use project_euler::number::Number;
fn main() { fn main() {
let width = Number::from(20); let width = Number::from(20);
let height = Number::from(20); let height = Number::from(20);
let a = (width.clone()+height.clone()).fact(); let a = (width.clone() + height.clone()).fact();
let b = width.clone().fact()*height.clone().fact(); let b = width.clone().fact() * height.clone().fact();
let euler_15 = a/b; let euler_15 = a / b;
println!("({width}+{height})!/{width}!*{height}!={euler_15}"); println!("({width}+{height})!/{width}!*{height}!={euler_15}");
} }

1
src/bin/problem_16.rs
View File

@ -15,4 +15,3 @@ fn get_power(exp: usize) -> Number {
} }
number number
} }

26
src/bin/problem_17.rs
View File

@ -8,41 +8,40 @@ fn main() {
println!("{num_letters}"); println!("{num_letters}");
} }
fn number_to_words(n: Number) -> String { fn number_to_words(n: Number) -> String {
let mut number_string = String::new(); let mut number_string = String::new();
let digits = n.clone().digits; let digits = n.clone().digits;
for (pos, &digit) in digits.iter().enumerate() { for (pos, &digit) in digits.iter().enumerate() {
if digits.len() > 1 && digits.len() - 2 == pos { if digits.len() > 1 && digits.len() - 2 == pos {
if digit == 1 { if digit == 1 {
if digits[digits.len()-1] == 0 { if digits[digits.len() - 1] == 0 {
number_string.push_str("ten"); number_string.push_str("ten");
} }
if digits[digits.len()-1] == 1 { if digits[digits.len() - 1] == 1 {
number_string.push_str("eleven"); number_string.push_str("eleven");
} }
if digits[digits.len()-1] == 2 { if digits[digits.len() - 1] == 2 {
number_string.push_str("twelve"); number_string.push_str("twelve");
} }
if digits[digits.len()-1] == 3 { if digits[digits.len() - 1] == 3 {
number_string.push_str("thirteen"); number_string.push_str("thirteen");
} }
if digits[digits.len()-1] == 4 { if digits[digits.len() - 1] == 4 {
number_string.push_str("fourteen"); number_string.push_str("fourteen");
} }
if digits[digits.len()-1] == 5 { if digits[digits.len() - 1] == 5 {
number_string.push_str("fifteen"); number_string.push_str("fifteen");
} }
if digits[digits.len()-1] == 6 { if digits[digits.len() - 1] == 6 {
number_string.push_str("sixteen"); number_string.push_str("sixteen");
} }
if digits[digits.len()-1] == 7 { if digits[digits.len() - 1] == 7 {
number_string.push_str("seventeen"); number_string.push_str("seventeen");
} }
if digits[digits.len()-1] == 8 { if digits[digits.len() - 1] == 8 {
number_string.push_str("eighteen"); number_string.push_str("eighteen");
} }
if digits[digits.len()-1] == 9 { if digits[digits.len() - 1] == 9 {
number_string.push_str("nineteen"); number_string.push_str("nineteen");
} }
} }
@ -70,7 +69,10 @@ fn number_to_words(n: Number) -> String {
if digit == 9 { if digit == 9 {
number_string.push_str("ninety"); number_string.push_str("ninety");
} }
} else if digits.len() == 1 || (digits.len() - 2 != pos && !(digits.len() - 1 == pos && digits[digits.len() - 2] == 1)) { } else if digits.len() == 1
|| (digits.len() - 2 != pos
&& !(digits.len() - 1 == pos && digits[digits.len() - 2] == 1))
{
if digit == 1 { if digit == 1 {
number_string.push_str("one"); number_string.push_str("one");
} }

42
src/bin/problem_18.rs
View File

@ -6,21 +6,21 @@ fn main() {
fn get_triangle() -> Vec<Vec<usize>> { fn get_triangle() -> Vec<Vec<usize>> {
vec![ vec![
vec![75], vec![75],
vec![95, 64], vec![95, 64],
vec![17, 47, 82], vec![17, 47, 82],
vec![18, 35, 87, 10], vec![18, 35, 87, 10],
vec![20, 04, 82, 47, 65], vec![20, 04, 82, 47, 65],
vec![19, 01, 23, 75, 03, 34], vec![19, 01, 23, 75, 03, 34],
vec![88, 02, 77, 73, 07, 63, 67], vec![88, 02, 77, 73, 07, 63, 67],
vec![99, 65, 04, 28, 06, 16, 70, 92], vec![99, 65, 04, 28, 06, 16, 70, 92],
vec![41, 41, 26, 56, 83, 40, 80, 70, 33], vec![41, 41, 26, 56, 83, 40, 80, 70, 33],
vec![41, 48, 72, 33, 47, 32, 37, 16, 94, 29], vec![41, 48, 72, 33, 47, 32, 37, 16, 94, 29],
vec![53, 71, 44, 65, 25, 43, 91, 52, 97, 51, 14], vec![53, 71, 44, 65, 25, 43, 91, 52, 97, 51, 14],
vec![70, 11, 33, 28, 77, 73, 17, 78, 39, 68, 17, 57], vec![70, 11, 33, 28, 77, 73, 17, 78, 39, 68, 17, 57],
vec![91, 71, 52, 38, 17, 14, 91, 43, 58, 50, 27, 29, 48], vec![91, 71, 52, 38, 17, 14, 91, 43, 58, 50, 27, 29, 48],
vec![63, 66, 04, 68, 89, 53, 67, 30, 73, 16, 69, 87, 40, 31], vec![63, 66, 04, 68, 89, 53, 67, 30, 73, 16, 69, 87, 40, 31],
vec![04, 62, 98, 27, 23, 09, 70, 98, 73, 93, 38, 53, 60, 04, 23], vec![04, 62, 98, 27, 23, 09, 70, 98, 73, 93, 38, 53, 60, 04, 23],
] ]
} }
@ -29,14 +29,14 @@ fn find_max_total(grid: Vec<Vec<usize>>) -> usize {
let mut idx = triangle_height - 1; let mut idx = triangle_height - 1;
let mut highest_sums = match grid.get(idx) { let mut highest_sums = match grid.get(idx) {
Some(sums) => sums.to_vec(), Some(sums) => sums.to_vec(),
None => panic!("Impossible path: check grid") None => panic!("Impossible path: check grid"),
}; };
while idx > 0 { while idx > 0 {
idx -= 1; idx -= 1;
let line = grid.get(idx).unwrap(); let line = grid.get(idx).unwrap();
let mut new_highest_sums = Vec::new(); let mut new_highest_sums = Vec::new();
for (pos, &num) in line.iter().enumerate() { for (pos, &num) in line.iter().enumerate() {
new_highest_sums.push(max(num + highest_sums[pos], num + highest_sums[pos+1])) new_highest_sums.push(max(num + highest_sums[pos], num + highest_sums[pos + 1]))
} }
highest_sums = new_highest_sums; highest_sums = new_highest_sums;
} }
@ -49,13 +49,7 @@ mod test_18 {
#[test] #[test]
fn test_find_max_total() { fn test_find_max_total() {
let grid = vec![ let grid = vec![vec![3], vec![7, 4], vec![2, 4, 6], vec![8, 5, 9, 3]];
vec![3],
vec![7, 4],
vec![2, 4, 6],
vec![8, 5, 9, 3],
];
assert_eq!(23, find_max_total(grid)); assert_eq!(23, find_max_total(grid));
} }
} }

6
src/bin/problem_19.rs
View File

@ -76,6 +76,10 @@ fn is_leap_year(year: usize) -> bool {
fn get_last_day(year: usize, month: usize, first_day: Day) -> Day { fn get_last_day(year: usize, month: usize, first_day: Day) -> Day {
let days_per_month = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]; let days_per_month = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
let day_num = first_day.day_num_in_week(); let day_num = first_day.day_num_in_week();
let days_in_month = if month == 1 && is_leap_year(year) { 29 } else { days_per_month[month] } + day_num; let days_in_month = if month == 1 && is_leap_year(year) {
29
} else {
days_per_month[month]
} + day_num;
Day::from_day_num((days_in_month - 1) % 7) Day::from_day_num((days_in_month - 1) % 7)
} }

2
src/bin/problem_20.rs
View File

@ -2,7 +2,7 @@ use project_euler::number::Number;
fn main() { fn main() {
let factorial = get_factorial(100); let factorial = get_factorial(100);
dbg!(factorial.digits.iter().sum::<isize>()); dbg!(factorial.digits.iter().sum::<isize>());
} }
fn get_factorial(factorial: isize) -> Number { fn get_factorial(factorial: isize) -> Number {

36
src/bin/problem_22.rs
View File

@ -7,24 +7,34 @@ fn main() {
let mut sorted_names = vec![]; let mut sorted_names = vec![];
loop { loop {
let mut buffer = vec![]; let mut buffer = vec![];
let num_bytes = reader.read_until(b',', &mut buffer).expect("could not read until"); let num_bytes = reader
.read_until(b',', &mut buffer)
.expect("could not read until");
if num_bytes == 0 { if num_bytes == 0 {
break; break;
} }
match sorted_names.binary_search(&buffer[..buffer.len()-1].to_vec()) { match sorted_names.binary_search(&buffer[..buffer.len() - 1].to_vec()) {
Ok(_pos) => {} Ok(_pos) => {}
Err(pos) => sorted_names.insert(pos, buffer[..buffer.len()-1].to_vec()) Err(pos) => sorted_names.insert(pos, buffer[..buffer.len() - 1].to_vec()),
} }
} }
let score_total = sorted_names.iter().enumerate().map(|(pos, bytes)| { let score_total = sorted_names
bytes.iter().map(|&byte| { .iter()
// Don't count " in front and back of name, or in the case of Alonso, only front since it's been removed in the sorting stage for him .enumerate()
if byte != b'"' { .map(|(pos, bytes)| {
(byte - b'@') as usize bytes
} else { .iter()
0 .map(|&byte| {
} // Don't count " in front and back of name, or in the case of Alonso, only front since it's been removed in the sorting stage for him
}).sum::<usize>() * (pos + 1) if byte != b'"' {
}).sum::<usize>(); (byte - b'@') as usize
} else {
0
}
})
.sum::<usize>()
* (pos + 1)
})
.sum::<usize>();
println!("\nscore: {score_total}"); println!("\nscore: {score_total}");
} }

4
src/bin/problem_23.rs
View File

@ -1,5 +1,5 @@
use std::cmp::Ordering;
use crate::NumberType::{Abundant, Deficient, Perfect}; use crate::NumberType::{Abundant, Deficient, Perfect};
use std::cmp::Ordering;
// 4179871 // 4179871
@ -14,7 +14,7 @@ fn main() {
} }
let mut contained = false; let mut contained = false;
for abundant in &abundants { for abundant in &abundants {
match abundants.binary_search(&(num-abundant)) { match abundants.binary_search(&(num - abundant)) {
Ok(_) => { Ok(_) => {
contained = true; contained = true;
break; break;

21
src/bin/problem_24.rs
View File

@ -3,15 +3,24 @@ use std::error::Error;
fn main() { fn main() {
let n = 1_000_000; let n = 1_000_000;
let digits = vec![1, 0, 2, 3, 4, 5, 6, 7, 8, 9]; let digits = vec![1, 0, 2, 3, 4, 5, 6, 7, 8, 9];
let perm = permutation(digits, n).expect("Should return ok").iter().map(|&digit| digit.to_string()).collect::<Vec<String>>().join(""); let perm = permutation(digits, n)
.expect("Should return ok")
.iter()
.map(|&digit| digit.to_string())
.collect::<Vec<String>>()
.join("");
println!("{perm}"); println!("{perm}");
let digits = vec!["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"]; let digits = vec!["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"];
//for n in 1..=factorial(digits.len()) { //for n in 1..=factorial(digits.len()) {
let perm = permutation(digits.clone(), n).expect("Should return ok").join(""); let perm = permutation(digits.clone(), n)
println!("{perm}"); .expect("Should return ok")
.join("");
println!("{perm}");
//} //}
let digits = vec!["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"]; let digits = vec!["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"];
let perm = permutation(digits.clone(), n).expect("Should return ok").join(""); let perm = permutation(digits.clone(), n)
.expect("Should return ok")
.join("");
println!("{perm}"); println!("{perm}");
} }
@ -39,8 +48,8 @@ fn permutation<T: Copy + Ord>(mut digits: Vec<T>, nth: usize) -> Result<Vec<T>,
let num_unique_digits = digits.len(); let num_unique_digits = digits.len();
let mut remainder = nth - 1; let mut remainder = nth - 1;
for idx in 1..=digits.len() { for idx in 1..=digits.len() {
let permutations = remainder / factorial(num_unique_digits-idx); let permutations = remainder / factorial(num_unique_digits - idx);
remainder = remainder % factorial(num_unique_digits-idx); remainder = remainder % factorial(num_unique_digits - idx);
perm.push(digits[permutations]); perm.push(digits[permutations]);
digits.remove(permutations); digits.remove(permutations);
} }

2
src/bin/problem_29.rs
View File

@ -1,5 +1,5 @@
use std::collections::HashSet;
use project_euler::number::Number; use project_euler::number::Number;
use std::collections::HashSet;
fn main() { fn main() {
let mut terms: HashSet<Number> = HashSet::new(); let mut terms: HashSet<Number> = HashSet::new();

6
src/bin/problem_34.rs
View File

@ -26,7 +26,11 @@ fn digit_factorials() -> isize {
idx += 1; idx += 1;
} }
for n in 3..=max { for n in 3..=max {
let digits_fact_sum = Number::from(n).digits.iter().map(|&digit| factorial(digit)).sum(); let digits_fact_sum = Number::from(n)
.digits
.iter()
.map(|&digit| factorial(digit))
.sum();
if n == digits_fact_sum { if n == digits_fact_sum {
factorials.push(n); factorials.push(n);
} }

2
src/bin/problem_50.rs
View File

@ -26,7 +26,7 @@ fn solve() -> usize {
for prime_window in primes.windows(chain_length) { for prime_window in primes.windows(chain_length) {
let sum = prime_window.iter().map(|&prime| prime).sum::<usize>(); let sum = prime_window.iter().map(|&prime| prime).sum::<usize>();
if primes.contains(&sum) { if primes.contains(&sum) {
return sum return sum;
} }
if sum > 1000000 { if sum > 1000000 {
break; break;

17
src/bin/problem_67.rs
View File

@ -12,7 +12,10 @@ fn get_triangle() -> Vec<Vec<usize>> {
let mut grid = Vec::new(); let mut grid = Vec::new();
for line in reader.lines() { for line in reader.lines() {
let line = line.expect("Could not get line"); let line = line.expect("Could not get line");
let nums = line.split_whitespace().map(|num| num.parse::<usize>().expect("Could not parse")).collect(); let nums = line
.split_whitespace()
.map(|num| num.parse::<usize>().expect("Could not parse"))
.collect();
grid.push(nums); grid.push(nums);
} }
grid grid
@ -23,14 +26,14 @@ fn find_max_total(grid: Vec<Vec<usize>>) -> usize {
let mut idx = triangle_height - 1; let mut idx = triangle_height - 1;
let mut highest_sums = match grid.get(idx) { let mut highest_sums = match grid.get(idx) {
Some(sums) => sums.to_vec(), Some(sums) => sums.to_vec(),
None => panic!("Impossible path: check grid") None => panic!("Impossible path: check grid"),
}; };
while idx > 0 { while idx > 0 {
idx -= 1; idx -= 1;
let line = grid.get(idx).unwrap(); let line = grid.get(idx).unwrap();
let mut new_highest_sums = Vec::new(); let mut new_highest_sums = Vec::new();
for (pos, &num) in line.iter().enumerate() { for (pos, &num) in line.iter().enumerate() {
new_highest_sums.push(max(num + highest_sums[pos], num + highest_sums[pos+1])) new_highest_sums.push(max(num + highest_sums[pos], num + highest_sums[pos + 1]))
} }
highest_sums = new_highest_sums; highest_sums = new_highest_sums;
} }
@ -43,13 +46,7 @@ mod test_18 {
#[test] #[test]
fn test_find_max_total() { fn test_find_max_total() {
let grid = vec![ let grid = vec![vec![3], vec![7, 4], vec![2, 4, 6], vec![8, 5, 9, 3]];
vec![3],
vec![7, 4],
vec![2, 4, 6],
vec![8, 5, 9, 3],
];
assert_eq!(23, find_max_total(grid)); assert_eq!(23, find_max_total(grid));
} }
} }

6
src/bin/problem_9.rs
View File

@ -2,7 +2,9 @@ fn main() {
for a in 0..=1000 { for a in 0..=1000 {
for b in a..=(1000 - a) { for b in a..=(1000 - a) {
let c = 1000 - (a + b); let c = 1000 - (a + b);
if b == c { continue; } if b == c {
continue;
}
if is_triplet(a, b, c) { if is_triplet(a, b, c) {
println!("a + b + c = {a} + {b} + {c} = {}", a + b + c); println!("a + b + c = {a} + {b} + {c} = {}", a + b + c);
println!("abc = {}", a * b * c); println!("abc = {}", a * b * c);
@ -12,5 +14,5 @@ fn main() {
} }
fn is_triplet(a: usize, b: usize, c: usize) -> bool { fn is_triplet(a: usize, b: usize, c: usize) -> bool {
return a * a + b * b == c * c return a * a + b * b == c * c;
} }

88
src/lib.rs
View File

@ -2,7 +2,7 @@ pub mod number {
use std::cmp::{min, Ordering}; use std::cmp::{min, Ordering};
use std::fmt::{Display, Formatter}; use std::fmt::{Display, Formatter};
use std::iter::zip; use std::iter::zip;
use std::ops::{Add, Mul, Div, Sub, Rem}; use std::ops::{Add, Div, Mul, Rem, Sub};
#[derive(Clone, Debug, Eq, PartialEq, Hash)] #[derive(Clone, Debug, Eq, PartialEq, Hash)]
pub enum Sign { pub enum Sign {
@ -34,7 +34,11 @@ pub mod number {
let mut digits_idx = digits_len - 1; let mut digits_idx = digits_len - 1;
loop { loop {
let digit_or_num = new_digits[digits_idx]; let digit_or_num = new_digits[digits_idx];
let digit_len = if digit_or_num != 0 { (digit_or_num.abs() as f64 + 1.0).log10().ceil() as usize } else { 1 }; let digit_len = if digit_or_num != 0 {
(digit_or_num.abs() as f64 + 1.0).log10().ceil() as usize
} else {
1
};
for i in 0..digit_len { for i in 0..digit_len {
let new_digit = Self::get_digit(digit_or_num, i); let new_digit = Self::get_digit(digit_or_num, i);
let (digit_idx, is_overflow) = digits_idx.overflowing_sub(i); let (digit_idx, is_overflow) = digits_idx.overflowing_sub(i);
@ -68,12 +72,12 @@ pub mod number {
} }
digits_len -= 1; digits_len -= 1;
new_digits.remove(0); new_digits.remove(0);
}, }
Ordering::Less => { Ordering::Less => {
self.sign = Sign::Negatif; self.sign = Sign::Negatif;
break; break;
}, }
_ => break _ => break,
}; };
} }
let mut digits_idx = digits_len - 1; let mut digits_idx = digits_len - 1;
@ -82,7 +86,7 @@ pub mod number {
if self.sign == Sign::Positif && digit < 0 && digits_idx > 0 { if self.sign == Sign::Positif && digit < 0 && digits_idx > 0 {
let mut_digit = new_digits.get_mut(digits_idx).unwrap(); let mut_digit = new_digits.get_mut(digits_idx).unwrap();
*mut_digit = 10 - digit.abs(); *mut_digit = 10 - digit.abs();
let mut_digit = new_digits.get_mut(digits_idx-1).unwrap(); let mut_digit = new_digits.get_mut(digits_idx - 1).unwrap();
*mut_digit -= 1; *mut_digit -= 1;
} else { } else {
let mut_digit = new_digits.get_mut(digits_idx).unwrap(); let mut_digit = new_digits.get_mut(digits_idx).unwrap();
@ -95,8 +99,10 @@ pub mod number {
} }
for digit in new_digits.clone() { for digit in new_digits.clone() {
match digit.cmp(&0) { match digit.cmp(&0) {
Ordering::Equal => {new_digits.remove(0);}, Ordering::Equal => {
_ => break new_digits.remove(0);
}
_ => break,
}; };
} }
} }
@ -141,7 +147,7 @@ pub mod number {
let mut quotient = vec![]; let mut quotient = vec![];
let mut remainder = Number { let mut remainder = Number {
digits: dividend.clone(), digits: dividend.clone(),
sign: Sign::Positif sign: Sign::Positif,
}; };
let mut iteration = 1; let mut iteration = 1;
loop { loop {
@ -158,12 +164,12 @@ pub mod number {
if n1_len == n2_len + iteration - 1 { if n1_len == n2_len + iteration - 1 {
break; break;
} }
remainder.digits.push(n1.digits[n2_len+iteration-1]); remainder.digits.push(n1.digits[n2_len + iteration - 1]);
iteration += 1; iteration += 1;
} }
let mut res = Number { let mut res = Number {
digits: quotient, digits: quotient,
sign: Sign::Positif sign: Sign::Positif,
}; };
res.handle_overflows(); res.handle_overflows();
for digit in res.clone().digits { for digit in res.clone().digits {
@ -194,7 +200,11 @@ pub mod number {
impl From<Number> for String { impl From<Number> for String {
fn from(value: Number) -> Self { fn from(value: Number) -> Self {
let string_vec: Vec<String> = value.digits.iter().map(|&digit| digit.to_string()).collect(); let string_vec: Vec<String> = value
.digits
.iter()
.map(|&digit| digit.to_string())
.collect();
string_vec.concat() string_vec.concat()
} }
} }
@ -211,10 +221,7 @@ pub mod number {
let digit = Self::byte_to_digit(byte); let digit = Self::byte_to_digit(byte);
digits.push(digit); digits.push(digit);
} }
Self { Self { digits, sign }
digits,
sign
}
} }
} }
@ -224,23 +231,29 @@ pub mod number {
if value < 0 { if value < 0 {
sign = Sign::Negatif; sign = Sign::Negatif;
} }
let num_len = if value > 0 { (value as f64 + 1.0).log10().ceil() as usize } else { 1 }; let num_len = if value > 0 {
(value as f64 + 1.0).log10().ceil() as usize
} else {
1
};
let mut digits = vec![]; let mut digits = vec![];
for digit_idx in 0..num_len { for digit_idx in 0..num_len {
let digit = Self::get_digit(value, digit_idx); let digit = Self::get_digit(value, digit_idx);
digits.push(digit); digits.push(digit);
} }
let digits = digits.iter().rev().map(|&digit| digit).collect(); let digits = digits.iter().rev().copied().collect();
Self { Self { digits, sign }
digits,
sign
}
} }
} }
impl Display for Number { impl Display for Number {
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
let number_string = self.digits.iter().map(|&digit| { digit.to_string() }).collect::<Vec<String>>().join(""); let number_string = self
.digits
.iter()
.map(|&digit| digit.to_string())
.collect::<Vec<String>>()
.join("");
match self.sign { match self.sign {
Sign::Positif => write!(f, "{number_string}"), Sign::Positif => write!(f, "{number_string}"),
Sign::Negatif => write!(f, "-{number_string}"), Sign::Negatif => write!(f, "-{number_string}"),
@ -266,10 +279,12 @@ pub mod number {
} }
} }
let zipped = zip(self_digits.iter(), rhs_digits.iter()); let zipped = zip(self_digits.iter(), rhs_digits.iter());
let added = zipped.map(|(self_digit, rhs_digit)| { self_digit + rhs_digit }).collect(); let added = zipped
.map(|(self_digit, rhs_digit)| self_digit + rhs_digit)
.collect();
let mut overflown_number = Self { let mut overflown_number = Self {
digits: added, digits: added,
sign: Sign::Positif sign: Sign::Positif,
}; };
overflown_number.handle_overflows(); overflown_number.handle_overflows();
overflown_number overflown_number
@ -294,10 +309,12 @@ pub mod number {
} }
} }
let zipped = zip(self_digits.iter(), rhs_digits.iter()); let zipped = zip(self_digits.iter(), rhs_digits.iter());
let added = zipped.map(|(self_digit, rhs_digit)| { self_digit - rhs_digit }).collect(); let added = zipped
.map(|(self_digit, rhs_digit)| self_digit - rhs_digit)
.collect();
let mut underflown_number = Self { let mut underflown_number = Self {
digits: added, digits: added,
sign: Sign::Positif sign: Sign::Positif,
}; };
underflown_number.handle_underflows(); underflown_number.handle_underflows();
underflown_number underflown_number
@ -323,10 +340,10 @@ pub mod number {
type Output = Number; type Output = Number;
fn mul(self, rhs: Number) -> Self::Output { fn mul(self, rhs: Number) -> Self::Output {
let multiplied = rhs.digits.iter().map(|digit| { digit * self }).collect(); let multiplied = rhs.digits.iter().map(|digit| digit * self).collect();
let mut overflown_number = Number { let mut overflown_number = Number {
digits: multiplied, digits: multiplied,
sign: Sign::Positif sign: Sign::Positif,
}; };
overflown_number.handle_overflows(); overflown_number.handle_overflows();
overflown_number overflown_number
@ -337,10 +354,10 @@ pub mod number {
type Output = Self; type Output = Self;
fn mul(self, rhs: isize) -> Self::Output { fn mul(self, rhs: isize) -> Self::Output {
let multiplied = self.digits.iter().map(|digit| { digit * rhs }).collect(); let multiplied = self.digits.iter().map(|digit| digit * rhs).collect();
let mut overflown_number = Self { let mut overflown_number = Self {
digits: multiplied, digits: multiplied,
sign: Sign::Positif sign: Sign::Positif,
}; };
overflown_number.handle_overflows(); overflown_number.handle_overflows();
overflown_number overflown_number
@ -370,7 +387,13 @@ pub mod number {
#[test] #[test]
fn test_from_isize() { fn test_from_isize() {
let number = Number::from(-1234); let number = Number::from(-1234);
assert_eq!(number, Number { digits: vec![1234], sign: Sign::Negatif }); assert_eq!(
number,
Number {
digits: vec![1234],
sign: Sign::Negatif
}
);
} }
#[test] #[test]
@ -388,5 +411,4 @@ pub mod number {
assert_eq!(digit_5, 1); assert_eq!(digit_5, 1);
} }
} }
} }