Merge pull request #1 from eugenp/master

local fetching

.gitignore

@@ -66,3 +66,10 @@ jmeter/src/main/resources/*-JMeter.csv
 **/nb-configuration.xml
 core-scala/.cache-main
 core-scala/.cache-tests
+
+
+persistence-modules/hibernate5/transaction.log
+apache-avro/src/main/java/com/baeldung/avro/model/
+jta/transaction-logs/
+software-security/sql-injection-samples/derby.log
+spring-soap/src/main/java/com/baeldung/springsoap/gen/

.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-first,default-second
+script: travis_wait 60 mvn -q install -Pdefault-first,default-second -Dgib.enabled=true
 
 sudo: required
 

JGit/pom.xml

@@ -5,9 +5,9 @@
     <groupId>com.baeldung</groupId>
     <artifactId>JGit</artifactId>
     <version>1.0-SNAPSHOT</version>
+	<name>JGit</name>
     <packaging>jar</packaging>
     <url>http://maven.apache.org</url>
-	<name>JGit</name>
 
     <parent>
         <groupId>com.baeldung</groupId>

JGit/src/main/java/com/baeldung/jgit/porcelain/Log.java

@@ -28,14 +28,14 @@ public class Log {
                 System.out.println("Had " + count + " commits overall on current branch");
 
                 logs = git.log()
-                        .add(repository.resolve("remotes/origin/testbranch"))
+                        .add(repository.resolve(git.getRepository().getFullBranch()))
                         .call();
                 count = 0;
                 for (RevCommit rev : logs) {
                     System.out.println("Commit: " + rev /* + ", name: " + rev.getName() + ", id: " + rev.getId().getName() */);
                     count++;
                 }
-                System.out.println("Had " + count + " commits overall on test-branch");
+                System.out.println("Had " + count + " commits overall on "+git.getRepository().getFullBranch());
 
                 logs = git.log()
                         .all()

JGit/src/test/java/com/baeldung/jgit/JGitBugIntegrationTest.java

@@ -1,3 +1,5 @@
+package com.baeldung.jgit;
+
 import com.baeldung.jgit.helper.Helper;
 import org.eclipse.jgit.lib.ObjectLoader;
 import org.eclipse.jgit.lib.ObjectReader;

README.md

@@ -14,7 +14,7 @@ Java and Spring Tutorials
 ================
 
 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. 
+A strong focus of these is, of course, the Spring Framework - Spring, Spring Boot and Spring Security. 
 In additional to Spring, the following technologies are in focus: `core Java`, `Jackson`, `HttpClient`, `Guava`. 
 
 

Twitter4J/pom.xml

@@ -2,8 +2,8 @@
     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
     <modelVersion>4.0.0</modelVersion>
     <artifactId>Twitter4J</artifactId>
-    <packaging>jar</packaging>
     <name>Twitter4J</name>
+    <packaging>jar</packaging>
 
     <parent>
         <groupId>com.baeldung</groupId>

akka-http/README.md

@@ -0,0 +1,3 @@
+## Relevant articles:
+
+- [Introduction to Akka HTTP](https://www.baeldung.com/akka-http)

akka-http/pom.xml

@@ -0,0 +1,47 @@
+<?xml version="1.0"?>
+<project
+	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"
+	xmlns="http://maven.apache.org/POM/4.0.0"
+	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+
+	<modelVersion>4.0.0</modelVersion>
+	<artifactId>akka-http</artifactId>
+	<name>akka-http</name>
+
+	<parent>
+		<artifactId>parent-modules</artifactId>
+		<groupId>com.baeldung</groupId>
+		<version>1.0.0-SNAPSHOT</version>
+	</parent>
+
+	<dependencies>
+		<dependency>
+			<groupId>com.typesafe.akka</groupId>
+			<artifactId>akka-http_2.12</artifactId>
+			<version>${akka.http.version}</version>
+		</dependency>
+		<dependency>
+			<groupId>com.typesafe.akka</groupId>
+			<artifactId>akka-stream_2.12</artifactId>
+			<version>${akka.stream.version}</version>
+		</dependency>
+		<dependency>
+			<groupId>com.typesafe.akka</groupId>
+			<artifactId>akka-http-jackson_2.12</artifactId>
+			<version>${akka.http.version}</version>
+		</dependency>
+		<dependency>
+			<groupId>com.typesafe.akka</groupId>
+			<artifactId>akka-http-testkit_2.12</artifactId>
+			<version>${akka.http.version}</version>
+			<scope>test</scope>
+		</dependency>
+	</dependencies>
+
+	<properties>
+		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
+		<akka.http.version>10.0.11</akka.http.version>
+		<akka.stream.version>2.5.11</akka.stream.version>
+	</properties>
+</project>

akka-http/src/main/java/com/baeldung/akkahttp/User.java

@@ -0,0 +1,26 @@
+package com.baeldung.akkahttp;
+
+public class User {
+
+    private final Long id;
+
+    private final String name;
+
+    public User() {
+        this.name = "";
+        this.id = null;
+    }
+
+    public User(Long id, String name) {
+        this.name = name;
+        this.id = id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public Long getId() {
+        return id;
+    }
+}

akka-http/src/main/java/com/baeldung/akkahttp/UserActor.java

@@ -0,0 +1,41 @@
+package com.baeldung.akkahttp;
+
+import akka.actor.AbstractActor;
+import akka.actor.Props;
+import akka.japi.pf.FI;
+import com.baeldung.akkahttp.UserMessages.ActionPerformed;
+import com.baeldung.akkahttp.UserMessages.CreateUserMessage;
+import com.baeldung.akkahttp.UserMessages.GetUserMessage;
+
+
+class UserActor extends AbstractActor {
+
+  private UserService userService = new UserService();
+
+  static Props props() {
+    return Props.create(UserActor.class);
+  }
+
+  @Override
+  public Receive createReceive() {
+    return receiveBuilder()
+            .match(CreateUserMessage.class, handleCreateUser())
+            .match(GetUserMessage.class, handleGetUser())
+            .build();
+  }
+
+  private FI.UnitApply<CreateUserMessage> handleCreateUser() {
+    return createUserMessageMessage -> {
+      userService.createUser(createUserMessageMessage.getUser());
+      sender().tell(new ActionPerformed(String.format("User %s created.", createUserMessageMessage.getUser()
+              .getName())), getSelf());
+    };
+  }
+
+  private FI.UnitApply<GetUserMessage> handleGetUser() {
+    return getUserMessageMessage -> {
+      sender().tell(userService.getUser(getUserMessageMessage.getUserId()), getSelf());
+    };
+  }
+
+}

akka-http/src/main/java/com/baeldung/akkahttp/UserMessages.java

@@ -0,0 +1,49 @@
+package com.baeldung.akkahttp;
+
+import java.io.Serializable;
+
+public interface UserMessages {
+
+  class ActionPerformed implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    private final String description;
+
+    public ActionPerformed(String description) {
+      this.description = description;
+    }
+
+    public String getDescription() {
+      return description;
+    }
+  }
+
+  class CreateUserMessage implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+    private final User user;
+
+    public CreateUserMessage(User user) {
+      this.user = user;
+    }
+
+    public User getUser() {
+      return user;
+    }
+  }
+
+  class GetUserMessage implements Serializable {
+    private static final long serialVersionUID = 1L;
+    private final Long userId;
+
+    public GetUserMessage(Long userId) {
+      this.userId = userId;
+    }
+
+    public Long getUserId() {
+      return userId;
+    }
+  }
+
+}

akka-http/src/main/java/com/baeldung/akkahttp/UserServer.java

@@ -0,0 +1,70 @@
+package com.baeldung.akkahttp;
+
+import java.util.Optional;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.TimeUnit;
+
+import akka.actor.ActorRef;
+import akka.actor.ActorSystem;
+import akka.http.javadsl.marshallers.jackson.Jackson;
+import akka.http.javadsl.model.StatusCodes;
+import akka.http.javadsl.server.HttpApp;
+import akka.http.javadsl.server.Route;
+import akka.pattern.PatternsCS;
+import akka.util.Timeout;
+import com.baeldung.akkahttp.UserMessages.ActionPerformed;
+import com.baeldung.akkahttp.UserMessages.CreateUserMessage;
+import com.baeldung.akkahttp.UserMessages.GetUserMessage;
+import scala.concurrent.duration.Duration;
+import static akka.http.javadsl.server.PathMatchers.*;
+
+class UserServer extends HttpApp {
+
+  private final ActorRef userActor;
+
+  Timeout timeout = new Timeout(Duration.create(5, TimeUnit.SECONDS));
+
+  UserServer(ActorRef userActor) {
+    this.userActor = userActor;
+  }
+
+  @Override
+  public Route routes() {
+    return path("users", this::postUser)
+            .orElse(path(segment("users").slash(longSegment()), id ->
+                    route(getUser(id))));
+  }
+
+  private Route getUser(Long id) {
+    return get(() -> {
+      CompletionStage<Optional<User>> user = PatternsCS.ask(userActor, new GetUserMessage(id), timeout)
+              .thenApply(obj -> (Optional<User>) obj);
+
+      return onSuccess(() -> user, performed -> {
+        if (performed.isPresent())
+          return complete(StatusCodes.OK, performed.get(), Jackson.marshaller());
+        else
+          return complete(StatusCodes.NOT_FOUND);
+      });
+    });
+  }
+
+  private Route postUser() {
+    return route(post(() -> entity(Jackson.unmarshaller(User.class), user -> {
+      CompletionStage<ActionPerformed> userCreated = PatternsCS.ask(userActor, new CreateUserMessage(user), timeout)
+              .thenApply(obj -> (ActionPerformed) obj);
+
+      return onSuccess(() -> userCreated, performed -> {
+        return complete(StatusCodes.CREATED, performed, Jackson.marshaller());
+      });
+    })));
+  }
+
+  public static void main(String[] args) throws Exception {
+    ActorSystem system = ActorSystem.create("userServer");
+    ActorRef userActor = system.actorOf(UserActor.props(), "userActor");
+    UserServer server = new UserServer(userActor);
+    server.startServer("localhost", 8080, system);
+  }
+
+}

akka-http/src/main/java/com/baeldung/akkahttp/UserService.java

@@ -0,0 +1,35 @@
+package com.baeldung.akkahttp;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+
+public class UserService {
+
+  private final static List<User> users = new ArrayList<>();
+
+  static {
+    users.add(new User(1l, "Alice"));
+    users.add(new User(2l, "Bob"));
+    users.add(new User(3l, "Chris"));
+    users.add(new User(4l, "Dick"));
+    users.add(new User(5l, "Eve"));
+    users.add(new User(6l, "Finn"));
+  }
+
+  public Optional<User> getUser(Long id) {
+    return users.stream()
+            .filter(user -> user.getId()
+                    .equals(id))
+            .findFirst();
+  }
+
+  public void createUser(User user) {
+    users.add(user);
+  }
+
+  public List<User> getUsers(){
+    return users;
+  }
+
+}

akka-http/src/test/java/com/baeldung/akkahttp/UserServerUnitTest.java

@@ -0,0 +1,50 @@
+package com.baeldung.akkahttp;
+
+import akka.actor.ActorRef;
+import akka.actor.ActorSystem;
+import akka.http.javadsl.model.ContentTypes;
+import akka.http.javadsl.model.HttpEntities;
+import akka.http.javadsl.model.HttpRequest;
+import akka.http.javadsl.testkit.JUnitRouteTest;
+import akka.http.javadsl.testkit.TestRoute;
+import org.junit.Test;
+
+public class UserServerUnitTest extends JUnitRouteTest {
+
+  ActorSystem system = ActorSystem.create("helloAkkaHttpServer");
+
+  ActorRef userActorRef = system.actorOf(UserActor.props(), "userActor");
+
+  TestRoute appRoute = testRoute(new UserServer(userActorRef).routes());
+
+  @Test
+  public void whenRequest_thenActorResponds() {
+
+    appRoute.run(HttpRequest.GET("/users/1"))
+            .assertEntity(alice())
+            .assertStatusCode(200);
+
+    appRoute.run(HttpRequest.GET("/users/42"))
+            .assertStatusCode(404);
+
+    appRoute.run(HttpRequest.DELETE("/users/1"))
+            .assertStatusCode(200);
+
+    appRoute.run(HttpRequest.DELETE("/users/42"))
+            .assertStatusCode(200);
+
+    appRoute.run(HttpRequest.POST("/users")
+            .withEntity(HttpEntities.create(ContentTypes.APPLICATION_JSON, zaphod())))
+            .assertStatusCode(201);
+
+  }
+
+  private String alice() {
+    return "{\"id\":1,\"name\":\"Alice\"}";
+  }
+
+  private String zaphod() {
+    return "{\"id\":42,\"name\":\"Zaphod\"}";
+  }
+
+}

algorithms-genetic/README.md

@@ -1,4 +1,6 @@
 ## Relevant articles:
 
 - [Introduction to Jenetics Library](http://www.baeldung.com/jenetics)
-- [Ant Colony Optimization](http://www.baeldung.com/java-ant-colony-optimization)
+- [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

@@ -1,10 +1,10 @@
 <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-genetic</artifactId>
     <version>0.0.1-SNAPSHOT</version>
-
+    <name>algorithms-genetic</name>
+    
     <parent>
         <groupId>com.baeldung</groupId>
         <artifactId>parent-modules</artifactId>
@@ -54,11 +54,11 @@
     </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>
+    
+</project>

algorithms-genetic/roundUpToHundred/.gitignore

@@ -1 +0,0 @@
-/bin/

algorithms-genetic/roundUpToHundred/src/com/java/src/RoundUpToHundred.java

@@ -1,20 +0,0 @@
-package com.java.src;
-
-import java.util.Scanner;
-
-public class RoundUpToHundred {
-
-    public static void main(String[] args) {
-        Scanner scanner = new Scanner(System.in);
-        double input = scanner.nextDouble();
-        scanner.close();
-
-        RoundUpToHundred.round(input);
-    }
-
-    static long round(double input) {
-        long i = (long) Math.ceil(input);
-        return ((i + 99) / 100) * 100;
-    };
-
-}

algorithms-genetic/roundUpToHundred/src/com/java/src/RoundUpToHundredTest.java

@@ -1,14 +0,0 @@
-package com.java.src;
-
-import static org.junit.Assert.assertEquals;
-
-import org.junit.Test;
-
-public class RoundUpToHundredTest {
-    @Test
-    public void givenInput_whenRound_thenRoundUpToTheNearestHundred() {
-        assertEquals("Rounded up to hundred", 100, RoundUpToHundred.round(99));
-        assertEquals("Rounded up to three hundred ", 300, RoundUpToHundred.round(200.2));
-        assertEquals("Returns same rounded value", 400, RoundUpToHundred.round(400));
-    }
-}

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("2 - Simple Genetic Algorithm");
-		System.out.println("3 - Simple Genetic Algorithm");
+		System.out.println("3 - Ant Colony");
-		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");
 		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/README.md

@@ -9,4 +9,12 @@
 - [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)
+- [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)
+- [Calculate Factorial in Java](https://www.baeldung.com/java-calculate-factorial)
+- [Find Substrings That Are Palindromes in Java](https://www.baeldung.com/java-palindrome-substrings)
+- [Find the Longest Substring without Repeating Characters](https://www.baeldung.com/java-longest-substring-without-repeated-characters)
+- [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

@@ -1,10 +1,10 @@
 <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-miscellaneous-1</artifactId>
     <version>0.0.1-SNAPSHOT</version>
-
+    <name>algorithms-miscellaneous-1</name>
+    
     <parent>
         <groupId>com.baeldung</groupId>
         <artifactId>parent-modules</artifactId>
@@ -17,6 +17,11 @@
             <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>
@@ -34,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>
@@ -69,10 +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>27.0.1-jre</guava.version>
     </properties>
 
 </project>

algorithms-miscellaneous-1/roundUpToHundred/.gitignore

@@ -1 +0,0 @@
-/bin/

algorithms-miscellaneous-1/roundUpToHundred/src/com/java/src/RoundUpToHundredTest.java

@@ -1,14 +0,0 @@
-package com.java.src;
-
-import static org.junit.Assert.assertEquals;
-
-import org.junit.Test;
-
-public class RoundUpToHundredTest {
-    @Test
-    public void givenInput_whenRound_thenRoundUpToTheNearestHundred() {
-        assertEquals("Rounded up to hundred", 100, RoundUpToHundred.round(99));
-        assertEquals("Rounded up to three hundred ", 300, RoundUpToHundred.round(200.2));
-        assertEquals("Returns same rounded value", 400, RoundUpToHundred.round(400));
-    }
-}

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);
+    }
+}

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

@@ -0,0 +1,50 @@
+package com.baeldung.algorithms.combination;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class SetRecursiveCombinationGenerator {
+
+    private static final int N = 5;
+    private static final int R = 2;
+
+    /** 
+     * Generate all combinations of r elements from a set
+     * @param n - number of elements in set
+     * @param r - number of elements in selection
+     * @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;
+    }
+
+    /**
+     * @param combinations - List to contain the generated combinations
+     * @param data - List of elements in the selection
+     * @param start - index of the starting element in the remaining set
+     * @param end - index of the last element in the set  
+     * @param index - number of elements selected 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 if (start <= end) {
+            data[index] = start;
+            helper(combinations, data, start + 1, end, index + 1);
+            helper(combinations, data, start + 1, end, index);
+        }
+    }
+
+    public static void main(String[] args) {
+        SetRecursiveCombinationGenerator generator = new SetRecursiveCombinationGenerator();
+        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);
+    }
+}

algorithms-miscellaneous-1/src/main/java/com/baeldung/algorithms/enumstatemachine/LeaveRequestState.java

@@ -0,0 +1,46 @@
+package com.baeldung.algorithms.enumstatemachine;
+
+public enum LeaveRequestState {
+
+    Submitted {
+        @Override
+        public LeaveRequestState nextState() {
+            System.out.println("Starting the Leave Request and sending to Team Leader for approval.");
+            return Escalated;
+        }
+
+        @Override
+        public String responsiblePerson() {
+            return "Employee";
+        }
+    },
+    Escalated {
+        @Override
+        public LeaveRequestState nextState() {
+            System.out.println("Reviewing the Leave Request and escalating to Department Manager.");
+            return Approved;
+        }
+
+        @Override
+        public String responsiblePerson() {
+            return "Team Leader";
+        }
+    },
+    Approved {
+        @Override
+        public LeaveRequestState nextState() {
+            System.out.println("Approving the Leave Request.");
+            return this;
+        }
+
+        @Override
+        public String responsiblePerson() {
+            return "Department Manager";
+        }
+    };
+
+    public abstract String responsiblePerson();
+
+    public abstract LeaveRequestState nextState();
+
+}

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/permutation/Permutation.java

@@ -0,0 +1,123 @@
+package com.baeldung.algorithms.permutation;
+
+import java.util.Arrays;
+import java.util.Collections;
+
+public  class Permutation {
+
+    public static <T> void printAllRecursive(T[] elements, char delimiter) {
+        printAllRecursive(elements.length, elements, delimiter);
+    }
+
+    public static <T> void printAllRecursive(int n, T[] elements, char delimiter) {
+
+        if(n == 1) {
+            printArray(elements, delimiter);
+        } else {
+            for(int i = 0; i < n-1; i++) {
+                printAllRecursive(n - 1, elements, delimiter);
+                if(n % 2 == 0) {
+                    swap(elements, i, n-1);
+                } else {
+                    swap(elements, 0, n-1);
+                }
+            }
+            printAllRecursive(n - 1, elements, delimiter);
+        }
+    }
+
+    public static <T> void printAllIterative(int n, T[] elements, char delimiter) {
+
+        int[] indexes = new int[n];
+        for (int i = 0; i < n; i++) {
+            indexes[i] = 0;
+        }
+
+        printArray(elements, delimiter);
+
+        int i = 0;
+        while (i < n) {
+            if (indexes[i] < i) {
+                swap(elements, i % 2 == 0 ?  0: indexes[i], i);
+                printArray(elements, delimiter);
+                indexes[i]++;
+                i = 0;
+            }
+            else {
+                indexes[i] = 0;
+                i++;
+            }
+        }
+    }
+
+    public static <T extends Comparable<T>> void printAllOrdered(T[] elements, char delimiter) {
+
+        Arrays.sort(elements);
+        boolean hasNext = true;
+
+        while(hasNext) {
+            printArray(elements, delimiter);
+            int k = 0, l = 0;
+            hasNext = false;
+            for (int i = elements.length - 1; i > 0; i--) {
+                if (elements[i].compareTo(elements[i - 1]) > 0) {
+                    k = i - 1;
+                    hasNext = true;
+                    break;
+                }
+            }
+
+            for (int i = elements.length - 1; i > k; i--) {
+                if (elements[i].compareTo(elements[k]) > 0) {
+                    l = i;
+                    break;
+                }
+            }
+
+            swap(elements, k, l);
+            Collections.reverse(Arrays.asList(elements).subList(k + 1, elements.length));
+        }
+    }
+
+    public static <T> void printRandom(T[] elements, char delimiter) {
+
+        Collections.shuffle(Arrays.asList(elements));
+        printArray(elements, delimiter);
+    }
+
+    private static <T> void swap(T[] elements, int a, int b) {
+
+        T tmp = elements[a];
+        elements[a] = elements[b];
+        elements[b] = tmp;
+    }
+
+    private static <T> void printArray(T[] elements, char delimiter) {
+
+        String delimiterSpace = delimiter + " ";
+        for(int i = 0; i < elements.length; i++) {
+            System.out.print(elements[i] + delimiterSpace);
+        }
+        System.out.print('\n');
+    }
+
+    public static void main(String[] argv) {
+
+        Integer[] elements = {1,2,3,4};
+
+        System.out.println("Rec:");
+        printAllRecursive(elements, ';');
+
+        System.out.println("Iter:");
+        printAllIterative(elements.length, elements, ';');
+
+        System.out.println("Orderes:");
+        printAllOrdered(elements, ';');
+
+        System.out.println("Random:");
+        printRandom(elements, ';');
+
+        System.out.println("Random:");
+        printRandom(elements, ';');
+    }
+}

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/main/java/com/baeldung/algorithms/string/SubstringPalindrome.java

@@ -0,0 +1,90 @@
+package com.baeldung.algorithms.string;
+
+import java.util.HashSet;
+import java.util.Set;
+
+public class SubstringPalindrome {
+
+    public Set<String> findAllPalindromesUsingCenter(String input) {
+        final Set<String> palindromes = new HashSet<>();
+        if (input == null || input.isEmpty()) {
+            return palindromes;
+        }
+        if (input.length() == 1) {
+            palindromes.add(input);
+            return palindromes;
+        }
+        for (int i = 0; i < input.length(); i++) {
+            palindromes.addAll(findPalindromes(input, i, i + 1));
+            palindromes.addAll(findPalindromes(input, i, i));
+        }
+        return palindromes;
+    }
+
+    private Set<String> findPalindromes(String input, int low, int high) {
+        Set<String> result = new HashSet<>();
+        while (low >= 0 && high < input.length() && input.charAt(low) == input.charAt(high)) {
+            result.add(input.substring(low, high + 1));
+            low--;
+            high++;
+        }
+        return result;
+    }
+
+    public Set<String> findAllPalindromesUsingBruteForceApproach(String input) {
+        Set<String> palindromes = new HashSet<>();
+        if (input == null || input.isEmpty()) {
+            return palindromes;
+        }
+        if (input.length() == 1) {
+            palindromes.add(input);
+            return palindromes;
+        }
+        for (int i = 0; i < input.length(); i++) {
+            for (int j = i + 1; j <= input.length(); j++)
+                if (isPalindrome(input.substring(i, j))) {
+                    palindromes.add(input.substring(i, j));
+                }
+        }
+        return palindromes;
+    }
+
+    private boolean isPalindrome(String input) {
+        StringBuilder plain = new StringBuilder(input);
+        StringBuilder reverse = plain.reverse();
+        return (reverse.toString()).equals(input);
+    }
+
+    public Set<String> findAllPalindromesUsingManachersAlgorithm(String input) {
+        Set<String> palindromes = new HashSet<>();
+        String formattedInput = "@" + input + "#";
+        char inputCharArr[] = formattedInput.toCharArray();
+        int max;
+        int radius[][] = new int[2][input.length() + 1];
+        for (int j = 0; j <= 1; j++) {
+            radius[j][0] = max = 0;
+            int i = 1;
+            while (i <= input.length()) {
+                palindromes.add(Character.toString(inputCharArr[i]));
+                while (inputCharArr[i - max - 1] == inputCharArr[i + j + max])
+                    max++;
+                radius[j][i] = max;
+                int k = 1;
+                while ((radius[j][i - k] != max - k) && (k < max)) {
+                    radius[j][i + k] = Math.min(radius[j][i - k], max - k);
+                    k++;
+                }
+                max = Math.max(max - k, 0);
+                i += k;
+            }
+        }
+        for (int i = 1; i <= input.length(); i++) {
+            for (int j = 0; j <= 1; j++) {
+                for (max = radius[j][i]; max > 0; max--) {
+                    palindromes.add(input.substring(i - max - 1, max + j + i - 1));
+                }
+            }
+        }
+        return palindromes;
+    }
+}

algorithms-miscellaneous-1/src/main/java/com/baeldung/algorithms/twopointertechnique/LinkedListFindMiddle.java

@@ -0,0 +1,16 @@
+package com.baeldung.algorithms.twopointertechnique;
+
+public class LinkedListFindMiddle {
+
+    public <T> T findMiddle(MyNode<T> head) {
+        MyNode<T> slowPointer = head;
+        MyNode<T> fastPointer = head;
+
+        while (fastPointer.next != null && fastPointer.next.next != null) {
+            fastPointer = fastPointer.next.next;
+            slowPointer = slowPointer.next;
+        }
+        return slowPointer.data;
+    }
+
+}

algorithms-miscellaneous-1/src/main/java/com/baeldung/algorithms/twopointertechnique/MyNode.java

@@ -0,0 +1,20 @@
+package com.baeldung.algorithms.twopointertechnique;
+
+public class MyNode<E> {
+    MyNode<E> next;
+    E data;
+
+    public MyNode(E value) {
+        data = value;
+        next = null;
+    }
+
+    public MyNode(E value, MyNode<E> n) {
+        data = value;
+        next = n;
+    }
+
+    public void setNext(MyNode<E> n) {
+        next = n;
+    }
+}

algorithms-miscellaneous-1/src/main/java/com/baeldung/algorithms/twopointertechnique/RotateArray.java

@@ -0,0 +1,22 @@
+package com.baeldung.algorithms.twopointertechnique;
+
+public class RotateArray {
+
+    public void rotate(int[] input, int step) {
+        step %= input.length;
+        reverse(input, 0, input.length - 1);
+        reverse(input, 0, step - 1);
+        reverse(input, step, input.length - 1);
+    }
+
+    private void reverse(int[] input, int start, int end) {
+        while (start < end) {
+            int temp = input[start];
+            input[start] = input[end];
+            input[end] = temp;
+            start++;
+            end--;
+        }
+    }
+
+}

algorithms-miscellaneous-1/src/main/java/com/baeldung/algorithms/twopointertechnique/TwoSum.java

@@ -0,0 +1,38 @@
+package com.baeldung.algorithms.twopointertechnique;
+
+public class TwoSum {
+
+    public boolean twoSum(int[] input, int targetValue) {
+
+        int pointerOne = 0;
+        int pointerTwo = input.length - 1;
+
+        while (pointerOne < pointerTwo) {
+            int sum = input[pointerOne] + input[pointerTwo];
+
+            if (sum == targetValue) {
+                return true;
+            } else if (sum < targetValue) {
+                pointerOne++;
+            } else {
+                pointerTwo--;
+            }
+        }
+
+        return false;
+    }
+
+    public boolean twoSumSlow(int[] input, int targetValue) {
+
+        for (int i = 0; i < input.length; i++) {
+            for (int j = 1; j < input.length; j++) {
+                if (input[i] + input[j] == targetValue) {
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    }
+
+}

algorithms-miscellaneous-1/src/main/resources/maze/maze1.txt

@@ -1,12 +0,0 @@
-S ########
-#        #
-# ### ## #
-# #    # #
-# #  # # #
-# ## #####
-# #      #
-# # #  # #
-##### ####
-#   #    E
-# #    # #
-##########

algorithms-miscellaneous-1/src/main/resources/maze/maze2.txt

@@ -1,22 +0,0 @@
-S ##########################
-# #      #                 #
-# # ####   ############### #
-# # #    # #               #
-# # #### # # ###############
-# # #    # # #             #
-# # # #### ### ########### #
-# # # #        #           #
-#       ################## #
-#########    # # #       # #
-# #       #### # ####### # #
-# # ### ###  # # #       # #
-#   #       ##   # ##### # #
-##### #######  # #     # # #
-#     #       ## ## #### # #
-# ##### #######     #      #
-#       #       ############
-####### #########        # #
-#       #         ######## #
-# ####### ###### ##   #    E
-#         #         #   ## #
-############################

algorithms-miscellaneous-1/src/test/java/com/baeldung/algorithms/combination/CombinationUnitTest.java

@@ -0,0 +1,35 @@
+package com.baeldung.algorithms.combination;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.util.List;
+
+import org.junit.Test;
+
+public class CombinationUnitTest {
+
+    private static final int N = 5;
+    private static final int R = 3;
+    private static final int nCr = 10;
+      
+    @Test
+    public void givenSetAndSelectionSize_whenCalculatedUsingSetRecursiveAlgorithm_thenExpectedCount() {
+        SetRecursiveCombinationGenerator generator = new SetRecursiveCombinationGenerator();
+        List<int[]> selection = generator.generate(N, R);
+        assertEquals(nCr, selection.size());
+    }
+
+    @Test
+    public void givenSetAndSelectionSize_whenCalculatedUsingSelectionRecursiveAlgorithm_thenExpectedCount() {
+        SelectionRecursiveCombinationGenerator generator = new SelectionRecursiveCombinationGenerator();
+        List<int[]> selection = generator.generate(N, R);
+        assertEquals(nCr, selection.size());
+    }
+    
+    @Test
+    public void givenSetAndSelectionSize_whenCalculatedUsingIterativeAlgorithm_thenExpectedCount() {
+        IterativeCombinationGenerator generator = new IterativeCombinationGenerator();
+        List<int[]> selection = generator.generate(N, R);
+        assertEquals(nCr, selection.size());
+    }
+}

algorithms-miscellaneous-1/src/test/java/com/baeldung/algorithms/enumstatemachine/LeaveRequestStateUnitTest.java

@@ -0,0 +1,37 @@
+package com.baeldung.algorithms.enumstatemachine;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+
+public class LeaveRequestStateUnitTest {
+
+    @Test
+    public void givenLeaveRequest_whenStateEscalated_thenResponsibleIsTeamLeader() {
+        LeaveRequestState state = LeaveRequestState.Escalated;
+
+        assertEquals(state.responsiblePerson(), "Team Leader");
+    }
+
+
+    @Test
+    public void givenLeaveRequest_whenStateApproved_thenResponsibleIsDepartmentManager() {
+        LeaveRequestState state = LeaveRequestState.Approved;
+
+        assertEquals(state.responsiblePerson(), "Department Manager");
+    }
+
+    @Test
+    public void givenLeaveRequest_whenNextStateIsCalled_thenStateIsChanged() {
+        LeaveRequestState state = LeaveRequestState.Submitted;
+
+        state = state.nextState();
+        assertEquals(state, LeaveRequestState.Escalated);
+
+        state = state.nextState();
+        assertEquals(state, LeaveRequestState.Approved);
+
+        state = state.nextState();
+        assertEquals(state, LeaveRequestState.Approved);
+    }
+}

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-1/src/test/java/com/baeldung/algorithms/string/SubstringPalindromeUnitTest.java

@@ -0,0 +1,83 @@
+package com.baeldung.algorithms.string;
+
+import static org.junit.Assert.assertEquals;
+import java.util.HashSet;
+import java.util.Set;
+import org.junit.Test;
+
+public class SubstringPalindromeUnitTest {
+
+    private static final String INPUT_BUBBLE = "bubble";
+    private static final String INPUT_CIVIC = "civic";
+    private static final String INPUT_INDEED = "indeed";
+    private static final String INPUT_ABABAC = "ababac";
+
+    Set<String> EXPECTED_PALINDROME_BUBBLE = new HashSet<String>() {
+        {
+            add("b");
+            add("u");
+            add("l");
+            add("e");
+            add("bb");
+            add("bub");
+        }
+    };
+
+    Set<String> EXPECTED_PALINDROME_CIVIC = new HashSet<String>() {
+        {
+            add("civic");
+            add("ivi");
+            add("i");
+            add("c");
+            add("v");
+        }
+    };
+
+    Set<String> EXPECTED_PALINDROME_INDEED = new HashSet<String>() {
+        {
+            add("i");
+            add("n");
+            add("d");
+            add("e");
+            add("ee");
+            add("deed");
+        }
+    };
+
+    Set<String> EXPECTED_PALINDROME_ABABAC = new HashSet<String>() {
+        {
+            add("a");
+            add("b");
+            add("c");
+            add("aba");
+            add("bab");
+            add("ababa");
+        }
+    };
+
+    private SubstringPalindrome palindrome = new SubstringPalindrome();
+
+    @Test
+    public void whenUsingManachersAlgorithm_thenFindsAllPalindromes() {
+        assertEquals(EXPECTED_PALINDROME_BUBBLE, palindrome.findAllPalindromesUsingManachersAlgorithm(INPUT_BUBBLE));
+        assertEquals(EXPECTED_PALINDROME_INDEED, palindrome.findAllPalindromesUsingManachersAlgorithm(INPUT_INDEED));
+        assertEquals(EXPECTED_PALINDROME_CIVIC, palindrome.findAllPalindromesUsingManachersAlgorithm(INPUT_CIVIC));
+        assertEquals(EXPECTED_PALINDROME_ABABAC, palindrome.findAllPalindromesUsingManachersAlgorithm(INPUT_ABABAC));
+    }
+
+    @Test
+    public void whenUsingCenterApproach_thenFindsAllPalindromes() {
+        assertEquals(EXPECTED_PALINDROME_BUBBLE, palindrome.findAllPalindromesUsingCenter(INPUT_BUBBLE));
+        assertEquals(EXPECTED_PALINDROME_INDEED, palindrome.findAllPalindromesUsingCenter(INPUT_INDEED));
+        assertEquals(EXPECTED_PALINDROME_CIVIC, palindrome.findAllPalindromesUsingCenter(INPUT_CIVIC));
+        assertEquals(EXPECTED_PALINDROME_ABABAC, palindrome.findAllPalindromesUsingCenter(INPUT_ABABAC));
+    }
+
+    @Test
+    public void whenUsingBruteForceApproach_thenFindsAllPalindromes() {
+        assertEquals(EXPECTED_PALINDROME_BUBBLE, palindrome.findAllPalindromesUsingBruteForceApproach(INPUT_BUBBLE));
+        assertEquals(EXPECTED_PALINDROME_INDEED, palindrome.findAllPalindromesUsingBruteForceApproach(INPUT_INDEED));
+        assertEquals(EXPECTED_PALINDROME_CIVIC, palindrome.findAllPalindromesUsingBruteForceApproach(INPUT_CIVIC));
+        assertEquals(EXPECTED_PALINDROME_ABABAC, palindrome.findAllPalindromesUsingBruteForceApproach(INPUT_ABABAC));
+    }
+}

algorithms-miscellaneous-1/src/test/java/com/baeldung/algorithms/twopointertechnique/LinkedListFindMiddleUnitTest.java

@@ -0,0 +1,37 @@
+package com.baeldung.algorithms.twopointertechnique;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.junit.Test;
+
+public class LinkedListFindMiddleUnitTest {
+
+    LinkedListFindMiddle linkedListFindMiddle = new LinkedListFindMiddle();
+
+    @Test
+    public void givenLinkedListOfMyNodes_whenLinkedListFindMiddle_thenCorrect() {
+
+        MyNode<String> head = createNodesList(8);
+
+        assertThat(linkedListFindMiddle.findMiddle(head)).isEqualTo("4");
+
+        head = createNodesList(9);
+
+        assertThat(linkedListFindMiddle.findMiddle(head)).isEqualTo("5");
+    }
+
+    private static MyNode<String> createNodesList(int n) {
+
+        MyNode<String> head = new MyNode<String>("1");
+        MyNode<String> current = head;
+
+        for (int i = 2; i <= n; i++) {
+            MyNode<String> newNode = new MyNode<String>(String.valueOf(i));
+            current.setNext(newNode);
+            current = newNode;
+        }
+
+        return head;
+    }
+
+}

algorithms-miscellaneous-1/src/test/java/com/baeldung/algorithms/twopointertechnique/RotateArrayUnitTest.java

@@ -0,0 +1,26 @@
+package com.baeldung.algorithms.twopointertechnique;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.junit.Test;
+
+public class RotateArrayUnitTest {
+
+    private RotateArray rotateArray = new RotateArray();
+
+    private int[] inputArray;
+
+    private int step;
+
+    @Test
+    public void givenAnArrayOfIntegers_whenRotateKsteps_thenCorrect() {
+
+        inputArray = new int[] { 1, 2, 3, 4, 5, 6, 7 };
+        step = 4;
+
+        rotateArray.rotate(inputArray, step);
+
+        assertThat(inputArray).containsExactly(new int[] { 4, 5, 6, 7, 1, 2, 3 });
+    }
+
+}

algorithms-miscellaneous-1/src/test/java/com/baeldung/algorithms/twopointertechnique/TwoSumUnitTest.java

@@ -0,0 +1,56 @@
+package com.baeldung.algorithms.twopointertechnique;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+
+public class TwoSumUnitTest {
+
+    private TwoSum twoSum = new TwoSum();
+
+    private int[] sortedArray;
+
+    private int targetValue;
+
+    @Test
+    public void givenASortedArrayOfIntegers_whenTwoSumSlow_thenPairExists() {
+
+        sortedArray = new int[] { 0, 1, 2, 3, 4, 5, 5, 6, 7, 8, 9, 9 };
+
+        targetValue = 12;
+
+        assertTrue(twoSum.twoSumSlow(sortedArray, targetValue));
+    }
+
+    @Test
+    public void givenASortedArrayOfIntegers_whenTwoSumSlow_thenPairDoesNotExists() {
+
+        sortedArray = new int[] { 0, 1, 2, 3, 4, 5, 5, 6, 7, 8, 9, 9 };
+
+        targetValue = 20;
+
+        assertFalse(twoSum.twoSumSlow(sortedArray, targetValue));
+    }
+
+    @Test
+    public void givenASortedArrayOfIntegers_whenTwoSum_thenPairExists() {
+
+        sortedArray = new int[] { 0, 1, 2, 3, 4, 5, 5, 6, 7, 8, 9, 9 };
+
+        targetValue = 12;
+
+        assertTrue(twoSum.twoSum(sortedArray, targetValue));
+    }
+
+    @Test
+    public void givenASortedArrayOfIntegers_whenTwoSum_thenPairDoesNotExists() {
+
+        sortedArray = new int[] { 0, 1, 2, 3, 4, 5, 5, 6, 7, 8, 9, 9 };
+
+        targetValue = 20;
+
+        assertFalse(twoSum.twoSum(sortedArray, targetValue));
+    }
+
+}

algorithms-miscellaneous-2/README.md

@@ -10,7 +10,6 @@
 - [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)
-- [Find the Middle Element of a Linked List](http://www.baeldung.com/java-linked-list-middle-element)
 - [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)
@@ -18,3 +17,4 @@
 - [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-miscellaneous-2</artifactId>
     <version>0.0.1-SNAPSHOT</version>
+    <name>algorithms-miscellaneous-2</name>
 
     <parent>
         <groupId>com.baeldung</groupId>
@@ -33,6 +33,11 @@
             <artifactId>jgrapht-core</artifactId>
             <version>${org.jgrapht.core.version}</version>
         </dependency>
+        <dependency>
+        	<groupId>org.jgrapht</groupId>
+        	<artifactId>jgrapht-ext</artifactId>
+        	<version>${org.jgrapht.ext.version}</version>
+        </dependency>
         <dependency>
             <groupId>pl.allegro.finance</groupId>
             <artifactId>tradukisto</artifactId>
@@ -63,7 +68,7 @@
             <plugin>
                 <groupId>org.codehaus.mojo</groupId>
                 <artifactId>cobertura-maven-plugin</artifactId>
-                <version>2.7</version>
+                <version>${cobertura-maven-plugin.version}</version>
                 <configuration>
                     <instrumentation>
                         <ignores>
@@ -79,12 +84,13 @@
     </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.jgrapht.ext.version>1.0.1</org.jgrapht.ext.version>
         <org.assertj.core.version>3.9.0</org.assertj.core.version>
         <commons-codec.version>1.11</commons-codec.version>
+        <cobertura-maven-plugin.version>2.7</cobertura-maven-plugin.version>
     </properties>
 
 </project>

algorithms-miscellaneous-2/roundUpToHundred/.gitignore

@@ -1 +0,0 @@
-/bin/

algorithms-miscellaneous-2/roundUpToHundred/src/com/java/src/RoundUpToHundred.java

@@ -1,20 +0,0 @@
-package com.java.src;
-
-import java.util.Scanner;
-
-public class RoundUpToHundred {
-
-    public static void main(String[] args) {
-        Scanner scanner = new Scanner(System.in);
-        double input = scanner.nextDouble();
-        scanner.close();
-
-        RoundUpToHundred.round(input);
-    }
-
-    static long round(double input) {
-        long i = (long) Math.ceil(input);
-        return ((i + 99) / 100) * 100;
-    };
-
-}

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/mercator/EllipticalMercator.java

@@ -0,0 +1,22 @@
+package com.baeldung.algorithms.mercator;
+
+class EllipticalMercator extends Mercator {
+
+    @Override
+    double yAxisProjection(double input) {
+
+        input = Math.min(Math.max(input, -89.5), 89.5);
+        double earthDimensionalRateNormalized = 1.0 - Math.pow(RADIUS_MINOR / RADIUS_MAJOR, 2);
+
+        double inputOnEarthProj = Math.sqrt(earthDimensionalRateNormalized) *  Math.sin( Math.toRadians(input));
+
+        inputOnEarthProj = Math.pow(((1.0 - inputOnEarthProj)/(1.0+inputOnEarthProj)), 0.5 * Math.sqrt(earthDimensionalRateNormalized));
+        double inputOnEarthProjNormalized = Math.tan(0.5 * ((Math.PI*0.5) -  Math.toRadians(input)))/inputOnEarthProj;
+        return (-1) * RADIUS_MAJOR * Math.log(inputOnEarthProjNormalized);
+    }
+
+    @Override
+    double xAxisProjection(double input) {
+        return RADIUS_MAJOR * Math.toRadians(input);
+    }
+}

algorithms-miscellaneous-2/src/main/java/com/baeldung/algorithms/mercator/Mercator.java

@@ -0,0 +1,10 @@
+package com.baeldung.algorithms.mercator;
+
+abstract class Mercator {
+    final static double RADIUS_MAJOR = 6378137.0;
+    final static double RADIUS_MINOR = 6356752.3142;
+
+    abstract double yAxisProjection(double input);
+
+    abstract double xAxisProjection(double input);
+}

algorithms-miscellaneous-2/src/main/java/com/baeldung/algorithms/mercator/SphericalMercator.java

@@ -0,0 +1,14 @@
+package com.baeldung.algorithms.mercator;
+
+public class SphericalMercator extends  Mercator {
+
+    @Override
+    double xAxisProjection(double input) {
+        return Math.toRadians(input) * RADIUS_MAJOR;
+    }
+
+    @Override
+    double yAxisProjection(double input) {
+        return Math.log(Math.tan(Math.PI / 4 + Math.toRadians(input) / 2)) * RADIUS_MAJOR;
+    }
+}

algorithms-miscellaneous-2/src/main/java/com/baeldung/algorithms/reversingtree/TreeNode.java

@@ -0,0 +1,42 @@
+package com.baeldung.algorithms.reversingtree;
+
+public class TreeNode {
+
+    private int value;
+    private TreeNode rightChild;
+    private TreeNode leftChild;
+
+    public int getValue() {
+        return value;
+    }
+
+    public void setValue(int value) {
+        this.value = value;
+    }
+
+    public TreeNode getRightChild() {
+        return rightChild;
+    }
+
+    public void setRightChild(TreeNode rightChild) {
+        this.rightChild = rightChild;
+    }
+
+    public TreeNode getLeftChild() {
+        return leftChild;
+    }
+
+    public void setLeftChild(TreeNode leftChild) {
+        this.leftChild = leftChild;
+    }
+
+    public TreeNode(int value, TreeNode rightChild, TreeNode leftChild) {
+        this.value = value;
+        this.rightChild = rightChild;
+        this.leftChild = leftChild;
+    }
+
+    public TreeNode(int value) {
+        this.value = value;
+    }
+}

algorithms-miscellaneous-2/src/main/java/com/baeldung/algorithms/reversingtree/TreeReverser.java

@@ -0,0 +1,68 @@
+package com.baeldung.algorithms.reversingtree;
+
+import java.util.LinkedList;
+
+public class TreeReverser {
+
+    public TreeNode createBinaryTree() {
+
+        TreeNode leaf1 = new TreeNode(3);
+        TreeNode leaf2 = new TreeNode(1);
+        TreeNode leaf3 = new TreeNode(9);
+        TreeNode leaf4 = new TreeNode(6);
+
+        TreeNode nodeLeft = new TreeNode(2, leaf1, leaf2);
+        TreeNode nodeRight = new TreeNode(7, leaf3, leaf4);
+
+        TreeNode root = new TreeNode(4, nodeRight, nodeLeft);
+
+        return root;
+    }
+
+    public void reverseRecursive(TreeNode treeNode) {
+        if (treeNode == null) {
+            return;
+        }
+
+        TreeNode temp = treeNode.getLeftChild();
+        treeNode.setLeftChild(treeNode.getRightChild());
+        treeNode.setRightChild(temp);
+
+        reverseRecursive(treeNode.getLeftChild());
+        reverseRecursive(treeNode.getRightChild());
+    }
+
+    public void reverseIterative(TreeNode treeNode) {
+        LinkedList<TreeNode> queue = new LinkedList<TreeNode>();
+
+        if (treeNode != null) {
+            queue.add(treeNode);
+        }
+
+        while (!queue.isEmpty()) {
+
+            TreeNode node = queue.poll();
+            if (node.getLeftChild() != null)
+                queue.add(node.getLeftChild());
+            if (node.getRightChild() != null)
+                queue.add(node.getRightChild());
+
+            TreeNode temp = node.getLeftChild();
+            node.setLeftChild(node.getRightChild());
+            node.setRightChild(temp);
+        }
+    }
+
+    public String toString(TreeNode root) {
+        if (root == null) {
+            return "";
+        }
+
+        StringBuffer buffer = new StringBuffer(String.valueOf(root.getValue())).append(" ");
+
+        buffer.append(toString(root.getLeftChild()));
+        buffer.append(toString(root.getRightChild()));
+
+        return buffer.toString();
+    }
+}

algorithms-miscellaneous-2/src/main/java/com/baeldung/algorithms/roundedup/RoundUpToHundred.java

@@ -1,4 +1,4 @@
-package com.java.src;
+package com.baeldung.algorithms.roundedup;
 
 import java.util.Scanner;
 

algorithms-miscellaneous-2/src/test/java/com/baeldung/algorithms/mercator/EllipticalMercatorUnitTest.java

@@ -0,0 +1,22 @@
+package com.baeldung.algorithms.mercator;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+
+public class EllipticalMercatorUnitTest {
+
+    @Test
+    public void giventThatTheInputIs22_whenXAxisProjectionIsCalled_thenTheResultIsTheCorrectOne() {
+        Mercator mercator = new EllipticalMercator();
+        double result = mercator.xAxisProjection(22);
+        Assert.assertEquals(result, 2449028.7974520186, 0.0);
+    }
+
+    @Test
+    public void giventThatTheInputIs44_whenYAxisProjectionIsCalled_thenTheResultIsTheCorrectOne() {
+        Mercator mercator = new EllipticalMercator();
+        double result = mercator.yAxisProjection(44);
+        Assert.assertEquals(result, 5435749.887511954, 0.0);
+    }
+}

algorithms-miscellaneous-2/src/test/java/com/baeldung/algorithms/mercator/SphericalMercatorUnitTest.java

@@ -0,0 +1,21 @@
+package com.baeldung.algorithms.mercator;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class SphericalMercatorUnitTest {
+
+    @Test
+    public void giventThatTheInputIs22_whenXAxisProjectionIsCalled_thenTheResultIsTheCorrectOne() {
+        Mercator mercator = new SphericalMercator();
+        double result = mercator.xAxisProjection(22);
+        Assert.assertEquals(result, 2449028.7974520186, 0.0);
+    }
+
+    @Test
+    public void giventThatTheInputIs44_whenYAxisProjectionIsCalled_thenTheResultIsTheCorrectOne() {
+        Mercator mercator = new SphericalMercator();
+        double result = mercator.yAxisProjection(44);
+        Assert.assertEquals(result, 5465442.183322753, 0.0);
+    }
+}

algorithms-miscellaneous-2/src/test/java/com/baeldung/algorithms/reversingtree/TreeReverserUnitTest.java

@@ -0,0 +1,33 @@
+package com.baeldung.algorithms.reversingtree;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import org.junit.jupiter.api.Test;
+
+public class TreeReverserUnitTest {
+
+    @Test
+    public void givenTreeWhenReversingRecursivelyThenReversed() {
+        TreeReverser reverser = new TreeReverser();
+
+        TreeNode treeNode = reverser.createBinaryTree();
+
+        reverser.reverseRecursive(treeNode);
+
+        assertEquals("4 7 9 6 2 3 1", reverser.toString(treeNode)
+            .trim());
+    }
+
+    @Test
+    public void givenTreeWhenReversingIterativelyThenReversed() {
+        TreeReverser reverser = new TreeReverser();
+
+        TreeNode treeNode = reverser.createBinaryTree();
+
+        reverser.reverseIterative(treeNode);
+
+        assertEquals("4 7 9 6 2 3 1", reverser.toString(treeNode)
+            .trim());
+    }
+
+}

algorithms-miscellaneous-2/src/test/java/com/baeldung/algorithms/roundedup/RoundUpToHundredUnitTest.java

@@ -1,10 +1,10 @@
-package com.java.src;
+package com.baeldung.algorithms.roundedup;
 
 import static org.junit.Assert.assertEquals;
 
 import org.junit.Test;
 
-public class RoundUpToHundredTest {
+public class RoundUpToHundredUnitTest {
     @Test
     public void givenInput_whenRound_thenRoundUpToTheNearestHundred() {
         assertEquals("Rounded up to hundred", 100, RoundUpToHundred.round(99));

algorithms-miscellaneous-2/src/test/java/com/baeldung/jgrapht/GraphImageGenerationUnitTest.java

@@ -0,0 +1,47 @@
+package com.baeldung.jgrapht;
+
+import static org.junit.Assert.assertTrue;
+import java.awt.Color;
+import java.awt.image.BufferedImage;
+import java.io.File;
+import java.io.IOException;
+import javax.imageio.ImageIO;
+import org.jgrapht.ext.JGraphXAdapter;
+import org.jgrapht.graph.DefaultDirectedGraph;
+import org.jgrapht.graph.DefaultEdge;
+import org.junit.Before;
+import org.junit.Test;
+import com.mxgraph.layout.mxCircleLayout;
+import com.mxgraph.layout.mxIGraphLayout;
+import com.mxgraph.util.mxCellRenderer;
+
+public class GraphImageGenerationUnitTest {
+    static DefaultDirectedGraph<String, DefaultEdge> g;
+
+    @Before
+    public void createGraph() throws IOException {
+        File imgFile = new File("src/test/resources/graph.png");
+        imgFile.createNewFile();
+        g = new DefaultDirectedGraph<String, DefaultEdge>(DefaultEdge.class);
+        String x1 = "x1";
+        String x2 = "x2";
+        String x3 = "x3";
+        g.addVertex(x1);
+        g.addVertex(x2);
+        g.addVertex(x3);
+        g.addEdge(x1, x2);
+        g.addEdge(x2, x3);
+        g.addEdge(x3, x1);
+    }
+
+    @Test
+    public void givenAdaptedGraph_whenWriteBufferedImage_ThenFileShouldExist() throws IOException {
+        JGraphXAdapter<String, DefaultEdge> graphAdapter = new JGraphXAdapter<String, DefaultEdge>(g);
+        mxIGraphLayout layout = new mxCircleLayout(graphAdapter);
+        layout.execute(graphAdapter.getDefaultParent());
+        File imgFile = new File("src/test/resources/graph.png");
+        BufferedImage image = mxCellRenderer.createBufferedImage(graphAdapter, null, 2, Color.WHITE, true, null);
+        ImageIO.write(image, "PNG", imgFile);
+        assertTrue(imgFile.exists());
+    }
+}

algorithms-sorting/README.md

@@ -4,4 +4,4 @@
 - [Merge Sort in Java](https://www.baeldung.com/java-merge-sort)
 - [Quicksort Algorithm Implementation in Java](https://www.baeldung.com/java-quicksort)
 - [Insertion Sort in Java](https://www.baeldung.com/java-insertion-sort)
-
+- [Heap Sort in Java](https://www.baeldung.com/java-heap-sort)

algorithms-sorting/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-sorting</artifactId>
     <version>0.0.1-SNAPSHOT</version>
+    <name>algorithms-sorting</name>
 
     <parent>
         <groupId>com.baeldung</groupId>
@@ -49,7 +49,6 @@
     </build>
 
     <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>

algorithms-sorting/roundUpToHundred/.gitignore

@@ -1 +0,0 @@
-/bin/

algorithms-sorting/roundUpToHundred/src/com/java/src/RoundUpToHundred.java

@@ -1,20 +0,0 @@
-package com.java.src;
-
-import java.util.Scanner;
-
-public class RoundUpToHundred {
-
-    public static void main(String[] args) {
-        Scanner scanner = new Scanner(System.in);
-        double input = scanner.nextDouble();
-        scanner.close();
-
-        RoundUpToHundred.round(input);
-    }
-
-    static long round(double input) {
-        long i = (long) Math.ceil(input);
-        return ((i + 99) / 100) * 100;
-    };
-
-}

algorithms-sorting/roundUpToHundred/src/com/java/src/RoundUpToHundredTest.java

@@ -1,14 +0,0 @@
-package com.java.src;
-
-import static org.junit.Assert.assertEquals;
-
-import org.junit.Test;
-
-public class RoundUpToHundredTest {
-    @Test
-    public void givenInput_whenRound_thenRoundUpToTheNearestHundred() {
-        assertEquals("Rounded up to hundred", 100, RoundUpToHundred.round(99));
-        assertEquals("Rounded up to three hundred ", 300, RoundUpToHundred.round(200.2));
-        assertEquals("Returns same rounded value", 400, RoundUpToHundred.round(400));
-    }
-}

algorithms-sorting/src/main/java/com/baeldung/algorithms/mergesort/MergeSort.java

@@ -34,7 +34,7 @@ public class MergeSort {
 
         while (i < left && j < right) {
 
-            if (l[i] < r[j])
+            if (l[i] <= r[j])
                 a[k++] = l[i++];
             else
                 a[k++] = r[j++];

animal-sniffer-mvn-plugin/pom.xml

@@ -3,9 +3,9 @@
     <modelVersion>4.0.0</modelVersion>
     <groupId>com.baeldung</groupId>
     <artifactId>animal-sniffer-mvn-plugin</artifactId>
-    <packaging>jar</packaging>
     <version>1.0-SNAPSHOT</version>
     <name>animal-sniffer-mvn-plugin</name>
+    <packaging>jar</packaging>
     <url>http://maven.apache.org</url>
 
     <parent>

annotations/annotation-processing/pom.xml

@@ -3,7 +3,8 @@
     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>annotation-processing</artifactId>
-
+    <name>annotation-processing</name>
+    
     <parent>
         <groupId>com.baeldung</groupId>
         <version>1.0.0-SNAPSHOT</version>

annotations/annotation-user/pom.xml

@@ -3,6 +3,7 @@
     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>annotation-user</artifactId>
+    <name>annotation-user</name>
 
     <parent>
         <artifactId>annotations</artifactId>

annotations/pom.xml

@@ -3,8 +3,9 @@
     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>annotations</artifactId>
+    <name>annotations</name>
     <packaging>pom</packaging>
-
+    
     <parent>
         <artifactId>parent-modules</artifactId>
         <groupId>com.baeldung</groupId>

apache-avro/pom.xml

@@ -3,19 +3,10 @@
          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>apache-avro</artifactId>
     <version>0.0.1-SNAPSHOT</version>
-	<name>Apache Avro</name>
+	<name>apache-avro</name>
 
-    <properties>
-        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
-        <compiler-plugin.version>3.5</compiler-plugin.version>
-        <avro.version>1.8.2</avro.version>
-        <java.version>1.8</java.version>
-        <slf4j.version>1.7.25</slf4j.version>
-    </properties>
-	
     <parent>
         <groupId>com.baeldung</groupId>
         <artifactId>parent-modules</artifactId>
@@ -86,4 +77,12 @@
             </plugin>
         </plugins>
     </build>
+
+    <properties>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <compiler-plugin.version>3.5</compiler-plugin.version>
+        <avro.version>1.8.2</avro.version>
+        <slf4j.version>1.7.25</slf4j.version>
+    </properties>
+	
 </project>

apache-bval/pom.xml

@@ -4,7 +4,8 @@
     <groupId>apache-bval</groupId>
     <artifactId>apache-bval</artifactId>
     <version>0.0.1-SNAPSHOT</version>
-
+    <name>apache-bval</name>
+    
     <parent>
         <groupId>com.baeldung</groupId>
         <artifactId>parent-modules</artifactId>

apache-curator/pom.xml

@@ -3,6 +3,7 @@
     <modelVersion>4.0.0</modelVersion>
     <artifactId>apache-curator</artifactId>
     <version>0.0.1-SNAPSHOT</version>
+	<name>apache-curator</name>
     <packaging>jar</packaging>
 
     <parent>
@@ -38,7 +39,7 @@
         <dependency>
             <groupId>com.fasterxml.jackson.core</groupId>
             <artifactId>jackson-databind</artifactId>
-            <version>${jackson-databind.version}</version>
+            <version>${jackson.version}</version>
         </dependency>
         <!-- test scoped -->
         <dependency>
@@ -58,7 +59,6 @@
     <properties>
         <curator.version>4.0.1</curator.version>
         <zookeeper.version>3.4.11</zookeeper.version>
-        <jackson-databind.version>2.9.4</jackson-databind.version>
         <!-- testing -->
         <assertj.version>3.6.1</assertj.version>
         <avaitility.version>1.7.0</avaitility.version>

apache-cxf/cxf-aegis/pom.xml

@@ -2,7 +2,8 @@
     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
     <modelVersion>4.0.0</modelVersion>
     <artifactId>cxf-aegis</artifactId>
-
+	<name>cxf-aegis</name>
+	
     <parent>
         <groupId>com.baeldung</groupId>
         <artifactId>apache-cxf</artifactId>

apache-cxf/cxf-introduction/pom.xml

@@ -4,7 +4,8 @@
     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
     <modelVersion>4.0.0</modelVersion>
     <artifactId>cxf-introduction</artifactId>
-
+	<name>cxf-introduction</name>
+	
     <parent>
         <groupId>com.baeldung</groupId>
         <artifactId>apache-cxf</artifactId>

apache-cxf/cxf-jaxrs-implementation/pom.xml

@@ -4,7 +4,8 @@
     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
     <modelVersion>4.0.0</modelVersion>
     <artifactId>cxf-jaxrs-implementation</artifactId>
-
+	<name>cxf-jaxrs-implementation</name>
+	
     <parent>
         <groupId>com.baeldung</groupId>
         <artifactId>apache-cxf</artifactId>

apache-cxf/cxf-spring/pom.xml

@@ -3,6 +3,7 @@
     <modelVersion>4.0.0</modelVersion>
     <artifactId>cxf-spring</artifactId>
     <packaging>war</packaging>
+	<name>cxf-spring</name>
 
     <parent>
         <groupId>com.baeldung</groupId>

apache-cxf/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>apache-cxf</artifactId>
     <version>0.0.1-SNAPSHOT</version>
+    <name>apache-cxf</name>
     <packaging>pom</packaging>
 
     <parent>

apache-cxf/sse-jaxrs/pom.xml

@@ -3,8 +3,8 @@
          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>sse-jaxrs</artifactId>
+    <name>sse-jaxrs</name>
     <packaging>pom</packaging>
 
     <parent>

apache-cxf/sse-jaxrs/sse-jaxrs-client/pom.xml

@@ -3,15 +3,15 @@
          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>sse-jaxrs-client</artifactId>
+    <name>sse-jaxrs-client</name>
+    
     <parent>
         <groupId>com.baeldung</groupId>
         <artifactId>sse-jaxrs</artifactId>
         <version>0.0.1-SNAPSHOT</version>
     </parent>
 
-    <artifactId>sse-jaxrs-client</artifactId>
-
     <properties>
         <cxf-version>3.2.0</cxf-version>
     </properties>
@@ -21,7 +21,6 @@
             <plugin>
                 <groupId>org.codehaus.mojo</groupId>
                 <artifactId>exec-maven-plugin</artifactId>
-                <version>1.6.0</version>
                 <executions>
                     <execution>
                         <id>singleEvent</id>

apache-cxf/sse-jaxrs/sse-jaxrs-server/pom.xml

@@ -3,16 +3,16 @@
          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>sse-jaxrs-server</artifactId>
+    <name>sse-jaxrs-server</name>
+    <packaging>war</packaging>
+    
     <parent>
         <groupId>com.baeldung</groupId>
         <artifactId>sse-jaxrs</artifactId>
         <version>0.0.1-SNAPSHOT</version>
     </parent>
 
-    <artifactId>sse-jaxrs-server</artifactId>
-    <packaging>war</packaging>
-
     <properties>
         <liberty-maven-plugin.version>2.4.2</liberty-maven-plugin.version>
         <failOnMissingWebXml>false</failOnMissingWebXml>

apache-fop/README.md

@@ -3,7 +3,3 @@
 ## Core Java Cookbooks and Examples
 
 ### Relevant Articles: 
-- [Immutable ArrayList in Java](http://www.baeldung.com/java-immutable-list)
-- [Java - Reading a Large File Efficiently](http://www.baeldung.com/java-read-lines-large-file)
-- [Java InputStream to String](http://www.baeldung.com/convert-input-stream-to-string)
-

apache-geode/pom.xml

@@ -3,32 +3,15 @@
          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>apache-geode</artifactId>
     <version>1.0-SNAPSHOT</version>
-
+    <name>apache-geode</name>
+    
     <parent>
         <groupId>com.baeldung</groupId>
         <artifactId>parent-modules</artifactId>
         <version>1.0.0-SNAPSHOT</version>
     </parent>
-    
-    <properties>
-        <geode.core>1.6.0</geode.core>
-    </properties>
-    <build>
-        <plugins>
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-compiler-plugin</artifactId>
-                <configuration>
-                    <source>1.8</source>
-                    <target>1.8</target>
-                </configuration>
-            </plugin>
-        </plugins>
-    </build>
 
     <dependencies>
         <dependency>
@@ -39,8 +22,24 @@
         <dependency>
             <groupId>junit</groupId>
             <artifactId>junit</artifactId>
-            <version>RELEASE</version>
+            <version>${junit.version}</version>
         </dependency>
     </dependencies>
     
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <configuration>
+                    <source>${java.version}</source>
+                    <target>${java.version}</target>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+	
+    <properties>
+        <geode.core>1.6.0</geode.core>
+    </properties>
 </project>

apache-meecrowave/pom.xml

@@ -7,51 +7,58 @@
     <name>apache-meecrowave</name>
     <description>A sample REST API application with Meecrowave</description>
 
-    <properties>
-        <maven.compiler.source>1.8</maven.compiler.source>
-        <maven.compiler.target>1.8</maven.compiler.target>
-    </properties>
     <dependencies>
         <!-- https://mvnrepository.com/artifact/org.apache.meecrowave/meecrowave-core -->
         <dependency>
             <groupId>org.apache.meecrowave</groupId>
             <artifactId>meecrowave-core</artifactId>
-            <version>1.2.1</version>
+            <version>${meecrowave-core.version}</version>
         </dependency>
         <!-- https://mvnrepository.com/artifact/org.apache.meecrowave/meecrowave-jpa -->
         <dependency>
             <groupId>org.apache.meecrowave</groupId>
             <artifactId>meecrowave-jpa</artifactId>
-            <version>1.2.1</version>
+            <version>${meecrowave-jpa.version}</version>
         </dependency>
 
         <dependency>
             <groupId>com.squareup.okhttp3</groupId>
             <artifactId>okhttp</artifactId>
-            <version>3.10.0</version>
+            <version>${okhttp.version}</version>
         </dependency>
         <dependency>
             <groupId>org.apache.meecrowave</groupId>
             <artifactId>meecrowave-junit</artifactId>
-            <version>1.2.0</version>
+            <version>${meecrowave-junit.version}</version>
             <scope>test</scope>
         </dependency>
         <!-- https://mvnrepository.com/artifact/junit/junit -->
         <dependency>
             <groupId>junit</groupId>
             <artifactId>junit</artifactId>
-            <version>4.10</version>
+            <version>${junit.version}</version>
             <scope>test</scope>
         </dependency>
-
     </dependencies>
+	
     <build>
         <plugins>
             <plugin>
                 <groupId>org.apache.meecrowave</groupId>
                 <artifactId>meecrowave-maven-plugin</artifactId>
-                <version>1.2.1</version>
+                <version>${meecrowave-maven-plugin.version}</version>
             </plugin>
         </plugins>
     </build>
+	
+    <properties>
+        <maven.compiler.source>1.8</maven.compiler.source>
+        <maven.compiler.target>1.8</maven.compiler.target>
+		<junit.version>4.10</junit.version>
+		<meecrowave-junit.version>1.2.0</meecrowave-junit.version>
+		<okhttp.version>3.10.0</okhttp.version>
+		<meecrowave-jpa.version>1.2.1</meecrowave-jpa.version>
+		<meecrowave-core.version>1.2.1</meecrowave-core.version>
+		<meecrowave-maven-plugin.version>1.2.1</meecrowave-maven-plugin.version>
+    </properties>
 </project>

apache-opennlp/pom.xml

@@ -4,6 +4,7 @@
     <modelVersion>4.0.0</modelVersion>
     <artifactId>apache-opennlp</artifactId>
     <version>1.0-SNAPSHOT</version>
+    <name>apache-opennlp</name>
     <packaging>jar</packaging>
 
     <parent>