BAEL-3298 Resolving merge conflict

2020-03-13 00:34:04 +05:30
parent 30322eca9e 8b6adc0904
commit 83c9c5470a
2700 changed files with 47706 additions and 35667 deletions
@@ -65,6 +65,7 @@ core-java-io/target_link.txt
 core-java/src/main/java/com/baeldung/manifest/MANIFEST.MF
 ethereum/logs/
 jmeter/src/main/resources/*-JMeter.csv
+ninja/devDb.mv.db

 **/node_modules/
 **/dist
@@ -7,6 +7,8 @@ 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.Ignore;
 import org.junit.Test;

 public class UserServerUnitTest extends JUnitRouteTest {
@@ -17,6 +19,7 @@ public class UserServerUnitTest extends JUnitRouteTest {

  TestRoute appRoute = testRoute(new UserServer(userActorRef).routes());

+  @Ignore
  @Test
  public void whenRequest_thenActorResponds() {

@@ -28,10 +31,10 @@ public class UserServerUnitTest extends JUnitRouteTest {
            .assertStatusCode(404);

    appRoute.run(HttpRequest.DELETE("/users/1"))
-            .assertStatusCode(200);
+            .assertStatusCode(405);

    appRoute.run(HttpRequest.DELETE("/users/42"))
-            .assertStatusCode(200);
+            .assertStatusCode(405);

    appRoute.run(HttpRequest.POST("/users")
            .withEntity(HttpEntities.create(ContentTypes.APPLICATION_JSON, zaphod())))
@@ -64,7 +64,7 @@
            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>cobertura-maven-plugin</artifactId>
-                <version>2.7</version>
+                <version>${cobertura.plugin.version}</version>
                <configuration>
                    <instrumentation>
                        <ignores>
@@ -85,6 +85,7 @@
        <commons-codec.version>1.11</commons-codec.version>
        <guava.version>27.0.1-jre</guava.version>
        <combinatoricslib3.version>3.3.0</combinatoricslib3.version>
+        <cobertura.plugin.version>2.7</cobertura.plugin.version>
    </properties>

 </project>
@@ -13,4 +13,5 @@ This module contains articles about algorithms. Some classes of algorithms, e.g.
 - [Create a Sudoku Solver in Java](https://www.baeldung.com/java-sudoku)
 - [Displaying Money Amounts in Words](https://www.baeldung.com/java-money-into-words)
 - [A Collaborative Filtering Recommendation System in Java](https://www.baeldung.com/java-collaborative-filtering-recommendations)
+- [Implementing A* Pathfinding in Java](https://www.baeldung.com/java-a-star-pathfinding)
 - More articles: [[<-- prev]](/../algorithms-miscellaneous-1) [[next -->]](/../algorithms-miscellaneous-3)
@@ -98,7 +98,7 @@ public class SlopeOne {
            for (Item j : InputData.items) {
                if (e.getValue().containsKey(j)) {
                    clean.put(j, e.getValue().get(j));
-                } else {
+                } else if (!clean.containsKey(j)) {
                    clean.put(j, -1.0);
                }
            }
@@ -46,13 +46,13 @@
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
-            <version>3.8.1</version>
+            <version>${commons.lang3.version}</version>
        </dependency>

        <dependency>
            <groupId>pl.pragmatists</groupId>
            <artifactId>JUnitParams</artifactId>
-            <version>1.1.0</version>
+            <version>${JUnitParams.version}</version>
            <scope>test</scope>
        </dependency>
        <dependency>
@@ -91,6 +91,8 @@
        <retrofit.version>2.6.0</retrofit.version>
        <jmh-core.version>1.19</jmh-core.version>
        <jmh-generator.version>1.19</jmh-generator.version>
+        <commons.lang3.version>3.8.1</commons.lang3.version>
+        <JUnitParams.version>1.1.0</JUnitParams.version>
    </properties>

 </project>
@@ -10,6 +10,13 @@ This module contains articles about algorithms. Some classes of algorithms, e.g.
 - [Find If Two Numbers Are Relatively Prime in Java](https://www.baeldung.com/java-two-relatively-prime-numbers)
 - [Knapsack Problem Implementation in Java](https://www.baeldung.com/java-knapsack)
 - [How to Determine if a Binary Tree is Balanced](https://www.baeldung.com/java-balanced-binary-tree)
- [The Caesar Cipher in Java](https://www.baeldung.com/java-caesar-cipher)
 - [Overview of Combinatorial Problems in Java](https://www.baeldung.com/java-combinatorial-algorithms)
+- [Prim’s Algorithm](https://www.baeldung.com/java-prim-algorithm)
+- [Maximum Subarray Problem](https://www.baeldung.com/java-maximum-subarray)
+- [How to Merge Two Sorted Arrays](https://www.baeldung.com/java-merge-sorted-arrays)
+- [Median of Stream of Integers using Heap](https://www.baeldung.com/java-stream-integers-median-using-heap)
+- [Kruskal’s Algorithm for Spanning Trees](https://www.baeldung.com/java-spanning-trees-kruskal)
+- [Balanced Brackets Algorithm in Java](https://www.baeldung.com/java-balanced-brackets-algorithm)
+- [Efficiently Merge Sorted Java Sequences](https://www.baeldung.com/java-merge-sorted-sequences)
+- [Introduction to Greedy Algorithms with Java](https://www.baeldung.com/java-greedy-algorithms)
 - More articles: [[<-- prev]](/../algorithms-miscellaneous-4)
@@ -37,7 +37,17 @@
        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
-            <version>28.1-jre</version>
+            <version>${guava.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>com.fasterxml.jackson.core</groupId>
+            <artifactId>jackson-databind</artifactId>
+            <version>${jackson.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.junit.platform</groupId>
+            <artifactId>junit-platform-commons</artifactId>
+            <version>${junit.platform.version}</version>
        </dependency>

        <dependency>
@@ -65,6 +75,9 @@
        <org.assertj.core.version>3.9.0</org.assertj.core.version>
        <commons-codec.version>1.11</commons-codec.version>
        <commons-math3.version>3.6.1</commons-math3.version>
+        <guava.version>28.1-jre</guava.version>
+        <jackson.version>2.10.2</jackson.version>
+        <junit.platform.version>1.6.0</junit.platform.version>
    </properties>

 </project>
@@ -0,0 +1,36 @@
+package com.baeldung.algorithms.balancedbrackets;
+
+import java.util.Deque;
+import java.util.LinkedList;
+
+public class BalancedBracketsUsingDeque {
+
+    public boolean isBalanced(String str) {
+        if (null == str || ((str.length() % 2) != 0)) {
+            return false;
+        } else {
+            char[] ch = str.toCharArray();
+            for (char c : ch) {
+                if (!(c == '{' || c == '[' || c == '(' || c == '}' || c == ']' || c == ')')) {
+                    return false;
+                }
+
+            }
+        }
+
+        Deque<Character> deque = new LinkedList<>();
+        for (char ch : str.toCharArray()) {
+            if (ch == '{' || ch == '[' || ch == '(') {
+                deque.addFirst(ch);
+            } else {
+                if (!deque.isEmpty() && ((deque.peekFirst() == '{' && ch == '}') || (deque.peekFirst() == '[' && ch == ']') || (deque.peekFirst() == '(' && ch == ')'))) {
+                    deque.removeFirst();
+                } else {
+                    return false;
+                }
+            }
+        }
+
+        return true;
+    }
+}
@@ -0,0 +1,27 @@
+package com.baeldung.algorithms.balancedbrackets;
+
+public class BalancedBracketsUsingString {
+
+    public boolean isBalanced(String str) {
+        if (null == str || ((str.length() % 2) != 0)) {
+            return false;
+        } else {
+            char[] ch = str.toCharArray();
+            for (char c : ch) {
+                if (!(c == '{' || c == '[' || c == '(' || c == '}' || c == ']' || c == ')')) {
+                    return false;
+                }
+
+            }
+        }
+
+        while (str.contains("()") || str.contains("[]") || str.contains("{}")) {
+            str = str.replaceAll("\\(\\)", "")
+                .replaceAll("\\[\\]", "")
+                .replaceAll("\\{\\}", "");
+        }
+        return (str.length() == 0);
+
+    }
+
+}
@@ -0,0 +1,61 @@
+package com.baeldung.algorithms.boruvka;
+
+public class BoruvkaMST {
+
+    private static Tree mst = new Tree();
+    private static int totalWeight;
+
+    public BoruvkaMST(Graph graph) {
+        DisjointSet dSet = new DisjointSet(graph.getNodes());
+
+        // repeat at most log N times or until we have N-1 edges
+        for (int t = 1; t < graph.getNodes() && mst.getEdgeCount() < graph.getNodes() - 1; t = t + t) {
+
+            // foreach tree in forest, find closest edge
+            Edge[] closestEdgeArray = new Edge[graph.getNodes()];
+            for (Edge edge : graph.getAllEdges()) {
+                int first = edge.getFirst();
+                int second = edge.getSecond();
+                int firstParent = dSet.getParent(first);
+                int secondParent = dSet.getParent(second);
+                if (firstParent == secondParent) {
+                    continue; // same tree
+                }
+                if (closestEdgeArray[firstParent] == null || edge.getWeight() < closestEdgeArray[firstParent].getWeight()) {
+                    closestEdgeArray[firstParent] = edge;
+                }
+                if (closestEdgeArray[secondParent] == null || edge.getWeight() < closestEdgeArray[secondParent].getWeight()) {
+                    closestEdgeArray[secondParent] = edge;
+                }
+            }
+
+            // add newly discovered edges to MST
+            for (int i = 0; i < graph.getNodes(); i++) {
+                Edge edge = closestEdgeArray[i];
+                if (edge != null) {
+                    int first = edge.getFirst();
+                    int second = edge.getSecond();
+                    // don't add the same edge twice
+                    if (dSet.getParent(first) != dSet.getParent(second)) {
+                        mst.addEdge(edge);
+                        totalWeight += edge.getWeight();
+                        dSet.union(first, second);
+                    }
+                }
+            }
+        }
+    }
+
+    public Iterable<Edge> getMST() {
+        return mst;
+    }
+
+    public int getTotalWeight() {
+        return totalWeight;
+    }
+
+    public String toString() {
+        return "MST: " + mst.toString() + " | Total Weight: " + totalWeight;
+    }
+
+}
@@ -0,0 +1,49 @@
+package com.baeldung.algorithms.boruvka;
+
+import java.util.Arrays;
+
+public class DisjointSet {
+
+    private int[] nodeParents;
+    private int[] nodeRanks;
+
+    public DisjointSet(int n) {
+        nodeParents = new int[n];
+        nodeRanks = new int[n];
+        for (int i = 0; i < n; i++) {
+            nodeParents[i] = i;
+            nodeRanks[i] = 0;
+        }
+    }
+
+    public int getParent(int node) {
+        while (node != nodeParents[node]) {
+            node = nodeParents[node];
+        }
+        return node;
+    }
+
+    public void union(int node1, int node2) {
+        int node1Parent = getParent(node1);
+        int node2Parent = getParent(node2);
+        if (node1Parent == node2Parent) {
+            return;
+        }
+
+        if (nodeRanks[node1Parent] < nodeRanks[node2Parent]) {
+            nodeParents[node1Parent] = node2Parent;
+        }
+        else if (nodeRanks[node1Parent] > nodeRanks[node2Parent]) {
+            nodeParents[node2Parent] = node1Parent;
+        }
+        else {
+            nodeParents[node2Parent] = node1Parent;
+            nodeRanks[node1Parent]++;
+        }
+    }
+
+    public String toString() {
+        return "Parent: " + Arrays.toString(nodeParents) + "Rank: " + Arrays.toString(nodeRanks);
+    }
+
+}
@@ -0,0 +1,40 @@
+package com.baeldung.algorithms.boruvka;
+
+public class Edge {
+
+    private final int first;
+    private final int second;
+    private final int weight;
+
+    public Edge(int first, int second, int weight) {
+        this.first = first;
+        this.second = second;
+        this.weight = weight;
+    }
+
+    public double getWeight() {
+        return weight;
+    }
+
+    public int getFirst() {
+        return first;
+    }
+    
+    public int getSecond() {
+        return second;
+    }
+
+    public int getOtherNode(int firstNode) {
+        int secondNode = 0;
+        if (firstNode == first)
+            secondNode = second;
+        else if (firstNode == second)
+            secondNode = first;
+        return secondNode;
+    }
+
+    public String toString() {
+        return String.format("%d-%d %d", first, second, weight);
+    }
+
+}
@@ -0,0 +1,64 @@
+package com.baeldung.algorithms.boruvka;
+
+import java.io.IOException;
+
+import com.fasterxml.jackson.core.JsonParseException;
+import com.fasterxml.jackson.databind.JsonMappingException;
+
+public class Graph {
+
+    private int nodes;
+    private int edges;
+    private Tree[] trees;
+
+    public Graph(Input jsonGraph) throws JsonParseException, JsonMappingException, IOException {
+        nodes = jsonGraph.getNodes();
+        trees = (Tree[]) new Tree[nodes];
+        for (int i = 0; i < nodes; i++) {
+            trees[i] = new Tree();
+        }
+
+        int edgesFromInput = jsonGraph.getEdges();
+        for (int i = 0; i < edgesFromInput; i++) {
+            int first = jsonGraph.getEdgeList()
+                .get(i)
+                .getFirst();
+            int second = jsonGraph.getEdgeList()
+                .get(i)
+                .getSecond();
+            int weight = jsonGraph.getEdgeList()
+                .get(i)
+                .getWeight();
+            Edge edge = new Edge(first, second, weight);
+            
+            trees[first].addEdge(edge);
+            trees[second].addEdge(edge);
+            edges++;
+        }
+
+    }
+
+    public int getNodes() {
+        return nodes;
+    }
+
+    public int getEdges() {
+        return edges;
+    }
+
+    public Iterable<Edge> iterableTree(int i) {
+        return trees[i];
+    }
+
+    public Iterable<Edge> getAllEdges() {
+        Iterable<Edge> list = new Tree();
+        for (int i = 0; i < nodes; i++) {
+            for (Edge edge : iterableTree(i)) {
+                if (edge.getOtherNode(i) > i) {
+                    ((Tree) list).addEdge(edge);
+                }
+            }
+        }
+        return list;
+    }
+}
@@ -0,0 +1,65 @@
+package com.baeldung.algorithms.boruvka;
+
+import java.util.List;
+
+public class Input {
+    private int nodes;
+    private int edges;
+    private List<E> edgeList;
+
+    public int getNodes() {
+        return nodes;
+    }
+
+    public void setNodes(int nodes) {
+        this.nodes = nodes;
+    }
+
+    public int getEdges() {
+        return edges;
+    }
+
+    public void setEdges(int edges) {
+        this.edges = edges;
+    }
+
+    public List<E> getEdgeList() {
+        return edgeList;
+    }
+
+    public void setEdgeList(List<E> edgeList) {
+        this.edgeList = edgeList;
+    }
+
+    static class E {
+        private int first;
+        private int second;
+        private int weight;
+
+        public int getFirst() {
+            return first;
+        }
+
+        public void setFirst(int first) {
+            this.first = first;
+        }
+
+        public int getSecond() {
+            return second;
+        }
+
+        public void setSecond(int second) {
+            this.second = second;
+        }
+
+        public int getWeight() {
+            return weight;
+        }
+
+        public void setWeight(int weight) {
+            this.weight = weight;
+        }
+
+    }
+
+}
@@ -0,0 +1,63 @@
+package com.baeldung.algorithms.boruvka;
+
+import java.util.Iterator;
+
+public class Tree implements Iterable<Edge> {
+    private Node root;
+    private int edgeCount;
+
+    private static class Node {
+        private Edge edge;
+        private Node next;
+
+        public String toString() {
+            String nextStr = next != null ? next.toString() : "";
+            return edge.toString() + " | " + nextStr;
+        }
+    }
+
+    public Tree() {
+        root = null;
+        edgeCount = 0;
+    }
+
+    public int getEdgeCount() {
+        return edgeCount;
+    }
+
+    public void addEdge(Edge edge) {
+        Node oldRoot = root;
+        root = new Node();
+        root.edge = edge;
+        root.next = oldRoot;
+        edgeCount++;
+    }
+
+    public String toString() {
+        String rootStr = root != null ? root.toString() : "";
+        return "Tree: " + rootStr + "Size: " + edgeCount;
+    }
+
+    public Iterator<Edge> iterator() {
+        return new LinkedIterator(root);
+    }
+
+    private class LinkedIterator implements Iterator<Edge> {
+        private Node current;
+
+        public LinkedIterator(Node root) {
+            current = root;
+        }
+
+        public boolean hasNext() {
+            return current != null;
+        }
+
+        public Edge next() {
+            Edge edge = current.edge;
+            current = current.next;
+            return edge;
+        }
+    }
+
+}
@@ -0,0 +1,76 @@
+package com.baeldung.algorithms.balancedbrackets;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class BalancedBracketsUsingDequeUnitTest {
+    private BalancedBracketsUsingDeque balancedBracketsUsingDeque;
+
+    @Before
+    public void setup() {
+        balancedBracketsUsingDeque = new BalancedBracketsUsingDeque();
+    }
+
+    @Test
+    public void givenNullInput_whenCheckingForBalance_shouldReturnFalse() {
+        boolean result = balancedBracketsUsingDeque.isBalanced(null);
+        assertThat(result).isFalse();
+    }
+
+    @Test
+    public void givenEmptyString_whenCheckingForBalance_shouldReturnTrue() {
+        boolean result = balancedBracketsUsingDeque.isBalanced("");
+        assertThat(result).isTrue();
+    }
+
+    @Test
+    public void givenInvalidCharacterString_whenCheckingForBalance_shouldReturnFalse() {
+        boolean result = balancedBracketsUsingDeque.isBalanced("abc[](){}");
+        assertThat(result).isFalse();
+    }
+
+    @Test
+    public void givenOddLengthString_whenCheckingForBalance_shouldReturnFalse() {
+        boolean result = balancedBracketsUsingDeque.isBalanced("{{[]()}}}");
+        assertThat(result).isFalse();
+    }
+
+    @Test
+    public void givenEvenLengthString_whenCheckingForBalance_shouldReturnFalse() {
+        boolean result = balancedBracketsUsingDeque.isBalanced("{{[]()}}}}");
+        assertThat(result).isFalse();
+    }
+
+    @Test
+    public void givenEvenLengthUnbalancedString_whenCheckingForBalance_shouldReturnFalse() {
+        boolean result = balancedBracketsUsingDeque.isBalanced("{[(])}");
+        assertThat(result).isFalse();
+    }
+
+    @Test
+    public void givenEvenLengthBalancedString_whenCheckingForBalance_shouldReturnTrue() {
+        boolean result = balancedBracketsUsingDeque.isBalanced("{[()]}");
+        assertThat(result).isTrue();
+    }
+
+    @Test
+    public void givenBalancedString_whenCheckingForBalance_shouldReturnTrue() {
+        boolean result = balancedBracketsUsingDeque.isBalanced("{{[[(())]]}}");
+        assertThat(result).isTrue();
+    }
+
+    @Test
+    public void givenAnotherBalancedString_whenCheckingForBalance_shouldReturnTrue() {
+        boolean result = balancedBracketsUsingDeque.isBalanced("{{([])}}");
+        assertThat(result).isTrue();
+    }
+
+    @Test
+    public void givenUnBalancedString_whenCheckingForBalance_shouldReturnFalse() {
+        boolean result = balancedBracketsUsingDeque.isBalanced("{{)[](}}");
+        assertThat(result).isFalse();
+    }
+
+}
@@ -0,0 +1,76 @@
+package com.baeldung.algorithms.balancedbrackets;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class BalancedBracketsUsingStringUnitTest {
+    private BalancedBracketsUsingString balancedBracketsUsingString;
+
+    @Before
+    public void setup() {
+        balancedBracketsUsingString = new BalancedBracketsUsingString();
+    }
+
+    @Test
+    public void givenNullInput_whenCheckingForBalance_shouldReturnFalse() {
+        boolean result = balancedBracketsUsingString.isBalanced(null);
+        assertThat(result).isFalse();
+    }
+
+    @Test
+    public void givenEmptyString_whenCheckingForBalance_shouldReturnTrue() {
+        boolean result = balancedBracketsUsingString.isBalanced("");
+        assertThat(result).isTrue();
+    }
+
+    @Test
+    public void givenInvalidCharacterString_whenCheckingForBalance_shouldReturnFalse() {
+        boolean result = balancedBracketsUsingString.isBalanced("abc[](){}");
+        assertThat(result).isFalse();
+    }
+
+    @Test
+    public void givenOddLengthString_whenCheckingForBalance_shouldReturnFalse() {
+        boolean result = balancedBracketsUsingString.isBalanced("{{[]()}}}");
+        assertThat(result).isFalse();
+    }
+
+    @Test
+    public void givenEvenLengthString_whenCheckingForBalance_shouldReturnFalse() {
+        boolean result = balancedBracketsUsingString.isBalanced("{{[]()}}}}");
+        assertThat(result).isFalse();
+    }
+
+    @Test
+    public void givenEvenLengthUnbalancedString_whenCheckingForBalance_shouldReturnFalse() {
+        boolean result = balancedBracketsUsingString.isBalanced("{[(])}");
+        assertThat(result).isFalse();
+    }
+
+    @Test
+    public void givenEvenLengthBalancedString_whenCheckingForBalance_shouldReturnTrue() {
+        boolean result = balancedBracketsUsingString.isBalanced("{[()]}");
+        assertThat(result).isTrue();
+    }
+
+    @Test
+    public void givenBalancedString_whenCheckingForBalance_shouldReturnTrue() {
+        boolean result = balancedBracketsUsingString.isBalanced("{{[[(())]]}}");
+        assertThat(result).isTrue();
+    }
+
+    @Test
+    public void givenAnotherBalancedString_whenCheckingForBalance_shouldReturnTrue() {
+        boolean result = balancedBracketsUsingString.isBalanced("{{([])}}");
+        assertThat(result).isTrue();
+    }
+
+    @Test
+    public void givenUnBalancedString_whenCheckingForBalance_shouldReturnFalse() {
+        boolean result = balancedBracketsUsingString.isBalanced("{{)[](}}");
+        assertThat(result).isFalse();
+    }
+
+}
@@ -0,0 +1,48 @@
+package com.baeldung.algorithms.boruvka;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import com.fasterxml.jackson.core.JsonParseException;
+import com.fasterxml.jackson.databind.JsonMappingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+
+public class BoruvkaUnitTest {
+
+    private Input input;
+    private static String INPUT_JSON = "/input.json";
+
+    @Before
+    public void convertInputJsonToObject() throws JsonParseException, JsonMappingException, IOException {
+        ObjectMapper mapper = new ObjectMapper();
+        StringBuilder jsonStr = new StringBuilder();
+        try (BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(BoruvkaMST.class.getResourceAsStream(INPUT_JSON)))) {
+            String line;
+            while ((line = bufferedReader.readLine()) != null) {
+                jsonStr.append(line)
+                    .append("\n");
+            }
+        }
+
+        input = mapper.readValue(jsonStr.toString(), Input.class);
+
+    }
+
+    @Test
+    public void givenInputGraph_whenBoruvkaPerformed_thenMinimumSpanningTree() throws JsonParseException, JsonMappingException, IOException {
+        Graph graph = new Graph(input);
+        BoruvkaMST boruvkaMST = new BoruvkaMST(graph);
+
+        Tree mst = (Tree) boruvkaMST.getMST();
+
+        assertEquals(30, boruvkaMST.getTotalWeight());
+        assertEquals(4, mst.getEdgeCount());
+    }
+
+}
@@ -0,0 +1,41 @@
+{
+	"nodes": 5,
+	"edges": 7,
+	"edgeList": [
+		{
+			"first": 0,
+			"second": 1,
+			"weight": 8
+		},
+		{
+			"first": 0,
+			"second": 2,
+			"weight": 5
+		},
+		{
+			"first": 1,
+			"second": 2,
+			"weight": 9
+		},
+		{
+			"first": 1,
+			"second": 3,
+			"weight": 11
+		},
+		{
+			"first": 2,
+			"second": 3,
+			"weight": 15
+		},
+		{
+			"first": 2,
+			"second": 4,
+			"weight": 10
+		},
+		{
+			"first": 3,
+			"second": 4,
+			"weight": 7
+		}
+	]
+}
@@ -0,0 +1,57 @@
+package com.baeldung.algorithms.suffixtree;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Node {
+    private String text;
+    private List<Node> children;
+    private int position;
+
+    public Node(String word, int position) {
+        this.text = word;
+        this.position = position;
+        this.children = new ArrayList<>();
+    }
+
+    public String getText() {
+        return text;
+    }
+
+    public void setText(String text) {
+        this.text = text;
+    }
+
+    public int getPosition() {
+        return position;
+    }
+
+    public void setPosition(int position) {
+        this.position = position;
+    }
+
+    public List<Node> getChildren() {
+        return children;
+    }
+
+    public void setChildren(List<Node> children) {
+        this.children = children;
+    }
+
+    public String printTree(String depthIndicator) {
+        String str = "";
+        String positionStr = position > -1 ? "[" + String.valueOf(position) + "]" : "";
+        str += depthIndicator + text + positionStr + "\n";
+
+        for (int i = 0; i < children.size(); i++) {
+            str += children.get(i)
+                .printTree(depthIndicator + "\t");
+        }
+        return str;
+    }
+
+    @Override
+    public String toString() {
+        return printTree("");
+    }
+}
@@ -0,0 +1,175 @@
+package com.baeldung.algorithms.suffixtree;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class SuffixTree {
+    private static final Logger LOGGER = LoggerFactory.getLogger(SuffixTree.class);
+    private static final String WORD_TERMINATION = "$";
+    private static final int POSITION_UNDEFINED = -1;
+    private Node root;
+    private String fullText;
+
+    public SuffixTree(String text) {
+        root = new Node("", POSITION_UNDEFINED);
+        for (int i = 0; i < text.length(); i++) {
+            addSuffix(text.substring(i) + WORD_TERMINATION, i);
+        }
+        fullText = text;
+    }
+
+    public List<String> searchText(String pattern) {
+        LOGGER.info("Searching for pattern \"{}\"", pattern);
+        List<String> result = new ArrayList<>();
+        List<Node> nodes = getAllNodesInTraversePath(pattern, root, false);
+
+        if (nodes.size() > 0) {
+            Node lastNode = nodes.get(nodes.size() - 1);
+            if (lastNode != null) {
+                List<Integer> positions = getPositions(lastNode);
+                positions = positions.stream()
+                    .sorted()
+                    .collect(Collectors.toList());
+                positions.forEach(m -> result.add((markPatternInText(m, pattern))));
+            }
+        }
+        return result;
+    }
+
+    private void addSuffix(String suffix, int position) {
+        LOGGER.info(">>>>>>>>>>>> Adding new suffix {}", suffix);
+        List<Node> nodes = getAllNodesInTraversePath(suffix, root, true);
+        if (nodes.size() == 0) {
+            addChildNode(root, suffix, position);
+            LOGGER.info("{}", printTree());
+        } else {
+            Node lastNode = nodes.remove(nodes.size() - 1);
+            String newText = suffix;
+            if (nodes.size() > 0) {
+                String existingSuffixUptoLastNode = nodes.stream()
+                    .map(a -> a.getText())
+                    .reduce("", String::concat);
+
+                // Remove prefix from newText already included in parent
+                newText = newText.substring(existingSuffixUptoLastNode.length());
+            }
+            extendNode(lastNode, newText, position);
+            LOGGER.info("{}", printTree());
+        }
+    }
+
+    private List<Integer> getPositions(Node node) {
+        List<Integer> positions = new ArrayList<>();
+        if (node.getText()
+            .endsWith(WORD_TERMINATION)) {
+            positions.add(node.getPosition());
+        }
+        for (int i = 0; i < node.getChildren()
+            .size(); i++) {
+            positions.addAll(getPositions(node.getChildren()
+                .get(i)));
+        }
+        return positions;
+    }
+
+    private String markPatternInText(Integer startPosition, String pattern) {
+        String matchingTextLHS = fullText.substring(0, startPosition);
+        String matchingText = fullText.substring(startPosition, startPosition + pattern.length());
+        String matchingTextRHS = fullText.substring(startPosition + pattern.length());
+        return matchingTextLHS + "[" + matchingText + "]" + matchingTextRHS;
+    }
+
+    private void addChildNode(Node parentNode, String text, int position) {
+        parentNode.getChildren()
+            .add(new Node(text, position));
+    }
+
+    private void extendNode(Node node, String newText, int position) {
+        String currentText = node.getText();
+        String commonPrefix = getLongestCommonPrefix(currentText, newText);
+
+        if (commonPrefix != currentText) {
+            String parentText = currentText.substring(0, commonPrefix.length());
+            String childText = currentText.substring(commonPrefix.length());
+            splitNodeToParentAndChild(node, parentText, childText);
+        }
+
+        String remainingText = newText.substring(commonPrefix.length());
+        addChildNode(node, remainingText, position);
+    }
+
+    private void splitNodeToParentAndChild(Node parentNode, String parentNewText, String childNewText) {
+        Node childNode = new Node(childNewText, parentNode.getPosition());
+
+        if (parentNode.getChildren()
+            .size() > 0) {
+            while (parentNode.getChildren()
+                .size() > 0) {
+                childNode.getChildren()
+                    .add(parentNode.getChildren()
+                        .remove(0));
+            }
+        }
+
+        parentNode.getChildren()
+            .add(childNode);
+        parentNode.setText(parentNewText);
+        parentNode.setPosition(POSITION_UNDEFINED);
+    }
+
+    private String getLongestCommonPrefix(String str1, String str2) {
+        int compareLength = Math.min(str1.length(), str2.length());
+        for (int i = 0; i < compareLength; i++) {
+            if (str1.charAt(i) != str2.charAt(i)) {
+                return str1.substring(0, i);
+            }
+        }
+        return str1.substring(0, compareLength);
+    }
+
+    private List<Node> getAllNodesInTraversePath(String pattern, Node startNode, boolean isAllowPartialMatch) {
+        List<Node> nodes = new ArrayList<>();
+        for (int i = 0; i < startNode.getChildren()
+            .size(); i++) {
+            Node currentNode = startNode.getChildren()
+                .get(i);
+            String nodeText = currentNode.getText();
+            if (pattern.charAt(0) == nodeText.charAt(0)) {
+                if (isAllowPartialMatch && pattern.length() <= nodeText.length()) {
+                    nodes.add(currentNode);
+                    return nodes;
+                }
+
+                int compareLength = Math.min(nodeText.length(), pattern.length());
+                for (int j = 1; j < compareLength; j++) {
+                    if (pattern.charAt(j) != nodeText.charAt(j)) {
+                        if (isAllowPartialMatch) {
+                            nodes.add(currentNode);
+                        }
+                        return nodes;
+                    }
+                }
+
+                nodes.add(currentNode);
+                if (pattern.length() > compareLength) {
+                    List<Node> nodes2 = getAllNodesInTraversePath(pattern.substring(compareLength), currentNode, isAllowPartialMatch);
+                    if (nodes2.size() > 0) {
+                        nodes.addAll(nodes2);
+                    } else if (!isAllowPartialMatch) {
+                        nodes.add(null);
+                    }
+                }
+                return nodes;
+            }
+        }
+        return nodes;
+    }
+
+    public String printTree() {
+        return root.printTree("");
+    }
+}
@@ -0,0 +1,77 @@
+package com.baeldung.algorithms.suffixtree;
+
+import java.util.List;
+
+import org.junit.Assert;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class SuffixTreeUnitTest {
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(SuffixTreeUnitTest.class);
+
+    private static SuffixTree suffixTree;
+
+    @BeforeClass
+    public static void setUp() {
+        suffixTree = new SuffixTree("havanabanana");
+        printTree();
+    }
+
+    @Test
+    public void givenSuffixTree_whenSearchingForA_thenReturn6Matches() {
+        List<String> matches = suffixTree.searchText("a");
+        matches.stream()
+            .forEach(m -> LOGGER.info(m));
+        Assert.assertArrayEquals(new String[] { "h[a]vanabanana", "hav[a]nabanana", "havan[a]banana", "havanab[a]nana", "havanaban[a]na", "havanabanan[a]" }, matches.toArray());
+    }
+
+    @Test
+    public void givenSuffixTree_whenSearchingForNab_thenReturn1Match() {
+        List<String> matches = suffixTree.searchText("nab");
+        matches.stream()
+            .forEach(m -> LOGGER.info(m));
+        Assert.assertArrayEquals(new String[] { "hava[nab]anana" }, matches.toArray());
+    }
+
+    @Test
+    public void givenSuffixTree_whenSearchingForNag_thenReturnNoMatches() {
+        List<String> matches = suffixTree.searchText("nag");
+        matches.stream()
+            .forEach(m -> LOGGER.info(m));
+        Assert.assertArrayEquals(new String[] {}, matches.toArray());
+    }
+
+    @Test
+    public void givenSuffixTree_whenSearchingForBanana_thenReturn2Matches() {
+        List<String> matches = suffixTree.searchText("ana");
+        matches.stream()
+            .forEach(m -> LOGGER.info(m));
+        Assert.assertArrayEquals(new String[] { "hav[ana]banana", "havanab[ana]na", "havanaban[ana]" }, matches.toArray());
+    }
+
+    @Test
+    public void givenSuffixTree_whenSearchingForNa_thenReturn4Matches() {
+        List<String> matches = suffixTree.searchText("na");
+        matches.stream()
+            .forEach(m -> LOGGER.info(m));
+        Assert.assertArrayEquals(new String[] { "hava[na]banana", "havanaba[na]na", "havanabana[na]" }, matches.toArray());
+    }
+
+    @Test
+    public void givenSuffixTree_whenSearchingForX_thenReturnNoMatches() {
+        List<String> matches = suffixTree.searchText("x");
+        matches.stream()
+            .forEach(m -> LOGGER.info(m));
+        Assert.assertArrayEquals(new String[] {}, matches.toArray());
+    }
+
+    private static void printTree() {
+        suffixTree.printTree();
+
+        LOGGER.info("\n" + suffixTree.printTree());
+        LOGGER.info("==============================================");
+    }
+}
@@ -0,0 +1,3 @@
+### Relevant Articles:
+
+- [Partitioning and Sorting Arrays with Many Repeated Entries](https://www.baeldung.com/java-sorting-arrays-with-repeated-entries)
@@ -0,0 +1,43 @@
+<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>
+
+    <parent>
+        <groupId>com.baeldung</groupId>
+        <artifactId>parent-modules</artifactId>
+        <version>1.0.0-SNAPSHOT</version>
+    </parent>
+
+    <groupId>com.baeldung.apache</groupId>
+    <artifactId>apache-beam</artifactId>
+    <version>0.0.1-SNAPSHOT</version>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.apache.beam</groupId>
+            <artifactId>beam-sdks-java-core</artifactId>
+            <version>${beam.version}</version>
+        </dependency>
+        <!-- runtime scoped -->
+        <dependency>
+            <groupId>org.apache.beam</groupId>
+            <artifactId>beam-runners-direct-java</artifactId>
+            <version>${beam.version}</version>
+            <scope>runtime</scope>
+        </dependency>
+        <!-- test scoped -->
+        <dependency>
+            <groupId>org.assertj</groupId>
+            <artifactId>assertj-core</artifactId>
+            <version>${assertj.version}</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+    <properties>
+        <beam.version>2.19.0</beam.version>
+        <assertj.version>3.6.1</assertj.version>
+    </properties>
+
+</project>
@@ -0,0 +1,71 @@
+package com.baeldung.apache.beam.intro;
+
+import java.util.Arrays;
+
+import org.apache.beam.sdk.Pipeline;
+import org.apache.beam.sdk.io.TextIO;
+import org.apache.beam.sdk.options.PipelineOptions;
+import org.apache.beam.sdk.options.PipelineOptionsFactory;
+import org.apache.beam.sdk.transforms.Count;
+import org.apache.beam.sdk.transforms.Filter;
+import org.apache.beam.sdk.transforms.FlatMapElements;
+import org.apache.beam.sdk.transforms.MapElements;
+import org.apache.beam.sdk.values.KV;
+import org.apache.beam.sdk.values.PCollection;
+import org.apache.beam.sdk.values.TypeDescriptors;
+
+public class WordCount {
+    
+    public static boolean wordCount(String inputFilePath, String outputFilePath) {
+        // We use default options
+        PipelineOptions options = PipelineOptionsFactory.create();
+        // to create the pipeline
+        Pipeline p = Pipeline.create(options);
+        // Here is our workflow graph
+        PCollection<KV<String, Long>> wordCount = p
+            .apply("(1) Read all lines", TextIO.read().from(inputFilePath))
+            .apply("(2) Flatmap to a list of words", FlatMapElements.into(TypeDescriptors.strings())
+                .via(line -> Arrays.asList(line.split("\\s"))))
+            .apply("(3) Lowercase all", MapElements.into(TypeDescriptors.strings())
+                .via(word -> word.toLowerCase()))
+            .apply("(4) Trim punctuations", MapElements.into(TypeDescriptors.strings())
+                .via(word -> trim(word)))
+            .apply("(5) Filter stopwords", Filter.by(word -> !isStopWord(word)))
+            .apply("(6) Count words", Count.perElement());
+        // We convert the PCollection to String so that we can write it to file
+        wordCount.apply(MapElements.into(TypeDescriptors.strings())
+                .via(count -> count.getKey() + " --> " + count.getValue()))
+            .apply(TextIO.write().to(outputFilePath));
+        // Finally we must run the pipeline, otherwise it's only a definition
+        p.run().waitUntilFinish();  
+        return true;
+    }
+    
+    public static boolean isStopWord(String word) {
+        String[] stopwords = {"am", "are", "is", "i", "you", "me",
+                               "he", "she", "they", "them", "was",
+                               "were", "from", "in", "of", "to", "be",
+                               "him", "her", "us", "and", "or"};
+        for (String stopword : stopwords) {
+            if (stopword.compareTo(word) == 0) {
+                return true;
+            }
+        }
+        return false;
+    }
+    
+    public static String trim(String word) {
+        return word.replace("(","")
+            .replace(")", "")
+            .replace(",", "")
+            .replace(".", "")
+            .replace("\"", "")
+            .replace("'", "")
+            .replace(":", "")
+            .replace(";", "")
+            .replace("-", "")
+            .replace("?", "")
+            .replace("!", "");
+    }
+
+}
@@ -0,0 +1,19 @@
+package com.baeldung.apache.beam.intro;
+
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Ignore;
+import org.junit.Test;
+
+import com.baeldung.apache.beam.intro.WordCount;
+
+public class WordCountUnitTest {
+    
+    @Test
+    // @Ignore
+    public void givenInputFile_whenWordCountRuns_thenJobFinishWithoutError() {
+        boolean jobDone = WordCount.wordCount("src/test/resources/wordcount.txt", "target/output");
+        assertTrue(jobDone);
+    }
+
+}
@@ -0,0 +1,16 @@
+We've all heard the scare stories about North Korea: the homemade nuclear arsenal built while their people starve and then aimed imprecisely at the rest of the world, a 
+leader so deluded he makes L Ron Hubbard look like a man excessively overburdened with self-doubt and their deep-seated belief that foreign capitalists will invade at any 
+moment and steal all their bauxite.
+The popular portrayal of this Marxist nation is something like one of the more harrowing episodes of M*A*S*H, only with the cast of wacky characters replaced by twitchy, 
+heavily armed Stalinist meth addicts
+Cracked would like to take a moment to celebrate the good things about North Korea though, the things that the country's enemies prefer to suppress as part of their politically 
+motivated jealousy. Like how no different to you and me, there's nothing every North Korean likes more after an 18 hour shift at the phosphorus plant than a nice beer to go with 
+his dried fish ration. Ever attentive to its people's needs and in the twinkling of a decade, North Korea's leadership bought, disassembled, transported and rebuilt a British 
+brewery in order to discover and reproduce the secrets of beer and then brew the sweet nectar for its hardworking people, up to 18 bottles at a time. And with minimal fatalities. 
+When was the last time YOUR leader got a beer for YOU, American? (NB do not answer this question if you are Henry Louis Gates).
+Or how about the fried chicken restaurant that downtown Pyongyang boasts? Yes real chicken, fried and then delivered to your sleeping cube, with optional beer if you like! You 
+don't even have to remove the feathers or pull out the gizzard yourself. Mostly. Americans must eat their fried chicken from a bucket, like swine, sold by a company so secretive 
+that even the very blend of seasoning used is intentionally kept from them. And they call North Korea paranoid?
+And how many nations would entertain the syphilitic, bourgeois ramblings of Bill Clinton let alone permit him anywhere near their proud womenfolk? Only wise Kim Jong Il could see 
+past Bill's many, many imperfections and treat him with the pity and kindness he deserves, accepting his feeble pleas to pardon the American spies rightly convicted of photographing 
+the nation's sensitive beetroot fields.
@@ -1,3 +0,0 @@
-### Relevant Articles
-
- [Introduction to Apache CXF Aegis Data Binding](https://www.baeldung.com/aegis-data-binding-in-apache-cxf)
@@ -18,19 +18,19 @@
        <dependency>
            <groupId>javax.ws.rs</groupId>
            <artifactId>javax.ws.rs-api</artifactId>
-            <version>2.1</version>
+            <version>${rs-api.version}</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>javax.enterprise</groupId>
            <artifactId>cdi-api</artifactId>
-            <version>2.0</version>
+            <version>${cdi-api.version}</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>javax.json.bind</groupId>
            <artifactId>javax.json.bind-api</artifactId>
-            <version>1.0</version>
+            <version>${bind-api.version}</version>
            <scope>provided</scope>
        </dependency>

@@ -80,6 +80,9 @@
        <liberty-maven-plugin.version>2.4.2</liberty-maven-plugin.version>
        <failOnMissingWebXml>false</failOnMissingWebXml>
        <openliberty-version>18.0.0.2</openliberty-version>
+        <rs-api.version>2.1</rs-api.version>
+        <cdi-api.version>2.0</cdi-api.version>
+        <bind-api.version>1.0</bind-api.version>
    </properties>

 </project>
--- a/Show More
+++ b/Show More