Solved Problems

Author: gouthampradhan

README.md

@@ -50,6 +50,9 @@ My accepted leetcode solutions to some of the common interview problems.
 - [Max Consecutive Ones](problems/src/array/MaxConsecutiveOnes.java) (Easy)
 - [Max Consecutive Ones II](problems/src/array/MaxConsecutiveOnesII.java) (Medium)
 - [Add to Array-Form of Integer](problems/src/array/AddToArrayFormOfInteger.java) (Easy)
+- [Find Pivot Index](problems/src/array/FindPivotIndex.java) (Easy)
+- [Largest Time for Given Digits](problems/src/array/LargestTimeForGivenDigits.java) (Easy)
+- [Minimum Time Difference](problems/src/array/MinimumTimeDifference.java) (Medium)
 
 #### [Backtracking](problems/src/backtracking)
 
@@ -87,6 +90,7 @@ My accepted leetcode solutions to some of the common interview problems.
 - [H-Index II](problems/src/binary_search/HIndexII.java) (Medium)
 - [Swim in Rising Water](problems/src/binary_search/SwimInRisingWater.java) (Hard)
 - [Time Based Key-Value Store](problems/src/binary_search/TimeBasedKeyValuePair.java) (Medium)
+- [Minimum Window Subsequence](problems/src/binary_search/MinimumWindowSubsequence.java) (Hard)
 
 #### [Bit Manipulation](problems/src/bit_manipulation)
 
@@ -131,6 +135,7 @@ My accepted leetcode solutions to some of the common interview problems.
 - [All Paths From Source to Target](problems/src/depth_first_search/AllPathsFromSourceToTarget.java) (Medium)
 - [Max Area of Island](problems/src/depth_first_search/MaxAreaOfIsland.java) (Medium)
 - [Satisfiability of Equality Equations](problems/src/depth_first_search/SatisfiabilityOfEquations.java) (Medium)
+- [Number of Enclaves](problems/src/depth_first_search/NumberOfEnclaves.java) (Medium)
 
 #### [Design](problems/src/design)
 
@@ -157,6 +162,7 @@ My accepted leetcode solutions to some of the common interview problems.
 - [Reverse Pairs](problems/src/divide_and_conquer/ReversePairs.java) (Hard)
 - [Search in a 2D Matrix](problems/src/divide_and_conquer/SearchA2DMatrix.java) (Medium)
 - [24 Game](problems/src/divide_and_conquer/TwentyFourGame.java) (Hard)
+- [Reverse Pairs II](problems/src/divide_and_conquer/ReversePairsII.java) (Hard)
 
 #### [Dynamic Programming](problems/src/dynamic_programming)
 
@@ -211,6 +217,7 @@ My accepted leetcode solutions to some of the common interview problems.
 - [Out of Boundary Paths](problems/src/dynamic_programming/OutOfBoundaryPaths.java) (Medium)
 - [Remove Boxes](problems/src/dynamic_programming/RemoveBoxes.java) (Hard)
 - [Stickers to Spell Word](problems/src/dynamic_programming/StickersToSpellWord.java) (Hard)
+- [Ones and Zeroes](problems/src/dynamic_programming/OnesAndZeroes.java) (Medium)
 
 #### [Greedy](problems/src/greedy)
 
@@ -247,6 +254,7 @@ My accepted leetcode solutions to some of the common interview problems.
 - [Substring with Concatenation of All Words](problems/src/hashing/SubstringConcatenationOfWords.java) (Hard)
 - [Distribute Candies](problems/src/hashing/DistributeCandies.java) (Easy)
 - [Groups of Special-Equivalent Strings](problems/src/hashing/GroupsOfSpecialEquivalentStrings.java) (Easy)
+- [Number of Atoms](problems/src/hashing/NumberOfAtoms.java) (Hard)
 
 #### [Heap](problems/src/heap)
 
@@ -271,6 +279,8 @@ My accepted leetcode solutions to some of the common interview problems.
 - [Reverse Nodes in k-Group](problems/src/linked_list/ReverseNodesKGroup.java) (Hard)
 - [Swap Nodes in Pairs](problems/src/linked_list/SwapNodesInPairs.java) (Medium)
 - [Middle of Linked List](problems/src/linked_list/MiddleOfLinkedList.java) (Easy)
