Removing vavr from problems

jabrena · May 26, 2024 · 9c9c7e6 · 9c9c7e6
1 parent faa6a07
commit 9c9c7e6
Show file tree

Hide file tree

Showing 18 changed files with 210 additions and 402 deletions.
diff --git a/problems/pom.xml b/problems/pom.xml
@@ -16,14 +16,7 @@
     <description>Euler and Latency solutions/tests</description>
 
     <dependencies>
-
-        <!-- TODO: To be removed -->
-        <dependency>
-            <groupId>io.vavr</groupId>
-            <artifactId>vavr</artifactId>
-            <version>${vavr.version}</version>
-        </dependency>
-
+
         <!-- JMH -->
         <dependency>
             <groupId>org.openjdk.jmh</groupId>

diff --git a/problems/src/main/java/info/jab/fp/euler/EulerProblem09.java b/problems/src/main/java/info/jab/fp/euler/EulerProblem09.java
@@ -1,10 +1,6 @@
 package info.jab.fp.euler;
 
-import io.vavr.Tuple;
-import io.vavr.Tuple3;
-import io.vavr.collection.List;
 import java.util.stream.LongStream;
-import org.apache.commons.lang3.NotImplementedException;
 
 /**
  * Problem 9: Special Pythagorean triplet
@@ -20,29 +16,15 @@
  */
 public class EulerProblem09 {
 
-    public Long JavaSolution(long limit) {
-
-        throw new NotImplementedException("¯\\_(ツ)_/¯");
-    }
-
     public long JavaStreamSolution(long limit) {
 
+        record Tuple3(Long param1, Long param2, Long param3) {}
+
         return LongStream.iterate(1, i -> i + 1)
-                .mapToObj(i -> new Tuple3<>(i, i, i))
-                .filter(t3 -> t3._1 + t3._2 + t3._3 == limit)
+                .mapToObj(i -> new Tuple3(i, i, i))
+                .filter(t3 -> t3.param1() + t3.param2() + t3.param3() == limit)
                 .peek(System.out::println)
                 .limit(1)
                 .count();
     }
-
-    public int VAVRSolution(long sum) {
-
-        return List.rangeClosed(1, (int) sum)
-                .crossProduct()
-                .filter(t -> t._1 + t._2 < (int) sum)
-                .map(t -> Tuple.of(t._1, t._2, (int) sum - t._1 - t._2))
-                .filter(t -> t._1 * t._1 + t._2 * t._2 == t._3 * t._3)
-                .map(t -> t._1 * t._2 * t._3)
-                .head();
-    }
 }
diff --git a/problems/src/main/java/info/jab/fp/euler/EulerProblem14.java b/problems/src/main/java/info/jab/fp/euler/EulerProblem14.java
@@ -1,7 +1,5 @@
 package info.jab.fp.euler;
 
-import io.vavr.Function1;
-import io.vavr.collection.Stream;
 import java.util.stream.LongStream;
 
 public class EulerProblem14 {
@@ -21,25 +19,4 @@ public long javaStreamSolution(long limit) {
                 .count();
     }
 
-    public long VAVRSsolution(long limit) {
-        return Stream.from(limit)
-                .take((int) limit)
-                .maxBy(collatzSequenceLength)
-                .get();
-    }
-
-    private final static Function1<Long, Long> collatzRecursive = n -> {
-        if (n == 1) {
-            return 1L;
-        } else {
-            if (n % 2 == 0) {
-                return EulerProblem14.collatzRecursive.apply(n / 2) + 1;
-            } else {
-                return EulerProblem14.collatzRecursive.apply(3 * n + 1) + 1;
-            }
-        }
-    };
-
-    private final static Function1<Long, Long> collatzSequenceLength = collatzRecursive.memoized();
-
 }
diff --git a/problems/src/main/java/info/jab/fp/euler/EulerProblem16.java b/problems/src/main/java/info/jab/fp/euler/EulerProblem16.java
@@ -1,6 +1,5 @@
 package info.jab.fp.euler;
 
