solve p0011 in rust, tweak doc return types

LivInTheLookingGlass · Jul 23, 2024 · 271c906 · 271c906
1 parent f0b50e3
commit 271c906
Show file tree

Hide file tree

Showing 16 changed files with 117 additions and 17 deletions.
diff --git a/README.rst b/README.rst
@@ -48,7 +48,7 @@ LivInTheLookingGlass’s Project Euler solutions
 |            | Pypy 3.6+ |br|          |        |                   |
 |            | GraalPy 23.1+           |        |                   |
 +------------+-------------------------+--------+-------------------+
-| Rust       | 1.69+                   | 11     | |Rust|            |
+| Rust       | 1.69+                   | 12     | |Rust|            |
 +------------+-------------------------+--------+-------------------+
 | Documentation (in progress)                   | |Pages|           |
 +-----------------------------------------------+-------------------+

diff --git a/docs/index.rst b/docs/index.rst
@@ -124,7 +124,7 @@ This project is divided into several Makefiles, connected by a root Makefile whi
 +-----------+------------+------------+------------+------------+------------+------------+
 |:prob:`10` |:c-d:`0010` |            |            |            |:py-d:`0010`|:rs-d:`0010`|
 +-----------+------------+------------+------------+------------+------------+------------+
-|:prob:`11` |:c-d:`0011` |:cp-d:`0011`|            |            |:py-d:`0011`|            |
+|:prob:`11` |:c-d:`0011` |:cp-d:`0011`|            |            |:py-d:`0011`|:rs-d:`0011`|
 +-----------+------------+------------+------------+------------+------------+------------+
 |:prob:`12` |:c-i:`0012` |            |            |            |:py-d:`0012`|            |
 +-----------+------------+------------+------------+------------+------------+------------+

diff --git a/docs/rust/p0001.rst b/docs/rust/p0001.rst
@@ -3,7 +3,7 @@ Rust Implementation of Problem 1
 
 View source code `here on GitHub! <https://github.com/LivInTheLookingGlass/Euler/blob/master/rust/src/p0001.rs>`_
 
-.. rust:fn:: p0001::p0001() -> u64
+.. rust:fn:: p0001::p0001() -> i128
 
 .. literalinclude:: ../../rust/src/p0001.rs
    :language: rust

diff --git a/docs/rust/p0002.rst b/docs/rust/p0002.rst
@@ -3,7 +3,7 @@ Rust Implementation of Problem 2
 
 View source code `here on GitHub! <https://github.com/LivInTheLookingGlass/Euler/blob/master/rust/src/p0002.rs>`_
 
-.. rust:fn:: p0002::p0002() -> u64
+.. rust:fn:: p0002::p0002() -> i128
 
 .. literalinclude:: ../../rust/src/p0002.rs
    :language: rust

diff --git a/docs/rust/p0003.rst b/docs/rust/p0003.rst
@@ -11,7 +11,7 @@ Includes
 Problem Solution
 ----------------
 
-.. rust:fn:: p0003::p0003() -> u64
+.. rust:fn:: p0003::p0003() -> i128
 
 .. literalinclude:: ../../rust/src/p0003.rs
    :language: rust

diff --git a/docs/rust/p0004.rst b/docs/rust/p0004.rst
@@ -6,9 +6,9 @@ View source code `here on GitHub! <https://github.com/LivInTheLookingGlass/Euler
 Problem Solution
 ----------------
 
-.. rust:fn:: p0004::is_palindrome(x: u64) -> bool
+.. rust:fn:: p0004::is_palindrome(x: u32) -> bool
 
-.. rust:fn:: p0004::p0004() -> u64
+.. rust:fn:: p0004::p0004() -> i128
 
 .. literalinclude:: ../../rust/src/p0004.rs
    :language: rust

diff --git a/docs/rust/p0005.rst b/docs/rust/p0005.rst
@@ -6,7 +6,7 @@ View source code `here on GitHub! <https://github.com/LivInTheLookingGlass/Euler
 Problem Solution
 ----------------
 
-.. rust:fn:: p0005::p0005() -> u64
+.. rust:fn:: p0005::p0005() -> i128
 
 .. literalinclude:: ../../rust/src/p0005.rs
    :language: rust

diff --git a/docs/rust/p0006.rst b/docs/rust/p0006.rst
@@ -6,7 +6,7 @@ View source code `here on GitHub! <https://github.com/LivInTheLookingGlass/Euler
 Problem Solution
 ----------------
 
-.. rust:fn:: p0006::p0006() -> u64
+.. rust:fn:: p0006::p0006() -> i128
 
 .. literalinclude:: ../../rust/src/p0006.rs
    :language: rust

diff --git a/docs/rust/p0007.rst b/docs/rust/p0007.rst
@@ -11,7 +11,7 @@ Includes
 Problem Solution
 ----------------
 
-.. rust:fn:: p0007::p0007() -> u64
+.. rust:fn:: p0007::p0007() -> i128
 
 .. literalinclude:: ../../rust/src/p0007.rs
    :language: rust

diff --git a/docs/rust/p0008.rst b/docs/rust/p0008.rst
@@ -6,7 +6,7 @@ View source code `here on GitHub! <https://github.com/LivInTheLookingGlass/Euler
 Problem Solution
 ----------------
 