+- [Split Linked List in Parts](problems/src/linked_list/SplitLinkedListInParts.java) (Medium)
+- [Next Greater Node In Linked List](problems/src/linked_list/NextGreaterNodeInLinkedList.java) (Medium)
 
 #### [Math](problems/src/math)
 
@@ -290,6 +300,7 @@ My accepted leetcode solutions to some of the common interview problems.
 - [Squirrel Simulation](problems/src/math/SquirrelSimulation.java) (Medium)
 - [Projection Area of 3D Shapes](problems/src/math/ProjectionAreaOf3DShapes.java) (Easy)
 - [Decoded String at Index](problems/src/math/DecodedStringAtIndex.java) (Medium)
+- [Base 7](problems/src/math/Base7.java) (Easy)
 
 #### [Reservoir Sampling](problems/src/reservoir_sampling)
 
@@ -345,6 +356,8 @@ My accepted leetcode solutions to some of the common interview problems.
 - [Valid Word Square](problems/src/string/ValidWordSquare.java) (Easy)
 - [Reconstruct Original Digits from English](problems/src/string/ReconstructOriginalDigitsFromEnglish.java) (Medium)
 - [Push Dominoes](problems/src/string/PushDominoes.java) (Medium)
+- [Validate IP Address](problems/src/string/ValidateIPAddress.java) (Medium)
+- [Reverse String II](problems/src/string/ReverseStringII.java) (Easy)
 
 #### [Tree](problems/src/tree)
 
@@ -380,7 +393,7 @@ My accepted leetcode solutions to some of the common interview problems.
 - [Average of Levels in Binary Tree](problems/src/tree/AverageOfLevelsInBinaryTree.java) (Easy)
 - [Convert Binary Search Tree to Sorted Doubly Linked List](problems/src/tree/BSTtoDoublyLinkedList.java) (Easy)
 - [Same Tree](problems/src/tree/SameTree.java) (Easy)
-- [Binary Tree Longest Consecutive Sequence II](problems/src/tree/BinaryTreeLongestConsecutiveSequenceII.java) (Medium)
+- [Binary Tree Longest Consecutive SequencefindMinDifference II](problems/src/tree/BinaryTreeLongestConsecutiveSequenceII.java) (Medium)
 - [Minimum Absolute Difference in BST](problems/src/tree/MinimumAbsoluteDifferenceInBST.java) (Medium)
 - [Equal Tree Partition](problems/src/tree/EqualTreePartition.java) (Medium)
 - [Split BST](problems/src/tree/SplitBST.java) (Medium)
@@ -392,6 +405,10 @@ My accepted leetcode solutions to some of the common interview problems.
 - [Convert BST to Greater Tree](problems/src/tree/ConvertBSTToGreaterTree.java) (Easy)
 - [All Nodes Distance K in Binary Tree](problems/src/tree/AllNodesDistanceKInBinaryTree.java) (Medium)
 - [All Possible Full Binary Trees](problems/src/tree/AllPossibleFullBinaryTrees.java) (Medium)
+- [Flip Equivalent Binary Trees](problems/src/tree/FlipEquivalentBinaryTrees.java) (Medium)
+- [Construct Binary Tree from String](problems/src/tree/ConstructBinaryTreefromString.java) (Medium)
+- [Find Largest Value in Each Tree Row](problems/src/tree/FindLargestValueInEachTreeRow.java) (Medium)
+- [Find Bottom Left Tree Value](problems/src/tree/FindBottomLeftTreeValue.java) (Medium)
 
 #### [Two Pointers](problems/src/two_pointers)
 

problems/src/array/FindPivotIndex.java

