Solve p8, p11, p13 in java, update C# formatting + comment

LivInTheLookingGlass · Aug 11, 2024 · 25f5a8c · 25f5a8c
1 parent 388766e
commit 25f5a8c
Show file tree

Hide file tree

Showing 13 changed files with 502 additions and 50 deletions.
diff --git a/README.rst b/README.rst
@@ -73,7 +73,7 @@ Olivia's Project Euler Solutions
 |            |                          |        | |CodeQL| |br|     |
 |            |                          |        | |C#-lint|         |
 +------------+--------------------------+--------+-------------------+
-| Java       | Java 8+                  |  7     | |Javai| |br|      |
+| Java       | Java 8+                  | 10     | |Javai| |br|      |
 |            |                          |        | |Ja-Cov| |br|     |
 |            |                          |        | |CodeQL| |br|     |
 |            |                          |        | |Java-lint|       |

diff --git a/csharp/Euler/p0008.cs b/csharp/Euler/p0008.cs
@@ -39,7 +39,6 @@ namespace Euler
 {
     public class p0008 : IEuler
     {
-        private const int MAX = 500;
         public object Answer()
         {
             String str = String.Concat(

diff --git a/csharp/Euler/p0011.cs b/csharp/Euler/p0011.cs
@@ -1,21 +1,37 @@
 /*
-Project Euler Problem 17
+Project Euler Problem 11
 
-I feel like there is a better way to recurse this problem, but I could not
-think of one at the time
+This one was tedious but pretty easy.
 
 Problem:
 
-If the numbers 1 to 5 are written out in words: one, two, three, four, five,
-then there are 3 + 3 + 5 + 4 + 4 = 19 letters used in total.
+In the 20×20 grid below, four numbers along a diagonal line have been marked in red.
 
-If all the numbers from 1 to 1000 (one thousand) inclusive were written out in
-words, how many letters would be used?
+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
 
-NOTE: Do not count spaces or hyphens. For example, 342 (three hundred and
-forty-two) contains 23 letters and 115 (one hundred and fifteen) contains 20
-letters. The use of "and" when writing out numbers is in compliance with
-British usage.
+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?
 */
 using System;
 
@@ -54,26 +70,26 @@ public object Answer()
         }
 
         byte[][] grid = new byte[20][]{
-            new byte[20]{ 8,  2, 22, 97, 38, 15,  0, 40,  0, 75,  4,  5,  7, 78, 52, 12, 50, 77, 91,  8},
-            new byte[20]{49, 49, 99, 40, 17, 81, 18, 57, 60, 87, 17, 40, 98, 43, 69, 48,  4, 56, 62,  0},
-            new byte[20] { 81, 49, 31, 73, 55, 79, 14, 29, 93, 71, 40, 67, 53, 88, 30, 3, 49, 13, 36, 65 },
-            new byte[20] { 52, 70, 95, 23, 4, 60, 11, 42, 69, 24, 68, 56, 1, 32, 56, 71, 37, 2, 36, 91 },
+            new byte[20] {  8,  2, 22, 97, 38, 15,  0, 40,  0, 75,  4,  5,  7, 78, 52, 12, 50, 77, 91,  8 },
+            new byte[20] { 49, 49, 99, 40, 17, 81, 18, 57, 60, 87, 17, 40, 98, 43, 69, 48,  4, 56, 62,  0 },
+            new byte[20] { 81, 49, 31, 73, 55, 79, 14, 29, 93, 71, 40, 67, 53, 88, 30,  3, 49, 13, 36, 65 },
+            new byte[20] { 52, 70, 95, 23,  4, 60, 11, 42, 69, 24, 68, 56,  1, 32, 56, 71, 37,  2, 36, 91 },
             new byte[20] { 22, 31, 16, 71, 51, 67, 63, 89, 41, 92, 36, 54, 22, 40, 40, 28, 66, 33, 13, 80 },
-            new byte[20] { 24, 47, 32, 60, 99, 03, 45, 2, 44, 75, 33, 53, 78, 36, 84, 20, 35, 17, 12, 50 },
+            new byte[20] { 24, 47, 32, 60, 99, 03, 45,  2, 44, 75, 33, 53, 78, 36, 84, 20, 35, 17, 12, 50 },
             new byte[20] { 32, 98, 81, 28, 64, 23, 67, 10, 26, 38, 40, 67, 59, 54, 70, 66, 18, 38, 64, 70 },
-            new byte[20] { 67, 26, 20, 68, 2, 62, 12, 20, 95, 63, 94, 39, 63, 8, 40, 91, 66, 49, 94, 21 },
-            new byte[20] { 24, 55, 58, 5, 66, 73, 99, 26, 97, 17, 78, 78, 96, 83, 14, 88, 34, 89, 63, 72 },
-            new byte[20] { 21, 36, 23, 9, 75, 0, 76, 44, 20, 45, 35, 14, 0, 61, 33, 97, 34, 31, 33, 95 },
-            new byte[20] { 78, 17, 53, 28, 22, 75, 31, 67, 15, 94, 3, 80, 4, 62, 16, 14, 9, 53, 56, 92 },
-            new byte[20] { 16, 39, 5, 42, 96, 35, 31, 47, 55, 58, 88, 24, 0, 17, 54, 24, 36, 29, 85, 57 },
-            new byte[20] { 86, 56, 0, 48, 35, 71, 89, 7, 5, 44, 44, 37, 44, 60, 21, 58, 51, 54, 17, 58 },
-            new byte[20] { 19, 80, 81, 68, 5, 94, 47, 69, 28, 73, 92, 13, 86, 52, 17, 77, 4, 89, 55, 40 },
-            new byte[20] { 4, 52, 8, 83, 97, 35, 99, 16, 7, 97, 57, 32, 16, 26, 26, 79, 33, 27, 98, 66 },
-            new byte[20] { 88, 36, 68, 87, 57, 62, 20, 72, 3, 46, 33, 67, 46, 55, 12, 32, 63, 93, 53, 69 },
-            new byte[20] { 4, 42, 16, 73, 38, 25, 39, 11, 24, 94, 72, 18, 8, 46, 29, 32, 40, 62, 76, 36 },
+            new byte[20] { 67, 26, 20, 68,  2, 62, 12, 20, 95, 63, 94, 39, 63,  8, 40, 91, 66, 49, 94, 21 },
+            new byte[20] { 24, 55, 58,  5, 66, 73, 99, 26, 97, 17, 78, 78, 96, 83, 14, 88, 34, 89, 63, 72 },
+            new byte[20] { 21, 36, 23,  9, 75,  0, 76, 44, 20, 45, 35, 14,  0, 61, 33, 97, 34, 31, 33, 95 },
+            new byte[20] { 78, 17, 53, 28, 22, 75, 31, 67, 15, 94,  3, 80,  4, 62, 16, 14,  9, 53, 56, 92 },
+            new byte[20] { 16, 39,  5, 42, 96, 35, 31, 47, 55, 58, 88, 24,  0, 17, 54, 24, 36, 29, 85, 57 },
+            new byte[20] { 86, 56,  0, 48, 35, 71, 89,  7,  5, 44, 44, 37, 44, 60, 21, 58, 51, 54, 17, 58 },
+            new byte[20] { 19, 80, 81, 68,  5, 94, 47, 69, 28, 73, 92, 13, 86, 52, 17, 77,  4, 89, 55, 40 },
+            new byte[20] {  4, 52,  8, 83, 97, 35, 99, 16,  7, 97, 57, 32, 16, 26, 26, 79, 33, 27, 98, 66 },
+            new byte[20] { 88, 36, 68, 87, 57, 62, 20, 72,  3, 46, 33, 67, 46, 55, 12, 32, 63, 93, 53, 69 },
+            new byte[20] {  4, 42, 16, 73, 38, 25, 39, 11, 24, 94, 72, 18,  8, 46, 29, 32, 40, 62, 76, 36 },
             new byte[20] { 20, 69, 36, 41, 72, 30, 23, 88, 34, 62, 99, 69, 82, 67, 59, 85, 74, 04, 36, 16 },
-            new byte[20] { 20, 73, 35, 29, 78, 31, 90, 1, 74, 31, 49, 71, 48, 86, 81, 16, 23, 57, 5, 54 },
-            new byte[20] { 1, 70, 54, 71, 83, 51, 54, 69, 16, 92, 33, 48, 61, 43, 52, 1, 89, 19, 67, 48 }
+            new byte[20] { 20, 73, 35, 29, 78, 31, 90,  1, 74, 31, 49, 71, 48, 86, 81, 16, 23, 57,  5, 54 },
+            new byte[20] {  1, 70, 54, 71, 83, 51, 54, 69, 16, 92, 33, 48, 61, 43, 52,  1, 89, 19, 67, 48 }
         };
     }
 }
diff --git a/docs/index.rst b/docs/index.rst
@@ -83,17 +83,17 @@ Problems Solved
 +-----------+------------+------------+------------+------------+------------+------------+------------+
 |:prob:`7`  |:c-d:`0007` |            |            |            |:js-d:`0007`|:py-d:`0007`|:rs-d:`0007`|
 +-----------+------------+------------+------------+------------+------------+------------+------------+
-|:prob:`8`  |:c-d:`0008` |:cp-d:`0008`|:cs-d:`0008`|            |:js-d:`0008`|:py-d:`0008`|:rs-d:`0008`|
+|:prob:`8`  |:c-d:`0008` |:cp-d:`0008`|:cs-d:`0008`|:ja-d:`0008`|:js-d:`0008`|:py-d:`0008`|:rs-d:`0008`|
 +-----------+------------+------------+------------+------------+------------+------------+------------+
 |:prob:`9`  |:c-d:`0009` |:cp-d:`0009`|:cs-d:`0009`|:ja-d:`0009`|:js-d:`0009`|:py-d:`0009`|:rs-d:`0009`|
 +-----------+------------+------------+------------+------------+------------+------------+------------+
 |:prob:`10` |:c-d:`0010` |            |            |            |:js-d:`0010`|:py-d:`0010`|:rs-d:`0010`|
 +-----------+------------+------------+------------+------------+------------+------------+------------+
-|:prob:`11` |:c-d:`0011` |:cp-d:`0011`|:cs-d:`0011`|            |:js-d:`0011`|:py-d:`0011`|:rs-d:`0011`|
+|:prob:`11` |:c-d:`0011` |:cp-d:`0011`|:cs-d:`0011`|:ja-d:`0011`|:js-d:`0011`|:py-d:`0011`|:rs-d:`0011`|
 +-----------+------------+------------+------------+------------+------------+------------+------------+
 |:prob:`12` |:c-s:`0012` |            |            |            |            |:py-d:`0012`|:rs-d:`0012`|
 +-----------+------------+------------+------------+------------+------------+------------+------------+
-|:prob:`13` |:c-d:`0013` |:cp-d:`0013`|:cs-d:`0013`|            |:js-d:`0013`|:py-d:`0013`|:rs-d:`0013`|
+|:prob:`13` |:c-d:`0013` |:cp-d:`0013`|:cs-d:`0013`|:ja-d:`0013`|:js-d:`0013`|:py-d:`0013`|:rs-d:`0013`|
 +-----------+------------+------------+------------+------------+------------+------------+------------+
 |:prob:`14` |:c-d:`0014` |:cp-d:`0014`|:cs-d:`0014`|            |:js-d:`0014`|:py-d:`0014`|:rs-d:`0014`|
 +-----------+------------+------------+------------+------------+------------+------------+------------+

diff --git a/docs/java/p0008.rst b/docs/java/p0008.rst
@@ -0,0 +1,14 @@
+Java Implementation of Problem 8
+================================
+
+View source code :source:`java/src/main/java/euler/p0008.java`
+
+.. java:type:: public class p0008 implements IEuler
+
+   .. java:method:: Object answer()
+
+    :return: The answer to Project Euler problem 8
+
+.. literalinclude:: ../../java/src/main/java/euler/p0008.java
+   :language: java
+   :linenos:
diff --git a/docs/java/p0011.rst b/docs/java/p0011.rst
@@ -0,0 +1,14 @@
+Java Implementation of Problem 11
+=================================
+
+View source code :source:`java/src/main/java/euler/p0011.java`
+
+.. java:type:: public class p0011 implements IEuler
+
+   .. java:method:: Object answer()
+
+    :return: The answer to Project Euler problem 11
+
+.. literalinclude:: ../../java/src/main/java/euler/p0011.java
+   :language: java
+   :linenos:
diff --git a/docs/java/p0013.rst b/docs/java/p0013.rst
@@ -0,0 +1,14 @@
+Java Implementation of Problem 13
+=================================
+
+View source code :source:`java/src/main/java/euler/p0013.java`
+
+.. java:type:: public class p0013 implements IEuler
+
+   .. java:method:: Object answer()
+
+    :return: The answer to Project Euler problem 13
+
+.. literalinclude:: ../../java/src/main/java/euler/p0013.java
+   :language: java
+   :linenos:
diff --git a/java/README.rst b/java/README.rst
@@ -79,6 +79,9 @@ Problems Solved
 -  ☒ `2 <./src/main/java/p0002.java>`__
 -  ☒ `4 <./src/main/java/p0004.java>`__
 -  ☒ `6 <./src/main/java/p0006.java>`__
+-  ☒ `8 <./src/main/java/p0008.java>`__
 -  ☒ `9 <./src/main/java/p0009.java>`__
+-  ☒ `11 <./src/main/java/p0011.java>`__
+-  ☒ `13 <./src/main/java/p0013.java>`__
 -  ☒ `22 <./src/main/java/p0022.java>`__
 -  ☒ `836 <./src/main/java/p0836.java>`__
diff --git a/java/src/main/java/euler/lib/Utilities.java b/java/src/main/java/euler/lib/Utilities.java
@@ -12,22 +12,18 @@
 public class Utilities {
 
     private static Path getDataPath(String name) throws IOException {
-try {
-        URI classUri = Utilities.class.getProtectionDomain().getCodeSource().getLocation().toURI();
-        Path classPath = Paths.get(classUri);
-//        Path classPath = Paths.get(Utilities.class.getProtectionDomain().getCodeSource().getLocation().getPath());
-        Path classDir = classPath.getParent();
-        Path filePath = classDir.getParent().getParent().resolve("_data").resolve(name);
-        return filePath;
-}
-catch (URISyntaxException e) {
-throw new IOException("Invalid syntax in class path");
-}
+        try {
+            URI classUri = Utilities.class.getProtectionDomain().getCodeSource().getLocation().toURI();
+            Path classPath = Paths.get(classUri);
+            return classPath.getParent().getParent().getParent().resolve("_data").resolve(name);
+        }
+        catch (URISyntaxException e) {
+            throw new IOException("Invalid syntax in class path");
+        }
     }
 
     public static byte[] getDataFileBytes(String name) throws IOException {
-        Path filePath = getDataPath(name);
-        return Files.readAllBytes(filePath);
+        return Files.readAllBytes(getDataPath(name));
     }
 
     public static String getDataFileText(String name) throws IOException {
@@ -41,7 +37,6 @@ public static Object getAnswer(long n) throws IOException {
             reader.readLine();
             while ((line = reader.readLine()) != null) {
                 String[] arr = line.split("\t");
-                if (arr.length < 4) continue;
                 long key = Long.parseLong(arr[0]);
                 if (key != n) continue;
 

diff --git a/java/src/main/java/euler/p0008.java b/java/src/main/java/euler/p0008.java
@@ -0,0 +1,75 @@
+/*
+Project Euler Problem 8
+
+In Python I did this with an iterator, but that is more cumbersome here,
+so I just did it with a loop that slices.
+
+Problem:
+
+The four adjacent digits in the 1000-digit number that have the greatest
+product are 9 × 9 × 8 × 9 = 5832.
+
+73167176531330624919225119674426574742355349194934
+96983520312774506326239578318016984801869478851843
+85861560789112949495459501737958331952853208805511
+12540698747158523863050715693290963295227443043557
+66896648950445244523161731856403098711121722383113
+62229893423380308135336276614282806444486645238749
+30358907296290491560440772390713810515859307960866
+70172427121883998797908792274921901699720888093776
+65727333001053367881220235421809751254540594752243
+52584907711670556013604839586446706324415722155397
+53697817977846174064955149290862569321978468622482
+83972241375657056057490261407972968652414535100474
+82166370484403199890008895243450658541227588666881
+16427171479924442928230863465674813919123162824586
+17866458359124566529476545682848912883142607690042
+24219022671055626321111109370544217506941658960408
+07198403850962455444362981230987879927244284909188
+84580156166097919133875499200524063689912560717606
+05886116467109405077541002256983155200055935729725
+71636269561882670428252483600823257530420752963450
+
+Find the thirteen adjacent digits in the 1000-digit number that have the
+greatest product. What is the value of this product?
+*/
+package euler;
+
+public class p0008 implements IEuler {
+    @Override
+    public Object answer() {
+        String str = (
+            "73167176531330624919225119674426574742355349194934" +
+            "96983520312774506326239578318016984801869478851843" +
+            "85861560789112949495459501737958331952853208805511" +
+            "12540698747158523863050715693290963295227443043557" +
+            "66896648950445244523161731856403098711121722383113" +
+            "62229893423380308135336276614282806444486645238749" +
+            "30358907296290491560440772390713810515859307960866" +
+            "70172427121883998797908792274921901699720888093776" +
+            "65727333001053367881220235421809751254540594752243" +
+            "52584907711670556013604839586446706324415722155397" +
+            "53697817977846174064955149290862569321978468622482" +
+            "83972241375657056057490261407972968652414535100474" +
+            "82166370484403199890008895243450658541227588666881" +
+            "16427171479924442928230863465674813919123162824586" +
+            "17866458359124566529476545682848912883142607690042" +
+            "24219022671055626321111109370544217506941658960408" +
+            "07198403850962455444362981230987879927244284909188" +
+            "84580156166097919133875499200524063689912560717606" +
+            "05886116467109405077541002256983155200055935729725" +
+            "71636269561882670428252483600823257530420752963450"
+        );
+        long answer = 0;
+        for (int i = 0; i < str.length() - 13; i++) {
+            String slice = str.substring(i, i + 13);
+            long prod = 1;
+            for (int j = 0; j < slice.length(); j++)
+                prod *= slice.charAt(j) - '0';
+
+            if (prod > answer)
+                answer = prod;
+        }
+        return answer;
+    }
+}