Solved Problems

Author: gouthampradhan

problems/src/array/AddToArrayFormOfInteger.java

@@ -0,0 +1,26 @@
+package heap;
+import java.math.BigInteger;
+import java.util.*;
+/**
+ * Created by gouthamvidyapradhan on 25/07/2019
+ */
+public class Task1 {
+  public static void main(String[] args) {
+    //
+  }
+
+    public List<Integer> addToArrayForm(int[] A, int K) {
+        StringBuilder sb = new StringBuilder();
+        for(int a : A){
+            sb.append(a);
+        }
+        BigInteger big  = new BigInteger(sb.toString());
+        BigInteger result = big.add(BigInteger.valueOf(K));
+        String resultStr = result.toString();
+        List<Integer> list = new ArrayList<>();
+        for(char a : resultStr.toCharArray()){
+            list.add(Integer.parseInt(String.valueOf(a)));
+        }
+        return list;
+    }
+}

problems/src/depth_first_search/SatisfiabilityOfEquations.java

@@ -0,0 +1,102 @@
+package heap;
+import java.util.*;
+/**
+ * Created by gouthamvidyapradhan on 25/07/2019 Given an array equations of strings that represent
+ * relationships between variables, each string equations[i] has length 4 and takes one of two
+ * different forms: "a==b" or "a!=b". Here, a and b are lowercase letters (not necessarily
+ * different) that represent one-letter variable names.
+ *
+ * <p>Return true if and only if it is possible to assign integers to variable names so as to
+ * satisfy all the given equations.
+ *
+ * <p>Example 1:
+ *
+ * <p>Input: ["a==b","b!=a"] Output: false Explanation: If we assign say, a = 1 and b = 1, then the
+ * first equation is satisfied, but not the second. There is no way to assign the variables to
+ * satisfy both equations. Example 2:
+ *
+ * <p>Input: ["b==a","a==b"] Output: true Explanation: We could assign a = 1 and b = 1 to satisfy
+ * both equations. Example 3:
+ *
+ * <p>Input: ["a==b","b==c","a==c"] Output: true Example 4:
+ *
+ * <p>Input: ["a==b","b!=c","c==a"] Output: false Example 5:
+ *
+ * <p>Input: ["c==c","b==d","x!=z"] Output: true
+ *
+ * <p>Note:
+ *
+ * <p>1 <= equations.length <= 500 equations[i].length == 4 equations[i][0] and equations[i][3] are
+ * lowercase letters equations[i][1] is either '=' or '!' equations[i][2] is '='
+ *
+ * Solution: O(N) For all the equations which are of the form 'a==b' form a graph of connected components. Start
+ * assigning values to each of the connected components. All the nodes in the connected components should have the
+ * same value assigned - If any of the connected components fails this criteria
+ * then return false.
+ */
+public class Task2 {
+  public static void main(String[] args) {
+      String[] input = {"c==c","f!=a","f==b","b==c"};
+    System.out.println(new Task2().equationsPossible(input));
+  }
+
+    private Set<Character> done;
+    private Map<Character, Integer> valueMap;
+    private int count = 0;
+    public boolean equationsPossible(String[] equations) {
+        Map<Character, List<Character>> graph = new HashMap<>();
+        done = new HashSet<>();
+        valueMap = new HashMap<>();
+        for(String eq : equations){
+            if(eq.charAt(1) == '='){
+                graph.putIfAbsent(eq.charAt(0), new ArrayList<>());
+                graph.get(eq.charAt(0)).add(eq.charAt(3));
+                graph.putIfAbsent(eq.charAt(3), new ArrayList<>());
+                graph.get(eq.charAt(3)).add(eq.charAt(0));
+
+            }
+        }
+        for(char c : graph.keySet()){
+            if(!done.contains(c)){
+                dfs(c, graph, ++count);
+            }
+        }
+
+        for(String eq : equations){
+            if(eq.charAt(1) == '!'){
+                char a = eq.charAt(0);
+                char b = eq.charAt(3);
+                if(a == b) return false;
+                if(valueMap.containsKey(a) && valueMap.containsKey(b)){
+                    if(valueMap.get(a).intValue() == valueMap.get(b).intValue()){
+                        return false;
+                    }
+                }
+            }
+        }
+        return true;
+    }
+
+
+    private boolean dfs(char node, Map<Character, List<Character>> graph, int value){
+        done.add(node);
+        valueMap.put(node, value);
+        List<Character> children = graph.get(node);
+        if(!children.isEmpty()){
+            for(char c : children){
+                if(!done.contains(c)){
+                    boolean status = dfs(c, graph, value);
+                    if(!status) {
+                        return status;
+                    }
+                } else{
+                    if(valueMap.get(c) != value){
+                        return false;
+                    }
+                }
+            }
+        }
+        return true;
+    }
+
+}