-import io.vavr.collection.CharSeq;
 import java.math.BigInteger;
 
 /**
@@ -19,12 +18,4 @@ public long javaStreamSolution(long power) {
                 .mapToLong(s -> Long.valueOf(s))
                 .sum();
     }
-
-    public long VAVRSolution(long power) {
-
-        return CharSeq.of(BigInteger.valueOf(2).pow((int) power).toString())
-                .map(c -> String.valueOf((char) c))
-                .map(s -> Long.valueOf(s))
-                .fold(0L, (a, b) -> a + b);
-    }
 }
diff --git a/problems/src/main/java/info/jab/fp/euler/EulerProblem21.java b/problems/src/main/java/info/jab/fp/euler/EulerProblem21.java
@@ -1,10 +1,7 @@
 package info.jab.fp.euler;
 
-import io.vavr.Function1;
-import io.vavr.Tuple;
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Objects;
 import java.util.function.Function;
 import java.util.stream.Collectors;
 import java.util.stream.LongStream;
@@ -64,20 +61,4 @@ public long javaStreamSolution(long limit) {
                 .peek(System.out::println)
                 .sum();
     }
-
-    int sumOfDivisors(int n) {
-        return 1 + io.vavr.collection.Stream.rangeClosed(2, (int) Math.sqrt(n))
-                .map(d -> Tuple.of(d, n / d))
-                .filter(t -> t._1 * t._2 == n && !Objects.equals(t._1, t._2))
-                .map(t -> t._1 + t._2)
-                .foldLeft(0, (sum, x) -> sum + x);
-    }
-
-    public int VAVRSolution(int n) {
-        final Function1<Integer, Integer> mSumOfDivisors = Function1.of(this::sumOfDivisors).memoized();
-        return io.vavr.collection.Stream.range(1, n)
-                .filter(x -> mSumOfDivisors.apply(mSumOfDivisors.apply(x)).intValue() == x && mSumOfDivisors.apply(x) > x)
-                //.peek(System.out::println)
-                .foldLeft(0, (sum, x) -> sum + x + mSumOfDivisors.apply(x));
-    }
 }
diff --git a/problems/src/main/java/info/jab/fp/euler/EulerProblem22.java b/problems/src/main/java/info/jab/fp/euler/EulerProblem22.java
@@ -1,22 +1,15 @@
 package info.jab.fp.euler;
 
-
-import io.vavr.Tuple2;
-import io.vavr.collection.CharSeq;
-import io.vavr.collection.Iterator;
-import io.vavr.collection.Stream;
-import io.vavr.control.Try;
-import java.io.File;
-import java.io.FileNotFoundException;
-import java.net.URL;
+import java.io.IOException;
+import java.net.URISyntaxException;
 import java.nio.file.Files;
 import java.nio.file.Paths;
 import java.util.Collections;
 import java.util.List;
-import java.util.Scanner;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.function.Function;
 import java.util.regex.Pattern;
+import java.util.stream.Collectors;
 
 import static java.util.stream.Collectors.toList;
 
@@ -43,19 +36,34 @@ public class EulerProblem22 {
             .map(l -> l.replaceAll("\"", ""))
             .collect(toList());
 
+    Function<String, List<String>> load = fileName -> {
+        try {
+            return Files.lines(Paths.get(
+                    getClass().getClassLoader().getResource(fileName).toURI()))
+                    .collect(Collectors.toList());
+        } catch (IOException | URISyntaxException | NullPointerException ex) {
+            System.out.println(ex.getLocalizedMessage());
+            return Collections.emptyList();
+        }
+    };
+
+    /*
     Function<String, List<String>> load = fileName -> Try.of(() -> Files.lines(Paths.get(
             getClass().getClassLoader().getResource(fileName).toURI()))
             .collect(toList()))
             .onFailure(System.out::println)
             .getOrElse(Collections.emptyList());
+             */
+
+    record Tuple2(Integer param1, String param2) {}
 
     Function<List<String>, List<Tuple2>> addIndex = list -> {
 
         AtomicInteger index = new AtomicInteger(0);
 
-        return Stream.of(list)
+        return list.stream()
                 .map(s -> new Tuple2(index.incrementAndGet(), String.valueOf(s)))
-                .toJavaList();
+                .toList();
     };
 
     Function<String, List<String>> loadFile = fileName -> this.load.andThen(this.split).apply(fileName);
@@ -71,7 +79,9 @@ public class EulerProblem22 {
 
     Function<List<Tuple2>, Long> sum = list -> list.stream()
             .map(item -> {
-                return toDigits.andThen(sumDigits).apply(String.valueOf(item._2)) * Long.valueOf(String.valueOf(item._1));
+                return toDigits
+                .andThen(sumDigits)
+                .apply(String.valueOf(item.param2())) * Long.valueOf(String.valueOf(item.param1()));
             })
             .reduce(0L, Long::sum);
 
@@ -83,52 +93,4 @@ public long javaStreamSolution() {
                 .apply("euler/p022_names.txt");
     }
 
-    public long VAVRSolution() {
-        return readLines(file("euler/p022_names.txt"))
-                .map(l -> l.replaceAll("\"", ""))
-                .flatMap(l -> Stream.of(l.split(",")))
-                .sorted()
-                .zipWithIndex()
-                .map(t -> nameScore(t._1, t._2 + 1))
-                .sum().longValue();
-    }
-
-    long nameScore(String name, long position) {
-        return CharSeq.of(name)
-                .map(c -> c - 'A' + 1)
-                .sum().longValue() * position;
-    }
-
-    private Stream<String> readLines(File file) {
-        try {
-            return Stream.ofAll(new Iterator<String>() {
-
-                final Scanner scanner = new Scanner(file);
-
-                @Override
-                public boolean hasNext() {
-                    final boolean hasNext = scanner.hasNextLine();
-                    if (!hasNext) {
-                        scanner.close();
-                    }
-                    return hasNext;
-                }
-
-                @Override
-                public String next() {
-                    return scanner.nextLine();
-                }
-            });
-        } catch (FileNotFoundException e) {
-            return Stream.empty();
-        }
-    }
-
-    private File file(String fileName) {
-        final URL resource = getClass().getClassLoader().getResource(fileName);
-        if (resource == null) {
-            throw new RuntimeException("resource not found");
-        }
-        return new File(resource.getFile());
-    }
 }
