Merge branch 'master' of https://github.com/eugenp/tutorials

# Conflicts:
#	java-strings/pom.xml

.gitignore

@@ -62,3 +62,7 @@ jmeter/src/main/resources/*-JMeter.csv
 **/dist
 **/tmp
 **/out-tsc
+**/nbproject/
+**/nb-configuration.xml
+core-scala/.cache-main
+core-scala/.cache-tests

.travis.yml

@@ -4,7 +4,7 @@ before_install:
   - echo "MAVEN_OPTS='-Xmx2048M -Xss128M -XX:+CMSClassUnloadingEnabled -XX:+UseG1GC -XX:-UseGCOverheadLimit'" > ~/.mavenrc
 
 install: skip
-script: travis_wait 60 mvn -q install -Pdefault
+script: travis_wait 60 mvn -q install -Pdefault-first,default-second -Dgib.enabled=true
 
 sudo: required
 

README.md

@@ -2,41 +2,37 @@
 The "REST with Spring" Classes
 ==============================
 
-Here's the Master Class of REST With Spring (price changes permanently next Friday): <br/>
-**[>> THE REST WITH SPRING MASTER CLASS](http://www.baeldung.com/rest-with-spring-course?utm_source=github&utm_medium=social&utm_content=tutorials&utm_campaign=rws#master-class)**
+Here's the Master Class of REST With Spring (along with the newly announced Boot 2 material): <br/>
+**[>> THE REST WITH SPRING - MASTER CLASS](http://www.baeldung.com/rest-with-spring-course?utm_source=github&utm_medium=social&utm_content=tutorials&utm_campaign=rws#master-class)**
 
 And here's the Master Class of Learn Spring Security: <br/>
-**[>> LEARN SPRING SECURITY MASTER CLASS](http://www.baeldung.com/learn-spring-security-course?utm_source=github&utm_medium=social&utm_content=tutorials&utm_campaign=lss#master-class)**
+**[>> LEARN SPRING SECURITY - MASTER CLASS](http://www.baeldung.com/learn-spring-security-course?utm_source=github&utm_medium=social&utm_content=tutorials&utm_campaign=lss#master-class)**
 
 
 
-Spring Tutorials
+Java and Spring Tutorials
 ================
 
-This project is **a collection of small and focused tutorials** each covering a single and well defined area of development. 
-Most of the tutorial projects are focused on the `Spring Framework` (and `Spring Security`).  
+This project is **a collection of small and focused tutorials** - each covering a single and well defined area of development in the Java ecosystem. 
+A strong focus of these is, of course, the Spring Framework - Spring, Spring Boot and Spring Securiyt. 
 In additional to Spring, the following technologies are in focus: `core Java`, `Jackson`, `HttpClient`, `Guava`. 
 
+
 Building the project
 ====================
 To do the full build, do: `mvn install -Pdefault -Dgib.enabled=false`
 
 
-Working with the code in Eclipse
-================================
-Any IDE can be used to work with the projects, but if you're using Eclipse, consider the following. 
-
-- import the included **formatter** in Eclipse: 
-`https://github.com/eugenp/tutorials/tree/master/eclipse`
+Building a single module
+====================
+To build a specific module run the command: `mvn clean install -Dgib.enabled=false` in the module directory
+
+
+Running a Spring Boot module
+====================
+To run a Spring Boot module run the command: `mvn spring-boot:run -Dgib.enabled=false` in the module directory
+
 
 
-CI - Jenkins
-================================
-This tutorials project is being built **[>> HERE](https://rest-security.ci.cloudbees.com/job/tutorials-unit/)**
 
-### Relevant Articles: 
-================================
 
-- [Apache Maven Standard Directory Layout](http://www.baeldung.com/maven-directory-structure)
-- [Apache Maven Tutorial](http://www.baeldung.com/maven)
-- [Designing a User Friendly Java Library](http://www.baeldung.com/design-a-user-friendly-java-library)

algorithms-genetic/.gitignore

@@ -2,4 +2,3 @@
 .settings/
 .classpath
 .project
-

algorithms-genetic/README.md

@@ -0,0 +1,6 @@
+## Relevant articles:
+
+- [Introduction to Jenetics Library](http://www.baeldung.com/jenetics)
+- [Ant Colony Optimization](http://www.baeldung.com/java-ant-colony-optimization)
+- [Design a Genetic Algorithm in Java](https://www.baeldung.com/java-genetic-algorithm)
+- [The Traveling Salesman Problem in Java](https://www.baeldung.com/java-simulated-annealing-for-traveling-salesman)

algorithms-genetic/pom.xml

@@ -0,0 +1,65 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <artifactId>algorithms-genetic</artifactId>
+    <version>0.0.1-SNAPSHOT</version>
+    <name>algorithms-genetic</name>
+    
+    <parent>
+        <groupId>com.baeldung</groupId>
+        <artifactId>parent-modules</artifactId>
+        <version>1.0.0-SNAPSHOT</version>
+    </parent>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-math3</artifactId>
+            <version>${commons-math3.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>commons-codec</groupId>
+            <artifactId>commons-codec</artifactId>
+            <version>${commons-codec.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <version>${lombok.version}</version>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>io.jenetics</groupId>
+            <artifactId>jenetics</artifactId>
+            <version>${io.jenetics.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.assertj</groupId>
+            <artifactId>assertj-core</artifactId>
+            <version>${org.assertj.core.version}</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <pluginManagement>
+            <plugins>
+                <plugin>
+                    <groupId>org.codehaus.mojo</groupId>
+                    <artifactId>exec-maven-plugin</artifactId>
+                    <version>${exec-maven-plugin.version}</version>
+                </plugin>
+            </plugins>
+        </pluginManagement>
+    </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>
+        <commons-codec.version>1.11</commons-codec.version>
+    </properties>
+
+    
+</project>

algorithms-genetic/src/main/java/com/baeldung/algorithms/RunAlgorithm.java

@@ -5,7 +5,6 @@ import java.util.Scanner;
 import com.baeldung.algorithms.ga.annealing.SimulatedAnnealing;
 import com.baeldung.algorithms.ga.ant_colony.AntColonyOptimization;
 import com.baeldung.algorithms.ga.binary.SimpleGeneticAlgorithm;
-import com.baeldung.algorithms.slope_one.SlopeOne;
 
 public class RunAlgorithm {
 
@@ -13,11 +12,8 @@ public class RunAlgorithm {
 		Scanner in = new Scanner(System.in);
 		System.out.println("Run algorithm:");
 		System.out.println("1 - Simulated Annealing");
-		System.out.println("2 - Slope One");
-		System.out.println("3 - Simple Genetic Algorithm");
-		System.out.println("4 - Ant Colony");
-		System.out.println("5 - Dijkstra");
-		System.out.println("6 - All pairs in an array that add up to a given sum");
+		System.out.println("2 - Simple Genetic Algorithm");
+		System.out.println("3 - Ant Colony");
 		int decision = in.nextInt();
 		switch (decision) {
 		case 1:
@@ -25,19 +21,13 @@ public class RunAlgorithm {
 					"Optimized distance for travel: " + SimulatedAnnealing.simulateAnnealing(10, 10000, 0.9995));
 			break;
 		case 2:
-			SlopeOne.slopeOne(3);
-			break;
-		case 3:
 			SimpleGeneticAlgorithm ga = new SimpleGeneticAlgorithm();
 			ga.runAlgorithm(50, "1011000100000100010000100000100111001000000100000100000000001111");
 			break;
-		case 4:
+		case 3:
 			AntColonyOptimization antColony = new AntColonyOptimization(21);
 			antColony.startAntOptimization();
 			break;
-		case 5:
-			System.out.println("Please run the DijkstraAlgorithmTest.");
-			break;
 		default:
 			System.out.println("Unknown option");
 			break;

algorithms-miscellaneous-1/.gitignore

@@ -0,0 +1,4 @@
+/target/
+.settings/
+.classpath
+.project

algorithms-miscellaneous-1/README.md

@@ -0,0 +1,13 @@
+## Relevant articles:
+
+- [Validating Input With Finite Automata in Java](http://www.baeldung.com/java-finite-automata)
+- [Example of Hill Climbing Algorithm](http://www.baeldung.com/java-hill-climbing-algorithm)
+- [Monte Carlo Tree Search for Tic-Tac-Toe Game](http://www.baeldung.com/java-monte-carlo-tree-search)
+- [Binary Search Algorithm in Java](http://www.baeldung.com/java-binary-search)
+- [Introduction to Minimax Algorithm](http://www.baeldung.com/java-minimax-algorithm)
+- [How to Calculate Levenshtein Distance in Java?](http://www.baeldung.com/java-levenshtein-distance)
+- [How to Find the Kth Largest Element in Java](http://www.baeldung.com/java-kth-largest-element)
+- [Multi-Swarm Optimization Algorithm in Java](http://www.baeldung.com/java-multi-swarm-algorithm)
+- [String Search Algorithms for Large Texts](http://www.baeldung.com/java-full-text-search-algorithms)
+- [Check If a String Contains All The Letters of The Alphabet](https://www.baeldung.com/java-string-contains-all-letters)
+- [Find the Middle Element of a Linked List](http://www.baeldung.com/java-linked-list-middle-element)

algorithms-miscellaneous-1/pom.xml

@@ -0,0 +1,84 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <artifactId>algorithms-miscellaneous-1</artifactId>
+    <version>0.0.1-SNAPSHOT</version>
+    <name>algorithms-miscellaneous-1</name>
+    
+    <parent>
+        <groupId>com.baeldung</groupId>
+        <artifactId>parent-modules</artifactId>
+        <version>1.0.0-SNAPSHOT</version>
+    </parent>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-math3</artifactId>
+            <version>${commons-math3.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>com.google.guava</groupId>
+            <artifactId>guava</artifactId>
+            <version>${guava.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>commons-codec</groupId>
+            <artifactId>commons-codec</artifactId>
+            <version>${commons-codec.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <version>${lombok.version}</version>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.assertj</groupId>
+            <artifactId>assertj-core</artifactId>
+            <version>${org.assertj.core.version}</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <pluginManagement>
+            <plugins>
+                <plugin>
+                    <groupId>org.codehaus.mojo</groupId>
+                    <artifactId>exec-maven-plugin</artifactId>
+                    <version>${exec-maven-plugin.version}</version>
+                </plugin>
+            </plugins>
+        </pluginManagement>
+    </build>
+
+    <reporting>
+        <plugins>
+            <plugin>
+                <groupId>org.codehaus.mojo</groupId>
+                <artifactId>cobertura-maven-plugin</artifactId>
+                <version>2.7</version>
+                <configuration>
+                    <instrumentation>
+                        <ignores>
+                            <ignore>com/baeldung/algorithms/dijkstra/*</ignore>
+                        </ignores>
+                        <excludes>
+                            <exclude>com/baeldung/algorithms/dijkstra/*</exclude>
+                        </excludes>
+                    </instrumentation>
+                </configuration>
+            </plugin>
+        </plugins>
+    </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>
+    </properties>
+
+</project>

algorithms-miscellaneous-1/src/main/java/com/baeldung/algorithms/factorial/Factorial.java

@@ -0,0 +1,63 @@
+package com.baeldung.algorithms.factorial;
+
+import java.math.BigInteger;
+import java.util.stream.LongStream;
+
+import org.apache.commons.math3.util.CombinatoricsUtils;
+
+import com.google.common.math.BigIntegerMath;
+
+public class Factorial {
+
+    public long factorialUsingForLoop(int n) {
+        long fact = 1;
+        for (int i = 2; i <= n; i++) {
+            fact = fact * i;
+        }
+        return fact;
+    }
+
+    public long factorialUsingStreams(int n) {
+        return LongStream.rangeClosed(1, n)
+            .reduce(1, (long x, long y) -> x * y);
+    }
+
+    public long factorialUsingRecursion(int n) {
+        if (n <= 2) {
+            return n;
+        }
+        return n * factorialUsingRecursion(n - 1);
+    }
+
+    private Long[] factorials = new Long[20];
+
+    public long factorialUsingMemoize(int n) {
+
+        if (factorials[n] != null) {
+            return factorials[n];
+        }
+
+        if (n <= 2) {
+            return n;
+        }
+        long nthValue = n * factorialUsingMemoize(n - 1);
+        factorials[n] = nthValue;
+        return nthValue;
+    }
+
+    public BigInteger factorialHavingLargeResult(int n) {
+        BigInteger result = BigInteger.ONE;
+        for (int i = 2; i <= n; i++)
+            result = result.multiply(BigInteger.valueOf(i));
+        return result;
+    }
+
+    public long factorialUsingApacheCommons(int n) {
+        return CombinatoricsUtils.factorial(n);
+    }
+
+    public BigInteger factorialUsingGuava(int n) {
+        return BigIntegerMath.factorial(n);
+    }
+
+}

algorithms-miscellaneous-1/src/main/java/com/baeldung/algorithms/kthlargest/FindKthLargest.java

@@ -98,7 +98,7 @@ public class FindKthLargest {
 
     private int randomPartition(Integer arr[], int left, int right) {
         int n = right - left + 1;
-        int pivot = (int) (Math.random()) % n;
+        int pivot = (int) (Math.random() * n);
         swap(arr, left + pivot, right);
         return partition(arr, left, right);
     }

algorithms-miscellaneous-1/src/main/java/com/baeldung/algorithms/string/LongestSubstringNonRepeatingCharacters.java

@@ -0,0 +1,54 @@
+package com.baeldung.algorithms.string;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+public class LongestSubstringNonRepeatingCharacters {
+
+    public static String getUniqueCharacterSubstringBruteForce(String input) {
+        String output = "";
+        for (int start = 0; start < input.length(); start++) {
+            Set<Character> visited = new HashSet<>();
+            int end = start;
+            for (; end < input.length(); end++) {
+                char currChar = input.charAt(end);
+                if (visited.contains(currChar)) {
+                    break;
+                } else {
+                    visited.add(currChar);
+                }
+            }
+            if (output.length() < end - start + 1) {
+                output = input.substring(start, end);
+            }
+        }
+        return output;
+    }
+
+    public static String getUniqueCharacterSubstring(String input) {
+        Map<Character, Integer> visited = new HashMap<>();
+        String output = "";
+        for (int start = 0, end = 0; end < input.length(); end++) {
+            char currChar = input.charAt(end);
+            if (visited.containsKey(currChar)) {
+                start = Math.max(visited.get(currChar) + 1, start);
+            }
+            if (output.length() < end - start + 1) {
+                output = input.substring(start, end + 1);
+            }
+            visited.put(currChar, end);
+        }
+        return output;
+    }
+
+    public static void main(String[] args) {
+        if(args.length > 0) {
+            System.out.println(getUniqueCharacterSubstring(args[0]));
+        } else {
+            System.err.println("This program expects command-line input. Please try again!");
+        }
+    }
+
+}

algorithms-miscellaneous-1/src/test/java/com/baeldung/algorithms/factorial/FactorialUnitTest.java

@@ -0,0 +1,72 @@
+package com.baeldung.algorithms.factorial;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.math.BigInteger;
+
+import org.junit.Before;
+import org.junit.Test;
+
+public class FactorialUnitTest {
+
+    Factorial factorial;
+
+    @Before
+    public void setup() {
+        factorial = new Factorial();
+    }
+
+    @Test
+    public void whenCalculatingFactorialUsingForLoop_thenCorrect() {
+        int n = 5;
+
+        assertThat(factorial.factorialUsingForLoop(n)).isEqualTo(120);
+    }
+
+    @Test
+    public void whenCalculatingFactorialUsingStreams_thenCorrect() {
+        int n = 5;
+
+        assertThat(factorial.factorialUsingStreams(n)).isEqualTo(120);
+    }
+
+    @Test
+    public void whenCalculatingFactorialUsingRecursion_thenCorrect() {
+        int n = 5;
+
+        assertThat(factorial.factorialUsingRecursion(n)).isEqualTo(120);
+    }
+
+    @Test
+    public void whenCalculatingFactorialUsingMemoize_thenCorrect() {
+        int n = 5;
+
+        assertThat(factorial.factorialUsingMemoize(n)).isEqualTo(120);
+
+        n = 6;
+
+        assertThat(factorial.factorialUsingMemoize(n)).isEqualTo(720);
+    }
+
+    @Test
+    public void whenCalculatingFactorialHavingLargeResult_thenCorrect() {
+        int n = 22;
+
+        assertThat(factorial.factorialHavingLargeResult(n)).isEqualTo(new BigInteger("1124000727777607680000"));
+    }
+
+    @Test
+    public void whenCalculatingFactorialUsingApacheCommons_thenCorrect() {
+        int n = 5;
+
+        assertThat(factorial.factorialUsingApacheCommons(n)).isEqualTo(120);
+    }
+
+    @Test
+    public void whenCalculatingFactorialUsingGuava_thenCorrect() {
+        int n = 22;
+
+        assertThat(factorial.factorialUsingGuava(n)).isEqualTo(new BigInteger("1124000727777607680000"));
+    }
+
+}

algorithms-miscellaneous-1/src/test/java/com/baeldung/algorithms/string/LongestSubstringNonRepeatingCharactersUnitTest.java

@@ -0,0 +1,31 @@
+package com.baeldung.algorithms.string;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static com.baeldung.algorithms.string.LongestSubstringNonRepeatingCharacters.getUniqueCharacterSubstring;
+import static com.baeldung.algorithms.string.LongestSubstringNonRepeatingCharacters.getUniqueCharacterSubstringBruteForce;
+
+public class LongestSubstringNonRepeatingCharactersUnitTest {
+
+    @Test
+    void givenString_whenGetUniqueCharacterSubstringBruteForceCalled_thenResultFoundAsExpectedUnitTest() {
+        assertEquals("", getUniqueCharacterSubstringBruteForce(""));
+        assertEquals("A", getUniqueCharacterSubstringBruteForce("A"));
+        assertEquals("ABCDEF", getUniqueCharacterSubstringBruteForce("AABCDEF"));
+        assertEquals("ABCDEF", getUniqueCharacterSubstringBruteForce("ABCDEFF"));
+        assertEquals("NGISAWE", getUniqueCharacterSubstringBruteForce("CODINGISAWESOME"));
+        assertEquals("be coding", getUniqueCharacterSubstringBruteForce("always be coding"));
+    }
+
+    @Test
+    void givenString_whenGetUniqueCharacterSubstringCalled_thenResultFoundAsExpectedUnitTest() {
+        assertEquals("", getUniqueCharacterSubstring(""));
+        assertEquals("A", getUniqueCharacterSubstring("A"));
+        assertEquals("ABCDEF", getUniqueCharacterSubstring("AABCDEF"));
+        assertEquals("ABCDEF", getUniqueCharacterSubstring("ABCDEFF"));
+        assertEquals("NGISAWE", getUniqueCharacterSubstring("CODINGISAWESOME"));
+        assertEquals("be coding", getUniqueCharacterSubstring("always be coding"));
+    }
+
+}

algorithms-miscellaneous-2/.gitignore

@@ -0,0 +1,4 @@
+/target/
+.settings/
+.classpath
+.project

algorithms-miscellaneous-2/README.md

@@ -0,0 +1,20 @@
+## Relevant articles:
+
+- [Dijkstra Algorithm in Java](http://www.baeldung.com/java-dijkstra)
+- [Introduction to Cobertura](http://www.baeldung.com/cobertura)
+- [Test a Linked List for Cyclicity](http://www.baeldung.com/java-linked-list-cyclicity)
+- [Introduction to JGraphT](http://www.baeldung.com/jgrapht)
+- [A Maze Solver in Java](http://www.baeldung.com/java-solve-maze)
+- [Create a Sudoku Solver in Java](http://www.baeldung.com/java-sudoku)
+- [Displaying Money Amounts in Words](http://www.baeldung.com/java-money-into-words)
+- [A Collaborative Filtering Recommendation System in Java](http://www.baeldung.com/java-collaborative-filtering-recommendations)
+- [Converting Between Roman and Arabic Numerals in Java](http://www.baeldung.com/java-convert-roman-arabic)
+- [Practical Java Examples of the Big O Notation](http://www.baeldung.com/java-algorithm-complexity)
+- [An Introduction to the Theory of Big-O Notation](http://www.baeldung.com/big-o-notation)
+- [Check If Two Rectangles Overlap In Java](https://www.baeldung.com/java-check-if-two-rectangles-overlap)
+- [Calculate the Distance Between Two Points in Java](https://www.baeldung.com/java-distance-between-two-points)
+- [Find the Intersection of Two Lines in Java](https://www.baeldung.com/java-intersection-of-two-lines)
+- [Round Up to the Nearest Hundred](https://www.baeldung.com/java-round-up-nearest-hundred)
+- [Calculate Percentage in Java](https://www.baeldung.com/java-calculate-percentage)
+- [Converting Between Byte Arrays and Hexadecimal Strings in Java](https://www.baeldung.com/java-byte-arrays-hex-strings)
+- [Convert Latitude and Longitude to a 2D Point in Java](https://www.baeldung.com/java-convert-latitude-longitude)

algorithms-miscellaneous-2/pom.xml

@@ -1,9 +1,9 @@
 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>
-    <groupId>com.baeldung</groupId>
-    <artifactId>algorithms</artifactId>
+    <artifactId>algorithms-miscellaneous-2</artifactId>
     <version>0.0.1-SNAPSHOT</version>
+    <name>algorithms-miscellaneous-2</name>
 
     <parent>
         <groupId>com.baeldung</groupId>
@@ -17,17 +17,17 @@
             <artifactId>commons-math3</artifactId>
             <version>${commons-math3.version}</version>
         </dependency>
+        <dependency>
+            <groupId>commons-codec</groupId>
+            <artifactId>commons-codec</artifactId>
+            <version>${commons-codec.version}</version>
+        </dependency>
         <dependency>
             <groupId>org.projectlombok</groupId>
             <artifactId>lombok</artifactId>
             <version>${lombok.version}</version>
             <scope>provided</scope>
         </dependency>
-        <dependency>
-            <groupId>io.jenetics</groupId>
-            <artifactId>jenetics</artifactId>
-            <version>${io.jenetics.version}</version>
-        </dependency>
         <dependency>
             <groupId>org.jgrapht</groupId>
             <artifactId>jgrapht-core</artifactId>
@@ -82,9 +82,9 @@
         <lombok.version>1.16.12</lombok.version>
         <commons-math3.version>3.6.1</commons-math3.version>
         <tradukisto.version>1.0.1</tradukisto.version>
-        <io.jenetics.version>3.7.0</io.jenetics.version>
         <org.jgrapht.core.version>1.0.1</org.jgrapht.core.version>
         <org.assertj.core.version>3.9.0</org.assertj.core.version>
+        <commons-codec.version>1.11</commons-codec.version>
     </properties>
 
 </project>

algorithms-miscellaneous-2/src/main/java/com/baeldung/algorithms/RunAlgorithm.java

@@ -0,0 +1,28 @@
+package com.baeldung.algorithms;
+
+import java.util.Scanner;
+
+import com.baeldung.algorithms.slope_one.SlopeOne;
+
+public class RunAlgorithm {
+
+	public static void main(String[] args) throws InstantiationException, IllegalAccessException {
+		Scanner in = new Scanner(System.in);
+		System.out.println("1 - Slope One");
+		System.out.println("2 - Dijkstra");
+		int decision = in.nextInt();
+		switch (decision) {
+		case 1:
+			SlopeOne.slopeOne(3);
+			break;
+		case 2:
+			System.out.println("Please run the DijkstraAlgorithmLongRunningUnitTest.");
+			break;
+		default:
+			System.out.println("Unknown option");
+			break;
+		}
+		in.close();
+	}
+
+}

algorithms-miscellaneous-2/src/main/java/com/baeldung/algorithms/conversion/HexStringConverter.java

@@ -0,0 +1,110 @@
+package com.baeldung.algorithms.conversion;
+
+import java.math.BigInteger;
+
+import javax.xml.bind.DatatypeConverter;
+
+import org.apache.commons.codec.DecoderException;
+import org.apache.commons.codec.binary.Hex;
+
+import com.google.common.io.BaseEncoding;
+
+public class HexStringConverter {
+
+    /**
+     * Create a byte Array from String of hexadecimal digits using Character conversion 
+     * @param hexString - Hexadecimal digits as String
+     * @return Desired byte Array
+     */
+    public byte[] decodeHexString(String hexString) {
+        if (hexString.length() % 2 == 1) {
+            throw new IllegalArgumentException("Invalid hexadecimal String supplied.");
+        }
+        byte[] bytes = new byte[hexString.length() / 2];
+
+        for (int i = 0; i < hexString.length(); i += 2) {
+            bytes[i / 2] = hexToByte(hexString.substring(i, i + 2));
+        }
+        return bytes;
+    }
+
+    /**
+     * Create a String of hexadecimal digits from a byte Array using Character conversion
+     * @param byteArray - The byte Array
+     * @return Desired String of hexadecimal digits in lower case
+     */
+    public String encodeHexString(byte[] byteArray) {
+        StringBuffer hexStringBuffer = new StringBuffer();
+        for (int i = 0; i < byteArray.length; i++) {
+            hexStringBuffer.append(byteToHex(byteArray[i]));
+        }
+        return hexStringBuffer.toString();
+    }
+
+    public String byteToHex(byte num) {
+        char[] hexDigits = new char[2];
+        hexDigits[0] = Character.forDigit((num >> 4) & 0xF, 16);
+        hexDigits[1] = Character.forDigit((num & 0xF), 16);
+        return new String(hexDigits);
+    }
+
+    public byte hexToByte(String hexString) {
+        int firstDigit = toDigit(hexString.charAt(0));
+        int secondDigit = toDigit(hexString.charAt(1));
+        return (byte) ((firstDigit << 4) + secondDigit);
+    }
+
+    private int toDigit(char hexChar) {
+        int digit = Character.digit(hexChar, 16);
+        if(digit == -1) {
+            throw new IllegalArgumentException("Invalid Hexadecimal Character: "+ hexChar);
+        }
+        return digit;
+    }
+
+    public String encodeUsingBigIntegerToString(byte[] bytes) {
+        BigInteger bigInteger = new BigInteger(1, bytes);
+        return bigInteger.toString(16);
+    }
+
+    public String encodeUsingBigIntegerStringFormat(byte[] bytes) {
+        BigInteger bigInteger = new BigInteger(1, bytes);
+        return String.format("%0" + (bytes.length << 1) + "x", bigInteger);
+    }
+
+    public byte[] decodeUsingBigInteger(String hexString) {
+        byte[] byteArray = new BigInteger(hexString, 16).toByteArray();
+        if (byteArray[0] == 0) {
+            byte[] output = new byte[byteArray.length - 1];
+            System.arraycopy(byteArray, 1, output, 0, output.length);
+            return output;
+        }
+        return byteArray;
+    }
+
+    public String encodeUsingDataTypeConverter(byte[] bytes) {
+        return DatatypeConverter.printHexBinary(bytes);
+    }
+
+    public byte[] decodeUsingDataTypeConverter(String hexString) {
+        return DatatypeConverter.parseHexBinary(hexString);
+    }
+
+    public String encodeUsingApacheCommons(byte[] bytes) throws DecoderException {
+        return Hex.encodeHexString(bytes);
+    }
+
+    public byte[] decodeUsingApacheCommons(String hexString) throws DecoderException {
+        return Hex.decodeHex(hexString);
+    }
+
+    public String encodeUsingGuava(byte[] bytes) {
+        return BaseEncoding.base16()
+            .encode(bytes);
+    }
+
+    public byte[] decodeUsingGuava(String hexString) {
+        return BaseEncoding.base16()
+            .decode(hexString.toUpperCase());
+    }
+}