problems/src/greedy/BrokenCalculator.java

@@ -0,0 +1,58 @@
+package heap;
+import java.util.*;
+/**
+ * Created by gouthamvidyapradhan on 25/07/2019 On a broken calculator that has a number showing on
+ * its display, we can perform two operations:
+ *
+ * <p>Double: Multiply the number on the display by 2, or; Decrement: Subtract 1 from the number on
+ * the display. Initially, the calculator is displaying the number X.
+ *
+ * <p>Return the minimum number of operations needed to display the number Y.
+ *
+ * <p>Example 1:
+ *
+ * <p>Input: X = 2, Y = 3 Output: 2 Explanation: Use double operation and then decrement operation
+ * {2 -> 4 -> 3}. Example 2:
+ *
+ * <p>Input: X = 5, Y = 8 Output: 2 Explanation: Use decrement and then double {5 -> 4 -> 8}.
+ * Example 3:
+ *
+ * <p>Input: X = 3, Y = 10 Output: 3 Explanation: Use double, decrement and double {3 -> 6 -> 5 ->
+ * 10}. Example 4:
+ *
+ * <p>Input: X = 1024, Y = 1 Output: 1023 Explanation: Use decrement operations 1023 times.
+ *
+ * <p>Note:
+ *
+ * <p>1 <= X <= 10^9 1 <= Y <= 10^9
+ *
+ * Solution: O(log Y) Arrive at the solution by working backwards starting from Y.
+ * General idea is as follows.
+ * If Y is even then find the minimum steps required to arrive at Y by finding the quotient after dividing by 2. If Y
+ * is odd then find the minimum steps required to arrive at Y + 1 (even number) + 1 (to move backwards)
+ */
+public class BrokenCalculator {
+  public static void main(String[] args) {
+    //
+  }
+
+    public int brokenCalc(int X, int Y) {
+        if(X == Y) return 0;
+        else if(Y < X) return X - Y;
+        else {
+            int count = 0;
+            while(Y > X){
+                if(Y % 2 == 0){
+                    Y /= 2;
+                    count++;
+                } else{
+                    Y += 1;
+                    Y /= 2;
+                    count+=2;
+                }
+            }
+            if(X == Y) return count;
+            else return count + (X - Y);
+        }
+    }
+}

problems/src/string/PushDominoes.java

