Merge remote-tracking branch 'eugenp/master'

Author: Doha2012

akka-http/pom.xml

@@ -41,7 +41,6 @@
 <properties>
 <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
 <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
-<java.version>1.8</java.version>
 <akka.http.version>10.0.11</akka.http.version>
 <akka.stream.version>2.5.11</akka.stream.version>
 </properties>

akka-streams/pom.xml

@@ -14,18 +14,19 @@
  <dependencies>
  <dependency>
  <groupId>com.typesafe.akka</groupId>
- <artifactId>akka-stream_2.11</artifactId>
+ <artifactId>akka-stream_${scala.version}</artifactId>
  <version>${akkastreams.version}</version>
  </dependency>
  <dependency>
  <groupId>com.typesafe.akka</groupId>
- <artifactId>akka-stream-testkit_2.11</artifactId>
+ <artifactId>akka-stream-testkit_${scala.version}</artifactId>
  <version>${akkastreams.version}</version>
  </dependency>
  </dependencies>
 
  <properties>
  <akkastreams.version>2.5.2</akkastreams.version>
+ <scala.version>2.11</scala.version>
  </properties>
 
 </project>

algorithms-genetic/pom.xml

@@ -54,7 +54,6 @@
  </build>
 
  <properties>
- <lombok.version>1.16.12</lombok.version>
  <commons-math3.version>3.6.1</commons-math3.version>
  <io.jenetics.version>3.7.0</io.jenetics.version>
  <org.assertj.core.version>3.9.0</org.assertj.core.version>

algorithms-miscellaneous-1/README.md

