More problems added

Author: abhiabhi

src/main/images/GetMinimumFromStackInConstantTime.png

@@ -19,7 +19,8 @@
  * <p>
  * <p>
  * Complexity Analysis:
- * Time Complexity: O(n log n), The algorithm used is divide and conquer, So in each level one full array traversal is needed and there are log n levels so the time complexity is O(n log n).
+ * Time Complexity: O(n log n), The algorithm used is divide and conquer,
+ * So in each level one full array traversal is needed and there are log n levels so the time complexity is O(n log n).
  * Space Compelxity:O(1), No extra space is required.
  */
 public class InversionCountInArray_MergeSort {

src/main/images/KDistanceFromGivenNode.png

@@ -0,0 +1,61 @@
+package com.arrays;
+
+import java.util.HashSet;
+
+/**
+ * Given an unsorted array of integers,
+ * find the length of the longest consecutive elements sequence.
+ *
+ * For example, given [100, 4, 200, 1, 3, 2],
+ * the longest consecutive elements sequence should be [1, 2, 3, 4]. Its length is 4.
+ *
+ * Because it requires O(n) complexity,
+ * we can not solve the problem by sorting the array first. Sorting takes at least O(nlogn) time.
+ *
+ * We can use a HashSet to add and remove elements.
+ * The add, remove and contains methods have constant time complexity O(1).
+ */
+public class LongestConsecutiveSubsequence {
+
+    public static int longestConsecutive(int[] nums) {
+
+        /** Add all the elements of array to Set */
+        HashSet<Integer> set = new HashSet<>();
+        for (int num : nums)
+            set.add(num);
+
+        int result = 0;
+
+        /** Iterate over each element in array */
+        for (int num : nums) {
+            int count = 1;
+
+            /** calculate previous element to current element to see if present in set */
+            int down = num - 1;
+            while (set.contains(down)) {
+                set.remove(down);
+                down--;
+                count++;
+            }
+
+            /** calculate next element to current element to see if present in set */
+            int up = num + 1;
+            while (set.contains(up)) {
+                set.remove(up);
+                up++;
+                count++;
+            }
+
+            /** update the result if current counter is bigger than result */
+            result = Math.max(result, count);
+        }
+
+        return result;
+    }
+
+    public static void main(String args[]) {
+        int nums[] = {1, 5, 4, 100, 200, 2, 3};
+        int result = longestConsecutive(nums);
+        System.out.println("longestConsecutive : " + result);
+    }
+}

src/main/images/KDistanceFromGivenNode1.png

@@ -1,5 +1,5 @@
 package com.arrays;
-/*
+/**
 
 Dynamic programming solves a problem by dividing it into smaller subproblems. This is very similar to the divide-and-conquer algorithm solving technique.
  The major difference, however, is that dynamic programming solves a subproblem only once.
@@ -13,13 +13,13 @@
 
 Complexity of finding largest sum subarray in an array is O(N) in time and O(1) in space.
 
-    */
+ */
 
 public class MaxSumSubArray_KadaneAlgo_DynamicProgram {
 
     public static void main(String[] args) {
 
-        int[] arr = {-1, 3, -5, 4, 6, -1, 2, -7, 3, -3};
+        int[] arr = {-1, -3, -5, -4, -1, -1, -2, -7, -3, -3};
 
         int[] result = findMaxSumIndex(arr);
         System.out.println("start index :" + result[0]);

src/main/images/KDistanceFromGivenNode2.png

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

src/main/images/KDistanceFromGivenNode3.png

@@ -0,0 +1,79 @@
+package com.arrays;
+
+import java.util.Arrays;
+
+/**
+ * Write a program to find the minimum number of platforms needed in a railway station.
+ * <p>
+ * The arrival and departure time of several trains are provided.
+ * Two disparate arrays are given: one with all the arrival times and another with the departure time in 24 hours clock.
+ * Write a program to find the minimum number of platforms needed in a given railway station.
+ * <p>
+ * Solution:
+ * <p>
+ * Clue: The minimum number of platforms is nothing but the maximum number of trains that rest in the given railway station
+ * from the time limit between the arrival of the first train to the departure of the last train.
+ * Input:  arr[]  = {9:00,  9:40, 9:50,  11:00, 15:00, 18:00}
+ * dep[]  = {9:10, 12:00, 11:20, 11:30, 19:00, 20:00}
+ * Output: 3
+ * There are at-most three trains at a time (time between 9:40 to 11:00)
+ * <p>
+ * Sort the timing values given in both the arrays and later check the count of trains at every given time of arrival and departure.
+ * The maximum number of trains in the process is taken as the output.
+ * <p>
+ * arr[]  = {9:00,  9:40, 9:50,  11:00, 15:00, 18:00}
+ * dep[]  = {9:10, 12:00, 11:20, 11:30, 19:00, 20:00}
+ * <p>
+ * Time complexity is O(n + nlog n).  n = traverse the array of n elements + nlogn (for sorting the array)
+ * Space Complexity: O(1).
+ * As no extra space is required.
+ * <p>
+ * dynamic programming is used to conserve memory.
+ */
+public class MinimumPlatforms_Greedy {
+
+    // Returns minimum number of platforms required
+    static int findPlatform(int arr[], int dep[], int n) {
+
+        /**important*/
+        // Sort arrival and departure arrays
+        Arrays.sort(arr);
+        Arrays.sort(dep);
+
+        // max_platforms_so_far indicates number of platforms needed at a time
+        int max_platforms_so_far = 1, needed_platforms = 1;
+        int i = 1, j = 0;
+
+        // Similar to merge in merge sort to process all events in sorted order
+        while (i < n && j < n) { /** end the loop when any one iterator completes any one array.*/
+            // If next event in sorted order is arrival,
+            // increment count of platforms needed
+            if (arr[i] <= dep[j])  /**means one more train can before any train could depart so increment the max_platfroms */ {
+                max_platforms_so_far++;
+                i++;
+
+                // Update result if needed
+                if (max_platforms_so_far > needed_platforms)
+                    needed_platforms = max_platforms_so_far;
+            }
+
+            // Else decrement count of platforms needed
+            else {
+                max_platforms_so_far--;
+                j++;
+            }
+        }
+
+        return needed_platforms;
+    }
+
+    // Driver program to test methods of graph class
+    public static void main(String[] args) {
+        int arr[] = {900, 940, 950, 1100, 1500, 1800};
+        int dep[] = {910, 1200, 1120, 1130, 1900, 2000};
+        int n = arr.length;
+        System.out.println("Minimum Number of Platforms Required = "
+                + findPlatform(arr, dep, n));
+    }
+}
+

src/main/images/KDistanceFromGivenNode4.png

@@ -1,75 +1,72 @@
 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
-
+ * '?' Matches any single character.
+ * '*' Matches any sequence of characters (including the empty sequence).
+ * <p>
+ * Input:
+ * s = "cb"
+ * p = "?a"
+ * Output: false
+ * Explanation: '?' matches 'c', but the second letter is 'a', which does not match 'b'.
+ * <p>
+ * 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 {
+    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 = true;
+                    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;
+        boolean T[][] = new boolean[str.length + 1][pattern.length + 1];
 
-            /**
-             * 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)
-             */
+        if (writeIndex > 0 && pattern[0] == '*') {
+            T[0][1] = 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];
-                    }
+        // 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];
         }
 
+        return T[str.length][pattern.length];
+    }
+
 
     public static void main(String args[]) {
         WildCardMatching wcm = new WildCardMatching();

src/main/images/KDistanceFromGivenNode5.png

@@ -0,0 +1,64 @@
+package com.linkedlist;
+
+import com.linkedlist.model.Node;
+
+import java.util.HashSet;
+import java.util.Set;
+
+/**
+ * Write a program to find the node at which the intersection of two singly linked lists begins.
+ *
+ * For example, the following two linked lists:
+ *
+ * Input: intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
+ * Output: Reference of the node with value = 8
+ * Input Explanation: The intersected node's value is 8 (note that this must not be 0 if the two lists intersect).
+ * From the head of A, it reads as [4,1,8,4,5]. From the head of B, it reads as [5,0,1,8,4,5].
+ * There are 2 nodes before the intersected node in A; There are 3 nodes before the intersected node in B.
+ *
+ * Notes
+ * If the two linked lists have no intersection at all, return null.
+ * The linked lists must retain their original structure after the function returns.
+ * You may assume there are no cycles anywhere in the entire linked structure.
+ * Your code should preferably run in O(n) time and use only O(1) memory.
+ *
+ */
+public class IntersectionOfTwoLinkedLists {
+
+    //Approach 2: Hash Table (10ms)
+    public Node getIntersectionNode(Node headA, Node headB) {
+        Set<Node> nodes = new HashSet<>();
+        Node pa = headA;
+        while (pa != null) {
+            nodes.add(pa);
+            pa = pa.next;
+        }
+        if (nodes.isEmpty()) {
+            return null;
+        }
+        Node pb = headB;
+        while (pb != null) {
+            if (nodes.contains(pb)) {
+                return pb;
+            }
+            pb = pb.next;
+        }
+        return null;
+    }
+
+    //Approach 3: Two Pointers (1ms)
+
+    public Node getIntersectionNode_1(Node headA, Node headB) {
+        Node pa = headA, pb = headB;
+        while (pa != pb) {
+            pa = (pa != null) ? pa.next : headB;
+            pb = (pb != null) ? pb.next : headA;
+        }
+        return pa;
+    }
+
+
+}
+
+
+

src/main/images/KDistanceFromGivenNode6.png

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