Rotated index: done

Author: rampatra

src/main/java/com/rampatra/arrays/PivotedBinarySearch.java

@@ -7,62 +7,68 @@
  *
  * @author rampatra
  * @since 5/31/15
- * @time: 10:44 PM
  */
 public class PivotedBinarySearch {
 
     /**
-     * Search an element in a sorted pivoted array {@param a}.
+     * Search an element in a sorted pivoted array {@code arr}.
      * <p/>
      * Example,
      * 1) For array [3,4,5,1,2] pivot is 5
      * 2) For array [6,7,8,5,4] pivot is 8
      *
-     * @param a
+     * @param arr
      * @param n
      * @return
      */
-    public static int pivotedBinarySearch(int a[], int n) {
-        int pivot = findPivot(a, 0, a.length - 1);
+    public static int pivotedBinarySearch(int[] arr, int n) {
+        int pivot = findPivotIndex(arr, 0, arr.length - 1);
 
-        if (pivot == -1 || a[pivot] == n) {
+        if (pivot == -1 || arr[pivot] == n) {
             return pivot;
-        } else if (n <= a[0]) {
-            return BinarySearch.binarySearch(a, n, pivot + 1, a.length - 1);
+        } else if (n < arr[0]) {
+            return BinarySearch.binarySearch(arr, n, pivot + 1, arr.length - 1);
         } else {
-            return BinarySearch.binarySearch(a, n, 0, pivot - 1);
+            return BinarySearch.binarySearch(arr, n, 0, pivot - 1);
         }
     }
 
     /**
-     * Finds the pivot element in array {@param a}. Pivot element is the only
+     * Finds the pivot element in array {@code arr}. Pivot element is the only
      * element for which next element to it is smaller than it.
      *
-     * @param a
+     * @param arr
      * @param low
      * @param high
-     * @return
+     * @return the index of the pivot element in the {@code arr}.
      */
-    public static int findPivot(int a[], int low, int high) {
+    public static int findPivotIndex(int[] arr, int low, int high) {
         if (low > high) return -1;
-        if (low == high) return low;
 
         int mid = (low + high) / 2;
 
-        if (a[mid] > a[mid + 1] && a[mid] > a[mid - 1]) {
+        if (mid == 0 || mid == arr.length - 1) return -1;
+        
+        if (arr[mid] > arr[mid + 1] && arr[mid] > arr[mid - 1]) {
             return mid;
-        } else if (a[mid] > a[mid - 1] && a[mid] < a[mid + 1]) {
-            return findPivot(a, mid + 1, a.length - 1);
+        } else if (arr[mid] > arr[mid - 1] && arr[mid] < arr[mid + 1]) {
+            return findPivotIndex(arr, mid + 1, arr.length - 1);
         } else {
-            return findPivot(a, 0, mid - 1);
+            return findPivotIndex(arr, 0, mid - 1);
         }
     }
 
     public static void main(String[] args) {
-        System.out.println("Pivot: " + findPivot(new int[]{1, 2, 3, 4, 5}, 0, 3));
+        System.out.println("Pivot: " + findPivotIndex(new int[]{3, 4, 5, 1, 2}, 0, 4));
+        System.out.println("Index: " + pivotedBinarySearch(new int[]{3, 4, 5, 1, 2}, 5));
+
+        System.out.println("Pivot: " + findPivotIndex(new int[]{1, 2, 3, 4, 5}, 0, 4));
         System.out.println("Index: " + pivotedBinarySearch(new int[]{1, 2, 3, 4, 5}, 4));
 
-        System.out.println("Pivot: " + findPivot(new int[]{5}, 0, 0));
-        System.out.println("Index: " + pivotedBinarySearch(new int[]{5}, 5));
+        System.out.println("Pivot: " + findPivotIndex(new int[]{5, 4, 3, 2, 1}, 0, 4));
+        System.out.println("Index: " + pivotedBinarySearch(new int[]{5, 4, 3, 2, 1}, 4));
+
+        System.out.println("Pivot: " + findPivotIndex(new int[]{5}, 0, -1));
+        System.out.println("Index: " + pivotedBinarySearch(new int[]{5}, -1));
     }
 }

src/main/java/com/rampatra/arrays/RotatedIndex.java

@@ -0,0 +1,55 @@
+package com.rampatra.arrays;
+
+/**
+ * @author rampatra
+ * @since 2019-04-04
+ */
+public class RotatedIndex {
+
+    private static int findIndexOfRotationPoint(String[] words) {
+        return findIndexOfRotationPoint(words, 0, words.length - 1);
+    }
+
+    private static int findIndexOfRotationPoint(String[] words, int start, int end) {
+        if (start > end) return -1;
+
+        int mid = (start + end) / 2;
+        
+        if (mid == 0 || mid == words.length - 1) return -1;
+
+        if (words[mid].compareTo(words[mid - 1]) < 0 && words[mid].compareTo(words[mid + 1]) < 0) {
+            return mid;
+        } else if (words[mid].compareTo(words[mid - 1]) > 0 && words[mid].compareTo(words[mid + 1]) < 0) {
+            return findIndexOfRotationPoint(words, start, mid - 1);
+        } else {
+            return findIndexOfRotationPoint(words, mid + 1, end);
+        }
+    }
+
+    public static void main(String[] args) {
+        System.out.println(findIndexOfRotationPoint(new String[]{
+                "ptolemaic",
+                "retrograde",
+                "supplant",
+                "undulate",
+                "xenoepist",
+                "asymptote",  // <-- rotates here!
+                "babka",
+                "banoffee",
+                "engender",
+                "karpatka",
+                "othellolagkage",
+        }));
+
+        System.out.println(findIndexOfRotationPoint(new String[]{}));
+        
+        System.out.println(findIndexOfRotationPoint(new String[]{
+                "asymptote",
+                "babka",
+                "banoffee",
+                "engender",
+                "karpatka",
+                "othellolagkage",
+        }));
+    }
+}

src/main/java/com/rampatra/base/Trie.java

@@ -3,28 +3,27 @@
 import java.util.HashMap;
 
 /**
- * Created by IntelliJ IDEA.
- * <p/>
  * Trie also called digital tree and sometimes radix tree or prefix tree (as they can be
  * searched by prefixes), is an ordered tree data structure that is used to store a dynamic
  * set or associative array where the keys are usually strings.
  * <p/>
  * You can think it as HashMap of HashMap of HashMap and so on. Each key in the HashMap is a
  * single digit/letter of the data you want to store and {@code data} is the final full word
  * you want to save in trie.
+ * <p>
+ * Some resources:
+ * <a href="https://en.wikipedia.org/wiki/Trie">Trie Data Structure</a>
+ * <a href="https://www.topcoder.com/community/data-science/data-science-tutorials/using-tries">More about Tries</a>
  *
  * @author rampatra
  * @since 9/22/15
- * @time: 8:19 PM
- * @see: https://en.wikipedia.org/wiki/Trie
- * @see: https://www.topcoder.com/community/data-science/data-science-tutorials/using-tries
  */
 public class Trie<E> {
 
     TrieNode<E> root;
 
     Trie() {
-        root = new TrieNode<>(null, new HashMap<String, TrieNode<E>>());
+        root = new TrieNode<>(null, new HashMap<>());
     }
 
     /**
@@ -48,7 +47,7 @@ public void insert(E data) {
         }
 
         while (i < str.length()) {
-            curr.children.put(str.substring(i, i + 1), new TrieNode<>(null, new HashMap<String, TrieNode<E>>()));
+            curr.children.put((E) str.substring(i, i + 1), new TrieNode<>(null, new HashMap<>()));
             curr = curr.children.get(str.substring(i, i + 1));
             i++;
         }
@@ -57,10 +56,10 @@ public void insert(E data) {
     }
 
     /**
-     * Searches {@param data} in trie.
+     * Searches {@code data} in trie.
      *
-     * @param data
-     * @return {@code true} if {@param data} is present, {@code false} otherwise.
+     * @param data the value to search.
+     * @return {@code true} if {@code data} is present, {@code false} otherwise.
      */
     public boolean search(E data) {
 
@@ -79,11 +78,11 @@ public boolean search(E data) {
         return curr.data != null && curr.data.equals(data);
     }
 
-    private class TrieNode<E> {
-        E data; // stores the complete string (required to determine whether the string is in the trie)
-        HashMap<String, TrieNode<E>> children;
+    private class TrieNode<T> {
+        T data; // stores the complete string (required to determine whether the string is in the trie)
+        HashMap<T, TrieNode<T>> children;
 
-        TrieNode(E data, HashMap<String, TrieNode<E>> children) {
+        TrieNode(T data, HashMap<T, TrieNode<T>> children) {
             this.data = data;
             this.children = children;
         }