@@ -0,0 +1,65 @@
+package array;
+import java.util.*;
+
+/**
+ * Created by gouthamvidyapradhan on 06/08/2019 Given an array of integers nums, write a method that
+ * returns the "pivot" index of this array.
+ *
+ * <p>We define the pivot index as the index where the sum of the numbers to the left of the index
+ * is equal to the sum of the numbers to the right of the index.
+ *
+ * <p>If no such index exists, we should return -1. If there are multiple pivot indexes, you should
+ * return the left-most pivot index.
+ *
+ * <p>Example 1:
+ *
+ * <p>Input: nums = [1, 7, 3, 6, 5, 6] Output: 3 Explanation: The sum of the numbers to the left of
+ * index 3 (nums[3] = 6) is equal to the sum of numbers to the right of index 3. Also, 3 is the
+ * first index where this occurs.
+ *
+ * <p>Example 2:
+ *
+ * <p>Input: nums = [1, 2, 3] Output: -1 Explanation: There is no index that satisfies the
+ * conditions in the problem statement.
+ *
+ * <p>Note:
+ *
+ * <p>The length of nums will be in the range [0, 10000]. Each element nums[i] will be an integer in
+ * the range [-1000, 1000].
+ *
+ * Solution: O(N) maintain a prefix and posfix sum array and then use this to arrive at the answer.
+ */
+public class FindPivotIndex {
+  public static void main(String[] args) {
+  }
+
+    public int pivotIndex(int[] nums) {
+      if(nums.length == 1) return 0;
+        int[] left = new int[nums.length];
+        int[] right = new int[nums.length];
+        left[0] = nums[0];
+        for(int i = 1; i < nums.length; i ++){
+            left[i] = left[i - 1] + nums[i];
+        }
+        right[nums.length - 1] = nums[nums.length - 1];
+        for(int i = nums.length - 2; i >= 0; i --){
+            right[i] = right[i + 1] + nums[i];
+        }
+        for(int i = 0; i < nums.length; i ++){
+            int l, r;
+            if(i == 0){
+                l = 0;
+            } else {
+                l = left[i - 1];
+            }
+
+            if(i == nums.length - 1){
+                r = 0;
+            } else {
+                r = right[i + 1];
+            }
+            if(l == r) return i;
+        }
+        return -1;
+    }
+}

problems/src/array/LargestTimeForGivenDigits.java

@@ -0,0 +1,54 @@
+package array;
+
+/**
+ * Created by gouthamvidyapradhan on 06/08/2019 Given an array of 4 digits, return the largest 24
+ * hour time that can be made.
+ *
+ * <p>The smallest 24 hour time is 00:00, and the largest is 23:59. Starting from 00:00, a time is
+ * larger if more time has elapsed since midnight.
+ *
+ * <p>Return the answer as a string of length 5. If no valid time can be made, return an empty
+ * string.
+ *
+ * <p>Example 1:
+ *
+ * <p>Input: [1,2,3,4] Output: "23:41" Example 2:
+ *
+ * <p>Input: [5,5,5,5] Output: ""
+ *
+ * <p>Note:
+ *
+ * <p>A.length == 4 0 <= A[i] <= 9
+ * Solution O(N ^ 4) Check all combinations of time possible and return the maximum possible as the answer.
+ */
+public class LargestTimeForGivenDigits {
+  public static void main(String[] args) {
+    int[] A = {2, 0, 6, 6};
+    System.out.println(new LargestTimeForGivenDigits().largestTimeFromDigits(A));
+  }
+
+  public String largestTimeFromDigits(int[] A) {
+    int max = -1;
+    String result = "";
+    for(int i = 0; i < A.length; i ++){
+      if(A[i] > 2) continue;
+      for(int j = 0; j < A.length; j ++){
+        if(j == i) continue;
+        if(A[i] == 2 && A[j] > 3) continue;
+        for(int k = 0; k < A.length; k ++){
+          if(k == i || k == j) continue;
+          if(A[k] > 5) continue;
+          for(int l = 0; l < A.length; l ++){
+            if(l == i || l == j || l == k) continue;
+            int value = ((A[i] * 10 + A[j]) * 60) + A[k] * 10 + A[l];
+            if(value > max){
+              max = value;
+              result = A[i] + "" + A[j] + ":" + A[k] + "" + A[l];
+            }
+          }
+        }
+      }
+    }
+    return result;
+  }
+}

problems/src/array/MinimumTimeDifference.java

