🎨 Format files (🛠️ from Github Actions)

rohankayan · Jul 21, 2022 · f1df6bf · f1df6bf
1 parent 0c52f59
commit f1df6bf
Show file tree

Hide file tree

Showing 374 changed files with 7,951 additions and 7,822 deletions.
diff --git a/java/1-Two-Sum.java b/java/1-Two-Sum.java
@@ -1,19 +1,19 @@
 class Solution {
 
-  public int[] twoSum(int[] nums, int target) {
-    HashMap<Integer, Integer> prevMap = new HashMap<>();
+    public int[] twoSum(int[] nums, int target) {
+        HashMap<Integer, Integer> prevMap = new HashMap<>();
 
-    for (int i = 0; i < nums.length; i++) {
-      int num = nums[i];
-      int diff = target - num;
+        for (int i = 0; i < nums.length; i++) {
+            int num = nums[i];
+            int diff = target - num;
 
-      if (prevMap.containsKey(nums[i])) {
-        return new int[] { prevMap.get(num), i };
-      }
+            if (prevMap.containsKey(nums[i])) {
+                return new int[] { prevMap.get(num), i };
+            }
 
-      prevMap.put(target - num, i);
-    }
+            prevMap.put(target - num, i);
+        }
 
-    return new int[] {};
-  }
+        return new int[] {};
+    }
 }
