Merge branch 'master' into thombergs-patch-4

Author: lor6

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`. 
 
 

akka-http/README.md

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

algorithms-miscellaneous-1/README.md

@@ -12,4 +12,5 @@
 - [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 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)

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