@@ -17,3 +17,4 @@
 - [Java Two Pointer Technique](https://www.baeldung.com/java-two-pointer-technique)
 - [Permutations of an Array in Java](https://www.baeldung.com/java-array-permutations)
 - [Implementing Simple State Machines with Java Enums](https://www.baeldung.com/java-enum-simple-state-machine)
+- [Generate Combinations in Java](https://www.baeldung.com/java-combinations-algorithm)

algorithms-miscellaneous-1/pom.xml

@@ -39,6 +39,11 @@
  <version>${org.assertj.core.version}</version>
  <scope>test</scope>
  </dependency>
+ <dependency>
+ <groupId>com.github.dpaukov</groupId>
+ <artifactId>combinatoricslib3</artifactId>
+ <version>3.3.0</version>
+ </dependency>
  </dependencies>
 
  <build>
@@ -74,11 +79,10 @@
  </reporting>
 
  <properties>
- <lombok.version>1.16.12</lombok.version>
  <commons-math3.version>3.6.1</commons-math3.version>
  <org.assertj.core.version>3.9.0</org.assertj.core.version>
  <commons-codec.version>1.11</commons-codec.version>
- <guava.version>25.1-jre</guava.version>
+ <guava.version>27.0.1-jre</guava.version>
  </properties>
 
 </project>

algorithms-miscellaneous-1/src/main/java/com/baeldung/algorithms/combination/ApacheCommonsCombinationGenerator.java

@@ -0,0 +1,29 @@
+package com.baeldung.algorithms.combination;
+
+import java.util.Arrays;
+import java.util.Iterator;
+
+import org.apache.commons.math3.util.CombinatoricsUtils;
+
+public class ApacheCommonsCombinationGenerator {
+
+ private static final int N = 6;
+ private static final int R = 3;
+
+ /** 
+ * Print all combinations of r elements from a set
+ * @param n - number of elements in set
+ * @param r - number of elements in selection
+ */
+ public static void generate(int n, int r) {
+ Iterator<int[]> iterator = CombinatoricsUtils.combinationsIterator(n, r);
+ while (iterator.hasNext()) {
+ final int[] combination = iterator.next();
+ System.out.println(Arrays.toString(combination));
+ }
+ }
+
+ public static void main(String[] args) {
+ generate(N, R);
+ }
+}

algorithms-miscellaneous-1/src/main/java/com/baeldung/algorithms/combination/CombinatoricsLibCombinationGenerator.java

@@ -0,0 +1,13 @@
+package com.baeldung.algorithms.combination;
+
+import org.paukov.combinatorics3.Generator;
+
+public class CombinatoricsLibCombinationGenerator {
+
+ public static void main(String[] args) {
+ Generator.combination(0, 1, 2, 3, 4, 5)
+ .simple(3)
+ .stream()
+ .forEach(System.out::println);
+ }
+}

algorithms-miscellaneous-1/src/main/java/com/baeldung/algorithms/combination/GuavaCombinationsGenerator.java

@@ -0,0 +1,17 @@
+package com.baeldung.algorithms.combination;
+
+import java.util.Arrays;
+import java.util.Set;
+
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Sets;
+
+public class GuavaCombinationsGenerator {
+
+ public static void main(String[] args) {
+
+ Set<Set<Integer>> combinations = Sets.combinations(ImmutableSet.of(0, 1, 2, 3, 4, 5), 3);
+ System.out.println(combinations.size());
+ System.out.println(Arrays.toString(combinations.toArray()));
+ }
+}

algorithms-miscellaneous-1/src/main/java/com/baeldung/algorithms/combination/IterativeCombinationGenerator.java

@@ -0,0 +1,52 @@
+package com.baeldung.algorithms.combination;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class IterativeCombinationGenerator {
+
+ private static final int N = 5;
+ private static final int R = 2;
+
+ /**
+ * Generate all combinations of r elements from a set
+ * @param n the number of elements in input set
+ * @param r the number of elements in a combination
+ * @return the list containing all combinations
+ */
+ public List<int[]> generate(int n, int r) {
+ List<int[]> combinations = new ArrayList<>();
+ int[] combination = new int[r];
+
+ // initialize with lowest lexicographic combination
+ for (int i = 0; i < r; i++) {
+ combination[i] = i;
+ }
+
+ while (combination[r - 1] < n) {
+ combinations.add(combination.clone());
+
+ // generate next combination in lexicographic order
+ int t = r - 1;
+ while (t != 0 && combination[t] == n - r + t) {
+ t--;
+ }
+ combination[t]++;
+ for (int i = t + 1; i < r; i++) {
+ combination[i] = combination[i - 1] + 1;
+ }
+ }
+
+ return combinations;
+ }
+
+ public static void main(String[] args) {
+ IterativeCombinationGenerator generator = new IterativeCombinationGenerator();
+ List<int[]> combinations = generator.generate(N, R);
+ System.out.println(combinations.size());
+ for (int[] combination : combinations) {
+ System.out.println(Arrays.toString(combination));
+ }
+ }
+}

algorithms-miscellaneous-1/src/main/java/com/baeldung/algorithms/combination/SelectionRecursiveCombinationGenerator.java

@@ -0,0 +1,53 @@
+package com.baeldung.algorithms.combination;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class SelectionRecursiveCombinationGenerator {
+
+ private static final int N = 6;
+ private static final int R = 3;
+
+ /** 
+ * Generate all combinations of r elements from a set
+ * @param n - number of elements in input set
+ * @param r - number of elements to be chosen
+ * @return the list containing all combinations
+ */
+ public List<int[]> generate(int n, int r) {
+ List<int[]> combinations = new ArrayList<>();
+ helper(combinations, new int[r], 0, n - 1, 0);
+ return combinations;
+ }
+
+ /** 
+ * Choose elements from set by recursing over elements selected
+ * @param combinations - List to store generated combinations
+ * @param data - current combination
+ * @param start - starting element of remaining set
+ * @param end - last element of remaining set
+ * @param index - number of elements chosen so far.
+ */
+ private void helper(List<int[]> combinations, int data[], int start, int end, int index) {
+ if (index == data.length) {
+ int[] combination = data.clone();
+ combinations.add(combination);
+ } else {
+ int max = Math.min(end, end + 1 - data.length + index);
+ for (int i = start; i <= max; i++) {
+ data[index] = i;
+ helper(combinations, data, i + 1, end, index + 1);
+ }
+ }
+ }
+
+ public static void main(String[] args) {
+ SelectionRecursiveCombinationGenerator generator = new SelectionRecursiveCombinationGenerator();
+ List<int[]> combinations = generator.generate(N, R);
+ for (int[] combination : combinations) {
+ System.out.println(Arrays.toString(combination));
+ }
+ System.out.printf("generated %d combinations of %d items from %d ", combinations.size(), R, N);
+ }
+}