diff --git a/java/100-Same-Tree.java b/java/100-Same-Tree.java
@@ -17,24 +17,24 @@
  */
 class Solution {
 
-  public boolean isSameTree(TreeNode p, TreeNode q) {
-    return dfs(p, q);
-  }
-
-  private boolean dfs(TreeNode p, TreeNode q) {
-    if (p == null && q == null) {
-      return true;
+    public boolean isSameTree(TreeNode p, TreeNode q) {
+        return dfs(p, q);
     }
 
-    if (p == null || q == null) {
-      return false;
-    }
+    private boolean dfs(TreeNode p, TreeNode q) {
+        if (p == null && q == null) {
+            return true;
+        }
 
-    if (p.val != q.val) return false;
+        if (p == null || q == null) {
+            return false;
+        }
 
-    boolean left = dfs(p.left, q.left);
-    boolean right = dfs(p.right, q.right);
+        if (p.val != q.val) return false;
 
-    return left && right;
-  }
+        boolean left = dfs(p.left, q.left);
+        boolean right = dfs(p.right, q.right);
+
+        return left && right;
+    }
 }
diff --git a/java/102-Binary-Tree-Level-Order-Traversal.java b/java/102-Binary-Tree-Level-Order-Traversal.java
@@ -15,28 +15,28 @@
  */
 class Solution {
 
-  public List<List<Integer>> levelOrder(TreeNode root) {
-    List<List<Integer>> res = new ArrayList<>();
-    Queue<TreeNode> queue = new LinkedList<>();
+    public List<List<Integer>> levelOrder(TreeNode root) {
+        List<List<Integer>> res = new ArrayList<>();
+        Queue<TreeNode> queue = new LinkedList<>();
 
-    if (root == null) return res;
+        if (root == null) return res;
 
-    queue.add(root);
-    while (!queue.isEmpty()) {
-      int len = queue.size();
-      List<Integer> level = new ArrayList<>();
-      for (int i = 0; i < len; i++) {
-        TreeNode curr = queue.poll();
-        level.add(curr.val);
-        if (curr.left != null) {
-          queue.add(curr.left);
+        queue.add(root);
+        while (!queue.isEmpty()) {
+            int len = queue.size();
+            List<Integer> level = new ArrayList<>();
+            for (int i = 0; i < len; i++) {
+                TreeNode curr = queue.poll();
+                level.add(curr.val);
+                if (curr.left != null) {
+                    queue.add(curr.left);
+                }
+                if (curr.right != null) {
+                    queue.add(curr.right);
+                }
+            }
+            res.add(level);
         }
-        if (curr.right != null) {
-          queue.add(curr.right);
-        }
-      }
-      res.add(level);
+        return res;
     }
-    return res;
-  }
 }
diff --git a/java/104-Maximum-Depth-of-Binary-Tree.java b/java/104-Maximum-Depth-of-Binary-Tree.java
@@ -1,7 +1,7 @@
 class Solution {
 
-  public int maxDepth(TreeNode root) {
-    if (root == null) return 0;
-    return 1 + Math.max(maxDepth(root.left), maxDepth(root.right));
-  }
+    public int maxDepth(TreeNode root) {
+        if (root == null) return 0;
+        return 1 + Math.max(maxDepth(root.left), maxDepth(root.right));
+    }
 }
diff --git a/java/1046-Last-Stone-Weight.java b/java/1046-Last-Stone-Weight.java
@@ -1,13 +1,13 @@
 class Solution {
 
-  public int lastStoneWeight(int[] stones) {
-    PriorityQueue<Integer> maxHeap = new PriorityQueue();
-    for (int stone : stones) maxHeap.add(-stone);
-    while (maxHeap.size() > 1) {
-      int stone1 = maxHeap.remove();
-      int stone2 = maxHeap.remove();
-      if (stone1 != stone2) maxHeap.add(stone1 - stone2);
+    public int lastStoneWeight(int[] stones) {
+        PriorityQueue<Integer> maxHeap = new PriorityQueue();
+        for (int stone : stones) maxHeap.add(-stone);
+        while (maxHeap.size() > 1) {
+            int stone1 = maxHeap.remove();
+            int stone2 = maxHeap.remove();
+            if (stone1 != stone2) maxHeap.add(stone1 - stone2);
+        }
+        return maxHeap.size() != 0 ? (-maxHeap.remove()) : 0;
     }
-    return maxHeap.size() != 0 ? (-maxHeap.remove()) : 0;
-  }
 }
diff --git a/java/105-Construct-Binary-Tree-from-Preorder-and-Inorder-Traversal.java b/java/105-Construct-Binary-Tree-from-Preorder-and-Inorder-Traversal.java
@@ -15,68 +15,68 @@
  */
 class Solution {
 
-  public TreeNode buildTree(int[] preorder, int[] inorder) {
-    if (preorder.length == 0 || inorder.length == 0) return null;
+    public TreeNode buildTree(int[] preorder, int[] inorder) {
+        if (preorder.length == 0 || inorder.length == 0) return null;
 
-    TreeNode root = new TreeNode(preorder[0]);
-    int mid = 0;
-    for (int i = 0; i < inorder.length; i++) {
-      if (preorder[0] == inorder[i]) mid = i;
-    }
+        TreeNode root = new TreeNode(preorder[0]);
+        int mid = 0;
+        for (int i = 0; i < inorder.length; i++) {
+            if (preorder[0] == inorder[i]) mid = i;
+        }
 
-    root.left =
-      buildTree(
-        Arrays.copyOfRange(preorder, 1, mid + 1),
-        Arrays.copyOfRange(inorder, 0, mid)
-      );
-    root.right =
-      buildTree(
-        Arrays.copyOfRange(preorder, mid + 1, preorder.length),
-        Arrays.copyOfRange(inorder, mid + 1, inorder.length)
-      );
+        root.left =
+            buildTree(
+                Arrays.copyOfRange(preorder, 1, mid + 1),
+                Arrays.copyOfRange(inorder, 0, mid)
+            );
+        root.right =
+            buildTree(
+                Arrays.copyOfRange(preorder, mid + 1, preorder.length),
+                Arrays.copyOfRange(inorder, mid + 1, inorder.length)
+            );
 
-    return root;
-  }
+        return root;
+    }
 }
 
 // Solution without using Array copies
 class Solution {
 
-  Map<Integer, Integer> inorderPositions = new HashMap<>();
+    Map<Integer, Integer> inorderPositions = new HashMap<>();
 
-  public TreeNode buildTree(int[] preorder, int[] inorder) {
-    if (preorder.length < 1 || inorder.length < 1) return null;
+    public TreeNode buildTree(int[] preorder, int[] inorder) {
+        if (preorder.length < 1 || inorder.length < 1) return null;
 
-    for (int i = 0; i < inorder.length; i++) {
-      inorderPositions.put(inorder[i], i);
-    }
+        for (int i = 0; i < inorder.length; i++) {
+            inorderPositions.put(inorder[i], i);
+        }
 
-    return builder(preorder, 0, 0, inorder.length - 1);
-  }
+        return builder(preorder, 0, 0, inorder.length - 1);
+    }
 
-  public TreeNode builder(
-    int[] preorder,
-    int preorderIndex,
-    int inorderLow,
-    int inorderHigh
-  ) {
-    if (
-      preorderIndex > preorder.length - 1 || inorderLow > inorderHigh
-    ) return null;
+    public TreeNode builder(
+        int[] preorder,
+        int preorderIndex,
+        int inorderLow,
+        int inorderHigh
+    ) {
+        if (
+            preorderIndex > preorder.length - 1 || inorderLow > inorderHigh
+        ) return null;
 
-    int currentVal = preorder[preorderIndex];
-    TreeNode n = new TreeNode(currentVal);
-    int mid = inorderPositions.get(currentVal);
+        int currentVal = preorder[preorderIndex];
+        TreeNode n = new TreeNode(currentVal);
+        int mid = inorderPositions.get(currentVal);
 
-    n.left = builder(preorder, preorderIndex + 1, inorderLow, mid - 1);
-    n.right =
-      builder(
-        preorder,
-        preorderIndex + (mid - inorderLow) + 1,
-        mid + 1,
-        inorderHigh
-      );
+        n.left = builder(preorder, preorderIndex + 1, inorderLow, mid - 1);
+        n.right =
+            builder(
+                preorder,
+                preorderIndex + (mid - inorderLow) + 1,
+                mid + 1,
+                inorderHigh
+            );
 
-    return n;
-  }
+        return n;
+    }
 }
diff --git a/java/106-Construct-Binary-Tree-from-Inorder-and-Postorder-Traversal.java b/java/106-Construct-Binary-Tree-from-Inorder-and-Postorder-Traversal.java
@@ -2,57 +2,57 @@
 
 class Solution {
 
-  public TreeNode buildTree(int[] inorder, int[] postorder) {
-    HashMap<Integer, Integer> inMap = new HashMap<>();
-    for (int i = 0; i < inorder.length; i++) {
-      inMap.put(inorder[i], i);
+    public TreeNode buildTree(int[] inorder, int[] postorder) {
+        HashMap<Integer, Integer> inMap = new HashMap<>();
+        for (int i = 0; i < inorder.length; i++) {
+            inMap.put(inorder[i], i);
+        }
+        return helper(
+            inorder,
+            0,
+            inorder.length - 1,
+            postorder,
+            0,
+            postorder.length - 1,
+            inMap
+        );
     }
-    return helper(
-      inorder,
-      0,
-      inorder.length - 1,
-      postorder,
-      0,
-      postorder.length - 1,
-      inMap
-    );
-  }
 
-  public TreeNode helper(
-    int[] inorder,
-    int iStart,
-    int iEnd,
-    int[] postorder,
-    int pStart,
-    int pEnd,
-    HashMap<Integer, Integer> inMap
-  ) {
-    if (pStart > pEnd || iStart > iEnd) {
-      return null;
+    public TreeNode helper(
+        int[] inorder,
+        int iStart,
+        int iEnd,
+        int[] postorder,
+        int pStart,
+        int pEnd,
+        HashMap<Integer, Integer> inMap
+    ) {
+        if (pStart > pEnd || iStart > iEnd) {
+            return null;
+        }
+        TreeNode root = new TreeNode(postorder[pEnd]);
+        int index = inMap.get(postorder[pEnd]);
+        int numsLeft = index - iStart;
+        root.left =
+            helper(
+                inorder,
+                iStart,
+                index - 1,
+                postorder,
+                pStart,
+                pStart + numsLeft - 1,
+                inMap
+            );
+        root.right =
+            helper(
+                inorder,
+                index + 1,
+                iEnd,
+                postorder,
+                pStart + numsLeft,
+                pEnd - 1,
+                inMap
+            );
+        return root;
     }
-    TreeNode root = new TreeNode(postorder[pEnd]);
-    int index = inMap.get(postorder[pEnd]);
-    int numsLeft = index - iStart;
-    root.left =
-      helper(
-        inorder,
-        iStart,
-        index - 1,
-        postorder,
-        pStart,
-        pStart + numsLeft - 1,
-        inMap
-      );
-    root.right =
-      helper(
-        inorder,
-        index + 1,
-        iEnd,
-        postorder,
-        pStart + numsLeft,
-        pEnd - 1,
-        inMap
-      );
-    return root;
-  }
 }