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

108
src/bin/problem_11.rs
View File

@ -1,38 +1,87 @@
fn main() {
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());
}
fn get_grid() -> Vec<Vec<usize>> {
vec![
vec![08, 02, 22, 97, 38, 15, 00, 40, 00, 75, 04, 05, 07, 78, 52, 12, 50, 77, 91, 08],
vec![49, 49, 99, 40, 17, 81, 18, 57, 60, 87, 17, 40, 98, 43, 69, 48, 04, 56, 62, 00],
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![22, 31, 16, 71, 51, 67, 63, 89, 41, 92, 36, 54, 22, 40, 40, 28, 66, 33, 13, 80],
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![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],
vec![
08, 02, 22, 97, 38, 15, 00, 40, 00, 75, 04, 05, 07, 78, 52, 12, 50, 77, 91, 08,
],
vec![
49, 49, 99, 40, 17, 81, 18, 57, 60, 87, 17, 40, 98, 43, 69, 48, 04, 56, 62, 00,
],
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![
22, 31, 16, 71, 51, 67, 63, 89, 41, 92, 36, 54, 22, 40, 40, 28, 66, 33, 13, 80,
],
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![
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 {
let mut greatest = 0;
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 {
greatest = greatest_in_line;
}
@ -45,7 +94,10 @@ fn find_v(grid: Vec<Vec<usize>>) -> usize {
let side_len = grid.len();
for line_quadruplets in grid.windows(4) {
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 {
greatest = prod;
}
@ -59,7 +111,10 @@ fn find_diag_lr(grid: Vec<Vec<usize>>) -> usize {
let side_len = grid.len();
for line_quadruplets in grid.windows(4) {
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 {
greatest = prod;
}
@ -73,7 +128,10 @@ fn find_diag_rl(grid: Vec<Vec<usize>>) -> usize {
let side_len = grid.len();
for line_quadruplets in grid.windows(4) {
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 {
greatest = prod;
}

1
src/bin/problem_14.rs
View File

@ -32,4 +32,3 @@ fn find_longest(max_start: usize) -> usize {
biggest.0
}

1
src/bin/problem_16.rs
View File

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

6
src/bin/problem_17.rs
View File

@ -8,7 +8,6 @@ fn main() {
println!("{num_letters}");
}
fn number_to_words(n: Number) -> String {
let mut number_string = String::new();
let digits = n.clone().digits;
@ -70,7 +69,10 @@ fn number_to_words(n: Number) -> String {
if digit == 9 {
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 {
number_string.push_str("one");
}

10
src/bin/problem_18.rs
View File

@ -29,7 +29,7 @@ fn find_max_total(grid: Vec<Vec<usize>>) -> usize {
let mut idx = triangle_height - 1;
let mut highest_sums = match grid.get(idx) {
Some(sums) => sums.to_vec(),
None => panic!("Impossible path: check grid")
None => panic!("Impossible path: check grid"),
};
while idx > 0 {
idx -= 1;
@ -49,13 +49,7 @@ mod test_18 {
#[test]
fn test_find_max_total() {
let grid = vec![
vec![3],
vec![7, 4],
vec![2, 4, 6],
vec![8, 5, 9, 3],
];
let grid = vec![vec![3], vec![7, 4], vec![2, 4, 6], vec![8, 5, 9, 3]];
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 {
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 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)
}

22
src/bin/problem_22.rs
View File

@ -7,24 +7,34 @@ fn main() {
let mut sorted_names = vec![];
loop {
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 {
break;
}
match sorted_names.binary_search(&buffer[..buffer.len() - 1].to_vec()) {
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)| {
bytes.iter().map(|&byte| {
let score_total = sorted_names
.iter()
.enumerate()
.map(|(pos, bytes)| {
bytes
.iter()
.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
if byte != b'"' {
(byte - b'@') as usize
} else {
0
}
}).sum::<usize>() * (pos + 1)
}).sum::<usize>();
})
.sum::<usize>()
* (pos + 1)
})
.sum::<usize>();
println!("\nscore: {score_total}");
}

2
src/bin/problem_23.rs
View File

@ -1,5 +1,5 @@
use std::cmp::Ordering;
use crate::NumberType::{Abundant, Deficient, Perfect};
use std::cmp::Ordering;
// 4179871

15
src/bin/problem_24.rs
View File

@ -3,15 +3,24 @@ use std::error::Error;
fn main() {
let n = 1_000_000;
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}");
let digits = vec!["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"];
//for n in 1..=factorial(digits.len()) {
let perm = permutation(digits.clone(), n).expect("Should return ok").join("");
let perm = permutation(digits.clone(), n)
.expect("Should return ok")
.join("");
println!("{perm}");
//}
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}");
}

2
src/bin/problem_29.rs
View File

@ -1,5 +1,5 @@
use std::collections::HashSet;
use project_euler::number::Number;
use std::collections::HashSet;
fn main() {
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;
}
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 {
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) {
let sum = prime_window.iter().map(|&prime| prime).sum::<usize>();
if primes.contains(&sum) {
return sum
return sum;
}
if sum > 1000000 {
break;

15
src/bin/problem_67.rs
View File

@ -12,7 +12,10 @@ fn get_triangle() -> Vec<Vec<usize>> {
let mut grid = Vec::new();
for line in reader.lines() {
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
@ -23,7 +26,7 @@ fn find_max_total(grid: Vec<Vec<usize>>) -> usize {
let mut idx = triangle_height - 1;
let mut highest_sums = match grid.get(idx) {
Some(sums) => sums.to_vec(),
None => panic!("Impossible path: check grid")
None => panic!("Impossible path: check grid"),
};
while idx > 0 {
idx -= 1;
@ -43,13 +46,7 @@ mod test_18 {
#[test]
fn test_find_max_total() {
let grid = vec![
vec![3],
vec![7, 4],
vec![2, 4, 6],
vec![8, 5, 9, 3],
];
let grid = vec![vec![3], vec![7, 4], vec![2, 4, 6], vec![8, 5, 9, 3]];
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 b in a..=(1000 - a) {
let c = 1000 - (a + b);
if b == c { continue; }
if b == c {
continue;
}
if is_triplet(a, b, c) {
println!("a + b + c = {a} + {b} + {c} = {}", a + b + c);
println!("abc = {}", a * b * c);
@ -12,5 +14,5 @@ fn main() {
}
fn is_triplet(a: usize, b: usize, c: usize) -> bool {
return a * a + b * b == c * c
return a * a + b * b == c * c;
}

84
src/lib.rs
View File

@ -2,7 +2,7 @@ pub mod number {
use std::cmp::{min, Ordering};
use std::fmt::{Display, Formatter};
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)]
pub enum Sign {
@ -34,7 +34,11 @@ pub mod number {
let mut digits_idx = digits_len - 1;
loop {
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 {
let new_digit = Self::get_digit(digit_or_num, i);
let (digit_idx, is_overflow) = digits_idx.overflowing_sub(i);
@ -68,12 +72,12 @@ pub mod number {
}
digits_len -= 1;
new_digits.remove(0);
},
}
Ordering::Less => {
self.sign = Sign::Negatif;
break;
},
_ => break
}
_ => break,
};
}
let mut digits_idx = digits_len - 1;
@ -95,8 +99,10 @@ pub mod number {
}
for digit in new_digits.clone() {
match digit.cmp(&0) {
Ordering::Equal => {new_digits.remove(0);},
_ => break
Ordering::Equal => {
new_digits.remove(0);
}
_ => break,
};
}
}
@ -141,7 +147,7 @@ pub mod number {
let mut quotient = vec![];
let mut remainder = Number {
digits: dividend.clone(),
sign: Sign::Positif
sign: Sign::Positif,
};
let mut iteration = 1;
loop {
@ -163,7 +169,7 @@ pub mod number {
}
let mut res = Number {
digits: quotient,
sign: Sign::Positif
sign: Sign::Positif,
};
res.handle_overflows();
for digit in res.clone().digits {
@ -194,7 +200,11 @@ pub mod number {
impl From<Number> for String {
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()
}
}
@ -211,10 +221,7 @@ pub mod number {
let digit = Self::byte_to_digit(byte);
digits.push(digit);
}
Self {
digits,
sign
}
Self { digits, sign }
}
}
@ -224,23 +231,29 @@ pub mod number {
if value < 0 {
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![];
for digit_idx in 0..num_len {
let digit = Self::get_digit(value, digit_idx);
digits.push(digit);
}
let digits = digits.iter().rev().map(|&digit| digit).collect();
Self {
digits,
sign
}
let digits = digits.iter().rev().copied().collect();
Self { digits, sign }
}
}
impl Display for Number {
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 {
Sign::Positif => 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 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 {
digits: added,
sign: Sign::Positif
sign: Sign::Positif,
};
overflown_number.handle_overflows();
overflown_number
@ -294,10 +309,12 @@ pub mod number {
}
}
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 {
digits: added,
sign: Sign::Positif
sign: Sign::Positif,
};
underflown_number.handle_underflows();
underflown_number
@ -323,10 +340,10 @@ pub mod number {
type Output = Number;
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 {
digits: multiplied,
sign: Sign::Positif
sign: Sign::Positif,
};
overflown_number.handle_overflows();
overflown_number
@ -337,10 +354,10 @@ pub mod number {
type Output = Self;
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 {
digits: multiplied,
sign: Sign::Positif
sign: Sign::Positif,
};
overflown_number.handle_overflows();
overflown_number
@ -370,7 +387,13 @@ pub mod number {
#[test]
fn test_from_isize() {
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]
@ -388,5 +411,4 @@ pub mod number {
assert_eq!(digit_5, 1);
}
}
}