Merge pull request #5 from eugenp/master

merge from head fork

.gitignore

@@ -63,4 +63,6 @@ jmeter/src/main/resources/*-JMeter.csv
 **/tmp
 **/out-tsc
 **/nbproject/
-**/nb-configuration.xml
+**/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

@@ -21,3 +21,18 @@ In additional to Spring, the following technologies are in focus: `core Java`, `
 Building the project
 ====================
 To do the full build, do: `mvn install -Pdefault -Dgib.enabled=false`
+
+
+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
+
+
+
+
+

algorithms-genetic/.gitignore

@@ -1,5 +1,4 @@
-/target/
-.settings/
-.classpath
-.project
-
+/target/
+.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/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-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,90 +1,90 @@
-<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>
-    <version>0.0.1-SNAPSHOT</version>
-
-    <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>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>
-            <version>${org.jgrapht.core.version}</version>
-        </dependency>
-        <dependency>
-            <groupId>pl.allegro.finance</groupId>
-            <artifactId>tradukisto</artifactId>
-            <version>${tradukisto.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>
-
-    <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>
-        <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>
-    </properties>
-
+<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-2</artifactId>
+    <version>0.0.1-SNAPSHOT</version>
+    <name>algorithms-miscellaneous-2</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>org.jgrapht</groupId>
+            <artifactId>jgrapht-core</artifactId>
+            <version>${org.jgrapht.core.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>pl.allegro.finance</groupId>
+            <artifactId>tradukisto</artifactId>
+            <version>${tradukisto.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>
+
+    <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>
+        <tradukisto.version>1.0.1</tradukisto.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());
+    }
+}

algorithms-miscellaneous-2/src/main/java/com/baeldung/algorithms/editdistance/EditDistanceBase.java

@@ -1,15 +1,15 @@
-package com.baeldung.algorithms.editdistance;
-
-import java.util.Arrays;
-
-public class EditDistanceBase {
-
-    static int costOfSubstitution(char a, char b) {
-        return a == b ? 0 : 1;
-    }
-
-    static int min(int... numbers) {
-        return Arrays.stream(numbers)
-          .min().orElse(Integer.MAX_VALUE);
-    }
-}
+package com.baeldung.algorithms.editdistance;
+
+import java.util.Arrays;
+
+public class EditDistanceBase {
+
+    static int costOfSubstitution(char a, char b) {
+        return a == b ? 0 : 1;
+    }
+
+    static int min(int... numbers) {
+        return Arrays.stream(numbers)
+          .min().orElse(Integer.MAX_VALUE);
+    }
+}

algorithms-miscellaneous-2/src/main/java/com/baeldung/algorithms/editdistance/EditDistanceDynamicProgramming.java

@@ -1,26 +1,26 @@
-package com.baeldung.algorithms.editdistance;
-
-public class EditDistanceDynamicProgramming extends EditDistanceBase {
-
-    static int calculate(String x, String y) {
-        int[][] dp = new int[x.length() + 1][y.length() + 1];
-
-        for (int i = 0; i <= x.length(); i++) {
-            for (int j = 0; j <= y.length(); j++) {
-                if (i == 0)
-                    dp[i][j] = j;
-
-                else if (j == 0)
-                    dp[i][j] = i;
-
-                else {
-                    dp[i][j] = min(dp[i - 1][j - 1]
-                        + costOfSubstitution(x.charAt(i - 1), y.charAt(j - 1)),
-                      dp[i - 1][j] + 1, dp[i][j - 1] + 1);
-                }
-            }
-        }
-
-        return dp[x.length()][y.length()];
-    }
-}
+package com.baeldung.algorithms.editdistance;
+
+public class EditDistanceDynamicProgramming extends EditDistanceBase {
+
+    static int calculate(String x, String y) {
+        int[][] dp = new int[x.length() + 1][y.length() + 1];
+
+        for (int i = 0; i <= x.length(); i++) {
+            for (int j = 0; j <= y.length(); j++) {
+                if (i == 0)
+                    dp[i][j] = j;
+
+                else if (j == 0)
+                    dp[i][j] = i;
+
+                else {
+                    dp[i][j] = min(dp[i - 1][j - 1]
+                        + costOfSubstitution(x.charAt(i - 1), y.charAt(j - 1)),
+                      dp[i - 1][j] + 1, dp[i][j - 1] + 1);
+                }
+            }
+        }
+
+        return dp[x.length()][y.length()];
+    }
+}

algorithms-miscellaneous-2/src/main/java/com/baeldung/algorithms/editdistance/EditDistanceRecursive.java

@@ -1,21 +1,21 @@
-package com.baeldung.algorithms.editdistance;
-
-public class EditDistanceRecursive extends EditDistanceBase {
-
-    static int calculate(String x, String y) {
-
-        if (x.isEmpty()) {
-            return y.length();
-        }
-
-        if (y.isEmpty()) {
-            return x.length();
-        }
-
-        int substitution = calculate(x.substring(1), y.substring(1)) + costOfSubstitution(x.charAt(0), y.charAt(0));
-        int insertion = calculate(x, y.substring(1)) + 1;
-        int deletion = calculate(x.substring(1), y) + 1;
-
-        return min(substitution, insertion, deletion);
-    }
-}
+package com.baeldung.algorithms.editdistance;
+
+public class EditDistanceRecursive extends EditDistanceBase {
+
+    static int calculate(String x, String y) {
+
+        if (x.isEmpty()) {
+            return y.length();
+        }
+
+        if (y.isEmpty()) {
+            return x.length();
+        }
+
+        int substitution = calculate(x.substring(1), y.substring(1)) + costOfSubstitution(x.charAt(0), y.charAt(0));
+        int insertion = calculate(x, y.substring(1)) + 1;
+        int deletion = calculate(x.substring(1), y) + 1;
+
+        return min(substitution, insertion, deletion);
+    }
+}

algorithms-miscellaneous-2/src/main/java/com/baeldung/algorithms/linkedlist/CycleDetectionBruteForce.java

@@ -1,38 +1,38 @@
-package com.baeldung.algorithms.linkedlist;
-
-public class CycleDetectionBruteForce {
-
-    public static <T> CycleDetectionResult<T> detectCycle(Node<T> head) {
-        if (head == null) {
-            return new CycleDetectionResult<>(false, null);
-        }
-
-        Node<T> it1 = head;
-        int nodesTraversedByOuter = 0;
-        while (it1 != null && it1.next != null) {
-            it1 = it1.next;
-            nodesTraversedByOuter++;
-
-            int x = nodesTraversedByOuter;
-            Node<T> it2 = head;
-            int noOfTimesCurrentNodeVisited = 0;
-
-            while (x > 0) {
-                it2 = it2.next;
-
-                if (it2 == it1) {
-                    noOfTimesCurrentNodeVisited++;
-                }
-
-                if (noOfTimesCurrentNodeVisited == 2) {
-                    return new CycleDetectionResult<>(true, it1);
-                }
-
-                x--;
-            }
-        }
-
-        return new CycleDetectionResult<>(false, null);
-    }
-
-}
+package com.baeldung.algorithms.linkedlist;
+
+public class CycleDetectionBruteForce {
+
+    public static <T> CycleDetectionResult<T> detectCycle(Node<T> head) {
+        if (head == null) {
+            return new CycleDetectionResult<>(false, null);
+        }
+
+        Node<T> it1 = head;
+        int nodesTraversedByOuter = 0;
+        while (it1 != null && it1.next != null) {
+            it1 = it1.next;
+            nodesTraversedByOuter++;
+
+            int x = nodesTraversedByOuter;
+            Node<T> it2 = head;
+            int noOfTimesCurrentNodeVisited = 0;
+
+            while (x > 0) {
+                it2 = it2.next;
+
+                if (it2 == it1) {
+                    noOfTimesCurrentNodeVisited++;
+                }
+
+                if (noOfTimesCurrentNodeVisited == 2) {
+                    return new CycleDetectionResult<>(true, it1);
+                }
+
+                x--;
+            }
+        }
+
+        return new CycleDetectionResult<>(false, null);
+    }
+
+}

algorithms-miscellaneous-2/src/main/java/com/baeldung/algorithms/linkedlist/CycleDetectionByFastAndSlowIterators.java

@@ -1,25 +1,25 @@
-package com.baeldung.algorithms.linkedlist;
-
-public class CycleDetectionByFastAndSlowIterators {
-
-    public static <T> CycleDetectionResult<T> detectCycle(Node<T> head) {
-        if (head == null) {
-            return new CycleDetectionResult<>(false, null);
-        }
-
-        Node<T> slow = head;
-        Node<T> fast = head;
-
-        while (fast != null && fast.next != null) {
-            slow = slow.next;
-            fast = fast.next.next;
-
-            if (slow == fast) {
-                return new CycleDetectionResult<>(true, fast);
-            }
-        }
-
-        return new CycleDetectionResult<>(false, null);
-    }
-
-}
+package com.baeldung.algorithms.linkedlist;
+
+public class CycleDetectionByFastAndSlowIterators {
+
+    public static <T> CycleDetectionResult<T> detectCycle(Node<T> head) {
+        if (head == null) {
+            return new CycleDetectionResult<>(false, null);
+        }
+
+        Node<T> slow = head;
+        Node<T> fast = head;
+
+        while (fast != null && fast.next != null) {
+            slow = slow.next;
+            fast = fast.next.next;
+
+            if (slow == fast) {
+                return new CycleDetectionResult<>(true, fast);
+            }
+        }
+
+        return new CycleDetectionResult<>(false, null);
+    }
+
+}

algorithms-miscellaneous-2/src/main/java/com/baeldung/algorithms/linkedlist/CycleDetectionByHashing.java

@@ -1,27 +1,27 @@
-package com.baeldung.algorithms.linkedlist;
-
-import java.util.HashSet;
-import java.util.Set;
-
-public class CycleDetectionByHashing {
-
-    public static <T> CycleDetectionResult<T> detectCycle(Node<T> head) {
-        if (head == null) {
-            return new CycleDetectionResult<>(false, null);
-        }
-
-        Set<Node<T>> set = new HashSet<>();
-        Node<T> node = head;
-
-        while (node != null) {
-            if (set.contains(node)) {
-                return new CycleDetectionResult<>(true, node);
-            }
-            set.add(node);
-            node = node.next;
-        }
-
-        return new CycleDetectionResult<>(false, null);
-    }
-
-}
+package com.baeldung.algorithms.linkedlist;
+
+import java.util.HashSet;
+import java.util.Set;
+
+public class CycleDetectionByHashing {
+
+    public static <T> CycleDetectionResult<T> detectCycle(Node<T> head) {
+        if (head == null) {
+            return new CycleDetectionResult<>(false, null);
+        }
+
+        Set<Node<T>> set = new HashSet<>();
+        Node<T> node = head;
+
+        while (node != null) {
+            if (set.contains(node)) {
+                return new CycleDetectionResult<>(true, node);
+            }
+            set.add(node);
+            node = node.next;
+        }
+
+        return new CycleDetectionResult<>(false, null);
+    }
+
+}

algorithms-miscellaneous-2/src/main/java/com/baeldung/algorithms/linkedlist/CycleDetectionResult.java

@@ -1,12 +1,12 @@
-package com.baeldung.algorithms.linkedlist;
-
-public class CycleDetectionResult<T> {
-    boolean cycleExists;
-    Node<T> node;
-
-    public CycleDetectionResult(boolean cycleExists, Node<T> node) {
-        super();
-        this.cycleExists = cycleExists;
-        this.node = node;
-    }
-}
+package com.baeldung.algorithms.linkedlist;
+
+public class CycleDetectionResult<T> {
+    boolean cycleExists;
+    Node<T> node;
+
+    public CycleDetectionResult(boolean cycleExists, Node<T> node) {
+        super();
+        this.cycleExists = cycleExists;
+        this.node = node;
+    }
+}

algorithms-miscellaneous-2/src/main/java/com/baeldung/algorithms/linkedlist/CycleRemovalBruteForce.java

@@ -1,56 +1,56 @@
-package com.baeldung.algorithms.linkedlist;
-
-public class CycleRemovalBruteForce {
-
-    public static <T> boolean detectAndRemoveCycle(Node<T> head) {
-        CycleDetectionResult<T> result = CycleDetectionByFastAndSlowIterators.detectCycle(head);
-
-        if (result.cycleExists) {
-            removeCycle(result.node, head);
-        }
-
-        return result.cycleExists;
-    }
-
-    /**
-     * @param loopNodeParam - reference to the node where Flyods cycle 
-     * finding algorithm ends, i.e. the fast and the slow iterators
-     * meet.
-     * @param head - reference to the head of the list
-     */
-    private static <T> void removeCycle(Node<T> loopNodeParam, Node<T> head) {
-        Node<T> it = head;
-
-        while (it != null) {
-            if (isNodeReachableFromLoopNode(it, loopNodeParam)) {
-                Node<T> loopStart = it;
-                findEndNodeAndBreakCycle(loopStart);
-                break;
-            }
-            it = it.next;
-        }
-    }
-
-    private static <T> boolean isNodeReachableFromLoopNode(Node<T> it, Node<T> loopNodeParam) {
-        Node<T> loopNode = loopNodeParam;
-
-        do {
-            if (it == loopNode) {
-                return true;
-            }
-            loopNode = loopNode.next;
-        } while (loopNode.next != loopNodeParam);
-
-        return false;
-    }
-
-    private static <T> void findEndNodeAndBreakCycle(Node<T> loopStartParam) {
-        Node<T> loopStart = loopStartParam;
-
-        while (loopStart.next != loopStartParam) {
-            loopStart = loopStart.next;
-        }
-
-        loopStart.next = null;
-    }
-}
+package com.baeldung.algorithms.linkedlist;
+
+public class CycleRemovalBruteForce {
+
+    public static <T> boolean detectAndRemoveCycle(Node<T> head) {
+        CycleDetectionResult<T> result = CycleDetectionByFastAndSlowIterators.detectCycle(head);
+
+        if (result.cycleExists) {
+            removeCycle(result.node, head);
+        }
+
+        return result.cycleExists;
+    }
+
+    /**
+     * @param loopNodeParam - reference to the node where Flyods cycle 
+     * finding algorithm ends, i.e. the fast and the slow iterators
+     * meet.
+     * @param head - reference to the head of the list
+     */
+    private static <T> void removeCycle(Node<T> loopNodeParam, Node<T> head) {
+        Node<T> it = head;
+
+        while (it != null) {
+            if (isNodeReachableFromLoopNode(it, loopNodeParam)) {
+                Node<T> loopStart = it;
+                findEndNodeAndBreakCycle(loopStart);
+                break;
+            }
+            it = it.next;
+        }
+    }
+
+    private static <T> boolean isNodeReachableFromLoopNode(Node<T> it, Node<T> loopNodeParam) {
+        Node<T> loopNode = loopNodeParam;
+
+        do {
+            if (it == loopNode) {
+                return true;
+            }
+            loopNode = loopNode.next;
+        } while (loopNode.next != loopNodeParam);
+
+        return false;
+    }
+
+    private static <T> void findEndNodeAndBreakCycle(Node<T> loopStartParam) {
+        Node<T> loopStart = loopStartParam;
+
+        while (loopStart.next != loopStartParam) {
+            loopStart = loopStart.next;
+        }
+
+        loopStart.next = null;
+    }
+}

algorithms-miscellaneous-2/src/main/java/com/baeldung/algorithms/linkedlist/CycleRemovalByCountingLoopNodes.java

@@ -1,44 +1,44 @@
-package com.baeldung.algorithms.linkedlist;
-
-public class CycleRemovalByCountingLoopNodes {
-
-    public static <T> boolean detectAndRemoveCycle(Node<T> head) {
-        CycleDetectionResult<T> result = CycleDetectionByFastAndSlowIterators.detectCycle(head);
-
-        if (result.cycleExists) {
-            removeCycle(result.node, head);
-        }
-
-        return result.cycleExists;
-    }
-
-    private static <T> void removeCycle(Node<T> loopNodeParam, Node<T> head) {
-        int cycleLength = calculateCycleLength(loopNodeParam);
-        Node<T> cycleLengthAdvancedIterator = head;
-        Node<T> it = head;
-
-        for (int i = 0; i < cycleLength; i++) {
-            cycleLengthAdvancedIterator = cycleLengthAdvancedIterator.next;
-        }
-
-        while (it.next != cycleLengthAdvancedIterator.next) {
-            it = it.next;
-            cycleLengthAdvancedIterator = cycleLengthAdvancedIterator.next;
-        }
-
-        cycleLengthAdvancedIterator.next = null;
-    }
-
-    private static <T> int calculateCycleLength(Node<T> loopNodeParam) {
-        Node<T> loopNode = loopNodeParam;
-        int length = 1;
-
-        while (loopNode.next != loopNodeParam) {
-            length++;
-            loopNode = loopNode.next;
-        }
-
-        return length;
-    }
-
-}
+package com.baeldung.algorithms.linkedlist;
+
+public class CycleRemovalByCountingLoopNodes {
+
+    public static <T> boolean detectAndRemoveCycle(Node<T> head) {
+        CycleDetectionResult<T> result = CycleDetectionByFastAndSlowIterators.detectCycle(head);
+
+        if (result.cycleExists) {
+            removeCycle(result.node, head);
+        }
+
+        return result.cycleExists;
+    }
+
+    private static <T> void removeCycle(Node<T> loopNodeParam, Node<T> head) {
+        int cycleLength = calculateCycleLength(loopNodeParam);
+        Node<T> cycleLengthAdvancedIterator = head;
+        Node<T> it = head;
+
+        for (int i = 0; i < cycleLength; i++) {
+            cycleLengthAdvancedIterator = cycleLengthAdvancedIterator.next;
+        }
+
+        while (it.next != cycleLengthAdvancedIterator.next) {
+            it = it.next;
+            cycleLengthAdvancedIterator = cycleLengthAdvancedIterator.next;
+        }
+
+        cycleLengthAdvancedIterator.next = null;
+    }
+
+    private static <T> int calculateCycleLength(Node<T> loopNodeParam) {
+        Node<T> loopNode = loopNodeParam;
+        int length = 1;
+
+        while (loopNode.next != loopNodeParam) {
+            length++;
+            loopNode = loopNode.next;
+        }
+
+        return length;
+    }
+
+}

algorithms-miscellaneous-2/src/main/java/com/baeldung/algorithms/linkedlist/CycleRemovalWithoutCountingLoopNodes.java

@@ -1,27 +1,27 @@
-package com.baeldung.algorithms.linkedlist;
-
-public class CycleRemovalWithoutCountingLoopNodes {
-
-    public static <T> boolean detectAndRemoveCycle(Node<T> head) {
-        CycleDetectionResult<T> result = CycleDetectionByFastAndSlowIterators.detectCycle(head);
-
-        if (result.cycleExists) {
-            removeCycle(result.node, head);
-        }
-
-        return result.cycleExists;
-    }
-
-    private static <T> void removeCycle(Node<T> meetingPointParam, Node<T> head) {
-        Node<T> loopNode = meetingPointParam;
-        Node<T> it = head;
-
-        while (loopNode.next != it.next) {
-            it = it.next;
-            loopNode = loopNode.next;
-        }
-
-        loopNode.next = null;
-    }
-
-}
+package com.baeldung.algorithms.linkedlist;
+
+public class CycleRemovalWithoutCountingLoopNodes {
+
+    public static <T> boolean detectAndRemoveCycle(Node<T> head) {
+        CycleDetectionResult<T> result = CycleDetectionByFastAndSlowIterators.detectCycle(head);
+
+        if (result.cycleExists) {
+            removeCycle(result.node, head);
+        }
+
+        return result.cycleExists;
+    }
+
+    private static <T> void removeCycle(Node<T> meetingPointParam, Node<T> head) {
+        Node<T> loopNode = meetingPointParam;
+        Node<T> it = head;
+
+        while (loopNode.next != it.next) {
+            it = it.next;
+            loopNode = loopNode.next;
+        }
+
+        loopNode.next = null;
+    }
+
+}

algorithms-miscellaneous-2/src/main/java/com/baeldung/algorithms/linkedlist/Node.java

@@ -1,38 +1,38 @@
-package com.baeldung.algorithms.linkedlist;
-
-public class Node<T> {
-    T data;
-    Node<T> next;
-
-    public static <T> Node<T> createNewNode(T data, Node<T> next) {
-        Node<T> node = new Node<T>();
-        node.data = data;
-        node.next = next;
-        return node;
-    }
-
-    public static <T> void traverseList(Node<T> root) {
-        if (root == null) {
-            return;
-        }
-
-        Node<T> node = root;
-        while (node != null) {
-            System.out.println(node.data);
-            node = node.next;
-        }
-    }
-
-    public static <T> Node<T> getTail(Node<T> root) {
-        if (root == null) {
-            return null;
-        }
-
-        Node<T> node = root;
-        while (node.next != null) {
-            node = node.next;
-        }
-        return node;
-    }
-
+package com.baeldung.algorithms.linkedlist;
+
+public class Node<T> {
+    T data;
+    Node<T> next;
+
+    public static <T> Node<T> createNewNode(T data, Node<T> next) {
+        Node<T> node = new Node<T>();
+        node.data = data;
+        node.next = next;
+        return node;
+    }
+
+    public static <T> void traverseList(Node<T> root) {
+        if (root == null) {
+            return;
+        }
+
+        Node<T> node = root;
+        while (node != null) {
+            System.out.println(node.data);
+            node = node.next;
+        }
+    }
+
+    public static <T> Node<T> getTail(Node<T> root) {
+        if (root == null) {
+            return null;
+        }
+
+        Node<T> node = root;
+        while (node.next != null) {
+            node = node.next;
+        }
+        return node;
+    }
+
 }

algorithms-miscellaneous-2/src/main/java/com/baeldung/algorithms/maze/solver/BFSMazeSolver.java

@@ -1,52 +1,52 @@
-package com.baeldung.algorithms.maze.solver;
-
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.LinkedList;
-import java.util.List;
-
-public class BFSMazeSolver {
-    private static final int[][] DIRECTIONS = { { 0, 1 }, { 1, 0 }, { 0, -1 }, { -1, 0 } };
-
-    public List<Coordinate> solve(Maze maze) {
-        LinkedList<Coordinate> nextToVisit = new LinkedList<>();
-        Coordinate start = maze.getEntry();
-        nextToVisit.add(start);
-
-        while (!nextToVisit.isEmpty()) {
-            Coordinate cur = nextToVisit.remove();
-
-            if (!maze.isValidLocation(cur.getX(), cur.getY()) || maze.isExplored(cur.getX(), cur.getY())) {
-                continue;
-            }
-
-            if (maze.isWall(cur.getX(), cur.getY())) {
-                maze.setVisited(cur.getX(), cur.getY(), true);
-                continue;
-            }
-
-            if (maze.isExit(cur.getX(), cur.getY())) {
-                return backtrackPath(cur);
-            }
-
-            for (int[] direction : DIRECTIONS) {
-                Coordinate coordinate = new Coordinate(cur.getX() + direction[0], cur.getY() + direction[1], cur);
-                nextToVisit.add(coordinate);
-                maze.setVisited(cur.getX(), cur.getY(), true);
-            }
-        }
-        return Collections.emptyList();
-    }
-
-    private List<Coordinate> backtrackPath(Coordinate cur) {
-        List<Coordinate> path = new ArrayList<>();
-        Coordinate iter = cur;
-
-        while (iter != null) {
-            path.add(iter);
-            iter = iter.parent;
-        }
-
-        return path;
-    }
-}
+package com.baeldung.algorithms.maze.solver;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.LinkedList;
+import java.util.List;
+
+public class BFSMazeSolver {
+    private static final int[][] DIRECTIONS = { { 0, 1 }, { 1, 0 }, { 0, -1 }, { -1, 0 } };
+
+    public List<Coordinate> solve(Maze maze) {
+        LinkedList<Coordinate> nextToVisit = new LinkedList<>();
+        Coordinate start = maze.getEntry();
+        nextToVisit.add(start);
+
+        while (!nextToVisit.isEmpty()) {
+            Coordinate cur = nextToVisit.remove();
+
+            if (!maze.isValidLocation(cur.getX(), cur.getY()) || maze.isExplored(cur.getX(), cur.getY())) {
+                continue;
+            }
+
+            if (maze.isWall(cur.getX(), cur.getY())) {
+                maze.setVisited(cur.getX(), cur.getY(), true);
+                continue;
+            }
+
+            if (maze.isExit(cur.getX(), cur.getY())) {
+                return backtrackPath(cur);
+            }
+
+            for (int[] direction : DIRECTIONS) {
+                Coordinate coordinate = new Coordinate(cur.getX() + direction[0], cur.getY() + direction[1], cur);
+                nextToVisit.add(coordinate);
+                maze.setVisited(cur.getX(), cur.getY(), true);
+            }
+        }
+        return Collections.emptyList();
+    }
+
+    private List<Coordinate> backtrackPath(Coordinate cur) {
+        List<Coordinate> path = new ArrayList<>();
+        Coordinate iter = cur;
+
+        while (iter != null) {
+            path.add(iter);
+            iter = iter.parent;
+        }
+
+        return path;
+    }
+}

algorithms-miscellaneous-2/src/main/java/com/baeldung/algorithms/maze/solver/Coordinate.java

@@ -1,31 +1,31 @@
-package com.baeldung.algorithms.maze.solver;
-
-public class Coordinate {
-    int x;
-    int y;
-    Coordinate parent;
-
-    public Coordinate(int x, int y) {
-        this.x = x;
-        this.y = y;
-        this.parent = null;
-    }
-
-    public Coordinate(int x, int y, Coordinate parent) {
-        this.x = x;
-        this.y = y;
-        this.parent = parent;
-    }
-
-    int getX() {
-        return x;
-    }
-
-    int getY() {
-        return y;
-    }
-
-    Coordinate getParent() {
-        return parent;
-    }
-}
+package com.baeldung.algorithms.maze.solver;
+
+public class Coordinate {
+    int x;
+    int y;
+    Coordinate parent;
+
+    public Coordinate(int x, int y) {
+        this.x = x;
+        this.y = y;
+        this.parent = null;
+    }
+
+    public Coordinate(int x, int y, Coordinate parent) {
+        this.x = x;
+        this.y = y;
+        this.parent = parent;
+    }
+
+    int getX() {
+        return x;
+    }
+
+    int getY() {
+        return y;
+    }
+
+    Coordinate getParent() {
+        return parent;
+    }
+}

algorithms-miscellaneous-2/src/main/java/com/baeldung/algorithms/maze/solver/DFSMazeSolver.java

@@ -1,48 +1,48 @@
-package com.baeldung.algorithms.maze.solver;
-
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-
-public class DFSMazeSolver {
-    private static final int[][] DIRECTIONS = { { 0, 1 }, { 1, 0 }, { 0, -1 }, { -1, 0 } };
-
-    public List<Coordinate> solve(Maze maze) {
-        List<Coordinate> path = new ArrayList<>();
-        if (explore(maze, maze.getEntry()
-            .getX(),
-            maze.getEntry()
-                .getY(),
-            path)) {
-            return path;
-        }
-        return Collections.emptyList();
-    }
-
-    private boolean explore(Maze maze, int row, int col, List<Coordinate> path) {
-        if (!maze.isValidLocation(row, col) || maze.isWall(row, col) || maze.isExplored(row, col)) {
-            return false;
-        }
-
-        path.add(new Coordinate(row, col));
-        maze.setVisited(row, col, true);
-
-        if (maze.isExit(row, col)) {
-            return true;
-        }
-
-        for (int[] direction : DIRECTIONS) {
-            Coordinate coordinate = getNextCoordinate(row, col, direction[0], direction[1]);
-            if (explore(maze, coordinate.getX(), coordinate.getY(), path)) {
-                return true;
-            }
-        }
-
-        path.remove(path.size() - 1);
-        return false;
-    }
-
-    private Coordinate getNextCoordinate(int row, int col, int i, int j) {
-        return new Coordinate(row + i, col + j);
-    }
-}
+package com.baeldung.algorithms.maze.solver;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class DFSMazeSolver {
+    private static final int[][] DIRECTIONS = { { 0, 1 }, { 1, 0 }, { 0, -1 }, { -1, 0 } };
+
+    public List<Coordinate> solve(Maze maze) {
+        List<Coordinate> path = new ArrayList<>();
+        if (explore(maze, maze.getEntry()
+            .getX(),
+            maze.getEntry()
+                .getY(),
+            path)) {
+            return path;
+        }
+        return Collections.emptyList();
+    }
+
+    private boolean explore(Maze maze, int row, int col, List<Coordinate> path) {
+        if (!maze.isValidLocation(row, col) || maze.isWall(row, col) || maze.isExplored(row, col)) {
+            return false;
+        }
+
+        path.add(new Coordinate(row, col));
+        maze.setVisited(row, col, true);
+
+        if (maze.isExit(row, col)) {
+            return true;
+        }
+
+        for (int[] direction : DIRECTIONS) {
+            Coordinate coordinate = getNextCoordinate(row, col, direction[0], direction[1]);
+            if (explore(maze, coordinate.getX(), coordinate.getY(), path)) {
+                return true;
+            }
+        }
+
+        path.remove(path.size() - 1);
+        return false;
+    }
+
+    private Coordinate getNextCoordinate(int row, int col, int i, int j) {
+        return new Coordinate(row + i, col + j);
+    }
+}