GP-39 fun-prime-numbers

* refactor main to introduce 3 more methods and corresponding tests

Author: tboychuk

5-0-functional-programming/5-4-1-fun-prime-numbers/src/main/java/com/bobocode/fp/PrimeNumbers.java

@@ -3,7 +3,9 @@
 import com.bobocode.util.ExerciseNotCompletedException;
 
 import java.util.List;
+import java.util.Map;
 import java.util.function.IntConsumer;
+import java.util.stream.IntStream;
 
 /**
  * {@link PrimeNumbers} provides an API to work with prime numbers. The implementation is based on the
@@ -15,6 +17,26 @@ public class PrimeNumbers {
     private PrimeNumbers() {
     }
 
+    /**
+     * Generates an infinite int stream of prime numbers.
+     * The stream values are 2, 3, 5,... and so on.
+     *
+     * @return an infinite int stream of prime numbers
+     */
+    public static IntStream stream() {
+        throw new ExerciseNotCompletedException(); // todo: create an infinite stream of ints, then filter prime numbs
+    }
+
+    /**
+     * Generates an int stream of a certain amount of prime numbers.
+     * It is based on the {@link PrimeNumbers#stream()} but specifies the exact size of the stream.
+     *
+     * @return an int stream of prime numbers with a specified size
+     */
+    public static IntStream stream(int size) {
+        throw new ExerciseNotCompletedException(); // todo: use the prev to generate a stream method but limit its size
+    }
+
     /**
      * Calculates the sum on first n prime numbers.
      * E.g. if n = 5, the result should be 2 + 3 + 5 + 7 + 11 = 28
@@ -23,7 +45,7 @@ private PrimeNumbers() {
      * @return the sum of n prime numbers
      */
     public static int sum(int n) {
-        throw new ExerciseNotCompletedException(); // todo: create an infinite stream of ints, then filter prime numbs
+        throw new ExerciseNotCompletedException(); // todo: use prev method and calculate the sum
 
     }
 
@@ -32,8 +54,8 @@ public static int sum(int n) {
      *
      * @return a list of collected prime numbers
      */
-    public static List<Integer> collect(int n) {
-        throw new ExerciseNotCompletedException(); // todo: reuse the logic of prime numbers stream and collect them
+    public static List<Integer> list(int n) {
+        throw new ExerciseNotCompletedException(); // todo: collect prime numbers into the list
     }
 
     /**
@@ -43,6 +65,20 @@ public static List<Integer> collect(int n) {
      * @param consumer a logic that should be applied to the found prime number
      */
     public static void processByIndex(int idx, IntConsumer consumer) {
-        throw new ExerciseNotCompletedException(); // todo: reuse the logic of prime numbers stream then process the last one
+        throw new ExerciseNotCompletedException(); // todo: find an element in the stream by index and process it
+    }
+
+    /**
+     * Creates a list of n prime numbers and returns a map where all of those prime numbers are groped. The key represents
+     * an amount of digits and the value is a corresponding list of all prime numbers.
+     * <p>
+     * So if you will call this method for with argument 20, you will receive the following map:
+     * {1=[2, 3, 5, 7], 2=[11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71]}
+     *
+     * @param n – the amount of prime numbers
+     * @return a map with prime number grouped by the amount of digits
+     */
+    public static Map<Integer, List<Integer>> groupByAmountOfDigits(int n) {
+        throw new ExerciseNotCompletedException(); // todo: group n prime numbers by the amount of digits
     }
 }

5-0-functional-programming/5-4-1-fun-prime-numbers/src/test/java/com/bobocode/fp/PrimeNumbersTest.java

@@ -2,6 +2,7 @@
 
 import org.junit.jupiter.api.MethodOrderer;
 import org.junit.jupiter.api.Order;
+import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.TestMethodOrder;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
@@ -10,15 +11,42 @@
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Map;
 import java.util.stream.Stream;
 
+import static java.util.stream.Collectors.toList;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.junit.jupiter.params.provider.Arguments.arguments;
 
 @TestMethodOrder(MethodOrderer.OrderAnnotation.class)
 class PrimeNumbersTest {
 
     @Order(1)
+    @Test
+    void stream() {
+        var primeNumbersStream = PrimeNumbers.stream();
+
+        var primeList = primeNumbersStream
+                .limit(5)
+                .boxed()
+                .collect(toList());
+
+        assertThat(primeList).isEqualTo(List.of(2, 3, 5, 7, 11));
+    }
+
+    @Order(2)
+    @Test
+    void streamN() {
+        var primeNumbersStream = PrimeNumbers.stream(8);
+
+        var primeList = primeNumbersStream
+                .boxed()
+                .collect(toList());
+
+        assertThat(primeList).isEqualTo(List.of(2, 3, 5, 7, 11, 13, 17, 19));
+    }
+
+    @Order(3)
     @ParameterizedTest
     @CsvSource({"0, 0", "1, 2", "2, 5", "3, 10", "4, 17", "5, 28", "10, 129", "20, 639"})
     void sum(int n, int sumOfPrimes) {
@@ -27,16 +55,16 @@ void sum(int n, int sumOfPrimes) {
         assertThat(result).isEqualTo(sumOfPrimes);
     }
 
-    @Order(2)
+    @Order(4)
     @ParameterizedTest
     @MethodSource("collectArgs")
     void collect(int n, List<Integer> primeNumbersList) {
-        List<Integer> result = PrimeNumbers.collect(n);
+        List<Integer> result = PrimeNumbers.list(n);
 
         assertThat(result).isEqualTo(primeNumbersList);
     }
 
-    @Order(3)
+    @Order(5)
     @ParameterizedTest
     @CsvSource({"0, 2", "1, 3", "2, 5", "3, 7", "10, 31", "20, 73", "279, 1811"})
     void processByIndexFindsCorrectPrimeNumber(int index, int primeNumber) {
@@ -57,4 +85,34 @@ static Stream<Arguments> collectArgs() {
                 arguments(10, List.of(2, 3, 5, 7, 11, 13, 17, 19, 23, 29))
         );
     }
+
+    @Order(6)
+    @ParameterizedTest
+    @MethodSource("groupByAmountOfDigitsArgs")
+    void groupByAmountOfDigits(int count, Map<Integer, List<Integer>> digitsToPrimesMap) {
+        var result = PrimeNumbers.groupByAmountOfDigits(count);
+
+        assertThat(result).isEqualTo(digitsToPrimesMap);
+    }
+
+    static Stream<Arguments> groupByAmountOfDigitsArgs() {
+        return Stream.of(
+                arguments(1, Map.of(1, List.of(2))),
+                arguments(10, Map.of(
+                        1, List.of(2, 3, 5, 7),
+                        2, List.of(11, 13, 17, 19, 23, 29)
+                )),
+                arguments(20, Map.of(
+                        1, List.of(2, 3, 5, 7),
+                        2, List.of(11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71)
+                )),
+                arguments(30, Map.of(
+                                1, List.of(2, 3, 5, 7),
+                                2, List.of(11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97),
+                                3, List.of(101, 103, 107, 109, 113)
+                        )
+                )
+
+        );
+    }
 }