Linked List problems

Author: abhiabhi

src/main/images/SearchInRotatedSortedArray.png

@@ -0,0 +1 @@
+image::../../../images/SearchInRotatedSortedArray.png[]

src/main/images/WildCardMatching.png

@@ -4,6 +4,8 @@
  * An array is called Bitonic if it is comprises of an increasing sequence of integers followed immediately
  * by a decreasing sequence of integers.
  * Given a bitonic array A of N distinct integers. Find a element X in it.
+ * <p>
+ * You may assume no duplicate exists in the array.
  */
 public class SearchInRotatedSortedArray_BitonicArray {
 
@@ -13,32 +15,35 @@ public static int search(int[] nums, int target) {
 
         while (left <= right) {
 
-            int mid = left + (right - left) / 2;
+            int mid = (left + right) / 2;
             if (target == nums[mid])
                 return mid;
 
-            if (nums[left] <= nums[mid]) {
-                if (nums[left] <= target && target < nums[mid]) {
+            /** update left and right
+                left will always move forward and right will always shrink*/
+            if (nums[left] <= nums[mid]) {  /** first half  = left -> mid */
+                if (nums[left] <= target && target < nums[mid]) { /** target is between left and mid so means left at right position and need
+                                                                      to update right as right will always shrink/move backward it will be mid-1 */
                     right = mid - 1;
                 } else {
                     left = mid + 1;
                 }
-            }
-
-            if (nums[mid] <= nums[right]) {
-                if (nums[mid] < target && target <= nums[right]) {
+            } else {  /** second half = mid -> right */
+                if (nums[mid] < target && target <= nums[right]) { /** target is between mid and right so means right is at correct position and need
+                                                                        to update left as left will always move forward it will be mid+1 */
                     left = mid + 1;
                 } else {
                     right = mid - 1;
                 }
             }
+
         }
 
         return -1;
     }
 
     public static void main(String args[]) {
         int[] arr = {4, 5, 6, 7, 0, 1, 2};
-        System.out.println("Element found at index : " + search(arr, 6));
+        System.out.println("Element found at index : " + search(arr, 7));
     }
 }

src/main/java/com/arrays/SearchInRotatedSortedArray_BitonicArray.adoc

@@ -0,0 +1 @@
+image::../../../images/WildCardMatching.png[]

src/main/java/com/arrays/SearchInRotatedSortedArray_BitonicArray.java

@@ -0,0 +1,78 @@
+package com.arrays;
+
+/**
+
+ '?' Matches any single character.
+ '*' Matches any sequence of characters (including the empty sequence).
+
+ Input:
+ s = "cb"
+ p = "?a"
+ Output: false
+ Explanation: '?' matches 'c', but the second letter is 'a', which does not match 'b'.
+
+ Time complexity of above solution is O(m x n). Auxiliary space used is also O(m x n).
+ where m = length of pattern
+       n = length of String
+
+ */
+
+public class WildCardMatching {
+
+        public boolean isMatch(String s, String p) {
+            char[] str = s.toCharArray();
+            char[] pattern = p.toCharArray();
+
+            //replace multiple * with one *
+            //e.g a**b***c --> a*b*c
+            int writeIndex = 0;
+            boolean isFirst = true;
+            for (int i = 0; i < pattern.length; i++) {
+                if (pattern[i] == '*') {
+                    if (isFirst) {
+                        pattern[writeIndex++] = pattern[i];
+                        isFirst = false;
+                    }
+                } else {
+                    pattern[writeIndex++] = pattern[i];
+                    isFirst = true;
+                }
+            }
+
+            boolean T[][] = new boolean[str.length + 1][pattern.length + 1];
+
+            if (writeIndex > 0 && pattern[0] == '*') {
+                T[0][1] = true;
+            }
+
+            // base case
+            T[0][0] = true;
+
+            /**
+             * Rules
+             * 1) if the value at boolean_array[i][j] is a matching character or a “?”.
+             *      boolean_array[i][j] = boolean_array[i-1][j-1] (means diagonal)
+             *
+             * 2) if the value at at boolean_array[i][j] is “*”.
+             *      boolean_array[i][j] = boolean_array[i][j-1] || boolean_array[i-1][j] (means one one left or one on top whichever is true)
+             */
+
+            for (int i = 1; i <= str.length; i++)
+            {
+                for (int j = 1; j <= pattern.length; j++)
+                    if (pattern[j - 1] == '?' || str[i - 1] == pattern[j - 1]) {
+                        T[i][j] = T[i - 1][j - 1]; //diagonal
+                    } else if (pattern[j - 1] == '*') {
+                        T[i][j] = T[i - 1][j] || T[i][j - 1];
+                    }
+                }
+
+            return T[str.length][pattern.length];
+        }
+
+
+    public static void main(String args[]) {
+        WildCardMatching wcm = new WildCardMatching();
+        System.out.println(wcm.isMatch("xbylmz", "x?y*z"));
+    }
+}

src/main/java/com/arrays/WildCardMatching.adoc

@@ -9,8 +9,7 @@ https://medium.com/@ajinkyajawale/inorder-preorder-postorder-traversal-of-binary
 
 GitHub
 https://github.com/kdn251/interviews
-https://github.com/mission-peace/interview/tree/master/src/com/interview/
-https://github.com/mission-peace/interview/wiki/String
+https://github.com/mission-peace/interview/wiki/String - Tushar Roy
 https://github.com/varunu28/InterviewBit-Java-Solutions
 https://github.com/dennyzhang/code.dennyzhang.com/tree/master/problems
 https://github.com/yc-gh/GeeksForGeeks