@@ -0,0 +1,75 @@
+package math;
+import java.util.*;
+/**
+ * Created by gouthamvidyapradhan on 24/07/2019 There are N dominoes in a line, and we place each
+ * domino vertically upright.
+ *
+ * <p>In the beginning, we simultaneously push some of the dominoes either to the left or to the
+ * right.
+ *
+ * <p>After each second, each domino that is falling to the left pushes the adjacent domino on the
+ * left.
+ *
+ * <p>Similarly, the dominoes falling to the right push their adjacent dominoes standing on the
+ * right.
+ *
+ * <p>When a vertical domino has dominoes falling on it from both sides, it stays still due to the
+ * balance of the forces.
+ *
+ * <p>For the purposes of this question, we will consider that a falling domino expends no
+ * additional force to a falling or already fallen domino.
+ *
+ * <p>Given a string "S" representing the initial state. S[i] = 'L', if the i-th domino has been
+ * pushed to the left; S[i] = 'R', if the i-th domino has been pushed to the right; S[i] = '.', if
+ * the i-th domino has not been pushed.
+ *
+ * <p>Return a string representing the final state.
+ *
+ * <p>Example 1:
+ *
+ * <p>Input: ".L.R...LR..L.." Output: "LL.RR.LLRRLL.." Example 2:
+ *
+ * <p>Input: "RR.L" Output: "RR.L" Explanation: The first domino expends no additional force on the
+ * second domino. Note:
+ *
+ * <p>0 <= N <= 10^5 String dominoes contains only 'L', 'R' and '.'
+ */
+public class Task2 {
+  public static void main(String[] args) {
+    System.out.println(new Task2().pushDominoes("RR.L"));
+  }
+
+    public String pushDominoes(String dominoes) {
+        int R = -1, L = -1;
+        char[] A = dominoes.toCharArray();
+        for(int i = 0; i < A.length; i ++){
+            if(A[i] == 'L'){
+                if(R > L){
+                    int d = (i - R);
+                    int st;
+                    st = R + d/2;
+                    if((d % 2) == 0){
+                        A[st] = '.';
+                    }
+                    for(int j = st + 1; j < i; j ++){
+                        A[j] = 'L';
+                    }
+                } else{
+                    for(int j = (L == -1 ? 0 : L); j < i; j ++){
+                        A[j] = 'L';
+                    }
+                }
+                L = i;
+            } else {
+                if(A[i] == 'R'){
+                    R = i;
+                } else{
+                    if(R > L){
+                        A[i] = 'R';
+                    }
+                }
+            }
+        }
+        return String.valueOf(A);
+    }
+}

problems/src/two_pointers/SubarraysWithKDifferentIntegers.java

@@ -0,0 +1,56 @@
+package two_pointers;
+/**
+ * Created by gouthamvidyapradhan on 25/07/2019 Given an array A of positive integers, call a
+ * (contiguous, not necessarily distinct) subarray of A good if the number of different integers in
+ * that subarray is exactly K.
+ *
+ * <p>(For example, [1,2,3,1,2] has 3 different integers: 1, 2, and 3.)
+ *
+ * <p>Return the number of good subarrays of A.
+ *
+ * <p>Example 1:
+ *
+ * <p>Input: A = [1,2,1,2,3], K = 2 Output: 7 Explanation: Subarrays formed with exactly 2 different
+ * integers: [1,2], [2,1], [1,2], [2,3], [1,2,1], [2,1,2], [1,2,1,2]. Example 2:
+ *
+ * <p>Input: A = [1,2,1,3,4], K = 3 Output: 3 Explanation: Subarrays formed with exactly 3 different
+ * integers: [1,2,1,3], [2,1,3], [1,3,4].
+ *
+ * <p>Note:
+ *
+ * <p>1 <= A.length <= 20000 1 <= A[i] <= A.length 1 <= K <= A.length
+ * Solution: O(N) General idea is to find subarraysWithKDistinct(A, atMost(K)) - subarraysWithKDistinct(A, atMost(K -
+ * 1)).
+ */
+public class Task4 {
+  public static void main(String[] args) {
+      int[] A = {1,2,1,2,3};
+      Task4 task = new Task4();
+    System.out.println(task.subarraysWithKDistinct(A, 2));
+  }
+
+    public int subarraysWithKDistinct(int[] A, int K) {
+      return calculate(A, K) - calculate(A, K - 1);
+    }
+
+    private int calculate(int[] A, int K) {
+        int count = 0;
+        int[] frequency = new int[A.length + 1];
+        int currCount = 0;
+        for(int i = 0, j = 0; i < A.length; i ++){
+            frequency[A[i]]++;
+            if(frequency[A[i]] == 1){
+                currCount ++;
+            }
+            while(currCount > K){
+                frequency[A[j]]--;
+                if(frequency[A[j]] == 0){
+                    currCount --;
+                }
+                j++;
+            }
+            count += (i - j + 1);
+        }
+        return count;
+    }
+}