Solved Problems and code format

Author: gouthampradhan

README.md

@@ -53,6 +53,7 @@ My accepted leetcode solutions to some of the common interview problems.
 - [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)
+- [Reveal Cards In Increasing Order](problems/src/array/RevealCardsInIncreasingOrder.java) (Medium)
 
 #### [Backtracking](problems/src/backtracking)
 

problems/src/array/FindPivotIndex.java

@@ -1,4 +1,5 @@
 package array;
+
 import java.util.*;
 
 /**
@@ -27,39 +28,39 @@
  * <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.
+ * <p>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 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];
-            }
+  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;
+      if (i == nums.length - 1) {
+        r = 0;
+      } else {
+        r = right[i + 1];
+      }
+      if (l == r) return i;
     }
+    return -1;
+  }
 }

problems/src/array/LargestTimeForGivenDigits.java

@@ -18,8 +18,8 @@
  *
  * <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.
+ * <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) {
@@ -30,18 +30,18 @@ public static void main(String[] args) {
   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;
+    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){
+            if (value > max) {
               max = value;
               result = A[i] + "" + A[j] + ":" + A[k] + "" + A[l];
             }

problems/src/array/MinimumTimeDifference.java

@@ -1,4 +1,5 @@
 package array;
+
 import java.util.*;
 import java.util.stream.Collectors;
 
@@ -9,32 +10,38 @@
  * 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.
+ * <p>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");
+    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;
+  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/array/RevealCardsInIncreasingOrder.java

@@ -0,0 +1,62 @@
+package array;
+
+import java.util.ArrayDeque;
+import java.util.Arrays;
+
+/**
+ * Created by gouthamvidyapradhan on 12/08/2019 In a deck of cards, every card has a unique integer.
+ * You can order the deck in any order you want.
+ *
+ * <p>Initially, all the cards start face down (unrevealed) in one deck.
+ *
+ * <p>Now, you do the following steps repeatedly, until all cards are revealed:
+ *
+ * <p>Take the top card of the deck, reveal it, and take it out of the deck. If there are still
+ * cards in the deck, put the next top card of the deck at the bottom of the deck. If there are
+ * still unrevealed cards, go back to step 1. Otherwise, stop. Return an ordering of the deck that
+ * would reveal the cards in increasing order.
+ *
+ * <p>The first entry in the answer is considered to be the top of the deck.
+ *
+ * <p>Example 1:
+ *
+ * <p>Input: [17,13,11,2,3,5,7] Output: [2,13,3,11,5,17,7] Explanation: We get the deck in the order
+ * [17,13,11,2,3,5,7] (this order doesn't matter), and reorder it. After reordering, the deck starts
+ * as [2,13,3,11,5,17,7], where 2 is the top of the deck. We reveal 2, and move 13 to the bottom.
+ * The deck is now [3,11,5,17,7,13]. We reveal 3, and move 11 to the bottom. The deck is now
+ * [5,17,7,13,11]. We reveal 5, and move 17 to the bottom. The deck is now [7,13,11,17]. We reveal
+ * 7, and move 13 to the bottom. The deck is now [11,17,13]. We reveal 11, and move 17 to the
+ * bottom. The deck is now [13,17]. We reveal 13, and move 17 to the bottom. The deck is now [17].
+ * We reveal 17. Since all the cards revealed are in increasing order, the answer is correct.
+ *
+ * <p>Note:
+ *
+ * <p>1 <= A.length <= 1000 1 <= A[i] <= 10^6 A[i] != A[j] for all i != j
+ *
+ * <p>Solution: O(N) General idea is to start from the last element and build the array of element
+ * in the backwards order. Use a doubly-ended queue which allows you to poll from either end of a
+ * queue.
+ */
+public class RevealCardsInIncreasingOrder {
+  public static void main(String[] args) {
+    int[] A = {17, 13, 11, 2, 3, 5, 7};
+    int[] R = new RevealCardsInIncreasingOrder().deckRevealedIncreasing(A);
+  }
+
+  public int[] deckRevealedIncreasing(int[] deck) {
+    Arrays.sort(deck);
+    ArrayDeque<Integer> queue = new ArrayDeque<>();
+    for (int i = deck.length - 1; i >= 0; i--) {
+      queue.offer(deck[i]);
+      if (i == 0) break;
+      int temp = queue.pollFirst();
+      queue.offer(temp);
+    }
+    int[] answer = new int[deck.length];
+    int i = 0;
+    while (!queue.isEmpty()) {
+      answer[i++] = queue.pollLast();
+    }
+    return answer;
+  }
+}

problems/src/binary_search/MinimumWindowSubsequence.java

@@ -1,5 +1,7 @@
 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.
@@ -19,61 +21,63 @@
  * <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.
+ * <p>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);
-     }
+    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);
+    }
   }
 }