@@ -0,0 +1,40 @@
+package array;
+import java.util.*;
+import java.util.stream.Collectors;
+
+/**
+ * Created by gouthamvidyapradhan on 30/07/2019 Given a list of 24-hour clock time points in
+ * "Hour:Minutes" format, find the minimum minutes difference between any two time points in the
+ * list. Example 1: Input: ["23:59","00:00"] Output: 1 Note: The number of time points in the given
+ * list is at least 2 and won't exceed 20000. The input time is legal and ranges from 00:00 to
+ * 23:59.
+ *
+ * Solution: O(N log N) convert each time value of the form hh:mm to minutes and sort the array. For every pair (i,
+ * j) where j = i + 1 (also for the case where i = 0 and j = N - 1) check the minute difference and return the
+ * minimum time difference as the answer.
+ */
+public class MinimumTimeDifference {
+  public static void main(String[] args) {
+    List<String> list = Arrays.asList("23:59","00:00");
+    System.out.println(new MinimumTimeDifference().findMinDifference(list));
+  }
+
+    public int findMinDifference(List<String> timePoints) {
+        List<Integer> timeInMinutes = timePoints.stream().map(t -> {
+            String[] strings = t.split(":");
+            return Integer.parseInt(strings[0]) * 60 + Integer.parseInt(strings[1]);
+        }).sorted(Integer::compareTo).collect(Collectors.toList());
+        int min = Integer.MAX_VALUE;
+        for(int i = 1, l = timeInMinutes.size(); i < l; i ++){
+            int prev = timeInMinutes.get(i - 1);
+            int curr = timeInMinutes.get(i);
+            min = Math.min(min, curr - prev);
+            min = Math.min(min, ((24 * 60) - curr) + prev);
+        }
+        int prev = timeInMinutes.get(0);
+        int curr = timeInMinutes.get(timeInMinutes.size() - 1);
+        min = Math.min(min, curr - prev);
+        min = Math.min(min, ((24 * 60) - curr) + prev);
+        return min;
+    }
+}

problems/src/binary_search/MinimumWindowSubsequence.java

@@ -0,0 +1,79 @@
+package binary_search;
+import java.util.*;
+/**
+ * Created by gouthamvidyapradhan on 06/08/2019 Given strings S and T, find the minimum (contiguous)
+ * substring W of S, so that T is a subsequence of W.
+ *
+ * <p>If there is no such window in S that covers all characters in T, return the empty string "".
+ * If there are multiple such minimum-length windows, return the one with the left-most starting
+ * index.
+ *
+ * <p>Example 1:
+ *
+ * <p>Input: S = "abcdebdde", T = "bde" Output: "bcde" Explanation: "bcde" is the answer because it
+ * occurs before "bdde" which has the same length. "deb" is not a smaller window because the
+ * elements of T in the window must occur in order.
+ *
+ * <p>Note:
+ *
+ * <p>All the strings in the input will only contain lowercase letters. The length of S will be in
+ * the range [1, 20000]. The length of T will be in the range [1, 100].
+ *
+ * Solution O(S x T x log S) General idea is to first find the left-most left (l) and right (r) index where r - l is
+ * minimum and the minimum window contains the sub-sequence and iteratively check the next left-most indices and
+ * continue for the entire string S. A naive implementation would result in O(S ^ 2)
+ * therefore to speed up we have to maintain a hashtable of character as key and all its index of occurrence in a
+ * sorted list. Now, since this list is sorted we can easily find the next left-most by binarySearch or even better
+ * by using a TreeSet higher or ceil function.
+ */
+public class MinimumWindowSubsequence {
+  public static void main(String[] args) {
+    System.out.println(new MinimumWindowSubsequence().minWindow("abcdebdde", "x"));
+  }
+
+  public String minWindow(String S, String T) {
+      if(T.isEmpty() || S.isEmpty()) return "";
+     Map<Character, TreeSet<Integer>> charMap = new HashMap<>();
+     for(int i = 0, l = S.length(); i < l; i ++){
+         char c = S.charAt(i);
+         charMap.putIfAbsent(c, new TreeSet<>());
+         charMap.get(c).add(i);
+     }
+     int min = Integer.MAX_VALUE;
+     int start = -1, end;
+     int ansStart = -1, ansEnd = -1;
+     boolean finished = false;
+     while(true){
+         int index = start;
+         end = -1;
+         for(int i = 0, l = T.length(); i < l; i ++){
+             char c = T.charAt(i);
+             if(!charMap.containsKey(c)){
+                 return "";
+             } else{
+                 TreeSet<Integer> indicies = charMap.get(c);
+                 Integer found = indicies.higher(index);
+                 if(found == null){
+                     finished = true;
+                     break;
+                 } else{
+                     index = found;
+                     if(i == 0){
+                         start = index;
+                     } if(i == l - 1){
+                         end = index;
+                     }
+                 }
+             }
+         }
+         if(start != -1 && end != -1){
+             if((end - start) < min){
+                 min = end - start;
+                 ansStart = start;
+                 ansEnd = end;
+             }
+         }
+         if(finished) return ansStart == -1 ? "" : S.substring(ansStart, ansEnd + 1);
+     }
+  }
+}