@@ -49,6 +49,7 @@ My accepted leetcode solutions to some of the common interview problems.
 - [Surface Area of 3D Shapes](problems/src/array/SurfaceAreaOfThreeDShapes.java) (Easy)
 - [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)
 
 #### [Backtracking](problems/src/backtracking)
 
@@ -129,6 +130,7 @@ My accepted leetcode solutions to some of the common interview problems.
 - [ing the Safe](problems/src/depth_first_search/ingTheSafe.java) (Hard)
 - [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)
 
 #### [Design](problems/src/design)
 
@@ -226,6 +228,7 @@ My accepted leetcode solutions to some of the common interview problems.
 - [IPO](problems/src/greedy/IPO.java) (Hard)
 - [String Without AAA or BBB](problems/src/greedy/StringWithout3A3B.java) (Medium)
 - [Boats to Save People](problems/src/greedy/BoatsToSavePeople.java) (Medium)
+- [Broken Calculator](problems/src/greedy/BrokenCalculator.java) (Medium)
 
 #### [Hashing](problems/src/hashing)
 
@@ -341,6 +344,7 @@ My accepted leetcode solutions to some of the common interview problems.
 - [Split Concatenated Strings](problems/src/string/SplitConcatenatedStrings.java) (Medium)
 - [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)
 
 #### [Tree](problems/src/tree)
 
@@ -404,4 +408,5 @@ My accepted leetcode solutions to some of the common interview problems.
 - [Smallest Range](problems/src/two_pointers/SmallestRange.java) (Hard)
 - [Subarray Product Less Than K](problems/src/two_pointers/SubarrayProductLessThanK.java) (Medium)
 - [Number of Matching Subsequences](problems/src/two_pointers/NumberOfMatchingSubsequences.java) (Medium)
+- [Subarrays with K Different Integers](problems/src/two_pointers/SubarraysWithKDifferentIntegers.java) (Hard)
 

@@ -1,26 +1,50 @@
-package heap;
+package array;
+
 import java.math.BigInteger;
 import java.util.*;
+
 /**
 * Created by gouthamvidyapradhan on 25/07/2019
+*
+* <p>For a non-negative integer X, the array-form of X is an array of its digits in left to right
+* order. For example, if X = 1231, then the array form is [1,2,3,1].
+*
+* <p>Given the array-form A of a non-negative integer X, return the array-form of the integer X+K.
+*
+* <p>Example 1:
+*
+* <p>Input: A = [1,2,0,0], K = 34 Output: [1,2,3,4] Explanation: 1200 + 34 = 1234 Example 2:
+*
+* <p>Input: A = [2,7,4], K = 181 Output: [4,5,5] Explanation: 274 + 181 = 455 Example 3:
+*
+* <p>Input: A = [2,1,5], K = 806 Output: [1,0,2,1] Explanation: 215 + 806 = 1021 Example 4:
+*
+* <p>Input: A = [9,9,9,9,9,9,9,9,9,9], K = 1 Output: [1,0,0,0,0,0,0,0,0,0,0] Explanation:
+* 9999999999 + 1 = 10000000000
+*
+* <p>Note：
+*
+* <p>1 <= A.length <= 10000 0 <= A[i] <= 9 0 <= K <= 10000 If A.length > 1, then A[0] != 0
+*
+* <p>Solution: O(N) use BigInteger to add long numbers
 */
-public class Task1 {
+public class AddToArrayFormOfInteger {
 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;
+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;
+}
 }

@@ -1,5 +1,7 @@
-package heap;
+package depth_first_search;
+
 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
@@ -29,74 +31,72 @@
 * <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.
+* <p>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 class SatisfiabilityOfEquations {
 public static void main(String[] args) {
-String[] input = {"c==c","f!=a","f==b","b==c"};
-System.out.println(new Task2().equationsPossible(input));
+String[] input = {"c==c", "f!=a", "f==b", "b==c"};
+System.out.println(new SatisfiabilityOfEquations().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));
+private Set<Character> done;
+private Map<Character, Integer> valueMap;
+private int count = 0;
 
-}
-}
-for(char c : graph.keySet()){
-if(!done.contains(c)){
-dfs(c, graph, ++count);
-}
-}
+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;
-}
-}
-}
+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;
+}
 }
+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;
-}
-}
-}
+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;
+}
 }
-
+return true;
+}
 }

@@ -1,5 +1,7 @@
-package heap;
+package greedy;
+
 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:
@@ -26,33 +28,33 @@
 *
 * <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)
+* <p>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);
+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);
 }
+}
 }

@@ -1,5 +1,5 @@
-package math;
-import java.util.*;
+package string;
+
 /**
 * Created by gouthamvidyapradhan on 24/07/2019 There are N dominoes in a line, and we place each
 * domino vertically upright.
@@ -32,44 +32,44 @@
 * <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 '.'
+* <p>0 <= N <= 10^5 String dominoes contains only 'L', 'R' and '.' Solution: O(N)
 */
-public class Task2 {
+public class PushDominoes {
 public static void main(String[] args) {
-System.out.println(new Task2().pushDominoes("RR.L"));
+System.out.println(new PushDominoes().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';
-}
-}
-}
+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);
+}
 }
+return String.valueOf(A);
+}
 }