@@ -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)
 

@@ -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;
+}
+}

@@ -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;
+}
+}

@@ -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;
+}
+}

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