-.. rust:fn:: p0008::p0008() -> u64
+.. rust:fn:: p0008::p0008() -> i128
 
 .. literalinclude:: ../../rust/src/p0008.rs
    :language: rust

diff --git a/docs/rust/p0009.rst b/docs/rust/p0009.rst
@@ -6,7 +6,7 @@ View source code `here on GitHub! <https://github.com/LivInTheLookingGlass/Euler
 Problem Solution
 ----------------
 
-.. rust:fn:: p0009::p0009() -> u64
+.. rust:fn:: p0009::p0009() -> i128
 
 .. literalinclude:: ../../rust/src/p0009.rs
    :language: rust

diff --git a/docs/rust/p0010.rst b/docs/rust/p0010.rst
@@ -11,7 +11,7 @@ Includes
 Problem Solution
 ----------------
 
-.. rust:fn:: p0010::p0010() -> u64
+.. rust:fn:: p0010::p0010() -> i128
 
 .. literalinclude:: ../../rust/src/p0010.rs
    :language: rust

diff --git a/docs/rust/p0011.rst b/docs/rust/p0011.rst
@@ -0,0 +1,13 @@
+Rust Implementation of Problem 11
+=================================
+
+View source code `here on GitHub! <https://github.com/LivInTheLookingGlass/Euler/blob/master/rust/src/p0011.rs>`_
+
+Problem Solution
+----------------
+
+.. rust:fn:: p0011::p0011() -> i128
+
+.. literalinclude:: ../../rust/src/p0011.rs
+   :language: rust
+   :linenos:
diff --git a/docs/rust/p0076.rst b/docs/rust/p0076.rst
@@ -6,7 +6,7 @@ View source code `here on GitHub! <https://github.com/LivInTheLookingGlass/Euler
 Problem Solution
 ----------------
 
-.. rust:fn:: p0076::p0076() -> u64
+.. rust:fn:: p0076::p0076() -> i128
 
 .. literalinclude:: ../../rust/src/p0076.rs
    :language: rust

diff --git a/rust/src/main.rs b/rust/src/main.rs
@@ -9,15 +9,15 @@ use rstest::rstest;
 #[cfg(test)]
 use itertools::Itertools;
 
-seq!(N in 0001..=0010 {
+seq!(N in 0001..=0011 {
 mod p~N;
 });
 mod p0076;
 mod primes;
 
 type ProblemType = fn() -> i128;
 type ProblemRef<'a> = (&'a str, ProblemType, i128);
-const ANSWERS: [ProblemRef; 11] = [
+const ANSWERS: [ProblemRef; 12] = [
     ("p0001", p0001::p0001, 233168),
     ("p0002", p0002::p0002, 4613732),
     ("p0003", p0003::p0003, 6857),
@@ -28,6 +28,7 @@ const ANSWERS: [ProblemRef; 11] = [
     ("p0008", p0008::p0008, 23514624000),
     ("p0009", p0009::p0009, 31875000),
     ("p0010", p0010::p0010, 142913828922),
+    ("p0011", p0011::p0011, 70600674),
     ("p0076", p0076::p0076, 190569291),
 ];
 
@@ -43,7 +44,7 @@ fn main() {
 }
 
 #[cfg(test)]
-seq!(N in 0..11 {
+seq!(N in 0..12 {
 #[rstest]
 #[timeout(Duration::new(60, 0))]
 #(

diff --git a/rust/src/p0011.rs b/rust/src/p0011.rs
@@ -0,0 +1,86 @@
+/*
+Project Euler Problem 11
+
+Problem:
+
+In the 20×20 grid below, four numbers along a diagonal line have been marked in red.
+
+08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08
+49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00
+81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65
+52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 91
+22 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80
+24 47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 50
+32 98 81 28 64 23 67 10 26 38 40 67 59 54 70 66 18 38 64 70
+67 26 20 68 02 62 12 20 95 63 94 39 63 08 40 91 66 49 94 21
+24 55 58 05 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 72
+21 36 23 09 75 00 76 44 20 45 35 14 00 61 33 97 34 31 33 95
+78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92
+16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57
+86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58
+19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40
+04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66
+88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69
+04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36
+20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16
+20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54
+01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48
+
+The product of these numbers is 26 × 63 × 78 × 14 = 1788696.
+
+What is the greatest product of four adjacent numbers in the same direction (up, down, left, right, or diagonally) in
+the 20×20 grid?
+*/
+use core::cmp::max;
+
+const GRID: [[u8; 20]; 20] = [
+    [ 8,  2, 22, 97, 38, 15,  0, 40,  0, 75,  4,  5,  7, 78, 52, 12, 50, 77, 91,  8],
+    [49, 49, 99, 40, 17, 81, 18, 57, 60, 87, 17, 40, 98, 43, 69, 48,  4, 56, 62,  0],
+    [81, 49, 31, 73, 55, 79, 14, 29, 93, 71, 40, 67, 53, 88, 30,  3, 49, 13, 36, 65],
+    [52, 70, 95, 23,  4, 60, 11, 42, 69, 24, 68, 56,  1, 32, 56, 71, 37,  2, 36, 91],
+    [22, 31, 16, 71, 51, 67, 63, 89, 41, 92, 36, 54, 22, 40, 40, 28, 66, 33, 13, 80],
+    [24, 47, 32, 60, 99, 03, 45,  2, 44, 75, 33, 53, 78, 36, 84, 20, 35, 17, 12, 50],
+    [32, 98, 81, 28, 64, 23, 67, 10, 26, 38, 40, 67, 59, 54, 70, 66, 18, 38, 64, 70],
+    [67, 26, 20, 68,  2, 62, 12, 20, 95, 63, 94, 39, 63,  8, 40, 91, 66, 49, 94, 21],
+    [24, 55, 58,  5, 66, 73, 99, 26, 97, 17, 78, 78, 96, 83, 14, 88, 34, 89, 63, 72],
+    [21, 36, 23,  9, 75,  0, 76, 44, 20, 45, 35, 14,  0, 61, 33, 97, 34, 31, 33, 95],
+    [78, 17, 53, 28, 22, 75, 31, 67, 15, 94,  3, 80,  4, 62, 16, 14,  9, 53, 56, 92],
+    [16, 39,  5, 42, 96, 35, 31, 47, 55, 58, 88, 24,  0, 17, 54, 24, 36, 29, 85, 57],
+    [86, 56,  0, 48, 35, 71, 89,  7,  5, 44, 44, 37, 44, 60, 21, 58, 51, 54, 17, 58],
+    [19, 80, 81, 68,  5, 94, 47, 69, 28, 73, 92, 13, 86, 52, 17, 77,  4, 89, 55, 40],
+    [ 4, 52,  8, 83, 97, 35, 99, 16,  7, 97, 57, 32, 16, 26, 26, 79, 33, 27, 98, 66],
+    [88, 36, 68, 87, 57, 62, 20, 72,  3, 46, 33, 67, 46, 55, 12, 32, 63, 93, 53, 69],
+    [ 4, 42, 16, 73, 38, 25, 39, 11, 24, 94, 72, 18,  8, 46, 29, 32, 40, 62, 76, 36],
+    [20, 69, 36, 41, 72, 30, 23, 88, 34, 62, 99, 69, 82, 67, 59, 85, 74, 04, 36, 16],
+    [20, 73, 35, 29, 78, 31, 90,  1, 74, 31, 49, 71, 48, 86, 81, 16, 23, 57,  5, 54],
+    [ 1, 70, 54, 71, 83, 51, 54, 69, 16, 92, 33, 48, 61, 43, 52,  1, 89, 19, 67, 48]
+];
+
+
+pub fn p0011() -> i128 {
+    let mut answer: u64 = 0;
+    let mut tmp: u64;
+    for i in 0..20 {
+        for j in 0..17 {
+            // horizontal section
+            tmp = GRID[i][j] as u64 * GRID[i][j + 1] as u64 * GRID[i][j + 2] as u64 * GRID[i][j + 3] as u64;
+            answer = max(answer, tmp);
+            // vertical section
+            tmp = GRID[j][i] as u64 * GRID[j + 1][i] as u64 * GRID[j + 2][i] as u64 * GRID[j + 3][i] as u64;
+            answer = max(answer, tmp);
+        }
+    }
+
+    for i in 0..17 {
+        for j in 0..17 {
+            // right diagonal section
+            tmp = GRID[i][j] as u64 * GRID[i + 1][j + 1] as u64 * GRID[i + 2][j + 2] as u64 * GRID[i + 3][j + 3] as u64;
+            answer = max(answer, tmp);
+            // left diagonal section
+            tmp = GRID[i][j + 3] as u64 * GRID[i + 1][j + 2] as u64 * GRID[i + 2][j + 1] as u64 * GRID[i + 3][j] as u64;
+            answer = max(answer, tmp);
+        }
+    }
+
+    return answer.into();
+}