diff --git a/problems/src/main/java/info/jab/fp/euler/EulerProblem29.java b/problems/src/main/java/info/jab/fp/euler/EulerProblem29.java
@@ -43,13 +43,4 @@ public long javaStreamSolution(long limit) {
          return generateSerie.apply(limit).count();
     }
 
-    public long VAVRSolution(long limit) {
-
-        return io.vavr.collection.Stream.rangeClosed(2, limit)
-                .map(BigInteger::valueOf)
-                .flatMap(a -> io.vavr.collection.Stream.rangeClosed(2, (int) limit).map(a::pow))
-                .distinct()
-                .length();
-    }
-
 }
diff --git a/problems/src/main/java/info/jab/fp/euler/EulerProblem30.java b/problems/src/main/java/info/jab/fp/euler/EulerProblem30.java
@@ -1,8 +1,5 @@
 package info.jab.fp.euler;
 
-import io.vavr.Tuple;
-import io.vavr.collection.CharSeq;
-import io.vavr.collection.Stream;
 import java.util.List;
 import java.util.function.BiPredicate;
 import java.util.function.Function;
@@ -53,24 +50,4 @@ public long javaStreamSolution(long limit) {
                 .reduce(0l, (l1, l2) -> l1 + l2);
     }
 
-    public long VAVRSolution(long powers) {
-        return io.vavr.collection.List.rangeClosed(10, maximalSumForPowers(powers))
-                .filter(i -> sumOfPowersOfDigits(powers, i) == i)
-                .sum().longValue();
-    }
-
-    private long maximalSumForPowers(long powers) {
-        return Stream.from(1)
-                .map(i -> Tuple.of((long) Math.pow(10, i) - 1, io.vavr.collection.List.fill(i, () -> Math.pow(9, powers)).sum().longValue()))
-                .find(t -> t._1 > t._2)
-                .map(t -> t._1).get();
-    }
-
-    private long sumOfPowersOfDigits(long powers, long num) {
-        return CharSeq.of(Long.toString(num))
-                .map(c -> Character.digit(c, 10))
-                .map(d -> (long) Math.pow(d, powers))
-                .sum().longValue();
-    }
-
 }
diff --git a/problems/src/main/java/info/jab/fp/euler/EulerProblem34.java b/problems/src/main/java/info/jab/fp/euler/EulerProblem34.java
@@ -1,8 +1,5 @@
 package info.jab.fp.euler;
 
-import io.vavr.Function1;
-import io.vavr.collection.CharSeq;
-import io.vavr.collection.Stream;
 import java.math.BigInteger;
 import java.util.List;
 import java.util.function.Function;
@@ -40,23 +37,4 @@ public long javaStreamSolution() {
                 .reduce(0L, (l1, l2) -> l1 + l2);
     }
 
-    public int VAVRSolution() {
-        return Stream.rangeClosed(3, 2_540_160) // 9! * 7 = 2 540 160 is a seven digit number, as is 9! * 8, therefor 9! * 7 is the definitive upper limit we have to investigate.
-                .filter(i -> i == sumOfDigitFactorial(i))
-                .peek(System.out::println)
-                .sum().intValue();
-    }
-
-    private int sumOfDigitFactorial(int num) {
-        return CharSeq.of(Integer.toString(num))
-                .map(c -> Character.digit(c, 10))
-                .map(MEMOIZED_FACTORIAL)
-                .sum().intValue();
-    }
-
-    final Function1<Integer, BigInteger> MEMOIZED_FACTORIAL = Function1.of(this::factorial).memoized();
-
-    BigInteger factorial(int n) {
-        return Stream.rangeClosed(1, n).map(BigInteger::valueOf).fold(BigInteger.ONE, BigInteger::multiply);
-    }
 }