From df0a087491cd52a1f0cfec5e22ef09a135d8ea83 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 27 Nov 2022 07:57:29 -0800 Subject: [PATCH 001/712] Create Append Characters to String to Make Subsequence.java --- ...nd Characters to String to Make Subsequence.java | 13 +++++++++++++ 1 file changed, 13 insertions(+) create mode 100644 Medium/Append Characters to String to Make Subsequence.java diff --git a/Medium/Append Characters to String to Make Subsequence.java b/Medium/Append Characters to String to Make Subsequence.java new file mode 100644 index 00000000..af35ca3d --- /dev/null +++ b/Medium/Append Characters to String to Make Subsequence.java @@ -0,0 +1,13 @@ +class Solution { + public int appendCharacters(String s, String t) { + int idxS = 0; + int idxT = 0; + while (idxS < s.length() && idxT < t.length()) { + if (s.charAt(idxS) == t.charAt(idxT)) { + idxT++; + } + idxS++; + } + return idxT == t.length() ? 0 : t.length() - idxT; + } +} From cbe46171937d1765f96c60fff58e4c143c9b2f52 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 27 Nov 2022 17:45:33 -0800 Subject: [PATCH 002/712] Create Remove Nodes From Linked List.java --- Medium/Remove Nodes From Linked List.java | 40 +++++++++++++++++++++++ 1 file changed, 40 insertions(+) create mode 100644 Medium/Remove Nodes From Linked List.java diff --git a/Medium/Remove Nodes From Linked List.java b/Medium/Remove Nodes From Linked List.java new file mode 100644 index 00000000..850e4da0 --- /dev/null +++ b/Medium/Remove Nodes From Linked List.java @@ -0,0 +1,40 @@ +/** + * Definition for singly-linked list. + * public class ListNode { + * int val; + * ListNode next; + * ListNode() {} + * ListNode(int val) { this.val = val; } + * ListNode(int val, ListNode next) { this.val = val; this.next = next; } + * } + */ +class Solution { + public ListNode removeNodes(ListNode head) { + ListNode revNode = reverse(head); + ListNode curr = revNode; + ListNode prev = null; + int maxValue = Integer.MIN_VALUE; + while (curr != null) { + if (curr.val < maxValue) { + prev.next = curr.next; + } else { + prev = curr; + maxValue = Math.max(curr.val, maxValue); + } + curr = curr.next; + } + return reverse(revNode); + } + + private ListNode reverse(ListNode node) { + ListNode curr = node; + ListNode prev = null; + while (curr != null) { + ListNode next = curr.next; + curr.next = prev; + prev = curr; + curr = next; + } + return prev; + } +} From 9bb3ac3b04c648b30d94067e777f2cd3351e992d Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Mon, 28 Nov 2022 07:04:59 -0800 Subject: [PATCH 003/712] Update Design Snake Game.java --- Medium/Design Snake Game.java | 137 +++++++++++++++------------------- 1 file changed, 62 insertions(+), 75 deletions(-) diff --git a/Medium/Design Snake Game.java b/Medium/Design Snake Game.java index e4185474..dd645d15 100644 --- a/Medium/Design Snake Game.java +++ b/Medium/Design Snake Game.java @@ -1,87 +1,74 @@ class SnakeGame { - - private final int width; - private final int height; - private final Set> body; - private final Deque> bodyQueue; - private final Queue> foodQueue; - private int foodPoint; - - public SnakeGame(int width, int height, int[][] food) { - this.width = width; - this.height = height; - this.body = new HashSet<>(); - this.bodyQueue = new LinkedList<>(); - this.body.add(new Pair(0, 0)); - this.bodyQueue.add(new Pair(0, 0)); - this.foodQueue = new LinkedList<>(); - for (int[] fd : food) { - foodQueue.add(new Pair(fd[0], fd[1])); + private final Deque snake; + private final Queue foodQueue; + private final Set snakeBody; + private final int width; + private final int height; + private int score; + + public SnakeGame(int width, int height, int[][] food) { + this.snake = new ArrayDeque<>(); + this.snake.addFirst(new int[]{0, 0}); + this.foodQueue = new LinkedList<>(); + this.foodQueue.addAll(Arrays.asList(food)); + this.snakeBody = new HashSet<>(); + this.snakeBody.add(0 + "|" + 0); + this.width = width; + this.height = height; + this.score = 0; } - this.foodPoint = 0; - } - - public int move(String direction) { - Pair currPosition = bodyQueue.peekLast(); - Pair nextPosition = move(currPosition, direction); - if (!isSnakeAlive(nextPosition)) { - return -1; + + public int move(String direction) { + int[] nextMove = getNextMove(direction); + if (!isMoveWithInBound(nextMove)) { + return -1; + } + moveSnake(nextMove); + if (isBitingItself(nextMove)) { + return -1; + } + this.snakeBody.add(nextMove[0] + "|" + nextMove[1]); + return score; } - if (!snakeAteFood(nextPosition)) { - body.remove(bodyQueue.pollFirst()); - bodyQueue.addLast(nextPosition); - body.add(nextPosition); + + private int[] getNextMove(String direction) { + int[] nextMove = Arrays.copyOf(this.snake.peekFirst(), 2); + switch (direction) { + case "L" -> nextMove[1]--; + case "R" -> nextMove[1]++; + case "U" -> nextMove[0]--; + case "D" -> nextMove[0]++; + default -> {} + } + return nextMove; } - return foodPoint; - } - - private Pair move(Pair currPosition, String direction) { - int row = currPosition.getKey(); - int col = currPosition.getValue(); - switch (direction) { - case "U": - row--; - break; - case "D": - row++; - break; - case "L": - col--; - break; - case "R": - col++; - break; - default: - break; + + private boolean isMoveWithInBound(int[] move) { + int x = move[0]; + int y = move[1]; + return x >= 0 && y >= 0 && x < this.height && y < this.width; } - return new Pair(row, col); - } - - private boolean isSnakeAlive(Pair position) { - int row = position.getKey(); - int col = position.getValue(); - // Snake touched the boundary - if (!(row >= 0 && col >= 0 && row < height && col < width)) { - return false; + + private void moveSnake(int[] move) { + this.snake.addFirst(move); + if (snakeEatsFood(move)) { + this.foodQueue.remove(); + this.score++; + } else { + int[] tail = this.snake.removeLast(); + this.snakeBody.remove(tail[0] + "|" + tail[1]); + } } - // Snake bit somewhere in middle of the body - if (!position.equals(this.bodyQueue.peekFirst()) && this.body.contains(position)) { - return false; + + private boolean snakeEatsFood(int[] move) { + return !this.foodQueue.isEmpty() && move[0] == this.foodQueue.peek()[0] && move[1] == this.foodQueue.peek()[1]; } - return true; - } - - private boolean snakeAteFood(Pair position) { - if (!foodQueue.isEmpty() && position.equals(foodQueue.peek())) { - bodyQueue.addLast(position); - body.add(position); - foodQueue.poll(); - foodPoint++; - return true; + + private boolean isBitingItself(int[] move) { + String key = move[0] + "|" + move[1]; + return this.snakeBody.contains(key); } - return false; - } } /** From 34ebf07124878e5a55181ef53d014a7b785abf81 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Tue, 29 Nov 2022 07:49:06 -0800 Subject: [PATCH 004/712] Create Design SQL.java --- Medium/Design SQL.java | 47 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 47 insertions(+) create mode 100644 Medium/Design SQL.java diff --git a/Medium/Design SQL.java b/Medium/Design SQL.java new file mode 100644 index 00000000..644009b1 --- /dev/null +++ b/Medium/Design SQL.java @@ -0,0 +1,47 @@ +class SQL { + + private final Map>> database; + private final Map tableIdMap; + + public SQL(List tableNames, List columns) { + this.database = new HashMap<>(); + this.tableIdMap = new HashMap<>(); + for (String name : tableNames) { + database.put(name, new HashMap<>()); + tableIdMap.put(name, 1); + } + } + + public void insertRow(String tableName, List row) { + // Select the table + Map> table = this.database.get(tableName); + // Insert row in the table + table.put(tableIdMap.get(tableName), row); + // Increment rowId for the table + tableIdMap.put(tableName, tableIdMap.get(tableName) + 1); + } + + public void deleteRow(String tableName, int rowId) { + // Select the table + Map> table = this.database.get(tableName); + // Delete the row against the rowId + table.remove(rowId); + } + + public String selectCell(String tableName, int rowId, int columnId) { + // Select the table + Map> table = this.database.get(tableName); + // Select row + List row = table.get(rowId); + // Select column + return row.get(columnId - 1); + } +} + +/** + * Your SQL object will be instantiated and called as such: + * SQL obj = new SQL(names, columns); + * obj.insertRow(name,row); + * obj.deleteRow(name,rowId); + * String param_3 = obj.selectCell(name,rowId,columnId); + */ From f1a24c0311d138b2efa37d8169e2230c4b902c10 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Wed, 30 Nov 2022 08:17:24 -0800 Subject: [PATCH 005/712] Update Implement Trie II (Prefix Tree).java --- Medium/Implement Trie II (Prefix Tree).java | 110 ++++++++------------ 1 file changed, 46 insertions(+), 64 deletions(-) diff --git a/Medium/Implement Trie II (Prefix Tree).java b/Medium/Implement Trie II (Prefix Tree).java index e6bae27d..a3bddf29 100644 --- a/Medium/Implement Trie II (Prefix Tree).java +++ b/Medium/Implement Trie II (Prefix Tree).java @@ -1,82 +1,64 @@ -class Trie { +public class Trie { - private Node head; + private final TrieNode root; - public Trie() { - this.head = new Node('-'); - } - - public void insert(String word) { - Node curr = this.head; - for (char c : word.toCharArray()) { - if (!curr.children.containsKey(c)) { - curr.children.put(c, new Node(c)); - } - curr = curr.children.get(c); + public Trie() { + this.root = new TrieNode(); } - curr.wordToFrequency.put(word, curr.wordToFrequency.getOrDefault(word, 0) + 1); - } - public int countWordsEqualTo(String word) { - Node curr = this.head; - curr = traverseTrie(curr, word); - if (curr == null) { - return 0; + public void insert(String word) { + TrieNode curr = root; + for (char c : word.toCharArray()) { + if (!curr.children.containsKey(c)) { + curr.children.put(c, new TrieNode()); + } + curr = curr.children.get(c); + curr.startingWordCount++; + } + curr.completeWordCount++; } - return curr.wordToFrequency.getOrDefault(word, 0); - } - public int countWordsStartingWith(String prefix) { - Node curr = this.head; - curr = traverseTrie(curr, prefix); - if (curr == null) { - return 0; + public int countWordsEqualTo(String word) { + TrieNode endNode = searchWord(word); + return endNode == null ? 0 : endNode.completeWordCount; } - int count = 0; - Queue queue = new LinkedList<>(); - queue.add(curr); - while (!queue.isEmpty()) { - Node removed = queue.remove(); - for (String word : removed.wordToFrequency.keySet()) { - count += removed.wordToFrequency.get(word); - } - for (Character child : removed.children.keySet()) { - queue.add(removed.children.get(child)); - } + + public int countWordsStartingWith(String prefix) { + TrieNode endNode = searchWord(prefix); + return endNode == null ? 0 : endNode.startingWordCount; } - return count; - } - public void erase(String word) { - Node curr = this.head; - curr = traverseTrie(curr, word); - if (curr == null || curr.wordToFrequency.getOrDefault(word, 0) == 0) { - return; + public void erase(String word) { + TrieNode curr = root; + for (char c : word.toCharArray()) { + curr = curr.children.get(c); + curr.startingWordCount--; + } + curr.completeWordCount--; } - curr.wordToFrequency.put(word, curr.wordToFrequency.get(word) - 1); - } - private Node traverseTrie(Node curr, String word) { - for (char c : word.toCharArray()) { - if (!curr.children.containsKey(c)) { - return null; - } - curr = curr.children.get(c); + private TrieNode searchWord(String word) { + TrieNode curr = root; + for (char c : word.toCharArray()) { + if (!curr.children.containsKey(c)) { + return null; + } + curr = curr.children.get(c); + } + return curr; } - return curr; - } - private static class Node { - char c; - Map children; - Map wordToFrequency; + private static class TrieNode { + Map children; + int completeWordCount; + int startingWordCount; - public Node(char c) { - this.c = c; - this.children = new HashMap<>(); - this.wordToFrequency = new HashMap<>(); + public TrieNode() { + this.children = new HashMap<>(); + this.completeWordCount = 0; + this.startingWordCount = 0; + } } - } } /** From 6d24d46dd60184c7eb523490bf7a9f91b76a997d Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Wed, 30 Nov 2022 13:56:53 -0800 Subject: [PATCH 006/712] Update Serialize and Deserialize BST.java --- Medium/Serialize and Deserialize BST.java | 70 +++++++++++------------ 1 file changed, 33 insertions(+), 37 deletions(-) diff --git a/Medium/Serialize and Deserialize BST.java b/Medium/Serialize and Deserialize BST.java index ff587f9d..a6da4bff 100644 --- a/Medium/Serialize and Deserialize BST.java +++ b/Medium/Serialize and Deserialize BST.java @@ -10,48 +10,44 @@ public class Codec { // Encodes a tree to a single string. - public String serialize(TreeNode root) { - if (root == null) { - return ""; + public String serialize(TreeNode root) { + if (root == null) { + return "#"; + } + StringBuilder sb = new StringBuilder(); + dfsSerialize(root, sb); + return sb.toString().trim(); } - StringBuilder sb = new StringBuilder(); - dfs(root, sb); - return sb.toString().trim(); - } - - private void dfs(TreeNode root, StringBuilder sb) { - if (root == null) { - return; + + private void dfsSerialize(TreeNode root, StringBuilder sb) { + if (root == null) { + sb.append("#").append(" "); + return; + } + sb.append(root.val).append(" "); + dfsSerialize(root.left, sb); + dfsSerialize(root.right, sb); } - sb.append(root.val).append(" "); - dfs(root.left, sb); - dfs(root.right, sb); - } - // Decodes your encoded data to tree. - public TreeNode deserialize(String data) { - if (data.length() == 0) { - return null; + // Decodes your encoded data to tree. + public TreeNode deserialize(String data) { + Queue queue = new LinkedList<>(Arrays.asList(data.split("\\s+"))); + return dfsDeserialize(queue); } - String[] split = data.split("\\s+"); - return buildBST(split, 0, split.length - 1); - } - - private TreeNode buildBST(String[] data, int start, int end) { - if (start > end) { - return null; + + private TreeNode dfsDeserialize(Queue queue) { + if (queue.isEmpty()) { + return null; + } + String removed = queue.remove(); + if (removed.equals("#")) { + return null; + } + TreeNode root = new TreeNode(Integer.parseInt(removed)); + root.left = dfsDeserialize(queue); + root.right = dfsDeserialize(queue); + return root; } - TreeNode root = new TreeNode(Integer.parseInt(data[start])); - int index; - for (index = start; index <= end; index++) { - if (Integer.parseInt(data[index]) > Integer.parseInt(data[start])) { - break; - } - } - root.left = buildBST(data, start + 1, index - 1); - root.right = buildBST(data, index, end); - return root; - } } // Your Codec object will be instantiated and called as such: From 2aaa32060b5eed2a459b110c4e1468c2c244c11e Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Fri, 2 Dec 2022 07:12:27 -0800 Subject: [PATCH 007/712] Update Minimize Product Sum of Two Arrays.java --- .../Minimize Product Sum of Two Arrays.java | 48 +++++++++---------- 1 file changed, 22 insertions(+), 26 deletions(-) diff --git a/Medium/Minimize Product Sum of Two Arrays.java b/Medium/Minimize Product Sum of Two Arrays.java index 4f8e184b..8302c68e 100644 --- a/Medium/Minimize Product Sum of Two Arrays.java +++ b/Medium/Minimize Product Sum of Two Arrays.java @@ -1,29 +1,25 @@ class Solution { - public int minProductSum(int[] nums1, int[] nums2) { - int[] frequencyOne = new int[101]; - int[] frequencyTwo = new int[101]; - for (int i = 0; i < nums1.length; i++) { - frequencyOne[nums1[i]]++; - frequencyTwo[nums2[i]]++; + public int minProductSum(int[] nums1, int[] nums2) { + int[] frequencyOne = new int[101]; + int[] frequencyTwo = new int[101]; + for (int i = 0; i < nums1.length; i++) { + frequencyOne[nums1[i]]++; + frequencyTwo[nums2[i]]++; + } + int productSum = 0; + int idxOne = 1; + int idxTwo = 100; + while (idxOne < 101 && idxTwo > 0) { + if (frequencyOne[idxOne] == 0) { + idxOne++; + } else if (frequencyTwo[idxTwo] == 0) { + idxTwo--; + } else { + productSum += idxOne * idxTwo; + frequencyOne[idxOne]--; + frequencyTwo[idxTwo]--; + } + } + return productSum; } - int idxOne = 0; - int idxTwo = 100; - int sum = 0; - while (idxOne < 101 && idxTwo >= 0) { - while (idxOne < 101 && frequencyOne[idxOne] == 0) { - idxOne++; - } - while (idxTwo >= 0 && frequencyTwo[idxTwo] == 0) { - idxTwo--; - } - if (idxOne == 101 || idxTwo == -1) { - break; - } - int counter = Math.min(frequencyOne[idxOne], frequencyTwo[idxTwo]); - sum += counter * idxOne * idxTwo; - frequencyOne[idxOne] -= counter; - frequencyTwo[idxTwo] -= counter; - } - return sum; - } } From 113c6829c318263f68ae8f415c0f93c2bbd74ecb Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Fri, 2 Dec 2022 17:58:28 -0800 Subject: [PATCH 008/712] Update Sort Characters By Frequency.java --- Medium/Sort Characters By Frequency.java | 63 ++++++++++-------------- 1 file changed, 27 insertions(+), 36 deletions(-) diff --git a/Medium/Sort Characters By Frequency.java b/Medium/Sort Characters By Frequency.java index d85dc32a..7c0978bc 100644 --- a/Medium/Sort Characters By Frequency.java +++ b/Medium/Sort Characters By Frequency.java @@ -1,41 +1,32 @@ class Solution { - public String frequencySort(String s) { - int[] freqMap = new int[62]; - int maxFrequency = 0; - for (char c : s.toCharArray()) { - int charIdx = getCharIndex(c); - freqMap[charIdx]++; - maxFrequency = Math.max(maxFrequency, freqMap[charIdx]); - } - List[] revMap = new List[maxFrequency + 1]; - for (int i = 0; i < 62; i++) { - char c = getDecodedChar(i); - int currFreq = freqMap[i]; - if (currFreq != 0) { - if (revMap[currFreq] == null) { - revMap[currFreq] = new ArrayList<>(); + + private static final String ALL_LETTERS = + "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"; + + public String frequencySort(String s) { + Map map = new HashMap<>(); + int maxFrequency = 0; + for (char c : s.toCharArray()) { + map.put(c, map.getOrDefault(c, 0) + 1); + maxFrequency = Math.max(maxFrequency, map.get(c)); } - revMap[currFreq].add(c); - } - } - StringBuilder sb = new StringBuilder(); - for (int i = maxFrequency; i > 0; i--) { - if (revMap[i] != null) { - List characterList = revMap[i]; - for (char c : characterList) { - sb.append(String.valueOf(c).repeat(i)); + List[] frequencyToChar = new List[maxFrequency + 1]; + for (char c : map.keySet()) { + if (frequencyToChar[map.get(c)] == null) { + frequencyToChar[map.get(c)] = new ArrayList<>(); + } + frequencyToChar[map.get(c)].add(c); + } + StringBuilder sb = new StringBuilder(); + for (int i = maxFrequency; i > 0; i--) { + List characters = frequencyToChar[i] == null ? + new ArrayList<>() : frequencyToChar[i]; + for (char c : characters) { + for (int j = 0; j < i; j++) { + sb.append(c); + } + } } - } + return sb.toString(); } - return sb.toString(); - } - - private char getDecodedChar(int idx) { - return (char) (idx < 26 ? 97 + idx : (idx >= 52 ? 48 + idx - 52 : 65 + idx - 26)); - } - - private int getCharIndex(char c) { - return Character.isDigit(c) ? 52 + c - '0' - : (Character.isUpperCase(c) ? c - 'A' + 26 : c - 'a'); - } } From 115f63273228150273361f99273264895fcb3dc1 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 4 Dec 2022 16:23:16 -0800 Subject: [PATCH 009/712] Create Circular Sentence.java --- Easy/Circular Sentence.java | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) create mode 100644 Easy/Circular Sentence.java diff --git a/Easy/Circular Sentence.java b/Easy/Circular Sentence.java new file mode 100644 index 00000000..51b21134 --- /dev/null +++ b/Easy/Circular Sentence.java @@ -0,0 +1,16 @@ +class Solution { + public boolean isCircularSentence(String sentence) { + String[] words = sentence.split("\\s+"); + int n = words.length; + for (int i = 0; i < n - 1; i++) { + char lastCharOfCurrentWord = words[i].charAt(words[i].length() - 1); + char firstCharOfNextWord = words[i + 1].charAt(0); + if (lastCharOfCurrentWord != firstCharOfNextWord) { + return false; + } + } + char lastCharOfLastWord = words[n - 1].charAt(words[n - 1].length() - 1); + char firstCharOfFirstWord = words[0].charAt(0); + return lastCharOfLastWord == firstCharOfFirstWord; + } +} From e41fdb30da2687e6b40d00db24ef7d2f706c776e Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Mon, 5 Dec 2022 07:05:17 -0800 Subject: [PATCH 010/712] Create Divide Players Into Teams of Equal Skill.java --- ...ide Players Into Teams of Equal Skill.java | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) create mode 100644 Medium/Divide Players Into Teams of Equal Skill.java diff --git a/Medium/Divide Players Into Teams of Equal Skill.java b/Medium/Divide Players Into Teams of Equal Skill.java new file mode 100644 index 00000000..bebcec21 --- /dev/null +++ b/Medium/Divide Players Into Teams of Equal Skill.java @@ -0,0 +1,19 @@ +class Solution { + public long dividePlayers(int[] skill) { + Arrays.sort(skill); + long totalChemistry = 0; + int start = 0; + int end = skill.length - 1; + int totalSkill = skill[start] + skill[end]; + while (start < end) { + int currTotal = skill[start] + skill[end]; + if (currTotal != totalSkill) { + return -1; + } + totalChemistry += skill[start] * skill[end]; + start++; + end--; + } + return totalChemistry; + } +} From 31e3692033b5707773e492a822e1ce895b55474a Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Tue, 6 Dec 2022 17:25:20 -0800 Subject: [PATCH 011/712] Update Range Sum of BST.java --- Easy/Range Sum of BST.java | 32 ++++++++++++++++---------------- 1 file changed, 16 insertions(+), 16 deletions(-) diff --git a/Easy/Range Sum of BST.java b/Easy/Range Sum of BST.java index b3d21555..3ed8dfdd 100644 --- a/Easy/Range Sum of BST.java +++ b/Easy/Range Sum of BST.java @@ -14,22 +14,22 @@ * } */ class Solution { - public int rangeSumBST(TreeNode root, int low, int high) { - Stack stack = new Stack<>(); - stack.push(root); - int sum = 0; - while (!stack.isEmpty()) { - TreeNode removed = stack.pop(); - if (removed.val > low && removed.left != null) { - stack.push(removed.left); - } - if (removed.val < high && removed.right != null) { - stack.push(removed.right); - } - if (low <= removed.val && removed.val <= high) { - sum += removed.val; + public int rangeSumBST(TreeNode root, int low, int high) { + int sum = 0; + Queue queue = new LinkedList<>(); + queue.add(root); + while (!queue.isEmpty()) { + TreeNode removed = queue.remove(); + if (removed.val >= low && removed.val <= high) { + sum += removed.val; + } + if (removed.val >= low && removed.left != null) { + queue.add(removed.left); + } + if (removed.val <= high && removed.right != null) { + queue.add(removed.right); + } } + return sum; } - return sum; - } } From 78dad25c23a39aeb7d419d3a59a394fcccd0095d Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Wed, 7 Dec 2022 07:10:09 -0800 Subject: [PATCH 012/712] Update Design an Expression Tree With Evaluate Function.java --- ...xpression Tree With Evaluate Function.java | 108 ++++++++++-------- 1 file changed, 61 insertions(+), 47 deletions(-) diff --git a/Medium/Design an Expression Tree With Evaluate Function.java b/Medium/Design an Expression Tree With Evaluate Function.java index 123e21df..e01eb49f 100644 --- a/Medium/Design an Expression Tree With Evaluate Function.java +++ b/Medium/Design an Expression Tree With Evaluate Function.java @@ -4,50 +4,56 @@ */ abstract class Node { - public abstract int evaluate(); - // define your fields here + public abstract int evaluate(); + // define your fields here }; + class NumericNode extends Node { - - private int val; - - public NumericNode(int val) { - this.val = val; - } - - public int evaluate() { - return this.val; - } + private int val; + + public NumericNode(int val) { + this.val = val; + } + + @Override + public int evaluate() { + return this.val; + } } + class OperatorNode extends Node { - private char operator; - private Node leftNode; - private Node rightNode; - - public OperatorNode(char operator, Node leftNode, Node rightNode) { - this.operator = operator; - this.leftNode = leftNode; - this.rightNode = rightNode; - } - - public int evaluate() { - int leftValue = this.leftNode == null ? 0 : this.leftNode.evaluate(); - int rightValue = this.rightNode == null ? 0 : this.rightNode.evaluate(); - if (this.operator == '+') { - return leftValue + rightValue; - } else if (this.operator == '-') { - return leftValue - rightValue; - } else if (this.operator == '*') { - return leftValue * rightValue; - } else { - return leftValue / rightValue; + private char operator; + private Node left; + private Node right; + + public OperatorNode(char operator) { + this.operator = operator; + this.left = null; + this.right = null; + } + + @Override + public int evaluate() { + return switch(operator) { + case '+' -> left.evaluate() + right.evaluate(); + case '-' -> left.evaluate() - right.evaluate(); + case '*' -> left.evaluate() * right.evaluate(); + case '/' -> left.evaluate() / right.evaluate(); + default -> 0; + }; + } + + public void setRightNode(Node right) { + this.right = right; + } + + public void setLeftNode(Node left) { + this.left = left; } - } } - /** * This is the TreeBuilder class. * You can treat it as the driver code that takes the postinfix input @@ -55,19 +61,27 @@ public int evaluate() { */ class TreeBuilder { - Node buildTree(String[] postfix) { - Stack stack = new Stack<>(); - for(String token: postfix){ - if (token.equals("*") || token.equals("+") || token.equals("-") || token.equals("/")) { - Node o2 = stack.pop(); - Node o1 = stack.pop(); - stack.push(new OperatorNode(token.charAt(0), o1, o2)); - } else{ - stack.push(new NumericNode(Integer.parseInt(token))); - } + private static final Set OPERATORS = Set.of("+", "-", "/", "*"); + + Node buildTree(String[] postfix) { + int[] idx = {postfix.length - 1}; + return buildTree(postfix, idx); + } + + private Node buildTree(String[] postfix, int[] idx) { + if (idx[0] < 0) { + return null; + } + String val = postfix[idx[0]--]; + if (OPERATORS.contains(val)) { + OperatorNode node = new OperatorNode(val.charAt(0)); + node.setRightNode(buildTree(postfix, idx)); + node.setLeftNode(buildTree(postfix, idx)); + return node; + } + NumericNode node = new NumericNode(Integer.parseInt(val)); + return node; } - return stack.pop(); - } }; From 2446f4b5c48df4479b74c241e97da53bf152c004 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Wed, 7 Dec 2022 13:32:53 -0800 Subject: [PATCH 013/712] Update Valid Word Square.java --- Easy/Valid Word Square.java | 23 ++++++++++------------- 1 file changed, 10 insertions(+), 13 deletions(-) diff --git a/Easy/Valid Word Square.java b/Easy/Valid Word Square.java index 69e1925d..392d8392 100644 --- a/Easy/Valid Word Square.java +++ b/Easy/Valid Word Square.java @@ -1,16 +1,13 @@ class Solution { - public boolean validWordSquare(List words) { - return IntStream.range(0, words.size()) - .allMatch(i -> words.get(i).equals(verticalRepresentation(words, i))); - } - - private String verticalRepresentation(List words, int col){ - StringBuilder sb = new StringBuilder(); - for (String word : words) { - if (col < word.length()) { - sb.append(word.charAt(col)); - } + public boolean validWordSquare(List words) { + int n = words.size(); + for (int i = 0; i < n; i++){ + for (int j = 0; j < words.get(i).length(); j++){ + if(j >= n || words.get(j).length() <= i || words.get(j).charAt(i) != words.get(i).charAt(j)) { + return false; + } + } + } + return true; } - return sb.toString(); - } } From f5a0c5ccd9016a35202cf2719443bb7519c434a0 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Wed, 7 Dec 2022 18:54:48 -0800 Subject: [PATCH 014/712] Update Leaf-Similar Trees.java --- Easy/Leaf-Similar Trees.java | 38 +++++++++++++++--------------------- 1 file changed, 16 insertions(+), 22 deletions(-) diff --git a/Easy/Leaf-Similar Trees.java b/Easy/Leaf-Similar Trees.java index 38bb0ab9..1ac4d480 100644 --- a/Easy/Leaf-Similar Trees.java +++ b/Easy/Leaf-Similar Trees.java @@ -14,29 +14,23 @@ * } */ class Solution { - public boolean leafSimilar(TreeNode root1, TreeNode root2) { - return getLeaves(root1).equals(getLeaves(root2)); - } - - private List getLeaves(TreeNode root) { - Stack stack = new Stack<>(); - List leaves = new ArrayList<>(); - while (root != null) { - stack.push(root); - root = root.left; + public boolean leafSimilar(TreeNode root1, TreeNode root2) { + StringBuilder leavesOne = new StringBuilder(); + StringBuilder leavesTwo = new StringBuilder(); + populateLeaves(root1, leavesOne); + populateLeaves(root2, leavesTwo); + return leavesOne.toString().equals(leavesTwo.toString()); } - while (!stack.isEmpty()) { - TreeNode removed = stack.pop(); - if (removed.left == null && removed.right == null) { - leaves.add(removed.val); - } else { - TreeNode rightNode = removed.right; - while (rightNode != null) { - stack.push(rightNode); - rightNode = rightNode.left; + + private void populateLeaves(TreeNode root, StringBuilder leaves) { + if (root == null) { + return; } - } + if (root.left == null && root.right == null) { + leaves.append(root.val).append(","); + return; + } + populateLeaves(root.left, leaves); + populateLeaves(root.right, leaves); } - return leaves; - } } From 4bcd108338b86f2326ab9206633a14c39aec3650 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Thu, 8 Dec 2022 09:06:36 -0800 Subject: [PATCH 015/712] Create XOR Operation in an Array.java --- Easy/XOR Operation in an Array.java | 10 ++++++++++ 1 file changed, 10 insertions(+) create mode 100644 Easy/XOR Operation in an Array.java diff --git a/Easy/XOR Operation in an Array.java b/Easy/XOR Operation in an Array.java new file mode 100644 index 00000000..17908959 --- /dev/null +++ b/Easy/XOR Operation in an Array.java @@ -0,0 +1,10 @@ +class Solution { + public int xorOperation(int n, int start) { + int xor = start; + for (int i = 1; i < n; i++) { + int nextNum = start + 2 * i; + xor = xor ^ nextNum; + } + return xor; + } +} From 785a04d97ef2dbb81982d8da6ba9b597cfe82a77 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Thu, 8 Dec 2022 09:21:12 -0800 Subject: [PATCH 016/712] Create Largest Local Values in a Matrix.java --- Easy/Largest Local Values in a Matrix.java | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) create mode 100644 Easy/Largest Local Values in a Matrix.java diff --git a/Easy/Largest Local Values in a Matrix.java b/Easy/Largest Local Values in a Matrix.java new file mode 100644 index 00000000..570443a9 --- /dev/null +++ b/Easy/Largest Local Values in a Matrix.java @@ -0,0 +1,17 @@ +class Solution { + public int[][] largestLocal(int[][] grid) { + int rows = grid.length; + int cols = grid[0].length; + int[][] result = new int[rows - 2][cols - 2]; + for (int i = 0; i < rows - 2; i++) { + for (int j = 0; j < cols - 2; j++) { + for (int k = i; k < i + 3; k++) { + for (int l = j; l < j + 3; l++) { + result[i][j] = Math.max(result[i][j], grid[k][l]); + } + } + } + } + return result; + } +} From b265e9d12baf76f919f69b0e4d37f03b8770908e Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Thu, 8 Dec 2022 09:21:26 -0800 Subject: [PATCH 017/712] Update README.md --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index ddb9b55e..92c01bb6 100644 --- a/README.md +++ b/README.md @@ -2,7 +2,7 @@ ## Solutions to Leetcode problems in Java -## [Current Leetcode profile: Solved 1100+ Problems](https://leetcode.com/varunsjsu/) +## [Current Leetcode profile: Solved 1200+ Problems](https://leetcode.com/varunsjsu/) ## [Previous Leetcode profile: Solved 759 Problems](https://leetcode.com/varunu28/) Problem Category | Count From e085714d8caaca4531f99522fff03693b0f0bc15 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Thu, 8 Dec 2022 09:32:42 -0800 Subject: [PATCH 018/712] Update Number of Connected Components in an Undirected Graph.java --- ...ted Components in an Undirected Graph.java | 72 +++++++------------ 1 file changed, 25 insertions(+), 47 deletions(-) diff --git a/Medium/Number of Connected Components in an Undirected Graph.java b/Medium/Number of Connected Components in an Undirected Graph.java index e794deea..59e0be29 100644 --- a/Medium/Number of Connected Components in an Undirected Graph.java +++ b/Medium/Number of Connected Components in an Undirected Graph.java @@ -1,51 +1,29 @@ class Solution { - public int countComponents(int n, int[][] edges) { - DisjointSet disjointSet = new DisjointSet(n); - for (int[] edge : edges) { - disjointSet.union(edge[0], edge[1]); - } - Set rootSet = new HashSet<>(); - for (int i = 0; i < n; i++) { - rootSet.add(disjointSet.find(i)); - } - return rootSet.size(); - } - - private static class DisjointSet { - - private final int[] root; - private final int[] rank; - - public DisjointSet(int size) { - this.root = new int[size]; - this.rank = new int[size]; - for (int i = 0; i < size; i++) { - this.root[i] = i; - this.rank[i] = 1; - } - } - - public void union(int nodeOne, int nodeTwo) { - int rootOne = find(nodeOne); - int rootTwo = find(nodeTwo); - if (rootOne != rootTwo) { - if (this.rank[rootOne] > this.rank[rootTwo]) { - this.root[rootTwo] = rootOne; - } else if (this.rank[rootOne] < this.rank[rootTwo]) { - this.root[rootOne] = rootTwo; - } else { - this.root[rootTwo] = rootOne; - this.rank[rootOne]++; + public int countComponents(int n, int[][] edges) { + Map> graph = new HashMap<>(); + for (int[] edge : edges) { + graph.computeIfAbsent(edge[0], k -> new HashSet<>()).add(edge[1]); + graph.computeIfAbsent(edge[1], k -> new HashSet<>()).add(edge[0]); } - } - } - - - public int find(int node) { - if (node == root[node]) { - return node; - } - return root[node] = find(root[node]); + int connectedComponentCount = 0; + Set visited = new HashSet<>(); + for (int i = 0; i < n; i++) { + if (!visited.contains(i)) { + Queue queue = new LinkedList<>(); + visited.add(i); + queue.add(i); + while (!queue.isEmpty()) { + int removed = queue.remove(); + for (Integer neighbor : graph.getOrDefault(removed, new HashSet<>())) { + if (!visited.contains(neighbor)) { + queue.add(neighbor); + visited.add(neighbor); + } + } + } + connectedComponentCount++; + } + } + return connectedComponentCount; } - } } From c8738e752f5ac6c600a310b58337240ed342df7d Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Thu, 8 Dec 2022 17:18:06 -0800 Subject: [PATCH 019/712] Update Maximum Difference Between Node and Ancestor.java --- ... Difference Between Node and Ancestor.java | 44 ++++++++++++++----- 1 file changed, 33 insertions(+), 11 deletions(-) diff --git a/Medium/Maximum Difference Between Node and Ancestor.java b/Medium/Maximum Difference Between Node and Ancestor.java index 75d54cfa..b623f146 100644 --- a/Medium/Maximum Difference Between Node and Ancestor.java +++ b/Medium/Maximum Difference Between Node and Ancestor.java @@ -14,16 +14,38 @@ * } */ class Solution { - public int maxAncestorDiff(TreeNode root) { - return dfs(root, root.val, root.val); - } - - private int dfs(TreeNode root, int min, int max) { - if (root == null) { - return max - min; + public int maxAncestorDiff(TreeNode root) { + int maxDiff = 0; + Queue queue = new LinkedList<>(); + queue.add(new NodeValuePair(root, root.val, root.val)); + while (!queue.isEmpty()) { + NodeValuePair removed = queue.remove(); + TreeNode node = removed.node; + Integer minNodeValue = removed.minNodeValue; + Integer maxNodeValue = removed.maxNodeValue; + maxDiff = Math.max(maxDiff, Math.max(Math.abs(node.val - minNodeValue), Math.abs(node.val - maxNodeValue))); + Integer updatedMinNodeValue = Math.min(node.val, minNodeValue); + Integer updatedMaxNodeValue = Math.max(node.val, maxNodeValue); + if (node.left != null) { + queue.add(new NodeValuePair(node.left, updatedMinNodeValue, updatedMaxNodeValue)); + } + if (node.right != null) { + queue.add(new NodeValuePair(node.right, updatedMinNodeValue, updatedMaxNodeValue)); + } + } + return maxDiff; + } + + + private static class NodeValuePair { + private TreeNode node; + private Integer minNodeValue; + private Integer maxNodeValue; + + public NodeValuePair(TreeNode node, Integer minNodeValue, Integer maxNodeValue) { + this.node = node; + this.minNodeValue = minNodeValue; + this.maxNodeValue = maxNodeValue; + } } - max = Math.max(root.val, max); - min = Math.min(root.val, min); - return Math.max(dfs(root.left, min, max), dfs(root.right, min, max)); - } } From 6b413315ca240c5ca220caa614a4fda11cb8d483 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sat, 10 Dec 2022 15:27:20 -0800 Subject: [PATCH 020/712] Create Maximum Product of Splitted Binary Tree.java --- ...ximum Product of Splitted Binary Tree.java | 37 +++++++++++++++++++ 1 file changed, 37 insertions(+) create mode 100644 Medium/Maximum Product of Splitted Binary Tree.java diff --git a/Medium/Maximum Product of Splitted Binary Tree.java b/Medium/Maximum Product of Splitted Binary Tree.java new file mode 100644 index 00000000..72a36750 --- /dev/null +++ b/Medium/Maximum Product of Splitted Binary Tree.java @@ -0,0 +1,37 @@ +/** + * Definition for a binary tree node. + * public class TreeNode { + * int val; + * TreeNode left; + * TreeNode right; + * TreeNode() {} + * TreeNode(int val) { this.val = val; } + * TreeNode(int val, TreeNode left, TreeNode right) { + * this.val = val; + * this.left = left; + * this.right = right; + * } + * } + */ +class Solution { + public int maxProduct(TreeNode root) { + List allNodeSums = new ArrayList<>(); + long totalSum = treeSum(root, allNodeSums); + long best = 0; + for (long sum : allNodeSums) { + best = Math.max(best, sum * (totalSum - sum)); + } + return (int) (best % 1000_000_007); + } + + private int treeSum(TreeNode root, List allNodeSums) { + if (root == null) { + return 0; + } + int leftSum = treeSum(root.left, allNodeSums); + int rightSum = treeSum(root.right, allNodeSums); + int totalSum = leftSum + rightSum + root.val; + allNodeSums.add(totalSum); + return totalSum; + } +} From e274ecf892388dfae8e765220fc608d5a7607366 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sat, 10 Dec 2022 15:33:59 -0800 Subject: [PATCH 021/712] Create Maximum Value of a String in an Array.java --- Easy/Maximum Value of a String in an Array.java | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) create mode 100644 Easy/Maximum Value of a String in an Array.java diff --git a/Easy/Maximum Value of a String in an Array.java b/Easy/Maximum Value of a String in an Array.java new file mode 100644 index 00000000..29b0ec25 --- /dev/null +++ b/Easy/Maximum Value of a String in an Array.java @@ -0,0 +1,17 @@ +class Solution { + public int maximumValue(String[] strs) { + return Arrays.stream(strs) + .mapToInt(Solution::getStringValue) + .max() + .orElse(0); + } + + private static int getStringValue(String s) { + for (char c : s.toCharArray()) { + if (!Character.isDigit(c)) { + return s.length(); + } + } + return Integer.parseInt(s); + } +} From 087654b6cd0a153c8e1dac0d4cda069225e578e9 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sat, 10 Dec 2022 15:48:47 -0800 Subject: [PATCH 022/712] Create Maximum Star Sum of a Graph.java --- Medium/Maximum Star Sum of a Graph.java | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) create mode 100644 Medium/Maximum Star Sum of a Graph.java diff --git a/Medium/Maximum Star Sum of a Graph.java b/Medium/Maximum Star Sum of a Graph.java new file mode 100644 index 00000000..f54f2f83 --- /dev/null +++ b/Medium/Maximum Star Sum of a Graph.java @@ -0,0 +1,19 @@ +class Solution { + public int maxStarSum(int[] vals, int[][] edges, int k) { + Map> graph = new HashMap<>(); + for (int[] edge : edges) { + graph.computeIfAbsent(edge[0], node -> new PriorityQueue<>(Comparator.reverseOrder())).add(vals[edge[1]]); + graph.computeIfAbsent(edge[1], node -> new PriorityQueue<>(Comparator.reverseOrder())).add(vals[edge[0]]); + } + int maxSum = Integer.MIN_VALUE; + for (int i = 0; i < vals.length; i++) { + int currSum = vals[i]; + PriorityQueue pq = graph.getOrDefault(i, new PriorityQueue<>()); + for (int j = 0; j < k && !pq.isEmpty(); j++){ + currSum += Math.max(pq.poll(), 0); + } + maxSum = Math.max(maxSum, currSum); + } + return maxSum; + } +} From fbdfc0054f2ce1852d8a5c959029dc3593af9745 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Thu, 15 Dec 2022 19:49:00 -0800 Subject: [PATCH 023/712] Update Implement Queue using Stacks.java --- Easy/Implement Queue using Stacks.java | 68 ++++++++++++-------------- 1 file changed, 31 insertions(+), 37 deletions(-) diff --git a/Easy/Implement Queue using Stacks.java b/Easy/Implement Queue using Stacks.java index c2a5254d..fd2b165e 100644 --- a/Easy/Implement Queue using Stacks.java +++ b/Easy/Implement Queue using Stacks.java @@ -1,46 +1,40 @@ class MyQueue { + + private final Stack stackOne; + private final Stack stackTwo; - /** Initialize your data structure here. */ - Stack stack; - Stack revStack; - public MyQueue() { - stack = new Stack<>(); - revStack = new Stack<>(); - } - - /** Push element x to the back of queue. */ - public void push(int x) { - stack.push(x); - } - - /** Removes the element from in front of queue and returns that element. */ - public int pop() { - while (!stack.isEmpty()) { - revStack.push(stack.pop()); + public MyQueue() { + this.stackOne = new Stack<>(); + this.stackTwo = new Stack<>(); } - int num = revStack.pop(); - while (!revStack.isEmpty()) { - stack.push(revStack.pop()); + + public void push(int x) { + this.stackOne.push(x); } - return num; - } - - /** Get the front element. */ - public int peek() { - while (!stack.isEmpty()) { - revStack.push(stack.pop()); + + public int pop() { + exchangeElements(stackOne, stackTwo); + int popped = stackTwo.pop(); + exchangeElements(stackTwo, stackOne); + return popped; } - int num = revStack.peek(); - while (!revStack.isEmpty()) { - stack.push(revStack.pop()); + + public int peek() { + exchangeElements(stackOne, stackTwo); + int peeked = stackTwo.peek(); + exchangeElements(stackTwo, stackOne); + return peeked; + } + + public boolean empty() { + return stackOne.isEmpty(); + } + + private void exchangeElements(Stack stack1, Stack stack2) { + while (!stack1.isEmpty()) { + stack2.push(stack1.pop()); + } } - return num; - } - - /** Returns whether the queue is empty. */ - public boolean empty() { - return stack.isEmpty(); - } } /** From 9c5f812efa54980ba27f7c1bb0929a6b765a1a19 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sat, 17 Dec 2022 08:15:32 -0800 Subject: [PATCH 024/712] Update Evaluate Reverse Polish Notation.java --- Medium/Evaluate Reverse Polish Notation.java | 45 ++++++++++---------- 1 file changed, 22 insertions(+), 23 deletions(-) diff --git a/Medium/Evaluate Reverse Polish Notation.java b/Medium/Evaluate Reverse Polish Notation.java index 483049db..17b3a709 100644 --- a/Medium/Evaluate Reverse Polish Notation.java +++ b/Medium/Evaluate Reverse Polish Notation.java @@ -1,27 +1,26 @@ class Solution { - public int evalRPN(String[] tokens) { - Stack stack = new Stack<>(); - String operations = "+-/*"; - for (String token : tokens) { - stack.push(operations.contains(token) ? Objects - .requireNonNull(performOperation(stack.pop(), stack.pop(), token)) - : Integer.parseInt(token)); + + private static final Set OPERATIONS = Set.of("*", "+", "/", "-"); + + public int evalRPN(String[] tokens) { + Stack stack = new Stack<>(); + for (String token : tokens) { + if (OPERATIONS.contains(token)) { + stack.push(performOperation(stack.pop(), stack.pop(), token)); + } else { + stack.push(Integer.parseInt(token)); + } + } + return stack.pop(); } - return stack.pop(); - } - - private Integer performOperation(Integer secondOperand, Integer firstOperand, String operation) { - switch (operation) { - case "+": - return firstOperand + secondOperand; - case "-": - return firstOperand - secondOperand; - case "*": - return firstOperand * secondOperand; - case "/": - return firstOperand / secondOperand; - default: - return null; + + private static int performOperation(int num2, int num1, String operation) throws UnsupportedOperationException { + return switch(operation) { + case "+" -> num1 + num2; + case "-" -> num1 - num2; + case "*" -> num1 * num2; + case "/" -> num1 / num2; + default -> throw new UnsupportedOperationException("Operation not supported"); + }; } - } } From d36cc6fa3adebcf5efd85afa882b87df8a322f46 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 18 Dec 2022 06:40:30 -0800 Subject: [PATCH 025/712] Create Count Pairs Of Similar Strings.java --- Easy/Count Pairs Of Similar Strings.java | 26 ++++++++++++++++++++++++ 1 file changed, 26 insertions(+) create mode 100644 Easy/Count Pairs Of Similar Strings.java diff --git a/Easy/Count Pairs Of Similar Strings.java b/Easy/Count Pairs Of Similar Strings.java new file mode 100644 index 00000000..d9b1f7f9 --- /dev/null +++ b/Easy/Count Pairs Of Similar Strings.java @@ -0,0 +1,26 @@ +class Solution { + public int similarPairs(String[] words) { + Map map = new HashMap<>(); + int pairCount = 0; + for (String word : words) { + String key = buildSortedCharString(word); + pairCount += map.getOrDefault(key, 0); + map.put(key, map.getOrDefault(key, 0) + 1); + } + return pairCount; + } + + private static String buildSortedCharString(String s) { + boolean[] exists = new boolean[26]; + for (char c : s.toCharArray()) { + exists[c - 'a'] = true; + } + StringBuilder sb = new StringBuilder(); + for (int i = 0; i < 26; i++) { + if (exists[i]) { + sb.append((char) (97 + i)); + } + } + return sb.toString(); + } +} From d07aabcad7e83b10d73795d0d926a99803b91081 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 18 Dec 2022 16:50:46 -0800 Subject: [PATCH 026/712] Update Find if Path Exists in Graph.java --- Easy/Find if Path Exists in Graph.java | 44 ++++++++++++-------------- 1 file changed, 21 insertions(+), 23 deletions(-) diff --git a/Easy/Find if Path Exists in Graph.java b/Easy/Find if Path Exists in Graph.java index cfa38aaa..7a0c6a47 100644 --- a/Easy/Find if Path Exists in Graph.java +++ b/Easy/Find if Path Exists in Graph.java @@ -1,28 +1,26 @@ class Solution { - public boolean validPath(int n, int[][] edges, int start, int end) { - Map> graph = new HashMap<>(); - for (int[] edge : edges) { - graph.computeIfAbsent(edge[0], k -> new HashSet<>()).add(edge[1]); - graph.computeIfAbsent(edge[1], k -> new HashSet<>()).add(edge[0]); - } - Queue queue = new LinkedList<>(); - queue.add(start); - Set visited = new HashSet<>(); - while (!queue.isEmpty()) { - int size = queue.size(); - while (size-- > 0) { - int removed = queue.remove(); - if (removed == end) { - return true; + public boolean validPath(int n, int[][] edges, int source, int destination) { + Map> graph = new HashMap<>(); + for (int[] edge : edges) { + graph.computeIfAbsent(edge[0], k -> new ArrayList<>()).add(edge[1]); + graph.computeIfAbsent(edge[1], k -> new ArrayList<>()).add(edge[0]); } - visited.add(removed); - for (Integer connection : graph.getOrDefault(removed, new HashSet<>())) { - if (!visited.contains(connection)) { - queue.add(connection); - } + Queue queue = new LinkedList<>(); + queue.add(source); + Set visited = new HashSet<>(); + visited.add(source); + while (!queue.isEmpty()) { + Integer removed = queue.remove(); + if (removed == destination) { + return true; + } + for (Integer connection : graph.getOrDefault(removed, new ArrayList<>())) { + if (!visited.contains(connection)) { + queue.add(connection); + visited.add(connection); + } + } } - } + return false; } - return false; - } } From e5b615220164071dfed7f08df0512d06af5877bd Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Mon, 19 Dec 2022 13:18:29 -0800 Subject: [PATCH 027/712] Create Add Edges to Make Degrees of All Nodes Even.java --- ...ges to Make Degrees of All Nodes Even.java | 48 +++++++++++++++++++ 1 file changed, 48 insertions(+) create mode 100644 Hard/Add Edges to Make Degrees of All Nodes Even.java diff --git a/Hard/Add Edges to Make Degrees of All Nodes Even.java b/Hard/Add Edges to Make Degrees of All Nodes Even.java new file mode 100644 index 00000000..2258af63 --- /dev/null +++ b/Hard/Add Edges to Make Degrees of All Nodes Even.java @@ -0,0 +1,48 @@ +class Solution { + public boolean isPossible(int n, List> edges) { + Map> graph = new HashMap<>(); + for (List edge : edges) { + graph.computeIfAbsent(edge.get(0), k -> new HashSet<>()).add(edge.get(1)); + graph.computeIfAbsent(edge.get(1), k -> new HashSet<>()).add(edge.get(0)); + } + List nodeWithOddEdges = graph.entrySet() + .stream() + .filter(e -> e.getValue().size() % 2 != 0) + .map(Map.Entry::getKey) + .collect(Collectors.toList()); + if (nodeWithOddEdges.size() == 0) { + return true; + } + if (nodeWithOddEdges.size() == 2) { + Integer nodeOne = nodeWithOddEdges.get(0); + Integer nodeTwo = nodeWithOddEdges.get(1); + if (!hasEdge(graph, nodeOne, nodeTwo)) { + return true; + } + for (int i = 1; i <= n; i++) { + if (i == nodeOne || i == nodeTwo) { + continue; + } + if (!hasEdge(graph, i, nodeOne) && !hasEdge(graph, i, nodeTwo)) { + return true; + } + } + } + if (nodeWithOddEdges.size() == 4) { + Integer nodeOne = nodeWithOddEdges.get(0); + Integer nodeTwo = nodeWithOddEdges.get(1); + Integer nodeThree = nodeWithOddEdges.get(2); + Integer nodeFour = nodeWithOddEdges.get(3); + if ((!hasEdge(graph, nodeOne, nodeTwo) && !hasEdge(graph, nodeThree, nodeFour)) || + (!hasEdge(graph, nodeOne, nodeThree) && !hasEdge(graph, nodeTwo, nodeFour)) || + (!hasEdge(graph, nodeOne, nodeFour) && !hasEdge(graph, nodeTwo, nodeThree))) { + return true; + } + } + return false; + } + + private static boolean hasEdge(Map> graph, int nodeOne, int nodeTwo) { + return graph.getOrDefault(nodeOne, new HashSet<>()).contains(nodeTwo); + } +} From a854e63dfc56e32291cd1647c431e08cb4c6dcf8 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Mon, 19 Dec 2022 18:41:16 -0800 Subject: [PATCH 028/712] Update Keys and Rooms.java --- Medium/Keys and Rooms.java | 23 +++++++++++------------ 1 file changed, 11 insertions(+), 12 deletions(-) diff --git a/Medium/Keys and Rooms.java b/Medium/Keys and Rooms.java index 6a2f8c3f..a4fd783a 100644 --- a/Medium/Keys and Rooms.java +++ b/Medium/Keys and Rooms.java @@ -1,19 +1,18 @@ class Solution { public boolean canVisitAllRooms(List> rooms) { - Stack stack = new Stack<>(); - Set set = new HashSet<>(); - set.add(0); - stack.add(0); - while (!stack.isEmpty()) { - int keyPopped = stack.pop(); - List keys = rooms.get(keyPopped); - for (Integer key : keys) { - if (!set.contains(key)) { - stack.push(key); - set.add(key); + Set visited = new HashSet<>(); + Queue queue = new LinkedList<>(); + queue.add(0); + visited.add(0); + while (!queue.isEmpty()) { + int removed = queue.remove(); + for (Integer nextRoom : rooms.get(removed)) { + if (!visited.contains(nextRoom)) { + queue.add(nextRoom); + visited.add(nextRoom); } } } - return set.size() == rooms.size(); + return visited.size() == rooms.size(); } } From 27b93972f221d1e43babb8cb12d7b81da50ab9d4 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Wed, 21 Dec 2022 11:29:49 -0800 Subject: [PATCH 029/712] Create Possible Bipartition.java --- Medium/Possible Bipartition.java | 38 ++++++++++++++++++++++++++++++++ 1 file changed, 38 insertions(+) create mode 100644 Medium/Possible Bipartition.java diff --git a/Medium/Possible Bipartition.java b/Medium/Possible Bipartition.java new file mode 100644 index 00000000..4d2a0500 --- /dev/null +++ b/Medium/Possible Bipartition.java @@ -0,0 +1,38 @@ +class Solution { + public boolean possibleBipartition(int n, int[][] dislikes) { + Map> map = new HashMap<>(); + for (int[] dislike : dislikes) { + map.computeIfAbsent(dislike[0], k -> new ArrayList<>()).add(dislike[1]); + map.computeIfAbsent(dislike[1], k -> new ArrayList<>()).add(dislike[0]); + } + int[] color = new int[n + 1]; + Arrays.fill(color, -1); + for (int i = 1; i <= n; i++) { + if (color[i] == -1) { + if (!bfs(i, map, color)) { + return false; + } + } + } + return true; + } + + private boolean bfs(int node, Map> map, int[] color) { + Queue queue = new LinkedList<>(); + queue.add(node); + color[node] = 0; + while (!queue.isEmpty()) { + int removed = queue.remove(); + for (Integer neighbor : map.getOrDefault(removed, new ArrayList<>())) { + if (color[neighbor] == color[removed]) { + return false; + } + if (color[neighbor] == -1) { + color[neighbor] = 1 - color[removed]; + queue.add(neighbor); + } + } + } + return true; + } +} From 2bf7a2c4394fa169963d600ae9b150da3e23cb58 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Tue, 3 Jan 2023 14:56:14 -0800 Subject: [PATCH 030/712] Create Count the Digits That Divide a Number.java --- Easy/Count the Digits That Divide a Number.java | 14 ++++++++++++++ 1 file changed, 14 insertions(+) create mode 100644 Easy/Count the Digits That Divide a Number.java diff --git a/Easy/Count the Digits That Divide a Number.java b/Easy/Count the Digits That Divide a Number.java new file mode 100644 index 00000000..085c312b --- /dev/null +++ b/Easy/Count the Digits That Divide a Number.java @@ -0,0 +1,14 @@ +class Solution { + public int countDigits(int num) { + int count = 0; + int copy = num; + while (num > 0) { + int digit = num % 10; + num /= 10; + if (digit != 0 && copy % digit == 0) { + count++; + } + } + return count; + } +} From 9c40397d9529c19fb89e58a0da425e1cbf381180 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Wed, 4 Jan 2023 07:56:02 -0800 Subject: [PATCH 031/712] Create Minimum Rounds to Complete All Tasks.java --- .../Minimum Rounds to Complete All Tasks.java | 22 +++++++++++++++++++ 1 file changed, 22 insertions(+) create mode 100644 Medium/Minimum Rounds to Complete All Tasks.java diff --git a/Medium/Minimum Rounds to Complete All Tasks.java b/Medium/Minimum Rounds to Complete All Tasks.java new file mode 100644 index 00000000..309810a0 --- /dev/null +++ b/Medium/Minimum Rounds to Complete All Tasks.java @@ -0,0 +1,22 @@ +class Solution { + public int minimumRounds(int[] tasks) { + Map frequencyMap = Arrays.stream(tasks) + .boxed() + .collect(Collectors.groupingBy( + Function.identity(), + HashMap::new, + Collectors.counting())); + int rounds = 0; + for (Long occurrences : frequencyMap.values()) { + if (occurrences == 1) { + return -1; + } + if (occurrences % 3 == 0) { + rounds += (int) (occurrences / 3); + } else { + rounds += (int) (occurrences / 3 + 1); + } + } + return rounds; + } +} From 719bf44f00dd6998ba07eb1b59eeb85d013b90ad Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Wed, 4 Jan 2023 16:09:13 -0800 Subject: [PATCH 032/712] Create Maximum Enemy Forts That Can Be Captured.java --- Easy/Maximum Enemy Forts That Can Be Captured.java | 14 ++++++++++++++ 1 file changed, 14 insertions(+) create mode 100644 Easy/Maximum Enemy Forts That Can Be Captured.java diff --git a/Easy/Maximum Enemy Forts That Can Be Captured.java b/Easy/Maximum Enemy Forts That Can Be Captured.java new file mode 100644 index 00000000..207f220c --- /dev/null +++ b/Easy/Maximum Enemy Forts That Can Be Captured.java @@ -0,0 +1,14 @@ +class Solution { + public int captureForts(int[] forts) { + int maximumCapture = 0; + for (int i = 0, j = 0; i < forts.length; i++) { + if (forts[i] != 0) { + if (forts[i] == -1 * forts[j]) { + maximumCapture = Math.max(maximumCapture, i - j - 1); + } + j = i; + } + } + return maximumCapture; + } +} From bc70c5ce3de3cc4d2c6eb127df4fc1ca9a0aa778 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Thu, 5 Jan 2023 17:01:13 -0800 Subject: [PATCH 033/712] Update Maximum Ice Cream Bars.java --- Medium/Maximum Ice Cream Bars.java | 24 +++++++++++++++--------- 1 file changed, 15 insertions(+), 9 deletions(-) diff --git a/Medium/Maximum Ice Cream Bars.java b/Medium/Maximum Ice Cream Bars.java index 75d34abf..d8faca38 100644 --- a/Medium/Maximum Ice Cream Bars.java +++ b/Medium/Maximum Ice Cream Bars.java @@ -1,12 +1,18 @@ class Solution { - public int maxIceCream(int[] costs, int coins) { - PriorityQueue pq = new PriorityQueue<>(); - pq.addAll(Arrays.stream(costs).boxed().collect(Collectors.toList())); - int icecreamCount = 0; - while (!pq.isEmpty() && (coins - pq.peek()) >= 0) { - coins -= pq.poll(); - icecreamCount++; + public int maxIceCream(int[] costs, int coins) { + int[] costFrequency = new int[1000_01]; + for (int cost : costs) { + costFrequency[cost]++; + } + int numberOfIcecreams = 0; + for (int i = 1; i <= 1000_00 && coins >= i; i++) { + if (costFrequency[i] > 0) { + while (coins >= i && costFrequency[i]-- > 0) { + numberOfIcecreams++; + coins -= i; + } + } + } + return numberOfIcecreams; } - return icecreamCount; - } } From e61e21200c8f2fcff2b34695094afe06832bff5b Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Fri, 6 Jan 2023 13:16:55 -0800 Subject: [PATCH 034/712] Create Shortest Distance to Target String in a Circular Array.java --- ... to Target String in a Circular Array.java | 24 +++++++++++++++++++ 1 file changed, 24 insertions(+) create mode 100644 Easy/Shortest Distance to Target String in a Circular Array.java diff --git a/Easy/Shortest Distance to Target String in a Circular Array.java b/Easy/Shortest Distance to Target String in a Circular Array.java new file mode 100644 index 00000000..9280c7b9 --- /dev/null +++ b/Easy/Shortest Distance to Target String in a Circular Array.java @@ -0,0 +1,24 @@ +class Solution { + public int closetTarget(String[] words, String target, int startIndex) { + int firstIdx = -1; + int lastIdx = -1; + int n = words.length; + int minDistance = Integer.MAX_VALUE; + for (int i = 0; i < n; i++) { + if (words[i].equals(target)) { + if (firstIdx == -1) { + firstIdx = i; + } + lastIdx = i; + minDistance = Math.min(minDistance, Math.abs(i - startIndex)); + } + } + if (minDistance == Integer.MAX_VALUE) { + return -1; + } + return Math.min(minDistance, Math.min( + n - startIndex + firstIdx, // Reach first instance by circulating from end of array + startIndex + n - lastIdx // Reach last instance by circulating from start of array + )); + } +} From 189cdff25edfd0ef53dbfa628a4641c268b7abfb Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sat, 7 Jan 2023 17:33:45 -0800 Subject: [PATCH 035/712] Create Categorize Box According to Criteria.java --- .../Categorize Box According to Criteria.java | 23 +++++++++++++++++++ 1 file changed, 23 insertions(+) create mode 100644 Easy/Categorize Box According to Criteria.java diff --git a/Easy/Categorize Box According to Criteria.java b/Easy/Categorize Box According to Criteria.java new file mode 100644 index 00000000..0c817a0a --- /dev/null +++ b/Easy/Categorize Box According to Criteria.java @@ -0,0 +1,23 @@ +class Solution { + + private static final int BULKY_DIMENSION_THRESHOLD = 1000_0; + private static final int BULKY_VOLUME_THRESHOLD = 1000_000_000; + private static final int HEAVY_MASS_THRESHOLD = 100; + + public String categorizeBox(int length, int width, int height, int mass) { + long volume = ((long) length) * width * height; + boolean isBulky = length >= BULKY_DIMENSION_THRESHOLD || + width >= BULKY_DIMENSION_THRESHOLD || + height >= BULKY_DIMENSION_THRESHOLD || + mass >= BULKY_DIMENSION_THRESHOLD || + volume >= BULKY_VOLUME_THRESHOLD; + boolean isHeavy = mass >= HEAVY_MASS_THRESHOLD; + if (isBulky && isHeavy) { + return "Both"; + } + if (!(isBulky || isHeavy)) { + return "Neither"; + } + return isBulky ? "Bulky" : "Heavy"; + } +} From f06c8e3273d72e11060a0be394e204a591bc435f Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 8 Jan 2023 07:52:27 -0800 Subject: [PATCH 036/712] Create Maximum Count of Positive Integer and Negative Integer.java --- ...ount of Positive Integer and Negative Integer.java | 11 +++++++++++ 1 file changed, 11 insertions(+) create mode 100644 Easy/Maximum Count of Positive Integer and Negative Integer.java diff --git a/Easy/Maximum Count of Positive Integer and Negative Integer.java b/Easy/Maximum Count of Positive Integer and Negative Integer.java new file mode 100644 index 00000000..73e0dba8 --- /dev/null +++ b/Easy/Maximum Count of Positive Integer and Negative Integer.java @@ -0,0 +1,11 @@ +class Solution { + public int maximumCount(int[] nums) { + int positiveCount = 0; + int negativeCount = 0; + for (int num : nums) { + positiveCount += num > 0 ? 1 : 0; + negativeCount += num < 0 ? 1 : 0; + } + return Math.max(positiveCount, negativeCount); + } +} From 18e448cd295f317da27099cbcf970eb572bf14a5 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 8 Jan 2023 18:43:32 -0800 Subject: [PATCH 037/712] Update Binary Tree Preorder Traversal.java --- Medium/Binary Tree Preorder Traversal.java | 36 ++++++++++++---------- 1 file changed, 19 insertions(+), 17 deletions(-) diff --git a/Medium/Binary Tree Preorder Traversal.java b/Medium/Binary Tree Preorder Traversal.java index e2f64ac4..61765340 100644 --- a/Medium/Binary Tree Preorder Traversal.java +++ b/Medium/Binary Tree Preorder Traversal.java @@ -4,31 +4,33 @@ * int val; * TreeNode left; * TreeNode right; - * TreeNode(int x) { val = x; } + * TreeNode() {} + * TreeNode(int val) { this.val = val; } + * TreeNode(int val, TreeNode left, TreeNode right) { + * this.val = val; + * this.left = left; + * this.right = right; + * } * } */ class Solution { public List preorderTraversal(TreeNode root) { - ArrayList ans = new ArrayList<>(); if (root == null) { - return ans; + return List.of(); } - Stack s = new Stack<>(); - - s.push(root); - - while(s.size() > 0) { - TreeNode curr = s.pop(); - ans.add(curr.val); - if(curr.right != null) { - s.push(curr.right); + Stack stack = new Stack<>(); + stack.push(root); + List result = new ArrayList<>(); + while (!stack.isEmpty()) { + TreeNode removed = stack.pop(); + result.add(removed.val); + if (removed.right != null) { + stack.push(removed.right); } - - if(curr.left != null) { - s.push(curr.left); + if (removed.left != null) { + stack.push(removed.left); } } - - return ans; + return result; } } From c6424ab6674f7ebf8e91f7a5a6abc35df95cfc9d Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Mon, 9 Jan 2023 15:17:52 -0800 Subject: [PATCH 038/712] Create Find Consecutive Integers from a Data Stream.java --- ...nsecutive Integers from a Data Stream.java | 23 +++++++++++++++++++ 1 file changed, 23 insertions(+) create mode 100644 Medium/Find Consecutive Integers from a Data Stream.java diff --git a/Medium/Find Consecutive Integers from a Data Stream.java b/Medium/Find Consecutive Integers from a Data Stream.java new file mode 100644 index 00000000..7f57b28d --- /dev/null +++ b/Medium/Find Consecutive Integers from a Data Stream.java @@ -0,0 +1,23 @@ +class DataStream { + + private int k; + private int value; + private int counter; + + public DataStream(int value, int k) { + this.k = k; + this.value = value; + this.counter = 0; + } + + public boolean consec(int num) { + counter = value == num ? (counter + 1) : 0; + return counter >= k; + } +} + +/** + * Your DataStream object will be instantiated and called as such: + * DataStream obj = new DataStream(value, k); + * boolean param_1 = obj.consec(num); + */ From 48e25e725edbaaf7fe10c72071a978ed3b98629b Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Fri, 13 Jan 2023 07:54:35 -0800 Subject: [PATCH 039/712] Create Maximal Score After Applying K Operations.java --- ...Maximal Score After Applying K Operations.java | 15 +++++++++++++++ 1 file changed, 15 insertions(+) create mode 100644 Medium/Maximal Score After Applying K Operations.java diff --git a/Medium/Maximal Score After Applying K Operations.java b/Medium/Maximal Score After Applying K Operations.java new file mode 100644 index 00000000..ca776caf --- /dev/null +++ b/Medium/Maximal Score After Applying K Operations.java @@ -0,0 +1,15 @@ +class Solution { + public long maxKelements(int[] nums, int k) { + PriorityQueue pq = new PriorityQueue<>((a, b) -> b - a); + for (int num : nums) { + pq.add(num); + } + long sum = 0; + while (!pq.isEmpty() && k-- > 0) { + int removed = pq.poll(); + sum += removed; + pq.add((int) Math.ceil(((double) removed) / 3)); + } + return sum; + } +} From 62a78b3aff64a78ca71d7be3a7ab14b1deb50ad2 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Fri, 13 Jan 2023 16:14:26 -0800 Subject: [PATCH 040/712] Update Number of Nodes in the Sub-Tree With the Same Label.java --- ...s in the Sub-Tree With the Same Label.java | 50 +++++++++---------- 1 file changed, 24 insertions(+), 26 deletions(-) diff --git a/Medium/Number of Nodes in the Sub-Tree With the Same Label.java b/Medium/Number of Nodes in the Sub-Tree With the Same Label.java index 473b9052..1798a058 100644 --- a/Medium/Number of Nodes in the Sub-Tree With the Same Label.java +++ b/Medium/Number of Nodes in the Sub-Tree With the Same Label.java @@ -1,30 +1,28 @@ class Solution { - public int[] countSubTrees(int n, int[][] edges, String labels) { - Map> map = new HashMap<>(); - for (int[] edge : edges) { - map.computeIfAbsent(edge[0], k -> new ArrayList<>()).add(edge[1]); - map.computeIfAbsent(edge[1], k -> new ArrayList<>()).add(edge[0]); - } - int[] count = new int[n]; - Set set = new HashSet<>(); - dfs(map, 0, labels, count, set); - return count; - } - - private int[] dfs(Map> map, int curr, String labels, int[] count, Set set) { - int[] cnt = new int[26]; - if (set.add(curr)) { - char c = labels.charAt(curr); - for (Integer child : map.getOrDefault(curr, new ArrayList<>())) { - int[] temp = dfs(map, child, labels, count, set); - for (int i = 0; i < 26; i++) { - cnt[i] += temp[i]; + public int[] countSubTrees(int n, int[][] edges, String labels) { + Map> tree = new HashMap<>(); + for (int[] edge : edges) { + tree.computeIfAbsent(edge[0], k -> new ArrayList<>()).add(edge[1]); + tree.computeIfAbsent(edge[1], k -> new ArrayList<>()).add(edge[0]); + } + int[] result = new int[n]; + Set visited = new HashSet<>(); + bfs(tree, 0, labels, result, visited); + return result; + } + + private int[] bfs(Map> tree, int currNode, String labels, int[] result, Set visited) { + int[] labelCount = new int[26]; + if (visited.add(currNode)) { + labelCount[labels.charAt(currNode) - 'a']++; + for (Integer child : tree.getOrDefault(currNode, new ArrayList<>())) { + int[] childLabelCount = bfs(tree, child, labels, result, visited); + for (int i = 0; i < 26; i++) { + labelCount[i] += childLabelCount[i]; + } + } + result[currNode] += labelCount[labels.charAt(currNode) - 'a']; } - } - cnt[c - 'a']++; - count[curr] = cnt[c - 'a']; + return labelCount; } - return cnt; - } } - From 624e04a5d4bf97cd2769e8bf938a967ee9d7574e Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 15 Jan 2023 07:42:33 -0800 Subject: [PATCH 041/712] Create Difference Between Element Sum and Digit Sum of an Array.java --- ...Element Sum and Digit Sum of an Array.java | 20 +++++++++++++++++++ 1 file changed, 20 insertions(+) create mode 100644 Easy/Difference Between Element Sum and Digit Sum of an Array.java diff --git a/Easy/Difference Between Element Sum and Digit Sum of an Array.java b/Easy/Difference Between Element Sum and Digit Sum of an Array.java new file mode 100644 index 00000000..1aef4cbe --- /dev/null +++ b/Easy/Difference Between Element Sum and Digit Sum of an Array.java @@ -0,0 +1,20 @@ +class Solution { + public int differenceOfSum(int[] nums) { + int elementSum = 0; + int digitSum = 0; + for (int num : nums) { + elementSum += num; + digitSum += getDigitSum(num); + } + return Math.abs(elementSum - digitSum); + } + + private static int getDigitSum(int num) { + int sum = 0; + while (num > 0) { + sum += num % 10; + num /= 10; + } + return sum; + } +} From 90a64d0a37ed431611cbf2ea17d630c4f83f5afb Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Fri, 20 Jan 2023 15:12:58 -0800 Subject: [PATCH 042/712] Update Duplicate Zeros.java --- Easy/Duplicate Zeros.java | 38 +++++++++++++++++++------------------- 1 file changed, 19 insertions(+), 19 deletions(-) diff --git a/Easy/Duplicate Zeros.java b/Easy/Duplicate Zeros.java index 54a3592a..9f97be38 100644 --- a/Easy/Duplicate Zeros.java +++ b/Easy/Duplicate Zeros.java @@ -1,23 +1,23 @@ class Solution { - public void duplicateZeros(int[] arr) { - int numOfZeros = 0; - for (int num : arr) { - numOfZeros += num == 0 ? 1 : 0; + public void duplicateZeros(int[] arr) { + int count = 0; + for (int i = 0; i < arr.length; i++) { + count += arr[i] == 0 ? 1 : 0; + } + int idxOne = arr.length - 1; + int idxTwo = arr.length + count - 1; + while (idxOne != idxTwo) { + insertAtEnd(arr, idxOne, idxTwo--); + if (arr[idxOne] == 0) { + insertAtEnd(arr, idxOne, idxTwo--); + } + idxOne--; + } } - int i = arr.length - 1; - int j = arr.length + numOfZeros - 1; - while (i != j) { - insert(arr, i, j--); - if (arr[i] == 0) { - insert(arr, i, j--); - } - i--; + + private void insertAtEnd(int[] arr, int idxOne, int idxTwo) { + if (idxTwo < arr.length) { + arr[idxTwo] = arr[idxOne]; + } } - } - - private void insert(int[] arr, int i, int j) { - if (j < arr.length) { - arr[j] = arr[i]; - } - } } From 3d6bf009a611de4148b75486de8943b64ae803ab Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sat, 21 Jan 2023 11:00:35 -0800 Subject: [PATCH 043/712] Create Minimum Common Value.java --- Easy/Minimum Common Value.java | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) create mode 100644 Easy/Minimum Common Value.java diff --git a/Easy/Minimum Common Value.java b/Easy/Minimum Common Value.java new file mode 100644 index 00000000..5062e9a3 --- /dev/null +++ b/Easy/Minimum Common Value.java @@ -0,0 +1,16 @@ +class Solution { + public int getCommon(int[] nums1, int[] nums2) { + int idxOne = 0; + int idxTwo = 0; + while (idxOne < nums1.length && idxTwo < nums2.length) { + if (nums1[idxOne] < nums2[idxTwo]) { + idxOne++; + } else if (nums2[idxTwo] < nums1[idxOne]) { + idxTwo++; + } else { + return nums1[idxOne]; + } + } + return -1; + } +} From 7a9b3a761ee43e2cb1a685bd42bc637ee70c4442 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 22 Jan 2023 07:22:28 -0800 Subject: [PATCH 044/712] Create Alternating Digit Sum.java --- Easy/Alternating Digit Sum.java | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) create mode 100644 Easy/Alternating Digit Sum.java diff --git a/Easy/Alternating Digit Sum.java b/Easy/Alternating Digit Sum.java new file mode 100644 index 00000000..4505e2e3 --- /dev/null +++ b/Easy/Alternating Digit Sum.java @@ -0,0 +1,18 @@ +class Solution { + public int alternateDigitSum(int n) { + int firstHalf = 0; + int secondHalf = 0; + int count = 0; + while (n > 0) { + secondHalf += n % 10; + n /= 10; + count++; + if (n > 0) { + firstHalf += n % 10; + n /= 10; + count++; + } + } + return count % 2 == 0 ? (firstHalf + -1 * secondHalf) : (secondHalf + -1 * firstHalf); + } +} From 7cf358c7e57a4ed4395a36dbccd4887cbb008f85 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Mon, 23 Jan 2023 09:21:19 -0800 Subject: [PATCH 045/712] Create Sort the Students by Their Kth Score.java --- Medium/Sort the Students by Their Kth Score.java | 6 ++++++ 1 file changed, 6 insertions(+) create mode 100644 Medium/Sort the Students by Their Kth Score.java diff --git a/Medium/Sort the Students by Their Kth Score.java b/Medium/Sort the Students by Their Kth Score.java new file mode 100644 index 00000000..7c4f83e9 --- /dev/null +++ b/Medium/Sort the Students by Their Kth Score.java @@ -0,0 +1,6 @@ +class Solution { + public int[][] sortTheStudents(int[][] score, int k) { + Arrays.sort(score, (o1, o2) -> o2[k] - o1[k]); + return score; + } +} From cd0f908dc1d656cfa78277a5b3c730bfee750902 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Wed, 25 Jan 2023 07:20:35 -0800 Subject: [PATCH 046/712] Create Find Closest Node to Given Two Nodes.java --- .../Find Closest Node to Given Two Nodes.java | 40 +++++++++++++++++++ 1 file changed, 40 insertions(+) create mode 100644 Medium/Find Closest Node to Given Two Nodes.java diff --git a/Medium/Find Closest Node to Given Two Nodes.java b/Medium/Find Closest Node to Given Two Nodes.java new file mode 100644 index 00000000..4c68c333 --- /dev/null +++ b/Medium/Find Closest Node to Given Two Nodes.java @@ -0,0 +1,40 @@ +class Solution { + public int closestMeetingNode(int[] edges, int node1, int node2) { + int n = edges.length; + int[] distance1 = new int[n]; + int[] distance2 = new int[n]; + Arrays.fill(distance1, Integer.MAX_VALUE); + Arrays.fill(distance2, Integer.MAX_VALUE); + bfs(node1, edges, distance1); + bfs(node2, edges, distance2); + int minDistanceNode = -1; + int currMinDistance = Integer.MAX_VALUE; + for (int i = 0; i < n; i++) { + if (currMinDistance > Math.max(distance1[i], distance2[i])) { + minDistanceNode = i; + currMinDistance = Math.max(distance1[i], distance2[i]); + } + } + return minDistanceNode; + } + + private void bfs(int startNode, int[] edges, int[] distance) { + int n = edges.length; + Queue queue = new LinkedList<>(); + queue.add(startNode); + boolean[] visited = new boolean[n]; + distance[startNode] = 0; + while (!queue.isEmpty()) { + int node = queue.remove(); + if (visited[node]) { + continue; + } + visited[node] = true; + int neighbor = edges[node]; + if (neighbor != -1 && !visited[neighbor]) { + distance[neighbor] = 1 + distance[node]; + queue.add(neighbor); + } + } + } +} From f79aa6c69435885fa989c69475a03565e89cdb8c Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Thu, 26 Jan 2023 10:24:06 -0800 Subject: [PATCH 047/712] Create Cheapest Flights Within K Stops.java --- Medium/Cheapest Flights Within K Stops.java | 32 +++++++++++++++++++++ 1 file changed, 32 insertions(+) create mode 100644 Medium/Cheapest Flights Within K Stops.java diff --git a/Medium/Cheapest Flights Within K Stops.java b/Medium/Cheapest Flights Within K Stops.java new file mode 100644 index 00000000..e937fdaf --- /dev/null +++ b/Medium/Cheapest Flights Within K Stops.java @@ -0,0 +1,32 @@ +class Solution { + public int findCheapestPrice(int n, int[][] flights, int src, int dst, int k) { + Map> graph = new HashMap<>(); + for (int[] flight : flights) { + graph.computeIfAbsent(flight[0], ArrayList::new).add(new int[]{flight[1], flight[2]}); + } + int[] price = new int[n]; + Arrays.fill(price, Integer.MAX_VALUE); + Queue queue = new LinkedList<>(); + queue.add(new int[]{src, 0}); + while (k-- >= 0 && !queue.isEmpty()) { + int size = queue.size(); + while (size-- > 0) { + int[] removed = queue.remove(); + int currCity = removed[0]; + int currPrice = removed[1]; + if (!graph.containsKey(currCity)) { + continue; + } + for (int[] node : graph.get(currCity)) { + int nextCity = node[0]; + int flightPrice = node[1]; + if (currPrice + flightPrice < price[nextCity]) { + price[nextCity] = currPrice + flightPrice; + queue.add(new int[]{nextCity, price[nextCity]}); + } + } + } + } + return price[dst] == Integer.MAX_VALUE ? -1 : price[dst]; + } +} From 05bfdaadb040e1c68d26c1330d3c8f6957ed4f29 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sat, 28 Jan 2023 08:57:17 -0800 Subject: [PATCH 048/712] Create Minimum Health to Beat Game.java --- Medium/Minimum Health to Beat Game.java | 11 +++++++++++ 1 file changed, 11 insertions(+) create mode 100644 Medium/Minimum Health to Beat Game.java diff --git a/Medium/Minimum Health to Beat Game.java b/Medium/Minimum Health to Beat Game.java new file mode 100644 index 00000000..9b93099e --- /dev/null +++ b/Medium/Minimum Health to Beat Game.java @@ -0,0 +1,11 @@ +class Solution { + public long minimumHealth(int[] damage, int armor) { + int maxDamage = 0; + long totalDamage = 0; + for (int d : damage) { + totalDamage += d; + maxDamage = Math.max(maxDamage, d); + } + return totalDamage - Math.min(armor, maxDamage) + 1; + } +} From 53169adafa0de5cb98c80b743910af00afdd9053 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 29 Jan 2023 08:03:55 -0800 Subject: [PATCH 049/712] Update LFU Cache.java --- Hard/LFU Cache.java | 209 +++++++++++++++++++++++--------------------- 1 file changed, 111 insertions(+), 98 deletions(-) diff --git a/Hard/LFU Cache.java b/Hard/LFU Cache.java index 4d52ade6..d4caef70 100644 --- a/Hard/LFU Cache.java +++ b/Hard/LFU Cache.java @@ -1,112 +1,125 @@ class LFUCache { - private final Map keyToNodeMap; - private final Map frequencyToNodeMap; - private final Map keyToFrequencyMap; - private int capacity; - private int currentCapacity; - - public LFUCache(int capacity) { - this.capacity = capacity; - this.currentCapacity = 0; - this.keyToNodeMap = new HashMap<>(); - this.frequencyToNodeMap = new TreeMap<>(); - this.keyToFrequencyMap = new HashMap<>(); - } - - public int get(int key) { - if (!keyToNodeMap.containsKey(key)) { - return -1; + private final TreeMap frequencyToNodeMap; + private final Map keyToNodeMap; + private final int capacity; + + public LFUCache(int capacity) { + this.frequencyToNodeMap = new TreeMap<>(); + this.keyToNodeMap = new HashMap<>(); + this.capacity = capacity; + } + + public int get(int key) { + if (!keyToNodeMap.containsKey(key)) { + return -1; + } + Node node = keyToNodeMap.get(key); + updateNodeForFrequencyChange(node); + return node.value; } - Node node = keyToNodeMap.get(key); - removeNode(node); - int currentFrequency = keyToFrequencyMap.get(key); - int newFrequency = currentFrequency + 1; - keyToFrequencyMap.put(key, newFrequency); - addNodeToFrequencyHead(node, newFrequency); - return node.val; - } - - public void put(int key, int value) { - if (this.capacity == 0) { - return; + + public void put(int key, int value) { + if (this.keyToNodeMap.containsKey(key)) { + updateNode(key, value); + } else { + addNewNode(key, value); + } } - removeNodeIfCapacityReached(key); - Node node = getNode(key, value); - int newFrequency = keyToFrequencyMap.getOrDefault(key, 0) + 1; - keyToFrequencyMap.put(key, newFrequency); - keyToNodeMap.put(key, node); - if (newFrequency > 1) { - removeNode(node); + + private void updateNode(int key, int value) { + Node node = keyToNodeMap.get(key); + node.value = value; + updateNodeForFrequencyChange(node); } - addNodeToFrequencyHead(node, newFrequency); - } - - private void removeNodeIfCapacityReached(int key) { - if (!keyToNodeMap.containsKey(key) && this.currentCapacity == capacity) { - for (Integer freq : frequencyToNodeMap.keySet()) { - Node[] nodes = frequencyToNodeMap.get(freq); - if (nodes[1].prev.val == -1) { - continue; + + private void addNewNode(int key, int value) { + if (capacity == 0) { + return; + } + if (capacity == keyToNodeMap.size()) { + evictCache(); + } + Node node = new Node(key, value); + addToFrequencyMap(node); + keyToNodeMap.put(key, node); + } + + private void evictCache() { + int firstKey = frequencyToNodeMap.firstKey(); + Node nodeToEvict = frequencyToNodeMap.get(firstKey).getFirstNode(); + removeNode(nodeToEvict); + keyToNodeMap.remove(nodeToEvict.key); + if (frequencyToNodeMap.get(firstKey).getFirstNode().value == -1) { + frequencyToNodeMap.remove(firstKey); + } + } + + private void updateNodeForFrequencyChange(Node node) { + int prevFrequency = node.frequency; + node.frequency = node.frequency + 1; + removeNode(node); + if (frequencyToNodeMap.get(prevFrequency).getFirstNode().value == -1) { + frequencyToNodeMap.remove(prevFrequency); } - Node toRemove = nodes[1].prev; - removeNode(toRemove); - keyToNodeMap.remove(toRemove.key); - keyToFrequencyMap.remove(toRemove.key); - this.currentCapacity--; - break; - } + addToFrequencyMap(node); } - } - - private Node getNode(int key, int value) { - Node node; - if (keyToNodeMap.containsKey(key)) { - node = keyToNodeMap.get(key); - removeNode(node); - node.val = value; - } else { - this.currentCapacity++; - node = new Node(value, key); + + private void removeNode(Node node) { + Node prevToNode = node.prev; + Node nextToNode = node.next; + prevToNode.next = nextToNode; + nextToNode.prev = prevToNode; } - return node; - } - - private void addNodeToFrequencyHead(Node node, int newFrequency) { - if (!frequencyToNodeMap.containsKey(newFrequency)) { - Node head = new Node(-1, Integer.MIN_VALUE); - Node tail = new Node(-1, Integer.MAX_VALUE); - head.next = tail; - tail.prev = head; - frequencyToNodeMap.put(newFrequency, new Node[]{head, tail}); + + private void addToFrequencyMap(Node node) { + if (!frequencyToNodeMap.containsKey(node.frequency)) { + frequencyToNodeMap.put(node.frequency, new NodeLinkedList()); + } + frequencyToNodeMap.get(node.frequency).addNode(node); } - Node headNode = frequencyToNodeMap.get(newFrequency)[0]; - Node nextToHead = headNode.next; - nextToHead.prev = node; - node.next = nextToHead; - headNode.next = node; - node.prev = headNode; - } - - private void removeNode(Node node) { - Node prevNode = node.prev; - Node nextNode = node.next; - prevNode.next = nextNode; - nextNode.prev = prevNode; - } - - private static class Node { - int val; - int key; - Node next; - Node prev; - - public Node(int val, int key) { - this.val = val; - this.key = key; + + private static class NodeLinkedList { + private final Node head; + private final Node tail; + + public NodeLinkedList() { + this.head = new Node(-1, -1); + this.tail = new Node(-1, -1); + head.next = tail; + tail.prev = head; + } + + public Node getFirstNode() { + return head.next; + } + + public void addNode(Node node) { + Node prevToTail = tail.prev; + node.prev = prevToTail; + prevToTail.next = node; + node.next = tail; + tail.prev = node; + } + } + + private static class Node { + private final int key; + private int value; + private int frequency; + private Node next; + private Node prev; + + public Node(int key, int value) { + this.key = key; + this.value = value; + this.frequency = 1; + this.next = null; + this.prev = null; + } } - } } + /** * Your LFUCache object will be instantiated and called as such: * LFUCache obj = new LFUCache(capacity); From 31dc4a0798c5265f6be9f3c86a8f712677e0ec29 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Tue, 31 Jan 2023 09:34:06 -0800 Subject: [PATCH 050/712] Create Count Distinct Numbers on Board.java --- Easy/Count Distinct Numbers on Board.java | 5 +++++ 1 file changed, 5 insertions(+) create mode 100644 Easy/Count Distinct Numbers on Board.java diff --git a/Easy/Count Distinct Numbers on Board.java b/Easy/Count Distinct Numbers on Board.java new file mode 100644 index 00000000..42a7ad68 --- /dev/null +++ b/Easy/Count Distinct Numbers on Board.java @@ -0,0 +1,5 @@ +class Solution { + public int distinctIntegers(int n) { + return Math.max(n - 1, 1); + } +} From e5b2cf9e87f8d6d9b2af971a8a7b85b6e1d7da8c Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Tue, 31 Jan 2023 19:33:57 -0800 Subject: [PATCH 051/712] Update Greatest Common Divisor of Strings.java --- Easy/Greatest Common Divisor of Strings.java | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/Easy/Greatest Common Divisor of Strings.java b/Easy/Greatest Common Divisor of Strings.java index 263b6caa..f817725a 100644 --- a/Easy/Greatest Common Divisor of Strings.java +++ b/Easy/Greatest Common Divisor of Strings.java @@ -1,13 +1,13 @@ class Solution { - public String gcdOfStrings(String str1, String str2) { - if (str1.length() < str2.length()) { - return gcdOfStrings(str2, str1); - } else if (!str1.startsWith(str2)) { - return ""; - } else if (str2.isEmpty()) { - return str1; - } else { - return gcdOfStrings(str1.substring(str2.length()), str2); + public String gcdOfStrings(String str1, String str2) { + if (!(str1 + str2).equals(str2 + str1)) { + return ""; + } + int gcdLength = gcd(str1.length(), str2.length()); + return str1.substring(0, gcdLength); + } + + private int gcd(int x, int y) { + return y == 0 ? x : gcd(y, x % y); } - } } From 4b9a51fdb0b1e94b07a03039eb29024aea14b456 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Wed, 1 Feb 2023 16:17:33 -0800 Subject: [PATCH 052/712] Update Verifying an Alien Dictionary.java --- Easy/Verifying an Alien Dictionary.java | 46 ++++++++++++------------- 1 file changed, 23 insertions(+), 23 deletions(-) diff --git a/Easy/Verifying an Alien Dictionary.java b/Easy/Verifying an Alien Dictionary.java index e11a4728..08bf111e 100644 --- a/Easy/Verifying an Alien Dictionary.java +++ b/Easy/Verifying an Alien Dictionary.java @@ -1,27 +1,27 @@ class Solution { - public boolean isAlienSorted(String[] words, String order) { - Map map = new HashMap<>(); - int idx = 0; - for (char c : order.toCharArray()) { - map.put(c, idx++); - } - for (int i = 1; i < words.length; i++) { - if (!isSorted(words[i - 1], words[i], map)) { - return false; - } - } - return true; - } - - private boolean isSorted(String wordOne, String wordTwo, Map map) { - for (int i = 0; i < Math.min(wordOne.length(), wordTwo.length()); i++) { - int diff = map.get(wordOne.charAt(i)) - map.get(wordTwo.charAt(i)); - if (diff > 0) { - return false; - } else if (diff < 0) { + public boolean isAlienSorted(String[] words, String order) { + Map map = new HashMap<>(); + for (int i = 0; i < order.length(); i++) { + map.put(order.charAt(i), i); + } + for (int i = 0; i < words.length - 1; i++) { + if (!inOrder(words[i], words[i + 1], map)) { + return false; + } + } return true; - } } - return wordOne.length() <= wordTwo.length(); - } + + private static boolean inOrder(String wordOne, String wordTwo, Map map) { + for (int i = 0; i < Math.min(wordOne.length(), wordTwo.length()); i++) { + int diff = map.get(wordOne.charAt(i)) - map.get(wordTwo.charAt(i)); + if (diff < 0) { + return true; + } + if (diff > 0) { + return false; + } + } + return wordOne.length() <= wordTwo.length(); + } } From 938ce93e6cdd35b86c4fd07e51fba01ff59ebcd7 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Thu, 2 Feb 2023 13:56:24 -0800 Subject: [PATCH 053/712] Update Subtree of Another Tree.java --- Easy/Subtree of Another Tree.java | 35 +++++++++++++------------------ 1 file changed, 15 insertions(+), 20 deletions(-) diff --git a/Easy/Subtree of Another Tree.java b/Easy/Subtree of Another Tree.java index a88e3642..c0e307eb 100644 --- a/Easy/Subtree of Another Tree.java +++ b/Easy/Subtree of Another Tree.java @@ -14,26 +14,21 @@ * } */ class Solution { - public boolean isSubtree(TreeNode root, TreeNode subRoot) { - if (root == null) { - return false; + public boolean isSubtree(TreeNode root, TreeNode subRoot) { + if (root == null) { + return false; + } + boolean result = root.val == subRoot.val && isSubtreeHelper(root, subRoot); + return result || isSubtree(root.left, subRoot) || isSubtree(root.right, subRoot); } - if (isSubtreeHelper(root, subRoot)) { - return true; + + private boolean isSubtreeHelper(TreeNode root, TreeNode subRoot) { + if (root == null && subRoot == null) { + return true; + } + if (root == null || subRoot == null) { + return false; + } + return root.val == subRoot.val && isSubtreeHelper(root.left, subRoot.left) && isSubtreeHelper(root.right, subRoot.right); } - return isSubtree(root.left, subRoot) || isSubtree(root.right, subRoot); - } - - private boolean isSubtreeHelper(TreeNode root, TreeNode subRoot) { - if (root == null && subRoot == null) { - return true; - } - if (root == null || subRoot == null) { - return false; - } - if (root.val != subRoot.val) { - return false; - } - return isSubtreeHelper(root.left, subRoot.left) && isSubtreeHelper(root.right, subRoot.right); - } } From a625604af6f02e0390f75f6108f970c05d26d446 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Fri, 3 Feb 2023 08:20:13 -0800 Subject: [PATCH 054/712] Update ZigZag Conversion.java --- Medium/ZigZag Conversion.java | 48 +++++++++++++++++++---------------- 1 file changed, 26 insertions(+), 22 deletions(-) diff --git a/Medium/ZigZag Conversion.java b/Medium/ZigZag Conversion.java index 62539da4..31793633 100644 --- a/Medium/ZigZag Conversion.java +++ b/Medium/ZigZag Conversion.java @@ -1,25 +1,29 @@ class Solution { - public String convert(String s, int numRows) { - if (numRows == 1) { - return s; + public String convert(String s, int numRows) { + if (numRows == 1) { + return s; + } + StringBuilder[] rows = new StringBuilder[numRows]; + for (int i = 0; i < numRows; i++) { + rows[i] = new StringBuilder(); + } + int row = 0; + int n = s.length(); + int idx = 0; + while (idx < n) { + while (idx < n && row < numRows) { + rows[row++].append(s.charAt(idx++)); + } + row -= 2; + while (idx < n && row >= 0) { + rows[row--].append(s.charAt(idx++)); + } + row += 2; + } + StringBuilder result = new StringBuilder(); + for (StringBuilder sb : rows) { + result.append(sb.toString()); + } + return result.toString(); } - List list = new ArrayList<>(); - for (int i = 0; i < numRows; i++) { - list.add(new StringBuilder()); - } - int idx = 0; - boolean downDirection = false; - for (char c : s.toCharArray()) { - list.get(idx).append(c); - if (idx == 0 || idx == numRows - 1) { - downDirection = !downDirection; - } - idx += downDirection ? 1 : -1; - } - StringBuilder result = new StringBuilder(); - for (StringBuilder sb : list) { - result.append(sb.toString()); - } - return result.toString(); - } } From 9382e4c247c939f8fdcc65d312cd74f164929342 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sat, 4 Feb 2023 12:38:17 -0800 Subject: [PATCH 055/712] Update Permutation in String.java --- Medium/Permutation in String.java | 62 +++++++++++++++++-------------- 1 file changed, 34 insertions(+), 28 deletions(-) diff --git a/Medium/Permutation in String.java b/Medium/Permutation in String.java index ff95424e..dd255290 100644 --- a/Medium/Permutation in String.java +++ b/Medium/Permutation in String.java @@ -1,32 +1,38 @@ class Solution { - public boolean checkInclusion(String s1, String s2) { - if (s2.length() < s1.length()) { - return false; - } - int[] frequency = new int[26]; - for (int i = 0; i < s1.length(); i++) { - frequency[s1.charAt(i) - 'a']++; - frequency[s2.charAt(i) - 'a']--; - } - if (allZeroArray(frequency)) { - return true; - } - for (int i = s1.length(); i < s2.length(); i++) { - frequency[s2.charAt(i) - 'a']--; - frequency[s2.charAt(i - s1.length()) - 'a']++; - if (allZeroArray(frequency)) { - return true; - } - } - return false; - } - - private boolean allZeroArray(int[] frequency) { - for (int count : frequency) { - if (count != 0) { + public boolean checkInclusion(String s1, String s2) { + if (s1.length() > s2.length()) { + return false; + } + Map map = new HashMap<>(); + for (char c : s1.toCharArray()) { + map.put(c, map.getOrDefault(c, 0) + 1); + } + int n = s1.length(); + int[] count = {map.size()}; + for (int i = 0; i < n - 1; i++) { + updateMap(map, s2.charAt(i), count, true); + } + int start = 0; + for (int i = n - 1; i < s2.length(); i++) { + updateMap(map, s2.charAt(i), count, true); + if (count[0] == 0) { + return true; + } + updateMap(map, s2.charAt(start++), count, false); + } return false; - } } - return true; - } + + private void updateMap(Map map, char c, int[] count, boolean decrement) { + if (map.containsKey(c)) { + int diff = decrement ? -1 : 1; + map.put(c, map.get(c) + diff); + if (decrement && map.get(c) == 0) { + count[0]--; + } + if (!decrement && map.get(c) == 1) { + count[0]++; + } + } + } } From 532d5eb08cb2ee1c9c1cde71af78a29516d2ade3 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sat, 4 Feb 2023 17:32:09 -0800 Subject: [PATCH 056/712] Create Separate the Digits in an Array.java --- Easy/Separate the Digits in an Array.java | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) create mode 100644 Easy/Separate the Digits in an Array.java diff --git a/Easy/Separate the Digits in an Array.java b/Easy/Separate the Digits in an Array.java new file mode 100644 index 00000000..9bd6878f --- /dev/null +++ b/Easy/Separate the Digits in an Array.java @@ -0,0 +1,19 @@ +class Solution { + public int[] separateDigits(int[] nums) { + List result = new ArrayList<>(); + for (int num : nums) { + int startIdx = result.size(); + while (num > 0) { + result.add(num % 10); + num /= 10; + } + int endIdx = result.size() - 1; + while (startIdx < endIdx) { + int temp = result.get(startIdx); + result.set(startIdx++, result.get(endIdx)); + result.set(endIdx--, temp); + } + } + return result.stream().mapToInt(Integer::intValue).toArray(); + } +} From de44f03a3fb7c986644554e147995415f204ad05 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 5 Feb 2023 09:17:44 -0800 Subject: [PATCH 057/712] Delete Find All Anagrams in a String.java --- Easy/Find All Anagrams in a String.java | 39 ------------------------- 1 file changed, 39 deletions(-) delete mode 100644 Easy/Find All Anagrams in a String.java diff --git a/Easy/Find All Anagrams in a String.java b/Easy/Find All Anagrams in a String.java deleted file mode 100644 index 8d79ab3b..00000000 --- a/Easy/Find All Anagrams in a String.java +++ /dev/null @@ -1,39 +0,0 @@ -class Solution { - public static List findAnagrams(String s, String p) { - List indexes = new ArrayList<>(); - Map pMap = new TreeMap<>(); - - for (char c : p.toCharArray()) { - pMap.put(c, pMap.getOrDefault(c, 0) + 1); - } - - Map map = new TreeMap<>(); - - for (int i=0; i Date: Sun, 5 Feb 2023 09:18:04 -0800 Subject: [PATCH 058/712] Update Find All Anagrams in a String.java --- Medium/Find All Anagrams in a String.java | 48 ++++++++++------------- 1 file changed, 21 insertions(+), 27 deletions(-) diff --git a/Medium/Find All Anagrams in a String.java b/Medium/Find All Anagrams in a String.java index 1edba8c7..e18917da 100644 --- a/Medium/Find All Anagrams in a String.java +++ b/Medium/Find All Anagrams in a String.java @@ -1,30 +1,24 @@ class Solution { - public List findAnagrams(String s, String p) { - List list = new ArrayList<>(); - if (s.length() < p.length()) { - return list; + public List findAnagrams(String s, String p) { + if (s.length() < p.length()) { + return new ArrayList<>(); + } + List result = new ArrayList<>(); + int[] patternCounter = new int[26]; + for (char c : p.toCharArray()) { + patternCounter[c - 'a']++; + } + int[] counter = new int[26]; + int start = 0; + for (int i = 0; i < s.length(); i++) { + counter[s.charAt(i) - 'a']++; + if (i >= p.length() - 1) { + if (Arrays.equals(patternCounter, counter)) { + result.add(start); + } + counter[s.charAt(start++) - 'a']--; + } + } + return result; } - int[] pArr = new int[26]; - for (char c : p.toCharArray()) { - pArr[c - 'a']++; - } - String pStr = Arrays.toString(pArr); - int start = 0; - int end = 0; - int n = s.length(); - int[] sArr = new int[26]; - while (end < (p.length() - 1)) { - sArr[s.charAt(end) - 'a']++; - end++; - } - while (end < n) { - sArr[s.charAt(end) - 'a']++; - end++; - if (Arrays.toString(sArr).equals(pStr)) { - list.add(start); - } - sArr[s.charAt(start++) - 'a']--; - } - return list; - } } From c61ec791cae1ce3acec4d2c1c42cc54d5a69d18c Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 5 Feb 2023 09:24:35 -0800 Subject: [PATCH 059/712] Create Take Gifts From the Richest Pile.java --- Easy/Take Gifts From the Richest Pile.java | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) create mode 100644 Easy/Take Gifts From the Richest Pile.java diff --git a/Easy/Take Gifts From the Richest Pile.java b/Easy/Take Gifts From the Richest Pile.java new file mode 100644 index 00000000..ea754818 --- /dev/null +++ b/Easy/Take Gifts From the Richest Pile.java @@ -0,0 +1,17 @@ +class Solution { + public long pickGifts(int[] gifts, int k) { + PriorityQueue pq = new PriorityQueue<>((a, b) -> b - a); + long totalGifts = 0; + for (int gift : gifts) { + pq.add(gift); + totalGifts += gift; + } + while (k-- > 0) { + int removedGift = pq.poll(); + int remainingGift = (int) Math.sqrt(removedGift); + totalGifts -= removedGift - remainingGift; + pq.add(remainingGift); + } + return totalGifts; + } +} From 3986e088971911d98b392aca2374ff92d43b3290 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 5 Feb 2023 15:04:35 -0800 Subject: [PATCH 060/712] Create Count Vowel Strings in Ranges.java --- Medium/Count Vowel Strings in Ranges.java | 26 +++++++++++++++++++++++ 1 file changed, 26 insertions(+) create mode 100644 Medium/Count Vowel Strings in Ranges.java diff --git a/Medium/Count Vowel Strings in Ranges.java b/Medium/Count Vowel Strings in Ranges.java new file mode 100644 index 00000000..8f836610 --- /dev/null +++ b/Medium/Count Vowel Strings in Ranges.java @@ -0,0 +1,26 @@ +class Solution { + + public int[] vowelStrings(String[] words, int[][] queries) { + int[] counter = new int[words.length]; + int currCounter = 0; + for (int i = 0; i < words.length; i++) { + String word = words[i]; + if (isVowel(word.charAt(0)) && isVowel(word.charAt(word.length() - 1))) { + currCounter++; + } + counter[i] = currCounter; + } + int[] result = new int[queries.length]; + for (int i = 0; i < queries.length; i++) { + int left = queries[i][0]; + int right = queries[i][1]; + result[i] = counter[right]; + result[i] -= left == 0 ? 0 : counter[left - 1]; + } + return result; + } + + private static boolean isVowel(char c) { + return c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u'; + } +} From efb2017407da2c52f7d34d7f9d781b48edbee60f Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Mon, 6 Feb 2023 07:16:42 -0800 Subject: [PATCH 061/712] Create Maximum Number of Integers to Choose From a Range I.java --- ...er of Integers to Choose From a Range I.java | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) create mode 100644 Medium/Maximum Number of Integers to Choose From a Range I.java diff --git a/Medium/Maximum Number of Integers to Choose From a Range I.java b/Medium/Maximum Number of Integers to Choose From a Range I.java new file mode 100644 index 00000000..8f3ad2ee --- /dev/null +++ b/Medium/Maximum Number of Integers to Choose From a Range I.java @@ -0,0 +1,17 @@ +class Solution { + public int maxCount(int[] banned, int n, int maxSum) { + int count = 0; + Set bannedSet = Arrays.stream(banned).boxed().collect(Collectors.toSet()); + for (int i = 1; i <= n && count < n; i++) { + if (bannedSet.contains(i)) { + continue; + } + if (maxSum - i < 0) { + break; + } + count++; + maxSum -= i; + } + return count; + } +} From 9df7f26ef218c97b9d2bc7d481410eff64d2c20c Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Mon, 6 Feb 2023 19:13:28 -0800 Subject: [PATCH 062/712] Update Fruit Into Baskets.java --- Medium/Fruit Into Baskets.java | 34 +++++++++++++++++----------------- 1 file changed, 17 insertions(+), 17 deletions(-) diff --git a/Medium/Fruit Into Baskets.java b/Medium/Fruit Into Baskets.java index 79889371..937fbbe9 100644 --- a/Medium/Fruit Into Baskets.java +++ b/Medium/Fruit Into Baskets.java @@ -1,21 +1,21 @@ class Solution { - public int totalFruit(int[] fruits) { - Map map = new HashMap<>(); - int startIdx = 0; - int endIdx = 0; - int n = fruits.length; - int maxPickedCount = 0; - while (endIdx < n) { - map.put(fruits[endIdx], map.getOrDefault(fruits[endIdx++], 0) + 1); - while (startIdx < endIdx && map.size() > 2) { - map.put(fruits[startIdx], map.get(fruits[startIdx]) - 1); - if (map.get(fruits[startIdx]) == 0) { - map.remove(fruits[startIdx]); + public int totalFruit(int[] fruits) { + int maximumFruits = 0; + Map map = new HashMap<>(); + int start = 0; + int end = 0; + while (end < fruits.length) { + map.put(fruits[end], map.getOrDefault(fruits[end], 0) + 1); + end++; + while (start < end && map.size() > 2) { + map.put(fruits[start], map.get(fruits[start]) - 1); + if (map.get(fruits[start]) == 0) { + map.remove(fruits[start]); + } + start++; + } + maximumFruits = Math.max(maximumFruits, end - start); } - startIdx++; - } - maxPickedCount = Math.max(maxPickedCount, endIdx - startIdx); + return maximumFruits; } - return maxPickedCount; - } } From dd963fb55ab560527a37f106c8cdd9b7e0f729b3 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Tue, 7 Feb 2023 07:59:20 -0800 Subject: [PATCH 063/712] Update Moving Average from Data Stream.java --- Easy/Moving Average from Data Stream.java | 34 +++++++++++------------ 1 file changed, 17 insertions(+), 17 deletions(-) diff --git a/Easy/Moving Average from Data Stream.java b/Easy/Moving Average from Data Stream.java index e52fa84a..ec9dca5b 100644 --- a/Easy/Moving Average from Data Stream.java +++ b/Easy/Moving Average from Data Stream.java @@ -1,23 +1,23 @@ class MovingAverage { - - private int currSum; - private Queue queue; - private int size; - - public MovingAverage(int size) { - this.currSum = 0; - this.size = size; - this.queue = new LinkedList<>(); - } - public double next(int val) { - this.queue.add(val); - this.currSum += val; - if (this.queue.size() > this.size) { - this.currSum -= this.queue.remove(); + private final Queue queue; + private double currSum; + private final int size; + + public MovingAverage(int size) { + this.queue = new LinkedList<>(); + this.currSum = 0; + this.size = size; + } + + public double next(int val) { + this.queue.add(val); + this.currSum += val; + if (this.queue.size() > this.size) { + this.currSum -= this.queue.remove(); + } + return this.currSum / this.queue.size(); } - return ((double) this.currSum) / this.queue.size(); - } } /** From d8c193280da25404d9ac9f4d29cfca00843b7f1b Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Tue, 7 Feb 2023 15:28:38 -0800 Subject: [PATCH 064/712] Update Print FooBar Alternately.java --- Concurrency/Print FooBar Alternately.java | 53 ++++++++++++----------- 1 file changed, 27 insertions(+), 26 deletions(-) diff --git a/Concurrency/Print FooBar Alternately.java b/Concurrency/Print FooBar Alternately.java index f19a774f..94fa19cc 100644 --- a/Concurrency/Print FooBar Alternately.java +++ b/Concurrency/Print FooBar Alternately.java @@ -1,32 +1,33 @@ class FooBar { - private int n; - - private Semaphore fooSemaphore = new Semaphore(1); - private Semaphore barSemaphore = new Semaphore(0); - - public FooBar(int n) { - this.n = n; - } - - public void foo(Runnable printFoo) throws InterruptedException { - - for (int i = 0; i < n; i++) { - - // printFoo.run() outputs "foo". Do not change or remove this line. - fooSemaphore.acquire(); - printFoo.run(); - barSemaphore.release(); + private int n; + + private final Semaphore fooMutex; + private final Semaphore barMutex; + + public FooBar(int n) { + this.n = n; + this.fooMutex = new Semaphore(1); + this.barMutex = new Semaphore(0); } - } - - public void bar(Runnable printBar) throws InterruptedException { - for (int i = 0; i < n; i++) { + public void foo(Runnable printFoo) throws InterruptedException { + + for (int i = 0; i < n; i++) { + + // printFoo.run() outputs "foo". Do not change or remove this line. + this.fooMutex.acquire(); + printFoo.run(); + this.barMutex.release(); + } + } - // printBar.run() outputs "bar". Do not change or remove this line. - barSemaphore.acquire(); - printBar.run(); - fooSemaphore.release(); + public void bar(Runnable printBar) throws InterruptedException { + + for (int i = 0; i < n; i++) { + this.barMutex.acquire(); + // printBar.run() outputs "bar". Do not change or remove this line. + printBar.run(); + this.fooMutex.release(); + } } - } } From 480f89b337836a264757186757a99ab02813a3f5 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Wed, 8 Feb 2023 07:34:32 -0800 Subject: [PATCH 065/712] Create Jump Game II.java --- Medium/Jump Game II.java | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) create mode 100644 Medium/Jump Game II.java diff --git a/Medium/Jump Game II.java b/Medium/Jump Game II.java new file mode 100644 index 00000000..0f3a792c --- /dev/null +++ b/Medium/Jump Game II.java @@ -0,0 +1,17 @@ +class Solution { + public int jump(int[] nums) { + int jumpCount = 0; + int left = 0; + int right = 0; + while (right < nums.length - 1) { + int farthest = 0; + for (int i = left; i <= right; i++) { + farthest = Math.max(farthest, i + nums[i]); + } + left = right + 1; + right = farthest; + jumpCount++; + } + return jumpCount; + } +} From fe1871836b77d554ab4138ae0c14cbcbd0a8d42e Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Wed, 8 Feb 2023 09:15:01 -0800 Subject: [PATCH 066/712] Update Wiggle Sort.java --- Medium/Wiggle Sort.java | 27 +++++++-------------------- 1 file changed, 7 insertions(+), 20 deletions(-) diff --git a/Medium/Wiggle Sort.java b/Medium/Wiggle Sort.java index e4e8ad13..68cac74b 100644 --- a/Medium/Wiggle Sort.java +++ b/Medium/Wiggle Sort.java @@ -1,24 +1,11 @@ class Solution { - public void wiggleSort(int[] nums) { - boolean small = true; - for (int i = 0; i < nums.length - 1; i++) { - if (small) { - if (nums[i] > nums[i + 1]) { - swap(nums, i, i + 1); + public void wiggleSort(int[] nums) { + for (int i = 1; i < nums.length; i++) { + if ((i % 2 == 1 && nums[i] < nums[i - 1]) || (i % 2 != 1 && nums[i] > nums[i - 1])) { + int temp = nums[i]; + nums[i] = nums[i - 1]; + nums[i - 1] = temp; + } } - } - else { - if (nums[i] < nums[i + 1]) { - swap(nums, i, i + 1); - } - } - small = !small; } - } - - private void swap(int[] nums, int idx1, int idx2) { - int temp = nums[idx2]; - nums[idx2] = nums[idx1]; - nums[idx1] = temp; - } } From b26a7663e960de9519cbc98871856baad532aa88 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Wed, 8 Feb 2023 19:34:52 -0800 Subject: [PATCH 067/712] Create Naming a Company.java --- Hard/Naming a Company.java | 26 ++++++++++++++++++++++++++ 1 file changed, 26 insertions(+) create mode 100644 Hard/Naming a Company.java diff --git a/Hard/Naming a Company.java b/Hard/Naming a Company.java new file mode 100644 index 00000000..c24f78fe --- /dev/null +++ b/Hard/Naming a Company.java @@ -0,0 +1,26 @@ +class Solution { + public long distinctNames(String[] ideas) { + Map> map = new HashMap<>(); + for (String idea : ideas) { + map.computeIfAbsent(idea.charAt(0), k -> new HashSet<>()).add(idea.substring(1, idea.length())); + } + long result = 0; + for (Character key1 : map.keySet()) { + for (Character key2 : map.keySet()) { + if (key1 == key2) { + continue; + } + int intersection = 0; + for (String word : map.get(key1)) { + if (map.get(key2).contains(word)) { + intersection++; + } + } + int distinctOne = map.get(key1).size() - intersection; + int distinctTwo = map.get(key2).size() - intersection; + result += distinctOne * distinctTwo; + } + } + return result; + } +} From 6e03310edaf59a802d56843c9be946c608a610d1 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Thu, 9 Feb 2023 07:47:26 -0800 Subject: [PATCH 068/712] Update Buddy Strings.java --- Easy/Buddy Strings.java | 57 +++++++++++++++++++---------------------- 1 file changed, 27 insertions(+), 30 deletions(-) diff --git a/Easy/Buddy Strings.java b/Easy/Buddy Strings.java index e153e52d..83f94a5a 100644 --- a/Easy/Buddy Strings.java +++ b/Easy/Buddy Strings.java @@ -1,36 +1,33 @@ class Solution { - public boolean buddyStrings(String s, String goal) { - if (s.length() != goal.length()) { - return false; - } - if (s.equals(goal)) { - Set set = new HashSet<>(); - for (char c : s.toCharArray()) { - if (set.contains(c)) { - return true; + public boolean buddyStrings(String s, String goal) { + if (s.length() != goal.length()) { + return false; } - set.add(c); - } - return false; - } - char[] mismatch = {'-', '-'}; - for (int i = 0; i < s.length(); i++) { - if (s.charAt(i) != goal.charAt(i)) { - if (mismatch[0] == '|') { - return false; + int mismatchIdx = -1; + Set set = new HashSet<>(); + for (int i = 0; i < s.length(); i++) { + if (s.charAt(i) != goal.charAt(i)) { + if (mismatchIdx == Integer.MAX_VALUE) { + return false; + } + if (mismatchIdx == -1) { + mismatchIdx = i; + } else { + if (!(s.charAt(mismatchIdx) == goal.charAt(i) && s.charAt(i) == goal.charAt(mismatchIdx))) { + return false; + } + mismatchIdx = Integer.MAX_VALUE; + } + } else { + set.add(s.charAt(i)); + } + } + if (mismatchIdx != -1 && mismatchIdx != Integer.MAX_VALUE) { + return false; } - if (mismatch[0] == '-') { - mismatch[0] = s.charAt(i); - mismatch[1] = goal.charAt(i); - } else { - if (goal.charAt(i) == mismatch[0] && s.charAt(i) == mismatch[1]) { - mismatch[0] = '|'; - continue; - } - return false; + if (mismatchIdx == -1) { + return s.length() > set.size(); } - } + return true; } - return mismatch[0] == '|'; - } } From b6ff432749cbebdce0a67a16c8df8b02adbc170f Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Thu, 9 Feb 2023 09:46:15 -0800 Subject: [PATCH 069/712] Update Partition Labels.java --- Medium/Partition Labels.java | 32 ++++++++++++++++---------------- 1 file changed, 16 insertions(+), 16 deletions(-) diff --git a/Medium/Partition Labels.java b/Medium/Partition Labels.java index d8896c4a..e3157703 100644 --- a/Medium/Partition Labels.java +++ b/Medium/Partition Labels.java @@ -1,19 +1,19 @@ class Solution { - public List partitionLabels(String s) { - Map lastIndex = new HashMap<>(); - for (int i = 0; i < s.length(); i++) { - lastIndex.put(s.charAt(i), i); + public List partitionLabels(String s) { + Map map = new HashMap<>(); + for (int i = 0; i < s.length(); i++) { + map.put(s.charAt(i), i); + } + List result = new ArrayList<>(); + int start = 0; + int maxIdx = Integer.MIN_VALUE; + for (int i = 0; i < s.length(); i++) { + maxIdx = Math.max(map.get(s.charAt(i)), maxIdx); + if (maxIdx == i) { + result.add(i - start + 1); + start = i + 1; + } + } + return result; } - List partitionIndices = new ArrayList<>(); - int currMaxIdx = -1; - int prevIdx = 0; - for (int i = 0; i < s.length(); i++) { - currMaxIdx = Math.max(currMaxIdx, lastIndex.get(s.charAt(i))); - if (i == currMaxIdx) { - partitionIndices.add(i - prevIdx + 1); - prevIdx = i + 1; - } - } - return partitionIndices; - } } From 7977ed03d5c487dcefca359d38f582880815addd Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Thu, 9 Feb 2023 17:05:00 -0800 Subject: [PATCH 070/712] Update As Far from Land as Possible.java --- Medium/As Far from Land as Possible.java | 65 ++++++++++++------------ 1 file changed, 33 insertions(+), 32 deletions(-) diff --git a/Medium/As Far from Land as Possible.java b/Medium/As Far from Land as Possible.java index 2e80a70b..6e1ba29a 100644 --- a/Medium/As Far from Land as Possible.java +++ b/Medium/As Far from Land as Possible.java @@ -1,37 +1,38 @@ class Solution { - private final int[][] DIRS = {{1, 0}, {-1, 0}, {0, -1}, {0, 1}}; - - public int maxDistance(int[][] grid) { - Queue queue = new LinkedList<>(); - int numRows = grid.length; - int numCols = grid[0].length; - for (int i = 0; i < numRows; i++) { - for (int j = 0; j < numCols; j++) { - if (grid[i][j] == 1) { - queue.add(new int[]{i, j}); + + private static final int[][] DIRS = {{0, 1}, {1, 0}, {-1, 0}, {0, -1}}; + + public int maxDistance(int[][] grid) { + int rows = grid.length; + int cols = grid[0].length; + Queue queue = new LinkedList<>(); + for (int i = 0; i < rows; i++) { + for (int j = 0; j < cols; j++) { + if (grid[i][j] == 1) { + queue.add(new int[]{i, j}); + } + } } - } - } - if (queue.isEmpty() || queue.size() == numRows * numCols) { - return -1; - } - int distance = 0; - while (!queue.isEmpty()) { - int size = queue.size(); - while (size-- > 0) { - int[] removed = queue.remove(); - for (int[] dir : DIRS) { - int x = removed[0] + dir[0]; - int y = removed[1] + dir[1]; - if (x < 0 || y < 0 || x >= numRows || y >= numCols || grid[x][y] == 1) { - continue; - } - grid[x][y] = 1; - queue.add(new int[]{x, y}); + if (queue.isEmpty() || queue.size() == rows * cols) { + return -1; + } + int distance = 0; + while (!queue.isEmpty()) { + int size = queue.size(); + while (size-- > 0) { + int[] removed = queue.remove(); + for (int[] dir : DIRS) { + int x = removed[0] + dir[0]; + int y = removed[1] + dir[1]; + if (x < 0 || y < 0 || x >= rows || y >= cols || grid[x][y] == 1) { + continue; + } + grid[x][y] = 1; + queue.add(new int[]{x, y}); + } + } + distance++; } - } - distance++; + return distance - 1; } - return distance - 1; - } } From 7290c9653ccdcc649a0b7ff58af31b658651a31e Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sat, 11 Feb 2023 12:07:02 -0800 Subject: [PATCH 071/712] Update Shortest Path with Alternating Colors.java --- ...Shortest Path with Alternating Colors.java | 117 ++++++++---------- 1 file changed, 51 insertions(+), 66 deletions(-) diff --git a/Medium/Shortest Path with Alternating Colors.java b/Medium/Shortest Path with Alternating Colors.java index c2c3622a..63f670d0 100644 --- a/Medium/Shortest Path with Alternating Colors.java +++ b/Medium/Shortest Path with Alternating Colors.java @@ -1,72 +1,57 @@ class Solution { - private final Integer RED = 1; - private final Integer BLUE = 2; - public int[] shortestAlternatingPaths(int n, int[][] red_edges, int[][] blue_edges) { - Map> map = new HashMap<>(); - for (int[] edge : red_edges) { - map.computeIfAbsent(edge[0], k -> new ArrayList<>()).add(new Connection(edge[1], RED)); - } - for (int[] edge : blue_edges) { - map.computeIfAbsent(edge[0], k -> new ArrayList<>()).add(new Connection(edge[1], BLUE)); - } - int[] distances = new int[n]; - for (int i = 1; i < n; i++) { - distances[i] = getDistance(map, i, n); - } - return distances; - } - - private int getDistance(Map> map, int target, int n) { - int curr = 0; - int steps = 0; - boolean found = false; - Queue queue = new LinkedList<>(); - boolean[][] visited = new boolean[2][n]; - queue.add(new int[]{0, -1}); - while (!queue.isEmpty()) { - int size = queue.size(); - while (size-- > 0) { - int[] removed = queue.remove(); - if (removed[0] == target) { - found = true; - break; + + private static final Integer RED = 1; + private static final Integer BLUE = 2; + + public int[] shortestAlternatingPaths(int n, int[][] red_edges, int[][] blue_edges) { + Map> map = new HashMap<>(); + for (int[] edge : red_edges) { + map.computeIfAbsent(edge[0], k -> new ArrayList<>()).add(new Connection(edge[1], RED)); } - int color = removed[1]; - for (Connection connection : map.getOrDefault(removed[0], new ArrayList<>())) { - if (color == -1 && !visited[connection.color - 1][connection.val]) { - visited[connection.color - 1][connection.val] = true; - queue.add(connection.getArray()); - } - else if (color == 1 && connection.color != 1 && !visited[connection.color - 1][connection.val]) { - visited[connection.color - 1][connection.val] = true; - queue.add(connection.getArray()); - } - else if (color == 2 && connection.color != 2 && !visited[connection.color - 1][connection.val]) { - visited[connection.color - 1][connection.val] = true; - queue.add(connection.getArray()); - } + for (int[] edge : blue_edges) { + map.computeIfAbsent(edge[0], k -> new ArrayList<>()).add(new Connection(edge[1], BLUE)); + } + int[] distances = new int[n]; + for (int i = 1; i < n; i++) { + distances[i] = getDistance(map, i, n); } - } - if (found) { - break; - } - steps++; + return distances; } - return found ? steps : -1; - } -} - -class Connection { - int val; - int color; - - public Connection(int val, int color) { - this.val = val; - this.color = color; - } - - public int[] getArray() { - return new int[]{this.val, this.color}; - } + private int getDistance(Map> map, int target, int n) { + int steps = 0; + Queue queue = new LinkedList<>(); + boolean[][] visited = new boolean[2][n]; + queue.add(new int[]{0, -1}); + while (!queue.isEmpty()) { + int size = queue.size(); + while (size-- > 0) { + int[] removed = queue.remove(); + if (removed[0] == target) { + return steps; + } + int color = removed[1]; + for (Connection connection : map.getOrDefault(removed[0], new ArrayList<>())) { + if (color == -1 && !visited[connection.color - 1][connection.val]) { + visited[connection.color - 1][connection.val] = true; + queue.add(connection.getArray()); + } else if (color == 1 && connection.color != 1 && !visited[connection.color - 1][connection.val]) { + visited[connection.color - 1][connection.val] = true; + queue.add(connection.getArray()); + } else if (color == 2 && connection.color != 2 && !visited[connection.color - 1][connection.val]) { + visited[connection.color - 1][connection.val] = true; + queue.add(connection.getArray()); + } + } + } + steps++; + } + return -1; + } + + private record Connection(int val, int color) { + public int[] getArray() { + return new int[]{this.val, this.color}; + } + } } From 22b6c990c61bf5654876f76a64087fc6315d8c7a Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 12 Feb 2023 08:36:44 -0800 Subject: [PATCH 072/712] Create Minimum Fuel Cost to Report to the Capital.java --- ...um Fuel Cost to Report to the Capital.java | 28 +++++++++++++++++++ 1 file changed, 28 insertions(+) create mode 100644 Medium/Minimum Fuel Cost to Report to the Capital.java diff --git a/Medium/Minimum Fuel Cost to Report to the Capital.java b/Medium/Minimum Fuel Cost to Report to the Capital.java new file mode 100644 index 00000000..ee48239f --- /dev/null +++ b/Medium/Minimum Fuel Cost to Report to the Capital.java @@ -0,0 +1,28 @@ +class Solution { + public long minimumFuelCost(int[][] roads, int seats) { + Map> graph = new HashMap<>(); + for (int[] road : roads) { + graph.computeIfAbsent(road[0], k -> new ArrayList<>()).add(road[1]); + graph.computeIfAbsent(road[1], k -> new ArrayList<>()).add(road[0]); + } + long[] fuel = {0l}; + dfs(0, -1, graph, seats, fuel); + return fuel[0]; + } + + private long dfs(int node, int parent, Map> graph, int seats, long[] fuel) { + int representativeCount = 1; + if (!graph.containsKey(node)) { + return representativeCount; + } + for (int child : graph.get(node)) { + if (child != parent) { + representativeCount += dfs(child, node, graph, seats, fuel); + } + } + if (node != 0) { + fuel[0] += Math.ceil((double) representativeCount / seats); + } + return representativeCount; + } +} From c809100454403a9bfcf897cedfc3028e3e4c554b Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 12 Feb 2023 10:04:53 -0800 Subject: [PATCH 073/712] Create Find the Array Concatenation Value.java --- Easy/Find the Array Concatenation Value.java | 13 +++++++++++++ 1 file changed, 13 insertions(+) create mode 100644 Easy/Find the Array Concatenation Value.java diff --git a/Easy/Find the Array Concatenation Value.java b/Easy/Find the Array Concatenation Value.java new file mode 100644 index 00000000..974ca82b --- /dev/null +++ b/Easy/Find the Array Concatenation Value.java @@ -0,0 +1,13 @@ +class Solution { + public long findTheArrayConcVal(int[] nums) { + long concatenatedValue = 0; + int start = 0; + int end = nums.length - 1; + while (start <= end) { + concatenatedValue += start == end ? nums[start] : Integer.parseInt(nums[start] + "" + nums[end]); + start++; + end--; + } + return concatenatedValue; + } +} From b3d2e3be3d2d459e3a1f852c2d55bc074d4facf8 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sun, 12 Feb 2023 17:05:45 -0800 Subject: [PATCH 074/712] Updated Readme stats --- Concurrency/README.md | 11 + Easy/README.md | 1010 +++++++++++++++++--------------- Hard/README.md | 162 +++--- Medium/README.md | 1282 ++++++++++++++++++++++++----------------- README.md | 7 +- 5 files changed, 1407 insertions(+), 1065 deletions(-) create mode 100644 Concurrency/README.md diff --git a/Concurrency/README.md b/Concurrency/README.md new file mode 100644 index 00000000..8bc6ef63 --- /dev/null +++ b/Concurrency/README.md @@ -0,0 +1,11 @@ +# Concurrency LeetCode Java Solutions +S.no | Coding Problem +--- | --- +1 | [Building H2O](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Concurrency/Building%20H2O.java) +2 | [Design Bounded Blocking Queue](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Concurrency/Design%20Bounded%20Blocking%20Queue.java) +3 | [Fizz Buzz Multithreaded](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Concurrency/Fizz%20Buzz%20Multithreaded.java) +4 | [Print FooBar Alternately](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Concurrency/Print%20FooBar%20Alternately.java) +5 | [Print Zero Even Odd](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Concurrency/Print%20Zero%20Even%20Odd.java) +6 | [Print in Order](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Concurrency/Print%20in%20Order.java) +7 | [The Dining Philosophers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Concurrency/The%20Dining%20Philosophers.java) +8 | [Traffic Light Controlled Intersection](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Concurrency/Traffic%20Light%20Controlled%20Intersection.java) diff --git a/Easy/README.md b/Easy/README.md index 423b1cfa..63afc542 100644 --- a/Easy/README.md +++ b/Easy/README.md @@ -1,454 +1,560 @@ -# Easy LeetCode-Java-Solutions +# Easy LeetCode Java Solutions S.no | Coding Problem --- | --- -1|[Count Binary Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Binary%20Substrings.java) -2|[Longest Harmonious Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Harmonious%20Subsequence.java) -3|[High Five](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/High%20Five.java) -4|[Binary Tree Tilt](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Tree%20Tilt.java) -5|[Max Stack](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Max%20Stack.java) -6|[Number of Boomerangs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Boomerangs.java) -7|[Count the Number of Consistent Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20the%20Number%20of%20Consistent%20Strings.java) -8|[Sentence Similarity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sentence%20Similarity.java) -9|[Perform String Shifts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Perform%20String%20Shifts.java) -10|[Kth Largest Element in a Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Kth%20Largest%20Element%20in%20a%20Stream.java) -11|[Kth Missing Positive Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Kth%20Missing%20Positive%20Number.java) -12|[Check If String Is a Prefix of Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20String%20Is%20a%20Prefix%20of%20Array.java) -13|[The K Weakest Rows in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/The%20K%20Weakest%20Rows%20in%20a%20Matrix.java) -14|[Missing Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Missing%20Number.java) -15|[Remove Duplicates from Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Duplicates%20from%20Sorted%20Array.java) -16|[Implement strStr](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Implement%20strStr.java) -17|[Reverse String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20String.java) -18|[Create Target Array in the Given Order](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Create%20Target%20Array%20in%20the%20Given%20Order.java) -19|[Increasing Order Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Increasing%20Order%20Search%20Tree.java) -20|[Bold Words in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Bold%20Words%20in%20String.java) -21|[Minimum Absolute Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Absolute%20Difference.java) -22|[Maximum 69 Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%2069%20Number.java) -23|[Largest Perimeter Triangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Perimeter%20Triangle.java) -24|[Number of Equivalent Domino Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Equivalent%20Domino%20Pairs.java) -25|[Summary Ranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Summary%20Ranges.java) -26|[Binary Number with Alternating Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Number%20with%20Alternating%20Bits.java) -27|[Palindrome Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Palindrome%20Linked%20List.java) -28|[Intersection of Three Sorted Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20Three%20Sorted%20Arrays.java) -29|[Minimum Changes To Make Alternating Binary String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Changes%20To%20Make%20Alternating%20Binary%20String.java) -30|[Jewels and Stones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Jewels%20and%20Stones.java) -31|[Unique Email Addresses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Unique%20Email%20Addresses.java) -32|[X of a Kind in a Deck of Cards](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/X%20of%20a%20Kind%20in%20a%20Deck%20of%20Cards.java) -33|[Reverse Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Integer.java) -34|[Longest Nice Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Nice%20Substring.java) -35|[Count Primes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Primes.java) -36|[Positions of Large Groups](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Positions%20of%20Large%20Groups.java) -37|[Maximum Population Year](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Population%20Year.java) -38|[Min Cost Climbing Stairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Min%20Cost%20Climbing%20Stairs.java) -39|[Number of Days Between Two Dates](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Days%20Between%20Two%20Dates.java) -40|[Minimum Distance to the Target Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Distance%20to%20the%20Target%20Element.java) -41|[Path Crossing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Path%20Crossing.java) -42|[Check If N and Its Double Exist](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20N%20and%20Its%20Double%20Exist.java) -43|[Word Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Word%20Pattern.java) -44|[Maximum Nesting Depth of the Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Nesting%20Depth%20of%20the%20Parentheses.java) -45|[Non-decreasing Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Non-decreasing%20Array.java) -46|[Two Sum IV - Input is a BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum%20IV%20-%20Input%20is%20a%20BST.java) -47|[Find Positive Integer Solution for a Given Equation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Positive%20Integer%20Solution%20for%20a%20Given%20Equation.java) -48|[Hamming Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Hamming%20Distance.java) -49|[Defuse the Bomb](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Defuse%20the%20Bomb.java) -50|[Final Prices With a Special Discount in a Shop](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Final%20Prices%20With%20a%20Special%20Discount%20in%20a%20Shop.java) -51|[Plus One](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Plus%20One.java) -52|[Submission Detail](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Submission%20Detail.java) -53|[Rotate String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rotate%20String.java) -54|[Minimum Depth of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Depth%20of%20a%20Binary%20Tree.java) -55|[Power of four](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Power%20of%20four.java) -56|[Valid Perfect Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Perfect%20Square.java) -57|[Find N Unique Integers Sum up to Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20N%20Unique%20Integers%20Sum%20up%20to%20Zero.java) -58|[Paint Fence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Paint%20Fence.java) -59|[Detect Capital](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Detect%20Capital.java) -60|[Flipping an Image](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flipping%20an%20Image.java) -61|[Subtract the Product and Sum of Digits of an Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Subtract%20the%20Product%20and%20Sum%20of%20Digits%20of%20an%20Integer.java) -62|[Two Sum III - Data Structure Design](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum%20III%20-%20Data%20Structure%20Design.java) -63|[Check if Binary String Has at Most One Segment of Ones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Binary%20String%20Has%20at%20Most%20One%20Segment%20of%20Ones.java) -64|[Number Complement](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20Complement.java) -65|[Longer Contiguous Segments of Ones than Zeros](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longer%20Contiguous%20Segments%20of%20Ones%20than%20Zeros.java) -66|[Design HashSet](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20HashSet.java) -67|[Find Mode in Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Mode%20in%20Binary%20Search%20Tree.java) -68|[Maximum Repeating Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Repeating%20Substring.java) -69|[1-bit and 2-bit Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/1-bit%20and%202-bit%20Characters.java) -70|[Binary Gap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Gap.java) -71|[Subtree of Another Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Subtree%20of%20Another%20Tree.java) -72|[Binary Tree Level Order Traversal II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Tree%20Level%20Order%20Traversal%20II.java) -73|[Defanging an IP Address](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Defanging%20an%20IP%20Address.java) -74|[Truncate Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Truncate%20Sentence.java) -75|[Diameter of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Diameter%20of%20Binary%20Tree.java) -76|[Maximum Average Subarray I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Average%20Subarray%20I.java) -77|[Fizz Buzz](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fizz%20Buzz.java) -78|[Check if All the Integers in a Range Are Covered](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20All%20the%20Integers%20in%20a%20Range%20Are%20Covered.java) -79|[Duplicate Zeros](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Duplicate%20Zeros.java) -80|[Minimum Subsequence in Non-Increasing Order](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Subsequence%20in%20Non-Increasing%20Order.java) -81|[Smallest Range I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Smallest%20Range%20I.java) -82|[Employee Importance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Employee%20Importance.java) -83|[Minimum_index_sum_of_two_lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum_index_sum_of_two_lists.java) -84|[Number of segments in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20segments%20in%20a%20String.java) -85|[Delete Columns to Make Sorted](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20Columns%20to%20Make%20Sorted.java) -86|[Reverse Only Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Only%20Letters.java) -87|[Repeated String Match](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Repeated%20String%20Match.java) -88|[Uncommon Words from Two Sentences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Uncommon%20Words%20from%20Two%20Sentences.java) -89|[Assign Cookies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Assign%20Cookies.java) -90|[Element Appearing More Than 25% In Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Element%20Appearing%20More%20Than%2025%%20In%20Sorted%20Array.java) -91|[Find the Town Judge](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Town%20Judge.java) -92|[Buddy Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Buddy%20Strings.java) -93|[Teoplitz Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Teoplitz%20Matrix.java) -94|[Goat Latin](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Goat%20Latin.java) -95|[Flower Planting With No Adjacent](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flower%20Planting%20With%20No%20Adjacent.java) -96|[Largest Triangle Area](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Triangle%20Area.java) -97|[Determine Color of a Chessboard Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Determine%20Color%20of%20a%20Chessboard%20Square.java) -98|[Richest Customer Wealth](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Richest%20Customer%20Wealth.java) -99|[Consecutive Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Consecutive%20Characters.java) -100|[Latest Time by Replacing Hidden Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Latest%20Time%20by%20Replacing%20Hidden%20Digits.java) -101|[Robot Return to Origin](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Robot%20Return%20to%20Origin.java) -102|[Count and Say](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20and%20Say.java) -103|[Determine Whether Matrix Can Be Obtained By Rotation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Determine%20Whether%20Matrix%20Can%20Be%20Obtained%20By%20Rotation.java) -104|[Flip Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flip%20Game.java) -105|[Minimum Value to Get Positive Step by Step Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Value%20to%20Get%20Positive%20Step%20by%20Step%20Sum.java) -106|[Reshape the matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reshape%20the%20matrix.java) -107|[Valid Anagram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Anagram.java) -108|[Number of Strings That Appear as Substrings in Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Strings%20That%20Appear%20as%20Substrings%20in%20Word.java) -109|[DI String Match](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/DI%20String%20Match.java) -110|[Running Sum of 1d Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Running%20Sum%20of%201d%20Array.java) -111|[Special Array With X Elements Greater Than or Equal X](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Special%20Array%20With%20X%20Elements%20Greater%20Than%20or%20Equal%20X.java) -112|[Backspace String Compare](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Backspace%20String%20Compare.java) -113|[Implement Stack using Queues](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Implement%20Stack%20using%20Queues.java) -114|[Baseball Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Baseball%20Game.java) -115|[Pairs of Songs With Total Durations Divisible by 60](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Pairs%20of%20Songs%20With%20Total%20Durations%20Divisible%20by%2060.java) -116|[Destination City](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Destination%20City.java) -117|[Maximum Product of three numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Product%20of%20three%20numbers.java) -118|[Three Consecutive Odds](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Three%20Consecutive%20Odds.java) -119|[Set Mismatch](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Set%20Mismatch.java) -120|[Sort Array by Increasing Frequency](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Array%20by%20Increasing%20Frequency.java) -121|[Find the Distance Value Between Two Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Distance%20Value%20Between%20Two%20Arrays.java) -122|[Find Anagram Mappings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Anagram%20Mappings.java) -123|[Decompress Run-Length Encoded List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Decompress%20Run-Length%20Encoded%20List.java) -124|[Flood Fill](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flood%20Fill.java) -125|[Magic Squares In Grid](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Magic%20Squares%20In%20Grid.java) -126|[Hexspeak](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Hexspeak.java) -127|[Diet Plan Performance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Diet%20Plan%20Performance.java) -128|[Maximum Number of Balloons](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Balloons.java) -129|[Find Smallest Letter Greater Than Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Smallest%20Letter%20Greater%20Than%20Target.java) -130|[Check if Array Is Sorted and Rotated](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Array%20Is%20Sorted%20and%20Rotated.java) -131|[Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Path%20Sum.java) -132|[Day of the Year](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Day%20of%20the%20Year.java) -133|[Can Make Arithmetic Progression From Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Can%20Make%20Arithmetic%20Progression%20From%20Sequence.java) -134|[Find the Highest Altitude](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Highest%20Altitude.java) -135|[Powerful Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Powerful%20Integers.java) -136|[Merge Two Sorted Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Two%20Sorted%20Lists.java) -137|[Binary Search](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Search.java) -138|[K-diff Pairs in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/K-diff%20Pairs%20in%20an%20Array.java) -139|[Repeated Substring Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Repeated%20Substring%20Pattern.java) -140|[Reformat Phone Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reformat%20Phone%20Number.java) -141|[Longest Continuous Increasing Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Continuous%20Increasing%20Subsequence.java) -142|[Shuffle the Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shuffle%20the%20Array.java) -143|[Reorder Data in Log Files](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reorder%20Data%20in%20Log%20Files.java) -144|[Ransom Note](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Ransom%20Note.java) -145|[trailing_zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/trailing_zeroes.java) -146|[Height Checker](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Height%20Checker.java) -147|[License Key Formatting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/License%20Key%20Formatting.java) -148|[Balanced Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Balanced%20Binary%20Tree.java) -149|[Check If It Is a Straight Line](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20It%20Is%20a%20Straight%20Line.java) -150|[Max Area of Island](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Max%20Area%20of%20Island.java) -151|[Three Divisors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Three%20Divisors.java) -152|[Maximum Number of Words You Can Type](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Words%20You%20Can%20Type.java) -153|[String Matching in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/String%20Matching%20in%20an%20Array.java) -154|[Distance Between Bus Stops](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Distance%20Between%20Bus%20Stops.java) -155|[Ugly Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Ugly%20Number.java) -156|[Pascal's Triangle II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Pascal's%20Triangle%20II.java) -157|[Pascal's Triangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Pascal's%20Triangle.java) -158|[Binary Prefix Divisible By 5](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Prefix%20Divisible%20By%205.java) -159|[Number Of Rectangles That Can Form The Largest Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20Of%20Rectangles%20That%20Can%20Form%20The%20Largest%20Square.java) -160|[Count Negative Numbers in a Sorted Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Negative%20Numbers%20in%20a%20Sorted%20Matrix.java) -161|[Remove One Element to Make the Array Strictly Increasing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20One%20Element%20to%20Make%20the%20Array%20Strictly%20Increasing.java) -162|[Special Positions in a Binary Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Special%20Positions%20in%20a%20Binary%20Matrix.java) -163|[Check if All Characters Have Equal Number of Occurrences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20All%20Characters%20Have%20Equal%20Number%20of%20Occurrences.java) -164|[Valid Word Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Word%20Sequence.java) -165|[Design Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20Linked%20List.java) -166|[Rotated Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rotated%20Digits.java) -167|[Count Good Triplets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Good%20Triplets.java) -168|[Design an Ordered System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20an%20Ordered%20System.java) -169|[Get Maximum in Generated Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Get%20Maximum%20in%20Generated%20Array.java) -170|[Arranging Coins](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Arranging%20Coins.java) -171|[Check if Word Equals Summation of Two Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Word%20Equals%20Summation%20of%20Two%20Words.java) -172|[House Robber](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/House%20Robber.java) -173|[Fair Candy Swap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fair%20Candy%20Swap.java) -174|[Design Parking System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20Parking%20System.java) -175|[Transpose Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Transpose%20Matrix.java) -176|[Excel Sheet Column Title](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Excel%20Sheet%20Column%20Title.java) -177|[Linked List Cycle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Linked%20List%20Cycle.java) -178|[Find All the Lonely Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20All%20the%20Lonely%20Nodes.java) -179|[Base 7](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Base%207.java) -180|[Reverse Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Bits.java) -181|[SqrtX](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/SqrtX.java) -182|[Is Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Is%20Subsequence.java) -183|[Reverse Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Linked%20List.java) -184|[Shortest Distance to a Character](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Distance%20to%20a%20Character.java) -185|[Count of Matches in Tournament](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20of%20Matches%20in%20Tournament.java) -186|[Valid Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Parentheses.java) -187|[Two Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum%20II.java) -188|[Convert Sorted Array To Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%20Sorted%20Array%20To%20Binary%20Search%20Tree.java) -189|[Construct the rectangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Construct%20the%20rectangle.java) -190|[Maximum Units on a Truck](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Units%20on%20a%20Truck.java) -191|[Sum of left leaves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20left%20leaves.java) -192|[Decrypt String from Alphabet to Integer Mapping](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Decrypt%20String%20from%20Alphabet%20to%20Integer%20Mapping.java) -193|[Find Pivot Index](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Pivot%20Index.java) -194|[Factorial Trailing Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Factorial%20Trailing%20Zeroes.java) -195|[Build an Array With Stack Operations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Build%20an%20Array%20With%20Stack%20Operations.java) -196|[Peak Index in a Mountain Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Peak%20Index%20in%20a%20Mountain%20Array.java) -197|[Last Stone Weight](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Last%20Stone%20Weight.java) -198|[K Closest Points to Origin](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/K%20Closest%20Points%20to%20Origin.java) -199|[Largest Time for Given Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Time%20for%20Given%20Digits.java) -200|[range_addition_II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/range_addition_II.java) -201|[Isomorphic Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Isomorphic%20Strings.java) -202|[Split a String in Balanced Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Split%20a%20String%20in%20Balanced%20Strings.java) -203|[To Lower Case](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/To%20Lower%20Case.java) -204|[Sum of Digits of String After Convert](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Digits%20of%20String%20After%20Convert.java) -205|[Read N characters Given Read4](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Read%20N%20characters%20Given%20Read4.java) -206|[Delete N Nodes After M Nodes of a Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20N%20Nodes%20After%20M%20Nodes%20of%20a%20Linked%20List.java) -207|[Count Items Matching a Rule](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Items%20Matching%20a%20Rule.java) -208|[Reverse Vowels of a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Vowels%20of%20a%20String.java) -209|[Roman to Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Roman%20to%20Integer.java) -210|[Cousins in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Cousins%20in%20Binary%20Tree.java) -211|[Binary Tree Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Tree%20Paths.java) -212|[Valid Word Abbrevation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Word%20Abbrevation.java) -213|[Complement of Base 10 Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Complement%20of%20Base%2010%20Integer.java) -214|[Minimum Difference Between Highest and Lowest of K Scores](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Difference%20Between%20Highest%20and%20Lowest%20of%20K%20Scores.java) -215|[Number of Days in a Month](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Days%20in%20a%20Month.java) -216|[Find All Anagrams in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20All%20Anagrams%20in%20a%20String.java) -217|[Palindrome Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Palindrome%20Number.java) -218|[Detect Pattern of Length M Repeated K or More Times](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Detect%20Pattern%20of%20Length%20M%20Repeated%20K%20or%20More%20Times.java) -219|[Univalued Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Univalued%20Binary%20Tree.java) -220|[Single-Row Keyboard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Single-Row%20Keyboard.java) -221|[Remove Linked List Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Linked%20List%20Elements.java) -222|[How Many Numbers Are Smaller Than the Current Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/How%20Many%20Numbers%20Are%20Smaller%20Than%20the%20Current%20Number.java) -223|[Armstrong Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Armstrong%20Number.java) -224|[Counting Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Counting%20Elements.java) -225|[Make The String Great](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Make%20The%20String%20Great.java) -226|[Cells with Odd Values in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Cells%20with%20Odd%20Values%20in%20a%20Matrix.java) -227|[Power of Two](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Power%20of%20Two.java) -228|[Decode XORed Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Decode%20XORed%20Array.java) -229|[Min Stack](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Min%20Stack.java) -230|[Long Pressed Name](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Long%20Pressed%20Name.java) -231|[Kids With the Greatest Number of Candies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Kids%20With%20the%20Greatest%20Number%20of%20Candies.java) -232|[N-ary Tree Postorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-ary%20Tree%20Postorder%20Traversal.java) -233|[Max Consecutive Ones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Max%20Consecutive%20Ones.java) -234|[Find Words That Can Be Formed by Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Words%20That%20Can%20Be%20Formed%20by%20Characters.java) -235|[Number of 1 bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%201%20bits.java) -236|[Largest Unique Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Unique%20Number.java) -237|[Paint House](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Paint%20House.java) -238|[Logger Rate Limiter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Logger%20Rate%20Limiter.java) -239|[Substrings of Size Three with Distinct Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Substrings%20of%20Size%20Three%20with%20Distinct%20Characters.java) -240|[Monotonic Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Monotonic%20Array.java) -241|[Check if One String Swap Can Make Strings Equal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20One%20String%20Swap%20Can%20Make%20Strings%20Equal.java) -242|[Valid Palindrome II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Palindrome%20II.java) -243|[Occurrences After Bigram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Occurrences%20After%20Bigram.java) -244|[Move Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Move%20Zeroes.java) -245|[N-ary Tree Level Order Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-ary%20Tree%20Level%20Order%20Traversal.java) -246|[Number of Lines To Write String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Lines%20To%20Write%20String.java) -247|[First Unique Character in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/First%20Unique%20Character%20in%20a%20String.java) -248|[Maximum depth of Binary tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20depth%20of%20Binary%20tree.java) -249|[Largest Number At Least Twice of Others](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Number%20At%20Least%20Twice%20of%20Others.java) -250|[Reverse String II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20String%20II.java) -251|[Letter Case Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Letter%20Case%20Permutation.java) -252|[Subdomain Visit Count](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Subdomain%20Visit%20Count.java) -253|[Two Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum.java) -254|[Climbing Stairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Climbing%20Stairs.java) -255|[Projection Area of 3D Shapes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Projection%20Area%20of%203D%20Shapes.java) -256|[Third Maximum Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Third%20Maximum%20Number.java) -257|[Sign of the Product of an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sign%20of%20the%20Product%20of%20an%20Array.java) -258|[Heaters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Heaters.java) -259|[Student Attendance Record I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Student%20Attendance%20Record%20I.java) -260|[Delete Characters to Make Fancy String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20Characters%20to%20Make%20Fancy%20String.java) -261|[Longest Uncommon Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Uncommon%20Subsequence.java) -262|[Valid Mountain Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Mountain%20Array.java) -263|[Shortest Word Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Word%20Distance.java) -264|[Matrix Cells in Distance Order](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Matrix%20Cells%20in%20Distance%20Order.java) -265|[Sum of Even Numbers After Queries](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Even%20Numbers%20After%20Queries.java) -266|[Shuffle String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shuffle%20String.java) -267|[Sum of Square Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Square%20Numbers.java) -268|[Intersection of two arrays II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20two%20arrays%20II.java) -269|[Most Common Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Most%20Common%20Word.java) -270|[Number of Students Doing Homework at a Given Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Students%20Doing%20Homework%20at%20a%20Given%20Time.java) -271|[Invert Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Invert%20Binary%20Tree.java) -272|[Check if the Sentence Is Pangram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20the%20Sentence%20Is%20Pangram.java) -273|[Island Perimeter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Island%20Perimeter.java) -274|[Available Captures for Rook](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Available%20Captures%20for%20Rook.java) -275|[Degree of an array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Degree%20of%20an%20array.java) -276|[Sum of Root To Leaf Binary Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Root%20To%20Leaf%20Binary%20Numbers.java) -277|[Sort Array By Parity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Array%20By%20Parity.java) -278|[Number of Good Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Good%20Pairs.java) -279|[Convert a number to hexadecimal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%20a%20number%20to%20hexadecimal.java) -280|[Check If a Word Occurs As a Prefix of Any Word in a Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20a%20Word%20Occurs%20As%20a%20Prefix%20of%20Any%20Word%20in%20a%20Sentence.java) -281|[Concatenation of Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Concatenation%20of%20Array.java) -282|[Number of Recent Calls](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Recent%20Calls.java) -283|[Fixed Point](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fixed%20Point.java) -284|[Valid Boomerang](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Boomerang.java) -285|[Minimum Moves to Equal an Array Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Moves%20to%20Equal%20an%20Array%20Element.java) -286|[Calculate Money in Leetcode Bank](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Calculate%20Money%20in%20Leetcode%20Bank.java) -287|[Check If Two String Arrays are Equivalent](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20Two%20String%20Arrays%20are%20Equivalent.java) -288|[Find Nearest Point That Has the Same X or Y Coordinate](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Nearest%20Point%20That%20Has%20the%20Same%20X%20or%20Y%20Coordinate.java) -289|[Maximum Product Difference Between Two Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Product%20Difference%20Between%20Two%20Pairs.java) -290|[Goal Parser Interpretation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Goal%20Parser%20Interpretation.java) -291|[Judge Route Cycle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Judge%20Route%20Cycle.java) -292|[Middle of the linked list](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Middle%20of%20the%20linked%20list.java) -293|[Compare Strings by Frequency of the Smallest Character](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Compare%20Strings%20by%20Frequency%20of%20the%20Smallest%20Character.java) -294|[Intersection of Two Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20Two%20Arrays.java) -295|[Bulls and Cows](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Bulls%20and%20Cows.java) -296|[Slowest Key](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Slowest%20Key.java) -297|[nim_game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/nim_game.java) -298|[Groups of Special-Equivalent Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Groups%20of%20Special-Equivalent%20Strings.java) -299|[Reformat The String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reformat%20The%20String.java) -300|[Minimum Operations to Make the Array Increasing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Operations%20to%20Make%20the%20Array%20Increasing.java) -301|[Index Pairs of a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Index%20Pairs%20of%20a%20String.java) -302|[Number of Steps to Reduce a Number to Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Steps%20to%20Reduce%20a%20Number%20to%20Zero.java) -303|[Confusing Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Confusing%20Number.java) -304|[Convert BST to Greater Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%20BST%20to%20Greater%20Tree.java) -305|[Find All Numbers Disappeared in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20All%20Numbers%20Disappeared%20in%20an%20Array.java) -306|[Maximum Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Subarray.java) -307|[Reformat Date](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reformat%20Date.java) -308|[Largest Odd Number in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Odd%20Number%20in%20String.java) -309|[Build Array from Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Build%20Array%20from%20Permutation.java) -310|[Find Lucky Integer in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Lucky%20Integer%20in%20an%20Array.java) -311|[Best time to buy & sell a stock II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Best%20time%20to%20buy%20&%20sell%20a%20stock%20II.java) -312|[Nested List Weight Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Nested%20List%20Weight%20Sum.java) -313|[Relative ranks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Relative%20ranks.java) -314|[Palindrome Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Palindrome%20Permutation.java) -315|[Find Winner on a Tic Tac Toe Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Winner%20on%20a%20Tic%20Tac%20Toe%20Game.java) -316|[Merge two binary trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20two%20binary%20trees.java) -317|[Power of Three](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Power%20of%20Three.java) -318|[Lemonade Change](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Lemonade%20Change.java) -319|[Length of last word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Length%20of%20last%20word.java) -320|[Increasing Decreasing String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Increasing%20Decreasing%20String.java) -321|[N-th Tribonacci Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-th%20Tribonacci%20Number.java) -322|[Longest Common Prefix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Common%20Prefix.java) -323|[Minimum Time Visiting All Points](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Time%20Visiting%20All%20Points.java) -324|[Number of Different Integers in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Different%20Integers%20in%20a%20String.java) -325|[Add Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Add%20Strings.java) -326|[Maximum Ascending Subarray Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Ascending%20Subarray%20Sum.java) -327|[Best Time to Buy and Sell Stock](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Best%20Time%20to%20Buy%20and%20Sell%20Stock.java) -328|[String Compression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/String%20Compression.java) -329|[Lowest Common Ancestor of a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Lowest%20Common%20Ancestor%20of%20a%20Binary%20Search%20Tree.java) -330|[Determine if String Halves Are Alike](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Determine%20if%20String%20Halves%20Are%20Alike.java) -331|[Find the difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20difference.java) -332|[Leaf Similar Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Leaf%20Similar%20Tree.java) -333|[Replace All Digits with Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Replace%20All%20Digits%20with%20Characters.java) -334|[Largest Substring Between Two Equal Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Substring%20Between%20Two%20Equal%20Characters.java) -335|[Strobogrammatic Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Strobogrammatic%20Number.java) -336|[Next Greater Element I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Next%20Greater%20Element%20I.java) -337|[Remove Outermost Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Outermost%20Parentheses.java) -338|[Replace All ?'s to Avoid Consecutive Repeating Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Replace%20All%20?'s%20to%20Avoid%20Consecutive%20Repeating%20Characters.java) -339|[Two Sum Less Than K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum%20Less%20Than%20K.java) -340|[Majority Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Majority%20Element.java) -341|[Merge Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Sorted%20Array.java) -342|[Unique Morse Code Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Unique%20Morse%20Code%20Words.java) -343|[Divisor Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Divisor%20Game.java) -344|[Find Numbers with Even Number of Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Numbers%20with%20Even%20Number%20of%20Digits.java) -345|[Implement Queue using Stacks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Implement%20Queue%20using%20Stacks.java) -346|[N-ary Tree Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-ary%20Tree%20Preorder%20Traversal.java) -347|[Delete node in a linked list](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20node%20in%20a%20linked%20list.java) -348|[Sort Array By Parity II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Array%20By%20Parity%20II.java) -349|[Most Visited Sector in a Circular Track](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Most%20Visited%20Sector%20in%20a%20Circular%20Track.java) -350|[Greatest Common Divisor of Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Greatest%20Common%20Divisor%20of%20Strings.java) -351|[Remove Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Element.java) -352|[Maximum Subarray Sum I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Subarray%20Sum%20I.java) -353|[Partition Array Into Three Parts With Equal Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Partition%20Array%20Into%20Three%20Parts%20With%20Equal%20Sum.java) -354|[Remove Duplicates From Sorted Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Duplicates%20From%20Sorted%20Lists.java) -355|[Meeting Rooms](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Meeting%20Rooms.java) -356|[Crawler Log Folder](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Crawler%20Log%20Folder.java) -357|[Range Sum Query Immutable](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Range%20Sum%20Query%20Immutable.java) -358|[Intersection of two Linked Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20two%20Linked%20Lists.java) -359|[Can Place Flowers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Can%20Place%20Flowers.java) -360|[Generate a String With Characters That Have Odd Counts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Generate%20a%20String%20With%20Characters%20That%20Have%20Odd%20Counts.java) -361|[Array Partition I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Array%20Partition%20I.java) -362|[Next Greater Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Next%20Greater%20Element.java) -363|[Perfect Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Perfect%20Number.java) -364|[Sum of Digits in the Minimum Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Digits%20in%20the%20Minimum%20Number.java) -365|[Guess Number Higher or Lower](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Guess%20Number%20Higher%20or%20Lower.java) -366|[Self Dividing Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Self%20Dividing%20Number.java) -367|[Design HashMap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20HashMap.java) -368|[Minimum Time to Type Word Using Special Typewriter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Time%20to%20Type%20Word%20Using%20Special%20Typewriter.java) -369|[Search in a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Search%20in%20a%20Binary%20Search%20Tree.java) -370|[Count Largest Group](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Largest%20Group.java) -371|[Sum of Unique Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Unique%20Elements.java) -372|[Moving Average from Data Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Moving%20Average%20from%20Data%20Stream.java) -373|[Symmetric Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Symmetric%20Tree.java) -374|[Maximum Product of Two Elements in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Product%20of%20Two%20Elements%20in%20an%20Array.java) -375|[Find Common Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Common%20Characters.java) -376|[Lucky Numbers in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Lucky%20Numbers%20in%20a%20Matrix.java) -377|[Remove Vowels from a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Vowels%20from%20a%20String.java) -378|[Add Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Add%20Digits.java) -379|[Contains Duplicate II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Contains%20Duplicate%20II.java) -380|[Two City Scheduling](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20City%20Scheduling.java) -381|[Minimum Index Sum of Two Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Index%20Sum%20of%20Two%20Lists.java) -382|[contains_duplicates](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/contains_duplicates.java) -383|[Closest Binary Search Tree Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Closest%20Binary%20Search%20Tree%20Value.java) -384|[Sum of Digits in Base K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Digits%20in%20Base%20K.java) -385|[Distribute Candies to People](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Distribute%20Candies%20to%20People.java) -386|[Distribute Candies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Distribute%20Candies.java) -387|[Check If a Number Is Majority Element in a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20a%20Number%20Is%20Majority%20Element%20in%20a%20Sorted%20Array.java) -388|[Path Sum III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Path%20Sum%20III.java) -389|[Verifying an Alien Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Verifying%20an%20Alien%20Dictionary.java) -390|[Longest Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Palindrome.java) -391|[Sum of All Odd Length Subarrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20All%20Odd%20Length%20Subarrays.java) -392|[Average Salary Excluding the Minimum and Maximum Salary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Average%20Salary%20Excluding%20the%20Minimum%20and%20Maximum%20Salary.java) -393|[Single Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Single%20Number.java) -394|[Keyboard Row](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Keyboard%20Row.java) -395|[Squares of a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Squares%20of%20a%20Sorted%20Array.java) -396|[Rearrange Spaces Between Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rearrange%20Spaces%20Between%20Words.java) -397|[Count Square Sum Triples](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Square%20Sum%20Triples.java) -398|[Maximum Distance in Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Distance%20in%20Arrays.java) -399|[Unique Number of Occurrences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Unique%20Number%20of%20Occurrences.java) -400|[Day of the Week](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Day%20of%20the%20Week.java) -401|[Minimum Distance Between BST Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Distance%20Between%20BST%20Nodes.java) -402|[Number of Students Unable to Eat Lunch](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Students%20Unable%20to%20Eat%20Lunch.java) -403|[Search Insert Position](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Search%20Insert%20Position.java) -404|[Longest Univalue Path](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Univalue%20Path.java) -405|[Maximum Depth of N-ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Depth%20of%20N-ary%20Tree.java) -406|[Thousand Separator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Thousand%20Separator.java) -407|[Add Binary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Add%20Binary.java) -408|[Convert Binary Number in a Linked List to Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%20Binary%20Number%20in%20a%20Linked%20List%20to%20Integer.java) -409|[Sorting the Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sorting%20the%20Sentence.java) -410|[Replace Elements with Greatest Element on Right Side](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Replace%20Elements%20with%20Greatest%20Element%20on%20Right%20Side.java) -411|[Matrix Diagonal Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Matrix%20Diagonal%20Sum.java) -412|[Check Array Formation Through Concatenation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20Array%20Formation%20Through%20Concatenation.java) -413|[Water Bottles](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Water%20Bottles.java) -414|[Add to Array-Form of Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Add%20to%20Array-Form%20of%20Integer.java) -415|[Fibonacci Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fibonacci%20Numbers.java) -416|[Missing Number In Arithmetic Progression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Missing%20Number%20In%20Arithmetic%20Progression.java) -417|[Maximum Number of Balls in a Box](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Balls%20in%20a%20Box.java) -418|[Mean of Array After Removing Some Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Mean%20of%20Array%20After%20Removing%20Some%20Elements.java) -419|[N-Repeated Element in Size 2N Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-Repeated%20Element%20in%20Size%202N%20Array.java) -420|[Redistribute Characters to Make All Strings Equal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Redistribute%20Characters%20to%20Make%20All%20Strings%20Equal.java) -421|[Remove All Adjacent Duplicates In String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20All%20Adjacent%20Duplicates%20In%20String.java) -422|[Minimum Absolute Difference in BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20%20Absolute%20Difference%20in%20BST.java) -423|[Image Smoother](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Image%20Smoother.java) -424|[How Many Apples Can You Put into the Basket](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/How%20Many%20Apples%20Can%20You%20Put%20into%20the%20Basket.java) -425|[Second Minimum Node in a binary tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Second%20Minimum%20Node%20in%20a%20binary%20tree.java) -426|[Excel Sheet Column Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Excel%20Sheet%20Column%20Number.java) -427|[Same Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Same%20Tree.java) -428|[Count Odd Numbers in an Interval Range](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Odd%20Numbers%20in%20an%20Interval%20Range.java) -429|[String Without AAA or BBB](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/String%20Without%20AAA%20or%20BBB.java) -430|[Find Greatest Common Divisor of Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Greatest%20Common%20Divisor%20of%20Array.java) -431|[Shortest Unsorted Continuous Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Unsorted%20Continuous%20Subarray.java) -432|[Longest Word in Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Word%20in%20Dictionary.java) -433|[Happy Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Happy%20Number.java) -434|[Array Transformation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Array%20Transformation.java) -435|[Design Compressed String Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20Compressed%20String%20Iterator.java) -436|[Reverse words in a String III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20words%20in%20a%20String%20III.java) -437|[Rank Transform of an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rank%20Transform%20of%20an%20Array.java) -438|[First Bad Version](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/First%20Bad%20Version.java) -439|[Sort Integers by The Number of 1 Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Integers%20by%20The%20Number%20of%201%20Bits.java) -440|[sum_of_two_integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/sum_of_two_integers.java) -441|[Construct String from Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Construct%20String%20from%20Binary%20Tree.java) -442|[Toeplitz Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Toeplitz%20Matrix.java) -443|[Second Largest Digit in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Second%20Largest%20Digit%20in%20a%20String.java) -444|[Valid Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Palindrome.java) -445|[Relative Sort Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Relative%20Sort%20Array.java) -446|[Path In Zigzag Labelled Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Path%20In%20Zigzag%20Labelled%20Binary%20Tree.java) -447|[Shortest Completing Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Completing%20Word.java) -448|[Nim Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Nim%20Game.java) -449|[Count Substrings with Only One Distinct Letter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Substrings%20with%20Only%20One%20Distinct%20Letter.java) -450|[Average of Levels in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Average%20of%20Levels%20in%20Binary%20Tree.java) -451|[Merge Strings Alternately](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Strings%20Alternately.java) +1 | [1-bit and 2-bit Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/1-bit%20and%202-bit%20Characters.java) +2 | [A Number After a Double Reversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/A%20Number%20After%20a%20Double%20Reversal.java) +3 | [Add Binary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Add%20Binary.java) +4 | [Add Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Add%20Digits.java) +5 | [Add Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Add%20Strings.java) +6 | [Add to Array-Form of Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Add%20to%20Array-Form%20of%20Integer.java) +7 | [Alternating Digit Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Alternating%20Digit%20Sum.java) +8 | [Apply Operations to an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Apply%20Operations%20to%20an%20Array.java) +9 | [Armstrong Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Armstrong%20Number.java) +10 | [Arranging Coins](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Arranging%20Coins.java) +11 | [Array Partition I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Array%20Partition%20I.java) +12 | [Array Transformation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Array%20Transformation.java) +13 | [Assign Cookies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Assign%20Cookies.java) +14 | [Available Captures for Rook](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Available%20Captures%20for%20Rook.java) +15 | [Average Salary Excluding the Minimum and Maximum Salary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Average%20Salary%20Excluding%20the%20Minimum%20and%20Maximum%20Salary.java) +16 | [Average Value of Even Numbers That Are Divisible by Three](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Average%20Value%20of%20Even%20Numbers%20That%20Are%20Divisible%20by%20Three.java) +17 | [Average of Levels in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Average%20of%20Levels%20in%20Binary%20Tree.java) +18 | [Backspace String Compare](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Backspace%20String%20Compare.java) +19 | [Balanced Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Balanced%20Binary%20Tree.java) +20 | [Base 7](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Base%207.java) +21 | [Baseball Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Baseball%20Game.java) +22 | [Best Poker Hand](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Best%20Poker%20Hand.java) +23 | [Best Time to Buy and Sell Stock](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Best%20Time%20to%20Buy%20and%20Sell%20Stock.java) +24 | [Binary Gap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Gap.java) +25 | [Binary Number with Alternating Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Number%20with%20Alternating%20Bits.java) +26 | [Binary Prefix Divisible By 5](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Prefix%20Divisible%20By%205.java) +27 | [Binary Search](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Search.java) +28 | [Binary Tree Inorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Tree%20Inorder%20Traversal.java) +29 | [Binary Tree Level Order Traversal II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Tree%20Level%20Order%20Traversal%20II.java) +30 | [Binary Tree Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Tree%20Paths.java) +31 | [Binary Tree Postorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Tree%20Postorder%20Traversal.java) +32 | [Binary Tree Tilt](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Tree%20Tilt.java) +33 | [Binary Watch](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Watch.java) +34 | [Buddy Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Buddy%20Strings.java) +35 | [Build Array from Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Build%20Array%20from%20Permutation.java) +36 | [Build an Array With Stack Operations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Build%20an%20Array%20With%20Stack%20Operations.java) +37 | [Bulls and Cows](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Bulls%20and%20Cows.java) +38 | [Calculate Amount Paid in Taxes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Calculate%20Amount%20Paid%20in%20Taxes.java) +39 | [Calculate Digit Sum of a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Calculate%20Digit%20Sum%20of%20a%20String.java) +40 | [Calculate Money in Leetcode Bank](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Calculate%20Money%20in%20Leetcode%20Bank.java) +41 | [Can Make Arithmetic Progression From Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Can%20Make%20Arithmetic%20Progression%20From%20Sequence.java) +42 | [Can Place Flowers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Can%20Place%20Flowers.java) +43 | [Capitalize the Title](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Capitalize%20the%20Title.java) +44 | [Categorize Box According to Criteria](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Categorize%20Box%20According%20to%20Criteria.java) +45 | [Cells in a Range on an Excel Sheet](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Cells%20in%20a%20Range%20on%20an%20Excel%20Sheet.java) +46 | [Cells with Odd Values in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Cells%20with%20Odd%20Values%20in%20a%20Matrix.java) +47 | [Check Array Formation Through Concatenation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20Array%20Formation%20Through%20Concatenation.java) +48 | [Check Distances Between Same Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20Distances%20Between%20Same%20Letters.java) +49 | [Check If It Is a Straight Line](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20It%20Is%20a%20Straight%20Line.java) +50 | [Check If N and Its Double Exist](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20N%20and%20Its%20Double%20Exist.java) +51 | [Check If String Is a Prefix of Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20String%20Is%20a%20Prefix%20of%20Array.java) +52 | [Check If Two String Arrays are Equivalent](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20Two%20String%20Arrays%20are%20Equivalent.java) +53 | [Check If a Number Is Majority Element in a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20a%20Number%20Is%20Majority%20Element%20in%20a%20Sorted%20Array.java) +54 | [Check If a Word Occurs As a Prefix of Any Word in a Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20a%20Word%20Occurs%20As%20a%20Prefix%20of%20Any%20Word%20in%20a%20Sentence.java) +55 | [Check Whether Two Strings are Almost Equivalent](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20Whether%20Two%20Strings%20are%20Almost%20Equivalent.java) +56 | [Check if All A's Appears Before All B's](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20All%20A's%20Appears%20Before%20All%20B's.java) +57 | [Check if All Characters Have Equal Number of Occurrences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20All%20Characters%20Have%20Equal%20Number%20of%20Occurrences.java) +58 | [Check if All the Integers in a Range Are Covered](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20All%20the%20Integers%20in%20a%20Range%20Are%20Covered.java) +59 | [Check if Array Is Sorted and Rotated](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Array%20Is%20Sorted%20and%20Rotated.java) +60 | [Check if Binary String Has at Most One Segment of Ones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Binary%20String%20Has%20at%20Most%20One%20Segment%20of%20Ones.java) +61 | [Check if Every Row and Column Contains All Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Every%20Row%20and%20Column%20Contains%20All%20Numbers.java) +62 | [Check if Matrix Is X-Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Matrix%20Is%20X-Matrix.java) +63 | [Check if Number Has Equal Digit Count and Digit Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Number%20Has%20Equal%20Digit%20Count%20and%20Digit%20Value.java) +64 | [Check if Numbers Are Ascending in a Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Numbers%20Are%20Ascending%20in%20a%20Sentence.java) +65 | [Check if One String Swap Can Make Strings Equal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20One%20String%20Swap%20Can%20Make%20Strings%20Equal.java) +66 | [Check if String Is Decomposable Into Value-Equal Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20String%20Is%20Decomposable%20Into%20Value-Equal%20Substrings.java) +67 | [Check if Word Equals Summation of Two Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Word%20Equals%20Summation%20of%20Two%20Words.java) +68 | [Check if an Array Is Consecutive](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20an%20Array%20Is%20Consecutive.java) +69 | [Check if the Sentence Is Pangram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20the%20Sentence%20Is%20Pangram.java) +70 | [Circular Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Circular%20Sentence.java) +71 | [Climbing Stairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Climbing%20Stairs.java) +72 | [Closest Binary Search Tree Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Closest%20Binary%20Search%20Tree%20Value.java) +73 | [Compare Strings by Frequency of the Smallest Character](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Compare%20Strings%20by%20Frequency%20of%20the%20Smallest%20Character.java) +74 | [Complement of Base 10 Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Complement%20of%20Base%2010%20Integer.java) +75 | [Concatenation of Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Concatenation%20of%20Array.java) +76 | [Confusing Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Confusing%20Number.java) +77 | [Consecutive Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Consecutive%20Characters.java) +78 | [Construct String from Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Construct%20String%20from%20Binary%20Tree.java) +79 | [Construct the rectangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Construct%20the%20rectangle.java) +80 | [Contains Duplicate II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Contains%20Duplicate%20II.java) +81 | [Contains Duplicate](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Contains%20Duplicate.java) +82 | [Convert 1D Array Into 2D Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%201D%20Array%20Into%202D%20Array.java) +83 | [Convert BST to Greater Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%20BST%20to%20Greater%20Tree.java) +84 | [Convert Binary Number in a Linked List to Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%20Binary%20Number%20in%20a%20Linked%20List%20to%20Integer.java) +85 | [Convert Sorted Array To Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%20Sorted%20Array%20To%20Binary%20Search%20Tree.java) +86 | [Convert a number to hexadecimal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%20a%20number%20to%20hexadecimal.java) +87 | [Convert the Temperature](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%20the%20Temperature.java) +88 | [Count Asterisks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Asterisks.java) +89 | [Count Binary Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Binary%20Substrings.java) +90 | [Count Common Words With One Occurrence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Common%20Words%20With%20One%20Occurrence.java) +91 | [Count Distinct Numbers on Board](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Distinct%20Numbers%20on%20Board.java) +92 | [Count Elements With Strictly Smaller and Greater Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Elements%20With%20Strictly%20Smaller%20and%20Greater%20Elements.java) +93 | [Count Equal and Divisible Pairs in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Equal%20and%20Divisible%20Pairs%20in%20an%20Array.java) +94 | [Count Good Triplets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Good%20Triplets.java) +95 | [Count Hills and Valleys in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Hills%20and%20Valleys%20in%20an%20Array.java) +96 | [Count Integers With Even Digit Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Integers%20With%20Even%20Digit%20Sum.java) +97 | [Count Items Matching a Rule](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Items%20Matching%20a%20Rule.java) +98 | [Count Largest Group](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Largest%20Group.java) +99 | [Count Negative Numbers in a Sorted Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Negative%20Numbers%20in%20a%20Sorted%20Matrix.java) +100 | [Count Number of Pairs With Absolute Difference K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Number%20of%20Pairs%20With%20Absolute%20Difference%20K.java) +101 | [Count Odd Numbers in an Interval Range](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Odd%20Numbers%20in%20an%20Interval%20Range.java) +102 | [Count Operations to Obtain Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Operations%20to%20Obtain%20Zero.java) +103 | [Count Pairs Of Similar Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Pairs%20Of%20Similar%20Strings.java) +104 | [Count Prefixes of a Given String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Prefixes%20of%20a%20Given%20String.java) +105 | [Count Primes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Primes.java) +106 | [Count Special Quadruplets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Special%20Quadruplets.java) +107 | [Count Square Sum Triples](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Square%20Sum%20Triples.java) +108 | [Count Substrings with Only One Distinct Letter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Substrings%20with%20Only%20One%20Distinct%20Letter.java) +109 | [Count Vowel Substrings of a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Vowel%20Substrings%20of%20a%20String.java) +110 | [Count of Matches in Tournament](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20of%20Matches%20in%20Tournament.java) +111 | [Count the Digits That Divide a Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20the%20Digits%20That%20Divide%20a%20Number.java) +112 | [Count the Number of Consistent Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20the%20Number%20of%20Consistent%20Strings.java) +113 | [Counting Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Counting%20Bits.java) +114 | [Counting Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Counting%20Elements.java) +115 | [Counting Words With a Given Prefix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Counting%20Words%20With%20a%20Given%20Prefix.java) +116 | [Cousins in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Cousins%20in%20Binary%20Tree.java) +117 | [Crawler Log Folder](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Crawler%20Log%20Folder.java) +118 | [Create Target Array in the Given Order](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Create%20Target%20Array%20in%20the%20Given%20Order.java) +119 | [DI String Match](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/DI%20String%20Match.java) +120 | [Day of the Week](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Day%20of%20the%20Week.java) +121 | [Day of the Year](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Day%20of%20the%20Year.java) +122 | [Decode XORed Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Decode%20XORed%20Array.java) +123 | [Decode the Message](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Decode%20the%20Message.java) +124 | [Decompress Run-Length Encoded List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Decompress%20Run-Length%20Encoded%20List.java) +125 | [Decrypt String from Alphabet to Integer Mapping](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Decrypt%20String%20from%20Alphabet%20to%20Integer%20Mapping.java) +126 | [Defanging an IP Address](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Defanging%20an%20IP%20Address.java) +127 | [Defuse the Bomb](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Defuse%20the%20Bomb.java) +128 | [Degree of an array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Degree%20of%20an%20array.java) +129 | [Delete Characters to Make Fancy String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20Characters%20to%20Make%20Fancy%20String.java) +130 | [Delete Columns to Make Sorted](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20Columns%20to%20Make%20Sorted.java) +131 | [Delete N Nodes After M Nodes of a Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20N%20Nodes%20After%20M%20Nodes%20of%20a%20Linked%20List.java) +132 | [Delete Node in a Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20Node%20in%20a%20Linked%20List.java) +133 | [Design Compressed String Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20Compressed%20String%20Iterator.java) +134 | [Design HashMap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20HashMap.java) +135 | [Design HashSet](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20HashSet.java) +136 | [Design Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20Linked%20List.java) +137 | [Design Parking System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20Parking%20System.java) +138 | [Design an Ordered Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20an%20Ordered%20Stream.java) +139 | [Design an Ordered System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20an%20Ordered%20System.java) +140 | [Destination City](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Destination%20City.java) +141 | [Detect Capital](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Detect%20Capital.java) +142 | [Detect Pattern of Length M Repeated K or More Times](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Detect%20Pattern%20of%20Length%20M%20Repeated%20K%20or%20More%20Times.java) +143 | [Determine Color of a Chessboard Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Determine%20Color%20of%20a%20Chessboard%20Square.java) +144 | [Determine Whether Matrix Can Be Obtained By Rotation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Determine%20Whether%20Matrix%20Can%20Be%20Obtained%20By%20Rotation.java) +145 | [Determine if String Halves Are Alike](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Determine%20if%20String%20Halves%20Are%20Alike.java) +146 | [Determine if Two Events Have Conflict](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Determine%20if%20Two%20Events%20Have%20Conflict.java) +147 | [Diameter of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Diameter%20of%20Binary%20Tree.java) +148 | [Diet Plan Performance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Diet%20Plan%20Performance.java) +149 | [Difference Between Element Sum and Digit Sum of an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Difference%20Between%20Element%20Sum%20and%20Digit%20Sum%20of%20an%20Array.java) +150 | [Distance Between Bus Stops](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Distance%20Between%20Bus%20Stops.java) +151 | [Distribute Candies to People](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Distribute%20Candies%20to%20People.java) +152 | [Distribute Candies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Distribute%20Candies.java) +153 | [Divide Array Into Equal Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Divide%20Array%20Into%20Equal%20Pairs.java) +154 | [Divide a String Into Groups of Size k](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Divide%20a%20String%20Into%20Groups%20of%20Size%20k.java) +155 | [Divisor Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Divisor%20Game.java) +156 | [Duplicate Zeros](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Duplicate%20Zeros.java) +157 | [Element Appearing More Than 25% In Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Element%20Appearing%20More%20Than%2025%%20In%20Sorted%20Array.java) +158 | [Employee Importance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Employee%20Importance.java) +159 | [Evaluate Boolean Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Evaluate%20Boolean%20Binary%20Tree.java) +160 | [Excel Sheet Column Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Excel%20Sheet%20Column%20Number.java) +161 | [Excel Sheet Column Title](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Excel%20Sheet%20Column%20Title.java) +162 | [Factorial Trailing Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Factorial%20Trailing%20Zeroes.java) +163 | [Fair Candy Swap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fair%20Candy%20Swap.java) +164 | [Fibonacci Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fibonacci%20Number.java) +165 | [Final Prices With a Special Discount in a Shop](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Final%20Prices%20With%20a%20Special%20Discount%20in%20a%20Shop.java) +166 | [Final Value of Variable After Performing Operations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Final%20Value%20of%20Variable%20After%20Performing%20Operations.java) +167 | [Find All K-Distant Indices in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20All%20K-Distant%20Indices%20in%20an%20Array.java) +168 | [Find All Numbers Disappeared in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20All%20Numbers%20Disappeared%20in%20an%20Array.java) +169 | [Find All the Lonely Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20All%20the%20Lonely%20Nodes.java) +170 | [Find Anagram Mappings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Anagram%20Mappings.java) +171 | [Find Closest Number to Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Closest%20Number%20to%20Zero.java) +172 | [Find Common Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Common%20Characters.java) +173 | [Find First Palindromic String in the Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20First%20Palindromic%20String%20in%20the%20Array.java) +174 | [Find Greatest Common Divisor of Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Greatest%20Common%20Divisor%20of%20Array.java) +175 | [Find Lucky Integer in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Lucky%20Integer%20in%20an%20Array.java) +176 | [Find Mode in Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Mode%20in%20Binary%20Search%20Tree.java) +177 | [Find N Unique Integers Sum up to Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20N%20Unique%20Integers%20Sum%20up%20to%20Zero.java) +178 | [Find Nearest Point That Has the Same X or Y Coordinate](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Nearest%20Point%20That%20Has%20the%20Same%20X%20or%20Y%20Coordinate.java) +179 | [Find Numbers with Even Number of Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Numbers%20with%20Even%20Number%20of%20Digits.java) +180 | [Find Pivot Index](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Pivot%20Index.java) +181 | [Find Positive Integer Solution for a Given Equation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Positive%20Integer%20Solution%20for%20a%20Given%20Equation.java) +182 | [Find Resultant Array After Removing Anagrams](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Resultant%20Array%20After%20Removing%20Anagrams.java) +183 | [Find Smallest Letter Greater Than Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Smallest%20Letter%20Greater%20Than%20Target.java) +184 | [Find Subarrays With Equal Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Subarrays%20With%20Equal%20Sum.java) +185 | [Find Target Indices After Sorting Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Target%20Indices%20After%20Sorting%20Array.java) +186 | [Find Winner on a Tic Tac Toe Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Winner%20on%20a%20Tic%20Tac%20Toe%20Game.java) +187 | [Find Words That Can Be Formed by Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Words%20That%20Can%20Be%20Formed%20by%20Characters.java) +188 | [Find if Path Exists in Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20if%20Path%20Exists%20in%20Graph.java) +189 | [Find the Array Concatenation Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Array%20Concatenation%20Value.java) +190 | [Find the Difference of Two Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Difference%20of%20Two%20Arrays.java) +191 | [Find the Distance Value Between Two Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Distance%20Value%20Between%20Two%20Arrays.java) +192 | [Find the Highest Altitude](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Highest%20Altitude.java) +193 | [Find the K-Beauty of a Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20K-Beauty%20of%20a%20Number.java) +194 | [Find the Middle Index in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Middle%20Index%20in%20Array.java) +195 | [Find the Town Judge](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Town%20Judge.java) +196 | [Find the difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20difference.java) +197 | [Finding 3-Digit Even Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Finding%203-Digit%20Even%20Numbers.java) +198 | [First Bad Version](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/First%20Bad%20Version.java) +199 | [First Letter to Appear Twice](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/First%20Letter%20to%20Appear%20Twice.java) +200 | [First Unique Character in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/First%20Unique%20Character%20in%20a%20String.java) +201 | [Fixed Point](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fixed%20Point.java) +202 | [Fizz Buzz](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fizz%20Buzz.java) +203 | [Flip Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flip%20Game.java) +204 | [Flipping an Image](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flipping%20an%20Image.java) +205 | [Flood Fill](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flood%20Fill.java) +206 | [Flower Planting With No Adjacent](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flower%20Planting%20With%20No%20Adjacent.java) +207 | [Generate a String With Characters That Have Odd Counts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Generate%20a%20String%20With%20Characters%20That%20Have%20Odd%20Counts.java) +208 | [Get Maximum in Generated Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Get%20Maximum%20in%20Generated%20Array.java) +209 | [Goal Parser Interpretation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Goal%20Parser%20Interpretation.java) +210 | [Goat Latin](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Goat%20Latin.java) +211 | [Greatest Common Divisor of Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Greatest%20Common%20Divisor%20of%20Strings.java) +212 | [Greatest English Letter in Upper and Lower Case](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Greatest%20English%20Letter%20in%20Upper%20and%20Lower%20Case.java) +213 | [Groups of Special-Equivalent Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Groups%20of%20Special-Equivalent%20Strings.java) +214 | [Guess Number Higher or Lower](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Guess%20Number%20Higher%20or%20Lower.java) +215 | [Hamming Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Hamming%20Distance.java) +216 | [Happy Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Happy%20Number.java) +217 | [Heaters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Heaters.java) +218 | [Height Checker](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Height%20Checker.java) +219 | [Hexspeak](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Hexspeak.java) +220 | [High Five](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/High%20Five.java) +221 | [How Many Apples Can You Put into the Basket](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/How%20Many%20Apples%20Can%20You%20Put%20into%20the%20Basket.java) +222 | [How Many Numbers Are Smaller Than the Current Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/How%20Many%20Numbers%20Are%20Smaller%20Than%20the%20Current%20Number.java) +223 | [Image Smoother](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Image%20Smoother.java) +224 | [Implement Queue using Stacks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Implement%20Queue%20using%20Stacks.java) +225 | [Implement Stack using Queues](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Implement%20Stack%20using%20Queues.java) +226 | [Implement strStr](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Implement%20strStr.java) +227 | [Increasing Decreasing String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Increasing%20Decreasing%20String.java) +228 | [Increasing Order Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Increasing%20Order%20Search%20Tree.java) +229 | [Index Pairs of a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Index%20Pairs%20of%20a%20String.java) +230 | [Intersection of Multiple Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20Multiple%20Arrays.java) +231 | [Intersection of Three Sorted Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20Three%20Sorted%20Arrays.java) +232 | [Intersection of Two Arrays II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20Two%20Arrays%20II.java) +233 | [Intersection of Two Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20Two%20Arrays.java) +234 | [Intersection of two Linked Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20two%20Linked%20Lists.java) +235 | [Invert Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Invert%20Binary%20Tree.java) +236 | [Is Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Is%20Subsequence.java) +237 | [Island Perimeter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Island%20Perimeter.java) +238 | [Isomorphic Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Isomorphic%20Strings.java) +239 | [Jewels and Stones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Jewels%20and%20Stones.java) +240 | [Judge Route Cycle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Judge%20Route%20Cycle.java) +241 | [K-diff Pairs in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/K-diff%20Pairs%20in%20an%20Array.java) +242 | [Keep Multiplying Found Values by Two](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Keep%20Multiplying%20Found%20Values%20by%20Two.java) +243 | [Keyboard Row](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Keyboard%20Row.java) +244 | [Kids With the Greatest Number of Candies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Kids%20With%20the%20Greatest%20Number%20of%20Candies.java) +245 | [Kth Distinct String in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Kth%20Distinct%20String%20in%20an%20Array.java) +246 | [Kth Largest Element in a Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Kth%20Largest%20Element%20in%20a%20Stream.java) +247 | [Kth Missing Positive Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Kth%20Missing%20Positive%20Number.java) +248 | [Largest 3-Same-Digit Number in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%203-Same-Digit%20Number%20in%20String.java) +249 | [Largest Local Values in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Local%20Values%20in%20a%20Matrix.java) +250 | [Largest Number After Digit Swaps by Parity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Number%20After%20Digit%20Swaps%20by%20Parity.java) +251 | [Largest Number At Least Twice of Others](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Number%20At%20Least%20Twice%20of%20Others.java) +252 | [Largest Odd Number in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Odd%20Number%20in%20String.java) +253 | [Largest Perimeter Triangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Perimeter%20Triangle.java) +254 | [Largest Positive Integer That Exists With Its Negative](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Positive%20Integer%20That%20Exists%20With%20Its%20Negative.java) +255 | [Largest Substring Between Two Equal Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Substring%20Between%20Two%20Equal%20Characters.java) +256 | [Largest Triangle Area](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Triangle%20Area.java) +257 | [Largest Unique Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Unique%20Number.java) +258 | [Last Stone Weight](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Last%20Stone%20Weight.java) +259 | [Latest Time by Replacing Hidden Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Latest%20Time%20by%20Replacing%20Hidden%20Digits.java) +260 | [Leaf-Similar Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Leaf-Similar%20Trees.java) +261 | [Lemonade Change](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Lemonade%20Change.java) +262 | [Length of last word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Length%20of%20last%20word.java) +263 | [Letter Case Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Letter%20Case%20Permutation.java) +264 | [License Key Formatting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/License%20Key%20Formatting.java) +265 | [Linked List Cycle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Linked%20List%20Cycle.java) +266 | [Logger Rate Limiter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Logger%20Rate%20Limiter.java) +267 | [Long Pressed Name](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Long%20Pressed%20Name.java) +268 | [Longer Contiguous Segments of Ones than Zeros](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longer%20Contiguous%20Segments%20of%20Ones%20than%20Zeros.java) +269 | [Longest Common Prefix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Common%20Prefix.java) +270 | [Longest Continuous Increasing Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Continuous%20Increasing%20Subsequence.java) +271 | [Longest Harmonious Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Harmonious%20Subsequence.java) +272 | [Longest Nice Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Nice%20Substring.java) +273 | [Longest Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Palindrome.java) +274 | [Longest Subsequence With Limited Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Subsequence%20With%20Limited%20Sum.java) +275 | [Longest Uncommon Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Uncommon%20Subsequence.java) +276 | [Longest Univalue Path](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Univalue%20Path.java) +277 | [Longest Word in Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Word%20in%20Dictionary.java) +278 | [Lowest Common Ancestor of a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Lowest%20Common%20Ancestor%20of%20a%20Binary%20Search%20Tree.java) +279 | [Lucky Numbers in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Lucky%20Numbers%20in%20a%20Matrix.java) +280 | [Magic Squares In Grid](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Magic%20Squares%20In%20Grid.java) +281 | [Majority Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Majority%20Element.java) +282 | [Make Array Zero by Subtracting Equal Amounts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Make%20Array%20Zero%20by%20Subtracting%20Equal%20Amounts.java) +283 | [Make The String Great](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Make%20The%20String%20Great.java) +284 | [Matrix Cells in Distance Order](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Matrix%20Cells%20in%20Distance%20Order.java) +285 | [Matrix Diagonal Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Matrix%20Diagonal%20Sum.java) +286 | [Max Consecutive Ones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Max%20Consecutive%20Ones.java) +287 | [Maximize Sum Of Array After K Negations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximize%20Sum%20Of%20Array%20After%20K%20Negations.java) +288 | [Maximum 69 Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%2069%20Number.java) +289 | [Maximum Ascending Subarray Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Ascending%20Subarray%20Sum.java) +290 | [Maximum Average Subarray I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Average%20Subarray%20I.java) +291 | [Maximum Count of Positive Integer and Negative Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Count%20of%20Positive%20Integer%20and%20Negative%20Integer.java) +292 | [Maximum Depth of N-ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Depth%20of%20N-ary%20Tree.java) +293 | [Maximum Difference Between Increasing Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Difference%20Between%20Increasing%20Elements.java) +294 | [Maximum Distance in Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Distance%20in%20Arrays.java) +295 | [Maximum Enemy Forts That Can Be Captured](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Enemy%20Forts%20That%20Can%20Be%20Captured.java) +296 | [Maximum Nesting Depth of the Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Nesting%20Depth%20of%20the%20Parentheses.java) +297 | [Maximum Number of Balloons](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Balloons.java) +298 | [Maximum Number of Balls in a Box](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Balls%20in%20a%20Box.java) +299 | [Maximum Number of Pairs in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Pairs%20in%20Array.java) +300 | [Maximum Number of Words Found in Sentences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Words%20Found%20in%20Sentences.java) +301 | [Maximum Number of Words You Can Type](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Words%20You%20Can%20Type.java) +302 | [Maximum Population Year](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Population%20Year.java) +303 | [Maximum Product Difference Between Two Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Product%20Difference%20Between%20Two%20Pairs.java) +304 | [Maximum Product of Three Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Product%20of%20Three%20Numbers.java) +305 | [Maximum Product of Two Elements in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Product%20of%20Two%20Elements%20in%20an%20Array.java) +306 | [Maximum Repeating Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Repeating%20Substring.java) +307 | [Maximum Subarray Sum I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Subarray%20Sum%20I.java) +308 | [Maximum Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Subarray.java) +309 | [Maximum Units on a Truck](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Units%20on%20a%20Truck.java) +310 | [Maximum Value of a String in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Value%20of%20a%20String%20in%20an%20Array.java) +311 | [Maximum depth of Binary tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20depth%20of%20Binary%20tree.java) +312 | [Mean of Array After Removing Some Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Mean%20of%20Array%20After%20Removing%20Some%20Elements.java) +313 | [Meeting Rooms](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Meeting%20Rooms.java) +314 | [Merge Similar Items](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Similar%20Items.java) +315 | [Merge Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Sorted%20Array.java) +316 | [Merge Strings Alternately](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Strings%20Alternately.java) +317 | [Merge Two Sorted Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Two%20Sorted%20Lists.java) +318 | [Merge two binary trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20two%20binary%20trees.java) +319 | [Middle of the linked list](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Middle%20of%20the%20linked%20list.java) +320 | [Min Cost Climbing Stairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Min%20Cost%20Climbing%20Stairs.java) +321 | [Min Max Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Min%20Max%20Game.java) +322 | [Minimum Absolute Difference in BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20%20Absolute%20Difference%20in%20BST.java) +323 | [Minimum Absolute Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Absolute%20Difference.java) +324 | [Minimum Amount of Time to Fill Cups](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Amount%20of%20Time%20to%20Fill%20Cups.java) +325 | [Minimum Bit Flips to Convert Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Bit%20Flips%20to%20Convert%20Number.java) +326 | [Minimum Changes To Make Alternating Binary String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Changes%20To%20Make%20Alternating%20Binary%20String.java) +327 | [Minimum Common Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Common%20Value.java) +328 | [Minimum Cost of Buying Candies With Discount](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Cost%20of%20Buying%20Candies%20With%20Discount.java) +329 | [Minimum Cost to Move Chips to The Same Position](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Cost%20to%20Move%20Chips%20to%20The%20Same%20Position.java) +330 | [Minimum Cuts to Divide a Circle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Cuts%20to%20Divide%20a%20Circle.java) +331 | [Minimum Depth of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Depth%20of%20a%20Binary%20Tree.java) +332 | [Minimum Difference Between Highest and Lowest of K Scores](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Difference%20Between%20Highest%20and%20Lowest%20of%20K%20Scores.java) +333 | [Minimum Distance Between BST Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Distance%20Between%20BST%20Nodes.java) +334 | [Minimum Distance to the Target Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Distance%20to%20the%20Target%20Element.java) +335 | [Minimum Hours of Training to Win a Competition](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Hours%20of%20Training%20to%20Win%20a%20Competition.java) +336 | [Minimum Index Sum of Two Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Index%20Sum%20of%20Two%20Lists.java) +337 | [Minimum Moves to Convert String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Moves%20to%20Convert%20String.java) +338 | [Minimum Moves to Equal an Array Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Moves%20to%20Equal%20an%20Array%20Element.java) +339 | [Minimum Number of Moves to Seat Everyone](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Number%20of%20Moves%20to%20Seat%20Everyone.java) +340 | [Minimum Number of Operations to Convert Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Number%20of%20Operations%20to%20Convert%20Time.java) +341 | [Minimum Operations to Make the Array Increasing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Operations%20to%20Make%20the%20Array%20Increasing.java) +342 | [Minimum Recolors to Get K Consecutive Black Blocks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Recolors%20to%20Get%20K%20Consecutive%20Black%20Blocks.java) +343 | [Minimum Subsequence in Non-Increasing Order](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Subsequence%20in%20Non-Increasing%20Order.java) +344 | [Minimum Sum of Four Digit Number After Splitting Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Sum%20of%20Four%20Digit%20Number%20After%20Splitting%20Digits.java) +345 | [Minimum Time Visiting All Points](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Time%20Visiting%20All%20Points.java) +346 | [Minimum Time to Type Word Using Special Typewriter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Time%20to%20Type%20Word%20Using%20Special%20Typewriter.java) +347 | [Minimum Value to Get Positive Step by Step Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Value%20to%20Get%20Positive%20Step%20by%20Step%20Sum.java) +348 | [Minimum_index_sum_of_two_lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum_index_sum_of_two_lists.java) +349 | [Missing Number In Arithmetic Progression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Missing%20Number%20In%20Arithmetic%20Progression.java) +350 | [Missing Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Missing%20Number.java) +351 | [Missing Ranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Missing%20Ranges.java) +352 | [Monotonic Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Monotonic%20Array.java) +353 | [Most Common Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Most%20Common%20Word.java) +354 | [Most Frequent Even Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Most%20Frequent%20Even%20Element.java) +355 | [Most Frequent Number Following Key In an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Most%20Frequent%20Number%20Following%20Key%20In%20an%20Array.java) +356 | [Most Visited Sector in a Circular Track](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Most%20Visited%20Sector%20in%20a%20Circular%20Track.java) +357 | [Move Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Move%20Zeroes.java) +358 | [Moving Average from Data Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Moving%20Average%20from%20Data%20Stream.java) +359 | [N-Repeated Element in Size 2N Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-Repeated%20Element%20in%20Size%202N%20Array.java) +360 | [N-ary Tree Postorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-ary%20Tree%20Postorder%20Traversal.java) +361 | [N-ary Tree Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-ary%20Tree%20Preorder%20Traversal.java) +362 | [N-th Tribonacci Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-th%20Tribonacci%20Number.java) +363 | [Nested List Weight Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Nested%20List%20Weight%20Sum.java) +364 | [Next Greater Element I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Next%20Greater%20Element%20I.java) +365 | [Next Greater Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Next%20Greater%20Element.java) +366 | [Nim Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Nim%20Game.java) +367 | [Number Complement](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20Complement.java) +368 | [Number Of Rectangles That Can Form The Largest Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20Of%20Rectangles%20That%20Can%20Form%20The%20Largest%20Square.java) +369 | [Number of 1 bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%201%20bits.java) +370 | [Number of Arithmetic Triplets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Arithmetic%20Triplets.java) +371 | [Number of Boomerangs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Boomerangs.java) +372 | [Number of Common Factors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Common%20Factors.java) +373 | [Number of Days Between Two Dates](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Days%20Between%20Two%20Dates.java) +374 | [Number of Days in a Month](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Days%20in%20a%20Month.java) +375 | [Number of Different Integers in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Different%20Integers%20in%20a%20String.java) +376 | [Number of Distinct Averages](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Distinct%20Averages.java) +377 | [Number of Equivalent Domino Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Equivalent%20Domino%20Pairs.java) +378 | [Number of Good Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Good%20Pairs.java) +379 | [Number of Lines To Write String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Lines%20To%20Write%20String.java) +380 | [Number of Recent Calls](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Recent%20Calls.java) +381 | [Number of Steps to Reduce a Number to Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Steps%20to%20Reduce%20a%20Number%20to%20Zero.java) +382 | [Number of Strings That Appear as Substrings in Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Strings%20That%20Appear%20as%20Substrings%20in%20Word.java) +383 | [Number of Students Doing Homework at a Given Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Students%20Doing%20Homework%20at%20a%20Given%20Time.java) +384 | [Number of Students Unable to Eat Lunch](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Students%20Unable%20to%20Eat%20Lunch.java) +385 | [Number of Unequal Triplets in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Unequal%20Triplets%20in%20Array.java) +386 | [Number of Valid Words in a Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Valid%20Words%20in%20a%20Sentence.java) +387 | [Number of segments in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20segments%20in%20a%20String.java) +388 | [Occurrences After Bigram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Occurrences%20After%20Bigram.java) +389 | [Odd String Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Odd%20String%20Difference.java) +390 | [Paint Fence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Paint%20Fence.java) +391 | [Paint House](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Paint%20House.java) +392 | [Pairs of Songs With Total Durations Divisible by 60](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Pairs%20of%20Songs%20With%20Total%20Durations%20Divisible%20by%2060.java) +393 | [Palindrome Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Palindrome%20Linked%20List.java) +394 | [Palindrome Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Palindrome%20Number.java) +395 | [Palindrome Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Palindrome%20Permutation.java) +396 | [Partition Array Into Three Parts With Equal Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Partition%20Array%20Into%20Three%20Parts%20With%20Equal%20Sum.java) +397 | [Pascal's Triangle II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Pascal's%20Triangle%20II.java) +398 | [Pascal's Triangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Pascal's%20Triangle.java) +399 | [Path Crossing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Path%20Crossing.java) +400 | [Path In Zigzag Labelled Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Path%20In%20Zigzag%20Labelled%20Binary%20Tree.java) +401 | [Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Path%20Sum.java) +402 | [Peak Index in a Mountain Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Peak%20Index%20in%20a%20Mountain%20Array.java) +403 | [Percentage of Letter in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Percentage%20of%20Letter%20in%20String.java) +404 | [Perfect Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Perfect%20Number.java) +405 | [Perform String Shifts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Perform%20String%20Shifts.java) +406 | [Plus One](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Plus%20One.java) +407 | [Positions of Large Groups](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Positions%20of%20Large%20Groups.java) +408 | [Power of Four](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Power%20of%20Four.java) +409 | [Power of Three](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Power%20of%20Three.java) +410 | [Power of Two](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Power%20of%20Two.java) +411 | [Powerful Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Powerful%20Integers.java) +412 | [Projection Area of 3D Shapes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Projection%20Area%20of%203D%20Shapes.java) +413 | [Range Sum Query Immutable](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Range%20Sum%20Query%20Immutable.java) +414 | [Range Sum of BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Range%20Sum%20of%20BST.java) +415 | [Rank Transform of an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rank%20Transform%20of%20an%20Array.java) +416 | [Ransom Note](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Ransom%20Note.java) +417 | [Read N characters Given Read4](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Read%20N%20characters%20Given%20Read4.java) +418 | [Rearrange Characters to Make Target String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rearrange%20Characters%20to%20Make%20Target%20String.java) +419 | [Rearrange Spaces Between Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rearrange%20Spaces%20Between%20Words.java) +420 | [Rectangle Overlap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rectangle%20Overlap.java) +421 | [Redistribute Characters to Make All Strings Equal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Redistribute%20Characters%20to%20Make%20All%20Strings%20Equal.java) +422 | [Reformat Date](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reformat%20Date.java) +423 | [Reformat Phone Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reformat%20Phone%20Number.java) +424 | [Reformat The String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reformat%20The%20String.java) +425 | [Relative Sort Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Relative%20Sort%20Array.java) +426 | [Relative ranks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Relative%20ranks.java) +427 | [Remove All Adjacent Duplicates In String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20All%20Adjacent%20Duplicates%20In%20String.java) +428 | [Remove Digit From Number to Maximize Result](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Digit%20From%20Number%20to%20Maximize%20Result.java) +429 | [Remove Duplicates From Sorted Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Duplicates%20From%20Sorted%20Lists.java) +430 | [Remove Duplicates from Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Duplicates%20from%20Sorted%20Array.java) +431 | [Remove Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Element.java) +432 | [Remove Letter To Equalize Frequency](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Letter%20To%20Equalize%20Frequency.java) +433 | [Remove Linked List Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Linked%20List%20Elements.java) +434 | [Remove One Element to Make the Array Strictly Increasing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20One%20Element%20to%20Make%20the%20Array%20Strictly%20Increasing.java) +435 | [Remove Outermost Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Outermost%20Parentheses.java) +436 | [Remove Palindromic Subsequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Palindromic%20Subsequences.java) +437 | [Remove Vowels from a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Vowels%20from%20a%20String.java) +438 | [Repeated String Match](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Repeated%20String%20Match.java) +439 | [Repeated Substring Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Repeated%20Substring%20Pattern.java) +440 | [Replace All ?'s to Avoid Consecutive Repeating Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Replace%20All%20?'s%20to%20Avoid%20Consecutive%20Repeating%20Characters.java) +441 | [Replace All Digits with Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Replace%20All%20Digits%20with%20Characters.java) +442 | [Replace Elements with Greatest Element on Right Side](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Replace%20Elements%20with%20Greatest%20Element%20on%20Right%20Side.java) +443 | [Reshape the matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reshape%20the%20matrix.java) +444 | [Reverse Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Bits.java) +445 | [Reverse Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Linked%20List.java) +446 | [Reverse Only Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Only%20Letters.java) +447 | [Reverse Prefix of Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Prefix%20of%20Word.java) +448 | [Reverse String II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20String%20II.java) +449 | [Reverse String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20String.java) +450 | [Reverse Vowels of a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Vowels%20of%20a%20String.java) +451 | [Reverse words in a String III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20words%20in%20a%20String%20III.java) +452 | [Richest Customer Wealth](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Richest%20Customer%20Wealth.java) +453 | [Rings and Rods](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rings%20and%20Rods.java) +454 | [Robot Return to Origin](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Robot%20Return%20to%20Origin.java) +455 | [Roman to Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Roman%20to%20Integer.java) +456 | [Root Equals Sum of Children](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Root%20Equals%20Sum%20of%20Children.java) +457 | [Rotate String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rotate%20String.java) +458 | [Running Sum of 1d Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Running%20Sum%20of%201d%20Array.java) +459 | [Same Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Same%20Tree.java) +460 | [Search Insert Position](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Search%20Insert%20Position.java) +461 | [Search in a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Search%20in%20a%20Binary%20Search%20Tree.java) +462 | [Second Largest Digit in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Second%20Largest%20Digit%20in%20a%20String.java) +463 | [Second Minimum Node in a binary tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Second%20Minimum%20Node%20in%20a%20binary%20tree.java) +464 | [Self Dividing Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Self%20Dividing%20Number.java) +465 | [Sentence Similarity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sentence%20Similarity.java) +466 | [Separate the Digits in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Separate%20the%20Digits%20in%20an%20Array.java) +467 | [Set Mismatch](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Set%20Mismatch.java) +468 | [Shortest Completing Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Completing%20Word.java) +469 | [Shortest Distance to Target String in a Circular Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Distance%20to%20Target%20String%20in%20a%20Circular%20Array.java) +470 | [Shortest Distance to a Character](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Distance%20to%20a%20Character.java) +471 | [Shortest Word Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Word%20Distance.java) +472 | [Shuffle String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shuffle%20String.java) +473 | [Shuffle the Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shuffle%20the%20Array.java) +474 | [Sign of the Product of an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sign%20of%20the%20Product%20of%20an%20Array.java) +475 | [Similar RGB Color](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Similar%20RGB%20Color.java) +476 | [Single Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Single%20Number.java) +477 | [Single-Row Keyboard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Single-Row%20Keyboard.java) +478 | [Slowest Key](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Slowest%20Key.java) +479 | [Smallest Even Multiple](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Smallest%20Even%20Multiple.java) +480 | [Smallest Index With Equal Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Smallest%20Index%20With%20Equal%20Value.java) +481 | [Smallest Range I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Smallest%20Range%20I.java) +482 | [Sort Array By Parity II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Array%20By%20Parity%20II.java) +483 | [Sort Array By Parity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Array%20By%20Parity.java) +484 | [Sort Array by Increasing Frequency](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Array%20by%20Increasing%20Frequency.java) +485 | [Sort Even and Odd Indices Independently](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Even%20and%20Odd%20Indices%20Independently.java) +486 | [Sort Integers by The Number of 1 Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Integers%20by%20The%20Number%20of%201%20Bits.java) +487 | [Sort the People](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20the%20People.java) +488 | [Sorting the Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sorting%20the%20Sentence.java) +489 | [Special Array With X Elements Greater Than or Equal X](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Special%20Array%20With%20X%20Elements%20Greater%20Than%20or%20Equal%20X.java) +490 | [Special Positions in a Binary Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Special%20Positions%20in%20a%20Binary%20Matrix.java) +491 | [Split a String in Balanced Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Split%20a%20String%20in%20Balanced%20Strings.java) +492 | [SqrtX](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/SqrtX.java) +493 | [Squares of a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Squares%20of%20a%20Sorted%20Array.java) +494 | [String Matching in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/String%20Matching%20in%20an%20Array.java) +495 | [String Without AAA or BBB](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/String%20Without%20AAA%20or%20BBB.java) +496 | [Strobogrammatic Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Strobogrammatic%20Number.java) +497 | [Strong Password Checker II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Strong%20Password%20Checker%20II.java) +498 | [Student Attendance Record I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Student%20Attendance%20Record%20I.java) +499 | [Submission Detail](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Submission%20Detail.java) +500 | [Substrings of Size Three with Distinct Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Substrings%20of%20Size%20Three%20with%20Distinct%20Characters.java) +501 | [Subtract the Product and Sum of Digits of an Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Subtract%20the%20Product%20and%20Sum%20of%20Digits%20of%20an%20Integer.java) +502 | [Subtree of Another Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Subtree%20of%20Another%20Tree.java) +503 | [Sum Of Two Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20Of%20Two%20Integers.java) +504 | [Sum of All Odd Length Subarrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20All%20Odd%20Length%20Subarrays.java) +505 | [Sum of Digits in Base K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Digits%20in%20Base%20K.java) +506 | [Sum of Digits in the Minimum Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Digits%20in%20the%20Minimum%20Number.java) +507 | [Sum of Digits of String After Convert](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Digits%20of%20String%20After%20Convert.java) +508 | [Sum of Left Leaves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Left%20Leaves.java) +509 | [Sum of Root To Leaf Binary Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Root%20To%20Leaf%20Binary%20Numbers.java) +510 | [Sum of Square Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Square%20Numbers.java) +511 | [Sum of Unique Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Unique%20Elements.java) +512 | [Summary Ranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Summary%20Ranges.java) +513 | [Symmetric Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Symmetric%20Tree.java) +514 | [Take Gifts From the Richest Pile](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Take%20Gifts%20From%20the%20Richest%20Pile.java) +515 | [Teemo Attacking](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Teemo%20Attacking.java) +516 | [Teoplitz Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Teoplitz%20Matrix.java) +517 | [The Employee That Worked on the Longest Task](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/The%20Employee%20That%20Worked%20on%20the%20Longest%20Task.java) +518 | [The K Weakest Rows in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/The%20K%20Weakest%20Rows%20in%20a%20Matrix.java) +519 | [Third Maximum Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Third%20Maximum%20Number.java) +520 | [Thousand Separator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Thousand%20Separator.java) +521 | [Three Consecutive Odds](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Three%20Consecutive%20Odds.java) +522 | [Three Divisors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Three%20Divisors.java) +523 | [Time Needed to Buy Tickets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Time%20Needed%20to%20Buy%20Tickets.java) +524 | [To Lower Case](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/To%20Lower%20Case.java) +525 | [Toeplitz Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Toeplitz%20Matrix.java) +526 | [Transpose Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Transpose%20Matrix.java) +527 | [Truncate Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Truncate%20Sentence.java) +528 | [Two Furthest Houses With Different Colors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Furthest%20Houses%20With%20Different%20Colors.java) +529 | [Two Out of Three](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Out%20of%20Three.java) +530 | [Two Sum III - Data Structure Design](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum%20III%20-%20Data%20Structure%20Design.java) +531 | [Two Sum IV - Input is a BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum%20IV%20-%20Input%20is%20a%20BST.java) +532 | [Two Sum Less Than K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum%20Less%20Than%20K.java) +533 | [Two Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum.java) +534 | [Ugly Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Ugly%20Number.java) +535 | [Uncommon Words from Two Sentences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Uncommon%20Words%20from%20Two%20Sentences.java) +536 | [Unique Email Addresses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Unique%20Email%20Addresses.java) +537 | [Unique Morse Code Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Unique%20Morse%20Code%20Words.java) +538 | [Unique Number of Occurrences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Unique%20Number%20of%20Occurrences.java) +539 | [Univalued Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Univalued%20Binary%20Tree.java) +540 | [Valid Anagram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Anagram.java) +541 | [Valid Boomerang](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Boomerang.java) +542 | [Valid Mountain Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Mountain%20Array.java) +543 | [Valid Palindrome II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Palindrome%20II.java) +544 | [Valid Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Palindrome.java) +545 | [Valid Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Parentheses.java) +546 | [Valid Perfect Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Perfect%20Square.java) +547 | [Valid Word Abbreviation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Word%20Abbreviation.java) +548 | [Valid Word Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Word%20Sequence.java) +549 | [Valid Word Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Word%20Square.java) +550 | [Verifying an Alien Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Verifying%20an%20Alien%20Dictionary.java) +551 | [Water Bottles](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Water%20Bottles.java) +552 | [Word Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Word%20Pattern.java) +553 | [X of a Kind in a Deck of Cards](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/X%20of%20a%20Kind%20in%20a%20Deck%20of%20Cards.java) +554 | [XOR Operation in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/XOR%20Operation%20in%20an%20Array.java) +555 | [nim_game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/nim_game.java) +556 | [range_addition_II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/range_addition_II.java) +557 | [trailing_zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/trailing_zeroes.java) diff --git a/Hard/README.md b/Hard/README.md index 06ab9137..75b409d1 100644 --- a/Hard/README.md +++ b/Hard/README.md @@ -1,69 +1,97 @@ -# Hard LeetCode-Java-Solutions +# Hard LeetCode Java Solutions S.no | Coding Problem --- | --- -1|[Concatenated Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Concatenated%20Words.java) -2|[Remove Invalid Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Remove%20Invalid%20Parentheses.java) -3|[First Missing Positive](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/First%20Missing%20Positive.java) -4|[Frog Jump](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Frog%20Jump.java) -5|[Sliding Window Median](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Sliding%20Window%20Median.java) -6|[Edit Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Edit%20Distance.java) -7|[Merge K Sorted Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Merge%20K%20Sorted%20Lists.java) -8|[Sliding Window Maximum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Sliding%20Window%20Maximum.java) -9|[Text Justification](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Text%20Justification.java) -10|[Basic Calculator III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Basic%20Calculator%20III.java) -11|[Insert Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Insert%20Interval.java) -12|[Integer to English Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Integer%20to%20English%20Words.java) -13|[Median of Two Sorted Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Median%20of%20Two%20Sorted%20Arrays.java) -14|[Divide Array Into Increasing Sequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Divide%20Array%20Into%20Increasing%20Sequences.java) -15|[Word Break II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Word%20Break%20II.java) -16|[Maximum Number of Non-Overlapping Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Number%20of%20Non-Overlapping%20Substrings.java) -17|[Subarrays with K Different Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Subarrays%20with%20K%20Different%20Integers.java) -18|[Parallel Courses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Parallel%20Courses.java) -19|[LFU Cache](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/LFU%20Cache.java) -20|[Word Search II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Word%20Search%20II.java) -21|[K Empty Slots](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/K%20Empty%20Slots.java) -22|[Employee Free Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Employee%20Free%20Time.java) -23|[N-Queens](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/N-Queens.java) -24|[Longest Palindrome Product](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Longest%20Palindrome%20Product.java) -25|[Odd Even Jump](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Odd%20Even%20Jump.java) -26|[Palindrome Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Palindrome%20Pairs.java) -27|[Stream of Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Stream%20of%20Characters.java) -28|[Cut Off Trees for Golf Event](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Cut%20Off%20Trees%20for%20Golf%20Event.java) -29|[Minimize Deviation in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimize%20Deviation%20in%20Array.java) -30|[Minimum Cost to Hire K Workers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Cost%20to%20Hire%20K%20Workers.java) -31|[Number of Valid Subarrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Valid%20Subarrays.java) -32|[Substring with Concatenation of All Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Substring%20with%20Concatenation%20of%20All%20Words.java) -33|[Number of Paths with Max Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Paths%20with%20Max%20Score.java) -34|[Design Search Autocomplete System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Design%20Search%20Autocomplete%20System.java) -35|[LRU Cache](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/LRU%20Cache.java) -36|[Number of Squareful Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Squareful%20Arrays.java) -37|[Robot Room Cleaner](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Robot%20Room%20Cleaner.java) -38|[Minimum Window Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Window%20Substring.java) -39|[Hard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Hard.md) -40|[Parsing A Boolean Expression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Parsing%20A%20Boolean%20Expression.java) -41|[Trapping Rain Water](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Trapping%20Rain%20Water.java) -42|[Optimal Account Balancing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Optimal%20Account%20Balancing.java) -43|[Find Median From Data Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Find%20Median%20From%20Data%20Stream.java) -44|[Find Minimum in Rotated Sorted Array II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Find%20Minimum%20in%20Rotated%20Sorted%20Array%20II.java) -45|[Longest Substring with At Most Two Distinct Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Longest%20Substring%20with%20At%20Most%20Two%20Distinct%20Characters.java) -46|[Number of Submatrices That Sum to Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Submatrices%20That%20Sum%20to%20Target.java) -47|[Candy](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Candy.java) -48|[Shortest Distance from All Buildings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Shortest%20Distance%20from%20All%20Buildings.java) -49|[Recover a Tree From Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Recover%20a%20Tree%20From%20Preorder%20Traversal.java) -50|[Longest Increasing Path in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Longest%20Increasing%20Path%20in%20a%20Matrix.java) -51|[Interleaving String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Interleaving%20String.java) -52|[Closest Binary Search Tree Values II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Closest%20Binary%20Search%20Tree%20Values%20II.java) -53|[Basic Calculator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Basic%20Calculator.java) -54|[Prefix and Suffix Search](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Prefix%20and%20Suffix%20Search.java) -55|[Valid Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Valid%20Number.java) -56|[Maximum Frequency Stack](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Frequency%20Stack.java) -57|[Reverse Nodes in k-Group](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Reverse%20Nodes%20in%20k-Group.java) -58|[Longest Substring with At Most K Distinct Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Longest%20Substring%20with%20At%20Most%20K%20Distinct%20Characters.java) -59|[Serialize and Deserialize N-ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Serialize%20and%20Deserialize%20N-ary%20Tree.java) -60|[Serialize and Deserialize a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Serialize%20and%20Deserialize%20a%20Binary%20Tree.java) -61|[Binary Tree PostOrder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Binary%20Tree%20PostOrder%20Traversal.java) -62|[Unique Paths III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Unique%20Paths%20III.java) -63|[Insert Delete GetRandom O(1) - Duplicates Allowed](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Insert%20Delete%20GetRandom%20O(1)%20-%20Duplicates%20Allowed.java) -64|[Maximum Sum BST in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Sum%20BST%20in%20Binary%20Tree.java) -65|[Binary Tree Maximum Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Binary%20Tree%20Maximum%20Path%20Sum.java) -66|[Largest Rectangle in Histogram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Largest%20Rectangle%20in%20Histogram.java) +1 | [Add Edges to Make Degrees of All Nodes Even](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Add%20Edges%20to%20Make%20Degrees%20of%20All%20Nodes%20Even.java) +2 | [Basic Calculator III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Basic%20Calculator%20III.java) +3 | [Basic Calculator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Basic%20Calculator.java) +4 | [Best Time to Buy and Sell Stock IV](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Best%20Time%20to%20Buy%20and%20Sell%20Stock%20IV.java) +5 | [Binary Tree Cameras](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Binary%20Tree%20Cameras.java) +6 | [Binary Tree Maximum Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Binary%20Tree%20Maximum%20Path%20Sum.java) +7 | [Candy](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Candy.java) +8 | [Closest Binary Search Tree Values II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Closest%20Binary%20Search%20Tree%20Values%20II.java) +9 | [Concatenated Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Concatenated%20Words.java) +10 | [Construct Target Array With Multiple Sums](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Construct%20Target%20Array%20With%20Multiple%20Sums.java) +11 | [Count Vowels Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Count%20Vowels%20Permutation.java) +12 | [Count of Smaller Numbers After Self](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Count%20of%20Smaller%20Numbers%20After%20Self.java) +13 | [Course Schedule III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Course%20Schedule%20III.java) +14 | [Critical Connections in a Network](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Critical%20Connections%20in%20a%20Network.java) +15 | [Cut Off Trees for Golf Event](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Cut%20Off%20Trees%20for%20Golf%20Event.java) +16 | [Design In-Memory File System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Design%20In-Memory%20File%20System.java) +17 | [Design Movie Rental System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Design%20Movie%20Rental%20System.java) +18 | [Design Search Autocomplete System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Design%20Search%20Autocomplete%20System.java) +19 | [Design Skiplist](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Design%20Skiplist.java) +20 | [Dice Roll Simulation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Dice%20Roll%20Simulation.java) +21 | [Divide Array Into Increasing Sequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Divide%20Array%20Into%20Increasing%20Sequences.java) +22 | [Edit Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Edit%20Distance.java) +23 | [Employee Free Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Employee%20Free%20Time.java) +24 | [Expression Add Operators](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Expression%20Add%20Operators.java) +25 | [Find Median from Data Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Find%20Median%20from%20Data%20Stream.java) +26 | [Find Minimum in Rotated Sorted Array II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Find%20Minimum%20in%20Rotated%20Sorted%20Array%20II.java) +27 | [Find the Kth Smallest Sum of a Matrix With Sorted Rows](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Find%20the%20Kth%20Smallest%20Sum%20of%20a%20Matrix%20With%20Sorted%20Rows.java) +28 | [First Missing Positive](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/First%20Missing%20Positive.java) +29 | [Frog Jump](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Frog%20Jump.java) +30 | [Insert Delete GetRandom O(1) - Duplicates Allowed](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Insert%20Delete%20GetRandom%20O(1)%20-%20Duplicates%20Allowed.java) +31 | [Integer to English Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Integer%20to%20English%20Words.java) +32 | [K Empty Slots](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/K%20Empty%20Slots.java) +33 | [K Inverse Pairs Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/K%20Inverse%20Pairs%20Array.java) +34 | [Kth Smallest Number in Multiplication Table](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Kth%20Smallest%20Number%20in%20Multiplication%20Table.java) +35 | [LFU Cache](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/LFU%20Cache.java) +36 | [Largest Rectangle in Histogram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Largest%20Rectangle%20in%20Histogram.java) +37 | [Longest Increasing Path in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Longest%20Increasing%20Path%20in%20a%20Matrix.java) +38 | [Longest Palindrome Product](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Longest%20Palindrome%20Product.java) +39 | [Longest Valid Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Longest%20Valid%20Parentheses.java) +40 | [Max Points on a Line](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Max%20Points%20on%20a%20Line.java) +41 | [Max Stack](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Max%20Stack.java) +42 | [Maximum Frequency Stack](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Frequency%20Stack.java) +43 | [Maximum Number of Non-Overlapping Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Number%20of%20Non-Overlapping%20Substrings.java) +44 | [Maximum Performance of a Team](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Performance%20of%20a%20Team.java) +45 | [Maximum Profit in Job Scheduling](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Profit%20in%20Job%20Scheduling.java) +46 | [Maximum Sum BST in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Sum%20BST%20in%20Binary%20Tree.java) +47 | [Median of Two Sorted Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Median%20of%20Two%20Sorted%20Arrays.java) +48 | [Merge K Sorted Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Merge%20K%20Sorted%20Lists.java) +49 | [Minimize Deviation in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimize%20Deviation%20in%20Array.java) +50 | [Minimum Cost to Hire K Workers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Cost%20to%20Hire%20K%20Workers.java) +51 | [Minimum Difficulty of a Job Schedule](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Difficulty%20of%20a%20Job%20Schedule.java) +52 | [Minimum Number of Refueling Stops](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Number%20of%20Refueling%20Stops.java) +53 | [Minimum Window Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Window%20Subsequence.java) +54 | [Minimum Window Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Window%20Substring.java) +55 | [My Calendar III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/My%20Calendar%20III.java) +56 | [N-Queens II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/N-Queens%20II.java) +57 | [N-Queens](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/N-Queens.java) +58 | [Naming a Company](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Naming%20a%20Company.java) +59 | [Number of Paths with Max Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Paths%20with%20Max%20Score.java) +60 | [Number of Squareful Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Squareful%20Arrays.java) +61 | [Number of Submatrices That Sum to Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Submatrices%20That%20Sum%20to%20Target.java) +62 | [Number of Valid Subarrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Valid%20Subarrays.java) +63 | [Odd Even Jump](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Odd%20Even%20Jump.java) +64 | [Optimal Account Balancing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Optimal%20Account%20Balancing.java) +65 | [Paint House III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Paint%20House%20III.java) +66 | [Palindrome Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Palindrome%20Pairs.java) +67 | [Parsing A Boolean Expression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Parsing%20A%20Boolean%20Expression.java) +68 | [Perfect Rectangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Perfect%20Rectangle.java) +69 | [Poor Pigs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Poor%20Pigs.java) +70 | [Prefix and Suffix Search](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Prefix%20and%20Suffix%20Search.java) +71 | [Reconstruct Itinerary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Reconstruct%20Itinerary.java) +72 | [Recover a Tree From Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Recover%20a%20Tree%20From%20Preorder%20Traversal.java) +73 | [Remove Invalid Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Remove%20Invalid%20Parentheses.java) +74 | [Reverse Nodes in k-Group](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Reverse%20Nodes%20in%20k-Group.java) +75 | [Robot Room Cleaner](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Robot%20Room%20Cleaner.java) +76 | [Serialize and Deserialize N-ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Serialize%20and%20Deserialize%20N-ary%20Tree.java) +77 | [Serialize and Deserialize a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Serialize%20and%20Deserialize%20a%20Binary%20Tree.java) +78 | [Shortest Distance from All Buildings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Shortest%20Distance%20from%20All%20Buildings.java) +79 | [Sliding Window Maximum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Sliding%20Window%20Maximum.java) +80 | [Sliding Window Median](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Sliding%20Window%20Median.java) +81 | [Stamping The Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Stamping%20The%20Sequence.java) +82 | [Stream of Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Stream%20of%20Characters.java) +83 | [String Compression II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/String%20Compression%20II.java) +84 | [Subarrays with K Different Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Subarrays%20with%20K%20Different%20Integers.java) +85 | [Substring with Concatenation of All Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Substring%20with%20Concatenation%20of%20All%20Words.java) +86 | [Text Justification](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Text%20Justification.java) +87 | [The Skyline Problem](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/The%20Skyline%20Problem.java) +88 | [Trapping Rain Water](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Trapping%20Rain%20Water.java) +89 | [Unique Paths III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Unique%20Paths%20III.java) +90 | [Valid Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Valid%20Number.java) +91 | [Vertical Order Traversal Of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Vertical%20Order%20Traversal%20Of%20a%20Binary%20Tree.java) +92 | [Wildcard Matching](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Wildcard%20Matching.java) +93 | [Word Break II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Word%20Break%20II.java) +94 | [Word Search II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Word%20Search%20II.java) diff --git a/Medium/README.md b/Medium/README.md index 549b4e57..afdf245d 100644 --- a/Medium/README.md +++ b/Medium/README.md @@ -1,545 +1,741 @@ -# Medium LeetCode-Java-Solutions +# Medium LeetCode Java Solutions S.no | Coding Problem --- | --- -1|[Unique Paths II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Paths%20II.java) -2|[Missing Ranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Missing%20Ranges.java) -3|[First Unique Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/First%20Unique%20Number.java) -4|[Minimum Number of Vertices to Reach All Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Number%20of%20Vertices%20to%20Reach%20All%20Nodes.java) -5|[Inorder Successor in BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Inorder%20Successor%20in%20BST.java) -6|[3Sum Closest](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/3Sum%20Closest.java) -7|[Binary Tree Zigzag Level Order Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Zigzag%20Level%20Order%20Traversal.java) -8|[House Robber III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/House%20Robber%20III.java) -9|[Campus Bikes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Campus%20Bikes.java) -10|[Arithmetic Subarrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Arithmetic%20Subarrays.java) -11|[Grumpy Bookstore Owner](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Grumpy%20Bookstore%20Owner.java) -12|[Linked List Cycle II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20Cycle%20II.java) -13|[Reconstruct Itinerary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reconstruct%20Itinerary.java) -14|[Largest Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Largest%20Number.java) -15|[Web Crawler](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Web%20Crawler.java) -16|[Champagne Tower](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Champagne%20Tower.java) -17|[Candy Crush](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Candy%20Crush.java) -18|[Diagonal Traverse](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Diagonal%20Traverse.java) -19|[Shortest Way to Form String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Way%20to%20Form%20String.java) -20|[Masking Personal Information](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Masking%20Personal%20Information.java) -21|[The Earliest Moment When Everyone Become Friends](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20Earliest%20Moment%20When%20Everyone%20Become%20Friends.java) -22|[Divide Two Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Divide%20Two%20Integers.java) -23|[Minimum Cost to Connect Sticks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Cost%20to%20Connect%20Sticks.java) -24|[Lowest Common Ancestor of Deepest Leaves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lowest%20Common%20Ancestor%20of%20Deepest%20Leaves.java) -25|[Single Number III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Single%20Number%20III.java) -26|[Next Greater Element III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Greater%20Element%20III.java) -27|[Making File Names Unique](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Making%20File%20Names%20Unique.java) -28|[Validate Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Validate%20Binary%20Search%20Tree.java) -29|[Sparse Matrix Multiplication](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sparse%20Matrix%20Multiplication.java) -30|[Rectangle Overlap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rectangle%20Overlap.java) -31|[Uncrossed Lines](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Uncrossed%20Lines.java) -32|[Capacity To Ship Packages Within D Days](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Capacity%20To%20Ship%20Packages%20Within%20D%20Days.java) -33|[Set Matrix Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Set%20Matrix%20Zeroes.java) -34|[Flatten a Multilevel Doubly Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%20a%20Multilevel%20Doubly%20Linked%20List.java) -35|[Find Smallest Common Element in All Rows](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Smallest%20Common%20Element%20in%20All%20Rows.java) -36|[Non Overlapping Intervals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Non%20Overlapping%20Intervals.java) -37|[Most Stones Removed with Same Row or Column](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Most%20Stones%20Removed%20with%20Same%20Row%20or%20Column.java) -38|[Shortest Word Distance II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Word%20Distance%20II.java) -39|[Total Hamming Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Total%20Hamming%20Distance.java) -40|[Count Number of Homogenous Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Number%20of%20Homogenous%20Substrings.java) -41|[Score of Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Score%20of%20Parentheses.java) -42|[Gas Station](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Gas%20Station.java) -43|[Number of Subarrays with Bounded Maximum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Subarrays%20with%20Bounded%20Maximum.java) -44|[Palindrome Partitioning](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Palindrome%20Partitioning.java) -45|[Find all Duplicates in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20all%20Duplicates%20in%20an%20Array.java) -46|[Find Largest Value in Each Tree Row](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Largest%20Value%20in%20Each%20Tree%20Row.java) -47|[Flatten 2D Vector](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%202D%20Vector.java) -48|[Convert Binary Search Tree to Sorted Doubly Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Convert%20Binary%20Search%20Tree%20to%20Sorted%20Doubly%20Linked%20List.java) -49|[Design a File Sharing System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20a%20File%20Sharing%20System.java) -50|[Smallest String Starting From Leaf](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20String%20Starting%20From%20Leaf.java) -51|[Throne Inheritence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Throne%20Inheritence.java) -52|[Minimum Remove to Make Valid Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Remove%20to%20Make%20Valid%20Parentheses.java) -53|[Remove Covered Intervals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Covered%20Intervals.java) -54|[Minimum Add to Make Parentheses Valid](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Add%20to%20Make%20Parentheses%20Valid.java) -55|[Arithmetic Slices](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Arithmetic%20Slices.java) -56|[Binary Tree Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Preorder%20Traversal.java) -57|[Time Needed to Inform All Employees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Time%20Needed%20to%20Inform%20All%20Employees.java) -58|[Kill Process](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kill%20Process.java) -59|[Line Reflection](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Line%20Reflection.java) -60|[Maximum Number of Occurrences of a Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Occurrences%20of%20a%20Substring.java) -61|[Diameter of N-ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Diameter%20of%20N-ary%20Tree.java) -62|[Maximum Number of Non-Overlapping Subarrays With Sum Equals Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Non-Overlapping%20Subarrays%20With%20Sum%20Equals%20Target.java) -63|[Majority Element II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Majority%20Element%20II.java) -64|[Plus One Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Plus%20One%20Linked%20List.java) -65|[Longest Consecutive Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Consecutive%20Sequence.java) -66|[Find Minimum in Rotated Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Minimum%20in%20Rotated%20Sorted%20Array.java) -67|[Decrease Elements To Make Array Zigzag](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Decrease%20Elements%20To%20Make%20Array%20Zigzag.java) -68|[Binary Tree Longest Consecutive Sequence II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Longest%20Consecutive%20Sequence%20II.java) -69|[Bitwise AND of Numbers Range](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Bitwise%20AND%20of%20Numbers%20Range.java) -70|[Count Number of Teams](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Number%20of%20Teams.java) -71|[Prime Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Prime%20Palindrome.java) -72|[Minimum Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Path%20Sum.java) -73|[Friend Circles](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Friend%20Circles.java) -74|[Valid Sudoku](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Sudoku.java) -75|[Four Divisors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Four%20Divisors.java) -76|[As Far from Land as Possible](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/As%20Far%20from%20Land%20as%20Possible.java) -77|[Count Square Submatrices with All Ones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Square%20Submatrices%20with%20All%20Ones.java) -78|[Linked List in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20in%20Binary%20Tree.java) -79|[Number of Nodes in the Sub-Tree With the Same Label](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Nodes%20in%20the%20Sub-Tree%20With%20the%20Same%20Label.java) -80|[Pseudo-Palindromic Paths in a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pseudo-Palindromic%20Paths%20in%20a%20Binary%20Tree.java) -81|[Pancake Sorting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pancake%20Sorting.java) -82|[Walls and Gates](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Walls%20and%20Gates.java) -83|[Decode String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Decode%20String.java) -84|[Combination Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Combination%20Sum%20II.java) -85|[Complete Binary Tree Insertor](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Complete%20Binary%20Tree%20Insertor.java) -86|[Binary Tree Pruning](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Pruning.java) -87|[Escape The Ghosts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Escape%20The%20Ghosts.java) -88|[Longest Arithmetic Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Arithmetic%20Sequence.java) -89|[Find the Town Judge](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Town%20Judge.java) -90|[Count Numbers With Unique Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Numbers%20With%20Unique%20Digits.java) -91|[Maximum Average Subtree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Average%20Subtree.java) -92|[Product of Array Except self](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Product%20of%20Array%20Except%20self.java) -93|[Find Bottom Left Tree Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Bottom%20Left%20Tree%20Value.java) -94|[Shifting Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shifting%20Letters.java) -95|[Minimum Knight Moves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Knight%20Moves.java) -96|[Rotting Oranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotting%20Oranges.java) -97|[Palindromic Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Palindromic%20Substrings.java) -98|[Maximum of Absolute Value Expression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20of%20Absolute%20Value%20Expression.java) -99|[Is Graph Bipartite](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Is%20Graph%20Bipartite.java) -100|[Add Two Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20Two%20Numbers.java) -101|[Find Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Permutation.java) -102|[Number of Burgers with No Waste of Ingredients](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Burgers%20with%20No%20Waste%20of%20Ingredients.java) -103|[Finding the Users Active Minutes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Finding%20the%20Users%20Active%20Minutes.java) -104|[Validate Stack Sequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Validate%20Stack%20Sequences.java) -105|[Number of Substrings Containing All Three Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Substrings%20Containing%20All%20Three%20Characters.java) -106|[Next Greater Element II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Greater%20Element%20II.java) -107|[Maximum Score From Removing Stones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Score%20From%20Removing%20Stones.java) -108|[Score After Flipping Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Score%20After%20Flipping%20Matrix.java) -109|[Design Browser History](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Browser%20History.java) -110|[Meeting Scheduler](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Meeting%20Scheduler.java) -111|[Perfect Squares](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Perfect%20Squares.java) -112|[Word Search](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Word%20Search.java) -113|[Knight Dialer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Knight%20Dialer.java) -114|[3Sum Smaller](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/3Sum%20Smaller.java) -115|[Repeated DNA Sequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Repeated%20DNA%20Sequences.java) -116|[Construct K Palindrome Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20K%20Palindrome%20Strings.java) -117|[Solve the Equation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Solve%20the%20Equation.java) -118|[Average Waiting Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Average%20Waiting%20Time.java) -119|[Combination Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Combination%20Sum.java) -120|[Merge Intervals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Merge%20Intervals.java) -121|[4 Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/4%20Sum%20II.java) -122|[Advantage Shuffle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Advantage%20Shuffle.java) -123|[Number of Dice Rolls With Target Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Dice%20Rolls%20With%20Target%20Sum.java) -124|[Basic Calculator II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Basic%20Calculator%20II.java) -125|[Lonely Pixel I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lonely%20Pixel%20I.java) -126|[Guess Number Higher or Lower II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Guess%20Number%20Higher%20or%20Lower%20II.java) -127|[Remove Duplicate Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Duplicate%20Letters.java) -128|[Group the People Given the Group Size They Belong To](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Group%20the%20People%20Given%20the%20Group%20Size%20They%20Belong%20To.java) -129|[House Robber II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/House%20Robber%20II.java) -130|[Find the Winner of an Array Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Winner%20of%20an%20Array%20Game.java) -131|[Letter Combinations of a Phone Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Letter%20Combinations%20of%20a%20Phone%20Number.java) -132|[Implement Magic Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Implement%20Magic%20Dictionary.java) -133|[Task Scheduler](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Task%20Scheduler.java) -134|[Minimum Size Subarray Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Size%20Subarray%20Sum.java) -135|[Max Chunks To Make Sorted](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Chunks%20To%20Make%20Sorted.java) -136|[Max Number of K-Sum Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Number%20of%20K-Sum%20Pairs.java) -137|[Longest Word in Dictionary through Deleting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Word%20in%20Dictionary%20through%20Deleting.java) -138|[Maximum Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Binary%20Tree.java) -139|[Find and Replace in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20and%20Replace%20in%20String.java) -140|[Sort Characters By Frequency](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Characters%20By%20Frequency.java) -141|[Maximum Erasure Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Erasure%20Value.java) -142|[Number of Matching Subsequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Matching%20Subsequences.java) -143|[Camelcase Matching](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Camelcase%20Matching.java) -144|[Split Array into Consecutive Subsequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Split%20Array%20into%20Consecutive%20Subsequences.java) -145|[Integer To Roman](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Integer%20To%20Roman.java) -146|[Count Servers That Communicate](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Servers%20That%20Communicate.java) -147|[Minimize Maximum Pair Sum in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimize%20Maximum%20Pair%20Sum%20in%20Array.java) -148|[Construct Binary Tree from Inorder and Postorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20Binary%20Tree%20from%20Inorder%20and%20Postorder%20Traversal.java) -149|[Split Linked List into Parts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Split%20Linked%20List%20into%20Parts.java) -150|[Multiply Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Multiply%20Strings.java) -151|[Path With Minimum Effort](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20With%20Minimum%20Effort.java) -152|[Minimum Moves to Equal Array Elements II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Moves%20to%20Equal%20Array%20Elements%20II.java) -153|[Adding Two Negabinary Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Adding%20Two%20Negabinary%20Numbers.java) -154|[Nested List Weight Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Nested%20List%20Weight%20Sum%20II.java) -155|[Range Sum Query 2D-Immutable](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Sum%20Query%202D-Immutable.java) -156|[Remove Nth Node From End of List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Nth%20Node%20From%20End%20of%20List.java) -157|[Peeking Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Peeking%20Iterator.java) -158|[Subsets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subsets.java) -159|[Design Circular Queue](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Circular%20Queue.java) -160|[Single Element in a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Single%20Element%20in%20a%20Sorted%20Array.java) -161|[Permutations II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Permutations%20II.java) -162|[Knight Probability in Chessboard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Knight%20Probability%20in%20Chessboard.java) -163|[Longest ZigZag Path in a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20ZigZag%20Path%20in%20a%20Binary%20Tree.java) -164|[Reduce Array Size to The Half](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reduce%20Array%20Size%20to%20The%20Half.java) -165|[Maximum Length of Pair Chain](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Length%20of%20Pair%20Chain.java) -166|[Binary Tree Vertical Order Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Vertical%20Order%20Traversal.java) -167|[Maximum Product Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Product%20Subarray.java) -168|[Rotate List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20List.java) -169|[Find the Celebrity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Celebrity.java) -170|[Swap Nodes in Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Swap%20Nodes%20in%20Pairs.java) -171|[Filter Restaurants by Vegan-Friendly, Price and Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Filter%20Restaurants%20by%20Vegan-Friendly,%20Price%20and%20Distance.java) -172|[Evaluate Division](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Evaluate%20Division.java) -173|[Minimum Operations to Make Array Equal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Operations%20to%20Make%20Array%20Equal.java) -174|[Combinations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Combinations.java) -175|[Sort List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20List.java) -176|[Most Frequent Subtree Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Most%20Frequent%20Subtree%20Sum.java) -177|[Find Peak Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Peak%20Element.java) -178|[Open The Lock](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Open%20The%20Lock.java) -179|[Fruit Into Baskets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Fruit%20Into%20Baskets.java) -180|[Remove K Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20K%20Digits.java) -181|[Minimum Number of Steps to Make Two Strings Anagram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Number%20of%20Steps%20to%20Make%20Two%20Strings%20Anagram.java) -182|[Satisfisbility of Equality Equations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Satisfisbility%20of%20Equality%20Equations.java) -183|[Pour Water](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pour%20Water.java) -184|[Gray Code](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Gray%20Code.java) -185|[Encode and Decode TinyURL](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Encode%20and%20Decode%20TinyURL.java) -186|[Game of Life](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Game%20of%20Life.java) -187|[Time Based Key-Value Store](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Time%20Based%20Key-Value%20Store.java) -188|[Compare Version Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Compare%20Version%20Numbers.java) -189|[Maximum Number of Vowels in a Substring of Given Length](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Vowels%20in%20a%20Substring%20of%20Given%20Length.java) -190|[Graph Valid Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Graph%20Valid%20Tree.java) -191|[Minimum Operations to Reduce X to Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Operations%20to%20Reduce%20X%20to%20Zero.java) -192|[Group Anagrams](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Group%20Anagrams.java) -193|[Lowest Common Ancestor of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lowest%20Common%20Ancestor%20of%20a%20Binary%20Tree.java) -194|[Deepest Leaves Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Deepest%20Leaves%20Sum.java) -195|[Boundary of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Boundary%20of%20Binary%20Tree.java) -196|[Clone N-ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Clone%20N-ary%20Tree.java) -197|[Rotate Image](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20Image.java) -198|[Self Dividing Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Self%20Dividing%20Numbers.java) -199|[Map Sum Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Map%20Sum%20Pairs.java) -200|[Restore the Array From Adjacent Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Restore%20the%20Array%20From%20Adjacent%20Pairs.java) -201|[Find the Index of the Large Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Index%20of%20the%20Large%20Integer.java) -202|[Delete Leaves With a Given Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Leaves%20With%20a%20Given%20Value.java) -203|[Pow](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pow.java) -204|[Binary Tree Inorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Inorder%20Traversal.java) -205|[Remove Comments](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Comments.java) -206|[Next Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Permutation.java) -207|[Design Log Storage System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Log%20Storage%20System.java) -208|[Decode Ways](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Decode%20Ways.java) -209|[Number of Longest Increasing Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Longest%20Increasing%20Subsequence.java) -210|[Broken Calculator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Broken%20Calculator.java) -211|[Vowel Spellchecker](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Vowel%20Spellchecker.java) -212|[4Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/4Sum.java) -213|[Find Root of N-Ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Root%20of%20N-Ary%20Tree.java) -214|[Rotate Function](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20Function.java) -215|[Can Make Palindrome from Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Can%20Make%20Palindrome%20from%20Substring.java) -216|[Design Hit Counter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Hit%20Counter.java) -217|[Insert into a Sorted Circular Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20into%20a%20Sorted%20Circular%20Linked%20List.java) -218|[Online Stock Span](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Online%20Stock%20Span.java) -219|[Minimum Area Rectangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Area%20Rectangle.java) -220|[Invalid Transactions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Invalid%20Transactions.java) -221|[Remove All Occurrences of a Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20All%20Occurrences%20of%20a%20Substring.java) -222|[Is Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Is%20Subsequence.java) -223|[Search in Rotated Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20in%20Rotated%20Sorted%20Array.java) -224|[Letter Tiles Possibilities](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Letter%20Tiles%20Possibilities.java) -225|[Path with Maximum Gold](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20with%20Maximum%20Gold.java) -226|[Copy List with Random Pointer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Copy%20List%20with%20Random%20Pointer.java) -227|[Number of Islands](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Islands.java) -228|[Custom Sort String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Custom%20Sort%20String.java) -229|[Populating Next Right Pointers in Each Node](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Populating%20Next%20Right%20Pointers%20in%20Each%20Node.java) -230|[All Possible Full Binary Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Possible%20Full%20Binary%20Trees.java) -231|[Sum Root to Leaf Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20Root%20to%20Leaf%20Numbers.java) -232|[Contiguous Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Contiguous%20Array.java) -233|[Large Divisble Subset](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Large%20Divisble%20Subset.java) -234|[Minimum Height Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Height%20Trees.java) -235|[Analyze User Website Visit Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Analyze%20User%20Website%20Visit%20Pattern.java) -236|[Partitioning Into Minimum Number Of Deci-Binary Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partitioning%20Into%20Minimum%20Number%20Of%20Deci-Binary%20Numbers.java) -237|[Permutations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Permutations.java) -238|[Coin Change 2](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Coin%20Change%202.java) -239|[Construct Quad Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20Quad%20Tree.java) -240|[Valid Parenthesis String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Parenthesis%20String.java) -241|[Apply Discount Every n Orders](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Apply%20Discount%20Every%20n%20Orders.java) -242|[All Elements in Two Binary Search Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Elements%20in%20Two%20Binary%20Search%20Trees.java) -243|[Longest Substring Without Repeating Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Substring%20Without%20Repeating%20Characters.java) -244|[Fraction to Recurring Decimal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Fraction%20to%20Recurring%20Decimal.java) -245|[Product of the Last K Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Product%20of%20the%20Last%20K%20Numbers.java) -246|[Wiggle Sort](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Wiggle%20Sort.java) -247|[Accounts Merge](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Accounts%20Merge.java) -248|[Reverse Words in a String II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Words%20in%20a%20String%20II.java) -249|[Find Leaves of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Leaves%20of%20Binary%20Tree.java) -250|[Partition Labels](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partition%20Labels.java) -251|[Sort An Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20An%20Array.java) -252|[Hand of Straights](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Hand%20of%20Straights.java) -253|[Angle Between Hands of a Clock](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Angle%20Between%20Hands%20of%20a%20Clock.java) -254|[Reorder List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reorder%20List.java) -255|[Find a Corresponding Node of a Binary Tree in a Clone of That Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20a%20Corresponding%20Node%20of%20a%20Binary%20Tree%20in%20a%20Clone%20of%20That%20Tree.java) -256|[Odd Even Linked Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Odd%20Even%20Linked%20Lists.java) -257|[Find Right Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Right%20Interval.java) -258|[Dot Product of Two Sparse Vectors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Dot%20Product%20of%20Two%20Sparse%20Vectors.java) -259|[Minimum Number of Arrows to Burst Balloons](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Number%20of%20Arrows%20to%20Burst%20Balloons.java) -260|[HTML Entity Parser](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/HTML%20Entity%20Parser.java) -261|[Find All Anagrams in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20All%20Anagrams%20in%20a%20String.java) -262|[Boats to Save People](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Boats%20to%20Save%20People.java) -263|[Print Words Vertically](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Print%20Words%20Vertically.java) -264|[Sentence Similarity III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sentence%20Similarity%20III.java) -265|[Minimum Genetic Mutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Genetic%20Mutation.java) -266|[Split BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Split%20BST.java) -267|[Iterator for Combination](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Iterator%20for%20Combination.java) -268|[Valid Triangle Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Triangle%20Number.java) -269|[Keys and Rooms](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Keys%20and%20Rooms.java) -270|[Interval List Intersections](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Interval%20List%20Intersections.java) -271|[Subarray Sums Divisible by K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subarray%20Sums%20Divisible%20by%20K.java) -272|[Maximum Level Sum of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Level%20Sum%20of%20a%20Binary%20Tree.java) -273|[Expressive Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Expressive%20Words.java) -274|[Flatten Nested List Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%20Nested%20List%20Iterator.java) -275|[Corporate Flight Bookings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Corporate%20Flight%20Bookings.java) -276|[Unique Binary Search Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Binary%20Search%20Trees.java) -277|[Longest Increasing Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Increasing%20Subsequence.java) -278|[Design A Leaderboard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20A%20Leaderboard.java) -279|[Search in Rotated Sorted Array II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20in%20Rotated%20Sorted%20Array%20II.java) -280|[Tuple With Same Product](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Tuple%20With%20Same%20Product.java) -281|[Delete Nodes And Return Forest](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Nodes%20And%20Return%20Forest.java) -282|[The kth Factor of n](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20kth%20Factor%20of%20n.java) -283|[Minimum Time Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Time%20Difference.java) -284|[Maximum Length of Subarray With Positive Product](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Length%20of%20Subarray%20With%20Positive%20Product.java) -285|[Smallest Integer Divisible by K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20Integer%20Divisible%20by%20K.java) -286|[Remove Zero Sum Consecutive Nodes from Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Zero%20Sum%20Consecutive%20Nodes%20from%20Linked%20List.java) -287|[Validate IP Address](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Validate%20IP%20Address.java) -288|[Reduction Operations to Make the Array Elements Equal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reduction%20Operations%20to%20Make%20the%20Array%20Elements%20Equal.java) -289|[Cinema Seat Allocation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Cinema%20Seat%20Allocation.java) -290|[Delete Operation for Two Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Operation%20for%20Two%20Strings.java) -291|[Path with Maximum Probability](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20with%20Maximum%20Probability.java) -292|[Check If All 1's Are at Least Length K Places Away](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20If%20All%201's%20Are%20at%20Least%20Length%20K%20Places%20Away.java) -293|[RLE Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/RLE%20Iterator.java) -294|[Vertical Order Traversal Of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Vertical%20Order%20Traversal%20Of%20Binary%20Tree.java) -295|[Increasing Subsequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Increasing%20Subsequences.java) -296|[Number of Substrings With Only 1s](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Substrings%20With%20Only%201s.java) -297|[Delete Tree Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Tree%20Nodes.java) -298|[Exclusive Time of Functions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Exclusive%20Time%20of%20Functions.java) -299|[Check If a String Is a Valid Sequence from Root to Leaves Path in a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20If%20a%20String%20Is%20a%20Valid%20Sequence%20from%20Root%20to%20Leaves%20Path%20in%20a%20Binary%20Tree.java) -300|[Leftmost Column with at Least a One](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Leftmost%20Column%20with%20at%20Least%20a%20One.java) -301|[Subsets II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subsets%20II.java) -302|[One Edit Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/One%20Edit%20Distance.java) -303|[Swap For Longest Repeated Character Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Swap%20For%20Longest%20Repeated%20Character%20Substring.java) -304|[Find the Student that Will Replace the Chalk](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Student%20that%20Will%20Replace%20the%20Chalk.java) -305|[Container With Most Water](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Container%20With%20Most%20Water.java) -306|[4Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/4Sum%20II.java) -307|[Word Ladder](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Word%20Ladder.java) -308|[Delete Node in a BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Node%20in%20a%20BST.java) -309|[Longest Well-Performing Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Well-Performing%20Interval.java) -310|[Reconstruct Original Digits from English](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reconstruct%20Original%20Digits%20from%20English.java) -311|[Single Number II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Single%20Number%20II.java) -312|[Maximum Value after Insertion](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Value%20after%20Insertion.java) -313|[Optimal Division](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Optimal%20Division.java) -314|[Network Delay Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Network%20Delay%20Time.java) -315|[Flip Equivalent Binary Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flip%20Equivalent%20Binary%20Trees.java) -316|[Coin Change](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Coin%20Change.java) -317|[Max Consecutives Ones II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Consecutives%20Ones%20II.java) -318|[Kth Smallest Element in a BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kth%20Smallest%20Element%20in%20a%20BST.java) -319|[Remove Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Interval.java) -320|[Find Nearest Right Node in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Nearest%20Right%20Node%20in%20Binary%20Tree.java) -321|[Random Pick Index](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Random%20Pick%20Index.java) -322|[Distribute Coins in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Distribute%20Coins%20in%20Binary%20Tree.java) -323|[Path With Maximum Minimum Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20With%20Maximum%20Minimum%20Value.java) -324|[Partition List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partition%20List.java) -325|[Number of Distinct Islands](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Distinct%20Islands.java) -326|[Design Circular Deque](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Circular%20Deque.java) -327|[Implement Trie (Prefix Tree)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Implement%20Trie%20(Prefix%20Tree).java) -328|[Largest BST Subtree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Largest%20BST%20Subtree.java) -329|[Range Sum Query - Mutable](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Sum%20Query%20-%20Mutable.java) -330|[Mini Parser](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Mini%20Parser.java) -331|[Maximum Distance Between a Pair of Values](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Distance%20Between%20a%20Pair%20of%20Values.java) -332|[Alert Using Same Key-Card Three or More Times in a One Hour Period](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Alert%20Using%20Same%20Key-Card%20Three%20or%20More%20Times%20in%20a%20One%20Hour%20Period.java) -333|[Linked List Components](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20Components.java) -334|[Binary Tree Upside Down](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Upside%20Down.java) -335|[Max Increase to Keep City Skyline](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Increase%20to%20Keep%20City%20Skyline.java) -336|[Daily Temperatures](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Daily%20Temperatures.java) -337|[Binary Search Tree to Greater Sum Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Search%20Tree%20to%20Greater%20Sum%20Tree.java) -338|[Subarray Product Less Than K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subarray%20Product%20Less%20Than%20K.java) -339|[Design a Stack With Increment Operation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20a%20Stack%20With%20Increment%20Operation.java) -340|[Break a Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Break%20a%20Palindrome.java) -341|[Maximum Size Subarray Sum Equals k](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Size%20Subarray%20Sum%20Equals%20k.java) -342|[Subarray Sum Equals K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subarray%20Sum%20Equals%20K.java) -343|[Car Pooling](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Car%20Pooling.java) -344|[Remove Sub-Folders from the Filesystem](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Sub-Folders%20from%20the%20Filesystem.java) -345|[Add and Search Word - Data structure design](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20and%20Search%20Word%20-%20Data%20structure%20design.java) -346|[Sum of Nodes with Even-Valued Grandparent](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Nodes%20with%20Even-Valued%20Grandparent.java) -347|[Check If a String Can Break Another String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20If%20a%20String%20Can%20Break%20Another%20String.java) -348|[Ternary Expression Parser](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Ternary%20Expression%20Parser.java) -349|[Generate Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Generate%20Parentheses.java) -350|[Encode and Decode Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Encode%20and%20Decode%20Strings.java) -351|[Asteroid Collision](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Asteroid%20Collision.java) -352|[Minimum Deletion Cost to Avoid Repeating Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Deletion%20Cost%20to%20Avoid%20Repeating%20Letters.java) -353|[Design Phone Directory](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Phone%20Directory.java) -354|[Remove Duplicates from Sorted List II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Duplicates%20from%20Sorted%20List%20II.java) -355|[Random Pick With Weight](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Random%20Pick%20With%20Weight.java) -356|[Swapping Nodes in a Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Swapping%20Nodes%20in%20a%20Linked%20List.java) -357|[Number of Connected Components in an Undirected Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Connected%20Components%20in%20an%20Undirected%20Graph.java) -358|[Display Table of Food Orders in a Restaurant](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Display%20Table%20of%20Food%20Orders%20in%20a%20Restaurant.java) -359|[Campus Bikes II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Campus%20Bikes%20II.java) -360|[Longest Line of Consecutive One in Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Line%20of%20Consecutive%20One%20in%20Matrix.java) -361|[Zigzag Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Zigzag%20Iterator.java) -362|[Merge In Between Linked Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Merge%20In%20Between%20Linked%20Lists.java) -363|[Surrounded Regions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Surrounded%20Regions.java) -364|[Seat Reservation Manager](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Seat%20Reservation%20Manager.java) -365|[Print Immutable Linked List in Reverse](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Print%20Immutable%20Linked%20List%20in%20Reverse.java) -366|[Incremental Memory Leak](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Incremental%20Memory%20Leak.java) -367|[Reverse Words in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Words%20in%20a%20String.java) -368|[Simplify Path](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Simplify%20Path.java) -369|[Design Underground System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Underground%20System.java) -370|[Sequential Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sequential%20Digits.java) -371|[Shortest Path with Alternating Colors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Path%20with%20Alternating%20Colors.java) -372|[Find K Pairs with Smallest Sums](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20K%20Pairs%20with%20Smallest%20Sums.java) -373|[Check if There is a Valid Path in a Grid](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20if%20There%20is%20a%20Valid%20Path%20in%20a%20Grid.java) -374|[Ugly Number II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Ugly%20Number%20II.java) -375|[Find First and Last Position of Element in Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20First%20and%20Last%20Position%20of%20Element%20in%20Sorted%20Array.java) -376|[Clone Binary Tree With Random Pointer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Clone%20Binary%20Tree%20With%20Random%20Pointer.java) -377|[Longest Continuous Subarray With Absolute Diff Less Than or Equal to Limit](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Continuous%20Subarray%20With%20Absolute%20Diff%20Less%20Than%20or%20Equal%20to%20Limit.java) -378|[Super Ugly Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Super%20Ugly%20Number.java) -379|[Add Two Numbers II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20Two%20Numbers%20II.java) -380|[Implement Rand10() Using Rand7()](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Implement%20Rand10()%20Using%20Rand7().java) -381|[Minimum Deletions to Make Character Frequencies Unique](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Deletions%20to%20Make%20Character%20Frequencies%20Unique.java) -382|[Array Nesting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Array%20Nesting.java) -383|[Valid Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Square.java) -384|[Course Schedule](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Course%20Schedule.java) -385|[The k Strongest Values in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20k%20Strongest%20Values%20in%20an%20Array.java) -386|[Path Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20Sum%20II.java) -387|[Unique Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Paths.java) -388|[Replace Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Replace%20Words.java) -389|[Rank Teams by Votes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rank%20Teams%20by%20Votes.java) -390|[Jump Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Jump%20Game.java) -391|[Can Convert String in K Moves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Can%20Convert%20String%20in%20K%20Moves.java) -392|[Least Number of Unique Integers after K Removals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Least%20Number%20of%20Unique%20Integers%20after%20K%20Removals.java) -393|[Sum of Absolute Differences in a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Absolute%20Differences%20in%20a%20Sorted%20Array.java) -394|[Linked List Random Node](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20Random%20Node.java) -395|[Valid Tic-Tac-Toe State](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Tic-Tac-Toe%20State.java) -396|[Increasing Triplet Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Increasing%20Triplet%20Subsequence.java) -397|[Range Addition](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Addition.java) -398|[Insert Into a Cyclic Sorted List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20Into%20a%20Cyclic%20Sorted%20List.java) -399|[Count Submatrices With All Ones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Submatrices%20With%20All%20Ones.java) -400|[Shuffle an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shuffle%20an%20Array.java) -401|[Battleships in a board](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Battleships%20in%20a%20board.java) -402|[Shortest Path in Binary Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Path%20in%20Binary%20Matrix.java) -403|[Complex Number Multiplication](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Complex%20Number%20Multiplication.java) -404|[Queries on a Permutation With Key](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Queries%20on%20a%20Permutation%20With%20Key.java) -405|[Find Duplicate Subtrees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Duplicate%20Subtrees.java) -406|[Maximum Ice Cream Bars](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Ice%20Cream%20Bars.java) -407|[My Calendar I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/My%20Calendar%20I.java) -408|[Reorder Routes to Make All Paths Lead to the City Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reorder%20Routes%20to%20Make%20All%20Paths%20Lead%20to%20the%20City%20Zero.java) -409|[Evaluate Reverse Polish Notation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Evaluate%20Reverse%20Polish%20Notation.java) -410|[Maximum Width Ramp](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Width%20Ramp.java) -411|[Counting Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Counting%20Bits.java) -412|[Number of Sub-arrays of Size K and Average Greater than or Equal to Threshold](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Sub-arrays%20of%20Size%20K%20and%20Average%20Greater%20than%20or%20Equal%20to%20Threshold.java) -413|[Range Sum of Sorted Subarray Sums](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Sum%20of%20Sorted%20Subarray%20Sums.java) -414|[Find Center of Star Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Center%20of%20Star%20Graph.java) -415|[Add Bold Tag in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20Bold%20Tag%20in%20String.java) -416|[Reverse Linked List II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Linked%20List%20II.java) -417|[Permutation in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Permutation%20in%20String.java) -418|[Shortest Word Distance III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Word%20Distance%20III.java) -419|[Serialize and Deserialize BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Serialize%20and%20Deserialize%20BST.java) -420|[Minimum Domino Rotations For Equal Row](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Domino%20Rotations%20For%20Equal%20Row.java) -421|[132 Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/132%20Pattern.java) -422|[Remove All Adjacent Duplicates in String II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20All%20Adjacent%20Duplicates%20in%20String%20II.java) -423|[Insertion Sort List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insertion%20Sort%20List.java) -424|[Find the duplicate number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20duplicate%20number.java) -425|[Design Twitter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Twitter.java) -426|[Last Moment Before All Ants Fall Out of a Plank](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Last%20Moment%20Before%20All%20Ants%20Fall%20Out%20of%20a%20Plank.java) -427|[Sentence Similarity II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sentence%20Similarity%20II.java) -428|[Last Stone Weight II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Last%20Stone%20Weight%20II.java) -429|[Rectangle Area](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rectangle%20Area.java) -430|[My Calendar II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/My%20Calendar%20II.java) -431|[Search Suggestions System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20Suggestions%20System.java) -432|[Subrectangle Queries](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subrectangle%20Queries.java) -433|[Sort the Matrix Diagonally](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20the%20Matrix%20Diagonally.java) -434|[Convert Sorted List to Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Convert%20Sorted%20List%20to%20Binary%20Search%20Tree.java) -435|[Bulb Switcher](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Bulb%20Switcher.java) -436|[Verify Preorder Serialization of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Verify%20Preorder%20Serialization%20of%20a%20Binary%20Tree.java) -437|[Inorder Successor in BST II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Inorder%20Successor%20in%20BST%20II.java) -438|[Add Minimum Number of Rungs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20Minimum%20Number%20of%20Rungs.java) -439|[Find the City With the Smallest Number of Neighbors at a Threshold Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20City%20With%20the%20Smallest%20Number%20of%20Neighbors%20at%20a%20Threshold%20Distance.java) -440|[Output Contest Matches](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Output%20Contest%20Matches.java) -441|[H-Index](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/H-Index.java) -442|[Best Time to Buy and Sell Stock with Cooldown](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Best%20Time%20to%20Buy%20and%20Sell%20Stock%20with%20Cooldown.java) -443|[Rabbits in Forest](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rabbits%20in%20Forest.java) -444|[Count Univalue Subtrees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Univalue%20Subtrees.java) -445|[Find Elements in a Contaminated Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Elements%20in%20a%20Contaminated%20Binary%20Tree.java) -446|[Next Greater Node In Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Greater%20Node%20In%20Linked%20List.java) -447|[Find and Replace Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20and%20Replace%20Pattern.java) -448|[Design File System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20File%20System.java) -449|[Determine if Two Strings Are Close](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Determine%20if%20Two%20Strings%20Are%20Close.java) -450|[Maximum Absolute Sum of Any Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Absolute%20Sum%20of%20Any%20Subarray.java) -451|[Kth Largest Element in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kth%20Largest%20Element%20in%20an%20Array.java) -452|[The Number of Full Rounds You Have Played](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20Number%20of%20Full%20Rounds%20You%20Have%20Played.java) -453|[Snapshot Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Snapshot%20Array.java) -454|[Top K Frequent Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Top%20K%20Frequent%20Elements.java) -455|[Teemo Attacking](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Teemo%20Attacking.java) -456|[Smallest Subtree with all the Deepest Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20Subtree%20with%20all%20the%20Deepest%20Nodes.java) -457|[Maximal Network Rank](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximal%20Network%20Rank.java) -458|[Kth Smallest Element in a Sorted Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kth%20Smallest%20Element%20in%20a%20Sorted%20Matrix.java) -459|[Minimum Score Triangulation of Polygon](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Score%20Triangulation%20of%20Polygon.java) -460|[Binary Tree Coloring Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Coloring%20Game.java) -461|[Maximum Difference Between Node and Ancestor](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Difference%20Between%20Node%20and%20Ancestor.java) -462|[Combination Sum III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Combination%20Sum%20III.java) -463|[Find K Closest Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20K%20Closest%20Elements.java) -464|[01 Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/01%20Matrix.java) -465|[Clone Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Clone%20Graph.java) -466|[Longest Palindromic Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Palindromic%20Substring.java) -467|[Robot Bounded In Circle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Robot%20Bounded%20In%20Circle.java) -468|[Koko Eating Bananas](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Koko%20Eating%20Bananas.java) -469|[Statistics from a Large Sample](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Statistics%20from%20a%20Large%20Sample.java) -470|[Insert Delete GetRandom O(1)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20Delete%20GetRandom%20O(1).java) -471|[Snakes and Ladders](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Snakes%20and%20Ladders.java) -472|[Longest Palindromic Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Palindromic%20Subsequence.java) -473|[Sort Transformed Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Transformed%20Array.java) -474|[Search in a Sorted Array of Unknown Size](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20in%20a%20Sorted%20Array%20of%20Unknown%20Size.java) -475|[Count Complete Tree Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Complete%20Tree%20Nodes.java) -476|[Minesweeper](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minesweeper.java) -477|[String to Integer(atoi)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/String%20to%20Integer(atoi).java) -478|[Online Election](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Online%20Election.java) -479|[Find K-Length Substrings With No Repeated Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20K-Length%20Substrings%20With%20No%20Repeated%20Characters.java) -480|[Word Break](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Word%20Break.java) -481|[Find the Kth Largest Integer in the Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Kth%20Largest%20Integer%20in%20the%20Array.java) -482|[Flatten Binary Tree to Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%20Binary%20Tree%20to%20Linked%20List.java) -483|[Sort Colors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Colors.java) -484|[Longest Absolute File Path](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Absolute%20File%20Path.java) -485|[Prison Cells After N Days](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Prison%20Cells%20After%20N%20Days.java) -486|[Insert into a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20into%20a%20Binary%20Search%20Tree.java) -487|[Course Schedule II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Course%20Schedule%20II.java) -488|[Remove Duplicates From Sorted Array II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Duplicates%20From%20Sorted%20Array%20II.java) -489|[Binary Search Tree Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Search%20Tree%20Iterator.java) -490|[Find Duplicate File in System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Duplicate%20File%20in%20System.java) -491|[Insufficient Nodes in Root to Leaf Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insufficient%20Nodes%20in%20Root%20to%20Leaf%20Paths.java) -492|[Divide Array in Sets of K Consecutive Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Divide%20Array%20in%20Sets%20of%20K%20Consecutive%20Numbers.java) -493|[Check Completeness of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20Completeness%20of%20a%20Binary%20Tree.java) -494|[Two Sum BSTs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Two%20Sum%20BSTs.java) -495|[Count Sorted Vowel Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Sorted%20Vowel%20Strings.java) -496|[Check If a String Contains All Binary Codes of Size K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20If%20a%20String%20Contains%20All%20Binary%20Codes%20of%20Size%20K.java) -497|[Contains Duplicate III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Contains%20Duplicate%20III.java) -498|[Spiral Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Spiral%20Matrix.java) -499|[Next Closest Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Closest%20Time.java) -500|[Group Shifted Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Group%20Shifted%20Strings.java) -501|[Array Circular Loop](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Array%20Circular%20Loop.java) -502|[ZigZag Conversion](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/ZigZag%20Conversion.java) -503|[Number of Matching Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Matching%20Subsequence.java) -504|[All Paths From Source to Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Paths%20From%20Source%20to%20Target.java) -505|[Spiral Matrix II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Spiral%20Matrix%20II.java) -506|[Design Authentication Manager](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Authentication%20Manager.java) -507|[People Whose List of Favorite Companies Is Not a Subset of Another List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/People%20Whose%20List%20of%20Favorite%20Companies%20Is%20Not%20a%20Subset%20of%20Another%20List.java) -508|[Binary Tree Longest Consecutive Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Longest%20Consecutive%20Sequence.java) -509|[All Paths from Source Lead to Destination](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Paths%20from%20Source%20Lead%20to%20Destination.java) -510|[Trim a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Trim%20a%20Binary%20Search%20Tree.java) -511|[Rotate Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20Array.java) -512|[Unique Word Abbrevation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Word%20Abbrevation.java) -513|[Binary Tree Right Side View](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Right%20Side%20View.java) -514|[All Nodes Distance K in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Nodes%20Distance%20K%20in%20Binary%20Tree.java) -515|[Queue Reconstruction By Height](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Queue%20Reconstruction%20By%20Height.java) -516|[Medium](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Medium.md) -517|[Meeting Rooms II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Meeting%20Rooms%20II.java) -518|[Maximum Binary Tree II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Binary%20Tree%20II.java) -519|[Smallest String With A Given Numeric Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20String%20With%20A%20Given%20Numeric%20Value.java) -520|[Print Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Print%20Binary%20Tree.java) -521|[Restore IP Address](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Restore%20IP%20Address.java) -522|[Water & Jug Problem](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Water%20&%20Jug%20Problem.java) -523|[Maximum Width of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Width%20of%20Binary%20Tree.java) -524|[Target Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Target%20Sum.java) -525|[Top K Frequent Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Top%20K%20Frequent%20Words.java) -526|[Maximize Distance to Closest Person](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximize%20Distance%20to%20Closest%20Person.java) -527|[Design Tic-Tac-Toe](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Tic-Tac-Toe.java) -528|[H-Index II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/H-Index%20II.java) -529|[3Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/3Sum.java) -530|[Reorganize String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reorganize%20String.java) -531|[Reverse Substrings Between Each Pair of Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Substrings%20Between%20Each%20Pair%20of%20Parentheses.java) -532|[Maximum XOR of Two Numbers in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20XOR%20of%20Two%20Numbers%20in%20an%20Array.java) -533|[Count Good Nodes in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Good%20Nodes%20in%20Binary%20Tree.java) -534|[Missing Element in Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Missing%20Element%20in%20Sorted%20Array.java) -535|[Even Odd Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Even%20Odd%20Tree.java) -536|[Search for a range](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20for%20a%20range.java) -537|[Numbers With Same Consecutive Differences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Numbers%20With%20Same%20Consecutive%20Differences.java) -538|[Populating Next Right Pointers in Each Node II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Populating%20Next%20Right%20Pointers%20in%20Each%20Node%20II.java) -539|[Construct Binary Search Tree from Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20Binary%20Search%20Tree%20from%20Preorder%20Traversal.java) -540|[Shortest Completing Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Completing%20Word.java) -541|[Search a 2D Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20a%202D%20Matrix.java) -542|[Add One Row to Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20One%20Row%20to%20Tree.java) +1 | [01 Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/01%20Matrix.java) +2 | [132 Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/132%20Pattern.java) +3 | [3Sum Closest](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/3Sum%20Closest.java) +4 | [3Sum Smaller](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/3Sum%20Smaller.java) +5 | [3Sum With Multiplicity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/3Sum%20With%20Multiplicity.java) +6 | [3Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/3Sum.java) +7 | [4 Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/4%20Sum%20II.java) +8 | [4Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/4Sum%20II.java) +9 | [4Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/4Sum.java) +10 | [Accounts Merge](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Accounts%20Merge.java) +11 | [Add Bold Tag in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20Bold%20Tag%20in%20String.java) +12 | [Add Minimum Number of Rungs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20Minimum%20Number%20of%20Rungs.java) +13 | [Add One Row to Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20One%20Row%20to%20Tree.java) +14 | [Add Two Numbers II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20Two%20Numbers%20II.java) +15 | [Add Two Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20Two%20Numbers.java) +16 | [Adding Spaces to a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Adding%20Spaces%20to%20a%20String.java) +17 | [Adding Two Negabinary Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Adding%20Two%20Negabinary%20Numbers.java) +18 | [Advantage Shuffle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Advantage%20Shuffle.java) +19 | [Alert Using Same Key-Card Three or More Times in a One Hour Period](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Alert%20Using%20Same%20Key-Card%20Three%20or%20More%20Times%20in%20a%20One%20Hour%20Period.java) +20 | [All Ancestors of a Node in a Directed Acyclic Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Ancestors%20of%20a%20Node%20in%20a%20Directed%20Acyclic%20Graph.java) +21 | [All Divisions With the Highest Score of a Binary Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Divisions%20With%20the%20Highest%20Score%20of%20a%20Binary%20Array.java) +22 | [All Elements in Two Binary Search Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Elements%20in%20Two%20Binary%20Search%20Trees.java) +23 | [All Nodes Distance K in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Nodes%20Distance%20K%20in%20Binary%20Tree.java) +24 | [All Paths From Source to Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Paths%20From%20Source%20to%20Target.java) +25 | [All Paths from Source Lead to Destination](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Paths%20from%20Source%20Lead%20to%20Destination.java) +26 | [All Possible Full Binary Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Possible%20Full%20Binary%20Trees.java) +27 | [Analyze User Website Visit Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Analyze%20User%20Website%20Visit%20Pattern.java) +28 | [Angle Between Hands of a Clock](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Angle%20Between%20Hands%20of%20a%20Clock.java) +29 | [Append Characters to String to Make Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Append%20Characters%20to%20String%20to%20Make%20Subsequence.java) +30 | [Append K Integers With Minimal Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Append%20K%20Integers%20With%20Minimal%20Sum.java) +31 | [Apply Discount Every n Orders](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Apply%20Discount%20Every%20n%20Orders.java) +32 | [Apply Discount to Prices](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Apply%20Discount%20to%20Prices.java) +33 | [Arithmetic Slices](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Arithmetic%20Slices.java) +34 | [Arithmetic Subarrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Arithmetic%20Subarrays.java) +35 | [Array Circular Loop](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Array%20Circular%20Loop.java) +36 | [Array Nesting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Array%20Nesting.java) +37 | [As Far from Land as Possible](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/As%20Far%20from%20Land%20as%20Possible.java) +38 | [Asteroid Collision](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Asteroid%20Collision.java) +39 | [Average Waiting Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Average%20Waiting%20Time.java) +40 | [Bag of Tokens](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Bag%20of%20Tokens.java) +41 | [Balance a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Balance%20a%20Binary%20Search%20Tree.java) +42 | [Basic Calculator II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Basic%20Calculator%20II.java) +43 | [Battleships in a board](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Battleships%20in%20a%20board.java) +44 | [Best Time to Buy and Sell Stock II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Best%20Time%20to%20Buy%20and%20Sell%20Stock%20II.java) +45 | [Best Time to Buy and Sell Stock with Cooldown](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Best%20Time%20to%20Buy%20and%20Sell%20Stock%20with%20Cooldown.java) +46 | [Binary Search Tree Iterator II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Search%20Tree%20Iterator%20II.java) +47 | [Binary Search Tree Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Search%20Tree%20Iterator.java) +48 | [Binary Search Tree to Greater Sum Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Search%20Tree%20to%20Greater%20Sum%20Tree.java) +49 | [Binary Tree Coloring Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Coloring%20Game.java) +50 | [Binary Tree Level Order Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Level%20Order%20Traversal.java) +51 | [Binary Tree Longest Consecutive Sequence II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Longest%20Consecutive%20Sequence%20II.java) +52 | [Binary Tree Longest Consecutive Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Longest%20Consecutive%20Sequence.java) +53 | [Binary Tree Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Preorder%20Traversal.java) +54 | [Binary Tree Pruning](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Pruning.java) +55 | [Binary Tree Right Side View](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Right%20Side%20View.java) +56 | [Binary Tree Upside Down](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Upside%20Down.java) +57 | [Binary Tree Vertical Order Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Vertical%20Order%20Traversal.java) +58 | [Binary Tree Zigzag Level Order Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Zigzag%20Level%20Order%20Traversal.java) +59 | [Binary Trees With Factors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Trees%20With%20Factors.java) +60 | [Bitwise AND of Numbers Range](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Bitwise%20AND%20of%20Numbers%20Range.java) +61 | [Boats to Save People](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Boats%20to%20Save%20People.java) +62 | [Bold Words in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Bold%20Words%20in%20String.java) +63 | [Bomb Enemy](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Bomb%20Enemy.java) +64 | [Boundary of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Boundary%20of%20Binary%20Tree.java) +65 | [Brace Expansion](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Brace%20Expansion.java) +66 | [Break a Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Break%20a%20Palindrome.java) +67 | [Broken Calculator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Broken%20Calculator.java) +68 | [Buildings With an Ocean View](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Buildings%20With%20an%20Ocean%20View.java) +69 | [Bulb Switcher](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Bulb%20Switcher.java) +70 | [Camelcase Matching](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Camelcase%20Matching.java) +71 | [Campus Bikes II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Campus%20Bikes%20II.java) +72 | [Campus Bikes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Campus%20Bikes.java) +73 | [Can Convert String in K Moves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Can%20Convert%20String%20in%20K%20Moves.java) +74 | [Can Make Palindrome from Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Can%20Make%20Palindrome%20from%20Substring.java) +75 | [Candy Crush](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Candy%20Crush.java) +76 | [Capacity To Ship Packages Within D Days](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Capacity%20To%20Ship%20Packages%20Within%20D%20Days.java) +77 | [Car Pooling](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Car%20Pooling.java) +78 | [Champagne Tower](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Champagne%20Tower.java) +79 | [Cheapest Flights Within K Stops](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Cheapest%20Flights%20Within%20K%20Stops.java) +80 | [Check Completeness of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20Completeness%20of%20a%20Binary%20Tree.java) +81 | [Check If All 1's Are at Least Length K Places Away](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20If%20All%201's%20Are%20at%20Least%20Length%20K%20Places%20Away.java) +82 | [Check If a String Can Break Another String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20If%20a%20String%20Can%20Break%20Another%20String.java) +83 | [Check If a String Contains All Binary Codes of Size K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20If%20a%20String%20Contains%20All%20Binary%20Codes%20of%20Size%20K.java) +84 | [Check If a String Is a Valid Sequence from Root to Leaves Path in a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20If%20a%20String%20Is%20a%20Valid%20Sequence%20from%20Root%20to%20Leaves%20Path%20in%20a%20Binary%20Tree.java) +85 | [Check if There is a Valid Path in a Grid](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20if%20There%20is%20a%20Valid%20Path%20in%20a%20Grid.java) +86 | [Cinema Seat Allocation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Cinema%20Seat%20Allocation.java) +87 | [Clone Binary Tree With Random Pointer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Clone%20Binary%20Tree%20With%20Random%20Pointer.java) +88 | [Clone Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Clone%20Graph.java) +89 | [Clone N-ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Clone%20N-ary%20Tree.java) +90 | [Closest Nodes Queries in a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Closest%20Nodes%20Queries%20in%20a%20Binary%20Search%20Tree.java) +91 | [Coin Change 2](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Coin%20Change%202.java) +92 | [Coin Change](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Coin%20Change.java) +93 | [Combination Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Combination%20Sum%20II.java) +94 | [Combination Sum III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Combination%20Sum%20III.java) +95 | [Combination Sum IV](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Combination%20Sum%20IV.java) +96 | [Combination Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Combination%20Sum.java) +97 | [Combinations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Combinations.java) +98 | [Compare Version Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Compare%20Version%20Numbers.java) +99 | [Complete Binary Tree Insertor](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Complete%20Binary%20Tree%20Insertor.java) +100 | [Complex Number Multiplication](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Complex%20Number%20Multiplication.java) +101 | [Concatenation of Consecutive Binary Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Concatenation%20of%20Consecutive%20Binary%20Numbers.java) +102 | [Connecting Cities With Minimum Cost](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Connecting%20Cities%20With%20Minimum%20Cost.java) +103 | [Construct Binary Search Tree from Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20Binary%20Search%20Tree%20from%20Preorder%20Traversal.java) +104 | [Construct Binary Tree from Inorder and Postorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20Binary%20Tree%20from%20Inorder%20and%20Postorder%20Traversal.java) +105 | [Construct Binary Tree from Preorder and Inorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20Binary%20Tree%20from%20Preorder%20and%20Inorder%20Traversal.java) +106 | [Construct K Palindrome Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20K%20Palindrome%20Strings.java) +107 | [Construct Quad Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20Quad%20Tree.java) +108 | [Construct String With Repeat Limit](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20String%20With%20Repeat%20Limit.java) +109 | [Container With Most Water](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Container%20With%20Most%20Water.java) +110 | [Contains Duplicate III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Contains%20Duplicate%20III.java) +111 | [Contiguous Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Contiguous%20Array.java) +112 | [Continuous Subarray Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Continuous%20Subarray%20Sum.java) +113 | [Convert Binary Search Tree to Sorted Doubly Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Convert%20Binary%20Search%20Tree%20to%20Sorted%20Doubly%20Linked%20List.java) +114 | [Convert Sorted List to Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Convert%20Sorted%20List%20to%20Binary%20Search%20Tree.java) +115 | [Copy List with Random Pointer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Copy%20List%20with%20Random%20Pointer.java) +116 | [Corporate Flight Bookings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Corporate%20Flight%20Bookings.java) +117 | [Count Collisions on a Road](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Collisions%20on%20a%20Road.java) +118 | [Count Complete Tree Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Complete%20Tree%20Nodes.java) +119 | [Count Good Nodes in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Good%20Nodes%20in%20Binary%20Tree.java) +120 | [Count Nodes Equal to Average of Subtree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Nodes%20Equal%20to%20Average%20of%20Subtree.java) +121 | [Count Nodes Equal to Sum of Descendants](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Nodes%20Equal%20to%20Sum%20of%20Descendants.java) +122 | [Count Number of Bad Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Number%20of%20Bad%20Pairs.java) +123 | [Count Number of Distinct Integers After Reverse Operations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Number%20of%20Distinct%20Integers%20After%20Reverse%20Operations.java) +124 | [Count Number of Homogenous Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Number%20of%20Homogenous%20Substrings.java) +125 | [Count Number of Teams](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Number%20of%20Teams.java) +126 | [Count Numbers With Unique Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Numbers%20With%20Unique%20Digits.java) +127 | [Count Servers That Communicate](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Servers%20That%20Communicate.java) +128 | [Count Sorted Vowel Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Sorted%20Vowel%20Strings.java) +129 | [Count Square Submatrices with All Ones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Square%20Submatrices%20with%20All%20Ones.java) +130 | [Count Sub Islands](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Sub%20Islands.java) +131 | [Count Submatrices With All Ones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Submatrices%20With%20All%20Ones.java) +132 | [Count Univalue Subtrees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Univalue%20Subtrees.java) +133 | [Count Unreachable Pairs of Nodes in an Undirected Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Unreachable%20Pairs%20of%20Nodes%20in%20an%20Undirected%20Graph.java) +134 | [Count Vowel Strings in Ranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Vowel%20Strings%20in%20Ranges.java) +135 | [Count and Say](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20and%20Say.java) +136 | [Course Schedule II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Course%20Schedule%20II.java) +137 | [Course Schedule](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Course%20Schedule.java) +138 | [Create Binary Tree From Descriptions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Create%20Binary%20Tree%20From%20Descriptions.java) +139 | [Custom Sort String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Custom%20Sort%20String.java) +140 | [Daily Temperatures](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Daily%20Temperatures.java) +141 | [Decode String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Decode%20String.java) +142 | [Decode Ways](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Decode%20Ways.java) +143 | [Decrease Elements To Make Array Zigzag](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Decrease%20Elements%20To%20Make%20Array%20Zigzag.java) +144 | [Deepest Leaves Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Deepest%20Leaves%20Sum.java) +145 | [Delete Leaves With a Given Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Leaves%20With%20a%20Given%20Value.java) +146 | [Delete Node in a BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Node%20in%20a%20BST.java) +147 | [Delete Nodes And Return Forest](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Nodes%20And%20Return%20Forest.java) +148 | [Delete Operation for Two Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Operation%20for%20Two%20Strings.java) +149 | [Delete Tree Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Tree%20Nodes.java) +150 | [Delete the Middle Node of a Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20the%20Middle%20Node%20of%20a%20Linked%20List.java) +151 | [Design A Leaderboard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20A%20Leaderboard.java) +152 | [Design Add and Search Words Data Structure](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Add%20and%20Search%20Words%20Data%20Structure.java) +153 | [Design Authentication Manager](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Authentication%20Manager.java) +154 | [Design Browser History](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Browser%20History.java) +155 | [Design Circular Deque](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Circular%20Deque.java) +156 | [Design Circular Queue](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Circular%20Queue.java) +157 | [Design File System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20File%20System.java) +158 | [Design Front Middle Back Queue](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Front%20Middle%20Back%20Queue.java) +159 | [Design Hit Counter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Hit%20Counter.java) +160 | [Design Log Storage System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Log%20Storage%20System.java) +161 | [Design Phone Directory](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Phone%20Directory.java) +162 | [Design SQL](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20SQL.java) +163 | [Design Snake Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Snake%20Game.java) +164 | [Design Tic-Tac-Toe](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Tic-Tac-Toe.java) +165 | [Design Twitter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Twitter.java) +166 | [Design Underground System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Underground%20System.java) +167 | [Design a File Sharing System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20a%20File%20Sharing%20System.java) +168 | [Design a Stack With Increment Operation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20a%20Stack%20With%20Increment%20Operation.java) +169 | [Design an ATM Machine](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20an%20ATM%20Machine.java) +170 | [Design an Expression Tree With Evaluate Function](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20an%20Expression%20Tree%20With%20Evaluate%20Function.java) +171 | [Determine if Two Strings Are Close](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Determine%20if%20Two%20Strings%20Are%20Close.java) +172 | [Diagonal Traverse](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Diagonal%20Traverse.java) +173 | [Diameter of N-ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Diameter%20of%20N-ary%20Tree.java) +174 | [Display Table of Food Orders in a Restaurant](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Display%20Table%20of%20Food%20Orders%20in%20a%20Restaurant.java) +175 | [Distribute Coins in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Distribute%20Coins%20in%20Binary%20Tree.java) +176 | [Divide Array in Sets of K Consecutive Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Divide%20Array%20in%20Sets%20of%20K%20Consecutive%20Numbers.java) +177 | [Divide Players Into Teams of Equal Skill](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Divide%20Players%20Into%20Teams%20of%20Equal%20Skill.java) +178 | [Divide Two Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Divide%20Two%20Integers.java) +179 | [Dot Product of Two Sparse Vectors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Dot%20Product%20of%20Two%20Sparse%20Vectors.java) +180 | [Encode and Decode Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Encode%20and%20Decode%20Strings.java) +181 | [Encode and Decode TinyURL](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Encode%20and%20Decode%20TinyURL.java) +182 | [Equal Row and Column Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Equal%20Row%20and%20Column%20Pairs.java) +183 | [Escape The Ghosts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Escape%20The%20Ghosts.java) +184 | [Evaluate Division](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Evaluate%20Division.java) +185 | [Evaluate Reverse Polish Notation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Evaluate%20Reverse%20Polish%20Notation.java) +186 | [Evaluate the Bracket Pairs of a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Evaluate%20the%20Bracket%20Pairs%20of%20a%20String.java) +187 | [Even Odd Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Even%20Odd%20Tree.java) +188 | [Exclusive Time of Functions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Exclusive%20Time%20of%20Functions.java) +189 | [Execution of All Suffix Instructions Staying in a Grid](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Execution%20of%20All%20Suffix%20Instructions%20Staying%20in%20a%20Grid.java) +190 | [Expressive Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Expressive%20Words.java) +191 | [Fair Distribution of Cookies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Fair%20Distribution%20of%20Cookies.java) +192 | [Filter Restaurants by Vegan-Friendly, Price and Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Filter%20Restaurants%20by%20Vegan-Friendly,%20Price%20and%20Distance.java) +193 | [Find All Anagrams in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20All%20Anagrams%20in%20a%20String.java) +194 | [Find All Lonely Numbers in the Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20All%20Lonely%20Numbers%20in%20the%20Array.java) +195 | [Find All Possible Recipes from Given Supplies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20All%20Possible%20Recipes%20from%20Given%20Supplies.java) +196 | [Find Bottom Left Tree Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Bottom%20Left%20Tree%20Value.java) +197 | [Find Center of Star Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Center%20of%20Star%20Graph.java) +198 | [Find Closest Node to Given Two Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Closest%20Node%20to%20Given%20Two%20Nodes.java) +199 | [Find Consecutive Integers from a Data Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Consecutive%20Integers%20from%20a%20Data%20Stream.java) +200 | [Find Distance in a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Distance%20in%20a%20Binary%20Tree.java) +201 | [Find Duplicate File in System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Duplicate%20File%20in%20System.java) +202 | [Find Duplicate Subtrees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Duplicate%20Subtrees.java) +203 | [Find Elements in a Contaminated Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Elements%20in%20a%20Contaminated%20Binary%20Tree.java) +204 | [Find First and Last Position of Element in Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20First%20and%20Last%20Position%20of%20Element%20in%20Sorted%20Array.java) +205 | [Find K Closest Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20K%20Closest%20Elements.java) +206 | [Find K Pairs with Smallest Sums](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20K%20Pairs%20with%20Smallest%20Sums.java) +207 | [Find K-Length Substrings With No Repeated Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20K-Length%20Substrings%20With%20No%20Repeated%20Characters.java) +208 | [Find Largest Value in Each Tree Row](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Largest%20Value%20in%20Each%20Tree%20Row.java) +209 | [Find Leaves of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Leaves%20of%20Binary%20Tree.java) +210 | [Find Minimum in Rotated Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Minimum%20in%20Rotated%20Sorted%20Array.java) +211 | [Find Missing Observations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Missing%20Observations.java) +212 | [Find Nearest Right Node in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Nearest%20Right%20Node%20in%20Binary%20Tree.java) +213 | [Find Original Array From Doubled Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Original%20Array%20From%20Doubled%20Array.java) +214 | [Find Peak Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Peak%20Element.java) +215 | [Find Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Permutation.java) +216 | [Find Players With Zero or One Losses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Players%20With%20Zero%20or%20One%20Losses.java) +217 | [Find Right Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Right%20Interval.java) +218 | [Find Root of N-Ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Root%20of%20N-Ary%20Tree.java) +219 | [Find Smallest Common Element in All Rows](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Smallest%20Common%20Element%20in%20All%20Rows.java) +220 | [Find The Original Array of Prefix Xor](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20The%20Original%20Array%20of%20Prefix%20Xor.java) +221 | [Find Triangular Sum of an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Triangular%20Sum%20of%20an%20Array.java) +222 | [Find a Corresponding Node of a Binary Tree in a Clone of That Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20a%20Corresponding%20Node%20of%20a%20Binary%20Tree%20in%20a%20Clone%20of%20That%20Tree.java) +223 | [Find all Duplicates in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20all%20Duplicates%20in%20an%20Array.java) +224 | [Find and Replace Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20and%20Replace%20Pattern.java) +225 | [Find and Replace in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20and%20Replace%20in%20String.java) +226 | [Find the Celebrity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Celebrity.java) +227 | [Find the City With the Smallest Number of Neighbors at a Threshold Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20City%20With%20the%20Smallest%20Number%20of%20Neighbors%20at%20a%20Threshold%20Distance.java) +228 | [Find the Duplicate Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Duplicate%20Number.java) +229 | [Find the Index of the Large Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Index%20of%20the%20Large%20Integer.java) +230 | [Find the Kth Largest Integer in the Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Kth%20Largest%20Integer%20in%20the%20Array.java) +231 | [Find the Minimum and Maximum Number of Nodes Between Critical Points](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Minimum%20and%20Maximum%20Number%20of%20Nodes%20Between%20Critical%20Points.java) +232 | [Find the Student that Will Replace the Chalk](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Student%20that%20Will%20Replace%20the%20Chalk.java) +233 | [Find the Winner of an Array Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Winner%20of%20an%20Array%20Game.java) +234 | [Finding the Users Active Minutes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Finding%20the%20Users%20Active%20Minutes.java) +235 | [First Unique Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/First%20Unique%20Number.java) +236 | [Flatten 2D Vector](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%202D%20Vector.java) +237 | [Flatten Binary Tree to Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%20Binary%20Tree%20to%20Linked%20List.java) +238 | [Flatten Nested List Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%20Nested%20List%20Iterator.java) +239 | [Flatten a Multilevel Doubly Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%20a%20Multilevel%20Doubly%20Linked%20List.java) +240 | [Flip Equivalent Binary Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flip%20Equivalent%20Binary%20Trees.java) +241 | [Four Divisors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Four%20Divisors.java) +242 | [Fraction to Recurring Decimal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Fraction%20to%20Recurring%20Decimal.java) +243 | [Friend Circles](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Friend%20Circles.java) +244 | [Friends Of Appropriate Ages](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Friends%20Of%20Appropriate%20Ages.java) +245 | [Fruit Into Baskets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Fruit%20Into%20Baskets.java) +246 | [Furthest Building You Can Reach](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Furthest%20Building%20You%20Can%20Reach.java) +247 | [Game of Life](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Game%20of%20Life.java) +248 | [Gas Station](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Gas%20Station.java) +249 | [Generate Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Generate%20Parentheses.java) +250 | [Graph Valid Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Graph%20Valid%20Tree.java) +251 | [Gray Code](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Gray%20Code.java) +252 | [Group Anagrams](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Group%20Anagrams.java) +253 | [Group Shifted Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Group%20Shifted%20Strings.java) +254 | [Group the People Given the Group Size They Belong To](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Group%20the%20People%20Given%20the%20Group%20Size%20They%20Belong%20To.java) +255 | [Grumpy Bookstore Owner](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Grumpy%20Bookstore%20Owner.java) +256 | [Guess Number Higher or Lower II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Guess%20Number%20Higher%20or%20Lower%20II.java) +257 | [H-Index II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/H-Index%20II.java) +258 | [H-Index](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/H-Index.java) +259 | [HTML Entity Parser](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/HTML%20Entity%20Parser.java) +260 | [Hand of Straights](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Hand%20of%20Straights.java) +261 | [House Robber II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/House%20Robber%20II.java) +262 | [House Robber III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/House%20Robber%20III.java) +263 | [House Robber](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/House%20Robber.java) +264 | [Image Overlap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Image%20Overlap.java) +265 | [Implement Magic Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Implement%20Magic%20Dictionary.java) +266 | [Implement Rand10() Using Rand7()](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Implement%20Rand10()%20Using%20Rand7().java) +267 | [Implement Trie (Prefix Tree)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Implement%20Trie%20(Prefix%20Tree).java) +268 | [Implement Trie II (Prefix Tree)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Implement%20Trie%20II%20(Prefix%20Tree).java) +269 | [Increasing Subsequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Increasing%20Subsequences.java) +270 | [Increasing Triplet Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Increasing%20Triplet%20Subsequence.java) +271 | [Incremental Memory Leak](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Incremental%20Memory%20Leak.java) +272 | [Inorder Successor in BST II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Inorder%20Successor%20in%20BST%20II.java) +273 | [Inorder Successor in BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Inorder%20Successor%20in%20BST.java) +274 | [Insert Delete GetRandom O(1)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20Delete%20GetRandom%20O(1).java) +275 | [Insert Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20Interval.java) +276 | [Insert Into a Cyclic Sorted List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20Into%20a%20Cyclic%20Sorted%20List.java) +277 | [Insert into a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20into%20a%20Binary%20Search%20Tree.java) +278 | [Insert into a Sorted Circular Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20into%20a%20Sorted%20Circular%20Linked%20List.java) +279 | [Insertion Sort List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insertion%20Sort%20List.java) +280 | [Insufficient Nodes in Root to Leaf Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insufficient%20Nodes%20in%20Root%20to%20Leaf%20Paths.java) +281 | [Integer To Roman](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Integer%20To%20Roman.java) +282 | [Interleaving String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Interleaving%20String.java) +283 | [Interval List Intersections](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Interval%20List%20Intersections.java) +284 | [Invalid Transactions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Invalid%20Transactions.java) +285 | [Is Graph Bipartite](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Is%20Graph%20Bipartite.java) +286 | [Iterator for Combination](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Iterator%20for%20Combination.java) +287 | [Jump Game II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Jump%20Game%20II.java) +288 | [Jump Game III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Jump%20Game%20III.java) +289 | [Jump Game VI](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Jump%20Game%20VI.java) +290 | [Jump Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Jump%20Game.java) +291 | [K Closest Points to Origin](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/K%20Closest%20Points%20to%20Origin.java) +292 | [K Radius Subarray Averages](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/K%20Radius%20Subarray%20Averages.java) +293 | [Keys and Rooms](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Keys%20and%20Rooms.java) +294 | [Kill Process](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kill%20Process.java) +295 | [Knight Dialer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Knight%20Dialer.java) +296 | [Knight Probability in Chessboard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Knight%20Probability%20in%20Chessboard.java) +297 | [Koko Eating Bananas](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Koko%20Eating%20Bananas.java) +298 | [Kth Largest Element in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kth%20Largest%20Element%20in%20an%20Array.java) +299 | [Kth Smallest Element in a BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kth%20Smallest%20Element%20in%20a%20BST.java) +300 | [Kth Smallest Element in a Sorted Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kth%20Smallest%20Element%20in%20a%20Sorted%20Matrix.java) +301 | [LRU Cache](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/LRU%20Cache.java) +302 | [Large Divisble Subset](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Large%20Divisble%20Subset.java) +303 | [Largest BST Subtree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Largest%20BST%20Subtree.java) +304 | [Largest Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Largest%20Number.java) +305 | [Largest Time for Given Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Largest%20Time%20for%20Given%20Digits.java) +306 | [Last Moment Before All Ants Fall Out of a Plank](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Last%20Moment%20Before%20All%20Ants%20Fall%20Out%20of%20a%20Plank.java) +307 | [Last Stone Weight II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Last%20Stone%20Weight%20II.java) +308 | [Least Number of Unique Integers after K Removals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Least%20Number%20of%20Unique%20Integers%20after%20K%20Removals.java) +309 | [Leftmost Column with at Least a One](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Leftmost%20Column%20with%20at%20Least%20a%20One.java) +310 | [Length of the Longest Alphabetical Continuous Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Length%20of%20the%20Longest%20Alphabetical%20Continuous%20Substring.java) +311 | [Letter Combinations of a Phone Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Letter%20Combinations%20of%20a%20Phone%20Number.java) +312 | [Letter Tiles Possibilities](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Letter%20Tiles%20Possibilities.java) +313 | [Lexicographical Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lexicographical%20Numbers.java) +314 | [Lexicographically Smallest Equivalent String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lexicographically%20Smallest%20Equivalent%20String.java) +315 | [Line Reflection](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Line%20Reflection.java) +316 | [Linked List Components](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20Components.java) +317 | [Linked List Cycle II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20Cycle%20II.java) +318 | [Linked List Random Node](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20Random%20Node.java) +319 | [Linked List in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20in%20Binary%20Tree.java) +320 | [Lonely Pixel I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lonely%20Pixel%20I.java) +321 | [Longest Absolute File Path](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Absolute%20File%20Path.java) +322 | [Longest Arithmetic Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Arithmetic%20Sequence.java) +323 | [Longest Arithmetic Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Arithmetic%20Subsequence.java) +324 | [Longest Consecutive Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Consecutive%20Sequence.java) +325 | [Longest Continuous Subarray With Absolute Diff Less Than or Equal to Limit](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Continuous%20Subarray%20With%20Absolute%20Diff%20Less%20Than%20or%20Equal%20to%20Limit.java) +326 | [Longest Happy String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Happy%20String.java) +327 | [Longest Increasing Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Increasing%20Subsequence.java) +328 | [Longest Line of Consecutive One in Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Line%20of%20Consecutive%20One%20in%20Matrix.java) +329 | [Longest Palindromic Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Palindromic%20Subsequence.java) +330 | [Longest Palindromic Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Palindromic%20Substring.java) +331 | [Longest String Chain](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20String%20Chain.java) +332 | [Longest Substring Without Repeating Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Substring%20Without%20Repeating%20Characters.java) +333 | [Longest Substring with At Most K Distinct Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Substring%20with%20At%20Most%20K%20Distinct%20Characters.java) +334 | [Longest Substring with At Most Two Distinct Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Substring%20with%20At%20Most%20Two%20Distinct%20Characters.java) +335 | [Longest Uploaded Prefix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Uploaded%20Prefix.java) +336 | [Longest Well-Performing Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Well-Performing%20Interval.java) +337 | [Longest Word With All Prefixes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Word%20With%20All%20Prefixes.java) +338 | [Longest Word in Dictionary through Deleting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Word%20in%20Dictionary%20through%20Deleting.java) +339 | [Longest ZigZag Path in a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20ZigZag%20Path%20in%20a%20Binary%20Tree.java) +340 | [Lowest Common Ancestor of Deepest Leaves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lowest%20Common%20Ancestor%20of%20Deepest%20Leaves.java) +341 | [Lowest Common Ancestor of a Binary Tree III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lowest%20Common%20Ancestor%20of%20a%20Binary%20Tree%20III.java) +342 | [Lowest Common Ancestor of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lowest%20Common%20Ancestor%20of%20a%20Binary%20Tree.java) +343 | [Majority Element II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Majority%20Element%20II.java) +344 | [Making File Names Unique](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Making%20File%20Names%20Unique.java) +345 | [Map Sum Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Map%20Sum%20Pairs.java) +346 | [Masking Personal Information](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Masking%20Personal%20Information.java) +347 | [Matchsticks to Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Matchsticks%20to%20Square.java) +348 | [Max Area of Island](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Area%20of%20Island.java) +349 | [Max Chunks To Make Sorted](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Chunks%20To%20Make%20Sorted.java) +350 | [Max Consecutives Ones II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Consecutives%20Ones%20II.java) +351 | [Max Increase to Keep City Skyline](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Increase%20to%20Keep%20City%20Skyline.java) +352 | [Max Number of K-Sum Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Number%20of%20K-Sum%20Pairs.java) +353 | [Max Sum of a Pair With Equal Sum of Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Sum%20of%20a%20Pair%20With%20Equal%20Sum%20of%20Digits.java) +354 | [Maximal Network Rank](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximal%20Network%20Rank.java) +355 | [Maximal Score After Applying K Operations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximal%20Score%20After%20Applying%20K%20Operations.java) +356 | [Maximize Distance to Closest Person](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximize%20Distance%20to%20Closest%20Person.java) +357 | [Maximize Number of Subsequences in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximize%20Number%20of%20Subsequences%20in%20a%20String.java) +358 | [Maximize the Topmost Element After K Moves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximize%20the%20Topmost%20Element%20After%20K%20Moves.java) +359 | [Maximum Absolute Sum of Any Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Absolute%20Sum%20of%20Any%20Subarray.java) +360 | [Maximum Area of a Piece of Cake After Horizontal and Vertical Cuts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Area%20of%20a%20Piece%20of%20Cake%20After%20Horizontal%20and%20Vertical%20Cuts.java) +361 | [Maximum Average Subtree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Average%20Subtree.java) +362 | [Maximum Bags With Full Capacity of Rocks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Bags%20With%20Full%20Capacity%20of%20Rocks.java) +363 | [Maximum Binary Tree II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Binary%20Tree%20II.java) +364 | [Maximum Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Binary%20Tree.java) +365 | [Maximum Consecutive Floors Without Special Floors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Consecutive%20Floors%20Without%20Special%20Floors.java) +366 | [Maximum Difference Between Node and Ancestor](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Difference%20Between%20Node%20and%20Ancestor.java) +367 | [Maximum Distance Between a Pair of Values](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Distance%20Between%20a%20Pair%20of%20Values.java) +368 | [Maximum Erasure Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Erasure%20Value.java) +369 | [Maximum Ice Cream Bars](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Ice%20Cream%20Bars.java) +370 | [Maximum Length of Pair Chain](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Length%20of%20Pair%20Chain.java) +371 | [Maximum Length of Repeated Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Length%20of%20Repeated%20Subarray.java) +372 | [Maximum Length of Subarray With Positive Product](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Length%20of%20Subarray%20With%20Positive%20Product.java) +373 | [Maximum Level Sum of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Level%20Sum%20of%20a%20Binary%20Tree.java) +374 | [Maximum Matching of Players With Trainers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Matching%20of%20Players%20With%20Trainers.java) +375 | [Maximum Nesting Depth of Two Valid Parentheses Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Nesting%20Depth%20of%20Two%20Valid%20Parentheses%20Strings.java) +376 | [Maximum Number of Coins You Can Get](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Coins%20You%20Can%20Get.java) +377 | [Maximum Number of Events That Can Be Attended](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Events%20That%20Can%20Be%20Attended.java) +378 | [Maximum Number of Groups Entering a Competition](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Groups%20Entering%20a%20Competition.java) +379 | [Maximum Number of Integers to Choose From a Range I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Integers%20to%20Choose%20From%20a%20Range%20I.java) +380 | [Maximum Number of Non-Overlapping Subarrays With Sum Equals Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Non-Overlapping%20Subarrays%20With%20Sum%20Equals%20Target.java) +381 | [Maximum Number of Occurrences of a Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Occurrences%20of%20a%20Substring.java) +382 | [Maximum Number of Vowels in a Substring of Given Length](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Vowels%20in%20a%20Substring%20of%20Given%20Length.java) +383 | [Maximum Points You Can Obtain from Cards](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Points%20You%20Can%20Obtain%20from%20Cards.java) +384 | [Maximum Product Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Product%20Subarray.java) +385 | [Maximum Product of Splitted Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Product%20of%20Splitted%20Binary%20Tree.java) +386 | [Maximum Product of Word Lengths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Product%20of%20Word%20Lengths.java) +387 | [Maximum Score From Removing Stones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Score%20From%20Removing%20Stones.java) +388 | [Maximum Score from Performing Multiplication Operations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Score%20from%20Performing%20Multiplication%20Operations.java) +389 | [Maximum Size Subarray Sum Equals k](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Size%20Subarray%20Sum%20Equals%20k.java) +390 | [Maximum Star Sum of a Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Star%20Sum%20of%20a%20Graph.java) +391 | [Maximum Sum of Distinct Subarrays With Length K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Sum%20of%20Distinct%20Subarrays%20With%20Length%20K.java) +392 | [Maximum Sum of an Hourglass](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Sum%20of%20an%20Hourglass.java) +393 | [Maximum Swap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Swap.java) +394 | [Maximum Total Importance of Roads](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Total%20Importance%20of%20Roads.java) +395 | [Maximum Twin Sum of a Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Twin%20Sum%20of%20a%20Linked%20List.java) +396 | [Maximum Value after Insertion](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Value%20after%20Insertion.java) +397 | [Maximum Width Ramp](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Width%20Ramp.java) +398 | [Maximum Width of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Width%20of%20Binary%20Tree.java) +399 | [Maximum XOR of Two Numbers in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20XOR%20of%20Two%20Numbers%20in%20an%20Array.java) +400 | [Maximum of Absolute Value Expression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20of%20Absolute%20Value%20Expression.java) +401 | [Meeting Rooms II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Meeting%20Rooms%20II.java) +402 | [Meeting Scheduler](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Meeting%20Scheduler.java) +403 | [Merge In Between Linked Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Merge%20In%20Between%20Linked%20Lists.java) +404 | [Merge Intervals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Merge%20Intervals.java) +405 | [Merge Nodes in Between Zeros](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Merge%20Nodes%20in%20Between%20Zeros.java) +406 | [Min Cost to Connect All Points](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Min%20Cost%20to%20Connect%20All%20Points.java) +407 | [Min Stack](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Min%20Stack.java) +408 | [Minesweeper](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minesweeper.java) +409 | [Mini Parser](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Mini%20Parser.java) +410 | [Minimize Maximum Pair Sum in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimize%20Maximum%20Pair%20Sum%20in%20Array.java) +411 | [Minimize Product Sum of Two Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimize%20Product%20Sum%20of%20Two%20Arrays.java) +412 | [Minimum Add to Make Parentheses Valid](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Add%20to%20Make%20Parentheses%20Valid.java) +413 | [Minimum Amount of Time to Collect Garbage](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Amount%20of%20Time%20to%20Collect%20Garbage.java) +414 | [Minimum Area Rectangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Area%20Rectangle.java) +415 | [Minimum Average Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Average%20Difference.java) +416 | [Minimum Consecutive Cards to Pick Up](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Consecutive%20Cards%20to%20Pick%20Up.java) +417 | [Minimum Cost to Connect Sticks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Cost%20to%20Connect%20Sticks.java) +418 | [Minimum Deletion Cost to Avoid Repeating Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Deletion%20Cost%20to%20Avoid%20Repeating%20Letters.java) +419 | [Minimum Deletions to Make Array Beautiful](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Deletions%20to%20Make%20Array%20Beautiful.java) +420 | [Minimum Deletions to Make Character Frequencies Unique](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Deletions%20to%20Make%20Character%20Frequencies%20Unique.java) +421 | [Minimum Domino Rotations For Equal Row](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Domino%20Rotations%20For%20Equal%20Row.java) +422 | [Minimum Falling Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Falling%20Path%20Sum.java) +423 | [Minimum Fuel Cost to Report to the Capital](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Fuel%20Cost%20to%20Report%20to%20the%20Capital.java) +424 | [Minimum Genetic Mutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Genetic%20Mutation.java) +425 | [Minimum Health to Beat Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Health%20to%20Beat%20Game.java) +426 | [Minimum Height Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Height%20Trees.java) +427 | [Minimum Knight Moves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Knight%20Moves.java) +428 | [Minimum Moves to Equal Array Elements II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Moves%20to%20Equal%20Array%20Elements%20II.java) +429 | [Minimum Moves to Equal Array Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Moves%20to%20Equal%20Array%20Elements.java) +430 | [Minimum Moves to Reach Target Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Moves%20to%20Reach%20Target%20Score.java) +431 | [Minimum Number of Arrows to Burst Balloons](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Number%20of%20Arrows%20to%20Burst%20Balloons.java) +432 | [Minimum Number of Steps to Make Two Strings Anagram II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Number%20of%20Steps%20to%20Make%20Two%20Strings%20Anagram%20II.java) +433 | [Minimum Number of Steps to Make Two Strings Anagram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Number%20of%20Steps%20to%20Make%20Two%20Strings%20Anagram.java) +434 | [Minimum Number of Vertices to Reach All Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Number%20of%20Vertices%20to%20Reach%20All%20Nodes.java) +435 | [Minimum Operations to Make Array Equal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Operations%20to%20Make%20Array%20Equal.java) +436 | [Minimum Operations to Reduce X to Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Operations%20to%20Reduce%20X%20to%20Zero.java) +437 | [Minimum Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Path%20Sum.java) +438 | [Minimum Remove to Make Valid Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Remove%20to%20Make%20Valid%20Parentheses.java) +439 | [Minimum Rounds to Complete All Tasks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Rounds%20to%20Complete%20All%20Tasks.java) +440 | [Minimum Score Triangulation of Polygon](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Score%20Triangulation%20of%20Polygon.java) +441 | [Minimum Size Subarray Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Size%20Subarray%20Sum.java) +442 | [Minimum Swaps to Group All 1's Together](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Swaps%20to%20Group%20All%201's%20Together.java) +443 | [Minimum Time Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Time%20Difference.java) +444 | [Minimum Time to Collect All Apples in a Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Time%20to%20Collect%20All%20Apples%20in%20a%20Tree.java) +445 | [Minimum Time to Complete Trips](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Time%20to%20Complete%20Trips.java) +446 | [Minimum Time to Make Rope Colorful](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Time%20to%20Make%20Rope%20Colorful.java) +447 | [Mirror Reflection](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Mirror%20Reflection.java) +448 | [Missing Element in Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Missing%20Element%20in%20Sorted%20Array.java) +449 | [Most Frequent Subtree Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Most%20Frequent%20Subtree%20Sum.java) +450 | [Most Popular Video Creator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Most%20Popular%20Video%20Creator.java) +451 | [Most Profit Assigning Work](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Most%20Profit%20Assigning%20Work.java) +452 | [Most Stones Removed with Same Row or Column](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Most%20Stones%20Removed%20with%20Same%20Row%20or%20Column.java) +453 | [Multiply Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Multiply%20Strings.java) +454 | [My Calendar I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/My%20Calendar%20I.java) +455 | [My Calendar II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/My%20Calendar%20II.java) +456 | [N-ary Tree Level Order Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/N-ary%20Tree%20Level%20Order%20Traversal.java) +457 | [Nearest Exit from Entrance in Maze](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Nearest%20Exit%20from%20Entrance%20in%20Maze.java) +458 | [Nested List Weight Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Nested%20List%20Weight%20Sum%20II.java) +459 | [Network Delay Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Network%20Delay%20Time.java) +460 | [Next Closest Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Closest%20Time.java) +461 | [Next Greater Element II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Greater%20Element%20II.java) +462 | [Next Greater Element III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Greater%20Element%20III.java) +463 | [Next Greater Node In Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Greater%20Node%20In%20Linked%20List.java) +464 | [Next Greater Numerically Balanced Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Greater%20Numerically%20Balanced%20Number.java) +465 | [Next Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Permutation.java) +466 | [Node With Highest Edge Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Node%20With%20Highest%20Edge%20Score.java) +467 | [Non Overlapping Intervals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Non%20Overlapping%20Intervals.java) +468 | [Non-decreasing Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Non-decreasing%20Array.java) +469 | [Number of Burgers with No Waste of Ingredients](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Burgers%20with%20No%20Waste%20of%20Ingredients.java) +470 | [Number of Closed Islands](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Closed%20Islands.java) +471 | [Number of Connected Components in an Undirected Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Connected%20Components%20in%20an%20Undirected%20Graph.java) +472 | [Number of Dice Rolls With Target Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Dice%20Rolls%20With%20Target%20Sum.java) +473 | [Number of Distinct Islands](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Distinct%20Islands.java) +474 | [Number of Distinct Substrings in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Distinct%20Substrings%20in%20a%20String.java) +475 | [Number of Enclaves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Enclaves.java) +476 | [Number of Islands](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Islands.java) +477 | [Number of Laser Beams in a Bank](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Laser%20Beams%20in%20a%20Bank.java) +478 | [Number of Longest Increasing Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Longest%20Increasing%20Subsequence.java) +479 | [Number of Matching Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Matching%20Subsequence.java) +480 | [Number of Matching Subsequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Matching%20Subsequences.java) +481 | [Number of Nodes in the Sub-Tree With the Same Label](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Nodes%20in%20the%20Sub-Tree%20With%20the%20Same%20Label.java) +482 | [Number of Pairs of Interchangeable Rectangles](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Pairs%20of%20Interchangeable%20Rectangles.java) +483 | [Number of Pairs of Strings With Concatenation Equal to Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Pairs%20of%20Strings%20With%20Concatenation%20Equal%20to%20Target.java) +484 | [Number of Provinces](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Provinces.java) +485 | [Number of Smooth Descent Periods of a Stock](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Smooth%20Descent%20Periods%20of%20a%20Stock.java) +486 | [Number of Sub-arrays of Size K and Average Greater than or Equal to Threshold](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Sub-arrays%20of%20Size%20K%20and%20Average%20Greater%20than%20or%20Equal%20to%20Threshold.java) +487 | [Number of Subarrays with Bounded Maximum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Subarrays%20with%20Bounded%20Maximum.java) +488 | [Number of Substrings Containing All Three Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Substrings%20Containing%20All%20Three%20Characters.java) +489 | [Number of Substrings With Only 1s](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Substrings%20With%20Only%201s.java) +490 | [Number of Ways to Split Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Ways%20to%20Split%20Array.java) +491 | [Number of Zero-Filled Subarrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Zero-Filled%20Subarrays.java) +492 | [Numbers With Same Consecutive Differences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Numbers%20With%20Same%20Consecutive%20Differences.java) +493 | [Odd Even Linked Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Odd%20Even%20Linked%20Lists.java) +494 | [One Edit Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/One%20Edit%20Distance.java) +495 | [Ones and Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Ones%20and%20Zeroes.java) +496 | [Online Election](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Online%20Election.java) +497 | [Online Stock Span](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Online%20Stock%20Span.java) +498 | [Open The Lock](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Open%20The%20Lock.java) +499 | [Optimal Division](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Optimal%20Division.java) +500 | [Optimal Partition of String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Optimal%20Partition%20of%20String.java) +501 | [Out of Boundary Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Out%20of%20Boundary%20Paths.java) +502 | [Output Contest Matches](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Output%20Contest%20Matches.java) +503 | [Pacific Atlantic Water Flow](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pacific%20Atlantic%20Water%20Flow.java) +504 | [Palindrome Partitioning](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Palindrome%20Partitioning.java) +505 | [Palindromic Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Palindromic%20Substrings.java) +506 | [Pancake Sorting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pancake%20Sorting.java) +507 | [Parallel Courses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Parallel%20Courses.java) +508 | [Partition Array According to Given Pivot](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partition%20Array%20According%20to%20Given%20Pivot.java) +509 | [Partition Equal Subset Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partition%20Equal%20Subset%20Sum.java) +510 | [Partition Labels](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partition%20Labels.java) +511 | [Partition List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partition%20List.java) +512 | [Partitioning Into Minimum Number Of Deci-Binary Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partitioning%20Into%20Minimum%20Number%20Of%20Deci-Binary%20Numbers.java) +513 | [Path Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20Sum%20II.java) +514 | [Path Sum III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20Sum%20III.java) +515 | [Path With Maximum Minimum Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20With%20Maximum%20Minimum%20Value.java) +516 | [Path With Minimum Effort](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20With%20Minimum%20Effort.java) +517 | [Path with Maximum Gold](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20with%20Maximum%20Gold.java) +518 | [Path with Maximum Probability](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20with%20Maximum%20Probability.java) +519 | [Peeking Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Peeking%20Iterator.java) +520 | [People Whose List of Favorite Companies Is Not a Subset of Another List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/People%20Whose%20List%20of%20Favorite%20Companies%20Is%20Not%20a%20Subset%20of%20Another%20List.java) +521 | [Perfect Squares](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Perfect%20Squares.java) +522 | [Permutation in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Permutation%20in%20String.java) +523 | [Permutations II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Permutations%20II.java) +524 | [Permutations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Permutations.java) +525 | [Plus One Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Plus%20One%20Linked%20List.java) +526 | [Populating Next Right Pointers in Each Node II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Populating%20Next%20Right%20Pointers%20in%20Each%20Node%20II.java) +527 | [Populating Next Right Pointers in Each Node](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Populating%20Next%20Right%20Pointers%20in%20Each%20Node.java) +528 | [Possible Bipartition](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Possible%20Bipartition.java) +529 | [Pour Water](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pour%20Water.java) +530 | [Pow(x, n)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pow(x,%20n).java) +531 | [Pow](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pow.java) +532 | [Prime Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Prime%20Palindrome.java) +533 | [Print Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Print%20Binary%20Tree.java) +534 | [Print Immutable Linked List in Reverse](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Print%20Immutable%20Linked%20List%20in%20Reverse.java) +535 | [Print Words Vertically](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Print%20Words%20Vertically.java) +536 | [Prison Cells After N Days](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Prison%20Cells%20After%20N%20Days.java) +537 | [Product of Array Except self](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Product%20of%20Array%20Except%20self.java) +538 | [Product of Two Run-Length Encoded Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Product%20of%20Two%20Run-Length%20Encoded%20Arrays.java) +539 | [Product of the Last K Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Product%20of%20the%20Last%20K%20Numbers.java) +540 | [Pseudo-Palindromic Paths in a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pseudo-Palindromic%20Paths%20in%20a%20Binary%20Tree.java) +541 | [Push Dominoes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Push%20Dominoes.java) +542 | [Put Boxes Into the Warehouse I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Put%20Boxes%20Into%20the%20Warehouse%20I.java) +543 | [Queries on a Permutation With Key](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Queries%20on%20a%20Permutation%20With%20Key.java) +544 | [Queue Reconstruction By Height](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Queue%20Reconstruction%20By%20Height.java) +545 | [RLE Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/RLE%20Iterator.java) +546 | [Rabbits in Forest](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rabbits%20in%20Forest.java) +547 | [Random Pick Index](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Random%20Pick%20Index.java) +548 | [Random Pick With Weight](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Random%20Pick%20With%20Weight.java) +549 | [Range Addition](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Addition.java) +550 | [Range Sum Query - Mutable](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Sum%20Query%20-%20Mutable.java) +551 | [Range Sum Query 2D-Immutable](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Sum%20Query%202D-Immutable.java) +552 | [Range Sum of Sorted Subarray Sums](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Sum%20of%20Sorted%20Subarray%20Sums.java) +553 | [Rank Teams by Votes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rank%20Teams%20by%20Votes.java) +554 | [Reachable Nodes With Restrictions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reachable%20Nodes%20With%20Restrictions.java) +555 | [Rearrange Array Elements by Sign](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rearrange%20Array%20Elements%20by%20Sign.java) +556 | [Reconstruct Original Digits from English](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reconstruct%20Original%20Digits%20from%20English.java) +557 | [Recover Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Recover%20Binary%20Search%20Tree.java) +558 | [Rectangle Area](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rectangle%20Area.java) +559 | [Reduce Array Size to The Half](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reduce%20Array%20Size%20to%20The%20Half.java) +560 | [Reduction Operations to Make the Array Elements Equal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reduction%20Operations%20to%20Make%20the%20Array%20Elements%20Equal.java) +561 | [Remove All Adjacent Duplicates in String II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20All%20Adjacent%20Duplicates%20in%20String%20II.java) +562 | [Remove All Occurrences of a Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20All%20Occurrences%20of%20a%20Substring.java) +563 | [Remove All Ones With Row and Column Flips II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20All%20Ones%20With%20Row%20and%20Column%20Flips%20II.java) +564 | [Remove Comments](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Comments.java) +565 | [Remove Covered Intervals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Covered%20Intervals.java) +566 | [Remove Duplicate Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Duplicate%20Letters.java) +567 | [Remove Duplicates From Sorted Array II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Duplicates%20From%20Sorted%20Array%20II.java) +568 | [Remove Duplicates From an Unsorted Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Duplicates%20From%20an%20Unsorted%20Linked%20List.java) +569 | [Remove Duplicates from Sorted List II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Duplicates%20from%20Sorted%20List%20II.java) +570 | [Remove Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Interval.java) +571 | [Remove K Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20K%20Digits.java) +572 | [Remove Nodes From Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Nodes%20From%20Linked%20List.java) +573 | [Remove Nth Node From End of List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Nth%20Node%20From%20End%20of%20List.java) +574 | [Remove Sub-Folders from the Filesystem](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Sub-Folders%20from%20the%20Filesystem.java) +575 | [Remove Zero Sum Consecutive Nodes from Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Zero%20Sum%20Consecutive%20Nodes%20from%20Linked%20List.java) +576 | [Removing Stars From a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Removing%20Stars%20From%20a%20String.java) +577 | [Reorder Data in Log Files](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reorder%20Data%20in%20Log%20Files.java) +578 | [Reorder List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reorder%20List.java) +579 | [Reorder Routes to Make All Paths Lead to the City Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reorder%20Routes%20to%20Make%20All%20Paths%20Lead%20to%20the%20City%20Zero.java) +580 | [Reordered Power of 2](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reordered%20Power%20of%202.java) +581 | [Reorganize String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reorganize%20String.java) +582 | [Repeated DNA Sequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Repeated%20DNA%20Sequences.java) +583 | [Replace Elements in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Replace%20Elements%20in%20an%20Array.java) +584 | [Replace Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Replace%20Words.java) +585 | [Restore IP Address](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Restore%20IP%20Address.java) +586 | [Restore the Array From Adjacent Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Restore%20the%20Array%20From%20Adjacent%20Pairs.java) +587 | [Reverse Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Integer.java) +588 | [Reverse Linked List II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Linked%20List%20II.java) +589 | [Reverse Nodes in Even Length Groups](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Nodes%20in%20Even%20Length%20Groups.java) +590 | [Reverse Odd Levels of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Odd%20Levels%20of%20Binary%20Tree.java) +591 | [Reverse Substrings Between Each Pair of Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Substrings%20Between%20Each%20Pair%20of%20Parentheses.java) +592 | [Reverse Words in a String II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Words%20in%20a%20String%20II.java) +593 | [Reverse Words in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Words%20in%20a%20String.java) +594 | [Robot Bounded In Circle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Robot%20Bounded%20In%20Circle.java) +595 | [Rotate Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20Array.java) +596 | [Rotate Function](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20Function.java) +597 | [Rotate Image](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20Image.java) +598 | [Rotate List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20List.java) +599 | [Rotated Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotated%20Digits.java) +600 | [Rotting Oranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotting%20Oranges.java) +601 | [Satisfiability of Equality Equations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Satisfiability%20of%20Equality%20Equations.java) +602 | [Satisfisbility of Equality Equations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Satisfisbility%20of%20Equality%20Equations.java) +603 | [Score After Flipping Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Score%20After%20Flipping%20Matrix.java) +604 | [Score of Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Score%20of%20Parentheses.java) +605 | [Search Suggestions System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20Suggestions%20System.java) +606 | [Search a 2D Matrix II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20a%202D%20Matrix%20II.java) +607 | [Search a 2D Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20a%202D%20Matrix.java) +608 | [Search for a range](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20for%20a%20range.java) +609 | [Search in Rotated Sorted Array II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20in%20Rotated%20Sorted%20Array%20II.java) +610 | [Search in Rotated Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20in%20Rotated%20Sorted%20Array.java) +611 | [Search in a Sorted Array of Unknown Size](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20in%20a%20Sorted%20Array%20of%20Unknown%20Size.java) +612 | [Seat Reservation Manager](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Seat%20Reservation%20Manager.java) +613 | [Self Dividing Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Self%20Dividing%20Numbers.java) +614 | [Sender With Largest Word Count](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sender%20With%20Largest%20Word%20Count.java) +615 | [Sentence Similarity II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sentence%20Similarity%20II.java) +616 | [Sentence Similarity III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sentence%20Similarity%20III.java) +617 | [Sequential Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sequential%20Digits.java) +618 | [Serialize and Deserialize BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Serialize%20and%20Deserialize%20BST.java) +619 | [Set Matrix Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Set%20Matrix%20Zeroes.java) +620 | [Shifting Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shifting%20Letters.java) +621 | [Short Encoding of Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Short%20Encoding%20of%20Words.java) +622 | [Shortest Completing Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Completing%20Word.java) +623 | [Shortest Path in Binary Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Path%20in%20Binary%20Matrix.java) +624 | [Shortest Path with Alternating Colors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Path%20with%20Alternating%20Colors.java) +625 | [Shortest Unsorted Continuous Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Unsorted%20Continuous%20Subarray.java) +626 | [Shortest Way to Form String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Way%20to%20Form%20String.java) +627 | [Shortest Word Distance II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Word%20Distance%20II.java) +628 | [Shortest Word Distance III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Word%20Distance%20III.java) +629 | [Shuffle an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shuffle%20an%20Array.java) +630 | [Simple Bank System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Simple%20Bank%20System.java) +631 | [Simplify Path](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Simplify%20Path.java) +632 | [Single Element in a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Single%20Element%20in%20a%20Sorted%20Array.java) +633 | [Single Number II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Single%20Number%20II.java) +634 | [Single Number III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Single%20Number%20III.java) +635 | [Smallest Integer Divisible by K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20Integer%20Divisible%20by%20K.java) +636 | [Smallest String Starting From Leaf](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20String%20Starting%20From%20Leaf.java) +637 | [Smallest String With A Given Numeric Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20String%20With%20A%20Given%20Numeric%20Value.java) +638 | [Smallest String With Swaps](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20String%20With%20Swaps.java) +639 | [Smallest Subtree with all the Deepest Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20Subtree%20with%20all%20the%20Deepest%20Nodes.java) +640 | [Smallest Value of the Rearranged Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20Value%20of%20the%20Rearranged%20Number.java) +641 | [Snakes and Ladders](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Snakes%20and%20Ladders.java) +642 | [Snapshot Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Snapshot%20Array.java) +643 | [Solve the Equation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Solve%20the%20Equation.java) +644 | [Sort An Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20An%20Array.java) +645 | [Sort Characters By Frequency](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Characters%20By%20Frequency.java) +646 | [Sort Colors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Colors.java) +647 | [Sort Integers by The Power Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Integers%20by%20The%20Power%20Value.java) +648 | [Sort List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20List.java) +649 | [Sort Transformed Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Transformed%20Array.java) +650 | [Sort the Jumbled Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20the%20Jumbled%20Numbers.java) +651 | [Sort the Matrix Diagonally](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20the%20Matrix%20Diagonally.java) +652 | [Sort the Students by Their Kth Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20the%20Students%20by%20Their%20Kth%20Score.java) +653 | [Sparse Matrix Multiplication](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sparse%20Matrix%20Multiplication.java) +654 | [Spiral Matrix II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Spiral%20Matrix%20II.java) +655 | [Spiral Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Spiral%20Matrix.java) +656 | [Split Array into Consecutive Subsequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Split%20Array%20into%20Consecutive%20Subsequences.java) +657 | [Split BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Split%20BST.java) +658 | [Split Linked List in Parts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Split%20Linked%20List%20in%20Parts.java) +659 | [Statistics from a Large Sample](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Statistics%20from%20a%20Large%20Sample.java) +660 | [Step-By-Step Directions From a Binary Tree Node to Another](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Step-By-Step%20Directions%20From%20a%20Binary%20Tree%20Node%20to%20Another.java) +661 | [Stock Price Fluctuation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Stock%20Price%20Fluctuation.java) +662 | [Strictly Palindromic Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Strictly%20Palindromic%20Number.java) +663 | [String Compression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/String%20Compression.java) +664 | [String to Integer (atoi)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/String%20to%20Integer%20(atoi).java) +665 | [Subarray Product Less Than K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subarray%20Product%20Less%20Than%20K.java) +666 | [Subarray Sum Equals K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subarray%20Sum%20Equals%20K.java) +667 | [Subarray Sums Divisible by K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subarray%20Sums%20Divisible%20by%20K.java) +668 | [Subdomain Visit Count](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subdomain%20Visit%20Count.java) +669 | [Subrectangle Queries](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subrectangle%20Queries.java) +670 | [Subsets II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subsets%20II.java) +671 | [Subsets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subsets.java) +672 | [Successful Pairs of Spells and Potions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Successful%20Pairs%20of%20Spells%20and%20Potions.java) +673 | [Sum Root to Leaf Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20Root%20to%20Leaf%20Numbers.java) +674 | [Sum of Absolute Differences in a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Absolute%20Differences%20in%20a%20Sorted%20Array.java) +675 | [Sum of Beauty of All Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Beauty%20of%20All%20Substrings.java) +676 | [Sum of Even Numbers After Queries](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Even%20Numbers%20After%20Queries.java) +677 | [Sum of Nodes with Even-Valued Grandparent](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Nodes%20with%20Even-Valued%20Grandparent.java) +678 | [Sum of Numbers With Units Digit K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Numbers%20With%20Units%20Digit%20K.java) +679 | [Sum of Subarray Minimums](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Subarray%20Minimums.java) +680 | [Super Ugly Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Super%20Ugly%20Number.java) +681 | [Surrounded Regions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Surrounded%20Regions.java) +682 | [Swap For Longest Repeated Character Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Swap%20For%20Longest%20Repeated%20Character%20Substring.java) +683 | [Swap Nodes in Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Swap%20Nodes%20in%20Pairs.java) +684 | [Swapping Nodes in a Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Swapping%20Nodes%20in%20a%20Linked%20List.java) +685 | [Synonymous Sentences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Synonymous%20Sentences.java) +686 | [Target Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Target%20Sum.java) +687 | [Task Scheduler](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Task%20Scheduler.java) +688 | [Ternary Expression Parser](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Ternary%20Expression%20Parser.java) +689 | [The Earliest Moment When Everyone Become Friends](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20Earliest%20Moment%20When%20Everyone%20Become%20Friends.java) +690 | [The Number of Full Rounds You Have Played](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20Number%20of%20Full%20Rounds%20You%20Have%20Played.java) +691 | [The Number of Weak Characters in the Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20Number%20of%20Weak%20Characters%20in%20the%20Game.java) +692 | [The k Strongest Values in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20k%20Strongest%20Values%20in%20an%20Array.java) +693 | [The kth Factor of n](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20kth%20Factor%20of%20n.java) +694 | [Throne Inheritence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Throne%20Inheritence.java) +695 | [Time Based Key-Value Store](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Time%20Based%20Key-Value%20Store.java) +696 | [Time Needed to Inform All Employees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Time%20Needed%20to%20Inform%20All%20Employees.java) +697 | [Time Needed to Rearrange a Binary String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Time%20Needed%20to%20Rearrange%20a%20Binary%20String.java) +698 | [Top K Frequent Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Top%20K%20Frequent%20Elements.java) +699 | [Top K Frequent Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Top%20K%20Frequent%20Words.java) +700 | [Total Hamming Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Total%20Hamming%20Distance.java) +701 | [Tree Diameter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Tree%20Diameter.java) +702 | [Triangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Triangle.java) +703 | [Trim a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Trim%20a%20Binary%20Search%20Tree.java) +704 | [Tuple With Same Product](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Tuple%20With%20Same%20Product.java) +705 | [Tweet Counts Per Frequency](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Tweet%20Counts%20Per%20Frequency.java) +706 | [Two City Scheduling](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Two%20City%20Scheduling.java) +707 | [Two Sum BSTs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Two%20Sum%20BSTs.java) +708 | [Two Sum II - Input Array Is Sorted](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Two%20Sum%20II%20-%20Input%20Array%20Is%20Sorted.java) +709 | [UTF-8 Validation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/UTF-8%20Validation.java) +710 | [Ugly Number II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Ugly%20Number%20II.java) +711 | [Uncrossed Lines](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Uncrossed%20Lines.java) +712 | [Unique Binary Search Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Binary%20Search%20Trees.java) +713 | [Unique Paths II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Paths%20II.java) +714 | [Unique Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Paths.java) +715 | [Unique Word Abbrevation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Word%20Abbrevation.java) +716 | [Valid Parenthesis String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Parenthesis%20String.java) +717 | [Valid Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Square.java) +718 | [Valid Sudoku](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Sudoku.java) +719 | [Valid Tic-Tac-Toe State](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Tic-Tac-Toe%20State.java) +720 | [Valid Triangle Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Triangle%20Number.java) +721 | [Validate Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Validate%20Binary%20Search%20Tree.java) +722 | [Validate IP Address](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Validate%20IP%20Address.java) +723 | [Validate Stack Sequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Validate%20Stack%20Sequences.java) +724 | [Verify Preorder Serialization of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Verify%20Preorder%20Serialization%20of%20a%20Binary%20Tree.java) +725 | [Vowel Spellchecker](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Vowel%20Spellchecker.java) +726 | [Vowels of All Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Vowels%20of%20All%20Substrings.java) +727 | [Walls and Gates](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Walls%20and%20Gates.java) +728 | [Water & Jug Problem](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Water%20&%20Jug%20Problem.java) +729 | [Watering Plants](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Watering%20Plants.java) +730 | [Web Crawler](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Web%20Crawler.java) +731 | [Wiggle Sort](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Wiggle%20Sort.java) +732 | [Wiggle Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Wiggle%20Subsequence.java) +733 | [Word Break](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Word%20Break.java) +734 | [Word Ladder](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Word%20Ladder.java) +735 | [Word Search](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Word%20Search.java) +736 | [Word Subsets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Word%20Subsets.java) +737 | [ZigZag Conversion](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/ZigZag%20Conversion.java) +738 | [Zigzag Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Zigzag%20Iterator.java) diff --git a/README.md b/README.md index 92c01bb6..e264f9eb 100644 --- a/README.md +++ b/README.md @@ -7,6 +7,7 @@ Problem Category | Count --- | --- -[Easy](https://github.com/varunu28/LeetCode-Java-Solutions/blob/master/Easy/README.md) | 452 -[Medium](https://github.com/varunu28/LeetCode-Java-Solutions/blob/master/Medium/README.md) | 543 -[Hard](https://github.com/varunu28/LeetCode-Java-Solutions/blob/master/Hard/README.md) | 67 +[Easy](https://github.com/varunu28/LeetCode-Java-Solutions/blob/master/Easy/README.md) | 558 +[Medium](https://github.com/varunu28/LeetCode-Java-Solutions/blob/master/Medium/README.md) | 739 +[Hard](https://github.com/varunu28/LeetCode-Java-Solutions/blob/master/Hard/README.md) | 95 +[Concurrency](https://github.com/varunu28/LeetCode-Java-Solutions/blob/master/Concurrency/README.md) | 9 From 941a02b99156b765207db30669a59e0a85fe346e Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Mon, 13 Feb 2023 10:03:21 -0800 Subject: [PATCH 075/712] Update Print Zero Even Odd.java --- Concurrency/Print Zero Even Odd.java | 69 ++++++++++++++-------------- 1 file changed, 35 insertions(+), 34 deletions(-) diff --git a/Concurrency/Print Zero Even Odd.java b/Concurrency/Print Zero Even Odd.java index 35b3a599..784b7fd7 100644 --- a/Concurrency/Print Zero Even Odd.java +++ b/Concurrency/Print Zero Even Odd.java @@ -1,42 +1,43 @@ class ZeroEvenOdd { - private int n; - private int flag = 0; - - public ZeroEvenOdd(int n) { - this.n = n; - } + private int n; + + private final Semaphore zeroMutex; + private final Semaphore oddMutex; + private final Semaphore evenMutex; + + public ZeroEvenOdd(int n) { + this.n = n; + this.zeroMutex = new Semaphore(1); + this.oddMutex = new Semaphore(0); + this.evenMutex = new Semaphore(0); + } - // printNumber.accept(x) outputs "x", where x is an integer. - public synchronized void zero(IntConsumer printNumber) throws InterruptedException { - for (int i = 0; i < n; i++) { - while (flag != 0) { - this.wait(); - } - printNumber.accept(0); - flag = i % 2 == 0 ? 1 : 2; - this.notifyAll(); + // printNumber.accept(x) outputs "x", where x is an integer. + public void zero(IntConsumer printNumber) throws InterruptedException { + for (int i = 0; i < n; i++) { + this.zeroMutex.acquire(); + printNumber.accept(0); + if (i % 2 == 0) { + this.oddMutex.release(); + } else { + this.evenMutex.release(); + } + } } - } - public synchronized void even(IntConsumer printNumber) throws InterruptedException { - for (int i = 2; i <= n; i += 2) { - while (flag != 2) { - this.wait(); - } - printNumber.accept(i); - flag = 0; - this.notifyAll(); + public void even(IntConsumer printNumber) throws InterruptedException { + for (int i = 2; i <= n; i += 2) { + this.evenMutex.acquire(); + printNumber.accept(i); + this.zeroMutex.release(); + } } - } - public synchronized void odd(IntConsumer printNumber) throws InterruptedException { - for (int i = 1; i <= n; i += 2) { - while (flag != 1) { - this.wait(); - } - printNumber.accept(i); - flag = 0; - this.notifyAll(); + public void odd(IntConsumer printNumber) throws InterruptedException { + for (int i = 1; i <= n; i += 2) { + this.oddMutex.acquire(); + printNumber.accept(i); + this.zeroMutex.release(); + } } - } } From 87be42c91377f21ea55b34ec2417a668b5efdd2b Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Mon, 13 Feb 2023 14:19:47 -0800 Subject: [PATCH 076/712] Update Fizz Buzz Multithreaded.java --- Concurrency/Fizz Buzz Multithreaded.java | 124 +++++++++++------------ 1 file changed, 59 insertions(+), 65 deletions(-) diff --git a/Concurrency/Fizz Buzz Multithreaded.java b/Concurrency/Fizz Buzz Multithreaded.java index 2e213c7c..b749ba25 100644 --- a/Concurrency/Fizz Buzz Multithreaded.java +++ b/Concurrency/Fizz Buzz Multithreaded.java @@ -1,77 +1,71 @@ class FizzBuzz { - private int n; - private int count; - private Semaphore fizz; - private Semaphore buzz; - private Semaphore fizzBuzz; - private Semaphore number; + private int n; + private final Semaphore fizzSemaphore; + private final Semaphore buzzSemaphore; + private final Semaphore fizzBuzzSemaphore; + private final Semaphore numSemaphore; - public FizzBuzz(int n) { - this.n = n; - this.count = 1; - this.fizz = new Semaphore(0); - this.buzz = new Semaphore(0); - this.fizzBuzz = new Semaphore(0); - this.number = new Semaphore(1); - } + public FizzBuzz(int n) { + this.n = n; + this.fizzSemaphore = new Semaphore(0); + this.buzzSemaphore = new Semaphore(0); + this.fizzBuzzSemaphore = new Semaphore(0); + this.numSemaphore = new Semaphore(1); + } - // printFizz.run() outputs "fizz". - public void fizz(Runnable printFizz) throws InterruptedException { - while (this.count <= this.n) { - if (this.count % 3 == 0 && this.count % 5 != 0) { - this.fizz.acquire(); - printFizz.run(); - this.count++; - releaseLock(this.count); - } + // printFizz.run() outputs "fizz". + public void fizz(Runnable printFizz) throws InterruptedException { + for (int i = 1; i <= n; i++) { + if (i % 3 == 0 && i % 5 != 0) { + fizzSemaphore.acquire(); + printFizz.run(); + releaseLock(i + 1); + } + } } - } - // printBuzz.run() outputs "buzz". - public void buzz(Runnable printBuzz) throws InterruptedException { - while (this.count <= this.n) { - if (this.count % 3 != 0 && this.count % 5 == 0) { - this.buzz.acquire(); - printBuzz.run(); - this.count++; - releaseLock(this.count); - } + // printBuzz.run() outputs "buzz". + public void buzz(Runnable printBuzz) throws InterruptedException { + for (int i = 1; i <= n; i++) { + if (i % 3 != 0 && i % 5 == 0) { + buzzSemaphore.acquire(); + printBuzz.run(); + releaseLock(i + 1); + } + } } - } - // printFizzBuzz.run() outputs "fizzbuzz". - public void fizzbuzz(Runnable printFizzBuzz) throws InterruptedException { - while (this.count <= this.n) { - if (this.count % 3 == 0 && this.count % 5 == 0) { - this.fizzBuzz.acquire(); - printFizzBuzz.run(); - this.count++; - releaseLock(this.count); - } + // printFizzBuzz.run() outputs "fizzbuzz". + public void fizzbuzz(Runnable printFizzBuzz) throws InterruptedException { + for (int i = 1; i <= n; i++) { + if (i % 3 == 0 && i % 5 == 0) { + fizzBuzzSemaphore.acquire(); + printFizzBuzz.run(); + releaseLock(i + 1); + } + } } - } - // printNumber.accept(x) outputs "x", where x is an integer. - public void number(IntConsumer printNumber) throws InterruptedException { - while (this.count <= this.n) { - if (this.count % 3 != 0 && this.count % 5 != 0) { - this.number.acquire(); - printNumber.accept(this.count); - this.count++; - releaseLock(this.count); - } + // printNumber.accept(x) outputs "x", where x is an integer. + public void number(IntConsumer printNumber) throws InterruptedException { + for (int i = 1; i <= n; i++) { + if (i % 3 != 0 && i % 5 != 0) { + numSemaphore.acquire(); + printNumber.accept(i); + releaseLock(i + 1); + } + } } - } - - private void releaseLock(int n) { - if (n % 15 == 0) { - this.fizzBuzz.release(); - } else if (n % 3 == 0) { - this.fizz.release(); - } else if (n % 5 == 0) { - this.buzz.release(); - } else { - this.number.release(); + + private void releaseLock(int num) { + if (num % 3 == 0 && num % 5 == 0) { + fizzBuzzSemaphore.release(); + } else if (num % 3 == 0 && num % 5 != 0) { + fizzSemaphore.release(); + } else if (num % 3 != 0 && num % 5 == 0) { + buzzSemaphore.release(); + } else { + numSemaphore.release(); + } } - } } From 1f05921833771527f5641a8aeca47ecf237a7866 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Tue, 14 Feb 2023 06:34:22 -0800 Subject: [PATCH 077/712] Update and rename Easy/Maximum Subarray.java to Medium/Maximum Subarray.java --- Easy/Maximum Subarray.java | 14 -------------- Medium/Maximum Subarray.java | 14 ++++++++++++++ 2 files changed, 14 insertions(+), 14 deletions(-) delete mode 100644 Easy/Maximum Subarray.java create mode 100644 Medium/Maximum Subarray.java diff --git a/Easy/Maximum Subarray.java b/Easy/Maximum Subarray.java deleted file mode 100644 index 46b106c7..00000000 --- a/Easy/Maximum Subarray.java +++ /dev/null @@ -1,14 +0,0 @@ -class Solution { - public int maxSubArray(int[] nums) { - int currSum = 0; - int maxSum = Integer.MIN_VALUE; - for (int num : nums) { - currSum += num; - if (num > currSum) { - currSum = num; - } - maxSum = Math.max(maxSum, currSum); - } - return maxSum; - } -} diff --git a/Medium/Maximum Subarray.java b/Medium/Maximum Subarray.java new file mode 100644 index 00000000..459a8733 --- /dev/null +++ b/Medium/Maximum Subarray.java @@ -0,0 +1,14 @@ +class Solution { + public int maxSubArray(int[] nums) { + int currSum = 0; + int maxSum = Integer.MIN_VALUE; + for (int num : nums) { + currSum += num; + if (currSum < num) { + currSum = num; + } + maxSum = Math.max(maxSum, currSum); + } + return maxSum; + } +} From c83324310a19917ce235b528685059aea0d12cbd Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Tue, 14 Feb 2023 16:17:25 -0800 Subject: [PATCH 078/712] Update Add to Array-Form of Integer.java --- Easy/Add to Array-Form of Integer.java | 31 ++++++++++++++++---------- 1 file changed, 19 insertions(+), 12 deletions(-) diff --git a/Easy/Add to Array-Form of Integer.java b/Easy/Add to Array-Form of Integer.java index 1ef362dd..64cbbb31 100644 --- a/Easy/Add to Array-Form of Integer.java +++ b/Easy/Add to Array-Form of Integer.java @@ -1,15 +1,22 @@ class Solution { - public List addToArrayForm(int[] num, int k) { - int carry = 0; - int idx = num.length - 1; - List result = new ArrayList<>(); - while (idx >= 0 || carry > 0 || k > 0) { - int temp = k % 10 + carry + (idx >= 0 ? num[idx--] : 0); - result.add(temp % 10); - carry = temp / 10; - k /= 10; + public List addToArrayForm(int[] num, int k) { + List result = new ArrayList<>(); + int idx = num.length - 1; + int carry = 0; + while (idx >= 0 || k > 0 || carry > 0) { + if (idx >= 0 && k > 0) { + carry += num[idx--] + k % 10; + k /= 10; + } else if (idx >= 0 && k == 0) { + carry += num[idx--]; + } else if (idx < 0 && k > 0) { + carry += k % 10; + k /= 10; + } + result.add(carry % 10); + carry /= 10; + } + Collections.reverse(result); + return result; } - Collections.reverse(result); - return result; - } } From 3e3198b55f0d3166f08c5ab86352a665771d008d Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Fri, 17 Feb 2023 06:36:40 -0800 Subject: [PATCH 079/712] Update Minimum Distance Between BST Nodes.java --- Easy/Minimum Distance Between BST Nodes.java | 35 +++++++++----------- 1 file changed, 16 insertions(+), 19 deletions(-) diff --git a/Easy/Minimum Distance Between BST Nodes.java b/Easy/Minimum Distance Between BST Nodes.java index 4c147e39..af92feb0 100644 --- a/Easy/Minimum Distance Between BST Nodes.java +++ b/Easy/Minimum Distance Between BST Nodes.java @@ -14,25 +14,22 @@ * } */ class Solution { - Integer minDiff; - Integer prev; - public int minDiffInBST(TreeNode root) { - minDiff = Integer.MAX_VALUE; - prev = null; - helper(root); - return minDiff; - } - - private void helper(TreeNode root) { - if (root == null) { - return; + public int minDiffInBST(TreeNode root) { + int[] minDiff = {Integer.MAX_VALUE}; + Integer[] prevVal = {null}; + inorder(root, minDiff, prevVal); + return minDiff[0]; } - helper(root.left); - if (prev != null) { - minDiff = Math.min(minDiff, root.val - prev); + + private void inorder(TreeNode node, int[] minDiff, Integer[] prevValue) { + if (node == null) { + return; + } + inorder(node.left, minDiff, prevValue); + if (prevValue[0] != null) { + minDiff[0] = Math.min(minDiff[0], node.val - prevValue[0]); + } + prevValue[0] = node.val; + inorder(node.right, minDiff, prevValue); } - prev = root.val; - helper(root.right); - } } - From 2d13d75457e356dbe454eba180176f4f36650728 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sat, 18 Feb 2023 07:01:28 -0800 Subject: [PATCH 080/712] Update Invert Binary Tree.java --- Easy/Invert Binary Tree.java | 18 ++++++++---------- 1 file changed, 8 insertions(+), 10 deletions(-) diff --git a/Easy/Invert Binary Tree.java b/Easy/Invert Binary Tree.java index f02950d0..d2c3c6ab 100644 --- a/Easy/Invert Binary Tree.java +++ b/Easy/Invert Binary Tree.java @@ -14,15 +14,13 @@ * } */ class Solution { - public TreeNode invertTree(TreeNode root) { - if (root == null) { - return root; + public TreeNode invertTree(TreeNode root) { + if (root == null) { + return null; + } + TreeNode leftNode = root.left; + root.left = invertTree(root.right); + root.right = invertTree(leftNode); + return root; } - TreeNode right = root.right; - root.right = root.left; - root.left = right; - invertTree(root.left); - invertTree(root.right); - return root; - } } From 888e64c2bca1c5d0472848c3c46d8e25e170b232 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sat, 18 Feb 2023 07:48:29 -0800 Subject: [PATCH 081/712] Update Reshape the matrix.java --- Easy/Reshape the matrix.java | 41 ++++++++++++++---------------------- 1 file changed, 16 insertions(+), 25 deletions(-) diff --git a/Easy/Reshape the matrix.java b/Easy/Reshape the matrix.java index 1093a616..ca61f4e4 100644 --- a/Easy/Reshape the matrix.java +++ b/Easy/Reshape the matrix.java @@ -1,31 +1,22 @@ class Solution { - public int[][] matrixReshape(int[][] nums, int r, int c) { - int numOfElem = nums.length*nums[0].length; - if (numOfElem != r*c) { - return nums; + public int[][] matrixReshape(int[][] mat, int r, int c) { + int m = mat.length; + int n = mat[0].length; + if (m * n != r * c) { + return mat; } - - int[] expandedArray = new int[numOfElem]; - int k = 0; - - for (int i=0;i Date: Sat, 18 Feb 2023 07:51:15 -0800 Subject: [PATCH 082/712] Update Pascal's Triangle.java --- Easy/Pascal's Triangle.java | 26 ++++++++++++++------------ 1 file changed, 14 insertions(+), 12 deletions(-) diff --git a/Easy/Pascal's Triangle.java b/Easy/Pascal's Triangle.java index a64f8bd4..86ea8bdb 100644 --- a/Easy/Pascal's Triangle.java +++ b/Easy/Pascal's Triangle.java @@ -1,15 +1,17 @@ class Solution { - public List> generate(int numRows) { - List> result = new ArrayList<>(); - for (int i = 0; i < numRows; i++) { - List temp = new ArrayList<>(); - for (int j = 0; j <= i; j++) { - temp.add( - (j == 0 || j == i) ? 1 : - (result.get(i - 1).get(j - 1) + result.get(i - 1).get(j))); - } - result.add(temp); + public List> generate(int numRows) { + List> result = new ArrayList<>(); + for (int i = 0; i < numRows; i++) { + List temp = new ArrayList<>(); + for (int j = 0; j <= i; j++) { + if (j == 0 || j == i) { + temp.add(1); + } else { + temp.add(result.get(i - 1).get(j - 1) + result.get(i - 1).get(j)); + } + } + result.add(temp); + } + return result; } - return result; - } } From 5b7f7f5de5b85e3aa420e0223ec82615647694a1 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sun, 19 Feb 2023 13:32:39 -0800 Subject: [PATCH 083/712] Added Merge Two 2D Arrays by Summing Values.java --- ...Merge Two 2D Arrays by Summing Values.java | 27 +++++++++++++++++++ 1 file changed, 27 insertions(+) create mode 100644 Easy/Merge Two 2D Arrays by Summing Values.java diff --git a/Easy/Merge Two 2D Arrays by Summing Values.java b/Easy/Merge Two 2D Arrays by Summing Values.java new file mode 100644 index 00000000..87d07080 --- /dev/null +++ b/Easy/Merge Two 2D Arrays by Summing Values.java @@ -0,0 +1,27 @@ +class Solution { + public int[][] mergeArrays(int[][] nums1, int[][] nums2) { + int[] totalSum = new int[1001]; + int count = nums1.length; + for (int i = 0; i < nums1.length; i++) { + int id = nums1[i][0]; + int val = nums1[i][1]; + totalSum[id] = val; + } + for (int i = 0; i < nums2.length; i++) { + int id = nums2[i][0]; + int val = nums2[i][1]; + if (totalSum[id] == 0) { + count++; + } + totalSum[id] += val; + } + int[][] result = new int[count][2]; + int idx = 0; + for (int i = 1; i <= 1000; i++) { + if (totalSum[i] != 0) { + result[idx++] = new int[]{i, totalSum[i]}; + } + } + return result; + } +} From 698dadd406bcf0e6091890cd813e244c4d302a60 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Mon, 20 Feb 2023 15:50:52 -0800 Subject: [PATCH 084/712] Added Maximum Difference by Remapping a Digit --- ...ximum Difference by Remapping a Digit.java | 25 +++++++++++++++++++ 1 file changed, 25 insertions(+) create mode 100644 Easy/Maximum Difference by Remapping a Digit.java diff --git a/Easy/Maximum Difference by Remapping a Digit.java b/Easy/Maximum Difference by Remapping a Digit.java new file mode 100644 index 00000000..5241297f --- /dev/null +++ b/Easy/Maximum Difference by Remapping a Digit.java @@ -0,0 +1,25 @@ +class Solution { + public int minMaxDifference(int num) { + char digitsOne[] = String.valueOf(num).toCharArray(); + char digitsTwo[] = String.valueOf(num).toCharArray(); + char firstDigitOne = digitsOne[0]; + char firstDigitTwo = digitsOne[0]; + for (int i = 0; i < digitsOne.length; i++) { + if (digitsOne[i] != '9') { + firstDigitOne = digitsOne[i]; + break; + } + } + for (int i = 0; i < digitsOne.length; i++) { + if (digitsOne[i] == firstDigitOne) { + digitsOne[i] = '9'; + } + } + for(int i = 0; i < digitsOne.length; i++) { + if (digitsTwo[i] == firstDigitTwo) { + digitsTwo[i] = '0'; + } + } + return Integer.parseInt(String.valueOf(digitsOne)) - Integer.parseInt(String.valueOf(digitsTwo)); + } +} From 05a1586f1b4523f85f9f861ad51c4355090f6e0c Mon Sep 17 00:00:00 2001 From: varunu28 Date: Mon, 20 Feb 2023 16:36:19 -0800 Subject: [PATCH 085/712] Updated Merge Two Sorted Lists.java --- Easy/Merge Two Sorted Lists.java | 56 +++++++++++++------------------- 1 file changed, 23 insertions(+), 33 deletions(-) diff --git a/Easy/Merge Two Sorted Lists.java b/Easy/Merge Two Sorted Lists.java index cb2fff94..e594a670 100644 --- a/Easy/Merge Two Sorted Lists.java +++ b/Easy/Merge Two Sorted Lists.java @@ -9,39 +9,29 @@ * } */ class Solution { - public ListNode mergeTwoLists(ListNode list1, ListNode list2) { - if (list1 == null || list2 == null) { - return list1 == null ? list2 : list1; - } - ListNode prev = null; - ListNode head = null; - while (list1 != null && list2 != null) { - if (list1.val <= list2.val) { - prev = list1; - if (head == null) { - head = list1; - } - list1 = list1.next; - } else { - ListNode node = list2; - list2 = list2.next; - if (prev == null) { - node.next = list1; - prev = node; - head = prev; - } else { - prev.next = node; - node.next = list1; - prev = node; + public ListNode mergeTwoLists(ListNode l1, ListNode l2) { + ListNode dummy = new ListNode(); + ListNode curr = dummy; + while (l1 != null || l2 != null) { + int val = -1; + if (l1 != null && l2 != null) { + if (l1.val > l2.val) { + val = l2.val; + l2 = l2.next; + } else { + val = l1.val; + l1 = l1.next; + } + } else if (l1 != null && l2 == null) { + val = l1.val; + l1 = l1.next; + } else { + val = l2.val; + l2 = l2.next; + } + curr.next = new ListNode(val); + curr = curr.next; } - } - } - if (list2 != null) { - prev.next = list2; - } - if (list1 != null) { - prev.next = list1; + return dummy.next; } - return head; - } } From 325529cc8c40d2a54321708adcf6d75e779f2436 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Mon, 20 Feb 2023 17:44:04 -0800 Subject: [PATCH 086/712] Updated Single Element in a Sorted Array --- Medium/Single Element in a Sorted Array.java | 44 ++++++++++---------- 1 file changed, 22 insertions(+), 22 deletions(-) diff --git a/Medium/Single Element in a Sorted Array.java b/Medium/Single Element in a Sorted Array.java index 3565e0b3..924794d3 100644 --- a/Medium/Single Element in a Sorted Array.java +++ b/Medium/Single Element in a Sorted Array.java @@ -1,25 +1,25 @@ class Solution { - public int singleNonDuplicate(int[] nums) { - if (nums.length == 1) { - return nums[0]; + public int singleNonDuplicate(int[] nums) { + int start = 0; + int end = nums.length - 1; + while (start < end) { + int mid = (end - start) / 2 + start; + if (nums[mid + 1] == nums[mid]) { + if ((end - mid) % 2 == 0) { + start = mid + 2; + } else { + end = mid - 1; + } + } else if (nums[mid - 1] == nums[mid]) { + if ((end - mid) % 2 == 0) { + end = mid - 2; + } else { + start = mid + 1; + } + } else { + return nums[mid]; + } + } + return nums[start]; } - return binarySearchHelper(nums, 0, nums.length - 1); - } - - private int binarySearchHelper(int[] nums, int start, int end) { - if (start > end) { - return Integer.MIN_VALUE; - } - int mid = (start + end) / 2; - if (mid == 0 && mid + 1 < nums.length && nums[mid] != nums[mid + 1]) { - return nums[mid]; - } - if (mid == nums.length - 1 && mid - 1 >= 0 && nums[mid] != nums[mid - 1]) { - return nums[mid]; - } - if (mid + 1 < nums.length && nums[mid] != nums[mid + 1] && mid - 1 >= 0 && nums[mid] != nums[mid - 1]) { - return nums[mid]; - } - return Math.max(binarySearchHelper(nums, start, mid - 1), binarySearchHelper(nums, mid + 1, end)); - } } From 244314f060c3b89916572a439c1ed7bfd0220b22 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Wed, 22 Feb 2023 19:59:10 -0800 Subject: [PATCH 087/712] Added IPO.java --- Hard/IPO.java | 31 +++++++++++++++++++++++++++++++ 1 file changed, 31 insertions(+) create mode 100644 Hard/IPO.java diff --git a/Hard/IPO.java b/Hard/IPO.java new file mode 100644 index 00000000..26cfaac8 --- /dev/null +++ b/Hard/IPO.java @@ -0,0 +1,31 @@ +class Solution { + public int findMaximizedCapital(int k, int w, int[] profits, int[] capital) { + int n = profits.length; + Project[] projects = new Project[n]; + int maximumCapital = w; + for (int i = 0; i < n; i++) { + projects[i] = new Project(capital[i], profits[i]); + } + Arrays.sort(projects); + PriorityQueue pq = new PriorityQueue<>(Collections.reverseOrder()); + int idx = 0; + for (int i = 0; i < k; i++) { + while (idx < n && projects[idx].capital <= maximumCapital) { + pq.add(projects[idx++].profit); + } + if (pq.isEmpty()) { + break; + } + maximumCapital += pq.poll(); + } + return maximumCapital; + } + + private record Project(int capital, int profit) implements Comparable { + + @Override + public int compareTo(Project o) { + return capital - o.capital; + } + } +} From 1d92d5d1e5a0182c540ff6fcef5a7d9190d01fb4 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Fri, 24 Feb 2023 06:30:26 -0800 Subject: [PATCH 088/712] Update Minimize Deviation in Array.java --- Hard/Minimize Deviation in Array.java | 36 +++++++++++++-------------- 1 file changed, 18 insertions(+), 18 deletions(-) diff --git a/Hard/Minimize Deviation in Array.java b/Hard/Minimize Deviation in Array.java index 736ccbd0..905621e6 100644 --- a/Hard/Minimize Deviation in Array.java +++ b/Hard/Minimize Deviation in Array.java @@ -1,21 +1,21 @@ class Solution { - public int minimumDeviation(int[] nums) { - int currMinimum = Integer.MAX_VALUE; - PriorityQueue priorityQueue = new PriorityQueue<>((a, b) -> b - a); - for (int num : nums) { - if (num % 2 != 0) { - num *= 2; - } - currMinimum = Math.min(currMinimum, num); - priorityQueue.add(num); + public int minimumDeviation(int[] nums) { + int currMinimum = Integer.MAX_VALUE; + PriorityQueue pq = new PriorityQueue<>(Collections.reverseOrder()); + for (int num : nums) { + if (num % 2 != 0) { + num *= 2; + } + currMinimum = Math.min(currMinimum, num); + pq.add(num); + } + int deviation = Integer.MAX_VALUE; + while (pq.peek() % 2 == 0) { + int removed = pq.poll() / 2; + currMinimum = Math.min(currMinimum, removed); + pq.add(removed); + deviation = Math.min(deviation, pq.peek() - currMinimum); + } + return deviation; } - int deviation = Integer.MAX_VALUE; - while (priorityQueue.peek() % 2 == 0) { - int removed = priorityQueue.poll() / 2; - currMinimum = Math.min(currMinimum, removed); - priorityQueue.add(removed); - deviation = Math.min(deviation, priorityQueue.peek() - currMinimum); - } - return deviation; - } } From 47e01c0983188538f8c087478b4c123d36be4a32 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Fri, 24 Feb 2023 07:27:59 -0800 Subject: [PATCH 089/712] Updated Symmetric Tree.java to iterative style --- Easy/Symmetric Tree.java | 37 ++++++++++++++++++++++++------------- 1 file changed, 24 insertions(+), 13 deletions(-) diff --git a/Easy/Symmetric Tree.java b/Easy/Symmetric Tree.java index b20e39a5..929d6ade 100644 --- a/Easy/Symmetric Tree.java +++ b/Easy/Symmetric Tree.java @@ -12,19 +12,30 @@ * this.right = right; * } * } -*/ + */ class Solution { - public boolean isSymmetric(TreeNode root) { - return helper(root.left, root.right); - } - - private boolean helper(TreeNode leftNode, TreeNode rightNode) { - if (leftNode == null && rightNode == null) { - return true; + public boolean isSymmetric(TreeNode root) { + Queue queue = new LinkedList<>(); + queue.add(new TreeNode[]{root.left, root.right}); + while (!queue.isEmpty()) { + int size = queue.size(); + while (size-- > 0) { + TreeNode[] removed = queue.remove(); + TreeNode nodeOne = removed[0]; + TreeNode nodeTwo = removed[1]; + if (nodeOne == null && nodeTwo == null) { + continue; + } + if (nodeOne == null || nodeTwo == null) { + return false; + } + if (nodeOne.val != nodeTwo.val) { + return false; + } + queue.add(new TreeNode[]{nodeOne.left, nodeTwo.right}); + queue.add(new TreeNode[]{nodeOne.right, nodeTwo.left}); + } + } + return true; } - if ((leftNode == null || rightNode == null) || leftNode.val != rightNode.val) { - return false; - } - return helper(leftNode.left, rightNode.right) && helper(leftNode.right, rightNode.left); - } } From 927db22e2033d9a015d4ac5a98354d61dd571aa7 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sun, 26 Feb 2023 07:43:57 -0800 Subject: [PATCH 090/712] Added Left and Right Sum Differences.java --- Easy/Left and Right Sum Differences.java | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) create mode 100644 Easy/Left and Right Sum Differences.java diff --git a/Easy/Left and Right Sum Differences.java b/Easy/Left and Right Sum Differences.java new file mode 100644 index 00000000..99a5338a --- /dev/null +++ b/Easy/Left and Right Sum Differences.java @@ -0,0 +1,17 @@ +class Solution { + public int[] leftRigthDifference(int[] nums) { + int n = nums.length; + int leftToRightSum = 0; + for (int i = 0; i < n; i++) { + leftToRightSum += nums[i]; + } + int[] result = new int[n]; + int rightToLeftSum = 0; + for (int i = n - 1; i >= 0; i--) { + leftToRightSum -= nums[i]; + result[i] = Math.abs(rightToLeftSum - leftToRightSum); + rightToLeftSum += nums[i]; + } + return result; + } +} From 53da45bc0c044f5f368965d8fb7798e1e11b1f92 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sun, 26 Feb 2023 09:49:15 -0800 Subject: [PATCH 091/712] Modified Edit Distance.java to use top-down --- Hard/Edit Distance.java | 48 ++++++++++++++++++++++++----------------- 1 file changed, 28 insertions(+), 20 deletions(-) diff --git a/Hard/Edit Distance.java b/Hard/Edit Distance.java index c4000645..b7ae5930 100644 --- a/Hard/Edit Distance.java +++ b/Hard/Edit Distance.java @@ -1,26 +1,34 @@ class Solution { - public int minDistance(String word1, String word2) { - int n = word1.length(); - int m = word2.length(); - if (n * m == 0) { - return n + m; + public int minDistance(String word1, String word2) { + return minDistanceHelper( + word1, + word2, + word1.length(), + word2.length(), + new Integer[word1.length() + 1][word2.length() + 1]); } - int[][] dp = new int[n + 1][m + 1]; - for (int i = 0; i <= n; i++) { - dp[i][0] = i; - } - for (int j = 0; j <= m; j++) { - dp[0][j] = j; - } - for (int i = 1; i <= n; i++) { - for (int j = 1; j <= m; j++) { - if (word1.charAt(i - 1) == word2.charAt(j - 1)) { - dp[i][j] = dp[i - 1][j - 1]; + + private int minDistanceHelper(String word1, String word2, int word1Index, int word2Index, Integer[][] memo) { + if (word1Index == 0) { + return word2Index; + } + if (word2Index == 0) { + return word1Index; + } + if (memo[word1Index][word2Index] != null) { + return memo[word1Index][word2Index]; + } + int minEditDistance = 0; + if (word1.charAt(word1Index - 1) == word2.charAt(word2Index - 1)) { + minEditDistance = minDistanceHelper(word1, word2, word1Index - 1, word2Index - 1, memo); } else { - dp[i][j] = Math.min(dp[i - 1][j - 1], Math.min(dp[i - 1][j], dp[i][j - 1])) + 1; + int distanceWithInsertion = minDistanceHelper(word1, word2, word1Index, word2Index - 1, memo); + int distanceWithDeletion = minDistanceHelper(word1, word2, word1Index - 1, word2Index, memo); + int distanceWithReplace = minDistanceHelper(word1, word2, word1Index - 1, word2Index - 1, memo); + minEditDistance = Math.min(distanceWithInsertion, + Math.min(distanceWithDeletion, distanceWithReplace)) + 1; } - } + memo[word1Index][word2Index] = minEditDistance; + return minEditDistance; } - return dp[n][m]; - } } From 810f758e80a7b1a3503efeca72c7cad54f3587a5 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sun, 26 Feb 2023 14:31:05 -0800 Subject: [PATCH 092/712] Updated Design a File Sharing System.java --- Medium/Design a File Sharing System.java | 85 +++++++++++------------- 1 file changed, 39 insertions(+), 46 deletions(-) diff --git a/Medium/Design a File Sharing System.java b/Medium/Design a File Sharing System.java index 2f6c3de7..b5bba82b 100644 --- a/Medium/Design a File Sharing System.java +++ b/Medium/Design a File Sharing System.java @@ -1,57 +1,50 @@ class FileSharing { - Map> chunkToUserMap; - Map> userToChunkMap; - int id; - PriorityQueue availableIds; - public FileSharing(int m) { - id = 1; - chunkToUserMap = new HashMap<>(); - userToChunkMap = new HashMap<>(); - for (int i = 1; i <= m; i++) { - chunkToUserMap.put(i, new HashSet<>()); - } - availableIds = new PriorityQueue<>(); - } - public int join(List ownedChunks) { - int userId = getUserId(); - userToChunkMap.put(userId, new HashSet<>(ownedChunks)); - for (Integer chunk : ownedChunks) { - chunkToUserMap.get(chunk).add(userId); - } - return userId; - } - - private int getUserId() { - if (availableIds.isEmpty()) { - return id++; + private final PriorityQueue userIdsInSystem; + private final Map> chunkToUserIdMapping; + private final Map> userIdToChunkMapping; + + public FileSharing(int m) { + this.userIdsInSystem = new PriorityQueue<>(); + this.userIdsInSystem.add(1); + this.chunkToUserIdMapping = new HashMap<>(); + for (int i = 1; i <= m; i++) { + chunkToUserIdMapping.put(i, new HashSet<>()); + } + this.userIdToChunkMapping = new HashMap<>(); } - return availableIds.poll(); - } - public void leave(int userID) { - Set chunksOwned = userToChunkMap.get(userID); - userToChunkMap.remove(userID); - for (Integer chunk : chunksOwned) { - chunkToUserMap.get(chunk).remove(userID); + public int join(List ownedChunks) { + int currUserId = this.userIdsInSystem.poll(); + if (this.userIdsInSystem.isEmpty()) { + this.userIdsInSystem.add(currUserId + 1); + } + this.userIdToChunkMapping.computeIfAbsent(currUserId, k -> new HashSet<>()); + for (Integer chunk : ownedChunks) { + this.chunkToUserIdMapping.get(chunk).add(currUserId); + this.userIdToChunkMapping.get(currUserId).add(chunk); + } + return currUserId; } - availableIds.add(userID); - } - public List request(int userID, int chunkID) { - Set usersOwningChunk = chunkToUserMap.get(chunkID); - Iterator iterator = usersOwningChunk.iterator(); - List users = new ArrayList<>(); - while (iterator.hasNext()) { - users.add(iterator.next()); + public void leave(int userID) { + this.userIdsInSystem.add(userID); + Set chunksOwned = this.userIdToChunkMapping.get(userID); + this.userIdToChunkMapping.remove(userID); + for (Integer chunk : chunksOwned) { + this.chunkToUserIdMapping.get(chunk).remove(userID); + } } - if (!usersOwningChunk.contains(userID) && usersOwningChunk.size() > 0) { - userToChunkMap.get(userID).add(chunkID); - chunkToUserMap.get(chunkID).add(userID); + + public List request(int userID, int chunkID) { + if (this.chunkToUserIdMapping.get(chunkID).isEmpty()) { + return new ArrayList<>(); + } + List usersOwningChunk = this.chunkToUserIdMapping.get(chunkID).stream().sorted().toList(); + this.userIdToChunkMapping.get(userID).add(chunkID); + this.chunkToUserIdMapping.get(chunkID).add(userID); + return usersOwningChunk; } - Collections.sort(users); - return users; - } } /** From 1e98fdc3096551c66e133562c022fd0e9988b391 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Mon, 27 Feb 2023 12:39:07 -0800 Subject: [PATCH 093/712] Updated Search in a Binary Search Tree to iterative --- Easy/Search in a Binary Search Tree.java | 24 ++++++++++++++++-------- 1 file changed, 16 insertions(+), 8 deletions(-) diff --git a/Easy/Search in a Binary Search Tree.java b/Easy/Search in a Binary Search Tree.java index 63e2f736..e3c00460 100644 --- a/Easy/Search in a Binary Search Tree.java +++ b/Easy/Search in a Binary Search Tree.java @@ -14,13 +14,21 @@ * } */ class Solution { - public TreeNode searchBST(TreeNode root, int val) { - if (root == null) { - return root; + public TreeNode searchBST(TreeNode root, int val) { + Queue queue = new LinkedList<>(); + queue.add(root); + while (!queue.isEmpty()) { + TreeNode removed = queue.remove(); + if (removed.val == val) { + return removed; + } + if (removed.val > val && removed.left != null) { + queue.add(removed.left); + } + if (removed.val < val && removed.right != null) { + queue.add(removed.right); + } + } + return null; } - if (root.val == val) { - return root; - } - return root.val > val ? searchBST(root.left, val) : searchBST(root.right, val); - } } From f195348c24a342a359567b22fd34bb1b510c2b91 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Tue, 28 Feb 2023 06:41:12 -0800 Subject: [PATCH 094/712] Updated Find Duplicate Subtrees.java --- Medium/Find Duplicate Subtrees.java | 45 ++++++++++++++--------------- 1 file changed, 21 insertions(+), 24 deletions(-) diff --git a/Medium/Find Duplicate Subtrees.java b/Medium/Find Duplicate Subtrees.java index b81a4bec..4800644b 100644 --- a/Medium/Find Duplicate Subtrees.java +++ b/Medium/Find Duplicate Subtrees.java @@ -4,35 +4,32 @@ * int val; * TreeNode left; * TreeNode right; - * TreeNode(int x) { val = x; } + * TreeNode() {} + * TreeNode(int val) { this.val = val; } + * TreeNode(int val, TreeNode left, TreeNode right) { + * this.val = val; + * this.left = left; + * this.right = right; + * } * } */ class Solution { - Map map; - public List findDuplicateSubtrees(TreeNode root) { - map = new HashMap<>(); - List ans = new ArrayList<>(); - - helper(root); - - for (TreeNode node : map.values()) { - if (node != null) { - ans.add(node); - } - } - - return ans; + List result = new LinkedList<>(); + traverse(root, new HashMap<>(), result); + return result; } - - private String helper(TreeNode root) { - if (root == null) { - return "#"; + + private String traverse(TreeNode node, Map frequencyMap, List result) { + if (node == null) { + return ""; + } + String key = ("(" + traverse(node.left, frequencyMap, result) + ")" + node.val + + "(" + traverse(node.right, frequencyMap, result) + ")"); + frequencyMap.put(key, frequencyMap.getOrDefault(key, 0) + 1); + if (frequencyMap.get(key) == 2) { + result.add(node); } - - String path = root.val + "|" + helper(root.left) + "|" + helper(root.right); - map.put(path, map.containsKey(path) ? root : null); - - return path; + return key; } } From 32a5bef670a17c7a973a8be96f7da57e8edf5ed7 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Tue, 28 Feb 2023 09:04:22 -0800 Subject: [PATCH 095/712] Updated 3Sum.java --- Medium/3Sum.java | 38 +++++++++++++++++++++----------------- 1 file changed, 21 insertions(+), 17 deletions(-) diff --git a/Medium/3Sum.java b/Medium/3Sum.java index fc4f25fa..3c615e51 100644 --- a/Medium/3Sum.java +++ b/Medium/3Sum.java @@ -1,21 +1,25 @@ class Solution { - public List> threeSum(int[] nums) { - Set> result = new HashSet<>(); - Set duplicates = new HashSet<>(); - Map map = new HashMap<>(); - for (int i = 0; i < nums.length; i++) { - if (duplicates.add(nums[i])) { - for (int j = i + 1; j < nums.length; j++) { - int target = -nums[i] - nums[j]; - if (map.containsKey(target) && map.get(target) == i) { - List temp = Arrays.asList(nums[i], nums[j], target); - Collections.sort(temp); - result.add(temp); - } - map.put(nums[j], i); + public List> threeSum(int[] nums) { + Arrays.sort(nums); + List> result = new ArrayList<>(); + for (int i = 0; i < nums.length; i++) { + if (i != 0 && nums[i] == nums[i - 1]) { + continue; + } + int low = i + 1; + int high = nums.length - 1; + while (low < high) { + int currSum = nums[low] + nums[high] + nums[i]; + if (currSum > 0 || (high < nums.length - 1 && nums[high] == nums[high + 1])) { + high--; + } else if (currSum < 0 || (low > i + 1 && nums[low] == nums[low - 1])) { + low++; + } else { + result.add(Arrays.asList(nums[i], nums[low++], nums[high--])); + } + + } } - } + return result; } - return new ArrayList<>(result); - } } From 0faa2f57c2d5132d784e990e4050703d9a22ac57 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Tue, 28 Feb 2023 13:01:26 -0800 Subject: [PATCH 096/712] Create Smallest Number in Infinite Set.java --- Medium/Smallest Number in Infinite Set.java | 34 +++++++++++++++++++++ 1 file changed, 34 insertions(+) create mode 100644 Medium/Smallest Number in Infinite Set.java diff --git a/Medium/Smallest Number in Infinite Set.java b/Medium/Smallest Number in Infinite Set.java new file mode 100644 index 00000000..2555f5ce --- /dev/null +++ b/Medium/Smallest Number in Infinite Set.java @@ -0,0 +1,34 @@ +class SmallestInfiniteSet { + + private final PriorityQueue pq; + private int current; + + public SmallestInfiniteSet() { + this.pq = new PriorityQueue<>(); + this.current = 1; + } + + public int popSmallest() { + int result = current; + if (!pq.isEmpty() && pq.peek() < current) { + result = pq.poll(); + } else { + current++; + } + while (!pq.isEmpty() && pq.peek() == result) { + pq.poll(); + } + return result; + } + + public void addBack(int num) { + pq.add(num); + } +} + +/** + * Your SmallestInfiniteSet object will be instantiated and called as such: + * SmallestInfiniteSet obj = new SmallestInfiniteSet(); + * int param_1 = obj.popSmallest(); + * obj.addBack(num); + */ From 96456396916637efbd8750f300bd4eb1a2544d28 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Tue, 28 Feb 2023 16:23:55 -0800 Subject: [PATCH 097/712] Update Sort An Array.java --- Medium/Sort An Array.java | 67 +++++++++++++++++++-------------------- 1 file changed, 33 insertions(+), 34 deletions(-) diff --git a/Medium/Sort An Array.java b/Medium/Sort An Array.java index 7c3f105e..a906afc4 100644 --- a/Medium/Sort An Array.java +++ b/Medium/Sort An Array.java @@ -1,40 +1,39 @@ class Solution { - public int[] sortArray(int[] nums) { - int n = nums.length - 1; - mergeSort(nums, 0, n); - return nums; - } - - private void mergeSort(int[] nums, int start, int end) { - if (end - start + 1 <= 1) { - return; + public int[] sortArray(int[] nums) { + mergeSort(nums, 0, nums.length - 1); + return nums; } - int mid = start + (end - start) / 2; - mergeSort(nums, start, mid); - mergeSort(nums, mid + 1, end); - merge(nums, start, mid, end); - } - private void merge(int[] nums, int start, int mid, int end) { - int left = start; - int right = mid + 1; - int[] temp = new int[end - start + 1]; - int idx = 0; - while (left <= mid && right <= end) { - if (nums[left] < nums[right]) { - temp[idx++] = nums[left++]; - } else { - temp[idx++] = nums[right++]; - } - } - while (left <= mid) { - temp[idx++] = nums[left++]; + private void mergeSort(int[] nums, int start, int end) { + if (end - start <= 0) { + return; + } + int mid = start + (end - start) / 2; + mergeSort(nums, start, mid); + mergeSort(nums, mid + 1, end); + merge(nums, start, mid, end); } - while (right <= end) { - temp[idx++] = nums[right++]; - } - for (int i = start; i <= end; i++) { - nums[i] = temp[i - start]; + + private void merge(int[] nums, int start, int mid, int end) { + int left = start; + int right = mid + 1; + int[] temp = new int[end - start + 1]; + int idx = 0; + while (left <= mid && right <= end) { + if (nums[left] < nums[right]) { + temp[idx++] = nums[left++]; + } else { + temp[idx++] = nums[right++]; + } + } + while (left <= mid) { + temp[idx++] = nums[left++]; + } + while (right <= end) { + temp[idx++] = nums[right++]; + } + for (int i = start; i <= end; i++) { + nums[i] = temp[i - start]; + } } - } } From 701b492cca15c9ae51364a99939bb6e010231c77 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Wed, 1 Mar 2023 10:22:10 -0800 Subject: [PATCH 098/712] Update Snapshot Array.java --- Medium/Snapshot Array.java | 38 ++++++++++++++++++++------------------ 1 file changed, 20 insertions(+), 18 deletions(-) diff --git a/Medium/Snapshot Array.java b/Medium/Snapshot Array.java index d735dde3..282b6476 100644 --- a/Medium/Snapshot Array.java +++ b/Medium/Snapshot Array.java @@ -1,26 +1,28 @@ class SnapshotArray { - TreeMap[] A; - int snapId; - public SnapshotArray(int length) { - A = new TreeMap[length]; - snapId = 0; - for (int i = 0; i < length; i++) { - A[i] = new TreeMap(); - A[i].put(0, 0); + + private final TreeMap[] db; + private int currentSnapId; + + public SnapshotArray(int length) { + db = new TreeMap[length]; + for (int i = 0; i < length; i++) { + db[i] = new TreeMap(); + db[i].put(0, 0); + } + this.currentSnapId = 0; } - } - public void set(int index, int val) { - A[index].put(snapId, val); - } + public void set(int index, int val) { + db[index].put(currentSnapId, val); + } - public int snap() { - return snapId++; - } + public int snap() { + return currentSnapId++; + } - public int get(int index, int snap_id) { - return A[index].floorEntry(snap_id).getValue(); - } + public int get(int index, int snap_id) { + return db[index].floorEntry(snap_id).getValue(); + } } /** From 9e9de5a770cd44269526d201256e9a1ad9e2eca2 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Wed, 1 Mar 2023 14:19:09 -0800 Subject: [PATCH 099/712] Update Valid Word Square.java --- Easy/Valid Word Square.java | 22 ++++++++++++++++------ 1 file changed, 16 insertions(+), 6 deletions(-) diff --git a/Easy/Valid Word Square.java b/Easy/Valid Word Square.java index 392d8392..0226d4d5 100644 --- a/Easy/Valid Word Square.java +++ b/Easy/Valid Word Square.java @@ -1,13 +1,23 @@ class Solution { public boolean validWordSquare(List words) { - int n = words.size(); - for (int i = 0; i < n; i++){ - for (int j = 0; j < words.get(i).length(); j++){ - if(j >= n || words.get(j).length() <= i || words.get(j).charAt(i) != words.get(i).charAt(j)) { - return false; - } + int column = 0; + for (String rowWord : words) { + String columnWord = getColumnWord(words, column++); + if (!rowWord.equals(columnWord)) { + return false; } } return true; } + + private String getColumnWord(List words, int column) { + StringBuilder sb = new StringBuilder(); + for (String word : words) { + if (column >= word.length()) { + break; + } + sb.append(word.charAt(column)); + } + return sb.toString(); + } } From 6d98b0acf584ad06ac2e346602eabbfe56492a20 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Wed, 1 Mar 2023 16:38:55 -0800 Subject: [PATCH 100/712] Update String Compression.java --- Medium/String Compression.java | 35 +++++++++++++++++----------------- 1 file changed, 17 insertions(+), 18 deletions(-) diff --git a/Medium/String Compression.java b/Medium/String Compression.java index 182df66f..060e655e 100644 --- a/Medium/String Compression.java +++ b/Medium/String Compression.java @@ -1,22 +1,21 @@ class Solution { - public int compress(char[] chars) { - int idx = 0; - int startIdx = 0; - while (idx < chars.length) { - char c = chars[idx]; - int count = 0; - while (idx < chars.length && chars[idx] == c) { - idx++; - count++; - } - chars[startIdx++] = c; - if (count > 1) { - String countString = String.valueOf(count); - for (char cs : countString.toCharArray()) { - chars[startIdx++] = cs; + public int compress(char[] chars) { + int startIdx = 0; + for (int i = 0; i < chars.length;) { + char c = chars[i]; + int count = 0; + while (i < chars.length && chars[i] == c) { + count++; + i++; + } + chars[startIdx++] = c; + if (count > 1) { + String temp = String.valueOf(count); + for (char digit : temp.toCharArray()) { + chars[startIdx++] = digit; + } + } } - } + return startIdx; } - return startIdx; - } } From e3fbc59aee6b6786bf7263c740613949c9a6f162 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Thu, 2 Mar 2023 15:23:23 -0800 Subject: [PATCH 101/712] Update Majority Element II.java --- Medium/Majority Element II.java | 79 +++++++++++++++++---------------- 1 file changed, 40 insertions(+), 39 deletions(-) diff --git a/Medium/Majority Element II.java b/Medium/Majority Element II.java index a44275b4..5b59752e 100644 --- a/Medium/Majority Element II.java +++ b/Medium/Majority Element II.java @@ -1,42 +1,43 @@ class Solution { - public List majorityElement(int[] nums) { - Integer majorityElementOne = null; - Integer majorityElementTwo = null; - int countOne = 0; - int countTwo = 0; - for (int num : nums) { - if (majorityElementOne != null && num == majorityElementOne) { - countOne++; - } else if (majorityElementTwo != null && num == majorityElementTwo) { - countTwo++; - } else if (countOne == 0) { - majorityElementOne = num; - countOne = 1; - } else if (countTwo == 0) { - majorityElementTwo = num; - countTwo = 1; - } else { - countOne--; - countTwo--; - } + public List majorityElement(int[] nums) { + Integer candidateOne = null; + Integer candidateTwo = null; + int countOne = 0; + int countTwo = 0; + for (int num : nums) { + if (candidateOne != null && candidateOne == num) { + countOne++; + } else if (candidateTwo != null && candidateTwo == num) { + countTwo++; + } else if (countOne == 0) { + candidateOne = num; + countOne++; + } else if (countTwo == 0) { + candidateTwo = num; + countTwo++; + } else { + countOne--; + countTwo--; + } + } + countOne = 0; + countTwo = 0; + for (int num : nums) { + if (candidateOne != null && candidateOne == num) { + countOne++; + } + if (candidateTwo != null && candidateTwo == num) { + countTwo++; + } + } + int n = nums.length; + List result = new ArrayList<>(); + if (countOne > n / 3) { + result.add(candidateOne); + } + if (countTwo > n / 3) { + result.add(candidateTwo); + } + return result; } - List result = new ArrayList<>(); - countOne = 0; - countTwo = 0; - for (int num : nums) { - if (majorityElementOne != null && majorityElementOne == num) { - countOne++; - } - if (majorityElementTwo != null && majorityElementTwo == num) { - countTwo++; - } - } - if (countOne > nums.length / 3) { - result.add(majorityElementOne); - } - if (countTwo > nums.length / 3) { - result.add(majorityElementTwo); - } - return result; - } } From a269fd566dba3b6aa0bac12af2a9693e009d5f24 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Thu, 2 Mar 2023 17:41:32 -0800 Subject: [PATCH 102/712] Added Find the Index of the First Occurrence in a String --- ... the Index of the First Occurrence in a String.java | 10 ++++++++++ 1 file changed, 10 insertions(+) create mode 100644 Medium/Find the Index of the First Occurrence in a String.java diff --git a/Medium/Find the Index of the First Occurrence in a String.java b/Medium/Find the Index of the First Occurrence in a String.java new file mode 100644 index 00000000..4156d0ba --- /dev/null +++ b/Medium/Find the Index of the First Occurrence in a String.java @@ -0,0 +1,10 @@ +class Solution { + public int strStr(String haystack, String needle) { + for (int i = 0; i <= haystack.length() - needle.length(); i++) { + if (haystack.substring(i, i + needle.length()).equals(needle)) { + return i; + } + } + return -1; + } +} From 613eb298b5fd1c6bb1330ba14ab90e0821333507 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sat, 4 Mar 2023 12:00:07 -0800 Subject: [PATCH 103/712] Added Count Subarrays With Fixed Bounds.java --- Hard/Count Subarrays With Fixed Bounds.java | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+) create mode 100644 Hard/Count Subarrays With Fixed Bounds.java diff --git a/Hard/Count Subarrays With Fixed Bounds.java b/Hard/Count Subarrays With Fixed Bounds.java new file mode 100644 index 00000000..2846d647 --- /dev/null +++ b/Hard/Count Subarrays With Fixed Bounds.java @@ -0,0 +1,21 @@ +class Solution { + public long countSubarrays(int[] nums, int minK, int maxK) { + long result = 0; + int minPosition = -1; + int maxPosition = -1; + int leftIdx = -1; + for (int i = 0; i < nums.length; i++) { + if (nums[i] < minK || nums[i] > maxK) { + leftIdx = i; + } + if (nums[i] == minK) { + minPosition = i; + } + if (nums[i] == maxK) { + maxPosition = i; + } + result += Math.max(0, Math.min(maxPosition, minPosition) - leftIdx); + } + return result; + } +} From 56629ad0d6abb90ec8e4cb4a783e94e95004135d Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sun, 5 Mar 2023 07:21:38 -0800 Subject: [PATCH 104/712] Added Jump Game IV --- Hard/Jump Game IV.java | 39 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 39 insertions(+) create mode 100644 Hard/Jump Game IV.java diff --git a/Hard/Jump Game IV.java b/Hard/Jump Game IV.java new file mode 100644 index 00000000..960ce4b7 --- /dev/null +++ b/Hard/Jump Game IV.java @@ -0,0 +1,39 @@ +class Solution { + public int minJumps(int[] arr) { + int n = arr.length; + Map> graph = new HashMap<>(); + for (int i = 0; i < n; i++) { + graph.computeIfAbsent(arr[i], k -> new ArrayList<>()).add(i); + } + Queue path = new LinkedList<>(); + Set visited = new HashSet<>(); + path.add(0); + int steps = 0; + while (!path.isEmpty()) { + int size = path.size(); + while (size-- > 0) { + int removed = path.remove(); + if (removed == n - 1) { + return steps; + } + for (Integer child : graph.get(arr[removed])) { + if (!visited.contains(child)) { + visited.add(child); + path.add(child); + } + } + graph.get(arr[removed]).clear(); + if (removed + 1 < n && !visited.contains(removed + 1)) { + visited.add(removed + 1); + path.add(removed + 1); + } + if (removed - 1 >= 0 && !visited.contains(removed - 1)) { + visited.add(removed - 1); + path.add(removed - 1); + } + } + steps++; + } + return -1; + } +} From 1357acfbe52974366ce73cf9fa75be37ce33e035 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sun, 5 Mar 2023 14:15:35 -0800 Subject: [PATCH 105/712] Added Pass the Pillow --- Easy/Pass the Pillow.java | 7 +++++++ 1 file changed, 7 insertions(+) create mode 100644 Easy/Pass the Pillow.java diff --git a/Easy/Pass the Pillow.java b/Easy/Pass the Pillow.java new file mode 100644 index 00000000..e9ae16ea --- /dev/null +++ b/Easy/Pass the Pillow.java @@ -0,0 +1,7 @@ +class Solution { + public int passThePillow(int n, int time) { + int factor = time / (n - 1); + int remainder = time % (n - 1); + return factor % 2 != 0 ? (n - remainder) : (1 + remainder); + } +} From 6e71fbed13f389fec45c81356bae45542fe61627 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Mon, 6 Mar 2023 19:53:48 -0800 Subject: [PATCH 106/712] Updated Minimum Time to Complete Trips.java --- Medium/Minimum Time to Complete Trips.java | 46 +++++++++++----------- 1 file changed, 23 insertions(+), 23 deletions(-) diff --git a/Medium/Minimum Time to Complete Trips.java b/Medium/Minimum Time to Complete Trips.java index 901a3e57..f6fa3539 100644 --- a/Medium/Minimum Time to Complete Trips.java +++ b/Medium/Minimum Time to Complete Trips.java @@ -1,27 +1,27 @@ class Solution { - public long minimumTime(int[] time, int totalTrips) { - long minTime = 1; - long fastestBus = time[0]; - for (int t : time) { - fastestBus = Math.min(fastestBus, t); + public long minimumTime(int[] time, int totalTrips) { + int maxTime = 1; + for (int t : time) { + maxTime = Math.max(maxTime, t); + } + long left = 1; + long right = (long) maxTime * totalTrips; + while (left < right) { + long mid = (left + right) / 2; + if (isPossible(time, mid, totalTrips)) { + right = mid; + } else { + left = mid + 1; + } + } + return left; } - long maxTime = fastestBus * totalTrips; - while (minTime < maxTime) { - long midTime = minTime + (maxTime - minTime) / 2; - if (getNumberOfTripsWithTime(time, midTime) >= totalTrips) { - maxTime = midTime; - } else { - minTime = midTime + 1; - } + + private boolean isPossible(int[] time, long totalTime, int totalTrips) { + long actualTrips = 0; + for (int t : time) { + actualTrips += totalTime / t; + } + return actualTrips >= totalTrips; } - return minTime; - } - - private long getNumberOfTripsWithTime(int[] time, long currentTime) { - long totalTrips = 0; - for (int t : time) { - totalTrips += currentTime / t; - } - return totalTrips; - } } From 96d75c9a8bb926acb97af2756b5224458fe5cdba Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Tue, 7 Mar 2023 08:19:27 -0800 Subject: [PATCH 107/712] Create Split With Minimum Sum.java --- Easy/Split With Minimum Sum.java | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+) create mode 100644 Easy/Split With Minimum Sum.java diff --git a/Easy/Split With Minimum Sum.java b/Easy/Split With Minimum Sum.java new file mode 100644 index 00000000..3f816605 --- /dev/null +++ b/Easy/Split With Minimum Sum.java @@ -0,0 +1,22 @@ +class Solution { + public int splitNum(int num) { + List digits = new ArrayList<>(); + while (num > 0) { + digits.add(num % 10); + num /= 10; + } + Collections.sort(digits); + int numOne = 0; + int numTwo = 0; + boolean flag = true; + for (int digit : digits) { + if (flag) { + numOne = numOne * 10 + digit; + } else { + numTwo = numTwo * 10 + digit; + } + flag = !flag; + } + return numOne + numTwo; + } +} From bef17f87c83f6c619b1c1c8b4240994015640712 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Tue, 7 Mar 2023 15:45:06 -0800 Subject: [PATCH 108/712] Create Kth Largest Sum in a Binary Tree.java --- Medium/Kth Largest Sum in a Binary Tree.java | 41 ++++++++++++++++++++ 1 file changed, 41 insertions(+) create mode 100644 Medium/Kth Largest Sum in a Binary Tree.java diff --git a/Medium/Kth Largest Sum in a Binary Tree.java b/Medium/Kth Largest Sum in a Binary Tree.java new file mode 100644 index 00000000..01955179 --- /dev/null +++ b/Medium/Kth Largest Sum in a Binary Tree.java @@ -0,0 +1,41 @@ +/** + * Definition for a binary tree node. + * public class TreeNode { + * int val; + * TreeNode left; + * TreeNode right; + * TreeNode() {} + * TreeNode(int val) { this.val = val; } + * TreeNode(int val, TreeNode left, TreeNode right) { + * this.val = val; + * this.left = left; + * this.right = right; + * } + * } + */ +class Solution { + public long kthLargestLevelSum(TreeNode root, int k) { + PriorityQueue pq = new PriorityQueue<>(); + Queue queue = new LinkedList<>(); + queue.add(root); + while (!queue.isEmpty()) { + int size = queue.size(); + long sum = 0l; + while (size-- > 0) { + TreeNode removed = queue.remove(); + sum += removed.val; + if (removed.left != null) { + queue.add(removed.left); + } + if (removed.right != null) { + queue.add(removed.right); + } + } + pq.add(sum); + if (pq.size() > k) { + pq.poll(); + } + } + return pq.size() < k ? -1 : pq.poll(); + } +} From 139f4792b78f4d940221ab535201178cc92bacec Mon Sep 17 00:00:00 2001 From: varunu28 Date: Wed, 8 Mar 2023 17:47:09 -0800 Subject: [PATCH 109/712] Updated Linked List Cycle II --- Medium/Linked List Cycle II.java | 38 ++++++++++++++++---------------- 1 file changed, 19 insertions(+), 19 deletions(-) diff --git a/Medium/Linked List Cycle II.java b/Medium/Linked List Cycle II.java index 42ba6ee8..2a88b1b4 100644 --- a/Medium/Linked List Cycle II.java +++ b/Medium/Linked List Cycle II.java @@ -10,24 +10,24 @@ * } */ public class Solution { - public ListNode detectCycle(ListNode head) { - ListNode fast = head; - ListNode slow = head; - while (fast != null && fast.next != null) { - slow = slow.next; - fast = fast.next.next; - if (slow == fast) { - break; - } + public ListNode detectCycle(ListNode head) { + ListNode slow = head; + ListNode fast = head; + while (fast != null && fast.next != null) { + slow = slow.next; + fast = fast.next.next; + if (slow == fast) { + break; + } + } + if (fast == null || fast.next == null) { + return null; + } + ListNode curr = head; + while (curr != slow) { + curr = curr.next; + slow = slow.next; + } + return curr; } - if (fast == null || fast.next == null) { - return null; - } - slow = head; - while (slow != fast) { - slow = slow.next; - fast = fast.next; - } - return slow; - } } From 57b4c08942fa7fb65979824c8a345ea1bd62e5f4 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Thu, 9 Mar 2023 16:58:48 -0800 Subject: [PATCH 110/712] Update Shortest Way to Form String.java --- Medium/Shortest Way to Form String.java | 43 +++++++++++-------------- 1 file changed, 19 insertions(+), 24 deletions(-) diff --git a/Medium/Shortest Way to Form String.java b/Medium/Shortest Way to Form String.java index c5f28f1f..e87eaf33 100644 --- a/Medium/Shortest Way to Form String.java +++ b/Medium/Shortest Way to Form String.java @@ -1,28 +1,23 @@ class Solution { - public int shortestWay(String source, String target) { - int count = 1; - int idx = 0; - int n = target.length(); - int sourceIdx = 0; - boolean match = false; - while (idx < n) { - if (source.charAt(sourceIdx) == target.charAt(idx)) { - idx++; - sourceIdx++; - match = true; - } - else { - sourceIdx++; - } - if (sourceIdx == source.length() && idx != n) { - if (!match) { - return -1; + public int shortestWay(String source, String target) { + Set letters = source.chars().mapToObj(c -> (char) c).collect(Collectors.toSet()); + int count = 0; + int sourceIdx = 0; + int targetIdx = 0; + while (targetIdx < target.length()) { + char targetLetter = target.charAt(targetIdx); + if (!letters.contains(targetLetter)) { + return -1; + } + if (targetLetter == source.charAt(sourceIdx)) { + targetIdx++; + } + sourceIdx++; + if (sourceIdx == source.length()) { + sourceIdx = 0; + count++; + } } - count++; - sourceIdx = 0; - match = false; - } + return count + (sourceIdx == 0 ? 0 : 1); } - return count; - } } From 7e3c64027a5d9b029e5569631270eca184beafbb Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sat, 11 Mar 2023 07:46:43 -0800 Subject: [PATCH 111/712] Updated Convert Sorted List to Binary Search Tree.java --- ...ert Sorted List to Binary Search Tree.java | 50 +++++++++---------- 1 file changed, 25 insertions(+), 25 deletions(-) diff --git a/Medium/Convert Sorted List to Binary Search Tree.java b/Medium/Convert Sorted List to Binary Search Tree.java index 5b49c0f3..c1258059 100644 --- a/Medium/Convert Sorted List to Binary Search Tree.java +++ b/Medium/Convert Sorted List to Binary Search Tree.java @@ -3,7 +3,9 @@ * public class ListNode { * int val; * ListNode next; - * ListNode(int x) { val = x; } + * ListNode() {} + * ListNode(int val) { this.val = val; } + * ListNode(int val, ListNode next) { this.val = val; this.next = next; } * } */ /** @@ -12,35 +14,33 @@ * int val; * TreeNode left; * TreeNode right; - * TreeNode(int x) { val = x; } + * TreeNode() {} + * TreeNode(int val) { this.val = val; } + * TreeNode(int val, TreeNode left, TreeNode right) { + * this.val = val; + * this.left = left; + * this.right = right; + * } * } */ class Solution { - ListNode curr; - - public TreeNode sortedListToBST(ListNode head) { - curr = head; - return generate(count(head)); - } - - public int count(ListNode node) { - int n = 0; - while (node != null) { - node = node.next; - ++n; + public TreeNode sortedListToBST(ListNode head) { + List list = new ArrayList<>(); + while (head != null) { + list.add(head.val); + head = head.next; } - return n; + return helper(list, 0, list.size() - 1); } - public TreeNode generate(int n) { - if (n==0) return null; - - TreeNode node = new TreeNode(0); - node.left = generate(n/2); - node.val = curr.val; - curr = curr.next; - node.right = generate(n-(n/2)-1); - - return node; + private TreeNode helper(List list, int start, int end) { + if (start > end) { + return null; + } + int mid = (start + end) / 2; + TreeNode root = new TreeNode(list.get(mid)); + root.left = helper(list, start, mid - 1); + root.right = helper(list, mid + 1, end); + return root; } } From a62cb373579970d281b2d14f377a9b14300ebd25 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sun, 12 Mar 2023 07:58:56 -0700 Subject: [PATCH 112/712] Added Count the Number of Vowel Strings in Range.java --- Easy/Count the Number of Vowel Strings in Range.java | 10 ++++++++++ 1 file changed, 10 insertions(+) create mode 100644 Easy/Count the Number of Vowel Strings in Range.java diff --git a/Easy/Count the Number of Vowel Strings in Range.java b/Easy/Count the Number of Vowel Strings in Range.java new file mode 100644 index 00000000..38eeb76e --- /dev/null +++ b/Easy/Count the Number of Vowel Strings in Range.java @@ -0,0 +1,10 @@ +class Solution { + public int vowelStrings(String[] words, int left, int right) { + Set vowels = Set.of('a', 'e', 'i', 'o', 'u'); + return (int) Arrays.stream(words) + .skip(left) + .limit(right - left + 1) + .filter(word -> vowels.contains(word.charAt(0)) && vowels.contains(word.charAt(word.length() - 1))) + .count(); + } +} From 5f47791115ab26d68bb2b7909a9c60124f709afc Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sun, 12 Mar 2023 18:19:12 -0700 Subject: [PATCH 113/712] Updated README --- Easy/README.md | 895 ++++++++++++++++++++-------------------- Hard/README.md | 171 ++++---- Medium/README.md | 1024 +++++++++++++++++++++++----------------------- 3 files changed, 1051 insertions(+), 1039 deletions(-) diff --git a/Easy/README.md b/Easy/README.md index 63afc542..23f8ec11 100644 --- a/Easy/README.md +++ b/Easy/README.md @@ -113,448 +113,453 @@ S.no | Coding Problem 110 | [Count of Matches in Tournament](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20of%20Matches%20in%20Tournament.java) 111 | [Count the Digits That Divide a Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20the%20Digits%20That%20Divide%20a%20Number.java) 112 | [Count the Number of Consistent Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20the%20Number%20of%20Consistent%20Strings.java) -113 | [Counting Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Counting%20Bits.java) -114 | [Counting Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Counting%20Elements.java) -115 | [Counting Words With a Given Prefix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Counting%20Words%20With%20a%20Given%20Prefix.java) -116 | [Cousins in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Cousins%20in%20Binary%20Tree.java) -117 | [Crawler Log Folder](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Crawler%20Log%20Folder.java) -118 | [Create Target Array in the Given Order](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Create%20Target%20Array%20in%20the%20Given%20Order.java) -119 | [DI String Match](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/DI%20String%20Match.java) -120 | [Day of the Week](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Day%20of%20the%20Week.java) -121 | [Day of the Year](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Day%20of%20the%20Year.java) -122 | [Decode XORed Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Decode%20XORed%20Array.java) -123 | [Decode the Message](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Decode%20the%20Message.java) -124 | [Decompress Run-Length Encoded List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Decompress%20Run-Length%20Encoded%20List.java) -125 | [Decrypt String from Alphabet to Integer Mapping](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Decrypt%20String%20from%20Alphabet%20to%20Integer%20Mapping.java) -126 | [Defanging an IP Address](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Defanging%20an%20IP%20Address.java) -127 | [Defuse the Bomb](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Defuse%20the%20Bomb.java) -128 | [Degree of an array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Degree%20of%20an%20array.java) -129 | [Delete Characters to Make Fancy String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20Characters%20to%20Make%20Fancy%20String.java) -130 | [Delete Columns to Make Sorted](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20Columns%20to%20Make%20Sorted.java) -131 | [Delete N Nodes After M Nodes of a Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20N%20Nodes%20After%20M%20Nodes%20of%20a%20Linked%20List.java) -132 | [Delete Node in a Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20Node%20in%20a%20Linked%20List.java) -133 | [Design Compressed String Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20Compressed%20String%20Iterator.java) -134 | [Design HashMap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20HashMap.java) -135 | [Design HashSet](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20HashSet.java) -136 | [Design Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20Linked%20List.java) -137 | [Design Parking System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20Parking%20System.java) -138 | [Design an Ordered Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20an%20Ordered%20Stream.java) -139 | [Design an Ordered System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20an%20Ordered%20System.java) -140 | [Destination City](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Destination%20City.java) -141 | [Detect Capital](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Detect%20Capital.java) -142 | [Detect Pattern of Length M Repeated K or More Times](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Detect%20Pattern%20of%20Length%20M%20Repeated%20K%20or%20More%20Times.java) -143 | [Determine Color of a Chessboard Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Determine%20Color%20of%20a%20Chessboard%20Square.java) -144 | [Determine Whether Matrix Can Be Obtained By Rotation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Determine%20Whether%20Matrix%20Can%20Be%20Obtained%20By%20Rotation.java) -145 | [Determine if String Halves Are Alike](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Determine%20if%20String%20Halves%20Are%20Alike.java) -146 | [Determine if Two Events Have Conflict](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Determine%20if%20Two%20Events%20Have%20Conflict.java) -147 | [Diameter of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Diameter%20of%20Binary%20Tree.java) -148 | [Diet Plan Performance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Diet%20Plan%20Performance.java) -149 | [Difference Between Element Sum and Digit Sum of an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Difference%20Between%20Element%20Sum%20and%20Digit%20Sum%20of%20an%20Array.java) -150 | [Distance Between Bus Stops](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Distance%20Between%20Bus%20Stops.java) -151 | [Distribute Candies to People](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Distribute%20Candies%20to%20People.java) -152 | [Distribute Candies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Distribute%20Candies.java) -153 | [Divide Array Into Equal Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Divide%20Array%20Into%20Equal%20Pairs.java) -154 | [Divide a String Into Groups of Size k](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Divide%20a%20String%20Into%20Groups%20of%20Size%20k.java) -155 | [Divisor Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Divisor%20Game.java) -156 | [Duplicate Zeros](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Duplicate%20Zeros.java) -157 | [Element Appearing More Than 25% In Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Element%20Appearing%20More%20Than%2025%%20In%20Sorted%20Array.java) -158 | [Employee Importance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Employee%20Importance.java) -159 | [Evaluate Boolean Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Evaluate%20Boolean%20Binary%20Tree.java) -160 | [Excel Sheet Column Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Excel%20Sheet%20Column%20Number.java) -161 | [Excel Sheet Column Title](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Excel%20Sheet%20Column%20Title.java) -162 | [Factorial Trailing Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Factorial%20Trailing%20Zeroes.java) -163 | [Fair Candy Swap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fair%20Candy%20Swap.java) -164 | [Fibonacci Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fibonacci%20Number.java) -165 | [Final Prices With a Special Discount in a Shop](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Final%20Prices%20With%20a%20Special%20Discount%20in%20a%20Shop.java) -166 | [Final Value of Variable After Performing Operations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Final%20Value%20of%20Variable%20After%20Performing%20Operations.java) -167 | [Find All K-Distant Indices in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20All%20K-Distant%20Indices%20in%20an%20Array.java) -168 | [Find All Numbers Disappeared in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20All%20Numbers%20Disappeared%20in%20an%20Array.java) -169 | [Find All the Lonely Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20All%20the%20Lonely%20Nodes.java) -170 | [Find Anagram Mappings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Anagram%20Mappings.java) -171 | [Find Closest Number to Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Closest%20Number%20to%20Zero.java) -172 | [Find Common Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Common%20Characters.java) -173 | [Find First Palindromic String in the Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20First%20Palindromic%20String%20in%20the%20Array.java) -174 | [Find Greatest Common Divisor of Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Greatest%20Common%20Divisor%20of%20Array.java) -175 | [Find Lucky Integer in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Lucky%20Integer%20in%20an%20Array.java) -176 | [Find Mode in Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Mode%20in%20Binary%20Search%20Tree.java) -177 | [Find N Unique Integers Sum up to Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20N%20Unique%20Integers%20Sum%20up%20to%20Zero.java) -178 | [Find Nearest Point That Has the Same X or Y Coordinate](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Nearest%20Point%20That%20Has%20the%20Same%20X%20or%20Y%20Coordinate.java) -179 | [Find Numbers with Even Number of Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Numbers%20with%20Even%20Number%20of%20Digits.java) -180 | [Find Pivot Index](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Pivot%20Index.java) -181 | [Find Positive Integer Solution for a Given Equation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Positive%20Integer%20Solution%20for%20a%20Given%20Equation.java) -182 | [Find Resultant Array After Removing Anagrams](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Resultant%20Array%20After%20Removing%20Anagrams.java) -183 | [Find Smallest Letter Greater Than Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Smallest%20Letter%20Greater%20Than%20Target.java) -184 | [Find Subarrays With Equal Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Subarrays%20With%20Equal%20Sum.java) -185 | [Find Target Indices After Sorting Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Target%20Indices%20After%20Sorting%20Array.java) -186 | [Find Winner on a Tic Tac Toe Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Winner%20on%20a%20Tic%20Tac%20Toe%20Game.java) -187 | [Find Words That Can Be Formed by Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Words%20That%20Can%20Be%20Formed%20by%20Characters.java) -188 | [Find if Path Exists in Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20if%20Path%20Exists%20in%20Graph.java) -189 | [Find the Array Concatenation Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Array%20Concatenation%20Value.java) -190 | [Find the Difference of Two Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Difference%20of%20Two%20Arrays.java) -191 | [Find the Distance Value Between Two Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Distance%20Value%20Between%20Two%20Arrays.java) -192 | [Find the Highest Altitude](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Highest%20Altitude.java) -193 | [Find the K-Beauty of a Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20K-Beauty%20of%20a%20Number.java) -194 | [Find the Middle Index in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Middle%20Index%20in%20Array.java) -195 | [Find the Town Judge](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Town%20Judge.java) -196 | [Find the difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20difference.java) -197 | [Finding 3-Digit Even Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Finding%203-Digit%20Even%20Numbers.java) -198 | [First Bad Version](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/First%20Bad%20Version.java) -199 | [First Letter to Appear Twice](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/First%20Letter%20to%20Appear%20Twice.java) -200 | [First Unique Character in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/First%20Unique%20Character%20in%20a%20String.java) -201 | [Fixed Point](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fixed%20Point.java) -202 | [Fizz Buzz](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fizz%20Buzz.java) -203 | [Flip Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flip%20Game.java) -204 | [Flipping an Image](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flipping%20an%20Image.java) -205 | [Flood Fill](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flood%20Fill.java) -206 | [Flower Planting With No Adjacent](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flower%20Planting%20With%20No%20Adjacent.java) -207 | [Generate a String With Characters That Have Odd Counts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Generate%20a%20String%20With%20Characters%20That%20Have%20Odd%20Counts.java) -208 | [Get Maximum in Generated Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Get%20Maximum%20in%20Generated%20Array.java) -209 | [Goal Parser Interpretation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Goal%20Parser%20Interpretation.java) -210 | [Goat Latin](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Goat%20Latin.java) -211 | [Greatest Common Divisor of Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Greatest%20Common%20Divisor%20of%20Strings.java) -212 | [Greatest English Letter in Upper and Lower Case](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Greatest%20English%20Letter%20in%20Upper%20and%20Lower%20Case.java) -213 | [Groups of Special-Equivalent Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Groups%20of%20Special-Equivalent%20Strings.java) -214 | [Guess Number Higher or Lower](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Guess%20Number%20Higher%20or%20Lower.java) -215 | [Hamming Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Hamming%20Distance.java) -216 | [Happy Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Happy%20Number.java) -217 | [Heaters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Heaters.java) -218 | [Height Checker](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Height%20Checker.java) -219 | [Hexspeak](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Hexspeak.java) -220 | [High Five](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/High%20Five.java) -221 | [How Many Apples Can You Put into the Basket](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/How%20Many%20Apples%20Can%20You%20Put%20into%20the%20Basket.java) -222 | [How Many Numbers Are Smaller Than the Current Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/How%20Many%20Numbers%20Are%20Smaller%20Than%20the%20Current%20Number.java) -223 | [Image Smoother](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Image%20Smoother.java) -224 | [Implement Queue using Stacks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Implement%20Queue%20using%20Stacks.java) -225 | [Implement Stack using Queues](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Implement%20Stack%20using%20Queues.java) -226 | [Implement strStr](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Implement%20strStr.java) -227 | [Increasing Decreasing String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Increasing%20Decreasing%20String.java) -228 | [Increasing Order Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Increasing%20Order%20Search%20Tree.java) -229 | [Index Pairs of a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Index%20Pairs%20of%20a%20String.java) -230 | [Intersection of Multiple Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20Multiple%20Arrays.java) -231 | [Intersection of Three Sorted Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20Three%20Sorted%20Arrays.java) -232 | [Intersection of Two Arrays II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20Two%20Arrays%20II.java) -233 | [Intersection of Two Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20Two%20Arrays.java) -234 | [Intersection of two Linked Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20two%20Linked%20Lists.java) -235 | [Invert Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Invert%20Binary%20Tree.java) -236 | [Is Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Is%20Subsequence.java) -237 | [Island Perimeter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Island%20Perimeter.java) -238 | [Isomorphic Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Isomorphic%20Strings.java) -239 | [Jewels and Stones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Jewels%20and%20Stones.java) -240 | [Judge Route Cycle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Judge%20Route%20Cycle.java) -241 | [K-diff Pairs in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/K-diff%20Pairs%20in%20an%20Array.java) -242 | [Keep Multiplying Found Values by Two](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Keep%20Multiplying%20Found%20Values%20by%20Two.java) -243 | [Keyboard Row](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Keyboard%20Row.java) -244 | [Kids With the Greatest Number of Candies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Kids%20With%20the%20Greatest%20Number%20of%20Candies.java) -245 | [Kth Distinct String in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Kth%20Distinct%20String%20in%20an%20Array.java) -246 | [Kth Largest Element in a Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Kth%20Largest%20Element%20in%20a%20Stream.java) -247 | [Kth Missing Positive Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Kth%20Missing%20Positive%20Number.java) -248 | [Largest 3-Same-Digit Number in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%203-Same-Digit%20Number%20in%20String.java) -249 | [Largest Local Values in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Local%20Values%20in%20a%20Matrix.java) -250 | [Largest Number After Digit Swaps by Parity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Number%20After%20Digit%20Swaps%20by%20Parity.java) -251 | [Largest Number At Least Twice of Others](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Number%20At%20Least%20Twice%20of%20Others.java) -252 | [Largest Odd Number in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Odd%20Number%20in%20String.java) -253 | [Largest Perimeter Triangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Perimeter%20Triangle.java) -254 | [Largest Positive Integer That Exists With Its Negative](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Positive%20Integer%20That%20Exists%20With%20Its%20Negative.java) -255 | [Largest Substring Between Two Equal Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Substring%20Between%20Two%20Equal%20Characters.java) -256 | [Largest Triangle Area](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Triangle%20Area.java) -257 | [Largest Unique Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Unique%20Number.java) -258 | [Last Stone Weight](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Last%20Stone%20Weight.java) -259 | [Latest Time by Replacing Hidden Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Latest%20Time%20by%20Replacing%20Hidden%20Digits.java) -260 | [Leaf-Similar Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Leaf-Similar%20Trees.java) -261 | [Lemonade Change](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Lemonade%20Change.java) -262 | [Length of last word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Length%20of%20last%20word.java) -263 | [Letter Case Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Letter%20Case%20Permutation.java) -264 | [License Key Formatting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/License%20Key%20Formatting.java) -265 | [Linked List Cycle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Linked%20List%20Cycle.java) -266 | [Logger Rate Limiter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Logger%20Rate%20Limiter.java) -267 | [Long Pressed Name](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Long%20Pressed%20Name.java) -268 | [Longer Contiguous Segments of Ones than Zeros](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longer%20Contiguous%20Segments%20of%20Ones%20than%20Zeros.java) -269 | [Longest Common Prefix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Common%20Prefix.java) -270 | [Longest Continuous Increasing Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Continuous%20Increasing%20Subsequence.java) -271 | [Longest Harmonious Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Harmonious%20Subsequence.java) -272 | [Longest Nice Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Nice%20Substring.java) -273 | [Longest Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Palindrome.java) -274 | [Longest Subsequence With Limited Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Subsequence%20With%20Limited%20Sum.java) -275 | [Longest Uncommon Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Uncommon%20Subsequence.java) -276 | [Longest Univalue Path](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Univalue%20Path.java) -277 | [Longest Word in Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Word%20in%20Dictionary.java) -278 | [Lowest Common Ancestor of a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Lowest%20Common%20Ancestor%20of%20a%20Binary%20Search%20Tree.java) -279 | [Lucky Numbers in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Lucky%20Numbers%20in%20a%20Matrix.java) -280 | [Magic Squares In Grid](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Magic%20Squares%20In%20Grid.java) -281 | [Majority Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Majority%20Element.java) -282 | [Make Array Zero by Subtracting Equal Amounts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Make%20Array%20Zero%20by%20Subtracting%20Equal%20Amounts.java) -283 | [Make The String Great](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Make%20The%20String%20Great.java) -284 | [Matrix Cells in Distance Order](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Matrix%20Cells%20in%20Distance%20Order.java) -285 | [Matrix Diagonal Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Matrix%20Diagonal%20Sum.java) -286 | [Max Consecutive Ones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Max%20Consecutive%20Ones.java) -287 | [Maximize Sum Of Array After K Negations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximize%20Sum%20Of%20Array%20After%20K%20Negations.java) -288 | [Maximum 69 Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%2069%20Number.java) -289 | [Maximum Ascending Subarray Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Ascending%20Subarray%20Sum.java) -290 | [Maximum Average Subarray I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Average%20Subarray%20I.java) -291 | [Maximum Count of Positive Integer and Negative Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Count%20of%20Positive%20Integer%20and%20Negative%20Integer.java) -292 | [Maximum Depth of N-ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Depth%20of%20N-ary%20Tree.java) -293 | [Maximum Difference Between Increasing Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Difference%20Between%20Increasing%20Elements.java) -294 | [Maximum Distance in Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Distance%20in%20Arrays.java) -295 | [Maximum Enemy Forts That Can Be Captured](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Enemy%20Forts%20That%20Can%20Be%20Captured.java) -296 | [Maximum Nesting Depth of the Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Nesting%20Depth%20of%20the%20Parentheses.java) -297 | [Maximum Number of Balloons](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Balloons.java) -298 | [Maximum Number of Balls in a Box](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Balls%20in%20a%20Box.java) -299 | [Maximum Number of Pairs in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Pairs%20in%20Array.java) -300 | [Maximum Number of Words Found in Sentences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Words%20Found%20in%20Sentences.java) -301 | [Maximum Number of Words You Can Type](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Words%20You%20Can%20Type.java) -302 | [Maximum Population Year](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Population%20Year.java) -303 | [Maximum Product Difference Between Two Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Product%20Difference%20Between%20Two%20Pairs.java) -304 | [Maximum Product of Three Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Product%20of%20Three%20Numbers.java) -305 | [Maximum Product of Two Elements in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Product%20of%20Two%20Elements%20in%20an%20Array.java) -306 | [Maximum Repeating Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Repeating%20Substring.java) -307 | [Maximum Subarray Sum I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Subarray%20Sum%20I.java) -308 | [Maximum Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Subarray.java) -309 | [Maximum Units on a Truck](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Units%20on%20a%20Truck.java) -310 | [Maximum Value of a String in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Value%20of%20a%20String%20in%20an%20Array.java) -311 | [Maximum depth of Binary tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20depth%20of%20Binary%20tree.java) -312 | [Mean of Array After Removing Some Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Mean%20of%20Array%20After%20Removing%20Some%20Elements.java) -313 | [Meeting Rooms](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Meeting%20Rooms.java) -314 | [Merge Similar Items](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Similar%20Items.java) -315 | [Merge Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Sorted%20Array.java) -316 | [Merge Strings Alternately](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Strings%20Alternately.java) -317 | [Merge Two Sorted Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Two%20Sorted%20Lists.java) -318 | [Merge two binary trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20two%20binary%20trees.java) -319 | [Middle of the linked list](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Middle%20of%20the%20linked%20list.java) -320 | [Min Cost Climbing Stairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Min%20Cost%20Climbing%20Stairs.java) -321 | [Min Max Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Min%20Max%20Game.java) -322 | [Minimum Absolute Difference in BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20%20Absolute%20Difference%20in%20BST.java) -323 | [Minimum Absolute Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Absolute%20Difference.java) -324 | [Minimum Amount of Time to Fill Cups](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Amount%20of%20Time%20to%20Fill%20Cups.java) -325 | [Minimum Bit Flips to Convert Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Bit%20Flips%20to%20Convert%20Number.java) -326 | [Minimum Changes To Make Alternating Binary String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Changes%20To%20Make%20Alternating%20Binary%20String.java) -327 | [Minimum Common Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Common%20Value.java) -328 | [Minimum Cost of Buying Candies With Discount](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Cost%20of%20Buying%20Candies%20With%20Discount.java) -329 | [Minimum Cost to Move Chips to The Same Position](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Cost%20to%20Move%20Chips%20to%20The%20Same%20Position.java) -330 | [Minimum Cuts to Divide a Circle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Cuts%20to%20Divide%20a%20Circle.java) -331 | [Minimum Depth of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Depth%20of%20a%20Binary%20Tree.java) -332 | [Minimum Difference Between Highest and Lowest of K Scores](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Difference%20Between%20Highest%20and%20Lowest%20of%20K%20Scores.java) -333 | [Minimum Distance Between BST Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Distance%20Between%20BST%20Nodes.java) -334 | [Minimum Distance to the Target Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Distance%20to%20the%20Target%20Element.java) -335 | [Minimum Hours of Training to Win a Competition](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Hours%20of%20Training%20to%20Win%20a%20Competition.java) -336 | [Minimum Index Sum of Two Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Index%20Sum%20of%20Two%20Lists.java) -337 | [Minimum Moves to Convert String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Moves%20to%20Convert%20String.java) -338 | [Minimum Moves to Equal an Array Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Moves%20to%20Equal%20an%20Array%20Element.java) -339 | [Minimum Number of Moves to Seat Everyone](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Number%20of%20Moves%20to%20Seat%20Everyone.java) -340 | [Minimum Number of Operations to Convert Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Number%20of%20Operations%20to%20Convert%20Time.java) -341 | [Minimum Operations to Make the Array Increasing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Operations%20to%20Make%20the%20Array%20Increasing.java) -342 | [Minimum Recolors to Get K Consecutive Black Blocks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Recolors%20to%20Get%20K%20Consecutive%20Black%20Blocks.java) -343 | [Minimum Subsequence in Non-Increasing Order](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Subsequence%20in%20Non-Increasing%20Order.java) -344 | [Minimum Sum of Four Digit Number After Splitting Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Sum%20of%20Four%20Digit%20Number%20After%20Splitting%20Digits.java) -345 | [Minimum Time Visiting All Points](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Time%20Visiting%20All%20Points.java) -346 | [Minimum Time to Type Word Using Special Typewriter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Time%20to%20Type%20Word%20Using%20Special%20Typewriter.java) -347 | [Minimum Value to Get Positive Step by Step Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Value%20to%20Get%20Positive%20Step%20by%20Step%20Sum.java) -348 | [Minimum_index_sum_of_two_lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum_index_sum_of_two_lists.java) -349 | [Missing Number In Arithmetic Progression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Missing%20Number%20In%20Arithmetic%20Progression.java) -350 | [Missing Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Missing%20Number.java) -351 | [Missing Ranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Missing%20Ranges.java) -352 | [Monotonic Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Monotonic%20Array.java) -353 | [Most Common Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Most%20Common%20Word.java) -354 | [Most Frequent Even Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Most%20Frequent%20Even%20Element.java) -355 | [Most Frequent Number Following Key In an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Most%20Frequent%20Number%20Following%20Key%20In%20an%20Array.java) -356 | [Most Visited Sector in a Circular Track](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Most%20Visited%20Sector%20in%20a%20Circular%20Track.java) -357 | [Move Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Move%20Zeroes.java) -358 | [Moving Average from Data Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Moving%20Average%20from%20Data%20Stream.java) -359 | [N-Repeated Element in Size 2N Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-Repeated%20Element%20in%20Size%202N%20Array.java) -360 | [N-ary Tree Postorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-ary%20Tree%20Postorder%20Traversal.java) -361 | [N-ary Tree Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-ary%20Tree%20Preorder%20Traversal.java) -362 | [N-th Tribonacci Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-th%20Tribonacci%20Number.java) -363 | [Nested List Weight Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Nested%20List%20Weight%20Sum.java) -364 | [Next Greater Element I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Next%20Greater%20Element%20I.java) -365 | [Next Greater Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Next%20Greater%20Element.java) -366 | [Nim Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Nim%20Game.java) -367 | [Number Complement](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20Complement.java) -368 | [Number Of Rectangles That Can Form The Largest Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20Of%20Rectangles%20That%20Can%20Form%20The%20Largest%20Square.java) -369 | [Number of 1 bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%201%20bits.java) -370 | [Number of Arithmetic Triplets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Arithmetic%20Triplets.java) -371 | [Number of Boomerangs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Boomerangs.java) -372 | [Number of Common Factors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Common%20Factors.java) -373 | [Number of Days Between Two Dates](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Days%20Between%20Two%20Dates.java) -374 | [Number of Days in a Month](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Days%20in%20a%20Month.java) -375 | [Number of Different Integers in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Different%20Integers%20in%20a%20String.java) -376 | [Number of Distinct Averages](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Distinct%20Averages.java) -377 | [Number of Equivalent Domino Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Equivalent%20Domino%20Pairs.java) -378 | [Number of Good Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Good%20Pairs.java) -379 | [Number of Lines To Write String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Lines%20To%20Write%20String.java) -380 | [Number of Recent Calls](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Recent%20Calls.java) -381 | [Number of Steps to Reduce a Number to Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Steps%20to%20Reduce%20a%20Number%20to%20Zero.java) -382 | [Number of Strings That Appear as Substrings in Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Strings%20That%20Appear%20as%20Substrings%20in%20Word.java) -383 | [Number of Students Doing Homework at a Given Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Students%20Doing%20Homework%20at%20a%20Given%20Time.java) -384 | [Number of Students Unable to Eat Lunch](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Students%20Unable%20to%20Eat%20Lunch.java) -385 | [Number of Unequal Triplets in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Unequal%20Triplets%20in%20Array.java) -386 | [Number of Valid Words in a Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Valid%20Words%20in%20a%20Sentence.java) -387 | [Number of segments in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20segments%20in%20a%20String.java) -388 | [Occurrences After Bigram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Occurrences%20After%20Bigram.java) -389 | [Odd String Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Odd%20String%20Difference.java) -390 | [Paint Fence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Paint%20Fence.java) -391 | [Paint House](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Paint%20House.java) -392 | [Pairs of Songs With Total Durations Divisible by 60](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Pairs%20of%20Songs%20With%20Total%20Durations%20Divisible%20by%2060.java) -393 | [Palindrome Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Palindrome%20Linked%20List.java) -394 | [Palindrome Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Palindrome%20Number.java) -395 | [Palindrome Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Palindrome%20Permutation.java) -396 | [Partition Array Into Three Parts With Equal Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Partition%20Array%20Into%20Three%20Parts%20With%20Equal%20Sum.java) -397 | [Pascal's Triangle II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Pascal's%20Triangle%20II.java) -398 | [Pascal's Triangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Pascal's%20Triangle.java) -399 | [Path Crossing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Path%20Crossing.java) -400 | [Path In Zigzag Labelled Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Path%20In%20Zigzag%20Labelled%20Binary%20Tree.java) -401 | [Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Path%20Sum.java) -402 | [Peak Index in a Mountain Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Peak%20Index%20in%20a%20Mountain%20Array.java) -403 | [Percentage of Letter in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Percentage%20of%20Letter%20in%20String.java) -404 | [Perfect Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Perfect%20Number.java) -405 | [Perform String Shifts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Perform%20String%20Shifts.java) -406 | [Plus One](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Plus%20One.java) -407 | [Positions of Large Groups](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Positions%20of%20Large%20Groups.java) -408 | [Power of Four](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Power%20of%20Four.java) -409 | [Power of Three](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Power%20of%20Three.java) -410 | [Power of Two](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Power%20of%20Two.java) -411 | [Powerful Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Powerful%20Integers.java) -412 | [Projection Area of 3D Shapes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Projection%20Area%20of%203D%20Shapes.java) -413 | [Range Sum Query Immutable](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Range%20Sum%20Query%20Immutable.java) -414 | [Range Sum of BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Range%20Sum%20of%20BST.java) -415 | [Rank Transform of an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rank%20Transform%20of%20an%20Array.java) -416 | [Ransom Note](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Ransom%20Note.java) -417 | [Read N characters Given Read4](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Read%20N%20characters%20Given%20Read4.java) -418 | [Rearrange Characters to Make Target String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rearrange%20Characters%20to%20Make%20Target%20String.java) -419 | [Rearrange Spaces Between Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rearrange%20Spaces%20Between%20Words.java) -420 | [Rectangle Overlap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rectangle%20Overlap.java) -421 | [Redistribute Characters to Make All Strings Equal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Redistribute%20Characters%20to%20Make%20All%20Strings%20Equal.java) -422 | [Reformat Date](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reformat%20Date.java) -423 | [Reformat Phone Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reformat%20Phone%20Number.java) -424 | [Reformat The String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reformat%20The%20String.java) -425 | [Relative Sort Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Relative%20Sort%20Array.java) -426 | [Relative ranks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Relative%20ranks.java) -427 | [Remove All Adjacent Duplicates In String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20All%20Adjacent%20Duplicates%20In%20String.java) -428 | [Remove Digit From Number to Maximize Result](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Digit%20From%20Number%20to%20Maximize%20Result.java) -429 | [Remove Duplicates From Sorted Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Duplicates%20From%20Sorted%20Lists.java) -430 | [Remove Duplicates from Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Duplicates%20from%20Sorted%20Array.java) -431 | [Remove Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Element.java) -432 | [Remove Letter To Equalize Frequency](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Letter%20To%20Equalize%20Frequency.java) -433 | [Remove Linked List Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Linked%20List%20Elements.java) -434 | [Remove One Element to Make the Array Strictly Increasing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20One%20Element%20to%20Make%20the%20Array%20Strictly%20Increasing.java) -435 | [Remove Outermost Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Outermost%20Parentheses.java) -436 | [Remove Palindromic Subsequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Palindromic%20Subsequences.java) -437 | [Remove Vowels from a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Vowels%20from%20a%20String.java) -438 | [Repeated String Match](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Repeated%20String%20Match.java) -439 | [Repeated Substring Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Repeated%20Substring%20Pattern.java) -440 | [Replace All ?'s to Avoid Consecutive Repeating Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Replace%20All%20?'s%20to%20Avoid%20Consecutive%20Repeating%20Characters.java) -441 | [Replace All Digits with Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Replace%20All%20Digits%20with%20Characters.java) -442 | [Replace Elements with Greatest Element on Right Side](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Replace%20Elements%20with%20Greatest%20Element%20on%20Right%20Side.java) -443 | [Reshape the matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reshape%20the%20matrix.java) -444 | [Reverse Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Bits.java) -445 | [Reverse Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Linked%20List.java) -446 | [Reverse Only Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Only%20Letters.java) -447 | [Reverse Prefix of Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Prefix%20of%20Word.java) -448 | [Reverse String II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20String%20II.java) -449 | [Reverse String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20String.java) -450 | [Reverse Vowels of a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Vowels%20of%20a%20String.java) -451 | [Reverse words in a String III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20words%20in%20a%20String%20III.java) -452 | [Richest Customer Wealth](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Richest%20Customer%20Wealth.java) -453 | [Rings and Rods](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rings%20and%20Rods.java) -454 | [Robot Return to Origin](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Robot%20Return%20to%20Origin.java) -455 | [Roman to Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Roman%20to%20Integer.java) -456 | [Root Equals Sum of Children](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Root%20Equals%20Sum%20of%20Children.java) -457 | [Rotate String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rotate%20String.java) -458 | [Running Sum of 1d Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Running%20Sum%20of%201d%20Array.java) -459 | [Same Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Same%20Tree.java) -460 | [Search Insert Position](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Search%20Insert%20Position.java) -461 | [Search in a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Search%20in%20a%20Binary%20Search%20Tree.java) -462 | [Second Largest Digit in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Second%20Largest%20Digit%20in%20a%20String.java) -463 | [Second Minimum Node in a binary tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Second%20Minimum%20Node%20in%20a%20binary%20tree.java) -464 | [Self Dividing Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Self%20Dividing%20Number.java) -465 | [Sentence Similarity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sentence%20Similarity.java) -466 | [Separate the Digits in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Separate%20the%20Digits%20in%20an%20Array.java) -467 | [Set Mismatch](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Set%20Mismatch.java) -468 | [Shortest Completing Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Completing%20Word.java) -469 | [Shortest Distance to Target String in a Circular Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Distance%20to%20Target%20String%20in%20a%20Circular%20Array.java) -470 | [Shortest Distance to a Character](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Distance%20to%20a%20Character.java) -471 | [Shortest Word Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Word%20Distance.java) -472 | [Shuffle String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shuffle%20String.java) -473 | [Shuffle the Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shuffle%20the%20Array.java) -474 | [Sign of the Product of an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sign%20of%20the%20Product%20of%20an%20Array.java) -475 | [Similar RGB Color](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Similar%20RGB%20Color.java) -476 | [Single Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Single%20Number.java) -477 | [Single-Row Keyboard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Single-Row%20Keyboard.java) -478 | [Slowest Key](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Slowest%20Key.java) -479 | [Smallest Even Multiple](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Smallest%20Even%20Multiple.java) -480 | [Smallest Index With Equal Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Smallest%20Index%20With%20Equal%20Value.java) -481 | [Smallest Range I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Smallest%20Range%20I.java) -482 | [Sort Array By Parity II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Array%20By%20Parity%20II.java) -483 | [Sort Array By Parity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Array%20By%20Parity.java) -484 | [Sort Array by Increasing Frequency](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Array%20by%20Increasing%20Frequency.java) -485 | [Sort Even and Odd Indices Independently](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Even%20and%20Odd%20Indices%20Independently.java) -486 | [Sort Integers by The Number of 1 Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Integers%20by%20The%20Number%20of%201%20Bits.java) -487 | [Sort the People](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20the%20People.java) -488 | [Sorting the Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sorting%20the%20Sentence.java) -489 | [Special Array With X Elements Greater Than or Equal X](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Special%20Array%20With%20X%20Elements%20Greater%20Than%20or%20Equal%20X.java) -490 | [Special Positions in a Binary Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Special%20Positions%20in%20a%20Binary%20Matrix.java) -491 | [Split a String in Balanced Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Split%20a%20String%20in%20Balanced%20Strings.java) -492 | [SqrtX](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/SqrtX.java) -493 | [Squares of a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Squares%20of%20a%20Sorted%20Array.java) -494 | [String Matching in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/String%20Matching%20in%20an%20Array.java) -495 | [String Without AAA or BBB](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/String%20Without%20AAA%20or%20BBB.java) -496 | [Strobogrammatic Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Strobogrammatic%20Number.java) -497 | [Strong Password Checker II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Strong%20Password%20Checker%20II.java) -498 | [Student Attendance Record I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Student%20Attendance%20Record%20I.java) -499 | [Submission Detail](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Submission%20Detail.java) -500 | [Substrings of Size Three with Distinct Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Substrings%20of%20Size%20Three%20with%20Distinct%20Characters.java) -501 | [Subtract the Product and Sum of Digits of an Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Subtract%20the%20Product%20and%20Sum%20of%20Digits%20of%20an%20Integer.java) -502 | [Subtree of Another Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Subtree%20of%20Another%20Tree.java) -503 | [Sum Of Two Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20Of%20Two%20Integers.java) -504 | [Sum of All Odd Length Subarrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20All%20Odd%20Length%20Subarrays.java) -505 | [Sum of Digits in Base K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Digits%20in%20Base%20K.java) -506 | [Sum of Digits in the Minimum Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Digits%20in%20the%20Minimum%20Number.java) -507 | [Sum of Digits of String After Convert](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Digits%20of%20String%20After%20Convert.java) -508 | [Sum of Left Leaves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Left%20Leaves.java) -509 | [Sum of Root To Leaf Binary Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Root%20To%20Leaf%20Binary%20Numbers.java) -510 | [Sum of Square Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Square%20Numbers.java) -511 | [Sum of Unique Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Unique%20Elements.java) -512 | [Summary Ranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Summary%20Ranges.java) -513 | [Symmetric Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Symmetric%20Tree.java) -514 | [Take Gifts From the Richest Pile](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Take%20Gifts%20From%20the%20Richest%20Pile.java) -515 | [Teemo Attacking](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Teemo%20Attacking.java) -516 | [Teoplitz Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Teoplitz%20Matrix.java) -517 | [The Employee That Worked on the Longest Task](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/The%20Employee%20That%20Worked%20on%20the%20Longest%20Task.java) -518 | [The K Weakest Rows in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/The%20K%20Weakest%20Rows%20in%20a%20Matrix.java) -519 | [Third Maximum Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Third%20Maximum%20Number.java) -520 | [Thousand Separator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Thousand%20Separator.java) -521 | [Three Consecutive Odds](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Three%20Consecutive%20Odds.java) -522 | [Three Divisors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Three%20Divisors.java) -523 | [Time Needed to Buy Tickets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Time%20Needed%20to%20Buy%20Tickets.java) -524 | [To Lower Case](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/To%20Lower%20Case.java) -525 | [Toeplitz Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Toeplitz%20Matrix.java) -526 | [Transpose Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Transpose%20Matrix.java) -527 | [Truncate Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Truncate%20Sentence.java) -528 | [Two Furthest Houses With Different Colors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Furthest%20Houses%20With%20Different%20Colors.java) -529 | [Two Out of Three](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Out%20of%20Three.java) -530 | [Two Sum III - Data Structure Design](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum%20III%20-%20Data%20Structure%20Design.java) -531 | [Two Sum IV - Input is a BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum%20IV%20-%20Input%20is%20a%20BST.java) -532 | [Two Sum Less Than K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum%20Less%20Than%20K.java) -533 | [Two Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum.java) -534 | [Ugly Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Ugly%20Number.java) -535 | [Uncommon Words from Two Sentences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Uncommon%20Words%20from%20Two%20Sentences.java) -536 | [Unique Email Addresses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Unique%20Email%20Addresses.java) -537 | [Unique Morse Code Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Unique%20Morse%20Code%20Words.java) -538 | [Unique Number of Occurrences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Unique%20Number%20of%20Occurrences.java) -539 | [Univalued Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Univalued%20Binary%20Tree.java) -540 | [Valid Anagram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Anagram.java) -541 | [Valid Boomerang](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Boomerang.java) -542 | [Valid Mountain Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Mountain%20Array.java) -543 | [Valid Palindrome II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Palindrome%20II.java) -544 | [Valid Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Palindrome.java) -545 | [Valid Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Parentheses.java) -546 | [Valid Perfect Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Perfect%20Square.java) -547 | [Valid Word Abbreviation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Word%20Abbreviation.java) -548 | [Valid Word Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Word%20Sequence.java) -549 | [Valid Word Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Word%20Square.java) -550 | [Verifying an Alien Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Verifying%20an%20Alien%20Dictionary.java) -551 | [Water Bottles](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Water%20Bottles.java) -552 | [Word Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Word%20Pattern.java) -553 | [X of a Kind in a Deck of Cards](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/X%20of%20a%20Kind%20in%20a%20Deck%20of%20Cards.java) -554 | [XOR Operation in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/XOR%20Operation%20in%20an%20Array.java) -555 | [nim_game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/nim_game.java) -556 | [range_addition_II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/range_addition_II.java) -557 | [trailing_zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/trailing_zeroes.java) +113 | [Count the Number of Vowel Strings in Range](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20the%20Number%20of%20Vowel%20Strings%20in%20Range.java) +114 | [Counting Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Counting%20Bits.java) +115 | [Counting Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Counting%20Elements.java) +116 | [Counting Words With a Given Prefix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Counting%20Words%20With%20a%20Given%20Prefix.java) +117 | [Cousins in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Cousins%20in%20Binary%20Tree.java) +118 | [Crawler Log Folder](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Crawler%20Log%20Folder.java) +119 | [Create Target Array in the Given Order](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Create%20Target%20Array%20in%20the%20Given%20Order.java) +120 | [DI String Match](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/DI%20String%20Match.java) +121 | [Day of the Week](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Day%20of%20the%20Week.java) +122 | [Day of the Year](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Day%20of%20the%20Year.java) +123 | [Decode XORed Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Decode%20XORed%20Array.java) +124 | [Decode the Message](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Decode%20the%20Message.java) +125 | [Decompress Run-Length Encoded List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Decompress%20Run-Length%20Encoded%20List.java) +126 | [Decrypt String from Alphabet to Integer Mapping](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Decrypt%20String%20from%20Alphabet%20to%20Integer%20Mapping.java) +127 | [Defanging an IP Address](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Defanging%20an%20IP%20Address.java) +128 | [Defuse the Bomb](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Defuse%20the%20Bomb.java) +129 | [Degree of an array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Degree%20of%20an%20array.java) +130 | [Delete Characters to Make Fancy String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20Characters%20to%20Make%20Fancy%20String.java) +131 | [Delete Columns to Make Sorted](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20Columns%20to%20Make%20Sorted.java) +132 | [Delete N Nodes After M Nodes of a Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20N%20Nodes%20After%20M%20Nodes%20of%20a%20Linked%20List.java) +133 | [Delete Node in a Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20Node%20in%20a%20Linked%20List.java) +134 | [Design Compressed String Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20Compressed%20String%20Iterator.java) +135 | [Design HashMap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20HashMap.java) +136 | [Design HashSet](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20HashSet.java) +137 | [Design Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20Linked%20List.java) +138 | [Design Parking System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20Parking%20System.java) +139 | [Design an Ordered Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20an%20Ordered%20Stream.java) +140 | [Design an Ordered System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20an%20Ordered%20System.java) +141 | [Destination City](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Destination%20City.java) +142 | [Detect Capital](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Detect%20Capital.java) +143 | [Detect Pattern of Length M Repeated K or More Times](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Detect%20Pattern%20of%20Length%20M%20Repeated%20K%20or%20More%20Times.java) +144 | [Determine Color of a Chessboard Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Determine%20Color%20of%20a%20Chessboard%20Square.java) +145 | [Determine Whether Matrix Can Be Obtained By Rotation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Determine%20Whether%20Matrix%20Can%20Be%20Obtained%20By%20Rotation.java) +146 | [Determine if String Halves Are Alike](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Determine%20if%20String%20Halves%20Are%20Alike.java) +147 | [Determine if Two Events Have Conflict](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Determine%20if%20Two%20Events%20Have%20Conflict.java) +148 | [Diameter of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Diameter%20of%20Binary%20Tree.java) +149 | [Diet Plan Performance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Diet%20Plan%20Performance.java) +150 | [Difference Between Element Sum and Digit Sum of an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Difference%20Between%20Element%20Sum%20and%20Digit%20Sum%20of%20an%20Array.java) +151 | [Distance Between Bus Stops](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Distance%20Between%20Bus%20Stops.java) +152 | [Distribute Candies to People](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Distribute%20Candies%20to%20People.java) +153 | [Distribute Candies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Distribute%20Candies.java) +154 | [Divide Array Into Equal Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Divide%20Array%20Into%20Equal%20Pairs.java) +155 | [Divide a String Into Groups of Size k](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Divide%20a%20String%20Into%20Groups%20of%20Size%20k.java) +156 | [Divisor Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Divisor%20Game.java) +157 | [Duplicate Zeros](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Duplicate%20Zeros.java) +158 | [Element Appearing More Than 25% In Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Element%20Appearing%20More%20Than%2025%%20In%20Sorted%20Array.java) +159 | [Employee Importance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Employee%20Importance.java) +160 | [Evaluate Boolean Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Evaluate%20Boolean%20Binary%20Tree.java) +161 | [Excel Sheet Column Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Excel%20Sheet%20Column%20Number.java) +162 | [Excel Sheet Column Title](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Excel%20Sheet%20Column%20Title.java) +163 | [Factorial Trailing Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Factorial%20Trailing%20Zeroes.java) +164 | [Fair Candy Swap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fair%20Candy%20Swap.java) +165 | [Fibonacci Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fibonacci%20Number.java) +166 | [Final Prices With a Special Discount in a Shop](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Final%20Prices%20With%20a%20Special%20Discount%20in%20a%20Shop.java) +167 | [Final Value of Variable After Performing Operations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Final%20Value%20of%20Variable%20After%20Performing%20Operations.java) +168 | [Find All K-Distant Indices in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20All%20K-Distant%20Indices%20in%20an%20Array.java) +169 | [Find All Numbers Disappeared in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20All%20Numbers%20Disappeared%20in%20an%20Array.java) +170 | [Find All the Lonely Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20All%20the%20Lonely%20Nodes.java) +171 | [Find Anagram Mappings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Anagram%20Mappings.java) +172 | [Find Closest Number to Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Closest%20Number%20to%20Zero.java) +173 | [Find Common Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Common%20Characters.java) +174 | [Find First Palindromic String in the Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20First%20Palindromic%20String%20in%20the%20Array.java) +175 | [Find Greatest Common Divisor of Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Greatest%20Common%20Divisor%20of%20Array.java) +176 | [Find Lucky Integer in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Lucky%20Integer%20in%20an%20Array.java) +177 | [Find Mode in Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Mode%20in%20Binary%20Search%20Tree.java) +178 | [Find N Unique Integers Sum up to Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20N%20Unique%20Integers%20Sum%20up%20to%20Zero.java) +179 | [Find Nearest Point That Has the Same X or Y Coordinate](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Nearest%20Point%20That%20Has%20the%20Same%20X%20or%20Y%20Coordinate.java) +180 | [Find Numbers with Even Number of Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Numbers%20with%20Even%20Number%20of%20Digits.java) +181 | [Find Pivot Index](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Pivot%20Index.java) +182 | [Find Positive Integer Solution for a Given Equation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Positive%20Integer%20Solution%20for%20a%20Given%20Equation.java) +183 | [Find Resultant Array After Removing Anagrams](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Resultant%20Array%20After%20Removing%20Anagrams.java) +184 | [Find Smallest Letter Greater Than Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Smallest%20Letter%20Greater%20Than%20Target.java) +185 | [Find Subarrays With Equal Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Subarrays%20With%20Equal%20Sum.java) +186 | [Find Target Indices After Sorting Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Target%20Indices%20After%20Sorting%20Array.java) +187 | [Find Winner on a Tic Tac Toe Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Winner%20on%20a%20Tic%20Tac%20Toe%20Game.java) +188 | [Find Words That Can Be Formed by Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Words%20That%20Can%20Be%20Formed%20by%20Characters.java) +189 | [Find if Path Exists in Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20if%20Path%20Exists%20in%20Graph.java) +190 | [Find the Array Concatenation Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Array%20Concatenation%20Value.java) +191 | [Find the Difference of Two Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Difference%20of%20Two%20Arrays.java) +192 | [Find the Distance Value Between Two Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Distance%20Value%20Between%20Two%20Arrays.java) +193 | [Find the Highest Altitude](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Highest%20Altitude.java) +194 | [Find the K-Beauty of a Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20K-Beauty%20of%20a%20Number.java) +195 | [Find the Middle Index in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Middle%20Index%20in%20Array.java) +196 | [Find the Town Judge](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Town%20Judge.java) +197 | [Find the difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20difference.java) +198 | [Finding 3-Digit Even Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Finding%203-Digit%20Even%20Numbers.java) +199 | [First Bad Version](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/First%20Bad%20Version.java) +200 | [First Letter to Appear Twice](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/First%20Letter%20to%20Appear%20Twice.java) +201 | [First Unique Character in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/First%20Unique%20Character%20in%20a%20String.java) +202 | [Fixed Point](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fixed%20Point.java) +203 | [Fizz Buzz](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fizz%20Buzz.java) +204 | [Flip Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flip%20Game.java) +205 | [Flipping an Image](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flipping%20an%20Image.java) +206 | [Flood Fill](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flood%20Fill.java) +207 | [Flower Planting With No Adjacent](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flower%20Planting%20With%20No%20Adjacent.java) +208 | [Generate a String With Characters That Have Odd Counts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Generate%20a%20String%20With%20Characters%20That%20Have%20Odd%20Counts.java) +209 | [Get Maximum in Generated Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Get%20Maximum%20in%20Generated%20Array.java) +210 | [Goal Parser Interpretation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Goal%20Parser%20Interpretation.java) +211 | [Goat Latin](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Goat%20Latin.java) +212 | [Greatest Common Divisor of Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Greatest%20Common%20Divisor%20of%20Strings.java) +213 | [Greatest English Letter in Upper and Lower Case](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Greatest%20English%20Letter%20in%20Upper%20and%20Lower%20Case.java) +214 | [Groups of Special-Equivalent Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Groups%20of%20Special-Equivalent%20Strings.java) +215 | [Guess Number Higher or Lower](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Guess%20Number%20Higher%20or%20Lower.java) +216 | [Hamming Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Hamming%20Distance.java) +217 | [Happy Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Happy%20Number.java) +218 | [Heaters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Heaters.java) +219 | [Height Checker](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Height%20Checker.java) +220 | [Hexspeak](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Hexspeak.java) +221 | [High Five](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/High%20Five.java) +222 | [How Many Apples Can You Put into the Basket](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/How%20Many%20Apples%20Can%20You%20Put%20into%20the%20Basket.java) +223 | [How Many Numbers Are Smaller Than the Current Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/How%20Many%20Numbers%20Are%20Smaller%20Than%20the%20Current%20Number.java) +224 | [Image Smoother](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Image%20Smoother.java) +225 | [Implement Queue using Stacks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Implement%20Queue%20using%20Stacks.java) +226 | [Implement Stack using Queues](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Implement%20Stack%20using%20Queues.java) +227 | [Implement strStr](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Implement%20strStr.java) +228 | [Increasing Decreasing String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Increasing%20Decreasing%20String.java) +229 | [Increasing Order Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Increasing%20Order%20Search%20Tree.java) +230 | [Index Pairs of a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Index%20Pairs%20of%20a%20String.java) +231 | [Intersection of Multiple Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20Multiple%20Arrays.java) +232 | [Intersection of Three Sorted Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20Three%20Sorted%20Arrays.java) +233 | [Intersection of Two Arrays II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20Two%20Arrays%20II.java) +234 | [Intersection of Two Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20Two%20Arrays.java) +235 | [Intersection of two Linked Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20two%20Linked%20Lists.java) +236 | [Invert Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Invert%20Binary%20Tree.java) +237 | [Is Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Is%20Subsequence.java) +238 | [Island Perimeter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Island%20Perimeter.java) +239 | [Isomorphic Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Isomorphic%20Strings.java) +240 | [Jewels and Stones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Jewels%20and%20Stones.java) +241 | [Judge Route Cycle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Judge%20Route%20Cycle.java) +242 | [K-diff Pairs in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/K-diff%20Pairs%20in%20an%20Array.java) +243 | [Keep Multiplying Found Values by Two](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Keep%20Multiplying%20Found%20Values%20by%20Two.java) +244 | [Keyboard Row](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Keyboard%20Row.java) +245 | [Kids With the Greatest Number of Candies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Kids%20With%20the%20Greatest%20Number%20of%20Candies.java) +246 | [Kth Distinct String in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Kth%20Distinct%20String%20in%20an%20Array.java) +247 | [Kth Largest Element in a Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Kth%20Largest%20Element%20in%20a%20Stream.java) +248 | [Kth Missing Positive Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Kth%20Missing%20Positive%20Number.java) +249 | [Largest 3-Same-Digit Number in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%203-Same-Digit%20Number%20in%20String.java) +250 | [Largest Local Values in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Local%20Values%20in%20a%20Matrix.java) +251 | [Largest Number After Digit Swaps by Parity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Number%20After%20Digit%20Swaps%20by%20Parity.java) +252 | [Largest Number At Least Twice of Others](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Number%20At%20Least%20Twice%20of%20Others.java) +253 | [Largest Odd Number in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Odd%20Number%20in%20String.java) +254 | [Largest Perimeter Triangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Perimeter%20Triangle.java) +255 | [Largest Positive Integer That Exists With Its Negative](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Positive%20Integer%20That%20Exists%20With%20Its%20Negative.java) +256 | [Largest Substring Between Two Equal Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Substring%20Between%20Two%20Equal%20Characters.java) +257 | [Largest Triangle Area](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Triangle%20Area.java) +258 | [Largest Unique Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Unique%20Number.java) +259 | [Last Stone Weight](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Last%20Stone%20Weight.java) +260 | [Latest Time by Replacing Hidden Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Latest%20Time%20by%20Replacing%20Hidden%20Digits.java) +261 | [Leaf-Similar Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Leaf-Similar%20Trees.java) +262 | [Left and Right Sum Differences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Left%20and%20Right%20Sum%20Differences.java) +263 | [Lemonade Change](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Lemonade%20Change.java) +264 | [Length of last word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Length%20of%20last%20word.java) +265 | [Letter Case Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Letter%20Case%20Permutation.java) +266 | [License Key Formatting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/License%20Key%20Formatting.java) +267 | [Linked List Cycle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Linked%20List%20Cycle.java) +268 | [Logger Rate Limiter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Logger%20Rate%20Limiter.java) +269 | [Long Pressed Name](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Long%20Pressed%20Name.java) +270 | [Longer Contiguous Segments of Ones than Zeros](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longer%20Contiguous%20Segments%20of%20Ones%20than%20Zeros.java) +271 | [Longest Common Prefix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Common%20Prefix.java) +272 | [Longest Continuous Increasing Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Continuous%20Increasing%20Subsequence.java) +273 | [Longest Harmonious Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Harmonious%20Subsequence.java) +274 | [Longest Nice Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Nice%20Substring.java) +275 | [Longest Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Palindrome.java) +276 | [Longest Subsequence With Limited Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Subsequence%20With%20Limited%20Sum.java) +277 | [Longest Uncommon Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Uncommon%20Subsequence.java) +278 | [Longest Univalue Path](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Univalue%20Path.java) +279 | [Longest Word in Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Word%20in%20Dictionary.java) +280 | [Lowest Common Ancestor of a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Lowest%20Common%20Ancestor%20of%20a%20Binary%20Search%20Tree.java) +281 | [Lucky Numbers in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Lucky%20Numbers%20in%20a%20Matrix.java) +282 | [Magic Squares In Grid](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Magic%20Squares%20In%20Grid.java) +283 | [Majority Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Majority%20Element.java) +284 | [Make Array Zero by Subtracting Equal Amounts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Make%20Array%20Zero%20by%20Subtracting%20Equal%20Amounts.java) +285 | [Make The String Great](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Make%20The%20String%20Great.java) +286 | [Matrix Cells in Distance Order](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Matrix%20Cells%20in%20Distance%20Order.java) +287 | [Matrix Diagonal Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Matrix%20Diagonal%20Sum.java) +288 | [Max Consecutive Ones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Max%20Consecutive%20Ones.java) +289 | [Maximize Sum Of Array After K Negations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximize%20Sum%20Of%20Array%20After%20K%20Negations.java) +290 | [Maximum 69 Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%2069%20Number.java) +291 | [Maximum Ascending Subarray Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Ascending%20Subarray%20Sum.java) +292 | [Maximum Average Subarray I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Average%20Subarray%20I.java) +293 | [Maximum Count of Positive Integer and Negative Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Count%20of%20Positive%20Integer%20and%20Negative%20Integer.java) +294 | [Maximum Depth of N-ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Depth%20of%20N-ary%20Tree.java) +295 | [Maximum Difference Between Increasing Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Difference%20Between%20Increasing%20Elements.java) +296 | [Maximum Difference by Remapping a Digit](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Difference%20by%20Remapping%20a%20Digit.java) +297 | [Maximum Distance in Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Distance%20in%20Arrays.java) +298 | [Maximum Enemy Forts That Can Be Captured](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Enemy%20Forts%20That%20Can%20Be%20Captured.java) +299 | [Maximum Nesting Depth of the Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Nesting%20Depth%20of%20the%20Parentheses.java) +300 | [Maximum Number of Balloons](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Balloons.java) +301 | [Maximum Number of Balls in a Box](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Balls%20in%20a%20Box.java) +302 | [Maximum Number of Pairs in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Pairs%20in%20Array.java) +303 | [Maximum Number of Words Found in Sentences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Words%20Found%20in%20Sentences.java) +304 | [Maximum Number of Words You Can Type](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Words%20You%20Can%20Type.java) +305 | [Maximum Population Year](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Population%20Year.java) +306 | [Maximum Product Difference Between Two Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Product%20Difference%20Between%20Two%20Pairs.java) +307 | [Maximum Product of Three Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Product%20of%20Three%20Numbers.java) +308 | [Maximum Product of Two Elements in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Product%20of%20Two%20Elements%20in%20an%20Array.java) +309 | [Maximum Repeating Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Repeating%20Substring.java) +310 | [Maximum Subarray Sum I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Subarray%20Sum%20I.java) +311 | [Maximum Units on a Truck](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Units%20on%20a%20Truck.java) +312 | [Maximum Value of a String in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Value%20of%20a%20String%20in%20an%20Array.java) +313 | [Maximum depth of Binary tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20depth%20of%20Binary%20tree.java) +314 | [Mean of Array After Removing Some Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Mean%20of%20Array%20After%20Removing%20Some%20Elements.java) +315 | [Meeting Rooms](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Meeting%20Rooms.java) +316 | [Merge Similar Items](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Similar%20Items.java) +317 | [Merge Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Sorted%20Array.java) +318 | [Merge Strings Alternately](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Strings%20Alternately.java) +319 | [Merge Two 2D Arrays by Summing Values](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Two%202D%20Arrays%20by%20Summing%20Values.java) +320 | [Merge Two Sorted Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Two%20Sorted%20Lists.java) +321 | [Merge two binary trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20two%20binary%20trees.java) +322 | [Middle of the linked list](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Middle%20of%20the%20linked%20list.java) +323 | [Min Cost Climbing Stairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Min%20Cost%20Climbing%20Stairs.java) +324 | [Min Max Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Min%20Max%20Game.java) +325 | [Minimum Absolute Difference in BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20%20Absolute%20Difference%20in%20BST.java) +326 | [Minimum Absolute Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Absolute%20Difference.java) +327 | [Minimum Amount of Time to Fill Cups](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Amount%20of%20Time%20to%20Fill%20Cups.java) +328 | [Minimum Bit Flips to Convert Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Bit%20Flips%20to%20Convert%20Number.java) +329 | [Minimum Changes To Make Alternating Binary String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Changes%20To%20Make%20Alternating%20Binary%20String.java) +330 | [Minimum Common Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Common%20Value.java) +331 | [Minimum Cost of Buying Candies With Discount](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Cost%20of%20Buying%20Candies%20With%20Discount.java) +332 | [Minimum Cost to Move Chips to The Same Position](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Cost%20to%20Move%20Chips%20to%20The%20Same%20Position.java) +333 | [Minimum Cuts to Divide a Circle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Cuts%20to%20Divide%20a%20Circle.java) +334 | [Minimum Depth of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Depth%20of%20a%20Binary%20Tree.java) +335 | [Minimum Difference Between Highest and Lowest of K Scores](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Difference%20Between%20Highest%20and%20Lowest%20of%20K%20Scores.java) +336 | [Minimum Distance Between BST Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Distance%20Between%20BST%20Nodes.java) +337 | [Minimum Distance to the Target Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Distance%20to%20the%20Target%20Element.java) +338 | [Minimum Hours of Training to Win a Competition](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Hours%20of%20Training%20to%20Win%20a%20Competition.java) +339 | [Minimum Index Sum of Two Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Index%20Sum%20of%20Two%20Lists.java) +340 | [Minimum Moves to Convert String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Moves%20to%20Convert%20String.java) +341 | [Minimum Moves to Equal an Array Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Moves%20to%20Equal%20an%20Array%20Element.java) +342 | [Minimum Number of Moves to Seat Everyone](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Number%20of%20Moves%20to%20Seat%20Everyone.java) +343 | [Minimum Number of Operations to Convert Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Number%20of%20Operations%20to%20Convert%20Time.java) +344 | [Minimum Operations to Make the Array Increasing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Operations%20to%20Make%20the%20Array%20Increasing.java) +345 | [Minimum Recolors to Get K Consecutive Black Blocks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Recolors%20to%20Get%20K%20Consecutive%20Black%20Blocks.java) +346 | [Minimum Subsequence in Non-Increasing Order](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Subsequence%20in%20Non-Increasing%20Order.java) +347 | [Minimum Sum of Four Digit Number After Splitting Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Sum%20of%20Four%20Digit%20Number%20After%20Splitting%20Digits.java) +348 | [Minimum Time Visiting All Points](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Time%20Visiting%20All%20Points.java) +349 | [Minimum Time to Type Word Using Special Typewriter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Time%20to%20Type%20Word%20Using%20Special%20Typewriter.java) +350 | [Minimum Value to Get Positive Step by Step Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Value%20to%20Get%20Positive%20Step%20by%20Step%20Sum.java) +351 | [Minimum_index_sum_of_two_lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum_index_sum_of_two_lists.java) +352 | [Missing Number In Arithmetic Progression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Missing%20Number%20In%20Arithmetic%20Progression.java) +353 | [Missing Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Missing%20Number.java) +354 | [Missing Ranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Missing%20Ranges.java) +355 | [Monotonic Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Monotonic%20Array.java) +356 | [Most Common Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Most%20Common%20Word.java) +357 | [Most Frequent Even Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Most%20Frequent%20Even%20Element.java) +358 | [Most Frequent Number Following Key In an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Most%20Frequent%20Number%20Following%20Key%20In%20an%20Array.java) +359 | [Most Visited Sector in a Circular Track](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Most%20Visited%20Sector%20in%20a%20Circular%20Track.java) +360 | [Move Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Move%20Zeroes.java) +361 | [Moving Average from Data Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Moving%20Average%20from%20Data%20Stream.java) +362 | [N-Repeated Element in Size 2N Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-Repeated%20Element%20in%20Size%202N%20Array.java) +363 | [N-ary Tree Postorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-ary%20Tree%20Postorder%20Traversal.java) +364 | [N-ary Tree Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-ary%20Tree%20Preorder%20Traversal.java) +365 | [N-th Tribonacci Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-th%20Tribonacci%20Number.java) +366 | [Nested List Weight Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Nested%20List%20Weight%20Sum.java) +367 | [Next Greater Element I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Next%20Greater%20Element%20I.java) +368 | [Next Greater Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Next%20Greater%20Element.java) +369 | [Nim Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Nim%20Game.java) +370 | [Number Complement](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20Complement.java) +371 | [Number Of Rectangles That Can Form The Largest Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20Of%20Rectangles%20That%20Can%20Form%20The%20Largest%20Square.java) +372 | [Number of 1 bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%201%20bits.java) +373 | [Number of Arithmetic Triplets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Arithmetic%20Triplets.java) +374 | [Number of Boomerangs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Boomerangs.java) +375 | [Number of Common Factors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Common%20Factors.java) +376 | [Number of Days Between Two Dates](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Days%20Between%20Two%20Dates.java) +377 | [Number of Days in a Month](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Days%20in%20a%20Month.java) +378 | [Number of Different Integers in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Different%20Integers%20in%20a%20String.java) +379 | [Number of Distinct Averages](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Distinct%20Averages.java) +380 | [Number of Equivalent Domino Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Equivalent%20Domino%20Pairs.java) +381 | [Number of Good Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Good%20Pairs.java) +382 | [Number of Lines To Write String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Lines%20To%20Write%20String.java) +383 | [Number of Recent Calls](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Recent%20Calls.java) +384 | [Number of Steps to Reduce a Number to Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Steps%20to%20Reduce%20a%20Number%20to%20Zero.java) +385 | [Number of Strings That Appear as Substrings in Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Strings%20That%20Appear%20as%20Substrings%20in%20Word.java) +386 | [Number of Students Doing Homework at a Given Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Students%20Doing%20Homework%20at%20a%20Given%20Time.java) +387 | [Number of Students Unable to Eat Lunch](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Students%20Unable%20to%20Eat%20Lunch.java) +388 | [Number of Unequal Triplets in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Unequal%20Triplets%20in%20Array.java) +389 | [Number of Valid Words in a Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Valid%20Words%20in%20a%20Sentence.java) +390 | [Number of segments in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20segments%20in%20a%20String.java) +391 | [Occurrences After Bigram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Occurrences%20After%20Bigram.java) +392 | [Odd String Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Odd%20String%20Difference.java) +393 | [Paint Fence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Paint%20Fence.java) +394 | [Paint House](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Paint%20House.java) +395 | [Pairs of Songs With Total Durations Divisible by 60](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Pairs%20of%20Songs%20With%20Total%20Durations%20Divisible%20by%2060.java) +396 | [Palindrome Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Palindrome%20Linked%20List.java) +397 | [Palindrome Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Palindrome%20Number.java) +398 | [Palindrome Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Palindrome%20Permutation.java) +399 | [Partition Array Into Three Parts With Equal Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Partition%20Array%20Into%20Three%20Parts%20With%20Equal%20Sum.java) +400 | [Pascal's Triangle II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Pascal's%20Triangle%20II.java) +401 | [Pascal's Triangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Pascal's%20Triangle.java) +402 | [Pass the Pillow](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Pass%20the%20Pillow.java) +403 | [Path Crossing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Path%20Crossing.java) +404 | [Path In Zigzag Labelled Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Path%20In%20Zigzag%20Labelled%20Binary%20Tree.java) +405 | [Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Path%20Sum.java) +406 | [Peak Index in a Mountain Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Peak%20Index%20in%20a%20Mountain%20Array.java) +407 | [Percentage of Letter in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Percentage%20of%20Letter%20in%20String.java) +408 | [Perfect Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Perfect%20Number.java) +409 | [Perform String Shifts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Perform%20String%20Shifts.java) +410 | [Plus One](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Plus%20One.java) +411 | [Positions of Large Groups](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Positions%20of%20Large%20Groups.java) +412 | [Power of Four](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Power%20of%20Four.java) +413 | [Power of Three](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Power%20of%20Three.java) +414 | [Power of Two](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Power%20of%20Two.java) +415 | [Powerful Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Powerful%20Integers.java) +416 | [Projection Area of 3D Shapes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Projection%20Area%20of%203D%20Shapes.java) +417 | [Range Sum Query Immutable](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Range%20Sum%20Query%20Immutable.java) +418 | [Range Sum of BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Range%20Sum%20of%20BST.java) +419 | [Rank Transform of an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rank%20Transform%20of%20an%20Array.java) +420 | [Ransom Note](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Ransom%20Note.java) +421 | [Read N characters Given Read4](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Read%20N%20characters%20Given%20Read4.java) +422 | [Rearrange Characters to Make Target String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rearrange%20Characters%20to%20Make%20Target%20String.java) +423 | [Rearrange Spaces Between Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rearrange%20Spaces%20Between%20Words.java) +424 | [Rectangle Overlap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rectangle%20Overlap.java) +425 | [Redistribute Characters to Make All Strings Equal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Redistribute%20Characters%20to%20Make%20All%20Strings%20Equal.java) +426 | [Reformat Date](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reformat%20Date.java) +427 | [Reformat Phone Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reformat%20Phone%20Number.java) +428 | [Reformat The String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reformat%20The%20String.java) +429 | [Relative Sort Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Relative%20Sort%20Array.java) +430 | [Relative ranks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Relative%20ranks.java) +431 | [Remove All Adjacent Duplicates In String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20All%20Adjacent%20Duplicates%20In%20String.java) +432 | [Remove Digit From Number to Maximize Result](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Digit%20From%20Number%20to%20Maximize%20Result.java) +433 | [Remove Duplicates From Sorted Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Duplicates%20From%20Sorted%20Lists.java) +434 | [Remove Duplicates from Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Duplicates%20from%20Sorted%20Array.java) +435 | [Remove Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Element.java) +436 | [Remove Letter To Equalize Frequency](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Letter%20To%20Equalize%20Frequency.java) +437 | [Remove Linked List Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Linked%20List%20Elements.java) +438 | [Remove One Element to Make the Array Strictly Increasing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20One%20Element%20to%20Make%20the%20Array%20Strictly%20Increasing.java) +439 | [Remove Outermost Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Outermost%20Parentheses.java) +440 | [Remove Palindromic Subsequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Palindromic%20Subsequences.java) +441 | [Remove Vowels from a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Vowels%20from%20a%20String.java) +442 | [Repeated String Match](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Repeated%20String%20Match.java) +443 | [Repeated Substring Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Repeated%20Substring%20Pattern.java) +444 | [Replace All ?'s to Avoid Consecutive Repeating Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Replace%20All%20?'s%20to%20Avoid%20Consecutive%20Repeating%20Characters.java) +445 | [Replace All Digits with Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Replace%20All%20Digits%20with%20Characters.java) +446 | [Replace Elements with Greatest Element on Right Side](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Replace%20Elements%20with%20Greatest%20Element%20on%20Right%20Side.java) +447 | [Reshape the matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reshape%20the%20matrix.java) +448 | [Reverse Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Bits.java) +449 | [Reverse Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Linked%20List.java) +450 | [Reverse Only Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Only%20Letters.java) +451 | [Reverse Prefix of Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Prefix%20of%20Word.java) +452 | [Reverse String II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20String%20II.java) +453 | [Reverse String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20String.java) +454 | [Reverse Vowels of a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Vowels%20of%20a%20String.java) +455 | [Reverse words in a String III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20words%20in%20a%20String%20III.java) +456 | [Richest Customer Wealth](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Richest%20Customer%20Wealth.java) +457 | [Rings and Rods](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rings%20and%20Rods.java) +458 | [Robot Return to Origin](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Robot%20Return%20to%20Origin.java) +459 | [Roman to Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Roman%20to%20Integer.java) +460 | [Root Equals Sum of Children](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Root%20Equals%20Sum%20of%20Children.java) +461 | [Rotate String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rotate%20String.java) +462 | [Running Sum of 1d Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Running%20Sum%20of%201d%20Array.java) +463 | [Same Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Same%20Tree.java) +464 | [Search Insert Position](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Search%20Insert%20Position.java) +465 | [Search in a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Search%20in%20a%20Binary%20Search%20Tree.java) +466 | [Second Largest Digit in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Second%20Largest%20Digit%20in%20a%20String.java) +467 | [Second Minimum Node in a binary tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Second%20Minimum%20Node%20in%20a%20binary%20tree.java) +468 | [Self Dividing Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Self%20Dividing%20Number.java) +469 | [Sentence Similarity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sentence%20Similarity.java) +470 | [Separate the Digits in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Separate%20the%20Digits%20in%20an%20Array.java) +471 | [Set Mismatch](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Set%20Mismatch.java) +472 | [Shortest Completing Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Completing%20Word.java) +473 | [Shortest Distance to Target String in a Circular Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Distance%20to%20Target%20String%20in%20a%20Circular%20Array.java) +474 | [Shortest Distance to a Character](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Distance%20to%20a%20Character.java) +475 | [Shortest Word Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Word%20Distance.java) +476 | [Shuffle String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shuffle%20String.java) +477 | [Shuffle the Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shuffle%20the%20Array.java) +478 | [Sign of the Product of an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sign%20of%20the%20Product%20of%20an%20Array.java) +479 | [Similar RGB Color](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Similar%20RGB%20Color.java) +480 | [Single Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Single%20Number.java) +481 | [Single-Row Keyboard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Single-Row%20Keyboard.java) +482 | [Slowest Key](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Slowest%20Key.java) +483 | [Smallest Even Multiple](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Smallest%20Even%20Multiple.java) +484 | [Smallest Index With Equal Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Smallest%20Index%20With%20Equal%20Value.java) +485 | [Smallest Range I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Smallest%20Range%20I.java) +486 | [Sort Array By Parity II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Array%20By%20Parity%20II.java) +487 | [Sort Array By Parity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Array%20By%20Parity.java) +488 | [Sort Array by Increasing Frequency](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Array%20by%20Increasing%20Frequency.java) +489 | [Sort Even and Odd Indices Independently](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Even%20and%20Odd%20Indices%20Independently.java) +490 | [Sort Integers by The Number of 1 Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Integers%20by%20The%20Number%20of%201%20Bits.java) +491 | [Sort the People](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20the%20People.java) +492 | [Sorting the Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sorting%20the%20Sentence.java) +493 | [Special Array With X Elements Greater Than or Equal X](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Special%20Array%20With%20X%20Elements%20Greater%20Than%20or%20Equal%20X.java) +494 | [Special Positions in a Binary Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Special%20Positions%20in%20a%20Binary%20Matrix.java) +495 | [Split With Minimum Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Split%20With%20Minimum%20Sum.java) +496 | [Split a String in Balanced Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Split%20a%20String%20in%20Balanced%20Strings.java) +497 | [SqrtX](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/SqrtX.java) +498 | [Squares of a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Squares%20of%20a%20Sorted%20Array.java) +499 | [String Matching in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/String%20Matching%20in%20an%20Array.java) +500 | [String Without AAA or BBB](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/String%20Without%20AAA%20or%20BBB.java) +501 | [Strobogrammatic Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Strobogrammatic%20Number.java) +502 | [Strong Password Checker II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Strong%20Password%20Checker%20II.java) +503 | [Student Attendance Record I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Student%20Attendance%20Record%20I.java) +504 | [Submission Detail](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Submission%20Detail.java) +505 | [Substrings of Size Three with Distinct Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Substrings%20of%20Size%20Three%20with%20Distinct%20Characters.java) +506 | [Subtract the Product and Sum of Digits of an Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Subtract%20the%20Product%20and%20Sum%20of%20Digits%20of%20an%20Integer.java) +507 | [Subtree of Another Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Subtree%20of%20Another%20Tree.java) +508 | [Sum Of Two Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20Of%20Two%20Integers.java) +509 | [Sum of All Odd Length Subarrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20All%20Odd%20Length%20Subarrays.java) +510 | [Sum of Digits in Base K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Digits%20in%20Base%20K.java) +511 | [Sum of Digits in the Minimum Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Digits%20in%20the%20Minimum%20Number.java) +512 | [Sum of Digits of String After Convert](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Digits%20of%20String%20After%20Convert.java) +513 | [Sum of Left Leaves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Left%20Leaves.java) +514 | [Sum of Root To Leaf Binary Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Root%20To%20Leaf%20Binary%20Numbers.java) +515 | [Sum of Square Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Square%20Numbers.java) +516 | [Sum of Unique Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Unique%20Elements.java) +517 | [Summary Ranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Summary%20Ranges.java) +518 | [Symmetric Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Symmetric%20Tree.java) +519 | [Take Gifts From the Richest Pile](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Take%20Gifts%20From%20the%20Richest%20Pile.java) +520 | [Teemo Attacking](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Teemo%20Attacking.java) +521 | [Teoplitz Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Teoplitz%20Matrix.java) +522 | [The Employee That Worked on the Longest Task](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/The%20Employee%20That%20Worked%20on%20the%20Longest%20Task.java) +523 | [The K Weakest Rows in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/The%20K%20Weakest%20Rows%20in%20a%20Matrix.java) +524 | [Third Maximum Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Third%20Maximum%20Number.java) +525 | [Thousand Separator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Thousand%20Separator.java) +526 | [Three Consecutive Odds](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Three%20Consecutive%20Odds.java) +527 | [Three Divisors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Three%20Divisors.java) +528 | [Time Needed to Buy Tickets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Time%20Needed%20to%20Buy%20Tickets.java) +529 | [To Lower Case](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/To%20Lower%20Case.java) +530 | [Toeplitz Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Toeplitz%20Matrix.java) +531 | [Transpose Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Transpose%20Matrix.java) +532 | [Truncate Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Truncate%20Sentence.java) +533 | [Two Furthest Houses With Different Colors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Furthest%20Houses%20With%20Different%20Colors.java) +534 | [Two Out of Three](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Out%20of%20Three.java) +535 | [Two Sum III - Data Structure Design](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum%20III%20-%20Data%20Structure%20Design.java) +536 | [Two Sum IV - Input is a BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum%20IV%20-%20Input%20is%20a%20BST.java) +537 | [Two Sum Less Than K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum%20Less%20Than%20K.java) +538 | [Two Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum.java) +539 | [Ugly Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Ugly%20Number.java) +540 | [Uncommon Words from Two Sentences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Uncommon%20Words%20from%20Two%20Sentences.java) +541 | [Unique Email Addresses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Unique%20Email%20Addresses.java) +542 | [Unique Morse Code Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Unique%20Morse%20Code%20Words.java) +543 | [Unique Number of Occurrences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Unique%20Number%20of%20Occurrences.java) +544 | [Univalued Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Univalued%20Binary%20Tree.java) +545 | [Valid Anagram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Anagram.java) +546 | [Valid Boomerang](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Boomerang.java) +547 | [Valid Mountain Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Mountain%20Array.java) +548 | [Valid Palindrome II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Palindrome%20II.java) +549 | [Valid Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Palindrome.java) +550 | [Valid Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Parentheses.java) +551 | [Valid Perfect Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Perfect%20Square.java) +552 | [Valid Word Abbreviation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Word%20Abbreviation.java) +553 | [Valid Word Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Word%20Sequence.java) +554 | [Valid Word Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Word%20Square.java) +555 | [Verifying an Alien Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Verifying%20an%20Alien%20Dictionary.java) +556 | [Water Bottles](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Water%20Bottles.java) +557 | [Word Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Word%20Pattern.java) +558 | [X of a Kind in a Deck of Cards](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/X%20of%20a%20Kind%20in%20a%20Deck%20of%20Cards.java) +559 | [XOR Operation in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/XOR%20Operation%20in%20an%20Array.java) +560 | [nim_game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/nim_game.java) +561 | [range_addition_II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/range_addition_II.java) +562 | [trailing_zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/trailing_zeroes.java) diff --git a/Hard/README.md b/Hard/README.md index 75b409d1..3ada6cad 100644 --- a/Hard/README.md +++ b/Hard/README.md @@ -11,87 +11,90 @@ S.no | Coding Problem 8 | [Closest Binary Search Tree Values II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Closest%20Binary%20Search%20Tree%20Values%20II.java) 9 | [Concatenated Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Concatenated%20Words.java) 10 | [Construct Target Array With Multiple Sums](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Construct%20Target%20Array%20With%20Multiple%20Sums.java) -11 | [Count Vowels Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Count%20Vowels%20Permutation.java) -12 | [Count of Smaller Numbers After Self](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Count%20of%20Smaller%20Numbers%20After%20Self.java) -13 | [Course Schedule III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Course%20Schedule%20III.java) -14 | [Critical Connections in a Network](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Critical%20Connections%20in%20a%20Network.java) -15 | [Cut Off Trees for Golf Event](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Cut%20Off%20Trees%20for%20Golf%20Event.java) -16 | [Design In-Memory File System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Design%20In-Memory%20File%20System.java) -17 | [Design Movie Rental System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Design%20Movie%20Rental%20System.java) -18 | [Design Search Autocomplete System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Design%20Search%20Autocomplete%20System.java) -19 | [Design Skiplist](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Design%20Skiplist.java) -20 | [Dice Roll Simulation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Dice%20Roll%20Simulation.java) -21 | [Divide Array Into Increasing Sequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Divide%20Array%20Into%20Increasing%20Sequences.java) -22 | [Edit Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Edit%20Distance.java) -23 | [Employee Free Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Employee%20Free%20Time.java) -24 | [Expression Add Operators](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Expression%20Add%20Operators.java) -25 | [Find Median from Data Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Find%20Median%20from%20Data%20Stream.java) -26 | [Find Minimum in Rotated Sorted Array II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Find%20Minimum%20in%20Rotated%20Sorted%20Array%20II.java) -27 | [Find the Kth Smallest Sum of a Matrix With Sorted Rows](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Find%20the%20Kth%20Smallest%20Sum%20of%20a%20Matrix%20With%20Sorted%20Rows.java) -28 | [First Missing Positive](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/First%20Missing%20Positive.java) -29 | [Frog Jump](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Frog%20Jump.java) -30 | [Insert Delete GetRandom O(1) - Duplicates Allowed](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Insert%20Delete%20GetRandom%20O(1)%20-%20Duplicates%20Allowed.java) -31 | [Integer to English Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Integer%20to%20English%20Words.java) -32 | [K Empty Slots](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/K%20Empty%20Slots.java) -33 | [K Inverse Pairs Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/K%20Inverse%20Pairs%20Array.java) -34 | [Kth Smallest Number in Multiplication Table](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Kth%20Smallest%20Number%20in%20Multiplication%20Table.java) -35 | [LFU Cache](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/LFU%20Cache.java) -36 | [Largest Rectangle in Histogram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Largest%20Rectangle%20in%20Histogram.java) -37 | [Longest Increasing Path in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Longest%20Increasing%20Path%20in%20a%20Matrix.java) -38 | [Longest Palindrome Product](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Longest%20Palindrome%20Product.java) -39 | [Longest Valid Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Longest%20Valid%20Parentheses.java) -40 | [Max Points on a Line](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Max%20Points%20on%20a%20Line.java) -41 | [Max Stack](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Max%20Stack.java) -42 | [Maximum Frequency Stack](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Frequency%20Stack.java) -43 | [Maximum Number of Non-Overlapping Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Number%20of%20Non-Overlapping%20Substrings.java) -44 | [Maximum Performance of a Team](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Performance%20of%20a%20Team.java) -45 | [Maximum Profit in Job Scheduling](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Profit%20in%20Job%20Scheduling.java) -46 | [Maximum Sum BST in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Sum%20BST%20in%20Binary%20Tree.java) -47 | [Median of Two Sorted Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Median%20of%20Two%20Sorted%20Arrays.java) -48 | [Merge K Sorted Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Merge%20K%20Sorted%20Lists.java) -49 | [Minimize Deviation in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimize%20Deviation%20in%20Array.java) -50 | [Minimum Cost to Hire K Workers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Cost%20to%20Hire%20K%20Workers.java) -51 | [Minimum Difficulty of a Job Schedule](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Difficulty%20of%20a%20Job%20Schedule.java) -52 | [Minimum Number of Refueling Stops](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Number%20of%20Refueling%20Stops.java) -53 | [Minimum Window Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Window%20Subsequence.java) -54 | [Minimum Window Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Window%20Substring.java) -55 | [My Calendar III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/My%20Calendar%20III.java) -56 | [N-Queens II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/N-Queens%20II.java) -57 | [N-Queens](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/N-Queens.java) -58 | [Naming a Company](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Naming%20a%20Company.java) -59 | [Number of Paths with Max Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Paths%20with%20Max%20Score.java) -60 | [Number of Squareful Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Squareful%20Arrays.java) -61 | [Number of Submatrices That Sum to Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Submatrices%20That%20Sum%20to%20Target.java) -62 | [Number of Valid Subarrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Valid%20Subarrays.java) -63 | [Odd Even Jump](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Odd%20Even%20Jump.java) -64 | [Optimal Account Balancing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Optimal%20Account%20Balancing.java) -65 | [Paint House III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Paint%20House%20III.java) -66 | [Palindrome Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Palindrome%20Pairs.java) -67 | [Parsing A Boolean Expression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Parsing%20A%20Boolean%20Expression.java) -68 | [Perfect Rectangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Perfect%20Rectangle.java) -69 | [Poor Pigs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Poor%20Pigs.java) -70 | [Prefix and Suffix Search](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Prefix%20and%20Suffix%20Search.java) -71 | [Reconstruct Itinerary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Reconstruct%20Itinerary.java) -72 | [Recover a Tree From Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Recover%20a%20Tree%20From%20Preorder%20Traversal.java) -73 | [Remove Invalid Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Remove%20Invalid%20Parentheses.java) -74 | [Reverse Nodes in k-Group](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Reverse%20Nodes%20in%20k-Group.java) -75 | [Robot Room Cleaner](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Robot%20Room%20Cleaner.java) -76 | [Serialize and Deserialize N-ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Serialize%20and%20Deserialize%20N-ary%20Tree.java) -77 | [Serialize and Deserialize a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Serialize%20and%20Deserialize%20a%20Binary%20Tree.java) -78 | [Shortest Distance from All Buildings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Shortest%20Distance%20from%20All%20Buildings.java) -79 | [Sliding Window Maximum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Sliding%20Window%20Maximum.java) -80 | [Sliding Window Median](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Sliding%20Window%20Median.java) -81 | [Stamping The Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Stamping%20The%20Sequence.java) -82 | [Stream of Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Stream%20of%20Characters.java) -83 | [String Compression II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/String%20Compression%20II.java) -84 | [Subarrays with K Different Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Subarrays%20with%20K%20Different%20Integers.java) -85 | [Substring with Concatenation of All Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Substring%20with%20Concatenation%20of%20All%20Words.java) -86 | [Text Justification](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Text%20Justification.java) -87 | [The Skyline Problem](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/The%20Skyline%20Problem.java) -88 | [Trapping Rain Water](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Trapping%20Rain%20Water.java) -89 | [Unique Paths III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Unique%20Paths%20III.java) -90 | [Valid Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Valid%20Number.java) -91 | [Vertical Order Traversal Of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Vertical%20Order%20Traversal%20Of%20a%20Binary%20Tree.java) -92 | [Wildcard Matching](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Wildcard%20Matching.java) -93 | [Word Break II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Word%20Break%20II.java) -94 | [Word Search II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Word%20Search%20II.java) +11 | [Count Subarrays With Fixed Bounds](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Count%20Subarrays%20With%20Fixed%20Bounds.java) +12 | [Count Vowels Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Count%20Vowels%20Permutation.java) +13 | [Count of Smaller Numbers After Self](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Count%20of%20Smaller%20Numbers%20After%20Self.java) +14 | [Course Schedule III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Course%20Schedule%20III.java) +15 | [Critical Connections in a Network](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Critical%20Connections%20in%20a%20Network.java) +16 | [Cut Off Trees for Golf Event](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Cut%20Off%20Trees%20for%20Golf%20Event.java) +17 | [Design In-Memory File System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Design%20In-Memory%20File%20System.java) +18 | [Design Movie Rental System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Design%20Movie%20Rental%20System.java) +19 | [Design Search Autocomplete System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Design%20Search%20Autocomplete%20System.java) +20 | [Design Skiplist](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Design%20Skiplist.java) +21 | [Dice Roll Simulation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Dice%20Roll%20Simulation.java) +22 | [Divide Array Into Increasing Sequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Divide%20Array%20Into%20Increasing%20Sequences.java) +23 | [Edit Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Edit%20Distance.java) +24 | [Employee Free Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Employee%20Free%20Time.java) +25 | [Expression Add Operators](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Expression%20Add%20Operators.java) +26 | [Find Median from Data Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Find%20Median%20from%20Data%20Stream.java) +27 | [Find Minimum in Rotated Sorted Array II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Find%20Minimum%20in%20Rotated%20Sorted%20Array%20II.java) +28 | [Find the Kth Smallest Sum of a Matrix With Sorted Rows](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Find%20the%20Kth%20Smallest%20Sum%20of%20a%20Matrix%20With%20Sorted%20Rows.java) +29 | [First Missing Positive](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/First%20Missing%20Positive.java) +30 | [Frog Jump](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Frog%20Jump.java) +31 | [IPO](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/IPO.java) +32 | [Insert Delete GetRandom O(1) - Duplicates Allowed](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Insert%20Delete%20GetRandom%20O(1)%20-%20Duplicates%20Allowed.java) +33 | [Integer to English Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Integer%20to%20English%20Words.java) +34 | [Jump Game IV](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Jump%20Game%20IV.java) +35 | [K Empty Slots](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/K%20Empty%20Slots.java) +36 | [K Inverse Pairs Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/K%20Inverse%20Pairs%20Array.java) +37 | [Kth Smallest Number in Multiplication Table](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Kth%20Smallest%20Number%20in%20Multiplication%20Table.java) +38 | [LFU Cache](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/LFU%20Cache.java) +39 | [Largest Rectangle in Histogram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Largest%20Rectangle%20in%20Histogram.java) +40 | [Longest Increasing Path in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Longest%20Increasing%20Path%20in%20a%20Matrix.java) +41 | [Longest Palindrome Product](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Longest%20Palindrome%20Product.java) +42 | [Longest Valid Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Longest%20Valid%20Parentheses.java) +43 | [Max Points on a Line](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Max%20Points%20on%20a%20Line.java) +44 | [Max Stack](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Max%20Stack.java) +45 | [Maximum Frequency Stack](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Frequency%20Stack.java) +46 | [Maximum Number of Non-Overlapping Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Number%20of%20Non-Overlapping%20Substrings.java) +47 | [Maximum Performance of a Team](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Performance%20of%20a%20Team.java) +48 | [Maximum Profit in Job Scheduling](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Profit%20in%20Job%20Scheduling.java) +49 | [Maximum Sum BST in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Sum%20BST%20in%20Binary%20Tree.java) +50 | [Median of Two Sorted Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Median%20of%20Two%20Sorted%20Arrays.java) +51 | [Merge K Sorted Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Merge%20K%20Sorted%20Lists.java) +52 | [Minimize Deviation in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimize%20Deviation%20in%20Array.java) +53 | [Minimum Cost to Hire K Workers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Cost%20to%20Hire%20K%20Workers.java) +54 | [Minimum Difficulty of a Job Schedule](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Difficulty%20of%20a%20Job%20Schedule.java) +55 | [Minimum Number of Refueling Stops](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Number%20of%20Refueling%20Stops.java) +56 | [Minimum Window Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Window%20Subsequence.java) +57 | [Minimum Window Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Window%20Substring.java) +58 | [My Calendar III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/My%20Calendar%20III.java) +59 | [N-Queens II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/N-Queens%20II.java) +60 | [N-Queens](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/N-Queens.java) +61 | [Naming a Company](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Naming%20a%20Company.java) +62 | [Number of Paths with Max Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Paths%20with%20Max%20Score.java) +63 | [Number of Squareful Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Squareful%20Arrays.java) +64 | [Number of Submatrices That Sum to Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Submatrices%20That%20Sum%20to%20Target.java) +65 | [Number of Valid Subarrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Valid%20Subarrays.java) +66 | [Odd Even Jump](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Odd%20Even%20Jump.java) +67 | [Optimal Account Balancing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Optimal%20Account%20Balancing.java) +68 | [Paint House III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Paint%20House%20III.java) +69 | [Palindrome Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Palindrome%20Pairs.java) +70 | [Parsing A Boolean Expression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Parsing%20A%20Boolean%20Expression.java) +71 | [Perfect Rectangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Perfect%20Rectangle.java) +72 | [Poor Pigs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Poor%20Pigs.java) +73 | [Prefix and Suffix Search](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Prefix%20and%20Suffix%20Search.java) +74 | [Reconstruct Itinerary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Reconstruct%20Itinerary.java) +75 | [Recover a Tree From Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Recover%20a%20Tree%20From%20Preorder%20Traversal.java) +76 | [Remove Invalid Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Remove%20Invalid%20Parentheses.java) +77 | [Reverse Nodes in k-Group](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Reverse%20Nodes%20in%20k-Group.java) +78 | [Robot Room Cleaner](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Robot%20Room%20Cleaner.java) +79 | [Serialize and Deserialize N-ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Serialize%20and%20Deserialize%20N-ary%20Tree.java) +80 | [Serialize and Deserialize a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Serialize%20and%20Deserialize%20a%20Binary%20Tree.java) +81 | [Shortest Distance from All Buildings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Shortest%20Distance%20from%20All%20Buildings.java) +82 | [Sliding Window Maximum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Sliding%20Window%20Maximum.java) +83 | [Sliding Window Median](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Sliding%20Window%20Median.java) +84 | [Stamping The Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Stamping%20The%20Sequence.java) +85 | [Stream of Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Stream%20of%20Characters.java) +86 | [String Compression II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/String%20Compression%20II.java) +87 | [Subarrays with K Different Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Subarrays%20with%20K%20Different%20Integers.java) +88 | [Substring with Concatenation of All Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Substring%20with%20Concatenation%20of%20All%20Words.java) +89 | [Text Justification](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Text%20Justification.java) +90 | [The Skyline Problem](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/The%20Skyline%20Problem.java) +91 | [Trapping Rain Water](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Trapping%20Rain%20Water.java) +92 | [Unique Paths III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Unique%20Paths%20III.java) +93 | [Valid Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Valid%20Number.java) +94 | [Vertical Order Traversal Of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Vertical%20Order%20Traversal%20Of%20a%20Binary%20Tree.java) +95 | [Wildcard Matching](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Wildcard%20Matching.java) +96 | [Word Break II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Word%20Break%20II.java) +97 | [Word Search II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Word%20Search%20II.java) diff --git a/Medium/README.md b/Medium/README.md index afdf245d..cea9747e 100644 --- a/Medium/README.md +++ b/Medium/README.md @@ -229,513 +229,517 @@ S.no | Coding Problem 226 | [Find the Celebrity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Celebrity.java) 227 | [Find the City With the Smallest Number of Neighbors at a Threshold Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20City%20With%20the%20Smallest%20Number%20of%20Neighbors%20at%20a%20Threshold%20Distance.java) 228 | [Find the Duplicate Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Duplicate%20Number.java) -229 | [Find the Index of the Large Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Index%20of%20the%20Large%20Integer.java) -230 | [Find the Kth Largest Integer in the Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Kth%20Largest%20Integer%20in%20the%20Array.java) -231 | [Find the Minimum and Maximum Number of Nodes Between Critical Points](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Minimum%20and%20Maximum%20Number%20of%20Nodes%20Between%20Critical%20Points.java) -232 | [Find the Student that Will Replace the Chalk](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Student%20that%20Will%20Replace%20the%20Chalk.java) -233 | [Find the Winner of an Array Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Winner%20of%20an%20Array%20Game.java) -234 | [Finding the Users Active Minutes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Finding%20the%20Users%20Active%20Minutes.java) -235 | [First Unique Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/First%20Unique%20Number.java) -236 | [Flatten 2D Vector](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%202D%20Vector.java) -237 | [Flatten Binary Tree to Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%20Binary%20Tree%20to%20Linked%20List.java) -238 | [Flatten Nested List Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%20Nested%20List%20Iterator.java) -239 | [Flatten a Multilevel Doubly Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%20a%20Multilevel%20Doubly%20Linked%20List.java) -240 | [Flip Equivalent Binary Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flip%20Equivalent%20Binary%20Trees.java) -241 | [Four Divisors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Four%20Divisors.java) -242 | [Fraction to Recurring Decimal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Fraction%20to%20Recurring%20Decimal.java) -243 | [Friend Circles](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Friend%20Circles.java) -244 | [Friends Of Appropriate Ages](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Friends%20Of%20Appropriate%20Ages.java) -245 | [Fruit Into Baskets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Fruit%20Into%20Baskets.java) -246 | [Furthest Building You Can Reach](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Furthest%20Building%20You%20Can%20Reach.java) -247 | [Game of Life](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Game%20of%20Life.java) -248 | [Gas Station](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Gas%20Station.java) -249 | [Generate Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Generate%20Parentheses.java) -250 | [Graph Valid Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Graph%20Valid%20Tree.java) -251 | [Gray Code](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Gray%20Code.java) -252 | [Group Anagrams](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Group%20Anagrams.java) -253 | [Group Shifted Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Group%20Shifted%20Strings.java) -254 | [Group the People Given the Group Size They Belong To](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Group%20the%20People%20Given%20the%20Group%20Size%20They%20Belong%20To.java) -255 | [Grumpy Bookstore Owner](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Grumpy%20Bookstore%20Owner.java) -256 | [Guess Number Higher or Lower II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Guess%20Number%20Higher%20or%20Lower%20II.java) -257 | [H-Index II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/H-Index%20II.java) -258 | [H-Index](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/H-Index.java) -259 | [HTML Entity Parser](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/HTML%20Entity%20Parser.java) -260 | [Hand of Straights](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Hand%20of%20Straights.java) -261 | [House Robber II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/House%20Robber%20II.java) -262 | [House Robber III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/House%20Robber%20III.java) -263 | [House Robber](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/House%20Robber.java) -264 | [Image Overlap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Image%20Overlap.java) -265 | [Implement Magic Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Implement%20Magic%20Dictionary.java) -266 | [Implement Rand10() Using Rand7()](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Implement%20Rand10()%20Using%20Rand7().java) -267 | [Implement Trie (Prefix Tree)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Implement%20Trie%20(Prefix%20Tree).java) -268 | [Implement Trie II (Prefix Tree)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Implement%20Trie%20II%20(Prefix%20Tree).java) -269 | [Increasing Subsequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Increasing%20Subsequences.java) -270 | [Increasing Triplet Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Increasing%20Triplet%20Subsequence.java) -271 | [Incremental Memory Leak](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Incremental%20Memory%20Leak.java) -272 | [Inorder Successor in BST II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Inorder%20Successor%20in%20BST%20II.java) -273 | [Inorder Successor in BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Inorder%20Successor%20in%20BST.java) -274 | [Insert Delete GetRandom O(1)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20Delete%20GetRandom%20O(1).java) -275 | [Insert Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20Interval.java) -276 | [Insert Into a Cyclic Sorted List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20Into%20a%20Cyclic%20Sorted%20List.java) -277 | [Insert into a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20into%20a%20Binary%20Search%20Tree.java) -278 | [Insert into a Sorted Circular Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20into%20a%20Sorted%20Circular%20Linked%20List.java) -279 | [Insertion Sort List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insertion%20Sort%20List.java) -280 | [Insufficient Nodes in Root to Leaf Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insufficient%20Nodes%20in%20Root%20to%20Leaf%20Paths.java) -281 | [Integer To Roman](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Integer%20To%20Roman.java) -282 | [Interleaving String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Interleaving%20String.java) -283 | [Interval List Intersections](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Interval%20List%20Intersections.java) -284 | [Invalid Transactions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Invalid%20Transactions.java) -285 | [Is Graph Bipartite](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Is%20Graph%20Bipartite.java) -286 | [Iterator for Combination](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Iterator%20for%20Combination.java) -287 | [Jump Game II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Jump%20Game%20II.java) -288 | [Jump Game III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Jump%20Game%20III.java) -289 | [Jump Game VI](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Jump%20Game%20VI.java) -290 | [Jump Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Jump%20Game.java) -291 | [K Closest Points to Origin](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/K%20Closest%20Points%20to%20Origin.java) -292 | [K Radius Subarray Averages](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/K%20Radius%20Subarray%20Averages.java) -293 | [Keys and Rooms](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Keys%20and%20Rooms.java) -294 | [Kill Process](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kill%20Process.java) -295 | [Knight Dialer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Knight%20Dialer.java) -296 | [Knight Probability in Chessboard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Knight%20Probability%20in%20Chessboard.java) -297 | [Koko Eating Bananas](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Koko%20Eating%20Bananas.java) -298 | [Kth Largest Element in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kth%20Largest%20Element%20in%20an%20Array.java) -299 | [Kth Smallest Element in a BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kth%20Smallest%20Element%20in%20a%20BST.java) -300 | [Kth Smallest Element in a Sorted Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kth%20Smallest%20Element%20in%20a%20Sorted%20Matrix.java) -301 | [LRU Cache](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/LRU%20Cache.java) -302 | [Large Divisble Subset](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Large%20Divisble%20Subset.java) -303 | [Largest BST Subtree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Largest%20BST%20Subtree.java) -304 | [Largest Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Largest%20Number.java) -305 | [Largest Time for Given Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Largest%20Time%20for%20Given%20Digits.java) -306 | [Last Moment Before All Ants Fall Out of a Plank](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Last%20Moment%20Before%20All%20Ants%20Fall%20Out%20of%20a%20Plank.java) -307 | [Last Stone Weight II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Last%20Stone%20Weight%20II.java) -308 | [Least Number of Unique Integers after K Removals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Least%20Number%20of%20Unique%20Integers%20after%20K%20Removals.java) -309 | [Leftmost Column with at Least a One](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Leftmost%20Column%20with%20at%20Least%20a%20One.java) -310 | [Length of the Longest Alphabetical Continuous Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Length%20of%20the%20Longest%20Alphabetical%20Continuous%20Substring.java) -311 | [Letter Combinations of a Phone Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Letter%20Combinations%20of%20a%20Phone%20Number.java) -312 | [Letter Tiles Possibilities](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Letter%20Tiles%20Possibilities.java) -313 | [Lexicographical Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lexicographical%20Numbers.java) -314 | [Lexicographically Smallest Equivalent String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lexicographically%20Smallest%20Equivalent%20String.java) -315 | [Line Reflection](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Line%20Reflection.java) -316 | [Linked List Components](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20Components.java) -317 | [Linked List Cycle II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20Cycle%20II.java) -318 | [Linked List Random Node](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20Random%20Node.java) -319 | [Linked List in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20in%20Binary%20Tree.java) -320 | [Lonely Pixel I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lonely%20Pixel%20I.java) -321 | [Longest Absolute File Path](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Absolute%20File%20Path.java) -322 | [Longest Arithmetic Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Arithmetic%20Sequence.java) -323 | [Longest Arithmetic Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Arithmetic%20Subsequence.java) -324 | [Longest Consecutive Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Consecutive%20Sequence.java) -325 | [Longest Continuous Subarray With Absolute Diff Less Than or Equal to Limit](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Continuous%20Subarray%20With%20Absolute%20Diff%20Less%20Than%20or%20Equal%20to%20Limit.java) -326 | [Longest Happy String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Happy%20String.java) -327 | [Longest Increasing Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Increasing%20Subsequence.java) -328 | [Longest Line of Consecutive One in Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Line%20of%20Consecutive%20One%20in%20Matrix.java) -329 | [Longest Palindromic Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Palindromic%20Subsequence.java) -330 | [Longest Palindromic Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Palindromic%20Substring.java) -331 | [Longest String Chain](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20String%20Chain.java) -332 | [Longest Substring Without Repeating Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Substring%20Without%20Repeating%20Characters.java) -333 | [Longest Substring with At Most K Distinct Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Substring%20with%20At%20Most%20K%20Distinct%20Characters.java) -334 | [Longest Substring with At Most Two Distinct Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Substring%20with%20At%20Most%20Two%20Distinct%20Characters.java) -335 | [Longest Uploaded Prefix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Uploaded%20Prefix.java) -336 | [Longest Well-Performing Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Well-Performing%20Interval.java) -337 | [Longest Word With All Prefixes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Word%20With%20All%20Prefixes.java) -338 | [Longest Word in Dictionary through Deleting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Word%20in%20Dictionary%20through%20Deleting.java) -339 | [Longest ZigZag Path in a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20ZigZag%20Path%20in%20a%20Binary%20Tree.java) -340 | [Lowest Common Ancestor of Deepest Leaves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lowest%20Common%20Ancestor%20of%20Deepest%20Leaves.java) -341 | [Lowest Common Ancestor of a Binary Tree III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lowest%20Common%20Ancestor%20of%20a%20Binary%20Tree%20III.java) -342 | [Lowest Common Ancestor of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lowest%20Common%20Ancestor%20of%20a%20Binary%20Tree.java) -343 | [Majority Element II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Majority%20Element%20II.java) -344 | [Making File Names Unique](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Making%20File%20Names%20Unique.java) -345 | [Map Sum Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Map%20Sum%20Pairs.java) -346 | [Masking Personal Information](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Masking%20Personal%20Information.java) -347 | [Matchsticks to Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Matchsticks%20to%20Square.java) -348 | [Max Area of Island](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Area%20of%20Island.java) -349 | [Max Chunks To Make Sorted](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Chunks%20To%20Make%20Sorted.java) -350 | [Max Consecutives Ones II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Consecutives%20Ones%20II.java) -351 | [Max Increase to Keep City Skyline](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Increase%20to%20Keep%20City%20Skyline.java) -352 | [Max Number of K-Sum Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Number%20of%20K-Sum%20Pairs.java) -353 | [Max Sum of a Pair With Equal Sum of Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Sum%20of%20a%20Pair%20With%20Equal%20Sum%20of%20Digits.java) -354 | [Maximal Network Rank](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximal%20Network%20Rank.java) -355 | [Maximal Score After Applying K Operations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximal%20Score%20After%20Applying%20K%20Operations.java) -356 | [Maximize Distance to Closest Person](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximize%20Distance%20to%20Closest%20Person.java) -357 | [Maximize Number of Subsequences in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximize%20Number%20of%20Subsequences%20in%20a%20String.java) -358 | [Maximize the Topmost Element After K Moves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximize%20the%20Topmost%20Element%20After%20K%20Moves.java) -359 | [Maximum Absolute Sum of Any Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Absolute%20Sum%20of%20Any%20Subarray.java) -360 | [Maximum Area of a Piece of Cake After Horizontal and Vertical Cuts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Area%20of%20a%20Piece%20of%20Cake%20After%20Horizontal%20and%20Vertical%20Cuts.java) -361 | [Maximum Average Subtree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Average%20Subtree.java) -362 | [Maximum Bags With Full Capacity of Rocks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Bags%20With%20Full%20Capacity%20of%20Rocks.java) -363 | [Maximum Binary Tree II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Binary%20Tree%20II.java) -364 | [Maximum Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Binary%20Tree.java) -365 | [Maximum Consecutive Floors Without Special Floors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Consecutive%20Floors%20Without%20Special%20Floors.java) -366 | [Maximum Difference Between Node and Ancestor](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Difference%20Between%20Node%20and%20Ancestor.java) -367 | [Maximum Distance Between a Pair of Values](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Distance%20Between%20a%20Pair%20of%20Values.java) -368 | [Maximum Erasure Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Erasure%20Value.java) -369 | [Maximum Ice Cream Bars](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Ice%20Cream%20Bars.java) -370 | [Maximum Length of Pair Chain](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Length%20of%20Pair%20Chain.java) -371 | [Maximum Length of Repeated Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Length%20of%20Repeated%20Subarray.java) -372 | [Maximum Length of Subarray With Positive Product](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Length%20of%20Subarray%20With%20Positive%20Product.java) -373 | [Maximum Level Sum of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Level%20Sum%20of%20a%20Binary%20Tree.java) -374 | [Maximum Matching of Players With Trainers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Matching%20of%20Players%20With%20Trainers.java) -375 | [Maximum Nesting Depth of Two Valid Parentheses Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Nesting%20Depth%20of%20Two%20Valid%20Parentheses%20Strings.java) -376 | [Maximum Number of Coins You Can Get](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Coins%20You%20Can%20Get.java) -377 | [Maximum Number of Events That Can Be Attended](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Events%20That%20Can%20Be%20Attended.java) -378 | [Maximum Number of Groups Entering a Competition](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Groups%20Entering%20a%20Competition.java) -379 | [Maximum Number of Integers to Choose From a Range I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Integers%20to%20Choose%20From%20a%20Range%20I.java) -380 | [Maximum Number of Non-Overlapping Subarrays With Sum Equals Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Non-Overlapping%20Subarrays%20With%20Sum%20Equals%20Target.java) -381 | [Maximum Number of Occurrences of a Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Occurrences%20of%20a%20Substring.java) -382 | [Maximum Number of Vowels in a Substring of Given Length](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Vowels%20in%20a%20Substring%20of%20Given%20Length.java) -383 | [Maximum Points You Can Obtain from Cards](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Points%20You%20Can%20Obtain%20from%20Cards.java) -384 | [Maximum Product Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Product%20Subarray.java) -385 | [Maximum Product of Splitted Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Product%20of%20Splitted%20Binary%20Tree.java) -386 | [Maximum Product of Word Lengths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Product%20of%20Word%20Lengths.java) -387 | [Maximum Score From Removing Stones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Score%20From%20Removing%20Stones.java) -388 | [Maximum Score from Performing Multiplication Operations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Score%20from%20Performing%20Multiplication%20Operations.java) -389 | [Maximum Size Subarray Sum Equals k](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Size%20Subarray%20Sum%20Equals%20k.java) -390 | [Maximum Star Sum of a Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Star%20Sum%20of%20a%20Graph.java) -391 | [Maximum Sum of Distinct Subarrays With Length K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Sum%20of%20Distinct%20Subarrays%20With%20Length%20K.java) -392 | [Maximum Sum of an Hourglass](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Sum%20of%20an%20Hourglass.java) -393 | [Maximum Swap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Swap.java) -394 | [Maximum Total Importance of Roads](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Total%20Importance%20of%20Roads.java) -395 | [Maximum Twin Sum of a Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Twin%20Sum%20of%20a%20Linked%20List.java) -396 | [Maximum Value after Insertion](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Value%20after%20Insertion.java) -397 | [Maximum Width Ramp](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Width%20Ramp.java) -398 | [Maximum Width of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Width%20of%20Binary%20Tree.java) -399 | [Maximum XOR of Two Numbers in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20XOR%20of%20Two%20Numbers%20in%20an%20Array.java) -400 | [Maximum of Absolute Value Expression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20of%20Absolute%20Value%20Expression.java) -401 | [Meeting Rooms II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Meeting%20Rooms%20II.java) -402 | [Meeting Scheduler](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Meeting%20Scheduler.java) -403 | [Merge In Between Linked Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Merge%20In%20Between%20Linked%20Lists.java) -404 | [Merge Intervals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Merge%20Intervals.java) -405 | [Merge Nodes in Between Zeros](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Merge%20Nodes%20in%20Between%20Zeros.java) -406 | [Min Cost to Connect All Points](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Min%20Cost%20to%20Connect%20All%20Points.java) -407 | [Min Stack](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Min%20Stack.java) -408 | [Minesweeper](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minesweeper.java) -409 | [Mini Parser](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Mini%20Parser.java) -410 | [Minimize Maximum Pair Sum in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimize%20Maximum%20Pair%20Sum%20in%20Array.java) -411 | [Minimize Product Sum of Two Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimize%20Product%20Sum%20of%20Two%20Arrays.java) -412 | [Minimum Add to Make Parentheses Valid](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Add%20to%20Make%20Parentheses%20Valid.java) -413 | [Minimum Amount of Time to Collect Garbage](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Amount%20of%20Time%20to%20Collect%20Garbage.java) -414 | [Minimum Area Rectangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Area%20Rectangle.java) -415 | [Minimum Average Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Average%20Difference.java) -416 | [Minimum Consecutive Cards to Pick Up](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Consecutive%20Cards%20to%20Pick%20Up.java) -417 | [Minimum Cost to Connect Sticks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Cost%20to%20Connect%20Sticks.java) -418 | [Minimum Deletion Cost to Avoid Repeating Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Deletion%20Cost%20to%20Avoid%20Repeating%20Letters.java) -419 | [Minimum Deletions to Make Array Beautiful](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Deletions%20to%20Make%20Array%20Beautiful.java) -420 | [Minimum Deletions to Make Character Frequencies Unique](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Deletions%20to%20Make%20Character%20Frequencies%20Unique.java) -421 | [Minimum Domino Rotations For Equal Row](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Domino%20Rotations%20For%20Equal%20Row.java) -422 | [Minimum Falling Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Falling%20Path%20Sum.java) -423 | [Minimum Fuel Cost to Report to the Capital](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Fuel%20Cost%20to%20Report%20to%20the%20Capital.java) -424 | [Minimum Genetic Mutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Genetic%20Mutation.java) -425 | [Minimum Health to Beat Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Health%20to%20Beat%20Game.java) -426 | [Minimum Height Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Height%20Trees.java) -427 | [Minimum Knight Moves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Knight%20Moves.java) -428 | [Minimum Moves to Equal Array Elements II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Moves%20to%20Equal%20Array%20Elements%20II.java) -429 | [Minimum Moves to Equal Array Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Moves%20to%20Equal%20Array%20Elements.java) -430 | [Minimum Moves to Reach Target Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Moves%20to%20Reach%20Target%20Score.java) -431 | [Minimum Number of Arrows to Burst Balloons](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Number%20of%20Arrows%20to%20Burst%20Balloons.java) -432 | [Minimum Number of Steps to Make Two Strings Anagram II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Number%20of%20Steps%20to%20Make%20Two%20Strings%20Anagram%20II.java) -433 | [Minimum Number of Steps to Make Two Strings Anagram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Number%20of%20Steps%20to%20Make%20Two%20Strings%20Anagram.java) -434 | [Minimum Number of Vertices to Reach All Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Number%20of%20Vertices%20to%20Reach%20All%20Nodes.java) -435 | [Minimum Operations to Make Array Equal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Operations%20to%20Make%20Array%20Equal.java) -436 | [Minimum Operations to Reduce X to Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Operations%20to%20Reduce%20X%20to%20Zero.java) -437 | [Minimum Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Path%20Sum.java) -438 | [Minimum Remove to Make Valid Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Remove%20to%20Make%20Valid%20Parentheses.java) -439 | [Minimum Rounds to Complete All Tasks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Rounds%20to%20Complete%20All%20Tasks.java) -440 | [Minimum Score Triangulation of Polygon](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Score%20Triangulation%20of%20Polygon.java) -441 | [Minimum Size Subarray Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Size%20Subarray%20Sum.java) -442 | [Minimum Swaps to Group All 1's Together](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Swaps%20to%20Group%20All%201's%20Together.java) -443 | [Minimum Time Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Time%20Difference.java) -444 | [Minimum Time to Collect All Apples in a Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Time%20to%20Collect%20All%20Apples%20in%20a%20Tree.java) -445 | [Minimum Time to Complete Trips](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Time%20to%20Complete%20Trips.java) -446 | [Minimum Time to Make Rope Colorful](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Time%20to%20Make%20Rope%20Colorful.java) -447 | [Mirror Reflection](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Mirror%20Reflection.java) -448 | [Missing Element in Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Missing%20Element%20in%20Sorted%20Array.java) -449 | [Most Frequent Subtree Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Most%20Frequent%20Subtree%20Sum.java) -450 | [Most Popular Video Creator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Most%20Popular%20Video%20Creator.java) -451 | [Most Profit Assigning Work](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Most%20Profit%20Assigning%20Work.java) -452 | [Most Stones Removed with Same Row or Column](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Most%20Stones%20Removed%20with%20Same%20Row%20or%20Column.java) -453 | [Multiply Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Multiply%20Strings.java) -454 | [My Calendar I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/My%20Calendar%20I.java) -455 | [My Calendar II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/My%20Calendar%20II.java) -456 | [N-ary Tree Level Order Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/N-ary%20Tree%20Level%20Order%20Traversal.java) -457 | [Nearest Exit from Entrance in Maze](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Nearest%20Exit%20from%20Entrance%20in%20Maze.java) -458 | [Nested List Weight Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Nested%20List%20Weight%20Sum%20II.java) -459 | [Network Delay Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Network%20Delay%20Time.java) -460 | [Next Closest Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Closest%20Time.java) -461 | [Next Greater Element II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Greater%20Element%20II.java) -462 | [Next Greater Element III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Greater%20Element%20III.java) -463 | [Next Greater Node In Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Greater%20Node%20In%20Linked%20List.java) -464 | [Next Greater Numerically Balanced Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Greater%20Numerically%20Balanced%20Number.java) -465 | [Next Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Permutation.java) -466 | [Node With Highest Edge Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Node%20With%20Highest%20Edge%20Score.java) -467 | [Non Overlapping Intervals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Non%20Overlapping%20Intervals.java) -468 | [Non-decreasing Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Non-decreasing%20Array.java) -469 | [Number of Burgers with No Waste of Ingredients](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Burgers%20with%20No%20Waste%20of%20Ingredients.java) -470 | [Number of Closed Islands](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Closed%20Islands.java) -471 | [Number of Connected Components in an Undirected Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Connected%20Components%20in%20an%20Undirected%20Graph.java) -472 | [Number of Dice Rolls With Target Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Dice%20Rolls%20With%20Target%20Sum.java) -473 | [Number of Distinct Islands](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Distinct%20Islands.java) -474 | [Number of Distinct Substrings in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Distinct%20Substrings%20in%20a%20String.java) -475 | [Number of Enclaves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Enclaves.java) -476 | [Number of Islands](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Islands.java) -477 | [Number of Laser Beams in a Bank](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Laser%20Beams%20in%20a%20Bank.java) -478 | [Number of Longest Increasing Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Longest%20Increasing%20Subsequence.java) -479 | [Number of Matching Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Matching%20Subsequence.java) -480 | [Number of Matching Subsequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Matching%20Subsequences.java) -481 | [Number of Nodes in the Sub-Tree With the Same Label](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Nodes%20in%20the%20Sub-Tree%20With%20the%20Same%20Label.java) -482 | [Number of Pairs of Interchangeable Rectangles](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Pairs%20of%20Interchangeable%20Rectangles.java) -483 | [Number of Pairs of Strings With Concatenation Equal to Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Pairs%20of%20Strings%20With%20Concatenation%20Equal%20to%20Target.java) -484 | [Number of Provinces](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Provinces.java) -485 | [Number of Smooth Descent Periods of a Stock](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Smooth%20Descent%20Periods%20of%20a%20Stock.java) -486 | [Number of Sub-arrays of Size K and Average Greater than or Equal to Threshold](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Sub-arrays%20of%20Size%20K%20and%20Average%20Greater%20than%20or%20Equal%20to%20Threshold.java) -487 | [Number of Subarrays with Bounded Maximum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Subarrays%20with%20Bounded%20Maximum.java) -488 | [Number of Substrings Containing All Three Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Substrings%20Containing%20All%20Three%20Characters.java) -489 | [Number of Substrings With Only 1s](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Substrings%20With%20Only%201s.java) -490 | [Number of Ways to Split Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Ways%20to%20Split%20Array.java) -491 | [Number of Zero-Filled Subarrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Zero-Filled%20Subarrays.java) -492 | [Numbers With Same Consecutive Differences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Numbers%20With%20Same%20Consecutive%20Differences.java) -493 | [Odd Even Linked Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Odd%20Even%20Linked%20Lists.java) -494 | [One Edit Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/One%20Edit%20Distance.java) -495 | [Ones and Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Ones%20and%20Zeroes.java) -496 | [Online Election](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Online%20Election.java) -497 | [Online Stock Span](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Online%20Stock%20Span.java) -498 | [Open The Lock](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Open%20The%20Lock.java) -499 | [Optimal Division](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Optimal%20Division.java) -500 | [Optimal Partition of String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Optimal%20Partition%20of%20String.java) -501 | [Out of Boundary Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Out%20of%20Boundary%20Paths.java) -502 | [Output Contest Matches](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Output%20Contest%20Matches.java) -503 | [Pacific Atlantic Water Flow](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pacific%20Atlantic%20Water%20Flow.java) -504 | [Palindrome Partitioning](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Palindrome%20Partitioning.java) -505 | [Palindromic Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Palindromic%20Substrings.java) -506 | [Pancake Sorting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pancake%20Sorting.java) -507 | [Parallel Courses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Parallel%20Courses.java) -508 | [Partition Array According to Given Pivot](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partition%20Array%20According%20to%20Given%20Pivot.java) -509 | [Partition Equal Subset Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partition%20Equal%20Subset%20Sum.java) -510 | [Partition Labels](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partition%20Labels.java) -511 | [Partition List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partition%20List.java) -512 | [Partitioning Into Minimum Number Of Deci-Binary Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partitioning%20Into%20Minimum%20Number%20Of%20Deci-Binary%20Numbers.java) -513 | [Path Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20Sum%20II.java) -514 | [Path Sum III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20Sum%20III.java) -515 | [Path With Maximum Minimum Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20With%20Maximum%20Minimum%20Value.java) -516 | [Path With Minimum Effort](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20With%20Minimum%20Effort.java) -517 | [Path with Maximum Gold](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20with%20Maximum%20Gold.java) -518 | [Path with Maximum Probability](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20with%20Maximum%20Probability.java) -519 | [Peeking Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Peeking%20Iterator.java) -520 | [People Whose List of Favorite Companies Is Not a Subset of Another List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/People%20Whose%20List%20of%20Favorite%20Companies%20Is%20Not%20a%20Subset%20of%20Another%20List.java) -521 | [Perfect Squares](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Perfect%20Squares.java) -522 | [Permutation in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Permutation%20in%20String.java) -523 | [Permutations II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Permutations%20II.java) -524 | [Permutations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Permutations.java) -525 | [Plus One Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Plus%20One%20Linked%20List.java) -526 | [Populating Next Right Pointers in Each Node II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Populating%20Next%20Right%20Pointers%20in%20Each%20Node%20II.java) -527 | [Populating Next Right Pointers in Each Node](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Populating%20Next%20Right%20Pointers%20in%20Each%20Node.java) -528 | [Possible Bipartition](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Possible%20Bipartition.java) -529 | [Pour Water](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pour%20Water.java) -530 | [Pow(x, n)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pow(x,%20n).java) -531 | [Pow](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pow.java) -532 | [Prime Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Prime%20Palindrome.java) -533 | [Print Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Print%20Binary%20Tree.java) -534 | [Print Immutable Linked List in Reverse](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Print%20Immutable%20Linked%20List%20in%20Reverse.java) -535 | [Print Words Vertically](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Print%20Words%20Vertically.java) -536 | [Prison Cells After N Days](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Prison%20Cells%20After%20N%20Days.java) -537 | [Product of Array Except self](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Product%20of%20Array%20Except%20self.java) -538 | [Product of Two Run-Length Encoded Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Product%20of%20Two%20Run-Length%20Encoded%20Arrays.java) -539 | [Product of the Last K Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Product%20of%20the%20Last%20K%20Numbers.java) -540 | [Pseudo-Palindromic Paths in a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pseudo-Palindromic%20Paths%20in%20a%20Binary%20Tree.java) -541 | [Push Dominoes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Push%20Dominoes.java) -542 | [Put Boxes Into the Warehouse I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Put%20Boxes%20Into%20the%20Warehouse%20I.java) -543 | [Queries on a Permutation With Key](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Queries%20on%20a%20Permutation%20With%20Key.java) -544 | [Queue Reconstruction By Height](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Queue%20Reconstruction%20By%20Height.java) -545 | [RLE Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/RLE%20Iterator.java) -546 | [Rabbits in Forest](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rabbits%20in%20Forest.java) -547 | [Random Pick Index](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Random%20Pick%20Index.java) -548 | [Random Pick With Weight](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Random%20Pick%20With%20Weight.java) -549 | [Range Addition](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Addition.java) -550 | [Range Sum Query - Mutable](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Sum%20Query%20-%20Mutable.java) -551 | [Range Sum Query 2D-Immutable](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Sum%20Query%202D-Immutable.java) -552 | [Range Sum of Sorted Subarray Sums](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Sum%20of%20Sorted%20Subarray%20Sums.java) -553 | [Rank Teams by Votes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rank%20Teams%20by%20Votes.java) -554 | [Reachable Nodes With Restrictions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reachable%20Nodes%20With%20Restrictions.java) -555 | [Rearrange Array Elements by Sign](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rearrange%20Array%20Elements%20by%20Sign.java) -556 | [Reconstruct Original Digits from English](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reconstruct%20Original%20Digits%20from%20English.java) -557 | [Recover Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Recover%20Binary%20Search%20Tree.java) -558 | [Rectangle Area](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rectangle%20Area.java) -559 | [Reduce Array Size to The Half](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reduce%20Array%20Size%20to%20The%20Half.java) -560 | [Reduction Operations to Make the Array Elements Equal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reduction%20Operations%20to%20Make%20the%20Array%20Elements%20Equal.java) -561 | [Remove All Adjacent Duplicates in String II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20All%20Adjacent%20Duplicates%20in%20String%20II.java) -562 | [Remove All Occurrences of a Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20All%20Occurrences%20of%20a%20Substring.java) -563 | [Remove All Ones With Row and Column Flips II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20All%20Ones%20With%20Row%20and%20Column%20Flips%20II.java) -564 | [Remove Comments](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Comments.java) -565 | [Remove Covered Intervals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Covered%20Intervals.java) -566 | [Remove Duplicate Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Duplicate%20Letters.java) -567 | [Remove Duplicates From Sorted Array II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Duplicates%20From%20Sorted%20Array%20II.java) -568 | [Remove Duplicates From an Unsorted Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Duplicates%20From%20an%20Unsorted%20Linked%20List.java) -569 | [Remove Duplicates from Sorted List II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Duplicates%20from%20Sorted%20List%20II.java) -570 | [Remove Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Interval.java) -571 | [Remove K Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20K%20Digits.java) -572 | [Remove Nodes From Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Nodes%20From%20Linked%20List.java) -573 | [Remove Nth Node From End of List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Nth%20Node%20From%20End%20of%20List.java) -574 | [Remove Sub-Folders from the Filesystem](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Sub-Folders%20from%20the%20Filesystem.java) -575 | [Remove Zero Sum Consecutive Nodes from Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Zero%20Sum%20Consecutive%20Nodes%20from%20Linked%20List.java) -576 | [Removing Stars From a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Removing%20Stars%20From%20a%20String.java) -577 | [Reorder Data in Log Files](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reorder%20Data%20in%20Log%20Files.java) -578 | [Reorder List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reorder%20List.java) -579 | [Reorder Routes to Make All Paths Lead to the City Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reorder%20Routes%20to%20Make%20All%20Paths%20Lead%20to%20the%20City%20Zero.java) -580 | [Reordered Power of 2](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reordered%20Power%20of%202.java) -581 | [Reorganize String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reorganize%20String.java) -582 | [Repeated DNA Sequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Repeated%20DNA%20Sequences.java) -583 | [Replace Elements in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Replace%20Elements%20in%20an%20Array.java) -584 | [Replace Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Replace%20Words.java) -585 | [Restore IP Address](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Restore%20IP%20Address.java) -586 | [Restore the Array From Adjacent Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Restore%20the%20Array%20From%20Adjacent%20Pairs.java) -587 | [Reverse Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Integer.java) -588 | [Reverse Linked List II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Linked%20List%20II.java) -589 | [Reverse Nodes in Even Length Groups](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Nodes%20in%20Even%20Length%20Groups.java) -590 | [Reverse Odd Levels of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Odd%20Levels%20of%20Binary%20Tree.java) -591 | [Reverse Substrings Between Each Pair of Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Substrings%20Between%20Each%20Pair%20of%20Parentheses.java) -592 | [Reverse Words in a String II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Words%20in%20a%20String%20II.java) -593 | [Reverse Words in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Words%20in%20a%20String.java) -594 | [Robot Bounded In Circle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Robot%20Bounded%20In%20Circle.java) -595 | [Rotate Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20Array.java) -596 | [Rotate Function](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20Function.java) -597 | [Rotate Image](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20Image.java) -598 | [Rotate List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20List.java) -599 | [Rotated Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotated%20Digits.java) -600 | [Rotting Oranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotting%20Oranges.java) -601 | [Satisfiability of Equality Equations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Satisfiability%20of%20Equality%20Equations.java) -602 | [Satisfisbility of Equality Equations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Satisfisbility%20of%20Equality%20Equations.java) -603 | [Score After Flipping Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Score%20After%20Flipping%20Matrix.java) -604 | [Score of Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Score%20of%20Parentheses.java) -605 | [Search Suggestions System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20Suggestions%20System.java) -606 | [Search a 2D Matrix II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20a%202D%20Matrix%20II.java) -607 | [Search a 2D Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20a%202D%20Matrix.java) -608 | [Search for a range](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20for%20a%20range.java) -609 | [Search in Rotated Sorted Array II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20in%20Rotated%20Sorted%20Array%20II.java) -610 | [Search in Rotated Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20in%20Rotated%20Sorted%20Array.java) -611 | [Search in a Sorted Array of Unknown Size](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20in%20a%20Sorted%20Array%20of%20Unknown%20Size.java) -612 | [Seat Reservation Manager](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Seat%20Reservation%20Manager.java) -613 | [Self Dividing Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Self%20Dividing%20Numbers.java) -614 | [Sender With Largest Word Count](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sender%20With%20Largest%20Word%20Count.java) -615 | [Sentence Similarity II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sentence%20Similarity%20II.java) -616 | [Sentence Similarity III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sentence%20Similarity%20III.java) -617 | [Sequential Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sequential%20Digits.java) -618 | [Serialize and Deserialize BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Serialize%20and%20Deserialize%20BST.java) -619 | [Set Matrix Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Set%20Matrix%20Zeroes.java) -620 | [Shifting Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shifting%20Letters.java) -621 | [Short Encoding of Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Short%20Encoding%20of%20Words.java) -622 | [Shortest Completing Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Completing%20Word.java) -623 | [Shortest Path in Binary Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Path%20in%20Binary%20Matrix.java) -624 | [Shortest Path with Alternating Colors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Path%20with%20Alternating%20Colors.java) -625 | [Shortest Unsorted Continuous Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Unsorted%20Continuous%20Subarray.java) -626 | [Shortest Way to Form String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Way%20to%20Form%20String.java) -627 | [Shortest Word Distance II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Word%20Distance%20II.java) -628 | [Shortest Word Distance III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Word%20Distance%20III.java) -629 | [Shuffle an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shuffle%20an%20Array.java) -630 | [Simple Bank System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Simple%20Bank%20System.java) -631 | [Simplify Path](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Simplify%20Path.java) -632 | [Single Element in a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Single%20Element%20in%20a%20Sorted%20Array.java) -633 | [Single Number II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Single%20Number%20II.java) -634 | [Single Number III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Single%20Number%20III.java) -635 | [Smallest Integer Divisible by K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20Integer%20Divisible%20by%20K.java) -636 | [Smallest String Starting From Leaf](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20String%20Starting%20From%20Leaf.java) -637 | [Smallest String With A Given Numeric Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20String%20With%20A%20Given%20Numeric%20Value.java) -638 | [Smallest String With Swaps](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20String%20With%20Swaps.java) -639 | [Smallest Subtree with all the Deepest Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20Subtree%20with%20all%20the%20Deepest%20Nodes.java) -640 | [Smallest Value of the Rearranged Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20Value%20of%20the%20Rearranged%20Number.java) -641 | [Snakes and Ladders](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Snakes%20and%20Ladders.java) -642 | [Snapshot Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Snapshot%20Array.java) -643 | [Solve the Equation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Solve%20the%20Equation.java) -644 | [Sort An Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20An%20Array.java) -645 | [Sort Characters By Frequency](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Characters%20By%20Frequency.java) -646 | [Sort Colors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Colors.java) -647 | [Sort Integers by The Power Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Integers%20by%20The%20Power%20Value.java) -648 | [Sort List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20List.java) -649 | [Sort Transformed Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Transformed%20Array.java) -650 | [Sort the Jumbled Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20the%20Jumbled%20Numbers.java) -651 | [Sort the Matrix Diagonally](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20the%20Matrix%20Diagonally.java) -652 | [Sort the Students by Their Kth Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20the%20Students%20by%20Their%20Kth%20Score.java) -653 | [Sparse Matrix Multiplication](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sparse%20Matrix%20Multiplication.java) -654 | [Spiral Matrix II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Spiral%20Matrix%20II.java) -655 | [Spiral Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Spiral%20Matrix.java) -656 | [Split Array into Consecutive Subsequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Split%20Array%20into%20Consecutive%20Subsequences.java) -657 | [Split BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Split%20BST.java) -658 | [Split Linked List in Parts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Split%20Linked%20List%20in%20Parts.java) -659 | [Statistics from a Large Sample](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Statistics%20from%20a%20Large%20Sample.java) -660 | [Step-By-Step Directions From a Binary Tree Node to Another](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Step-By-Step%20Directions%20From%20a%20Binary%20Tree%20Node%20to%20Another.java) -661 | [Stock Price Fluctuation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Stock%20Price%20Fluctuation.java) -662 | [Strictly Palindromic Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Strictly%20Palindromic%20Number.java) -663 | [String Compression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/String%20Compression.java) -664 | [String to Integer (atoi)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/String%20to%20Integer%20(atoi).java) -665 | [Subarray Product Less Than K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subarray%20Product%20Less%20Than%20K.java) -666 | [Subarray Sum Equals K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subarray%20Sum%20Equals%20K.java) -667 | [Subarray Sums Divisible by K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subarray%20Sums%20Divisible%20by%20K.java) -668 | [Subdomain Visit Count](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subdomain%20Visit%20Count.java) -669 | [Subrectangle Queries](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subrectangle%20Queries.java) -670 | [Subsets II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subsets%20II.java) -671 | [Subsets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subsets.java) -672 | [Successful Pairs of Spells and Potions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Successful%20Pairs%20of%20Spells%20and%20Potions.java) -673 | [Sum Root to Leaf Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20Root%20to%20Leaf%20Numbers.java) -674 | [Sum of Absolute Differences in a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Absolute%20Differences%20in%20a%20Sorted%20Array.java) -675 | [Sum of Beauty of All Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Beauty%20of%20All%20Substrings.java) -676 | [Sum of Even Numbers After Queries](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Even%20Numbers%20After%20Queries.java) -677 | [Sum of Nodes with Even-Valued Grandparent](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Nodes%20with%20Even-Valued%20Grandparent.java) -678 | [Sum of Numbers With Units Digit K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Numbers%20With%20Units%20Digit%20K.java) -679 | [Sum of Subarray Minimums](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Subarray%20Minimums.java) -680 | [Super Ugly Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Super%20Ugly%20Number.java) -681 | [Surrounded Regions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Surrounded%20Regions.java) -682 | [Swap For Longest Repeated Character Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Swap%20For%20Longest%20Repeated%20Character%20Substring.java) -683 | [Swap Nodes in Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Swap%20Nodes%20in%20Pairs.java) -684 | [Swapping Nodes in a Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Swapping%20Nodes%20in%20a%20Linked%20List.java) -685 | [Synonymous Sentences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Synonymous%20Sentences.java) -686 | [Target Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Target%20Sum.java) -687 | [Task Scheduler](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Task%20Scheduler.java) -688 | [Ternary Expression Parser](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Ternary%20Expression%20Parser.java) -689 | [The Earliest Moment When Everyone Become Friends](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20Earliest%20Moment%20When%20Everyone%20Become%20Friends.java) -690 | [The Number of Full Rounds You Have Played](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20Number%20of%20Full%20Rounds%20You%20Have%20Played.java) -691 | [The Number of Weak Characters in the Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20Number%20of%20Weak%20Characters%20in%20the%20Game.java) -692 | [The k Strongest Values in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20k%20Strongest%20Values%20in%20an%20Array.java) -693 | [The kth Factor of n](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20kth%20Factor%20of%20n.java) -694 | [Throne Inheritence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Throne%20Inheritence.java) -695 | [Time Based Key-Value Store](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Time%20Based%20Key-Value%20Store.java) -696 | [Time Needed to Inform All Employees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Time%20Needed%20to%20Inform%20All%20Employees.java) -697 | [Time Needed to Rearrange a Binary String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Time%20Needed%20to%20Rearrange%20a%20Binary%20String.java) -698 | [Top K Frequent Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Top%20K%20Frequent%20Elements.java) -699 | [Top K Frequent Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Top%20K%20Frequent%20Words.java) -700 | [Total Hamming Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Total%20Hamming%20Distance.java) -701 | [Tree Diameter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Tree%20Diameter.java) -702 | [Triangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Triangle.java) -703 | [Trim a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Trim%20a%20Binary%20Search%20Tree.java) -704 | [Tuple With Same Product](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Tuple%20With%20Same%20Product.java) -705 | [Tweet Counts Per Frequency](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Tweet%20Counts%20Per%20Frequency.java) -706 | [Two City Scheduling](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Two%20City%20Scheduling.java) -707 | [Two Sum BSTs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Two%20Sum%20BSTs.java) -708 | [Two Sum II - Input Array Is Sorted](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Two%20Sum%20II%20-%20Input%20Array%20Is%20Sorted.java) -709 | [UTF-8 Validation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/UTF-8%20Validation.java) -710 | [Ugly Number II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Ugly%20Number%20II.java) -711 | [Uncrossed Lines](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Uncrossed%20Lines.java) -712 | [Unique Binary Search Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Binary%20Search%20Trees.java) -713 | [Unique Paths II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Paths%20II.java) -714 | [Unique Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Paths.java) -715 | [Unique Word Abbrevation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Word%20Abbrevation.java) -716 | [Valid Parenthesis String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Parenthesis%20String.java) -717 | [Valid Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Square.java) -718 | [Valid Sudoku](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Sudoku.java) -719 | [Valid Tic-Tac-Toe State](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Tic-Tac-Toe%20State.java) -720 | [Valid Triangle Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Triangle%20Number.java) -721 | [Validate Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Validate%20Binary%20Search%20Tree.java) -722 | [Validate IP Address](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Validate%20IP%20Address.java) -723 | [Validate Stack Sequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Validate%20Stack%20Sequences.java) -724 | [Verify Preorder Serialization of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Verify%20Preorder%20Serialization%20of%20a%20Binary%20Tree.java) -725 | [Vowel Spellchecker](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Vowel%20Spellchecker.java) -726 | [Vowels of All Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Vowels%20of%20All%20Substrings.java) -727 | [Walls and Gates](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Walls%20and%20Gates.java) -728 | [Water & Jug Problem](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Water%20&%20Jug%20Problem.java) -729 | [Watering Plants](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Watering%20Plants.java) -730 | [Web Crawler](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Web%20Crawler.java) -731 | [Wiggle Sort](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Wiggle%20Sort.java) -732 | [Wiggle Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Wiggle%20Subsequence.java) -733 | [Word Break](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Word%20Break.java) -734 | [Word Ladder](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Word%20Ladder.java) -735 | [Word Search](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Word%20Search.java) -736 | [Word Subsets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Word%20Subsets.java) -737 | [ZigZag Conversion](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/ZigZag%20Conversion.java) -738 | [Zigzag Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Zigzag%20Iterator.java) +229 | [Find the Index of the First Occurrence in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Index%20of%20the%20First%20Occurrence%20in%20a%20String.java) +230 | [Find the Index of the Large Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Index%20of%20the%20Large%20Integer.java) +231 | [Find the Kth Largest Integer in the Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Kth%20Largest%20Integer%20in%20the%20Array.java) +232 | [Find the Minimum and Maximum Number of Nodes Between Critical Points](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Minimum%20and%20Maximum%20Number%20of%20Nodes%20Between%20Critical%20Points.java) +233 | [Find the Student that Will Replace the Chalk](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Student%20that%20Will%20Replace%20the%20Chalk.java) +234 | [Find the Winner of an Array Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Winner%20of%20an%20Array%20Game.java) +235 | [Finding the Users Active Minutes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Finding%20the%20Users%20Active%20Minutes.java) +236 | [First Unique Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/First%20Unique%20Number.java) +237 | [Flatten 2D Vector](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%202D%20Vector.java) +238 | [Flatten Binary Tree to Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%20Binary%20Tree%20to%20Linked%20List.java) +239 | [Flatten Nested List Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%20Nested%20List%20Iterator.java) +240 | [Flatten a Multilevel Doubly Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%20a%20Multilevel%20Doubly%20Linked%20List.java) +241 | [Flip Equivalent Binary Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flip%20Equivalent%20Binary%20Trees.java) +242 | [Four Divisors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Four%20Divisors.java) +243 | [Fraction to Recurring Decimal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Fraction%20to%20Recurring%20Decimal.java) +244 | [Friend Circles](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Friend%20Circles.java) +245 | [Friends Of Appropriate Ages](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Friends%20Of%20Appropriate%20Ages.java) +246 | [Fruit Into Baskets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Fruit%20Into%20Baskets.java) +247 | [Furthest Building You Can Reach](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Furthest%20Building%20You%20Can%20Reach.java) +248 | [Game of Life](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Game%20of%20Life.java) +249 | [Gas Station](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Gas%20Station.java) +250 | [Generate Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Generate%20Parentheses.java) +251 | [Graph Valid Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Graph%20Valid%20Tree.java) +252 | [Gray Code](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Gray%20Code.java) +253 | [Group Anagrams](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Group%20Anagrams.java) +254 | [Group Shifted Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Group%20Shifted%20Strings.java) +255 | [Group the People Given the Group Size They Belong To](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Group%20the%20People%20Given%20the%20Group%20Size%20They%20Belong%20To.java) +256 | [Grumpy Bookstore Owner](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Grumpy%20Bookstore%20Owner.java) +257 | [Guess Number Higher or Lower II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Guess%20Number%20Higher%20or%20Lower%20II.java) +258 | [H-Index II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/H-Index%20II.java) +259 | [H-Index](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/H-Index.java) +260 | [HTML Entity Parser](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/HTML%20Entity%20Parser.java) +261 | [Hand of Straights](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Hand%20of%20Straights.java) +262 | [House Robber II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/House%20Robber%20II.java) +263 | [House Robber III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/House%20Robber%20III.java) +264 | [House Robber](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/House%20Robber.java) +265 | [Image Overlap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Image%20Overlap.java) +266 | [Implement Magic Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Implement%20Magic%20Dictionary.java) +267 | [Implement Rand10() Using Rand7()](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Implement%20Rand10()%20Using%20Rand7().java) +268 | [Implement Trie (Prefix Tree)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Implement%20Trie%20(Prefix%20Tree).java) +269 | [Implement Trie II (Prefix Tree)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Implement%20Trie%20II%20(Prefix%20Tree).java) +270 | [Increasing Subsequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Increasing%20Subsequences.java) +271 | [Increasing Triplet Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Increasing%20Triplet%20Subsequence.java) +272 | [Incremental Memory Leak](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Incremental%20Memory%20Leak.java) +273 | [Inorder Successor in BST II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Inorder%20Successor%20in%20BST%20II.java) +274 | [Inorder Successor in BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Inorder%20Successor%20in%20BST.java) +275 | [Insert Delete GetRandom O(1)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20Delete%20GetRandom%20O(1).java) +276 | [Insert Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20Interval.java) +277 | [Insert Into a Cyclic Sorted List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20Into%20a%20Cyclic%20Sorted%20List.java) +278 | [Insert into a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20into%20a%20Binary%20Search%20Tree.java) +279 | [Insert into a Sorted Circular Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20into%20a%20Sorted%20Circular%20Linked%20List.java) +280 | [Insertion Sort List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insertion%20Sort%20List.java) +281 | [Insufficient Nodes in Root to Leaf Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insufficient%20Nodes%20in%20Root%20to%20Leaf%20Paths.java) +282 | [Integer To Roman](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Integer%20To%20Roman.java) +283 | [Interleaving String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Interleaving%20String.java) +284 | [Interval List Intersections](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Interval%20List%20Intersections.java) +285 | [Invalid Transactions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Invalid%20Transactions.java) +286 | [Is Graph Bipartite](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Is%20Graph%20Bipartite.java) +287 | [Iterator for Combination](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Iterator%20for%20Combination.java) +288 | [Jump Game II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Jump%20Game%20II.java) +289 | [Jump Game III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Jump%20Game%20III.java) +290 | [Jump Game VI](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Jump%20Game%20VI.java) +291 | [Jump Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Jump%20Game.java) +292 | [K Closest Points to Origin](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/K%20Closest%20Points%20to%20Origin.java) +293 | [K Radius Subarray Averages](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/K%20Radius%20Subarray%20Averages.java) +294 | [Keys and Rooms](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Keys%20and%20Rooms.java) +295 | [Kill Process](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kill%20Process.java) +296 | [Knight Dialer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Knight%20Dialer.java) +297 | [Knight Probability in Chessboard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Knight%20Probability%20in%20Chessboard.java) +298 | [Koko Eating Bananas](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Koko%20Eating%20Bananas.java) +299 | [Kth Largest Element in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kth%20Largest%20Element%20in%20an%20Array.java) +300 | [Kth Largest Sum in a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kth%20Largest%20Sum%20in%20a%20Binary%20Tree.java) +301 | [Kth Smallest Element in a BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kth%20Smallest%20Element%20in%20a%20BST.java) +302 | [Kth Smallest Element in a Sorted Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kth%20Smallest%20Element%20in%20a%20Sorted%20Matrix.java) +303 | [LRU Cache](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/LRU%20Cache.java) +304 | [Large Divisble Subset](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Large%20Divisble%20Subset.java) +305 | [Largest BST Subtree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Largest%20BST%20Subtree.java) +306 | [Largest Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Largest%20Number.java) +307 | [Largest Time for Given Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Largest%20Time%20for%20Given%20Digits.java) +308 | [Last Moment Before All Ants Fall Out of a Plank](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Last%20Moment%20Before%20All%20Ants%20Fall%20Out%20of%20a%20Plank.java) +309 | [Last Stone Weight II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Last%20Stone%20Weight%20II.java) +310 | [Least Number of Unique Integers after K Removals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Least%20Number%20of%20Unique%20Integers%20after%20K%20Removals.java) +311 | [Leftmost Column with at Least a One](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Leftmost%20Column%20with%20at%20Least%20a%20One.java) +312 | [Length of the Longest Alphabetical Continuous Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Length%20of%20the%20Longest%20Alphabetical%20Continuous%20Substring.java) +313 | [Letter Combinations of a Phone Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Letter%20Combinations%20of%20a%20Phone%20Number.java) +314 | [Letter Tiles Possibilities](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Letter%20Tiles%20Possibilities.java) +315 | [Lexicographical Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lexicographical%20Numbers.java) +316 | [Lexicographically Smallest Equivalent String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lexicographically%20Smallest%20Equivalent%20String.java) +317 | [Line Reflection](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Line%20Reflection.java) +318 | [Linked List Components](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20Components.java) +319 | [Linked List Cycle II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20Cycle%20II.java) +320 | [Linked List Random Node](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20Random%20Node.java) +321 | [Linked List in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20in%20Binary%20Tree.java) +322 | [Lonely Pixel I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lonely%20Pixel%20I.java) +323 | [Longest Absolute File Path](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Absolute%20File%20Path.java) +324 | [Longest Arithmetic Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Arithmetic%20Sequence.java) +325 | [Longest Arithmetic Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Arithmetic%20Subsequence.java) +326 | [Longest Consecutive Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Consecutive%20Sequence.java) +327 | [Longest Continuous Subarray With Absolute Diff Less Than or Equal to Limit](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Continuous%20Subarray%20With%20Absolute%20Diff%20Less%20Than%20or%20Equal%20to%20Limit.java) +328 | [Longest Happy String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Happy%20String.java) +329 | [Longest Increasing Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Increasing%20Subsequence.java) +330 | [Longest Line of Consecutive One in Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Line%20of%20Consecutive%20One%20in%20Matrix.java) +331 | [Longest Palindromic Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Palindromic%20Subsequence.java) +332 | [Longest Palindromic Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Palindromic%20Substring.java) +333 | [Longest String Chain](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20String%20Chain.java) +334 | [Longest Substring Without Repeating Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Substring%20Without%20Repeating%20Characters.java) +335 | [Longest Substring with At Most K Distinct Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Substring%20with%20At%20Most%20K%20Distinct%20Characters.java) +336 | [Longest Substring with At Most Two Distinct Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Substring%20with%20At%20Most%20Two%20Distinct%20Characters.java) +337 | [Longest Uploaded Prefix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Uploaded%20Prefix.java) +338 | [Longest Well-Performing Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Well-Performing%20Interval.java) +339 | [Longest Word With All Prefixes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Word%20With%20All%20Prefixes.java) +340 | [Longest Word in Dictionary through Deleting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Word%20in%20Dictionary%20through%20Deleting.java) +341 | [Longest ZigZag Path in a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20ZigZag%20Path%20in%20a%20Binary%20Tree.java) +342 | [Lowest Common Ancestor of Deepest Leaves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lowest%20Common%20Ancestor%20of%20Deepest%20Leaves.java) +343 | [Lowest Common Ancestor of a Binary Tree III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lowest%20Common%20Ancestor%20of%20a%20Binary%20Tree%20III.java) +344 | [Lowest Common Ancestor of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lowest%20Common%20Ancestor%20of%20a%20Binary%20Tree.java) +345 | [Majority Element II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Majority%20Element%20II.java) +346 | [Making File Names Unique](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Making%20File%20Names%20Unique.java) +347 | [Map Sum Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Map%20Sum%20Pairs.java) +348 | [Masking Personal Information](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Masking%20Personal%20Information.java) +349 | [Matchsticks to Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Matchsticks%20to%20Square.java) +350 | [Max Area of Island](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Area%20of%20Island.java) +351 | [Max Chunks To Make Sorted](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Chunks%20To%20Make%20Sorted.java) +352 | [Max Consecutives Ones II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Consecutives%20Ones%20II.java) +353 | [Max Increase to Keep City Skyline](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Increase%20to%20Keep%20City%20Skyline.java) +354 | [Max Number of K-Sum Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Number%20of%20K-Sum%20Pairs.java) +355 | [Max Sum of a Pair With Equal Sum of Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Sum%20of%20a%20Pair%20With%20Equal%20Sum%20of%20Digits.java) +356 | [Maximal Network Rank](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximal%20Network%20Rank.java) +357 | [Maximal Score After Applying K Operations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximal%20Score%20After%20Applying%20K%20Operations.java) +358 | [Maximize Distance to Closest Person](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximize%20Distance%20to%20Closest%20Person.java) +359 | [Maximize Number of Subsequences in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximize%20Number%20of%20Subsequences%20in%20a%20String.java) +360 | [Maximize the Topmost Element After K Moves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximize%20the%20Topmost%20Element%20After%20K%20Moves.java) +361 | [Maximum Absolute Sum of Any Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Absolute%20Sum%20of%20Any%20Subarray.java) +362 | [Maximum Area of a Piece of Cake After Horizontal and Vertical Cuts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Area%20of%20a%20Piece%20of%20Cake%20After%20Horizontal%20and%20Vertical%20Cuts.java) +363 | [Maximum Average Subtree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Average%20Subtree.java) +364 | [Maximum Bags With Full Capacity of Rocks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Bags%20With%20Full%20Capacity%20of%20Rocks.java) +365 | [Maximum Binary Tree II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Binary%20Tree%20II.java) +366 | [Maximum Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Binary%20Tree.java) +367 | [Maximum Consecutive Floors Without Special Floors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Consecutive%20Floors%20Without%20Special%20Floors.java) +368 | [Maximum Difference Between Node and Ancestor](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Difference%20Between%20Node%20and%20Ancestor.java) +369 | [Maximum Distance Between a Pair of Values](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Distance%20Between%20a%20Pair%20of%20Values.java) +370 | [Maximum Erasure Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Erasure%20Value.java) +371 | [Maximum Ice Cream Bars](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Ice%20Cream%20Bars.java) +372 | [Maximum Length of Pair Chain](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Length%20of%20Pair%20Chain.java) +373 | [Maximum Length of Repeated Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Length%20of%20Repeated%20Subarray.java) +374 | [Maximum Length of Subarray With Positive Product](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Length%20of%20Subarray%20With%20Positive%20Product.java) +375 | [Maximum Level Sum of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Level%20Sum%20of%20a%20Binary%20Tree.java) +376 | [Maximum Matching of Players With Trainers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Matching%20of%20Players%20With%20Trainers.java) +377 | [Maximum Nesting Depth of Two Valid Parentheses Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Nesting%20Depth%20of%20Two%20Valid%20Parentheses%20Strings.java) +378 | [Maximum Number of Coins You Can Get](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Coins%20You%20Can%20Get.java) +379 | [Maximum Number of Events That Can Be Attended](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Events%20That%20Can%20Be%20Attended.java) +380 | [Maximum Number of Groups Entering a Competition](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Groups%20Entering%20a%20Competition.java) +381 | [Maximum Number of Integers to Choose From a Range I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Integers%20to%20Choose%20From%20a%20Range%20I.java) +382 | [Maximum Number of Non-Overlapping Subarrays With Sum Equals Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Non-Overlapping%20Subarrays%20With%20Sum%20Equals%20Target.java) +383 | [Maximum Number of Occurrences of a Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Occurrences%20of%20a%20Substring.java) +384 | [Maximum Number of Vowels in a Substring of Given Length](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Vowels%20in%20a%20Substring%20of%20Given%20Length.java) +385 | [Maximum Points You Can Obtain from Cards](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Points%20You%20Can%20Obtain%20from%20Cards.java) +386 | [Maximum Product Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Product%20Subarray.java) +387 | [Maximum Product of Splitted Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Product%20of%20Splitted%20Binary%20Tree.java) +388 | [Maximum Product of Word Lengths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Product%20of%20Word%20Lengths.java) +389 | [Maximum Score From Removing Stones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Score%20From%20Removing%20Stones.java) +390 | [Maximum Score from Performing Multiplication Operations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Score%20from%20Performing%20Multiplication%20Operations.java) +391 | [Maximum Size Subarray Sum Equals k](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Size%20Subarray%20Sum%20Equals%20k.java) +392 | [Maximum Star Sum of a Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Star%20Sum%20of%20a%20Graph.java) +393 | [Maximum Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Subarray.java) +394 | [Maximum Sum of Distinct Subarrays With Length K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Sum%20of%20Distinct%20Subarrays%20With%20Length%20K.java) +395 | [Maximum Sum of an Hourglass](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Sum%20of%20an%20Hourglass.java) +396 | [Maximum Swap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Swap.java) +397 | [Maximum Total Importance of Roads](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Total%20Importance%20of%20Roads.java) +398 | [Maximum Twin Sum of a Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Twin%20Sum%20of%20a%20Linked%20List.java) +399 | [Maximum Value after Insertion](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Value%20after%20Insertion.java) +400 | [Maximum Width Ramp](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Width%20Ramp.java) +401 | [Maximum Width of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Width%20of%20Binary%20Tree.java) +402 | [Maximum XOR of Two Numbers in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20XOR%20of%20Two%20Numbers%20in%20an%20Array.java) +403 | [Maximum of Absolute Value Expression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20of%20Absolute%20Value%20Expression.java) +404 | [Meeting Rooms II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Meeting%20Rooms%20II.java) +405 | [Meeting Scheduler](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Meeting%20Scheduler.java) +406 | [Merge In Between Linked Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Merge%20In%20Between%20Linked%20Lists.java) +407 | [Merge Intervals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Merge%20Intervals.java) +408 | [Merge Nodes in Between Zeros](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Merge%20Nodes%20in%20Between%20Zeros.java) +409 | [Min Cost to Connect All Points](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Min%20Cost%20to%20Connect%20All%20Points.java) +410 | [Min Stack](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Min%20Stack.java) +411 | [Minesweeper](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minesweeper.java) +412 | [Mini Parser](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Mini%20Parser.java) +413 | [Minimize Maximum Pair Sum in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimize%20Maximum%20Pair%20Sum%20in%20Array.java) +414 | [Minimize Product Sum of Two Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimize%20Product%20Sum%20of%20Two%20Arrays.java) +415 | [Minimum Add to Make Parentheses Valid](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Add%20to%20Make%20Parentheses%20Valid.java) +416 | [Minimum Amount of Time to Collect Garbage](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Amount%20of%20Time%20to%20Collect%20Garbage.java) +417 | [Minimum Area Rectangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Area%20Rectangle.java) +418 | [Minimum Average Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Average%20Difference.java) +419 | [Minimum Consecutive Cards to Pick Up](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Consecutive%20Cards%20to%20Pick%20Up.java) +420 | [Minimum Cost to Connect Sticks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Cost%20to%20Connect%20Sticks.java) +421 | [Minimum Deletion Cost to Avoid Repeating Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Deletion%20Cost%20to%20Avoid%20Repeating%20Letters.java) +422 | [Minimum Deletions to Make Array Beautiful](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Deletions%20to%20Make%20Array%20Beautiful.java) +423 | [Minimum Deletions to Make Character Frequencies Unique](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Deletions%20to%20Make%20Character%20Frequencies%20Unique.java) +424 | [Minimum Domino Rotations For Equal Row](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Domino%20Rotations%20For%20Equal%20Row.java) +425 | [Minimum Falling Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Falling%20Path%20Sum.java) +426 | [Minimum Fuel Cost to Report to the Capital](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Fuel%20Cost%20to%20Report%20to%20the%20Capital.java) +427 | [Minimum Genetic Mutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Genetic%20Mutation.java) +428 | [Minimum Health to Beat Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Health%20to%20Beat%20Game.java) +429 | [Minimum Height Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Height%20Trees.java) +430 | [Minimum Knight Moves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Knight%20Moves.java) +431 | [Minimum Moves to Equal Array Elements II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Moves%20to%20Equal%20Array%20Elements%20II.java) +432 | [Minimum Moves to Equal Array Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Moves%20to%20Equal%20Array%20Elements.java) +433 | [Minimum Moves to Reach Target Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Moves%20to%20Reach%20Target%20Score.java) +434 | [Minimum Number of Arrows to Burst Balloons](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Number%20of%20Arrows%20to%20Burst%20Balloons.java) +435 | [Minimum Number of Steps to Make Two Strings Anagram II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Number%20of%20Steps%20to%20Make%20Two%20Strings%20Anagram%20II.java) +436 | [Minimum Number of Steps to Make Two Strings Anagram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Number%20of%20Steps%20to%20Make%20Two%20Strings%20Anagram.java) +437 | [Minimum Number of Vertices to Reach All Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Number%20of%20Vertices%20to%20Reach%20All%20Nodes.java) +438 | [Minimum Operations to Make Array Equal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Operations%20to%20Make%20Array%20Equal.java) +439 | [Minimum Operations to Reduce X to Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Operations%20to%20Reduce%20X%20to%20Zero.java) +440 | [Minimum Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Path%20Sum.java) +441 | [Minimum Remove to Make Valid Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Remove%20to%20Make%20Valid%20Parentheses.java) +442 | [Minimum Rounds to Complete All Tasks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Rounds%20to%20Complete%20All%20Tasks.java) +443 | [Minimum Score Triangulation of Polygon](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Score%20Triangulation%20of%20Polygon.java) +444 | [Minimum Size Subarray Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Size%20Subarray%20Sum.java) +445 | [Minimum Swaps to Group All 1's Together](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Swaps%20to%20Group%20All%201's%20Together.java) +446 | [Minimum Time Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Time%20Difference.java) +447 | [Minimum Time to Collect All Apples in a Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Time%20to%20Collect%20All%20Apples%20in%20a%20Tree.java) +448 | [Minimum Time to Complete Trips](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Time%20to%20Complete%20Trips.java) +449 | [Minimum Time to Make Rope Colorful](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Time%20to%20Make%20Rope%20Colorful.java) +450 | [Mirror Reflection](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Mirror%20Reflection.java) +451 | [Missing Element in Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Missing%20Element%20in%20Sorted%20Array.java) +452 | [Most Frequent Subtree Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Most%20Frequent%20Subtree%20Sum.java) +453 | [Most Popular Video Creator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Most%20Popular%20Video%20Creator.java) +454 | [Most Profit Assigning Work](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Most%20Profit%20Assigning%20Work.java) +455 | [Most Stones Removed with Same Row or Column](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Most%20Stones%20Removed%20with%20Same%20Row%20or%20Column.java) +456 | [Multiply Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Multiply%20Strings.java) +457 | [My Calendar I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/My%20Calendar%20I.java) +458 | [My Calendar II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/My%20Calendar%20II.java) +459 | [N-ary Tree Level Order Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/N-ary%20Tree%20Level%20Order%20Traversal.java) +460 | [Nearest Exit from Entrance in Maze](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Nearest%20Exit%20from%20Entrance%20in%20Maze.java) +461 | [Nested List Weight Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Nested%20List%20Weight%20Sum%20II.java) +462 | [Network Delay Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Network%20Delay%20Time.java) +463 | [Next Closest Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Closest%20Time.java) +464 | [Next Greater Element II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Greater%20Element%20II.java) +465 | [Next Greater Element III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Greater%20Element%20III.java) +466 | [Next Greater Node In Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Greater%20Node%20In%20Linked%20List.java) +467 | [Next Greater Numerically Balanced Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Greater%20Numerically%20Balanced%20Number.java) +468 | [Next Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Permutation.java) +469 | [Node With Highest Edge Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Node%20With%20Highest%20Edge%20Score.java) +470 | [Non Overlapping Intervals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Non%20Overlapping%20Intervals.java) +471 | [Non-decreasing Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Non-decreasing%20Array.java) +472 | [Number of Burgers with No Waste of Ingredients](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Burgers%20with%20No%20Waste%20of%20Ingredients.java) +473 | [Number of Closed Islands](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Closed%20Islands.java) +474 | [Number of Connected Components in an Undirected Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Connected%20Components%20in%20an%20Undirected%20Graph.java) +475 | [Number of Dice Rolls With Target Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Dice%20Rolls%20With%20Target%20Sum.java) +476 | [Number of Distinct Islands](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Distinct%20Islands.java) +477 | [Number of Distinct Substrings in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Distinct%20Substrings%20in%20a%20String.java) +478 | [Number of Enclaves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Enclaves.java) +479 | [Number of Islands](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Islands.java) +480 | [Number of Laser Beams in a Bank](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Laser%20Beams%20in%20a%20Bank.java) +481 | [Number of Longest Increasing Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Longest%20Increasing%20Subsequence.java) +482 | [Number of Matching Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Matching%20Subsequence.java) +483 | [Number of Matching Subsequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Matching%20Subsequences.java) +484 | [Number of Nodes in the Sub-Tree With the Same Label](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Nodes%20in%20the%20Sub-Tree%20With%20the%20Same%20Label.java) +485 | [Number of Pairs of Interchangeable Rectangles](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Pairs%20of%20Interchangeable%20Rectangles.java) +486 | [Number of Pairs of Strings With Concatenation Equal to Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Pairs%20of%20Strings%20With%20Concatenation%20Equal%20to%20Target.java) +487 | [Number of Provinces](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Provinces.java) +488 | [Number of Smooth Descent Periods of a Stock](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Smooth%20Descent%20Periods%20of%20a%20Stock.java) +489 | [Number of Sub-arrays of Size K and Average Greater than or Equal to Threshold](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Sub-arrays%20of%20Size%20K%20and%20Average%20Greater%20than%20or%20Equal%20to%20Threshold.java) +490 | [Number of Subarrays with Bounded Maximum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Subarrays%20with%20Bounded%20Maximum.java) +491 | [Number of Substrings Containing All Three Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Substrings%20Containing%20All%20Three%20Characters.java) +492 | [Number of Substrings With Only 1s](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Substrings%20With%20Only%201s.java) +493 | [Number of Ways to Split Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Ways%20to%20Split%20Array.java) +494 | [Number of Zero-Filled Subarrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Zero-Filled%20Subarrays.java) +495 | [Numbers With Same Consecutive Differences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Numbers%20With%20Same%20Consecutive%20Differences.java) +496 | [Odd Even Linked Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Odd%20Even%20Linked%20Lists.java) +497 | [One Edit Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/One%20Edit%20Distance.java) +498 | [Ones and Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Ones%20and%20Zeroes.java) +499 | [Online Election](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Online%20Election.java) +500 | [Online Stock Span](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Online%20Stock%20Span.java) +501 | [Open The Lock](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Open%20The%20Lock.java) +502 | [Optimal Division](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Optimal%20Division.java) +503 | [Optimal Partition of String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Optimal%20Partition%20of%20String.java) +504 | [Out of Boundary Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Out%20of%20Boundary%20Paths.java) +505 | [Output Contest Matches](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Output%20Contest%20Matches.java) +506 | [Pacific Atlantic Water Flow](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pacific%20Atlantic%20Water%20Flow.java) +507 | [Palindrome Partitioning](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Palindrome%20Partitioning.java) +508 | [Palindromic Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Palindromic%20Substrings.java) +509 | [Pancake Sorting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pancake%20Sorting.java) +510 | [Parallel Courses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Parallel%20Courses.java) +511 | [Partition Array According to Given Pivot](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partition%20Array%20According%20to%20Given%20Pivot.java) +512 | [Partition Equal Subset Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partition%20Equal%20Subset%20Sum.java) +513 | [Partition Labels](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partition%20Labels.java) +514 | [Partition List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partition%20List.java) +515 | [Partitioning Into Minimum Number Of Deci-Binary Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partitioning%20Into%20Minimum%20Number%20Of%20Deci-Binary%20Numbers.java) +516 | [Path Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20Sum%20II.java) +517 | [Path Sum III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20Sum%20III.java) +518 | [Path With Maximum Minimum Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20With%20Maximum%20Minimum%20Value.java) +519 | [Path With Minimum Effort](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20With%20Minimum%20Effort.java) +520 | [Path with Maximum Gold](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20with%20Maximum%20Gold.java) +521 | [Path with Maximum Probability](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20with%20Maximum%20Probability.java) +522 | [Peeking Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Peeking%20Iterator.java) +523 | [People Whose List of Favorite Companies Is Not a Subset of Another List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/People%20Whose%20List%20of%20Favorite%20Companies%20Is%20Not%20a%20Subset%20of%20Another%20List.java) +524 | [Perfect Squares](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Perfect%20Squares.java) +525 | [Permutation in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Permutation%20in%20String.java) +526 | [Permutations II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Permutations%20II.java) +527 | [Permutations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Permutations.java) +528 | [Plus One Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Plus%20One%20Linked%20List.java) +529 | [Populating Next Right Pointers in Each Node II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Populating%20Next%20Right%20Pointers%20in%20Each%20Node%20II.java) +530 | [Populating Next Right Pointers in Each Node](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Populating%20Next%20Right%20Pointers%20in%20Each%20Node.java) +531 | [Possible Bipartition](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Possible%20Bipartition.java) +532 | [Pour Water](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pour%20Water.java) +533 | [Pow(x, n)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pow(x,%20n).java) +534 | [Pow](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pow.java) +535 | [Prime Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Prime%20Palindrome.java) +536 | [Print Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Print%20Binary%20Tree.java) +537 | [Print Immutable Linked List in Reverse](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Print%20Immutable%20Linked%20List%20in%20Reverse.java) +538 | [Print Words Vertically](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Print%20Words%20Vertically.java) +539 | [Prison Cells After N Days](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Prison%20Cells%20After%20N%20Days.java) +540 | [Product of Array Except self](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Product%20of%20Array%20Except%20self.java) +541 | [Product of Two Run-Length Encoded Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Product%20of%20Two%20Run-Length%20Encoded%20Arrays.java) +542 | [Product of the Last K Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Product%20of%20the%20Last%20K%20Numbers.java) +543 | [Pseudo-Palindromic Paths in a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pseudo-Palindromic%20Paths%20in%20a%20Binary%20Tree.java) +544 | [Push Dominoes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Push%20Dominoes.java) +545 | [Put Boxes Into the Warehouse I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Put%20Boxes%20Into%20the%20Warehouse%20I.java) +546 | [Queries on a Permutation With Key](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Queries%20on%20a%20Permutation%20With%20Key.java) +547 | [Queue Reconstruction By Height](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Queue%20Reconstruction%20By%20Height.java) +548 | [RLE Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/RLE%20Iterator.java) +549 | [Rabbits in Forest](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rabbits%20in%20Forest.java) +550 | [Random Pick Index](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Random%20Pick%20Index.java) +551 | [Random Pick With Weight](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Random%20Pick%20With%20Weight.java) +552 | [Range Addition](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Addition.java) +553 | [Range Sum Query - Mutable](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Sum%20Query%20-%20Mutable.java) +554 | [Range Sum Query 2D-Immutable](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Sum%20Query%202D-Immutable.java) +555 | [Range Sum of Sorted Subarray Sums](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Sum%20of%20Sorted%20Subarray%20Sums.java) +556 | [Rank Teams by Votes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rank%20Teams%20by%20Votes.java) +557 | [Reachable Nodes With Restrictions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reachable%20Nodes%20With%20Restrictions.java) +558 | [Rearrange Array Elements by Sign](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rearrange%20Array%20Elements%20by%20Sign.java) +559 | [Reconstruct Original Digits from English](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reconstruct%20Original%20Digits%20from%20English.java) +560 | [Recover Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Recover%20Binary%20Search%20Tree.java) +561 | [Rectangle Area](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rectangle%20Area.java) +562 | [Reduce Array Size to The Half](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reduce%20Array%20Size%20to%20The%20Half.java) +563 | [Reduction Operations to Make the Array Elements Equal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reduction%20Operations%20to%20Make%20the%20Array%20Elements%20Equal.java) +564 | [Remove All Adjacent Duplicates in String II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20All%20Adjacent%20Duplicates%20in%20String%20II.java) +565 | [Remove All Occurrences of a Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20All%20Occurrences%20of%20a%20Substring.java) +566 | [Remove All Ones With Row and Column Flips II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20All%20Ones%20With%20Row%20and%20Column%20Flips%20II.java) +567 | [Remove Comments](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Comments.java) +568 | [Remove Covered Intervals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Covered%20Intervals.java) +569 | [Remove Duplicate Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Duplicate%20Letters.java) +570 | [Remove Duplicates From Sorted Array II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Duplicates%20From%20Sorted%20Array%20II.java) +571 | [Remove Duplicates From an Unsorted Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Duplicates%20From%20an%20Unsorted%20Linked%20List.java) +572 | [Remove Duplicates from Sorted List II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Duplicates%20from%20Sorted%20List%20II.java) +573 | [Remove Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Interval.java) +574 | [Remove K Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20K%20Digits.java) +575 | [Remove Nodes From Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Nodes%20From%20Linked%20List.java) +576 | [Remove Nth Node From End of List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Nth%20Node%20From%20End%20of%20List.java) +577 | [Remove Sub-Folders from the Filesystem](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Sub-Folders%20from%20the%20Filesystem.java) +578 | [Remove Zero Sum Consecutive Nodes from Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Zero%20Sum%20Consecutive%20Nodes%20from%20Linked%20List.java) +579 | [Removing Stars From a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Removing%20Stars%20From%20a%20String.java) +580 | [Reorder Data in Log Files](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reorder%20Data%20in%20Log%20Files.java) +581 | [Reorder List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reorder%20List.java) +582 | [Reorder Routes to Make All Paths Lead to the City Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reorder%20Routes%20to%20Make%20All%20Paths%20Lead%20to%20the%20City%20Zero.java) +583 | [Reordered Power of 2](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reordered%20Power%20of%202.java) +584 | [Reorganize String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reorganize%20String.java) +585 | [Repeated DNA Sequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Repeated%20DNA%20Sequences.java) +586 | [Replace Elements in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Replace%20Elements%20in%20an%20Array.java) +587 | [Replace Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Replace%20Words.java) +588 | [Restore IP Address](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Restore%20IP%20Address.java) +589 | [Restore the Array From Adjacent Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Restore%20the%20Array%20From%20Adjacent%20Pairs.java) +590 | [Reverse Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Integer.java) +591 | [Reverse Linked List II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Linked%20List%20II.java) +592 | [Reverse Nodes in Even Length Groups](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Nodes%20in%20Even%20Length%20Groups.java) +593 | [Reverse Odd Levels of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Odd%20Levels%20of%20Binary%20Tree.java) +594 | [Reverse Substrings Between Each Pair of Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Substrings%20Between%20Each%20Pair%20of%20Parentheses.java) +595 | [Reverse Words in a String II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Words%20in%20a%20String%20II.java) +596 | [Reverse Words in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Words%20in%20a%20String.java) +597 | [Robot Bounded In Circle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Robot%20Bounded%20In%20Circle.java) +598 | [Rotate Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20Array.java) +599 | [Rotate Function](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20Function.java) +600 | [Rotate Image](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20Image.java) +601 | [Rotate List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20List.java) +602 | [Rotated Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotated%20Digits.java) +603 | [Rotting Oranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotting%20Oranges.java) +604 | [Satisfiability of Equality Equations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Satisfiability%20of%20Equality%20Equations.java) +605 | [Satisfisbility of Equality Equations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Satisfisbility%20of%20Equality%20Equations.java) +606 | [Score After Flipping Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Score%20After%20Flipping%20Matrix.java) +607 | [Score of Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Score%20of%20Parentheses.java) +608 | [Search Suggestions System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20Suggestions%20System.java) +609 | [Search a 2D Matrix II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20a%202D%20Matrix%20II.java) +610 | [Search a 2D Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20a%202D%20Matrix.java) +611 | [Search for a range](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20for%20a%20range.java) +612 | [Search in Rotated Sorted Array II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20in%20Rotated%20Sorted%20Array%20II.java) +613 | [Search in Rotated Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20in%20Rotated%20Sorted%20Array.java) +614 | [Search in a Sorted Array of Unknown Size](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20in%20a%20Sorted%20Array%20of%20Unknown%20Size.java) +615 | [Seat Reservation Manager](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Seat%20Reservation%20Manager.java) +616 | [Self Dividing Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Self%20Dividing%20Numbers.java) +617 | [Sender With Largest Word Count](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sender%20With%20Largest%20Word%20Count.java) +618 | [Sentence Similarity II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sentence%20Similarity%20II.java) +619 | [Sentence Similarity III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sentence%20Similarity%20III.java) +620 | [Sequential Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sequential%20Digits.java) +621 | [Serialize and Deserialize BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Serialize%20and%20Deserialize%20BST.java) +622 | [Set Matrix Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Set%20Matrix%20Zeroes.java) +623 | [Shifting Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shifting%20Letters.java) +624 | [Short Encoding of Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Short%20Encoding%20of%20Words.java) +625 | [Shortest Completing Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Completing%20Word.java) +626 | [Shortest Path in Binary Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Path%20in%20Binary%20Matrix.java) +627 | [Shortest Path with Alternating Colors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Path%20with%20Alternating%20Colors.java) +628 | [Shortest Unsorted Continuous Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Unsorted%20Continuous%20Subarray.java) +629 | [Shortest Way to Form String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Way%20to%20Form%20String.java) +630 | [Shortest Word Distance II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Word%20Distance%20II.java) +631 | [Shortest Word Distance III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Word%20Distance%20III.java) +632 | [Shuffle an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shuffle%20an%20Array.java) +633 | [Simple Bank System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Simple%20Bank%20System.java) +634 | [Simplify Path](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Simplify%20Path.java) +635 | [Single Element in a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Single%20Element%20in%20a%20Sorted%20Array.java) +636 | [Single Number II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Single%20Number%20II.java) +637 | [Single Number III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Single%20Number%20III.java) +638 | [Smallest Integer Divisible by K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20Integer%20Divisible%20by%20K.java) +639 | [Smallest Number in Infinite Set](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20Number%20in%20Infinite%20Set.java) +640 | [Smallest String Starting From Leaf](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20String%20Starting%20From%20Leaf.java) +641 | [Smallest String With A Given Numeric Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20String%20With%20A%20Given%20Numeric%20Value.java) +642 | [Smallest String With Swaps](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20String%20With%20Swaps.java) +643 | [Smallest Subtree with all the Deepest Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20Subtree%20with%20all%20the%20Deepest%20Nodes.java) +644 | [Smallest Value of the Rearranged Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20Value%20of%20the%20Rearranged%20Number.java) +645 | [Snakes and Ladders](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Snakes%20and%20Ladders.java) +646 | [Snapshot Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Snapshot%20Array.java) +647 | [Solve the Equation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Solve%20the%20Equation.java) +648 | [Sort An Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20An%20Array.java) +649 | [Sort Characters By Frequency](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Characters%20By%20Frequency.java) +650 | [Sort Colors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Colors.java) +651 | [Sort Integers by The Power Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Integers%20by%20The%20Power%20Value.java) +652 | [Sort List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20List.java) +653 | [Sort Transformed Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Transformed%20Array.java) +654 | [Sort the Jumbled Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20the%20Jumbled%20Numbers.java) +655 | [Sort the Matrix Diagonally](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20the%20Matrix%20Diagonally.java) +656 | [Sort the Students by Their Kth Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20the%20Students%20by%20Their%20Kth%20Score.java) +657 | [Sparse Matrix Multiplication](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sparse%20Matrix%20Multiplication.java) +658 | [Spiral Matrix II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Spiral%20Matrix%20II.java) +659 | [Spiral Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Spiral%20Matrix.java) +660 | [Split Array into Consecutive Subsequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Split%20Array%20into%20Consecutive%20Subsequences.java) +661 | [Split BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Split%20BST.java) +662 | [Split Linked List in Parts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Split%20Linked%20List%20in%20Parts.java) +663 | [Statistics from a Large Sample](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Statistics%20from%20a%20Large%20Sample.java) +664 | [Step-By-Step Directions From a Binary Tree Node to Another](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Step-By-Step%20Directions%20From%20a%20Binary%20Tree%20Node%20to%20Another.java) +665 | [Stock Price Fluctuation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Stock%20Price%20Fluctuation.java) +666 | [Strictly Palindromic Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Strictly%20Palindromic%20Number.java) +667 | [String Compression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/String%20Compression.java) +668 | [String to Integer (atoi)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/String%20to%20Integer%20(atoi).java) +669 | [Subarray Product Less Than K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subarray%20Product%20Less%20Than%20K.java) +670 | [Subarray Sum Equals K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subarray%20Sum%20Equals%20K.java) +671 | [Subarray Sums Divisible by K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subarray%20Sums%20Divisible%20by%20K.java) +672 | [Subdomain Visit Count](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subdomain%20Visit%20Count.java) +673 | [Subrectangle Queries](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subrectangle%20Queries.java) +674 | [Subsets II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subsets%20II.java) +675 | [Subsets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subsets.java) +676 | [Successful Pairs of Spells and Potions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Successful%20Pairs%20of%20Spells%20and%20Potions.java) +677 | [Sum Root to Leaf Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20Root%20to%20Leaf%20Numbers.java) +678 | [Sum of Absolute Differences in a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Absolute%20Differences%20in%20a%20Sorted%20Array.java) +679 | [Sum of Beauty of All Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Beauty%20of%20All%20Substrings.java) +680 | [Sum of Even Numbers After Queries](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Even%20Numbers%20After%20Queries.java) +681 | [Sum of Nodes with Even-Valued Grandparent](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Nodes%20with%20Even-Valued%20Grandparent.java) +682 | [Sum of Numbers With Units Digit K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Numbers%20With%20Units%20Digit%20K.java) +683 | [Sum of Subarray Minimums](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Subarray%20Minimums.java) +684 | [Super Ugly Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Super%20Ugly%20Number.java) +685 | [Surrounded Regions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Surrounded%20Regions.java) +686 | [Swap For Longest Repeated Character Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Swap%20For%20Longest%20Repeated%20Character%20Substring.java) +687 | [Swap Nodes in Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Swap%20Nodes%20in%20Pairs.java) +688 | [Swapping Nodes in a Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Swapping%20Nodes%20in%20a%20Linked%20List.java) +689 | [Synonymous Sentences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Synonymous%20Sentences.java) +690 | [Target Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Target%20Sum.java) +691 | [Task Scheduler](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Task%20Scheduler.java) +692 | [Ternary Expression Parser](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Ternary%20Expression%20Parser.java) +693 | [The Earliest Moment When Everyone Become Friends](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20Earliest%20Moment%20When%20Everyone%20Become%20Friends.java) +694 | [The Number of Full Rounds You Have Played](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20Number%20of%20Full%20Rounds%20You%20Have%20Played.java) +695 | [The Number of Weak Characters in the Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20Number%20of%20Weak%20Characters%20in%20the%20Game.java) +696 | [The k Strongest Values in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20k%20Strongest%20Values%20in%20an%20Array.java) +697 | [The kth Factor of n](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20kth%20Factor%20of%20n.java) +698 | [Throne Inheritence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Throne%20Inheritence.java) +699 | [Time Based Key-Value Store](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Time%20Based%20Key-Value%20Store.java) +700 | [Time Needed to Inform All Employees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Time%20Needed%20to%20Inform%20All%20Employees.java) +701 | [Time Needed to Rearrange a Binary String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Time%20Needed%20to%20Rearrange%20a%20Binary%20String.java) +702 | [Top K Frequent Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Top%20K%20Frequent%20Elements.java) +703 | [Top K Frequent Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Top%20K%20Frequent%20Words.java) +704 | [Total Hamming Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Total%20Hamming%20Distance.java) +705 | [Tree Diameter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Tree%20Diameter.java) +706 | [Triangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Triangle.java) +707 | [Trim a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Trim%20a%20Binary%20Search%20Tree.java) +708 | [Tuple With Same Product](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Tuple%20With%20Same%20Product.java) +709 | [Tweet Counts Per Frequency](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Tweet%20Counts%20Per%20Frequency.java) +710 | [Two City Scheduling](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Two%20City%20Scheduling.java) +711 | [Two Sum BSTs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Two%20Sum%20BSTs.java) +712 | [Two Sum II - Input Array Is Sorted](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Two%20Sum%20II%20-%20Input%20Array%20Is%20Sorted.java) +713 | [UTF-8 Validation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/UTF-8%20Validation.java) +714 | [Ugly Number II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Ugly%20Number%20II.java) +715 | [Uncrossed Lines](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Uncrossed%20Lines.java) +716 | [Unique Binary Search Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Binary%20Search%20Trees.java) +717 | [Unique Paths II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Paths%20II.java) +718 | [Unique Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Paths.java) +719 | [Unique Word Abbrevation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Word%20Abbrevation.java) +720 | [Valid Parenthesis String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Parenthesis%20String.java) +721 | [Valid Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Square.java) +722 | [Valid Sudoku](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Sudoku.java) +723 | [Valid Tic-Tac-Toe State](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Tic-Tac-Toe%20State.java) +724 | [Valid Triangle Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Triangle%20Number.java) +725 | [Validate Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Validate%20Binary%20Search%20Tree.java) +726 | [Validate IP Address](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Validate%20IP%20Address.java) +727 | [Validate Stack Sequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Validate%20Stack%20Sequences.java) +728 | [Verify Preorder Serialization of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Verify%20Preorder%20Serialization%20of%20a%20Binary%20Tree.java) +729 | [Vowel Spellchecker](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Vowel%20Spellchecker.java) +730 | [Vowels of All Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Vowels%20of%20All%20Substrings.java) +731 | [Walls and Gates](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Walls%20and%20Gates.java) +732 | [Water & Jug Problem](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Water%20&%20Jug%20Problem.java) +733 | [Watering Plants](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Watering%20Plants.java) +734 | [Web Crawler](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Web%20Crawler.java) +735 | [Wiggle Sort](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Wiggle%20Sort.java) +736 | [Wiggle Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Wiggle%20Subsequence.java) +737 | [Word Break](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Word%20Break.java) +738 | [Word Ladder](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Word%20Ladder.java) +739 | [Word Search](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Word%20Search.java) +740 | [Word Subsets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Word%20Subsets.java) +741 | [ZigZag Conversion](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/ZigZag%20Conversion.java) +742 | [Zigzag Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Zigzag%20Iterator.java) From 4897731a79532937c7eb2b7dfdd580fc68330387 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Mon, 13 Mar 2023 09:39:10 -0700 Subject: [PATCH 114/712] Added Rearrange Array to Maximize Prefix Score.java --- .../Rearrange Array to Maximize Prefix Score.java | 15 +++++++++++++++ 1 file changed, 15 insertions(+) create mode 100644 Medium/Rearrange Array to Maximize Prefix Score.java diff --git a/Medium/Rearrange Array to Maximize Prefix Score.java b/Medium/Rearrange Array to Maximize Prefix Score.java new file mode 100644 index 00000000..6f52eda8 --- /dev/null +++ b/Medium/Rearrange Array to Maximize Prefix Score.java @@ -0,0 +1,15 @@ +class Solution { + public int maxScore(int[] nums) { + Arrays.sort(nums); + long currPrefixSum = 0; + int prefixScore = 0; + for (int i = nums.length - 1; i >= 0; i--) { + currPrefixSum += nums[i]; + if (currPrefixSum <= 0) { + break; + } + prefixScore++; + } + return prefixScore; + } +} From 463b06fa93ad0b6830fc0f3f1953109d3318cc08 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Mon, 13 Mar 2023 17:13:53 -0700 Subject: [PATCH 115/712] Update Sum Root to Leaf Numbers.java --- Medium/Sum Root to Leaf Numbers.java | 41 ++++++++++++++++------------ 1 file changed, 24 insertions(+), 17 deletions(-) diff --git a/Medium/Sum Root to Leaf Numbers.java b/Medium/Sum Root to Leaf Numbers.java index 63179830..0cad0868 100644 --- a/Medium/Sum Root to Leaf Numbers.java +++ b/Medium/Sum Root to Leaf Numbers.java @@ -14,22 +14,29 @@ * } */ class Solution { - public int sumNumbers(TreeNode root) { - int[] sum = {0}; - helper(root, 0, sum); - return sum[0]; - } - - private void helper(TreeNode root, int currValue, int[] sum) { - if (root == null) { - return; + public int sumNumbers(TreeNode root) { + if (root == null) { + return 0; + } + Queue queue = new LinkedList<>(); + queue.add(new NodeSumPair(root, 0)); + int totalSum = 0; + while (!queue.isEmpty()) { + NodeSumPair removed = queue.remove(); + TreeNode node = removed.node; + int currSum = removed.sum * 10 + node.val; + if (node.left == null && node.right == null) { + totalSum += currSum; + } + if (node.left != null) { + queue.add(new NodeSumPair(node.left, currSum)); + } + if (node.right != null) { + queue.add(new NodeSumPair(node.right, currSum)); + } + } + return totalSum; } - currValue = currValue * 10 + root.val; - if (root.left == null && root.right == null) { - sum[0] += currValue; - return; - } - helper(root.left, currValue, sum); - helper(root.right, currValue, sum); - } + + private static record NodeSumPair(TreeNode node, int sum) {} } From 6d9400d4e209d87775410b4180f8f13337f0a150 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Wed, 15 Mar 2023 07:15:25 -0700 Subject: [PATCH 116/712] Updated Check Completeness of a Binary Tree --- .../Check Completeness of a Binary Tree.java | 33 ++++++++++--------- 1 file changed, 17 insertions(+), 16 deletions(-) diff --git a/Medium/Check Completeness of a Binary Tree.java b/Medium/Check Completeness of a Binary Tree.java index 30ee5adb..2d0c94f0 100644 --- a/Medium/Check Completeness of a Binary Tree.java +++ b/Medium/Check Completeness of a Binary Tree.java @@ -14,22 +14,23 @@ * } */ class Solution { - public boolean isCompleteTree(TreeNode root) { - Queue queue = new LinkedList<>(); - queue.add(root); - boolean end = false; - while (!queue.isEmpty()) { - TreeNode removed = queue.poll(); - if (removed == null) { - end = true; - } else { - if (end) { - return false; + public boolean isCompleteTree(TreeNode root) { + Queue queue = new LinkedList<>(); + boolean isEnd = false; + queue.add(root); + while (!queue.isEmpty()) { + TreeNode removed = queue.remove(); + if (removed == null) { + isEnd = true; + } + if (removed != null) { + if (isEnd) { + return false; + } + queue.add(removed.left); + queue.add(removed.right); + } } - queue.add(removed.left); - queue.add(removed.right); - } + return true; } - return true; - } } From b01c0ce5201c34b5c7d1d807be6ab26a9d23c4cc Mon Sep 17 00:00:00 2001 From: varunu28 Date: Wed, 15 Mar 2023 07:29:10 -0700 Subject: [PATCH 117/712] Updated Clone Binary Tree With Random Pointer --- ...Clone Binary Tree With Random Pointer.java | 69 +++++++++---------- 1 file changed, 34 insertions(+), 35 deletions(-) diff --git a/Medium/Clone Binary Tree With Random Pointer.java b/Medium/Clone Binary Tree With Random Pointer.java index 323b1b6e..cf43c71a 100644 --- a/Medium/Clone Binary Tree With Random Pointer.java +++ b/Medium/Clone Binary Tree With Random Pointer.java @@ -17,44 +17,43 @@ */ class Solution { - public NodeCopy copyRandomBinaryTree(Node root) { - if (root == null) { - return null; - } - Queue queue = new LinkedList<>(); - Map map = new HashMap<>(); - queue.add(root); - while (!queue.isEmpty()) { - int size = queue.size(); - while (size-- > 0) { - Node removed = queue.remove(); - map.put(removed, new NodeCopy(removed.val)); - if (removed.left != null) { - queue.add(removed.left); - } - if (removed.right != null) { - queue.add(removed.right); + public NodeCopy copyRandomBinaryTree(Node root) { + if (root == null) { + return null; } - } + Map map = new HashMap<>(); + copyOnlyNode(root, map); + copyNodePointers(root, map); + return map.get(root); } - queue.add(root); - while (!queue.isEmpty()) { - int size = queue.size(); - while (size-- > 0) { - Node removed = queue.remove(); - if (removed.left != null) { - queue.add(removed.left); - map.get(removed).left = map.get(removed.left); + + private void copyNodePointers(Node root, Map map) { + Queue queue = new LinkedList<>(); + queue.add(root); + while (!queue.isEmpty()) { + Node removed = queue.remove(); + NodeCopy copied = map.get(removed); + if (removed.left != null) { + queue.add(removed.left); + copied.left = map.get(removed.left); + } + if (removed.right != null) { + queue.add(removed.right); + copied.right = map.get(removed.right); + } + if (removed.random != null) { + copied.random = map.get(removed.random); + } } - if (removed.right != null) { - queue.add(removed.right); - map.get(removed).right = map.get(removed.right); - } - if (removed.random != null) { - map.get(removed).random = map.get(removed.random); + } + + private void copyOnlyNode(Node root, Map map) { + if (root == null) { + return; } - } + NodeCopy copiedNode = new NodeCopy(root.val); + map.put(root, copiedNode); + copyOnlyNode(root.left, map); + copyOnlyNode(root.right, map); } - return map.get(root); - } } From a0c9a40f466a65624dc80dc3e1b38d2c86444587 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Thu, 16 Mar 2023 19:56:58 -0700 Subject: [PATCH 118/712] Updated Implement Trie (Prefix Tree) --- Medium/Implement Trie (Prefix Tree).java | 101 ++++++++++++----------- 1 file changed, 53 insertions(+), 48 deletions(-) diff --git a/Medium/Implement Trie (Prefix Tree).java b/Medium/Implement Trie (Prefix Tree).java index 8df3049a..353634fd 100644 --- a/Medium/Implement Trie (Prefix Tree).java +++ b/Medium/Implement Trie (Prefix Tree).java @@ -1,56 +1,61 @@ +import java.util.Optional; + class Trie { - - private TrieNode root; - - public Trie() { - this.root = new TrieNode(); - } - - public void insert(String word) { - TrieNode curr = root; - for (char c : word.toCharArray()) { - if (!curr.children.containsKey(c)) { - curr.children.put(c, new TrieNode()); - } - curr = curr.children.get(c); + + private final TrieNode root; + + public Trie() { + root = new TrieNode(); } - curr.isWord = true; - } - - public boolean search(String word) { - TrieNode searchNode = searchHelper(word); - return searchNode != null && searchNode.isWord; - } - - public boolean startsWith(String prefix) { - return searchHelper(prefix) != null; - } - - private TrieNode searchHelper(String s) { - TrieNode curr = root; - for (char c : s.toCharArray()) { - if (!curr.children.containsKey(c)) { - return null; - } - curr = curr.children.get(c); + + public void insert(String word) { + TrieNode curr = root; + for (char c : word.toCharArray()) { + if (!curr.children.containsKey(c)) { + curr.children.put(c, new TrieNode()); + } + curr = curr.children.get(c); + } + curr.isWord = true; + } + + public boolean search(String word) { + Optional node = searchHelper(word); + return node.isPresent() && node.get().isWord; + } + + public boolean startsWith(String prefix) { + Optional node = searchHelper(prefix); + return node.isPresent(); } - return curr; - } - - private class TrieNode { - Map children; - boolean isWord; - public TrieNode() { - this.children = new HashMap<>(); + public Optional searchHelper(String word) { + TrieNode curr = root; + for (char c : word.toCharArray()) { + if (!curr.children.containsKey(c)) { + return Optional.empty(); + } + curr = curr.children.get(c); + } + return Optional.of(curr); + } + + private static class TrieNode { + + private final Map children; + private boolean isWord; + + private TrieNode() { + this.children = new HashMap<>(); + this.isWord = false; + } } - } } /** -* Your Trie object will be instantiated and called as such: -* Trie obj = new Trie(); -* obj.insert(word); -* boolean param_2 = obj.search(word); -* boolean param_3 = obj.startsWith(prefix); -*/ + * Your Trie object will be instantiated and called as such: + * Trie obj = new Trie(); + * obj.insert(word); + * boolean param_2 = obj.search(word); + * boolean param_3 = obj.startsWith(prefix); + */ From 9a1d2396465c3dc985c3859bb09f17bc8113aa48 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sat, 18 Mar 2023 07:51:51 -0700 Subject: [PATCH 119/712] Updated Design Browser History --- Medium/Design Browser History.java | 50 +++++++++++++++--------------- 1 file changed, 25 insertions(+), 25 deletions(-) diff --git a/Medium/Design Browser History.java b/Medium/Design Browser History.java index 8aa9f71f..63799e9d 100644 --- a/Medium/Design Browser History.java +++ b/Medium/Design Browser History.java @@ -1,32 +1,32 @@ class BrowserHistory { + + private final Stack history; + private final Stack future; - private Stack history; - private Stack future; - - public BrowserHistory(String homepage) { - this.history = new Stack<>(); - this.history.push(homepage); - this.future = new Stack<>(); - } - - public void visit(String url) { - this.future.removeAllElements(); - this.history.push(url); - } - - public String back(int steps) { - while (steps-- > 0 && this.history.size() > 1) { - this.future.push(this.history.pop()); + public BrowserHistory(String homepage) { + this.history = new Stack<>(); + this.future = new Stack<>(); + this.history.push(homepage); } - return this.history.peek(); - } - - public String forward(int steps) { - while (steps-- > 0 && !this.future.isEmpty()) { - this.history.push(this.future.pop()); + + public void visit(String url) { + future.removeAllElements(); + history.push(url); + } + + public String back(int steps) { + while (steps-- > 0 && history.size() > 1) { + future.push(history.pop()); + } + return history.peek(); + } + + public String forward(int steps) { + while (steps-- > 0 && !future.isEmpty()) { + history.push(future.pop()); + } + return history.peek(); } - return this.history.peek(); - } } /** From f3c457c2327a18ae71d84d0f21e14ab2aa2f13b0 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sat, 18 Mar 2023 18:16:35 -0700 Subject: [PATCH 120/712] Updated Design Add and Search Words Data Structure --- ...n Add and Search Words Data Structure.java | 87 +++++++++---------- 1 file changed, 43 insertions(+), 44 deletions(-) diff --git a/Medium/Design Add and Search Words Data Structure.java b/Medium/Design Add and Search Words Data Structure.java index 45fc78fd..17814eb0 100644 --- a/Medium/Design Add and Search Words Data Structure.java +++ b/Medium/Design Add and Search Words Data Structure.java @@ -1,54 +1,53 @@ class WordDictionary { - - private Node root; - - public WordDictionary() { - this.root = new Node(); - } - - public void addWord(String word) { - Node curr = root; - for (char c : word.toCharArray()) { - if (curr.children[c - 'a'] == null) { - curr.children[c - 'a'] = new Node(); - } - curr = curr.children[c - 'a']; + + private final TrieNode root; + + public WordDictionary() { + this.root = new TrieNode(); } - curr.isWord = true; - } - - public boolean search(String word) { - Node curr = root; - return searchHelper(word, 0, curr); - } - - private boolean searchHelper(String word, int idx, Node curr) { - if (idx == word.length()) { - return curr.isWord; + + public void addWord(String word) { + TrieNode curr = root; + for (char c : word.toCharArray()) { + if (!curr.children.containsKey(c)) { + curr.children.put(c, new TrieNode()); + } + curr = curr.children.get(c); + } + curr.isWord = true; } - if (word.charAt(idx) != '.' && curr.children[word.charAt(idx) - 'a'] == null) { - return false; + + public boolean search(String word) { + return searchHelper(word, 0, root); } - if (word.charAt(idx) == '.') { - for (Node child : curr.children) { - if (child != null && searchHelper(word, idx + 1, child)) { - return true; + + private boolean searchHelper(String word, int idx, TrieNode node) { + if (idx == word.length()) { + return node.isWord; } - } - return false; + if (node.children.containsKey(word.charAt(idx))) { + return searchHelper(word, idx + 1, node.children.get(word.charAt(idx))); + } + if (word.charAt(idx) == '.') { + for (TrieNode child : node.children.values()) { + if (searchHelper(word, idx + 1, child)) { + return true; + } + } + } + return false; } - return searchHelper(word, idx + 1, curr.children[word.charAt(idx) - 'a']); - } - - private static class Node { - Node[] children; - boolean isWord; - - public Node() { - this.children = new Node[26]; - this.isWord = false; + + + static class TrieNode { + private final Map children; + private boolean isWord; + + public TrieNode() { + this.children = new HashMap<>(); + this.isWord = false; + } } - } } /** From 46b64faeb7fff2af2a3289934efbe1e82dee295b Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sun, 19 Mar 2023 09:28:23 -0700 Subject: [PATCH 121/712] Added Distribute Money to Maximum Children.java --- Easy/Distribute Money to Maximum Children.java | 15 +++++++++++++++ 1 file changed, 15 insertions(+) create mode 100644 Easy/Distribute Money to Maximum Children.java diff --git a/Easy/Distribute Money to Maximum Children.java b/Easy/Distribute Money to Maximum Children.java new file mode 100644 index 00000000..06dd063f --- /dev/null +++ b/Easy/Distribute Money to Maximum Children.java @@ -0,0 +1,15 @@ +class Solution { + public int distMoney(int money, int children) { + money -= children; + if (money < 0) { + return -1; + } + if (money / 7 == children && money % 7 == 0) { + return children; + } + if (money / 7 == children - 1 && money % 7 == 3) { + return children - 2; + } + return Math.min(children - 1, money / 7); + } +} From a06b0d228c3383537c9367b3641f0115fc82e66d Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sun, 19 Mar 2023 17:26:33 -0700 Subject: [PATCH 122/712] Updated Can Place Flowers --- Easy/Can Place Flowers.java | 30 +++++++++++++++--------------- 1 file changed, 15 insertions(+), 15 deletions(-) diff --git a/Easy/Can Place Flowers.java b/Easy/Can Place Flowers.java index c5b9df5d..eb2a21fb 100644 --- a/Easy/Can Place Flowers.java +++ b/Easy/Can Place Flowers.java @@ -1,19 +1,19 @@ class Solution { - public boolean canPlaceFlowers(int[] flowerbed, int n) { - for (int i = 0; i < flowerbed.length && n > 0; i++) { - if (flowerbed[i] == 0) { - if (i == 0 && (flowerbed.length == 1 || flowerbed[i + 1] == 0)) { - flowerbed[i] = 1; - n--; - } else if (i == flowerbed.length - 1 && flowerbed[i - 1] == 0) { - flowerbed[i] = 1; - n--; - } else if (i + 1 < flowerbed.length && flowerbed[i + 1] == 0 && i - 1 >= 0 && flowerbed[i - 1] == 0) { - flowerbed[i] = 1; - n--; + public boolean canPlaceFlowers(int[] flowerbed, int n) { + for (int i = 0; i < flowerbed.length && n > 0; i++) { + if (canPlaceCheck(i, flowerbed)) { + flowerbed[i] = 1; + n--; + } } - } + return n == 0; + } + + private boolean canPlaceCheck(int i, int[] flowerbed) { + return flowerbed[i] == 0 && ( + (i == 0 && (i + 1 == flowerbed.length || flowerbed[i + 1] == 0)) || + (i == flowerbed.length - 1 && (i - 1 == -1 || flowerbed[i - 1] == 0)) || + (i != 0 && i != flowerbed.length - 1 && flowerbed[i - 1] == 0 && flowerbed[i + 1] == 0) + ); } - return n == 0; - } } From 20bbc5734700a3266fae95108e90d68ee333d2ba Mon Sep 17 00:00:00 2001 From: varunu28 Date: Mon, 20 Mar 2023 18:15:55 -0700 Subject: [PATCH 123/712] Updated Number of Zero-Filled Subarrays --- Medium/Number of Zero-Filled Subarrays.java | 24 +++++++++++---------- 1 file changed, 13 insertions(+), 11 deletions(-) diff --git a/Medium/Number of Zero-Filled Subarrays.java b/Medium/Number of Zero-Filled Subarrays.java index af77e188..b7c17309 100644 --- a/Medium/Number of Zero-Filled Subarrays.java +++ b/Medium/Number of Zero-Filled Subarrays.java @@ -1,14 +1,16 @@ class Solution { - public long zeroFilledSubarray(int[] nums) { - long count = 0; - long subarrayLength = 0; - for (int i = 0; i < nums.length; i++) { - if (nums[i] == 0) { - count += ++subarrayLength; - } else { - subarrayLength = 0; - } + public long zeroFilledSubarray(int[] nums) { + long subarrayCount = 0L; + int idx = 0; + while (idx < nums.length) { + long count = 0L; + while (idx < nums.length && nums[idx] == 0) { + idx++; + count++; + } + subarrayCount += (count * (count + 1)) / 2; + idx++; + } + return subarrayCount; } - return count; - } } From e3ef07b08ef612eb6e846d3e7000784d4b51c382 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Tue, 21 Mar 2023 09:29:47 -0700 Subject: [PATCH 124/712] Updated Median of Two Sorted Arrays --- Hard/Median of Two Sorted Arrays.java | 53 +++++++++------------------ 1 file changed, 18 insertions(+), 35 deletions(-) diff --git a/Hard/Median of Two Sorted Arrays.java b/Hard/Median of Two Sorted Arrays.java index 375c07fa..33ec700b 100644 --- a/Hard/Median of Two Sorted Arrays.java +++ b/Hard/Median of Two Sorted Arrays.java @@ -1,42 +1,25 @@ class Solution { public double findMedianSortedArrays(int[] nums1, int[] nums2) { - int n = nums1.length + nums2.length; - ArrayList arr = new ArrayList<>(); - - int i = 0; - int j = 0; - int k = 0; - int limit = (n)/2 + 1; - - while (i < nums1.length && j < nums2.length && k < limit) { - if (nums1[i] < nums2[j]) { - arr.add(nums1[i]); - i++; - } - else { - arr.add(nums2[j]); - j++; - } - k++; - } - - if (i < nums1.length) { - while (i < nums1.length && k < limit) { - arr.add(nums1[i]); - i++; - k++; - } + if (nums1.length < nums2.length) { + return findMedianSortedArrays(nums2, nums1); } - else { - while (j < nums2.length && k < limit) { - arr.add (nums2[j]); - j++; - k++; + int low = 0; + int high = nums2.length * 2; + while (low <= high) { + int midTwo = (low + high) / 2; + int midOne = nums1.length + nums2.length - midTwo; + double leftOne = (midOne == 0) ? Integer.MIN_VALUE : nums1[(midOne - 1) / 2]; + double leftTwo = (midTwo == 0) ? Integer.MIN_VALUE : nums2[(midTwo - 1) / 2]; + double rightOne = (midOne == nums1.length * 2) ? Integer.MAX_VALUE : nums1[(midOne) / 2]; + double rightTwo = (midTwo == nums2.length * 2) ? Integer.MAX_VALUE : nums2[(midTwo) / 2]; + if (leftOne > rightTwo) { + low = midTwo + 1; + } else if (leftTwo > rightOne) { + high = midTwo - 1; + } else { + return (Math.max(leftOne, leftTwo) + Math.min(rightOne, rightTwo)) / 2; } } - - k--; - - return n%2 == 0 ? (double) (arr.get(k - 1) + arr.get(k)) / 2.0 : (double) arr.get(k); + return -1; } } From 1f2797f276f1f7ae119bf6e70d69a7baa7a94fce Mon Sep 17 00:00:00 2001 From: varunu28 Date: Tue, 21 Mar 2023 18:27:46 -0700 Subject: [PATCH 125/712] Added Minimum Score of a Path Between Two Cities --- ...um Score of a Path Between Two Cities.java | 31 +++++++++++++++++++ 1 file changed, 31 insertions(+) create mode 100644 Medium/Minimum Score of a Path Between Two Cities.java diff --git a/Medium/Minimum Score of a Path Between Two Cities.java b/Medium/Minimum Score of a Path Between Two Cities.java new file mode 100644 index 00000000..28b7ed1b --- /dev/null +++ b/Medium/Minimum Score of a Path Between Two Cities.java @@ -0,0 +1,31 @@ +class Solution { + public int minScore(int n, int[][] roads) { + Map>> graph = new HashMap<>(); + for (int[] road : roads) { + graph.computeIfAbsent(road[0], k -> new ArrayList<>()) + .add(List.of(road[1], road[2])); + graph.computeIfAbsent(road[1], k -> new ArrayList<>()) + .add(List.of(road[0], road[2])); + } + return bfs(n, graph); + } + + private int bfs(int n , Map>> graph) { + boolean[] visited = new boolean[n + 1]; + Queue queue = new LinkedList<>(); + int result = Integer.MAX_VALUE; + queue.add(1); + visited[1] = true; + while (!queue.isEmpty()) { + int node = queue.remove(); + for (List edge : graph.getOrDefault(node, new ArrayList<>())) { + result = Math.min(result, edge.get(1)); + if (!visited[edge.get(0)]) { + visited[edge.get(0)] = true; + queue.add(edge.get(0)); + } + } + } + return result; + } +} From f2c2a47849c1e6465dc82eaa611cbf6de07bf6f4 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Thu, 23 Mar 2023 07:09:40 -0700 Subject: [PATCH 126/712] Added Number of Operations to Make Network Connected --- ... Operations to Make Network Connected.java | 36 +++++++++++++++++++ 1 file changed, 36 insertions(+) create mode 100644 Medium/Number of Operations to Make Network Connected.java diff --git a/Medium/Number of Operations to Make Network Connected.java b/Medium/Number of Operations to Make Network Connected.java new file mode 100644 index 00000000..c44c17d8 --- /dev/null +++ b/Medium/Number of Operations to Make Network Connected.java @@ -0,0 +1,36 @@ +class Solution { + public int makeConnected(int n, int[][] connections) { + if (connections.length < n - 1) { + return -1; + } + Map> graph = new HashMap<>(); + for (int[] conn : connections) { + graph.computeIfAbsent(conn[0], k -> new HashSet<>()).add(conn[1]); + graph.computeIfAbsent(conn[1], k -> new HashSet<>()).add(conn[0]); + } + int count = 0; + boolean[] visited = new boolean[n]; + for (int i = 0; i < n; i++) { + if (!visited[i]) { + bfs(graph, i, visited); + count++; + } + } + return count - 1; + } + + private void bfs(Map> graph, int start, boolean[] visited) { + Queue queue = new LinkedList<>(); + queue.add(start); + visited[start] = true; + while (!queue.isEmpty()) { + int removed = queue.remove(); + for (Integer node : graph.getOrDefault(removed, new HashSet<>())) { + if (!visited[node]) { + visited[node] = true; + queue.add(node); + } + } + } + } +} From d1591f889482881c72b7d4ae3ef9960b1dba015a Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Thu, 23 Mar 2023 17:42:49 -0700 Subject: [PATCH 127/712] Update Reorder Routes to Make All Paths Lead to the City Zero.java --- ... Make All Paths Lead to the City Zero.java | 51 ++++++++++--------- 1 file changed, 26 insertions(+), 25 deletions(-) diff --git a/Medium/Reorder Routes to Make All Paths Lead to the City Zero.java b/Medium/Reorder Routes to Make All Paths Lead to the City Zero.java index 121798de..78f7e54f 100644 --- a/Medium/Reorder Routes to Make All Paths Lead to the City Zero.java +++ b/Medium/Reorder Routes to Make All Paths Lead to the City Zero.java @@ -1,30 +1,31 @@ class Solution { - public int minReorder(int n, int[][] connections) { - Map> map = new HashMap<>(); - Set set = new HashSet<>(); - for (int[] connection : connections) { - map.computeIfAbsent(connection[0], k -> new HashSet<>()).add(connection[1]); - map.computeIfAbsent(connection[1], k -> new HashSet<>()).add(connection[0]); - set.add(connection[0] + "->" + connection[1]); - } - Queue queue = new LinkedList<>(); - queue.add(0); - int numOfReorders = 0; - boolean[] visited = new boolean[n]; - visited[0] = true; - while (!queue.isEmpty()) { - int removed = queue.remove(); - for (int connection : map.getOrDefault(removed, new HashSet<>())) { - if (visited[connection]) { - continue; + public int minReorder(int n, int[][] connections) { + Map>> graph = new HashMap<>(); + for (int[] conn : connections) { + graph.computeIfAbsent(conn[0], k -> new ArrayList<>()).add(List.of(conn[1], 1)); + graph.computeIfAbsent(conn[1], k -> new ArrayList<>()).add(List.of(conn[0], 0)); } - visited[connection] = true; - if (!set.contains(connection + "->" + removed)) { - numOfReorders++; + int[] count = {0}; + bfs(0, n, graph, count); + return count[0]; + } + + private void bfs(int node, int n, Map>> graph, int[] count) { + Queue queue = new LinkedList<>(); + boolean[] visited = new boolean[n]; + visited[node] = true; + queue.add(node); + while (!queue.isEmpty()) { + int removed = queue.remove(); + for (List conn : graph.getOrDefault(removed, new ArrayList<>())) { + int neighbor = conn.get(0); + int direction = conn.get(1); + if (!visited[neighbor]) { + count[0] += direction; + visited[neighbor] = true; + queue.add(neighbor); + } + } } - queue.add(connection); - } } - return numOfReorders; - } } From ea605a4299846f3f1929e17a4c219c293cd3bf28 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Fri, 24 Mar 2023 19:27:03 -0700 Subject: [PATCH 128/712] Updated Count Unreachable Pairs of Nodes in an Undirected Graph --- ...Pairs of Nodes in an Undirected Graph.java | 57 +++++++++++-------- 1 file changed, 32 insertions(+), 25 deletions(-) diff --git a/Medium/Count Unreachable Pairs of Nodes in an Undirected Graph.java b/Medium/Count Unreachable Pairs of Nodes in an Undirected Graph.java index b8f9bb09..4b927bce 100644 --- a/Medium/Count Unreachable Pairs of Nodes in an Undirected Graph.java +++ b/Medium/Count Unreachable Pairs of Nodes in an Undirected Graph.java @@ -1,29 +1,36 @@ class Solution { - public long countPairs(int n, int[][] edges) { - Map> graph = new HashMap<>(); - for (int[] edge : edges) { - graph.computeIfAbsent(edge[0], k -> new ArrayList<>()).add(edge[1]); - graph.computeIfAbsent(edge[1], k -> new ArrayList<>()).add(edge[0]); + public long countPairs(int n, int[][] edges) { + Map> graph = new HashMap<>(); + for (int[] edge : edges) { + graph.computeIfAbsent(edge[0], k -> new HashSet<>()).add(edge[1]); + graph.computeIfAbsent(edge[1], k -> new HashSet<>()).add(edge[0]); + } + boolean[] visited = new boolean[n]; + long unreachableNodeCount = (((long) n) * (n - 1)) / 2; + for (int i = 0; i < n; i++) { + if (!visited[i]) { + long reachCount = traverseHelper(i, graph, visited); + unreachableNodeCount -= (reachCount * (reachCount - 1)) / 2; + } + } + return unreachableNodeCount; } - long unreachableNodes = (((long) n) * (n - 1)) / 2; - boolean[] visited = new boolean[n]; - for (int i = 0; i < n; i++) { - if (!visited[i]) { - long[] reachCount = {0}; - dfs(graph, i, reachCount, visited); - unreachableNodes -= (reachCount[0] * (reachCount[0] - 1)) / 2; - } + + private long traverseHelper(int node, Map> graph, boolean[] visited) { + Queue queue = new LinkedList<>(); + long count = 0; + queue.add(node); + visited[node] = true; + while (!queue.isEmpty()) { + int removed = queue.remove(); + count++; + for (Integer conn : graph.getOrDefault(removed, new HashSet<>())) { + if (!visited[conn]) { + visited[conn] = true; + queue.add(conn); + } + } + } + return count; } - return unreachableNodes; - } - - private void dfs(Map> graph, int node, long[] reachCount, boolean[] visited) { - visited[node] = true; - reachCount[0]++; - for (Integer conn : graph.getOrDefault(node, new ArrayList<>())) { - if (!visited[conn]) { - dfs(graph, conn, reachCount, visited); - } - } - } } From 01571afd10df1f1b4d1b6008d8d4024a36d20684 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sun, 26 Mar 2023 09:18:56 -0700 Subject: [PATCH 129/712] Added Longest Cycle in a Graph --- Hard/Longest Cycle in a Graph.java | 26 ++++++++++++++++++++++++++ 1 file changed, 26 insertions(+) create mode 100644 Hard/Longest Cycle in a Graph.java diff --git a/Hard/Longest Cycle in a Graph.java b/Hard/Longest Cycle in a Graph.java new file mode 100644 index 00000000..6405e016 --- /dev/null +++ b/Hard/Longest Cycle in a Graph.java @@ -0,0 +1,26 @@ +class Solution { + public int longestCycle(int[] edges) { + int n = edges.length; + boolean[] visited = new boolean[n]; + int[] result = {-1}; + for (int i = 0; i < n; i++) { + if (!visited[i]) { + Map map = new HashMap<>(); + map.put(i, 1); + dfs(i, edges, map, visited, result); + } + } + return result[0]; + } + + private void dfs(int node, int[] edges, Map map, boolean[] visited, int[] result) { + visited[node] = true; + int neighbor = edges[node]; + if (neighbor != -1 && !visited[neighbor]) { + map.put(neighbor, map.get(node) + 1); + dfs(neighbor, edges, map, visited, result); + } else if (neighbor != -1 && map.containsKey(neighbor)) { + result[0] = Math.max(result[0], map.get(node) - map.get(neighbor) + 1); + } + } +} From 8c6f7851a76308b2e3c3d34aaaa513ab3c8af150 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sun, 26 Mar 2023 10:43:33 -0700 Subject: [PATCH 130/712] Added K Items With the Maximum Sum --- Easy/K Items With the Maximum Sum.java | 11 +++++++++++ 1 file changed, 11 insertions(+) create mode 100644 Easy/K Items With the Maximum Sum.java diff --git a/Easy/K Items With the Maximum Sum.java b/Easy/K Items With the Maximum Sum.java new file mode 100644 index 00000000..01d51965 --- /dev/null +++ b/Easy/K Items With the Maximum Sum.java @@ -0,0 +1,11 @@ +class Solution { + public int kItemsWithMaximumSum(int numOnes, int numZeros, int numNegOnes, int k) { + int sum = 0; + sum += Math.min(numOnes, k) * 1; + k -= Math.min(numOnes, k); + sum += Math.min(numZeros, k) * 0; + k -= Math.min(numZeros, k); + sum += Math.min(numNegOnes, k) * -1; + return sum; + } +} From 96e0ff49797fef67f902553c610928e8459b5e03 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sun, 26 Mar 2023 17:40:14 -0700 Subject: [PATCH 131/712] Updated Minimum Path Sum --- Medium/Minimum Path Sum.java | 28 ++++++++++++++-------------- 1 file changed, 14 insertions(+), 14 deletions(-) diff --git a/Medium/Minimum Path Sum.java b/Medium/Minimum Path Sum.java index 2100ec3a..0565b7b0 100644 --- a/Medium/Minimum Path Sum.java +++ b/Medium/Minimum Path Sum.java @@ -1,18 +1,18 @@ class Solution { - public int minPathSum(int[][] grid) { - int[][] dp = new int[grid.length][grid[0].length]; - for (int i = 0; i < dp.length; i++) { - for (int j = 0; j < dp[i].length; j++) { - dp[i][j] += grid[i][j]; - if (i > 0 && j > 0) { - dp[i][j] += Math.min(dp[i - 1][j], dp[i][j - 1]); - } else if (i > 0) { - dp[i][j] += dp[i - 1][j]; - } else if (j > 0) { - dp[i][j] += dp[i][j - 1]; + public int minPathSum(int[][] grid) { + int[][] dp = new int[grid.length][grid[0].length]; + for (int i = 0; i < grid.length; i++) { + for (int j = 0; j < grid[0].length; j++) { + dp[i][j] = grid[i][j]; + if (i > 0 && j > 0) { + dp[i][j] += Math.min(dp[i - 1][j], dp[i][j - 1]); + } else if (i > 0) { + dp[i][j] += dp[i - 1][j]; + } else if (j > 0) { + dp[i][j] += dp[i][j - 1]; + } + } } - } + return dp[grid.length - 1][grid[0].length - 1]; } - return dp[grid.length - 1][grid[0].length - 1]; - } } From a5baef0a157d3aefe256a41c495928cd2d3e2c64 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Tue, 28 Mar 2023 08:08:49 -0700 Subject: [PATCH 132/712] Added Minimum Cost For Tickets --- Medium/Minimum Cost For Tickets.java | 29 ++++++++++++++++++++++++++++ 1 file changed, 29 insertions(+) create mode 100644 Medium/Minimum Cost For Tickets.java diff --git a/Medium/Minimum Cost For Tickets.java b/Medium/Minimum Cost For Tickets.java new file mode 100644 index 00000000..8867660b --- /dev/null +++ b/Medium/Minimum Cost For Tickets.java @@ -0,0 +1,29 @@ +class Solution { + public int mincostTickets(int[] days, int[] costs) { + Set daySet = new HashSet<>(); + for (int day : days) { + daySet.add(day); + } + int[] dp = new int[days[days.length - 1]]; + return helper(days[days.length - 1], daySet, costs, dp); + } + + private int helper(int currDay, Set daySet, int[] costs, int[] dp) { + if (currDay <= 0) { + return 0; + } + if (dp[currDay - 1] != 0) { + return dp[currDay - 1]; + } + int result = 0; + if (daySet.contains(currDay)) { + int one = helper(currDay - 1, daySet, costs, dp) + costs[0]; + int seven = helper(currDay - 7, daySet, costs, dp) + costs[1]; + int thirty = helper(currDay - 30, daySet, costs, dp) + costs[2]; + result = Math.min(one, Math.min(seven, thirty)); + } else { + result = helper(currDay - 1, daySet, costs, dp); + } + return dp[currDay - 1] = result; + } +} From b60c6d76e839dd78f8b1a0853a6ded43486a5cb7 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Tue, 28 Mar 2023 18:39:07 -0700 Subject: [PATCH 133/712] Added Reducing Dishes --- Hard/Reducing Dishes.java | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) create mode 100644 Hard/Reducing Dishes.java diff --git a/Hard/Reducing Dishes.java b/Hard/Reducing Dishes.java new file mode 100644 index 00000000..2a69540e --- /dev/null +++ b/Hard/Reducing Dishes.java @@ -0,0 +1,20 @@ +class Solution { + public int maxSatisfaction(int[] satisfaction) { + Arrays.sort(satisfaction); + int n = satisfaction.length; + Integer[][] dp = new Integer[n + 1][n + 1]; + return helper(satisfaction, 0, 1, dp); + } + + private int helper(int[] satisfaction, int idx, int time, Integer[][] dp) { + if (idx == satisfaction.length) { + return 0; + } + if (dp[idx][time] != null) { + return dp[idx][time]; + } + dp[idx][time] = Math.max(satisfaction[idx] * time + helper(satisfaction, idx + 1, time + 1, dp), + helper(satisfaction, idx + 1, time, dp)); + return dp[idx][time]; + } +} From f35c580ea510cb5d4153da0631d6d3c61da25b6d Mon Sep 17 00:00:00 2001 From: varunu28 Date: Thu, 30 Mar 2023 06:52:38 -0700 Subject: [PATCH 134/712] Added Scramble String --- Hard/Scramble String.java | 25 +++++++++++++++++++++++++ 1 file changed, 25 insertions(+) create mode 100644 Hard/Scramble String.java diff --git a/Hard/Scramble String.java b/Hard/Scramble String.java new file mode 100644 index 00000000..ac35d39c --- /dev/null +++ b/Hard/Scramble String.java @@ -0,0 +1,25 @@ +class Solution { + public boolean isScramble(String s1, String s2) { + int n = s1.length(); + Boolean[][][] dp = new Boolean[n][n][n + 1]; + return helper(s1, s2, 0, 0, n, dp); + } + + private boolean helper(String s1, String s2, int idxOne, int idxTwo, int n, Boolean[][][] dp) { + if (dp[idxOne][idxTwo][n] != null) { + return dp[idxOne][idxTwo][n]; + } + if (n == 1) { + return dp[idxOne][idxTwo][n] = s1.charAt(idxOne) == s2.charAt(idxTwo); + } + for (int l = 1; l < n; l++) { + if (helper(s1, s2, idxOne, idxTwo, l, dp) && helper(s1, s2, idxOne + l, idxTwo + l, n - l, dp)) { + return dp[idxOne][idxTwo][n] = true; + } + if (helper(s1, s2, idxOne, idxTwo + n - l, l, dp) && helper(s1, s2, idxOne + l, idxTwo, n - l, dp)) { + return dp[idxOne][idxTwo][n] = true; + } + } + return dp[idxOne][idxTwo][n] = false; + } +} From aa0b930116863355cddaa45fe226d63f7fe16021 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Thu, 30 Mar 2023 19:49:42 -0700 Subject: [PATCH 135/712] Added Number of Ways of Cutting a Pizza --- Hard/Number of Ways of Cutting a Pizza.java | 37 +++++++++++++++++++++ 1 file changed, 37 insertions(+) create mode 100644 Hard/Number of Ways of Cutting a Pizza.java diff --git a/Hard/Number of Ways of Cutting a Pizza.java b/Hard/Number of Ways of Cutting a Pizza.java new file mode 100644 index 00000000..a96b2064 --- /dev/null +++ b/Hard/Number of Ways of Cutting a Pizza.java @@ -0,0 +1,37 @@ +class Solution { + + private static final int MOD = 1000_000_007; + + public int ways(String[] pizza, int k) { + int rows = pizza.length; + int cols = pizza[0].length(); + int[][] apples = new int[rows + 1][cols + 1]; + int[][][] dp = new int[k][rows][cols]; + for (int row = rows - 1; row >= 0; row--) { + for (int col = cols - 1; col >= 0; col--) { + apples[row][col] = (pizza[row].charAt(col) == 'A' ? 1 : 0) + apples[row + 1][col] + apples[row][col + 1] - apples[row + 1][col + 1]; + dp[0][row][col] = apples[row][col] > 0 ? 1 : 0; + } + } + + for (int i = 1; i < k; i++) { + for (int row = 0; row < rows; row++) { + for (int col = 0; col < cols; col++) { + for (int nextRow = row + 1; nextRow < rows; nextRow++) { + if (apples[row][col] - apples[nextRow][col] > 0) { + dp[i][row][col] += dp[i - 1][nextRow][col]; + dp[i][row][col] %= MOD; + } + } + for (int nextCol = col + 1; nextCol < cols; nextCol++) { + if (apples[row][col] - apples[row][nextCol] > 0) { + dp[i][row][col] += dp[i - 1][row][nextCol]; + dp[i][row][col] %= MOD; + } + } + } + } + } + return dp[k - 1][0][0]; + } +} From 93de89d96da86beb4d51d2f67ac261cd7b762adc Mon Sep 17 00:00:00 2001 From: varunu28 Date: Fri, 31 Mar 2023 06:43:54 -0700 Subject: [PATCH 136/712] Added 4 Keys Keyboard --- Medium/4 Keys Keyboard.java | 14 ++++++++++++++ 1 file changed, 14 insertions(+) create mode 100644 Medium/4 Keys Keyboard.java diff --git a/Medium/4 Keys Keyboard.java b/Medium/4 Keys Keyboard.java new file mode 100644 index 00000000..2ca4bb8e --- /dev/null +++ b/Medium/4 Keys Keyboard.java @@ -0,0 +1,14 @@ +class Solution { + public int maxA(int n) { + int[] dp = new int[n + 1]; + for (int i = 0; i <= n; i++) { + dp[i] = i; + } + for (int i = 0; i <= n - 3; i++) { + for (int j = i + 3; j <= Math.min(n, i + 6); j++) { + dp[j] = Math.max(dp[j], (j - i - 1) * dp[i]); + } + } + return dp[n]; + } +} From 2cf3328da7d6fd6e6d57a127dcc7ea16d36fc436 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sat, 1 Apr 2023 14:56:24 -0700 Subject: [PATCH 137/712] Added Form Smallest Number From Two Digit Arrays --- ...Smallest Number From Two Digit Arrays.java | 21 +++++++++++++++++++ 1 file changed, 21 insertions(+) create mode 100644 Easy/Form Smallest Number From Two Digit Arrays.java diff --git a/Easy/Form Smallest Number From Two Digit Arrays.java b/Easy/Form Smallest Number From Two Digit Arrays.java new file mode 100644 index 00000000..5ae6bd94 --- /dev/null +++ b/Easy/Form Smallest Number From Two Digit Arrays.java @@ -0,0 +1,21 @@ +class Solution { + public int minNumber(int[] nums1, int[] nums2) { + int[] counter = new int[10]; + int smallestOne = nums1[0]; + int smallestTwo = nums2[0]; + for (int num : nums1) { + counter[num]++; + smallestOne = Math.min(smallestOne, num); + } + for (int num : nums2) { + counter[num]++; + smallestTwo = Math.min(smallestTwo, num); + } + for (int i = 1; i < counter.length; i++) { + if (counter[i] == 2) { + return i; + } + } + return Math.min(smallestOne, smallestTwo) * 10 + Math.max(smallestOne, smallestTwo); + } +} From 2755705abf32b39d6cd207f162dbed899830ab95 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sat, 1 Apr 2023 15:34:33 -0700 Subject: [PATCH 138/712] Added Find the Substring With Maximum Cost.java --- Medium/Find the Substring With Maximum Cost.java | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) create mode 100644 Medium/Find the Substring With Maximum Cost.java diff --git a/Medium/Find the Substring With Maximum Cost.java b/Medium/Find the Substring With Maximum Cost.java new file mode 100644 index 00000000..24e00548 --- /dev/null +++ b/Medium/Find the Substring With Maximum Cost.java @@ -0,0 +1,16 @@ +class Solution { + public int maximumCostSubstring(String s, String chars, int[] vals) { + Map valueMap = new HashMap<>(); + for (int i = 0; i < chars.length(); i++) { + valueMap.put(chars.charAt(i), vals[i]); + } + int maxCost = 0; + int currCost = 0; + for (char c : s.toCharArray()) { + int currCharCost = valueMap.containsKey(c) ? valueMap.get(c) : (c - 'a' + 1); + currCost = Math.max(currCharCost, currCost + currCharCost); + maxCost = Math.max(currCost, maxCost); + } + return maxCost; + } +} From 273c1f2c71f649579d5312294b8f4e586a509aac Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sat, 1 Apr 2023 15:40:42 -0700 Subject: [PATCH 139/712] Added commit-script.sh --- commit-script.sh | 15 +++++++++++++++ 1 file changed, 15 insertions(+) create mode 100755 commit-script.sh diff --git a/commit-script.sh b/commit-script.sh new file mode 100755 index 00000000..90a4f404 --- /dev/null +++ b/commit-script.sh @@ -0,0 +1,15 @@ +#!/bin/sh + +git add . + +if git status | grep -q 'modified'; then + status=$(git status | grep 'modified') + modified_file=${status##*/} + git commit -m "Updated ${modified_file}" +elif git status | grep -q 'new file:'; then + status=$(git status | grep 'new file:') + added_file=${status##*/} + git commit -m "Added ${added_file}" +fi + +git push From f2c68be5498d5e5723f1e0ff2892b175f3fa382e Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sat, 1 Apr 2023 17:22:58 -0700 Subject: [PATCH 140/712] Updated Successful Pairs of Spells and Potions.java --- ...uccessful Pairs of Spells and Potions.java | 44 +++++++++---------- 1 file changed, 22 insertions(+), 22 deletions(-) diff --git a/Medium/Successful Pairs of Spells and Potions.java b/Medium/Successful Pairs of Spells and Potions.java index 40c459c7..8a8e6886 100644 --- a/Medium/Successful Pairs of Spells and Potions.java +++ b/Medium/Successful Pairs of Spells and Potions.java @@ -1,26 +1,26 @@ class Solution { - public int[] successfulPairs(int[] spells, int[] potions, long success) { - int[] result = new int[spells.length]; - Arrays.sort(potions); - for (int i = 0; i < spells.length; i++) { - int idx = getSuccessIdx(potions, spells[i], success); - result[i] = potions.length - idx; + public int[] successfulPairs(int[] spells, int[] potions, long success) { + Arrays.sort(potions); + int[] result = new int[spells.length]; + for (int i = 0; i < spells.length; i++) { + result[i] = findCountOfSuccessfulPotion(potions, success, (long) spells[i]); + } + return result; } - return result; - } - - private int getSuccessIdx(int[] potions, int spell, long success) { - int left = 0; - int right = potions.length; - while (left < right) { - int mid = (left + right) / 2; - long currSuccess = ((long) potions[mid]) * spell; - if (currSuccess >= success) { - right = mid; - } else { - left = mid + 1; - } + + private int findCountOfSuccessfulPotion(int[] potions, long success, long spell) { + int left = 0; + int right = potions.length - 1; + int minIdx = Integer.MAX_VALUE; + while (left <= right) { + int mid = (left + right) / 2; + if (potions[mid] * spell >= success) { + minIdx = Math.min(minIdx, mid); + right = mid - 1; + } else { + left = mid + 1; + } + } + return minIdx == Integer.MAX_VALUE ? 0 : (potions.length - minIdx); } - return left; - } } From fa1372856b855ae761eb4ce732004b9e07a6d864 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sun, 2 Apr 2023 06:41:44 -0700 Subject: [PATCH 141/712] Added Find the Longest Balanced Substring of a Binary String.java --- ...Balanced Substring of a Binary String.java | 25 +++++++++++++++++++ 1 file changed, 25 insertions(+) create mode 100644 Easy/Find the Longest Balanced Substring of a Binary String.java diff --git a/Easy/Find the Longest Balanced Substring of a Binary String.java b/Easy/Find the Longest Balanced Substring of a Binary String.java new file mode 100644 index 00000000..2b1d3f2a --- /dev/null +++ b/Easy/Find the Longest Balanced Substring of a Binary String.java @@ -0,0 +1,25 @@ +class Solution { + public int findTheLongestBalancedSubstring(String s) { + int maxLength = 0; + int idx = 0; + while (idx < s.length()) { + if (s.charAt(idx) != '0') { + idx++; + continue; + } + int zeroCount = 0; + while (idx < s.length() && s.charAt(idx) == '0') { + idx++; + zeroCount++; + } + int oneCount = 0; + while (idx < s.length() && s.charAt(idx) == '1') { + idx++; + oneCount++; + } + maxLength = Math.max(maxLength, 2 * Math.min(zeroCount, oneCount)); + + } + return maxLength; + } +} From 3c1247f87aa3f6a704c27682363ad70ded0c696c Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sun, 2 Apr 2023 06:48:32 -0700 Subject: [PATCH 142/712] Added Convert an Array Into a 2D Array With Conditions.java --- ...Array Into a 2D Array With Conditions.java | 25 +++++++++++++++++++ 1 file changed, 25 insertions(+) create mode 100644 Medium/Convert an Array Into a 2D Array With Conditions.java diff --git a/Medium/Convert an Array Into a 2D Array With Conditions.java b/Medium/Convert an Array Into a 2D Array With Conditions.java new file mode 100644 index 00000000..c774bda6 --- /dev/null +++ b/Medium/Convert an Array Into a 2D Array With Conditions.java @@ -0,0 +1,25 @@ +class Solution { + public List> findMatrix(int[] nums) { + Map frequencyMap = new HashMap<>(); + for (int num : nums) { + frequencyMap.put(num, frequencyMap.getOrDefault(num, 0) + 1); + } + Queue queue = new LinkedList<>(); + queue.addAll(frequencyMap.keySet()); + List> result = new ArrayList<>(); + while (!queue.isEmpty()) { + int size = queue.size(); + List row = new ArrayList<>(); + while (size-- > 0) { + int removed = queue.remove(); + row.add(removed); + if (frequencyMap.get(removed) > 1) { + frequencyMap.put(removed, frequencyMap.get(removed) - 1); + queue.add(removed); + } + } + result.add(row); + } + return result; + } +} From 1f4411567a5ab8fe45d883cf8d7c2ddc25dd25b8 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Mon, 3 Apr 2023 06:40:07 -0700 Subject: [PATCH 143/712] Updated Boats to Save People.java --- Medium/Boats to Save People.java | 28 ++++++++++++++-------------- 1 file changed, 14 insertions(+), 14 deletions(-) diff --git a/Medium/Boats to Save People.java b/Medium/Boats to Save People.java index 725f18c7..dab79035 100644 --- a/Medium/Boats to Save People.java +++ b/Medium/Boats to Save People.java @@ -1,16 +1,16 @@ class Solution { - public int numRescueBoats(int[] people, int limit) { - Arrays.sort(people); - int startIdx = 0; - int endIdx = people.length - 1; - int count = 0; - while (startIdx <= endIdx) { - int currWeight = people[endIdx--]; - if (startIdx <= endIdx && currWeight + people[startIdx] <= limit) { - currWeight += people[startIdx++]; - } - count++; - } - return count; - } + public int numRescueBoats(int[] people, int limit) { + Arrays.sort(people); + int left = 0; + int right = people.length - 1; + int count = 0; + while (left <= right) { + int capacity = people[right--]; + if (left <= right && capacity + people[left] <= limit) { + left++; + } + count++; + } + return count; + } } From 3492e1be759604c0f3b28209b92a742c81368132 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Mon, 3 Apr 2023 06:52:29 -0700 Subject: [PATCH 144/712] Updated Shortest Word Distance III.java --- Medium/Shortest Word Distance III.java | 31 +++++++++++++++++--------- 1 file changed, 20 insertions(+), 11 deletions(-) diff --git a/Medium/Shortest Word Distance III.java b/Medium/Shortest Word Distance III.java index ba7216c1..fba93082 100644 --- a/Medium/Shortest Word Distance III.java +++ b/Medium/Shortest Word Distance III.java @@ -1,15 +1,24 @@ class Solution { - public int shortestWordDistance(String[] wordsDict, String word1, String word2) { - int minIdxDiff = wordsDict.length; - int prevIdx = -1; - for (int i = 0; i < wordsDict.length; i++) { - if (wordsDict[i].equals(word1) || wordsDict[i].equals(word2)) { - if (prevIdx != -1 && (word1.equals(word2) || !wordsDict[prevIdx].equals(wordsDict[i]))) { - minIdxDiff = Math.min(minIdxDiff, Math.abs(prevIdx - i)); + public int shortestWordDistance(String[] wordsDict, String word1, String word2) { + int idxOne = -1; + int idxTwo = -1; + int minDistance = Integer.MAX_VALUE; + boolean sameWord = word1.equals(word2); + for (int i = 0; i < wordsDict.length; i++) { + if (wordsDict[i].equals(word1)) { + idxOne = sameWord ? (idxOne == -1 ? i : idxOne) : i; + } + if (wordsDict[i].equals(word2)) { + idxTwo = sameWord ? (idxOne != i ? i : idxTwo) : i; + } + if (idxOne != -1 && idxTwo != -1) { + minDistance = Math.min(minDistance, Math.abs(idxOne - idxTwo)); + if (sameWord) { + idxOne = idxTwo; + idxTwo = -1; + } + } } - prevIdx = i; - } + return minDistance; } - return minIdxDiff; - } } From 004d680823e9846a78ec8afbe2915bb678c6fa35 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Mon, 3 Apr 2023 17:22:55 -0700 Subject: [PATCH 145/712] Updated Optimal Partition of String.java --- Medium/Optimal Partition of String.java | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/Medium/Optimal Partition of String.java b/Medium/Optimal Partition of String.java index 2c42afa6..68b01d59 100644 --- a/Medium/Optimal Partition of String.java +++ b/Medium/Optimal Partition of String.java @@ -1,14 +1,14 @@ class Solution { - public int partitionString(String s) { - int idx = 0; - int count = 0; - while (idx < s.length()) { - Set set = new HashSet<>(); - while (idx < s.length() && set.add(s.charAt(idx))) { - idx++; - } - count++; + public int partitionString(String s) { + int count = 0; + int idx = 0; + while (idx < s.length()) { + Set set = new HashSet<>(); + while (idx < s.length() && set.add(s.charAt(idx))) { + idx++; + } + count++; + } + return count; } - return count; - } } From 59c5848f72b9f9104b88f60d5a04b8c06fa36412 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Tue, 4 Apr 2023 17:42:29 -0700 Subject: [PATCH 146/712] Added Minimize Maximum of Array.java --- Medium/Minimize Maximum of Array.java | 11 +++++++++++ 1 file changed, 11 insertions(+) create mode 100644 Medium/Minimize Maximum of Array.java diff --git a/Medium/Minimize Maximum of Array.java b/Medium/Minimize Maximum of Array.java new file mode 100644 index 00000000..79d5ee9b --- /dev/null +++ b/Medium/Minimize Maximum of Array.java @@ -0,0 +1,11 @@ +class Solution { + public int minimizeArrayValue(int[] nums) { + long prefixSum = 0L; + long result = 0L; + for (int i = 0; i < nums.length; i++) { + prefixSum += nums[i]; + result = Math.max(result, (prefixSum + i) / (i + 1)); + } + return (int) result; + } +} From 563b41ea825069d095fd01527b23781d69529d08 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Wed, 5 Apr 2023 17:31:05 -0700 Subject: [PATCH 147/712] Updated Number of Closed Islands.java --- Medium/Number of Closed Islands.java | 68 ++++++++++++++-------------- 1 file changed, 33 insertions(+), 35 deletions(-) diff --git a/Medium/Number of Closed Islands.java b/Medium/Number of Closed Islands.java index 201b30a3..bc8a9a9e 100644 --- a/Medium/Number of Closed Islands.java +++ b/Medium/Number of Closed Islands.java @@ -1,40 +1,38 @@ class Solution { - private static final int[][] DIRS = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}}; - - public int closedIsland(int[][] grid) { - int closedIslandCount = 0; - for (int i = 0; i < grid.length; i++) { - for (int j = 0; j < grid[0].length; j++) { - if (grid[i][j] == 0 && isSurroundedSuccessfully(grid, i, j)) { - closedIslandCount++; + + private static final int[][] DIRS = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}}; + + public int closedIsland(int[][] grid) { + int count = 0; + boolean[][] visited = new boolean[grid.length][grid[0].length]; + for (int i = 0; i < grid.length; i++) { + for (int j = 0; j < grid[0].length; j++) { + if (grid[i][j] == 0 && !visited[i][j] && isClosed(grid, i, j, visited)) { + count++; + } + } } - } + return count; } - return closedIslandCount; - } - - private boolean isSurroundedSuccessfully(int[][] grid, int i, int j) { - Queue queue = new LinkedList<>(); - queue.add(new int[]{i, j}); - boolean surroundingCheck = true; - while (!queue.isEmpty()) { - int[] removed = queue.remove(); - int x = removed[0]; - int y = removed[1]; - if (x < 0 || y < 0 || x >= grid.length || y >= grid[0].length) { - surroundingCheck = false; - continue; - } - if (grid[x][y] == 1) { - continue; - } - grid[x][y] = 1; - for (int[] dir : DIRS) { - int newX = x + dir[0]; - int newY = y + dir[1]; - queue.add(new int[]{newX, newY}); - } + + private boolean isClosed(int[][] grid, int i, int j, boolean[][] visited) { + Queue queue = new LinkedList<>(); + queue.add(new int[]{i, j}); + visited[i][j] = true; + boolean closed = true; + while (!queue.isEmpty()) { + int[] removed = queue.remove(); + for (int[] dir : DIRS) { + int newX = removed[0] + dir[0]; + int newY = removed[1] + dir[1]; + if (newX < 0 || newY < 0 || newX >= grid.length || newY >= grid[0].length) { + closed = false; + } else if (grid[newX][newY] == 0 && !visited[newX][newY]) { + queue.add(new int[]{newX, newY}); + visited[newX][newY] = true; + } + } + } + return closed; } - return surroundingCheck; - } } From a51ef04068f7a284bb74b5a41aeffb4c3c5c81a3 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Thu, 6 Apr 2023 17:34:58 -0700 Subject: [PATCH 148/712] Updated Number of Enclaves.java --- Medium/Number of Enclaves.java | 60 ++++++++++++++++++++-------------- 1 file changed, 35 insertions(+), 25 deletions(-) diff --git a/Medium/Number of Enclaves.java b/Medium/Number of Enclaves.java index 105942a1..afacc77a 100644 --- a/Medium/Number of Enclaves.java +++ b/Medium/Number of Enclaves.java @@ -1,30 +1,40 @@ class Solution { - private static final int[][] DIRS = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}}; - - public int numEnclaves(int[][] grid) { - Queue queue = new LinkedList<>(); - int result = 0; - for (int i = 0; i < grid.length; i++) { - for (int j = 0; j < grid[0].length; j++) { - result += grid[i][j]; - if (i * j == 0 || i == grid.length - 1 || j == grid[i].length - 1) { - queue.add(new int[]{i, j}); + + private static final int[][] DIRS = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}}; + + public int numEnclaves(int[][] grid) { + int count = 0; + boolean[][] visited = new boolean[grid.length][grid[0].length]; + for (int i = 0; i < grid.length; i++) { + for (int j = 0; j < grid[0].length; j++) { + if (grid[i][j] == 1 && !visited[i][j]) { + count += getClosedEnclaveCount(grid, i, j, visited); + } + } } - } + return count; } - while (!queue.isEmpty()) { - int[] removed = queue.remove(); - int x = removed[0]; - int y = removed[1]; - if (x < 0 || y < 0 || x == grid.length || y == grid[0].length || grid[x][y] != 1) { - continue; - } - grid[x][y] = 0; - result--; - for (int[] dir : DIRS) { - queue.add(new int[]{x + dir[0], y + dir[1]}); - } + + private int getClosedEnclaveCount(int[][] grid, int i, int j, boolean[][] visited) { + boolean isClosed = true; + int enclaveCount = 0; + Queue queue = new LinkedList<>(); + queue.add(new int[]{i, j}); + visited[i][j] = true; + while (!queue.isEmpty()) { + int[] removed = queue.remove(); + enclaveCount++; + for (int[] dir : DIRS) { + int newX = removed[0] + dir[0]; + int newY = removed[1] + dir[1]; + if (newX < 0 || newY < 0 || newX >= grid.length || newY >= grid[0].length) { + isClosed = false; + } else if (grid[newX][newY] == 1 && !visited[newX][newY]) { + visited[newX][newY] = true; + queue.add(new int[]{newX, newY}); + } + } + } + return isClosed ? enclaveCount : 0; } - return result; - } } From dce1f7776febe51afbd62b42e3ceb65683d8aeb4 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Fri, 7 Apr 2023 17:05:27 -0700 Subject: [PATCH 149/712] Updated Clone Graph.java --- Medium/Clone Graph.java | 39 ++++++++++++++++++--------------------- 1 file changed, 18 insertions(+), 21 deletions(-) diff --git a/Medium/Clone Graph.java b/Medium/Clone Graph.java index 47a4ba95..cddb7b81 100644 --- a/Medium/Clone Graph.java +++ b/Medium/Clone Graph.java @@ -3,17 +3,14 @@ class Node { public int val; public List neighbors; - public Node() { val = 0; neighbors = new ArrayList(); } - public Node(int _val) { val = _val; neighbors = new ArrayList(); } - public Node(int _val, ArrayList _neighbors) { val = _val; neighbors = _neighbors; @@ -22,24 +19,24 @@ public Node(int _val, ArrayList _neighbors) { */ class Solution { - public Node cloneGraph(Node node) { - if (node == null) { - return null; - } - Map map = new HashMap<>(); - Queue queue = new LinkedList<>(); - queue.add(node); - map.put(node, new Node(node.val)); - while (!queue.isEmpty()) { - Node removed = queue.remove(); - for (Node neighbor : removed.neighbors) { - if (!map.containsKey(neighbor)) { - map.put(neighbor, new Node(neighbor.val)); - queue.add(neighbor); + public Node cloneGraph(Node node) { + if (node == null) { + return null; + } + Map map = new HashMap(); + Queue queue = new LinkedList<>(); + queue.add(node); + map.put(node, new Node(node.val)); + while (!queue.isEmpty()) { + Node removed = queue.remove(); + for (Node neighbor : removed.neighbors) { + if (!map.containsKey(neighbor)) { + map.put(neighbor, new Node(neighbor.val)); + queue.add(neighbor); + } + map.get(removed).neighbors.add(map.get(neighbor)); + } } - map.get(removed).neighbors.add(map.get(neighbor)); - } + return map.get(node); } - return map.get(node); - } } From cb72a61686b69ac51ca4359093e9f288d07e0305 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Fri, 7 Apr 2023 17:09:44 -0700 Subject: [PATCH 150/712] Updated Find Anagram Mappings.java --- Easy/Find Anagram Mappings.java | 19 ++++++++++--------- 1 file changed, 10 insertions(+), 9 deletions(-) diff --git a/Easy/Find Anagram Mappings.java b/Easy/Find Anagram Mappings.java index 2a7c34e3..3650db78 100644 --- a/Easy/Find Anagram Mappings.java +++ b/Easy/Find Anagram Mappings.java @@ -1,12 +1,13 @@ class Solution { - public int[] anagramMappings(int[] nums1, int[] nums2) { - Map indexMapping = new HashMap<>(); - for (int i = 0; i < nums2.length; i++) { - indexMapping.put(nums2[i], i); + public int[] anagramMappings(int[] nums1, int[] nums2) { + Map indexMap = new HashMap<>(); + for (int i = 0; i < nums2.length; i++) { + indexMap.putIfAbsent(nums2[i], i); + } + int[] result = new int[nums1.length]; + for (int i = 0; i < nums1.length; i++) { + result[i] = indexMap.get(nums1[i]); + } + return result; } - for (int i = 0; i < nums1.length; i++) { - nums1[i] = indexMapping.get(nums1[i]); - } - return nums1; - } } From 7b11656984c2ed24185dccf802063f1286e5f1c8 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sun, 9 Apr 2023 09:21:10 -0700 Subject: [PATCH 151/712] Added Largest Color Value in a Directed Graph.java --- ...rgest Color Value in a Directed Graph.java | 39 +++++++++++++++++++ 1 file changed, 39 insertions(+) create mode 100644 Hard/Largest Color Value in a Directed Graph.java diff --git a/Hard/Largest Color Value in a Directed Graph.java b/Hard/Largest Color Value in a Directed Graph.java new file mode 100644 index 00000000..2d2fe6d5 --- /dev/null +++ b/Hard/Largest Color Value in a Directed Graph.java @@ -0,0 +1,39 @@ +class Solution { + public int largestPathValue(String colors, int[][] edges) { + int n = colors.length(); + Map> graph = new HashMap<>(); + int[] indegree = new int[n]; + for (int[] edge : edges) { + graph.computeIfAbsent(edge[0], k -> new ArrayList<>()) + .add(edge[1]); + indegree[edge[1]]++; + } + int[][] count = new int[n][26]; + Queue queue = new LinkedList<>(); + for (int i = 0; i < n; i++) { + if (indegree[i] == 0) { + queue.add(i); + } + } + int result = 1; + int seen = 0; + while (!queue.isEmpty()) { + int node = queue.remove(); + result = Math.max(result, ++count[node][colors.charAt(node) - 'a']); + seen++; + if (!graph.containsKey(node)) { + continue; + } + for (int neighbor : graph.get(node)) { + for (int i = 0; i < 26; i++) { + count[neighbor][i] = Math.max(count[neighbor][i], count[node][i]); + } + indegree[neighbor]--; + if (indegree[neighbor] == 0) { + queue.add(neighbor); + } + } + } + return seen < n ? -1 : result; + } +} From b9add47cbe0e3be8dac61e3cf12402cfda6754ae Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sun, 9 Apr 2023 09:28:45 -0700 Subject: [PATCH 152/712] Added Prime In Diagonal.java --- Easy/Prime In Diagonal.java | 30 ++++++++++++++++++++++++++++++ 1 file changed, 30 insertions(+) create mode 100644 Easy/Prime In Diagonal.java diff --git a/Easy/Prime In Diagonal.java b/Easy/Prime In Diagonal.java new file mode 100644 index 00000000..16b34fda --- /dev/null +++ b/Easy/Prime In Diagonal.java @@ -0,0 +1,30 @@ +class Solution { + public int diagonalPrime(int[][] nums) { + int n = nums.length; + int maxPrime = 0; + for (int i = 0; i < n; i++) { + for (int j = 0; j < n; j++) { + if ((i == j || i + j == n - 1) && isPrime(nums[i][j])) { + maxPrime = Math.max(maxPrime, nums[i][j]); + } + } + } + return maxPrime; + } + + private static boolean isPrime(int n) { + if (n <= 1) { + return false; + } + if (n == 2) { + return true; + } + int midPoint = ((int) Math.sqrt(n)) + 1; + for (int i = 2; i <= midPoint; i++) { + if (n % i == 0) { + return false; + } + } + return true; + } +} From 342118382d4ce4c5cca25587e1efce1fa1dca3ed Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Mon, 10 Apr 2023 17:43:08 -0700 Subject: [PATCH 153/712] Update Removing Stars From a String.java --- Medium/Removing Stars From a String.java | 28 ++++++++++++------------ 1 file changed, 14 insertions(+), 14 deletions(-) diff --git a/Medium/Removing Stars From a String.java b/Medium/Removing Stars From a String.java index 0cb79bea..9278128a 100644 --- a/Medium/Removing Stars From a String.java +++ b/Medium/Removing Stars From a String.java @@ -1,17 +1,17 @@ class Solution { - public String removeStars(String s) { - Stack stack = new Stack<>(); - for (char c : s.toCharArray()) { - if (c == '*') { - stack.pop(); - } else { - stack.push(c); - } + public String removeStars(String s) { + Stack stack = new Stack<>(); + for (char c : s.toCharArray()) { + if (c == '*') { + stack.pop(); + } else { + stack.push(c); + } + } + StringBuilder sb = new StringBuilder(); + while (!stack.isEmpty()) { + sb.append(stack.pop()); + } + return sb.reverse().toString(); } - StringBuilder sb = new StringBuilder(); - while (!stack.isEmpty()) { - sb.append(stack.pop()); - } - return sb.reverse().toString(); - } } From f2e1d1fe4f8c7f95f38292280ee6f59b3de0565a Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Tue, 11 Apr 2023 17:24:14 -0700 Subject: [PATCH 154/712] Update Simplify Path.java --- Medium/Simplify Path.java | 37 +++++++++++++++++++------------------ 1 file changed, 19 insertions(+), 18 deletions(-) diff --git a/Medium/Simplify Path.java b/Medium/Simplify Path.java index 51c19971..b04ccd5e 100644 --- a/Medium/Simplify Path.java +++ b/Medium/Simplify Path.java @@ -1,22 +1,23 @@ class Solution { - public String simplifyPath(String path) { - Stack stack = new Stack<>(); - String[] splits = path.split("/"); - for (String split : splits) { - if (split.equals("") || split.equals(".")) { - continue; - } else if (split.equals("..")) { - if (!stack.isEmpty()) { - stack.pop(); + public String simplifyPath(String path) { + Stack stack = new Stack<>(); + String[] splits = path.split("\\/"); + for (String split : splits) { + if (split.equals(".") || split.equals("/") || split.isBlank()) { + continue; + } + if (split.equals("..")) { + if (!stack.isEmpty()) { + stack.pop(); + } + } else { + stack.push(split); + } } - } else { - stack.push(split); - } - } - StringBuilder resultingPath = new StringBuilder(); - while (!stack.isEmpty()) { - resultingPath.insert(0, stack.pop()).insert(0, "/"); + StringBuilder sb = new StringBuilder(); + while (!stack.isEmpty()) { + sb.insert(0, stack.pop()).insert(0, "/"); + } + return sb.length() == 0 ? "/" : sb.toString(); } - return resultingPath.length() == 0 ? "/" : resultingPath.toString(); - } } From 2b4883da7ff2d566271460143c1dda5bea817f04 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Wed, 12 Apr 2023 17:16:48 -0700 Subject: [PATCH 155/712] Updated Validate Stack Sequences.java --- Medium/Validate Stack Sequences.java | 36 +++++++++++++--------------- 1 file changed, 17 insertions(+), 19 deletions(-) diff --git a/Medium/Validate Stack Sequences.java b/Medium/Validate Stack Sequences.java index 87d61d31..64ae1452 100644 --- a/Medium/Validate Stack Sequences.java +++ b/Medium/Validate Stack Sequences.java @@ -1,22 +1,20 @@ class Solution { - public boolean validateStackSequences(int[] pushed, int[] popped) { - Stack stack = new Stack<>(); - int pushIdx = 0; - int popIdx = 0; - while (pushIdx < pushed.length) { - while (!stack.isEmpty() && popped[popIdx] == stack.peek()) { - stack.pop(); - popIdx++; - } - stack.push(pushed[pushIdx++]); + public boolean validateStackSequences(int[] pushed, int[] popped) { + Stack stack = new Stack<>(); + int pushedIdx = 0; + int poppedIdx = 0; + while (pushedIdx < pushed.length && poppedIdx < popped.length) { + if (!stack.isEmpty() && stack.peek() == popped[poppedIdx]) { + stack.pop(); + poppedIdx++; + } else { + stack.push(pushed[pushedIdx++]); + } + } + while (poppedIdx < popped.length && !stack.isEmpty() && stack.peek() == popped[poppedIdx]) { + stack.pop(); + poppedIdx++; + } + return pushedIdx == pushed.length && poppedIdx == popped.length; } - while (popIdx < popped.length) { - if (stack.isEmpty() || stack.peek() != popped[popIdx]) { - return false; - } - stack.pop(); - popIdx++; - } - return true; - } } From c1335270bf916fa7deab3b7e5f260e23ee3433bf Mon Sep 17 00:00:00 2001 From: varunu28 Date: Thu, 13 Apr 2023 17:56:14 -0700 Subject: [PATCH 156/712] Updated Longest Palindromic Subsequence.java --- Medium/Longest Palindromic Subsequence.java | 47 +++++++++------------ 1 file changed, 19 insertions(+), 28 deletions(-) diff --git a/Medium/Longest Palindromic Subsequence.java b/Medium/Longest Palindromic Subsequence.java index 5d9d4dfd..85c6c5e7 100644 --- a/Medium/Longest Palindromic Subsequence.java +++ b/Medium/Longest Palindromic Subsequence.java @@ -1,34 +1,25 @@ class Solution { public int longestPalindromeSubseq(String s) { - int[][] temp = new int[s.length()][s.length()]; - for(int i=0;i endIdx) { + return 0; } - - int j; - - for (int cl=2;cl <= s.length();cl++) { - for (int i=0;i Date: Sat, 15 Apr 2023 07:38:01 -0700 Subject: [PATCH 157/712] Added Maximum Value of K Coins From Piles.java --- Hard/Maximum Value of K Coins From Piles.java | 20 +++++++++++++++++++ 1 file changed, 20 insertions(+) create mode 100644 Hard/Maximum Value of K Coins From Piles.java diff --git a/Hard/Maximum Value of K Coins From Piles.java b/Hard/Maximum Value of K Coins From Piles.java new file mode 100644 index 00000000..08fbc802 --- /dev/null +++ b/Hard/Maximum Value of K Coins From Piles.java @@ -0,0 +1,20 @@ +class Solution { + public int maxValueOfCoins(List> piles, int k) { + int n = piles.size(); + int[][] dp = new int[n + 1][k + 1]; + for (int i = 1; i <= n; i++) { + for (int coins = 0; coins <= k; coins++) { + int currSum = 0; + for (int currCoins = 0; + currCoins <= Math.min((int) piles.get(i - 1).size(), coins); + currCoins++) { + if (currCoins > 0) { + currSum += piles.get(i - 1).get(currCoins - 1); + } + dp[i][coins] = Math.max(dp[i][coins], dp[i - 1][coins - currCoins] + currSum); + } + } + } + return dp[n][k]; + } +} From 3dce5914f8a2e6d0ea088801e34c7c1ea4991679 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sun, 16 Apr 2023 08:17:40 -0700 Subject: [PATCH 158/712] Added Number of Ways to Form a Target String Given a Dictionary.java --- ...rm a Target String Given a Dictionary.java | 28 +++++++++++++++++++ 1 file changed, 28 insertions(+) create mode 100644 Hard/Number of Ways to Form a Target String Given a Dictionary.java diff --git a/Hard/Number of Ways to Form a Target String Given a Dictionary.java b/Hard/Number of Ways to Form a Target String Given a Dictionary.java new file mode 100644 index 00000000..a6354f1f --- /dev/null +++ b/Hard/Number of Ways to Form a Target String Given a Dictionary.java @@ -0,0 +1,28 @@ +class Solution { + + private static final int MOD = 1000_000_007; + + public int numWays(String[] words, String target) { + int m = target.length(); + int k = words[0].length(); + int[][] count = new int[26][k]; + for (int i = 0; i < k; i++) { + for (String word : words) { + count[word.charAt(i) - 'a'][i]++; + } + } + long[][] dp = new long[m + 1][k + 1]; + dp[0][0] = 1l; + for (int i = 0; i <= m; i++) { + for (int j = 0; j < k; j++) { + if (i < m) { + dp[i + 1][j + 1] += count[target.charAt(i) - 'a'][j] * dp[i][j]; + dp[i + 1][j + 1] %= MOD; + } + dp[i][j + 1] += dp[i][j]; + dp[i][j + 1] %= MOD; + } + } + return (int) dp[m][k]; + } +} From a102b912bc5ea4825ae8304e207846e6b6ff3982 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sun, 16 Apr 2023 08:26:36 -0700 Subject: [PATCH 159/712] Added Find the Width of Columns of a Grid.java --- Easy/Find the Width of Columns of a Grid.java | 13 +++++++++++++ 1 file changed, 13 insertions(+) create mode 100644 Easy/Find the Width of Columns of a Grid.java diff --git a/Easy/Find the Width of Columns of a Grid.java b/Easy/Find the Width of Columns of a Grid.java new file mode 100644 index 00000000..843813b9 --- /dev/null +++ b/Easy/Find the Width of Columns of a Grid.java @@ -0,0 +1,13 @@ +class Solution { + public int[] findColumnWidth(int[][] grid) { + int[] result = new int[grid[0].length]; + for (int i = 0; i < grid[0].length; i++) { + int maxLength = 0; + for (int j = 0; j < grid.length; j++) { + maxLength = Math.max(maxLength, String.valueOf(grid[j][i]).length()); + } + result[i] = maxLength; + } + return result; + } +} From 5201ec217eae6affc0e683fd8c66370f5c03ecbb Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sun, 16 Apr 2023 17:14:52 -0700 Subject: [PATCH 160/712] Updated Kids With the Greatest Number of Candies.java --- ...ids With the Greatest Number of Candies.java | 17 +++++++---------- 1 file changed, 7 insertions(+), 10 deletions(-) diff --git a/Easy/Kids With the Greatest Number of Candies.java b/Easy/Kids With the Greatest Number of Candies.java index 79789d90..67e2441d 100644 --- a/Easy/Kids With the Greatest Number of Candies.java +++ b/Easy/Kids With the Greatest Number of Candies.java @@ -1,13 +1,10 @@ class Solution { - public List kidsWithCandies(int[] candies, int extraCandies) { - int maxCandyCount = 0; - for (int candy : candies) { - maxCandyCount = Math.max(maxCandyCount, candy); + public List kidsWithCandies(int[] candies, int extraCandies) { + final int maxCandy = Arrays.stream(candies) + .max() + .orElse(0); + return Arrays.stream(candies) + .mapToObj(candy -> candy + extraCandies >= maxCandy) + .collect(Collectors.toList()); } - List result = new ArrayList<>(); - for (int candy : candies) { - result.add((candy + extraCandies) >= maxCandyCount); - } - return result; - } } From 73f6e1580b295618a806697790dbae7c6c32b500 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Mon, 17 Apr 2023 10:19:07 -0700 Subject: [PATCH 161/712] Create Row With Maximum Ones.java --- Easy/Row With Maximum Ones.java | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) create mode 100644 Easy/Row With Maximum Ones.java diff --git a/Easy/Row With Maximum Ones.java b/Easy/Row With Maximum Ones.java new file mode 100644 index 00000000..e1d32424 --- /dev/null +++ b/Easy/Row With Maximum Ones.java @@ -0,0 +1,17 @@ +class Solution { + public int[] rowAndMaximumOnes(int[][] mat) { + int maxOnes = 0; + int maxOnesRow = 0; + for (int i = 0; i < mat.length; i++) { + int oneCount = 0; + for (int num : mat[i]) { + oneCount += num == 1 ? 1 : 0; + } + if (oneCount > maxOnes) { + maxOnes = oneCount; + maxOnesRow = i; + } + } + return new int[]{maxOnesRow, maxOnes}; + } +} From a43654c560890c4c0ee66780a7c1da9a56389303 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Mon, 17 Apr 2023 10:24:42 -0700 Subject: [PATCH 162/712] Create Find the Score of All Prefixes of an Array.java --- ...d the Score of All Prefixes of an Array.java | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) create mode 100644 Medium/Find the Score of All Prefixes of an Array.java diff --git a/Medium/Find the Score of All Prefixes of an Array.java b/Medium/Find the Score of All Prefixes of an Array.java new file mode 100644 index 00000000..ff88ca98 --- /dev/null +++ b/Medium/Find the Score of All Prefixes of an Array.java @@ -0,0 +1,17 @@ +class Solution { + public long[] findPrefixScore(int[] nums) { + int[] conver = new int[nums.length]; + int max = nums[0]; + for (int i = 0; i < nums.length; i++) { + max = Math.max(max, nums[i]); + conver[i] = nums[i] + max; + } + long[] result = new long[nums.length]; + long score = 0; + for (int i = 0; i < nums.length; i++) { + score += conver[i]; + result[i] = score; + } + return result; + } +} From 2239630cc15d051a58ff0fba730d329607fa909b Mon Sep 17 00:00:00 2001 From: varunu28 Date: Mon, 17 Apr 2023 17:22:14 -0700 Subject: [PATCH 163/712] Updated Merge Strings Alternately.java --- Easy/Merge Strings Alternately.java | 29 +++++++++++++---------------- 1 file changed, 13 insertions(+), 16 deletions(-) diff --git a/Easy/Merge Strings Alternately.java b/Easy/Merge Strings Alternately.java index 65fb9904..7b851597 100644 --- a/Easy/Merge Strings Alternately.java +++ b/Easy/Merge Strings Alternately.java @@ -1,19 +1,16 @@ class Solution { - public String mergeAlternately(String word1, String word2) { - int idx1 = 0; - int idx2 = 0; - StringBuilder sb = new StringBuilder(); - boolean first = true; - while (idx1 < word1.length() && idx2 < word2.length()) { - sb.append(first ? word1.charAt(idx1++) : word2.charAt(idx2++)); - first = !first; + public String mergeAlternately(String word1, String word2) { + StringBuilder sb = new StringBuilder(); + int idxOne = 0; + int idxTwo = 0; + while (idxOne < word1.length() || idxTwo < word2.length()) { + if (idxOne < word1.length()) { + sb.append(word1.charAt(idxOne++)); + } + if (idxTwo < word2.length()) { + sb.append(word2.charAt(idxTwo++)); + } + } + return sb.toString(); } - while (idx1 < word1.length()) { - sb.append(word1.charAt(idx1++)); - } - while (idx2 < word2.length()) { - sb.append(word2.charAt(idx2++)); - } - return sb.toString(); - } } From fbc0111a75d33ae06cebb128620d24e609a778f7 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Tue, 18 Apr 2023 17:22:15 -0700 Subject: [PATCH 164/712] Updated Longest ZigZag Path in a Binary Tree.java --- .../Longest ZigZag Path in a Binary Tree.java | 52 +++++++++++-------- 1 file changed, 29 insertions(+), 23 deletions(-) diff --git a/Medium/Longest ZigZag Path in a Binary Tree.java b/Medium/Longest ZigZag Path in a Binary Tree.java index bdc3e8f9..71e32231 100644 --- a/Medium/Longest ZigZag Path in a Binary Tree.java +++ b/Medium/Longest ZigZag Path in a Binary Tree.java @@ -4,33 +4,39 @@ * int val; * TreeNode left; * TreeNode right; - * TreeNode(int x) { val = x; } + * TreeNode() {} + * TreeNode(int val) { this.val = val; } + * TreeNode(int val, TreeNode left, TreeNode right) { + * this.val = val; + * this.left = left; + * this.right = right; + * } * } */ class Solution { - int max; - public int longestZigZag(TreeNode root) { - if (root == null) { - return -1; + + private enum DIRECTION { + LEFT, RIGHT; } - max = 0; - helper(root.right, 1, true); - helper(root.left, 1, false); - return max; - } - - private void helper(TreeNode root, int step, boolean isRight) { - if (root == null) { - return; + + public int longestZigZag(TreeNode root) { + int[] pathLength = {0}; + dfs(root, DIRECTION.LEFT, 0, pathLength); + dfs(root, DIRECTION.RIGHT, 0, pathLength); + return pathLength[0]; } - max = Math.max(max, step); - if (isRight) { - helper(root.left, step + 1, false); - helper(root.right, 1, true); + + private void dfs(TreeNode node, DIRECTION direction, int steps, int[] pathLength) { + if (node == null) { + return; + } + pathLength[0] = Math.max(pathLength[0], steps); + if (direction == DIRECTION.LEFT) { + dfs(node.left, DIRECTION.RIGHT, steps + 1, pathLength); + dfs(node.right, DIRECTION.LEFT, 1, pathLength); + } else { + dfs(node.left, DIRECTION.RIGHT, 1, pathLength); + dfs(node.right, DIRECTION.LEFT, steps + 1, pathLength); + } } - else { - helper(root.right, step + 1, true); - helper(root.left, 1, false); - } - } } From 3e4377a9e34ebf03aedda62a6af92ee7ad4b4e89 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Thu, 20 Apr 2023 07:51:31 -0700 Subject: [PATCH 165/712] Updated Maximum Width of Binary Tree.java --- Medium/Maximum Width of Binary Tree.java | 51 +++++++++++------------- 1 file changed, 23 insertions(+), 28 deletions(-) diff --git a/Medium/Maximum Width of Binary Tree.java b/Medium/Maximum Width of Binary Tree.java index 3610e37d..d5edef7e 100644 --- a/Medium/Maximum Width of Binary Tree.java +++ b/Medium/Maximum Width of Binary Tree.java @@ -14,35 +14,30 @@ * } */ class Solution { - public int widthOfBinaryTree(TreeNode root) { - int maxWidth = 0; - Queue queue = new LinkedList<>(); - Map map = new HashMap<>(); - map.put(root, 1); - queue.add(root); - while (!queue.isEmpty()) { - int size = queue.size(); - int start = 0; - int end = 0; - for (int i = 0; i < size; i++) { - TreeNode node = queue.poll(); - if (i == 0) { - start = map.get(node); + public int widthOfBinaryTree(TreeNode root) { + if (root == null) { + return 0; } - if (i == size - 1) { - end = map.get(node); + Queue queue = new LinkedList<>(); + queue.add(new NodeColIndex(root, 0)); + int maxWidth = 0; + while (!queue.isEmpty()) { + NodeColIndex head = queue.peek(); + int levelSize = queue.size(); + for (int i = 0; i < levelSize; i++) { + NodeColIndex removed = queue.remove(); + TreeNode node = removed.node; + if (node.left != null) { + queue.add(new NodeColIndex(node.left, 2 * removed.colIdx)); + } + if (node.right != null) { + queue.add(new NodeColIndex(node.right, 2 * removed.colIdx + 1)); + } + maxWidth = Math.max(maxWidth, removed.colIdx - head.colIdx + 1); + } } - if (node.left != null) { - map.put(node.left, map.get(node) * 2); - queue.add(node.left); - } - if (node.right != null) { - map.put(node.right, map.get(node) * 2 + 1); - queue.add(node.right); - } - } - maxWidth = Math.max(maxWidth, end - start + 1); + return maxWidth; } - return maxWidth; - } + + private record NodeColIndex(TreeNode node, int colIdx) {} } From 699c847f02b498efa1696178f758e9b5db9fdaa5 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Thu, 20 Apr 2023 17:13:32 -0700 Subject: [PATCH 166/712] Create Profitable Schemes.java --- Hard/Profitable Schemes.java | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+) create mode 100644 Hard/Profitable Schemes.java diff --git a/Hard/Profitable Schemes.java b/Hard/Profitable Schemes.java new file mode 100644 index 00000000..7a1cabc4 --- /dev/null +++ b/Hard/Profitable Schemes.java @@ -0,0 +1,23 @@ +class Solution { + + private static final int MOD = 1000_000_007; + + public int profitableSchemes(int n, int minProfit, int[] group, int[] profit) { + Integer[][][] dp = new Integer[101][101][101]; + return helper(0, 0, 0, n, minProfit, group, profit, dp); + } + + private int helper(int pos, int count, int profit, int n, int minProfit, int[] group, int[] profits, Integer[][][] dp) { + if (pos == group.length) { + return profit >= minProfit ? 1 : 0; + } + if (dp[pos][count][profit] != null) { + return dp[pos][count][profit]; + } + int totalWays = helper(pos + 1, count, profit, n, minProfit, group, profits, dp); + if (count + group[pos] <= n) { + totalWays += helper(pos + 1, count + group[pos], Math.min(minProfit, profit + profits[pos]), n, minProfit, group, profits, dp); + } + return dp[pos][count][profit] = totalWays % MOD; + } +} From 2b7e3f0123b892d91688ef9ee93d84f84276e373 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Fri, 21 Apr 2023 06:16:26 -0700 Subject: [PATCH 167/712] Added Find the Maximum Divisibility Score.java --- .../Find the Maximum Divisibility Score.java | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) create mode 100644 Medium/Find the Maximum Divisibility Score.java diff --git a/Medium/Find the Maximum Divisibility Score.java b/Medium/Find the Maximum Divisibility Score.java new file mode 100644 index 00000000..2e33ee9a --- /dev/null +++ b/Medium/Find the Maximum Divisibility Score.java @@ -0,0 +1,19 @@ +class Solution { + public int maxDivScore(int[] nums, int[] divisors) { + int maxScore = -1; + int maxScoreCandidate = -1; + for (int divisor : divisors) { + int currScore = 0; + for (int num : nums) { + currScore += num % divisor == 0 ? 1 : 0; + } + if (currScore > maxScore) { + maxScore = currScore; + maxScoreCandidate = divisor; + } else if (currScore == maxScore) { + maxScoreCandidate = Math.min(maxScoreCandidate, divisor); + } + } + return maxScoreCandidate; + } +} From f2304067c2c542b3e3bdb519f6d2a62705cc9c2b Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Fri, 21 Apr 2023 14:23:14 -0700 Subject: [PATCH 168/712] Update Trapping Rain Water.java --- Hard/Trapping Rain Water.java | 40 ++++++++++++++++------------------- 1 file changed, 18 insertions(+), 22 deletions(-) diff --git a/Hard/Trapping Rain Water.java b/Hard/Trapping Rain Water.java index 8747d76b..263ab08a 100644 --- a/Hard/Trapping Rain Water.java +++ b/Hard/Trapping Rain Water.java @@ -1,27 +1,23 @@ class Solution { - public int trap(int[] height) { - int leftIdx = 0; - int rightIdx = height.length - 1; - int leftMax = 0; - int rightMax = 0; - int result = 0; - while (leftIdx < rightIdx) { - if (height[leftIdx] < height[rightIdx]) { - if (height[leftIdx] >= leftMax) { - leftMax = height[leftIdx]; - } else { - result += leftMax - height[leftIdx]; + public int trap(int[] height) { + if (height.length == 0) { + return 0; } - leftIdx++; - } else { - if (height[rightIdx] >= rightMax) { - rightMax = height[rightIdx]; - } else { - result += rightMax - height[rightIdx]; + int n = height.length; + int[] leftMax = new int[n]; + leftMax[0] = height[0]; + for (int i = 1; i < n; i++) { + leftMax[i] = Math.max(height[i], leftMax[i - 1]); } - rightIdx--; - } + int[] rightMax = new int[n]; + rightMax[n - 1] = height[n - 1]; + for (int i = n - 2; i >= 0; i--) { + rightMax[i] = Math.max(rightMax[i + 1], height[i]); + } + int result = 0; + for (int i = 1; i < n - 1; i++) { + result += Math.min(leftMax[i], rightMax[i]) - height[i]; + } + return result; } - return result; - } } From 5b31e8013879b0630a52847fde34409d4b492e6d Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sat, 22 Apr 2023 07:45:07 -0700 Subject: [PATCH 169/712] Create Minimum Insertion Steps to Make a String Palindrome.java --- ...ion Steps to Make a String Palindrome.java | 22 +++++++++++++++++++ 1 file changed, 22 insertions(+) create mode 100644 Hard/Minimum Insertion Steps to Make a String Palindrome.java diff --git a/Hard/Minimum Insertion Steps to Make a String Palindrome.java b/Hard/Minimum Insertion Steps to Make a String Palindrome.java new file mode 100644 index 00000000..3ffd2f07 --- /dev/null +++ b/Hard/Minimum Insertion Steps to Make a String Palindrome.java @@ -0,0 +1,22 @@ +class Solution { + public int minInsertions(String s) { + int n = s.length(); + return n - lcs(s, new StringBuilder(s).reverse().toString(), n, n); + } + + private int lcs(String s1, String s2, int m, int n) { + int[][] dp = new int[m + 1][n + 1]; + for (int i = 0; i <= m; i++) { + for (int j = 0; j <= n; j++) { + if (i == 0 || j == 0) { + dp[i][j] = 0; + } else if (s1.charAt(i - 1) == s2.charAt(j - 1)) { + dp[i][j] = dp[i - 1][j - 1] + 1; + } else { + dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]); + } + } + } + return dp[m][n]; + } +} From f3ffae5aa4cca3fefe4579592443150be48f6ab1 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sun, 23 Apr 2023 06:49:51 -0700 Subject: [PATCH 170/712] Added Restore The Array.java --- Hard/Restore The Array.java | 31 +++++++++++++++++++++++++++++++ 1 file changed, 31 insertions(+) create mode 100644 Hard/Restore The Array.java diff --git a/Hard/Restore The Array.java b/Hard/Restore The Array.java new file mode 100644 index 00000000..9b6ffc76 --- /dev/null +++ b/Hard/Restore The Array.java @@ -0,0 +1,31 @@ +class Solution { + + private static final int MOD = 1000_000_007; + + public int numberOfArrays(String s, int k) { + int n = s.length(); + int[] dp = new int[n + 1]; + return dfs(dp, 0, s, k); + } + + private int dfs(int[] dp, int start, String s, int k) { + if (dp[start] != 0) { + return dp[start]; + } + if (start == s.length()) { + return 1; + } + if (s.charAt(start) == '0') { + return 0; + } + int count = 0; + for (int end = start; end < s.length(); end++) { + String currNum = s.substring(start, end + 1); + if (Long.parseLong(currNum) > k) { + break; + } + count = (count + dfs(dp, end + 1, s, k)) % MOD; + } + return dp[start] = count; + } +} From db9a788061764ae30471659808fd59af3d03c475 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sun, 23 Apr 2023 06:53:00 -0700 Subject: [PATCH 171/712] Added Calculate Delayed Arrival Time.java --- Easy/Calculate Delayed Arrival Time.java | 6 ++++++ 1 file changed, 6 insertions(+) create mode 100644 Easy/Calculate Delayed Arrival Time.java diff --git a/Easy/Calculate Delayed Arrival Time.java b/Easy/Calculate Delayed Arrival Time.java new file mode 100644 index 00000000..47367e00 --- /dev/null +++ b/Easy/Calculate Delayed Arrival Time.java @@ -0,0 +1,6 @@ +class Solution { + public int findDelayedArrivalTime(int arrivalTime, int delayedTime) { + int newTime = arrivalTime + delayedTime; + return newTime - (newTime >= 24 ? 24 : 0); + } +} From 2e0f4ff134aceb372482c1382790b1b9c405468c Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sun, 23 Apr 2023 06:56:58 -0700 Subject: [PATCH 172/712] Added Sum Multiples.java --- Medium/Sum Multiples.java | 7 +++++++ 1 file changed, 7 insertions(+) create mode 100644 Medium/Sum Multiples.java diff --git a/Medium/Sum Multiples.java b/Medium/Sum Multiples.java new file mode 100644 index 00000000..59bfa012 --- /dev/null +++ b/Medium/Sum Multiples.java @@ -0,0 +1,7 @@ +class Solution { + public int sumOfMultiples(int n) { + return IntStream.rangeClosed(1, n) + .filter(value -> value % 3 == 0 || value % 5 == 0 || value % 7 == 0) + .sum(); + } +} From 9172a003269d65343caa90f3be7a5d10ba74a8f9 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sun, 23 Apr 2023 17:36:37 -0700 Subject: [PATCH 173/712] Updated Last Stone Weight.java --- Easy/Last Stone Weight.java | 26 +++++++++++++------------- 1 file changed, 13 insertions(+), 13 deletions(-) diff --git a/Easy/Last Stone Weight.java b/Easy/Last Stone Weight.java index 08f390b1..afb35b41 100644 --- a/Easy/Last Stone Weight.java +++ b/Easy/Last Stone Weight.java @@ -1,16 +1,16 @@ class Solution { - public int lastStoneWeight(int[] stones) { - PriorityQueue pq = new PriorityQueue<>((o1, o2) -> o2 - o1); - for (int stone : stones) { - pq.add(stone); + public int lastStoneWeight(int[] stones) { + PriorityQueue pq = new PriorityQueue<>((a, b) -> b - a); + for (int stone : stones) { + pq.add(stone); + } + while (pq.size() > 1) { + int stoneOne = pq.poll(); + int stoneTwo = pq.poll(); + if (stoneOne != stoneTwo) { + pq.add(stoneOne - stoneTwo); + } + } + return pq.isEmpty() ? 0 : pq.poll(); } - while (pq.size() > 1) { - int firstStone = pq.poll(); - int secondStone = pq.poll(); - if (firstStone != secondStone) { - pq.add(firstStone - secondStone); - } - } - return pq.isEmpty() ? 0 : pq.poll(); - } } From ea4c113b8c98bdbb0310e2ae11f03a9e3a447451 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Mon, 24 Apr 2023 12:32:55 -0700 Subject: [PATCH 174/712] Updated Sliding Window Maximum.java --- Hard/Sliding Window Maximum.java | 43 +++++++++++++++++--------------- 1 file changed, 23 insertions(+), 20 deletions(-) diff --git a/Hard/Sliding Window Maximum.java b/Hard/Sliding Window Maximum.java index c1ae146e..2aafc22d 100644 --- a/Hard/Sliding Window Maximum.java +++ b/Hard/Sliding Window Maximum.java @@ -1,23 +1,26 @@ class Solution { - public int[] maxSlidingWindow(int[] nums, int k) { - int n = nums.length; - if (n == 0 || k == 0) { - return new int[0]; + public int[] maxSlidingWindow(int[] nums, int k) { + int[] result = new int[nums.length - k + 1]; + int start = 0; + int end = 0; + Deque queue = new ArrayDeque<>(); + while (end < nums.length) { + // Remove elements from end of queue as long as the value at end of queue is less + // than the current value + while (!queue.isEmpty() && nums[queue.peekLast()] < nums[end]) { + queue.removeLast(); + } + queue.add(end); + // Remove the first element from the queue if we have already passed it in our range + if (start > queue.peekFirst()) { + queue.removeFirst(); + } + // Update result if our window is at least of size k + if (end + 1 >= k) { + result[start++] = nums[queue.peekFirst()]; + } + end++; + } + return result; } - int[] result = new int[n - k + 1]; - Deque deque = new ArrayDeque<>(); - for (int i = 0; i < n; i++) { - while (deque.size() > 0 && deque.peekFirst() <= i - k) { - deque.pollFirst(); - } - while (deque.size() > 0 && nums[deque.peekLast()] < nums[i]) { - deque.pollLast(); - } - deque.offerLast(i); - if (i >= k - 1) { - result[i -k + 1] = nums[deque.peekFirst()]; - } - } - return result; - } } From 48835931330cdefe460f8c8685c0a0d61384c4bc Mon Sep 17 00:00:00 2001 From: varunu28 Date: Mon, 24 Apr 2023 13:10:01 -0700 Subject: [PATCH 175/712] Updated Next Permutation.java --- Medium/Next Permutation.java | 54 ++++++++++++++++++------------------ 1 file changed, 27 insertions(+), 27 deletions(-) diff --git a/Medium/Next Permutation.java b/Medium/Next Permutation.java index 7b808969..b08a0001 100644 --- a/Medium/Next Permutation.java +++ b/Medium/Next Permutation.java @@ -1,31 +1,31 @@ class Solution { - public void nextPermutation(int[] nums) { - int idx = nums.length - 2; - while (idx >= 0 && nums[idx + 1] <= nums[idx]) { - idx--; + public void nextPermutation(int[] nums) { + int n = nums.length; + int pivot = n - 1; + // Find the first value where decreasing order doesn't holds + while (pivot > 0 && nums[pivot] <= nums[pivot - 1]) { + pivot--; + } + if (pivot != 0) { + int i = n - 1; + // Find the first value from right to left which is greater than element at + // pivot - 1 + while (nums[i] <= nums[pivot - 1]) { + i--; + } + swap(nums, pivot - 1, i); + } + // Reverse the complete array + int left = pivot; + int right = n - 1; + while (left < right) { + swap(nums, left++, right--); + } } - if (idx >= 0) { - int endIdx = nums.length - 1; - while (nums[endIdx] <= nums[idx]) { - endIdx--; - } - swap(nums, idx, endIdx); + + private void swap(int[] nums, int idxOne, int idxTwo) { + int temp = nums[idxOne]; + nums[idxOne] = nums[idxTwo]; + nums[idxTwo] = temp; } - reverse(nums, idx + 1); - } - - private void reverse(int[] nums, int startIdx) { - int endIdx = nums.length - 1; - while (startIdx < endIdx) { - swap(nums, startIdx, endIdx); - startIdx++; - endIdx--; - } - } - - private void swap(int[] nums, int i, int j) { - int temp = nums[i]; - nums[i] = nums[j]; - nums[j] = temp; - } } From 12612219c07351b29034b86190f1eff6c828e424 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Mon, 24 Apr 2023 13:28:46 -0700 Subject: [PATCH 176/712] Updated Task Scheduler.java --- Medium/Task Scheduler.java | 40 +++++++++++++++++++++++++------------- 1 file changed, 27 insertions(+), 13 deletions(-) diff --git a/Medium/Task Scheduler.java b/Medium/Task Scheduler.java index 558e1f77..0023aa9d 100644 --- a/Medium/Task Scheduler.java +++ b/Medium/Task Scheduler.java @@ -1,16 +1,30 @@ class Solution { - public int leastInterval(char[] tasks, int n) { - int[] frequencies = new int[26]; - for (char task : tasks) { - frequencies[task - 'A']++; + public int leastInterval(char[] tasks, int n) { + Map map = new HashMap<>(); + for (char c : tasks) { + map.put(c, map.getOrDefault(c, 0) + 1); + } + PriorityQueue pq = new PriorityQueue<>((a, b) -> b - a); + pq.addAll(map.values()); + int cycles = 0; + while (!pq.isEmpty()) { + List temp = new ArrayList<>(); + // Wait for one cooldown period and process one occurrence of all remaining tasks + for (int i = 0; i < n + 1; i++) { + if (!pq.isEmpty()) { + temp.add(pq.remove()); + } + } + // If task has more occurrences left then add it back to heap + for (int task : temp) { + if (task > 1) { + pq.add(task - 1); + } + } + // If heap is empty that means we finished all tasks and don't need to wait for + // the whole cooldown to finish else add one complete cooldown period + cycles += pq.isEmpty() ? temp.size() : n + 1; + } + return cycles; } - Arrays.sort(frequencies); - int maxFrequency = frequencies[25]; - int idleTime = (maxFrequency - 1) * n; - for (int i = frequencies.length - 2; i >= 0 && idleTime > 0; i--) { - idleTime -= Math.min(maxFrequency - 1, frequencies[i]); - } - idleTime = Math.max(0, idleTime); - return idleTime + tasks.length; - } } From d9847ba15c92bfbe20e875e9447ec8d029361162 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Mon, 24 Apr 2023 14:26:46 -0700 Subject: [PATCH 177/712] Added Alien Dictionary.java --- Hard/Alien Dictionary.java | 48 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 48 insertions(+) create mode 100644 Hard/Alien Dictionary.java diff --git a/Hard/Alien Dictionary.java b/Hard/Alien Dictionary.java new file mode 100644 index 00000000..939de634 --- /dev/null +++ b/Hard/Alien Dictionary.java @@ -0,0 +1,48 @@ +class Solution { + public String alienOrder(String[] words) { + Map> graph = new HashMap<>(); + for (String word : words) { + for (char c : word.toCharArray()) { + graph.computeIfAbsent(c, k -> new HashSet<>()); + } + } + for (int i = 0; i < words.length - 1; i++) { + String word1 = words[i]; + String word2 = words[i + 1]; + int minLength = Math.min(word1.length(), word2.length()); + if (word1.length() > word2.length() && word1.startsWith(word2)) { + return ""; + } + for (int j = 0; j < minLength; j++) { + if (word1.charAt(j) != word2.charAt(j)) { + graph.get(word1.charAt(j)).add(word2.charAt(j)); + break; + } + } + } + StringBuilder sb = new StringBuilder(); + Map visited = new HashMap<>(); + for (Character c : graph.keySet()) { + if (dfs(c, graph, sb, visited)) { + return ""; + } + } + return sb.reverse().toString(); + } + + private boolean dfs(Character c, Map> graph, + StringBuilder sb, Map visited) { + if (visited.containsKey(c)) { + return visited.get(c); + } + visited.put(c, true); + for (Character neighbor : graph.getOrDefault(c, new HashSet<>())) { + if (dfs(neighbor, graph, sb, visited)) { + return true; + } + } + visited.put(c, false); + sb.append(c); + return false; + } +} From 86947527a7e06fe4c34a556fc2d2a3365647cfa3 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Thu, 27 Apr 2023 06:49:48 -0700 Subject: [PATCH 178/712] Updated Minimum Window Subsequence.java --- Hard/Minimum Window Subsequence.java | 58 ++++++++++++++++------------ 1 file changed, 34 insertions(+), 24 deletions(-) diff --git a/Hard/Minimum Window Subsequence.java b/Hard/Minimum Window Subsequence.java index 88c2a006..d1a9b971 100644 --- a/Hard/Minimum Window Subsequence.java +++ b/Hard/Minimum Window Subsequence.java @@ -1,29 +1,39 @@ class Solution { - public String minWindow(String s1, String s2) { - String window = ""; - int j = 0; - int minLength = s1.length() + 1; - for (int i = 0; i < s1.length(); i++) { - if (s1.charAt(i) == s2.charAt(j)) { - j++; - if (j == s2.length()) { - int end = i + 1; - j--; - while (j >= 0) { - if (s1.charAt(i) == s2.charAt(j)) { - j--; + public String minWindow(String s1, String s2) { + int right = 0; + int minWindowLength = Integer.MAX_VALUE; + String result = ""; + while (right < s1.length()) { + int s2Idx = 0; + while (right < s1.length()) { + if (s1.charAt(right) == s2.charAt(s2Idx)) { + s2Idx++; + } + if (s2Idx == s2.length()) { + break; + } + right++; } - i--; - } - j++; - i++; - if (end - i < minLength) { - minLength = end - i; - window = s1.substring(i, end); - } + if (right == s1.length()) { + break; + } + int s1EndIdx = right; + int s2EndIdx = s2.length() - 1; + while (s1EndIdx >= 0) { + if (s1.charAt(s1EndIdx) == s2.charAt(s2EndIdx)) { + s2EndIdx--; + } + if (s2EndIdx < 0) { + break; + } + s1EndIdx--; + } + if (right - s1EndIdx + 1 < minWindowLength) { + minWindowLength = right - s1EndIdx + 1; + result = s1.substring(s1EndIdx, right + 1); + } + right = s1EndIdx + 1; } - } + return result; } - return window; - } } From 82b09798ab699ee6781d5f0e9fa55513a8a0942a Mon Sep 17 00:00:00 2001 From: varunu28 Date: Thu, 27 Apr 2023 18:09:01 -0700 Subject: [PATCH 179/712] Added Similar String Groups.java --- Hard/Similar String Groups.java | 51 +++++++++++++++++++++++++++++++++ 1 file changed, 51 insertions(+) create mode 100644 Hard/Similar String Groups.java diff --git a/Hard/Similar String Groups.java b/Hard/Similar String Groups.java new file mode 100644 index 00000000..50eb13d2 --- /dev/null +++ b/Hard/Similar String Groups.java @@ -0,0 +1,51 @@ +class Solution { + public int numSimilarGroups(String[] strs) { + int n = strs.length; + Map> graph = new HashMap<>(); + for (int i = 0; i < n; i++) { + for (int j = i + 1; j < n; j++) { + if (isSimilar(strs[i], strs[j])) { + graph.computeIfAbsent(i, k -> new ArrayList<>()).add(j); + graph.computeIfAbsent(j, k -> new ArrayList<>()).add(i); + } + } + } + boolean[] visited = new boolean[n]; + int count = 0; + for (int i = 0; i < n; i++) { + if (!visited[i]) { + bfs(i, graph, visited); + count++; + } + } + return count; + } + + private boolean isSimilar(String s1, String s2) { + int diff = 0; + for (int i = 0; i < s1.length(); i++) { + if (s1.charAt(i) != s2.charAt(i)) { + diff++; + } + } + return diff == 0 || diff == 2; + } + + private void bfs(int node, Map> graph, boolean[] visited) { + Queue queue = new LinkedList<>(); + queue.add(node); + visited[node] = true; + while (!queue.isEmpty()) { + node = queue.poll(); + if (!graph.containsKey(node)) { + continue; + } + for (int neighbor : graph.get(node)) { + if (!visited[neighbor]) { + visited[neighbor] = true; + queue.add(neighbor); + } + } + } + } +} From 23d28abb51e5417318918d1b10bfbd8aab3f59d8 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sat, 29 Apr 2023 07:32:47 -0700 Subject: [PATCH 180/712] Added Checking Existence of Edge Length Limited Paths.java --- ...xistence of Edge Length Limited Paths.java | 41 +++++++++++++++++++ 1 file changed, 41 insertions(+) create mode 100644 Hard/Checking Existence of Edge Length Limited Paths.java diff --git a/Hard/Checking Existence of Edge Length Limited Paths.java b/Hard/Checking Existence of Edge Length Limited Paths.java new file mode 100644 index 00000000..d03848ef --- /dev/null +++ b/Hard/Checking Existence of Edge Length Limited Paths.java @@ -0,0 +1,41 @@ +class Solution { + public boolean[] distanceLimitedPathsExist(int n, int[][] edgeList, int[][] queries) { + UnionFind unionFind = new UnionFind(n); + for (int i = 0; i < queries.length; i++) { + queries[i] = new int[]{queries[i][0], queries[i][1], queries[i][2], i}; + } + Arrays.sort(queries, Comparator.comparingInt(a -> a[2])); + Arrays.sort(edgeList, Comparator.comparingInt(a -> a[2])); + boolean[] result = new boolean[queries.length]; + for (int i = 0, j = 0; i < queries.length; i++) { + int[] query = queries[i]; + while (j < edgeList.length && edgeList[j][2] < query[2]) { + unionFind.union(edgeList[j][0], edgeList[j++][1]); + } + result[query[3]] = unionFind.find(query[0]) == unionFind.find(query[1]); + } + return result; + } + + private static class UnionFind { + private final int[] parent; + + public UnionFind(int n) { + this.parent = new int[n]; + for (int i = 0; i < n; i++) { + parent[i] = i; + } + } + + public int find(int node) { + if (parent[node] != node) { + parent[node] = find(parent[node]); + } + return parent[node]; + } + + public void union(int x, int y) { + parent[find(x)] = parent[find(y)]; + } + } +} From 0b1e882294cac31192762809e1c1c723d6475416 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sat, 29 Apr 2023 10:25:32 -0700 Subject: [PATCH 181/712] Added Maximum Sum With Exactly K Elements.java --- Easy/Maximum Sum With Exactly K Elements.java | 13 +++++++++++++ 1 file changed, 13 insertions(+) create mode 100644 Easy/Maximum Sum With Exactly K Elements.java diff --git a/Easy/Maximum Sum With Exactly K Elements.java b/Easy/Maximum Sum With Exactly K Elements.java new file mode 100644 index 00000000..ad738207 --- /dev/null +++ b/Easy/Maximum Sum With Exactly K Elements.java @@ -0,0 +1,13 @@ +class Solution { + public int maximizeSum(int[] nums, int k) { + int maxNum = 0; + for (int num : nums) { + maxNum = Math.max(num, maxNum); + } + int score = 0; + while (k-- > 0) { + score += maxNum++; + } + return score; + } +} From ece65cc705adc2f8c63839d22f8e29d26941b85f Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sat, 29 Apr 2023 10:28:31 -0700 Subject: [PATCH 182/712] Updated stats --- Easy/README.md | 1057 +++++++++++++++++---------------- Hard/README.md | 205 ++++--- Medium/README.md | 1483 +++++++++++++++++++++++----------------------- README.md | 8 +- 4 files changed, 1393 insertions(+), 1360 deletions(-) diff --git a/Easy/README.md b/Easy/README.md index 23f8ec11..d3b1e72e 100644 --- a/Easy/README.md +++ b/Easy/README.md @@ -39,527 +39,536 @@ S.no | Coding Problem 36 | [Build an Array With Stack Operations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Build%20an%20Array%20With%20Stack%20Operations.java) 37 | [Bulls and Cows](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Bulls%20and%20Cows.java) 38 | [Calculate Amount Paid in Taxes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Calculate%20Amount%20Paid%20in%20Taxes.java) -39 | [Calculate Digit Sum of a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Calculate%20Digit%20Sum%20of%20a%20String.java) -40 | [Calculate Money in Leetcode Bank](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Calculate%20Money%20in%20Leetcode%20Bank.java) -41 | [Can Make Arithmetic Progression From Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Can%20Make%20Arithmetic%20Progression%20From%20Sequence.java) -42 | [Can Place Flowers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Can%20Place%20Flowers.java) -43 | [Capitalize the Title](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Capitalize%20the%20Title.java) -44 | [Categorize Box According to Criteria](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Categorize%20Box%20According%20to%20Criteria.java) -45 | [Cells in a Range on an Excel Sheet](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Cells%20in%20a%20Range%20on%20an%20Excel%20Sheet.java) -46 | [Cells with Odd Values in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Cells%20with%20Odd%20Values%20in%20a%20Matrix.java) -47 | [Check Array Formation Through Concatenation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20Array%20Formation%20Through%20Concatenation.java) -48 | [Check Distances Between Same Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20Distances%20Between%20Same%20Letters.java) -49 | [Check If It Is a Straight Line](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20It%20Is%20a%20Straight%20Line.java) -50 | [Check If N and Its Double Exist](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20N%20and%20Its%20Double%20Exist.java) -51 | [Check If String Is a Prefix of Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20String%20Is%20a%20Prefix%20of%20Array.java) -52 | [Check If Two String Arrays are Equivalent](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20Two%20String%20Arrays%20are%20Equivalent.java) -53 | [Check If a Number Is Majority Element in a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20a%20Number%20Is%20Majority%20Element%20in%20a%20Sorted%20Array.java) -54 | [Check If a Word Occurs As a Prefix of Any Word in a Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20a%20Word%20Occurs%20As%20a%20Prefix%20of%20Any%20Word%20in%20a%20Sentence.java) -55 | [Check Whether Two Strings are Almost Equivalent](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20Whether%20Two%20Strings%20are%20Almost%20Equivalent.java) -56 | [Check if All A's Appears Before All B's](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20All%20A's%20Appears%20Before%20All%20B's.java) -57 | [Check if All Characters Have Equal Number of Occurrences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20All%20Characters%20Have%20Equal%20Number%20of%20Occurrences.java) -58 | [Check if All the Integers in a Range Are Covered](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20All%20the%20Integers%20in%20a%20Range%20Are%20Covered.java) -59 | [Check if Array Is Sorted and Rotated](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Array%20Is%20Sorted%20and%20Rotated.java) -60 | [Check if Binary String Has at Most One Segment of Ones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Binary%20String%20Has%20at%20Most%20One%20Segment%20of%20Ones.java) -61 | [Check if Every Row and Column Contains All Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Every%20Row%20and%20Column%20Contains%20All%20Numbers.java) -62 | [Check if Matrix Is X-Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Matrix%20Is%20X-Matrix.java) -63 | [Check if Number Has Equal Digit Count and Digit Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Number%20Has%20Equal%20Digit%20Count%20and%20Digit%20Value.java) -64 | [Check if Numbers Are Ascending in a Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Numbers%20Are%20Ascending%20in%20a%20Sentence.java) -65 | [Check if One String Swap Can Make Strings Equal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20One%20String%20Swap%20Can%20Make%20Strings%20Equal.java) -66 | [Check if String Is Decomposable Into Value-Equal Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20String%20Is%20Decomposable%20Into%20Value-Equal%20Substrings.java) -67 | [Check if Word Equals Summation of Two Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Word%20Equals%20Summation%20of%20Two%20Words.java) -68 | [Check if an Array Is Consecutive](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20an%20Array%20Is%20Consecutive.java) -69 | [Check if the Sentence Is Pangram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20the%20Sentence%20Is%20Pangram.java) -70 | [Circular Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Circular%20Sentence.java) -71 | [Climbing Stairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Climbing%20Stairs.java) -72 | [Closest Binary Search Tree Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Closest%20Binary%20Search%20Tree%20Value.java) -73 | [Compare Strings by Frequency of the Smallest Character](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Compare%20Strings%20by%20Frequency%20of%20the%20Smallest%20Character.java) -74 | [Complement of Base 10 Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Complement%20of%20Base%2010%20Integer.java) -75 | [Concatenation of Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Concatenation%20of%20Array.java) -76 | [Confusing Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Confusing%20Number.java) -77 | [Consecutive Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Consecutive%20Characters.java) -78 | [Construct String from Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Construct%20String%20from%20Binary%20Tree.java) -79 | [Construct the rectangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Construct%20the%20rectangle.java) -80 | [Contains Duplicate II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Contains%20Duplicate%20II.java) -81 | [Contains Duplicate](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Contains%20Duplicate.java) -82 | [Convert 1D Array Into 2D Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%201D%20Array%20Into%202D%20Array.java) -83 | [Convert BST to Greater Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%20BST%20to%20Greater%20Tree.java) -84 | [Convert Binary Number in a Linked List to Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%20Binary%20Number%20in%20a%20Linked%20List%20to%20Integer.java) -85 | [Convert Sorted Array To Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%20Sorted%20Array%20To%20Binary%20Search%20Tree.java) -86 | [Convert a number to hexadecimal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%20a%20number%20to%20hexadecimal.java) -87 | [Convert the Temperature](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%20the%20Temperature.java) -88 | [Count Asterisks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Asterisks.java) -89 | [Count Binary Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Binary%20Substrings.java) -90 | [Count Common Words With One Occurrence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Common%20Words%20With%20One%20Occurrence.java) -91 | [Count Distinct Numbers on Board](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Distinct%20Numbers%20on%20Board.java) -92 | [Count Elements With Strictly Smaller and Greater Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Elements%20With%20Strictly%20Smaller%20and%20Greater%20Elements.java) -93 | [Count Equal and Divisible Pairs in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Equal%20and%20Divisible%20Pairs%20in%20an%20Array.java) -94 | [Count Good Triplets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Good%20Triplets.java) -95 | [Count Hills and Valleys in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Hills%20and%20Valleys%20in%20an%20Array.java) -96 | [Count Integers With Even Digit Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Integers%20With%20Even%20Digit%20Sum.java) -97 | [Count Items Matching a Rule](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Items%20Matching%20a%20Rule.java) -98 | [Count Largest Group](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Largest%20Group.java) -99 | [Count Negative Numbers in a Sorted Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Negative%20Numbers%20in%20a%20Sorted%20Matrix.java) -100 | [Count Number of Pairs With Absolute Difference K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Number%20of%20Pairs%20With%20Absolute%20Difference%20K.java) -101 | [Count Odd Numbers in an Interval Range](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Odd%20Numbers%20in%20an%20Interval%20Range.java) -102 | [Count Operations to Obtain Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Operations%20to%20Obtain%20Zero.java) -103 | [Count Pairs Of Similar Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Pairs%20Of%20Similar%20Strings.java) -104 | [Count Prefixes of a Given String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Prefixes%20of%20a%20Given%20String.java) -105 | [Count Primes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Primes.java) -106 | [Count Special Quadruplets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Special%20Quadruplets.java) -107 | [Count Square Sum Triples](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Square%20Sum%20Triples.java) -108 | [Count Substrings with Only One Distinct Letter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Substrings%20with%20Only%20One%20Distinct%20Letter.java) -109 | [Count Vowel Substrings of a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Vowel%20Substrings%20of%20a%20String.java) -110 | [Count of Matches in Tournament](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20of%20Matches%20in%20Tournament.java) -111 | [Count the Digits That Divide a Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20the%20Digits%20That%20Divide%20a%20Number.java) -112 | [Count the Number of Consistent Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20the%20Number%20of%20Consistent%20Strings.java) -113 | [Count the Number of Vowel Strings in Range](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20the%20Number%20of%20Vowel%20Strings%20in%20Range.java) -114 | [Counting Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Counting%20Bits.java) -115 | [Counting Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Counting%20Elements.java) -116 | [Counting Words With a Given Prefix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Counting%20Words%20With%20a%20Given%20Prefix.java) -117 | [Cousins in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Cousins%20in%20Binary%20Tree.java) -118 | [Crawler Log Folder](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Crawler%20Log%20Folder.java) -119 | [Create Target Array in the Given Order](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Create%20Target%20Array%20in%20the%20Given%20Order.java) -120 | [DI String Match](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/DI%20String%20Match.java) -121 | [Day of the Week](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Day%20of%20the%20Week.java) -122 | [Day of the Year](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Day%20of%20the%20Year.java) -123 | [Decode XORed Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Decode%20XORed%20Array.java) -124 | [Decode the Message](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Decode%20the%20Message.java) -125 | [Decompress Run-Length Encoded List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Decompress%20Run-Length%20Encoded%20List.java) -126 | [Decrypt String from Alphabet to Integer Mapping](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Decrypt%20String%20from%20Alphabet%20to%20Integer%20Mapping.java) -127 | [Defanging an IP Address](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Defanging%20an%20IP%20Address.java) -128 | [Defuse the Bomb](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Defuse%20the%20Bomb.java) -129 | [Degree of an array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Degree%20of%20an%20array.java) -130 | [Delete Characters to Make Fancy String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20Characters%20to%20Make%20Fancy%20String.java) -131 | [Delete Columns to Make Sorted](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20Columns%20to%20Make%20Sorted.java) -132 | [Delete N Nodes After M Nodes of a Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20N%20Nodes%20After%20M%20Nodes%20of%20a%20Linked%20List.java) -133 | [Delete Node in a Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20Node%20in%20a%20Linked%20List.java) -134 | [Design Compressed String Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20Compressed%20String%20Iterator.java) -135 | [Design HashMap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20HashMap.java) -136 | [Design HashSet](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20HashSet.java) -137 | [Design Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20Linked%20List.java) -138 | [Design Parking System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20Parking%20System.java) -139 | [Design an Ordered Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20an%20Ordered%20Stream.java) -140 | [Design an Ordered System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20an%20Ordered%20System.java) -141 | [Destination City](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Destination%20City.java) -142 | [Detect Capital](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Detect%20Capital.java) -143 | [Detect Pattern of Length M Repeated K or More Times](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Detect%20Pattern%20of%20Length%20M%20Repeated%20K%20or%20More%20Times.java) -144 | [Determine Color of a Chessboard Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Determine%20Color%20of%20a%20Chessboard%20Square.java) -145 | [Determine Whether Matrix Can Be Obtained By Rotation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Determine%20Whether%20Matrix%20Can%20Be%20Obtained%20By%20Rotation.java) -146 | [Determine if String Halves Are Alike](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Determine%20if%20String%20Halves%20Are%20Alike.java) -147 | [Determine if Two Events Have Conflict](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Determine%20if%20Two%20Events%20Have%20Conflict.java) -148 | [Diameter of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Diameter%20of%20Binary%20Tree.java) -149 | [Diet Plan Performance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Diet%20Plan%20Performance.java) -150 | [Difference Between Element Sum and Digit Sum of an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Difference%20Between%20Element%20Sum%20and%20Digit%20Sum%20of%20an%20Array.java) -151 | [Distance Between Bus Stops](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Distance%20Between%20Bus%20Stops.java) -152 | [Distribute Candies to People](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Distribute%20Candies%20to%20People.java) -153 | [Distribute Candies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Distribute%20Candies.java) -154 | [Divide Array Into Equal Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Divide%20Array%20Into%20Equal%20Pairs.java) -155 | [Divide a String Into Groups of Size k](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Divide%20a%20String%20Into%20Groups%20of%20Size%20k.java) -156 | [Divisor Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Divisor%20Game.java) -157 | [Duplicate Zeros](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Duplicate%20Zeros.java) -158 | [Element Appearing More Than 25% In Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Element%20Appearing%20More%20Than%2025%%20In%20Sorted%20Array.java) -159 | [Employee Importance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Employee%20Importance.java) -160 | [Evaluate Boolean Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Evaluate%20Boolean%20Binary%20Tree.java) -161 | [Excel Sheet Column Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Excel%20Sheet%20Column%20Number.java) -162 | [Excel Sheet Column Title](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Excel%20Sheet%20Column%20Title.java) -163 | [Factorial Trailing Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Factorial%20Trailing%20Zeroes.java) -164 | [Fair Candy Swap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fair%20Candy%20Swap.java) -165 | [Fibonacci Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fibonacci%20Number.java) -166 | [Final Prices With a Special Discount in a Shop](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Final%20Prices%20With%20a%20Special%20Discount%20in%20a%20Shop.java) -167 | [Final Value of Variable After Performing Operations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Final%20Value%20of%20Variable%20After%20Performing%20Operations.java) -168 | [Find All K-Distant Indices in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20All%20K-Distant%20Indices%20in%20an%20Array.java) -169 | [Find All Numbers Disappeared in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20All%20Numbers%20Disappeared%20in%20an%20Array.java) -170 | [Find All the Lonely Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20All%20the%20Lonely%20Nodes.java) -171 | [Find Anagram Mappings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Anagram%20Mappings.java) -172 | [Find Closest Number to Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Closest%20Number%20to%20Zero.java) -173 | [Find Common Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Common%20Characters.java) -174 | [Find First Palindromic String in the Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20First%20Palindromic%20String%20in%20the%20Array.java) -175 | [Find Greatest Common Divisor of Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Greatest%20Common%20Divisor%20of%20Array.java) -176 | [Find Lucky Integer in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Lucky%20Integer%20in%20an%20Array.java) -177 | [Find Mode in Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Mode%20in%20Binary%20Search%20Tree.java) -178 | [Find N Unique Integers Sum up to Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20N%20Unique%20Integers%20Sum%20up%20to%20Zero.java) -179 | [Find Nearest Point That Has the Same X or Y Coordinate](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Nearest%20Point%20That%20Has%20the%20Same%20X%20or%20Y%20Coordinate.java) -180 | [Find Numbers with Even Number of Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Numbers%20with%20Even%20Number%20of%20Digits.java) -181 | [Find Pivot Index](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Pivot%20Index.java) -182 | [Find Positive Integer Solution for a Given Equation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Positive%20Integer%20Solution%20for%20a%20Given%20Equation.java) -183 | [Find Resultant Array After Removing Anagrams](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Resultant%20Array%20After%20Removing%20Anagrams.java) -184 | [Find Smallest Letter Greater Than Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Smallest%20Letter%20Greater%20Than%20Target.java) -185 | [Find Subarrays With Equal Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Subarrays%20With%20Equal%20Sum.java) -186 | [Find Target Indices After Sorting Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Target%20Indices%20After%20Sorting%20Array.java) -187 | [Find Winner on a Tic Tac Toe Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Winner%20on%20a%20Tic%20Tac%20Toe%20Game.java) -188 | [Find Words That Can Be Formed by Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Words%20That%20Can%20Be%20Formed%20by%20Characters.java) -189 | [Find if Path Exists in Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20if%20Path%20Exists%20in%20Graph.java) -190 | [Find the Array Concatenation Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Array%20Concatenation%20Value.java) -191 | [Find the Difference of Two Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Difference%20of%20Two%20Arrays.java) -192 | [Find the Distance Value Between Two Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Distance%20Value%20Between%20Two%20Arrays.java) -193 | [Find the Highest Altitude](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Highest%20Altitude.java) -194 | [Find the K-Beauty of a Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20K-Beauty%20of%20a%20Number.java) -195 | [Find the Middle Index in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Middle%20Index%20in%20Array.java) -196 | [Find the Town Judge](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Town%20Judge.java) -197 | [Find the difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20difference.java) -198 | [Finding 3-Digit Even Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Finding%203-Digit%20Even%20Numbers.java) -199 | [First Bad Version](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/First%20Bad%20Version.java) -200 | [First Letter to Appear Twice](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/First%20Letter%20to%20Appear%20Twice.java) -201 | [First Unique Character in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/First%20Unique%20Character%20in%20a%20String.java) -202 | [Fixed Point](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fixed%20Point.java) -203 | [Fizz Buzz](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fizz%20Buzz.java) -204 | [Flip Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flip%20Game.java) -205 | [Flipping an Image](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flipping%20an%20Image.java) -206 | [Flood Fill](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flood%20Fill.java) -207 | [Flower Planting With No Adjacent](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flower%20Planting%20With%20No%20Adjacent.java) -208 | [Generate a String With Characters That Have Odd Counts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Generate%20a%20String%20With%20Characters%20That%20Have%20Odd%20Counts.java) -209 | [Get Maximum in Generated Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Get%20Maximum%20in%20Generated%20Array.java) -210 | [Goal Parser Interpretation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Goal%20Parser%20Interpretation.java) -211 | [Goat Latin](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Goat%20Latin.java) -212 | [Greatest Common Divisor of Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Greatest%20Common%20Divisor%20of%20Strings.java) -213 | [Greatest English Letter in Upper and Lower Case](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Greatest%20English%20Letter%20in%20Upper%20and%20Lower%20Case.java) -214 | [Groups of Special-Equivalent Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Groups%20of%20Special-Equivalent%20Strings.java) -215 | [Guess Number Higher or Lower](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Guess%20Number%20Higher%20or%20Lower.java) -216 | [Hamming Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Hamming%20Distance.java) -217 | [Happy Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Happy%20Number.java) -218 | [Heaters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Heaters.java) -219 | [Height Checker](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Height%20Checker.java) -220 | [Hexspeak](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Hexspeak.java) -221 | [High Five](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/High%20Five.java) -222 | [How Many Apples Can You Put into the Basket](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/How%20Many%20Apples%20Can%20You%20Put%20into%20the%20Basket.java) -223 | [How Many Numbers Are Smaller Than the Current Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/How%20Many%20Numbers%20Are%20Smaller%20Than%20the%20Current%20Number.java) -224 | [Image Smoother](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Image%20Smoother.java) -225 | [Implement Queue using Stacks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Implement%20Queue%20using%20Stacks.java) -226 | [Implement Stack using Queues](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Implement%20Stack%20using%20Queues.java) -227 | [Implement strStr](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Implement%20strStr.java) -228 | [Increasing Decreasing String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Increasing%20Decreasing%20String.java) -229 | [Increasing Order Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Increasing%20Order%20Search%20Tree.java) -230 | [Index Pairs of a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Index%20Pairs%20of%20a%20String.java) -231 | [Intersection of Multiple Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20Multiple%20Arrays.java) -232 | [Intersection of Three Sorted Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20Three%20Sorted%20Arrays.java) -233 | [Intersection of Two Arrays II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20Two%20Arrays%20II.java) -234 | [Intersection of Two Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20Two%20Arrays.java) -235 | [Intersection of two Linked Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20two%20Linked%20Lists.java) -236 | [Invert Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Invert%20Binary%20Tree.java) -237 | [Is Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Is%20Subsequence.java) -238 | [Island Perimeter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Island%20Perimeter.java) -239 | [Isomorphic Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Isomorphic%20Strings.java) -240 | [Jewels and Stones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Jewels%20and%20Stones.java) -241 | [Judge Route Cycle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Judge%20Route%20Cycle.java) -242 | [K-diff Pairs in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/K-diff%20Pairs%20in%20an%20Array.java) -243 | [Keep Multiplying Found Values by Two](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Keep%20Multiplying%20Found%20Values%20by%20Two.java) -244 | [Keyboard Row](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Keyboard%20Row.java) -245 | [Kids With the Greatest Number of Candies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Kids%20With%20the%20Greatest%20Number%20of%20Candies.java) -246 | [Kth Distinct String in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Kth%20Distinct%20String%20in%20an%20Array.java) -247 | [Kth Largest Element in a Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Kth%20Largest%20Element%20in%20a%20Stream.java) -248 | [Kth Missing Positive Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Kth%20Missing%20Positive%20Number.java) -249 | [Largest 3-Same-Digit Number in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%203-Same-Digit%20Number%20in%20String.java) -250 | [Largest Local Values in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Local%20Values%20in%20a%20Matrix.java) -251 | [Largest Number After Digit Swaps by Parity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Number%20After%20Digit%20Swaps%20by%20Parity.java) -252 | [Largest Number At Least Twice of Others](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Number%20At%20Least%20Twice%20of%20Others.java) -253 | [Largest Odd Number in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Odd%20Number%20in%20String.java) -254 | [Largest Perimeter Triangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Perimeter%20Triangle.java) -255 | [Largest Positive Integer That Exists With Its Negative](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Positive%20Integer%20That%20Exists%20With%20Its%20Negative.java) -256 | [Largest Substring Between Two Equal Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Substring%20Between%20Two%20Equal%20Characters.java) -257 | [Largest Triangle Area](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Triangle%20Area.java) -258 | [Largest Unique Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Unique%20Number.java) -259 | [Last Stone Weight](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Last%20Stone%20Weight.java) -260 | [Latest Time by Replacing Hidden Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Latest%20Time%20by%20Replacing%20Hidden%20Digits.java) -261 | [Leaf-Similar Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Leaf-Similar%20Trees.java) -262 | [Left and Right Sum Differences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Left%20and%20Right%20Sum%20Differences.java) -263 | [Lemonade Change](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Lemonade%20Change.java) -264 | [Length of last word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Length%20of%20last%20word.java) -265 | [Letter Case Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Letter%20Case%20Permutation.java) -266 | [License Key Formatting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/License%20Key%20Formatting.java) -267 | [Linked List Cycle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Linked%20List%20Cycle.java) -268 | [Logger Rate Limiter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Logger%20Rate%20Limiter.java) -269 | [Long Pressed Name](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Long%20Pressed%20Name.java) -270 | [Longer Contiguous Segments of Ones than Zeros](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longer%20Contiguous%20Segments%20of%20Ones%20than%20Zeros.java) -271 | [Longest Common Prefix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Common%20Prefix.java) -272 | [Longest Continuous Increasing Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Continuous%20Increasing%20Subsequence.java) -273 | [Longest Harmonious Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Harmonious%20Subsequence.java) -274 | [Longest Nice Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Nice%20Substring.java) -275 | [Longest Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Palindrome.java) -276 | [Longest Subsequence With Limited Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Subsequence%20With%20Limited%20Sum.java) -277 | [Longest Uncommon Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Uncommon%20Subsequence.java) -278 | [Longest Univalue Path](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Univalue%20Path.java) -279 | [Longest Word in Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Word%20in%20Dictionary.java) -280 | [Lowest Common Ancestor of a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Lowest%20Common%20Ancestor%20of%20a%20Binary%20Search%20Tree.java) -281 | [Lucky Numbers in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Lucky%20Numbers%20in%20a%20Matrix.java) -282 | [Magic Squares In Grid](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Magic%20Squares%20In%20Grid.java) -283 | [Majority Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Majority%20Element.java) -284 | [Make Array Zero by Subtracting Equal Amounts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Make%20Array%20Zero%20by%20Subtracting%20Equal%20Amounts.java) -285 | [Make The String Great](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Make%20The%20String%20Great.java) -286 | [Matrix Cells in Distance Order](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Matrix%20Cells%20in%20Distance%20Order.java) -287 | [Matrix Diagonal Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Matrix%20Diagonal%20Sum.java) -288 | [Max Consecutive Ones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Max%20Consecutive%20Ones.java) -289 | [Maximize Sum Of Array After K Negations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximize%20Sum%20Of%20Array%20After%20K%20Negations.java) -290 | [Maximum 69 Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%2069%20Number.java) -291 | [Maximum Ascending Subarray Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Ascending%20Subarray%20Sum.java) -292 | [Maximum Average Subarray I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Average%20Subarray%20I.java) -293 | [Maximum Count of Positive Integer and Negative Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Count%20of%20Positive%20Integer%20and%20Negative%20Integer.java) -294 | [Maximum Depth of N-ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Depth%20of%20N-ary%20Tree.java) -295 | [Maximum Difference Between Increasing Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Difference%20Between%20Increasing%20Elements.java) -296 | [Maximum Difference by Remapping a Digit](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Difference%20by%20Remapping%20a%20Digit.java) -297 | [Maximum Distance in Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Distance%20in%20Arrays.java) -298 | [Maximum Enemy Forts That Can Be Captured](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Enemy%20Forts%20That%20Can%20Be%20Captured.java) -299 | [Maximum Nesting Depth of the Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Nesting%20Depth%20of%20the%20Parentheses.java) -300 | [Maximum Number of Balloons](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Balloons.java) -301 | [Maximum Number of Balls in a Box](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Balls%20in%20a%20Box.java) -302 | [Maximum Number of Pairs in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Pairs%20in%20Array.java) -303 | [Maximum Number of Words Found in Sentences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Words%20Found%20in%20Sentences.java) -304 | [Maximum Number of Words You Can Type](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Words%20You%20Can%20Type.java) -305 | [Maximum Population Year](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Population%20Year.java) -306 | [Maximum Product Difference Between Two Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Product%20Difference%20Between%20Two%20Pairs.java) -307 | [Maximum Product of Three Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Product%20of%20Three%20Numbers.java) -308 | [Maximum Product of Two Elements in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Product%20of%20Two%20Elements%20in%20an%20Array.java) -309 | [Maximum Repeating Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Repeating%20Substring.java) -310 | [Maximum Subarray Sum I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Subarray%20Sum%20I.java) -311 | [Maximum Units on a Truck](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Units%20on%20a%20Truck.java) -312 | [Maximum Value of a String in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Value%20of%20a%20String%20in%20an%20Array.java) -313 | [Maximum depth of Binary tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20depth%20of%20Binary%20tree.java) -314 | [Mean of Array After Removing Some Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Mean%20of%20Array%20After%20Removing%20Some%20Elements.java) -315 | [Meeting Rooms](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Meeting%20Rooms.java) -316 | [Merge Similar Items](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Similar%20Items.java) -317 | [Merge Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Sorted%20Array.java) -318 | [Merge Strings Alternately](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Strings%20Alternately.java) -319 | [Merge Two 2D Arrays by Summing Values](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Two%202D%20Arrays%20by%20Summing%20Values.java) -320 | [Merge Two Sorted Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Two%20Sorted%20Lists.java) -321 | [Merge two binary trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20two%20binary%20trees.java) -322 | [Middle of the linked list](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Middle%20of%20the%20linked%20list.java) -323 | [Min Cost Climbing Stairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Min%20Cost%20Climbing%20Stairs.java) -324 | [Min Max Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Min%20Max%20Game.java) -325 | [Minimum Absolute Difference in BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20%20Absolute%20Difference%20in%20BST.java) -326 | [Minimum Absolute Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Absolute%20Difference.java) -327 | [Minimum Amount of Time to Fill Cups](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Amount%20of%20Time%20to%20Fill%20Cups.java) -328 | [Minimum Bit Flips to Convert Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Bit%20Flips%20to%20Convert%20Number.java) -329 | [Minimum Changes To Make Alternating Binary String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Changes%20To%20Make%20Alternating%20Binary%20String.java) -330 | [Minimum Common Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Common%20Value.java) -331 | [Minimum Cost of Buying Candies With Discount](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Cost%20of%20Buying%20Candies%20With%20Discount.java) -332 | [Minimum Cost to Move Chips to The Same Position](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Cost%20to%20Move%20Chips%20to%20The%20Same%20Position.java) -333 | [Minimum Cuts to Divide a Circle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Cuts%20to%20Divide%20a%20Circle.java) -334 | [Minimum Depth of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Depth%20of%20a%20Binary%20Tree.java) -335 | [Minimum Difference Between Highest and Lowest of K Scores](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Difference%20Between%20Highest%20and%20Lowest%20of%20K%20Scores.java) -336 | [Minimum Distance Between BST Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Distance%20Between%20BST%20Nodes.java) -337 | [Minimum Distance to the Target Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Distance%20to%20the%20Target%20Element.java) -338 | [Minimum Hours of Training to Win a Competition](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Hours%20of%20Training%20to%20Win%20a%20Competition.java) -339 | [Minimum Index Sum of Two Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Index%20Sum%20of%20Two%20Lists.java) -340 | [Minimum Moves to Convert String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Moves%20to%20Convert%20String.java) -341 | [Minimum Moves to Equal an Array Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Moves%20to%20Equal%20an%20Array%20Element.java) -342 | [Minimum Number of Moves to Seat Everyone](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Number%20of%20Moves%20to%20Seat%20Everyone.java) -343 | [Minimum Number of Operations to Convert Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Number%20of%20Operations%20to%20Convert%20Time.java) -344 | [Minimum Operations to Make the Array Increasing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Operations%20to%20Make%20the%20Array%20Increasing.java) -345 | [Minimum Recolors to Get K Consecutive Black Blocks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Recolors%20to%20Get%20K%20Consecutive%20Black%20Blocks.java) -346 | [Minimum Subsequence in Non-Increasing Order](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Subsequence%20in%20Non-Increasing%20Order.java) -347 | [Minimum Sum of Four Digit Number After Splitting Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Sum%20of%20Four%20Digit%20Number%20After%20Splitting%20Digits.java) -348 | [Minimum Time Visiting All Points](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Time%20Visiting%20All%20Points.java) -349 | [Minimum Time to Type Word Using Special Typewriter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Time%20to%20Type%20Word%20Using%20Special%20Typewriter.java) -350 | [Minimum Value to Get Positive Step by Step Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Value%20to%20Get%20Positive%20Step%20by%20Step%20Sum.java) -351 | [Minimum_index_sum_of_two_lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum_index_sum_of_two_lists.java) -352 | [Missing Number In Arithmetic Progression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Missing%20Number%20In%20Arithmetic%20Progression.java) -353 | [Missing Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Missing%20Number.java) -354 | [Missing Ranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Missing%20Ranges.java) -355 | [Monotonic Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Monotonic%20Array.java) -356 | [Most Common Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Most%20Common%20Word.java) -357 | [Most Frequent Even Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Most%20Frequent%20Even%20Element.java) -358 | [Most Frequent Number Following Key In an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Most%20Frequent%20Number%20Following%20Key%20In%20an%20Array.java) -359 | [Most Visited Sector in a Circular Track](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Most%20Visited%20Sector%20in%20a%20Circular%20Track.java) -360 | [Move Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Move%20Zeroes.java) -361 | [Moving Average from Data Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Moving%20Average%20from%20Data%20Stream.java) -362 | [N-Repeated Element in Size 2N Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-Repeated%20Element%20in%20Size%202N%20Array.java) -363 | [N-ary Tree Postorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-ary%20Tree%20Postorder%20Traversal.java) -364 | [N-ary Tree Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-ary%20Tree%20Preorder%20Traversal.java) -365 | [N-th Tribonacci Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-th%20Tribonacci%20Number.java) -366 | [Nested List Weight Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Nested%20List%20Weight%20Sum.java) -367 | [Next Greater Element I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Next%20Greater%20Element%20I.java) -368 | [Next Greater Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Next%20Greater%20Element.java) -369 | [Nim Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Nim%20Game.java) -370 | [Number Complement](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20Complement.java) -371 | [Number Of Rectangles That Can Form The Largest Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20Of%20Rectangles%20That%20Can%20Form%20The%20Largest%20Square.java) -372 | [Number of 1 bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%201%20bits.java) -373 | [Number of Arithmetic Triplets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Arithmetic%20Triplets.java) -374 | [Number of Boomerangs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Boomerangs.java) -375 | [Number of Common Factors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Common%20Factors.java) -376 | [Number of Days Between Two Dates](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Days%20Between%20Two%20Dates.java) -377 | [Number of Days in a Month](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Days%20in%20a%20Month.java) -378 | [Number of Different Integers in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Different%20Integers%20in%20a%20String.java) -379 | [Number of Distinct Averages](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Distinct%20Averages.java) -380 | [Number of Equivalent Domino Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Equivalent%20Domino%20Pairs.java) -381 | [Number of Good Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Good%20Pairs.java) -382 | [Number of Lines To Write String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Lines%20To%20Write%20String.java) -383 | [Number of Recent Calls](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Recent%20Calls.java) -384 | [Number of Steps to Reduce a Number to Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Steps%20to%20Reduce%20a%20Number%20to%20Zero.java) -385 | [Number of Strings That Appear as Substrings in Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Strings%20That%20Appear%20as%20Substrings%20in%20Word.java) -386 | [Number of Students Doing Homework at a Given Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Students%20Doing%20Homework%20at%20a%20Given%20Time.java) -387 | [Number of Students Unable to Eat Lunch](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Students%20Unable%20to%20Eat%20Lunch.java) -388 | [Number of Unequal Triplets in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Unequal%20Triplets%20in%20Array.java) -389 | [Number of Valid Words in a Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Valid%20Words%20in%20a%20Sentence.java) -390 | [Number of segments in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20segments%20in%20a%20String.java) -391 | [Occurrences After Bigram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Occurrences%20After%20Bigram.java) -392 | [Odd String Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Odd%20String%20Difference.java) -393 | [Paint Fence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Paint%20Fence.java) -394 | [Paint House](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Paint%20House.java) -395 | [Pairs of Songs With Total Durations Divisible by 60](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Pairs%20of%20Songs%20With%20Total%20Durations%20Divisible%20by%2060.java) -396 | [Palindrome Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Palindrome%20Linked%20List.java) -397 | [Palindrome Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Palindrome%20Number.java) -398 | [Palindrome Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Palindrome%20Permutation.java) -399 | [Partition Array Into Three Parts With Equal Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Partition%20Array%20Into%20Three%20Parts%20With%20Equal%20Sum.java) -400 | [Pascal's Triangle II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Pascal's%20Triangle%20II.java) -401 | [Pascal's Triangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Pascal's%20Triangle.java) -402 | [Pass the Pillow](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Pass%20the%20Pillow.java) -403 | [Path Crossing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Path%20Crossing.java) -404 | [Path In Zigzag Labelled Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Path%20In%20Zigzag%20Labelled%20Binary%20Tree.java) -405 | [Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Path%20Sum.java) -406 | [Peak Index in a Mountain Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Peak%20Index%20in%20a%20Mountain%20Array.java) -407 | [Percentage of Letter in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Percentage%20of%20Letter%20in%20String.java) -408 | [Perfect Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Perfect%20Number.java) -409 | [Perform String Shifts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Perform%20String%20Shifts.java) -410 | [Plus One](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Plus%20One.java) -411 | [Positions of Large Groups](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Positions%20of%20Large%20Groups.java) -412 | [Power of Four](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Power%20of%20Four.java) -413 | [Power of Three](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Power%20of%20Three.java) -414 | [Power of Two](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Power%20of%20Two.java) -415 | [Powerful Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Powerful%20Integers.java) -416 | [Projection Area of 3D Shapes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Projection%20Area%20of%203D%20Shapes.java) -417 | [Range Sum Query Immutable](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Range%20Sum%20Query%20Immutable.java) -418 | [Range Sum of BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Range%20Sum%20of%20BST.java) -419 | [Rank Transform of an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rank%20Transform%20of%20an%20Array.java) -420 | [Ransom Note](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Ransom%20Note.java) -421 | [Read N characters Given Read4](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Read%20N%20characters%20Given%20Read4.java) -422 | [Rearrange Characters to Make Target String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rearrange%20Characters%20to%20Make%20Target%20String.java) -423 | [Rearrange Spaces Between Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rearrange%20Spaces%20Between%20Words.java) -424 | [Rectangle Overlap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rectangle%20Overlap.java) -425 | [Redistribute Characters to Make All Strings Equal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Redistribute%20Characters%20to%20Make%20All%20Strings%20Equal.java) -426 | [Reformat Date](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reformat%20Date.java) -427 | [Reformat Phone Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reformat%20Phone%20Number.java) -428 | [Reformat The String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reformat%20The%20String.java) -429 | [Relative Sort Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Relative%20Sort%20Array.java) -430 | [Relative ranks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Relative%20ranks.java) -431 | [Remove All Adjacent Duplicates In String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20All%20Adjacent%20Duplicates%20In%20String.java) -432 | [Remove Digit From Number to Maximize Result](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Digit%20From%20Number%20to%20Maximize%20Result.java) -433 | [Remove Duplicates From Sorted Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Duplicates%20From%20Sorted%20Lists.java) -434 | [Remove Duplicates from Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Duplicates%20from%20Sorted%20Array.java) -435 | [Remove Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Element.java) -436 | [Remove Letter To Equalize Frequency](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Letter%20To%20Equalize%20Frequency.java) -437 | [Remove Linked List Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Linked%20List%20Elements.java) -438 | [Remove One Element to Make the Array Strictly Increasing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20One%20Element%20to%20Make%20the%20Array%20Strictly%20Increasing.java) -439 | [Remove Outermost Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Outermost%20Parentheses.java) -440 | [Remove Palindromic Subsequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Palindromic%20Subsequences.java) -441 | [Remove Vowels from a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Vowels%20from%20a%20String.java) -442 | [Repeated String Match](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Repeated%20String%20Match.java) -443 | [Repeated Substring Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Repeated%20Substring%20Pattern.java) -444 | [Replace All ?'s to Avoid Consecutive Repeating Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Replace%20All%20?'s%20to%20Avoid%20Consecutive%20Repeating%20Characters.java) -445 | [Replace All Digits with Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Replace%20All%20Digits%20with%20Characters.java) -446 | [Replace Elements with Greatest Element on Right Side](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Replace%20Elements%20with%20Greatest%20Element%20on%20Right%20Side.java) -447 | [Reshape the matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reshape%20the%20matrix.java) -448 | [Reverse Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Bits.java) -449 | [Reverse Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Linked%20List.java) -450 | [Reverse Only Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Only%20Letters.java) -451 | [Reverse Prefix of Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Prefix%20of%20Word.java) -452 | [Reverse String II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20String%20II.java) -453 | [Reverse String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20String.java) -454 | [Reverse Vowels of a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Vowels%20of%20a%20String.java) -455 | [Reverse words in a String III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20words%20in%20a%20String%20III.java) -456 | [Richest Customer Wealth](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Richest%20Customer%20Wealth.java) -457 | [Rings and Rods](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rings%20and%20Rods.java) -458 | [Robot Return to Origin](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Robot%20Return%20to%20Origin.java) -459 | [Roman to Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Roman%20to%20Integer.java) -460 | [Root Equals Sum of Children](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Root%20Equals%20Sum%20of%20Children.java) -461 | [Rotate String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rotate%20String.java) -462 | [Running Sum of 1d Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Running%20Sum%20of%201d%20Array.java) -463 | [Same Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Same%20Tree.java) -464 | [Search Insert Position](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Search%20Insert%20Position.java) -465 | [Search in a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Search%20in%20a%20Binary%20Search%20Tree.java) -466 | [Second Largest Digit in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Second%20Largest%20Digit%20in%20a%20String.java) -467 | [Second Minimum Node in a binary tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Second%20Minimum%20Node%20in%20a%20binary%20tree.java) -468 | [Self Dividing Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Self%20Dividing%20Number.java) -469 | [Sentence Similarity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sentence%20Similarity.java) -470 | [Separate the Digits in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Separate%20the%20Digits%20in%20an%20Array.java) -471 | [Set Mismatch](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Set%20Mismatch.java) -472 | [Shortest Completing Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Completing%20Word.java) -473 | [Shortest Distance to Target String in a Circular Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Distance%20to%20Target%20String%20in%20a%20Circular%20Array.java) -474 | [Shortest Distance to a Character](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Distance%20to%20a%20Character.java) -475 | [Shortest Word Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Word%20Distance.java) -476 | [Shuffle String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shuffle%20String.java) -477 | [Shuffle the Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shuffle%20the%20Array.java) -478 | [Sign of the Product of an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sign%20of%20the%20Product%20of%20an%20Array.java) -479 | [Similar RGB Color](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Similar%20RGB%20Color.java) -480 | [Single Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Single%20Number.java) -481 | [Single-Row Keyboard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Single-Row%20Keyboard.java) -482 | [Slowest Key](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Slowest%20Key.java) -483 | [Smallest Even Multiple](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Smallest%20Even%20Multiple.java) -484 | [Smallest Index With Equal Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Smallest%20Index%20With%20Equal%20Value.java) -485 | [Smallest Range I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Smallest%20Range%20I.java) -486 | [Sort Array By Parity II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Array%20By%20Parity%20II.java) -487 | [Sort Array By Parity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Array%20By%20Parity.java) -488 | [Sort Array by Increasing Frequency](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Array%20by%20Increasing%20Frequency.java) -489 | [Sort Even and Odd Indices Independently](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Even%20and%20Odd%20Indices%20Independently.java) -490 | [Sort Integers by The Number of 1 Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Integers%20by%20The%20Number%20of%201%20Bits.java) -491 | [Sort the People](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20the%20People.java) -492 | [Sorting the Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sorting%20the%20Sentence.java) -493 | [Special Array With X Elements Greater Than or Equal X](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Special%20Array%20With%20X%20Elements%20Greater%20Than%20or%20Equal%20X.java) -494 | [Special Positions in a Binary Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Special%20Positions%20in%20a%20Binary%20Matrix.java) -495 | [Split With Minimum Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Split%20With%20Minimum%20Sum.java) -496 | [Split a String in Balanced Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Split%20a%20String%20in%20Balanced%20Strings.java) -497 | [SqrtX](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/SqrtX.java) -498 | [Squares of a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Squares%20of%20a%20Sorted%20Array.java) -499 | [String Matching in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/String%20Matching%20in%20an%20Array.java) -500 | [String Without AAA or BBB](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/String%20Without%20AAA%20or%20BBB.java) -501 | [Strobogrammatic Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Strobogrammatic%20Number.java) -502 | [Strong Password Checker II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Strong%20Password%20Checker%20II.java) -503 | [Student Attendance Record I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Student%20Attendance%20Record%20I.java) -504 | [Submission Detail](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Submission%20Detail.java) -505 | [Substrings of Size Three with Distinct Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Substrings%20of%20Size%20Three%20with%20Distinct%20Characters.java) -506 | [Subtract the Product and Sum of Digits of an Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Subtract%20the%20Product%20and%20Sum%20of%20Digits%20of%20an%20Integer.java) -507 | [Subtree of Another Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Subtree%20of%20Another%20Tree.java) -508 | [Sum Of Two Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20Of%20Two%20Integers.java) -509 | [Sum of All Odd Length Subarrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20All%20Odd%20Length%20Subarrays.java) -510 | [Sum of Digits in Base K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Digits%20in%20Base%20K.java) -511 | [Sum of Digits in the Minimum Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Digits%20in%20the%20Minimum%20Number.java) -512 | [Sum of Digits of String After Convert](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Digits%20of%20String%20After%20Convert.java) -513 | [Sum of Left Leaves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Left%20Leaves.java) -514 | [Sum of Root To Leaf Binary Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Root%20To%20Leaf%20Binary%20Numbers.java) -515 | [Sum of Square Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Square%20Numbers.java) -516 | [Sum of Unique Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Unique%20Elements.java) -517 | [Summary Ranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Summary%20Ranges.java) -518 | [Symmetric Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Symmetric%20Tree.java) -519 | [Take Gifts From the Richest Pile](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Take%20Gifts%20From%20the%20Richest%20Pile.java) -520 | [Teemo Attacking](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Teemo%20Attacking.java) -521 | [Teoplitz Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Teoplitz%20Matrix.java) -522 | [The Employee That Worked on the Longest Task](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/The%20Employee%20That%20Worked%20on%20the%20Longest%20Task.java) -523 | [The K Weakest Rows in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/The%20K%20Weakest%20Rows%20in%20a%20Matrix.java) -524 | [Third Maximum Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Third%20Maximum%20Number.java) -525 | [Thousand Separator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Thousand%20Separator.java) -526 | [Three Consecutive Odds](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Three%20Consecutive%20Odds.java) -527 | [Three Divisors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Three%20Divisors.java) -528 | [Time Needed to Buy Tickets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Time%20Needed%20to%20Buy%20Tickets.java) -529 | [To Lower Case](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/To%20Lower%20Case.java) -530 | [Toeplitz Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Toeplitz%20Matrix.java) -531 | [Transpose Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Transpose%20Matrix.java) -532 | [Truncate Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Truncate%20Sentence.java) -533 | [Two Furthest Houses With Different Colors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Furthest%20Houses%20With%20Different%20Colors.java) -534 | [Two Out of Three](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Out%20of%20Three.java) -535 | [Two Sum III - Data Structure Design](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum%20III%20-%20Data%20Structure%20Design.java) -536 | [Two Sum IV - Input is a BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum%20IV%20-%20Input%20is%20a%20BST.java) -537 | [Two Sum Less Than K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum%20Less%20Than%20K.java) -538 | [Two Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum.java) -539 | [Ugly Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Ugly%20Number.java) -540 | [Uncommon Words from Two Sentences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Uncommon%20Words%20from%20Two%20Sentences.java) -541 | [Unique Email Addresses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Unique%20Email%20Addresses.java) -542 | [Unique Morse Code Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Unique%20Morse%20Code%20Words.java) -543 | [Unique Number of Occurrences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Unique%20Number%20of%20Occurrences.java) -544 | [Univalued Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Univalued%20Binary%20Tree.java) -545 | [Valid Anagram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Anagram.java) -546 | [Valid Boomerang](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Boomerang.java) -547 | [Valid Mountain Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Mountain%20Array.java) -548 | [Valid Palindrome II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Palindrome%20II.java) -549 | [Valid Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Palindrome.java) -550 | [Valid Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Parentheses.java) -551 | [Valid Perfect Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Perfect%20Square.java) -552 | [Valid Word Abbreviation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Word%20Abbreviation.java) -553 | [Valid Word Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Word%20Sequence.java) -554 | [Valid Word Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Word%20Square.java) -555 | [Verifying an Alien Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Verifying%20an%20Alien%20Dictionary.java) -556 | [Water Bottles](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Water%20Bottles.java) -557 | [Word Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Word%20Pattern.java) -558 | [X of a Kind in a Deck of Cards](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/X%20of%20a%20Kind%20in%20a%20Deck%20of%20Cards.java) -559 | [XOR Operation in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/XOR%20Operation%20in%20an%20Array.java) -560 | [nim_game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/nim_game.java) -561 | [range_addition_II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/range_addition_II.java) -562 | [trailing_zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/trailing_zeroes.java) +39 | [Calculate Delayed Arrival Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Calculate%20Delayed%20Arrival%20Time.java) +40 | [Calculate Digit Sum of a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Calculate%20Digit%20Sum%20of%20a%20String.java) +41 | [Calculate Money in Leetcode Bank](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Calculate%20Money%20in%20Leetcode%20Bank.java) +42 | [Can Make Arithmetic Progression From Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Can%20Make%20Arithmetic%20Progression%20From%20Sequence.java) +43 | [Can Place Flowers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Can%20Place%20Flowers.java) +44 | [Capitalize the Title](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Capitalize%20the%20Title.java) +45 | [Categorize Box According to Criteria](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Categorize%20Box%20According%20to%20Criteria.java) +46 | [Cells in a Range on an Excel Sheet](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Cells%20in%20a%20Range%20on%20an%20Excel%20Sheet.java) +47 | [Cells with Odd Values in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Cells%20with%20Odd%20Values%20in%20a%20Matrix.java) +48 | [Check Array Formation Through Concatenation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20Array%20Formation%20Through%20Concatenation.java) +49 | [Check Distances Between Same Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20Distances%20Between%20Same%20Letters.java) +50 | [Check If It Is a Straight Line](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20It%20Is%20a%20Straight%20Line.java) +51 | [Check If N and Its Double Exist](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20N%20and%20Its%20Double%20Exist.java) +52 | [Check If String Is a Prefix of Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20String%20Is%20a%20Prefix%20of%20Array.java) +53 | [Check If Two String Arrays are Equivalent](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20Two%20String%20Arrays%20are%20Equivalent.java) +54 | [Check If a Number Is Majority Element in a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20a%20Number%20Is%20Majority%20Element%20in%20a%20Sorted%20Array.java) +55 | [Check If a Word Occurs As a Prefix of Any Word in a Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20a%20Word%20Occurs%20As%20a%20Prefix%20of%20Any%20Word%20in%20a%20Sentence.java) +56 | [Check Whether Two Strings are Almost Equivalent](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20Whether%20Two%20Strings%20are%20Almost%20Equivalent.java) +57 | [Check if All A's Appears Before All B's](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20All%20A's%20Appears%20Before%20All%20B's.java) +58 | [Check if All Characters Have Equal Number of Occurrences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20All%20Characters%20Have%20Equal%20Number%20of%20Occurrences.java) +59 | [Check if All the Integers in a Range Are Covered](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20All%20the%20Integers%20in%20a%20Range%20Are%20Covered.java) +60 | [Check if Array Is Sorted and Rotated](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Array%20Is%20Sorted%20and%20Rotated.java) +61 | [Check if Binary String Has at Most One Segment of Ones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Binary%20String%20Has%20at%20Most%20One%20Segment%20of%20Ones.java) +62 | [Check if Every Row and Column Contains All Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Every%20Row%20and%20Column%20Contains%20All%20Numbers.java) +63 | [Check if Matrix Is X-Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Matrix%20Is%20X-Matrix.java) +64 | [Check if Number Has Equal Digit Count and Digit Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Number%20Has%20Equal%20Digit%20Count%20and%20Digit%20Value.java) +65 | [Check if Numbers Are Ascending in a Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Numbers%20Are%20Ascending%20in%20a%20Sentence.java) +66 | [Check if One String Swap Can Make Strings Equal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20One%20String%20Swap%20Can%20Make%20Strings%20Equal.java) +67 | [Check if String Is Decomposable Into Value-Equal Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20String%20Is%20Decomposable%20Into%20Value-Equal%20Substrings.java) +68 | [Check if Word Equals Summation of Two Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Word%20Equals%20Summation%20of%20Two%20Words.java) +69 | [Check if an Array Is Consecutive](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20an%20Array%20Is%20Consecutive.java) +70 | [Check if the Sentence Is Pangram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20the%20Sentence%20Is%20Pangram.java) +71 | [Circular Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Circular%20Sentence.java) +72 | [Climbing Stairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Climbing%20Stairs.java) +73 | [Closest Binary Search Tree Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Closest%20Binary%20Search%20Tree%20Value.java) +74 | [Compare Strings by Frequency of the Smallest Character](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Compare%20Strings%20by%20Frequency%20of%20the%20Smallest%20Character.java) +75 | [Complement of Base 10 Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Complement%20of%20Base%2010%20Integer.java) +76 | [Concatenation of Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Concatenation%20of%20Array.java) +77 | [Confusing Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Confusing%20Number.java) +78 | [Consecutive Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Consecutive%20Characters.java) +79 | [Construct String from Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Construct%20String%20from%20Binary%20Tree.java) +80 | [Construct the rectangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Construct%20the%20rectangle.java) +81 | [Contains Duplicate II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Contains%20Duplicate%20II.java) +82 | [Contains Duplicate](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Contains%20Duplicate.java) +83 | [Convert 1D Array Into 2D Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%201D%20Array%20Into%202D%20Array.java) +84 | [Convert BST to Greater Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%20BST%20to%20Greater%20Tree.java) +85 | [Convert Binary Number in a Linked List to Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%20Binary%20Number%20in%20a%20Linked%20List%20to%20Integer.java) +86 | [Convert Sorted Array To Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%20Sorted%20Array%20To%20Binary%20Search%20Tree.java) +87 | [Convert a number to hexadecimal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%20a%20number%20to%20hexadecimal.java) +88 | [Convert the Temperature](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%20the%20Temperature.java) +89 | [Count Asterisks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Asterisks.java) +90 | [Count Binary Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Binary%20Substrings.java) +91 | [Count Common Words With One Occurrence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Common%20Words%20With%20One%20Occurrence.java) +92 | [Count Distinct Numbers on Board](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Distinct%20Numbers%20on%20Board.java) +93 | [Count Elements With Strictly Smaller and Greater Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Elements%20With%20Strictly%20Smaller%20and%20Greater%20Elements.java) +94 | [Count Equal and Divisible Pairs in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Equal%20and%20Divisible%20Pairs%20in%20an%20Array.java) +95 | [Count Good Triplets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Good%20Triplets.java) +96 | [Count Hills and Valleys in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Hills%20and%20Valleys%20in%20an%20Array.java) +97 | [Count Integers With Even Digit Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Integers%20With%20Even%20Digit%20Sum.java) +98 | [Count Items Matching a Rule](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Items%20Matching%20a%20Rule.java) +99 | [Count Largest Group](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Largest%20Group.java) +100 | [Count Negative Numbers in a Sorted Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Negative%20Numbers%20in%20a%20Sorted%20Matrix.java) +101 | [Count Number of Pairs With Absolute Difference K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Number%20of%20Pairs%20With%20Absolute%20Difference%20K.java) +102 | [Count Odd Numbers in an Interval Range](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Odd%20Numbers%20in%20an%20Interval%20Range.java) +103 | [Count Operations to Obtain Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Operations%20to%20Obtain%20Zero.java) +104 | [Count Pairs Of Similar Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Pairs%20Of%20Similar%20Strings.java) +105 | [Count Prefixes of a Given String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Prefixes%20of%20a%20Given%20String.java) +106 | [Count Primes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Primes.java) +107 | [Count Special Quadruplets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Special%20Quadruplets.java) +108 | [Count Square Sum Triples](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Square%20Sum%20Triples.java) +109 | [Count Substrings with Only One Distinct Letter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Substrings%20with%20Only%20One%20Distinct%20Letter.java) +110 | [Count Vowel Substrings of a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Vowel%20Substrings%20of%20a%20String.java) +111 | [Count of Matches in Tournament](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20of%20Matches%20in%20Tournament.java) +112 | [Count the Digits That Divide a Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20the%20Digits%20That%20Divide%20a%20Number.java) +113 | [Count the Number of Consistent Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20the%20Number%20of%20Consistent%20Strings.java) +114 | [Count the Number of Vowel Strings in Range](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20the%20Number%20of%20Vowel%20Strings%20in%20Range.java) +115 | [Counting Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Counting%20Bits.java) +116 | [Counting Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Counting%20Elements.java) +117 | [Counting Words With a Given Prefix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Counting%20Words%20With%20a%20Given%20Prefix.java) +118 | [Cousins in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Cousins%20in%20Binary%20Tree.java) +119 | [Crawler Log Folder](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Crawler%20Log%20Folder.java) +120 | [Create Target Array in the Given Order](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Create%20Target%20Array%20in%20the%20Given%20Order.java) +121 | [DI String Match](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/DI%20String%20Match.java) +122 | [Day of the Week](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Day%20of%20the%20Week.java) +123 | [Day of the Year](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Day%20of%20the%20Year.java) +124 | [Decode XORed Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Decode%20XORed%20Array.java) +125 | [Decode the Message](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Decode%20the%20Message.java) +126 | [Decompress Run-Length Encoded List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Decompress%20Run-Length%20Encoded%20List.java) +127 | [Decrypt String from Alphabet to Integer Mapping](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Decrypt%20String%20from%20Alphabet%20to%20Integer%20Mapping.java) +128 | [Defanging an IP Address](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Defanging%20an%20IP%20Address.java) +129 | [Defuse the Bomb](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Defuse%20the%20Bomb.java) +130 | [Degree of an array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Degree%20of%20an%20array.java) +131 | [Delete Characters to Make Fancy String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20Characters%20to%20Make%20Fancy%20String.java) +132 | [Delete Columns to Make Sorted](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20Columns%20to%20Make%20Sorted.java) +133 | [Delete N Nodes After M Nodes of a Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20N%20Nodes%20After%20M%20Nodes%20of%20a%20Linked%20List.java) +134 | [Delete Node in a Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20Node%20in%20a%20Linked%20List.java) +135 | [Design Compressed String Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20Compressed%20String%20Iterator.java) +136 | [Design HashMap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20HashMap.java) +137 | [Design HashSet](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20HashSet.java) +138 | [Design Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20Linked%20List.java) +139 | [Design Parking System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20Parking%20System.java) +140 | [Design an Ordered Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20an%20Ordered%20Stream.java) +141 | [Design an Ordered System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20an%20Ordered%20System.java) +142 | [Destination City](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Destination%20City.java) +143 | [Detect Capital](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Detect%20Capital.java) +144 | [Detect Pattern of Length M Repeated K or More Times](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Detect%20Pattern%20of%20Length%20M%20Repeated%20K%20or%20More%20Times.java) +145 | [Determine Color of a Chessboard Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Determine%20Color%20of%20a%20Chessboard%20Square.java) +146 | [Determine Whether Matrix Can Be Obtained By Rotation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Determine%20Whether%20Matrix%20Can%20Be%20Obtained%20By%20Rotation.java) +147 | [Determine if String Halves Are Alike](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Determine%20if%20String%20Halves%20Are%20Alike.java) +148 | [Determine if Two Events Have Conflict](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Determine%20if%20Two%20Events%20Have%20Conflict.java) +149 | [Diameter of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Diameter%20of%20Binary%20Tree.java) +150 | [Diet Plan Performance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Diet%20Plan%20Performance.java) +151 | [Difference Between Element Sum and Digit Sum of an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Difference%20Between%20Element%20Sum%20and%20Digit%20Sum%20of%20an%20Array.java) +152 | [Distance Between Bus Stops](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Distance%20Between%20Bus%20Stops.java) +153 | [Distribute Candies to People](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Distribute%20Candies%20to%20People.java) +154 | [Distribute Candies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Distribute%20Candies.java) +155 | [Distribute Money to Maximum Children](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Distribute%20Money%20to%20Maximum%20Children.java) +156 | [Divide Array Into Equal Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Divide%20Array%20Into%20Equal%20Pairs.java) +157 | [Divide a String Into Groups of Size k](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Divide%20a%20String%20Into%20Groups%20of%20Size%20k.java) +158 | [Divisor Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Divisor%20Game.java) +159 | [Duplicate Zeros](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Duplicate%20Zeros.java) +160 | [Element Appearing More Than 25% In Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Element%20Appearing%20More%20Than%2025%%20In%20Sorted%20Array.java) +161 | [Employee Importance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Employee%20Importance.java) +162 | [Evaluate Boolean Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Evaluate%20Boolean%20Binary%20Tree.java) +163 | [Excel Sheet Column Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Excel%20Sheet%20Column%20Number.java) +164 | [Excel Sheet Column Title](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Excel%20Sheet%20Column%20Title.java) +165 | [Factorial Trailing Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Factorial%20Trailing%20Zeroes.java) +166 | [Fair Candy Swap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fair%20Candy%20Swap.java) +167 | [Fibonacci Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fibonacci%20Number.java) +168 | [Final Prices With a Special Discount in a Shop](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Final%20Prices%20With%20a%20Special%20Discount%20in%20a%20Shop.java) +169 | [Final Value of Variable After Performing Operations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Final%20Value%20of%20Variable%20After%20Performing%20Operations.java) +170 | [Find All K-Distant Indices in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20All%20K-Distant%20Indices%20in%20an%20Array.java) +171 | [Find All Numbers Disappeared in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20All%20Numbers%20Disappeared%20in%20an%20Array.java) +172 | [Find All the Lonely Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20All%20the%20Lonely%20Nodes.java) +173 | [Find Anagram Mappings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Anagram%20Mappings.java) +174 | [Find Closest Number to Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Closest%20Number%20to%20Zero.java) +175 | [Find Common Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Common%20Characters.java) +176 | [Find First Palindromic String in the Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20First%20Palindromic%20String%20in%20the%20Array.java) +177 | [Find Greatest Common Divisor of Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Greatest%20Common%20Divisor%20of%20Array.java) +178 | [Find Lucky Integer in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Lucky%20Integer%20in%20an%20Array.java) +179 | [Find Mode in Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Mode%20in%20Binary%20Search%20Tree.java) +180 | [Find N Unique Integers Sum up to Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20N%20Unique%20Integers%20Sum%20up%20to%20Zero.java) +181 | [Find Nearest Point That Has the Same X or Y Coordinate](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Nearest%20Point%20That%20Has%20the%20Same%20X%20or%20Y%20Coordinate.java) +182 | [Find Numbers with Even Number of Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Numbers%20with%20Even%20Number%20of%20Digits.java) +183 | [Find Pivot Index](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Pivot%20Index.java) +184 | [Find Positive Integer Solution for a Given Equation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Positive%20Integer%20Solution%20for%20a%20Given%20Equation.java) +185 | [Find Resultant Array After Removing Anagrams](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Resultant%20Array%20After%20Removing%20Anagrams.java) +186 | [Find Smallest Letter Greater Than Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Smallest%20Letter%20Greater%20Than%20Target.java) +187 | [Find Subarrays With Equal Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Subarrays%20With%20Equal%20Sum.java) +188 | [Find Target Indices After Sorting Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Target%20Indices%20After%20Sorting%20Array.java) +189 | [Find Winner on a Tic Tac Toe Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Winner%20on%20a%20Tic%20Tac%20Toe%20Game.java) +190 | [Find Words That Can Be Formed by Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Words%20That%20Can%20Be%20Formed%20by%20Characters.java) +191 | [Find if Path Exists in Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20if%20Path%20Exists%20in%20Graph.java) +192 | [Find the Array Concatenation Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Array%20Concatenation%20Value.java) +193 | [Find the Difference of Two Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Difference%20of%20Two%20Arrays.java) +194 | [Find the Distance Value Between Two Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Distance%20Value%20Between%20Two%20Arrays.java) +195 | [Find the Highest Altitude](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Highest%20Altitude.java) +196 | [Find the K-Beauty of a Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20K-Beauty%20of%20a%20Number.java) +197 | [Find the Longest Balanced Substring of a Binary String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Longest%20Balanced%20Substring%20of%20a%20Binary%20String.java) +198 | [Find the Middle Index in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Middle%20Index%20in%20Array.java) +199 | [Find the Town Judge](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Town%20Judge.java) +200 | [Find the Width of Columns of a Grid](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Width%20of%20Columns%20of%20a%20Grid.java) +201 | [Find the difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20difference.java) +202 | [Finding 3-Digit Even Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Finding%203-Digit%20Even%20Numbers.java) +203 | [First Bad Version](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/First%20Bad%20Version.java) +204 | [First Letter to Appear Twice](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/First%20Letter%20to%20Appear%20Twice.java) +205 | [First Unique Character in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/First%20Unique%20Character%20in%20a%20String.java) +206 | [Fixed Point](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fixed%20Point.java) +207 | [Fizz Buzz](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fizz%20Buzz.java) +208 | [Flip Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flip%20Game.java) +209 | [Flipping an Image](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flipping%20an%20Image.java) +210 | [Flood Fill](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flood%20Fill.java) +211 | [Flower Planting With No Adjacent](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flower%20Planting%20With%20No%20Adjacent.java) +212 | [Form Smallest Number From Two Digit Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Form%20Smallest%20Number%20From%20Two%20Digit%20Arrays.java) +213 | [Generate a String With Characters That Have Odd Counts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Generate%20a%20String%20With%20Characters%20That%20Have%20Odd%20Counts.java) +214 | [Get Maximum in Generated Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Get%20Maximum%20in%20Generated%20Array.java) +215 | [Goal Parser Interpretation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Goal%20Parser%20Interpretation.java) +216 | [Goat Latin](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Goat%20Latin.java) +217 | [Greatest Common Divisor of Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Greatest%20Common%20Divisor%20of%20Strings.java) +218 | [Greatest English Letter in Upper and Lower Case](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Greatest%20English%20Letter%20in%20Upper%20and%20Lower%20Case.java) +219 | [Groups of Special-Equivalent Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Groups%20of%20Special-Equivalent%20Strings.java) +220 | [Guess Number Higher or Lower](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Guess%20Number%20Higher%20or%20Lower.java) +221 | [Hamming Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Hamming%20Distance.java) +222 | [Happy Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Happy%20Number.java) +223 | [Heaters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Heaters.java) +224 | [Height Checker](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Height%20Checker.java) +225 | [Hexspeak](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Hexspeak.java) +226 | [High Five](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/High%20Five.java) +227 | [How Many Apples Can You Put into the Basket](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/How%20Many%20Apples%20Can%20You%20Put%20into%20the%20Basket.java) +228 | [How Many Numbers Are Smaller Than the Current Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/How%20Many%20Numbers%20Are%20Smaller%20Than%20the%20Current%20Number.java) +229 | [Image Smoother](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Image%20Smoother.java) +230 | [Implement Queue using Stacks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Implement%20Queue%20using%20Stacks.java) +231 | [Implement Stack using Queues](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Implement%20Stack%20using%20Queues.java) +232 | [Implement strStr](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Implement%20strStr.java) +233 | [Increasing Decreasing String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Increasing%20Decreasing%20String.java) +234 | [Increasing Order Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Increasing%20Order%20Search%20Tree.java) +235 | [Index Pairs of a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Index%20Pairs%20of%20a%20String.java) +236 | [Intersection of Multiple Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20Multiple%20Arrays.java) +237 | [Intersection of Three Sorted Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20Three%20Sorted%20Arrays.java) +238 | [Intersection of Two Arrays II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20Two%20Arrays%20II.java) +239 | [Intersection of Two Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20Two%20Arrays.java) +240 | [Intersection of two Linked Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20two%20Linked%20Lists.java) +241 | [Invert Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Invert%20Binary%20Tree.java) +242 | [Is Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Is%20Subsequence.java) +243 | [Island Perimeter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Island%20Perimeter.java) +244 | [Isomorphic Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Isomorphic%20Strings.java) +245 | [Jewels and Stones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Jewels%20and%20Stones.java) +246 | [Judge Route Cycle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Judge%20Route%20Cycle.java) +247 | [K Items With the Maximum Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/K%20Items%20With%20the%20Maximum%20Sum.java) +248 | [K-diff Pairs in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/K-diff%20Pairs%20in%20an%20Array.java) +249 | [Keep Multiplying Found Values by Two](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Keep%20Multiplying%20Found%20Values%20by%20Two.java) +250 | [Keyboard Row](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Keyboard%20Row.java) +251 | [Kids With the Greatest Number of Candies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Kids%20With%20the%20Greatest%20Number%20of%20Candies.java) +252 | [Kth Distinct String in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Kth%20Distinct%20String%20in%20an%20Array.java) +253 | [Kth Largest Element in a Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Kth%20Largest%20Element%20in%20a%20Stream.java) +254 | [Kth Missing Positive Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Kth%20Missing%20Positive%20Number.java) +255 | [Largest 3-Same-Digit Number in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%203-Same-Digit%20Number%20in%20String.java) +256 | [Largest Local Values in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Local%20Values%20in%20a%20Matrix.java) +257 | [Largest Number After Digit Swaps by Parity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Number%20After%20Digit%20Swaps%20by%20Parity.java) +258 | [Largest Number At Least Twice of Others](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Number%20At%20Least%20Twice%20of%20Others.java) +259 | [Largest Odd Number in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Odd%20Number%20in%20String.java) +260 | [Largest Perimeter Triangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Perimeter%20Triangle.java) +261 | [Largest Positive Integer That Exists With Its Negative](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Positive%20Integer%20That%20Exists%20With%20Its%20Negative.java) +262 | [Largest Substring Between Two Equal Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Substring%20Between%20Two%20Equal%20Characters.java) +263 | [Largest Triangle Area](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Triangle%20Area.java) +264 | [Largest Unique Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Unique%20Number.java) +265 | [Last Stone Weight](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Last%20Stone%20Weight.java) +266 | [Latest Time by Replacing Hidden Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Latest%20Time%20by%20Replacing%20Hidden%20Digits.java) +267 | [Leaf-Similar Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Leaf-Similar%20Trees.java) +268 | [Left and Right Sum Differences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Left%20and%20Right%20Sum%20Differences.java) +269 | [Lemonade Change](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Lemonade%20Change.java) +270 | [Length of last word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Length%20of%20last%20word.java) +271 | [Letter Case Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Letter%20Case%20Permutation.java) +272 | [License Key Formatting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/License%20Key%20Formatting.java) +273 | [Linked List Cycle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Linked%20List%20Cycle.java) +274 | [Logger Rate Limiter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Logger%20Rate%20Limiter.java) +275 | [Long Pressed Name](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Long%20Pressed%20Name.java) +276 | [Longer Contiguous Segments of Ones than Zeros](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longer%20Contiguous%20Segments%20of%20Ones%20than%20Zeros.java) +277 | [Longest Common Prefix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Common%20Prefix.java) +278 | [Longest Continuous Increasing Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Continuous%20Increasing%20Subsequence.java) +279 | [Longest Harmonious Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Harmonious%20Subsequence.java) +280 | [Longest Nice Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Nice%20Substring.java) +281 | [Longest Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Palindrome.java) +282 | [Longest Subsequence With Limited Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Subsequence%20With%20Limited%20Sum.java) +283 | [Longest Uncommon Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Uncommon%20Subsequence.java) +284 | [Longest Univalue Path](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Univalue%20Path.java) +285 | [Longest Word in Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Word%20in%20Dictionary.java) +286 | [Lowest Common Ancestor of a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Lowest%20Common%20Ancestor%20of%20a%20Binary%20Search%20Tree.java) +287 | [Lucky Numbers in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Lucky%20Numbers%20in%20a%20Matrix.java) +288 | [Magic Squares In Grid](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Magic%20Squares%20In%20Grid.java) +289 | [Majority Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Majority%20Element.java) +290 | [Make Array Zero by Subtracting Equal Amounts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Make%20Array%20Zero%20by%20Subtracting%20Equal%20Amounts.java) +291 | [Make The String Great](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Make%20The%20String%20Great.java) +292 | [Matrix Cells in Distance Order](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Matrix%20Cells%20in%20Distance%20Order.java) +293 | [Matrix Diagonal Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Matrix%20Diagonal%20Sum.java) +294 | [Max Consecutive Ones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Max%20Consecutive%20Ones.java) +295 | [Maximize Sum Of Array After K Negations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximize%20Sum%20Of%20Array%20After%20K%20Negations.java) +296 | [Maximum 69 Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%2069%20Number.java) +297 | [Maximum Ascending Subarray Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Ascending%20Subarray%20Sum.java) +298 | [Maximum Average Subarray I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Average%20Subarray%20I.java) +299 | [Maximum Count of Positive Integer and Negative Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Count%20of%20Positive%20Integer%20and%20Negative%20Integer.java) +300 | [Maximum Depth of N-ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Depth%20of%20N-ary%20Tree.java) +301 | [Maximum Difference Between Increasing Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Difference%20Between%20Increasing%20Elements.java) +302 | [Maximum Difference by Remapping a Digit](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Difference%20by%20Remapping%20a%20Digit.java) +303 | [Maximum Distance in Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Distance%20in%20Arrays.java) +304 | [Maximum Enemy Forts That Can Be Captured](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Enemy%20Forts%20That%20Can%20Be%20Captured.java) +305 | [Maximum Nesting Depth of the Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Nesting%20Depth%20of%20the%20Parentheses.java) +306 | [Maximum Number of Balloons](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Balloons.java) +307 | [Maximum Number of Balls in a Box](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Balls%20in%20a%20Box.java) +308 | [Maximum Number of Pairs in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Pairs%20in%20Array.java) +309 | [Maximum Number of Words Found in Sentences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Words%20Found%20in%20Sentences.java) +310 | [Maximum Number of Words You Can Type](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Words%20You%20Can%20Type.java) +311 | [Maximum Population Year](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Population%20Year.java) +312 | [Maximum Product Difference Between Two Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Product%20Difference%20Between%20Two%20Pairs.java) +313 | [Maximum Product of Three Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Product%20of%20Three%20Numbers.java) +314 | [Maximum Product of Two Elements in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Product%20of%20Two%20Elements%20in%20an%20Array.java) +315 | [Maximum Repeating Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Repeating%20Substring.java) +316 | [Maximum Subarray Sum I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Subarray%20Sum%20I.java) +317 | [Maximum Sum With Exactly K Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Sum%20With%20Exactly%20K%20Elements.java) +318 | [Maximum Units on a Truck](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Units%20on%20a%20Truck.java) +319 | [Maximum Value of a String in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Value%20of%20a%20String%20in%20an%20Array.java) +320 | [Maximum depth of Binary tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20depth%20of%20Binary%20tree.java) +321 | [Mean of Array After Removing Some Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Mean%20of%20Array%20After%20Removing%20Some%20Elements.java) +322 | [Meeting Rooms](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Meeting%20Rooms.java) +323 | [Merge Similar Items](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Similar%20Items.java) +324 | [Merge Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Sorted%20Array.java) +325 | [Merge Strings Alternately](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Strings%20Alternately.java) +326 | [Merge Two 2D Arrays by Summing Values](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Two%202D%20Arrays%20by%20Summing%20Values.java) +327 | [Merge Two Sorted Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Two%20Sorted%20Lists.java) +328 | [Merge two binary trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20two%20binary%20trees.java) +329 | [Middle of the linked list](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Middle%20of%20the%20linked%20list.java) +330 | [Min Cost Climbing Stairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Min%20Cost%20Climbing%20Stairs.java) +331 | [Min Max Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Min%20Max%20Game.java) +332 | [Minimum Absolute Difference in BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20%20Absolute%20Difference%20in%20BST.java) +333 | [Minimum Absolute Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Absolute%20Difference.java) +334 | [Minimum Amount of Time to Fill Cups](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Amount%20of%20Time%20to%20Fill%20Cups.java) +335 | [Minimum Bit Flips to Convert Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Bit%20Flips%20to%20Convert%20Number.java) +336 | [Minimum Changes To Make Alternating Binary String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Changes%20To%20Make%20Alternating%20Binary%20String.java) +337 | [Minimum Common Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Common%20Value.java) +338 | [Minimum Cost of Buying Candies With Discount](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Cost%20of%20Buying%20Candies%20With%20Discount.java) +339 | [Minimum Cost to Move Chips to The Same Position](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Cost%20to%20Move%20Chips%20to%20The%20Same%20Position.java) +340 | [Minimum Cuts to Divide a Circle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Cuts%20to%20Divide%20a%20Circle.java) +341 | [Minimum Depth of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Depth%20of%20a%20Binary%20Tree.java) +342 | [Minimum Difference Between Highest and Lowest of K Scores](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Difference%20Between%20Highest%20and%20Lowest%20of%20K%20Scores.java) +343 | [Minimum Distance Between BST Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Distance%20Between%20BST%20Nodes.java) +344 | [Minimum Distance to the Target Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Distance%20to%20the%20Target%20Element.java) +345 | [Minimum Hours of Training to Win a Competition](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Hours%20of%20Training%20to%20Win%20a%20Competition.java) +346 | [Minimum Index Sum of Two Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Index%20Sum%20of%20Two%20Lists.java) +347 | [Minimum Moves to Convert String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Moves%20to%20Convert%20String.java) +348 | [Minimum Moves to Equal an Array Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Moves%20to%20Equal%20an%20Array%20Element.java) +349 | [Minimum Number of Moves to Seat Everyone](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Number%20of%20Moves%20to%20Seat%20Everyone.java) +350 | [Minimum Number of Operations to Convert Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Number%20of%20Operations%20to%20Convert%20Time.java) +351 | [Minimum Operations to Make the Array Increasing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Operations%20to%20Make%20the%20Array%20Increasing.java) +352 | [Minimum Recolors to Get K Consecutive Black Blocks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Recolors%20to%20Get%20K%20Consecutive%20Black%20Blocks.java) +353 | [Minimum Subsequence in Non-Increasing Order](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Subsequence%20in%20Non-Increasing%20Order.java) +354 | [Minimum Sum of Four Digit Number After Splitting Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Sum%20of%20Four%20Digit%20Number%20After%20Splitting%20Digits.java) +355 | [Minimum Time Visiting All Points](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Time%20Visiting%20All%20Points.java) +356 | [Minimum Time to Type Word Using Special Typewriter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Time%20to%20Type%20Word%20Using%20Special%20Typewriter.java) +357 | [Minimum Value to Get Positive Step by Step Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Value%20to%20Get%20Positive%20Step%20by%20Step%20Sum.java) +358 | [Minimum_index_sum_of_two_lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum_index_sum_of_two_lists.java) +359 | [Missing Number In Arithmetic Progression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Missing%20Number%20In%20Arithmetic%20Progression.java) +360 | [Missing Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Missing%20Number.java) +361 | [Missing Ranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Missing%20Ranges.java) +362 | [Monotonic Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Monotonic%20Array.java) +363 | [Most Common Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Most%20Common%20Word.java) +364 | [Most Frequent Even Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Most%20Frequent%20Even%20Element.java) +365 | [Most Frequent Number Following Key In an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Most%20Frequent%20Number%20Following%20Key%20In%20an%20Array.java) +366 | [Most Visited Sector in a Circular Track](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Most%20Visited%20Sector%20in%20a%20Circular%20Track.java) +367 | [Move Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Move%20Zeroes.java) +368 | [Moving Average from Data Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Moving%20Average%20from%20Data%20Stream.java) +369 | [N-Repeated Element in Size 2N Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-Repeated%20Element%20in%20Size%202N%20Array.java) +370 | [N-ary Tree Postorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-ary%20Tree%20Postorder%20Traversal.java) +371 | [N-ary Tree Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-ary%20Tree%20Preorder%20Traversal.java) +372 | [N-th Tribonacci Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-th%20Tribonacci%20Number.java) +373 | [Nested List Weight Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Nested%20List%20Weight%20Sum.java) +374 | [Next Greater Element I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Next%20Greater%20Element%20I.java) +375 | [Next Greater Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Next%20Greater%20Element.java) +376 | [Nim Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Nim%20Game.java) +377 | [Number Complement](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20Complement.java) +378 | [Number Of Rectangles That Can Form The Largest Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20Of%20Rectangles%20That%20Can%20Form%20The%20Largest%20Square.java) +379 | [Number of 1 bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%201%20bits.java) +380 | [Number of Arithmetic Triplets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Arithmetic%20Triplets.java) +381 | [Number of Boomerangs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Boomerangs.java) +382 | [Number of Common Factors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Common%20Factors.java) +383 | [Number of Days Between Two Dates](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Days%20Between%20Two%20Dates.java) +384 | [Number of Days in a Month](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Days%20in%20a%20Month.java) +385 | [Number of Different Integers in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Different%20Integers%20in%20a%20String.java) +386 | [Number of Distinct Averages](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Distinct%20Averages.java) +387 | [Number of Equivalent Domino Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Equivalent%20Domino%20Pairs.java) +388 | [Number of Good Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Good%20Pairs.java) +389 | [Number of Lines To Write String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Lines%20To%20Write%20String.java) +390 | [Number of Recent Calls](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Recent%20Calls.java) +391 | [Number of Steps to Reduce a Number to Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Steps%20to%20Reduce%20a%20Number%20to%20Zero.java) +392 | [Number of Strings That Appear as Substrings in Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Strings%20That%20Appear%20as%20Substrings%20in%20Word.java) +393 | [Number of Students Doing Homework at a Given Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Students%20Doing%20Homework%20at%20a%20Given%20Time.java) +394 | [Number of Students Unable to Eat Lunch](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Students%20Unable%20to%20Eat%20Lunch.java) +395 | [Number of Unequal Triplets in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Unequal%20Triplets%20in%20Array.java) +396 | [Number of Valid Words in a Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Valid%20Words%20in%20a%20Sentence.java) +397 | [Number of segments in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20segments%20in%20a%20String.java) +398 | [Occurrences After Bigram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Occurrences%20After%20Bigram.java) +399 | [Odd String Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Odd%20String%20Difference.java) +400 | [Paint Fence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Paint%20Fence.java) +401 | [Paint House](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Paint%20House.java) +402 | [Pairs of Songs With Total Durations Divisible by 60](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Pairs%20of%20Songs%20With%20Total%20Durations%20Divisible%20by%2060.java) +403 | [Palindrome Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Palindrome%20Linked%20List.java) +404 | [Palindrome Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Palindrome%20Number.java) +405 | [Palindrome Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Palindrome%20Permutation.java) +406 | [Partition Array Into Three Parts With Equal Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Partition%20Array%20Into%20Three%20Parts%20With%20Equal%20Sum.java) +407 | [Pascal's Triangle II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Pascal's%20Triangle%20II.java) +408 | [Pascal's Triangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Pascal's%20Triangle.java) +409 | [Pass the Pillow](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Pass%20the%20Pillow.java) +410 | [Path Crossing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Path%20Crossing.java) +411 | [Path In Zigzag Labelled Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Path%20In%20Zigzag%20Labelled%20Binary%20Tree.java) +412 | [Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Path%20Sum.java) +413 | [Peak Index in a Mountain Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Peak%20Index%20in%20a%20Mountain%20Array.java) +414 | [Percentage of Letter in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Percentage%20of%20Letter%20in%20String.java) +415 | [Perfect Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Perfect%20Number.java) +416 | [Perform String Shifts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Perform%20String%20Shifts.java) +417 | [Plus One](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Plus%20One.java) +418 | [Positions of Large Groups](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Positions%20of%20Large%20Groups.java) +419 | [Power of Four](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Power%20of%20Four.java) +420 | [Power of Three](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Power%20of%20Three.java) +421 | [Power of Two](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Power%20of%20Two.java) +422 | [Powerful Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Powerful%20Integers.java) +423 | [Prime In Diagonal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Prime%20In%20Diagonal.java) +424 | [Projection Area of 3D Shapes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Projection%20Area%20of%203D%20Shapes.java) +425 | [Range Sum Query Immutable](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Range%20Sum%20Query%20Immutable.java) +426 | [Range Sum of BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Range%20Sum%20of%20BST.java) +427 | [Rank Transform of an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rank%20Transform%20of%20an%20Array.java) +428 | [Ransom Note](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Ransom%20Note.java) +429 | [Read N characters Given Read4](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Read%20N%20characters%20Given%20Read4.java) +430 | [Rearrange Characters to Make Target String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rearrange%20Characters%20to%20Make%20Target%20String.java) +431 | [Rearrange Spaces Between Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rearrange%20Spaces%20Between%20Words.java) +432 | [Rectangle Overlap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rectangle%20Overlap.java) +433 | [Redistribute Characters to Make All Strings Equal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Redistribute%20Characters%20to%20Make%20All%20Strings%20Equal.java) +434 | [Reformat Date](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reformat%20Date.java) +435 | [Reformat Phone Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reformat%20Phone%20Number.java) +436 | [Reformat The String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reformat%20The%20String.java) +437 | [Relative Sort Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Relative%20Sort%20Array.java) +438 | [Relative ranks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Relative%20ranks.java) +439 | [Remove All Adjacent Duplicates In String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20All%20Adjacent%20Duplicates%20In%20String.java) +440 | [Remove Digit From Number to Maximize Result](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Digit%20From%20Number%20to%20Maximize%20Result.java) +441 | [Remove Duplicates From Sorted Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Duplicates%20From%20Sorted%20Lists.java) +442 | [Remove Duplicates from Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Duplicates%20from%20Sorted%20Array.java) +443 | [Remove Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Element.java) +444 | [Remove Letter To Equalize Frequency](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Letter%20To%20Equalize%20Frequency.java) +445 | [Remove Linked List Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Linked%20List%20Elements.java) +446 | [Remove One Element to Make the Array Strictly Increasing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20One%20Element%20to%20Make%20the%20Array%20Strictly%20Increasing.java) +447 | [Remove Outermost Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Outermost%20Parentheses.java) +448 | [Remove Palindromic Subsequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Palindromic%20Subsequences.java) +449 | [Remove Vowels from a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Vowels%20from%20a%20String.java) +450 | [Repeated String Match](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Repeated%20String%20Match.java) +451 | [Repeated Substring Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Repeated%20Substring%20Pattern.java) +452 | [Replace All ?'s to Avoid Consecutive Repeating Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Replace%20All%20?'s%20to%20Avoid%20Consecutive%20Repeating%20Characters.java) +453 | [Replace All Digits with Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Replace%20All%20Digits%20with%20Characters.java) +454 | [Replace Elements with Greatest Element on Right Side](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Replace%20Elements%20with%20Greatest%20Element%20on%20Right%20Side.java) +455 | [Reshape the matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reshape%20the%20matrix.java) +456 | [Reverse Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Bits.java) +457 | [Reverse Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Linked%20List.java) +458 | [Reverse Only Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Only%20Letters.java) +459 | [Reverse Prefix of Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Prefix%20of%20Word.java) +460 | [Reverse String II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20String%20II.java) +461 | [Reverse String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20String.java) +462 | [Reverse Vowels of a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Vowels%20of%20a%20String.java) +463 | [Reverse words in a String III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20words%20in%20a%20String%20III.java) +464 | [Richest Customer Wealth](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Richest%20Customer%20Wealth.java) +465 | [Rings and Rods](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rings%20and%20Rods.java) +466 | [Robot Return to Origin](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Robot%20Return%20to%20Origin.java) +467 | [Roman to Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Roman%20to%20Integer.java) +468 | [Root Equals Sum of Children](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Root%20Equals%20Sum%20of%20Children.java) +469 | [Rotate String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rotate%20String.java) +470 | [Row With Maximum Ones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Row%20With%20Maximum%20Ones.java) +471 | [Running Sum of 1d Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Running%20Sum%20of%201d%20Array.java) +472 | [Same Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Same%20Tree.java) +473 | [Search Insert Position](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Search%20Insert%20Position.java) +474 | [Search in a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Search%20in%20a%20Binary%20Search%20Tree.java) +475 | [Second Largest Digit in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Second%20Largest%20Digit%20in%20a%20String.java) +476 | [Second Minimum Node in a binary tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Second%20Minimum%20Node%20in%20a%20binary%20tree.java) +477 | [Self Dividing Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Self%20Dividing%20Number.java) +478 | [Sentence Similarity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sentence%20Similarity.java) +479 | [Separate the Digits in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Separate%20the%20Digits%20in%20an%20Array.java) +480 | [Set Mismatch](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Set%20Mismatch.java) +481 | [Shortest Completing Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Completing%20Word.java) +482 | [Shortest Distance to Target String in a Circular Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Distance%20to%20Target%20String%20in%20a%20Circular%20Array.java) +483 | [Shortest Distance to a Character](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Distance%20to%20a%20Character.java) +484 | [Shortest Word Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Word%20Distance.java) +485 | [Shuffle String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shuffle%20String.java) +486 | [Shuffle the Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shuffle%20the%20Array.java) +487 | [Sign of the Product of an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sign%20of%20the%20Product%20of%20an%20Array.java) +488 | [Similar RGB Color](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Similar%20RGB%20Color.java) +489 | [Single Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Single%20Number.java) +490 | [Single-Row Keyboard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Single-Row%20Keyboard.java) +491 | [Slowest Key](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Slowest%20Key.java) +492 | [Smallest Even Multiple](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Smallest%20Even%20Multiple.java) +493 | [Smallest Index With Equal Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Smallest%20Index%20With%20Equal%20Value.java) +494 | [Smallest Range I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Smallest%20Range%20I.java) +495 | [Sort Array By Parity II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Array%20By%20Parity%20II.java) +496 | [Sort Array By Parity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Array%20By%20Parity.java) +497 | [Sort Array by Increasing Frequency](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Array%20by%20Increasing%20Frequency.java) +498 | [Sort Even and Odd Indices Independently](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Even%20and%20Odd%20Indices%20Independently.java) +499 | [Sort Integers by The Number of 1 Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Integers%20by%20The%20Number%20of%201%20Bits.java) +500 | [Sort the People](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20the%20People.java) +501 | [Sorting the Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sorting%20the%20Sentence.java) +502 | [Special Array With X Elements Greater Than or Equal X](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Special%20Array%20With%20X%20Elements%20Greater%20Than%20or%20Equal%20X.java) +503 | [Special Positions in a Binary Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Special%20Positions%20in%20a%20Binary%20Matrix.java) +504 | [Split With Minimum Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Split%20With%20Minimum%20Sum.java) +505 | [Split a String in Balanced Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Split%20a%20String%20in%20Balanced%20Strings.java) +506 | [SqrtX](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/SqrtX.java) +507 | [Squares of a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Squares%20of%20a%20Sorted%20Array.java) +508 | [String Matching in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/String%20Matching%20in%20an%20Array.java) +509 | [String Without AAA or BBB](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/String%20Without%20AAA%20or%20BBB.java) +510 | [Strobogrammatic Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Strobogrammatic%20Number.java) +511 | [Strong Password Checker II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Strong%20Password%20Checker%20II.java) +512 | [Student Attendance Record I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Student%20Attendance%20Record%20I.java) +513 | [Submission Detail](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Submission%20Detail.java) +514 | [Substrings of Size Three with Distinct Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Substrings%20of%20Size%20Three%20with%20Distinct%20Characters.java) +515 | [Subtract the Product and Sum of Digits of an Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Subtract%20the%20Product%20and%20Sum%20of%20Digits%20of%20an%20Integer.java) +516 | [Subtree of Another Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Subtree%20of%20Another%20Tree.java) +517 | [Sum Of Two Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20Of%20Two%20Integers.java) +518 | [Sum of All Odd Length Subarrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20All%20Odd%20Length%20Subarrays.java) +519 | [Sum of Digits in Base K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Digits%20in%20Base%20K.java) +520 | [Sum of Digits in the Minimum Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Digits%20in%20the%20Minimum%20Number.java) +521 | [Sum of Digits of String After Convert](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Digits%20of%20String%20After%20Convert.java) +522 | [Sum of Left Leaves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Left%20Leaves.java) +523 | [Sum of Root To Leaf Binary Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Root%20To%20Leaf%20Binary%20Numbers.java) +524 | [Sum of Square Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Square%20Numbers.java) +525 | [Sum of Unique Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Unique%20Elements.java) +526 | [Summary Ranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Summary%20Ranges.java) +527 | [Symmetric Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Symmetric%20Tree.java) +528 | [Take Gifts From the Richest Pile](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Take%20Gifts%20From%20the%20Richest%20Pile.java) +529 | [Teemo Attacking](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Teemo%20Attacking.java) +530 | [Teoplitz Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Teoplitz%20Matrix.java) +531 | [The Employee That Worked on the Longest Task](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/The%20Employee%20That%20Worked%20on%20the%20Longest%20Task.java) +532 | [The K Weakest Rows in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/The%20K%20Weakest%20Rows%20in%20a%20Matrix.java) +533 | [Third Maximum Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Third%20Maximum%20Number.java) +534 | [Thousand Separator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Thousand%20Separator.java) +535 | [Three Consecutive Odds](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Three%20Consecutive%20Odds.java) +536 | [Three Divisors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Three%20Divisors.java) +537 | [Time Needed to Buy Tickets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Time%20Needed%20to%20Buy%20Tickets.java) +538 | [To Lower Case](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/To%20Lower%20Case.java) +539 | [Toeplitz Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Toeplitz%20Matrix.java) +540 | [Transpose Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Transpose%20Matrix.java) +541 | [Truncate Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Truncate%20Sentence.java) +542 | [Two Furthest Houses With Different Colors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Furthest%20Houses%20With%20Different%20Colors.java) +543 | [Two Out of Three](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Out%20of%20Three.java) +544 | [Two Sum III - Data Structure Design](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum%20III%20-%20Data%20Structure%20Design.java) +545 | [Two Sum IV - Input is a BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum%20IV%20-%20Input%20is%20a%20BST.java) +546 | [Two Sum Less Than K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum%20Less%20Than%20K.java) +547 | [Two Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum.java) +548 | [Ugly Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Ugly%20Number.java) +549 | [Uncommon Words from Two Sentences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Uncommon%20Words%20from%20Two%20Sentences.java) +550 | [Unique Email Addresses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Unique%20Email%20Addresses.java) +551 | [Unique Morse Code Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Unique%20Morse%20Code%20Words.java) +552 | [Unique Number of Occurrences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Unique%20Number%20of%20Occurrences.java) +553 | [Univalued Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Univalued%20Binary%20Tree.java) +554 | [Valid Anagram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Anagram.java) +555 | [Valid Boomerang](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Boomerang.java) +556 | [Valid Mountain Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Mountain%20Array.java) +557 | [Valid Palindrome II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Palindrome%20II.java) +558 | [Valid Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Palindrome.java) +559 | [Valid Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Parentheses.java) +560 | [Valid Perfect Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Perfect%20Square.java) +561 | [Valid Word Abbreviation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Word%20Abbreviation.java) +562 | [Valid Word Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Word%20Sequence.java) +563 | [Valid Word Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Word%20Square.java) +564 | [Verifying an Alien Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Verifying%20an%20Alien%20Dictionary.java) +565 | [Water Bottles](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Water%20Bottles.java) +566 | [Word Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Word%20Pattern.java) +567 | [X of a Kind in a Deck of Cards](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/X%20of%20a%20Kind%20in%20a%20Deck%20of%20Cards.java) +568 | [XOR Operation in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/XOR%20Operation%20in%20an%20Array.java) +569 | [nim_game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/nim_game.java) +570 | [range_addition_II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/range_addition_II.java) +571 | [trailing_zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/trailing_zeroes.java) diff --git a/Hard/README.md b/Hard/README.md index 3ada6cad..e97d573a 100644 --- a/Hard/README.md +++ b/Hard/README.md @@ -2,99 +2,112 @@ S.no | Coding Problem --- | --- 1 | [Add Edges to Make Degrees of All Nodes Even](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Add%20Edges%20to%20Make%20Degrees%20of%20All%20Nodes%20Even.java) -2 | [Basic Calculator III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Basic%20Calculator%20III.java) -3 | [Basic Calculator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Basic%20Calculator.java) -4 | [Best Time to Buy and Sell Stock IV](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Best%20Time%20to%20Buy%20and%20Sell%20Stock%20IV.java) -5 | [Binary Tree Cameras](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Binary%20Tree%20Cameras.java) -6 | [Binary Tree Maximum Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Binary%20Tree%20Maximum%20Path%20Sum.java) -7 | [Candy](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Candy.java) -8 | [Closest Binary Search Tree Values II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Closest%20Binary%20Search%20Tree%20Values%20II.java) -9 | [Concatenated Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Concatenated%20Words.java) -10 | [Construct Target Array With Multiple Sums](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Construct%20Target%20Array%20With%20Multiple%20Sums.java) -11 | [Count Subarrays With Fixed Bounds](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Count%20Subarrays%20With%20Fixed%20Bounds.java) -12 | [Count Vowels Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Count%20Vowels%20Permutation.java) -13 | [Count of Smaller Numbers After Self](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Count%20of%20Smaller%20Numbers%20After%20Self.java) -14 | [Course Schedule III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Course%20Schedule%20III.java) -15 | [Critical Connections in a Network](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Critical%20Connections%20in%20a%20Network.java) -16 | [Cut Off Trees for Golf Event](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Cut%20Off%20Trees%20for%20Golf%20Event.java) -17 | [Design In-Memory File System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Design%20In-Memory%20File%20System.java) -18 | [Design Movie Rental System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Design%20Movie%20Rental%20System.java) -19 | [Design Search Autocomplete System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Design%20Search%20Autocomplete%20System.java) -20 | [Design Skiplist](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Design%20Skiplist.java) -21 | [Dice Roll Simulation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Dice%20Roll%20Simulation.java) -22 | [Divide Array Into Increasing Sequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Divide%20Array%20Into%20Increasing%20Sequences.java) -23 | [Edit Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Edit%20Distance.java) -24 | [Employee Free Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Employee%20Free%20Time.java) -25 | [Expression Add Operators](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Expression%20Add%20Operators.java) -26 | [Find Median from Data Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Find%20Median%20from%20Data%20Stream.java) -27 | [Find Minimum in Rotated Sorted Array II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Find%20Minimum%20in%20Rotated%20Sorted%20Array%20II.java) -28 | [Find the Kth Smallest Sum of a Matrix With Sorted Rows](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Find%20the%20Kth%20Smallest%20Sum%20of%20a%20Matrix%20With%20Sorted%20Rows.java) -29 | [First Missing Positive](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/First%20Missing%20Positive.java) -30 | [Frog Jump](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Frog%20Jump.java) -31 | [IPO](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/IPO.java) -32 | [Insert Delete GetRandom O(1) - Duplicates Allowed](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Insert%20Delete%20GetRandom%20O(1)%20-%20Duplicates%20Allowed.java) -33 | [Integer to English Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Integer%20to%20English%20Words.java) -34 | [Jump Game IV](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Jump%20Game%20IV.java) -35 | [K Empty Slots](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/K%20Empty%20Slots.java) -36 | [K Inverse Pairs Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/K%20Inverse%20Pairs%20Array.java) -37 | [Kth Smallest Number in Multiplication Table](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Kth%20Smallest%20Number%20in%20Multiplication%20Table.java) -38 | [LFU Cache](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/LFU%20Cache.java) -39 | [Largest Rectangle in Histogram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Largest%20Rectangle%20in%20Histogram.java) -40 | [Longest Increasing Path in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Longest%20Increasing%20Path%20in%20a%20Matrix.java) -41 | [Longest Palindrome Product](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Longest%20Palindrome%20Product.java) -42 | [Longest Valid Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Longest%20Valid%20Parentheses.java) -43 | [Max Points on a Line](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Max%20Points%20on%20a%20Line.java) -44 | [Max Stack](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Max%20Stack.java) -45 | [Maximum Frequency Stack](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Frequency%20Stack.java) -46 | [Maximum Number of Non-Overlapping Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Number%20of%20Non-Overlapping%20Substrings.java) -47 | [Maximum Performance of a Team](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Performance%20of%20a%20Team.java) -48 | [Maximum Profit in Job Scheduling](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Profit%20in%20Job%20Scheduling.java) -49 | [Maximum Sum BST in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Sum%20BST%20in%20Binary%20Tree.java) -50 | [Median of Two Sorted Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Median%20of%20Two%20Sorted%20Arrays.java) -51 | [Merge K Sorted Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Merge%20K%20Sorted%20Lists.java) -52 | [Minimize Deviation in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimize%20Deviation%20in%20Array.java) -53 | [Minimum Cost to Hire K Workers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Cost%20to%20Hire%20K%20Workers.java) -54 | [Minimum Difficulty of a Job Schedule](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Difficulty%20of%20a%20Job%20Schedule.java) -55 | [Minimum Number of Refueling Stops](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Number%20of%20Refueling%20Stops.java) -56 | [Minimum Window Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Window%20Subsequence.java) -57 | [Minimum Window Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Window%20Substring.java) -58 | [My Calendar III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/My%20Calendar%20III.java) -59 | [N-Queens II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/N-Queens%20II.java) -60 | [N-Queens](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/N-Queens.java) -61 | [Naming a Company](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Naming%20a%20Company.java) -62 | [Number of Paths with Max Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Paths%20with%20Max%20Score.java) -63 | [Number of Squareful Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Squareful%20Arrays.java) -64 | [Number of Submatrices That Sum to Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Submatrices%20That%20Sum%20to%20Target.java) -65 | [Number of Valid Subarrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Valid%20Subarrays.java) -66 | [Odd Even Jump](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Odd%20Even%20Jump.java) -67 | [Optimal Account Balancing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Optimal%20Account%20Balancing.java) -68 | [Paint House III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Paint%20House%20III.java) -69 | [Palindrome Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Palindrome%20Pairs.java) -70 | [Parsing A Boolean Expression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Parsing%20A%20Boolean%20Expression.java) -71 | [Perfect Rectangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Perfect%20Rectangle.java) -72 | [Poor Pigs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Poor%20Pigs.java) -73 | [Prefix and Suffix Search](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Prefix%20and%20Suffix%20Search.java) -74 | [Reconstruct Itinerary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Reconstruct%20Itinerary.java) -75 | [Recover a Tree From Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Recover%20a%20Tree%20From%20Preorder%20Traversal.java) -76 | [Remove Invalid Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Remove%20Invalid%20Parentheses.java) -77 | [Reverse Nodes in k-Group](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Reverse%20Nodes%20in%20k-Group.java) -78 | [Robot Room Cleaner](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Robot%20Room%20Cleaner.java) -79 | [Serialize and Deserialize N-ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Serialize%20and%20Deserialize%20N-ary%20Tree.java) -80 | [Serialize and Deserialize a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Serialize%20and%20Deserialize%20a%20Binary%20Tree.java) -81 | [Shortest Distance from All Buildings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Shortest%20Distance%20from%20All%20Buildings.java) -82 | [Sliding Window Maximum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Sliding%20Window%20Maximum.java) -83 | [Sliding Window Median](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Sliding%20Window%20Median.java) -84 | [Stamping The Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Stamping%20The%20Sequence.java) -85 | [Stream of Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Stream%20of%20Characters.java) -86 | [String Compression II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/String%20Compression%20II.java) -87 | [Subarrays with K Different Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Subarrays%20with%20K%20Different%20Integers.java) -88 | [Substring with Concatenation of All Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Substring%20with%20Concatenation%20of%20All%20Words.java) -89 | [Text Justification](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Text%20Justification.java) -90 | [The Skyline Problem](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/The%20Skyline%20Problem.java) -91 | [Trapping Rain Water](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Trapping%20Rain%20Water.java) -92 | [Unique Paths III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Unique%20Paths%20III.java) -93 | [Valid Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Valid%20Number.java) -94 | [Vertical Order Traversal Of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Vertical%20Order%20Traversal%20Of%20a%20Binary%20Tree.java) -95 | [Wildcard Matching](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Wildcard%20Matching.java) -96 | [Word Break II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Word%20Break%20II.java) -97 | [Word Search II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Word%20Search%20II.java) +2 | [Alien Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Alien%20Dictionary.java) +3 | [Basic Calculator III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Basic%20Calculator%20III.java) +4 | [Basic Calculator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Basic%20Calculator.java) +5 | [Best Time to Buy and Sell Stock IV](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Best%20Time%20to%20Buy%20and%20Sell%20Stock%20IV.java) +6 | [Binary Tree Cameras](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Binary%20Tree%20Cameras.java) +7 | [Binary Tree Maximum Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Binary%20Tree%20Maximum%20Path%20Sum.java) +8 | [Candy](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Candy.java) +9 | [Checking Existence of Edge Length Limited Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Checking%20Existence%20of%20Edge%20Length%20Limited%20Paths.java) +10 | [Closest Binary Search Tree Values II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Closest%20Binary%20Search%20Tree%20Values%20II.java) +11 | [Concatenated Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Concatenated%20Words.java) +12 | [Construct Target Array With Multiple Sums](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Construct%20Target%20Array%20With%20Multiple%20Sums.java) +13 | [Count Subarrays With Fixed Bounds](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Count%20Subarrays%20With%20Fixed%20Bounds.java) +14 | [Count Vowels Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Count%20Vowels%20Permutation.java) +15 | [Count of Smaller Numbers After Self](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Count%20of%20Smaller%20Numbers%20After%20Self.java) +16 | [Course Schedule III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Course%20Schedule%20III.java) +17 | [Critical Connections in a Network](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Critical%20Connections%20in%20a%20Network.java) +18 | [Cut Off Trees for Golf Event](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Cut%20Off%20Trees%20for%20Golf%20Event.java) +19 | [Design In-Memory File System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Design%20In-Memory%20File%20System.java) +20 | [Design Movie Rental System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Design%20Movie%20Rental%20System.java) +21 | [Design Search Autocomplete System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Design%20Search%20Autocomplete%20System.java) +22 | [Design Skiplist](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Design%20Skiplist.java) +23 | [Dice Roll Simulation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Dice%20Roll%20Simulation.java) +24 | [Divide Array Into Increasing Sequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Divide%20Array%20Into%20Increasing%20Sequences.java) +25 | [Edit Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Edit%20Distance.java) +26 | [Employee Free Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Employee%20Free%20Time.java) +27 | [Expression Add Operators](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Expression%20Add%20Operators.java) +28 | [Find Median from Data Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Find%20Median%20from%20Data%20Stream.java) +29 | [Find Minimum in Rotated Sorted Array II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Find%20Minimum%20in%20Rotated%20Sorted%20Array%20II.java) +30 | [Find the Kth Smallest Sum of a Matrix With Sorted Rows](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Find%20the%20Kth%20Smallest%20Sum%20of%20a%20Matrix%20With%20Sorted%20Rows.java) +31 | [First Missing Positive](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/First%20Missing%20Positive.java) +32 | [Frog Jump](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Frog%20Jump.java) +33 | [IPO](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/IPO.java) +34 | [Insert Delete GetRandom O(1) - Duplicates Allowed](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Insert%20Delete%20GetRandom%20O(1)%20-%20Duplicates%20Allowed.java) +35 | [Integer to English Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Integer%20to%20English%20Words.java) +36 | [Jump Game IV](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Jump%20Game%20IV.java) +37 | [K Empty Slots](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/K%20Empty%20Slots.java) +38 | [K Inverse Pairs Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/K%20Inverse%20Pairs%20Array.java) +39 | [Kth Smallest Number in Multiplication Table](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Kth%20Smallest%20Number%20in%20Multiplication%20Table.java) +40 | [LFU Cache](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/LFU%20Cache.java) +41 | [Largest Color Value in a Directed Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Largest%20Color%20Value%20in%20a%20Directed%20Graph.java) +42 | [Largest Rectangle in Histogram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Largest%20Rectangle%20in%20Histogram.java) +43 | [Longest Cycle in a Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Longest%20Cycle%20in%20a%20Graph.java) +44 | [Longest Increasing Path in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Longest%20Increasing%20Path%20in%20a%20Matrix.java) +45 | [Longest Palindrome Product](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Longest%20Palindrome%20Product.java) +46 | [Longest Valid Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Longest%20Valid%20Parentheses.java) +47 | [Max Points on a Line](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Max%20Points%20on%20a%20Line.java) +48 | [Max Stack](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Max%20Stack.java) +49 | [Maximum Frequency Stack](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Frequency%20Stack.java) +50 | [Maximum Number of Non-Overlapping Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Number%20of%20Non-Overlapping%20Substrings.java) +51 | [Maximum Performance of a Team](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Performance%20of%20a%20Team.java) +52 | [Maximum Profit in Job Scheduling](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Profit%20in%20Job%20Scheduling.java) +53 | [Maximum Sum BST in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Sum%20BST%20in%20Binary%20Tree.java) +54 | [Maximum Value of K Coins From Piles](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Value%20of%20K%20Coins%20From%20Piles.java) +55 | [Median of Two Sorted Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Median%20of%20Two%20Sorted%20Arrays.java) +56 | [Merge K Sorted Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Merge%20K%20Sorted%20Lists.java) +57 | [Minimize Deviation in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimize%20Deviation%20in%20Array.java) +58 | [Minimum Cost to Hire K Workers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Cost%20to%20Hire%20K%20Workers.java) +59 | [Minimum Difficulty of a Job Schedule](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Difficulty%20of%20a%20Job%20Schedule.java) +60 | [Minimum Insertion Steps to Make a String Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Insertion%20Steps%20to%20Make%20a%20String%20Palindrome.java) +61 | [Minimum Number of Refueling Stops](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Number%20of%20Refueling%20Stops.java) +62 | [Minimum Window Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Window%20Subsequence.java) +63 | [Minimum Window Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Window%20Substring.java) +64 | [My Calendar III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/My%20Calendar%20III.java) +65 | [N-Queens II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/N-Queens%20II.java) +66 | [N-Queens](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/N-Queens.java) +67 | [Naming a Company](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Naming%20a%20Company.java) +68 | [Number of Paths with Max Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Paths%20with%20Max%20Score.java) +69 | [Number of Squareful Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Squareful%20Arrays.java) +70 | [Number of Submatrices That Sum to Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Submatrices%20That%20Sum%20to%20Target.java) +71 | [Number of Valid Subarrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Valid%20Subarrays.java) +72 | [Number of Ways of Cutting a Pizza](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Ways%20of%20Cutting%20a%20Pizza.java) +73 | [Number of Ways to Form a Target String Given a Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Ways%20to%20Form%20a%20Target%20String%20Given%20a%20Dictionary.java) +74 | [Odd Even Jump](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Odd%20Even%20Jump.java) +75 | [Optimal Account Balancing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Optimal%20Account%20Balancing.java) +76 | [Paint House III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Paint%20House%20III.java) +77 | [Palindrome Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Palindrome%20Pairs.java) +78 | [Parsing A Boolean Expression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Parsing%20A%20Boolean%20Expression.java) +79 | [Perfect Rectangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Perfect%20Rectangle.java) +80 | [Poor Pigs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Poor%20Pigs.java) +81 | [Prefix and Suffix Search](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Prefix%20and%20Suffix%20Search.java) +82 | [Profitable Schemes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Profitable%20Schemes.java) +83 | [Reconstruct Itinerary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Reconstruct%20Itinerary.java) +84 | [Recover a Tree From Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Recover%20a%20Tree%20From%20Preorder%20Traversal.java) +85 | [Reducing Dishes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Reducing%20Dishes.java) +86 | [Remove Invalid Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Remove%20Invalid%20Parentheses.java) +87 | [Restore The Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Restore%20The%20Array.java) +88 | [Reverse Nodes in k-Group](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Reverse%20Nodes%20in%20k-Group.java) +89 | [Robot Room Cleaner](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Robot%20Room%20Cleaner.java) +90 | [Scramble String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Scramble%20String.java) +91 | [Serialize and Deserialize N-ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Serialize%20and%20Deserialize%20N-ary%20Tree.java) +92 | [Serialize and Deserialize a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Serialize%20and%20Deserialize%20a%20Binary%20Tree.java) +93 | [Shortest Distance from All Buildings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Shortest%20Distance%20from%20All%20Buildings.java) +94 | [Similar String Groups](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Similar%20String%20Groups.java) +95 | [Sliding Window Maximum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Sliding%20Window%20Maximum.java) +96 | [Sliding Window Median](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Sliding%20Window%20Median.java) +97 | [Stamping The Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Stamping%20The%20Sequence.java) +98 | [Stream of Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Stream%20of%20Characters.java) +99 | [String Compression II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/String%20Compression%20II.java) +100 | [Subarrays with K Different Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Subarrays%20with%20K%20Different%20Integers.java) +101 | [Substring with Concatenation of All Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Substring%20with%20Concatenation%20of%20All%20Words.java) +102 | [Text Justification](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Text%20Justification.java) +103 | [The Skyline Problem](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/The%20Skyline%20Problem.java) +104 | [Trapping Rain Water](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Trapping%20Rain%20Water.java) +105 | [Unique Paths III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Unique%20Paths%20III.java) +106 | [Valid Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Valid%20Number.java) +107 | [Vertical Order Traversal Of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Vertical%20Order%20Traversal%20Of%20a%20Binary%20Tree.java) +108 | [Wildcard Matching](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Wildcard%20Matching.java) +109 | [Word Break II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Word%20Break%20II.java) +110 | [Word Search II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Word%20Search%20II.java) diff --git a/Medium/README.md b/Medium/README.md index cea9747e..0d6a9299 100644 --- a/Medium/README.md +++ b/Medium/README.md @@ -7,739 +7,750 @@ S.no | Coding Problem 4 | [3Sum Smaller](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/3Sum%20Smaller.java) 5 | [3Sum With Multiplicity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/3Sum%20With%20Multiplicity.java) 6 | [3Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/3Sum.java) -7 | [4 Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/4%20Sum%20II.java) -8 | [4Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/4Sum%20II.java) -9 | [4Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/4Sum.java) -10 | [Accounts Merge](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Accounts%20Merge.java) -11 | [Add Bold Tag in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20Bold%20Tag%20in%20String.java) -12 | [Add Minimum Number of Rungs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20Minimum%20Number%20of%20Rungs.java) -13 | [Add One Row to Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20One%20Row%20to%20Tree.java) -14 | [Add Two Numbers II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20Two%20Numbers%20II.java) -15 | [Add Two Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20Two%20Numbers.java) -16 | [Adding Spaces to a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Adding%20Spaces%20to%20a%20String.java) -17 | [Adding Two Negabinary Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Adding%20Two%20Negabinary%20Numbers.java) -18 | [Advantage Shuffle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Advantage%20Shuffle.java) -19 | [Alert Using Same Key-Card Three or More Times in a One Hour Period](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Alert%20Using%20Same%20Key-Card%20Three%20or%20More%20Times%20in%20a%20One%20Hour%20Period.java) -20 | [All Ancestors of a Node in a Directed Acyclic Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Ancestors%20of%20a%20Node%20in%20a%20Directed%20Acyclic%20Graph.java) -21 | [All Divisions With the Highest Score of a Binary Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Divisions%20With%20the%20Highest%20Score%20of%20a%20Binary%20Array.java) -22 | [All Elements in Two Binary Search Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Elements%20in%20Two%20Binary%20Search%20Trees.java) -23 | [All Nodes Distance K in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Nodes%20Distance%20K%20in%20Binary%20Tree.java) -24 | [All Paths From Source to Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Paths%20From%20Source%20to%20Target.java) -25 | [All Paths from Source Lead to Destination](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Paths%20from%20Source%20Lead%20to%20Destination.java) -26 | [All Possible Full Binary Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Possible%20Full%20Binary%20Trees.java) -27 | [Analyze User Website Visit Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Analyze%20User%20Website%20Visit%20Pattern.java) -28 | [Angle Between Hands of a Clock](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Angle%20Between%20Hands%20of%20a%20Clock.java) -29 | [Append Characters to String to Make Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Append%20Characters%20to%20String%20to%20Make%20Subsequence.java) -30 | [Append K Integers With Minimal Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Append%20K%20Integers%20With%20Minimal%20Sum.java) -31 | [Apply Discount Every n Orders](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Apply%20Discount%20Every%20n%20Orders.java) -32 | [Apply Discount to Prices](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Apply%20Discount%20to%20Prices.java) -33 | [Arithmetic Slices](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Arithmetic%20Slices.java) -34 | [Arithmetic Subarrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Arithmetic%20Subarrays.java) -35 | [Array Circular Loop](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Array%20Circular%20Loop.java) -36 | [Array Nesting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Array%20Nesting.java) -37 | [As Far from Land as Possible](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/As%20Far%20from%20Land%20as%20Possible.java) -38 | [Asteroid Collision](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Asteroid%20Collision.java) -39 | [Average Waiting Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Average%20Waiting%20Time.java) -40 | [Bag of Tokens](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Bag%20of%20Tokens.java) -41 | [Balance a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Balance%20a%20Binary%20Search%20Tree.java) -42 | [Basic Calculator II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Basic%20Calculator%20II.java) -43 | [Battleships in a board](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Battleships%20in%20a%20board.java) -44 | [Best Time to Buy and Sell Stock II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Best%20Time%20to%20Buy%20and%20Sell%20Stock%20II.java) -45 | [Best Time to Buy and Sell Stock with Cooldown](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Best%20Time%20to%20Buy%20and%20Sell%20Stock%20with%20Cooldown.java) -46 | [Binary Search Tree Iterator II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Search%20Tree%20Iterator%20II.java) -47 | [Binary Search Tree Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Search%20Tree%20Iterator.java) -48 | [Binary Search Tree to Greater Sum Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Search%20Tree%20to%20Greater%20Sum%20Tree.java) -49 | [Binary Tree Coloring Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Coloring%20Game.java) -50 | [Binary Tree Level Order Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Level%20Order%20Traversal.java) -51 | [Binary Tree Longest Consecutive Sequence II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Longest%20Consecutive%20Sequence%20II.java) -52 | [Binary Tree Longest Consecutive Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Longest%20Consecutive%20Sequence.java) -53 | [Binary Tree Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Preorder%20Traversal.java) -54 | [Binary Tree Pruning](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Pruning.java) -55 | [Binary Tree Right Side View](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Right%20Side%20View.java) -56 | [Binary Tree Upside Down](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Upside%20Down.java) -57 | [Binary Tree Vertical Order Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Vertical%20Order%20Traversal.java) -58 | [Binary Tree Zigzag Level Order Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Zigzag%20Level%20Order%20Traversal.java) -59 | [Binary Trees With Factors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Trees%20With%20Factors.java) -60 | [Bitwise AND of Numbers Range](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Bitwise%20AND%20of%20Numbers%20Range.java) -61 | [Boats to Save People](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Boats%20to%20Save%20People.java) -62 | [Bold Words in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Bold%20Words%20in%20String.java) -63 | [Bomb Enemy](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Bomb%20Enemy.java) -64 | [Boundary of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Boundary%20of%20Binary%20Tree.java) -65 | [Brace Expansion](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Brace%20Expansion.java) -66 | [Break a Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Break%20a%20Palindrome.java) -67 | [Broken Calculator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Broken%20Calculator.java) -68 | [Buildings With an Ocean View](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Buildings%20With%20an%20Ocean%20View.java) -69 | [Bulb Switcher](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Bulb%20Switcher.java) -70 | [Camelcase Matching](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Camelcase%20Matching.java) -71 | [Campus Bikes II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Campus%20Bikes%20II.java) -72 | [Campus Bikes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Campus%20Bikes.java) -73 | [Can Convert String in K Moves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Can%20Convert%20String%20in%20K%20Moves.java) -74 | [Can Make Palindrome from Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Can%20Make%20Palindrome%20from%20Substring.java) -75 | [Candy Crush](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Candy%20Crush.java) -76 | [Capacity To Ship Packages Within D Days](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Capacity%20To%20Ship%20Packages%20Within%20D%20Days.java) -77 | [Car Pooling](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Car%20Pooling.java) -78 | [Champagne Tower](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Champagne%20Tower.java) -79 | [Cheapest Flights Within K Stops](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Cheapest%20Flights%20Within%20K%20Stops.java) -80 | [Check Completeness of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20Completeness%20of%20a%20Binary%20Tree.java) -81 | [Check If All 1's Are at Least Length K Places Away](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20If%20All%201's%20Are%20at%20Least%20Length%20K%20Places%20Away.java) -82 | [Check If a String Can Break Another String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20If%20a%20String%20Can%20Break%20Another%20String.java) -83 | [Check If a String Contains All Binary Codes of Size K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20If%20a%20String%20Contains%20All%20Binary%20Codes%20of%20Size%20K.java) -84 | [Check If a String Is a Valid Sequence from Root to Leaves Path in a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20If%20a%20String%20Is%20a%20Valid%20Sequence%20from%20Root%20to%20Leaves%20Path%20in%20a%20Binary%20Tree.java) -85 | [Check if There is a Valid Path in a Grid](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20if%20There%20is%20a%20Valid%20Path%20in%20a%20Grid.java) -86 | [Cinema Seat Allocation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Cinema%20Seat%20Allocation.java) -87 | [Clone Binary Tree With Random Pointer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Clone%20Binary%20Tree%20With%20Random%20Pointer.java) -88 | [Clone Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Clone%20Graph.java) -89 | [Clone N-ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Clone%20N-ary%20Tree.java) -90 | [Closest Nodes Queries in a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Closest%20Nodes%20Queries%20in%20a%20Binary%20Search%20Tree.java) -91 | [Coin Change 2](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Coin%20Change%202.java) -92 | [Coin Change](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Coin%20Change.java) -93 | [Combination Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Combination%20Sum%20II.java) -94 | [Combination Sum III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Combination%20Sum%20III.java) -95 | [Combination Sum IV](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Combination%20Sum%20IV.java) -96 | [Combination Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Combination%20Sum.java) -97 | [Combinations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Combinations.java) -98 | [Compare Version Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Compare%20Version%20Numbers.java) -99 | [Complete Binary Tree Insertor](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Complete%20Binary%20Tree%20Insertor.java) -100 | [Complex Number Multiplication](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Complex%20Number%20Multiplication.java) -101 | [Concatenation of Consecutive Binary Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Concatenation%20of%20Consecutive%20Binary%20Numbers.java) -102 | [Connecting Cities With Minimum Cost](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Connecting%20Cities%20With%20Minimum%20Cost.java) -103 | [Construct Binary Search Tree from Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20Binary%20Search%20Tree%20from%20Preorder%20Traversal.java) -104 | [Construct Binary Tree from Inorder and Postorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20Binary%20Tree%20from%20Inorder%20and%20Postorder%20Traversal.java) -105 | [Construct Binary Tree from Preorder and Inorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20Binary%20Tree%20from%20Preorder%20and%20Inorder%20Traversal.java) -106 | [Construct K Palindrome Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20K%20Palindrome%20Strings.java) -107 | [Construct Quad Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20Quad%20Tree.java) -108 | [Construct String With Repeat Limit](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20String%20With%20Repeat%20Limit.java) -109 | [Container With Most Water](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Container%20With%20Most%20Water.java) -110 | [Contains Duplicate III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Contains%20Duplicate%20III.java) -111 | [Contiguous Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Contiguous%20Array.java) -112 | [Continuous Subarray Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Continuous%20Subarray%20Sum.java) -113 | [Convert Binary Search Tree to Sorted Doubly Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Convert%20Binary%20Search%20Tree%20to%20Sorted%20Doubly%20Linked%20List.java) -114 | [Convert Sorted List to Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Convert%20Sorted%20List%20to%20Binary%20Search%20Tree.java) -115 | [Copy List with Random Pointer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Copy%20List%20with%20Random%20Pointer.java) -116 | [Corporate Flight Bookings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Corporate%20Flight%20Bookings.java) -117 | [Count Collisions on a Road](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Collisions%20on%20a%20Road.java) -118 | [Count Complete Tree Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Complete%20Tree%20Nodes.java) -119 | [Count Good Nodes in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Good%20Nodes%20in%20Binary%20Tree.java) -120 | [Count Nodes Equal to Average of Subtree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Nodes%20Equal%20to%20Average%20of%20Subtree.java) -121 | [Count Nodes Equal to Sum of Descendants](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Nodes%20Equal%20to%20Sum%20of%20Descendants.java) -122 | [Count Number of Bad Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Number%20of%20Bad%20Pairs.java) -123 | [Count Number of Distinct Integers After Reverse Operations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Number%20of%20Distinct%20Integers%20After%20Reverse%20Operations.java) -124 | [Count Number of Homogenous Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Number%20of%20Homogenous%20Substrings.java) -125 | [Count Number of Teams](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Number%20of%20Teams.java) -126 | [Count Numbers With Unique Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Numbers%20With%20Unique%20Digits.java) -127 | [Count Servers That Communicate](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Servers%20That%20Communicate.java) -128 | [Count Sorted Vowel Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Sorted%20Vowel%20Strings.java) -129 | [Count Square Submatrices with All Ones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Square%20Submatrices%20with%20All%20Ones.java) -130 | [Count Sub Islands](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Sub%20Islands.java) -131 | [Count Submatrices With All Ones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Submatrices%20With%20All%20Ones.java) -132 | [Count Univalue Subtrees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Univalue%20Subtrees.java) -133 | [Count Unreachable Pairs of Nodes in an Undirected Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Unreachable%20Pairs%20of%20Nodes%20in%20an%20Undirected%20Graph.java) -134 | [Count Vowel Strings in Ranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Vowel%20Strings%20in%20Ranges.java) -135 | [Count and Say](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20and%20Say.java) -136 | [Course Schedule II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Course%20Schedule%20II.java) -137 | [Course Schedule](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Course%20Schedule.java) -138 | [Create Binary Tree From Descriptions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Create%20Binary%20Tree%20From%20Descriptions.java) -139 | [Custom Sort String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Custom%20Sort%20String.java) -140 | [Daily Temperatures](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Daily%20Temperatures.java) -141 | [Decode String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Decode%20String.java) -142 | [Decode Ways](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Decode%20Ways.java) -143 | [Decrease Elements To Make Array Zigzag](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Decrease%20Elements%20To%20Make%20Array%20Zigzag.java) -144 | [Deepest Leaves Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Deepest%20Leaves%20Sum.java) -145 | [Delete Leaves With a Given Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Leaves%20With%20a%20Given%20Value.java) -146 | [Delete Node in a BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Node%20in%20a%20BST.java) -147 | [Delete Nodes And Return Forest](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Nodes%20And%20Return%20Forest.java) -148 | [Delete Operation for Two Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Operation%20for%20Two%20Strings.java) -149 | [Delete Tree Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Tree%20Nodes.java) -150 | [Delete the Middle Node of a Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20the%20Middle%20Node%20of%20a%20Linked%20List.java) -151 | [Design A Leaderboard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20A%20Leaderboard.java) -152 | [Design Add and Search Words Data Structure](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Add%20and%20Search%20Words%20Data%20Structure.java) -153 | [Design Authentication Manager](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Authentication%20Manager.java) -154 | [Design Browser History](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Browser%20History.java) -155 | [Design Circular Deque](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Circular%20Deque.java) -156 | [Design Circular Queue](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Circular%20Queue.java) -157 | [Design File System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20File%20System.java) -158 | [Design Front Middle Back Queue](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Front%20Middle%20Back%20Queue.java) -159 | [Design Hit Counter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Hit%20Counter.java) -160 | [Design Log Storage System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Log%20Storage%20System.java) -161 | [Design Phone Directory](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Phone%20Directory.java) -162 | [Design SQL](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20SQL.java) -163 | [Design Snake Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Snake%20Game.java) -164 | [Design Tic-Tac-Toe](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Tic-Tac-Toe.java) -165 | [Design Twitter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Twitter.java) -166 | [Design Underground System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Underground%20System.java) -167 | [Design a File Sharing System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20a%20File%20Sharing%20System.java) -168 | [Design a Stack With Increment Operation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20a%20Stack%20With%20Increment%20Operation.java) -169 | [Design an ATM Machine](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20an%20ATM%20Machine.java) -170 | [Design an Expression Tree With Evaluate Function](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20an%20Expression%20Tree%20With%20Evaluate%20Function.java) -171 | [Determine if Two Strings Are Close](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Determine%20if%20Two%20Strings%20Are%20Close.java) -172 | [Diagonal Traverse](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Diagonal%20Traverse.java) -173 | [Diameter of N-ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Diameter%20of%20N-ary%20Tree.java) -174 | [Display Table of Food Orders in a Restaurant](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Display%20Table%20of%20Food%20Orders%20in%20a%20Restaurant.java) -175 | [Distribute Coins in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Distribute%20Coins%20in%20Binary%20Tree.java) -176 | [Divide Array in Sets of K Consecutive Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Divide%20Array%20in%20Sets%20of%20K%20Consecutive%20Numbers.java) -177 | [Divide Players Into Teams of Equal Skill](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Divide%20Players%20Into%20Teams%20of%20Equal%20Skill.java) -178 | [Divide Two Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Divide%20Two%20Integers.java) -179 | [Dot Product of Two Sparse Vectors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Dot%20Product%20of%20Two%20Sparse%20Vectors.java) -180 | [Encode and Decode Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Encode%20and%20Decode%20Strings.java) -181 | [Encode and Decode TinyURL](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Encode%20and%20Decode%20TinyURL.java) -182 | [Equal Row and Column Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Equal%20Row%20and%20Column%20Pairs.java) -183 | [Escape The Ghosts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Escape%20The%20Ghosts.java) -184 | [Evaluate Division](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Evaluate%20Division.java) -185 | [Evaluate Reverse Polish Notation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Evaluate%20Reverse%20Polish%20Notation.java) -186 | [Evaluate the Bracket Pairs of a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Evaluate%20the%20Bracket%20Pairs%20of%20a%20String.java) -187 | [Even Odd Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Even%20Odd%20Tree.java) -188 | [Exclusive Time of Functions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Exclusive%20Time%20of%20Functions.java) -189 | [Execution of All Suffix Instructions Staying in a Grid](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Execution%20of%20All%20Suffix%20Instructions%20Staying%20in%20a%20Grid.java) -190 | [Expressive Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Expressive%20Words.java) -191 | [Fair Distribution of Cookies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Fair%20Distribution%20of%20Cookies.java) -192 | [Filter Restaurants by Vegan-Friendly, Price and Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Filter%20Restaurants%20by%20Vegan-Friendly,%20Price%20and%20Distance.java) -193 | [Find All Anagrams in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20All%20Anagrams%20in%20a%20String.java) -194 | [Find All Lonely Numbers in the Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20All%20Lonely%20Numbers%20in%20the%20Array.java) -195 | [Find All Possible Recipes from Given Supplies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20All%20Possible%20Recipes%20from%20Given%20Supplies.java) -196 | [Find Bottom Left Tree Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Bottom%20Left%20Tree%20Value.java) -197 | [Find Center of Star Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Center%20of%20Star%20Graph.java) -198 | [Find Closest Node to Given Two Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Closest%20Node%20to%20Given%20Two%20Nodes.java) -199 | [Find Consecutive Integers from a Data Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Consecutive%20Integers%20from%20a%20Data%20Stream.java) -200 | [Find Distance in a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Distance%20in%20a%20Binary%20Tree.java) -201 | [Find Duplicate File in System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Duplicate%20File%20in%20System.java) -202 | [Find Duplicate Subtrees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Duplicate%20Subtrees.java) -203 | [Find Elements in a Contaminated Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Elements%20in%20a%20Contaminated%20Binary%20Tree.java) -204 | [Find First and Last Position of Element in Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20First%20and%20Last%20Position%20of%20Element%20in%20Sorted%20Array.java) -205 | [Find K Closest Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20K%20Closest%20Elements.java) -206 | [Find K Pairs with Smallest Sums](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20K%20Pairs%20with%20Smallest%20Sums.java) -207 | [Find K-Length Substrings With No Repeated Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20K-Length%20Substrings%20With%20No%20Repeated%20Characters.java) -208 | [Find Largest Value in Each Tree Row](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Largest%20Value%20in%20Each%20Tree%20Row.java) -209 | [Find Leaves of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Leaves%20of%20Binary%20Tree.java) -210 | [Find Minimum in Rotated Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Minimum%20in%20Rotated%20Sorted%20Array.java) -211 | [Find Missing Observations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Missing%20Observations.java) -212 | [Find Nearest Right Node in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Nearest%20Right%20Node%20in%20Binary%20Tree.java) -213 | [Find Original Array From Doubled Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Original%20Array%20From%20Doubled%20Array.java) -214 | [Find Peak Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Peak%20Element.java) -215 | [Find Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Permutation.java) -216 | [Find Players With Zero or One Losses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Players%20With%20Zero%20or%20One%20Losses.java) -217 | [Find Right Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Right%20Interval.java) -218 | [Find Root of N-Ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Root%20of%20N-Ary%20Tree.java) -219 | [Find Smallest Common Element in All Rows](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Smallest%20Common%20Element%20in%20All%20Rows.java) -220 | [Find The Original Array of Prefix Xor](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20The%20Original%20Array%20of%20Prefix%20Xor.java) -221 | [Find Triangular Sum of an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Triangular%20Sum%20of%20an%20Array.java) -222 | [Find a Corresponding Node of a Binary Tree in a Clone of That Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20a%20Corresponding%20Node%20of%20a%20Binary%20Tree%20in%20a%20Clone%20of%20That%20Tree.java) -223 | [Find all Duplicates in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20all%20Duplicates%20in%20an%20Array.java) -224 | [Find and Replace Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20and%20Replace%20Pattern.java) -225 | [Find and Replace in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20and%20Replace%20in%20String.java) -226 | [Find the Celebrity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Celebrity.java) -227 | [Find the City With the Smallest Number of Neighbors at a Threshold Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20City%20With%20the%20Smallest%20Number%20of%20Neighbors%20at%20a%20Threshold%20Distance.java) -228 | [Find the Duplicate Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Duplicate%20Number.java) -229 | [Find the Index of the First Occurrence in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Index%20of%20the%20First%20Occurrence%20in%20a%20String.java) -230 | [Find the Index of the Large Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Index%20of%20the%20Large%20Integer.java) -231 | [Find the Kth Largest Integer in the Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Kth%20Largest%20Integer%20in%20the%20Array.java) -232 | [Find the Minimum and Maximum Number of Nodes Between Critical Points](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Minimum%20and%20Maximum%20Number%20of%20Nodes%20Between%20Critical%20Points.java) -233 | [Find the Student that Will Replace the Chalk](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Student%20that%20Will%20Replace%20the%20Chalk.java) -234 | [Find the Winner of an Array Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Winner%20of%20an%20Array%20Game.java) -235 | [Finding the Users Active Minutes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Finding%20the%20Users%20Active%20Minutes.java) -236 | [First Unique Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/First%20Unique%20Number.java) -237 | [Flatten 2D Vector](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%202D%20Vector.java) -238 | [Flatten Binary Tree to Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%20Binary%20Tree%20to%20Linked%20List.java) -239 | [Flatten Nested List Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%20Nested%20List%20Iterator.java) -240 | [Flatten a Multilevel Doubly Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%20a%20Multilevel%20Doubly%20Linked%20List.java) -241 | [Flip Equivalent Binary Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flip%20Equivalent%20Binary%20Trees.java) -242 | [Four Divisors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Four%20Divisors.java) -243 | [Fraction to Recurring Decimal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Fraction%20to%20Recurring%20Decimal.java) -244 | [Friend Circles](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Friend%20Circles.java) -245 | [Friends Of Appropriate Ages](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Friends%20Of%20Appropriate%20Ages.java) -246 | [Fruit Into Baskets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Fruit%20Into%20Baskets.java) -247 | [Furthest Building You Can Reach](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Furthest%20Building%20You%20Can%20Reach.java) -248 | [Game of Life](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Game%20of%20Life.java) -249 | [Gas Station](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Gas%20Station.java) -250 | [Generate Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Generate%20Parentheses.java) -251 | [Graph Valid Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Graph%20Valid%20Tree.java) -252 | [Gray Code](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Gray%20Code.java) -253 | [Group Anagrams](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Group%20Anagrams.java) -254 | [Group Shifted Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Group%20Shifted%20Strings.java) -255 | [Group the People Given the Group Size They Belong To](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Group%20the%20People%20Given%20the%20Group%20Size%20They%20Belong%20To.java) -256 | [Grumpy Bookstore Owner](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Grumpy%20Bookstore%20Owner.java) -257 | [Guess Number Higher or Lower II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Guess%20Number%20Higher%20or%20Lower%20II.java) -258 | [H-Index II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/H-Index%20II.java) -259 | [H-Index](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/H-Index.java) -260 | [HTML Entity Parser](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/HTML%20Entity%20Parser.java) -261 | [Hand of Straights](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Hand%20of%20Straights.java) -262 | [House Robber II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/House%20Robber%20II.java) -263 | [House Robber III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/House%20Robber%20III.java) -264 | [House Robber](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/House%20Robber.java) -265 | [Image Overlap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Image%20Overlap.java) -266 | [Implement Magic Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Implement%20Magic%20Dictionary.java) -267 | [Implement Rand10() Using Rand7()](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Implement%20Rand10()%20Using%20Rand7().java) -268 | [Implement Trie (Prefix Tree)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Implement%20Trie%20(Prefix%20Tree).java) -269 | [Implement Trie II (Prefix Tree)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Implement%20Trie%20II%20(Prefix%20Tree).java) -270 | [Increasing Subsequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Increasing%20Subsequences.java) -271 | [Increasing Triplet Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Increasing%20Triplet%20Subsequence.java) -272 | [Incremental Memory Leak](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Incremental%20Memory%20Leak.java) -273 | [Inorder Successor in BST II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Inorder%20Successor%20in%20BST%20II.java) -274 | [Inorder Successor in BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Inorder%20Successor%20in%20BST.java) -275 | [Insert Delete GetRandom O(1)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20Delete%20GetRandom%20O(1).java) -276 | [Insert Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20Interval.java) -277 | [Insert Into a Cyclic Sorted List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20Into%20a%20Cyclic%20Sorted%20List.java) -278 | [Insert into a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20into%20a%20Binary%20Search%20Tree.java) -279 | [Insert into a Sorted Circular Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20into%20a%20Sorted%20Circular%20Linked%20List.java) -280 | [Insertion Sort List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insertion%20Sort%20List.java) -281 | [Insufficient Nodes in Root to Leaf Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insufficient%20Nodes%20in%20Root%20to%20Leaf%20Paths.java) -282 | [Integer To Roman](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Integer%20To%20Roman.java) -283 | [Interleaving String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Interleaving%20String.java) -284 | [Interval List Intersections](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Interval%20List%20Intersections.java) -285 | [Invalid Transactions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Invalid%20Transactions.java) -286 | [Is Graph Bipartite](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Is%20Graph%20Bipartite.java) -287 | [Iterator for Combination](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Iterator%20for%20Combination.java) -288 | [Jump Game II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Jump%20Game%20II.java) -289 | [Jump Game III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Jump%20Game%20III.java) -290 | [Jump Game VI](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Jump%20Game%20VI.java) -291 | [Jump Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Jump%20Game.java) -292 | [K Closest Points to Origin](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/K%20Closest%20Points%20to%20Origin.java) -293 | [K Radius Subarray Averages](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/K%20Radius%20Subarray%20Averages.java) -294 | [Keys and Rooms](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Keys%20and%20Rooms.java) -295 | [Kill Process](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kill%20Process.java) -296 | [Knight Dialer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Knight%20Dialer.java) -297 | [Knight Probability in Chessboard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Knight%20Probability%20in%20Chessboard.java) -298 | [Koko Eating Bananas](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Koko%20Eating%20Bananas.java) -299 | [Kth Largest Element in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kth%20Largest%20Element%20in%20an%20Array.java) -300 | [Kth Largest Sum in a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kth%20Largest%20Sum%20in%20a%20Binary%20Tree.java) -301 | [Kth Smallest Element in a BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kth%20Smallest%20Element%20in%20a%20BST.java) -302 | [Kth Smallest Element in a Sorted Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kth%20Smallest%20Element%20in%20a%20Sorted%20Matrix.java) -303 | [LRU Cache](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/LRU%20Cache.java) -304 | [Large Divisble Subset](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Large%20Divisble%20Subset.java) -305 | [Largest BST Subtree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Largest%20BST%20Subtree.java) -306 | [Largest Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Largest%20Number.java) -307 | [Largest Time for Given Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Largest%20Time%20for%20Given%20Digits.java) -308 | [Last Moment Before All Ants Fall Out of a Plank](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Last%20Moment%20Before%20All%20Ants%20Fall%20Out%20of%20a%20Plank.java) -309 | [Last Stone Weight II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Last%20Stone%20Weight%20II.java) -310 | [Least Number of Unique Integers after K Removals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Least%20Number%20of%20Unique%20Integers%20after%20K%20Removals.java) -311 | [Leftmost Column with at Least a One](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Leftmost%20Column%20with%20at%20Least%20a%20One.java) -312 | [Length of the Longest Alphabetical Continuous Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Length%20of%20the%20Longest%20Alphabetical%20Continuous%20Substring.java) -313 | [Letter Combinations of a Phone Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Letter%20Combinations%20of%20a%20Phone%20Number.java) -314 | [Letter Tiles Possibilities](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Letter%20Tiles%20Possibilities.java) -315 | [Lexicographical Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lexicographical%20Numbers.java) -316 | [Lexicographically Smallest Equivalent String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lexicographically%20Smallest%20Equivalent%20String.java) -317 | [Line Reflection](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Line%20Reflection.java) -318 | [Linked List Components](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20Components.java) -319 | [Linked List Cycle II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20Cycle%20II.java) -320 | [Linked List Random Node](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20Random%20Node.java) -321 | [Linked List in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20in%20Binary%20Tree.java) -322 | [Lonely Pixel I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lonely%20Pixel%20I.java) -323 | [Longest Absolute File Path](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Absolute%20File%20Path.java) -324 | [Longest Arithmetic Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Arithmetic%20Sequence.java) -325 | [Longest Arithmetic Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Arithmetic%20Subsequence.java) -326 | [Longest Consecutive Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Consecutive%20Sequence.java) -327 | [Longest Continuous Subarray With Absolute Diff Less Than or Equal to Limit](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Continuous%20Subarray%20With%20Absolute%20Diff%20Less%20Than%20or%20Equal%20to%20Limit.java) -328 | [Longest Happy String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Happy%20String.java) -329 | [Longest Increasing Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Increasing%20Subsequence.java) -330 | [Longest Line of Consecutive One in Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Line%20of%20Consecutive%20One%20in%20Matrix.java) -331 | [Longest Palindromic Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Palindromic%20Subsequence.java) -332 | [Longest Palindromic Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Palindromic%20Substring.java) -333 | [Longest String Chain](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20String%20Chain.java) -334 | [Longest Substring Without Repeating Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Substring%20Without%20Repeating%20Characters.java) -335 | [Longest Substring with At Most K Distinct Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Substring%20with%20At%20Most%20K%20Distinct%20Characters.java) -336 | [Longest Substring with At Most Two Distinct Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Substring%20with%20At%20Most%20Two%20Distinct%20Characters.java) -337 | [Longest Uploaded Prefix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Uploaded%20Prefix.java) -338 | [Longest Well-Performing Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Well-Performing%20Interval.java) -339 | [Longest Word With All Prefixes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Word%20With%20All%20Prefixes.java) -340 | [Longest Word in Dictionary through Deleting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Word%20in%20Dictionary%20through%20Deleting.java) -341 | [Longest ZigZag Path in a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20ZigZag%20Path%20in%20a%20Binary%20Tree.java) -342 | [Lowest Common Ancestor of Deepest Leaves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lowest%20Common%20Ancestor%20of%20Deepest%20Leaves.java) -343 | [Lowest Common Ancestor of a Binary Tree III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lowest%20Common%20Ancestor%20of%20a%20Binary%20Tree%20III.java) -344 | [Lowest Common Ancestor of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lowest%20Common%20Ancestor%20of%20a%20Binary%20Tree.java) -345 | [Majority Element II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Majority%20Element%20II.java) -346 | [Making File Names Unique](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Making%20File%20Names%20Unique.java) -347 | [Map Sum Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Map%20Sum%20Pairs.java) -348 | [Masking Personal Information](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Masking%20Personal%20Information.java) -349 | [Matchsticks to Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Matchsticks%20to%20Square.java) -350 | [Max Area of Island](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Area%20of%20Island.java) -351 | [Max Chunks To Make Sorted](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Chunks%20To%20Make%20Sorted.java) -352 | [Max Consecutives Ones II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Consecutives%20Ones%20II.java) -353 | [Max Increase to Keep City Skyline](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Increase%20to%20Keep%20City%20Skyline.java) -354 | [Max Number of K-Sum Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Number%20of%20K-Sum%20Pairs.java) -355 | [Max Sum of a Pair With Equal Sum of Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Sum%20of%20a%20Pair%20With%20Equal%20Sum%20of%20Digits.java) -356 | [Maximal Network Rank](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximal%20Network%20Rank.java) -357 | [Maximal Score After Applying K Operations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximal%20Score%20After%20Applying%20K%20Operations.java) -358 | [Maximize Distance to Closest Person](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximize%20Distance%20to%20Closest%20Person.java) -359 | [Maximize Number of Subsequences in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximize%20Number%20of%20Subsequences%20in%20a%20String.java) -360 | [Maximize the Topmost Element After K Moves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximize%20the%20Topmost%20Element%20After%20K%20Moves.java) -361 | [Maximum Absolute Sum of Any Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Absolute%20Sum%20of%20Any%20Subarray.java) -362 | [Maximum Area of a Piece of Cake After Horizontal and Vertical Cuts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Area%20of%20a%20Piece%20of%20Cake%20After%20Horizontal%20and%20Vertical%20Cuts.java) -363 | [Maximum Average Subtree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Average%20Subtree.java) -364 | [Maximum Bags With Full Capacity of Rocks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Bags%20With%20Full%20Capacity%20of%20Rocks.java) -365 | [Maximum Binary Tree II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Binary%20Tree%20II.java) -366 | [Maximum Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Binary%20Tree.java) -367 | [Maximum Consecutive Floors Without Special Floors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Consecutive%20Floors%20Without%20Special%20Floors.java) -368 | [Maximum Difference Between Node and Ancestor](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Difference%20Between%20Node%20and%20Ancestor.java) -369 | [Maximum Distance Between a Pair of Values](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Distance%20Between%20a%20Pair%20of%20Values.java) -370 | [Maximum Erasure Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Erasure%20Value.java) -371 | [Maximum Ice Cream Bars](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Ice%20Cream%20Bars.java) -372 | [Maximum Length of Pair Chain](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Length%20of%20Pair%20Chain.java) -373 | [Maximum Length of Repeated Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Length%20of%20Repeated%20Subarray.java) -374 | [Maximum Length of Subarray With Positive Product](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Length%20of%20Subarray%20With%20Positive%20Product.java) -375 | [Maximum Level Sum of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Level%20Sum%20of%20a%20Binary%20Tree.java) -376 | [Maximum Matching of Players With Trainers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Matching%20of%20Players%20With%20Trainers.java) -377 | [Maximum Nesting Depth of Two Valid Parentheses Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Nesting%20Depth%20of%20Two%20Valid%20Parentheses%20Strings.java) -378 | [Maximum Number of Coins You Can Get](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Coins%20You%20Can%20Get.java) -379 | [Maximum Number of Events That Can Be Attended](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Events%20That%20Can%20Be%20Attended.java) -380 | [Maximum Number of Groups Entering a Competition](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Groups%20Entering%20a%20Competition.java) -381 | [Maximum Number of Integers to Choose From a Range I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Integers%20to%20Choose%20From%20a%20Range%20I.java) -382 | [Maximum Number of Non-Overlapping Subarrays With Sum Equals Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Non-Overlapping%20Subarrays%20With%20Sum%20Equals%20Target.java) -383 | [Maximum Number of Occurrences of a Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Occurrences%20of%20a%20Substring.java) -384 | [Maximum Number of Vowels in a Substring of Given Length](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Vowels%20in%20a%20Substring%20of%20Given%20Length.java) -385 | [Maximum Points You Can Obtain from Cards](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Points%20You%20Can%20Obtain%20from%20Cards.java) -386 | [Maximum Product Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Product%20Subarray.java) -387 | [Maximum Product of Splitted Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Product%20of%20Splitted%20Binary%20Tree.java) -388 | [Maximum Product of Word Lengths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Product%20of%20Word%20Lengths.java) -389 | [Maximum Score From Removing Stones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Score%20From%20Removing%20Stones.java) -390 | [Maximum Score from Performing Multiplication Operations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Score%20from%20Performing%20Multiplication%20Operations.java) -391 | [Maximum Size Subarray Sum Equals k](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Size%20Subarray%20Sum%20Equals%20k.java) -392 | [Maximum Star Sum of a Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Star%20Sum%20of%20a%20Graph.java) -393 | [Maximum Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Subarray.java) -394 | [Maximum Sum of Distinct Subarrays With Length K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Sum%20of%20Distinct%20Subarrays%20With%20Length%20K.java) -395 | [Maximum Sum of an Hourglass](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Sum%20of%20an%20Hourglass.java) -396 | [Maximum Swap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Swap.java) -397 | [Maximum Total Importance of Roads](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Total%20Importance%20of%20Roads.java) -398 | [Maximum Twin Sum of a Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Twin%20Sum%20of%20a%20Linked%20List.java) -399 | [Maximum Value after Insertion](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Value%20after%20Insertion.java) -400 | [Maximum Width Ramp](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Width%20Ramp.java) -401 | [Maximum Width of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Width%20of%20Binary%20Tree.java) -402 | [Maximum XOR of Two Numbers in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20XOR%20of%20Two%20Numbers%20in%20an%20Array.java) -403 | [Maximum of Absolute Value Expression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20of%20Absolute%20Value%20Expression.java) -404 | [Meeting Rooms II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Meeting%20Rooms%20II.java) -405 | [Meeting Scheduler](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Meeting%20Scheduler.java) -406 | [Merge In Between Linked Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Merge%20In%20Between%20Linked%20Lists.java) -407 | [Merge Intervals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Merge%20Intervals.java) -408 | [Merge Nodes in Between Zeros](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Merge%20Nodes%20in%20Between%20Zeros.java) -409 | [Min Cost to Connect All Points](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Min%20Cost%20to%20Connect%20All%20Points.java) -410 | [Min Stack](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Min%20Stack.java) -411 | [Minesweeper](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minesweeper.java) -412 | [Mini Parser](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Mini%20Parser.java) -413 | [Minimize Maximum Pair Sum in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimize%20Maximum%20Pair%20Sum%20in%20Array.java) -414 | [Minimize Product Sum of Two Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimize%20Product%20Sum%20of%20Two%20Arrays.java) -415 | [Minimum Add to Make Parentheses Valid](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Add%20to%20Make%20Parentheses%20Valid.java) -416 | [Minimum Amount of Time to Collect Garbage](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Amount%20of%20Time%20to%20Collect%20Garbage.java) -417 | [Minimum Area Rectangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Area%20Rectangle.java) -418 | [Minimum Average Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Average%20Difference.java) -419 | [Minimum Consecutive Cards to Pick Up](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Consecutive%20Cards%20to%20Pick%20Up.java) -420 | [Minimum Cost to Connect Sticks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Cost%20to%20Connect%20Sticks.java) -421 | [Minimum Deletion Cost to Avoid Repeating Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Deletion%20Cost%20to%20Avoid%20Repeating%20Letters.java) -422 | [Minimum Deletions to Make Array Beautiful](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Deletions%20to%20Make%20Array%20Beautiful.java) -423 | [Minimum Deletions to Make Character Frequencies Unique](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Deletions%20to%20Make%20Character%20Frequencies%20Unique.java) -424 | [Minimum Domino Rotations For Equal Row](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Domino%20Rotations%20For%20Equal%20Row.java) -425 | [Minimum Falling Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Falling%20Path%20Sum.java) -426 | [Minimum Fuel Cost to Report to the Capital](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Fuel%20Cost%20to%20Report%20to%20the%20Capital.java) -427 | [Minimum Genetic Mutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Genetic%20Mutation.java) -428 | [Minimum Health to Beat Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Health%20to%20Beat%20Game.java) -429 | [Minimum Height Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Height%20Trees.java) -430 | [Minimum Knight Moves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Knight%20Moves.java) -431 | [Minimum Moves to Equal Array Elements II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Moves%20to%20Equal%20Array%20Elements%20II.java) -432 | [Minimum Moves to Equal Array Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Moves%20to%20Equal%20Array%20Elements.java) -433 | [Minimum Moves to Reach Target Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Moves%20to%20Reach%20Target%20Score.java) -434 | [Minimum Number of Arrows to Burst Balloons](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Number%20of%20Arrows%20to%20Burst%20Balloons.java) -435 | [Minimum Number of Steps to Make Two Strings Anagram II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Number%20of%20Steps%20to%20Make%20Two%20Strings%20Anagram%20II.java) -436 | [Minimum Number of Steps to Make Two Strings Anagram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Number%20of%20Steps%20to%20Make%20Two%20Strings%20Anagram.java) -437 | [Minimum Number of Vertices to Reach All Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Number%20of%20Vertices%20to%20Reach%20All%20Nodes.java) -438 | [Minimum Operations to Make Array Equal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Operations%20to%20Make%20Array%20Equal.java) -439 | [Minimum Operations to Reduce X to Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Operations%20to%20Reduce%20X%20to%20Zero.java) -440 | [Minimum Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Path%20Sum.java) -441 | [Minimum Remove to Make Valid Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Remove%20to%20Make%20Valid%20Parentheses.java) -442 | [Minimum Rounds to Complete All Tasks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Rounds%20to%20Complete%20All%20Tasks.java) -443 | [Minimum Score Triangulation of Polygon](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Score%20Triangulation%20of%20Polygon.java) -444 | [Minimum Size Subarray Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Size%20Subarray%20Sum.java) -445 | [Minimum Swaps to Group All 1's Together](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Swaps%20to%20Group%20All%201's%20Together.java) -446 | [Minimum Time Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Time%20Difference.java) -447 | [Minimum Time to Collect All Apples in a Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Time%20to%20Collect%20All%20Apples%20in%20a%20Tree.java) -448 | [Minimum Time to Complete Trips](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Time%20to%20Complete%20Trips.java) -449 | [Minimum Time to Make Rope Colorful](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Time%20to%20Make%20Rope%20Colorful.java) -450 | [Mirror Reflection](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Mirror%20Reflection.java) -451 | [Missing Element in Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Missing%20Element%20in%20Sorted%20Array.java) -452 | [Most Frequent Subtree Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Most%20Frequent%20Subtree%20Sum.java) -453 | [Most Popular Video Creator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Most%20Popular%20Video%20Creator.java) -454 | [Most Profit Assigning Work](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Most%20Profit%20Assigning%20Work.java) -455 | [Most Stones Removed with Same Row or Column](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Most%20Stones%20Removed%20with%20Same%20Row%20or%20Column.java) -456 | [Multiply Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Multiply%20Strings.java) -457 | [My Calendar I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/My%20Calendar%20I.java) -458 | [My Calendar II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/My%20Calendar%20II.java) -459 | [N-ary Tree Level Order Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/N-ary%20Tree%20Level%20Order%20Traversal.java) -460 | [Nearest Exit from Entrance in Maze](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Nearest%20Exit%20from%20Entrance%20in%20Maze.java) -461 | [Nested List Weight Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Nested%20List%20Weight%20Sum%20II.java) -462 | [Network Delay Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Network%20Delay%20Time.java) -463 | [Next Closest Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Closest%20Time.java) -464 | [Next Greater Element II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Greater%20Element%20II.java) -465 | [Next Greater Element III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Greater%20Element%20III.java) -466 | [Next Greater Node In Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Greater%20Node%20In%20Linked%20List.java) -467 | [Next Greater Numerically Balanced Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Greater%20Numerically%20Balanced%20Number.java) -468 | [Next Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Permutation.java) -469 | [Node With Highest Edge Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Node%20With%20Highest%20Edge%20Score.java) -470 | [Non Overlapping Intervals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Non%20Overlapping%20Intervals.java) -471 | [Non-decreasing Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Non-decreasing%20Array.java) -472 | [Number of Burgers with No Waste of Ingredients](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Burgers%20with%20No%20Waste%20of%20Ingredients.java) -473 | [Number of Closed Islands](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Closed%20Islands.java) -474 | [Number of Connected Components in an Undirected Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Connected%20Components%20in%20an%20Undirected%20Graph.java) -475 | [Number of Dice Rolls With Target Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Dice%20Rolls%20With%20Target%20Sum.java) -476 | [Number of Distinct Islands](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Distinct%20Islands.java) -477 | [Number of Distinct Substrings in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Distinct%20Substrings%20in%20a%20String.java) -478 | [Number of Enclaves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Enclaves.java) -479 | [Number of Islands](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Islands.java) -480 | [Number of Laser Beams in a Bank](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Laser%20Beams%20in%20a%20Bank.java) -481 | [Number of Longest Increasing Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Longest%20Increasing%20Subsequence.java) -482 | [Number of Matching Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Matching%20Subsequence.java) -483 | [Number of Matching Subsequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Matching%20Subsequences.java) -484 | [Number of Nodes in the Sub-Tree With the Same Label](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Nodes%20in%20the%20Sub-Tree%20With%20the%20Same%20Label.java) -485 | [Number of Pairs of Interchangeable Rectangles](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Pairs%20of%20Interchangeable%20Rectangles.java) -486 | [Number of Pairs of Strings With Concatenation Equal to Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Pairs%20of%20Strings%20With%20Concatenation%20Equal%20to%20Target.java) -487 | [Number of Provinces](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Provinces.java) -488 | [Number of Smooth Descent Periods of a Stock](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Smooth%20Descent%20Periods%20of%20a%20Stock.java) -489 | [Number of Sub-arrays of Size K and Average Greater than or Equal to Threshold](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Sub-arrays%20of%20Size%20K%20and%20Average%20Greater%20than%20or%20Equal%20to%20Threshold.java) -490 | [Number of Subarrays with Bounded Maximum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Subarrays%20with%20Bounded%20Maximum.java) -491 | [Number of Substrings Containing All Three Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Substrings%20Containing%20All%20Three%20Characters.java) -492 | [Number of Substrings With Only 1s](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Substrings%20With%20Only%201s.java) -493 | [Number of Ways to Split Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Ways%20to%20Split%20Array.java) -494 | [Number of Zero-Filled Subarrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Zero-Filled%20Subarrays.java) -495 | [Numbers With Same Consecutive Differences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Numbers%20With%20Same%20Consecutive%20Differences.java) -496 | [Odd Even Linked Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Odd%20Even%20Linked%20Lists.java) -497 | [One Edit Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/One%20Edit%20Distance.java) -498 | [Ones and Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Ones%20and%20Zeroes.java) -499 | [Online Election](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Online%20Election.java) -500 | [Online Stock Span](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Online%20Stock%20Span.java) -501 | [Open The Lock](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Open%20The%20Lock.java) -502 | [Optimal Division](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Optimal%20Division.java) -503 | [Optimal Partition of String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Optimal%20Partition%20of%20String.java) -504 | [Out of Boundary Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Out%20of%20Boundary%20Paths.java) -505 | [Output Contest Matches](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Output%20Contest%20Matches.java) -506 | [Pacific Atlantic Water Flow](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pacific%20Atlantic%20Water%20Flow.java) -507 | [Palindrome Partitioning](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Palindrome%20Partitioning.java) -508 | [Palindromic Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Palindromic%20Substrings.java) -509 | [Pancake Sorting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pancake%20Sorting.java) -510 | [Parallel Courses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Parallel%20Courses.java) -511 | [Partition Array According to Given Pivot](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partition%20Array%20According%20to%20Given%20Pivot.java) -512 | [Partition Equal Subset Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partition%20Equal%20Subset%20Sum.java) -513 | [Partition Labels](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partition%20Labels.java) -514 | [Partition List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partition%20List.java) -515 | [Partitioning Into Minimum Number Of Deci-Binary Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partitioning%20Into%20Minimum%20Number%20Of%20Deci-Binary%20Numbers.java) -516 | [Path Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20Sum%20II.java) -517 | [Path Sum III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20Sum%20III.java) -518 | [Path With Maximum Minimum Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20With%20Maximum%20Minimum%20Value.java) -519 | [Path With Minimum Effort](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20With%20Minimum%20Effort.java) -520 | [Path with Maximum Gold](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20with%20Maximum%20Gold.java) -521 | [Path with Maximum Probability](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20with%20Maximum%20Probability.java) -522 | [Peeking Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Peeking%20Iterator.java) -523 | [People Whose List of Favorite Companies Is Not a Subset of Another List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/People%20Whose%20List%20of%20Favorite%20Companies%20Is%20Not%20a%20Subset%20of%20Another%20List.java) -524 | [Perfect Squares](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Perfect%20Squares.java) -525 | [Permutation in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Permutation%20in%20String.java) -526 | [Permutations II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Permutations%20II.java) -527 | [Permutations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Permutations.java) -528 | [Plus One Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Plus%20One%20Linked%20List.java) -529 | [Populating Next Right Pointers in Each Node II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Populating%20Next%20Right%20Pointers%20in%20Each%20Node%20II.java) -530 | [Populating Next Right Pointers in Each Node](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Populating%20Next%20Right%20Pointers%20in%20Each%20Node.java) -531 | [Possible Bipartition](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Possible%20Bipartition.java) -532 | [Pour Water](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pour%20Water.java) -533 | [Pow(x, n)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pow(x,%20n).java) -534 | [Pow](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pow.java) -535 | [Prime Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Prime%20Palindrome.java) -536 | [Print Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Print%20Binary%20Tree.java) -537 | [Print Immutable Linked List in Reverse](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Print%20Immutable%20Linked%20List%20in%20Reverse.java) -538 | [Print Words Vertically](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Print%20Words%20Vertically.java) -539 | [Prison Cells After N Days](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Prison%20Cells%20After%20N%20Days.java) -540 | [Product of Array Except self](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Product%20of%20Array%20Except%20self.java) -541 | [Product of Two Run-Length Encoded Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Product%20of%20Two%20Run-Length%20Encoded%20Arrays.java) -542 | [Product of the Last K Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Product%20of%20the%20Last%20K%20Numbers.java) -543 | [Pseudo-Palindromic Paths in a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pseudo-Palindromic%20Paths%20in%20a%20Binary%20Tree.java) -544 | [Push Dominoes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Push%20Dominoes.java) -545 | [Put Boxes Into the Warehouse I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Put%20Boxes%20Into%20the%20Warehouse%20I.java) -546 | [Queries on a Permutation With Key](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Queries%20on%20a%20Permutation%20With%20Key.java) -547 | [Queue Reconstruction By Height](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Queue%20Reconstruction%20By%20Height.java) -548 | [RLE Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/RLE%20Iterator.java) -549 | [Rabbits in Forest](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rabbits%20in%20Forest.java) -550 | [Random Pick Index](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Random%20Pick%20Index.java) -551 | [Random Pick With Weight](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Random%20Pick%20With%20Weight.java) -552 | [Range Addition](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Addition.java) -553 | [Range Sum Query - Mutable](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Sum%20Query%20-%20Mutable.java) -554 | [Range Sum Query 2D-Immutable](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Sum%20Query%202D-Immutable.java) -555 | [Range Sum of Sorted Subarray Sums](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Sum%20of%20Sorted%20Subarray%20Sums.java) -556 | [Rank Teams by Votes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rank%20Teams%20by%20Votes.java) -557 | [Reachable Nodes With Restrictions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reachable%20Nodes%20With%20Restrictions.java) -558 | [Rearrange Array Elements by Sign](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rearrange%20Array%20Elements%20by%20Sign.java) -559 | [Reconstruct Original Digits from English](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reconstruct%20Original%20Digits%20from%20English.java) -560 | [Recover Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Recover%20Binary%20Search%20Tree.java) -561 | [Rectangle Area](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rectangle%20Area.java) -562 | [Reduce Array Size to The Half](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reduce%20Array%20Size%20to%20The%20Half.java) -563 | [Reduction Operations to Make the Array Elements Equal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reduction%20Operations%20to%20Make%20the%20Array%20Elements%20Equal.java) -564 | [Remove All Adjacent Duplicates in String II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20All%20Adjacent%20Duplicates%20in%20String%20II.java) -565 | [Remove All Occurrences of a Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20All%20Occurrences%20of%20a%20Substring.java) -566 | [Remove All Ones With Row and Column Flips II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20All%20Ones%20With%20Row%20and%20Column%20Flips%20II.java) -567 | [Remove Comments](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Comments.java) -568 | [Remove Covered Intervals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Covered%20Intervals.java) -569 | [Remove Duplicate Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Duplicate%20Letters.java) -570 | [Remove Duplicates From Sorted Array II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Duplicates%20From%20Sorted%20Array%20II.java) -571 | [Remove Duplicates From an Unsorted Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Duplicates%20From%20an%20Unsorted%20Linked%20List.java) -572 | [Remove Duplicates from Sorted List II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Duplicates%20from%20Sorted%20List%20II.java) -573 | [Remove Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Interval.java) -574 | [Remove K Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20K%20Digits.java) -575 | [Remove Nodes From Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Nodes%20From%20Linked%20List.java) -576 | [Remove Nth Node From End of List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Nth%20Node%20From%20End%20of%20List.java) -577 | [Remove Sub-Folders from the Filesystem](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Sub-Folders%20from%20the%20Filesystem.java) -578 | [Remove Zero Sum Consecutive Nodes from Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Zero%20Sum%20Consecutive%20Nodes%20from%20Linked%20List.java) -579 | [Removing Stars From a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Removing%20Stars%20From%20a%20String.java) -580 | [Reorder Data in Log Files](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reorder%20Data%20in%20Log%20Files.java) -581 | [Reorder List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reorder%20List.java) -582 | [Reorder Routes to Make All Paths Lead to the City Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reorder%20Routes%20to%20Make%20All%20Paths%20Lead%20to%20the%20City%20Zero.java) -583 | [Reordered Power of 2](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reordered%20Power%20of%202.java) -584 | [Reorganize String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reorganize%20String.java) -585 | [Repeated DNA Sequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Repeated%20DNA%20Sequences.java) -586 | [Replace Elements in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Replace%20Elements%20in%20an%20Array.java) -587 | [Replace Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Replace%20Words.java) -588 | [Restore IP Address](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Restore%20IP%20Address.java) -589 | [Restore the Array From Adjacent Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Restore%20the%20Array%20From%20Adjacent%20Pairs.java) -590 | [Reverse Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Integer.java) -591 | [Reverse Linked List II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Linked%20List%20II.java) -592 | [Reverse Nodes in Even Length Groups](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Nodes%20in%20Even%20Length%20Groups.java) -593 | [Reverse Odd Levels of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Odd%20Levels%20of%20Binary%20Tree.java) -594 | [Reverse Substrings Between Each Pair of Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Substrings%20Between%20Each%20Pair%20of%20Parentheses.java) -595 | [Reverse Words in a String II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Words%20in%20a%20String%20II.java) -596 | [Reverse Words in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Words%20in%20a%20String.java) -597 | [Robot Bounded In Circle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Robot%20Bounded%20In%20Circle.java) -598 | [Rotate Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20Array.java) -599 | [Rotate Function](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20Function.java) -600 | [Rotate Image](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20Image.java) -601 | [Rotate List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20List.java) -602 | [Rotated Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotated%20Digits.java) -603 | [Rotting Oranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotting%20Oranges.java) -604 | [Satisfiability of Equality Equations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Satisfiability%20of%20Equality%20Equations.java) -605 | [Satisfisbility of Equality Equations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Satisfisbility%20of%20Equality%20Equations.java) -606 | [Score After Flipping Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Score%20After%20Flipping%20Matrix.java) -607 | [Score of Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Score%20of%20Parentheses.java) -608 | [Search Suggestions System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20Suggestions%20System.java) -609 | [Search a 2D Matrix II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20a%202D%20Matrix%20II.java) -610 | [Search a 2D Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20a%202D%20Matrix.java) -611 | [Search for a range](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20for%20a%20range.java) -612 | [Search in Rotated Sorted Array II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20in%20Rotated%20Sorted%20Array%20II.java) -613 | [Search in Rotated Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20in%20Rotated%20Sorted%20Array.java) -614 | [Search in a Sorted Array of Unknown Size](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20in%20a%20Sorted%20Array%20of%20Unknown%20Size.java) -615 | [Seat Reservation Manager](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Seat%20Reservation%20Manager.java) -616 | [Self Dividing Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Self%20Dividing%20Numbers.java) -617 | [Sender With Largest Word Count](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sender%20With%20Largest%20Word%20Count.java) -618 | [Sentence Similarity II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sentence%20Similarity%20II.java) -619 | [Sentence Similarity III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sentence%20Similarity%20III.java) -620 | [Sequential Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sequential%20Digits.java) -621 | [Serialize and Deserialize BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Serialize%20and%20Deserialize%20BST.java) -622 | [Set Matrix Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Set%20Matrix%20Zeroes.java) -623 | [Shifting Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shifting%20Letters.java) -624 | [Short Encoding of Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Short%20Encoding%20of%20Words.java) -625 | [Shortest Completing Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Completing%20Word.java) -626 | [Shortest Path in Binary Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Path%20in%20Binary%20Matrix.java) -627 | [Shortest Path with Alternating Colors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Path%20with%20Alternating%20Colors.java) -628 | [Shortest Unsorted Continuous Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Unsorted%20Continuous%20Subarray.java) -629 | [Shortest Way to Form String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Way%20to%20Form%20String.java) -630 | [Shortest Word Distance II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Word%20Distance%20II.java) -631 | [Shortest Word Distance III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Word%20Distance%20III.java) -632 | [Shuffle an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shuffle%20an%20Array.java) -633 | [Simple Bank System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Simple%20Bank%20System.java) -634 | [Simplify Path](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Simplify%20Path.java) -635 | [Single Element in a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Single%20Element%20in%20a%20Sorted%20Array.java) -636 | [Single Number II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Single%20Number%20II.java) -637 | [Single Number III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Single%20Number%20III.java) -638 | [Smallest Integer Divisible by K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20Integer%20Divisible%20by%20K.java) -639 | [Smallest Number in Infinite Set](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20Number%20in%20Infinite%20Set.java) -640 | [Smallest String Starting From Leaf](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20String%20Starting%20From%20Leaf.java) -641 | [Smallest String With A Given Numeric Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20String%20With%20A%20Given%20Numeric%20Value.java) -642 | [Smallest String With Swaps](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20String%20With%20Swaps.java) -643 | [Smallest Subtree with all the Deepest Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20Subtree%20with%20all%20the%20Deepest%20Nodes.java) -644 | [Smallest Value of the Rearranged Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20Value%20of%20the%20Rearranged%20Number.java) -645 | [Snakes and Ladders](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Snakes%20and%20Ladders.java) -646 | [Snapshot Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Snapshot%20Array.java) -647 | [Solve the Equation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Solve%20the%20Equation.java) -648 | [Sort An Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20An%20Array.java) -649 | [Sort Characters By Frequency](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Characters%20By%20Frequency.java) -650 | [Sort Colors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Colors.java) -651 | [Sort Integers by The Power Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Integers%20by%20The%20Power%20Value.java) -652 | [Sort List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20List.java) -653 | [Sort Transformed Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Transformed%20Array.java) -654 | [Sort the Jumbled Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20the%20Jumbled%20Numbers.java) -655 | [Sort the Matrix Diagonally](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20the%20Matrix%20Diagonally.java) -656 | [Sort the Students by Their Kth Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20the%20Students%20by%20Their%20Kth%20Score.java) -657 | [Sparse Matrix Multiplication](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sparse%20Matrix%20Multiplication.java) -658 | [Spiral Matrix II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Spiral%20Matrix%20II.java) -659 | [Spiral Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Spiral%20Matrix.java) -660 | [Split Array into Consecutive Subsequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Split%20Array%20into%20Consecutive%20Subsequences.java) -661 | [Split BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Split%20BST.java) -662 | [Split Linked List in Parts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Split%20Linked%20List%20in%20Parts.java) -663 | [Statistics from a Large Sample](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Statistics%20from%20a%20Large%20Sample.java) -664 | [Step-By-Step Directions From a Binary Tree Node to Another](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Step-By-Step%20Directions%20From%20a%20Binary%20Tree%20Node%20to%20Another.java) -665 | [Stock Price Fluctuation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Stock%20Price%20Fluctuation.java) -666 | [Strictly Palindromic Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Strictly%20Palindromic%20Number.java) -667 | [String Compression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/String%20Compression.java) -668 | [String to Integer (atoi)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/String%20to%20Integer%20(atoi).java) -669 | [Subarray Product Less Than K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subarray%20Product%20Less%20Than%20K.java) -670 | [Subarray Sum Equals K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subarray%20Sum%20Equals%20K.java) -671 | [Subarray Sums Divisible by K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subarray%20Sums%20Divisible%20by%20K.java) -672 | [Subdomain Visit Count](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subdomain%20Visit%20Count.java) -673 | [Subrectangle Queries](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subrectangle%20Queries.java) -674 | [Subsets II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subsets%20II.java) -675 | [Subsets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subsets.java) -676 | [Successful Pairs of Spells and Potions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Successful%20Pairs%20of%20Spells%20and%20Potions.java) -677 | [Sum Root to Leaf Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20Root%20to%20Leaf%20Numbers.java) -678 | [Sum of Absolute Differences in a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Absolute%20Differences%20in%20a%20Sorted%20Array.java) -679 | [Sum of Beauty of All Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Beauty%20of%20All%20Substrings.java) -680 | [Sum of Even Numbers After Queries](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Even%20Numbers%20After%20Queries.java) -681 | [Sum of Nodes with Even-Valued Grandparent](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Nodes%20with%20Even-Valued%20Grandparent.java) -682 | [Sum of Numbers With Units Digit K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Numbers%20With%20Units%20Digit%20K.java) -683 | [Sum of Subarray Minimums](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Subarray%20Minimums.java) -684 | [Super Ugly Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Super%20Ugly%20Number.java) -685 | [Surrounded Regions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Surrounded%20Regions.java) -686 | [Swap For Longest Repeated Character Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Swap%20For%20Longest%20Repeated%20Character%20Substring.java) -687 | [Swap Nodes in Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Swap%20Nodes%20in%20Pairs.java) -688 | [Swapping Nodes in a Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Swapping%20Nodes%20in%20a%20Linked%20List.java) -689 | [Synonymous Sentences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Synonymous%20Sentences.java) -690 | [Target Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Target%20Sum.java) -691 | [Task Scheduler](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Task%20Scheduler.java) -692 | [Ternary Expression Parser](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Ternary%20Expression%20Parser.java) -693 | [The Earliest Moment When Everyone Become Friends](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20Earliest%20Moment%20When%20Everyone%20Become%20Friends.java) -694 | [The Number of Full Rounds You Have Played](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20Number%20of%20Full%20Rounds%20You%20Have%20Played.java) -695 | [The Number of Weak Characters in the Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20Number%20of%20Weak%20Characters%20in%20the%20Game.java) -696 | [The k Strongest Values in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20k%20Strongest%20Values%20in%20an%20Array.java) -697 | [The kth Factor of n](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20kth%20Factor%20of%20n.java) -698 | [Throne Inheritence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Throne%20Inheritence.java) -699 | [Time Based Key-Value Store](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Time%20Based%20Key-Value%20Store.java) -700 | [Time Needed to Inform All Employees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Time%20Needed%20to%20Inform%20All%20Employees.java) -701 | [Time Needed to Rearrange a Binary String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Time%20Needed%20to%20Rearrange%20a%20Binary%20String.java) -702 | [Top K Frequent Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Top%20K%20Frequent%20Elements.java) -703 | [Top K Frequent Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Top%20K%20Frequent%20Words.java) -704 | [Total Hamming Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Total%20Hamming%20Distance.java) -705 | [Tree Diameter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Tree%20Diameter.java) -706 | [Triangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Triangle.java) -707 | [Trim a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Trim%20a%20Binary%20Search%20Tree.java) -708 | [Tuple With Same Product](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Tuple%20With%20Same%20Product.java) -709 | [Tweet Counts Per Frequency](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Tweet%20Counts%20Per%20Frequency.java) -710 | [Two City Scheduling](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Two%20City%20Scheduling.java) -711 | [Two Sum BSTs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Two%20Sum%20BSTs.java) -712 | [Two Sum II - Input Array Is Sorted](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Two%20Sum%20II%20-%20Input%20Array%20Is%20Sorted.java) -713 | [UTF-8 Validation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/UTF-8%20Validation.java) -714 | [Ugly Number II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Ugly%20Number%20II.java) -715 | [Uncrossed Lines](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Uncrossed%20Lines.java) -716 | [Unique Binary Search Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Binary%20Search%20Trees.java) -717 | [Unique Paths II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Paths%20II.java) -718 | [Unique Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Paths.java) -719 | [Unique Word Abbrevation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Word%20Abbrevation.java) -720 | [Valid Parenthesis String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Parenthesis%20String.java) -721 | [Valid Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Square.java) -722 | [Valid Sudoku](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Sudoku.java) -723 | [Valid Tic-Tac-Toe State](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Tic-Tac-Toe%20State.java) -724 | [Valid Triangle Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Triangle%20Number.java) -725 | [Validate Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Validate%20Binary%20Search%20Tree.java) -726 | [Validate IP Address](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Validate%20IP%20Address.java) -727 | [Validate Stack Sequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Validate%20Stack%20Sequences.java) -728 | [Verify Preorder Serialization of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Verify%20Preorder%20Serialization%20of%20a%20Binary%20Tree.java) -729 | [Vowel Spellchecker](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Vowel%20Spellchecker.java) -730 | [Vowels of All Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Vowels%20of%20All%20Substrings.java) -731 | [Walls and Gates](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Walls%20and%20Gates.java) -732 | [Water & Jug Problem](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Water%20&%20Jug%20Problem.java) -733 | [Watering Plants](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Watering%20Plants.java) -734 | [Web Crawler](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Web%20Crawler.java) -735 | [Wiggle Sort](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Wiggle%20Sort.java) -736 | [Wiggle Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Wiggle%20Subsequence.java) -737 | [Word Break](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Word%20Break.java) -738 | [Word Ladder](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Word%20Ladder.java) -739 | [Word Search](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Word%20Search.java) -740 | [Word Subsets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Word%20Subsets.java) -741 | [ZigZag Conversion](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/ZigZag%20Conversion.java) -742 | [Zigzag Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Zigzag%20Iterator.java) +7 | [4 Keys Keyboard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/4%20Keys%20Keyboard.java) +8 | [4 Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/4%20Sum%20II.java) +9 | [4Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/4Sum%20II.java) +10 | [4Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/4Sum.java) +11 | [Accounts Merge](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Accounts%20Merge.java) +12 | [Add Bold Tag in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20Bold%20Tag%20in%20String.java) +13 | [Add Minimum Number of Rungs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20Minimum%20Number%20of%20Rungs.java) +14 | [Add One Row to Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20One%20Row%20to%20Tree.java) +15 | [Add Two Numbers II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20Two%20Numbers%20II.java) +16 | [Add Two Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20Two%20Numbers.java) +17 | [Adding Spaces to a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Adding%20Spaces%20to%20a%20String.java) +18 | [Adding Two Negabinary Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Adding%20Two%20Negabinary%20Numbers.java) +19 | [Advantage Shuffle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Advantage%20Shuffle.java) +20 | [Alert Using Same Key-Card Three or More Times in a One Hour Period](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Alert%20Using%20Same%20Key-Card%20Three%20or%20More%20Times%20in%20a%20One%20Hour%20Period.java) +21 | [All Ancestors of a Node in a Directed Acyclic Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Ancestors%20of%20a%20Node%20in%20a%20Directed%20Acyclic%20Graph.java) +22 | [All Divisions With the Highest Score of a Binary Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Divisions%20With%20the%20Highest%20Score%20of%20a%20Binary%20Array.java) +23 | [All Elements in Two Binary Search Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Elements%20in%20Two%20Binary%20Search%20Trees.java) +24 | [All Nodes Distance K in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Nodes%20Distance%20K%20in%20Binary%20Tree.java) +25 | [All Paths From Source to Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Paths%20From%20Source%20to%20Target.java) +26 | [All Paths from Source Lead to Destination](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Paths%20from%20Source%20Lead%20to%20Destination.java) +27 | [All Possible Full Binary Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Possible%20Full%20Binary%20Trees.java) +28 | [Analyze User Website Visit Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Analyze%20User%20Website%20Visit%20Pattern.java) +29 | [Angle Between Hands of a Clock](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Angle%20Between%20Hands%20of%20a%20Clock.java) +30 | [Append Characters to String to Make Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Append%20Characters%20to%20String%20to%20Make%20Subsequence.java) +31 | [Append K Integers With Minimal Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Append%20K%20Integers%20With%20Minimal%20Sum.java) +32 | [Apply Discount Every n Orders](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Apply%20Discount%20Every%20n%20Orders.java) +33 | [Apply Discount to Prices](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Apply%20Discount%20to%20Prices.java) +34 | [Arithmetic Slices](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Arithmetic%20Slices.java) +35 | [Arithmetic Subarrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Arithmetic%20Subarrays.java) +36 | [Array Circular Loop](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Array%20Circular%20Loop.java) +37 | [Array Nesting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Array%20Nesting.java) +38 | [As Far from Land as Possible](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/As%20Far%20from%20Land%20as%20Possible.java) +39 | [Asteroid Collision](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Asteroid%20Collision.java) +40 | [Average Waiting Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Average%20Waiting%20Time.java) +41 | [Bag of Tokens](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Bag%20of%20Tokens.java) +42 | [Balance a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Balance%20a%20Binary%20Search%20Tree.java) +43 | [Basic Calculator II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Basic%20Calculator%20II.java) +44 | [Battleships in a board](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Battleships%20in%20a%20board.java) +45 | [Best Time to Buy and Sell Stock II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Best%20Time%20to%20Buy%20and%20Sell%20Stock%20II.java) +46 | [Best Time to Buy and Sell Stock with Cooldown](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Best%20Time%20to%20Buy%20and%20Sell%20Stock%20with%20Cooldown.java) +47 | [Binary Search Tree Iterator II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Search%20Tree%20Iterator%20II.java) +48 | [Binary Search Tree Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Search%20Tree%20Iterator.java) +49 | [Binary Search Tree to Greater Sum Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Search%20Tree%20to%20Greater%20Sum%20Tree.java) +50 | [Binary Tree Coloring Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Coloring%20Game.java) +51 | [Binary Tree Level Order Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Level%20Order%20Traversal.java) +52 | [Binary Tree Longest Consecutive Sequence II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Longest%20Consecutive%20Sequence%20II.java) +53 | [Binary Tree Longest Consecutive Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Longest%20Consecutive%20Sequence.java) +54 | [Binary Tree Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Preorder%20Traversal.java) +55 | [Binary Tree Pruning](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Pruning.java) +56 | [Binary Tree Right Side View](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Right%20Side%20View.java) +57 | [Binary Tree Upside Down](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Upside%20Down.java) +58 | [Binary Tree Vertical Order Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Vertical%20Order%20Traversal.java) +59 | [Binary Tree Zigzag Level Order Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Zigzag%20Level%20Order%20Traversal.java) +60 | [Binary Trees With Factors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Trees%20With%20Factors.java) +61 | [Bitwise AND of Numbers Range](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Bitwise%20AND%20of%20Numbers%20Range.java) +62 | [Boats to Save People](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Boats%20to%20Save%20People.java) +63 | [Bold Words in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Bold%20Words%20in%20String.java) +64 | [Bomb Enemy](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Bomb%20Enemy.java) +65 | [Boundary of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Boundary%20of%20Binary%20Tree.java) +66 | [Brace Expansion](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Brace%20Expansion.java) +67 | [Break a Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Break%20a%20Palindrome.java) +68 | [Broken Calculator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Broken%20Calculator.java) +69 | [Buildings With an Ocean View](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Buildings%20With%20an%20Ocean%20View.java) +70 | [Bulb Switcher](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Bulb%20Switcher.java) +71 | [Camelcase Matching](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Camelcase%20Matching.java) +72 | [Campus Bikes II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Campus%20Bikes%20II.java) +73 | [Campus Bikes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Campus%20Bikes.java) +74 | [Can Convert String in K Moves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Can%20Convert%20String%20in%20K%20Moves.java) +75 | [Can Make Palindrome from Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Can%20Make%20Palindrome%20from%20Substring.java) +76 | [Candy Crush](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Candy%20Crush.java) +77 | [Capacity To Ship Packages Within D Days](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Capacity%20To%20Ship%20Packages%20Within%20D%20Days.java) +78 | [Car Pooling](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Car%20Pooling.java) +79 | [Champagne Tower](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Champagne%20Tower.java) +80 | [Cheapest Flights Within K Stops](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Cheapest%20Flights%20Within%20K%20Stops.java) +81 | [Check Completeness of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20Completeness%20of%20a%20Binary%20Tree.java) +82 | [Check If All 1's Are at Least Length K Places Away](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20If%20All%201's%20Are%20at%20Least%20Length%20K%20Places%20Away.java) +83 | [Check If a String Can Break Another String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20If%20a%20String%20Can%20Break%20Another%20String.java) +84 | [Check If a String Contains All Binary Codes of Size K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20If%20a%20String%20Contains%20All%20Binary%20Codes%20of%20Size%20K.java) +85 | [Check If a String Is a Valid Sequence from Root to Leaves Path in a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20If%20a%20String%20Is%20a%20Valid%20Sequence%20from%20Root%20to%20Leaves%20Path%20in%20a%20Binary%20Tree.java) +86 | [Check if There is a Valid Path in a Grid](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20if%20There%20is%20a%20Valid%20Path%20in%20a%20Grid.java) +87 | [Cinema Seat Allocation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Cinema%20Seat%20Allocation.java) +88 | [Clone Binary Tree With Random Pointer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Clone%20Binary%20Tree%20With%20Random%20Pointer.java) +89 | [Clone Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Clone%20Graph.java) +90 | [Clone N-ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Clone%20N-ary%20Tree.java) +91 | [Closest Nodes Queries in a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Closest%20Nodes%20Queries%20in%20a%20Binary%20Search%20Tree.java) +92 | [Coin Change 2](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Coin%20Change%202.java) +93 | [Coin Change](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Coin%20Change.java) +94 | [Combination Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Combination%20Sum%20II.java) +95 | [Combination Sum III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Combination%20Sum%20III.java) +96 | [Combination Sum IV](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Combination%20Sum%20IV.java) +97 | [Combination Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Combination%20Sum.java) +98 | [Combinations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Combinations.java) +99 | [Compare Version Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Compare%20Version%20Numbers.java) +100 | [Complete Binary Tree Insertor](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Complete%20Binary%20Tree%20Insertor.java) +101 | [Complex Number Multiplication](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Complex%20Number%20Multiplication.java) +102 | [Concatenation of Consecutive Binary Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Concatenation%20of%20Consecutive%20Binary%20Numbers.java) +103 | [Connecting Cities With Minimum Cost](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Connecting%20Cities%20With%20Minimum%20Cost.java) +104 | [Construct Binary Search Tree from Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20Binary%20Search%20Tree%20from%20Preorder%20Traversal.java) +105 | [Construct Binary Tree from Inorder and Postorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20Binary%20Tree%20from%20Inorder%20and%20Postorder%20Traversal.java) +106 | [Construct Binary Tree from Preorder and Inorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20Binary%20Tree%20from%20Preorder%20and%20Inorder%20Traversal.java) +107 | [Construct K Palindrome Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20K%20Palindrome%20Strings.java) +108 | [Construct Quad Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20Quad%20Tree.java) +109 | [Construct String With Repeat Limit](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20String%20With%20Repeat%20Limit.java) +110 | [Container With Most Water](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Container%20With%20Most%20Water.java) +111 | [Contains Duplicate III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Contains%20Duplicate%20III.java) +112 | [Contiguous Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Contiguous%20Array.java) +113 | [Continuous Subarray Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Continuous%20Subarray%20Sum.java) +114 | [Convert Binary Search Tree to Sorted Doubly Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Convert%20Binary%20Search%20Tree%20to%20Sorted%20Doubly%20Linked%20List.java) +115 | [Convert Sorted List to Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Convert%20Sorted%20List%20to%20Binary%20Search%20Tree.java) +116 | [Convert an Array Into a 2D Array With Conditions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Convert%20an%20Array%20Into%20a%202D%20Array%20With%20Conditions.java) +117 | [Copy List with Random Pointer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Copy%20List%20with%20Random%20Pointer.java) +118 | [Corporate Flight Bookings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Corporate%20Flight%20Bookings.java) +119 | [Count Collisions on a Road](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Collisions%20on%20a%20Road.java) +120 | [Count Complete Tree Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Complete%20Tree%20Nodes.java) +121 | [Count Good Nodes in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Good%20Nodes%20in%20Binary%20Tree.java) +122 | [Count Nodes Equal to Average of Subtree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Nodes%20Equal%20to%20Average%20of%20Subtree.java) +123 | [Count Nodes Equal to Sum of Descendants](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Nodes%20Equal%20to%20Sum%20of%20Descendants.java) +124 | [Count Number of Bad Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Number%20of%20Bad%20Pairs.java) +125 | [Count Number of Distinct Integers After Reverse Operations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Number%20of%20Distinct%20Integers%20After%20Reverse%20Operations.java) +126 | [Count Number of Homogenous Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Number%20of%20Homogenous%20Substrings.java) +127 | [Count Number of Teams](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Number%20of%20Teams.java) +128 | [Count Numbers With Unique Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Numbers%20With%20Unique%20Digits.java) +129 | [Count Servers That Communicate](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Servers%20That%20Communicate.java) +130 | [Count Sorted Vowel Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Sorted%20Vowel%20Strings.java) +131 | [Count Square Submatrices with All Ones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Square%20Submatrices%20with%20All%20Ones.java) +132 | [Count Sub Islands](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Sub%20Islands.java) +133 | [Count Submatrices With All Ones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Submatrices%20With%20All%20Ones.java) +134 | [Count Univalue Subtrees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Univalue%20Subtrees.java) +135 | [Count Unreachable Pairs of Nodes in an Undirected Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Unreachable%20Pairs%20of%20Nodes%20in%20an%20Undirected%20Graph.java) +136 | [Count Vowel Strings in Ranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Vowel%20Strings%20in%20Ranges.java) +137 | [Count and Say](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20and%20Say.java) +138 | [Course Schedule II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Course%20Schedule%20II.java) +139 | [Course Schedule](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Course%20Schedule.java) +140 | [Create Binary Tree From Descriptions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Create%20Binary%20Tree%20From%20Descriptions.java) +141 | [Custom Sort String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Custom%20Sort%20String.java) +142 | [Daily Temperatures](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Daily%20Temperatures.java) +143 | [Decode String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Decode%20String.java) +144 | [Decode Ways](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Decode%20Ways.java) +145 | [Decrease Elements To Make Array Zigzag](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Decrease%20Elements%20To%20Make%20Array%20Zigzag.java) +146 | [Deepest Leaves Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Deepest%20Leaves%20Sum.java) +147 | [Delete Leaves With a Given Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Leaves%20With%20a%20Given%20Value.java) +148 | [Delete Node in a BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Node%20in%20a%20BST.java) +149 | [Delete Nodes And Return Forest](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Nodes%20And%20Return%20Forest.java) +150 | [Delete Operation for Two Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Operation%20for%20Two%20Strings.java) +151 | [Delete Tree Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Tree%20Nodes.java) +152 | [Delete the Middle Node of a Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20the%20Middle%20Node%20of%20a%20Linked%20List.java) +153 | [Design A Leaderboard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20A%20Leaderboard.java) +154 | [Design Add and Search Words Data Structure](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Add%20and%20Search%20Words%20Data%20Structure.java) +155 | [Design Authentication Manager](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Authentication%20Manager.java) +156 | [Design Browser History](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Browser%20History.java) +157 | [Design Circular Deque](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Circular%20Deque.java) +158 | [Design Circular Queue](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Circular%20Queue.java) +159 | [Design File System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20File%20System.java) +160 | [Design Front Middle Back Queue](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Front%20Middle%20Back%20Queue.java) +161 | [Design Hit Counter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Hit%20Counter.java) +162 | [Design Log Storage System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Log%20Storage%20System.java) +163 | [Design Phone Directory](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Phone%20Directory.java) +164 | [Design SQL](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20SQL.java) +165 | [Design Snake Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Snake%20Game.java) +166 | [Design Tic-Tac-Toe](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Tic-Tac-Toe.java) +167 | [Design Twitter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Twitter.java) +168 | [Design Underground System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Underground%20System.java) +169 | [Design a File Sharing System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20a%20File%20Sharing%20System.java) +170 | [Design a Stack With Increment Operation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20a%20Stack%20With%20Increment%20Operation.java) +171 | [Design an ATM Machine](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20an%20ATM%20Machine.java) +172 | [Design an Expression Tree With Evaluate Function](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20an%20Expression%20Tree%20With%20Evaluate%20Function.java) +173 | [Determine if Two Strings Are Close](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Determine%20if%20Two%20Strings%20Are%20Close.java) +174 | [Diagonal Traverse](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Diagonal%20Traverse.java) +175 | [Diameter of N-ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Diameter%20of%20N-ary%20Tree.java) +176 | [Display Table of Food Orders in a Restaurant](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Display%20Table%20of%20Food%20Orders%20in%20a%20Restaurant.java) +177 | [Distribute Coins in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Distribute%20Coins%20in%20Binary%20Tree.java) +178 | [Divide Array in Sets of K Consecutive Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Divide%20Array%20in%20Sets%20of%20K%20Consecutive%20Numbers.java) +179 | [Divide Players Into Teams of Equal Skill](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Divide%20Players%20Into%20Teams%20of%20Equal%20Skill.java) +180 | [Divide Two Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Divide%20Two%20Integers.java) +181 | [Dot Product of Two Sparse Vectors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Dot%20Product%20of%20Two%20Sparse%20Vectors.java) +182 | [Encode and Decode Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Encode%20and%20Decode%20Strings.java) +183 | [Encode and Decode TinyURL](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Encode%20and%20Decode%20TinyURL.java) +184 | [Equal Row and Column Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Equal%20Row%20and%20Column%20Pairs.java) +185 | [Escape The Ghosts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Escape%20The%20Ghosts.java) +186 | [Evaluate Division](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Evaluate%20Division.java) +187 | [Evaluate Reverse Polish Notation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Evaluate%20Reverse%20Polish%20Notation.java) +188 | [Evaluate the Bracket Pairs of a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Evaluate%20the%20Bracket%20Pairs%20of%20a%20String.java) +189 | [Even Odd Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Even%20Odd%20Tree.java) +190 | [Exclusive Time of Functions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Exclusive%20Time%20of%20Functions.java) +191 | [Execution of All Suffix Instructions Staying in a Grid](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Execution%20of%20All%20Suffix%20Instructions%20Staying%20in%20a%20Grid.java) +192 | [Expressive Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Expressive%20Words.java) +193 | [Fair Distribution of Cookies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Fair%20Distribution%20of%20Cookies.java) +194 | [Filter Restaurants by Vegan-Friendly, Price and Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Filter%20Restaurants%20by%20Vegan-Friendly,%20Price%20and%20Distance.java) +195 | [Find All Anagrams in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20All%20Anagrams%20in%20a%20String.java) +196 | [Find All Lonely Numbers in the Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20All%20Lonely%20Numbers%20in%20the%20Array.java) +197 | [Find All Possible Recipes from Given Supplies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20All%20Possible%20Recipes%20from%20Given%20Supplies.java) +198 | [Find Bottom Left Tree Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Bottom%20Left%20Tree%20Value.java) +199 | [Find Center of Star Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Center%20of%20Star%20Graph.java) +200 | [Find Closest Node to Given Two Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Closest%20Node%20to%20Given%20Two%20Nodes.java) +201 | [Find Consecutive Integers from a Data Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Consecutive%20Integers%20from%20a%20Data%20Stream.java) +202 | [Find Distance in a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Distance%20in%20a%20Binary%20Tree.java) +203 | [Find Duplicate File in System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Duplicate%20File%20in%20System.java) +204 | [Find Duplicate Subtrees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Duplicate%20Subtrees.java) +205 | [Find Elements in a Contaminated Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Elements%20in%20a%20Contaminated%20Binary%20Tree.java) +206 | [Find First and Last Position of Element in Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20First%20and%20Last%20Position%20of%20Element%20in%20Sorted%20Array.java) +207 | [Find K Closest Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20K%20Closest%20Elements.java) +208 | [Find K Pairs with Smallest Sums](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20K%20Pairs%20with%20Smallest%20Sums.java) +209 | [Find K-Length Substrings With No Repeated Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20K-Length%20Substrings%20With%20No%20Repeated%20Characters.java) +210 | [Find Largest Value in Each Tree Row](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Largest%20Value%20in%20Each%20Tree%20Row.java) +211 | [Find Leaves of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Leaves%20of%20Binary%20Tree.java) +212 | [Find Minimum in Rotated Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Minimum%20in%20Rotated%20Sorted%20Array.java) +213 | [Find Missing Observations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Missing%20Observations.java) +214 | [Find Nearest Right Node in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Nearest%20Right%20Node%20in%20Binary%20Tree.java) +215 | [Find Original Array From Doubled Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Original%20Array%20From%20Doubled%20Array.java) +216 | [Find Peak Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Peak%20Element.java) +217 | [Find Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Permutation.java) +218 | [Find Players With Zero or One Losses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Players%20With%20Zero%20or%20One%20Losses.java) +219 | [Find Right Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Right%20Interval.java) +220 | [Find Root of N-Ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Root%20of%20N-Ary%20Tree.java) +221 | [Find Smallest Common Element in All Rows](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Smallest%20Common%20Element%20in%20All%20Rows.java) +222 | [Find The Original Array of Prefix Xor](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20The%20Original%20Array%20of%20Prefix%20Xor.java) +223 | [Find Triangular Sum of an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Triangular%20Sum%20of%20an%20Array.java) +224 | [Find a Corresponding Node of a Binary Tree in a Clone of That Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20a%20Corresponding%20Node%20of%20a%20Binary%20Tree%20in%20a%20Clone%20of%20That%20Tree.java) +225 | [Find all Duplicates in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20all%20Duplicates%20in%20an%20Array.java) +226 | [Find and Replace Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20and%20Replace%20Pattern.java) +227 | [Find and Replace in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20and%20Replace%20in%20String.java) +228 | [Find the Celebrity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Celebrity.java) +229 | [Find the City With the Smallest Number of Neighbors at a Threshold Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20City%20With%20the%20Smallest%20Number%20of%20Neighbors%20at%20a%20Threshold%20Distance.java) +230 | [Find the Duplicate Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Duplicate%20Number.java) +231 | [Find the Index of the First Occurrence in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Index%20of%20the%20First%20Occurrence%20in%20a%20String.java) +232 | [Find the Index of the Large Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Index%20of%20the%20Large%20Integer.java) +233 | [Find the Kth Largest Integer in the Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Kth%20Largest%20Integer%20in%20the%20Array.java) +234 | [Find the Maximum Divisibility Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Maximum%20Divisibility%20Score.java) +235 | [Find the Minimum and Maximum Number of Nodes Between Critical Points](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Minimum%20and%20Maximum%20Number%20of%20Nodes%20Between%20Critical%20Points.java) +236 | [Find the Score of All Prefixes of an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Score%20of%20All%20Prefixes%20of%20an%20Array.java) +237 | [Find the Student that Will Replace the Chalk](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Student%20that%20Will%20Replace%20the%20Chalk.java) +238 | [Find the Substring With Maximum Cost](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Substring%20With%20Maximum%20Cost.java) +239 | [Find the Winner of an Array Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Winner%20of%20an%20Array%20Game.java) +240 | [Finding the Users Active Minutes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Finding%20the%20Users%20Active%20Minutes.java) +241 | [First Unique Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/First%20Unique%20Number.java) +242 | [Flatten 2D Vector](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%202D%20Vector.java) +243 | [Flatten Binary Tree to Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%20Binary%20Tree%20to%20Linked%20List.java) +244 | [Flatten Nested List Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%20Nested%20List%20Iterator.java) +245 | [Flatten a Multilevel Doubly Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%20a%20Multilevel%20Doubly%20Linked%20List.java) +246 | [Flip Equivalent Binary Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flip%20Equivalent%20Binary%20Trees.java) +247 | [Four Divisors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Four%20Divisors.java) +248 | [Fraction to Recurring Decimal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Fraction%20to%20Recurring%20Decimal.java) +249 | [Friend Circles](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Friend%20Circles.java) +250 | [Friends Of Appropriate Ages](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Friends%20Of%20Appropriate%20Ages.java) +251 | [Fruit Into Baskets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Fruit%20Into%20Baskets.java) +252 | [Furthest Building You Can Reach](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Furthest%20Building%20You%20Can%20Reach.java) +253 | [Game of Life](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Game%20of%20Life.java) +254 | [Gas Station](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Gas%20Station.java) +255 | [Generate Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Generate%20Parentheses.java) +256 | [Graph Valid Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Graph%20Valid%20Tree.java) +257 | [Gray Code](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Gray%20Code.java) +258 | [Group Anagrams](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Group%20Anagrams.java) +259 | [Group Shifted Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Group%20Shifted%20Strings.java) +260 | [Group the People Given the Group Size They Belong To](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Group%20the%20People%20Given%20the%20Group%20Size%20They%20Belong%20To.java) +261 | [Grumpy Bookstore Owner](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Grumpy%20Bookstore%20Owner.java) +262 | [Guess Number Higher or Lower II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Guess%20Number%20Higher%20or%20Lower%20II.java) +263 | [H-Index II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/H-Index%20II.java) +264 | [H-Index](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/H-Index.java) +265 | [HTML Entity Parser](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/HTML%20Entity%20Parser.java) +266 | [Hand of Straights](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Hand%20of%20Straights.java) +267 | [House Robber II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/House%20Robber%20II.java) +268 | [House Robber III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/House%20Robber%20III.java) +269 | [House Robber](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/House%20Robber.java) +270 | [Image Overlap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Image%20Overlap.java) +271 | [Implement Magic Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Implement%20Magic%20Dictionary.java) +272 | [Implement Rand10() Using Rand7()](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Implement%20Rand10()%20Using%20Rand7().java) +273 | [Implement Trie (Prefix Tree)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Implement%20Trie%20(Prefix%20Tree).java) +274 | [Implement Trie II (Prefix Tree)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Implement%20Trie%20II%20(Prefix%20Tree).java) +275 | [Increasing Subsequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Increasing%20Subsequences.java) +276 | [Increasing Triplet Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Increasing%20Triplet%20Subsequence.java) +277 | [Incremental Memory Leak](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Incremental%20Memory%20Leak.java) +278 | [Inorder Successor in BST II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Inorder%20Successor%20in%20BST%20II.java) +279 | [Inorder Successor in BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Inorder%20Successor%20in%20BST.java) +280 | [Insert Delete GetRandom O(1)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20Delete%20GetRandom%20O(1).java) +281 | [Insert Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20Interval.java) +282 | [Insert Into a Cyclic Sorted List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20Into%20a%20Cyclic%20Sorted%20List.java) +283 | [Insert into a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20into%20a%20Binary%20Search%20Tree.java) +284 | [Insert into a Sorted Circular Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20into%20a%20Sorted%20Circular%20Linked%20List.java) +285 | [Insertion Sort List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insertion%20Sort%20List.java) +286 | [Insufficient Nodes in Root to Leaf Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insufficient%20Nodes%20in%20Root%20to%20Leaf%20Paths.java) +287 | [Integer To Roman](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Integer%20To%20Roman.java) +288 | [Interleaving String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Interleaving%20String.java) +289 | [Interval List Intersections](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Interval%20List%20Intersections.java) +290 | [Invalid Transactions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Invalid%20Transactions.java) +291 | [Is Graph Bipartite](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Is%20Graph%20Bipartite.java) +292 | [Iterator for Combination](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Iterator%20for%20Combination.java) +293 | [Jump Game II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Jump%20Game%20II.java) +294 | [Jump Game III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Jump%20Game%20III.java) +295 | [Jump Game VI](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Jump%20Game%20VI.java) +296 | [Jump Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Jump%20Game.java) +297 | [K Closest Points to Origin](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/K%20Closest%20Points%20to%20Origin.java) +298 | [K Radius Subarray Averages](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/K%20Radius%20Subarray%20Averages.java) +299 | [Keys and Rooms](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Keys%20and%20Rooms.java) +300 | [Kill Process](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kill%20Process.java) +301 | [Knight Dialer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Knight%20Dialer.java) +302 | [Knight Probability in Chessboard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Knight%20Probability%20in%20Chessboard.java) +303 | [Koko Eating Bananas](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Koko%20Eating%20Bananas.java) +304 | [Kth Largest Element in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kth%20Largest%20Element%20in%20an%20Array.java) +305 | [Kth Largest Sum in a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kth%20Largest%20Sum%20in%20a%20Binary%20Tree.java) +306 | [Kth Smallest Element in a BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kth%20Smallest%20Element%20in%20a%20BST.java) +307 | [Kth Smallest Element in a Sorted Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kth%20Smallest%20Element%20in%20a%20Sorted%20Matrix.java) +308 | [LRU Cache](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/LRU%20Cache.java) +309 | [Large Divisble Subset](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Large%20Divisble%20Subset.java) +310 | [Largest BST Subtree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Largest%20BST%20Subtree.java) +311 | [Largest Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Largest%20Number.java) +312 | [Largest Time for Given Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Largest%20Time%20for%20Given%20Digits.java) +313 | [Last Moment Before All Ants Fall Out of a Plank](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Last%20Moment%20Before%20All%20Ants%20Fall%20Out%20of%20a%20Plank.java) +314 | [Last Stone Weight II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Last%20Stone%20Weight%20II.java) +315 | [Least Number of Unique Integers after K Removals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Least%20Number%20of%20Unique%20Integers%20after%20K%20Removals.java) +316 | [Leftmost Column with at Least a One](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Leftmost%20Column%20with%20at%20Least%20a%20One.java) +317 | [Length of the Longest Alphabetical Continuous Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Length%20of%20the%20Longest%20Alphabetical%20Continuous%20Substring.java) +318 | [Letter Combinations of a Phone Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Letter%20Combinations%20of%20a%20Phone%20Number.java) +319 | [Letter Tiles Possibilities](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Letter%20Tiles%20Possibilities.java) +320 | [Lexicographical Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lexicographical%20Numbers.java) +321 | [Lexicographically Smallest Equivalent String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lexicographically%20Smallest%20Equivalent%20String.java) +322 | [Line Reflection](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Line%20Reflection.java) +323 | [Linked List Components](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20Components.java) +324 | [Linked List Cycle II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20Cycle%20II.java) +325 | [Linked List Random Node](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20Random%20Node.java) +326 | [Linked List in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20in%20Binary%20Tree.java) +327 | [Lonely Pixel I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lonely%20Pixel%20I.java) +328 | [Longest Absolute File Path](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Absolute%20File%20Path.java) +329 | [Longest Arithmetic Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Arithmetic%20Sequence.java) +330 | [Longest Arithmetic Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Arithmetic%20Subsequence.java) +331 | [Longest Consecutive Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Consecutive%20Sequence.java) +332 | [Longest Continuous Subarray With Absolute Diff Less Than or Equal to Limit](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Continuous%20Subarray%20With%20Absolute%20Diff%20Less%20Than%20or%20Equal%20to%20Limit.java) +333 | [Longest Happy String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Happy%20String.java) +334 | [Longest Increasing Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Increasing%20Subsequence.java) +335 | [Longest Line of Consecutive One in Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Line%20of%20Consecutive%20One%20in%20Matrix.java) +336 | [Longest Palindromic Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Palindromic%20Subsequence.java) +337 | [Longest Palindromic Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Palindromic%20Substring.java) +338 | [Longest String Chain](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20String%20Chain.java) +339 | [Longest Substring Without Repeating Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Substring%20Without%20Repeating%20Characters.java) +340 | [Longest Substring with At Most K Distinct Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Substring%20with%20At%20Most%20K%20Distinct%20Characters.java) +341 | [Longest Substring with At Most Two Distinct Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Substring%20with%20At%20Most%20Two%20Distinct%20Characters.java) +342 | [Longest Uploaded Prefix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Uploaded%20Prefix.java) +343 | [Longest Well-Performing Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Well-Performing%20Interval.java) +344 | [Longest Word With All Prefixes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Word%20With%20All%20Prefixes.java) +345 | [Longest Word in Dictionary through Deleting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Word%20in%20Dictionary%20through%20Deleting.java) +346 | [Longest ZigZag Path in a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20ZigZag%20Path%20in%20a%20Binary%20Tree.java) +347 | [Lowest Common Ancestor of Deepest Leaves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lowest%20Common%20Ancestor%20of%20Deepest%20Leaves.java) +348 | [Lowest Common Ancestor of a Binary Tree III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lowest%20Common%20Ancestor%20of%20a%20Binary%20Tree%20III.java) +349 | [Lowest Common Ancestor of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lowest%20Common%20Ancestor%20of%20a%20Binary%20Tree.java) +350 | [Majority Element II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Majority%20Element%20II.java) +351 | [Making File Names Unique](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Making%20File%20Names%20Unique.java) +352 | [Map Sum Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Map%20Sum%20Pairs.java) +353 | [Masking Personal Information](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Masking%20Personal%20Information.java) +354 | [Matchsticks to Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Matchsticks%20to%20Square.java) +355 | [Max Area of Island](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Area%20of%20Island.java) +356 | [Max Chunks To Make Sorted](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Chunks%20To%20Make%20Sorted.java) +357 | [Max Consecutives Ones II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Consecutives%20Ones%20II.java) +358 | [Max Increase to Keep City Skyline](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Increase%20to%20Keep%20City%20Skyline.java) +359 | [Max Number of K-Sum Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Number%20of%20K-Sum%20Pairs.java) +360 | [Max Sum of a Pair With Equal Sum of Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Sum%20of%20a%20Pair%20With%20Equal%20Sum%20of%20Digits.java) +361 | [Maximal Network Rank](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximal%20Network%20Rank.java) +362 | [Maximal Score After Applying K Operations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximal%20Score%20After%20Applying%20K%20Operations.java) +363 | [Maximize Distance to Closest Person](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximize%20Distance%20to%20Closest%20Person.java) +364 | [Maximize Number of Subsequences in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximize%20Number%20of%20Subsequences%20in%20a%20String.java) +365 | [Maximize the Topmost Element After K Moves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximize%20the%20Topmost%20Element%20After%20K%20Moves.java) +366 | [Maximum Absolute Sum of Any Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Absolute%20Sum%20of%20Any%20Subarray.java) +367 | [Maximum Area of a Piece of Cake After Horizontal and Vertical Cuts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Area%20of%20a%20Piece%20of%20Cake%20After%20Horizontal%20and%20Vertical%20Cuts.java) +368 | [Maximum Average Subtree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Average%20Subtree.java) +369 | [Maximum Bags With Full Capacity of Rocks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Bags%20With%20Full%20Capacity%20of%20Rocks.java) +370 | [Maximum Binary Tree II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Binary%20Tree%20II.java) +371 | [Maximum Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Binary%20Tree.java) +372 | [Maximum Consecutive Floors Without Special Floors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Consecutive%20Floors%20Without%20Special%20Floors.java) +373 | [Maximum Difference Between Node and Ancestor](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Difference%20Between%20Node%20and%20Ancestor.java) +374 | [Maximum Distance Between a Pair of Values](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Distance%20Between%20a%20Pair%20of%20Values.java) +375 | [Maximum Erasure Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Erasure%20Value.java) +376 | [Maximum Ice Cream Bars](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Ice%20Cream%20Bars.java) +377 | [Maximum Length of Pair Chain](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Length%20of%20Pair%20Chain.java) +378 | [Maximum Length of Repeated Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Length%20of%20Repeated%20Subarray.java) +379 | [Maximum Length of Subarray With Positive Product](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Length%20of%20Subarray%20With%20Positive%20Product.java) +380 | [Maximum Level Sum of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Level%20Sum%20of%20a%20Binary%20Tree.java) +381 | [Maximum Matching of Players With Trainers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Matching%20of%20Players%20With%20Trainers.java) +382 | [Maximum Nesting Depth of Two Valid Parentheses Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Nesting%20Depth%20of%20Two%20Valid%20Parentheses%20Strings.java) +383 | [Maximum Number of Coins You Can Get](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Coins%20You%20Can%20Get.java) +384 | [Maximum Number of Events That Can Be Attended](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Events%20That%20Can%20Be%20Attended.java) +385 | [Maximum Number of Groups Entering a Competition](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Groups%20Entering%20a%20Competition.java) +386 | [Maximum Number of Integers to Choose From a Range I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Integers%20to%20Choose%20From%20a%20Range%20I.java) +387 | [Maximum Number of Non-Overlapping Subarrays With Sum Equals Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Non-Overlapping%20Subarrays%20With%20Sum%20Equals%20Target.java) +388 | [Maximum Number of Occurrences of a Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Occurrences%20of%20a%20Substring.java) +389 | [Maximum Number of Vowels in a Substring of Given Length](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Vowels%20in%20a%20Substring%20of%20Given%20Length.java) +390 | [Maximum Points You Can Obtain from Cards](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Points%20You%20Can%20Obtain%20from%20Cards.java) +391 | [Maximum Product Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Product%20Subarray.java) +392 | [Maximum Product of Splitted Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Product%20of%20Splitted%20Binary%20Tree.java) +393 | [Maximum Product of Word Lengths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Product%20of%20Word%20Lengths.java) +394 | [Maximum Score From Removing Stones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Score%20From%20Removing%20Stones.java) +395 | [Maximum Score from Performing Multiplication Operations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Score%20from%20Performing%20Multiplication%20Operations.java) +396 | [Maximum Size Subarray Sum Equals k](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Size%20Subarray%20Sum%20Equals%20k.java) +397 | [Maximum Star Sum of a Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Star%20Sum%20of%20a%20Graph.java) +398 | [Maximum Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Subarray.java) +399 | [Maximum Sum of Distinct Subarrays With Length K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Sum%20of%20Distinct%20Subarrays%20With%20Length%20K.java) +400 | [Maximum Sum of an Hourglass](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Sum%20of%20an%20Hourglass.java) +401 | [Maximum Swap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Swap.java) +402 | [Maximum Total Importance of Roads](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Total%20Importance%20of%20Roads.java) +403 | [Maximum Twin Sum of a Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Twin%20Sum%20of%20a%20Linked%20List.java) +404 | [Maximum Value after Insertion](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Value%20after%20Insertion.java) +405 | [Maximum Width Ramp](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Width%20Ramp.java) +406 | [Maximum Width of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Width%20of%20Binary%20Tree.java) +407 | [Maximum XOR of Two Numbers in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20XOR%20of%20Two%20Numbers%20in%20an%20Array.java) +408 | [Maximum of Absolute Value Expression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20of%20Absolute%20Value%20Expression.java) +409 | [Meeting Rooms II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Meeting%20Rooms%20II.java) +410 | [Meeting Scheduler](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Meeting%20Scheduler.java) +411 | [Merge In Between Linked Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Merge%20In%20Between%20Linked%20Lists.java) +412 | [Merge Intervals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Merge%20Intervals.java) +413 | [Merge Nodes in Between Zeros](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Merge%20Nodes%20in%20Between%20Zeros.java) +414 | [Min Cost to Connect All Points](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Min%20Cost%20to%20Connect%20All%20Points.java) +415 | [Min Stack](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Min%20Stack.java) +416 | [Minesweeper](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minesweeper.java) +417 | [Mini Parser](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Mini%20Parser.java) +418 | [Minimize Maximum Pair Sum in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimize%20Maximum%20Pair%20Sum%20in%20Array.java) +419 | [Minimize Maximum of Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimize%20Maximum%20of%20Array.java) +420 | [Minimize Product Sum of Two Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimize%20Product%20Sum%20of%20Two%20Arrays.java) +421 | [Minimum Add to Make Parentheses Valid](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Add%20to%20Make%20Parentheses%20Valid.java) +422 | [Minimum Amount of Time to Collect Garbage](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Amount%20of%20Time%20to%20Collect%20Garbage.java) +423 | [Minimum Area Rectangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Area%20Rectangle.java) +424 | [Minimum Average Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Average%20Difference.java) +425 | [Minimum Consecutive Cards to Pick Up](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Consecutive%20Cards%20to%20Pick%20Up.java) +426 | [Minimum Cost For Tickets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Cost%20For%20Tickets.java) +427 | [Minimum Cost to Connect Sticks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Cost%20to%20Connect%20Sticks.java) +428 | [Minimum Deletion Cost to Avoid Repeating Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Deletion%20Cost%20to%20Avoid%20Repeating%20Letters.java) +429 | [Minimum Deletions to Make Array Beautiful](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Deletions%20to%20Make%20Array%20Beautiful.java) +430 | [Minimum Deletions to Make Character Frequencies Unique](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Deletions%20to%20Make%20Character%20Frequencies%20Unique.java) +431 | [Minimum Domino Rotations For Equal Row](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Domino%20Rotations%20For%20Equal%20Row.java) +432 | [Minimum Falling Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Falling%20Path%20Sum.java) +433 | [Minimum Fuel Cost to Report to the Capital](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Fuel%20Cost%20to%20Report%20to%20the%20Capital.java) +434 | [Minimum Genetic Mutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Genetic%20Mutation.java) +435 | [Minimum Health to Beat Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Health%20to%20Beat%20Game.java) +436 | [Minimum Height Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Height%20Trees.java) +437 | [Minimum Knight Moves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Knight%20Moves.java) +438 | [Minimum Moves to Equal Array Elements II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Moves%20to%20Equal%20Array%20Elements%20II.java) +439 | [Minimum Moves to Equal Array Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Moves%20to%20Equal%20Array%20Elements.java) +440 | [Minimum Moves to Reach Target Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Moves%20to%20Reach%20Target%20Score.java) +441 | [Minimum Number of Arrows to Burst Balloons](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Number%20of%20Arrows%20to%20Burst%20Balloons.java) +442 | [Minimum Number of Steps to Make Two Strings Anagram II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Number%20of%20Steps%20to%20Make%20Two%20Strings%20Anagram%20II.java) +443 | [Minimum Number of Steps to Make Two Strings Anagram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Number%20of%20Steps%20to%20Make%20Two%20Strings%20Anagram.java) +444 | [Minimum Number of Vertices to Reach All Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Number%20of%20Vertices%20to%20Reach%20All%20Nodes.java) +445 | [Minimum Operations to Make Array Equal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Operations%20to%20Make%20Array%20Equal.java) +446 | [Minimum Operations to Reduce X to Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Operations%20to%20Reduce%20X%20to%20Zero.java) +447 | [Minimum Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Path%20Sum.java) +448 | [Minimum Remove to Make Valid Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Remove%20to%20Make%20Valid%20Parentheses.java) +449 | [Minimum Rounds to Complete All Tasks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Rounds%20to%20Complete%20All%20Tasks.java) +450 | [Minimum Score Triangulation of Polygon](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Score%20Triangulation%20of%20Polygon.java) +451 | [Minimum Score of a Path Between Two Cities](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Score%20of%20a%20Path%20Between%20Two%20Cities.java) +452 | [Minimum Size Subarray Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Size%20Subarray%20Sum.java) +453 | [Minimum Swaps to Group All 1's Together](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Swaps%20to%20Group%20All%201's%20Together.java) +454 | [Minimum Time Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Time%20Difference.java) +455 | [Minimum Time to Collect All Apples in a Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Time%20to%20Collect%20All%20Apples%20in%20a%20Tree.java) +456 | [Minimum Time to Complete Trips](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Time%20to%20Complete%20Trips.java) +457 | [Minimum Time to Make Rope Colorful](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Time%20to%20Make%20Rope%20Colorful.java) +458 | [Mirror Reflection](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Mirror%20Reflection.java) +459 | [Missing Element in Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Missing%20Element%20in%20Sorted%20Array.java) +460 | [Most Frequent Subtree Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Most%20Frequent%20Subtree%20Sum.java) +461 | [Most Popular Video Creator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Most%20Popular%20Video%20Creator.java) +462 | [Most Profit Assigning Work](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Most%20Profit%20Assigning%20Work.java) +463 | [Most Stones Removed with Same Row or Column](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Most%20Stones%20Removed%20with%20Same%20Row%20or%20Column.java) +464 | [Multiply Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Multiply%20Strings.java) +465 | [My Calendar I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/My%20Calendar%20I.java) +466 | [My Calendar II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/My%20Calendar%20II.java) +467 | [N-ary Tree Level Order Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/N-ary%20Tree%20Level%20Order%20Traversal.java) +468 | [Nearest Exit from Entrance in Maze](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Nearest%20Exit%20from%20Entrance%20in%20Maze.java) +469 | [Nested List Weight Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Nested%20List%20Weight%20Sum%20II.java) +470 | [Network Delay Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Network%20Delay%20Time.java) +471 | [Next Closest Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Closest%20Time.java) +472 | [Next Greater Element II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Greater%20Element%20II.java) +473 | [Next Greater Element III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Greater%20Element%20III.java) +474 | [Next Greater Node In Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Greater%20Node%20In%20Linked%20List.java) +475 | [Next Greater Numerically Balanced Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Greater%20Numerically%20Balanced%20Number.java) +476 | [Next Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Permutation.java) +477 | [Node With Highest Edge Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Node%20With%20Highest%20Edge%20Score.java) +478 | [Non Overlapping Intervals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Non%20Overlapping%20Intervals.java) +479 | [Non-decreasing Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Non-decreasing%20Array.java) +480 | [Number of Burgers with No Waste of Ingredients](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Burgers%20with%20No%20Waste%20of%20Ingredients.java) +481 | [Number of Closed Islands](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Closed%20Islands.java) +482 | [Number of Connected Components in an Undirected Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Connected%20Components%20in%20an%20Undirected%20Graph.java) +483 | [Number of Dice Rolls With Target Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Dice%20Rolls%20With%20Target%20Sum.java) +484 | [Number of Distinct Islands](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Distinct%20Islands.java) +485 | [Number of Distinct Substrings in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Distinct%20Substrings%20in%20a%20String.java) +486 | [Number of Enclaves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Enclaves.java) +487 | [Number of Islands](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Islands.java) +488 | [Number of Laser Beams in a Bank](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Laser%20Beams%20in%20a%20Bank.java) +489 | [Number of Longest Increasing Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Longest%20Increasing%20Subsequence.java) +490 | [Number of Matching Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Matching%20Subsequence.java) +491 | [Number of Matching Subsequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Matching%20Subsequences.java) +492 | [Number of Nodes in the Sub-Tree With the Same Label](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Nodes%20in%20the%20Sub-Tree%20With%20the%20Same%20Label.java) +493 | [Number of Operations to Make Network Connected](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Operations%20to%20Make%20Network%20Connected.java) +494 | [Number of Pairs of Interchangeable Rectangles](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Pairs%20of%20Interchangeable%20Rectangles.java) +495 | [Number of Pairs of Strings With Concatenation Equal to Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Pairs%20of%20Strings%20With%20Concatenation%20Equal%20to%20Target.java) +496 | [Number of Provinces](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Provinces.java) +497 | [Number of Smooth Descent Periods of a Stock](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Smooth%20Descent%20Periods%20of%20a%20Stock.java) +498 | [Number of Sub-arrays of Size K and Average Greater than or Equal to Threshold](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Sub-arrays%20of%20Size%20K%20and%20Average%20Greater%20than%20or%20Equal%20to%20Threshold.java) +499 | [Number of Subarrays with Bounded Maximum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Subarrays%20with%20Bounded%20Maximum.java) +500 | [Number of Substrings Containing All Three Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Substrings%20Containing%20All%20Three%20Characters.java) +501 | [Number of Substrings With Only 1s](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Substrings%20With%20Only%201s.java) +502 | [Number of Ways to Split Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Ways%20to%20Split%20Array.java) +503 | [Number of Zero-Filled Subarrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Zero-Filled%20Subarrays.java) +504 | [Numbers With Same Consecutive Differences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Numbers%20With%20Same%20Consecutive%20Differences.java) +505 | [Odd Even Linked Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Odd%20Even%20Linked%20Lists.java) +506 | [One Edit Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/One%20Edit%20Distance.java) +507 | [Ones and Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Ones%20and%20Zeroes.java) +508 | [Online Election](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Online%20Election.java) +509 | [Online Stock Span](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Online%20Stock%20Span.java) +510 | [Open The Lock](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Open%20The%20Lock.java) +511 | [Optimal Division](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Optimal%20Division.java) +512 | [Optimal Partition of String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Optimal%20Partition%20of%20String.java) +513 | [Out of Boundary Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Out%20of%20Boundary%20Paths.java) +514 | [Output Contest Matches](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Output%20Contest%20Matches.java) +515 | [Pacific Atlantic Water Flow](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pacific%20Atlantic%20Water%20Flow.java) +516 | [Palindrome Partitioning](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Palindrome%20Partitioning.java) +517 | [Palindromic Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Palindromic%20Substrings.java) +518 | [Pancake Sorting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pancake%20Sorting.java) +519 | [Parallel Courses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Parallel%20Courses.java) +520 | [Partition Array According to Given Pivot](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partition%20Array%20According%20to%20Given%20Pivot.java) +521 | [Partition Equal Subset Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partition%20Equal%20Subset%20Sum.java) +522 | [Partition Labels](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partition%20Labels.java) +523 | [Partition List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partition%20List.java) +524 | [Partitioning Into Minimum Number Of Deci-Binary Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partitioning%20Into%20Minimum%20Number%20Of%20Deci-Binary%20Numbers.java) +525 | [Path Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20Sum%20II.java) +526 | [Path Sum III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20Sum%20III.java) +527 | [Path With Maximum Minimum Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20With%20Maximum%20Minimum%20Value.java) +528 | [Path With Minimum Effort](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20With%20Minimum%20Effort.java) +529 | [Path with Maximum Gold](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20with%20Maximum%20Gold.java) +530 | [Path with Maximum Probability](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20with%20Maximum%20Probability.java) +531 | [Peeking Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Peeking%20Iterator.java) +532 | [People Whose List of Favorite Companies Is Not a Subset of Another List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/People%20Whose%20List%20of%20Favorite%20Companies%20Is%20Not%20a%20Subset%20of%20Another%20List.java) +533 | [Perfect Squares](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Perfect%20Squares.java) +534 | [Permutation in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Permutation%20in%20String.java) +535 | [Permutations II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Permutations%20II.java) +536 | [Permutations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Permutations.java) +537 | [Plus One Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Plus%20One%20Linked%20List.java) +538 | [Populating Next Right Pointers in Each Node II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Populating%20Next%20Right%20Pointers%20in%20Each%20Node%20II.java) +539 | [Populating Next Right Pointers in Each Node](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Populating%20Next%20Right%20Pointers%20in%20Each%20Node.java) +540 | [Possible Bipartition](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Possible%20Bipartition.java) +541 | [Pour Water](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pour%20Water.java) +542 | [Pow(x, n)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pow(x,%20n).java) +543 | [Pow](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pow.java) +544 | [Prime Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Prime%20Palindrome.java) +545 | [Print Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Print%20Binary%20Tree.java) +546 | [Print Immutable Linked List in Reverse](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Print%20Immutable%20Linked%20List%20in%20Reverse.java) +547 | [Print Words Vertically](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Print%20Words%20Vertically.java) +548 | [Prison Cells After N Days](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Prison%20Cells%20After%20N%20Days.java) +549 | [Product of Array Except self](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Product%20of%20Array%20Except%20self.java) +550 | [Product of Two Run-Length Encoded Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Product%20of%20Two%20Run-Length%20Encoded%20Arrays.java) +551 | [Product of the Last K Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Product%20of%20the%20Last%20K%20Numbers.java) +552 | [Pseudo-Palindromic Paths in a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pseudo-Palindromic%20Paths%20in%20a%20Binary%20Tree.java) +553 | [Push Dominoes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Push%20Dominoes.java) +554 | [Put Boxes Into the Warehouse I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Put%20Boxes%20Into%20the%20Warehouse%20I.java) +555 | [Queries on a Permutation With Key](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Queries%20on%20a%20Permutation%20With%20Key.java) +556 | [Queue Reconstruction By Height](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Queue%20Reconstruction%20By%20Height.java) +557 | [RLE Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/RLE%20Iterator.java) +558 | [Rabbits in Forest](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rabbits%20in%20Forest.java) +559 | [Random Pick Index](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Random%20Pick%20Index.java) +560 | [Random Pick With Weight](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Random%20Pick%20With%20Weight.java) +561 | [Range Addition](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Addition.java) +562 | [Range Sum Query - Mutable](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Sum%20Query%20-%20Mutable.java) +563 | [Range Sum Query 2D-Immutable](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Sum%20Query%202D-Immutable.java) +564 | [Range Sum of Sorted Subarray Sums](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Sum%20of%20Sorted%20Subarray%20Sums.java) +565 | [Rank Teams by Votes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rank%20Teams%20by%20Votes.java) +566 | [Reachable Nodes With Restrictions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reachable%20Nodes%20With%20Restrictions.java) +567 | [Rearrange Array Elements by Sign](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rearrange%20Array%20Elements%20by%20Sign.java) +568 | [Rearrange Array to Maximize Prefix Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rearrange%20Array%20to%20Maximize%20Prefix%20Score.java) +569 | [Reconstruct Original Digits from English](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reconstruct%20Original%20Digits%20from%20English.java) +570 | [Recover Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Recover%20Binary%20Search%20Tree.java) +571 | [Rectangle Area](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rectangle%20Area.java) +572 | [Reduce Array Size to The Half](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reduce%20Array%20Size%20to%20The%20Half.java) +573 | [Reduction Operations to Make the Array Elements Equal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reduction%20Operations%20to%20Make%20the%20Array%20Elements%20Equal.java) +574 | [Remove All Adjacent Duplicates in String II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20All%20Adjacent%20Duplicates%20in%20String%20II.java) +575 | [Remove All Occurrences of a Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20All%20Occurrences%20of%20a%20Substring.java) +576 | [Remove All Ones With Row and Column Flips II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20All%20Ones%20With%20Row%20and%20Column%20Flips%20II.java) +577 | [Remove Comments](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Comments.java) +578 | [Remove Covered Intervals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Covered%20Intervals.java) +579 | [Remove Duplicate Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Duplicate%20Letters.java) +580 | [Remove Duplicates From Sorted Array II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Duplicates%20From%20Sorted%20Array%20II.java) +581 | [Remove Duplicates From an Unsorted Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Duplicates%20From%20an%20Unsorted%20Linked%20List.java) +582 | [Remove Duplicates from Sorted List II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Duplicates%20from%20Sorted%20List%20II.java) +583 | [Remove Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Interval.java) +584 | [Remove K Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20K%20Digits.java) +585 | [Remove Nodes From Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Nodes%20From%20Linked%20List.java) +586 | [Remove Nth Node From End of List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Nth%20Node%20From%20End%20of%20List.java) +587 | [Remove Sub-Folders from the Filesystem](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Sub-Folders%20from%20the%20Filesystem.java) +588 | [Remove Zero Sum Consecutive Nodes from Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Zero%20Sum%20Consecutive%20Nodes%20from%20Linked%20List.java) +589 | [Removing Stars From a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Removing%20Stars%20From%20a%20String.java) +590 | [Reorder Data in Log Files](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reorder%20Data%20in%20Log%20Files.java) +591 | [Reorder List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reorder%20List.java) +592 | [Reorder Routes to Make All Paths Lead to the City Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reorder%20Routes%20to%20Make%20All%20Paths%20Lead%20to%20the%20City%20Zero.java) +593 | [Reordered Power of 2](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reordered%20Power%20of%202.java) +594 | [Reorganize String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reorganize%20String.java) +595 | [Repeated DNA Sequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Repeated%20DNA%20Sequences.java) +596 | [Replace Elements in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Replace%20Elements%20in%20an%20Array.java) +597 | [Replace Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Replace%20Words.java) +598 | [Restore IP Address](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Restore%20IP%20Address.java) +599 | [Restore the Array From Adjacent Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Restore%20the%20Array%20From%20Adjacent%20Pairs.java) +600 | [Reverse Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Integer.java) +601 | [Reverse Linked List II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Linked%20List%20II.java) +602 | [Reverse Nodes in Even Length Groups](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Nodes%20in%20Even%20Length%20Groups.java) +603 | [Reverse Odd Levels of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Odd%20Levels%20of%20Binary%20Tree.java) +604 | [Reverse Substrings Between Each Pair of Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Substrings%20Between%20Each%20Pair%20of%20Parentheses.java) +605 | [Reverse Words in a String II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Words%20in%20a%20String%20II.java) +606 | [Reverse Words in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Words%20in%20a%20String.java) +607 | [Robot Bounded In Circle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Robot%20Bounded%20In%20Circle.java) +608 | [Rotate Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20Array.java) +609 | [Rotate Function](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20Function.java) +610 | [Rotate Image](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20Image.java) +611 | [Rotate List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20List.java) +612 | [Rotated Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotated%20Digits.java) +613 | [Rotting Oranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotting%20Oranges.java) +614 | [Satisfiability of Equality Equations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Satisfiability%20of%20Equality%20Equations.java) +615 | [Satisfisbility of Equality Equations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Satisfisbility%20of%20Equality%20Equations.java) +616 | [Score After Flipping Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Score%20After%20Flipping%20Matrix.java) +617 | [Score of Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Score%20of%20Parentheses.java) +618 | [Search Suggestions System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20Suggestions%20System.java) +619 | [Search a 2D Matrix II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20a%202D%20Matrix%20II.java) +620 | [Search a 2D Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20a%202D%20Matrix.java) +621 | [Search for a range](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20for%20a%20range.java) +622 | [Search in Rotated Sorted Array II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20in%20Rotated%20Sorted%20Array%20II.java) +623 | [Search in Rotated Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20in%20Rotated%20Sorted%20Array.java) +624 | [Search in a Sorted Array of Unknown Size](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20in%20a%20Sorted%20Array%20of%20Unknown%20Size.java) +625 | [Seat Reservation Manager](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Seat%20Reservation%20Manager.java) +626 | [Self Dividing Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Self%20Dividing%20Numbers.java) +627 | [Sender With Largest Word Count](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sender%20With%20Largest%20Word%20Count.java) +628 | [Sentence Similarity II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sentence%20Similarity%20II.java) +629 | [Sentence Similarity III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sentence%20Similarity%20III.java) +630 | [Sequential Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sequential%20Digits.java) +631 | [Serialize and Deserialize BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Serialize%20and%20Deserialize%20BST.java) +632 | [Set Matrix Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Set%20Matrix%20Zeroes.java) +633 | [Shifting Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shifting%20Letters.java) +634 | [Short Encoding of Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Short%20Encoding%20of%20Words.java) +635 | [Shortest Completing Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Completing%20Word.java) +636 | [Shortest Path in Binary Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Path%20in%20Binary%20Matrix.java) +637 | [Shortest Path with Alternating Colors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Path%20with%20Alternating%20Colors.java) +638 | [Shortest Unsorted Continuous Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Unsorted%20Continuous%20Subarray.java) +639 | [Shortest Way to Form String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Way%20to%20Form%20String.java) +640 | [Shortest Word Distance II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Word%20Distance%20II.java) +641 | [Shortest Word Distance III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Word%20Distance%20III.java) +642 | [Shuffle an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shuffle%20an%20Array.java) +643 | [Simple Bank System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Simple%20Bank%20System.java) +644 | [Simplify Path](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Simplify%20Path.java) +645 | [Single Element in a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Single%20Element%20in%20a%20Sorted%20Array.java) +646 | [Single Number II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Single%20Number%20II.java) +647 | [Single Number III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Single%20Number%20III.java) +648 | [Smallest Integer Divisible by K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20Integer%20Divisible%20by%20K.java) +649 | [Smallest Number in Infinite Set](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20Number%20in%20Infinite%20Set.java) +650 | [Smallest String Starting From Leaf](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20String%20Starting%20From%20Leaf.java) +651 | [Smallest String With A Given Numeric Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20String%20With%20A%20Given%20Numeric%20Value.java) +652 | [Smallest String With Swaps](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20String%20With%20Swaps.java) +653 | [Smallest Subtree with all the Deepest Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20Subtree%20with%20all%20the%20Deepest%20Nodes.java) +654 | [Smallest Value of the Rearranged Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20Value%20of%20the%20Rearranged%20Number.java) +655 | [Snakes and Ladders](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Snakes%20and%20Ladders.java) +656 | [Snapshot Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Snapshot%20Array.java) +657 | [Solve the Equation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Solve%20the%20Equation.java) +658 | [Sort An Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20An%20Array.java) +659 | [Sort Characters By Frequency](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Characters%20By%20Frequency.java) +660 | [Sort Colors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Colors.java) +661 | [Sort Integers by The Power Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Integers%20by%20The%20Power%20Value.java) +662 | [Sort List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20List.java) +663 | [Sort Transformed Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Transformed%20Array.java) +664 | [Sort the Jumbled Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20the%20Jumbled%20Numbers.java) +665 | [Sort the Matrix Diagonally](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20the%20Matrix%20Diagonally.java) +666 | [Sort the Students by Their Kth Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20the%20Students%20by%20Their%20Kth%20Score.java) +667 | [Sparse Matrix Multiplication](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sparse%20Matrix%20Multiplication.java) +668 | [Spiral Matrix II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Spiral%20Matrix%20II.java) +669 | [Spiral Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Spiral%20Matrix.java) +670 | [Split Array into Consecutive Subsequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Split%20Array%20into%20Consecutive%20Subsequences.java) +671 | [Split BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Split%20BST.java) +672 | [Split Linked List in Parts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Split%20Linked%20List%20in%20Parts.java) +673 | [Statistics from a Large Sample](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Statistics%20from%20a%20Large%20Sample.java) +674 | [Step-By-Step Directions From a Binary Tree Node to Another](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Step-By-Step%20Directions%20From%20a%20Binary%20Tree%20Node%20to%20Another.java) +675 | [Stock Price Fluctuation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Stock%20Price%20Fluctuation.java) +676 | [Strictly Palindromic Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Strictly%20Palindromic%20Number.java) +677 | [String Compression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/String%20Compression.java) +678 | [String to Integer (atoi)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/String%20to%20Integer%20(atoi).java) +679 | [Subarray Product Less Than K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subarray%20Product%20Less%20Than%20K.java) +680 | [Subarray Sum Equals K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subarray%20Sum%20Equals%20K.java) +681 | [Subarray Sums Divisible by K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subarray%20Sums%20Divisible%20by%20K.java) +682 | [Subdomain Visit Count](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subdomain%20Visit%20Count.java) +683 | [Subrectangle Queries](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subrectangle%20Queries.java) +684 | [Subsets II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subsets%20II.java) +685 | [Subsets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subsets.java) +686 | [Successful Pairs of Spells and Potions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Successful%20Pairs%20of%20Spells%20and%20Potions.java) +687 | [Sum Multiples](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20Multiples.java) +688 | [Sum Root to Leaf Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20Root%20to%20Leaf%20Numbers.java) +689 | [Sum of Absolute Differences in a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Absolute%20Differences%20in%20a%20Sorted%20Array.java) +690 | [Sum of Beauty of All Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Beauty%20of%20All%20Substrings.java) +691 | [Sum of Even Numbers After Queries](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Even%20Numbers%20After%20Queries.java) +692 | [Sum of Nodes with Even-Valued Grandparent](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Nodes%20with%20Even-Valued%20Grandparent.java) +693 | [Sum of Numbers With Units Digit K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Numbers%20With%20Units%20Digit%20K.java) +694 | [Sum of Subarray Minimums](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Subarray%20Minimums.java) +695 | [Super Ugly Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Super%20Ugly%20Number.java) +696 | [Surrounded Regions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Surrounded%20Regions.java) +697 | [Swap For Longest Repeated Character Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Swap%20For%20Longest%20Repeated%20Character%20Substring.java) +698 | [Swap Nodes in Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Swap%20Nodes%20in%20Pairs.java) +699 | [Swapping Nodes in a Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Swapping%20Nodes%20in%20a%20Linked%20List.java) +700 | [Synonymous Sentences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Synonymous%20Sentences.java) +701 | [Target Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Target%20Sum.java) +702 | [Task Scheduler](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Task%20Scheduler.java) +703 | [Ternary Expression Parser](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Ternary%20Expression%20Parser.java) +704 | [The Earliest Moment When Everyone Become Friends](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20Earliest%20Moment%20When%20Everyone%20Become%20Friends.java) +705 | [The Number of Full Rounds You Have Played](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20Number%20of%20Full%20Rounds%20You%20Have%20Played.java) +706 | [The Number of Weak Characters in the Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20Number%20of%20Weak%20Characters%20in%20the%20Game.java) +707 | [The k Strongest Values in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20k%20Strongest%20Values%20in%20an%20Array.java) +708 | [The kth Factor of n](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20kth%20Factor%20of%20n.java) +709 | [Throne Inheritence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Throne%20Inheritence.java) +710 | [Time Based Key-Value Store](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Time%20Based%20Key-Value%20Store.java) +711 | [Time Needed to Inform All Employees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Time%20Needed%20to%20Inform%20All%20Employees.java) +712 | [Time Needed to Rearrange a Binary String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Time%20Needed%20to%20Rearrange%20a%20Binary%20String.java) +713 | [Top K Frequent Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Top%20K%20Frequent%20Elements.java) +714 | [Top K Frequent Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Top%20K%20Frequent%20Words.java) +715 | [Total Hamming Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Total%20Hamming%20Distance.java) +716 | [Tree Diameter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Tree%20Diameter.java) +717 | [Triangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Triangle.java) +718 | [Trim a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Trim%20a%20Binary%20Search%20Tree.java) +719 | [Tuple With Same Product](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Tuple%20With%20Same%20Product.java) +720 | [Tweet Counts Per Frequency](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Tweet%20Counts%20Per%20Frequency.java) +721 | [Two City Scheduling](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Two%20City%20Scheduling.java) +722 | [Two Sum BSTs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Two%20Sum%20BSTs.java) +723 | [Two Sum II - Input Array Is Sorted](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Two%20Sum%20II%20-%20Input%20Array%20Is%20Sorted.java) +724 | [UTF-8 Validation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/UTF-8%20Validation.java) +725 | [Ugly Number II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Ugly%20Number%20II.java) +726 | [Uncrossed Lines](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Uncrossed%20Lines.java) +727 | [Unique Binary Search Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Binary%20Search%20Trees.java) +728 | [Unique Paths II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Paths%20II.java) +729 | [Unique Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Paths.java) +730 | [Unique Word Abbrevation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Word%20Abbrevation.java) +731 | [Valid Parenthesis String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Parenthesis%20String.java) +732 | [Valid Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Square.java) +733 | [Valid Sudoku](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Sudoku.java) +734 | [Valid Tic-Tac-Toe State](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Tic-Tac-Toe%20State.java) +735 | [Valid Triangle Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Triangle%20Number.java) +736 | [Validate Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Validate%20Binary%20Search%20Tree.java) +737 | [Validate IP Address](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Validate%20IP%20Address.java) +738 | [Validate Stack Sequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Validate%20Stack%20Sequences.java) +739 | [Verify Preorder Serialization of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Verify%20Preorder%20Serialization%20of%20a%20Binary%20Tree.java) +740 | [Vowel Spellchecker](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Vowel%20Spellchecker.java) +741 | [Vowels of All Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Vowels%20of%20All%20Substrings.java) +742 | [Walls and Gates](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Walls%20and%20Gates.java) +743 | [Water & Jug Problem](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Water%20&%20Jug%20Problem.java) +744 | [Watering Plants](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Watering%20Plants.java) +745 | [Web Crawler](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Web%20Crawler.java) +746 | [Wiggle Sort](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Wiggle%20Sort.java) +747 | [Wiggle Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Wiggle%20Subsequence.java) +748 | [Word Break](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Word%20Break.java) +749 | [Word Ladder](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Word%20Ladder.java) +750 | [Word Search](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Word%20Search.java) +751 | [Word Subsets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Word%20Subsets.java) +752 | [ZigZag Conversion](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/ZigZag%20Conversion.java) +753 | [Zigzag Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Zigzag%20Iterator.java) diff --git a/README.md b/README.md index e264f9eb..dd9ecf17 100644 --- a/README.md +++ b/README.md @@ -2,12 +2,12 @@ ## Solutions to Leetcode problems in Java -## [Current Leetcode profile: Solved 1200+ Problems](https://leetcode.com/varunsjsu/) +## [Current Leetcode profile: Solved 1300+ Problems](https://leetcode.com/varunsjsu/) ## [Previous Leetcode profile: Solved 759 Problems](https://leetcode.com/varunu28/) Problem Category | Count --- | --- -[Easy](https://github.com/varunu28/LeetCode-Java-Solutions/blob/master/Easy/README.md) | 558 -[Medium](https://github.com/varunu28/LeetCode-Java-Solutions/blob/master/Medium/README.md) | 739 -[Hard](https://github.com/varunu28/LeetCode-Java-Solutions/blob/master/Hard/README.md) | 95 +[Easy](https://github.com/varunu28/LeetCode-Java-Solutions/blob/master/Easy/README.md) | 572 +[Medium](https://github.com/varunu28/LeetCode-Java-Solutions/blob/master/Medium/README.md) | 754 +[Hard](https://github.com/varunu28/LeetCode-Java-Solutions/blob/master/Hard/README.md) | 111 [Concurrency](https://github.com/varunu28/LeetCode-Java-Solutions/blob/master/Concurrency/README.md) | 9 From 55c8a9b396780f5817aec3b36db8648a1df6e1e8 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sat, 29 Apr 2023 19:02:30 -0700 Subject: [PATCH 183/712] Added Find the Prefix Common Array of Two Arrays.java --- ...d the Prefix Common Array of Two Arrays.java | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) create mode 100644 Medium/Find the Prefix Common Array of Two Arrays.java diff --git a/Medium/Find the Prefix Common Array of Two Arrays.java b/Medium/Find the Prefix Common Array of Two Arrays.java new file mode 100644 index 00000000..bd747227 --- /dev/null +++ b/Medium/Find the Prefix Common Array of Two Arrays.java @@ -0,0 +1,17 @@ +class Solution { + public int[] findThePrefixCommonArray(int[] A, int[] B) { + Map map = new HashMap<>(); + int count = 0; + int[] result = new int[A.length]; + for (int i = 0; i < A.length; i++) { + map.put(A[i], map.getOrDefault(A[i], 0) + 1); + map.put(B[i], map.getOrDefault(B[i], 0) + 1); + count += map.get(A[i]) == 2 ? 1 : 0; + if (A[i] != B[i]) { + count += map.get(B[i]) == 2 ? 1 : 0; + } + result[i] = count; + } + return result; + } +} From 391f217baa1c169f95dde4176cd3ca3e52bcbacc Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sun, 30 Apr 2023 10:32:51 -0700 Subject: [PATCH 184/712] Added Determine the Winner of a Bowling Game.java --- ...etermine the Winner of a Bowling Game.java | 25 +++++++++++++++++++ 1 file changed, 25 insertions(+) create mode 100644 Easy/Determine the Winner of a Bowling Game.java diff --git a/Easy/Determine the Winner of a Bowling Game.java b/Easy/Determine the Winner of a Bowling Game.java new file mode 100644 index 00000000..0b64db30 --- /dev/null +++ b/Easy/Determine the Winner of a Bowling Game.java @@ -0,0 +1,25 @@ +class Solution { + public int isWinner(int[] player1, int[] player2) { + int score1 = 0; + int score2 = 0; + int tenIndex1 = -1; + int tenIndex2 = -1; + for (int i = 0; i < player1.length; i++) { + score1 += player1[i]; + score2 += player2[i]; + if (tenIndex1 != -1 && i - tenIndex1 <= 2) { + score1 += player1[i]; + } + if (tenIndex2 != -1 && i - tenIndex2 <= 2) { + score2 += player2[i]; + } + if (player1[i] == 10) { + tenIndex1 = i; + } + if (player2[i] == 10) { + tenIndex2 = i; + } + } + return score1 > score2 ? 1 : (score1 == score2 ? 0 : 2); + } +} From f348fed45d237066c75b1aae9784c346ce853cb2 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 30 Apr 2023 13:56:37 -0700 Subject: [PATCH 185/712] Create Remove Max Number of Edges to Keep Graph Fully Traversable.java --- ...Edges to Keep Graph Fully Traversable.java | 67 +++++++++++++++++++ 1 file changed, 67 insertions(+) create mode 100644 Hard/Remove Max Number of Edges to Keep Graph Fully Traversable.java diff --git a/Hard/Remove Max Number of Edges to Keep Graph Fully Traversable.java b/Hard/Remove Max Number of Edges to Keep Graph Fully Traversable.java new file mode 100644 index 00000000..152ab81b --- /dev/null +++ b/Hard/Remove Max Number of Edges to Keep Graph Fully Traversable.java @@ -0,0 +1,67 @@ +class Solution { + public int maxNumEdgesToRemove(int n, int[][] edges) { + UnionFind alice = new UnionFind(n); + UnionFind bob = new UnionFind(n); + int requiredEdges = 0; + for (int[] edge : edges) { + if (edge[0] == 3) { + requiredEdges += (alice.union(edge[1], edge[2]) | bob.union(edge[1], edge[2])); + } + } + for (int[] edge : edges) { + if (edge[0] == 1) { + requiredEdges += alice.union(edge[1], edge[2]); + } else if (edge[0] == 2) { + requiredEdges += bob.union(edge[1], edge[2]); + } + } + if (alice.isConnected() && bob.isConnected()) { + return edges.length - requiredEdges; + } + return -1; + } + + private class UnionFind { + private final int[] representatives; + private final int[] componentSize; + private int components; + + public UnionFind(int n) { + this.representatives = new int[n + 1]; + this.componentSize = new int[n + 1]; + this.components = n; + for (int i = 0; i <= n; i++) { + componentSize[i] = 1; + representatives[i] = i; + } + } + + public int find(int x) { + if (representatives[x] == x) { + return x; + } + return representatives[x] = find(representatives[x]); + } + + public int union(int x, int y) { + x = find(x); + y = find(y); + if (x == y) { + return 0; + } + if (componentSize[x] > componentSize[y]) { + componentSize[x] += componentSize[y]; + representatives[y] = x; + } else { + componentSize[y] += componentSize[x]; + representatives[x] = y; + } + components--; + return 1; + } + + public boolean isConnected() { + return components == 1; + } + } +} From fef17fd274e589de7b4986fe89d487fbe3f96393 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sun, 30 Apr 2023 18:38:33 -0700 Subject: [PATCH 186/712] Updated Average Salary Excluding the Minimum and Maximum Salary.java --- ...luding the Minimum and Maximum Salary.java | 22 +++++++++---------- 1 file changed, 10 insertions(+), 12 deletions(-) diff --git a/Easy/Average Salary Excluding the Minimum and Maximum Salary.java b/Easy/Average Salary Excluding the Minimum and Maximum Salary.java index 08d8663e..1d4d872c 100644 --- a/Easy/Average Salary Excluding the Minimum and Maximum Salary.java +++ b/Easy/Average Salary Excluding the Minimum and Maximum Salary.java @@ -1,15 +1,13 @@ class Solution { - public double average(int[] salary) { - int minSalary = salary[0]; - int maxSalary = salary[0]; - int n = salary.length; - int sum = 0; - for (int i = 0; i < n; i++) { - sum += salary[i]; - minSalary = Math.min(minSalary, salary[i]); - maxSalary = Math.max(maxSalary, salary[i]); + public double average(int[] salary) { + int minSalary = salary[0]; + int maxSalary = salary[0]; + double totalSalary = 0; + for (int s : salary) { + minSalary = Math.min(minSalary, s); + maxSalary = Math.max(maxSalary, s); + totalSalary += s; + } + return (totalSalary - minSalary - maxSalary) / (salary.length - 2); } - sum -= (maxSalary + minSalary); - return ((double) sum) / (n - 2); - } } From 1b421f46b4e527373527938d5a12473f6fd8eb2f Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sun, 30 Apr 2023 18:47:16 -0700 Subject: [PATCH 187/712] Updated Index Pairs of a String.java --- Easy/Index Pairs of a String.java | 56 ++++++------------------------- 1 file changed, 10 insertions(+), 46 deletions(-) diff --git a/Easy/Index Pairs of a String.java b/Easy/Index Pairs of a String.java index 97d590ce..5fd32b1e 100644 --- a/Easy/Index Pairs of a String.java +++ b/Easy/Index Pairs of a String.java @@ -1,50 +1,14 @@ class Solution { - public int[][] indexPairs(String text, String[] words) { - TrieNode root = new TrieNode('-'); - for (String word : words) { - addWord(word, root); - } - List list = new ArrayList<>(); - for (int i = 0; i < text.length(); i++) { - int j = i; - TrieNode curr = root; - while (j < text.length() && curr.childrens.containsKey(text.charAt(j))) { - curr = curr.childrens.get(text.charAt(j)); - if (curr.isWord) { - list.add(new int[]{i, j}); + public int[][] indexPairs(String text, String[] words) { + List pairs = new ArrayList<>(); + for (String word : words) { + for (int i = 0; i < text.length() - word.length() + 1; i++) { + if (text.startsWith(word, i)) { + pairs.add(new int[]{i, i + word.length() - 1}); + } + } } - j++; - } - } - int[][] ans = new int[list.size()][2]; - for (int i = 0; i < list.size(); i++) { - ans[i] = list.get(i); + pairs.sort(Comparator.comparingInt((int[] o) -> o[0]).thenComparingInt(o -> o[1])); + return pairs.toArray(new int[0][]); } - return ans; - } - - private void addWord(String s, TrieNode root) { - for (int i = 0; i < s.length(); i++) { - if (!root.childrens.containsKey(s.charAt(i))) { - root.childrens.put(s.charAt(i), new TrieNode(s.charAt(i))); - } - root = root.childrens.get(s.charAt(i)); - if (i == s.length() - 1) { - root.isWord = true; - } - } - } -} - - -class TrieNode { - char c; - Map childrens; - boolean isWord; - - public TrieNode(char c) { - this.c = c; - childrens = new HashMap<>(); - isWord = false; - } } From 0edbde0debe23895091975afc288ab1b264e0eb4 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Mon, 1 May 2023 17:36:26 -0700 Subject: [PATCH 188/712] Updated Sign of the Product of an Array.java --- Easy/Sign of the Product of an Array.java | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/Easy/Sign of the Product of an Array.java b/Easy/Sign of the Product of an Array.java index 8f286c24..b4f1172c 100644 --- a/Easy/Sign of the Product of an Array.java +++ b/Easy/Sign of the Product of an Array.java @@ -1,12 +1,12 @@ class Solution { - public int arraySign(int[] nums) { - int negativeCount = 0; - for (int num : nums) { - if (num == 0) { - return 0; - } - negativeCount += num < 0 ? 1 : 0; + public int arraySign(int[] nums) { + int negCount = 0; + for (int num : nums) { + if (num == 0) { + return 0; + } + negCount += num > 0 ? 0 : 1; + } + return negCount % 2 == 0 ? 1 : -1; } - return negativeCount % 2 == 0 ? 1 : -1; - } } From 757ae7369d60f144e74af0eed50057e078ea16fa Mon Sep 17 00:00:00 2001 From: varunu28 Date: Wed, 3 May 2023 06:48:54 -0700 Subject: [PATCH 189/712] Updated Building H2O.java --- Concurrency/Building H2O.java | 40 +++++++++++++++++------------------ 1 file changed, 19 insertions(+), 21 deletions(-) diff --git a/Concurrency/Building H2O.java b/Concurrency/Building H2O.java index 2d2dee57..04fda0bc 100644 --- a/Concurrency/Building H2O.java +++ b/Concurrency/Building H2O.java @@ -1,26 +1,24 @@ class H2O { - - private final Semaphore hydrogenSemaphore; - private final Semaphore oxygenSemaphore; + + private Semaphore hydrogenSemaphore; + private Semaphore oxygenSemaphore; - public H2O() { - this.hydrogenSemaphore = new Semaphore(2); - this.oxygenSemaphore = new Semaphore(0); - } + public H2O() { + this.hydrogenSemaphore = new Semaphore(2); + this.oxygenSemaphore = new Semaphore(0); + } - public void hydrogen(Runnable releaseHydrogen) throws InterruptedException { + public void hydrogen(Runnable releaseHydrogen) throws InterruptedException { + hydrogenSemaphore.acquire(); + // releaseHydrogen.run() outputs "H". Do not change or remove this line. + releaseHydrogen.run(); + this.oxygenSemaphore.release(); + } - this.hydrogenSemaphore.acquire(); - // releaseHydrogen.run() outputs "H". Do not change or remove this line. - releaseHydrogen.run(); - this.oxygenSemaphore.release(); - } - - public void oxygen(Runnable releaseOxygen) throws InterruptedException { - - this.oxygenSemaphore.acquire(2); - // releaseOxygen.run() outputs "O". Do not change or remove this line. - releaseOxygen.run(); - this.hydrogenSemaphore.release(2); - } + public void oxygen(Runnable releaseOxygen) throws InterruptedException { + this.oxygenSemaphore.acquire(2); + // releaseOxygen.run() outputs "O". Do not change or remove this line. + releaseOxygen.run(); + this.hydrogenSemaphore.release(2); + } } From 29c9d6db7191ab8082bf2d082ff75211a9b7f44d Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Thu, 4 May 2023 06:17:28 -0700 Subject: [PATCH 190/712] Create Dota2 Senate.java --- Medium/Dota2 Senate.java | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+) create mode 100644 Medium/Dota2 Senate.java diff --git a/Medium/Dota2 Senate.java b/Medium/Dota2 Senate.java new file mode 100644 index 00000000..56465cb4 --- /dev/null +++ b/Medium/Dota2 Senate.java @@ -0,0 +1,24 @@ +class Solution { + public String predictPartyVictory(String senate) { + int n = senate.length(); + Queue rValid = new LinkedList<>(); + Queue dValid = new LinkedList<>(); + for (int i = 0; i < n; i++) { + if (senate.charAt(i) == 'R') { + rValid.add(i); + } else { + dValid.add(i); + } + } + while (!rValid.isEmpty() && !dValid.isEmpty()) { + int rTurn = rValid.remove(); + int dTurn = dValid.remove(); + if (dTurn < rTurn) { + dValid.add(dTurn + n); + } else { + rValid.add(rTurn + n); + } + } + return rValid.isEmpty() ? "Dire" : "Radiant"; + } +} From 6eddbb3029c37553f7429a96a906fc8cc36394ed Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Thu, 4 May 2023 17:52:00 -0700 Subject: [PATCH 191/712] Update Maximum Number of Vowels in a Substring of Given Length.java --- ...Vowels in a Substring of Given Length.java | 49 ++++++++----------- 1 file changed, 20 insertions(+), 29 deletions(-) diff --git a/Medium/Maximum Number of Vowels in a Substring of Given Length.java b/Medium/Maximum Number of Vowels in a Substring of Given Length.java index 5af78c54..0b27eda9 100644 --- a/Medium/Maximum Number of Vowels in a Substring of Given Length.java +++ b/Medium/Maximum Number of Vowels in a Substring of Given Length.java @@ -1,32 +1,23 @@ class Solution { - public int maxVowels(String s, int k) { - Map map = new HashMap<>(); - String vowels = "aeiou"; - int count = 0; - int maxCount = 0; - int start = 0; - int end = 0; - int n = s.length(); - while (end < (k - 1)) { - if (vowels.indexOf(s.charAt(end)) != -1) { - map.put(s.charAt(end), map.getOrDefault(s.charAt(end), 0) + 1); - count++; - } - end++; + public int maxVowels(String s, int k) { + int currCount = 0; + Set vowels = Set.of('a', 'e', 'i', 'o', 'u'); + for (int i = 0; i < k - 1; i++) { + if (vowels.contains(s.charAt(i))) { + currCount++; + } + } + int maxCount = 0; + int start = 0; + for (int i = k - 1; i < s.length(); i++) { + if (vowels.contains(s.charAt(i))) { + currCount++; + } + maxCount = Math.max(maxCount, currCount); + if (vowels.contains(s.charAt(start++))) { + currCount--; + } + } + return maxCount; } - while (end < n) { - if (vowels.indexOf(s.charAt(end)) != -1) { - map.put(s.charAt(end), map.getOrDefault(s.charAt(end), 0) + 1); - count++; - } - end++; - maxCount = Math.max(maxCount, count); - if (vowels.indexOf(s.charAt(start)) != -1) { - map.put(s.charAt(start), map.getOrDefault(s.charAt(start), 0) - 1); - count--; - } - start++; - } - return maxCount; - } } From f22f7a0473ee59a43875dc1987e03d0dcf03367c Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sat, 6 May 2023 07:27:19 -0700 Subject: [PATCH 192/712] Added Number of Subsequences That Satisfy the Given Sum Condition.java --- ... That Satisfy the Given Sum Condition.java | 26 +++++++++++++++++++ 1 file changed, 26 insertions(+) create mode 100644 Medium/Number of Subsequences That Satisfy the Given Sum Condition.java diff --git a/Medium/Number of Subsequences That Satisfy the Given Sum Condition.java b/Medium/Number of Subsequences That Satisfy the Given Sum Condition.java new file mode 100644 index 00000000..9a40ee6b --- /dev/null +++ b/Medium/Number of Subsequences That Satisfy the Given Sum Condition.java @@ -0,0 +1,26 @@ +class Solution { + + private static final int MOD = 1000_000_007; + + public int numSubseq(int[] nums, int target) { + int n = nums.length; + Arrays.sort(nums); + int[] power = new int[n]; + power[0] = 1; + for (int i = 1; i < n; i++) { + power[i] = (power[i - 1] * 2) % MOD; + } + int result = 0; + int left = 0; + int right = n - 1; + while (left <= right) { + if (nums[left] + nums[right] <= target) { + result = (result + power[right - left]) % MOD; + left++; + } else { + right--; + } + } + return result; + } +} From 50dee52b80df69c6bea25983c4830e5a8e5082b8 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sun, 7 May 2023 07:29:52 -0700 Subject: [PATCH 193/712] Added Find the Distinct Difference Array.java --- Easy/Find the Distinct Difference Array.java | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) create mode 100644 Easy/Find the Distinct Difference Array.java diff --git a/Easy/Find the Distinct Difference Array.java b/Easy/Find the Distinct Difference Array.java new file mode 100644 index 00000000..5578427f --- /dev/null +++ b/Easy/Find the Distinct Difference Array.java @@ -0,0 +1,17 @@ +class Solution { + public int[] distinctDifferenceArray(int[] nums) { + int[] rightToLeft = new int[nums.length]; + Set set = new HashSet<>(); + for (int i = nums.length - 1; i >= 0; i--) { + set.add(nums[i]); + rightToLeft[i] = set.size(); + } + int[] diff = new int[nums.length]; + set.clear(); + for (int i = 0; i < nums.length; i++) { + set.add(nums[i]); + diff[i] = set.size() - (i == nums.length - 1 ? 0 : rightToLeft[i + 1]); + } + return diff; + } +} From b1722b789cc13e48f6565ab9229e3e4de6df97f8 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sun, 7 May 2023 10:07:32 -0700 Subject: [PATCH 194/712] Added Find the Longest Valid Obstacle Course at Each Position.java --- ...alid Obstacle Course at Each Position.java | 34 +++++++++++++++++++ 1 file changed, 34 insertions(+) create mode 100644 Hard/Find the Longest Valid Obstacle Course at Each Position.java diff --git a/Hard/Find the Longest Valid Obstacle Course at Each Position.java b/Hard/Find the Longest Valid Obstacle Course at Each Position.java new file mode 100644 index 00000000..fcd272fb --- /dev/null +++ b/Hard/Find the Longest Valid Obstacle Course at Each Position.java @@ -0,0 +1,34 @@ +class Solution { + public int[] longestObstacleCourseAtEachPosition(int[] obstacles) { + int n = obstacles.length; + int lisLength = 0; + int[] result = new int[n]; + int[] lis = new int[n]; + for (int i = 0; i < n; i++) { + int height = obstacles[i]; + int idx = bisect(lis, height, lisLength); + if (idx == lisLength) { + lisLength++; + } + lis[idx] = height; + result[i] = idx + 1; + } + return result; + } + + private int bisect(int[] lis, int target, int right) { + if (right == 0) { + return 0; + } + int left = 0; + while (left < right) { + int mid = left + (right - left) / 2; + if (lis[mid] <= target) { + left = mid + 1; + } else { + right = mid; + } + } + return left; + } +} From bd776c303881b9f273ef41abf502586a59f5dc64 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sun, 7 May 2023 10:19:42 -0700 Subject: [PATCH 195/712] Added Frequency Tracker.java --- Medium/Frequency Tracker.java | 48 +++++++++++++++++++++++++++++++++++ 1 file changed, 48 insertions(+) create mode 100644 Medium/Frequency Tracker.java diff --git a/Medium/Frequency Tracker.java b/Medium/Frequency Tracker.java new file mode 100644 index 00000000..e5e83453 --- /dev/null +++ b/Medium/Frequency Tracker.java @@ -0,0 +1,48 @@ +class FrequencyTracker { + + private final Map numToFrequencyMapping; + private final Map> frequencyToNumMapping; + + public FrequencyTracker() { + this.numToFrequencyMapping = new HashMap<>(); + this.frequencyToNumMapping = new HashMap<>(); + } + + public void add(int number) { + int prevFrequency = this.numToFrequencyMapping.getOrDefault(number, 0); + int newFrequency = prevFrequency + 1; + this.numToFrequencyMapping.put(number, newFrequency); + updateFreqToNumMapping(number, prevFrequency, newFrequency); + } + + public void deleteOne(int number) { + int prevFrequency = this.numToFrequencyMapping.getOrDefault(number, 0); + if (prevFrequency == 0) { + return; + } + int newFrequency = prevFrequency - 1; + this.numToFrequencyMapping.put(number, newFrequency); + updateFreqToNumMapping(number, prevFrequency, newFrequency); + } + + public boolean hasFrequency(int frequency) { + return this.frequencyToNumMapping.getOrDefault(frequency, new HashSet<>()).size() > 0; + } + + private void updateFreqToNumMapping(int number, int prevFrequency, int newFrequency) { + if (prevFrequency != 0) { + this.frequencyToNumMapping.get(prevFrequency).remove(number); + } + if (newFrequency != 0) { + this.frequencyToNumMapping.computeIfAbsent(newFrequency, k -> new HashSet<>()).add(number); + } + } +} + +/** + * Your FrequencyTracker object will be instantiated and called as such: + * FrequencyTracker obj = new FrequencyTracker(); + * obj.add(number); + * obj.deleteOne(number); + * boolean param_3 = obj.hasFrequency(frequency); + */ From 0b2f422764938ae75bbcc4cc4550e1940f99dce8 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Mon, 8 May 2023 12:46:46 -0700 Subject: [PATCH 196/712] Update Find Minimum in Rotated Sorted Array.java --- .../Find Minimum in Rotated Sorted Array.java | 41 +++++++------------ 1 file changed, 14 insertions(+), 27 deletions(-) diff --git a/Medium/Find Minimum in Rotated Sorted Array.java b/Medium/Find Minimum in Rotated Sorted Array.java index 8c18f17b..79ae6e51 100644 --- a/Medium/Find Minimum in Rotated Sorted Array.java +++ b/Medium/Find Minimum in Rotated Sorted Array.java @@ -1,30 +1,17 @@ class Solution { - public int findMin(int[] nums) { - if (nums.length == 1) { - return nums[0]; + public int findMin(int[] nums) { + int start = 0; + int end = nums.length - 1; + int minValue = 5001; + while (start <= end) { + int mid = (start + end) / 2; + minValue = Math.min(minValue, nums[mid]); + if (nums[end] > nums[mid]) { + end = mid - 1; + } else { + start = mid + 1; + } + } + return minValue; } - int left = 0; - int right = nums.length - 1; - // Sorted but not rotated - if (nums[right] > nums[left]) { - return nums[left]; - } - while (left <= right) { - int mid = (left + right) / 2; - // mid + 1 is point of rotation - if (nums[mid] > nums[mid + 1]) { - return nums[mid + 1]; - } - // mid is point of rotation - if (nums[mid - 1] > nums[mid]) { - return nums[mid]; - } - if (nums[mid] > nums[0]) { - left = mid + 1; - } else { - right = mid - 1; - } - } - return Integer.MAX_VALUE; - } } From 1bfdf2dbabea029b8826106b024e3b872002d2a6 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Mon, 8 May 2023 17:33:46 -0700 Subject: [PATCH 197/712] Update Spiral Matrix.java --- Medium/Spiral Matrix.java | 56 +++++++++++++++++++-------------------- 1 file changed, 28 insertions(+), 28 deletions(-) diff --git a/Medium/Spiral Matrix.java b/Medium/Spiral Matrix.java index 6004fe4d..252374fb 100644 --- a/Medium/Spiral Matrix.java +++ b/Medium/Spiral Matrix.java @@ -1,32 +1,32 @@ class Solution { - public List spiralOrder(int[][] matrix) { - List list = new ArrayList<>(); - int rowStart = 0; - int rowEnd = matrix.length - 1; - int colStart = 0; - int colEnd = matrix[0].length - 1; - while (rowStart <= rowEnd && colStart <= colEnd) { - for (int i = colStart; i <= colEnd; i++) { - list.add(matrix[rowStart][i]); - } - rowStart++; - for (int i = rowStart; i <= rowEnd; i++) { - list.add(matrix[i][colEnd]); - } - colEnd--; - if (rowStart <= rowEnd) { - for (int i = colEnd; i >= colStart; i--) { - list.add(matrix[rowEnd][i]); + public List spiralOrder(int[][] matrix) { + List result = new ArrayList<>(); + int rowStart = 0; + int rowEnd = matrix.length - 1; + int colStart = 0; + int colEnd = matrix[0].length - 1; + while (rowStart <= rowEnd && colStart <= colEnd) { + for (int i = colStart; i <= colEnd; i++) { + result.add(matrix[rowStart][i]); + } + rowStart++; + for (int i = rowStart; i <= rowEnd; i++) { + result.add(matrix[i][colEnd]); + } + colEnd--; + if (rowStart <= rowEnd) { + for (int i = colEnd; i >= colStart; i--) { + result.add(matrix[rowEnd][i]); + } + rowEnd--; + } + if (colStart <= colEnd) { + for (int i = rowEnd; i >= rowStart; i--) { + result.add(matrix[i][colStart]); + } + colStart++; + } } - rowEnd--; - } - if (colStart <= colEnd) { - for (int i = rowEnd; i >= rowStart; i--) { - list.add(matrix[i][colStart]); - } - colStart++; - } + return result; } - return list; - } } From 74fc658d62e964a2272d7e76fc0aebec8fc92549 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Tue, 9 May 2023 07:20:28 -0700 Subject: [PATCH 198/712] Added Find the Pivot Integer.java --- Easy/Find the Pivot Integer.java | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) create mode 100644 Easy/Find the Pivot Integer.java diff --git a/Easy/Find the Pivot Integer.java b/Easy/Find the Pivot Integer.java new file mode 100644 index 00000000..3cad5e0b --- /dev/null +++ b/Easy/Find the Pivot Integer.java @@ -0,0 +1,18 @@ +class Solution { + public int pivotInteger(int n) { + int[] leftToRightSum = new int[n]; + int currSum = 0; + for (int i = 0; i < n; i++) { + currSum += i + 1; + leftToRightSum[i] = currSum; + } + int rightToLeftSum = 0; + for (int i = n - 1; i >= 0; i--) { + rightToLeftSum += i + 1; + if (leftToRightSum[i] == rightToLeftSum) { + return i + 1; + } + } + return -1; + } +} From ba891a7557b17607eff32ffc242b162afc81a62b Mon Sep 17 00:00:00 2001 From: varunu28 Date: Tue, 9 May 2023 07:22:40 -0700 Subject: [PATCH 199/712] Added Delete Greatest Value in Each Row.java --- Easy/Delete Greatest Value in Each Row.java | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) create mode 100644 Easy/Delete Greatest Value in Each Row.java diff --git a/Easy/Delete Greatest Value in Each Row.java b/Easy/Delete Greatest Value in Each Row.java new file mode 100644 index 00000000..ca6794aa --- /dev/null +++ b/Easy/Delete Greatest Value in Each Row.java @@ -0,0 +1,16 @@ +class Solution { + public int deleteGreatestValue(int[][] grid) { + for (int[] g : grid) { + Arrays.sort(g); + } + int result = 0; + for (int i = grid[0].length - 1; i >= 0; i--) { + int maxValue = Integer.MIN_VALUE; + for (int[] g : grid) { + maxValue = Math.max(maxValue, g[i]); + } + result += maxValue; + } + return result; + } +} From ad7a72e85ed501b25be5277c7bca459f96c2c083 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Tue, 9 May 2023 17:34:01 -0700 Subject: [PATCH 200/712] Update Spiral Matrix II.java --- Medium/Spiral Matrix II.java | 56 +++++++++++++++++++----------------- 1 file changed, 30 insertions(+), 26 deletions(-) diff --git a/Medium/Spiral Matrix II.java b/Medium/Spiral Matrix II.java index ffa09b62..636fbb69 100644 --- a/Medium/Spiral Matrix II.java +++ b/Medium/Spiral Matrix II.java @@ -1,29 +1,33 @@ class Solution { - public int[][] generateMatrix(int n) { - int[][] ans = new int[n][n]; - int left = 0; - int top = 0; - int right = n -1; - int down = n - 1; - int count = 1; - while (left <= right) { - for (int j = left; j <= right; j ++) { - ans[top][j] = count++; - } - top++; - for (int i = top; i <= down; i ++) { - ans[i][right] = count ++; - } - right--; - for (int j = right; j >= left; j --) { - ans[down][j] = count ++; - } - down--; - for (int i = down; i >= top; i --) { - ans[i][left] = count ++; - } - left++; + public int[][] generateMatrix(int n) { + int[][] result = new int[n][n]; + int rowStart = 0; + int rowEnd = n - 1; + int colStart = 0; + int colEnd = n - 1; + int value = 1; + while (rowStart <= rowEnd && colStart <= colEnd) { + for (int i = colStart; i <= colEnd; i++) { + result[rowStart][i] = value++; + } + rowStart++; + for (int i = rowStart; i <= rowEnd; i++) { + result[i][colEnd] = value++; + } + colEnd--; + if (rowStart <= rowEnd) { + for (int i = colEnd; i >= colStart; i--) { + result[rowEnd][i] = value++; + } + rowEnd--; + } + if (colStart <= colEnd) { + for (int i = rowEnd; i >= rowStart; i--) { + result[i][colStart] = value++; + } + colStart++; + } + } + return result; } - return ans; - } } From b3241878560e55031415baa1d6b4b473fb7d8a9e Mon Sep 17 00:00:00 2001 From: varunu28 Date: Wed, 10 May 2023 17:09:27 -0700 Subject: [PATCH 201/712] Updated Uncrossed Lines.java --- Medium/Uncrossed Lines.java | 36 +++++++++++++++++------------------- 1 file changed, 17 insertions(+), 19 deletions(-) diff --git a/Medium/Uncrossed Lines.java b/Medium/Uncrossed Lines.java index 6a923dfa..729da13d 100644 --- a/Medium/Uncrossed Lines.java +++ b/Medium/Uncrossed Lines.java @@ -1,23 +1,21 @@ class Solution { - Integer[][] dp; - public int maxUncrossedLines(int[] A, int[] B) { - dp = new Integer[A.length][B.length]; - return helper(A, 0, B, 0); - } - - private int helper(int[] A, int idxA, int[] B, int idxB) { - if (idxA == A.length || idxB == B.length) { - return 0; - } - if (dp[idxA][idxB] != null) { - return dp[idxA][idxB]; + public int maxUncrossedLines(int[] nums1, int[] nums2) { + Integer[][] dp = new Integer[nums1.length][nums2.length]; + return helper(nums1, 0, nums2, 0, dp); } - if (A[idxA] == B[idxB]) { - dp[idxA][idxB] = 1 + helper(A, idxA + 1, B, idxB + 1); + + private int helper(int[] nums1, int idxOne, int[] nums2, int idxTwo, Integer[][] dp) { + if (idxOne == nums1.length || idxTwo == nums2.length) { + return 0; + } + if (dp[idxOne][idxTwo] != null) { + return dp[idxOne][idxTwo]; + } + if (nums1[idxOne] == nums2[idxTwo]) { + return dp[idxOne][idxTwo] = 1 + helper(nums1, idxOne + 1, nums2, idxTwo + 1, dp); + } + return dp[idxOne][idxTwo] = Math.max( + helper(nums1, idxOne, nums2, idxTwo + 1, dp), + helper(nums1, idxOne + 1, nums2, idxTwo, dp)); } - else { - dp[idxA][idxB] = Math.max(helper(A, idxA + 1, B, idxB), helper(A, idxA, B, idxB + 1)); - } - return dp[idxA][idxB]; - } } From a7228134a9273e85572939de02ac80e2fdc2b56e Mon Sep 17 00:00:00 2001 From: varunu28 Date: Fri, 12 May 2023 06:33:01 -0700 Subject: [PATCH 202/712] Added Solving Questions With Brainpower.java --- Medium/Solving Questions With Brainpower.java | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) create mode 100644 Medium/Solving Questions With Brainpower.java diff --git a/Medium/Solving Questions With Brainpower.java b/Medium/Solving Questions With Brainpower.java new file mode 100644 index 00000000..76e640d1 --- /dev/null +++ b/Medium/Solving Questions With Brainpower.java @@ -0,0 +1,19 @@ +class Solution { + public long mostPoints(int[][] questions) { + Long[] dp = new Long[questions.length]; + return helper(questions, 0, dp); + } + + private long helper(int[][] questions, int idx, Long[] dp) { + if (idx >= questions.length) { + return 0; + } + if (dp[idx] != null) { + return dp[idx]; + } + return dp[idx] = Math.max( + questions[idx][0] + helper(questions, idx + questions[idx][1] + 1, dp), + helper(questions, idx + 1, dp) + ); + } +} From 8d15a6b1d68e6d7df9ca39ea79f7b95a8264447a Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sat, 13 May 2023 14:28:40 -0700 Subject: [PATCH 203/712] Create Count Ways To Build Good Strings.java --- Medium/Count Ways To Build Good Strings.java | 23 ++++++++++++++++++++ 1 file changed, 23 insertions(+) create mode 100644 Medium/Count Ways To Build Good Strings.java diff --git a/Medium/Count Ways To Build Good Strings.java b/Medium/Count Ways To Build Good Strings.java new file mode 100644 index 00000000..16991f0c --- /dev/null +++ b/Medium/Count Ways To Build Good Strings.java @@ -0,0 +1,23 @@ +class Solution { + + private static final int MOD = 1000_000_007; + + public int countGoodStrings(int low, int high, int zero, int one) { + int[] dp = new int[high + 1]; + dp[0] = 1; + for (int i = 1; i <= high; i++) { + if (i >= zero) { + dp[i] += dp[i - zero]; + } + if (i >= one) { + dp[i] += dp[i - one]; + } + dp[i] %= MOD; + } + int result = 0; + for (int i = low; i <= high; i++) { + result = (result + dp[i]) % MOD; + } + return result; + } +} From e1b690f7c5b690385c2d1c558e929a27c3545ab6 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sat, 13 May 2023 16:10:56 -0700 Subject: [PATCH 204/712] Added Number of Senior Citizens.java --- Easy/Number of Senior Citizens.java | 8 ++++++++ 1 file changed, 8 insertions(+) create mode 100644 Easy/Number of Senior Citizens.java diff --git a/Easy/Number of Senior Citizens.java b/Easy/Number of Senior Citizens.java new file mode 100644 index 00000000..cb658ee0 --- /dev/null +++ b/Easy/Number of Senior Citizens.java @@ -0,0 +1,8 @@ +class Solution { + public int countSeniors(String[] details) { + return (int) Arrays.stream(details) + .map(s -> Integer.parseInt(s.substring(11, 13))) + .filter(age -> age > 60) + .count(); + } +} From f9e9563598991ee9e7cb14272da3b20d67c7a9ca Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sun, 14 May 2023 06:14:49 -0700 Subject: [PATCH 205/712] Added Maximize Score After N Operations.java --- Hard/Maximize Score After N Operations.java | 37 +++++++++++++++++++++ 1 file changed, 37 insertions(+) create mode 100644 Hard/Maximize Score After N Operations.java diff --git a/Hard/Maximize Score After N Operations.java b/Hard/Maximize Score After N Operations.java new file mode 100644 index 00000000..2ed4f892 --- /dev/null +++ b/Hard/Maximize Score After N Operations.java @@ -0,0 +1,37 @@ +class Solution { + public int maxScore(int[] nums) { + int dpSize = 1 << nums.length; + int[] dp = new int[dpSize]; + Arrays.fill(dp, -1); + return backtrack(nums, 0, 0, dp); + } + + private int backtrack(int[] nums, int mask, int pickCount, int[] dp) { + if (2 * pickCount == nums.length) { + return 0; + } + if (dp[mask] != -1) { + return dp[mask]; + } + int maxScore = 0; + for (int i = 0; i < nums.length; i++) { + for (int j = i + 1; j < nums.length; j++) { + if (((mask >> i) & 1) == 1 || ((mask >> j) & 1) == 1) { + continue; + } + int newMask = mask | (1 << i) | (1 << j); + int curr = (pickCount + 1) * gcd(nums[i], nums[j]); + int remaining = backtrack(nums, newMask, pickCount + 1, dp); + maxScore = Math.max(maxScore, curr + remaining); + } + } + return dp[mask] = maxScore; + } + + private int gcd(int a, int b) { + if (b == 0) { + return a; + } + return gcd(b, a % b); + } +} From 1e29e3ee9674379488ffc42f76324ec41fbf1e56 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sun, 14 May 2023 06:25:15 -0700 Subject: [PATCH 206/712] Added Find the Losers of the Circular Game.java --- .../Find the Losers of the Circular Game.java | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) create mode 100644 Easy/Find the Losers of the Circular Game.java diff --git a/Easy/Find the Losers of the Circular Game.java b/Easy/Find the Losers of the Circular Game.java new file mode 100644 index 00000000..aaa8c059 --- /dev/null +++ b/Easy/Find the Losers of the Circular Game.java @@ -0,0 +1,19 @@ +class Solution { + public int[] circularGameLosers(int n, int k) { + Set set = new HashSet<>(); + int player = 1; + int multiple = k; + while (set.add(player)) { + player = (player + k) % n; + player = player == 0 ? n : player; + k += multiple; + } + int[] result = new int[n - set.size()]; + for (int i = 1, j = 0; i <= n; i++) { + if (!set.contains(i)) { + result[j++] = i; + } + } + return result; + } +} From 98e0c50250e0a49088c704bb0e13bb2ae4c843e7 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sun, 14 May 2023 15:55:33 -0700 Subject: [PATCH 207/712] Added Sum in a Matrix.java --- Medium/Sum in a Matrix.java | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) create mode 100644 Medium/Sum in a Matrix.java diff --git a/Medium/Sum in a Matrix.java b/Medium/Sum in a Matrix.java new file mode 100644 index 00000000..0261f81b --- /dev/null +++ b/Medium/Sum in a Matrix.java @@ -0,0 +1,16 @@ +class Solution { + public int matrixSum(int[][] nums) { + for (int[] num : nums) { + Arrays.sort(num); + } + int score = 0; + for (int i = 0; i < nums[0].length; i++) { + int maxNum = 0; + for (int[] num : nums) { + maxNum = Math.max(maxNum, num[i]); + } + score += maxNum; + } + return score; + } +} From f9edb33c4e3f06aee3698697b55b6d1a769560ea Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Mon, 15 May 2023 17:43:15 -0700 Subject: [PATCH 208/712] Update Swap Nodes in Pairs.java --- Medium/Swap Nodes in Pairs.java | 35 +++++++++++++++++---------------- 1 file changed, 18 insertions(+), 17 deletions(-) diff --git a/Medium/Swap Nodes in Pairs.java b/Medium/Swap Nodes in Pairs.java index 980e4356..505f7af0 100644 --- a/Medium/Swap Nodes in Pairs.java +++ b/Medium/Swap Nodes in Pairs.java @@ -9,22 +9,23 @@ * } */ class Solution { - public ListNode swapPairs(ListNode head) { - ListNode curr = head; - ListNode prev = null; - while (curr != null && curr.next != null) { - ListNode nextNode = curr.next; - if (curr == head) { - head = nextNode; - } - curr.next = nextNode.next; - nextNode.next = curr; - if (prev != null) { - prev.next = nextNode; - } - prev = curr; - curr = curr.next; + public ListNode swapPairs(ListNode head) { + ListNode curr = head; + ListNode prev = null; + while (curr != null && curr.next != null) { + ListNode nextNode = curr.next; + ListNode nextToNext = curr.next.next; + if (prev == null) { + head = nextNode; + } + if (prev != null) { + prev.next = nextNode; + } + nextNode.next = curr; + curr.next = nextToNext; + prev = curr; + curr = nextToNext; + } + return head; } - return head; - } } From 922c0b01e6afac116e9d8808dc9aac4e8a283738 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Mon, 15 May 2023 18:54:08 -0700 Subject: [PATCH 209/712] Added Paint House II.java --- Hard/Paint House II.java | 28 ++++++++++++++++++++++++++++ 1 file changed, 28 insertions(+) create mode 100644 Hard/Paint House II.java diff --git a/Hard/Paint House II.java b/Hard/Paint House II.java new file mode 100644 index 00000000..23ac7a3d --- /dev/null +++ b/Hard/Paint House II.java @@ -0,0 +1,28 @@ +class Solution { + public int minCostII(int[][] costs) { + int n = costs.length; + int k = costs[0].length; + int[][] dp = new int[n][k]; + for (int i = 0; i < k; i++) { + dp[0][i] = costs[0][i]; + } + for (int i = 1; i < n; i++) { + for (int j = 0; j < k; j++) { + dp[i][j] = minCost(dp[i - 1], j) + costs[i][j]; + } + } + return minCost(dp[n - 1], -1); + } + + private int minCost(int[] dp, int currPaintIdx) { + int cost = Integer.MAX_VALUE; + int idx = 0; + while (idx < dp.length) { + if (!(currPaintIdx != -1 && idx == currPaintIdx)) { + cost = Math.min(cost, dp[idx]); + } + idx++; + } + return cost; + } +} From b1f564ccced0d69f86be6c20718f35463b6c620b Mon Sep 17 00:00:00 2001 From: varunu28 Date: Thu, 18 May 2023 06:29:09 -0700 Subject: [PATCH 210/712] Updated Minimum Number of Vertices to Reach All Nodes.java --- ...Number of Vertices to Reach All Nodes.java | 24 +++++++++---------- 1 file changed, 12 insertions(+), 12 deletions(-) diff --git a/Medium/Minimum Number of Vertices to Reach All Nodes.java b/Medium/Minimum Number of Vertices to Reach All Nodes.java index 6c0688b6..6459877d 100644 --- a/Medium/Minimum Number of Vertices to Reach All Nodes.java +++ b/Medium/Minimum Number of Vertices to Reach All Nodes.java @@ -1,15 +1,15 @@ class Solution { - public List findSmallestSetOfVertices(int n, List> edges) { - int[] indegree = new int[n]; - for (List edge : edges) { - indegree[edge.get(1)]++; + public List findSmallestSetOfVertices(int n, List> edges) { + int[] indegree = new int[n]; + for (List edge : edges) { + indegree[edge.get(1)]++; + } + List zeroIndegree = new ArrayList<>(); + for (int i = 0; i < n; i++) { + if (indegree[i] == 0) { + zeroIndegree.add(i); + } + } + return zeroIndegree; } - List ans = new ArrayList<>(); - for (int i = 0; i < n; i++) { - if (indegree[i] == 0) { - ans.add(i); - } - } - return ans; - } } From 2773659c8c184371b3a38c632b750a9b8a995424 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Thu, 18 May 2023 18:10:31 -0700 Subject: [PATCH 211/712] Updated Is Graph Bipartite.java --- Medium/Is Graph Bipartite.java | 67 +++++++++++++++++----------------- 1 file changed, 33 insertions(+), 34 deletions(-) diff --git a/Medium/Is Graph Bipartite.java b/Medium/Is Graph Bipartite.java index c77018dc..3a30604f 100644 --- a/Medium/Is Graph Bipartite.java +++ b/Medium/Is Graph Bipartite.java @@ -1,39 +1,38 @@ class Solution { - public boolean isBipartite(int[][] graph) { - int n = graph.length; - int[] color = new int[n]; - Arrays.fill(color, -1); - for (int i = 0; i < n; i++) { - if (color[i] == -1 && !bipartiteCheck(graph, i, color)) { - return false; - } - } - return true; - } - - private boolean bipartiteCheck(int[][] graph, int node, int[] color) { - Queue queue = new LinkedList<>(); - queue.add(node); - int currColor = 0; - while (!queue.isEmpty()) { - int size = queue.size(); - while (size-- > 0) { - int removed = queue.remove(); - if (color[removed] != -1) { - if (color[removed] != currColor) { - return false; - } - continue; + public boolean isBipartite(int[][] graph) { + int n = graph.length; + int[] color = new int[n]; + for (int i = 0; i < n; i++) { + if (color[i] == 0 && !isBipartite(graph, i, color)) { + return false; + } } - color[removed] = currColor; - for (int conn : graph[removed]) { - if (color[conn] == -1) { - queue.add(conn); - } + return true; + } + + private boolean isBipartite(int[][] graph, int node, int[] color) { + Queue queue = new LinkedList<>(); + queue.add(node); + int currColor = 1; + while (!queue.isEmpty()) { + int size = queue.size(); + while (size-- > 0) { + int removed = queue.remove(); + if (color[removed] != 0) { + if (color[removed] != currColor) { + return false; + } + } else { + color[removed] = currColor; + for (int conn : graph[removed]) { + if (color[conn] == 0) { + queue.add(conn); + } + } + } + } + currColor = currColor == 1 ? 2 : 1; } - } - currColor = currColor == 1 ? 0 : 1; + return true; } - return true; - } } From b9301cf85ff6819780ed16c069eab7c4b2ebee9f Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sat, 20 May 2023 16:26:13 -0700 Subject: [PATCH 212/712] Added Sort Linked List Already Sorted Using Absolute Values.java --- ... Already Sorted Using Absolute Values.java | 25 +++++++++++++++++++ 1 file changed, 25 insertions(+) create mode 100644 Medium/Sort Linked List Already Sorted Using Absolute Values.java diff --git a/Medium/Sort Linked List Already Sorted Using Absolute Values.java b/Medium/Sort Linked List Already Sorted Using Absolute Values.java new file mode 100644 index 00000000..fd43f251 --- /dev/null +++ b/Medium/Sort Linked List Already Sorted Using Absolute Values.java @@ -0,0 +1,25 @@ +/** + * Definition for singly-linked list. + * public class ListNode { + * int val; + * ListNode next; + * ListNode() {} + * ListNode(int val) { this.val = val; } + * ListNode(int val, ListNode next) { this.val = val; this.next = next; } + * } + */ +class Solution { + public ListNode sortLinkedList(ListNode head) { + ListNode curr = head; + while (curr != null && curr.next != null){ + if (curr.next.val < 0) { + // Make a new head with negative value and assign its next pointer to current head + head = new ListNode(curr.next.val,head); + curr.next = curr.next.next; + } else { + curr = curr.next; + } + } + return head; + } +} From 42d508fa5cdec44cdd6c1de5749bba29eb11470c Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sun, 21 May 2023 06:57:45 -0700 Subject: [PATCH 213/712] Added Minimum String Length After Removing Substrings.java --- ...m String Length After Removing Substrings.java | 15 +++++++++++++++ 1 file changed, 15 insertions(+) create mode 100644 Easy/Minimum String Length After Removing Substrings.java diff --git a/Easy/Minimum String Length After Removing Substrings.java b/Easy/Minimum String Length After Removing Substrings.java new file mode 100644 index 00000000..606d3394 --- /dev/null +++ b/Easy/Minimum String Length After Removing Substrings.java @@ -0,0 +1,15 @@ +class Solution { + public int minLength(String s) { + Stack stack = new Stack<>(); + for (char c : s.toCharArray()) { + if (!stack.isEmpty() && c == 'B' && stack.peek() == 'A') { + stack.pop(); + } else if (!stack.isEmpty() && c == 'D' && stack.peek() == 'C') { + stack.pop(); + } else { + stack.push(c); + } + } + return stack.size(); + } +} From 92c2adb93fe20993119924badbe114874240168b Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sun, 21 May 2023 11:43:16 -0700 Subject: [PATCH 214/712] Added Shortest Bridge.java --- Medium/Shortest Bridge.java | 65 +++++++++++++++++++++++++++++++++++++ 1 file changed, 65 insertions(+) create mode 100644 Medium/Shortest Bridge.java diff --git a/Medium/Shortest Bridge.java b/Medium/Shortest Bridge.java new file mode 100644 index 00000000..f5194373 --- /dev/null +++ b/Medium/Shortest Bridge.java @@ -0,0 +1,65 @@ +class Solution { + + private static final int[][] DIRS = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}}; + + public int shortestBridge(int[][] grid) { + int n = grid.length; + int x = -1; + int y = -1; + for (int i = 0; i < n; i++) { + for (int j = 0; j < n; j++) { + if (grid[i][j] == 1) { + x = i; + y = j; + break; + } + } + } + List queueOne = new ArrayList<>(); + List queueTwo = new ArrayList<>(); + queueOne.add(new int[]{x, y}); + queueTwo.add(new int[]{x, y}); + grid[x][y] = 2; + while (!queueOne.isEmpty()) { + List bfs = new ArrayList<>(); + for (int[] cell : queueOne) { + int currX = cell[0]; + int currY = cell[1]; + for (int[] dir : DIRS) { + int newX = currX + dir[0]; + int newY = currY + dir[1]; + if (newX >= 0 && newX < n && newY >= 0 && newY < n && grid[newX][newY] == 1) { + bfs.add(new int[]{newX, newY}); + queueTwo.add(new int[]{newX, newY}); + grid[newX][newY] = 2; + } + } + } + queueOne = bfs; + } + int distance = 0; + while (!queueTwo.isEmpty()) { + List bfs = new ArrayList<>(); + for (int[] cell : queueTwo) { + int currX = cell[0]; + int currY = cell[1]; + for (int[] dir : DIRS) { + int newX = currX + dir[0]; + int newY = currY + dir[1]; + if (newX >= 0 && newX < n && newY >= 0 && newY < n) { + if (grid[newX][newY] == 1) { + return distance; + } else if (grid[newX][newY] == 0) { + bfs.add(new int[]{newX, newY}); + grid[newX][newY] = -1; + } + } + } + } + queueTwo = bfs; + distance++; + } + return distance; + } +} + From c47202023fca9448e8fb347e6f59cd9ede5ffc78 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sun, 21 May 2023 15:41:19 -0700 Subject: [PATCH 215/712] Updated Minimum Size Subarray Sum.java --- Medium/Minimum Size Subarray Sum.java | 38 +++++++++------------------ 1 file changed, 13 insertions(+), 25 deletions(-) diff --git a/Medium/Minimum Size Subarray Sum.java b/Medium/Minimum Size Subarray Sum.java index 4d41780e..5bafe959 100644 --- a/Medium/Minimum Size Subarray Sum.java +++ b/Medium/Minimum Size Subarray Sum.java @@ -1,30 +1,18 @@ class Solution { - public int minSubArrayLen(int s, int[] nums) { - int sum = 0; - int slow = 0; - int fast = 0; - int n = nums.length; - int minLen = Integer.MAX_VALUE; - - while (fast < n) { - sum += nums[fast]; - - if (sum >= s) { - while (slow <= fast) { - minLen = Math.min(minLen, fast - slow + 1); - if (sum - nums[slow] >= s) { - sum -= nums[slow]; - slow++; - } - else { - break; - } - } + public int minSubArrayLen(int target, int[] nums) { + int start = 0; + int end = 0; + int currSum = 0; + int minLength = Integer.MAX_VALUE; + while (end < nums.length) { + currSum += nums[end++]; + while (start < end && currSum - nums[start] >= target) { + currSum -= nums[start++]; + } + if (currSum >= target) { + minLength = Math.min(minLength, end - start); } - - fast++; } - - return minLen == Integer.MAX_VALUE ? 0 : minLen; + return minLength == Integer.MAX_VALUE ? 0 : minLength; } } From f4227494b8ce834ed98bf5609f7a6b5f4e5bf721 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Mon, 22 May 2023 16:59:29 -0700 Subject: [PATCH 216/712] Updated Meeting Rooms II.java --- Medium/Meeting Rooms II.java | 25 ++++++++++++------------- 1 file changed, 12 insertions(+), 13 deletions(-) diff --git a/Medium/Meeting Rooms II.java b/Medium/Meeting Rooms II.java index d43eab4e..ff594c8a 100644 --- a/Medium/Meeting Rooms II.java +++ b/Medium/Meeting Rooms II.java @@ -1,16 +1,15 @@ class Solution { - public int minMeetingRooms(int[][] intervals) { - Arrays.sort(intervals, Comparator.comparingInt((a) -> a[0])); - PriorityQueue meetingsInProgress = new PriorityQueue<>( - Comparator.comparingInt((a) -> a[1])); - int result = 0; - for (int[] interval : intervals) { - while (!meetingsInProgress.isEmpty() && meetingsInProgress.peek()[1] <= interval[0]) { - meetingsInProgress.poll(); - } - meetingsInProgress.add(interval); - result = Math.max(result, meetingsInProgress.size()); + public int minMeetingRooms(int[][] intervals) { + Arrays.sort(intervals, Comparator.comparingInt((int[] o) -> o[0])); + PriorityQueue pq = new PriorityQueue<>(Comparator.comparingInt(a -> a[1])); + int meetingRooms = 0; + for (int[] interval : intervals) { + while (!pq.isEmpty() && pq.peek()[1] <= interval[0]) { + pq.poll(); + } + pq.add(interval); + meetingRooms = Math.max(meetingRooms, pq.size()); + } + return meetingRooms; } - return result; - } } From 04bf94660422a50a0f22f94e325e2bc87630a7fb Mon Sep 17 00:00:00 2001 From: varunu28 Date: Mon, 22 May 2023 17:16:03 -0700 Subject: [PATCH 217/712] Updated Kth Largest Element in a Stream.java --- Easy/Kth Largest Element in a Stream.java | 39 ++++++++++++----------- 1 file changed, 21 insertions(+), 18 deletions(-) diff --git a/Easy/Kth Largest Element in a Stream.java b/Easy/Kth Largest Element in a Stream.java index 30bbc6f6..4b1868f3 100644 --- a/Easy/Kth Largest Element in a Stream.java +++ b/Easy/Kth Largest Element in a Stream.java @@ -1,25 +1,28 @@ class KthLargest { + + private final PriorityQueue pq; + private final int k; - private PriorityQueue pq; - private int k; - public KthLargest(int k, int[] nums) { - this.k = k; - this.pq = new PriorityQueue<>(); - for (int num : nums) { - pq.add(num); - if (pq.size() > k) { - pq.poll(); - } + public KthLargest(int k, int[] nums) { + this.k = k; + this.pq = new PriorityQueue<>((a, b) -> a - b); + for (int num : nums) { + pq.add(num); + checkLength(); + } } - } - - public int add(int val) { - pq.add(val); - if (pq.size() > k) { - pq.poll(); + + public int add(int val) { + pq.add(val); + checkLength(); + return pq.peek(); + } + + private void checkLength() { + if (pq.size() > k) { + pq.poll(); + } } - return pq.peek(); - } } /** From 3f9b65398725d12127e01070db7a674d5e0da1bb Mon Sep 17 00:00:00 2001 From: varunu28 Date: Tue, 23 May 2023 07:04:36 -0700 Subject: [PATCH 218/712] Updated Course Schedule II.java --- Medium/Course Schedule II.java | 54 ++++++++++++++++++---------------- 1 file changed, 28 insertions(+), 26 deletions(-) diff --git a/Medium/Course Schedule II.java b/Medium/Course Schedule II.java index 78fb8e08..ce957faf 100644 --- a/Medium/Course Schedule II.java +++ b/Medium/Course Schedule II.java @@ -1,30 +1,32 @@ class Solution { - public int[] findOrder(int numCourses, int[][] prerequisites) { - Map> prerequisiteToCourseDependency = new HashMap<>(); - int[] prerequisiteCount = new int[numCourses]; - for (int[] prerequisite : prerequisites) { - prerequisiteToCourseDependency.computeIfAbsent(prerequisite[1], k -> new ArrayList<>()) - .add(prerequisite[0]); - prerequisiteCount[prerequisite[0]]++; - } - Queue queue = new LinkedList<>(); - for (int i = 0; i < numCourses; i++) { - if (prerequisiteCount[i] == 0) { - queue.add(i); - } - } - int[] courseOrder = new int[numCourses]; - int courseOrderIdx = 0; - while (!queue.isEmpty()) { - int course = queue.remove(); - courseOrder[courseOrderIdx++] = course; - for (Integer dependentCourse : prerequisiteToCourseDependency.getOrDefault(course, new ArrayList<>())) { - prerequisiteCount[dependentCourse]--; - if (prerequisiteCount[dependentCourse] == 0) { - queue.add(dependentCourse); + public int[] findOrder(int numCourses, int[][] prerequisites) { + Map> map = new HashMap<>(); + int[] indegree = new int[numCourses]; + for (int[] prerequisite : prerequisites) { + int course = prerequisite[0]; + int dependency = prerequisite[1]; + map.computeIfAbsent(dependency, k -> new HashSet<>()).add(course); + indegree[course]++; + } + Queue queue = new LinkedList<>(); + int[] result = new int[numCourses]; + int resultIdx = 0; + Set taken = new HashSet<>(); + for (int i = 0; i < numCourses; i++) { + if (indegree[i] == 0) { + queue.add(i); + } + } + while (!queue.isEmpty()) { + int removed = queue.remove(); + result[resultIdx++] = removed; + for (Integer dependent : map.getOrDefault(removed, new HashSet<>())) { + indegree[dependent]--; + if (indegree[dependent] == 0) { + queue.add(dependent); + } + } } - } + return resultIdx == numCourses ? result : new int[0]; } - return courseOrderIdx == numCourses ? courseOrder : new int[]{}; - } } From b96a91203e543980b50b519db48e1bbf338c1468 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Thu, 25 May 2023 07:35:50 -0700 Subject: [PATCH 219/712] Added Maximum Subsequence Score.java --- Medium/Maximum Subsequence Score.java | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+) create mode 100644 Medium/Maximum Subsequence Score.java diff --git a/Medium/Maximum Subsequence Score.java b/Medium/Maximum Subsequence Score.java new file mode 100644 index 00000000..2598f5ed --- /dev/null +++ b/Medium/Maximum Subsequence Score.java @@ -0,0 +1,23 @@ +class Solution { + public long maxScore(int[] nums1, int[] nums2, int k) { + int[][] combined = new int[nums1.length][2]; + for (int i = 0; i < nums1.length; i++) { + combined[i] = new int[]{nums1[i], nums2[i]}; + } + Arrays.sort(combined, (o1, o2) -> o2[1] - o1[1]); + long result = 0; + long total = 0; + PriorityQueue pq = new PriorityQueue<>(); + for (int[] unit : combined) { + pq.add(unit[0]); + total += unit[0]; + if (pq.size() > k) { + total -= pq.poll(); + } + if (pq.size() == k) { + result = Math.max(result, total * unit[1]); + } + } + return result; + } +} From 2c2bcd54053b58915f0dd554a16ae02bc9888f51 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Thu, 25 May 2023 10:36:00 -0700 Subject: [PATCH 220/712] Create New 21 Game.java --- Medium/New 21 Game.java | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+) create mode 100644 Medium/New 21 Game.java diff --git a/Medium/New 21 Game.java b/Medium/New 21 Game.java new file mode 100644 index 00000000..26c88d90 --- /dev/null +++ b/Medium/New 21 Game.java @@ -0,0 +1,21 @@ +class Solution { + public double new21Game(int n, int k, int maxPts) { + double[] dp = new double[n + 1]; + dp[0] = 1; + double s = k > 0 ? 1 : 0; + for (int i = 1; i <= n; i++) { + dp[i] = s / maxPts; + if (i < k) { + s += dp[i]; + } + if (i - maxPts >= 0 && i - maxPts < k) { + s -= dp[i - maxPts]; + } + } + double result = 0; + for (int i = k; i <= n; i++) { + result += dp[i]; + } + return result; + } +} From 395bd9cc3df7b83ea3dbbaf598255ae359de6db4 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Fri, 26 May 2023 07:22:44 -0700 Subject: [PATCH 221/712] Added Stone Game II.java --- Medium/Stone Game II.java | 26 ++++++++++++++++++++++++++ 1 file changed, 26 insertions(+) create mode 100644 Medium/Stone Game II.java diff --git a/Medium/Stone Game II.java b/Medium/Stone Game II.java new file mode 100644 index 00000000..c56cbd43 --- /dev/null +++ b/Medium/Stone Game II.java @@ -0,0 +1,26 @@ +class Solution { + public int stoneGameII(int[] piles) { + Integer[][][] dp = new Integer[2][piles.length + 1][piles.length + 1]; + return helper(piles, dp, 0, 0, 1); + } + + private int helper(int[] piles, Integer[][][] dp, int p, int i, int m) { + if (i == piles.length) { + return 0; + } + if (dp[p][i][m] != null) { + return dp[p][i][m]; + } + int result = p == 1 ? 1000_000 : -1; + int s = 0; + for (int j = 1; j <= Math.min(2 * m, piles.length - i); j++) { + s += piles[i + j - 1]; + if (p == 0) { + result = Math.max(result, s + helper(piles, dp, 1, i + j, Math.max(m, j))); + } else { + result = Math.min(result, helper(piles, dp, 0, i + j, Math.max(m, j))); + } + } + return dp[p][i][m] = result; + } +} From 1cdc4443724f72a5b10050f8ae84c76886313fb3 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sat, 27 May 2023 05:51:36 -0700 Subject: [PATCH 222/712] Added Stone Game III.java --- Hard/Stone Game III.java | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) create mode 100644 Hard/Stone Game III.java diff --git a/Hard/Stone Game III.java b/Hard/Stone Game III.java new file mode 100644 index 00000000..0ee4e539 --- /dev/null +++ b/Hard/Stone Game III.java @@ -0,0 +1,16 @@ +class Solution { + public String stoneGameIII(int[] stoneValue) { + int n = stoneValue.length; + int[] dp = new int[n + 1]; + for (int i = n - 1; i >= 0; i--) { + dp[i] = stoneValue[i] - dp[i + 1]; + if (i + 2 <= n) { + dp[i] = Math.max(dp[i], stoneValue[i] + stoneValue[i + 1] - dp[i + 2]); + } + if (i + 3 <= n) { + dp[i] = Math.max(dp[i], stoneValue[i] + stoneValue[i + 1] + stoneValue[i + 2] - dp[i + 3]); + } + } + return dp[0] == 0 ? "Tie" : (dp[0] > 0 ? "Alice" : "Bob"); + } +} From 9d1391469d509648e44ac3b27eb4b3f98df0cac8 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Mon, 29 May 2023 19:16:12 -0700 Subject: [PATCH 223/712] Added Buy Two Chocolates.java --- Easy/Buy Two Chocolates.java | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) create mode 100644 Easy/Buy Two Chocolates.java diff --git a/Easy/Buy Two Chocolates.java b/Easy/Buy Two Chocolates.java new file mode 100644 index 00000000..fac6699e --- /dev/null +++ b/Easy/Buy Two Chocolates.java @@ -0,0 +1,16 @@ +class Solution { + public int buyChoco(int[] prices, int money) { + int cheapestChocolate = Math.min(prices[0], prices[1]); + int secondCheapestChocolate = Math.max(prices[0], prices[1]); + for (int i = 2; i < prices.length; i++) { + if (prices[i] < cheapestChocolate) { + secondCheapestChocolate = cheapestChocolate; + cheapestChocolate = prices[i]; + } else if (prices[i] < secondCheapestChocolate) { + secondCheapestChocolate = prices[i]; + } + } + int totalCost = cheapestChocolate + secondCheapestChocolate; + return totalCost <= money ? (money - totalCost) : money; + } +} From 70fde968259d29eb444a7859b22e1d74bfc52214 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Mon, 29 May 2023 19:28:34 -0700 Subject: [PATCH 224/712] Added Remove Trailing Zeros From a String.java --- Easy/Remove Trailing Zeros From a String.java | 9 +++++++++ 1 file changed, 9 insertions(+) create mode 100644 Easy/Remove Trailing Zeros From a String.java diff --git a/Easy/Remove Trailing Zeros From a String.java b/Easy/Remove Trailing Zeros From a String.java new file mode 100644 index 00000000..996c079e --- /dev/null +++ b/Easy/Remove Trailing Zeros From a String.java @@ -0,0 +1,9 @@ +class Solution { + public String removeTrailingZeros(String num) { + int idx = num.length() - 1; + while (idx >= 0 && num.charAt(idx) == '0') { + idx--; + } + return num.substring(0, idx + 1); + } +} From 87cf2a510fac5e0e5d929c35fadac7d2aa6b21c7 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Tue, 30 May 2023 12:13:54 -0700 Subject: [PATCH 225/712] Create Extra Characters in a String.java --- Medium/Extra Characters in a String.java | 25 ++++++++++++++++++++++++ 1 file changed, 25 insertions(+) create mode 100644 Medium/Extra Characters in a String.java diff --git a/Medium/Extra Characters in a String.java b/Medium/Extra Characters in a String.java new file mode 100644 index 00000000..4d43cc5c --- /dev/null +++ b/Medium/Extra Characters in a String.java @@ -0,0 +1,25 @@ +class Solution { + public int minExtraChar(String s, String[] dictionary) { + Integer[] dp = new Integer[s.length() + 1]; + return helper(0, s, Arrays.stream(dictionary).collect(Collectors.toSet()), dp); + } + + private int helper(int idx, String s, Set set, Integer[] dp) { + if (idx == s.length()) { + return 0; + } + if (dp[idx] != null) { + return dp[idx]; + } + int result = Integer.MAX_VALUE; + for (int i = idx; i < s.length(); i++) { + String sub = s.substring(idx, i + 1); + if (set.contains(sub)) { + result = Math.min(result, helper(i + 1, s, set, dp)); + } else { + result = Math.min(result, i - idx + 1 + helper(i + 1, s, set, dp)); + } + } + return dp[idx] = result; + } +} From 7f41c397e005be5d639158645155c2dadef587d1 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Tue, 30 May 2023 19:41:07 -0700 Subject: [PATCH 226/712] Updated Design Underground System.java --- Medium/Design Underground System.java | 60 ++++++++++++++------------- 1 file changed, 32 insertions(+), 28 deletions(-) diff --git a/Medium/Design Underground System.java b/Medium/Design Underground System.java index 51aa492a..6297656a 100644 --- a/Medium/Design Underground System.java +++ b/Medium/Design Underground System.java @@ -1,33 +1,37 @@ class UndergroundSystem { - - private Map totalTimeFromStartToEndStation; - private Map numberOfCustomersFromStartToEndStation; - private Map customerIdToStartTime; - private Map customerIdToStartStation; - - public UndergroundSystem() { - this.totalTimeFromStartToEndStation = new HashMap<>(); - this.numberOfCustomersFromStartToEndStation = new HashMap<>(); - this.customerIdToStartTime = new HashMap<>(); - this.customerIdToStartStation = new HashMap<>(); - } + + private final Map customerToCheckInMapping; + private final Map startEndStationTotalTimeMapping; + private final Map startEndStationCountMapping; - public void checkIn(int id, String stationName, int t) { - this.customerIdToStartTime.put(id, t); - this.customerIdToStartStation.put(id, stationName); - } - - public void checkOut(int id, String stationName, int t) { - int totalTime = t - this.customerIdToStartTime.get(id); - String key = this.customerIdToStartStation.get(id) + "|" + stationName; - this.totalTimeFromStartToEndStation.put(key, this.totalTimeFromStartToEndStation.getOrDefault(key, 0) + totalTime); - this.numberOfCustomersFromStartToEndStation.put(key, this.numberOfCustomersFromStartToEndStation.getOrDefault(key, 0) + 1); - } - - public double getAverageTime(String startStation, String endStation) { - String key = startStation + "|" + endStation; - return this.totalTimeFromStartToEndStation.get(key) / (double) (this.numberOfCustomersFromStartToEndStation.get(key)); - } + public UndergroundSystem() { + this.customerToCheckInMapping = new HashMap<>(); + this.startEndStationTotalTimeMapping = new HashMap<>(); + this.startEndStationCountMapping = new HashMap<>(); + } + + public void checkIn(int id, String stationName, int t) { + StationTimePair pair = new StationTimePair(stationName, t); + customerToCheckInMapping.put(id, pair); + } + + public void checkOut(int id, String stationName, int t) { + StationTimePair pair = customerToCheckInMapping.get(id); + String key = pair.station() + "|" + stationName; + int totalTime = t - pair.time(); + startEndStationTotalTimeMapping.put(key, startEndStationTotalTimeMapping.getOrDefault(key, 0) + totalTime); + startEndStationCountMapping.put(key, startEndStationCountMapping.getOrDefault(key, 0) + 1); + } + + public double getAverageTime(String startStation, String endStation) { + String key = startStation + "|" + endStation; + if (!startEndStationTotalTimeMapping.containsKey(key)) { + return 0.0; + } + return ((double) startEndStationTotalTimeMapping.get(key)) / startEndStationCountMapping.get(key); + } + + static record StationTimePair(String station, int time) {} } /** From 07ed79c304efd4041119accd6c64368fae34f2f2 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Wed, 31 May 2023 15:19:50 -0700 Subject: [PATCH 227/712] Updated Design In-Memory File System.java --- Hard/Design In-Memory File System.java | 216 +++++++++++++++---------- 1 file changed, 130 insertions(+), 86 deletions(-) diff --git a/Hard/Design In-Memory File System.java b/Hard/Design In-Memory File System.java index 9bc2ba8e..9002c758 100644 --- a/Hard/Design In-Memory File System.java +++ b/Hard/Design In-Memory File System.java @@ -1,104 +1,148 @@ +import java.util.Optional; + class FileSystem { - private final FileNode root; - - public FileSystem() { - this.root = new FileNode("ROOT", FileType.FOLDER); - } - - /* - * If path is a file path, returns a list that only contains this file's name. - * If path is a directory path, returns the list of file and directory names in this directory. - * */ - public List ls(String path) { - String[] split = path.split("/"); - FileNode currNode = root; - for (int i = 1; i < split.length; i++) { - currNode = currNode.subFiles.get(split[i]); + private final Node root; + + public FileSystem() { + this.root = new DirectoryNode("/"); } - if (currNode.fileType.equals(FileType.FILE)) { - return List.of(currNode.value); - } else { - return currNode.subFiles.keySet().stream().sorted().collect(Collectors.toList()); + + public List ls(String path) { + String[] splits = path.split("/"); + if (splits.length == 0) { + return buildlsResult((DirectoryNode) root); + } + Node curr = root; + for (int i = 1; i < splits.length - 1; i++) { + curr = ((DirectoryNode) curr).getNode(splits[i]).get(); + } + Node lastNode = ((DirectoryNode) curr).getNode(splits[splits.length - 1]).get(); + if (lastNode.isFile()) { + return Collections.singletonList(lastNode.getName()); + } + return buildlsResult((DirectoryNode) lastNode); } - } - - /* - * Makes a new directory according to the given path. The given directory path does not exist. - * If the middle directories in the path do not exist, you should create them as well. - * */ - public void mkdir(String path) { - String[] splits = path.split("/"); - FileNode currNode = root; - for (int i = 1; i < splits.length; i++) { - String fileName = splits[i]; - if (!currNode.subFiles.containsKey(fileName)) { - currNode.subFiles.put(fileName, new FileNode(fileName, FileType.FOLDER)); - } - currNode = currNode.subFiles.get(fileName); + + public void mkdir(String path) { + String[] splits = path.split("/"); + createIfNotExists(splits); } - } - - /* - * If filePath does not exist, creates that file containing given content. - * If filePath already exists, appends the given content to original content. - * */ - public void addContentToFile(String filePath, String content) { - String[] splits = filePath.split("/"); - FileNode currNode = root; - for (int i = 1; i < splits.length - 1; i++) { - String folderName = splits[i]; - if (!currNode.subFiles.containsKey(folderName)) { - currNode.subFiles.put(folderName, new FileNode(folderName, FileType.FOLDER)); - } - currNode = currNode.subFiles.get(folderName); + + public void addContentToFile(String filePath, String content) { + String[] splits = filePath.split("/"); + DirectoryNode directoryNode = createIfNotExists(Arrays.copyOfRange(splits, 0, splits.length)); + String fileName = splits[splits.length - 1]; + if (directoryNode.getNode(fileName).isEmpty()) { + FileNode fileNode = new FileNode(fileName); + directoryNode.addContent(fileName, fileNode); + } + FileNode fileNode = (FileNode) directoryNode.getNode(fileName).get(); + fileNode.addContent(content); } - String fileName = splits[splits.length - 1]; - if (!currNode.subFiles.containsKey(fileName) || - !currNode.subFiles.get(fileName).fileType.equals(FileType.FILE)) { - currNode.subFiles.put(fileName, new FileNode(fileName, FileType.FILE)); + + public String readContentFromFile(String filePath) { + String[] splits = filePath.split("/"); + DirectoryNode directoryNode = createIfNotExists(Arrays.copyOfRange(splits, 0, splits.length)); + String fileName = splits[splits.length - 1]; + FileNode fileNode = (FileNode) directoryNode.getNode(fileName).get(); + return fileNode.getContents(); } - currNode = currNode.subFiles.get(fileName); - currNode.addContentToFile(content); - } - - /* - * Returns the content in the file at filePath. - * */ - public String readContentFromFile(String filePath) { - String[] splits = filePath.split("/"); - FileNode currNode = root; - for (int i = 1; i < splits.length; i++) { - String folderName = splits[i]; - currNode = currNode.subFiles.get(folderName); + + private static List buildlsResult(DirectoryNode curr) { + return curr + .getContents() + .stream() + .map(Node::getName) + .sorted() + .collect(Collectors.toList()); } - return currNode.fileContent.toString(); - } - enum FileType { - FILE, FOLDER - } + private DirectoryNode createIfNotExists(String[] splits) { + DirectoryNode curr = (DirectoryNode) root; + for (int i = 1; i < splits.length; i++) { + Optional nextDirectory = curr.getNode(splits[i]); + if (nextDirectory.isEmpty()) { + DirectoryNode node = new DirectoryNode(splits[i]); + curr.addContent(splits[i], node); + curr = node; + } else { + curr = (DirectoryNode) nextDirectory.get(); + } + } + return curr; + } + + private static class FileNode implements Node { + + private final String name; + + private final StringBuilder contents; + + public FileNode(String name) { + this.name = name; + this.contents = new StringBuilder(); + } + + public void addContent(String content) { + this.contents.append(content); + } - static class FileNode { + public String getContents() { + return contents.toString(); + } - private final String value; - private final Map subFiles; - private final FileType fileType; - private StringBuilder fileContent; + @Override + public String getName() { + return this.name; + } - public FileNode(String value, FileType fileType) { - this.value = value; - this.fileType = fileType; - this.subFiles = new HashMap<>(); + @Override + public boolean isFile() { + return true; + } } - public void addContentToFile(String content) { - if (fileContent == null) { - fileContent = new StringBuilder(); - } - fileContent.append(content); + private static class DirectoryNode implements Node { + + private String name; + + private final Map contents; + + public DirectoryNode(String name) { + this.name = name; + this.contents = new HashMap<>(); + } + + @Override + public String getName() { + return name; + } + + @Override + public boolean isFile() { + return false; + } + + public void addContent(String key, Node node) { + contents.put(key, node); + } + + public List getContents() { + return contents.values().stream().toList(); + } + + public Optional getNode(String nodeName) { + return Optional.ofNullable(contents.getOrDefault(nodeName, null)); + } + } + + private interface Node { + + String getName(); + + boolean isFile(); } - } } /** From 6ac31b58892d71863f583ab4808f7d5917cc1ce0 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Thu, 1 Jun 2023 10:30:41 -0700 Subject: [PATCH 228/712] Updated Shortest Path in Binary Matrix.java --- Medium/Shortest Path in Binary Matrix.java | 67 +++++++++++----------- 1 file changed, 35 insertions(+), 32 deletions(-) diff --git a/Medium/Shortest Path in Binary Matrix.java b/Medium/Shortest Path in Binary Matrix.java index 9977e11b..0be69c86 100644 --- a/Medium/Shortest Path in Binary Matrix.java +++ b/Medium/Shortest Path in Binary Matrix.java @@ -1,37 +1,40 @@ class Solution { - private final int[][] DIRS = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}, {1, 1}, {-1, 1}, {1, -1}, {-1, -1}}; - - public int shortestPathBinaryMatrix(int[][] grid) { - if (grid[0][0] == 1) { - return -1; - } - int numRows = grid.length; - int numCols = grid[0].length; - boolean[][] visited = new boolean[numRows][numCols]; - Queue queue = new LinkedList<>(); - queue.add(new int[]{0, 0}); - visited[0][0] = true; - int numOfSteps = 0; - while (!queue.isEmpty()) { - numOfSteps++; - int size = queue.size(); - while (size-- > 0) { - int[] removed = queue.remove(); - int x = removed[0]; - int y = removed[1]; - if (x == numRows - 1 && y == numCols - 1) { - return numOfSteps; + + private static final int[][] DIRS = {{0,1},{0,-1},{1,0},{-1,0},{1,-1},{-1,1},{-1,-1},{1,1}}; + + public int shortestPathBinaryMatrix(int[][] grid) { + int numRows = grid.length; + int numCols = grid[0].length; + if (grid[0][0] == 1 || grid[numRows - 1][numCols - 1] == 1) { + return -1; } - for (int[] dir : DIRS) { - int newX = x + dir[0]; - int newY = y + dir[1]; - if (newX >= 0 && newY >= 0 && newX < numRows && newY < numCols && !visited[newX][newY] && grid[newX][newY] == 0) { - queue.add(new int[]{newX, newY}); - visited[newX][newY] = true; - } + int shortestDistance = 0; + Queue queue = new LinkedList<>(); + queue.add(new int[]{0, 0}); + boolean[][] visited = new boolean[numRows][numCols]; + visited[0][0] = true; + while (!queue.isEmpty()) { + int size = queue.size(); + while (size-- > 0) { + int[] removed = queue.remove(); + if (removed[0] == (numRows - 1) && removed[1] == (numCols - 1)) { + return shortestDistance + 1; + } + for (int i = 0; i < DIRS.length; i++) { + int newX = removed[0] + DIRS[i][0]; + int newY = removed[1] + DIRS[i][1]; + if (isValidCoordinate(newX, newY, numRows, numCols, visited, grid)) { + queue.add(new int[]{newX, newY}); + visited[newX][newY] = true; + } + } + } + shortestDistance++; } - } + return -1; + } + + private static boolean isValidCoordinate(int x, int y, int rows, int cols, boolean[][] visited, int[][] grid) { + return x >= 0 && x < rows && y >= 0 && y < cols && !visited[x][y] && grid[x][y] == 0; } - return -1; - } } From c0d05f95cabf58da96bf3af333fd3e4b0a08b00a Mon Sep 17 00:00:00 2001 From: varunu28 Date: Thu, 1 Jun 2023 19:37:00 -0700 Subject: [PATCH 229/712] Added Detonate the Maximum Bombs.java --- Medium/Detonate the Maximum Bombs.java | 37 ++++++++++++++++++++++++++ 1 file changed, 37 insertions(+) create mode 100644 Medium/Detonate the Maximum Bombs.java diff --git a/Medium/Detonate the Maximum Bombs.java b/Medium/Detonate the Maximum Bombs.java new file mode 100644 index 00000000..2dbecdc0 --- /dev/null +++ b/Medium/Detonate the Maximum Bombs.java @@ -0,0 +1,37 @@ +class Solution { + public int maximumDetonation(int[][] bombs) { + Map> graph = new HashMap<>(); + int n = bombs.length; + for (int i = 0; i < n; i++) { + for (int j = 0; j < n; j++) { + if (i == j) { + continue; + } + int x1 = bombs[i][0]; + int y1 = bombs[i][1]; + int r = bombs[i][2]; + int x2 = bombs[j][0]; + int y2 = bombs[j][1]; + if ((long) r * r >= (long) (x1 - x2) * (x1 - x2) + (long) (y1 - y2) * (y1 - y2)) { + graph.computeIfAbsent(i, k -> new ArrayList<>()).add(j); + } + } + } + int result = 0; + for (int i = 0; i < n; i++) { + result = Math.max(result, dfs(i, new HashSet<>(), graph)); + } + return result; + } + + private int dfs(int curr, Set visited, Map> graph) { + visited.add(curr); + int count = 1; + for (Integer neighbor : graph.getOrDefault(curr, new ArrayList<>())) { + if (!visited.contains(neighbor)) { + count += dfs(neighbor, visited, graph); + } + } + return count; + } +} From e97550355a8734098472d08253d9a1c15a688452 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Fri, 2 Jun 2023 17:27:07 -0700 Subject: [PATCH 230/712] Updated Time Needed to Inform All Employees.java --- .../Time Needed to Inform All Employees.java | 41 ++++++++++--------- 1 file changed, 21 insertions(+), 20 deletions(-) diff --git a/Medium/Time Needed to Inform All Employees.java b/Medium/Time Needed to Inform All Employees.java index 901f53b5..f8cc21ac 100644 --- a/Medium/Time Needed to Inform All Employees.java +++ b/Medium/Time Needed to Inform All Employees.java @@ -1,23 +1,24 @@ class Solution { - public int numOfMinutes(int n, int headID, int[] manager, int[] informTime) { - Map> organization = new HashMap<>(); - for (int i = 0; i < manager.length; i++) { - if (manager[i] != -1) { - organization.computeIfAbsent(manager[i], k -> new ArrayList<>()).add(i); - } + public int numOfMinutes(int n, int headID, int[] manager, int[] informTime) { + Map> organization = new HashMap<>(); + for (int i = 0; i < manager.length; i++) { + if (manager[i] == -1) { + continue; + } + organization.computeIfAbsent(manager[i], k -> new ArrayList<>()).add(i); + } + int maxTime = 0; + Queue queue = new LinkedList<>(); + queue.add(new int[]{headID, 0}); + while (!queue.isEmpty()) { + int[] removed = queue.remove(); + int currManager = removed[0]; + int timeElapsed = removed[1]; + maxTime = Math.max(maxTime, timeElapsed); + for (Integer employee : organization.getOrDefault(currManager, new ArrayList<>())) { + queue.add(new int[]{employee, timeElapsed + informTime[currManager]}); + } + } + return maxTime; } - int totalTime = 0; - Queue queue = new LinkedList<>(); - queue.add(new int[]{headID, 0}); - while (!queue.isEmpty()) { - int[] removed = queue.remove(); - int id = removed[0]; - int time = removed[1]; - totalTime = Math.max(totalTime, time); - for (int associate : organization.getOrDefault(id, new ArrayList<>())) { - queue.add(new int[]{associate, time + informTime[id]}); - } - } - return totalTime; - } } From 41c51ea48837dff914deaad98223e924a2d9d81b Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sun, 4 Jun 2023 09:00:55 -0700 Subject: [PATCH 231/712] Updated Number of Provinces.java --- Medium/Number of Provinces.java | 53 +++++++++++++++++---------------- 1 file changed, 28 insertions(+), 25 deletions(-) diff --git a/Medium/Number of Provinces.java b/Medium/Number of Provinces.java index 4f485f0d..03338dd8 100644 --- a/Medium/Number of Provinces.java +++ b/Medium/Number of Provinces.java @@ -1,34 +1,37 @@ class Solution { - public int findCircleNum(int[][] isConnected) { - int n = isConnected.length; - Map> map = new HashMap<>(); - for (int i = 0; i < n; i++) { - for (int j = 0; j < n; j++) { - if (i != j && isConnected[i][j] == 1) { - map.computeIfAbsent(i, k -> new HashSet<>()).add(j); - map.computeIfAbsent(j, k -> new HashSet<>()).add(i); + public int findCircleNum(int[][] isConnected) { + Map> graph = new HashMap<>(); + for (int i = 0; i < isConnected.length; i++) { + for (int j = 0; j < isConnected[i].length; j++) { + if (i != j && isConnected[i][j] == 1) { + graph.computeIfAbsent(i, k -> new HashSet<>()).add(j); + graph.computeIfAbsent(j, k -> new HashSet<>()).add(i); + } + } + } + Set visited = new HashSet<>(); + int provinces = 0; + for (int i = 0; i < isConnected.length; i++) { + if (!visited.contains(i)) { + traverse(graph, i, visited); + provinces++; + } } - } + return provinces; } - Set visited = new HashSet<>(); - int provinceCount = 0; - for (int i = 0; i < n; i++) { - if (!visited.contains(i)) { + + private void traverse(Map> graph, int city, Set visited) { Queue queue = new LinkedList<>(); - queue.add(i); - visited.add(i); + queue.add(city); + visited.add(city); while (!queue.isEmpty()) { - int removed = queue.remove(); - for (Integer connection : map.getOrDefault(removed, new HashSet<>())) { - if (!visited.contains(connection)) { - queue.add(connection); - visited.add(connection); + int removed = queue.remove(); + for (Integer conn : graph.getOrDefault(removed, new HashSet<>())) { + if (!visited.contains(conn)) { + queue.add(conn); + visited.add(conn); + } } - } } - provinceCount++; - } } - return provinceCount; - } } From 53848d3486110031e8e5feb963e43fe47437c0f6 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sun, 4 Jun 2023 09:05:04 -0700 Subject: [PATCH 232/712] Added Minimize String Length.java --- Easy/Minimize String Length.java | 8 ++++++++ 1 file changed, 8 insertions(+) create mode 100644 Easy/Minimize String Length.java diff --git a/Easy/Minimize String Length.java b/Easy/Minimize String Length.java new file mode 100644 index 00000000..1cb68cf5 --- /dev/null +++ b/Easy/Minimize String Length.java @@ -0,0 +1,8 @@ +class Solution { + public int minimizedStringLength(String s) { + return s.chars() + .mapToObj(c -> (char) c) + .collect(Collectors.toSet()) + .size(); + } +} From 5bbc5c666894ea1f8dcfca0f076bee9a059b35a7 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sun, 4 Jun 2023 09:06:05 -0700 Subject: [PATCH 233/712] Updated Minimize String Length.java --- Easy/Minimize String Length.java | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/Easy/Minimize String Length.java b/Easy/Minimize String Length.java index 1cb68cf5..48d8ab26 100644 --- a/Easy/Minimize String Length.java +++ b/Easy/Minimize String Length.java @@ -1,8 +1,7 @@ class Solution { public int minimizedStringLength(String s) { - return s.chars() - .mapToObj(c -> (char) c) - .collect(Collectors.toSet()) - .size(); + return (int) s.chars() + .distinct() + .count(); } } From 22816322b7409e183ae7ff211e9f26b25dd57394 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sun, 4 Jun 2023 17:37:24 -0700 Subject: [PATCH 234/712] Updated Check If It Is a Straight Line.java --- Easy/Check If It Is a Straight Line.java | 33 ++++++++++++++---------- 1 file changed, 19 insertions(+), 14 deletions(-) diff --git a/Easy/Check If It Is a Straight Line.java b/Easy/Check If It Is a Straight Line.java index 174053a3..407ed220 100644 --- a/Easy/Check If It Is a Straight Line.java +++ b/Easy/Check If It Is a Straight Line.java @@ -1,16 +1,21 @@ -class Solution { - public boolean checkStraightLine(int[][] coordinates) { - int xOne = coordinates[1][0]; - int yOne = coordinates[1][1]; - int dx = xOne - coordinates[0][0]; - int dy = yOne - coordinates[0][1]; - for (int[] coordinate : coordinates) { - int x = coordinate[0]; - int y = coordinate[1]; - if (dx * (y - yOne) != dy * (x - xOne)) { - return false; - } +class Solution { + public boolean checkStraightLine(int[][] coordinates) { + int deltaY = getYDiff(coordinates[1], coordinates[0]); + int deltaX = getXDiff(coordinates[1], coordinates[0]); + for (int i = 2; i < coordinates.length; i++) { + if (deltaY * getXDiff(coordinates[i], coordinates[0]) != deltaX * getYDiff(coordinates[i], coordinates[0])) { + return false; + } + } + return true; } - return true; - } + + private int getYDiff(int[] a, int[] b) { + return a[1] - b[1]; + } + + private int getXDiff(int[] a, int[] b) { + return a[0] - b[0]; + } + } From 7cf26a8577ef68df23c38a949b4b006cb630a76a Mon Sep 17 00:00:00 2001 From: varunu28 Date: Mon, 5 Jun 2023 18:01:50 -0700 Subject: [PATCH 235/712] Updated Can Make Arithmetic Progression From Sequence.java --- ...e Arithmetic Progression From Sequence.java | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/Easy/Can Make Arithmetic Progression From Sequence.java b/Easy/Can Make Arithmetic Progression From Sequence.java index edc5b0db..fbd09e98 100644 --- a/Easy/Can Make Arithmetic Progression From Sequence.java +++ b/Easy/Can Make Arithmetic Progression From Sequence.java @@ -1,12 +1,12 @@ class Solution { - public boolean canMakeArithmeticProgression(int[] arr) { - Arrays.sort(arr); - int diff = arr[1] - arr[0]; - for (int i = 2; i < arr.length; i++) { - if (arr[i] - arr[i - 1] != diff) { - return false; - } + public boolean canMakeArithmeticProgression(int[] arr) { + Arrays.sort(arr); + int diff = arr[1] - arr[0]; + for (int i = 2; i < arr.length; i++) { + if (arr[i] - arr[i - 1] != diff) { + return false; + } + } + return true; } - return true; - } } From eeefb09a22ea781114971952f1e1108d6571ebc8 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Tue, 6 Jun 2023 17:53:14 -0700 Subject: [PATCH 236/712] Added Minimum Flips to Make a OR b Equal to c.java --- Medium/Minimum Flips to Make a OR b Equal to c.java | 5 +++++ 1 file changed, 5 insertions(+) create mode 100644 Medium/Minimum Flips to Make a OR b Equal to c.java diff --git a/Medium/Minimum Flips to Make a OR b Equal to c.java b/Medium/Minimum Flips to Make a OR b Equal to c.java new file mode 100644 index 00000000..91963256 --- /dev/null +++ b/Medium/Minimum Flips to Make a OR b Equal to c.java @@ -0,0 +1,5 @@ +class Solution { + public int minFlips(int a, int b, int c) { + return Integer.bitCount((a | b) ^ c) + Integer.bitCount(a & b & ((a | b) ^ c)); + } +} From c94158c3aa2b810811be68c90d1ea4fd3bce7271 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Wed, 7 Jun 2023 17:30:39 -0700 Subject: [PATCH 237/712] Update Count Negative Numbers in a Sorted Matrix.java --- ...t Negative Numbers in a Sorted Matrix.java | 46 +++++++++---------- 1 file changed, 22 insertions(+), 24 deletions(-) diff --git a/Easy/Count Negative Numbers in a Sorted Matrix.java b/Easy/Count Negative Numbers in a Sorted Matrix.java index 96daf80b..af842b43 100644 --- a/Easy/Count Negative Numbers in a Sorted Matrix.java +++ b/Easy/Count Negative Numbers in a Sorted Matrix.java @@ -1,28 +1,26 @@ class Solution { - public int countNegatives(int[][] grid) { - int total = 0; - int n = grid[0].length; - for (int[] gr : grid) { - int negInd = binarySearchHelper(gr, 0, n - 1); - if (negInd != -1) { - total += n - negInd; - } + public int countNegatives(int[][] grid) { + int count = 0; + for (int[] row : grid) { + int idx = findFirstNonNegativeIndex(row); + count += idx == -1 ? 0 : (row.length - idx); + } + return count; } - return total; - } - - private int binarySearchHelper(int[] arr, int start, int end) { - int idx = -1; - while (start <= end) { - int mid = (start + end) / 2; - if (arr[mid] < 0) { - idx = idx == -1 ? mid : Math.min(idx, mid); - end = mid - 1; - } - if (arr[mid] >= 0) { - start = mid + 1; - } + + private int findFirstNonNegativeIndex(int[] row) { + int start = 0; + int end = row.length - 1; + int idx = -1; + while (start <= end) { + int mid = (start + end) / 2; + if (row[mid] < 0) { + idx = mid; + end = mid - 1; + } else { + start = mid + 1; + } + } + return idx; } - return idx; - } } From 92994b4fec8f27c58c77b21afd7272bcba76fa22 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Thu, 8 Jun 2023 07:40:52 -0700 Subject: [PATCH 238/712] Updated Check If a Number Is Majority Element in a Sorted Array.java --- ...Is Majority Element in a Sorted Array.java | 66 +++++++++---------- 1 file changed, 33 insertions(+), 33 deletions(-) diff --git a/Easy/Check If a Number Is Majority Element in a Sorted Array.java b/Easy/Check If a Number Is Majority Element in a Sorted Array.java index 5913a03a..6491d715 100644 --- a/Easy/Check If a Number Is Majority Element in a Sorted Array.java +++ b/Easy/Check If a Number Is Majority Element in a Sorted Array.java @@ -1,38 +1,38 @@ class Solution { - - private static enum DIRECTION { - LEFT, RIGHT; - } - - public boolean isMajorityElement(int[] nums, int target) { - int rightIdx = getIndex(nums, target, DIRECTION.RIGHT); - int leftIdx = getIndex(nums, target, DIRECTION.LEFT); - if (leftIdx == -1 || rightIdx == -1) { - return false; + + private static enum Direction { + LEFT, RIGHT; } - int occurrences = rightIdx - leftIdx + 1; - return occurrences > nums.length / 2; - } - - private int getIndex(int[] nums, int target, DIRECTION direction) { - int resultIdx = -1; - int left = 0; - int right = nums.length - 1; - while (left <= right) { - int mid = (left + right) / 2; - if (nums[mid] == target) { - resultIdx = mid; - if (direction == DIRECTION.LEFT) { - right = mid - 1; - } else { - left = mid + 1; + + public boolean isMajorityElement(int[] nums, int target) { + int firstIndex = findIndex(nums, target, Direction.LEFT); + if (firstIndex == -1) { + return false; } - } else if (nums[mid] > target) { - right = mid - 1; - } else { - left = mid + 1; - } + int lastIndex = findIndex(nums, target, Direction.RIGHT); + int occurrences = lastIndex - firstIndex + 1; + return occurrences > nums.length / 2; + } + + private int findIndex(int[] nums, int target, Direction direction) { + int idx = -1; + int start = 0; + int end = nums.length - 1; + while (start <= end) { + int mid = (start + end) / 2; + if (nums[mid] == target) { + idx = mid; + if (direction == Direction.LEFT) { + end = mid - 1; + } else { + start = mid + 1; + } + } else if (nums[mid] > target) { + end = mid - 1; + } else { + start = mid + 1; + } + } + return idx; } - return resultIdx; - } } From 97c6f39986bab73e050b2e6db1acdba366adc65d Mon Sep 17 00:00:00 2001 From: varunu28 Date: Thu, 8 Jun 2023 14:37:39 -0700 Subject: [PATCH 239/712] Updated Merge Intervals.java --- Medium/Merge Intervals.java | 34 +++++++++++++++------------------- 1 file changed, 15 insertions(+), 19 deletions(-) diff --git a/Medium/Merge Intervals.java b/Medium/Merge Intervals.java index c4b49872..cb0a90cf 100644 --- a/Medium/Merge Intervals.java +++ b/Medium/Merge Intervals.java @@ -1,22 +1,18 @@ class Solution { - public int[][] merge(int[][] intervals) { - Arrays.sort(intervals, Comparator.comparingInt((int[] o) -> o[0]).thenComparingInt(o -> o[1])); - List mergedIntervals = new ArrayList<>(); - int idx = 0; - while (idx < intervals.length) { - int currentStart = intervals[idx][0]; - int currentEnd = intervals[idx][1]; - idx++; - while (idx < intervals.length && intervals[idx][0] <= currentEnd) { - currentEnd = Math.max(intervals[idx][1], currentEnd); - idx++; - } - mergedIntervals.add(new int[]{currentStart, currentEnd}); + public int[][] merge(int[][] intervals) { + Arrays.sort(intervals, Comparator.comparingInt((int[] o) -> o[0]) + .thenComparingInt(o -> o[1])); + int idx = 0; + List result = new ArrayList<>(); + while (idx < intervals.length) { + int start = intervals[idx][0]; + int end = intervals[idx][1]; + idx++; + while (idx < intervals.length && intervals[idx][0] <= end) { + end = Math.max(end, intervals[idx++][1]); + } + result.add(new int[]{start, end}); + } + return result.toArray(new int[][]{}); } - int[][] result = new int[mergedIntervals.size()][2]; - for (int i = 0; i < mergedIntervals.size(); i++) { - result[i] = mergedIntervals.get(i); - } - return result; - } } From 0a29fb631d6454d8a29dbc42443b6f9449fe9eec Mon Sep 17 00:00:00 2001 From: varunu28 Date: Thu, 8 Jun 2023 18:56:07 -0700 Subject: [PATCH 240/712] Updated Find Smallest Letter Greater Than Target.java --- ...d Smallest Letter Greater Than Target.java | 28 +++++++++---------- 1 file changed, 14 insertions(+), 14 deletions(-) diff --git a/Easy/Find Smallest Letter Greater Than Target.java b/Easy/Find Smallest Letter Greater Than Target.java index 62e6cf03..6cdfb73a 100644 --- a/Easy/Find Smallest Letter Greater Than Target.java +++ b/Easy/Find Smallest Letter Greater Than Target.java @@ -1,17 +1,17 @@ class Solution { - public char nextGreatestLetter(char[] letters, char target) { - int start = 0; - int end = letters.length - 1; - int minIdx = Integer.MAX_VALUE; - while (start <= end) { - int mid = (start + end) / 2; - if (letters[mid] > target) { - minIdx = mid; - end = mid - 1; - } else { - start = mid + 1; - } + public char nextGreatestLetter(char[] letters, char target) { + int start = 0; + int end = letters.length - 1; + int idx = -1; + while (start <= end) { + int mid = (start + end) / 2; + if (letters[mid] > target) { + idx = mid; + end = mid - 1; + } else { + start = mid + 1; + } + } + return idx == -1 ? letters[0] : letters[idx]; } - return minIdx == Integer.MAX_VALUE ? letters[0] : letters[minIdx]; - } } From 1a6187b29dc66de08415de45c9c945093c45d679 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sat, 10 Jun 2023 12:23:32 -0700 Subject: [PATCH 241/712] Added Maximum Value at a Given Index in a Bounded Array.java --- ...e at a Given Index in a Bounded Array.java | 30 +++++++++++++++++++ 1 file changed, 30 insertions(+) create mode 100644 Medium/Maximum Value at a Given Index in a Bounded Array.java diff --git a/Medium/Maximum Value at a Given Index in a Bounded Array.java b/Medium/Maximum Value at a Given Index in a Bounded Array.java new file mode 100644 index 00000000..6a1a4966 --- /dev/null +++ b/Medium/Maximum Value at a Given Index in a Bounded Array.java @@ -0,0 +1,30 @@ +class Solution { + public int maxValue(int n, int index, int maxSum) { + int start = 1; + int end = maxSum; + while (start < end) { + int mid = (start + end + 1) / 2; + if (findSum(index, mid, n) <= maxSum) { + start = mid; + } else { + end = mid - 1; + } + } + return start; + } + + private long findSum(int index, int targetIndex, int n) { + long count = 0; + if (targetIndex > index) { + count += (long) (2 * targetIndex - index) * (index + 1) / 2; + } else { + count += (long) (targetIndex + 1) * targetIndex / 2 + index - targetIndex + 1; + } + if (targetIndex >= n - index) { + count += (long) (targetIndex + targetIndex - n + 1 + index) * (n - index) / 2; + } else { + count += (long) (targetIndex + 1) * targetIndex / 2 + n - index - targetIndex; + } + return count - targetIndex; + } +} From 4cad923b9990fcc55edc26e2a5dee70d6214fe39 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sat, 10 Jun 2023 13:29:57 -0700 Subject: [PATCH 242/712] Added Check if The Number is Fascinating.java --- Easy/Check if The Number is Fascinating.java | 13 +++++++++++++ 1 file changed, 13 insertions(+) create mode 100644 Easy/Check if The Number is Fascinating.java diff --git a/Easy/Check if The Number is Fascinating.java b/Easy/Check if The Number is Fascinating.java new file mode 100644 index 00000000..d5074568 --- /dev/null +++ b/Easy/Check if The Number is Fascinating.java @@ -0,0 +1,13 @@ +class Solution { + public boolean isFascinating(int n) { + return isFascinatingHelper(n + "" + 2 * n + "" + 3 * n); + } + + private boolean isFascinatingHelper(String s) { + return s.length() == 9 && s.chars() + .mapToObj(c -> (char) c) + .filter(c -> c != '0') + .collect(Collectors.toSet()) + .size() == 9; + } +} From a7951290fddcdf8dc5c911c6d3513d9c54abd1bd Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sat, 10 Jun 2023 17:49:47 -0700 Subject: [PATCH 243/712] Added Find the Longest Semi-Repetitive Substring.java --- ...the Longest Semi-Repetitive Substring.java | 22 +++++++++++++++++++ 1 file changed, 22 insertions(+) create mode 100644 Medium/Find the Longest Semi-Repetitive Substring.java diff --git a/Medium/Find the Longest Semi-Repetitive Substring.java b/Medium/Find the Longest Semi-Repetitive Substring.java new file mode 100644 index 00000000..f6743a56 --- /dev/null +++ b/Medium/Find the Longest Semi-Repetitive Substring.java @@ -0,0 +1,22 @@ +class Solution { + public int longestSemiRepetitiveSubstring(String s) { + int start = 0; + int end = 0; + int maxLength = 1; + int consecutiveCount = 0; + while (end < s.length() - 1) { + if (s.charAt(end) == s.charAt(end + 1)) { + consecutiveCount++; + } + end++; + while (start < end && consecutiveCount > 1) { + if (s.charAt(start) == s.charAt(start + 1)) { + consecutiveCount--; + } + start++; + } + maxLength = Math.max(maxLength, end - start + 1); + } + return maxLength; + } +} From 220e3c191fe32bb28493aaabc9560ab2af7ebd19 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sun, 11 Jun 2023 09:21:03 -0700 Subject: [PATCH 244/712] Added Neither Minimum nor Maximum.java --- Easy/Neither Minimum nor Maximum.java | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) create mode 100644 Easy/Neither Minimum nor Maximum.java diff --git a/Easy/Neither Minimum nor Maximum.java b/Easy/Neither Minimum nor Maximum.java new file mode 100644 index 00000000..b5d7a6d1 --- /dev/null +++ b/Easy/Neither Minimum nor Maximum.java @@ -0,0 +1,16 @@ +class Solution { + public int findNonMinOrMax(int[] nums) { + int min = nums[0]; + int max = nums[0]; + for (int num : nums) { + min = Math.min(num, min); + max = Math.max(num, max); + } + final int arrayMin = min; + final int arrayMax = max; + return Arrays.stream(nums) + .filter(num -> num != arrayMin && num != arrayMax) + .findFirst() + .orElse(-1); + } +} From c9e15169f169737873777053a1a78a7fc14395db Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sun, 11 Jun 2023 09:30:22 -0700 Subject: [PATCH 245/712] Added Lexicographically Smallest String After Substring Operation.java --- ...lest String After Substring Operation.java | 20 +++++++++++++++++++ 1 file changed, 20 insertions(+) create mode 100644 Medium/Lexicographically Smallest String After Substring Operation.java diff --git a/Medium/Lexicographically Smallest String After Substring Operation.java b/Medium/Lexicographically Smallest String After Substring Operation.java new file mode 100644 index 00000000..e55990b7 --- /dev/null +++ b/Medium/Lexicographically Smallest String After Substring Operation.java @@ -0,0 +1,20 @@ +class Solution { + public String smallestString(String s) { + StringBuilder sb = new StringBuilder(); + int idx = 0; + while (idx < s.length() && s.charAt(idx) == 'a') { + sb.append(s.charAt(idx++)); + } + if (idx == s.length()) { + return s.substring(0, s.length() - 1) + 'z'; + } + while (idx < s.length() && s.charAt(idx) != 'a') { + sb.append(getPreviousChar(s.charAt(idx++))); + } + return sb.append(s.substring(idx)).toString(); + } + + private char getPreviousChar(char c) { + return (char) (c - 1); + } +} From e84f8856b088683a88b430fca9a548e927ae1fa2 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sun, 11 Jun 2023 09:48:01 -0700 Subject: [PATCH 246/712] Updated Longest Palindromic Substring.java --- Medium/Longest Palindromic Substring.java | 46 ++++++++++++----------- 1 file changed, 25 insertions(+), 21 deletions(-) diff --git a/Medium/Longest Palindromic Substring.java b/Medium/Longest Palindromic Substring.java index c22fec2d..73732212 100644 --- a/Medium/Longest Palindromic Substring.java +++ b/Medium/Longest Palindromic Substring.java @@ -1,24 +1,28 @@ class Solution { - public String longestPalindrome(String s) { - int start = 0; - int end = 0; - for (int i = 0; i < s.length(); i++) { - int lenOne = helper(s, i, i); - int lenTwo = helper(s, i, i + 1); - int maxLength = Math.max(lenOne, lenTwo); - if (maxLength > end - start) { - start = i - (maxLength - 1) / 2; - end = i + maxLength / 2; - } + public String longestPalindrome(String s) { + int n = s.length(); + boolean[][] dp = new boolean[n][n]; + int[] result = new int[]{0, 0}; + for (int i = 0; i < n; i++) { + dp[i][i] = true; + } + for (int i = 0; i < n - 1; i++) { + if (s.charAt(i) == s.charAt(i + 1)) { + dp[i][i + 1] = true; + result[0] = i; + result[1] = i + 1; + } + } + for (int i = 2; i < n; i++) { + for (int j = 0; j < n - i; j++) { + int k = i + j; + if (s.charAt(j) == s.charAt(k) && dp[j + 1][k - 1]) { + dp[j][k] = true; + result[0] = j; + result[1] = k; + } + } + } + return s.substring(result[0], result[1] + 1); } - return s.substring(start, end + 1); - } - - private int helper(String s, int left, int right) { - while (left >= 0 && right < s.length() && s.charAt(left) == s.charAt(right)) { - left--; - right++; - } - return right - left - 1; - } } From 87898047e5d7f922a44f6fe01f676ba49aa1fced Mon Sep 17 00:00:00 2001 From: varunu28 Date: Mon, 12 Jun 2023 06:41:03 -0700 Subject: [PATCH 247/712] Updated Summary Ranges.java --- Easy/Summary Ranges.java | 28 +++++++++++++--------------- 1 file changed, 13 insertions(+), 15 deletions(-) diff --git a/Easy/Summary Ranges.java b/Easy/Summary Ranges.java index cf67a700..0de1dc7b 100644 --- a/Easy/Summary Ranges.java +++ b/Easy/Summary Ranges.java @@ -1,18 +1,16 @@ class Solution { - public List summaryRanges(int[] nums) { - List result = new ArrayList<>(); - int idx = 0; - int n = nums.length; - while (idx < n) { - int start = nums[idx]; - int end = start; - idx++; - while (idx < n && nums[idx] == end + 1) { - end = nums[idx]; - idx++; - } - result.add(start == end ? String.valueOf(start) : (start + "->" + end)); + public List summaryRanges(int[] nums) { + List result = new ArrayList<>(); + int idx = 0; + while (idx < nums.length) { + int startIdx = idx; + int endIdx = idx; + idx++; + while (idx < nums.length && nums[idx] - nums[idx - 1] == 1) { + endIdx = idx++; + } + result.add(startIdx == endIdx ? String.valueOf(nums[startIdx]) : nums[startIdx] + "->" + nums[endIdx]); + } + return result; } - return result; - } } From c2cd62e5dce249eb8126ff5fc47fd2eef8de1f37 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Mon, 12 Jun 2023 17:17:06 -0700 Subject: [PATCH 248/712] Updated Equal Row and Column Pairs.java --- Medium/Equal Row and Column Pairs.java | 42 ++++++++++++-------------- 1 file changed, 20 insertions(+), 22 deletions(-) diff --git a/Medium/Equal Row and Column Pairs.java b/Medium/Equal Row and Column Pairs.java index 7c31eb66..515fb2db 100644 --- a/Medium/Equal Row and Column Pairs.java +++ b/Medium/Equal Row and Column Pairs.java @@ -1,25 +1,23 @@ class Solution { - public int equalPairs(int[][] grid) { - Map map = new HashMap<>(); - int rows = grid.length; - int cols = grid[0].length; - for (int i = 0; i < rows; i++) { - StringBuilder sb = new StringBuilder(); - for (int j = 0; j < cols; j++) { - sb.append(grid[i][j]).append("|"); - } - String key = sb.toString(); - map.put(key, map.getOrDefault(key, 0) + 1); + public int equalPairs(int[][] grid) { + Map rowMap = new HashMap<>(); + for (int[] value : grid) { + StringBuilder sb = new StringBuilder(); + for (int j = 0; j < grid[0].length; j++) { + sb.append(value[j]).append("|"); + } + String key = sb.toString(); + rowMap.put(key, rowMap.getOrDefault(key, 0) + 1); + } + int count = 0; + for (int i = 0; i < grid[0].length; i++) { + StringBuilder sb = new StringBuilder(); + for (int[] ints : grid) { + sb.append(ints[i]).append("|"); + } + String key = sb.toString(); + count += rowMap.getOrDefault(key, 0); + } + return count; } - int count = 0; - for (int i = 0; i < cols; i++) { - StringBuilder sb = new StringBuilder(); - for (int j = 0; j < rows; j++) { - sb.append(grid[j][i]).append("|"); - } - String key = sb.toString(); - count += map.getOrDefault(key, 0); - } - return count; - } } From 9568033f2a62dbc2c4944975e6802b6baa0d04d6 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Tue, 13 Jun 2023 17:53:49 -0700 Subject: [PATCH 249/712] Updated Minimum Absolute Difference in BST.java --- Easy/Minimum Absolute Difference in BST.java | 34 +++++++++---------- 1 file changed, 16 insertions(+), 18 deletions(-) diff --git a/Easy/Minimum Absolute Difference in BST.java b/Easy/Minimum Absolute Difference in BST.java index d29da542..80248dc1 100644 --- a/Easy/Minimum Absolute Difference in BST.java +++ b/Easy/Minimum Absolute Difference in BST.java @@ -14,24 +14,22 @@ * } */ class Solution { - int minDiff; - TreeNode prev; - public int getMinimumDifference(TreeNode root) { - minDiff = Integer.MAX_VALUE; - prev = null; - helper(root); - return minDiff; - } - - private void helper(TreeNode root) { - if (root == null) { - return; + public int getMinimumDifference(TreeNode root) { + List nodeValues = new ArrayList<>(); + inorder(root, nodeValues); + int minDifference = Integer.MAX_VALUE; + for (int i = 1; i < nodeValues.size(); i++) { + minDifference = Math.min(minDifference, nodeValues.get(i) - nodeValues.get(i - 1)); + } + return minDifference; } - helper(root.left); - if (prev != null) { - minDiff = Math.min(minDiff, Math.abs(root.val - prev.val)); + + private void inorder(TreeNode root, List nodeValues) { + if (root == null) { + return; + } + inorder(root.left, nodeValues); + nodeValues.add(root.val); + inorder(root.right, nodeValues); } - prev = root; - helper(root.right); - } } From 5ff595191ff7e7e91b006010218ea4a4703473f9 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Wed, 14 Jun 2023 17:10:20 -0700 Subject: [PATCH 250/712] Updated Maximum Level Sum of a Binary Tree.java --- .../Maximum Level Sum of a Binary Tree.java | 53 +++++++++---------- 1 file changed, 25 insertions(+), 28 deletions(-) diff --git a/Medium/Maximum Level Sum of a Binary Tree.java b/Medium/Maximum Level Sum of a Binary Tree.java index 8c1bdac6..74c62767 100644 --- a/Medium/Maximum Level Sum of a Binary Tree.java +++ b/Medium/Maximum Level Sum of a Binary Tree.java @@ -14,34 +14,31 @@ * } */ class Solution { - public int maxLevelSum(TreeNode root) { - if (root == null) { - return 0; - } - int currLevel = 1; - int maxSum = Integer.MIN_VALUE; - int maxSumLevel = 0; - Queue queue = new LinkedList<>(); - queue.add(root); - while (!queue.isEmpty()) { - int size = queue.size(); - int currSum = 0; - while (size-- > 0) { - TreeNode removed = queue.remove(); - currSum += removed.val; - if (removed.left != null) { - queue.add(removed.left); - } - if (removed.right != null) { - queue.add(removed.right); + public int maxLevelSum(TreeNode root) { + int maxSum = Integer.MIN_VALUE; + int maxSumLevel = 0; + int currLevel = 1; + Queue queue = new LinkedList<>(); + queue.add(root); + while (!queue.isEmpty()) { + int levelSum = 0; + int size = queue.size(); + while (size-- > 0) { + TreeNode removed = queue.remove(); + levelSum += removed.val; + if (removed.left != null) { + queue.add(removed.left); + } + if (removed.right != null) { + queue.add(removed.right); + } + } + if (levelSum > maxSum) { + maxSum = levelSum; + maxSumLevel = currLevel; + } + currLevel++; } - } - if (maxSum < currSum) { - maxSum = currSum; - maxSumLevel = currLevel; - } - currLevel++; + return maxSumLevel; } - return maxSumLevel; - } } From 82a1e5fe9c7d6abb761ad6ebaf75e41482092ef3 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Thu, 15 Jun 2023 17:10:51 -0700 Subject: [PATCH 251/712] Added Number of Ways to Reorder Array to Get Same BST.java --- ...Ways to Reorder Array to Get Same BST.java | 38 +++++++++++++++++++ 1 file changed, 38 insertions(+) create mode 100644 Hard/Number of Ways to Reorder Array to Get Same BST.java diff --git a/Hard/Number of Ways to Reorder Array to Get Same BST.java b/Hard/Number of Ways to Reorder Array to Get Same BST.java new file mode 100644 index 00000000..a47c1f1d --- /dev/null +++ b/Hard/Number of Ways to Reorder Array to Get Same BST.java @@ -0,0 +1,38 @@ +class Solution { + + private static final long MOD = 1000_000_007; + + public int numOfWays(int[] nums) { + int n = nums.length; + long[][] dp = new long[n][n]; + for (int i = 0; i < n; i++) { + dp[i][0] = dp[i][i] = 1; + } + for (int i = 2; i < n; i++) { + for (int j = 1; j < i; j++) { + dp[i][j] = (dp[i - 1][j - 1] + dp[i - 1][j]) % MOD; + } + } + List list = Arrays.stream(nums).boxed().collect(Collectors.toList()); + return (int) ((dfs(list, dp) - 1) % MOD); + } + + private long dfs(List nums, long[][] dp) { + int n = nums.size(); + if (n < 3) { + return 1; + } + List leftNodes = new ArrayList<>(); + List rightNodes = new ArrayList<>(); + for (int i = 1; i < n; i++) { + if (nums.get(i) < nums.get(0)) { + leftNodes.add(nums.get(i)); + } else { + rightNodes.add(nums.get(i)); + } + } + long leftCount = dfs(leftNodes, dp) % MOD; + long rightCount = dfs(rightNodes, dp) % MOD; + return (((leftCount * rightCount) % MOD) * dp[n - 1][leftNodes.size()]) % MOD; + } +} From c294d1945c617cd2a1e8c8c1fbade7390fe2f4b0 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sat, 17 Jun 2023 07:19:29 -0700 Subject: [PATCH 252/712] Added Make Array Strictly Increasing.java --- Hard/Make Array Strictly Increasing.java | 41 ++++++++++++++++++++++++ 1 file changed, 41 insertions(+) create mode 100644 Hard/Make Array Strictly Increasing.java diff --git a/Hard/Make Array Strictly Increasing.java b/Hard/Make Array Strictly Increasing.java new file mode 100644 index 00000000..77bed2a8 --- /dev/null +++ b/Hard/Make Array Strictly Increasing.java @@ -0,0 +1,41 @@ +class Solution { + public int makeArrayIncreasing(int[] arr1, int[] arr2) { + Arrays.sort(arr2); + Map, Integer> dp = new HashMap<>(); + int result = dfs(0, -1, arr1, arr2, dp); + return result < 2001 ? result : -1; + } + + private int dfs(int idx, int prev, int[] arr1, int[] arr2, Map, Integer> dp) { + if (idx == arr1.length) { + return 0; + } + if (dp.containsKey(new Pair<>(idx, prev))) { + return dp.get(new Pair<>(idx, prev)); + } + int cost = 2001; + if (arr1[idx] > prev) { + cost = dfs(idx + 1, arr1[idx], arr1, arr2, dp); + } + int replaceIdx = binarySearch(arr2, prev); + if (replaceIdx < arr2.length) { + cost = Math.min(cost, 1 + dfs(idx + 1, arr2[replaceIdx], arr1, arr2, dp)); + } + dp.put(new Pair<>(idx, prev), cost); + return cost; + } + + private static int binarySearch(int[] arr, int value) { + int left = 0; + int right = arr.length; + while (left < right) { + int mid = (left + right) / 2; + if (arr[mid] <= value) { + left = mid + 1; + } else { + right = mid; + } + } + return left; + } +} From 5db3be7839486bddeb3e561ee5a887bac4036476 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Mon, 19 Jun 2023 17:00:37 -0700 Subject: [PATCH 253/712] Updated Find the Highest Altitude.java --- Easy/Find the Highest Altitude.java | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/Easy/Find the Highest Altitude.java b/Easy/Find the Highest Altitude.java index a7df7bf1..aa7d12e5 100644 --- a/Easy/Find the Highest Altitude.java +++ b/Easy/Find the Highest Altitude.java @@ -1,11 +1,11 @@ class Solution { - public int largestAltitude(int[] gain) { - int highestAltitude = 0; - int currAltitude = 0; - for (int i = 0; i < gain.length; i++) { - currAltitude += gain[i]; - highestAltitude = Math.max(highestAltitude, currAltitude); + public int largestAltitude(int[] gain) { + int highestAltitude = 0; + int currAltitude = 0; + for (int i = 0; i < gain.length; i++) { + currAltitude = currAltitude + gain[i]; + highestAltitude = Math.max(highestAltitude, currAltitude); + } + return highestAltitude; } - return highestAltitude; - } } From 81e70f92df9bc013c7f0edc347f338f830623323 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Mon, 19 Jun 2023 17:11:01 -0700 Subject: [PATCH 254/712] Added Total Distance Traveled.java --- Easy/Total Distance Traveled.java | 5 +++++ 1 file changed, 5 insertions(+) create mode 100644 Easy/Total Distance Traveled.java diff --git a/Easy/Total Distance Traveled.java b/Easy/Total Distance Traveled.java new file mode 100644 index 00000000..e9697899 --- /dev/null +++ b/Easy/Total Distance Traveled.java @@ -0,0 +1,5 @@ +class Solution { + public int distanceTraveled(int mainTank, int additionalTank) { + return (mainTank + Math.min((mainTank - 1) / 4, additionalTank)) * 10; + } +} From c9ba0096554df67e1a40f6a55aaaca2af0fabe47 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Tue, 20 Jun 2023 17:44:27 -0700 Subject: [PATCH 255/712] Added Minimum Cost to Make Array Equal.java --- Hard/Minimum Cost to Make Array Equal.java | 27 ++++++++++++++++++++++ 1 file changed, 27 insertions(+) create mode 100644 Hard/Minimum Cost to Make Array Equal.java diff --git a/Hard/Minimum Cost to Make Array Equal.java b/Hard/Minimum Cost to Make Array Equal.java new file mode 100644 index 00000000..9fe9b8f9 --- /dev/null +++ b/Hard/Minimum Cost to Make Array Equal.java @@ -0,0 +1,27 @@ +class Solution { + public long minCost(int[] nums, int[] cost) { + int n = nums.length; + int[][] numWithCost = new int[n][2]; + for (int i = 0; i < n; i++) { + numWithCost[i] = new int[]{nums[i], cost[i]}; + } + Arrays.sort(numWithCost, (a, b) -> a[0] - b[0]); + long[] prefixCost = new long[n]; + prefixCost[0] = numWithCost[0][1]; + for (int i = 1; i < n; i++) { + prefixCost[i] = numWithCost[i][1] + prefixCost[i - 1]; + } + long totalCost = 0; + for (int i = 1; i < n; i++) { + totalCost += 1L * numWithCost[i][1] * (numWithCost[i][0] - numWithCost[0][0]); + } + long result = totalCost; + for (int i = 1; i < n; ++i) { + int gap = numWithCost[i][0] - numWithCost[i - 1][0]; + totalCost += 1L * prefixCost[i - 1] * gap; + totalCost -= 1L * (prefixCost[n - 1] - prefixCost[i - 1]) * gap; + result = Math.min(result, totalCost); + } + return result; + } +} From d9bf069395adaabd39adb6a479d537bf0e5a163d Mon Sep 17 00:00:00 2001 From: varunu28 Date: Thu, 22 Jun 2023 07:22:19 -0700 Subject: [PATCH 256/712] Added Best Time to Buy and Sell Stock with Transaction Fee.java --- ... to Buy and Sell Stock with Transaction Fee.java | 13 +++++++++++++ 1 file changed, 13 insertions(+) create mode 100644 Medium/Best Time to Buy and Sell Stock with Transaction Fee.java diff --git a/Medium/Best Time to Buy and Sell Stock with Transaction Fee.java b/Medium/Best Time to Buy and Sell Stock with Transaction Fee.java new file mode 100644 index 00000000..1251e8d0 --- /dev/null +++ b/Medium/Best Time to Buy and Sell Stock with Transaction Fee.java @@ -0,0 +1,13 @@ +class Solution { + public int maxProfit(int[] prices, int fee) { + int n = prices.length; + int[] notHolding = new int[n]; + int[] holding = new int[n]; + holding[0] = -prices[0]; + for (int i = 1; i < n; i++) { + holding[i] = Math.max(holding[i - 1], notHolding[i - 1] - prices[i]); + notHolding[i] = Math.max(notHolding[i - 1], holding[i - 1] + prices[i] - fee); + } + return notHolding[n - 1]; + } +} From 157f7bfd46771922c330031f695cb639389962fb Mon Sep 17 00:00:00 2001 From: varunu28 Date: Fri, 23 Jun 2023 06:50:39 -0700 Subject: [PATCH 257/712] Updated Longest Arithmetic Subsequence.java --- Medium/Longest Arithmetic Subsequence.java | 24 +++++++++++----------- 1 file changed, 12 insertions(+), 12 deletions(-) diff --git a/Medium/Longest Arithmetic Subsequence.java b/Medium/Longest Arithmetic Subsequence.java index 70544ee4..67a7fbb6 100644 --- a/Medium/Longest Arithmetic Subsequence.java +++ b/Medium/Longest Arithmetic Subsequence.java @@ -1,15 +1,15 @@ class Solution { - public int longestArithSeqLength(int[] nums) { - int result = 2; - Map[] dp = new HashMap[nums.length]; - for (int i = 0; i < nums.length; i++) { - dp[i] = new HashMap<>(); - for (int j = 0; j < i; j++) { - int diff = nums[i] - nums[j]; - dp[i].put(diff, dp[j].getOrDefault(diff, 1) + 1); - result = Math.max(result, dp[i].get(diff)); - } + public int longestArithSeqLength(int[] nums) { + int result = 0; + Map[] dp = new HashMap[nums.length]; + for (int i = 0; i < nums.length; i++) { + dp[i] = new HashMap<>(); + for (int j = 0; j < i; j++) { + int diff = nums[j] - nums[i]; + dp[i].put(diff, dp[j].getOrDefault(diff, 1) + 1); + result = Math.max(result, dp[i].get(diff)); + } + } + return result; } - return result; - } } From 9f9edb0697d85042e4e917f248699facb234ce24 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sat, 24 Jun 2023 07:41:33 -0700 Subject: [PATCH 258/712] Added Tallest Billboard.java --- Hard/Tallest Billboard.java | 35 +++++++++++++++++++++++++++++++++++ 1 file changed, 35 insertions(+) create mode 100644 Hard/Tallest Billboard.java diff --git a/Hard/Tallest Billboard.java b/Hard/Tallest Billboard.java new file mode 100644 index 00000000..04f81763 --- /dev/null +++ b/Hard/Tallest Billboard.java @@ -0,0 +1,35 @@ +class Solution { + public int tallestBillboard(int[] rods) { + int n = rods.length; + Map firstHalf = helper(rods, 0, n / 2); + Map secondHalf = helper(rods, n / 2, n); + int result = 0; + for (Integer difference : firstHalf.keySet()) { + if (secondHalf.containsKey(-1 * difference)) { + result = Math.max(result, firstHalf.get(difference) + secondHalf.get(-1 * difference)); + } + } + return result; + } + + private Map helper(int[] rods, int leftIdx, int rightIdx) { + Set> states = new HashSet<>(); + states.add(new Pair(0, 0)); + for (int i = leftIdx; i < rightIdx; i++) { + int rod = rods[i]; + Set> newStates = new HashSet<>(); + for (Pair state : states) { + newStates.add(new Pair(state.getKey() + rod, state.getValue())); + newStates.add(new Pair(state.getKey(), state.getValue() + rod)); + } + states.addAll(newStates); + } + Map dp = new HashMap<>(); + for (Pair pair : states) { + Integer left = pair.getKey(); + Integer right = pair.getValue(); + dp.put(left - right, Math.max(dp.getOrDefault(left - right, 0), left)); + } + return dp; + } +} From b66cf22f9d15257d8df8b820c177f485bead5681 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sat, 24 Jun 2023 14:23:21 -0700 Subject: [PATCH 259/712] Added Find Maximum Number of String Pairs.java --- Easy/Find Maximum Number of String Pairs.java | 13 +++++++++++++ 1 file changed, 13 insertions(+) create mode 100644 Easy/Find Maximum Number of String Pairs.java diff --git a/Easy/Find Maximum Number of String Pairs.java b/Easy/Find Maximum Number of String Pairs.java new file mode 100644 index 00000000..f2673fbe --- /dev/null +++ b/Easy/Find Maximum Number of String Pairs.java @@ -0,0 +1,13 @@ +class Solution { + public int maximumNumberOfStringPairs(String[] words) { + Set set = new HashSet<>(); + int pairCount = 0; + for (String word : words) { + if (set.contains(new StringBuilder(word).reverse().toString())) { + pairCount++; + } + set.add(word); + } + return pairCount; + } +} From 0259040e6657c3e246ad602b6d9d88797cf460a0 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sun, 25 Jun 2023 07:33:31 -0700 Subject: [PATCH 260/712] Added Number of Beautiful Pairs.java --- Easy/Number of Beautiful Pairs.java | 29 +++++++++++++++++++++++++++++ 1 file changed, 29 insertions(+) create mode 100644 Easy/Number of Beautiful Pairs.java diff --git a/Easy/Number of Beautiful Pairs.java b/Easy/Number of Beautiful Pairs.java new file mode 100644 index 00000000..2993a81e --- /dev/null +++ b/Easy/Number of Beautiful Pairs.java @@ -0,0 +1,29 @@ +class Solution { + public int countBeautifulPairs(int[] nums) { + int pairCount = 0; + for (int i = 0; i < nums.length; i++) { + int lastDigit = nums[i] % 10; + for (int j = 0; j < i; j++) { + int firstDigit = getFirstDigit(nums[j]); + pairCount += gcd(firstDigit, lastDigit) == 1 ? 1 : 0; + } + } + return pairCount; + } + + private static int getFirstDigit(int num) { + while (num >= 10) { + num /= 10; + } + return num; + } + + private static int gcd(int a, int b) { + while (b != 0) { + int temp = a % b; + a = b; + b = temp; + } + return a; + } +} From a4d59271959434a39250148d30dbfc7aff266d5d Mon Sep 17 00:00:00 2001 From: varunu28 Date: Mon, 26 Jun 2023 08:48:34 -0700 Subject: [PATCH 261/712] Added Total Cost to Hire K Workers.java --- Medium/Total Cost to Hire K Workers.java | 29 ++++++++++++++++++++++++ 1 file changed, 29 insertions(+) create mode 100644 Medium/Total Cost to Hire K Workers.java diff --git a/Medium/Total Cost to Hire K Workers.java b/Medium/Total Cost to Hire K Workers.java new file mode 100644 index 00000000..c5708a4b --- /dev/null +++ b/Medium/Total Cost to Hire K Workers.java @@ -0,0 +1,29 @@ +class Solution { + public long totalCost(int[] costs, int k, int candidates) { + PriorityQueue headWorkers = new PriorityQueue<>(); + PriorityQueue tailWorkers = new PriorityQueue<>(); + for (int i = 0; i < candidates; i++) { + headWorkers.add(costs[i]); + } + for (int i = Math.max(candidates, costs.length - candidates); i < costs.length; i++) { + tailWorkers.add(costs[i]); + } + int headIdx = candidates; + int tailIdx = costs.length - candidates - 1; + long result = 0; + for (int i = 0; i < k; i++) { + if (tailWorkers.isEmpty() || (!headWorkers.isEmpty() && headWorkers.peek() <= tailWorkers.peek())) { + result += headWorkers.poll(); + if (headIdx <= tailIdx) { + headWorkers.add(costs[headIdx++]); + } + } else { + result += tailWorkers.poll(); + if (headIdx <= tailIdx) { + tailWorkers.add(costs[tailIdx--]); + } + } + } + return result; + } +} From dfa8b889cc78825fb08b7c7ce5c6216c3feb6daf Mon Sep 17 00:00:00 2001 From: varunu28 Date: Mon, 26 Jun 2023 17:37:51 -0700 Subject: [PATCH 262/712] Updated Find K Pairs with Smallest Sums.java --- Medium/Find K Pairs with Smallest Sums.java | 70 +++++++-------------- 1 file changed, 21 insertions(+), 49 deletions(-) diff --git a/Medium/Find K Pairs with Smallest Sums.java b/Medium/Find K Pairs with Smallest Sums.java index 894ca10d..f29f5c15 100644 --- a/Medium/Find K Pairs with Smallest Sums.java +++ b/Medium/Find K Pairs with Smallest Sums.java @@ -1,54 +1,26 @@ -class Solution { - public List kSmallestPairs(int[] nums1, int[] nums2, int k) { - List ans = new ArrayList<>(); - - if (nums1.length == 0 || nums2.length == 0 || k == 0) { - return ans; - } - - PriorityQueue pq = new PriorityQueue<>(new Comparator() { - @Override - public int compare(Element o1, Element o2) { - return (o1.x + o1.y) - (o2.x + o2.y); - } - }); - - for (int i=0; i> kSmallestPairs(int[] nums1, int[] nums2, int k) { + PriorityQueue pq = new PriorityQueue<>((a, b) -> a[2] - b[2]); + List> result = new ArrayList<>(); + Set> visited = new HashSet<>(); + pq.add(new int[]{0, 0, nums1[0] + nums2[0]}); + visited.add(new Pair(0, 0)); while (k-- > 0 && !pq.isEmpty()) { - Element temp = pq.poll(); - ans.add(new int[]{temp.y, temp.x}); - - if (temp.idx >= nums1.length-1) { - continue; + int[] removed = pq.poll(); + int i = removed[0]; + int j = removed[1]; + result.add(List.of(nums1[i], nums2[j])); + Pair nums1Pair = new Pair(i + 1, j); + Pair nums2Pair = new Pair(i, j + 1); + if (i + 1 < nums1.length && !visited.contains(nums1Pair)) { + pq.add(new int[]{i + 1, j, nums1[i + 1] + nums2[j]}); + visited.add(nums1Pair); + } + if (j + 1 < nums2.length && !visited.contains(nums2Pair)) { + pq.add(new int[]{i, j + 1, nums1[i] + nums2[j + 1]}); + visited.add(nums2Pair); } - - pq.offer(new Element(temp.idx+1, temp.x, nums1[temp.idx+1])); - } - - return ans; - } - - class Element { - int idx; - int x; - int y; - - public Element(int val, int x, int y) { - this.idx = val; - this.x = x; - this.y = y; - } - - @Override - public String toString() { - return "Element{" + - "idx=" + idx + - ", x=" + x + - ", y=" + y + - '}'; } + return result; } } From 52111fe5405a6b1d1842b5ec063301e9dbd499a1 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sat, 1 Jul 2023 22:03:18 -0700 Subject: [PATCH 263/712] Added Longest Even Odd Subarray With Threshold.java --- ...gest Even Odd Subarray With Threshold.java | 31 +++++++++++++++++++ 1 file changed, 31 insertions(+) create mode 100644 Easy/Longest Even Odd Subarray With Threshold.java diff --git a/Easy/Longest Even Odd Subarray With Threshold.java b/Easy/Longest Even Odd Subarray With Threshold.java new file mode 100644 index 00000000..f3dcc239 --- /dev/null +++ b/Easy/Longest Even Odd Subarray With Threshold.java @@ -0,0 +1,31 @@ +class Solution { + public int longestAlternatingSubarray(int[] nums, int threshold) { + int maxLength = 0; + int start = 0; + boolean evenRequired = true; + int idx = 0; + while (idx < nums.length) { + if (nums[idx] > threshold) { + idx++; + start = idx; + evenRequired = true; + continue; + } + if (nums[idx] % 2 == 0 && !evenRequired) { + start = idx; + evenRequired = true; + continue; + } + if (nums[idx] % 2 != 0 && evenRequired) { + idx++; + start = idx; + evenRequired = true; + continue; + } + idx++; + maxLength = Math.max(maxLength, idx - start); + evenRequired = !evenRequired; + } + return maxLength; + } +} From ab79856e35201bbb7e6b3d0d09808557f0d597d7 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sun, 2 Jul 2023 17:24:13 -0700 Subject: [PATCH 264/712] Updated Buddy Strings.java --- Easy/Buddy Strings.java | 35 +++++++++++++++++------------------ 1 file changed, 17 insertions(+), 18 deletions(-) diff --git a/Easy/Buddy Strings.java b/Easy/Buddy Strings.java index 83f94a5a..f34ecf35 100644 --- a/Easy/Buddy Strings.java +++ b/Easy/Buddy Strings.java @@ -1,33 +1,32 @@ class Solution { + + private static final int SWAP_DONE_IDX = Integer.MIN_VALUE; + public boolean buddyStrings(String s, String goal) { if (s.length() != goal.length()) { return false; } - int mismatchIdx = -1; + int swapIdx = -1; Set set = new HashSet<>(); for (int i = 0; i < s.length(); i++) { + if (s.charAt(i) == goal.charAt(i)) { + set.add(s.charAt(i)); + continue; + } if (s.charAt(i) != goal.charAt(i)) { - if (mismatchIdx == Integer.MAX_VALUE) { + if (swapIdx == SWAP_DONE_IDX) { return false; } - if (mismatchIdx == -1) { - mismatchIdx = i; - } else { - if (!(s.charAt(mismatchIdx) == goal.charAt(i) && s.charAt(i) == goal.charAt(mismatchIdx))) { - return false; - } - mismatchIdx = Integer.MAX_VALUE; + if (swapIdx == -1) { + swapIdx = i; + continue; + } + if (!(s.charAt(swapIdx) == goal.charAt(i) && s.charAt(i) == goal.charAt(swapIdx))) { + return false; } - } else { - set.add(s.charAt(i)); + swapIdx = SWAP_DONE_IDX; } } - if (mismatchIdx != -1 && mismatchIdx != Integer.MAX_VALUE) { - return false; - } - if (mismatchIdx == -1) { - return s.length() > set.size(); - } - return true; + return (swapIdx != -1 && swapIdx == SWAP_DONE_IDX) || (swapIdx == -1 && set.size() < s.length()); } } From 85c734aa61a38757ae91ed354a9262d329d0448e Mon Sep 17 00:00:00 2001 From: varunu28 Date: Tue, 4 Jul 2023 17:44:18 -0700 Subject: [PATCH 265/712] Added Longest Subarray of 1's After Deleting One Element.java --- ...ubarray of 1's After Deleting One Element.java | 15 +++++++++++++++ 1 file changed, 15 insertions(+) create mode 100644 Medium/Longest Subarray of 1's After Deleting One Element.java diff --git a/Medium/Longest Subarray of 1's After Deleting One Element.java b/Medium/Longest Subarray of 1's After Deleting One Element.java new file mode 100644 index 00000000..b10a1675 --- /dev/null +++ b/Medium/Longest Subarray of 1's After Deleting One Element.java @@ -0,0 +1,15 @@ +class Solution { + public int longestSubarray(int[] nums) { + int zeroIdx = -1; + int windowSize = 0; + int startIdx = 0; + for (int i = 0; i < nums.length; i++) { + if (nums[i] == 0) { + startIdx = zeroIdx + 1; + zeroIdx = i; + } + windowSize = Math.max(windowSize, i - startIdx); + } + return windowSize; + } +} From 97c634930a2062e9a1d5d42b7dc3b6b3ea16a1de Mon Sep 17 00:00:00 2001 From: varunu28 Date: Thu, 6 Jul 2023 17:24:24 -0700 Subject: [PATCH 266/712] Added Maximize the Confusion of an Exam.java --- Medium/Maximize the Confusion of an Exam.java | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) create mode 100644 Medium/Maximize the Confusion of an Exam.java diff --git a/Medium/Maximize the Confusion of an Exam.java b/Medium/Maximize the Confusion of an Exam.java new file mode 100644 index 00000000..3e7e14d1 --- /dev/null +++ b/Medium/Maximize the Confusion of an Exam.java @@ -0,0 +1,19 @@ +class Solution { + public int maxConsecutiveAnswers(String answerKey, int k) { + int resultSize = k; + Map map = new HashMap<>(); + for (int i = 0; i < k; i++) { + map.put(answerKey.charAt(i), map.getOrDefault(answerKey.charAt(i), 0) + 1); + } + int start = 0; + for (int i = k; i < answerKey.length(); i++) { + map.put(answerKey.charAt(i), map.getOrDefault(answerKey.charAt(i), 0) + 1); + while (Math.min(map.getOrDefault('T', 0), map.getOrDefault('F', 0)) > k) { + map.put(answerKey.charAt(start), map.get(answerKey.charAt(start)) - 1); + start++; + } + resultSize = Math.max(resultSize, i - start + 1); + } + return resultSize; + } +} From 5c15c2c4ec60e4e30a7528e61cd89c720d3a0f1c Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sat, 8 Jul 2023 10:58:57 -0700 Subject: [PATCH 267/712] Added Longest Alternating Subarray.java --- Easy/Longest Alternating Subarray.java | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+) create mode 100644 Easy/Longest Alternating Subarray.java diff --git a/Easy/Longest Alternating Subarray.java b/Easy/Longest Alternating Subarray.java new file mode 100644 index 00000000..65de425c --- /dev/null +++ b/Easy/Longest Alternating Subarray.java @@ -0,0 +1,21 @@ +class Solution { + public int alternatingSubarray(int[] nums) { + int start = 0; + int maxLength = -1; + int expectedDiff = 1; + for (int i = 1; i < nums.length;) { + if (nums[i] - nums[i - 1] != expectedDiff) { + if (nums[i] - nums[i - 1] != 1) { + i++; + } + start = i - 1; + expectedDiff = 1; + continue; + } + expectedDiff *= -1; + maxLength = Math.max(maxLength, i - start + 1); + i++; + } + return maxLength; + } +} From ca0aa5f3d50a52363b2ed46cffb0d1981dc0c16d Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sun, 9 Jul 2023 06:43:54 -0700 Subject: [PATCH 268/712] Added Find the Maximum Achievable Number.java --- Easy/Find the Maximum Achievable Number.java | 5 +++++ 1 file changed, 5 insertions(+) create mode 100644 Easy/Find the Maximum Achievable Number.java diff --git a/Easy/Find the Maximum Achievable Number.java b/Easy/Find the Maximum Achievable Number.java new file mode 100644 index 00000000..841862be --- /dev/null +++ b/Easy/Find the Maximum Achievable Number.java @@ -0,0 +1,5 @@ +class Solution { + public int theMaximumAchievableX(int num, int t) { + return num + 2 * t; + } +} From 6cb7d533c288ce708d1e8d210a97ed3a63b5ff43 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sun, 9 Jul 2023 06:51:46 -0700 Subject: [PATCH 269/712] Updated Longest Substring with At Most K Distinct Characters.java --- ...ng with At Most K Distinct Characters.java | 34 +++++++++---------- 1 file changed, 17 insertions(+), 17 deletions(-) diff --git a/Medium/Longest Substring with At Most K Distinct Characters.java b/Medium/Longest Substring with At Most K Distinct Characters.java index 02936a53..a793b8c0 100644 --- a/Medium/Longest Substring with At Most K Distinct Characters.java +++ b/Medium/Longest Substring with At Most K Distinct Characters.java @@ -1,21 +1,21 @@ class Solution { - public int lengthOfLongestSubstringKDistinct(String s, int k) { - Map map = new HashMap<>(); - int startIdx = 0; - int endIdx = 0; - int maxLength = 0; - while (endIdx < s.length()) { - map.put(s.charAt(endIdx), map.getOrDefault(s.charAt(endIdx), 0) + 1); - endIdx++; - while (startIdx < endIdx && map.size() > k) { - map.put(s.charAt(startIdx), map.getOrDefault(s.charAt(startIdx), 0 ) - 1); - if (map.get(s.charAt(startIdx)) == 0) { - map.remove(s.charAt(startIdx)); + public int lengthOfLongestSubstringKDistinct(String s, int k) { + Map map = new HashMap<>(); + int start = 0; + int end = 0; + int maxLength = 0; + while (end < s.length()) { + map.put(s.charAt(end), map.getOrDefault(s.charAt(end), 0) + 1); + while (start <= end && map.size() > k) { + map.put(s.charAt(start), map.get(s.charAt(start)) - 1); + if (map.get(s.charAt(start)) == 0) { + map.remove(s.charAt(start)); + } + start++; + } + end++; + maxLength = Math.max(maxLength, end - start); } - startIdx++; - } - maxLength = Math.max(maxLength, endIdx - startIdx); + return maxLength; } - return maxLength; - } } From f38831aadfe1c0ce6e3ab6c4aa88f958db2e2cad Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sun, 9 Jul 2023 18:46:15 -0700 Subject: [PATCH 270/712] Updated Minimum Depth of a Binary Tree.java --- Easy/Minimum Depth of a Binary Tree.java | 46 ++++++++++++------------ 1 file changed, 22 insertions(+), 24 deletions(-) diff --git a/Easy/Minimum Depth of a Binary Tree.java b/Easy/Minimum Depth of a Binary Tree.java index e1d21cc6..0da04114 100644 --- a/Easy/Minimum Depth of a Binary Tree.java +++ b/Easy/Minimum Depth of a Binary Tree.java @@ -14,31 +14,29 @@ * } */ class Solution { - public int minDepth(TreeNode root) { - if (root == null) { - return 0; - } - int steps = 1; - Queue queue = new LinkedList<>(); - queue.add(root); - while (!queue.isEmpty()) { - int size = queue.size(); - // Level iteration - while (size-- > 0) { - TreeNode removed = queue.remove(); - // Leaf reached - if (removed.left == null && removed.right == null) { - return steps; - } - if (removed.left != null) { - queue.add(removed.left); + public int minDepth(TreeNode root) { + if (root == null) { + return 0; } - if (removed.right != null) { - queue.add(removed.right); + int level = 1; + Queue queue = new LinkedList<>(); + queue.add(root); + while (!queue.isEmpty()) { + int size = queue.size(); + while (size-- > 0) { + TreeNode removed = queue.remove(); + if (removed.left == null && removed.right == null) { + return level; + } + if (removed.left != null) { + queue.add(removed.left); + } + if (removed.right != null) { + queue.add(removed.right); + } + } + level++; } - } - steps++; + return level; } - return steps; - } } From b86b4488f7a3d51036e42fabc46dd9223930651d Mon Sep 17 00:00:00 2001 From: varunu28 Date: Tue, 11 Jul 2023 08:21:15 -0700 Subject: [PATCH 271/712] Updated All Nodes Distance K in Binary Tree.java --- .../All Nodes Distance K in Binary Tree.java | 77 +++++++++---------- 1 file changed, 38 insertions(+), 39 deletions(-) diff --git a/Medium/All Nodes Distance K in Binary Tree.java b/Medium/All Nodes Distance K in Binary Tree.java index 13e9485b..9f88451e 100644 --- a/Medium/All Nodes Distance K in Binary Tree.java +++ b/Medium/All Nodes Distance K in Binary Tree.java @@ -8,49 +8,48 @@ * } */ class Solution { - public List distanceK(TreeNode root, TreeNode target, int k) { - List result = new ArrayList<>(); - dfs(root, target, k, result); - return new ArrayList<>(result); - } - - private int dfs(TreeNode node, TreeNode target, int k, List result) { - if (node == null) { - return -1; + public List distanceK(TreeNode root, TreeNode target, int k) { + List result = new ArrayList<>(); + dfs(root, target, k, result); + return result; } - if (node == target) { - addToResult(node, 0, result, k); - return 1; - } else { - int left = dfs(node.left, target, k, result); - int right = dfs(node.right, target, k, result); - if (left != -1) { - if (left == k) { - result.add(node.val); + + private int dfs(TreeNode node, TreeNode target, int k, List result) { + if (node == null) { + return -1; } - addToResult(node.right, left + 1, result, k); - return left + 1; - } else if (right != -1) { - if (right == k) { - result.add(node.val); + if (node == target) { + dfs(node, 0, k, result); + return 1; + } + int left = dfs(node.left, target, k, result); + if (left != -1) { + if (left == k) { + result.add(node.val); + } + dfs(node.right, left + 1, k, result); + return left + 1; + } + int right = dfs(node.right, target, k, result); + if (right != -1) { + if (right == k) { + result.add(node.val); + } + dfs(node.left, right + 1, k, result); + return right + 1; } - addToResult(node.left, right + 1, result, k); - return right + 1; - } else { return -1; - } - } - } - - private void addToResult(TreeNode node, int dist, List result, int k) { - if (node == null || dist > k) { - return; } - if (dist == k) { - result.add(node.val); - } else { - addToResult(node.left, dist + 1, result, k); - addToResult(node.right, dist + 1, result, k); + + private void dfs(TreeNode node, int distance, int k, List result) { + if (node == null || distance > k) { + return; + } + if (distance == k) { + result.add(node.val); + return; + } + dfs(node.left, distance + 1, k, result); + dfs(node.right, distance + 1, k, result); } - } } From 8e7e64da784242b3c62ddb04fabf5da83baae74a Mon Sep 17 00:00:00 2001 From: varunu28 Date: Tue, 11 Jul 2023 18:30:11 -0700 Subject: [PATCH 272/712] Added Find Eventual Safe States.java --- Medium/Find Eventual Safe States.java | 35 +++++++++++++++++++++++++++ 1 file changed, 35 insertions(+) create mode 100644 Medium/Find Eventual Safe States.java diff --git a/Medium/Find Eventual Safe States.java b/Medium/Find Eventual Safe States.java new file mode 100644 index 00000000..2948587d --- /dev/null +++ b/Medium/Find Eventual Safe States.java @@ -0,0 +1,35 @@ +class Solution { + public List eventualSafeNodes(int[][] graph) { + int n = graph.length; + Map> map = new HashMap<>(); + int[] indegree = new int[n]; + for (int i = 0; i < n; i++) { + for (Integer conn : graph[i]) { + indegree[i]++; + map.computeIfAbsent(conn, k -> new HashSet<>()).add(i); + } + } + Queue queue = new LinkedList<>(); + for (int i = 0; i < n; i++) { + if (indegree[i] == 0) { + queue.add(i); + } + } + List result = new ArrayList<>(); + while (!queue.isEmpty()) { + int size = queue.size(); + while (size-- > 0) { + int removed = queue.remove(); + result.add(removed); + for (Integer conn : map.getOrDefault(removed, new HashSet<>())) { + indegree[conn]--; + if (indegree[conn] == 0) { + queue.add(conn); + } + } + } + } + Collections.sort(result); + return result; + } +} From 3523744aed753badf83a54e68879ab20ed5655ad Mon Sep 17 00:00:00 2001 From: varunu28 Date: Thu, 13 Jul 2023 09:08:53 -0700 Subject: [PATCH 273/712] Updated Course Schedule.java --- Medium/Course Schedule.java | 52 +++++++++++++++++++------------------ 1 file changed, 27 insertions(+), 25 deletions(-) diff --git a/Medium/Course Schedule.java b/Medium/Course Schedule.java index bea1a964..1f8c0693 100644 --- a/Medium/Course Schedule.java +++ b/Medium/Course Schedule.java @@ -1,29 +1,31 @@ class Solution { - public boolean canFinish(int numCourses, int[][] prerequisites) { - Map> map = new HashMap<>(); - int[] indegree = new int[numCourses]; - for (int[] prerequisite : prerequisites) { - map.computeIfAbsent(prerequisite[1], k -> new HashSet<>()).add(prerequisite[0]); - indegree[prerequisite[0]]++; - } - Queue queue = new LinkedList<>(); - Set taken = new HashSet<>(); - for (int i = 0; i < numCourses; i++) { - if (indegree[i] == 0) { - queue.add(i); - taken.add(i); - } - } - while (!queue.isEmpty()) { - int removed = queue.remove(); - for (Integer dependentCourse : map.getOrDefault(removed, new HashSet<>())) { - indegree[dependentCourse]--; - if (indegree[dependentCourse] == 0) { - taken.add(dependentCourse); - queue.add(dependentCourse); + public boolean canFinish(int numCourses, int[][] prerequisites) { + int[] indegree = new int[numCourses]; + Map> map = new HashMap<>(); + for (int[] prerequisite : prerequisites) { + int course = prerequisite[0]; + int prereq = prerequisite[1]; + indegree[course]++; + map.computeIfAbsent(prereq, k -> new HashSet<>()).add(course); + } + Queue queue = new LinkedList<>(); + Set visited = new HashSet<>(); + for (int i = 0; i < numCourses; i++) { + if (indegree[i] == 0) { + queue.add(i); + visited.add(i); + } + } + while (!queue.isEmpty()) { + int removed = queue.remove(); + for (Integer conn : map.getOrDefault(removed, new HashSet<>())) { + indegree[conn]--; + if (indegree[conn] == 0) { + queue.add(conn); + visited.add(conn); + } + } } - } + return visited.size() == numCourses; } - return taken.size() == numCourses; - } } From a89344a94b320af42b8c740e388d89db9e53db7f Mon Sep 17 00:00:00 2001 From: varunu28 Date: Fri, 14 Jul 2023 07:43:29 -0700 Subject: [PATCH 274/712] Added Longest Arithmetic Subsequence of Given Difference.java --- ...t Arithmetic Subsequence of Given Difference.java | 12 ++++++++++++ 1 file changed, 12 insertions(+) create mode 100644 Medium/Longest Arithmetic Subsequence of Given Difference.java diff --git a/Medium/Longest Arithmetic Subsequence of Given Difference.java b/Medium/Longest Arithmetic Subsequence of Given Difference.java new file mode 100644 index 00000000..ef48493e --- /dev/null +++ b/Medium/Longest Arithmetic Subsequence of Given Difference.java @@ -0,0 +1,12 @@ +class Solution { + public int longestSubsequence(int[] arr, int difference) { + Map map = new HashMap<>(); + int maxValue = 0; + for (int num : arr) { + int endingSubLength = map.getOrDefault(num - difference, 0); + map.put(num, endingSubLength + 1); + maxValue = Math.max(maxValue, map.get(num)); + } + return maxValue; + } +} From 91dd115b39eb3e77b54c889f0688c6e93b99a48a Mon Sep 17 00:00:00 2001 From: varunu28 Date: Fri, 14 Jul 2023 13:11:54 -0700 Subject: [PATCH 275/712] Added Web Crawler Multithreaded.java --- Concurrency/Web Crawler Multithreaded.java | 108 +++++++++++++++++++++ 1 file changed, 108 insertions(+) create mode 100644 Concurrency/Web Crawler Multithreaded.java diff --git a/Concurrency/Web Crawler Multithreaded.java b/Concurrency/Web Crawler Multithreaded.java new file mode 100644 index 00000000..bb48616c --- /dev/null +++ b/Concurrency/Web Crawler Multithreaded.java @@ -0,0 +1,108 @@ +/** + * // This is the HtmlParser's API interface. + * // You should not implement it, or speculate about its implementation + * interface HtmlParser { + * public List getUrls(String url) {} + * } + */ +import java.net.URI; +import java.net.URISyntaxException; + + +class Solution { + public List crawl(String startUrl, HtmlParser htmlParser) { + ResultRecord resultRecord = new ResultRecord(); + CrawlTask task = new CrawlTask( + startUrl, htmlParser, resultRecord, UrlUtil.parseHostname(startUrl)); + try { + task.start(); + task.join(); + } catch (InterruptedException e) { + e.printStackTrace(); + } + return resultRecord.getResultList(); + } +} + +class CrawlTask extends Thread { + + private final String url; + private final HtmlParser htmlParser; + private final ResultRecord resultRecord; + private final String parentHost; + + public CrawlTask(String url, + HtmlParser htmlParser, + ResultRecord resultRecord, + String parentHost) { + this.url = url; + this.htmlParser = htmlParser; + this.resultRecord = resultRecord; + this.parentHost = parentHost; + } + + public void run() { + String hostname = UrlUtil.parseHostname(url); + if (!hostname.equals(parentHost)) { + return; + } + if (resultRecord.addIfNotExists(url)) { + List childUrls = htmlParser.getUrls(url); + List tasks = new ArrayList<>(); + for (String childUrl : childUrls) { + tasks.add(new CrawlTask( + childUrl, htmlParser, resultRecord, parentHost)); + } + try { + for (CrawlTask task : tasks) { + task.start(); + } + for (CrawlTask task : tasks) { + task.join(); + } + } catch (InterruptedException e) { + e.printStackTrace(); + } + } + } +} + +class UrlUtil { + + public static String parseHostname(String url) { + try { + URI uri = new URI(url); + return uri.getHost(); + } catch(URISyntaxException e) { + e.printStackTrace(); + } + return null; + } +} + +class ResultRecord { + + private Set urls; + private Semaphore mutex; + + public ResultRecord() { + this.urls = new HashSet<>(); + this.mutex = new Semaphore(1); + } + + public boolean addIfNotExists(String url) { + try { + this.mutex.acquire(); + boolean added = this.urls.add(url); + this.mutex.release(); + return added; + } catch (InterruptedException e) { + e.printStackTrace(); + } + return false; + } + + public List getResultList() { + return new ArrayList<>(urls); + } +} From 32088448fd2cb7b6171d8fff65087b68a7aea181 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sat, 15 Jul 2023 14:18:10 -0700 Subject: [PATCH 276/712] Updated Combination Sum.java --- Medium/Combination Sum.java | 35 ++++++++++++++++++----------------- 1 file changed, 18 insertions(+), 17 deletions(-) diff --git a/Medium/Combination Sum.java b/Medium/Combination Sum.java index de3b3740..6d9e8f77 100644 --- a/Medium/Combination Sum.java +++ b/Medium/Combination Sum.java @@ -1,21 +1,22 @@ class Solution { - public List> combinationSum(int[] candidates, int target) { - List> result = new ArrayList<>(); - helper(candidates, 0, target, new ArrayList<>(), result); - return result; - } + public List> combinationSum(int[] candidates, int target) { + List> result = new ArrayList<>(); + helper(candidates, target, new ArrayList<>(), result, 0); + return result; + } - private void helper(int[] candidates, int idx, int target, List currCombination, - List> result) { - if (target == 0) { - result.add(new ArrayList<>(currCombination)); - } - if (target > 0 && idx < candidates.length) { - for (int i = idx; i < candidates.length; i++) { - currCombination.add(candidates[i]); - helper(candidates, i, target - candidates[i], currCombination, result); - currCombination.remove(currCombination.size() - 1); - } + private void helper(int[] candidates, int target, List combination, List> result, int idx) { + if (target < 0 || idx == candidates.length) { + return; + } + if (target == 0) { + result.add(combination); + return; + } + for (int i = idx; i < candidates.length; i++) { + combination.add(candidates[i]); + helper(candidates, target - candidates[i], new ArrayList<>(combination), result, i); + combination.remove(combination.size() - 1); + } } - } } From 343b1fc60b051544444d75ac0ced78454c36004d Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sat, 15 Jul 2023 14:43:55 -0700 Subject: [PATCH 277/712] Updated Reorganize String.java --- Medium/Reorganize String.java | 63 ++++++++++++++++++----------------- 1 file changed, 32 insertions(+), 31 deletions(-) diff --git a/Medium/Reorganize String.java b/Medium/Reorganize String.java index f3c2dfc1..9dd20760 100644 --- a/Medium/Reorganize String.java +++ b/Medium/Reorganize String.java @@ -1,37 +1,38 @@ class Solution { - public String reorganizeString(String s) { - Map map = new HashMap<>(); - for (char c : s.toCharArray()) { - map.put(c, map.getOrDefault(c, 0) + 1); - } - PriorityQueue pq = new PriorityQueue<>( - (o1, o2) -> map.get(o2).compareTo(map.get(o1))); - pq.addAll(map.keySet()); - StringBuilder sb = new StringBuilder(); - while (!pq.isEmpty()) { - char removed = pq.poll(); - if (!sb.isEmpty() && sb.charAt(sb.length() - 1) == removed) { - if (pq.isEmpty()) { - return ""; + public String reorganizeString(String s) { + Map map = new HashMap<>(); + int maxFrequency = 0; + char maxFrequencyLetter = ' '; + int n = s.length(); + for (char c : s.toCharArray()) { + map.put(c, map.getOrDefault(c, 0) + 1); + if (maxFrequency < map.get(c)) { + maxFrequency = map.get(c); + maxFrequencyLetter = c; + } + } + if (maxFrequency > (n + 1) / 2) { + return ""; } - char secondRemoved = pq.poll(); - pq.add(removed); - sb.append(secondRemoved); - updateStructure(map, pq, secondRemoved); - } else { - sb.append(removed); - updateStructure(map, pq, removed); - } + char[] letters = new char[s.length()]; + int idx = 0; + idx = insertLetter(n, map, maxFrequencyLetter, letters, idx); + map.remove(maxFrequencyLetter); + for (Character key : map.keySet()) { + idx = insertLetter(n, map, key, letters, idx); + } + return String.valueOf(letters); } - return sb.toString(); - } - private void updateStructure(Map map, PriorityQueue pq, char c) { - map.put(c, map.get(c) - 1); - if (map.get(c) > 0) { - pq.add(c); - } else { - map.remove(c); + private static int insertLetter(int n, Map map, char maxFrequencyLetter, char[] letters, int idx) { + while (map.get(maxFrequencyLetter) > 0) { + if (idx >= n) { + idx = 1; + } + letters[idx] = maxFrequencyLetter; + idx += 2; + map.put(maxFrequencyLetter, map.get(maxFrequencyLetter) - 1); + } + return idx; } - } } From 2a5879f2d2341289d6088796ba1d0ad8129774c2 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sun, 16 Jul 2023 06:45:14 -0700 Subject: [PATCH 278/712] Added Sum of Squares of Special Elements.java --- Easy/Sum of Squares of Special Elements.java | 8 ++++++++ 1 file changed, 8 insertions(+) create mode 100644 Easy/Sum of Squares of Special Elements.java diff --git a/Easy/Sum of Squares of Special Elements.java b/Easy/Sum of Squares of Special Elements.java new file mode 100644 index 00000000..2072eee5 --- /dev/null +++ b/Easy/Sum of Squares of Special Elements.java @@ -0,0 +1,8 @@ +class Solution { + public int sumOfSquares(int[] nums) { + return IntStream.range(0, nums.length) + .filter(i -> nums.length % (i + 1) == 0) + .map(i -> nums[i] * nums[i]) + .sum(); + } +} From 433c62a177ec3f9403028295aa32399eac6cb811 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sun, 16 Jul 2023 09:07:18 -0700 Subject: [PATCH 279/712] Updated Lowest Common Ancestor of a Binary Tree.java --- ...west Common Ancestor of a Binary Tree.java | 26 ++++++++++++------- 1 file changed, 16 insertions(+), 10 deletions(-) diff --git a/Medium/Lowest Common Ancestor of a Binary Tree.java b/Medium/Lowest Common Ancestor of a Binary Tree.java index b49de19a..890c71e6 100644 --- a/Medium/Lowest Common Ancestor of a Binary Tree.java +++ b/Medium/Lowest Common Ancestor of a Binary Tree.java @@ -8,15 +8,21 @@ * } */ class Solution { - public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) { - if (root == null || root == p || root == q) { - return root; + public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) { + if (root == null) { + return null; + } + if (root == p || root == q) { + return root; + } + TreeNode left = lowestCommonAncestor(root.left, p, q); + TreeNode right = lowestCommonAncestor(root.right, p, q); + if (left != null && right != null) { + return root; + } + if (left != null || right != null) { + return left != null ? left : right; + } + return null; } - TreeNode leftRoot = lowestCommonAncestor(root.left, p, q); - TreeNode rightRoot = lowestCommonAncestor(root.right, p, q); - if (leftRoot != null && rightRoot != null) { - return root; - } - return leftRoot != null ? leftRoot : rightRoot; - } } From b0b2dba5fab86f28fdc192673b44d2ccf0ccbe6a Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sun, 16 Jul 2023 09:18:31 -0700 Subject: [PATCH 280/712] Added Lowest Common Ancestor of a Binary Tree II.java --- ...t Common Ancestor of a Binary Tree II.java | 46 +++++++++++++++++++ 1 file changed, 46 insertions(+) create mode 100644 Medium/Lowest Common Ancestor of a Binary Tree II.java diff --git a/Medium/Lowest Common Ancestor of a Binary Tree II.java b/Medium/Lowest Common Ancestor of a Binary Tree II.java new file mode 100644 index 00000000..be4c28d2 --- /dev/null +++ b/Medium/Lowest Common Ancestor of a Binary Tree II.java @@ -0,0 +1,46 @@ +/** + * Definition for a binary tree node. + * public class TreeNode { + * int val; + * TreeNode left; + * TreeNode right; + * TreeNode(int x) { val = x; } + * } + */ +class Solution { + public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) { + TreeNode result = lca(root, p, q); + if (result == p) { + return checkIfNodeExist(p, q) ? p : null; + } + if (result == q) { + return checkIfNodeExist(q, p) ? q : null; + } + return result; + } + + private boolean checkIfNodeExist(TreeNode root, TreeNode target) { + if (root == target) { + return true; + } + if (root == null) { + return false; + } + return checkIfNodeExist(root.left, target) || checkIfNodeExist(root.right, target); + } + + private TreeNode lca(TreeNode root, TreeNode p, TreeNode q) { + if (root == null) { + return root; + } + if (root == p || root == q) { + return root; + } + TreeNode left = lca(root.left, p, q); + TreeNode right = lca(root.right, p, q); + if (left != null && right != null) { + return root; + } + return left != null ? left : right; + } +} From bed63498e394f69d47e6d733ab530b57db7030f8 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sun, 16 Jul 2023 17:44:51 -0700 Subject: [PATCH 281/712] Updated Add Two Numbers II.java --- Medium/Add Two Numbers II.java | 68 +++++++++++++++++----------------- 1 file changed, 34 insertions(+), 34 deletions(-) diff --git a/Medium/Add Two Numbers II.java b/Medium/Add Two Numbers II.java index fe08935f..59d717cb 100644 --- a/Medium/Add Two Numbers II.java +++ b/Medium/Add Two Numbers II.java @@ -9,40 +9,40 @@ * } */ class Solution { - public ListNode addTwoNumbers(ListNode l1, ListNode l2) { - ListNode revL1 = reverse(l1); - ListNode revL2 = reverse(l2); - ListNode dummy = new ListNode(0); - ListNode curr = dummy; - int carry = 0; - while (revL1 != null || revL2 != null || carry != 0) { - if (revL1 != null && revL2 != null) { - carry += revL1.val + revL2.val; - revL1 = revL1.next; - revL2 = revL2.next; - } else if (revL1 != null && revL2 == null) { - carry += revL1.val; - revL1 = revL1.next; - } else if (revL1 == null && revL2 != null) { - carry += revL2.val; - revL2 = revL2.next; - } - curr.next = new ListNode(carry % 10); - carry /= 10; - curr = curr.next; + public ListNode addTwoNumbers(ListNode l1, ListNode l2) { + ListNode rev1 = reverse(l1); + ListNode rev2 = reverse(l2); + ListNode dummy = new ListNode(); + ListNode curr = dummy; + int carry = 0; + while (rev1 != null || rev2 != null || carry > 0) { + if (rev1 != null && rev2 != null) { + carry += rev1.val + rev2.val; + rev1 = rev1.next; + rev2 = rev2.next; + } else if (rev1 == null && rev2 != null) { + carry += rev2.val; + rev2 = rev2.next; + } else if (rev1 != null && rev2 == null) { + carry += rev1.val; + rev1 = rev1.next; + } + curr.next = new ListNode(carry % 10); + curr = curr.next; + carry /= 10; + } + return reverse(dummy.next); } - return reverse(dummy.next); - } - - private ListNode reverse(ListNode root) { - ListNode curr = root; - ListNode prev = null; - while (curr != null) { - ListNode next = curr.next; - curr.next = prev; - prev = curr; - curr = next; + + private ListNode reverse(ListNode node) { + ListNode curr = node; + ListNode prev = null; + while (curr != null) { + ListNode next = curr.next; + curr.next = prev; + prev = curr; + curr = next; + } + return prev; } - return prev; - } } From 86f10a6e61d9127420318e80ce5ba0a15bb64a74 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Tue, 18 Jul 2023 08:55:44 -0700 Subject: [PATCH 282/712] Updated LRU Cache.java --- Medium/LRU Cache.java | 131 +++++++++++++++++++++++------------------- 1 file changed, 73 insertions(+), 58 deletions(-) diff --git a/Medium/LRU Cache.java b/Medium/LRU Cache.java index e141637f..1e1b3ae6 100644 --- a/Medium/LRU Cache.java +++ b/Medium/LRU Cache.java @@ -1,69 +1,84 @@ class LRUCache { + + private final Map map; + private final int capacity; + private final Node head; + private final Node tail; + + public LRUCache(int capacity) { + this.capacity = capacity; + this.map = new HashMap<>(); + this.head = new Node(-1, -1); + this.tail = new Node(-1, -1); + this.head.next = this.tail; + this.tail.prev = this.head; + } + + public int get(int key) { + if (!map.containsKey(key)) { + return -1; + } + Node node = map.get(key); + removeNode(node); + addToFront(node); + return node.value; + } - private final Map map; - private final Node head; - private final Node tail; - private int capacity; + public void put(int key, int value) { + if (map.containsKey(key)) { + updateExistingKey(key, value); + return; + } + if (map.size() == this.capacity) { + Node leastUsed = tail.prev; + removeNode(leastUsed); + map.remove(leastUsed.key); + } + Node newNode = new Node(key, value); + addToFront(newNode); + map.put(key, newNode); + } - public LRUCache(int capacity) { - this.map = new HashMap<>(); - this.head = new Node(-1, -1); - this.tail = new Node(-1, -1); - head.next = tail; - tail.prev = head; - this.capacity = capacity; - } + private void updateExistingKey(int key, int value) { + Node node = map.get(key); + Node updatedNode = new Node(key, value); + removeNode(node); + addToFront(updatedNode); + map.put(key, updatedNode); + } - public int get(int key) { - if (!this.map.containsKey(key)) { - return -1; + private void removeNode(Node node) { + Node prevToNode = node.prev; + Node nextToNode = node.next; + prevToNode.next = nextToNode; + nextToNode.prev = prevToNode; } - Node node = this.map.get(key); - removeNode(node); - addNode(node); - return this.map.get(key).val; - } - public void put(int key, int value) { - if (!map.containsKey(key)) { - if (capacity == 0) { - removeNode(tail.prev); - } - } else { - removeNode(this.map.get(key)); + private void addToFront(Node node) { + Node nextToHead = head.next; + node.next = nextToHead; + nextToHead.prev = node; + node.prev = head; + head.next = node; } - addNode(new Node(key, value)); - } - - private void addNode(Node node) { - Node nextToHead = head.next; - head.next = node; - node.next = nextToHead; - nextToHead.prev = node; - node.prev = head; - this.map.put(node.key, node); - this.capacity--; - } - - private void removeNode(Node node) { - Node nextNode = node.next; - node.prev.next = nextNode; - nextNode.prev = node.prev; - this.map.remove(node.key); - this.capacity++; - } - private static class Node { - Node next; - Node prev; - int key; - int val; + private static class Node { - public Node(int key, int val) { - this.key = key; - this.val = val; - this.next = null; - this.prev = null; + private final int key; + private final int value; + private Node next; + private Node prev; + + public Node(int key, int value) { + this.key = key; + this.value = value; + } } - } } + +/** + * Your LRUCache object will be instantiated and called as such: + * LRUCache obj = new LRUCache(capacity); + * int param_1 = obj.get(key); + * obj.put(key,value); + */ From 77437e8516b3faa064f9b17fdb0ee5c7bb651cf9 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Wed, 19 Jul 2023 06:14:02 -0700 Subject: [PATCH 283/712] Added Non-overlapping Intervals.java --- Medium/Non Overlapping Intervals.java | 17 ----------------- Medium/Non-overlapping Intervals.java | 17 +++++++++++++++++ 2 files changed, 17 insertions(+), 17 deletions(-) delete mode 100644 Medium/Non Overlapping Intervals.java create mode 100644 Medium/Non-overlapping Intervals.java diff --git a/Medium/Non Overlapping Intervals.java b/Medium/Non Overlapping Intervals.java deleted file mode 100644 index cbdae574..00000000 --- a/Medium/Non Overlapping Intervals.java +++ /dev/null @@ -1,17 +0,0 @@ -class Solution { - public int eraseOverlapIntervals(int[][] intervals) { - if (intervals.length == 0) { - return 0; - } - Arrays.sort(intervals, Comparator.comparingInt(o -> o[1])); - int notRemoved = 1; - int end = intervals[0][1]; - for (int i = 1; i < intervals.length; i++) { - if (intervals[i][0] >= end) { - notRemoved++; - end = intervals[i][1]; - } - } - return intervals.length - notRemoved; - } -} diff --git a/Medium/Non-overlapping Intervals.java b/Medium/Non-overlapping Intervals.java new file mode 100644 index 00000000..c403b5ed --- /dev/null +++ b/Medium/Non-overlapping Intervals.java @@ -0,0 +1,17 @@ +class Solution { + public int eraseOverlapIntervals(int[][] intervals) { + Arrays.sort(intervals, Comparator.comparingInt((int[] o) -> o[1])); + int result = 0; + int minEndTime = Integer.MIN_VALUE; + for (int i = 0; i < intervals.length; i++) { + int start = intervals[i][0]; + int end = intervals[i][1]; + if (start >= minEndTime) { + minEndTime = end; + } else { + result++; + } + } + return result; + } +} From 030ccf5ff473cd0e0a80662abeddb6e0869637c3 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Wed, 19 Jul 2023 18:27:58 -0700 Subject: [PATCH 284/712] Updated Asteroid Collision.java --- Medium/Asteroid Collision.java | 49 +++++++++++++++++++--------------- 1 file changed, 28 insertions(+), 21 deletions(-) diff --git a/Medium/Asteroid Collision.java b/Medium/Asteroid Collision.java index f739ff48..64a10bf3 100644 --- a/Medium/Asteroid Collision.java +++ b/Medium/Asteroid Collision.java @@ -1,26 +1,33 @@ class Solution { - public int[] asteroidCollision(int[] asteroids) { - Stack stack = new Stack<>(); - for (int asteroid : asteroids) { - if (asteroid < 0) { - while (!stack.isEmpty() && stack.peek() > 0 && stack.peek() < Math.abs(asteroid)) { - stack.pop(); + public int[] asteroidCollision(int[] asteroids) { + List result = new ArrayList<>(); + int idx = 0; + while (idx < asteroids.length && asteroids[idx] < 0) { + result.add(asteroids[idx++]); } - if (!stack.isEmpty() && stack.peek() > 0) { - if (stack.peek() == Math.abs(asteroid)) { - stack.pop(); - } - } else { - stack.push(asteroid); + while (idx < asteroids.length) { + if (asteroids[idx] > 0) { + result.add(asteroids[idx++]); + } else { + if (result.isEmpty() || result.get(result.size() - 1) < 0) { + result.add(asteroids[idx]); + } else { + while (!result.isEmpty() && + result.get(result.size() - 1) > 0 && + result.get(result.size() - 1) < Math.abs(asteroids[idx])) { + result.remove(result.size() - 1); + } + if (!result.isEmpty() && result.get(result.size() - 1) > 0) { + if (result.get(result.size() - 1) == Math.abs(asteroids[idx])) { + result.remove(result.size() - 1); + } + } else { + result.add(asteroids[idx]); + } + } + idx++; + } } - } else { - stack.push(asteroid); - } + return result.stream().mapToInt(Integer::valueOf).toArray(); } - int[] result = new int[stack.size()]; - for (int i = result.length - 1; i >= 0; i--) { - result[i] = stack.pop(); - } - return result; - } } From af2dcca53ab3bc59f08bd7fbcb62e1ebe600f472 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sat, 22 Jul 2023 17:54:40 -0700 Subject: [PATCH 285/712] Added Check if Array is Good.java --- Easy/Check if Array is Good.java | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+) create mode 100644 Easy/Check if Array is Good.java diff --git a/Easy/Check if Array is Good.java b/Easy/Check if Array is Good.java new file mode 100644 index 00000000..f0b86ddc --- /dev/null +++ b/Easy/Check if Array is Good.java @@ -0,0 +1,24 @@ +class Solution { + public boolean isGood(int[] nums) { + if (nums.length <= 1) { + return false; + } + int n = nums.length - 1; + Map map = new HashMap<>(); + for (int num : nums) { + map.put(num, map.getOrDefault(num, 0) + 1); + } + for (int i = 1; i <= n; i++) { + if (!map.containsKey(i)) { + return false; + } + if (map.get(i) > 1 && i != n) { + return false; + } + if (i == n && map.get(i) != 2) { + return false; + } + } + return true; + } +} From 21cc646c90cf987d73508826557ab82bb150f205 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sat, 22 Jul 2023 18:33:40 -0700 Subject: [PATCH 286/712] Updated Ternary Expression Parser.java --- Medium/Ternary Expression Parser.java | 36 ++++++++++++--------------- 1 file changed, 16 insertions(+), 20 deletions(-) diff --git a/Medium/Ternary Expression Parser.java b/Medium/Ternary Expression Parser.java index c0079881..6798336d 100644 --- a/Medium/Ternary Expression Parser.java +++ b/Medium/Ternary Expression Parser.java @@ -1,23 +1,19 @@ class Solution { - public String parseTernary(String expression) { - if (expression == null || expression.length() == 0) { - return ""; + public String parseTernary(String expression) { + Stack stack = new Stack<>(); + int idx = expression.length() - 1; + while (idx >= 0) { + char c = expression.charAt(idx); + if (c >= '0' && c <= '9' || c == 'T' || c == 'F') { + stack.push(c); + } else if (c == '?') { + char trueValue = stack.pop(); + char falseValue = stack.pop(); + stack.push(expression.charAt(idx - 1) == 'T' ? trueValue : falseValue); + idx--; + } + idx--; + } + return String.valueOf(stack.pop()); } - Deque stack = new LinkedList<>(); - int n = expression.length(); - for (int i = n - 1; i >= 0; i--) { - char c = expression.charAt(i); - if (!stack.isEmpty() && stack.peek() == '?') { - stack.pop(); // Pop ? - char first = stack.pop(); - stack.pop(); // Pop : - char second = stack.pop(); - stack.push(c == 'T' ? first : second); - } - else { - stack.push(c); - } - } - return String.valueOf(stack.peek()); - } } From 4feb8fec7c911f0370d16c68290d6cf54b6f9e49 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Sun, 23 Jul 2023 09:05:40 -0700 Subject: [PATCH 287/712] Added Split Strings by Separator.java --- Easy/Split Strings by Separator.java | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+) create mode 100644 Easy/Split Strings by Separator.java diff --git a/Easy/Split Strings by Separator.java b/Easy/Split Strings by Separator.java new file mode 100644 index 00000000..2292a309 --- /dev/null +++ b/Easy/Split Strings by Separator.java @@ -0,0 +1,22 @@ +class Solution { + public List splitWordsBySeparator(List words, char separator) { + List result = new ArrayList<>(); + for (String word : words) { + int startIdx = 0; + int currIdx = 0; + while (currIdx < word.length()) { + if (word.charAt(currIdx) == separator) { + if (currIdx - startIdx > 0) { + result.add(word.substring(startIdx, currIdx)); + } + startIdx = currIdx + 1; + } + currIdx++; + } + if (currIdx - startIdx > 0) { + result.add(word.substring(startIdx, currIdx)); + } + } + return result; + } +} From 9cfef955c90e6afd14d08cc15b492c424b720e76 Mon Sep 17 00:00:00 2001 From: varunu28 Date: Mon, 24 Jul 2023 17:58:41 -0700 Subject: [PATCH 288/712] Added Peak Index in a Mountain Array.java --- Easy/Peak Index in a Mountain Array.java | 16 ---------------- Medium/Peak Index in a Mountain Array.java | 15 +++++++++++++++ 2 files changed, 15 insertions(+), 16 deletions(-) delete mode 100644 Easy/Peak Index in a Mountain Array.java create mode 100644 Medium/Peak Index in a Mountain Array.java diff --git a/Easy/Peak Index in a Mountain Array.java b/Easy/Peak Index in a Mountain Array.java deleted file mode 100644 index 818dbf9c..00000000 --- a/Easy/Peak Index in a Mountain Array.java +++ /dev/null @@ -1,16 +0,0 @@ -class Solution { - public int peakIndexInMountainArray(int[] A) { - int low = 0; - int high = A.length - 1; - while (low < high) { - int mid = low + (high - low) / 2; - if (A[mid] < A[mid + 1]) { - low = mid + 1; - } - else { - high = mid; - } - } - return low; - } -} diff --git a/Medium/Peak Index in a Mountain Array.java b/Medium/Peak Index in a Mountain Array.java new file mode 100644 index 00000000..d496f7c4 --- /dev/null +++ b/Medium/Peak Index in a Mountain Array.java @@ -0,0 +1,15 @@ +class Solution { + public int peakIndexInMountainArray(int[] arr) { + int start = 0; + int end = arr.length - 1; + while (start < end) { + int mid = (start + end) / 2; + if (arr[mid] < arr[mid + 1]) { + start = mid + 1; + } else { + end = mid; + } + } + return start; + } +} From 6b73d50956da22787d7ca4d16a54d7ba11d79469 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Tue, 25 Jul 2023 18:44:14 -0700 Subject: [PATCH 289/712] Create Minimum Speed to Arrive on Time.java --- Medium/Minimum Speed to Arrive on Time.java | 26 +++++++++++++++++++++ 1 file changed, 26 insertions(+) create mode 100644 Medium/Minimum Speed to Arrive on Time.java diff --git a/Medium/Minimum Speed to Arrive on Time.java b/Medium/Minimum Speed to Arrive on Time.java new file mode 100644 index 00000000..c5751902 --- /dev/null +++ b/Medium/Minimum Speed to Arrive on Time.java @@ -0,0 +1,26 @@ +class Solution { + public int minSpeedOnTime(int[] dist, double hour) { + int start = 1; + int end = 1000_000_0; + int minSpeed = -1; + while (start <= end) { + int mid = (start + end) / 2; + if (isPossible(dist, mid, hour)) { + minSpeed = mid; + end = mid - 1; + } else { + start = mid + 1; + } + } + return minSpeed; + } + + private boolean isPossible(int[] dist, int speed, double hour) { + double totalTime = 0.0; + for (int i = 0; i < dist.length; i++) { + double time = (double) dist[i] / (double) speed; + totalTime += (i == dist.length - 1 ? time : Math.ceil(time)); + } + return totalTime <= hour; + } +} From c04e0a8bb8873c44f4c56618153c538598536d60 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 30 Jul 2023 08:30:30 -0700 Subject: [PATCH 290/712] Create Number of Employees Who Met the Target.java --- Easy/Number of Employees Who Met the Target.java | 5 +++++ 1 file changed, 5 insertions(+) create mode 100644 Easy/Number of Employees Who Met the Target.java diff --git a/Easy/Number of Employees Who Met the Target.java b/Easy/Number of Employees Who Met the Target.java new file mode 100644 index 00000000..64f20287 --- /dev/null +++ b/Easy/Number of Employees Who Met the Target.java @@ -0,0 +1,5 @@ +class Solution { + public int numberOfEmployeesWhoMetTarget(int[] hours, int target) { + return (int) Arrays.stream(hours).filter(hour -> hour >= target).count(); + } +} From 51074092e35e2cdeb1559819326cea0d3480f512 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 30 Jul 2023 08:31:03 -0700 Subject: [PATCH 291/712] Update README.md --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index dd9ecf17..79190be6 100644 --- a/README.md +++ b/README.md @@ -2,7 +2,7 @@ ## Solutions to Leetcode problems in Java -## [Current Leetcode profile: Solved 1300+ Problems](https://leetcode.com/varunsjsu/) +## [Current Leetcode profile: Solved 1400+ Problems](https://leetcode.com/varunsjsu/) ## [Previous Leetcode profile: Solved 759 Problems](https://leetcode.com/varunu28/) Problem Category | Count From 5ca5bfc1ae8f36abe3b47301a0744ed971dbf395 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Mon, 31 Jul 2023 17:52:05 -0700 Subject: [PATCH 292/712] Update Combinations.java --- Medium/Combinations.java | 38 +++++++++++++++++--------------------- 1 file changed, 17 insertions(+), 21 deletions(-) diff --git a/Medium/Combinations.java b/Medium/Combinations.java index f5d99e2b..425b44ff 100644 --- a/Medium/Combinations.java +++ b/Medium/Combinations.java @@ -1,26 +1,22 @@ class Solution { - public List> combine(int n, int k) { - List> ans = new ArrayList<>(); - List curr = new ArrayList<>(); - helper(ans, curr, new boolean[n], k, 0); - return ans; - } - - private void helper(List> ans, List curr, boolean[] visited, int k, int idx) { - if (curr.size() == k) { - ans.add(new ArrayList<>(curr)); + public List> combine(int n, int k) { + List> result = new ArrayList<>(); + helper(result, n, k, new ArrayList<>(), 1); + return result; } - else { - for (int i = idx; i < visited.length; i++) { - if (visited[i]) { - continue; + + private void helper(List> result, int n, int k, List curr, int currValue) { + if (curr.size() == k) { + result.add(new ArrayList<>(curr)); + return; + } + for (int i = currValue; i <= n; i++) { + if (!curr.isEmpty() && curr.get(curr.size() - 1) >= i) { + continue; + } + curr.add(i); + helper(result, n, k, curr, currValue + 1); + curr.remove(curr.size() - 1); } - curr.add(i + 1); - visited[i] = true; - helper(ans, curr, visited, k, i + 1); - curr.remove(curr.size() - 1); - visited[i] = false; - } } - } } From 948b2fc4bbc7a43cae264bcb911ef6486683a52e Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Tue, 1 Aug 2023 17:47:26 -0700 Subject: [PATCH 293/712] Update Permutations.java --- Medium/Permutations.java | 40 +++++++++++++++++++++------------------- 1 file changed, 21 insertions(+), 19 deletions(-) diff --git a/Medium/Permutations.java b/Medium/Permutations.java index 760b7452..61c86f42 100644 --- a/Medium/Permutations.java +++ b/Medium/Permutations.java @@ -1,23 +1,25 @@ class Solution { - public List> permute(int[] nums) { - List> result = new ArrayList<>(); - helper(nums, result, new ArrayList<>(), new boolean[nums.length]); - return result; - } - - private void helper(int[] nums, List> result, List curr, boolean[] visited) { - if (curr.size() == nums.length) { - result.add(new ArrayList<>(curr)); - } else { - for (int i = 0; i < nums.length; i++) { - if (!visited[i]) { - visited[i] = true; - curr.add(nums[i]); - helper(nums, result, curr, visited); - visited[i] = false; - curr.remove(curr.size() - 1); + public List> permute(int[] nums) { + List> result = new ArrayList<>(); + Set visited = new HashSet<>(); + permute(nums, result, new ArrayList<>(), visited); + return result; + } + + private void permute(int[] nums, List> result, List curr, Set visited) { + if (curr.size() == nums.length) { + result.add(new ArrayList<>(curr)); + return; + } + for (int i = 0; i < nums.length; i++) { + if (visited.contains(nums[i])) { + continue; + } + visited.add(nums[i]); + curr.add(nums[i]); + permute(nums, result, curr, visited); + visited.remove(nums[i]); + curr.remove(curr.size() - 1); } - } } - } } From f9008e0defd3aae742e88bd0126eb72ab47d0818 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Thu, 3 Aug 2023 11:24:25 -0700 Subject: [PATCH 294/712] Update Letter Combinations of a Phone Number.java --- ...Letter Combinations of a Phone Number.java | 51 +++++++++++-------- 1 file changed, 29 insertions(+), 22 deletions(-) diff --git a/Medium/Letter Combinations of a Phone Number.java b/Medium/Letter Combinations of a Phone Number.java index 2c3a8c23..b145954b 100644 --- a/Medium/Letter Combinations of a Phone Number.java +++ b/Medium/Letter Combinations of a Phone Number.java @@ -1,25 +1,32 @@ class Solution { - - private final List LETTER_MAPPING = Arrays.asList("abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"); - - public List letterCombinations(String digits) { - List result = new ArrayList<>(); - helper(digits, 0, new StringBuilder(), result); - return result; - } - - private void helper(String digits, int idx, StringBuilder sb, List result) { - if (idx == digits.length()) { - if (sb.length() > 0) { - result.add(new String(sb.toString())); - } - return; - } - int mappingIdx = Character.getNumericValue(digits.charAt(idx)) - 2; - for (char c : LETTER_MAPPING.get(mappingIdx).toCharArray()) { - sb.append(c); - helper(digits, idx + 1, sb, result); - sb.deleteCharAt(sb.length() - 1); + private static final Map DIGIT_TO_CHAR_MAPPING = Map.of( + '2', "abc", + '3', "def", + '4', "ghi", + '5', "jkl", + '6', "mno", + '7', "pqrs", + '8', "tuv", + '9', "wxyz" + ); + + public List letterCombinations(String digits) { + List result = new ArrayList<>(); + letterCombinations(digits, 0, new StringBuilder(), result); + return result; + } + + private void letterCombinations(String digits, int idx, StringBuilder sb, List result) { + if (idx == digits.length()) { + if (!sb.isEmpty()) { + result.add(sb.toString()); + } + return; + } + for (char c : DIGIT_TO_CHAR_MAPPING.get(digits.charAt(idx)).toCharArray()) { + sb.append(c); + letterCombinations(digits, idx + 1, sb, result); + sb.deleteCharAt(sb.length() - 1); + } } - } } From 786047b7d738f735525f7ad5b418c902e52e2f20 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sat, 5 Aug 2023 18:36:51 -0700 Subject: [PATCH 295/712] Create Account Balance After Rounded Purchase.java --- Easy/Account Balance After Rounded Purchase.java | 10 ++++++++++ 1 file changed, 10 insertions(+) create mode 100644 Easy/Account Balance After Rounded Purchase.java diff --git a/Easy/Account Balance After Rounded Purchase.java b/Easy/Account Balance After Rounded Purchase.java new file mode 100644 index 00000000..3342d18d --- /dev/null +++ b/Easy/Account Balance After Rounded Purchase.java @@ -0,0 +1,10 @@ +class Solution { + public int accountBalanceAfterPurchase(int purchaseAmount) { + if (purchaseAmount % 10 >= 5) { + purchaseAmount += 10 - purchaseAmount % 10; + } else { + purchaseAmount -= purchaseAmount % 10; + } + return 100 - purchaseAmount; + } +} From 6775fadb7f0d45f1eb7e2e44c87b2169280e6eec Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 6 Aug 2023 07:51:35 -0700 Subject: [PATCH 296/712] Create Faulty Keyboard.java --- Easy/Faulty Keyboard.java | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+) create mode 100644 Easy/Faulty Keyboard.java diff --git a/Easy/Faulty Keyboard.java b/Easy/Faulty Keyboard.java new file mode 100644 index 00000000..500dc39b --- /dev/null +++ b/Easy/Faulty Keyboard.java @@ -0,0 +1,22 @@ +class Solution { + public String finalString(String s) { + Deque deque = new ArrayDeque<>(); + boolean flip = false; + for (char c : s.toCharArray()) { + if (c == 'i') { + flip = !flip; + } else { + if (flip) { + deque.addFirst(c); + } else { + deque.addLast(c); + } + } + } + StringBuilder sb = new StringBuilder(); + for (char c : deque){ + sb.append(c); + } + return flip ? sb.reverse().toString() : sb.toString(); + } +} From b44f362cb1c8add8f1f9a616c6e9ee77fcd1b842 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Mon, 7 Aug 2023 06:40:10 -0700 Subject: [PATCH 297/712] Update Search a 2D Matrix.java --- Medium/Search a 2D Matrix.java | 34 +++++++++++++++++----------------- 1 file changed, 17 insertions(+), 17 deletions(-) diff --git a/Medium/Search a 2D Matrix.java b/Medium/Search a 2D Matrix.java index e7de2a1f..086454e0 100644 --- a/Medium/Search a 2D Matrix.java +++ b/Medium/Search a 2D Matrix.java @@ -1,21 +1,21 @@ class Solution { - public boolean searchMatrix(int[][] matrix, int target) { - int rowIdx = matrix.length - 1; - int colIdx = matrix[0].length - 1; - while (rowIdx >= 0 && colIdx >= 0) { - if (matrix[rowIdx][colIdx] == target) { - return true; - } - if (matrix[rowIdx][colIdx] > target) { - colIdx--; - if (colIdx < 0) { - colIdx = matrix[0].length - 1; - rowIdx--; + public boolean searchMatrix(int[][] matrix, int target) { + int row = matrix.length - 1; + int col = matrix[0].length - 1; + while (row >= 0 && col >= 0) { + if (matrix[row][col] == target) { + return true; + } + if (matrix[row][col] > target) { + col--; + if (col < 0) { + col = matrix[0].length - 1; + row--; + } + } else { + row--; + } } - } else { - rowIdx--; - } + return false; } - return false; - } } From 632f7892d835aa73b69cc100c0be01b64b6bcf09 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Mon, 7 Aug 2023 06:48:18 -0700 Subject: [PATCH 298/712] Create Insert Greatest Common Divisors in Linked List.java --- ...eatest Common Divisors in Linked List.java | 29 +++++++++++++++++++ 1 file changed, 29 insertions(+) create mode 100644 Medium/Insert Greatest Common Divisors in Linked List.java diff --git a/Medium/Insert Greatest Common Divisors in Linked List.java b/Medium/Insert Greatest Common Divisors in Linked List.java new file mode 100644 index 00000000..6dcf5fd0 --- /dev/null +++ b/Medium/Insert Greatest Common Divisors in Linked List.java @@ -0,0 +1,29 @@ +/** + * Definition for singly-linked list. + * public class ListNode { + * int val; + * ListNode next; + * ListNode() {} + * ListNode(int val) { this.val = val; } + * ListNode(int val, ListNode next) { this.val = val; this.next = next; } + * } + */ +class Solution { + public ListNode insertGreatestCommonDivisors(ListNode head) { + ListNode curr = head; + while (curr != null && curr.next != null) { + ListNode gcdNode = new ListNode(findGcd(curr.val, curr.next.val)); + gcdNode.next = curr.next; + curr.next = gcdNode; + curr = gcdNode.next; + } + return head; + } + + private static int findGcd(int numOne, int numTwo) { + if (numOne == numTwo) { + return numOne; + } + return numOne > numTwo ? findGcd(numOne - numTwo, numTwo) : findGcd(numOne, numTwo - numOne); + } +} From ff3e17292ea34d3355e30e177ce06c6cc19ac742 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Wed, 9 Aug 2023 13:43:37 -0700 Subject: [PATCH 299/712] Create Minimize the Maximum Difference of Pairs.java --- ...imize the Maximum Difference of Pairs.java | 30 +++++++++++++++++++ 1 file changed, 30 insertions(+) create mode 100644 Medium/Minimize the Maximum Difference of Pairs.java diff --git a/Medium/Minimize the Maximum Difference of Pairs.java b/Medium/Minimize the Maximum Difference of Pairs.java new file mode 100644 index 00000000..5ec67591 --- /dev/null +++ b/Medium/Minimize the Maximum Difference of Pairs.java @@ -0,0 +1,30 @@ +class Solution { + public int minimizeMax(int[] nums, int p) { + Arrays.sort(nums); + int n = nums.length; + int start = 0; + int end = nums[n - 1] - nums[0]; + while (start < end) { + int mid = (start + end) / 2; + if (countValidPairs(nums, mid) >= p) { + end = mid; + } else { + start = mid + 1; + } + } + return start; + } + + private static int countValidPairs(int[] nums, int limit) { + int idx = 0; + int count = 0; + while (idx < nums.length - 1) { + if (nums[idx + 1] - nums[idx] <= limit) { + count++; + idx++; + } + idx++; + } + return count; + } +} From 6e45a6a2254b08182704b42abeabb7b151ce9cb8 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Thu, 10 Aug 2023 10:02:12 -0700 Subject: [PATCH 300/712] Update Search in Rotated Sorted Array II.java --- Medium/Search in Rotated Sorted Array II.java | 48 +++++++++---------- 1 file changed, 24 insertions(+), 24 deletions(-) diff --git a/Medium/Search in Rotated Sorted Array II.java b/Medium/Search in Rotated Sorted Array II.java index 65081528..bcb34f99 100644 --- a/Medium/Search in Rotated Sorted Array II.java +++ b/Medium/Search in Rotated Sorted Array II.java @@ -1,28 +1,28 @@ class Solution { - public boolean search(int[] nums, int target) { - int start = 0; - int end = nums.length - 1; - while (start <= end) { - int mid = (start + end) / 2; - if (nums[mid] == target) { - return true; - } - if (nums[mid] < nums[end] || nums[mid] < nums[start]) { - if (target > nums[mid] && target <= nums[end]) { - start = mid + 1; - } else { - end = mid - 1; + public boolean search(int[] nums, int target) { + int start = 0; + int end = nums.length - 1; + while (start <= end) { + int mid = (start + end) / 2; + if (nums[mid] == target) { + return true; + } + if (nums[mid] < nums[end] || nums[mid] < nums[start]) { + if (target > nums[mid] && target <= nums[end]) { + start = mid + 1; + } else { + end = mid - 1; + } + } else if (nums[mid] > nums[start] || nums[mid] > nums[end]) { + if (target < nums[mid] && target >= nums[start]) { + end = mid - 1; + } else { + start = mid + 1; + } + } else { + end--; + } } - } else if (nums[mid] > nums[start] || nums[mid] > nums[end]) { - if (target < nums[mid] && target >= nums[start]) { - end = mid - 1; - } else { - start = mid + 1; - } - } else { - end--; - } + return false; } - return false; - } } From de9e6a09d0537b777eddbc4de9870c538d2a9d68 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 13 Aug 2023 06:41:55 -0700 Subject: [PATCH 301/712] Create Max Pair Sum in an Array.java --- Easy/Max Pair Sum in an Array.java | 54 ++++++++++++++++++++++++++++++ 1 file changed, 54 insertions(+) create mode 100644 Easy/Max Pair Sum in an Array.java diff --git a/Easy/Max Pair Sum in an Array.java b/Easy/Max Pair Sum in an Array.java new file mode 100644 index 00000000..e7f6332e --- /dev/null +++ b/Easy/Max Pair Sum in an Array.java @@ -0,0 +1,54 @@ +class Solution { + public int maxSum(int[] nums) { + Map map = new HashMap<>(); + for (int num : nums) { + int maxDigit = getMaxDigit(num); + if (!map.containsKey(maxDigit)) { + map.put(maxDigit, new Pair()); + } + map.get(maxDigit).record(num); + } + int result = -1; + for (Integer key : map.keySet()) { + result = Math.max(result, map.get(key).getPairSum()); + } + return result; + } + + private int getMaxDigit(int num) { + int maxDigit = 0; + while (num > 0) { + maxDigit = Math.max(maxDigit, num % 10); + num /= 10; + } + return maxDigit; + } + + private static class Pair { + int maximum; + int secondMaximum; + + public Pair() { + maximum = -1; + secondMaximum = -1; + } + + public void record(int num) { + if (maximum < num) { + if (secondMaximum < maximum) { + secondMaximum = maximum; + } + maximum = num; + } else if (secondMaximum < num) { + secondMaximum = num; + } + } + + public int getPairSum() { + if (maximum == -1 || secondMaximum == -1) { + return -1; + } + return maximum + secondMaximum; + } + } +} From 3b753db3d0ca7a0be5b210cfa4dbea592d83ebde Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Tue, 15 Aug 2023 13:53:41 -0700 Subject: [PATCH 302/712] Update Partition List.java --- Medium/Partition List.java | 59 ++++++++++++++++++-------------------- 1 file changed, 28 insertions(+), 31 deletions(-) diff --git a/Medium/Partition List.java b/Medium/Partition List.java index bb1f9dcf..a807608c 100644 --- a/Medium/Partition List.java +++ b/Medium/Partition List.java @@ -9,38 +9,35 @@ * } */ class Solution { - public ListNode partition(ListNode head, int x) { - ListNode lessThanHead = null; - ListNode lessThan = null; - ListNode greaterThan = null; - ListNode greaterThanHead = null; - while (head != null) { - ListNode nextNode = head.next; - if (head.val < x) { - if (lessThan == null) { - lessThan = head; - lessThanHead = lessThan; - } else { - lessThan.next = head; - lessThan = lessThan.next; + public ListNode partition(ListNode head, int x) { + ListNode lessHead = null; + ListNode lessCurr = null; + ListNode greaterHead = null; + ListNode greaterCurr = null; + while (head != null) { + if (head.val < x) { + if (lessCurr == null) { + lessCurr = new ListNode(head.val); + lessHead = lessCurr; + } else { + lessCurr.next = new ListNode(head.val); + lessCurr = lessCurr.next; + } + } else { + if (greaterCurr == null) { + greaterCurr = new ListNode(head.val); + greaterHead = greaterCurr; + } else { + greaterCurr.next = new ListNode(head.val); + greaterCurr = greaterCurr.next; + } + } + head = head.next; } - lessThan.next = null; - } else { - if (greaterThan == null) { - greaterThan = head; - greaterThanHead = greaterThan; - } else { - greaterThan.next = head; - greaterThan = greaterThan.next; + if (lessHead == null) { + return greaterHead; } - greaterThan.next = null; - } - head = nextNode; + lessCurr.next = greaterHead; + return lessHead; } - if (lessThanHead == null || greaterThanHead == null) { - return lessThan == null ? greaterThanHead : lessThanHead; - } - lessThan.next = greaterThanHead; - return lessThanHead; - } } From 265791bdf2285190ac5b840c708804856701c679 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Wed, 16 Aug 2023 11:51:52 -0700 Subject: [PATCH 303/712] Update Sliding Window Maximum.java --- Hard/Sliding Window Maximum.java | 25 +++++++++---------------- 1 file changed, 9 insertions(+), 16 deletions(-) diff --git a/Hard/Sliding Window Maximum.java b/Hard/Sliding Window Maximum.java index 2aafc22d..635720b8 100644 --- a/Hard/Sliding Window Maximum.java +++ b/Hard/Sliding Window Maximum.java @@ -1,25 +1,18 @@ class Solution { public int[] maxSlidingWindow(int[] nums, int k) { + Deque dequeue = new ArrayDeque<>(); int[] result = new int[nums.length - k + 1]; - int start = 0; - int end = 0; - Deque queue = new ArrayDeque<>(); - while (end < nums.length) { - // Remove elements from end of queue as long as the value at end of queue is less - // than the current value - while (!queue.isEmpty() && nums[queue.peekLast()] < nums[end]) { - queue.removeLast(); + for (int i = 0; i < nums.length; i++) { + if (!dequeue.isEmpty() && dequeue.getFirst() == i - k) { + dequeue.removeFirst(); } - queue.add(end); - // Remove the first element from the queue if we have already passed it in our range - if (start > queue.peekFirst()) { - queue.removeFirst(); + while (!dequeue.isEmpty() && nums[i] > nums[dequeue.getLast()]) { + dequeue.removeLast(); } - // Update result if our window is at least of size k - if (end + 1 >= k) { - result[start++] = nums[queue.peekFirst()]; + dequeue.addLast(i); + if (i >= k - 1) { + result[i - k + 1] = nums[dequeue.getFirst()]; } - end++; } return result; } From 0568a1ad8acc18f44337c12e043a4bbe103829d8 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Fri, 18 Aug 2023 09:44:20 -0700 Subject: [PATCH 304/712] Update Maximal Network Rank.java --- Medium/Maximal Network Rank.java | 34 +++++++++++++++++--------------- 1 file changed, 18 insertions(+), 16 deletions(-) diff --git a/Medium/Maximal Network Rank.java b/Medium/Maximal Network Rank.java index 211a7c8e..e5c3f20c 100644 --- a/Medium/Maximal Network Rank.java +++ b/Medium/Maximal Network Rank.java @@ -1,19 +1,21 @@ class Solution { - public int maximalNetworkRank(int n, int[][] roads) { - boolean[][] connected = new boolean[n][n]; - int[] count = new int[n]; - for (int[] road : roads) { - count[road[0]]++; - count[road[1]]++; - connected[road[0]][road[1]] = true; - connected[road[1]][road[0]] = true; + public int maximalNetworkRank(int n, int[][] roads) { + Map> map = new HashMap<>(); + for (int[] road : roads) { + map.computeIfAbsent(road[0], k -> new HashSet<>()).add(road[1]); + map.computeIfAbsent(road[1], k -> new HashSet<>()).add(road[0]); + } + int maximumRank = 0; + for (int i = 0; i < n; i++) { + int iRank = map.getOrDefault(i, new HashSet<>()).size(); + for (int j = i + 1; j < n; j++) { + int combinedRank = iRank + map.getOrDefault(j, new HashSet<>()).size(); + if (map.getOrDefault(j, new HashSet<>()).contains(i)) { + combinedRank--; + } + maximumRank = Math.max(maximumRank, combinedRank); + } + } + return maximumRank; } - int maxCount = 0; - for (int i = 0; i < n; i++) { - for (int j = i + 1; j < n; j++) { - maxCount = Math.max(maxCount, count[i] + count[j] - (connected[i][j] ? 1 : 0)); - } - } - return maxCount; - } } From 04946d7f6cca3822ae65c6e5d9c1b62a3b9543d3 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 20 Aug 2023 12:27:23 -0700 Subject: [PATCH 305/712] Create Sort Items by Groups Respecting Dependencies.java --- ...ems by Groups Respecting Dependencies.java | 62 +++++++++++++++++++ 1 file changed, 62 insertions(+) create mode 100644 Hard/Sort Items by Groups Respecting Dependencies.java diff --git a/Hard/Sort Items by Groups Respecting Dependencies.java b/Hard/Sort Items by Groups Respecting Dependencies.java new file mode 100644 index 00000000..38c531a3 --- /dev/null +++ b/Hard/Sort Items by Groups Respecting Dependencies.java @@ -0,0 +1,62 @@ +class Solution { + public int[] sortItems(int n, int m, int[] group, List> beforeItems) { + int groupId = m; + for (int i = 0; i < group.length; i++) { + if (group[i] == -1) { + group[i] = groupId++; + } + } + Map> nodeToDependentNodes = new HashMap<>(); + Map> groupToDependentGroups = new HashMap<>(); + int[] itemIndegree = new int[n]; + int[] groupIndegree = new int[groupId]; + for (int i = 0; i < beforeItems.size(); i++) { + for (Integer prev : beforeItems.get(i)) { + nodeToDependentNodes.computeIfAbsent(prev, k -> new ArrayList<>()).add(i); + itemIndegree[i]++; + if (group[i] != group[prev]) { + groupToDependentGroups.computeIfAbsent(group[prev], k -> new ArrayList<>()).add(group[i]); + groupIndegree[group[i]]++; + } + } + } + List itemOrdering = topologicalSort(nodeToDependentNodes, itemIndegree); + List groupOrdering = topologicalSort(groupToDependentGroups, groupIndegree); + if (itemOrdering.isEmpty() || groupOrdering.isEmpty()) { + return new int[]{}; + } + Map> orderedGroups = new HashMap<>(); + for (Integer item : itemOrdering) { + orderedGroups.computeIfAbsent(group[item], k -> new ArrayList<>()).add(item); + } + int[] result = new int[n]; + int idx = 0; + for (Integer groupNo : groupOrdering) { + for (Integer item : orderedGroups.getOrDefault(groupNo, new ArrayList<>())) { + result[idx++] = item; + } + } + return result; + } + + private static List topologicalSort(Map> graph, int[] indegree) { + List visited = new ArrayList<>(); + Queue queue = new LinkedList<>(); + for (int i = 0; i < indegree.length; i++) { + if (indegree[i] == 0) { + queue.add(i); + } + } + while (!queue.isEmpty()) { + int removed = queue.remove(); + visited.add(removed); + for (Integer conn : graph.getOrDefault(removed, new ArrayList<>())) { + indegree[conn]--; + if (indegree[conn] == 0) { + queue.add(conn); + } + } + } + return visited.size() == indegree.length ? visited : new ArrayList<>(); + } +} From cc431382291b2cf01b8dce7088698cd7759dce6e Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 20 Aug 2023 17:34:10 -0700 Subject: [PATCH 306/712] Update Repeated Substring Pattern.java --- Easy/Repeated Substring Pattern.java | 27 ++++++++++++--------------- 1 file changed, 12 insertions(+), 15 deletions(-) diff --git a/Easy/Repeated Substring Pattern.java b/Easy/Repeated Substring Pattern.java index 79ea250c..fc817f7e 100644 --- a/Easy/Repeated Substring Pattern.java +++ b/Easy/Repeated Substring Pattern.java @@ -1,19 +1,16 @@ class Solution { - public boolean repeatedSubstringPattern(String s) { - int n = s.length(); - for (int i = n / 2; i >= 1; i--) { - if (n % i == 0) { - int count = n / i; - StringBuilder sb = new StringBuilder(); - String sub = s.substring(0, i); - while (count-- > 0) { - sb.append(sub); + public boolean repeatedSubstringPattern(String s) { + int n = s.length(); + for (int i = n / 2; i > 0; i--) { + if (n % i == 0) { + int count = n / i; + String substring = s.substring(0, i); + String repeatedString = substring.repeat(count); + if (repeatedString.equals(s)) { + return true; + } + } } - if (sb.toString().equals(s)) { - return true; - } - } + return false; } - return false; - } } From 36aec1a994a56f82e26f90c46f75696fb3ef8646 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 20 Aug 2023 17:36:41 -0700 Subject: [PATCH 307/712] Create Check if a String Is an Acronym of Words.java --- Easy/Check if a String Is an Acronym of Words.java | 9 +++++++++ 1 file changed, 9 insertions(+) create mode 100644 Easy/Check if a String Is an Acronym of Words.java diff --git a/Easy/Check if a String Is an Acronym of Words.java b/Easy/Check if a String Is an Acronym of Words.java new file mode 100644 index 00000000..5608783c --- /dev/null +++ b/Easy/Check if a String Is an Acronym of Words.java @@ -0,0 +1,9 @@ +class Solution { + public boolean isAcronym(List words, String s) { + StringBuilder sb = new StringBuilder(); + for (String word : words) { + sb.append(word.charAt(0)); + } + return sb.toString().equals(s); + } +} From 13c88ecbdab6dcac0d33dd7698f12528c6498745 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Mon, 21 Aug 2023 07:31:03 -0700 Subject: [PATCH 308/712] Create Count Pairs Whose Sum is Less than Target.java --- ...nt Pairs Whose Sum is Less than Target.java | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) create mode 100644 Easy/Count Pairs Whose Sum is Less than Target.java diff --git a/Easy/Count Pairs Whose Sum is Less than Target.java b/Easy/Count Pairs Whose Sum is Less than Target.java new file mode 100644 index 00000000..90c31c23 --- /dev/null +++ b/Easy/Count Pairs Whose Sum is Less than Target.java @@ -0,0 +1,18 @@ +class Solution { + public int countPairs(List nums, int target) { + Collections.sort(nums); + int start = 0; + int end = nums.size() - 1; + int count = 0; + while (start < end) { + int sum = nums.get(start) + nums.get(end); + if (sum < target) { + count += end - start; + start++; + } else { + end--; + } + } + return count; + } +} From 94d6c7631e9ad5154c03b87cec621a02574c7642 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Tue, 22 Aug 2023 16:52:21 -0700 Subject: [PATCH 309/712] Create Determine the Minimum Sum of a k-avoiding Array.java --- ... the Minimum Sum of a k-avoiding Array.java | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) create mode 100644 Medium/Determine the Minimum Sum of a k-avoiding Array.java diff --git a/Medium/Determine the Minimum Sum of a k-avoiding Array.java b/Medium/Determine the Minimum Sum of a k-avoiding Array.java new file mode 100644 index 00000000..3eab331f --- /dev/null +++ b/Medium/Determine the Minimum Sum of a k-avoiding Array.java @@ -0,0 +1,18 @@ +class Solution { + public int minimumSum(int n, int k) { + Set set = new HashSet<>(); + set.add(1); + int sum = 1; + int next = 2; + while (n > 1) { + if (set.contains(k - next)) { + next++; + continue; + } + set.add(next); + sum += next++; + n--; + } + return sum; + } +} From 3ab5cb5cc7d9c0d0826268f91ef150d50333c5b6 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Tue, 22 Aug 2023 17:00:54 -0700 Subject: [PATCH 310/712] Create Make String a Subsequence Using Cyclic Increments.java --- ... a Subsequence Using Cyclic Increments.java | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) create mode 100644 Medium/Make String a Subsequence Using Cyclic Increments.java diff --git a/Medium/Make String a Subsequence Using Cyclic Increments.java b/Medium/Make String a Subsequence Using Cyclic Increments.java new file mode 100644 index 00000000..1247a755 --- /dev/null +++ b/Medium/Make String a Subsequence Using Cyclic Increments.java @@ -0,0 +1,18 @@ +class Solution { + public boolean canMakeSubsequence(String str1, String str2) { + int idxOne = 0; + int idxTwo = 0; + while (idxOne < str1.length() && idxTwo < str2.length()) { + if (str1.charAt(idxOne) == str2.charAt(idxTwo) || + nextCyclicChar(str1.charAt(idxOne)) == str2.charAt(idxTwo)) { + idxTwo++; + } + idxOne++; + } + return idxTwo == str2.length(); + } + + private static char nextCyclicChar(char c) { + return c == 'z' ? 'a' : (char) (c + 1); + } +} From 8c4f2cfb09055746c83be881ed85de019ee11c03 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sat, 26 Aug 2023 13:12:46 -0700 Subject: [PATCH 311/712] Update Maximum Length of Pair Chain.java --- Medium/Maximum Length of Pair Chain.java | 24 ++++++++---------------- 1 file changed, 8 insertions(+), 16 deletions(-) diff --git a/Medium/Maximum Length of Pair Chain.java b/Medium/Maximum Length of Pair Chain.java index 1ad30427..cb98b670 100644 --- a/Medium/Maximum Length of Pair Chain.java +++ b/Medium/Maximum Length of Pair Chain.java @@ -1,22 +1,14 @@ class Solution { public int findLongestChain(int[][] pairs) { - Arrays.sort(pairs, new Comparator() { - @Override - public int compare(int[] o1, int[] o2) { - return o1[0] - o2[0]; - } - }); - - int[] temp = new int[pairs.length]; - Arrays.fill(temp, 1); - for (int i=1; i a[1])); + int curr = Integer.MIN_VALUE; + int result = 0; + for (int[] pair : pairs) { + if (pair[0] > curr) { + result++; + curr = pair[1]; } } - - return Arrays.stream(temp).max().getAsInt(); + return result; } } From d68bc4f512443e0d54e7e32f5d95c48871b3fc57 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 27 Aug 2023 07:17:35 -0700 Subject: [PATCH 312/712] Create Furthest Point From Origin.java --- Easy/Furthest Point From Origin.java | 14 ++++++++++++++ 1 file changed, 14 insertions(+) create mode 100644 Easy/Furthest Point From Origin.java diff --git a/Easy/Furthest Point From Origin.java b/Easy/Furthest Point From Origin.java new file mode 100644 index 00000000..d7abca92 --- /dev/null +++ b/Easy/Furthest Point From Origin.java @@ -0,0 +1,14 @@ +class Solution { + public int furthestDistanceFromOrigin(String moves) { + int emptyCount = 0; + int direction = 0; + for (char c : moves.toCharArray()) { + if (c == '_') { + emptyCount++; + } else { + direction += c == 'L' ? -1 : 1; + } + } + return Math.abs(direction) + emptyCount; + } +} From 92023ae957e8647e1b4fdae4ff444b17ec54878c Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 27 Aug 2023 17:44:26 -0700 Subject: [PATCH 313/712] Update Implement Stack using Queues.java --- Easy/Implement Stack using Queues.java | 87 +++++++++++++------------- 1 file changed, 43 insertions(+), 44 deletions(-) diff --git a/Easy/Implement Stack using Queues.java b/Easy/Implement Stack using Queues.java index 43c62339..d93ce3ae 100644 --- a/Easy/Implement Stack using Queues.java +++ b/Easy/Implement Stack using Queues.java @@ -1,52 +1,51 @@ class MyStack { - - private Queue primaryQueue; - private Queue secondaryQueue; - - public MyStack() { - this.primaryQueue = new LinkedList<>(); - this.secondaryQueue = new LinkedList<>(); - } + + private final Queue mainQueue; + private final Queue backupQueue; - public void push(int x) { - this.primaryQueue.add(x); - } - - public int pop() { - int result = moveFromPrimaryToSecondary(); - moveFromSecondaryToPrimary(true); - return result; - } - - public int top() { - int result = moveFromPrimaryToSecondary(); - moveFromSecondaryToPrimary(false); - return result; - } - - public boolean empty() { - return this.primaryQueue.isEmpty(); - } - - private int moveFromPrimaryToSecondary() { - int last = this.primaryQueue.peek(); - while (!this.primaryQueue.isEmpty()) { - last = this.primaryQueue.peek(); - this.secondaryQueue.add(this.primaryQueue.remove()); + public MyStack() { + this.mainQueue = new LinkedList<>(); + this.backupQueue = new LinkedList<>(); + } + + public void push(int x) { + this.mainQueue.add(x); + } + + public int pop() { + int lastElement = moveToBackupQueue(); + moveToMainQueue(true); + return lastElement; + } + + public int top() { + int lastElement = moveToBackupQueue(); + moveToMainQueue(false); + return lastElement; + } + + public boolean empty() { + return this.mainQueue.isEmpty(); } - return last; - } - - private void moveFromSecondaryToPrimary(boolean removeLast) { - while (this.secondaryQueue.size() > 1) { - this.primaryQueue.add(this.secondaryQueue.remove()); + + private int moveToBackupQueue() { + int lastElement = this.mainQueue.peek(); + while (!this.mainQueue.isEmpty()) { + lastElement = this.mainQueue.peek(); + this.backupQueue.add(this.mainQueue.poll()); + } + return lastElement; } - if (removeLast) { - this.secondaryQueue.remove(); - } else { - this.primaryQueue.add(this.secondaryQueue.remove()); + + private void moveToMainQueue(boolean removeLast) { + int sizeLimit = removeLast ? 1 : 0; + while (this.backupQueue.size() > sizeLimit) { + this.mainQueue.add(this.backupQueue.poll()); + } + if (removeLast) { + this.backupQueue.remove(); + } } - } } /** From 455fcb85c8c55a2a90bc8bd9a2224cd5458f82a2 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 27 Aug 2023 17:44:46 -0700 Subject: [PATCH 314/712] Update Implement Stack using Queues.java From e361d66356431914ebfd507b9924188e1a7f2ffd Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Tue, 29 Aug 2023 08:58:42 -0700 Subject: [PATCH 315/712] Create Minimum Penalty for a Shop.java --- Medium/Minimum Penalty for a Shop.java | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) create mode 100644 Medium/Minimum Penalty for a Shop.java diff --git a/Medium/Minimum Penalty for a Shop.java b/Medium/Minimum Penalty for a Shop.java new file mode 100644 index 00000000..e5c5eaa9 --- /dev/null +++ b/Medium/Minimum Penalty for a Shop.java @@ -0,0 +1,16 @@ +class Solution { + public int bestClosingTime(String customers) { + int n = customers.length(); + int minPenalty = 0; + int currPenalty = 0; + int minPenaltyHour = 0; + for (int i = 0; i < n; i++) { + currPenalty += customers.charAt(i) == 'Y' ? -1 : 1; + if (currPenalty < minPenalty) { + minPenaltyHour = i + 1; + minPenalty = currPenalty; + } + } + return minPenaltyHour; + } +} From d9c6a40491a4fff7ce976d4252c0a15b30656e49 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Wed, 30 Aug 2023 08:02:04 -0700 Subject: [PATCH 316/712] Create Minimum Replacements to Sort the Array.java --- Hard/Minimum Replacements to Sort the Array.java | 14 ++++++++++++++ 1 file changed, 14 insertions(+) create mode 100644 Hard/Minimum Replacements to Sort the Array.java diff --git a/Hard/Minimum Replacements to Sort the Array.java b/Hard/Minimum Replacements to Sort the Array.java new file mode 100644 index 00000000..1c3cfc4f --- /dev/null +++ b/Hard/Minimum Replacements to Sort the Array.java @@ -0,0 +1,14 @@ +class Solution { + public long minimumReplacement(int[] nums) { + int n = nums.length; + long numOfOperations = 0; + for (int i = n - 2; i >= 0; i--) { + if (nums[i] > nums[i + 1]) { + long numElements = (long)(nums[i] + nums[i + 1] - 1) / (long)nums[i + 1]; + numOfOperations += numElements - 1; + nums[i] = nums[i] / (int)numElements; + } + } + return numOfOperations; + } +} From 66a79a031f220ba6f295a9db2bb69321aa76a9f9 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Fri, 1 Sep 2023 09:53:25 -0700 Subject: [PATCH 317/712] Update Counting Bits.java --- Easy/Counting Bits.java | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/Easy/Counting Bits.java b/Easy/Counting Bits.java index 4d948810..4b5c69fa 100644 --- a/Easy/Counting Bits.java +++ b/Easy/Counting Bits.java @@ -1,9 +1,9 @@ class Solution { - public int[] countBits(int n) { - int[] numofOnes = new int[n + 1]; - for (int i = 1; i <= n; i++) { - numofOnes[i] = numofOnes[i / 2] + i % 2; + public int[] countBits(int n) { + int[] result = new int[n + 1]; + for (int i = 1; i <= n; i++) { + result[i] = result[i / 2] + i % 2; + } + return result; } - return numofOnes; - } } From 475f7f8e8f7c252b2ee98098364ea672f1339071 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 3 Sep 2023 14:58:05 -0700 Subject: [PATCH 318/712] Create Check if Strings Can be Made Equal With Operations I.java --- ...k if Strings Can be Made Equal With Operations I.java | 9 +++++++++ 1 file changed, 9 insertions(+) create mode 100644 Easy/Check if Strings Can be Made Equal With Operations I.java diff --git a/Easy/Check if Strings Can be Made Equal With Operations I.java b/Easy/Check if Strings Can be Made Equal With Operations I.java new file mode 100644 index 00000000..cc99065a --- /dev/null +++ b/Easy/Check if Strings Can be Made Equal With Operations I.java @@ -0,0 +1,9 @@ +class Solution { + public boolean canBeEqual(String s1, String s2) { + boolean firstSwap = (s1.charAt(0) == s2.charAt(0) && s1.charAt(2) == s2.charAt(2)) || + (s1.charAt(2) == s2.charAt(0) && s1.charAt(0) == s2.charAt(2)); + boolean secondSwap = (s1.charAt(1) == s2.charAt(1) && s1.charAt(3) == s2.charAt(3)) || + (s1.charAt(1) == s2.charAt(3) && s1.charAt(3) == s2.charAt(1)); + return firstSwap && secondSwap; + } +} From b850056ed748167424052d4655f24d9c9cb3687f Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 3 Sep 2023 15:21:15 -0700 Subject: [PATCH 319/712] Create Check if Strings Can be Made Equal With Operations II.java --- ... Can be Made Equal With Operations II.java | 21 +++++++++++++++++++ 1 file changed, 21 insertions(+) create mode 100644 Medium/Check if Strings Can be Made Equal With Operations II.java diff --git a/Medium/Check if Strings Can be Made Equal With Operations II.java b/Medium/Check if Strings Can be Made Equal With Operations II.java new file mode 100644 index 00000000..7507b140 --- /dev/null +++ b/Medium/Check if Strings Can be Made Equal With Operations II.java @@ -0,0 +1,21 @@ +class Solution { + public boolean checkStrings(String s1, String s2) { + int[] odd = new int[26]; + int[] even = new int[26]; + for (int i = 0; i < s1.length(); i++) { + if (i % 2 == 0) { + even[s1.charAt(i) - 'a']++; + even[s2.charAt(i) - 'a']--; + } else { + odd[s1.charAt(i) - 'a']++; + odd[s2.charAt(i) - 'a']--; + } + } + for (int i = 0; i < 26; i++) { + if (odd[i] != 0 || even[i] != 0) { + return false; + } + } + return true; + } +} From 4b0fa539231b11fde6b3aba232bb0d712252c20a Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Tue, 5 Sep 2023 12:48:01 -0700 Subject: [PATCH 320/712] Create Count Symmetric Integers.java --- Easy/Count Symmetric Integers.java | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) create mode 100644 Easy/Count Symmetric Integers.java diff --git a/Easy/Count Symmetric Integers.java b/Easy/Count Symmetric Integers.java new file mode 100644 index 00000000..f32301e1 --- /dev/null +++ b/Easy/Count Symmetric Integers.java @@ -0,0 +1,17 @@ +class Solution { + public int countSymmetricIntegers(int low, int high) { + int result = 0; + for (int i = low; i <= high; i++) { + String s = String.valueOf(i); + int diff = 0; + int n = s.length(); + for (int j = 0; j < n / 2; j++) { + diff += s.charAt(j) - s.charAt(n - j - 1); + } + if (n % 2 == 0 && diff == 0) { + result++; + } + } + return result; + } +} From 5642e0cadbeeb10bcbaa534f2d74c7645915bb20 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Wed, 6 Sep 2023 07:35:18 -0700 Subject: [PATCH 321/712] Update Split Linked List in Parts.java --- Medium/Split Linked List in Parts.java | 40 ++++++++++++++------------ 1 file changed, 21 insertions(+), 19 deletions(-) diff --git a/Medium/Split Linked List in Parts.java b/Medium/Split Linked List in Parts.java index 30121c82..2fdd787c 100644 --- a/Medium/Split Linked List in Parts.java +++ b/Medium/Split Linked List in Parts.java @@ -7,25 +7,27 @@ * ListNode(int val) { this.val = val; } * ListNode(int val, ListNode next) { this.val = val; this.next = next; } * } -*/ + */ class Solution { - public ListNode[] splitListToParts(ListNode head, int k) { - ListNode[] arr = new ListNode[k]; - int nodeLength = 0; - for (ListNode curr = head; curr != null; curr = curr.next) { - nodeLength++; + public ListNode[] splitListToParts(ListNode head, int k) { + int length = 0; + ListNode curr = head; + while (curr != null) { + length++; + curr = curr.next; + } + ListNode[] splits = new ListNode[k]; + int elementsPerPart = length / k; + int partsWithExtra = length % k; + ListNode prev = null; + for (int i = 0; i < k && head != null; i++, partsWithExtra--) { + splits[i] = head; + for (int j = 0; j < elementsPerPart + (partsWithExtra > 0 ? 1 : 0); j++) { + prev = head; + head = head.next; + } + prev.next = null; + } + return splits; } - int n = nodeLength / k; - int remaining = nodeLength % k; - ListNode prev = null; - for (int i = 0; i < k && head != null; i++, remaining--) { - arr[i] = head; - for (int j = 0; j < n + (remaining > 0 ? 1 : 0); j++) { - prev = head; - head = head.next; - } - prev.next = null; - } - return arr; - } } From c9d4f1a65cbf4bdc3919d1040aa160247e806514 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Wed, 6 Sep 2023 14:54:20 -0700 Subject: [PATCH 322/712] Create Minimum Operations to Make a Special Number.java --- ...m Operations to Make a Special Number.java | 25 +++++++++++++++++++ 1 file changed, 25 insertions(+) create mode 100644 Medium/Minimum Operations to Make a Special Number.java diff --git a/Medium/Minimum Operations to Make a Special Number.java b/Medium/Minimum Operations to Make a Special Number.java new file mode 100644 index 00000000..20f250fc --- /dev/null +++ b/Medium/Minimum Operations to Make a Special Number.java @@ -0,0 +1,25 @@ +class Solution { + + private final int NOT_FOUND_VALUE = 100_000; + + public int minimumOperations(String num) { + Integer[][] dp = new Integer[100][25]; + return helper(num, 0, 0, dp); + } + + private int helper(String num, int idx, int mod, Integer[][] dp) { + if (idx == num.length()) { + if (mod == 0) { + return 0; + } + return NOT_FOUND_VALUE; + } + if (dp[idx][mod] != null) { + return dp[idx][mod]; + } + int take = helper(num, idx + 1, (mod * 10 + (num.charAt(idx) - '0')) % 25, dp); + int remove = 1 + helper(num, idx + 1, mod, dp); + dp[idx][mod] = Math.min(take, remove); + return dp[idx][mod]; + } +} From b234fe82a97a0e0eb0ac48c08e11ff4593befaf2 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Wed, 6 Sep 2023 17:16:17 -0700 Subject: [PATCH 323/712] Update Reverse Linked List II.java --- Medium/Reverse Linked List II.java | 72 +++++++++++++++--------------- 1 file changed, 37 insertions(+), 35 deletions(-) diff --git a/Medium/Reverse Linked List II.java b/Medium/Reverse Linked List II.java index 53edc4e4..3835dbcd 100644 --- a/Medium/Reverse Linked List II.java +++ b/Medium/Reverse Linked List II.java @@ -9,41 +9,43 @@ * } */ class Solution { - public ListNode reverseBetween(ListNode head, int left, int right) { - ListNode prev = null; - ListNode start = head; - for (int i = 1; i < left; i++) { - prev = start; - start = start.next; + public ListNode reverseBetween(ListNode head, int left, int right) { + ListNode curr = head; + ListNode prevToLeft = null; + for (int i = 1; i < left; i++) { + prevToLeft = curr; + curr = curr.next; + } + ListNode nextToLeft = prevToLeft == null ? head : prevToLeft.next; + for (int i = left; i < right; i++) { + curr = curr.next; + } + ListNode nextToRight = curr.next; + curr.next = null; + if (prevToLeft != null) { + prevToLeft.next = null; + } + ListNode reversedStart = reverse(nextToLeft); + if (prevToLeft != null) { + prevToLeft.next = reversedStart; + } + curr = reversedStart; + while (curr.next != null) { + curr = curr.next; + } + curr.next = nextToRight; + return prevToLeft == null ? reversedStart : head; } - ListNode end = start; - for (int i = left; i < right; i++) { - end = end.next; + + private ListNode reverse(ListNode head) { + ListNode prev = null; + ListNode curr = head; + while (curr != null) { + ListNode next = curr.next; + curr.next = prev; + prev = curr; + curr = next; + } + return prev; } - ListNode nextToEnd = end.next; - end.next = null; - ListNode reverseStart = reverse(start); - if (prev != null) { - prev.next = reverseStart; - } - ListNode curr = reverseStart; - while (curr.next != null) { - curr = curr.next; - } - curr.next = nextToEnd; - return prev == null ? reverseStart : head; - } - - private ListNode reverse(ListNode node) { - ListNode prev = null; - ListNode next = null; - ListNode curr = node; - while (curr != null) { - next = curr.next; - curr.next = prev; - prev = curr; - curr = next; - } - return prev; - } } From dadb59b7d7253a89f042fc39a3d9529fad48ccc5 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Thu, 7 Sep 2023 07:15:39 -0700 Subject: [PATCH 324/712] Create Maximum Sum of Almost Unique Subarray.java --- ...Maximum Sum of Almost Unique Subarray.java | 28 +++++++++++++++++++ 1 file changed, 28 insertions(+) create mode 100644 Medium/Maximum Sum of Almost Unique Subarray.java diff --git a/Medium/Maximum Sum of Almost Unique Subarray.java b/Medium/Maximum Sum of Almost Unique Subarray.java new file mode 100644 index 00000000..1d9facff --- /dev/null +++ b/Medium/Maximum Sum of Almost Unique Subarray.java @@ -0,0 +1,28 @@ +class Solution { + public long maxSum(List nums, int m, int k) { + long result = 0; + long currSum = 0; + Map frequencyMap = new HashMap<>(); + int uniqueCount = 0; + for (int i = 0; i < nums.size(); i++) { + int curr = nums.get(i); + frequencyMap.put(curr, frequencyMap.getOrDefault(curr, 0) + 1); + if (frequencyMap.get(curr) == 1) { + uniqueCount++; + } + currSum += curr; + if (i >= k - 1) { + if (uniqueCount >= m) { + result = Math.max(result, currSum); + } + int temp = nums.get(i - k + 1); + frequencyMap.put(temp, frequencyMap.getOrDefault(temp, 0) - 1); + if (frequencyMap.get(temp) == 0) { + uniqueCount--; + } + currSum -= temp; + } + } + return result; + } +} From 1f561e474e24e63411218f05e4fdfc11e049434a Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Fri, 8 Sep 2023 10:59:22 -0700 Subject: [PATCH 325/712] Create Rearrange String k Distance Apart.java --- Hard/Rearrange String k Distance Apart.java | 26 +++++++++++++++++++++ 1 file changed, 26 insertions(+) create mode 100644 Hard/Rearrange String k Distance Apart.java diff --git a/Hard/Rearrange String k Distance Apart.java b/Hard/Rearrange String k Distance Apart.java new file mode 100644 index 00000000..da212877 --- /dev/null +++ b/Hard/Rearrange String k Distance Apart.java @@ -0,0 +1,26 @@ +class Solution { + public String rearrangeString(String s, int k) { + Map map = new HashMap<>(); + for (char c : s.toCharArray()) { + map.put(c, map.getOrDefault(c, 0) + 1); + } + PriorityQueue pq = new PriorityQueue<>((a, b) -> map.get(b).compareTo(map.get(a))); + Queue busy = new LinkedList<>(); + StringBuilder sb = new StringBuilder(); + pq.addAll(map.keySet()); + while (!pq.isEmpty()) { + Character removed = pq.poll(); + sb.append(removed); + map.put(removed, map.get(removed) - 1); + busy.add(removed); + if (busy.size() < k) { + continue; + } + Character busyRemoved = busy.remove(); + if (map.get(busyRemoved) > 0) { + pq.add(busyRemoved); + } + } + return sb.length() == s.length() ? sb.toString() : ""; + } +} From 42c41ac800637e833bbbf733b4b880fb1b5d806f Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sat, 9 Sep 2023 07:44:36 -0700 Subject: [PATCH 326/712] Update Combination Sum IV.java --- Medium/Combination Sum IV.java | 39 ++++++++++++++++------------------ 1 file changed, 18 insertions(+), 21 deletions(-) diff --git a/Medium/Combination Sum IV.java b/Medium/Combination Sum IV.java index bc8c1924..3a0eb51e 100644 --- a/Medium/Combination Sum IV.java +++ b/Medium/Combination Sum IV.java @@ -1,25 +1,22 @@ class Solution { - public int combinationSum4(int[] nums, int target) { - Integer[] dp = new Integer[target + 1]; - return getCount(target, nums, dp); - } - - public int getCount(int target, int[] nums, Integer[] dp) { - if (dp[target] != null) { - return dp[target]; + public int combinationSum4(int[] nums, int target) { + Integer[] dp = new Integer[target + 1]; + return helper(nums, target, dp); } - if (target == 0) { - return 1; + + private int helper(int[] nums, int target, Integer[] dp) { + if (dp[target] != null) { + return dp[target]; + } + if (target == 0) { + return 1; + } + int count = 0; + for (int num : nums) { + if (target >= num) { + count += helper(nums, target - num, dp); + } + } + return dp[target] = count; } - if (target < 0) { - return 0; - } - int total = 0; - for (int num : nums) { - if (target >= num) { - total += getCount(target - num, nums, dp); - } - } - return dp[target] = total; - } } From 64429283f6c25e5d98d69cb7fc0aa0427004dc5c Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Mon, 11 Sep 2023 06:56:14 -0700 Subject: [PATCH 327/712] Update Group the People Given the Group Size They Belong To.java --- ...e Given the Group Size They Belong To.java | 30 +++++++++---------- 1 file changed, 14 insertions(+), 16 deletions(-) diff --git a/Medium/Group the People Given the Group Size They Belong To.java b/Medium/Group the People Given the Group Size They Belong To.java index 475cf0c6..095fb67f 100644 --- a/Medium/Group the People Given the Group Size They Belong To.java +++ b/Medium/Group the People Given the Group Size They Belong To.java @@ -1,20 +1,18 @@ class Solution { - public List> groupThePeople(int[] groupSizes) { - Map> groupSizeToId = new HashMap<>(); - for (int i = 0; i < groupSizes.length; i++) { - groupSizeToId.computeIfAbsent(groupSizes[i], k -> new LinkedList<>()).add(i); - } - List> result = new ArrayList<>(); - for (Integer groupSize : groupSizeToId.keySet()) { - Queue ids = groupSizeToId.get(groupSize); - while (!ids.isEmpty()) { - List group = new ArrayList<>(groupSize); - for (int i = 0; i< groupSize; i++) { - group.add(ids.remove()); + public List> groupThePeople(int[] groupSizes) { + Map> map = new HashMap<>(); + for (int i = 0; i < groupSizes.length; i++) { + map.computeIfAbsent(groupSizes[i], k -> new ArrayList<>()).add(i); + } + List> result = new ArrayList<>(); + for (Integer key : map.keySet()) { + List candidates = map.get(key); + int idx = 0; + while (idx < candidates.size()) { + result.add(candidates.subList(idx, idx + key)); + idx += key; + } } - result.add(group); - } + return result; } - return result; - } } From cbdf34baf52b2dae10108834af7ac3c63f24e3dc Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Mon, 11 Sep 2023 09:37:35 -0700 Subject: [PATCH 328/712] Create Points That Intersect With Cars.java --- Easy/Points That Intersect With Cars.java | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) create mode 100644 Easy/Points That Intersect With Cars.java diff --git a/Easy/Points That Intersect With Cars.java b/Easy/Points That Intersect With Cars.java new file mode 100644 index 00000000..8443505c --- /dev/null +++ b/Easy/Points That Intersect With Cars.java @@ -0,0 +1,20 @@ +class Solution { + public int numberOfPoints(List> coordinates) { + coordinates.sort(Comparator.comparingInt((List o) -> o.get(0)).thenComparingInt(o -> o.get(1))); + int points = 0; + int intervalStart = -1; + int intervalEnd = -1; + for (List coordinate : coordinates) { + if (intervalStart == -1) { + intervalStart = coordinate.get(0); + } else { + if (intervalEnd < coordinate.get(0)) { + points += intervalEnd - intervalStart + 1; + intervalStart = coordinate.get(0); + } + } + intervalEnd = Math.max(intervalEnd, coordinate.get(1)); + } + return points + intervalEnd - intervalStart + 1; + } +} From 65f9addfce377ab18e93c9d8c0b7f87f03b4e3e0 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Mon, 11 Sep 2023 15:43:54 -0700 Subject: [PATCH 329/712] Create Determine if a Cell Is Reachable at a Given Time.java --- ...termine if a Cell Is Reachable at a Given Time.java | 10 ++++++++++ 1 file changed, 10 insertions(+) create mode 100644 Medium/Determine if a Cell Is Reachable at a Given Time.java diff --git a/Medium/Determine if a Cell Is Reachable at a Given Time.java b/Medium/Determine if a Cell Is Reachable at a Given Time.java new file mode 100644 index 00000000..37878fa8 --- /dev/null +++ b/Medium/Determine if a Cell Is Reachable at a Given Time.java @@ -0,0 +1,10 @@ +class Solution { + public boolean isReachableAtTime(int sx, int sy, int fx, int fy, int t) { + int xDiff = Math.abs(sx - fx); + int yDiff = Math.abs(sy - fy); + if (xDiff == 0 && yDiff == 0 && t == 1) { + return false; + } + return (Math.min(xDiff, yDiff) + Math.abs(xDiff - yDiff)) <= t; + } +} From 01347e7f723f0c155ebfef1c2f7d18b5de7672a2 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Tue, 12 Sep 2023 07:17:04 -0700 Subject: [PATCH 330/712] Update Minimum Deletions to Make Character Frequencies Unique.java --- ... to Make Character Frequencies Unique.java | 42 +++++++++---------- 1 file changed, 21 insertions(+), 21 deletions(-) diff --git a/Medium/Minimum Deletions to Make Character Frequencies Unique.java b/Medium/Minimum Deletions to Make Character Frequencies Unique.java index f98fa559..2d57dc68 100644 --- a/Medium/Minimum Deletions to Make Character Frequencies Unique.java +++ b/Medium/Minimum Deletions to Make Character Frequencies Unique.java @@ -1,25 +1,25 @@ class Solution { - public int minDeletions(String s) { - int[] frequency = new int[26]; - for (char c : s.toCharArray()) { - frequency[c - 'a']++; - } - PriorityQueue pq = new PriorityQueue<>(Collections.reverseOrder()); - for (int freq : frequency) { - if (freq > 0) { - pq.add(freq); - } - } - int numOfDeletions = 0; - while (!pq.isEmpty()) { - int removedFreq = pq.poll(); - if (!pq.isEmpty() && pq.peek() == removedFreq) { - numOfDeletions++; - if (removedFreq > 1) { - pq.add(removedFreq - 1); + public int minDeletions(String s) { + int[] frequency = new int[26]; + for (char c : s.toCharArray()) { + frequency[c - 'a']++; + } + Arrays.sort(frequency); + int numOfDeletions = 0; + int expectedFrequency = frequency[25]; + for (int i = 25; i >= 0; i--) { + if (frequency[i] == 0) { + break; + } + if (frequency[i] > expectedFrequency) { + numOfDeletions += frequency[i] - expectedFrequency; + } else { + expectedFrequency = frequency[i]; + } + if (expectedFrequency > 0) { + expectedFrequency--; + } } - } + return numOfDeletions; } - return numOfDeletions; - } } From 9759e5a4ba6ea77fbfc3fb32cc8a0c65eba460ea Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Wed, 13 Sep 2023 07:26:55 -0700 Subject: [PATCH 331/712] Update Candy.java --- Hard/Candy.java | 35 +++++++++++++++++++---------------- 1 file changed, 19 insertions(+), 16 deletions(-) diff --git a/Hard/Candy.java b/Hard/Candy.java index 5bf67db1..269d4d6a 100644 --- a/Hard/Candy.java +++ b/Hard/Candy.java @@ -1,19 +1,22 @@ class Solution { - public int candy(int[] ratings) { - int[] candies = new int[ratings.length]; - Arrays.fill(candies, 1); - for (int i = 1; i < ratings.length; i++) { - if (ratings[i] > ratings[i - 1]) { - candies[i] = candies[i - 1] + 1; - } + public int candy(int[] ratings) { + int n = ratings.length; + int[] candies = new int[n]; + Arrays.fill(candies, 1); + for (int i = 1; i < n; i++) { + if (ratings[i] > ratings[i - 1]) { + candies[i] = candies[i - 1] + 1; + } + } + for (int i = n - 2; i >= 0; i--) { + if (ratings[i] > ratings[i + 1]) { + candies[i] = Math.max(candies[i], candies[i + 1] + 1); + } + } + int totalCandies = 0; + for (int i = 0; i < n; i++) { + totalCandies += candies[i]; + } + return totalCandies; } - int totalCandies = candies[candies.length - 1]; - for (int i = ratings.length - 2; i >= 0; i--) { - if (ratings[i] > ratings[i + 1]) { - candies[i] = Math.max(candies[i], candies[i + 1] + 1); - } - totalCandies += candies[i]; - } - return totalCandies; - } } From 49a1a51566eb3eeb63ce779c6ddc869246a24e89 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Wed, 13 Sep 2023 18:02:02 -0700 Subject: [PATCH 332/712] Update Reconstruct Itinerary.java --- Hard/Reconstruct Itinerary.java | 35 +++++++++++++++------------------ 1 file changed, 16 insertions(+), 19 deletions(-) diff --git a/Hard/Reconstruct Itinerary.java b/Hard/Reconstruct Itinerary.java index 0c3c962f..e5616f94 100644 --- a/Hard/Reconstruct Itinerary.java +++ b/Hard/Reconstruct Itinerary.java @@ -1,22 +1,19 @@ class Solution { - public List findItinerary(List> tickets) { - Map> map = new HashMap<>(); - for (List ticket : tickets) { - String from = ticket.get(0); - String to = ticket.get(1); - map.computeIfAbsent(from, k -> new PriorityQueue<>()).add(to); + public List findItinerary(List> tickets) { + Map> map = new HashMap<>(); + for (List ticket : tickets) { + map.computeIfAbsent(ticket.get(0), k -> new PriorityQueue<>()).add(ticket.get(1)); + } + Stack stack = new Stack<>(); + stack.push("JFK"); + List result = new ArrayList<>(); + while (!stack.isEmpty()) { + while (map.containsKey(stack.peek()) && !map.get(stack.peek()).isEmpty()) { + stack.push(map.get(stack.peek()).poll()); + } + result.add(stack.pop()); + } + Collections.reverse(result); + return result; } - Stack stack = new Stack<>(); - LinkedList result = new LinkedList<>(); - stack.push("JFK"); - while (!stack.isEmpty()) { - String destination = stack.peek(); - if (!map.getOrDefault(destination, new PriorityQueue<>()).isEmpty()) { - stack.push(map.get(destination).remove()); - } else { - result.addFirst(stack.pop()); - } - } - return result; - } } From 76f32c6f4fd8eb4c621f18ae29c042ff7110ea77 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Fri, 15 Sep 2023 09:28:06 -0700 Subject: [PATCH 333/712] Update Min Cost to Connect All Points.java --- Medium/Min Cost to Connect All Points.java | 126 +++++++++------------ 1 file changed, 55 insertions(+), 71 deletions(-) diff --git a/Medium/Min Cost to Connect All Points.java b/Medium/Min Cost to Connect All Points.java index 15cc689b..168142ca 100644 --- a/Medium/Min Cost to Connect All Points.java +++ b/Medium/Min Cost to Connect All Points.java @@ -1,80 +1,64 @@ class Solution { - public int minCostConnectPoints(int[][] points) { - int n = points.length; - PriorityQueue priorityQueue = new PriorityQueue<>((x, y) -> x.cost - y.cost); - UnionFind unionFind = new UnionFind(n); - for (int i = 0; i < n; i++) { - int[] coordinate = points[i]; - for (int j = i + 1; j < n; j++) { - int[] secondCoordinate = points[j]; - int cost = Math.abs(coordinate[0] - secondCoordinate[0]) + Math.abs(coordinate[1] - secondCoordinate[1]); - Edge edge = new Edge(i, j, cost); - priorityQueue.add(edge); - } - } - int minimumCost = 0; - int totalEdges = n - 1; - while (!priorityQueue.isEmpty() && totalEdges > 0) { - Edge edge = priorityQueue.poll(); - if (!unionFind.connected(edge.pointOne, edge.pointTwo)) { - unionFind.union(edge.pointOne, edge.pointTwo); - minimumCost += edge.cost; - totalEdges--; - } - } - return minimumCost; - } - - private static class Edge { - int pointOne; - int pointTwo; - int cost; - - public Edge(int pointOne, int pointTwo, int cost) { - this.pointOne = pointOne; - this.pointTwo = pointTwo; - this.cost = cost; + public int minCostConnectPoints(int[][] points) { + int n = points.length; + List edges = new ArrayList<>(); + for (int i = 0; i < n; i++) { + for (int j = i + 1; j < n; j++) { + int weight = Math.abs(points[i][0] - points[j][0]) + Math.abs(points[i][1] - points[j][1]); + int[] curr = {weight, i, j}; + edges.add(curr); + } + } + Collections.sort(edges, Comparator.comparingInt(a -> a[0])); + UnionFind unionFind = new UnionFind(n); + int minCost = 0; + int edgeUsedCount = 0; + for (int i = 0; i < edges.size() && edgeUsedCount < n - 1; i++) { + int nodeOne = edges.get(i)[1]; + int nodeTwo = edges.get(i)[2]; + int weight = edges.get(i)[0]; + if (unionFind.union(nodeOne, nodeTwo)) { + minCost += weight; + edgeUsedCount++; + } + } + return minCost; } - } - - private static class UnionFind { - private final int[] root; - private final int[] rank; + private static class UnionFind { + private final int[] group; + private final int[] rank; - public UnionFind(int size) { - this.root = new int[size]; - this.rank = new int[size]; - for (int i = 0; i < size; i++) { - this.root[i] = i; - this.rank[i] = 1; - } - } - - public void union(int nodeOne, int nodeTwo) { - int rootOne = find(nodeOne); - int rootTwo = find(nodeTwo); - if (rootOne != rootTwo) { - if (this.rank[rootOne] > this.rank[rootTwo]) { - this.root[rootTwo] = rootOne; - } else if (this.rank[rootOne] < this.rank[rootTwo]) { - this.root[rootOne] = rootTwo; - } else { - this.root[rootTwo] = rootOne; - this.rank[rootOne]++; + public UnionFind(int n) { + this.group = new int[n]; + this.rank = new int[n]; + for (int i = 0; i < n; i++) { + this.group[i] = i; + } } - } - } - public int find(int node) { - if (node == root[node]) { - return node; - } - return root[node] = find(root[node]); - } + public int find(int node) { + if (group[node] != node) { + group[node] = find(group[node]); + } + return group[node]; + } - public boolean connected(int nodeOne, int nodeTwo) { - return find(nodeOne) == find(nodeTwo); + public boolean union(int nodeOne, int nodeTwo) { + int groupOne = find(nodeOne); + int groupTwo = find(nodeTwo); + if (groupOne == groupTwo) { + return false; + } + if (rank[groupOne] > rank[groupTwo]) { + group[groupTwo] = groupOne; + } else if (rank[groupOne] < rank[groupTwo]) { + group[groupOne] = groupTwo; + } else { + group[groupOne] = groupTwo; + rank[groupTwo]++; + } + return true; + } } - } } From 80259e4d2dae2210d70bb5e05797fe6387ff5abd Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sat, 16 Sep 2023 16:23:50 -0700 Subject: [PATCH 334/712] Create Minimum Right Shifts to Sort the Array.java --- ...inimum Right Shifts to Sort the Array.java | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) create mode 100644 Easy/Minimum Right Shifts to Sort the Array.java diff --git a/Easy/Minimum Right Shifts to Sort the Array.java b/Easy/Minimum Right Shifts to Sort the Array.java new file mode 100644 index 00000000..aad801a0 --- /dev/null +++ b/Easy/Minimum Right Shifts to Sort the Array.java @@ -0,0 +1,19 @@ +class Solution { + public int minimumRightShifts(List nums) { + int mismatchIdx = -1; + int count = 0; + for (int i = 1; i < nums.size(); i++) { + if (nums.get(i - 1) > nums.get(i)) { + mismatchIdx = i; + count++; + } + } + if (count > 1) { + return -1; + } + if (count == 0) { + return 0; + } + return nums.get(nums.size() - 1) > nums.get(0) ? -1 : nums.size() - mismatchIdx; + } +} From c21dafb087383fafc50a347daf81d32b80ab826c Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 17 Sep 2023 09:34:14 -0700 Subject: [PATCH 335/712] Create Sum of Values at Indices With K Set Bits.java --- Easy/Sum of Values at Indices With K Set Bits.java | 8 ++++++++ 1 file changed, 8 insertions(+) create mode 100644 Easy/Sum of Values at Indices With K Set Bits.java diff --git a/Easy/Sum of Values at Indices With K Set Bits.java b/Easy/Sum of Values at Indices With K Set Bits.java new file mode 100644 index 00000000..598f65c1 --- /dev/null +++ b/Easy/Sum of Values at Indices With K Set Bits.java @@ -0,0 +1,8 @@ +class Solution { + public int sumIndicesWithKSetBits(List nums, int k) { + return IntStream.range(0, nums.size()) + .filter(idx -> Integer.bitCount(idx) == k) + .map(idx -> nums.get(idx)) + .sum(); + } +} From b07d068d74e02b8000bf3e7e475493845434524c Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 17 Sep 2023 12:05:05 -0700 Subject: [PATCH 336/712] Create Shortest Path Visiting All Nodes.java --- Hard/Shortest Path Visiting All Nodes.java | 33 ++++++++++++++++++++++ 1 file changed, 33 insertions(+) create mode 100644 Hard/Shortest Path Visiting All Nodes.java diff --git a/Hard/Shortest Path Visiting All Nodes.java b/Hard/Shortest Path Visiting All Nodes.java new file mode 100644 index 00000000..8d08ecfa --- /dev/null +++ b/Hard/Shortest Path Visiting All Nodes.java @@ -0,0 +1,33 @@ +class Solution { + public int shortestPathLength(int[][] graph) { + int n = graph.length; + Map>> map = new HashMap<>(); + Queue queue = new LinkedList<>(); + for (int i = 0; i < n; i++) { + Set visited = new HashSet<>(); + visited.add(i); + map.put(i, new HashSet<>(List.of(visited))); + queue.add(new State(i, 0, visited)); + } + while (!queue.isEmpty()) { + State removed = queue.remove(); + int node = removed.node(); + int steps = removed.steps(); + Set visited = removed.visited(); + if (visited.size() == n) { + return steps; + } + for (int conn : graph[node]) { + Set connVisited = new HashSet<>(visited); + connVisited.add(conn); + if (!map.get(conn).contains(connVisited)) { + queue.add(new State(conn, steps + 1, connVisited)); + map.computeIfAbsent(conn, k -> new HashSet<>()).add(connVisited); + } + } + } + return -1; + } + + private static record State(int node, int steps, Set visited) {} +} From 5502fe64029d14cef414b388c85e8b2ba19f4de9 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Mon, 18 Sep 2023 07:05:13 -0700 Subject: [PATCH 337/712] Update The K Weakest Rows in a Matrix.java --- Easy/The K Weakest Rows in a Matrix.java | 46 ++++++++++++------------ 1 file changed, 23 insertions(+), 23 deletions(-) diff --git a/Easy/The K Weakest Rows in a Matrix.java b/Easy/The K Weakest Rows in a Matrix.java index 09e395be..a4a52ad7 100644 --- a/Easy/The K Weakest Rows in a Matrix.java +++ b/Easy/The K Weakest Rows in a Matrix.java @@ -1,28 +1,28 @@ class Solution { - public int[] kWeakestRows(int[][] mat, int k) { - PriorityQueue pq = new PriorityQueue<>( - Comparator.comparingInt((int[] o) -> o[1]).thenComparingInt(o -> o[0])); - for (int i = 0; i < mat.length; i++) { - pq.add(new int[]{i, getNumberOfOnes(mat[i])}); + public int[] kWeakestRows(int[][] mat, int k) { + PriorityQueue pq = + new PriorityQueue<>(Comparator.comparingInt((int[] o) -> o[1]).thenComparingInt(o -> o[0])); + for (int i = 0; i < mat.length; i++) { + pq.add(new int[]{i, findNumberOfSoldiers(mat[i])}); + } + int[] result = new int[k]; + for (int i = 0; i < k && !pq.isEmpty(); i++){ + result[i] = pq.poll()[0]; + } + return result; } - int[] result = new int[k]; - for (int i = 0; i < result.length && !pq.isEmpty(); i++) { - result[i] = pq.poll()[0]; - } - return result; - } - private int getNumberOfOnes(int[] arr) { - int start = 0; - int end = arr.length - 1; - while (start <= end) { - int mid = (start + end) / 2; - if (arr[mid] == 0) { - end = mid - 1; - } else { - start = mid + 1; - } + private int findNumberOfSoldiers(int[] row) { + int left = 0; + int right = row.length - 1; + while (left <= right) { + int mid = (left + right) / 2; + if (row[mid] == 0) { + right = mid - 1; + } else { + left = mid + 1; + } + } + return right < 0 ? 0 : left; } - return end < 0 ? 0 : start; - } } From 40bb0b180ad7865e54efd790f7f143131d723d41 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Mon, 18 Sep 2023 08:51:40 -0700 Subject: [PATCH 338/712] Update Parallel Courses.java --- Medium/Parallel Courses.java | 60 +++++++++++++++++++----------------- 1 file changed, 31 insertions(+), 29 deletions(-) diff --git a/Medium/Parallel Courses.java b/Medium/Parallel Courses.java index a3843f23..797e3b58 100644 --- a/Medium/Parallel Courses.java +++ b/Medium/Parallel Courses.java @@ -1,33 +1,35 @@ class Solution { - public int minimumSemesters(int n, int[][] relations) { - Map> graph = new HashMap<>(); - int[] indegree = new int[n + 1]; - for (int[] relation : relations) { - graph.computeIfAbsent(relation[0], k -> new ArrayList<>()).add(relation[1]); - indegree[relation[1]]++; - } - Queue queue = new LinkedList<>(); - int numOfSemesters = 0; - Set coursesTaken = new HashSet<>(); - for (int i = 1; i <= n; i++) { - if (indegree[i] == 0) { - queue.add(i); - } - } - while (!queue.isEmpty()) { - int size = queue.size(); - while (size-- > 0) { - int course = queue.remove(); - coursesTaken.add(course); - for (int dependentCourse : graph.getOrDefault(course, new ArrayList<>())) { - indegree[dependentCourse]--; - if (indegree[dependentCourse] <= 0 && !coursesTaken.contains(dependentCourse)) { - queue.add(dependentCourse); - } + public int minimumSemesters(int n, int[][] relations) { + Map> graph = new HashMap<>(); + int[] indegree = new int[n]; + for (int[] relation : relations) { + int course = relation[0]; + int dependency = relation[1]; + indegree[course - 1]++; + graph.computeIfAbsent(dependency, k -> new HashSet<>()).add(course); + } + Queue queue = new LinkedList<>(); + int numOfSemesters = 0; + int coursesTaken = 0; + for (int i = 0; i < n; i++) { + if (indegree[i] == 0) { + queue.add(i + 1); + } + } + while (!queue.isEmpty()) { + int size = queue.size(); + while (size-- > 0) { + int removed = queue.remove(); + coursesTaken++; + for (Integer dependent : graph.getOrDefault(removed, new HashSet<>())) { + indegree[dependent - 1]--; + if (indegree[dependent - 1] == 0) { + queue.add(dependent); + } + } + } + numOfSemesters++; } - } - numOfSemesters++; + return coursesTaken == n ? numOfSemesters : -1; } - return coursesTaken.size() == n ? numOfSemesters : -1; - } } From 01039f5e50509d0fd496abadb507b3ae53b57cb2 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Tue, 19 Sep 2023 08:19:22 -0700 Subject: [PATCH 339/712] Update Find the Duplicate Number.java From b43550af66a9288fe7487d71cb1a95d81b8344c9 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Tue, 19 Sep 2023 08:19:33 -0700 Subject: [PATCH 340/712] Update Find the Duplicate Number.java --- Medium/Find the Duplicate Number.java | 30 +++++++++++++++------------ 1 file changed, 17 insertions(+), 13 deletions(-) diff --git a/Medium/Find the Duplicate Number.java b/Medium/Find the Duplicate Number.java index c4f5a541..bfd8908b 100644 --- a/Medium/Find the Duplicate Number.java +++ b/Medium/Find the Duplicate Number.java @@ -1,16 +1,20 @@ class Solution { - public int findDuplicate(int[] nums) { - int slow = nums[0]; - int fast = nums[0]; - do { - slow = nums[slow]; - fast = nums[nums[fast]]; - } while (slow != fast); - slow = nums[0]; - while (slow != fast) { - slow = nums[slow]; - fast = nums[fast]; + public int findDuplicate(int[] nums) { + int slow = nums[0]; + int fast = nums[0]; + while (true) { + slow = nums[slow]; + fast = nums[nums[fast]]; + if (slow == fast) { + break; + } + } + int idxOne = nums[0]; + int idxTwo = slow; + while (idxOne != idxTwo) { + idxOne = nums[idxOne]; + idxTwo = nums[idxTwo]; + } + return idxOne; } - return fast; - } } From 9f154a1703d583d7261bda066aa242e92cdba3f3 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Wed, 20 Sep 2023 08:30:12 -0700 Subject: [PATCH 341/712] Update Minimum Operations to Reduce X to Zero.java --- ...inimum Operations to Reduce X to Zero.java | 37 ++++++++++--------- 1 file changed, 19 insertions(+), 18 deletions(-) diff --git a/Medium/Minimum Operations to Reduce X to Zero.java b/Medium/Minimum Operations to Reduce X to Zero.java index 3e202cb6..f2f2a99b 100644 --- a/Medium/Minimum Operations to Reduce X to Zero.java +++ b/Medium/Minimum Operations to Reduce X to Zero.java @@ -1,21 +1,22 @@ class Solution { - public int minOperations(int[] nums, int x) { - int totalSum = 0; - for (int num : nums) { - totalSum += num; + public int minOperations(int[] nums, int x) { + int sum = 0; + for (int num : nums) { + sum += num; + } + int max = -1; + int left = 0; + int curr = 0; + int n = nums.length; + for (int right = 0; right < n; right++) { + curr += nums[right]; + while (curr > sum - x && left <= right) { + curr -= nums[left++]; + } + if (curr == sum - x) { + max = Math.max(max, right - left + 1); + } + } + return max != -1 ? n - max : -1; } - int max = -1; - int left = 0; - int current = 0; - for (int right = 0; right < nums.length; right++) { - current += nums[right]; - while (current > totalSum - x && left <= right) { - current -= nums[left++]; - } - if (current == totalSum - x) { - max = Math.max(max, right - left + 1); - } - } - return max != -1 ? nums.length - max : -1; - } } From e2c2b2372b952c4ee16f19250a05a4a7346defb4 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Thu, 21 Sep 2023 17:20:10 -0700 Subject: [PATCH 342/712] Update Is Subsequence.java --- Easy/Is Subsequence.java | 18 ++++++++++-------- 1 file changed, 10 insertions(+), 8 deletions(-) diff --git a/Easy/Is Subsequence.java b/Easy/Is Subsequence.java index 90732379..2d67a698 100644 --- a/Easy/Is Subsequence.java +++ b/Easy/Is Subsequence.java @@ -1,11 +1,13 @@ class Solution { - public boolean isSubsequence(String s, String t) { - int j = 0; - for (int i = 0; i < t.length() && j < s.length(); i++) { - if (s.charAt(j) == t.charAt(i)) { - j++; - } + public boolean isSubsequence(String s, String t) { + int sIdx = 0; + int tIdx = 0; + while (sIdx < s.length() && tIdx < t.length()) { + if (s.charAt(sIdx) == t.charAt(tIdx)) { + sIdx++; + } + tIdx++; + } + return sIdx == s.length(); } - return j == s.length(); - } } From 162a26bf7f655add678c07960c5aa13ae9f02042 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sat, 23 Sep 2023 08:43:44 -0700 Subject: [PATCH 343/712] Update Longest String Chain.java --- Medium/Longest String Chain.java | 52 +++++++++++++++++--------------- 1 file changed, 27 insertions(+), 25 deletions(-) diff --git a/Medium/Longest String Chain.java b/Medium/Longest String Chain.java index 17d14f0c..5c36ef9d 100644 --- a/Medium/Longest String Chain.java +++ b/Medium/Longest String Chain.java @@ -1,29 +1,31 @@ class Solution { - public int longestStrChain(String[] words) { - Map dp = new HashMap<>(); - Set wordSet = Arrays.stream(words).collect(Collectors.toSet()); - int maxLength = 0; - for (String word : words) { - maxLength = Math.max(maxLength, dfs(wordSet, dp, word)); + public int longestStrChain(String[] words) { + Set wordSet = Arrays.stream(words) + .collect(Collectors.toSet()); + Map memo = new HashMap<>(); + int result = 0; + for (String word : words) { + result = Math.max(result, dfs(wordSet, memo, word)); + } + return result; } - return maxLength; - } - - private int dfs(Set wordSet, Map dp, String currWord) { - if (dp.containsKey(currWord)) { - return dp.get(currWord); + + private int dfs(Set wordSet, Map memo, String word) { + if (memo.containsKey(word)) { + return memo.get(word); + } + int maxLength = 1; + StringBuilder sb = new StringBuilder(word); + for (int i = 0; i < word.length(); i++) { + sb.deleteCharAt(i); + String newWord = sb.toString(); + if (wordSet.contains(newWord)) { + int currLength = 1 + dfs(wordSet, memo, newWord); + maxLength = Math.max(maxLength, currLength); + } + sb.insert(i, word.charAt(i)); + } + memo.put(word, maxLength); + return maxLength; } - int maxLength = 1; - StringBuilder sb = new StringBuilder(currWord); - for (int i = 0; i < currWord.length(); i++) { - sb.deleteCharAt(i); - String newWord = sb.toString(); - if (wordSet.contains(newWord)) { - maxLength = Math.max(maxLength, 1 + dfs(wordSet, dp, newWord)); - } - sb.insert(i, currWord.charAt(i)); - } - dp.put(currWord, maxLength); - return dp.get(currWord); - } } From 5c7f8b7106ab6174d147f94899798faa047ac10f Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sat, 23 Sep 2023 17:54:15 -0700 Subject: [PATCH 344/712] Update Champagne Tower.java --- Medium/Champagne Tower.java | 21 ++++++++++----------- 1 file changed, 10 insertions(+), 11 deletions(-) diff --git a/Medium/Champagne Tower.java b/Medium/Champagne Tower.java index b8f0797e..ccd07a8b 100644 --- a/Medium/Champagne Tower.java +++ b/Medium/Champagne Tower.java @@ -1,14 +1,13 @@ class Solution { - public double champagneTower(int poured, int query_row, int query_glass) { - double[][] glassCapacity = new double[query_row + 1][query_glass + 2]; - glassCapacity[0][0] = poured; - for (int currRow = 0; currRow < query_row; currRow++) { - for (int currCol = 0; currCol <= query_glass; currCol++) { - double currCapacity = Math.max(glassCapacity[currRow][currCol] - 1.0, 0); - glassCapacity[currRow + 1][currCol] += currCapacity / 2.0; - glassCapacity[currRow + 1][currCol + 1] += currCapacity / 2.0; - } + public double champagneTower(int poured, int query_row, int query_glass) { + double[] glass = new double[query_row + 2]; + glass[0] = poured; + for (int row = 1; row <= query_row; row++) { + for (int idx = row; idx >= 0; idx--) { + glass[idx] = Math.max(0.0, (glass[idx] - 1) / 2); + glass[idx + 1] += glass[idx]; + } + } + return Math.min(glass[query_glass], 1.0); } - return Math.min(glassCapacity[query_row][query_glass], 1.0); - } } From de2351a228b16cc5caf781bacccdee9e1224c0ae Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 24 Sep 2023 07:45:44 -0700 Subject: [PATCH 345/712] Create Maximum Odd Binary Number.java --- Easy/Maximum Odd Binary Number.java | 13 +++++++++++++ 1 file changed, 13 insertions(+) create mode 100644 Easy/Maximum Odd Binary Number.java diff --git a/Easy/Maximum Odd Binary Number.java b/Easy/Maximum Odd Binary Number.java new file mode 100644 index 00000000..861a3fd1 --- /dev/null +++ b/Easy/Maximum Odd Binary Number.java @@ -0,0 +1,13 @@ +class Solution { + public String maximumOddBinaryNumber(String s) { + int oneCount = 0; + for (char c : s.toCharArray()) { + oneCount += c == '1' ? 1 : 0; + } + if (oneCount == 0) { + return s; + } + int zeroCount = s.length() - oneCount; + return "1".repeat(oneCount - 1) + "0".repeat(zeroCount) + "1"; + } +} From f01834c0c536c2ed9f260a70376f117130f3629a Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 24 Sep 2023 20:50:12 -0700 Subject: [PATCH 346/712] Update Find the difference.java --- Easy/Find the difference.java | 24 ++++++++++++------------ 1 file changed, 12 insertions(+), 12 deletions(-) diff --git a/Easy/Find the difference.java b/Easy/Find the difference.java index 710a70d3..ca12be6d 100644 --- a/Easy/Find the difference.java +++ b/Easy/Find the difference.java @@ -1,15 +1,15 @@ class Solution { - public char findTheDifference(String s, String t) { - int[] counter = new int[26]; - for (char c : s.toCharArray()) { - counter[c - 'a']++; + public char findTheDifference(String s, String t) { + int[] frequency = new int[26]; + for (char c : s.toCharArray()) { + frequency[c - 'a']++; + } + for (char c : t.toCharArray()) { + if (frequency[c - 'a'] == 0) { + return c; + } + frequency[c - 'a']--; + } + return ' '; } - for (char c : t.toCharArray()) { - if (counter[c - 'a'] == 0) { - return c; - } - counter[c - 'a']--; - } - return '-'; - } } From f65450e5cc65333d00b56d73e1d3c7bd16eda4e3 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Tue, 26 Sep 2023 06:26:42 -0700 Subject: [PATCH 347/712] Update Remove Duplicate Letters.java --- Medium/Remove Duplicate Letters.java | 46 +++++++++++++--------------- 1 file changed, 22 insertions(+), 24 deletions(-) diff --git a/Medium/Remove Duplicate Letters.java b/Medium/Remove Duplicate Letters.java index 25cfd16c..19bd928d 100644 --- a/Medium/Remove Duplicate Letters.java +++ b/Medium/Remove Duplicate Letters.java @@ -1,27 +1,25 @@ class Solution { - public String removeDuplicateLetters(String s) { - int[] counter = new int[26]; - for (char c : s.toCharArray()) { - counter[c - 'a']++; + public String removeDuplicateLetters(String s) { + Map lastIndexMap = new HashMap<>(); + for (int i = 0; i < s.length(); i++) { + lastIndexMap.put(s.charAt(i), i); + } + Stack stack = new Stack<>(); + Set visited = new HashSet<>(); + for (int i = 0; i < s.length(); i++) { + char c = s.charAt(i); + if (!visited.contains(c)) { + while (!stack.isEmpty() && c < stack.peek() && lastIndexMap.get(stack.peek()) > i) { + visited.remove(stack.pop()); + } + visited.add(c); + stack.push(c); + } + } + StringBuilder sb = new StringBuilder(); + for (Character c : stack) { + sb.append(c); + } + return sb.toString(); } - Stack stack = new Stack<>(); - boolean[] visited = new boolean[26]; - for (char c : s.toCharArray()) { - int idx = c - 'a'; - counter[idx]--; - if (visited[idx]) { - continue; - } - while (!stack.isEmpty() && stack.peek() > idx && counter[stack.peek()] > 0) { - visited[stack.pop()] = false; - } - stack.add(idx); - visited[idx] = true; - } - StringBuilder sb = new StringBuilder(); - while (!stack.isEmpty()) { - sb.append((char) (stack.pop() + 'a')); - } - return sb.reverse().toString(); - } } From c0bc4aba017f8c62ec662106636418447fb40d88 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Wed, 27 Sep 2023 08:34:44 -0700 Subject: [PATCH 348/712] Create Decoded String at Index.java --- Medium/Decoded String at Index.java | 27 +++++++++++++++++++++++++++ 1 file changed, 27 insertions(+) create mode 100644 Medium/Decoded String at Index.java diff --git a/Medium/Decoded String at Index.java b/Medium/Decoded String at Index.java new file mode 100644 index 00000000..a0c94968 --- /dev/null +++ b/Medium/Decoded String at Index.java @@ -0,0 +1,27 @@ +class Solution { + public String decodeAtIndex(String s, int k) { + long size = 0; + int n = s.length(); + for (int i = 0; i < n; i++) { + char c = s.charAt(i); + if (Character.isDigit(c)) { + size *= (c - '0'); + } else { + size++; + } + } + for (int i = n - 1; i >= 0; i--) { + char c = s.charAt(i); + k %= size; + if (k == 0 && Character.isLetter(c)) { + return Character.toString(c); + } + if (Character.isDigit(c)) { + size /= (c - '0'); + } else { + size--; + } + } + return ""; + } +} From 866f09583d07f33f6d988fa1df33fd98e3082923 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Thu, 28 Sep 2023 09:02:43 -0700 Subject: [PATCH 349/712] Update Sort Array By Parity.java --- Easy/Sort Array By Parity.java | 27 +++++++++++++-------------- 1 file changed, 13 insertions(+), 14 deletions(-) diff --git a/Easy/Sort Array By Parity.java b/Easy/Sort Array By Parity.java index c74dcae0..0b54ae53 100644 --- a/Easy/Sort Array By Parity.java +++ b/Easy/Sort Array By Parity.java @@ -1,17 +1,16 @@ class Solution { - public int[] sortArrayByParity(int[] A) { - int evenIdx = 0; - int oddIdx = A.length - 1; - while (evenIdx < oddIdx) { - if (A[evenIdx] % 2 == 0) { - evenIdx++; - } - else { - int temp = A[evenIdx]; - A[evenIdx] = A[oddIdx]; - A[oddIdx--] = temp; - } + public int[] sortArrayByParity(int[] nums) { + int start = 0; + int end = 0; + int n = nums.length; + while (end < n) { + if (nums[end] % 2 == 0) { + int temp = nums[start]; + nums[start++] = nums[end]; + nums[end] = temp; + } + end++; + } + return nums; } - return A; - } } From 0cb7779f1f326f3fdeb43c95db4b4c3620ad5b8d Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Thu, 28 Sep 2023 17:04:44 -0700 Subject: [PATCH 350/712] Update Monotonic Array.java --- Easy/Monotonic Array.java | 34 ++++++++++++++++------------------ 1 file changed, 16 insertions(+), 18 deletions(-) diff --git a/Easy/Monotonic Array.java b/Easy/Monotonic Array.java index 4a348d71..e460648c 100644 --- a/Easy/Monotonic Array.java +++ b/Easy/Monotonic Array.java @@ -1,21 +1,19 @@ class Solution { - public boolean isMonotonic(int[] nums) { - int idx = 0; - int sign = 0; - while (idx < nums.length - 1 && sign == 0) { - if (nums[idx] < nums[idx + 1]) { - sign = 1; - } else if (nums[idx] > nums[idx + 1]) { - sign = -1; - } - idx++; + public boolean isMonotonic(int[] nums) { + int idx = 0; + while (idx + 1 < nums.length && nums[idx] == nums[idx + 1]) { + idx++; + } + boolean increasing = idx + 1 < nums.length && nums[idx] < nums[idx + 1]; + while (idx + 1 < nums.length) { + if (nums[idx] > nums[idx + 1] && increasing) { + return false; + } + if (nums[idx] < nums[idx + 1] && !increasing) { + return false; + } + idx++; + } + return true; } - while (idx < nums.length - 1) { - if ((sign == 1 && nums[idx] > nums[idx + 1]) || (sign == -1 && nums[idx] < nums[idx + 1])) { - return false; - } - idx++; - } - return true; - } } From 88f4c846c5f3afca739cb44f3c2143963e783507 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sat, 30 Sep 2023 09:01:31 -0700 Subject: [PATCH 351/712] Update 132 Pattern.java --- Medium/132 Pattern.java | 38 ++++++++++++++++++-------------------- 1 file changed, 18 insertions(+), 20 deletions(-) diff --git a/Medium/132 Pattern.java b/Medium/132 Pattern.java index 80a6c64e..54937149 100644 --- a/Medium/132 Pattern.java +++ b/Medium/132 Pattern.java @@ -1,25 +1,23 @@ class Solution { - public boolean find132pattern(int[] nums) { - if (nums.length < 3) { - return false; - } - int[] minTillIndex = new int[nums.length]; - minTillIndex[0] = nums[0]; - for (int idx = 1; idx < nums.length; idx++) { - minTillIndex[idx] = Math.min(minTillIndex[idx - 1], nums[idx]); - } - Stack stack = new Stack<>(); - for (int idx = nums.length - 1; idx >= 0; idx--) { - if (nums[idx] > minTillIndex[idx]) { - while (!stack.isEmpty() && stack.peek() <= minTillIndex[idx]) { - stack.pop(); + public boolean find132pattern(int[] nums) { + int n = nums.length; + int[] uptoIdxMin = new int[n]; + uptoIdxMin[0] = nums[0]; + for (int i = 1; i < n; i++) { + uptoIdxMin[i] = Math.min(uptoIdxMin[i - 1], nums[i]); } - if (!stack.isEmpty() && stack.peek() < nums[idx]) { - return true; + Stack stack = new Stack<>(); + for (int i = n - 1; i >= 0; i--) { + if (nums[i] > uptoIdxMin[i]) { + while (!stack.isEmpty() && stack.peek() <= uptoIdxMin[i]) { + stack.pop(); + } + if (!stack.isEmpty() && stack.peek() < nums[i]) { + return true; + } + stack.push(nums[i]); + } } - stack.push(nums[idx]); - } + return false; } - return false; - } } From d202d37900aeec8a517f39041fa71efb7f53ba3a Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sat, 30 Sep 2023 12:44:55 -0700 Subject: [PATCH 352/712] Create Minimum Operations to Collect Elements.java --- Easy/Minimum Operations to Collect Elements.java | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) create mode 100644 Easy/Minimum Operations to Collect Elements.java diff --git a/Easy/Minimum Operations to Collect Elements.java b/Easy/Minimum Operations to Collect Elements.java new file mode 100644 index 00000000..59e9d7c4 --- /dev/null +++ b/Easy/Minimum Operations to Collect Elements.java @@ -0,0 +1,16 @@ +class Solution { + public int minOperations(List nums, int k) { + boolean[] found = new boolean[k]; + int foundCount = 0; + for (int i = nums.size() - 1; i >= 0; i--) { + if (nums.get(i) <= k && !found[nums.get(i) - 1]) { + found[nums.get(i) - 1] = true; + foundCount++; + } + if (foundCount == k) { + return nums.size() - i; + } + } + return -1; + } +} From f626d03defca6cbac2a486d21015785af18f5a99 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sat, 30 Sep 2023 18:26:02 -0700 Subject: [PATCH 353/712] Update Reverse words in a String III.java --- Easy/Reverse words in a String III.java | 47 ++++++++++++++----------- 1 file changed, 27 insertions(+), 20 deletions(-) diff --git a/Easy/Reverse words in a String III.java b/Easy/Reverse words in a String III.java index e50dd770..c6c46160 100644 --- a/Easy/Reverse words in a String III.java +++ b/Easy/Reverse words in a String III.java @@ -1,23 +1,30 @@ class Solution { - public String reverseWords(String s) { - int idx = 0; - int n = s.length(); - StringBuilder sb = new StringBuilder(); - int start = 0; - while (idx < n) { - while (idx < n && s.charAt(idx) != ' ') { - idx++; - } - int curr = idx - 1; - while (curr >= start) { - sb.append(s.charAt(curr--)); - } - if (idx != n) { - sb.append(" "); - } - idx++; - start = idx; + public String reverseWords(String s) { + int start = 0; + int end = 0; + char[] chars = s.toCharArray(); + while (end < s.length()) { + if (chars[end] == ' ') { + if (start < end - 1) { + reverse(chars, start, end - 1); + } + end++; + start = end; + } else { + end++; + } + } + if (start < end) { + reverse(chars, start, end - 1); + } + return String.valueOf(chars); + } + + private void reverse(char[] chars, int start, int end) { + while (start < end) { + char temp = chars[start]; + chars[start++] = chars[end]; + chars[end--] = temp; + } } - return sb.toString(); - } } From ea1ff399c56360f66ad2fe864017020756c9f811 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 1 Oct 2023 07:25:01 -0700 Subject: [PATCH 354/712] Create Maximum Value of an Ordered Triplet I.java --- ...Maximum Value of an Ordered Triplet I.java | 22 +++++++++++++++++++ 1 file changed, 22 insertions(+) create mode 100644 Easy/Maximum Value of an Ordered Triplet I.java diff --git a/Easy/Maximum Value of an Ordered Triplet I.java b/Easy/Maximum Value of an Ordered Triplet I.java new file mode 100644 index 00000000..870e4602 --- /dev/null +++ b/Easy/Maximum Value of an Ordered Triplet I.java @@ -0,0 +1,22 @@ +class Solution { + public long maximumTripletValue(int[] nums) { + int n = nums.length; + int[] maxLeft = new int[n]; + int[] maxRight = new int[n]; + maxLeft[0] = nums[0]; + for (int i = 1; i < n; i++) { + maxLeft[i] = Math.max(maxLeft[i - 1], nums[i]); + } + maxRight[n - 1] = nums[n - 1]; + for (int i = n - 2; i >= 0; i--) { + maxRight[i] = Math.max(maxRight[i + 1], nums[i]); + } + long maxValue = -1; + for (int i = 1; i < n - 1; i++) { + long left = (long) maxLeft[i - 1]; + long right = (long) maxRight[i + 1]; + maxValue = Math.max(maxValue, (left - nums[i]) * right); + } + return maxValue == -1 ? 0 : maxValue; + } +} From ea6f89d24079ec634b9d51b8fdc2b82610d73217 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 1 Oct 2023 08:35:23 -0700 Subject: [PATCH 355/712] Update Implement Trie II (Prefix Tree).java --- Medium/Implement Trie II (Prefix Tree).java | 51 +++++++++++---------- 1 file changed, 28 insertions(+), 23 deletions(-) diff --git a/Medium/Implement Trie II (Prefix Tree).java b/Medium/Implement Trie II (Prefix Tree).java index a3bddf29..7c5b1a36 100644 --- a/Medium/Implement Trie II (Prefix Tree).java +++ b/Medium/Implement Trie II (Prefix Tree).java @@ -1,62 +1,67 @@ -public class Trie { +import java.util.Optional; - private final TrieNode root; + +class Trie { + + private final Node root; public Trie() { - this.root = new TrieNode(); + root = new Node(); } public void insert(String word) { - TrieNode curr = root; + Node curr = root; for (char c : word.toCharArray()) { if (!curr.children.containsKey(c)) { - curr.children.put(c, new TrieNode()); + curr.children.put(c, new Node()); } curr = curr.children.get(c); curr.startingWordCount++; } - curr.completeWordCount++; + curr.endingWordCount++; } public int countWordsEqualTo(String word) { - TrieNode endNode = searchWord(word); - return endNode == null ? 0 : endNode.completeWordCount; + Optional curr = search(word); + return curr.map(node -> node.endingWordCount).orElse(0); } public int countWordsStartingWith(String prefix) { - TrieNode endNode = searchWord(prefix); - return endNode == null ? 0 : endNode.startingWordCount; + Optional curr = search(prefix); + return curr.map(node -> node.startingWordCount).orElse(0); } public void erase(String word) { - TrieNode curr = root; + Node curr = root; for (char c : word.toCharArray()) { curr = curr.children.get(c); curr.startingWordCount--; } - curr.completeWordCount--; + curr.endingWordCount--; } - private TrieNode searchWord(String word) { - TrieNode curr = root; + private Optional search(String word) { + Node curr = root; for (char c : word.toCharArray()) { if (!curr.children.containsKey(c)) { - return null; + return Optional.empty(); } curr = curr.children.get(c); } - return curr; + return Optional.of(curr); } - private static class TrieNode { - Map children; - int completeWordCount; - int startingWordCount; + private static class Node { - public TrieNode() { - this.children = new HashMap<>(); - this.completeWordCount = 0; + private int startingWordCount; + private int endingWordCount; + + private final Map children; + + public Node() { this.startingWordCount = 0; + this.endingWordCount = 0; + this.children = new HashMap<>(); } } } From c7f0398ba830f64d54f3de4f344da2c67d2c875f Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Mon, 2 Oct 2023 06:40:27 -0700 Subject: [PATCH 356/712] Create Remove Colored Pieces if Both Neighbors are the Same Color.java --- ...ces if Both Neighbors are the Same Color.java | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) create mode 100644 Medium/Remove Colored Pieces if Both Neighbors are the Same Color.java diff --git a/Medium/Remove Colored Pieces if Both Neighbors are the Same Color.java b/Medium/Remove Colored Pieces if Both Neighbors are the Same Color.java new file mode 100644 index 00000000..950afa6f --- /dev/null +++ b/Medium/Remove Colored Pieces if Both Neighbors are the Same Color.java @@ -0,0 +1,16 @@ +class Solution { + public boolean winnerOfGame(String colors) { + int alice = 0; + int bob = 0; + for (int i = 1; i < colors.length() - 1; i++) { + if (colors.charAt(i - 1) == colors.charAt(i) && colors.charAt(i + 1) == colors.charAt(i)) { + if (colors.charAt(i) == 'A') { + alice++; + } else { + bob++; + } + } + } + return alice - bob > 0; + } +} From 64077658a5f27876f8118439012ae020f4a4532c Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Mon, 2 Oct 2023 17:15:32 -0700 Subject: [PATCH 357/712] Update Number of Good Pairs.java --- Easy/Number of Good Pairs.java | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/Easy/Number of Good Pairs.java b/Easy/Number of Good Pairs.java index d3c347af..edb3a754 100644 --- a/Easy/Number of Good Pairs.java +++ b/Easy/Number of Good Pairs.java @@ -1,11 +1,11 @@ class Solution { - public int numIdenticalPairs(int[] nums) { - Map map = new HashMap<>(); - int count = 0; - for (int num : nums) { - count += map.getOrDefault(num, 0); - map.put(num, map.getOrDefault(num, 0) + 1); + public int numIdenticalPairs(int[] nums) { + Map map = new HashMap<>(); + int count = 0; + for (int num : nums) { + count += map.getOrDefault(num, 0); + map.put(num, map.getOrDefault(num, 0) + 1); + } + return count; } - return count; - } } From 13ffcb896d6fe6ffa120ce3d89070d629ca6e41c Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Wed, 4 Oct 2023 05:30:41 -0700 Subject: [PATCH 358/712] Update Design HashMap.java --- Easy/Design HashMap.java | 66 +++++++++++++++++++--------------------- 1 file changed, 32 insertions(+), 34 deletions(-) diff --git a/Easy/Design HashMap.java b/Easy/Design HashMap.java index d59fe9e1..ff29c920 100644 --- a/Easy/Design HashMap.java +++ b/Easy/Design HashMap.java @@ -1,42 +1,40 @@ class MyHashMap { - /** Initialize your data structure here. */ - Integer[][] map; - int NUM_OF_BUCKETS = 1000; - int BUCKET_SIZE = 1000; - public MyHashMap() { - map = new Integer[NUM_OF_BUCKETS][BUCKET_SIZE]; - } + private static final int BUCKET_COUNT = 1001; - /** value will always be non-negative. */ - public void put(int key, int value) { - Integer[] bucket = getBucket(key); - int keyHash = getKeyHash(key); - bucket[keyHash] = value; - } + private static final int BUCKET_SIZE = 1001; - /** Returns the value to which the specified key is mapped, or -1 if this map contains no mapping for the key */ - public int get(int key) { - Integer[] bucket = getBucket(key); - int keyHash = getKeyHash(key); - return bucket[keyHash] == null ? -1 : bucket[keyHash]; - } + private final Integer[][] map; - /** Removes the mapping of the specified value key if this map contains a mapping for the key */ - public void remove(int key) { - Integer[] bucket = getBucket(key); - int keyHash = getKeyHash(key); - bucket[keyHash] = null; - } - - private Integer[] getBucket(int key) { - int bucketIdx = key / BUCKET_SIZE; - return map[bucketIdx]; - } - - private Integer getKeyHash(int key) { - return key % BUCKET_SIZE; - } + public MyHashMap() { + this.map = new Integer[BUCKET_COUNT][BUCKET_SIZE]; + } + + public void put(int key, int value) { + Position position = getPosition(key); + map[position.bucket()][position.index()] = value; + } + + public int get(int key) { + Position position = getPosition(key); + Integer value = map[position.bucket()][position.index()]; + return value == null ? -1 : value; + } + + public void remove(int key) { + Position position = getPosition(key); + map[position.bucket()][position.index()] = null; + } + + private static Position getPosition(int key) { + int bucket = key / BUCKET_COUNT; + int index = key % BUCKET_SIZE; + return new Position(bucket, index); + } + + private static record Position(int bucket, int index) { + + } } /** From 26fd48c8f78ecbc93eef72f621622e388014f0bb Mon Sep 17 00:00:00 2001 From: varunu28 Date: Wed, 4 Oct 2023 12:25:33 -0700 Subject: [PATCH 359/712] Updated README --- Easy/README.md | 1179 ++++++++++++++++++----------------- Hard/README.md | 236 +++---- Medium/README.md | 1547 ++++++++++++++++++++++++---------------------- README.md | 6 +- 4 files changed, 1528 insertions(+), 1440 deletions(-) diff --git a/Easy/README.md b/Easy/README.md index d3b1e72e..ff578ea7 100644 --- a/Easy/README.md +++ b/Easy/README.md @@ -1,574 +1,609 @@ -# Easy LeetCode Java Solutions +# Easy LeetCode-Java-Solutions S.no | Coding Problem --- | --- -1 | [1-bit and 2-bit Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/1-bit%20and%202-bit%20Characters.java) -2 | [A Number After a Double Reversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/A%20Number%20After%20a%20Double%20Reversal.java) -3 | [Add Binary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Add%20Binary.java) -4 | [Add Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Add%20Digits.java) -5 | [Add Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Add%20Strings.java) -6 | [Add to Array-Form of Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Add%20to%20Array-Form%20of%20Integer.java) -7 | [Alternating Digit Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Alternating%20Digit%20Sum.java) -8 | [Apply Operations to an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Apply%20Operations%20to%20an%20Array.java) -9 | [Armstrong Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Armstrong%20Number.java) -10 | [Arranging Coins](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Arranging%20Coins.java) -11 | [Array Partition I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Array%20Partition%20I.java) -12 | [Array Transformation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Array%20Transformation.java) -13 | [Assign Cookies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Assign%20Cookies.java) -14 | [Available Captures for Rook](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Available%20Captures%20for%20Rook.java) -15 | [Average Salary Excluding the Minimum and Maximum Salary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Average%20Salary%20Excluding%20the%20Minimum%20and%20Maximum%20Salary.java) -16 | [Average Value of Even Numbers That Are Divisible by Three](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Average%20Value%20of%20Even%20Numbers%20That%20Are%20Divisible%20by%20Three.java) -17 | [Average of Levels in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Average%20of%20Levels%20in%20Binary%20Tree.java) -18 | [Backspace String Compare](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Backspace%20String%20Compare.java) -19 | [Balanced Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Balanced%20Binary%20Tree.java) -20 | [Base 7](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Base%207.java) -21 | [Baseball Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Baseball%20Game.java) -22 | [Best Poker Hand](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Best%20Poker%20Hand.java) -23 | [Best Time to Buy and Sell Stock](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Best%20Time%20to%20Buy%20and%20Sell%20Stock.java) -24 | [Binary Gap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Gap.java) -25 | [Binary Number with Alternating Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Number%20with%20Alternating%20Bits.java) -26 | [Binary Prefix Divisible By 5](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Prefix%20Divisible%20By%205.java) -27 | [Binary Search](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Search.java) -28 | [Binary Tree Inorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Tree%20Inorder%20Traversal.java) -29 | [Binary Tree Level Order Traversal II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Tree%20Level%20Order%20Traversal%20II.java) -30 | [Binary Tree Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Tree%20Paths.java) -31 | [Binary Tree Postorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Tree%20Postorder%20Traversal.java) -32 | [Binary Tree Tilt](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Tree%20Tilt.java) -33 | [Binary Watch](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Watch.java) -34 | [Buddy Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Buddy%20Strings.java) -35 | [Build Array from Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Build%20Array%20from%20Permutation.java) -36 | [Build an Array With Stack Operations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Build%20an%20Array%20With%20Stack%20Operations.java) -37 | [Bulls and Cows](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Bulls%20and%20Cows.java) -38 | [Calculate Amount Paid in Taxes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Calculate%20Amount%20Paid%20in%20Taxes.java) -39 | [Calculate Delayed Arrival Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Calculate%20Delayed%20Arrival%20Time.java) -40 | [Calculate Digit Sum of a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Calculate%20Digit%20Sum%20of%20a%20String.java) -41 | [Calculate Money in Leetcode Bank](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Calculate%20Money%20in%20Leetcode%20Bank.java) -42 | [Can Make Arithmetic Progression From Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Can%20Make%20Arithmetic%20Progression%20From%20Sequence.java) -43 | [Can Place Flowers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Can%20Place%20Flowers.java) -44 | [Capitalize the Title](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Capitalize%20the%20Title.java) -45 | [Categorize Box According to Criteria](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Categorize%20Box%20According%20to%20Criteria.java) -46 | [Cells in a Range on an Excel Sheet](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Cells%20in%20a%20Range%20on%20an%20Excel%20Sheet.java) -47 | [Cells with Odd Values in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Cells%20with%20Odd%20Values%20in%20a%20Matrix.java) -48 | [Check Array Formation Through Concatenation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20Array%20Formation%20Through%20Concatenation.java) -49 | [Check Distances Between Same Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20Distances%20Between%20Same%20Letters.java) -50 | [Check If It Is a Straight Line](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20It%20Is%20a%20Straight%20Line.java) -51 | [Check If N and Its Double Exist](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20N%20and%20Its%20Double%20Exist.java) -52 | [Check If String Is a Prefix of Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20String%20Is%20a%20Prefix%20of%20Array.java) -53 | [Check If Two String Arrays are Equivalent](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20Two%20String%20Arrays%20are%20Equivalent.java) -54 | [Check If a Number Is Majority Element in a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20a%20Number%20Is%20Majority%20Element%20in%20a%20Sorted%20Array.java) -55 | [Check If a Word Occurs As a Prefix of Any Word in a Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20a%20Word%20Occurs%20As%20a%20Prefix%20of%20Any%20Word%20in%20a%20Sentence.java) -56 | [Check Whether Two Strings are Almost Equivalent](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20Whether%20Two%20Strings%20are%20Almost%20Equivalent.java) -57 | [Check if All A's Appears Before All B's](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20All%20A's%20Appears%20Before%20All%20B's.java) -58 | [Check if All Characters Have Equal Number of Occurrences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20All%20Characters%20Have%20Equal%20Number%20of%20Occurrences.java) -59 | [Check if All the Integers in a Range Are Covered](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20All%20the%20Integers%20in%20a%20Range%20Are%20Covered.java) -60 | [Check if Array Is Sorted and Rotated](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Array%20Is%20Sorted%20and%20Rotated.java) -61 | [Check if Binary String Has at Most One Segment of Ones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Binary%20String%20Has%20at%20Most%20One%20Segment%20of%20Ones.java) -62 | [Check if Every Row and Column Contains All Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Every%20Row%20and%20Column%20Contains%20All%20Numbers.java) -63 | [Check if Matrix Is X-Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Matrix%20Is%20X-Matrix.java) -64 | [Check if Number Has Equal Digit Count and Digit Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Number%20Has%20Equal%20Digit%20Count%20and%20Digit%20Value.java) -65 | [Check if Numbers Are Ascending in a Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Numbers%20Are%20Ascending%20in%20a%20Sentence.java) -66 | [Check if One String Swap Can Make Strings Equal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20One%20String%20Swap%20Can%20Make%20Strings%20Equal.java) -67 | [Check if String Is Decomposable Into Value-Equal Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20String%20Is%20Decomposable%20Into%20Value-Equal%20Substrings.java) -68 | [Check if Word Equals Summation of Two Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Word%20Equals%20Summation%20of%20Two%20Words.java) -69 | [Check if an Array Is Consecutive](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20an%20Array%20Is%20Consecutive.java) -70 | [Check if the Sentence Is Pangram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20the%20Sentence%20Is%20Pangram.java) -71 | [Circular Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Circular%20Sentence.java) -72 | [Climbing Stairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Climbing%20Stairs.java) -73 | [Closest Binary Search Tree Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Closest%20Binary%20Search%20Tree%20Value.java) -74 | [Compare Strings by Frequency of the Smallest Character](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Compare%20Strings%20by%20Frequency%20of%20the%20Smallest%20Character.java) -75 | [Complement of Base 10 Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Complement%20of%20Base%2010%20Integer.java) -76 | [Concatenation of Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Concatenation%20of%20Array.java) -77 | [Confusing Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Confusing%20Number.java) -78 | [Consecutive Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Consecutive%20Characters.java) -79 | [Construct String from Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Construct%20String%20from%20Binary%20Tree.java) -80 | [Construct the rectangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Construct%20the%20rectangle.java) -81 | [Contains Duplicate II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Contains%20Duplicate%20II.java) -82 | [Contains Duplicate](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Contains%20Duplicate.java) -83 | [Convert 1D Array Into 2D Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%201D%20Array%20Into%202D%20Array.java) -84 | [Convert BST to Greater Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%20BST%20to%20Greater%20Tree.java) -85 | [Convert Binary Number in a Linked List to Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%20Binary%20Number%20in%20a%20Linked%20List%20to%20Integer.java) -86 | [Convert Sorted Array To Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%20Sorted%20Array%20To%20Binary%20Search%20Tree.java) -87 | [Convert a number to hexadecimal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%20a%20number%20to%20hexadecimal.java) -88 | [Convert the Temperature](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%20the%20Temperature.java) -89 | [Count Asterisks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Asterisks.java) -90 | [Count Binary Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Binary%20Substrings.java) -91 | [Count Common Words With One Occurrence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Common%20Words%20With%20One%20Occurrence.java) -92 | [Count Distinct Numbers on Board](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Distinct%20Numbers%20on%20Board.java) -93 | [Count Elements With Strictly Smaller and Greater Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Elements%20With%20Strictly%20Smaller%20and%20Greater%20Elements.java) -94 | [Count Equal and Divisible Pairs in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Equal%20and%20Divisible%20Pairs%20in%20an%20Array.java) -95 | [Count Good Triplets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Good%20Triplets.java) -96 | [Count Hills and Valleys in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Hills%20and%20Valleys%20in%20an%20Array.java) -97 | [Count Integers With Even Digit Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Integers%20With%20Even%20Digit%20Sum.java) -98 | [Count Items Matching a Rule](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Items%20Matching%20a%20Rule.java) -99 | [Count Largest Group](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Largest%20Group.java) -100 | [Count Negative Numbers in a Sorted Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Negative%20Numbers%20in%20a%20Sorted%20Matrix.java) -101 | [Count Number of Pairs With Absolute Difference K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Number%20of%20Pairs%20With%20Absolute%20Difference%20K.java) -102 | [Count Odd Numbers in an Interval Range](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Odd%20Numbers%20in%20an%20Interval%20Range.java) -103 | [Count Operations to Obtain Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Operations%20to%20Obtain%20Zero.java) -104 | [Count Pairs Of Similar Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Pairs%20Of%20Similar%20Strings.java) -105 | [Count Prefixes of a Given String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Prefixes%20of%20a%20Given%20String.java) -106 | [Count Primes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Primes.java) -107 | [Count Special Quadruplets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Special%20Quadruplets.java) -108 | [Count Square Sum Triples](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Square%20Sum%20Triples.java) -109 | [Count Substrings with Only One Distinct Letter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Substrings%20with%20Only%20One%20Distinct%20Letter.java) -110 | [Count Vowel Substrings of a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Vowel%20Substrings%20of%20a%20String.java) -111 | [Count of Matches in Tournament](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20of%20Matches%20in%20Tournament.java) -112 | [Count the Digits That Divide a Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20the%20Digits%20That%20Divide%20a%20Number.java) -113 | [Count the Number of Consistent Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20the%20Number%20of%20Consistent%20Strings.java) -114 | [Count the Number of Vowel Strings in Range](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20the%20Number%20of%20Vowel%20Strings%20in%20Range.java) -115 | [Counting Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Counting%20Bits.java) -116 | [Counting Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Counting%20Elements.java) -117 | [Counting Words With a Given Prefix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Counting%20Words%20With%20a%20Given%20Prefix.java) -118 | [Cousins in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Cousins%20in%20Binary%20Tree.java) -119 | [Crawler Log Folder](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Crawler%20Log%20Folder.java) -120 | [Create Target Array in the Given Order](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Create%20Target%20Array%20in%20the%20Given%20Order.java) -121 | [DI String Match](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/DI%20String%20Match.java) -122 | [Day of the Week](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Day%20of%20the%20Week.java) -123 | [Day of the Year](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Day%20of%20the%20Year.java) -124 | [Decode XORed Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Decode%20XORed%20Array.java) -125 | [Decode the Message](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Decode%20the%20Message.java) -126 | [Decompress Run-Length Encoded List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Decompress%20Run-Length%20Encoded%20List.java) -127 | [Decrypt String from Alphabet to Integer Mapping](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Decrypt%20String%20from%20Alphabet%20to%20Integer%20Mapping.java) -128 | [Defanging an IP Address](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Defanging%20an%20IP%20Address.java) -129 | [Defuse the Bomb](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Defuse%20the%20Bomb.java) -130 | [Degree of an array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Degree%20of%20an%20array.java) -131 | [Delete Characters to Make Fancy String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20Characters%20to%20Make%20Fancy%20String.java) -132 | [Delete Columns to Make Sorted](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20Columns%20to%20Make%20Sorted.java) -133 | [Delete N Nodes After M Nodes of a Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20N%20Nodes%20After%20M%20Nodes%20of%20a%20Linked%20List.java) -134 | [Delete Node in a Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20Node%20in%20a%20Linked%20List.java) -135 | [Design Compressed String Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20Compressed%20String%20Iterator.java) -136 | [Design HashMap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20HashMap.java) -137 | [Design HashSet](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20HashSet.java) -138 | [Design Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20Linked%20List.java) -139 | [Design Parking System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20Parking%20System.java) -140 | [Design an Ordered Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20an%20Ordered%20Stream.java) -141 | [Design an Ordered System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20an%20Ordered%20System.java) -142 | [Destination City](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Destination%20City.java) -143 | [Detect Capital](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Detect%20Capital.java) -144 | [Detect Pattern of Length M Repeated K or More Times](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Detect%20Pattern%20of%20Length%20M%20Repeated%20K%20or%20More%20Times.java) -145 | [Determine Color of a Chessboard Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Determine%20Color%20of%20a%20Chessboard%20Square.java) -146 | [Determine Whether Matrix Can Be Obtained By Rotation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Determine%20Whether%20Matrix%20Can%20Be%20Obtained%20By%20Rotation.java) -147 | [Determine if String Halves Are Alike](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Determine%20if%20String%20Halves%20Are%20Alike.java) -148 | [Determine if Two Events Have Conflict](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Determine%20if%20Two%20Events%20Have%20Conflict.java) -149 | [Diameter of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Diameter%20of%20Binary%20Tree.java) -150 | [Diet Plan Performance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Diet%20Plan%20Performance.java) -151 | [Difference Between Element Sum and Digit Sum of an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Difference%20Between%20Element%20Sum%20and%20Digit%20Sum%20of%20an%20Array.java) -152 | [Distance Between Bus Stops](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Distance%20Between%20Bus%20Stops.java) -153 | [Distribute Candies to People](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Distribute%20Candies%20to%20People.java) -154 | [Distribute Candies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Distribute%20Candies.java) -155 | [Distribute Money to Maximum Children](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Distribute%20Money%20to%20Maximum%20Children.java) -156 | [Divide Array Into Equal Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Divide%20Array%20Into%20Equal%20Pairs.java) -157 | [Divide a String Into Groups of Size k](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Divide%20a%20String%20Into%20Groups%20of%20Size%20k.java) -158 | [Divisor Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Divisor%20Game.java) -159 | [Duplicate Zeros](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Duplicate%20Zeros.java) -160 | [Element Appearing More Than 25% In Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Element%20Appearing%20More%20Than%2025%%20In%20Sorted%20Array.java) -161 | [Employee Importance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Employee%20Importance.java) -162 | [Evaluate Boolean Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Evaluate%20Boolean%20Binary%20Tree.java) -163 | [Excel Sheet Column Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Excel%20Sheet%20Column%20Number.java) -164 | [Excel Sheet Column Title](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Excel%20Sheet%20Column%20Title.java) -165 | [Factorial Trailing Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Factorial%20Trailing%20Zeroes.java) -166 | [Fair Candy Swap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fair%20Candy%20Swap.java) -167 | [Fibonacci Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fibonacci%20Number.java) -168 | [Final Prices With a Special Discount in a Shop](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Final%20Prices%20With%20a%20Special%20Discount%20in%20a%20Shop.java) -169 | [Final Value of Variable After Performing Operations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Final%20Value%20of%20Variable%20After%20Performing%20Operations.java) -170 | [Find All K-Distant Indices in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20All%20K-Distant%20Indices%20in%20an%20Array.java) -171 | [Find All Numbers Disappeared in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20All%20Numbers%20Disappeared%20in%20an%20Array.java) -172 | [Find All the Lonely Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20All%20the%20Lonely%20Nodes.java) -173 | [Find Anagram Mappings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Anagram%20Mappings.java) -174 | [Find Closest Number to Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Closest%20Number%20to%20Zero.java) -175 | [Find Common Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Common%20Characters.java) -176 | [Find First Palindromic String in the Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20First%20Palindromic%20String%20in%20the%20Array.java) -177 | [Find Greatest Common Divisor of Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Greatest%20Common%20Divisor%20of%20Array.java) -178 | [Find Lucky Integer in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Lucky%20Integer%20in%20an%20Array.java) -179 | [Find Mode in Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Mode%20in%20Binary%20Search%20Tree.java) -180 | [Find N Unique Integers Sum up to Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20N%20Unique%20Integers%20Sum%20up%20to%20Zero.java) -181 | [Find Nearest Point That Has the Same X or Y Coordinate](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Nearest%20Point%20That%20Has%20the%20Same%20X%20or%20Y%20Coordinate.java) -182 | [Find Numbers with Even Number of Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Numbers%20with%20Even%20Number%20of%20Digits.java) -183 | [Find Pivot Index](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Pivot%20Index.java) -184 | [Find Positive Integer Solution for a Given Equation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Positive%20Integer%20Solution%20for%20a%20Given%20Equation.java) -185 | [Find Resultant Array After Removing Anagrams](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Resultant%20Array%20After%20Removing%20Anagrams.java) -186 | [Find Smallest Letter Greater Than Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Smallest%20Letter%20Greater%20Than%20Target.java) -187 | [Find Subarrays With Equal Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Subarrays%20With%20Equal%20Sum.java) -188 | [Find Target Indices After Sorting Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Target%20Indices%20After%20Sorting%20Array.java) -189 | [Find Winner on a Tic Tac Toe Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Winner%20on%20a%20Tic%20Tac%20Toe%20Game.java) -190 | [Find Words That Can Be Formed by Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Words%20That%20Can%20Be%20Formed%20by%20Characters.java) -191 | [Find if Path Exists in Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20if%20Path%20Exists%20in%20Graph.java) -192 | [Find the Array Concatenation Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Array%20Concatenation%20Value.java) -193 | [Find the Difference of Two Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Difference%20of%20Two%20Arrays.java) -194 | [Find the Distance Value Between Two Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Distance%20Value%20Between%20Two%20Arrays.java) -195 | [Find the Highest Altitude](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Highest%20Altitude.java) -196 | [Find the K-Beauty of a Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20K-Beauty%20of%20a%20Number.java) -197 | [Find the Longest Balanced Substring of a Binary String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Longest%20Balanced%20Substring%20of%20a%20Binary%20String.java) -198 | [Find the Middle Index in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Middle%20Index%20in%20Array.java) -199 | [Find the Town Judge](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Town%20Judge.java) -200 | [Find the Width of Columns of a Grid](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Width%20of%20Columns%20of%20a%20Grid.java) -201 | [Find the difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20difference.java) -202 | [Finding 3-Digit Even Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Finding%203-Digit%20Even%20Numbers.java) -203 | [First Bad Version](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/First%20Bad%20Version.java) -204 | [First Letter to Appear Twice](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/First%20Letter%20to%20Appear%20Twice.java) -205 | [First Unique Character in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/First%20Unique%20Character%20in%20a%20String.java) -206 | [Fixed Point](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fixed%20Point.java) -207 | [Fizz Buzz](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fizz%20Buzz.java) -208 | [Flip Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flip%20Game.java) -209 | [Flipping an Image](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flipping%20an%20Image.java) -210 | [Flood Fill](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flood%20Fill.java) -211 | [Flower Planting With No Adjacent](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flower%20Planting%20With%20No%20Adjacent.java) -212 | [Form Smallest Number From Two Digit Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Form%20Smallest%20Number%20From%20Two%20Digit%20Arrays.java) -213 | [Generate a String With Characters That Have Odd Counts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Generate%20a%20String%20With%20Characters%20That%20Have%20Odd%20Counts.java) -214 | [Get Maximum in Generated Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Get%20Maximum%20in%20Generated%20Array.java) -215 | [Goal Parser Interpretation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Goal%20Parser%20Interpretation.java) -216 | [Goat Latin](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Goat%20Latin.java) -217 | [Greatest Common Divisor of Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Greatest%20Common%20Divisor%20of%20Strings.java) -218 | [Greatest English Letter in Upper and Lower Case](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Greatest%20English%20Letter%20in%20Upper%20and%20Lower%20Case.java) -219 | [Groups of Special-Equivalent Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Groups%20of%20Special-Equivalent%20Strings.java) -220 | [Guess Number Higher or Lower](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Guess%20Number%20Higher%20or%20Lower.java) -221 | [Hamming Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Hamming%20Distance.java) -222 | [Happy Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Happy%20Number.java) -223 | [Heaters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Heaters.java) -224 | [Height Checker](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Height%20Checker.java) -225 | [Hexspeak](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Hexspeak.java) -226 | [High Five](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/High%20Five.java) -227 | [How Many Apples Can You Put into the Basket](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/How%20Many%20Apples%20Can%20You%20Put%20into%20the%20Basket.java) -228 | [How Many Numbers Are Smaller Than the Current Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/How%20Many%20Numbers%20Are%20Smaller%20Than%20the%20Current%20Number.java) -229 | [Image Smoother](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Image%20Smoother.java) -230 | [Implement Queue using Stacks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Implement%20Queue%20using%20Stacks.java) -231 | [Implement Stack using Queues](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Implement%20Stack%20using%20Queues.java) -232 | [Implement strStr](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Implement%20strStr.java) -233 | [Increasing Decreasing String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Increasing%20Decreasing%20String.java) -234 | [Increasing Order Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Increasing%20Order%20Search%20Tree.java) -235 | [Index Pairs of a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Index%20Pairs%20of%20a%20String.java) -236 | [Intersection of Multiple Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20Multiple%20Arrays.java) -237 | [Intersection of Three Sorted Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20Three%20Sorted%20Arrays.java) -238 | [Intersection of Two Arrays II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20Two%20Arrays%20II.java) -239 | [Intersection of Two Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20Two%20Arrays.java) -240 | [Intersection of two Linked Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20two%20Linked%20Lists.java) -241 | [Invert Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Invert%20Binary%20Tree.java) -242 | [Is Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Is%20Subsequence.java) -243 | [Island Perimeter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Island%20Perimeter.java) -244 | [Isomorphic Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Isomorphic%20Strings.java) -245 | [Jewels and Stones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Jewels%20and%20Stones.java) -246 | [Judge Route Cycle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Judge%20Route%20Cycle.java) -247 | [K Items With the Maximum Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/K%20Items%20With%20the%20Maximum%20Sum.java) -248 | [K-diff Pairs in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/K-diff%20Pairs%20in%20an%20Array.java) -249 | [Keep Multiplying Found Values by Two](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Keep%20Multiplying%20Found%20Values%20by%20Two.java) -250 | [Keyboard Row](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Keyboard%20Row.java) -251 | [Kids With the Greatest Number of Candies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Kids%20With%20the%20Greatest%20Number%20of%20Candies.java) -252 | [Kth Distinct String in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Kth%20Distinct%20String%20in%20an%20Array.java) -253 | [Kth Largest Element in a Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Kth%20Largest%20Element%20in%20a%20Stream.java) -254 | [Kth Missing Positive Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Kth%20Missing%20Positive%20Number.java) -255 | [Largest 3-Same-Digit Number in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%203-Same-Digit%20Number%20in%20String.java) -256 | [Largest Local Values in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Local%20Values%20in%20a%20Matrix.java) -257 | [Largest Number After Digit Swaps by Parity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Number%20After%20Digit%20Swaps%20by%20Parity.java) -258 | [Largest Number At Least Twice of Others](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Number%20At%20Least%20Twice%20of%20Others.java) -259 | [Largest Odd Number in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Odd%20Number%20in%20String.java) -260 | [Largest Perimeter Triangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Perimeter%20Triangle.java) -261 | [Largest Positive Integer That Exists With Its Negative](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Positive%20Integer%20That%20Exists%20With%20Its%20Negative.java) -262 | [Largest Substring Between Two Equal Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Substring%20Between%20Two%20Equal%20Characters.java) -263 | [Largest Triangle Area](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Triangle%20Area.java) -264 | [Largest Unique Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Unique%20Number.java) -265 | [Last Stone Weight](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Last%20Stone%20Weight.java) -266 | [Latest Time by Replacing Hidden Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Latest%20Time%20by%20Replacing%20Hidden%20Digits.java) -267 | [Leaf-Similar Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Leaf-Similar%20Trees.java) -268 | [Left and Right Sum Differences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Left%20and%20Right%20Sum%20Differences.java) -269 | [Lemonade Change](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Lemonade%20Change.java) -270 | [Length of last word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Length%20of%20last%20word.java) -271 | [Letter Case Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Letter%20Case%20Permutation.java) -272 | [License Key Formatting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/License%20Key%20Formatting.java) -273 | [Linked List Cycle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Linked%20List%20Cycle.java) -274 | [Logger Rate Limiter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Logger%20Rate%20Limiter.java) -275 | [Long Pressed Name](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Long%20Pressed%20Name.java) -276 | [Longer Contiguous Segments of Ones than Zeros](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longer%20Contiguous%20Segments%20of%20Ones%20than%20Zeros.java) -277 | [Longest Common Prefix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Common%20Prefix.java) -278 | [Longest Continuous Increasing Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Continuous%20Increasing%20Subsequence.java) -279 | [Longest Harmonious Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Harmonious%20Subsequence.java) -280 | [Longest Nice Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Nice%20Substring.java) -281 | [Longest Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Palindrome.java) -282 | [Longest Subsequence With Limited Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Subsequence%20With%20Limited%20Sum.java) -283 | [Longest Uncommon Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Uncommon%20Subsequence.java) -284 | [Longest Univalue Path](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Univalue%20Path.java) -285 | [Longest Word in Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Word%20in%20Dictionary.java) -286 | [Lowest Common Ancestor of a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Lowest%20Common%20Ancestor%20of%20a%20Binary%20Search%20Tree.java) -287 | [Lucky Numbers in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Lucky%20Numbers%20in%20a%20Matrix.java) -288 | [Magic Squares In Grid](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Magic%20Squares%20In%20Grid.java) -289 | [Majority Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Majority%20Element.java) -290 | [Make Array Zero by Subtracting Equal Amounts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Make%20Array%20Zero%20by%20Subtracting%20Equal%20Amounts.java) -291 | [Make The String Great](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Make%20The%20String%20Great.java) -292 | [Matrix Cells in Distance Order](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Matrix%20Cells%20in%20Distance%20Order.java) -293 | [Matrix Diagonal Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Matrix%20Diagonal%20Sum.java) -294 | [Max Consecutive Ones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Max%20Consecutive%20Ones.java) -295 | [Maximize Sum Of Array After K Negations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximize%20Sum%20Of%20Array%20After%20K%20Negations.java) -296 | [Maximum 69 Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%2069%20Number.java) -297 | [Maximum Ascending Subarray Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Ascending%20Subarray%20Sum.java) -298 | [Maximum Average Subarray I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Average%20Subarray%20I.java) -299 | [Maximum Count of Positive Integer and Negative Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Count%20of%20Positive%20Integer%20and%20Negative%20Integer.java) -300 | [Maximum Depth of N-ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Depth%20of%20N-ary%20Tree.java) -301 | [Maximum Difference Between Increasing Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Difference%20Between%20Increasing%20Elements.java) -302 | [Maximum Difference by Remapping a Digit](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Difference%20by%20Remapping%20a%20Digit.java) -303 | [Maximum Distance in Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Distance%20in%20Arrays.java) -304 | [Maximum Enemy Forts That Can Be Captured](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Enemy%20Forts%20That%20Can%20Be%20Captured.java) -305 | [Maximum Nesting Depth of the Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Nesting%20Depth%20of%20the%20Parentheses.java) -306 | [Maximum Number of Balloons](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Balloons.java) -307 | [Maximum Number of Balls in a Box](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Balls%20in%20a%20Box.java) -308 | [Maximum Number of Pairs in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Pairs%20in%20Array.java) -309 | [Maximum Number of Words Found in Sentences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Words%20Found%20in%20Sentences.java) -310 | [Maximum Number of Words You Can Type](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Words%20You%20Can%20Type.java) -311 | [Maximum Population Year](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Population%20Year.java) -312 | [Maximum Product Difference Between Two Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Product%20Difference%20Between%20Two%20Pairs.java) -313 | [Maximum Product of Three Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Product%20of%20Three%20Numbers.java) -314 | [Maximum Product of Two Elements in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Product%20of%20Two%20Elements%20in%20an%20Array.java) -315 | [Maximum Repeating Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Repeating%20Substring.java) -316 | [Maximum Subarray Sum I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Subarray%20Sum%20I.java) -317 | [Maximum Sum With Exactly K Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Sum%20With%20Exactly%20K%20Elements.java) -318 | [Maximum Units on a Truck](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Units%20on%20a%20Truck.java) -319 | [Maximum Value of a String in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Value%20of%20a%20String%20in%20an%20Array.java) -320 | [Maximum depth of Binary tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20depth%20of%20Binary%20tree.java) -321 | [Mean of Array After Removing Some Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Mean%20of%20Array%20After%20Removing%20Some%20Elements.java) -322 | [Meeting Rooms](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Meeting%20Rooms.java) -323 | [Merge Similar Items](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Similar%20Items.java) -324 | [Merge Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Sorted%20Array.java) -325 | [Merge Strings Alternately](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Strings%20Alternately.java) -326 | [Merge Two 2D Arrays by Summing Values](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Two%202D%20Arrays%20by%20Summing%20Values.java) -327 | [Merge Two Sorted Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Two%20Sorted%20Lists.java) -328 | [Merge two binary trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20two%20binary%20trees.java) -329 | [Middle of the linked list](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Middle%20of%20the%20linked%20list.java) -330 | [Min Cost Climbing Stairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Min%20Cost%20Climbing%20Stairs.java) -331 | [Min Max Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Min%20Max%20Game.java) -332 | [Minimum Absolute Difference in BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20%20Absolute%20Difference%20in%20BST.java) -333 | [Minimum Absolute Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Absolute%20Difference.java) -334 | [Minimum Amount of Time to Fill Cups](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Amount%20of%20Time%20to%20Fill%20Cups.java) -335 | [Minimum Bit Flips to Convert Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Bit%20Flips%20to%20Convert%20Number.java) -336 | [Minimum Changes To Make Alternating Binary String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Changes%20To%20Make%20Alternating%20Binary%20String.java) -337 | [Minimum Common Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Common%20Value.java) -338 | [Minimum Cost of Buying Candies With Discount](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Cost%20of%20Buying%20Candies%20With%20Discount.java) -339 | [Minimum Cost to Move Chips to The Same Position](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Cost%20to%20Move%20Chips%20to%20The%20Same%20Position.java) -340 | [Minimum Cuts to Divide a Circle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Cuts%20to%20Divide%20a%20Circle.java) -341 | [Minimum Depth of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Depth%20of%20a%20Binary%20Tree.java) -342 | [Minimum Difference Between Highest and Lowest of K Scores](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Difference%20Between%20Highest%20and%20Lowest%20of%20K%20Scores.java) -343 | [Minimum Distance Between BST Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Distance%20Between%20BST%20Nodes.java) -344 | [Minimum Distance to the Target Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Distance%20to%20the%20Target%20Element.java) -345 | [Minimum Hours of Training to Win a Competition](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Hours%20of%20Training%20to%20Win%20a%20Competition.java) -346 | [Minimum Index Sum of Two Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Index%20Sum%20of%20Two%20Lists.java) -347 | [Minimum Moves to Convert String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Moves%20to%20Convert%20String.java) -348 | [Minimum Moves to Equal an Array Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Moves%20to%20Equal%20an%20Array%20Element.java) -349 | [Minimum Number of Moves to Seat Everyone](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Number%20of%20Moves%20to%20Seat%20Everyone.java) -350 | [Minimum Number of Operations to Convert Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Number%20of%20Operations%20to%20Convert%20Time.java) -351 | [Minimum Operations to Make the Array Increasing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Operations%20to%20Make%20the%20Array%20Increasing.java) -352 | [Minimum Recolors to Get K Consecutive Black Blocks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Recolors%20to%20Get%20K%20Consecutive%20Black%20Blocks.java) -353 | [Minimum Subsequence in Non-Increasing Order](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Subsequence%20in%20Non-Increasing%20Order.java) -354 | [Minimum Sum of Four Digit Number After Splitting Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Sum%20of%20Four%20Digit%20Number%20After%20Splitting%20Digits.java) -355 | [Minimum Time Visiting All Points](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Time%20Visiting%20All%20Points.java) -356 | [Minimum Time to Type Word Using Special Typewriter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Time%20to%20Type%20Word%20Using%20Special%20Typewriter.java) -357 | [Minimum Value to Get Positive Step by Step Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Value%20to%20Get%20Positive%20Step%20by%20Step%20Sum.java) -358 | [Minimum_index_sum_of_two_lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum_index_sum_of_two_lists.java) -359 | [Missing Number In Arithmetic Progression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Missing%20Number%20In%20Arithmetic%20Progression.java) -360 | [Missing Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Missing%20Number.java) -361 | [Missing Ranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Missing%20Ranges.java) -362 | [Monotonic Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Monotonic%20Array.java) -363 | [Most Common Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Most%20Common%20Word.java) -364 | [Most Frequent Even Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Most%20Frequent%20Even%20Element.java) -365 | [Most Frequent Number Following Key In an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Most%20Frequent%20Number%20Following%20Key%20In%20an%20Array.java) -366 | [Most Visited Sector in a Circular Track](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Most%20Visited%20Sector%20in%20a%20Circular%20Track.java) -367 | [Move Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Move%20Zeroes.java) -368 | [Moving Average from Data Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Moving%20Average%20from%20Data%20Stream.java) -369 | [N-Repeated Element in Size 2N Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-Repeated%20Element%20in%20Size%202N%20Array.java) -370 | [N-ary Tree Postorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-ary%20Tree%20Postorder%20Traversal.java) -371 | [N-ary Tree Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-ary%20Tree%20Preorder%20Traversal.java) -372 | [N-th Tribonacci Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-th%20Tribonacci%20Number.java) -373 | [Nested List Weight Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Nested%20List%20Weight%20Sum.java) -374 | [Next Greater Element I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Next%20Greater%20Element%20I.java) -375 | [Next Greater Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Next%20Greater%20Element.java) -376 | [Nim Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Nim%20Game.java) -377 | [Number Complement](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20Complement.java) -378 | [Number Of Rectangles That Can Form The Largest Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20Of%20Rectangles%20That%20Can%20Form%20The%20Largest%20Square.java) -379 | [Number of 1 bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%201%20bits.java) -380 | [Number of Arithmetic Triplets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Arithmetic%20Triplets.java) -381 | [Number of Boomerangs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Boomerangs.java) -382 | [Number of Common Factors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Common%20Factors.java) -383 | [Number of Days Between Two Dates](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Days%20Between%20Two%20Dates.java) -384 | [Number of Days in a Month](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Days%20in%20a%20Month.java) -385 | [Number of Different Integers in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Different%20Integers%20in%20a%20String.java) -386 | [Number of Distinct Averages](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Distinct%20Averages.java) -387 | [Number of Equivalent Domino Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Equivalent%20Domino%20Pairs.java) -388 | [Number of Good Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Good%20Pairs.java) -389 | [Number of Lines To Write String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Lines%20To%20Write%20String.java) -390 | [Number of Recent Calls](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Recent%20Calls.java) -391 | [Number of Steps to Reduce a Number to Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Steps%20to%20Reduce%20a%20Number%20to%20Zero.java) -392 | [Number of Strings That Appear as Substrings in Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Strings%20That%20Appear%20as%20Substrings%20in%20Word.java) -393 | [Number of Students Doing Homework at a Given Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Students%20Doing%20Homework%20at%20a%20Given%20Time.java) -394 | [Number of Students Unable to Eat Lunch](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Students%20Unable%20to%20Eat%20Lunch.java) -395 | [Number of Unequal Triplets in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Unequal%20Triplets%20in%20Array.java) -396 | [Number of Valid Words in a Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Valid%20Words%20in%20a%20Sentence.java) -397 | [Number of segments in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20segments%20in%20a%20String.java) -398 | [Occurrences After Bigram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Occurrences%20After%20Bigram.java) -399 | [Odd String Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Odd%20String%20Difference.java) -400 | [Paint Fence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Paint%20Fence.java) -401 | [Paint House](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Paint%20House.java) -402 | [Pairs of Songs With Total Durations Divisible by 60](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Pairs%20of%20Songs%20With%20Total%20Durations%20Divisible%20by%2060.java) -403 | [Palindrome Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Palindrome%20Linked%20List.java) -404 | [Palindrome Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Palindrome%20Number.java) -405 | [Palindrome Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Palindrome%20Permutation.java) -406 | [Partition Array Into Three Parts With Equal Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Partition%20Array%20Into%20Three%20Parts%20With%20Equal%20Sum.java) -407 | [Pascal's Triangle II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Pascal's%20Triangle%20II.java) -408 | [Pascal's Triangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Pascal's%20Triangle.java) -409 | [Pass the Pillow](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Pass%20the%20Pillow.java) -410 | [Path Crossing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Path%20Crossing.java) -411 | [Path In Zigzag Labelled Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Path%20In%20Zigzag%20Labelled%20Binary%20Tree.java) -412 | [Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Path%20Sum.java) -413 | [Peak Index in a Mountain Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Peak%20Index%20in%20a%20Mountain%20Array.java) -414 | [Percentage of Letter in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Percentage%20of%20Letter%20in%20String.java) -415 | [Perfect Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Perfect%20Number.java) -416 | [Perform String Shifts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Perform%20String%20Shifts.java) -417 | [Plus One](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Plus%20One.java) -418 | [Positions of Large Groups](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Positions%20of%20Large%20Groups.java) -419 | [Power of Four](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Power%20of%20Four.java) -420 | [Power of Three](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Power%20of%20Three.java) -421 | [Power of Two](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Power%20of%20Two.java) -422 | [Powerful Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Powerful%20Integers.java) -423 | [Prime In Diagonal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Prime%20In%20Diagonal.java) -424 | [Projection Area of 3D Shapes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Projection%20Area%20of%203D%20Shapes.java) -425 | [Range Sum Query Immutable](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Range%20Sum%20Query%20Immutable.java) -426 | [Range Sum of BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Range%20Sum%20of%20BST.java) -427 | [Rank Transform of an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rank%20Transform%20of%20an%20Array.java) -428 | [Ransom Note](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Ransom%20Note.java) -429 | [Read N characters Given Read4](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Read%20N%20characters%20Given%20Read4.java) -430 | [Rearrange Characters to Make Target String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rearrange%20Characters%20to%20Make%20Target%20String.java) -431 | [Rearrange Spaces Between Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rearrange%20Spaces%20Between%20Words.java) -432 | [Rectangle Overlap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rectangle%20Overlap.java) -433 | [Redistribute Characters to Make All Strings Equal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Redistribute%20Characters%20to%20Make%20All%20Strings%20Equal.java) -434 | [Reformat Date](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reformat%20Date.java) -435 | [Reformat Phone Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reformat%20Phone%20Number.java) -436 | [Reformat The String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reformat%20The%20String.java) -437 | [Relative Sort Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Relative%20Sort%20Array.java) -438 | [Relative ranks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Relative%20ranks.java) -439 | [Remove All Adjacent Duplicates In String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20All%20Adjacent%20Duplicates%20In%20String.java) -440 | [Remove Digit From Number to Maximize Result](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Digit%20From%20Number%20to%20Maximize%20Result.java) -441 | [Remove Duplicates From Sorted Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Duplicates%20From%20Sorted%20Lists.java) -442 | [Remove Duplicates from Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Duplicates%20from%20Sorted%20Array.java) -443 | [Remove Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Element.java) -444 | [Remove Letter To Equalize Frequency](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Letter%20To%20Equalize%20Frequency.java) -445 | [Remove Linked List Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Linked%20List%20Elements.java) -446 | [Remove One Element to Make the Array Strictly Increasing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20One%20Element%20to%20Make%20the%20Array%20Strictly%20Increasing.java) -447 | [Remove Outermost Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Outermost%20Parentheses.java) -448 | [Remove Palindromic Subsequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Palindromic%20Subsequences.java) -449 | [Remove Vowels from a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Vowels%20from%20a%20String.java) -450 | [Repeated String Match](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Repeated%20String%20Match.java) -451 | [Repeated Substring Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Repeated%20Substring%20Pattern.java) -452 | [Replace All ?'s to Avoid Consecutive Repeating Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Replace%20All%20?'s%20to%20Avoid%20Consecutive%20Repeating%20Characters.java) -453 | [Replace All Digits with Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Replace%20All%20Digits%20with%20Characters.java) -454 | [Replace Elements with Greatest Element on Right Side](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Replace%20Elements%20with%20Greatest%20Element%20on%20Right%20Side.java) -455 | [Reshape the matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reshape%20the%20matrix.java) -456 | [Reverse Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Bits.java) -457 | [Reverse Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Linked%20List.java) -458 | [Reverse Only Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Only%20Letters.java) -459 | [Reverse Prefix of Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Prefix%20of%20Word.java) -460 | [Reverse String II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20String%20II.java) -461 | [Reverse String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20String.java) -462 | [Reverse Vowels of a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Vowels%20of%20a%20String.java) -463 | [Reverse words in a String III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20words%20in%20a%20String%20III.java) -464 | [Richest Customer Wealth](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Richest%20Customer%20Wealth.java) -465 | [Rings and Rods](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rings%20and%20Rods.java) -466 | [Robot Return to Origin](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Robot%20Return%20to%20Origin.java) -467 | [Roman to Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Roman%20to%20Integer.java) -468 | [Root Equals Sum of Children](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Root%20Equals%20Sum%20of%20Children.java) -469 | [Rotate String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rotate%20String.java) -470 | [Row With Maximum Ones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Row%20With%20Maximum%20Ones.java) -471 | [Running Sum of 1d Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Running%20Sum%20of%201d%20Array.java) -472 | [Same Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Same%20Tree.java) -473 | [Search Insert Position](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Search%20Insert%20Position.java) -474 | [Search in a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Search%20in%20a%20Binary%20Search%20Tree.java) -475 | [Second Largest Digit in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Second%20Largest%20Digit%20in%20a%20String.java) -476 | [Second Minimum Node in a binary tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Second%20Minimum%20Node%20in%20a%20binary%20tree.java) -477 | [Self Dividing Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Self%20Dividing%20Number.java) -478 | [Sentence Similarity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sentence%20Similarity.java) -479 | [Separate the Digits in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Separate%20the%20Digits%20in%20an%20Array.java) -480 | [Set Mismatch](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Set%20Mismatch.java) -481 | [Shortest Completing Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Completing%20Word.java) -482 | [Shortest Distance to Target String in a Circular Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Distance%20to%20Target%20String%20in%20a%20Circular%20Array.java) -483 | [Shortest Distance to a Character](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Distance%20to%20a%20Character.java) -484 | [Shortest Word Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Word%20Distance.java) -485 | [Shuffle String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shuffle%20String.java) -486 | [Shuffle the Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shuffle%20the%20Array.java) -487 | [Sign of the Product of an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sign%20of%20the%20Product%20of%20an%20Array.java) -488 | [Similar RGB Color](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Similar%20RGB%20Color.java) -489 | [Single Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Single%20Number.java) -490 | [Single-Row Keyboard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Single-Row%20Keyboard.java) -491 | [Slowest Key](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Slowest%20Key.java) -492 | [Smallest Even Multiple](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Smallest%20Even%20Multiple.java) -493 | [Smallest Index With Equal Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Smallest%20Index%20With%20Equal%20Value.java) -494 | [Smallest Range I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Smallest%20Range%20I.java) -495 | [Sort Array By Parity II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Array%20By%20Parity%20II.java) -496 | [Sort Array By Parity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Array%20By%20Parity.java) -497 | [Sort Array by Increasing Frequency](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Array%20by%20Increasing%20Frequency.java) -498 | [Sort Even and Odd Indices Independently](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Even%20and%20Odd%20Indices%20Independently.java) -499 | [Sort Integers by The Number of 1 Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Integers%20by%20The%20Number%20of%201%20Bits.java) -500 | [Sort the People](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20the%20People.java) -501 | [Sorting the Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sorting%20the%20Sentence.java) -502 | [Special Array With X Elements Greater Than or Equal X](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Special%20Array%20With%20X%20Elements%20Greater%20Than%20or%20Equal%20X.java) -503 | [Special Positions in a Binary Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Special%20Positions%20in%20a%20Binary%20Matrix.java) -504 | [Split With Minimum Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Split%20With%20Minimum%20Sum.java) -505 | [Split a String in Balanced Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Split%20a%20String%20in%20Balanced%20Strings.java) -506 | [SqrtX](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/SqrtX.java) -507 | [Squares of a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Squares%20of%20a%20Sorted%20Array.java) -508 | [String Matching in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/String%20Matching%20in%20an%20Array.java) -509 | [String Without AAA or BBB](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/String%20Without%20AAA%20or%20BBB.java) -510 | [Strobogrammatic Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Strobogrammatic%20Number.java) -511 | [Strong Password Checker II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Strong%20Password%20Checker%20II.java) -512 | [Student Attendance Record I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Student%20Attendance%20Record%20I.java) -513 | [Submission Detail](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Submission%20Detail.java) -514 | [Substrings of Size Three with Distinct Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Substrings%20of%20Size%20Three%20with%20Distinct%20Characters.java) -515 | [Subtract the Product and Sum of Digits of an Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Subtract%20the%20Product%20and%20Sum%20of%20Digits%20of%20an%20Integer.java) -516 | [Subtree of Another Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Subtree%20of%20Another%20Tree.java) -517 | [Sum Of Two Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20Of%20Two%20Integers.java) -518 | [Sum of All Odd Length Subarrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20All%20Odd%20Length%20Subarrays.java) -519 | [Sum of Digits in Base K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Digits%20in%20Base%20K.java) -520 | [Sum of Digits in the Minimum Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Digits%20in%20the%20Minimum%20Number.java) -521 | [Sum of Digits of String After Convert](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Digits%20of%20String%20After%20Convert.java) -522 | [Sum of Left Leaves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Left%20Leaves.java) -523 | [Sum of Root To Leaf Binary Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Root%20To%20Leaf%20Binary%20Numbers.java) -524 | [Sum of Square Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Square%20Numbers.java) -525 | [Sum of Unique Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Unique%20Elements.java) -526 | [Summary Ranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Summary%20Ranges.java) -527 | [Symmetric Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Symmetric%20Tree.java) -528 | [Take Gifts From the Richest Pile](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Take%20Gifts%20From%20the%20Richest%20Pile.java) -529 | [Teemo Attacking](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Teemo%20Attacking.java) -530 | [Teoplitz Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Teoplitz%20Matrix.java) -531 | [The Employee That Worked on the Longest Task](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/The%20Employee%20That%20Worked%20on%20the%20Longest%20Task.java) -532 | [The K Weakest Rows in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/The%20K%20Weakest%20Rows%20in%20a%20Matrix.java) -533 | [Third Maximum Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Third%20Maximum%20Number.java) -534 | [Thousand Separator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Thousand%20Separator.java) -535 | [Three Consecutive Odds](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Three%20Consecutive%20Odds.java) -536 | [Three Divisors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Three%20Divisors.java) -537 | [Time Needed to Buy Tickets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Time%20Needed%20to%20Buy%20Tickets.java) -538 | [To Lower Case](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/To%20Lower%20Case.java) -539 | [Toeplitz Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Toeplitz%20Matrix.java) -540 | [Transpose Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Transpose%20Matrix.java) -541 | [Truncate Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Truncate%20Sentence.java) -542 | [Two Furthest Houses With Different Colors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Furthest%20Houses%20With%20Different%20Colors.java) -543 | [Two Out of Three](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Out%20of%20Three.java) -544 | [Two Sum III - Data Structure Design](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum%20III%20-%20Data%20Structure%20Design.java) -545 | [Two Sum IV - Input is a BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum%20IV%20-%20Input%20is%20a%20BST.java) -546 | [Two Sum Less Than K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum%20Less%20Than%20K.java) -547 | [Two Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum.java) -548 | [Ugly Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Ugly%20Number.java) -549 | [Uncommon Words from Two Sentences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Uncommon%20Words%20from%20Two%20Sentences.java) -550 | [Unique Email Addresses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Unique%20Email%20Addresses.java) -551 | [Unique Morse Code Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Unique%20Morse%20Code%20Words.java) -552 | [Unique Number of Occurrences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Unique%20Number%20of%20Occurrences.java) -553 | [Univalued Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Univalued%20Binary%20Tree.java) -554 | [Valid Anagram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Anagram.java) -555 | [Valid Boomerang](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Boomerang.java) -556 | [Valid Mountain Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Mountain%20Array.java) -557 | [Valid Palindrome II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Palindrome%20II.java) -558 | [Valid Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Palindrome.java) -559 | [Valid Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Parentheses.java) -560 | [Valid Perfect Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Perfect%20Square.java) -561 | [Valid Word Abbreviation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Word%20Abbreviation.java) -562 | [Valid Word Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Word%20Sequence.java) -563 | [Valid Word Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Word%20Square.java) -564 | [Verifying an Alien Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Verifying%20an%20Alien%20Dictionary.java) -565 | [Water Bottles](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Water%20Bottles.java) -566 | [Word Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Word%20Pattern.java) -567 | [X of a Kind in a Deck of Cards](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/X%20of%20a%20Kind%20in%20a%20Deck%20of%20Cards.java) -568 | [XOR Operation in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/XOR%20Operation%20in%20an%20Array.java) -569 | [nim_game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/nim_game.java) -570 | [range_addition_II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/range_addition_II.java) -571 | [trailing_zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/trailing_zeroes.java) +1|[Count Binary Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Binary%20Substrings.java) +2|[Check if All A's Appears Before All B's](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20All%20A's%20Appears%20Before%20All%20B's.java) +3|[Longest Harmonious Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Harmonious%20Subsequence.java) +4|[Missing Ranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Missing%20Ranges.java) +5|[High Five](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/High%20Five.java) +6|[Binary Tree Tilt](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Tree%20Tilt.java) +7|[Number of Boomerangs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Boomerangs.java) +8|[Count the Number of Consistent Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20the%20Number%20of%20Consistent%20Strings.java) +9|[Sentence Similarity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sentence%20Similarity.java) +10|[Strong Password Checker II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Strong%20Password%20Checker%20II.java) +11|[Perform String Shifts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Perform%20String%20Shifts.java) +12|[Kth Largest Element in a Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Kth%20Largest%20Element%20in%20a%20Stream.java) +13|[Kth Missing Positive Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Kth%20Missing%20Positive%20Number.java) +14|[Check If String Is a Prefix of Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20String%20Is%20a%20Prefix%20of%20Array.java) +15|[Capitalize the Title](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Capitalize%20the%20Title.java) +16|[The K Weakest Rows in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/The%20K%20Weakest%20Rows%20in%20a%20Matrix.java) +17|[Missing Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Missing%20Number.java) +18|[Remove Duplicates from Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Duplicates%20from%20Sorted%20Array.java) +19|[Implement strStr](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Implement%20strStr.java) +20|[Reverse String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20String.java) +21|[Create Target Array in the Given Order](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Create%20Target%20Array%20in%20the%20Given%20Order.java) +22|[Increasing Order Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Increasing%20Order%20Search%20Tree.java) +23|[Minimum Number of Moves to Seat Everyone](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Number%20of%20Moves%20to%20Seat%20Everyone.java) +24|[Minimum Absolute Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Absolute%20Difference.java) +25|[Maximum 69 Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%2069%20Number.java) +26|[Largest Perimeter Triangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Perimeter%20Triangle.java) +27|[Minimum Cost of Buying Candies With Discount](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Cost%20of%20Buying%20Candies%20With%20Discount.java) +28|[Number of Equivalent Domino Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Equivalent%20Domino%20Pairs.java) +29|[Summary Ranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Summary%20Ranges.java) +30|[Binary Number with Alternating Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Number%20with%20Alternating%20Bits.java) +31|[Find the Distinct Difference Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Distinct%20Difference%20Array.java) +32|[Buy Two Chocolates](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Buy%20Two%20Chocolates.java) +33|[Intersection of Multiple Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20Multiple%20Arrays.java) +34|[Palindrome Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Palindrome%20Linked%20List.java) +35|[Rectangle Overlap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rectangle%20Overlap.java) +36|[Intersection of Three Sorted Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20Three%20Sorted%20Arrays.java) +37|[Minimum Changes To Make Alternating Binary String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Changes%20To%20Make%20Alternating%20Binary%20String.java) +38|[Jewels and Stones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Jewels%20and%20Stones.java) +39|[Number of Valid Words in a Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Valid%20Words%20in%20a%20Sentence.java) +40|[Greatest English Letter in Upper and Lower Case](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Greatest%20English%20Letter%20in%20Upper%20and%20Lower%20Case.java) +41|[Unique Email Addresses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Unique%20Email%20Addresses.java) +42|[X of a Kind in a Deck of Cards](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/X%20of%20a%20Kind%20in%20a%20Deck%20of%20Cards.java) +43|[Longest Nice Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Nice%20Substring.java) +44|[Count Primes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Primes.java) +45|[Positions of Large Groups](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Positions%20of%20Large%20Groups.java) +46|[Maximum Population Year](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Population%20Year.java) +47|[Min Cost Climbing Stairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Min%20Cost%20Climbing%20Stairs.java) +48|[Number of Days Between Two Dates](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Days%20Between%20Two%20Dates.java) +49|[Minimum Distance to the Target Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Distance%20to%20the%20Target%20Element.java) +50|[Path Crossing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Path%20Crossing.java) +51|[Check If N and Its Double Exist](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20N%20and%20Its%20Double%20Exist.java) +52|[Word Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Word%20Pattern.java) +53|[Maximum Nesting Depth of the Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Nesting%20Depth%20of%20the%20Parentheses.java) +54|[Two Sum IV - Input is a BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum%20IV%20-%20Input%20is%20a%20BST.java) +55|[Find Positive Integer Solution for a Given Equation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Positive%20Integer%20Solution%20for%20a%20Given%20Equation.java) +56|[Hamming Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Hamming%20Distance.java) +57|[Defuse the Bomb](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Defuse%20the%20Bomb.java) +58|[Check if The Number is Fascinating](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20The%20Number%20is%20Fascinating.java) +59|[Minimum Common Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Common%20Value.java) +60|[Final Prices With a Special Discount in a Shop](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Final%20Prices%20With%20a%20Special%20Discount%20in%20a%20Shop.java) +61|[Plus One](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Plus%20One.java) +62|[Submission Detail](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Submission%20Detail.java) +63|[Rotate String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rotate%20String.java) +64|[Minimum Depth of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Depth%20of%20a%20Binary%20Tree.java) +65|[Power of Four](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Power%20of%20Four.java) +66|[Valid Perfect Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Perfect%20Square.java) +67|[Find N Unique Integers Sum up to Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20N%20Unique%20Integers%20Sum%20up%20to%20Zero.java) +68|[Remove Trailing Zeros From a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Trailing%20Zeros%20From%20a%20String.java) +69|[Paint Fence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Paint%20Fence.java) +70|[Detect Capital](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Detect%20Capital.java) +71|[XOR Operation in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/XOR%20Operation%20in%20an%20Array.java) +72|[Divide a String Into Groups of Size k](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Divide%20a%20String%20Into%20Groups%20of%20Size%20k.java) +73|[Flipping an Image](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flipping%20an%20Image.java) +74|[Subtract the Product and Sum of Digits of an Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Subtract%20the%20Product%20and%20Sum%20of%20Digits%20of%20an%20Integer.java) +75|[Two Sum III - Data Structure Design](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum%20III%20-%20Data%20Structure%20Design.java) +76|[Check if Binary String Has at Most One Segment of Ones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Binary%20String%20Has%20at%20Most%20One%20Segment%20of%20Ones.java) +77|[Number Complement](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20Complement.java) +78|[Longer Contiguous Segments of Ones than Zeros](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longer%20Contiguous%20Segments%20of%20Ones%20than%20Zeros.java) +79|[Design HashSet](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20HashSet.java) +80|[Convert 1D Array Into 2D Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%201D%20Array%20Into%202D%20Array.java) +81|[Odd String Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Odd%20String%20Difference.java) +82|[Remove Digit From Number to Maximize Result](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Digit%20From%20Number%20to%20Maximize%20Result.java) +83|[Find Mode in Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Mode%20in%20Binary%20Search%20Tree.java) +84|[Count Hills and Valleys in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Hills%20and%20Valleys%20in%20an%20Array.java) +85|[Maximum Repeating Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Repeating%20Substring.java) +86|[Number of Unequal Triplets in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Unequal%20Triplets%20in%20Array.java) +87|[Split Strings by Separator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Split%20Strings%20by%20Separator.java) +88|[Find Closest Number to Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Closest%20Number%20to%20Zero.java) +89|[1-bit and 2-bit Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/1-bit%20and%202-bit%20Characters.java) +90|[Binary Gap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Gap.java) +91|[Subtree of Another Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Subtree%20of%20Another%20Tree.java) +92|[Binary Tree Level Order Traversal II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Tree%20Level%20Order%20Traversal%20II.java) +93|[Count Prefixes of a Given String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Prefixes%20of%20a%20Given%20String.java) +94|[Find the Width of Columns of a Grid](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Width%20of%20Columns%20of%20a%20Grid.java) +95|[Defanging an IP Address](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Defanging%20an%20IP%20Address.java) +96|[Find Target Indices After Sorting Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Target%20Indices%20After%20Sorting%20Array.java) +97|[Truncate Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Truncate%20Sentence.java) +98|[Diameter of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Diameter%20of%20Binary%20Tree.java) +99|[Best Poker Hand](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Best%20Poker%20Hand.java) +100|[Range Sum of BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Range%20Sum%20of%20BST.java) +101|[Maximum Average Subarray I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Average%20Subarray%20I.java) +102|[Fizz Buzz](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fizz%20Buzz.java) +103|[Check if All the Integers in a Range Are Covered](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20All%20the%20Integers%20in%20a%20Range%20Are%20Covered.java) +104|[Find First Palindromic String in the Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20First%20Palindromic%20String%20in%20the%20Array.java) +105|[Duplicate Zeros](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Duplicate%20Zeros.java) +106|[Minimum Subsequence in Non-Increasing Order](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Subsequence%20in%20Non-Increasing%20Order.java) +107|[Smallest Range I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Smallest%20Range%20I.java) +108|[Employee Importance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Employee%20Importance.java) +109|[Minimum_index_sum_of_two_lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum_index_sum_of_two_lists.java) +110|[Points That Intersect With Cars](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Points%20That%20Intersect%20With%20Cars.java) +111|[Number of segments in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20segments%20in%20a%20String.java) +112|[Delete Columns to Make Sorted](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20Columns%20to%20Make%20Sorted.java) +113|[Reverse Only Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Only%20Letters.java) +114|[Evaluate Boolean Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Evaluate%20Boolean%20Binary%20Tree.java) +115|[Repeated String Match](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Repeated%20String%20Match.java) +116|[Neither Minimum nor Maximum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Neither%20Minimum%20nor%20Maximum.java) +117|[Maximum Value of an Ordered Triplet I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Value%20of%20an%20Ordered%20Triplet%20I.java) +118|[Uncommon Words from Two Sentences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Uncommon%20Words%20from%20Two%20Sentences.java) +119|[Assign Cookies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Assign%20Cookies.java) +120|[Most Frequent Number Following Key In an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Most%20Frequent%20Number%20Following%20Key%20In%20an%20Array.java) +121|[Element Appearing More Than 25% In Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Element%20Appearing%20More%20Than%2025%%20In%20Sorted%20Array.java) +122|[Find the Town Judge](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Town%20Judge.java) +123|[Buddy Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Buddy%20Strings.java) +124|[Teoplitz Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Teoplitz%20Matrix.java) +125|[Leaf-Similar Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Leaf-Similar%20Trees.java) +126|[Minimum Hours of Training to Win a Competition](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Hours%20of%20Training%20to%20Win%20a%20Competition.java) +127|[Goat Latin](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Goat%20Latin.java) +128|[Flower Planting With No Adjacent](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flower%20Planting%20With%20No%20Adjacent.java) +129|[Largest Triangle Area](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Triangle%20Area.java) +130|[Row With Maximum Ones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Row%20With%20Maximum%20Ones.java) +131|[Determine Color of a Chessboard Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Determine%20Color%20of%20a%20Chessboard%20Square.java) +132|[Richest Customer Wealth](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Richest%20Customer%20Wealth.java) +133|[Consecutive Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Consecutive%20Characters.java) +134|[Latest Time by Replacing Hidden Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Latest%20Time%20by%20Replacing%20Hidden%20Digits.java) +135|[Robot Return to Origin](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Robot%20Return%20to%20Origin.java) +136|[Determine Whether Matrix Can Be Obtained By Rotation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Determine%20Whether%20Matrix%20Can%20Be%20Obtained%20By%20Rotation.java) +137|[Flip Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flip%20Game.java) +138|[Minimum Value to Get Positive Step by Step Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Value%20to%20Get%20Positive%20Step%20by%20Step%20Sum.java) +139|[Average Value of Even Numbers That Are Divisible by Three](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Average%20Value%20of%20Even%20Numbers%20That%20Are%20Divisible%20by%20Three.java) +140|[Reshape the matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reshape%20the%20matrix.java) +141|[Valid Anagram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Anagram.java) +142|[Number of Strings That Appear as Substrings in Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Strings%20That%20Appear%20as%20Substrings%20in%20Word.java) +143|[DI String Match](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/DI%20String%20Match.java) +144|[Running Sum of 1d Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Running%20Sum%20of%201d%20Array.java) +145|[Special Array With X Elements Greater Than or Equal X](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Special%20Array%20With%20X%20Elements%20Greater%20Than%20or%20Equal%20X.java) +146|[Number of Distinct Averages](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Distinct%20Averages.java) +147|[Check if an Array Is Consecutive](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20an%20Array%20Is%20Consecutive.java) +148|[Backspace String Compare](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Backspace%20String%20Compare.java) +149|[Rings and Rods](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rings%20and%20Rods.java) +150|[Implement Stack using Queues](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Implement%20Stack%20using%20Queues.java) +151|[Baseball Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Baseball%20Game.java) +152|[Pairs of Songs With Total Durations Divisible by 60](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Pairs%20of%20Songs%20With%20Total%20Durations%20Divisible%20by%2060.java) +153|[Destination City](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Destination%20City.java) +154|[Maximum Product of Three Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Product%20of%20Three%20Numbers.java) +155|[Three Consecutive Odds](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Three%20Consecutive%20Odds.java) +156|[Set Mismatch](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Set%20Mismatch.java) +157|[Sort Array by Increasing Frequency](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Array%20by%20Increasing%20Frequency.java) +158|[Find the Distance Value Between Two Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Distance%20Value%20Between%20Two%20Arrays.java) +159|[Find Anagram Mappings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Anagram%20Mappings.java) +160|[Check if Array is Good](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Array%20is%20Good.java) +161|[Decompress Run-Length Encoded List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Decompress%20Run-Length%20Encoded%20List.java) +162|[Flood Fill](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flood%20Fill.java) +163|[Magic Squares In Grid](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Magic%20Squares%20In%20Grid.java) +164|[Smallest Even Multiple](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Smallest%20Even%20Multiple.java) +165|[Hexspeak](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Hexspeak.java) +166|[Diet Plan Performance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Diet%20Plan%20Performance.java) +167|[Maximum Number of Balloons](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Balloons.java) +168|[Find Smallest Letter Greater Than Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Smallest%20Letter%20Greater%20Than%20Target.java) +169|[Check if Array Is Sorted and Rotated](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Array%20Is%20Sorted%20and%20Rotated.java) +170|[Maximum Enemy Forts That Can Be Captured](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Enemy%20Forts%20That%20Can%20Be%20Captured.java) +171|[Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Path%20Sum.java) +172|[Day of the Year](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Day%20of%20the%20Year.java) +173|[Number of Beautiful Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Beautiful%20Pairs.java) +174|[Can Make Arithmetic Progression From Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Can%20Make%20Arithmetic%20Progression%20From%20Sequence.java) +175|[Furthest Point From Origin](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Furthest%20Point%20From%20Origin.java) +176|[Find the Highest Altitude](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Highest%20Altitude.java) +177|[Root Equals Sum of Children](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Root%20Equals%20Sum%20of%20Children.java) +178|[Powerful Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Powerful%20Integers.java) +179|[Merge Two Sorted Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Two%20Sorted%20Lists.java) +180|[Binary Search](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Search.java) +181|[K-diff Pairs in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/K-diff%20Pairs%20in%20an%20Array.java) +182|[Repeated Substring Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Repeated%20Substring%20Pattern.java) +183|[Calculate Digit Sum of a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Calculate%20Digit%20Sum%20of%20a%20String.java) +184|[Reformat Phone Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reformat%20Phone%20Number.java) +185|[Longest Continuous Increasing Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Continuous%20Increasing%20Subsequence.java) +186|[Shuffle the Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shuffle%20the%20Array.java) +187|[Count Pairs Of Similar Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Pairs%20Of%20Similar%20Strings.java) +188|[Ransom Note](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Ransom%20Note.java) +189|[trailing_zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/trailing_zeroes.java) +190|[Height Checker](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Height%20Checker.java) +191|[License Key Formatting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/License%20Key%20Formatting.java) +192|[Sum of Values at Indices With K Set Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Values%20at%20Indices%20With%20K%20Set%20Bits.java) +193|[Balanced Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Balanced%20Binary%20Tree.java) +194|[Check If It Is a Straight Line](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20It%20Is%20a%20Straight%20Line.java) +195|[Binary Watch](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Watch.java) +196|[Count Special Quadruplets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Special%20Quadruplets.java) +197|[Three Divisors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Three%20Divisors.java) +198|[Make Array Zero by Subtracting Equal Amounts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Make%20Array%20Zero%20by%20Subtracting%20Equal%20Amounts.java) +199|[Maximum Number of Words You Can Type](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Words%20You%20Can%20Type.java) +200|[Contains Duplicate](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Contains%20Duplicate.java) +201|[Decode the Message](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Decode%20the%20Message.java) +202|[String Matching in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/String%20Matching%20in%20an%20Array.java) +203|[Count the Digits That Divide a Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20the%20Digits%20That%20Divide%20a%20Number.java) +204|[Distance Between Bus Stops](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Distance%20Between%20Bus%20Stops.java) +205|[Ugly Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Ugly%20Number.java) +206|[Faulty Keyboard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Faulty%20Keyboard.java) +207|[Find the Pivot Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Pivot%20Integer.java) +208|[Pascal's Triangle II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Pascal's%20Triangle%20II.java) +209|[Maximum Count of Positive Integer and Negative Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Count%20of%20Positive%20Integer%20and%20Negative%20Integer.java) +210|[Count Symmetric Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Symmetric%20Integers.java) +211|[Pascal's Triangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Pascal's%20Triangle.java) +212|[Binary Prefix Divisible By 5](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Prefix%20Divisible%20By%205.java) +213|[Number Of Rectangles That Can Form The Largest Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20Of%20Rectangles%20That%20Can%20Form%20The%20Largest%20Square.java) +214|[Separate the Digits in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Separate%20the%20Digits%20in%20an%20Array.java) +215|[Count Negative Numbers in a Sorted Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Negative%20Numbers%20in%20a%20Sorted%20Matrix.java) +216|[Remove One Element to Make the Array Strictly Increasing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20One%20Element%20to%20Make%20the%20Array%20Strictly%20Increasing.java) +217|[Two Furthest Houses With Different Colors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Furthest%20Houses%20With%20Different%20Colors.java) +218|[Special Positions in a Binary Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Special%20Positions%20in%20a%20Binary%20Matrix.java) +219|[Check if All Characters Have Equal Number of Occurrences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20All%20Characters%20Have%20Equal%20Number%20of%20Occurrences.java) +220|[Valid Word Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Word%20Sequence.java) +221|[Counting Words With a Given Prefix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Counting%20Words%20With%20a%20Given%20Prefix.java) +222|[Binary Tree Inorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Tree%20Inorder%20Traversal.java) +223|[Minimum Moves to Convert String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Moves%20to%20Convert%20String.java) +224|[Design Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20Linked%20List.java) +225|[Kth Distinct String in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Kth%20Distinct%20String%20in%20an%20Array.java) +226|[Count Good Triplets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Good%20Triplets.java) +227|[Design an Ordered System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20an%20Ordered%20System.java) +228|[Get Maximum in Generated Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Get%20Maximum%20in%20Generated%20Array.java) +229|[Convert the Temperature](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%20the%20Temperature.java) +230|[Arranging Coins](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Arranging%20Coins.java) +231|[Count Pairs Whose Sum is Less than Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Pairs%20Whose%20Sum%20is%20Less%20than%20Target.java) +232|[Check if Word Equals Summation of Two Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Word%20Equals%20Summation%20of%20Two%20Words.java) +233|[Fair Candy Swap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fair%20Candy%20Swap.java) +234|[Design Parking System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20Parking%20System.java) +235|[Transpose Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Transpose%20Matrix.java) +236|[Delete Greatest Value in Each Row](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20Greatest%20Value%20in%20Each%20Row.java) +237|[Excel Sheet Column Title](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Excel%20Sheet%20Column%20Title.java) +238|[First Letter to Appear Twice](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/First%20Letter%20to%20Appear%20Twice.java) +239|[Linked List Cycle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Linked%20List%20Cycle.java) +240|[Find All the Lonely Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20All%20the%20Lonely%20Nodes.java) +241|[Find the Maximum Achievable Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Maximum%20Achievable%20Number.java) +242|[Base 7](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Base%207.java) +243|[Reverse Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Bits.java) +244|[SqrtX](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/SqrtX.java) +245|[Check if Strings Can be Made Equal With Operations I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Strings%20Can%20be%20Made%20Equal%20With%20Operations%20I.java) +246|[Similar RGB Color](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Similar%20RGB%20Color.java) +247|[Sort the People](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20the%20People.java) +248|[Is Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Is%20Subsequence.java) +249|[Longest Even Odd Subarray With Threshold](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Even%20Odd%20Subarray%20With%20Threshold.java) +250|[Reverse Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Linked%20List.java) +251|[Shortest Distance to a Character](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Distance%20to%20a%20Character.java) +252|[Count of Matches in Tournament](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20of%20Matches%20in%20Tournament.java) +253|[Valid Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Parentheses.java) +254|[Convert Sorted Array To Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%20Sorted%20Array%20To%20Binary%20Search%20Tree.java) +255|[Count Vowel Substrings of a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Vowel%20Substrings%20of%20a%20String.java) +256|[Construct the rectangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Construct%20the%20rectangle.java) +257|[Maximum Units on a Truck](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Units%20on%20a%20Truck.java) +258|[Sum of Left Leaves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Left%20Leaves.java) +259|[Decrypt String from Alphabet to Integer Mapping](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Decrypt%20String%20from%20Alphabet%20to%20Integer%20Mapping.java) +260|[Number of Employees Who Met the Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Employees%20Who%20Met%20the%20Target.java) +261|[Find Pivot Index](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Pivot%20Index.java) +262|[Factorial Trailing Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Factorial%20Trailing%20Zeroes.java) +263|[Build an Array With Stack Operations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Build%20an%20Array%20With%20Stack%20Operations.java) +264|[Last Stone Weight](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Last%20Stone%20Weight.java) +265|[range_addition_II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/range_addition_II.java) +266|[Isomorphic Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Isomorphic%20Strings.java) +267|[Longest Subsequence With Limited Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Subsequence%20With%20Limited%20Sum.java) +268|[Split a String in Balanced Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Split%20a%20String%20in%20Balanced%20Strings.java) +269|[To Lower Case](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/To%20Lower%20Case.java) +270|[Sum of Digits of String After Convert](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Digits%20of%20String%20After%20Convert.java) +271|[Number of Senior Citizens](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Senior%20Citizens.java) +272|[Minimum Cost to Move Chips to The Same Position](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Cost%20to%20Move%20Chips%20to%20The%20Same%20Position.java) +273|[Read N characters Given Read4](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Read%20N%20characters%20Given%20Read4.java) +274|[Longest Alternating Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Alternating%20Subarray.java) +275|[Delete N Nodes After M Nodes of a Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20N%20Nodes%20After%20M%20Nodes%20of%20a%20Linked%20List.java) +276|[Count Items Matching a Rule](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Items%20Matching%20a%20Rule.java) +277|[Reverse Vowels of a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Vowels%20of%20a%20String.java) +278|[Largest Local Values in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Local%20Values%20in%20a%20Matrix.java) +279|[A Number After a Double Reversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/A%20Number%20After%20a%20Double%20Reversal.java) +280|[Roman to Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Roman%20to%20Integer.java) +281|[Cousins in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Cousins%20in%20Binary%20Tree.java) +282|[Binary Tree Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Tree%20Paths.java) +283|[Complement of Base 10 Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Complement%20of%20Base%2010%20Integer.java) +284|[Find if Path Exists in Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20if%20Path%20Exists%20in%20Graph.java) +285|[Minimum Difference Between Highest and Lowest of K Scores](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Difference%20Between%20Highest%20and%20Lowest%20of%20K%20Scores.java) +286|[Number of Days in a Month](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Days%20in%20a%20Month.java) +287|[Find Resultant Array After Removing Anagrams](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Resultant%20Array%20After%20Removing%20Anagrams.java) +288|[Minimum String Length After Removing Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20String%20Length%20After%20Removing%20Substrings.java) +289|[Palindrome Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Palindrome%20Number.java) +290|[Find Subarrays With Equal Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Subarrays%20With%20Equal%20Sum.java) +291|[Account Balance After Rounded Purchase](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Account%20Balance%20After%20Rounded%20Purchase.java) +292|[Minimum Amount of Time to Fill Cups](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Amount%20of%20Time%20to%20Fill%20Cups.java) +293|[Detect Pattern of Length M Repeated K or More Times](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Detect%20Pattern%20of%20Length%20M%20Repeated%20K%20or%20More%20Times.java) +294|[Largest Positive Integer That Exists With Its Negative](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Positive%20Integer%20That%20Exists%20With%20Its%20Negative.java) +295|[Univalued Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Univalued%20Binary%20Tree.java) +296|[Single-Row Keyboard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Single-Row%20Keyboard.java) +297|[Remove Linked List Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Linked%20List%20Elements.java) +298|[How Many Numbers Are Smaller Than the Current Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/How%20Many%20Numbers%20Are%20Smaller%20Than%20the%20Current%20Number.java) +299|[Most Frequent Even Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Most%20Frequent%20Even%20Element.java) +300|[Maximum Odd Binary Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Odd%20Binary%20Number.java) +301|[Armstrong Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Armstrong%20Number.java) +302|[Counting Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Counting%20Elements.java) +303|[Make The String Great](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Make%20The%20String%20Great.java) +304|[Cells with Odd Values in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Cells%20with%20Odd%20Values%20in%20a%20Matrix.java) +305|[Power of Two](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Power%20of%20Two.java) +306|[Decode XORed Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Decode%20XORed%20Array.java) +307|[Long Pressed Name](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Long%20Pressed%20Name.java) +308|[Kids With the Greatest Number of Candies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Kids%20With%20the%20Greatest%20Number%20of%20Candies.java) +309|[N-ary Tree Postorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-ary%20Tree%20Postorder%20Traversal.java) +310|[Max Consecutive Ones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Max%20Consecutive%20Ones.java) +311|[Find Words That Can Be Formed by Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Words%20That%20Can%20Be%20Formed%20by%20Characters.java) +312|[Number of 1 bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%201%20bits.java) +313|[Largest Unique Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Unique%20Number.java) +314|[The Employee That Worked on the Longest Task](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/The%20Employee%20That%20Worked%20on%20the%20Longest%20Task.java) +315|[Paint House](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Paint%20House.java) +316|[Logger Rate Limiter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Logger%20Rate%20Limiter.java) +317|[Substrings of Size Three with Distinct Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Substrings%20of%20Size%20Three%20with%20Distinct%20Characters.java) +318|[Maximum Difference by Remapping a Digit](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Difference%20by%20Remapping%20a%20Digit.java) +319|[Monotonic Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Monotonic%20Array.java) +320|[Check if One String Swap Can Make Strings Equal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20One%20String%20Swap%20Can%20Make%20Strings%20Equal.java) +321|[Valid Palindrome II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Palindrome%20II.java) +322|[Occurrences After Bigram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Occurrences%20After%20Bigram.java) +323|[Minimum Sum of Four Digit Number After Splitting Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Sum%20of%20Four%20Digit%20Number%20After%20Splitting%20Digits.java) +324|[Move Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Move%20Zeroes.java) +325|[Number of Arithmetic Triplets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Arithmetic%20Triplets.java) +326|[Count Number of Pairs With Absolute Difference K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Number%20of%20Pairs%20With%20Absolute%20Difference%20K.java) +327|[Number of Lines To Write String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Lines%20To%20Write%20String.java) +328|[First Unique Character in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/First%20Unique%20Character%20in%20a%20String.java) +329|[Maximum depth of Binary tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20depth%20of%20Binary%20tree.java) +330|[Largest Number At Least Twice of Others](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Number%20At%20Least%20Twice%20of%20Others.java) +331|[Reverse String II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20String%20II.java) +332|[Letter Case Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Letter%20Case%20Permutation.java) +333|[Two Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum.java) +334|[Climbing Stairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Climbing%20Stairs.java) +335|[Projection Area of 3D Shapes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Projection%20Area%20of%203D%20Shapes.java) +336|[Maximize Sum Of Array After K Negations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximize%20Sum%20Of%20Array%20After%20K%20Negations.java) +337|[Third Maximum Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Third%20Maximum%20Number.java) +338|[Sign of the Product of an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sign%20of%20the%20Product%20of%20an%20Array.java) +339|[Heaters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Heaters.java) +340|[Remove Palindromic Subsequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Palindromic%20Subsequences.java) +341|[Time Needed to Buy Tickets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Time%20Needed%20to%20Buy%20Tickets.java) +342|[Find the K-Beauty of a Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20K-Beauty%20of%20a%20Number.java) +343|[Find All K-Distant Indices in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20All%20K-Distant%20Indices%20in%20an%20Array.java) +344|[Student Attendance Record I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Student%20Attendance%20Record%20I.java) +345|[Delete Characters to Make Fancy String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20Characters%20to%20Make%20Fancy%20String.java) +346|[Longest Uncommon Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Uncommon%20Subsequence.java) +347|[Check Distances Between Same Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20Distances%20Between%20Same%20Letters.java) +348|[Valid Mountain Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Mountain%20Array.java) +349|[Shortest Word Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Word%20Distance.java) +350|[Check if String Is Decomposable Into Value-Equal Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20String%20Is%20Decomposable%20Into%20Value-Equal%20Substrings.java) +351|[Matrix Cells in Distance Order](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Matrix%20Cells%20in%20Distance%20Order.java) +352|[Final Value of Variable After Performing Operations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Final%20Value%20of%20Variable%20After%20Performing%20Operations.java) +353|[Shuffle String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shuffle%20String.java) +354|[Sum of Square Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Square%20Numbers.java) +355|[Percentage of Letter in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Percentage%20of%20Letter%20in%20String.java) +356|[Intersection of Two Arrays II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20Two%20Arrays%20II.java) +357|[Most Common Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Most%20Common%20Word.java) +358|[Count Asterisks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Asterisks.java) +359|[Sum of Squares of Special Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Squares%20of%20Special%20Elements.java) +360|[Largest 3-Same-Digit Number in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%203-Same-Digit%20Number%20in%20String.java) +361|[Number of Students Doing Homework at a Given Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Students%20Doing%20Homework%20at%20a%20Given%20Time.java) +362|[Invert Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Invert%20Binary%20Tree.java) +363|[Check if the Sentence Is Pangram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20the%20Sentence%20Is%20Pangram.java) +364|[Island Perimeter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Island%20Perimeter.java) +365|[Available Captures for Rook](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Available%20Captures%20for%20Rook.java) +366|[Count Common Words With One Occurrence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Common%20Words%20With%20One%20Occurrence.java) +367|[Degree of an array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Degree%20of%20an%20array.java) +368|[Sum of Root To Leaf Binary Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Root%20To%20Leaf%20Binary%20Numbers.java) +369|[Circular Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Circular%20Sentence.java) +370|[Sort Array By Parity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Array%20By%20Parity.java) +371|[Number of Good Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Good%20Pairs.java) +372|[Convert a number to hexadecimal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%20a%20number%20to%20hexadecimal.java) +373|[Check If a Word Occurs As a Prefix of Any Word in a Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20a%20Word%20Occurs%20As%20a%20Prefix%20of%20Any%20Word%20in%20a%20Sentence.java) +374|[Calculate Delayed Arrival Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Calculate%20Delayed%20Arrival%20Time.java) +375|[Concatenation of Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Concatenation%20of%20Array.java) +376|[Number of Recent Calls](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Recent%20Calls.java) +377|[Fixed Point](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fixed%20Point.java) +378|[Valid Boomerang](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Boomerang.java) +379|[Minimum Moves to Equal an Array Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Moves%20to%20Equal%20an%20Array%20Element.java) +380|[Calculate Money in Leetcode Bank](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Calculate%20Money%20in%20Leetcode%20Bank.java) +381|[Check If Two String Arrays are Equivalent](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20Two%20String%20Arrays%20are%20Equivalent.java) +382|[Find Nearest Point That Has the Same X or Y Coordinate](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Nearest%20Point%20That%20Has%20the%20Same%20X%20or%20Y%20Coordinate.java) +383|[Maximum Product Difference Between Two Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Product%20Difference%20Between%20Two%20Pairs.java) +384|[Goal Parser Interpretation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Goal%20Parser%20Interpretation.java) +385|[Find the Losers of the Circular Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Losers%20of%20the%20Circular%20Game.java) +386|[Judge Route Cycle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Judge%20Route%20Cycle.java) +387|[K Items With the Maximum Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/K%20Items%20With%20the%20Maximum%20Sum.java) +388|[Middle of the linked list](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Middle%20of%20the%20linked%20list.java) +389|[Maximum Number of Pairs in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Pairs%20in%20Array.java) +390|[Check if Matrix Is X-Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Matrix%20Is%20X-Matrix.java) +391|[Compare Strings by Frequency of the Smallest Character](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Compare%20Strings%20by%20Frequency%20of%20the%20Smallest%20Character.java) +392|[Intersection of Two Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20Two%20Arrays.java) +393|[Bulls and Cows](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Bulls%20and%20Cows.java) +394|[Slowest Key](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Slowest%20Key.java) +395|[Count Equal and Divisible Pairs in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Equal%20and%20Divisible%20Pairs%20in%20an%20Array.java) +396|[nim_game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/nim_game.java) +397|[Min Max Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Min%20Max%20Game.java) +398|[Groups of Special-Equivalent Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Groups%20of%20Special-Equivalent%20Strings.java) +399|[Reformat The String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reformat%20The%20String.java) +400|[Minimum Number of Operations to Convert Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Number%20of%20Operations%20to%20Convert%20Time.java) +401|[Form Smallest Number From Two Digit Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Form%20Smallest%20Number%20From%20Two%20Digit%20Arrays.java) +402|[Minimum Operations to Collect Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Operations%20to%20Collect%20Elements.java) +403|[Count Elements With Strictly Smaller and Greater Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Elements%20With%20Strictly%20Smaller%20and%20Greater%20Elements.java) +404|[Determine the Winner of a Bowling Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Determine%20the%20Winner%20of%20a%20Bowling%20Game.java) +405|[Minimum Operations to Make the Array Increasing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Operations%20to%20Make%20the%20Array%20Increasing.java) +406|[Minimum Right Shifts to Sort the Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Right%20Shifts%20to%20Sort%20the%20Array.java) +407|[Index Pairs of a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Index%20Pairs%20of%20a%20String.java) +408|[Number of Steps to Reduce a Number to Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Steps%20to%20Reduce%20a%20Number%20to%20Zero.java) +409|[Confusing Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Confusing%20Number.java) +410|[Convert BST to Greater Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%20BST%20to%20Greater%20Tree.java) +411|[Find All Numbers Disappeared in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20All%20Numbers%20Disappeared%20in%20an%20Array.java) +412|[Largest Number After Digit Swaps by Parity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Number%20After%20Digit%20Swaps%20by%20Parity.java) +413|[Merge Two 2D Arrays by Summing Values](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Two%202D%20Arrays%20by%20Summing%20Values.java) +414|[Reformat Date](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reformat%20Date.java) +415|[Largest Odd Number in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Odd%20Number%20in%20String.java) +416|[Build Array from Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Build%20Array%20from%20Permutation.java) +417|[Find Lucky Integer in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Lucky%20Integer%20in%20an%20Array.java) +418|[Reverse Prefix of Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Prefix%20of%20Word.java) +419|[Nested List Weight Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Nested%20List%20Weight%20Sum.java) +420|[Relative ranks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Relative%20ranks.java) +421|[Palindrome Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Palindrome%20Permutation.java) +422|[Find Winner on a Tic Tac Toe Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Winner%20on%20a%20Tic%20Tac%20Toe%20Game.java) +423|[Merge two binary trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20two%20binary%20trees.java) +424|[Check if Numbers Are Ascending in a Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Numbers%20Are%20Ascending%20in%20a%20Sentence.java) +425|[Power of Three](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Power%20of%20Three.java) +426|[Remove Letter To Equalize Frequency](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Letter%20To%20Equalize%20Frequency.java) +427|[Lemonade Change](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Lemonade%20Change.java) +428|[Length of last word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Length%20of%20last%20word.java) +429|[Increasing Decreasing String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Increasing%20Decreasing%20String.java) +430|[N-th Tribonacci Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-th%20Tribonacci%20Number.java) +431|[Longest Common Prefix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Common%20Prefix.java) +432|[Minimum Time Visiting All Points](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Time%20Visiting%20All%20Points.java) +433|[Calculate Amount Paid in Taxes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Calculate%20Amount%20Paid%20in%20Taxes.java) +434|[Number of Different Integers in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Different%20Integers%20in%20a%20String.java) +435|[Minimize String Length](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimize%20String%20Length.java) +436|[Add Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Add%20Strings.java) +437|[Maximum Ascending Subarray Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Ascending%20Subarray%20Sum.java) +438|[Best Time to Buy and Sell Stock](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Best%20Time%20to%20Buy%20and%20Sell%20Stock.java) +439|[Lowest Common Ancestor of a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Lowest%20Common%20Ancestor%20of%20a%20Binary%20Search%20Tree.java) +440|[Determine if String Halves Are Alike](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Determine%20if%20String%20Halves%20Are%20Alike.java) +441|[Find the difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20difference.java) +442|[Check if Every Row and Column Contains All Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Every%20Row%20and%20Column%20Contains%20All%20Numbers.java) +443|[Replace All Digits with Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Replace%20All%20Digits%20with%20Characters.java) +444|[Largest Substring Between Two Equal Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Substring%20Between%20Two%20Equal%20Characters.java) +445|[Strobogrammatic Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Strobogrammatic%20Number.java) +446|[Rearrange Characters to Make Target String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rearrange%20Characters%20to%20Make%20Target%20String.java) +447|[Next Greater Element I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Next%20Greater%20Element%20I.java) +448|[Counting Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Counting%20Bits.java) +449|[Remove Outermost Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Outermost%20Parentheses.java) +450|[Count the Number of Vowel Strings in Range](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20the%20Number%20of%20Vowel%20Strings%20in%20Range.java) +451|[Determine if Two Events Have Conflict](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Determine%20if%20Two%20Events%20Have%20Conflict.java) +452|[Replace All ?'s to Avoid Consecutive Repeating Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Replace%20All%20?'s%20to%20Avoid%20Consecutive%20Repeating%20Characters.java) +453|[Two Sum Less Than K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum%20Less%20Than%20K.java) +454|[Majority Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Majority%20Element.java) +455|[Merge Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Sorted%20Array.java) +456|[Unique Morse Code Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Unique%20Morse%20Code%20Words.java) +457|[Divisor Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Divisor%20Game.java) +458|[Find Numbers with Even Number of Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Numbers%20with%20Even%20Number%20of%20Digits.java) +459|[Categorize Box According to Criteria](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Categorize%20Box%20According%20to%20Criteria.java) +460|[Implement Queue using Stacks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Implement%20Queue%20using%20Stacks.java) +461|[N-ary Tree Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-ary%20Tree%20Preorder%20Traversal.java) +462|[Smallest Index With Equal Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Smallest%20Index%20With%20Equal%20Value.java) +463|[Total Distance Traveled](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Total%20Distance%20Traveled.java) +464|[Delete Node in a Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20Node%20in%20a%20Linked%20List.java) +465|[Sort Array By Parity II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Array%20By%20Parity%20II.java) +466|[Most Visited Sector in a Circular Track](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Most%20Visited%20Sector%20in%20a%20Circular%20Track.java) +467|[Greatest Common Divisor of Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Greatest%20Common%20Divisor%20of%20Strings.java) +468|[Remove Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Element.java) +469|[Maximum Subarray Sum I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Subarray%20Sum%20I.java) +470|[Partition Array Into Three Parts With Equal Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Partition%20Array%20Into%20Three%20Parts%20With%20Equal%20Sum.java) +471|[Remove Duplicates From Sorted Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Duplicates%20From%20Sorted%20Lists.java) +472|[Minimum Bit Flips to Convert Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Bit%20Flips%20to%20Convert%20Number.java) +473|[Sort Even and Odd Indices Independently](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Even%20and%20Odd%20Indices%20Independently.java) +474|[Meeting Rooms](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Meeting%20Rooms.java) +475|[Crawler Log Folder](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Crawler%20Log%20Folder.java) +476|[Maximum Difference Between Increasing Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Difference%20Between%20Increasing%20Elements.java) +477|[Left and Right Sum Differences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Left%20and%20Right%20Sum%20Differences.java) +478|[Find the Middle Index in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Middle%20Index%20in%20Array.java) +479|[Range Sum Query Immutable](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Range%20Sum%20Query%20Immutable.java) +480|[Intersection of two Linked Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20two%20Linked%20Lists.java) +481|[Merge Similar Items](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Similar%20Items.java) +482|[Can Place Flowers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Can%20Place%20Flowers.java) +483|[Generate a String With Characters That Have Odd Counts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Generate%20a%20String%20With%20Characters%20That%20Have%20Odd%20Counts.java) +484|[Count Operations to Obtain Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Operations%20to%20Obtain%20Zero.java) +485|[Array Partition I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Array%20Partition%20I.java) +486|[Next Greater Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Next%20Greater%20Element.java) +487|[Perfect Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Perfect%20Number.java) +488|[Sum of Digits in the Minimum Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Digits%20in%20the%20Minimum%20Number.java) +489|[Guess Number Higher or Lower](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Guess%20Number%20Higher%20or%20Lower.java) +490|[Find the Array Concatenation Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Array%20Concatenation%20Value.java) +491|[Self Dividing Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Self%20Dividing%20Number.java) +492|[Design HashMap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20HashMap.java) +493|[Minimum Time to Type Word Using Special Typewriter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Time%20to%20Type%20Word%20Using%20Special%20Typewriter.java) +494|[Check Whether Two Strings are Almost Equivalent](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20Whether%20Two%20Strings%20are%20Almost%20Equivalent.java) +495|[Shortest Distance to Target String in a Circular Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Distance%20to%20Target%20String%20in%20a%20Circular%20Array.java) +496|[Cells in a Range on an Excel Sheet](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Cells%20in%20a%20Range%20on%20an%20Excel%20Sheet.java) +497|[Number of Common Factors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Common%20Factors.java) +498|[Keep Multiplying Found Values by Two](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Keep%20Multiplying%20Found%20Values%20by%20Two.java) +499|[Search in a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Search%20in%20a%20Binary%20Search%20Tree.java) +500|[Count Largest Group](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Largest%20Group.java) +501|[Sum of Unique Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Unique%20Elements.java) +502|[Moving Average from Data Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Moving%20Average%20from%20Data%20Stream.java) +503|[Symmetric Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Symmetric%20Tree.java) +504|[Maximum Product of Two Elements in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Product%20of%20Two%20Elements%20in%20an%20Array.java) +505|[Difference Between Element Sum and Digit Sum of an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Difference%20Between%20Element%20Sum%20and%20Digit%20Sum%20of%20an%20Array.java) +506|[Find Common Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Common%20Characters.java) +507|[Lucky Numbers in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Lucky%20Numbers%20in%20a%20Matrix.java) +508|[Remove Vowels from a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Vowels%20from%20a%20String.java) +509|[Add Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Add%20Digits.java) +510|[Teemo Attacking](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Teemo%20Attacking.java) +511|[Contains Duplicate II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Contains%20Duplicate%20II.java) +512|[Count Integers With Even Digit Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Integers%20With%20Even%20Digit%20Sum.java) +513|[Minimum Index Sum of Two Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Index%20Sum%20of%20Two%20Lists.java) +514|[Two Out of Three](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Out%20of%20Three.java) +515|[Closest Binary Search Tree Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Closest%20Binary%20Search%20Tree%20Value.java) +516|[Distribute Money to Maximum Children](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Distribute%20Money%20to%20Maximum%20Children.java) +517|[Sum of Digits in Base K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Digits%20in%20Base%20K.java) +518|[Fibonacci Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fibonacci%20Number.java) +519|[Distribute Candies to People](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Distribute%20Candies%20to%20People.java) +520|[Valid Word Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Word%20Square.java) +521|[Distribute Candies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Distribute%20Candies.java) +522|[Check If a Number Is Majority Element in a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20a%20Number%20Is%20Majority%20Element%20in%20a%20Sorted%20Array.java) +523|[Alternating Digit Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Alternating%20Digit%20Sum.java) +524|[Take Gifts From the Richest Pile](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Take%20Gifts%20From%20the%20Richest%20Pile.java) +525|[Verifying an Alien Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Verifying%20an%20Alien%20Dictionary.java) +526|[Longest Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Palindrome.java) +527|[Sum of All Odd Length Subarrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20All%20Odd%20Length%20Subarrays.java) +528|[Average Salary Excluding the Minimum and Maximum Salary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Average%20Salary%20Excluding%20the%20Minimum%20and%20Maximum%20Salary.java) +529|[Apply Operations to an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Apply%20Operations%20to%20an%20Array.java) +530|[Single Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Single%20Number.java) +531|[Keyboard Row](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Keyboard%20Row.java) +532|[Count Distinct Numbers on Board](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Distinct%20Numbers%20on%20Board.java) +533|[Squares of a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Squares%20of%20a%20Sorted%20Array.java) +534|[Find the Longest Balanced Substring of a Binary String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Longest%20Balanced%20Substring%20of%20a%20Binary%20String.java) +535|[Binary Tree Postorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Tree%20Postorder%20Traversal.java) +536|[Rearrange Spaces Between Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rearrange%20Spaces%20Between%20Words.java) +537|[Minimum Recolors to Get K Consecutive Black Blocks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Recolors%20to%20Get%20K%20Consecutive%20Black%20Blocks.java) +538|[Count Square Sum Triples](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Square%20Sum%20Triples.java) +539|[Maximum Distance in Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Distance%20in%20Arrays.java) +540|[Unique Number of Occurrences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Unique%20Number%20of%20Occurrences.java) +541|[Day of the Week](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Day%20of%20the%20Week.java) +542|[Design an Ordered Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20an%20Ordered%20Stream.java) +543|[Minimum Distance Between BST Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Distance%20Between%20BST%20Nodes.java) +544|[Maximum Sum With Exactly K Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Sum%20With%20Exactly%20K%20Elements.java) +545|[Number of Students Unable to Eat Lunch](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Students%20Unable%20to%20Eat%20Lunch.java) +546|[Check if Number Has Equal Digit Count and Digit Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Number%20Has%20Equal%20Digit%20Count%20and%20Digit%20Value.java) +547|[Sum Of Two Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20Of%20Two%20Integers.java) +548|[Check if a String Is an Acronym of Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20a%20String%20Is%20an%20Acronym%20of%20Words.java) +549|[Search Insert Position](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Search%20Insert%20Position.java) +550|[Max Pair Sum in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Max%20Pair%20Sum%20in%20an%20Array.java) +551|[Longest Univalue Path](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Univalue%20Path.java) +552|[Maximum Depth of N-ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Depth%20of%20N-ary%20Tree.java) +553|[Thousand Separator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Thousand%20Separator.java) +554|[Add Binary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Add%20Binary.java) +555|[Convert Binary Number in a Linked List to Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%20Binary%20Number%20in%20a%20Linked%20List%20to%20Integer.java) +556|[Sorting the Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sorting%20the%20Sentence.java) +557|[Replace Elements with Greatest Element on Right Side](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Replace%20Elements%20with%20Greatest%20Element%20on%20Right%20Side.java) +558|[Matrix Diagonal Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Matrix%20Diagonal%20Sum.java) +559|[Check Array Formation Through Concatenation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20Array%20Formation%20Through%20Concatenation.java) +560|[Water Bottles](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Water%20Bottles.java) +561|[Add to Array-Form of Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Add%20to%20Array-Form%20of%20Integer.java) +562|[Prime In Diagonal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Prime%20In%20Diagonal.java) +563|[Pass the Pillow](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Pass%20the%20Pillow.java) +564|[Missing Number In Arithmetic Progression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Missing%20Number%20In%20Arithmetic%20Progression.java) +565|[Divide Array Into Equal Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Divide%20Array%20Into%20Equal%20Pairs.java) +566|[Maximum Value of a String in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Value%20of%20a%20String%20in%20an%20Array.java) +567|[Maximum Number of Balls in a Box](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Balls%20in%20a%20Box.java) +568|[Mean of Array After Removing Some Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Mean%20of%20Array%20After%20Removing%20Some%20Elements.java) +569|[N-Repeated Element in Size 2N Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-Repeated%20Element%20in%20Size%202N%20Array.java) +570|[Redistribute Characters to Make All Strings Equal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Redistribute%20Characters%20to%20Make%20All%20Strings%20Equal.java) +571|[Remove All Adjacent Duplicates In String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20All%20Adjacent%20Duplicates%20In%20String.java) +572|[Minimum Absolute Difference in BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20%20Absolute%20Difference%20in%20BST.java) +573|[Image Smoother](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Image%20Smoother.java) +574|[Find the Difference of Two Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Difference%20of%20Two%20Arrays.java) +575|[How Many Apples Can You Put into the Basket](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/How%20Many%20Apples%20Can%20You%20Put%20into%20the%20Basket.java) +576|[Second Minimum Node in a binary tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Second%20Minimum%20Node%20in%20a%20binary%20tree.java) +577|[Excel Sheet Column Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Excel%20Sheet%20Column%20Number.java) +578|[Same Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Same%20Tree.java) +579|[Count Odd Numbers in an Interval Range](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Odd%20Numbers%20in%20an%20Interval%20Range.java) +580|[String Without AAA or BBB](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/String%20Without%20AAA%20or%20BBB.java) +581|[Find Greatest Common Divisor of Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Greatest%20Common%20Divisor%20of%20Array.java) +582|[Longest Word in Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Word%20in%20Dictionary.java) +583|[Happy Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Happy%20Number.java) +584|[Array Transformation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Array%20Transformation.java) +585|[Design Compressed String Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20Compressed%20String%20Iterator.java) +586|[Reverse words in a String III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20words%20in%20a%20String%20III.java) +587|[Rank Transform of an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rank%20Transform%20of%20an%20Array.java) +588|[First Bad Version](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/First%20Bad%20Version.java) +589|[Sort Integers by The Number of 1 Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Integers%20by%20The%20Number%20of%201%20Bits.java) +590|[Split With Minimum Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Split%20With%20Minimum%20Sum.java) +591|[Construct String from Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Construct%20String%20from%20Binary%20Tree.java) +592|[Maximum Number of Words Found in Sentences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Words%20Found%20in%20Sentences.java) +593|[Toeplitz Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Toeplitz%20Matrix.java) +594|[Find Maximum Number of String Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Maximum%20Number%20of%20String%20Pairs.java) +595|[Finding 3-Digit Even Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Finding%203-Digit%20Even%20Numbers.java) +596|[Valid Word Abbreviation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Word%20Abbreviation.java) +597|[Second Largest Digit in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Second%20Largest%20Digit%20in%20a%20String.java) +598|[Valid Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Palindrome.java) +599|[Relative Sort Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Relative%20Sort%20Array.java) +600|[Minimum Cuts to Divide a Circle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Cuts%20to%20Divide%20a%20Circle.java) +601|[Path In Zigzag Labelled Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Path%20In%20Zigzag%20Labelled%20Binary%20Tree.java) +602|[Shortest Completing Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Completing%20Word.java) +603|[Nim Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Nim%20Game.java) +604|[Count Substrings with Only One Distinct Letter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Substrings%20with%20Only%20One%20Distinct%20Letter.java) +605|[Average of Levels in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Average%20of%20Levels%20in%20Binary%20Tree.java) +606|[Merge Strings Alternately](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Strings%20Alternately.java) diff --git a/Hard/README.md b/Hard/README.md index e97d573a..0e44bb8b 100644 --- a/Hard/README.md +++ b/Hard/README.md @@ -1,113 +1,127 @@ -# Hard LeetCode Java Solutions +# Hard LeetCode-Java-Solutions S.no | Coding Problem --- | --- -1 | [Add Edges to Make Degrees of All Nodes Even](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Add%20Edges%20to%20Make%20Degrees%20of%20All%20Nodes%20Even.java) -2 | [Alien Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Alien%20Dictionary.java) -3 | [Basic Calculator III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Basic%20Calculator%20III.java) -4 | [Basic Calculator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Basic%20Calculator.java) -5 | [Best Time to Buy and Sell Stock IV](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Best%20Time%20to%20Buy%20and%20Sell%20Stock%20IV.java) -6 | [Binary Tree Cameras](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Binary%20Tree%20Cameras.java) -7 | [Binary Tree Maximum Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Binary%20Tree%20Maximum%20Path%20Sum.java) -8 | [Candy](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Candy.java) -9 | [Checking Existence of Edge Length Limited Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Checking%20Existence%20of%20Edge%20Length%20Limited%20Paths.java) -10 | [Closest Binary Search Tree Values II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Closest%20Binary%20Search%20Tree%20Values%20II.java) -11 | [Concatenated Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Concatenated%20Words.java) -12 | [Construct Target Array With Multiple Sums](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Construct%20Target%20Array%20With%20Multiple%20Sums.java) -13 | [Count Subarrays With Fixed Bounds](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Count%20Subarrays%20With%20Fixed%20Bounds.java) -14 | [Count Vowels Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Count%20Vowels%20Permutation.java) -15 | [Count of Smaller Numbers After Self](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Count%20of%20Smaller%20Numbers%20After%20Self.java) -16 | [Course Schedule III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Course%20Schedule%20III.java) -17 | [Critical Connections in a Network](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Critical%20Connections%20in%20a%20Network.java) -18 | [Cut Off Trees for Golf Event](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Cut%20Off%20Trees%20for%20Golf%20Event.java) -19 | [Design In-Memory File System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Design%20In-Memory%20File%20System.java) -20 | [Design Movie Rental System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Design%20Movie%20Rental%20System.java) -21 | [Design Search Autocomplete System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Design%20Search%20Autocomplete%20System.java) -22 | [Design Skiplist](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Design%20Skiplist.java) -23 | [Dice Roll Simulation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Dice%20Roll%20Simulation.java) -24 | [Divide Array Into Increasing Sequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Divide%20Array%20Into%20Increasing%20Sequences.java) -25 | [Edit Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Edit%20Distance.java) -26 | [Employee Free Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Employee%20Free%20Time.java) -27 | [Expression Add Operators](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Expression%20Add%20Operators.java) -28 | [Find Median from Data Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Find%20Median%20from%20Data%20Stream.java) -29 | [Find Minimum in Rotated Sorted Array II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Find%20Minimum%20in%20Rotated%20Sorted%20Array%20II.java) -30 | [Find the Kth Smallest Sum of a Matrix With Sorted Rows](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Find%20the%20Kth%20Smallest%20Sum%20of%20a%20Matrix%20With%20Sorted%20Rows.java) -31 | [First Missing Positive](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/First%20Missing%20Positive.java) -32 | [Frog Jump](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Frog%20Jump.java) -33 | [IPO](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/IPO.java) -34 | [Insert Delete GetRandom O(1) - Duplicates Allowed](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Insert%20Delete%20GetRandom%20O(1)%20-%20Duplicates%20Allowed.java) -35 | [Integer to English Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Integer%20to%20English%20Words.java) -36 | [Jump Game IV](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Jump%20Game%20IV.java) -37 | [K Empty Slots](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/K%20Empty%20Slots.java) -38 | [K Inverse Pairs Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/K%20Inverse%20Pairs%20Array.java) -39 | [Kth Smallest Number in Multiplication Table](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Kth%20Smallest%20Number%20in%20Multiplication%20Table.java) -40 | [LFU Cache](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/LFU%20Cache.java) -41 | [Largest Color Value in a Directed Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Largest%20Color%20Value%20in%20a%20Directed%20Graph.java) -42 | [Largest Rectangle in Histogram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Largest%20Rectangle%20in%20Histogram.java) -43 | [Longest Cycle in a Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Longest%20Cycle%20in%20a%20Graph.java) -44 | [Longest Increasing Path in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Longest%20Increasing%20Path%20in%20a%20Matrix.java) -45 | [Longest Palindrome Product](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Longest%20Palindrome%20Product.java) -46 | [Longest Valid Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Longest%20Valid%20Parentheses.java) -47 | [Max Points on a Line](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Max%20Points%20on%20a%20Line.java) -48 | [Max Stack](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Max%20Stack.java) -49 | [Maximum Frequency Stack](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Frequency%20Stack.java) -50 | [Maximum Number of Non-Overlapping Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Number%20of%20Non-Overlapping%20Substrings.java) -51 | [Maximum Performance of a Team](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Performance%20of%20a%20Team.java) -52 | [Maximum Profit in Job Scheduling](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Profit%20in%20Job%20Scheduling.java) -53 | [Maximum Sum BST in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Sum%20BST%20in%20Binary%20Tree.java) -54 | [Maximum Value of K Coins From Piles](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Value%20of%20K%20Coins%20From%20Piles.java) -55 | [Median of Two Sorted Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Median%20of%20Two%20Sorted%20Arrays.java) -56 | [Merge K Sorted Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Merge%20K%20Sorted%20Lists.java) -57 | [Minimize Deviation in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimize%20Deviation%20in%20Array.java) -58 | [Minimum Cost to Hire K Workers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Cost%20to%20Hire%20K%20Workers.java) -59 | [Minimum Difficulty of a Job Schedule](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Difficulty%20of%20a%20Job%20Schedule.java) -60 | [Minimum Insertion Steps to Make a String Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Insertion%20Steps%20to%20Make%20a%20String%20Palindrome.java) -61 | [Minimum Number of Refueling Stops](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Number%20of%20Refueling%20Stops.java) -62 | [Minimum Window Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Window%20Subsequence.java) -63 | [Minimum Window Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Window%20Substring.java) -64 | [My Calendar III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/My%20Calendar%20III.java) -65 | [N-Queens II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/N-Queens%20II.java) -66 | [N-Queens](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/N-Queens.java) -67 | [Naming a Company](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Naming%20a%20Company.java) -68 | [Number of Paths with Max Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Paths%20with%20Max%20Score.java) -69 | [Number of Squareful Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Squareful%20Arrays.java) -70 | [Number of Submatrices That Sum to Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Submatrices%20That%20Sum%20to%20Target.java) -71 | [Number of Valid Subarrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Valid%20Subarrays.java) -72 | [Number of Ways of Cutting a Pizza](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Ways%20of%20Cutting%20a%20Pizza.java) -73 | [Number of Ways to Form a Target String Given a Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Ways%20to%20Form%20a%20Target%20String%20Given%20a%20Dictionary.java) -74 | [Odd Even Jump](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Odd%20Even%20Jump.java) -75 | [Optimal Account Balancing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Optimal%20Account%20Balancing.java) -76 | [Paint House III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Paint%20House%20III.java) -77 | [Palindrome Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Palindrome%20Pairs.java) -78 | [Parsing A Boolean Expression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Parsing%20A%20Boolean%20Expression.java) -79 | [Perfect Rectangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Perfect%20Rectangle.java) -80 | [Poor Pigs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Poor%20Pigs.java) -81 | [Prefix and Suffix Search](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Prefix%20and%20Suffix%20Search.java) -82 | [Profitable Schemes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Profitable%20Schemes.java) -83 | [Reconstruct Itinerary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Reconstruct%20Itinerary.java) -84 | [Recover a Tree From Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Recover%20a%20Tree%20From%20Preorder%20Traversal.java) -85 | [Reducing Dishes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Reducing%20Dishes.java) -86 | [Remove Invalid Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Remove%20Invalid%20Parentheses.java) -87 | [Restore The Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Restore%20The%20Array.java) -88 | [Reverse Nodes in k-Group](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Reverse%20Nodes%20in%20k-Group.java) -89 | [Robot Room Cleaner](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Robot%20Room%20Cleaner.java) -90 | [Scramble String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Scramble%20String.java) -91 | [Serialize and Deserialize N-ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Serialize%20and%20Deserialize%20N-ary%20Tree.java) -92 | [Serialize and Deserialize a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Serialize%20and%20Deserialize%20a%20Binary%20Tree.java) -93 | [Shortest Distance from All Buildings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Shortest%20Distance%20from%20All%20Buildings.java) -94 | [Similar String Groups](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Similar%20String%20Groups.java) -95 | [Sliding Window Maximum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Sliding%20Window%20Maximum.java) -96 | [Sliding Window Median](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Sliding%20Window%20Median.java) -97 | [Stamping The Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Stamping%20The%20Sequence.java) -98 | [Stream of Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Stream%20of%20Characters.java) -99 | [String Compression II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/String%20Compression%20II.java) -100 | [Subarrays with K Different Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Subarrays%20with%20K%20Different%20Integers.java) -101 | [Substring with Concatenation of All Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Substring%20with%20Concatenation%20of%20All%20Words.java) -102 | [Text Justification](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Text%20Justification.java) -103 | [The Skyline Problem](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/The%20Skyline%20Problem.java) -104 | [Trapping Rain Water](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Trapping%20Rain%20Water.java) -105 | [Unique Paths III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Unique%20Paths%20III.java) -106 | [Valid Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Valid%20Number.java) -107 | [Vertical Order Traversal Of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Vertical%20Order%20Traversal%20Of%20a%20Binary%20Tree.java) -108 | [Wildcard Matching](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Wildcard%20Matching.java) -109 | [Word Break II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Word%20Break%20II.java) -110 | [Word Search II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Word%20Search%20II.java) +1|[Concatenated Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Concatenated%20Words.java) +2|[Minimum Cost to Make Array Equal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Cost%20to%20Make%20Array%20Equal.java) +3|[Max Stack](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Max%20Stack.java) +4|[Course Schedule III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Course%20Schedule%20III.java) +5|[Binary Tree Cameras](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Binary%20Tree%20Cameras.java) +6|[Remove Invalid Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Remove%20Invalid%20Parentheses.java) +7|[First Missing Positive](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/First%20Missing%20Positive.java) +8|[Reconstruct Itinerary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Reconstruct%20Itinerary.java) +9|[Frog Jump](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Frog%20Jump.java) +10|[Sort Items by Groups Respecting Dependencies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Sort%20Items%20by%20Groups%20Respecting%20Dependencies.java) +11|[Shortest Path Visiting All Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Shortest%20Path%20Visiting%20All%20Nodes.java) +12|[Critical Connections in a Network](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Critical%20Connections%20in%20a%20Network.java) +13|[Sliding Window Median](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Sliding%20Window%20Median.java) +14|[Edit Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Edit%20Distance.java) +15|[Checking Existence of Edge Length Limited Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Checking%20Existence%20of%20Edge%20Length%20Limited%20Paths.java) +16|[Perfect Rectangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Perfect%20Rectangle.java) +17|[Minimum Window Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Window%20Subsequence.java) +18|[Remove Max Number of Edges to Keep Graph Fully Traversable](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Remove%20Max%20Number%20of%20Edges%20to%20Keep%20Graph%20Fully%20Traversable.java) +19|[K Inverse Pairs Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/K%20Inverse%20Pairs%20Array.java) +20|[Merge K Sorted Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Merge%20K%20Sorted%20Lists.java) +21|[Minimum Replacements to Sort the Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Replacements%20to%20Sort%20the%20Array.java) +22|[Design Movie Rental System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Design%20Movie%20Rental%20System.java) +23|[Sliding Window Maximum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Sliding%20Window%20Maximum.java) +24|[My Calendar III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/My%20Calendar%20III.java) +25|[Longest Cycle in a Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Longest%20Cycle%20in%20a%20Graph.java) +26|[Text Justification](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Text%20Justification.java) +27|[Design In-Memory File System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Design%20In-Memory%20File%20System.java) +28|[Basic Calculator III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Basic%20Calculator%20III.java) +29|[Integer to English Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Integer%20to%20English%20Words.java) +30|[Naming a Company](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Naming%20a%20Company.java) +31|[Minimum Number of Refueling Stops](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Number%20of%20Refueling%20Stops.java) +32|[Rearrange String k Distance Apart](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Rearrange%20String%20k%20Distance%20Apart.java) +33|[Make Array Strictly Increasing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Make%20Array%20Strictly%20Increasing.java) +34|[Median of Two Sorted Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Median%20of%20Two%20Sorted%20Arrays.java) +35|[Vertical Order Traversal Of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Vertical%20Order%20Traversal%20Of%20a%20Binary%20Tree.java) +36|[Divide Array Into Increasing Sequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Divide%20Array%20Into%20Increasing%20Sequences.java) +37|[Word Break II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Word%20Break%20II.java) +38|[Maximum Number of Non-Overlapping Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Number%20of%20Non-Overlapping%20Substrings.java) +39|[Paint House II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Paint%20House%20II.java) +40|[Subarrays with K Different Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Subarrays%20with%20K%20Different%20Integers.java) +41|[Maximum Performance of a Team](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Performance%20of%20a%20Team.java) +42|[Jump Game IV](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Jump%20Game%20IV.java) +43|[Paint House III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Paint%20House%20III.java) +44|[LFU Cache](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/LFU%20Cache.java) +45|[Scramble String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Scramble%20String.java) +46|[Word Search II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Word%20Search%20II.java) +47|[K Empty Slots](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/K%20Empty%20Slots.java) +48|[Employee Free Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Employee%20Free%20Time.java) +49|[Maximize Score After N Operations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximize%20Score%20After%20N%20Operations.java) +50|[Max Points on a Line](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Max%20Points%20on%20a%20Line.java) +51|[The Skyline Problem](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/The%20Skyline%20Problem.java) +52|[N-Queens](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/N-Queens.java) +53|[Longest Palindrome Product](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Longest%20Palindrome%20Product.java) +54|[Odd Even Jump](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Odd%20Even%20Jump.java) +55|[Palindrome Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Palindrome%20Pairs.java) +56|[Stream of Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Stream%20of%20Characters.java) +57|[Cut Off Trees for Golf Event](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Cut%20Off%20Trees%20for%20Golf%20Event.java) +58|[Kth Smallest Number in Multiplication Table](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Kth%20Smallest%20Number%20in%20Multiplication%20Table.java) +59|[String Compression II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/String%20Compression%20II.java) +60|[Minimize Deviation in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimize%20Deviation%20in%20Array.java) +61|[Minimum Cost to Hire K Workers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Cost%20to%20Hire%20K%20Workers.java) +62|[Find the Longest Valid Obstacle Course at Each Position](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Find%20the%20Longest%20Valid%20Obstacle%20Course%20at%20Each%20Position.java) +63|[Number of Valid Subarrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Valid%20Subarrays.java) +64|[Maximum Value of K Coins From Piles](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Value%20of%20K%20Coins%20From%20Piles.java) +65|[Substring with Concatenation of All Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Substring%20with%20Concatenation%20of%20All%20Words.java) +66|[Number of Paths with Max Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Paths%20with%20Max%20Score.java) +67|[Profitable Schemes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Profitable%20Schemes.java) +68|[Design Search Autocomplete System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Design%20Search%20Autocomplete%20System.java) +69|[Number of Squareful Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Squareful%20Arrays.java) +70|[N-Queens II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/N-Queens%20II.java) +71|[Robot Room Cleaner](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Robot%20Room%20Cleaner.java) +72|[Poor Pigs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Poor%20Pigs.java) +73|[Minimum Window Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Window%20Substring.java) +74|[Number of Ways of Cutting a Pizza](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Ways%20of%20Cutting%20a%20Pizza.java) +75|[Hard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Hard.md) +76|[Parsing A Boolean Expression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Parsing%20A%20Boolean%20Expression.java) +77|[Trapping Rain Water](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Trapping%20Rain%20Water.java) +78|[Similar String Groups](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Similar%20String%20Groups.java) +79|[Number of Ways to Form a Target String Given a Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Ways%20to%20Form%20a%20Target%20String%20Given%20a%20Dictionary.java) +80|[Find the Kth Smallest Sum of a Matrix With Sorted Rows](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Find%20the%20Kth%20Smallest%20Sum%20of%20a%20Matrix%20With%20Sorted%20Rows.java) +81|[Optimal Account Balancing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Optimal%20Account%20Balancing.java) +82|[Design Skiplist](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Design%20Skiplist.java) +83|[Wildcard Matching](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Wildcard%20Matching.java) +84|[Expression Add Operators](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Expression%20Add%20Operators.java) +85|[Count of Smaller Numbers After Self](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Count%20of%20Smaller%20Numbers%20After%20Self.java) +86|[Number of Ways to Reorder Array to Get Same BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Ways%20to%20Reorder%20Array%20to%20Get%20Same%20BST.java) +87|[Find Median from Data Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Find%20Median%20from%20Data%20Stream.java) +88|[Best Time to Buy and Sell Stock IV](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Best%20Time%20to%20Buy%20and%20Sell%20Stock%20IV.java) +89|[Find Minimum in Rotated Sorted Array II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Find%20Minimum%20in%20Rotated%20Sorted%20Array%20II.java) +90|[Longest Valid Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Longest%20Valid%20Parentheses.java) +91|[Stone Game III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Stone%20Game%20III.java) +92|[Reducing Dishes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Reducing%20Dishes.java) +93|[Count Subarrays With Fixed Bounds](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Count%20Subarrays%20With%20Fixed%20Bounds.java) +94|[Stamping The Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Stamping%20The%20Sequence.java) +95|[Number of Submatrices That Sum to Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Submatrices%20That%20Sum%20to%20Target.java) +96|[Candy](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Candy.java) +97|[Minimum Insertion Steps to Make a String Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Insertion%20Steps%20to%20Make%20a%20String%20Palindrome.java) +98|[Shortest Distance from All Buildings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Shortest%20Distance%20from%20All%20Buildings.java) +99|[Recover a Tree From Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Recover%20a%20Tree%20From%20Preorder%20Traversal.java) +100|[Count Vowels Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Count%20Vowels%20Permutation.java) +101|[Longest Increasing Path in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Longest%20Increasing%20Path%20in%20a%20Matrix.java) +102|[Maximum Profit in Job Scheduling](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Profit%20in%20Job%20Scheduling.java) +103|[Closest Binary Search Tree Values II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Closest%20Binary%20Search%20Tree%20Values%20II.java) +104|[Basic Calculator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Basic%20Calculator.java) +105|[Alien Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Alien%20Dictionary.java) +106|[Prefix and Suffix Search](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Prefix%20and%20Suffix%20Search.java) +107|[Construct Target Array With Multiple Sums](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Construct%20Target%20Array%20With%20Multiple%20Sums.java) +108|[Tallest Billboard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Tallest%20Billboard.java) +109|[Largest Color Value in a Directed Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Largest%20Color%20Value%20in%20a%20Directed%20Graph.java) +110|[Valid Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Valid%20Number.java) +111|[Dice Roll Simulation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Dice%20Roll%20Simulation.java) +112|[Maximum Frequency Stack](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Frequency%20Stack.java) +113|[Reverse Nodes in k-Group](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Reverse%20Nodes%20in%20k-Group.java) +114|[Serialize and Deserialize N-ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Serialize%20and%20Deserialize%20N-ary%20Tree.java) +115|[Serialize and Deserialize a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Serialize%20and%20Deserialize%20a%20Binary%20Tree.java) +116|[Minimum Difficulty of a Job Schedule](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Difficulty%20of%20a%20Job%20Schedule.java) +117|[Unique Paths III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Unique%20Paths%20III.java) +118|[Restore The Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Restore%20The%20Array.java) +119|[IPO](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/IPO.java) +120|[Insert Delete GetRandom O(1) - Duplicates Allowed](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Insert%20Delete%20GetRandom%20O(1)%20-%20Duplicates%20Allowed.java) +121|[Add Edges to Make Degrees of All Nodes Even](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Add%20Edges%20to%20Make%20Degrees%20of%20All%20Nodes%20Even.java) +122|[Maximum Sum BST in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Sum%20BST%20in%20Binary%20Tree.java) +123|[Binary Tree Maximum Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Binary%20Tree%20Maximum%20Path%20Sum.java) +124|[Largest Rectangle in Histogram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Largest%20Rectangle%20in%20Histogram.java) diff --git a/Medium/README.md b/Medium/README.md index 0d6a9299..cb496742 100644 --- a/Medium/README.md +++ b/Medium/README.md @@ -1,756 +1,795 @@ -# Medium LeetCode Java Solutions +# Medium LeetCode-Java-Solutions S.no | Coding Problem --- | --- -1 | [01 Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/01%20Matrix.java) -2 | [132 Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/132%20Pattern.java) -3 | [3Sum Closest](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/3Sum%20Closest.java) -4 | [3Sum Smaller](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/3Sum%20Smaller.java) -5 | [3Sum With Multiplicity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/3Sum%20With%20Multiplicity.java) -6 | [3Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/3Sum.java) -7 | [4 Keys Keyboard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/4%20Keys%20Keyboard.java) -8 | [4 Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/4%20Sum%20II.java) -9 | [4Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/4Sum%20II.java) -10 | [4Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/4Sum.java) -11 | [Accounts Merge](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Accounts%20Merge.java) -12 | [Add Bold Tag in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20Bold%20Tag%20in%20String.java) -13 | [Add Minimum Number of Rungs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20Minimum%20Number%20of%20Rungs.java) -14 | [Add One Row to Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20One%20Row%20to%20Tree.java) -15 | [Add Two Numbers II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20Two%20Numbers%20II.java) -16 | [Add Two Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20Two%20Numbers.java) -17 | [Adding Spaces to a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Adding%20Spaces%20to%20a%20String.java) -18 | [Adding Two Negabinary Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Adding%20Two%20Negabinary%20Numbers.java) -19 | [Advantage Shuffle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Advantage%20Shuffle.java) -20 | [Alert Using Same Key-Card Three or More Times in a One Hour Period](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Alert%20Using%20Same%20Key-Card%20Three%20or%20More%20Times%20in%20a%20One%20Hour%20Period.java) -21 | [All Ancestors of a Node in a Directed Acyclic Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Ancestors%20of%20a%20Node%20in%20a%20Directed%20Acyclic%20Graph.java) -22 | [All Divisions With the Highest Score of a Binary Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Divisions%20With%20the%20Highest%20Score%20of%20a%20Binary%20Array.java) -23 | [All Elements in Two Binary Search Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Elements%20in%20Two%20Binary%20Search%20Trees.java) -24 | [All Nodes Distance K in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Nodes%20Distance%20K%20in%20Binary%20Tree.java) -25 | [All Paths From Source to Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Paths%20From%20Source%20to%20Target.java) -26 | [All Paths from Source Lead to Destination](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Paths%20from%20Source%20Lead%20to%20Destination.java) -27 | [All Possible Full Binary Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Possible%20Full%20Binary%20Trees.java) -28 | [Analyze User Website Visit Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Analyze%20User%20Website%20Visit%20Pattern.java) -29 | [Angle Between Hands of a Clock](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Angle%20Between%20Hands%20of%20a%20Clock.java) -30 | [Append Characters to String to Make Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Append%20Characters%20to%20String%20to%20Make%20Subsequence.java) -31 | [Append K Integers With Minimal Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Append%20K%20Integers%20With%20Minimal%20Sum.java) -32 | [Apply Discount Every n Orders](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Apply%20Discount%20Every%20n%20Orders.java) -33 | [Apply Discount to Prices](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Apply%20Discount%20to%20Prices.java) -34 | [Arithmetic Slices](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Arithmetic%20Slices.java) -35 | [Arithmetic Subarrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Arithmetic%20Subarrays.java) -36 | [Array Circular Loop](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Array%20Circular%20Loop.java) -37 | [Array Nesting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Array%20Nesting.java) -38 | [As Far from Land as Possible](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/As%20Far%20from%20Land%20as%20Possible.java) -39 | [Asteroid Collision](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Asteroid%20Collision.java) -40 | [Average Waiting Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Average%20Waiting%20Time.java) -41 | [Bag of Tokens](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Bag%20of%20Tokens.java) -42 | [Balance a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Balance%20a%20Binary%20Search%20Tree.java) -43 | [Basic Calculator II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Basic%20Calculator%20II.java) -44 | [Battleships in a board](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Battleships%20in%20a%20board.java) -45 | [Best Time to Buy and Sell Stock II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Best%20Time%20to%20Buy%20and%20Sell%20Stock%20II.java) -46 | [Best Time to Buy and Sell Stock with Cooldown](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Best%20Time%20to%20Buy%20and%20Sell%20Stock%20with%20Cooldown.java) -47 | [Binary Search Tree Iterator II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Search%20Tree%20Iterator%20II.java) -48 | [Binary Search Tree Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Search%20Tree%20Iterator.java) -49 | [Binary Search Tree to Greater Sum Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Search%20Tree%20to%20Greater%20Sum%20Tree.java) -50 | [Binary Tree Coloring Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Coloring%20Game.java) -51 | [Binary Tree Level Order Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Level%20Order%20Traversal.java) -52 | [Binary Tree Longest Consecutive Sequence II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Longest%20Consecutive%20Sequence%20II.java) -53 | [Binary Tree Longest Consecutive Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Longest%20Consecutive%20Sequence.java) -54 | [Binary Tree Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Preorder%20Traversal.java) -55 | [Binary Tree Pruning](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Pruning.java) -56 | [Binary Tree Right Side View](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Right%20Side%20View.java) -57 | [Binary Tree Upside Down](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Upside%20Down.java) -58 | [Binary Tree Vertical Order Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Vertical%20Order%20Traversal.java) -59 | [Binary Tree Zigzag Level Order Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Zigzag%20Level%20Order%20Traversal.java) -60 | [Binary Trees With Factors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Trees%20With%20Factors.java) -61 | [Bitwise AND of Numbers Range](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Bitwise%20AND%20of%20Numbers%20Range.java) -62 | [Boats to Save People](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Boats%20to%20Save%20People.java) -63 | [Bold Words in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Bold%20Words%20in%20String.java) -64 | [Bomb Enemy](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Bomb%20Enemy.java) -65 | [Boundary of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Boundary%20of%20Binary%20Tree.java) -66 | [Brace Expansion](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Brace%20Expansion.java) -67 | [Break a Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Break%20a%20Palindrome.java) -68 | [Broken Calculator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Broken%20Calculator.java) -69 | [Buildings With an Ocean View](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Buildings%20With%20an%20Ocean%20View.java) -70 | [Bulb Switcher](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Bulb%20Switcher.java) -71 | [Camelcase Matching](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Camelcase%20Matching.java) -72 | [Campus Bikes II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Campus%20Bikes%20II.java) -73 | [Campus Bikes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Campus%20Bikes.java) -74 | [Can Convert String in K Moves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Can%20Convert%20String%20in%20K%20Moves.java) -75 | [Can Make Palindrome from Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Can%20Make%20Palindrome%20from%20Substring.java) -76 | [Candy Crush](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Candy%20Crush.java) -77 | [Capacity To Ship Packages Within D Days](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Capacity%20To%20Ship%20Packages%20Within%20D%20Days.java) -78 | [Car Pooling](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Car%20Pooling.java) -79 | [Champagne Tower](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Champagne%20Tower.java) -80 | [Cheapest Flights Within K Stops](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Cheapest%20Flights%20Within%20K%20Stops.java) -81 | [Check Completeness of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20Completeness%20of%20a%20Binary%20Tree.java) -82 | [Check If All 1's Are at Least Length K Places Away](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20If%20All%201's%20Are%20at%20Least%20Length%20K%20Places%20Away.java) -83 | [Check If a String Can Break Another String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20If%20a%20String%20Can%20Break%20Another%20String.java) -84 | [Check If a String Contains All Binary Codes of Size K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20If%20a%20String%20Contains%20All%20Binary%20Codes%20of%20Size%20K.java) -85 | [Check If a String Is a Valid Sequence from Root to Leaves Path in a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20If%20a%20String%20Is%20a%20Valid%20Sequence%20from%20Root%20to%20Leaves%20Path%20in%20a%20Binary%20Tree.java) -86 | [Check if There is a Valid Path in a Grid](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20if%20There%20is%20a%20Valid%20Path%20in%20a%20Grid.java) -87 | [Cinema Seat Allocation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Cinema%20Seat%20Allocation.java) -88 | [Clone Binary Tree With Random Pointer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Clone%20Binary%20Tree%20With%20Random%20Pointer.java) -89 | [Clone Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Clone%20Graph.java) -90 | [Clone N-ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Clone%20N-ary%20Tree.java) -91 | [Closest Nodes Queries in a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Closest%20Nodes%20Queries%20in%20a%20Binary%20Search%20Tree.java) -92 | [Coin Change 2](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Coin%20Change%202.java) -93 | [Coin Change](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Coin%20Change.java) -94 | [Combination Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Combination%20Sum%20II.java) -95 | [Combination Sum III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Combination%20Sum%20III.java) -96 | [Combination Sum IV](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Combination%20Sum%20IV.java) -97 | [Combination Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Combination%20Sum.java) -98 | [Combinations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Combinations.java) -99 | [Compare Version Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Compare%20Version%20Numbers.java) -100 | [Complete Binary Tree Insertor](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Complete%20Binary%20Tree%20Insertor.java) -101 | [Complex Number Multiplication](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Complex%20Number%20Multiplication.java) -102 | [Concatenation of Consecutive Binary Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Concatenation%20of%20Consecutive%20Binary%20Numbers.java) -103 | [Connecting Cities With Minimum Cost](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Connecting%20Cities%20With%20Minimum%20Cost.java) -104 | [Construct Binary Search Tree from Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20Binary%20Search%20Tree%20from%20Preorder%20Traversal.java) -105 | [Construct Binary Tree from Inorder and Postorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20Binary%20Tree%20from%20Inorder%20and%20Postorder%20Traversal.java) -106 | [Construct Binary Tree from Preorder and Inorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20Binary%20Tree%20from%20Preorder%20and%20Inorder%20Traversal.java) -107 | [Construct K Palindrome Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20K%20Palindrome%20Strings.java) -108 | [Construct Quad Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20Quad%20Tree.java) -109 | [Construct String With Repeat Limit](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20String%20With%20Repeat%20Limit.java) -110 | [Container With Most Water](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Container%20With%20Most%20Water.java) -111 | [Contains Duplicate III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Contains%20Duplicate%20III.java) -112 | [Contiguous Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Contiguous%20Array.java) -113 | [Continuous Subarray Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Continuous%20Subarray%20Sum.java) -114 | [Convert Binary Search Tree to Sorted Doubly Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Convert%20Binary%20Search%20Tree%20to%20Sorted%20Doubly%20Linked%20List.java) -115 | [Convert Sorted List to Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Convert%20Sorted%20List%20to%20Binary%20Search%20Tree.java) -116 | [Convert an Array Into a 2D Array With Conditions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Convert%20an%20Array%20Into%20a%202D%20Array%20With%20Conditions.java) -117 | [Copy List with Random Pointer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Copy%20List%20with%20Random%20Pointer.java) -118 | [Corporate Flight Bookings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Corporate%20Flight%20Bookings.java) -119 | [Count Collisions on a Road](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Collisions%20on%20a%20Road.java) -120 | [Count Complete Tree Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Complete%20Tree%20Nodes.java) -121 | [Count Good Nodes in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Good%20Nodes%20in%20Binary%20Tree.java) -122 | [Count Nodes Equal to Average of Subtree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Nodes%20Equal%20to%20Average%20of%20Subtree.java) -123 | [Count Nodes Equal to Sum of Descendants](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Nodes%20Equal%20to%20Sum%20of%20Descendants.java) -124 | [Count Number of Bad Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Number%20of%20Bad%20Pairs.java) -125 | [Count Number of Distinct Integers After Reverse Operations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Number%20of%20Distinct%20Integers%20After%20Reverse%20Operations.java) -126 | [Count Number of Homogenous Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Number%20of%20Homogenous%20Substrings.java) -127 | [Count Number of Teams](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Number%20of%20Teams.java) -128 | [Count Numbers With Unique Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Numbers%20With%20Unique%20Digits.java) -129 | [Count Servers That Communicate](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Servers%20That%20Communicate.java) -130 | [Count Sorted Vowel Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Sorted%20Vowel%20Strings.java) -131 | [Count Square Submatrices with All Ones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Square%20Submatrices%20with%20All%20Ones.java) -132 | [Count Sub Islands](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Sub%20Islands.java) -133 | [Count Submatrices With All Ones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Submatrices%20With%20All%20Ones.java) -134 | [Count Univalue Subtrees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Univalue%20Subtrees.java) -135 | [Count Unreachable Pairs of Nodes in an Undirected Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Unreachable%20Pairs%20of%20Nodes%20in%20an%20Undirected%20Graph.java) -136 | [Count Vowel Strings in Ranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Vowel%20Strings%20in%20Ranges.java) -137 | [Count and Say](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20and%20Say.java) -138 | [Course Schedule II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Course%20Schedule%20II.java) -139 | [Course Schedule](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Course%20Schedule.java) -140 | [Create Binary Tree From Descriptions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Create%20Binary%20Tree%20From%20Descriptions.java) -141 | [Custom Sort String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Custom%20Sort%20String.java) -142 | [Daily Temperatures](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Daily%20Temperatures.java) -143 | [Decode String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Decode%20String.java) -144 | [Decode Ways](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Decode%20Ways.java) -145 | [Decrease Elements To Make Array Zigzag](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Decrease%20Elements%20To%20Make%20Array%20Zigzag.java) -146 | [Deepest Leaves Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Deepest%20Leaves%20Sum.java) -147 | [Delete Leaves With a Given Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Leaves%20With%20a%20Given%20Value.java) -148 | [Delete Node in a BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Node%20in%20a%20BST.java) -149 | [Delete Nodes And Return Forest](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Nodes%20And%20Return%20Forest.java) -150 | [Delete Operation for Two Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Operation%20for%20Two%20Strings.java) -151 | [Delete Tree Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Tree%20Nodes.java) -152 | [Delete the Middle Node of a Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20the%20Middle%20Node%20of%20a%20Linked%20List.java) -153 | [Design A Leaderboard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20A%20Leaderboard.java) -154 | [Design Add and Search Words Data Structure](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Add%20and%20Search%20Words%20Data%20Structure.java) -155 | [Design Authentication Manager](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Authentication%20Manager.java) -156 | [Design Browser History](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Browser%20History.java) -157 | [Design Circular Deque](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Circular%20Deque.java) -158 | [Design Circular Queue](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Circular%20Queue.java) -159 | [Design File System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20File%20System.java) -160 | [Design Front Middle Back Queue](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Front%20Middle%20Back%20Queue.java) -161 | [Design Hit Counter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Hit%20Counter.java) -162 | [Design Log Storage System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Log%20Storage%20System.java) -163 | [Design Phone Directory](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Phone%20Directory.java) -164 | [Design SQL](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20SQL.java) -165 | [Design Snake Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Snake%20Game.java) -166 | [Design Tic-Tac-Toe](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Tic-Tac-Toe.java) -167 | [Design Twitter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Twitter.java) -168 | [Design Underground System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Underground%20System.java) -169 | [Design a File Sharing System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20a%20File%20Sharing%20System.java) -170 | [Design a Stack With Increment Operation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20a%20Stack%20With%20Increment%20Operation.java) -171 | [Design an ATM Machine](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20an%20ATM%20Machine.java) -172 | [Design an Expression Tree With Evaluate Function](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20an%20Expression%20Tree%20With%20Evaluate%20Function.java) -173 | [Determine if Two Strings Are Close](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Determine%20if%20Two%20Strings%20Are%20Close.java) -174 | [Diagonal Traverse](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Diagonal%20Traverse.java) -175 | [Diameter of N-ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Diameter%20of%20N-ary%20Tree.java) -176 | [Display Table of Food Orders in a Restaurant](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Display%20Table%20of%20Food%20Orders%20in%20a%20Restaurant.java) -177 | [Distribute Coins in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Distribute%20Coins%20in%20Binary%20Tree.java) -178 | [Divide Array in Sets of K Consecutive Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Divide%20Array%20in%20Sets%20of%20K%20Consecutive%20Numbers.java) -179 | [Divide Players Into Teams of Equal Skill](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Divide%20Players%20Into%20Teams%20of%20Equal%20Skill.java) -180 | [Divide Two Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Divide%20Two%20Integers.java) -181 | [Dot Product of Two Sparse Vectors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Dot%20Product%20of%20Two%20Sparse%20Vectors.java) -182 | [Encode and Decode Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Encode%20and%20Decode%20Strings.java) -183 | [Encode and Decode TinyURL](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Encode%20and%20Decode%20TinyURL.java) -184 | [Equal Row and Column Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Equal%20Row%20and%20Column%20Pairs.java) -185 | [Escape The Ghosts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Escape%20The%20Ghosts.java) -186 | [Evaluate Division](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Evaluate%20Division.java) -187 | [Evaluate Reverse Polish Notation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Evaluate%20Reverse%20Polish%20Notation.java) -188 | [Evaluate the Bracket Pairs of a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Evaluate%20the%20Bracket%20Pairs%20of%20a%20String.java) -189 | [Even Odd Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Even%20Odd%20Tree.java) -190 | [Exclusive Time of Functions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Exclusive%20Time%20of%20Functions.java) -191 | [Execution of All Suffix Instructions Staying in a Grid](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Execution%20of%20All%20Suffix%20Instructions%20Staying%20in%20a%20Grid.java) -192 | [Expressive Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Expressive%20Words.java) -193 | [Fair Distribution of Cookies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Fair%20Distribution%20of%20Cookies.java) -194 | [Filter Restaurants by Vegan-Friendly, Price and Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Filter%20Restaurants%20by%20Vegan-Friendly,%20Price%20and%20Distance.java) -195 | [Find All Anagrams in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20All%20Anagrams%20in%20a%20String.java) -196 | [Find All Lonely Numbers in the Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20All%20Lonely%20Numbers%20in%20the%20Array.java) -197 | [Find All Possible Recipes from Given Supplies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20All%20Possible%20Recipes%20from%20Given%20Supplies.java) -198 | [Find Bottom Left Tree Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Bottom%20Left%20Tree%20Value.java) -199 | [Find Center of Star Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Center%20of%20Star%20Graph.java) -200 | [Find Closest Node to Given Two Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Closest%20Node%20to%20Given%20Two%20Nodes.java) -201 | [Find Consecutive Integers from a Data Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Consecutive%20Integers%20from%20a%20Data%20Stream.java) -202 | [Find Distance in a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Distance%20in%20a%20Binary%20Tree.java) -203 | [Find Duplicate File in System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Duplicate%20File%20in%20System.java) -204 | [Find Duplicate Subtrees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Duplicate%20Subtrees.java) -205 | [Find Elements in a Contaminated Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Elements%20in%20a%20Contaminated%20Binary%20Tree.java) -206 | [Find First and Last Position of Element in Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20First%20and%20Last%20Position%20of%20Element%20in%20Sorted%20Array.java) -207 | [Find K Closest Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20K%20Closest%20Elements.java) -208 | [Find K Pairs with Smallest Sums](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20K%20Pairs%20with%20Smallest%20Sums.java) -209 | [Find K-Length Substrings With No Repeated Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20K-Length%20Substrings%20With%20No%20Repeated%20Characters.java) -210 | [Find Largest Value in Each Tree Row](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Largest%20Value%20in%20Each%20Tree%20Row.java) -211 | [Find Leaves of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Leaves%20of%20Binary%20Tree.java) -212 | [Find Minimum in Rotated Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Minimum%20in%20Rotated%20Sorted%20Array.java) -213 | [Find Missing Observations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Missing%20Observations.java) -214 | [Find Nearest Right Node in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Nearest%20Right%20Node%20in%20Binary%20Tree.java) -215 | [Find Original Array From Doubled Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Original%20Array%20From%20Doubled%20Array.java) -216 | [Find Peak Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Peak%20Element.java) -217 | [Find Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Permutation.java) -218 | [Find Players With Zero or One Losses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Players%20With%20Zero%20or%20One%20Losses.java) -219 | [Find Right Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Right%20Interval.java) -220 | [Find Root of N-Ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Root%20of%20N-Ary%20Tree.java) -221 | [Find Smallest Common Element in All Rows](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Smallest%20Common%20Element%20in%20All%20Rows.java) -222 | [Find The Original Array of Prefix Xor](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20The%20Original%20Array%20of%20Prefix%20Xor.java) -223 | [Find Triangular Sum of an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Triangular%20Sum%20of%20an%20Array.java) -224 | [Find a Corresponding Node of a Binary Tree in a Clone of That Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20a%20Corresponding%20Node%20of%20a%20Binary%20Tree%20in%20a%20Clone%20of%20That%20Tree.java) -225 | [Find all Duplicates in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20all%20Duplicates%20in%20an%20Array.java) -226 | [Find and Replace Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20and%20Replace%20Pattern.java) -227 | [Find and Replace in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20and%20Replace%20in%20String.java) -228 | [Find the Celebrity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Celebrity.java) -229 | [Find the City With the Smallest Number of Neighbors at a Threshold Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20City%20With%20the%20Smallest%20Number%20of%20Neighbors%20at%20a%20Threshold%20Distance.java) -230 | [Find the Duplicate Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Duplicate%20Number.java) -231 | [Find the Index of the First Occurrence in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Index%20of%20the%20First%20Occurrence%20in%20a%20String.java) -232 | [Find the Index of the Large Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Index%20of%20the%20Large%20Integer.java) -233 | [Find the Kth Largest Integer in the Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Kth%20Largest%20Integer%20in%20the%20Array.java) -234 | [Find the Maximum Divisibility Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Maximum%20Divisibility%20Score.java) -235 | [Find the Minimum and Maximum Number of Nodes Between Critical Points](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Minimum%20and%20Maximum%20Number%20of%20Nodes%20Between%20Critical%20Points.java) -236 | [Find the Score of All Prefixes of an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Score%20of%20All%20Prefixes%20of%20an%20Array.java) -237 | [Find the Student that Will Replace the Chalk](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Student%20that%20Will%20Replace%20the%20Chalk.java) -238 | [Find the Substring With Maximum Cost](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Substring%20With%20Maximum%20Cost.java) -239 | [Find the Winner of an Array Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Winner%20of%20an%20Array%20Game.java) -240 | [Finding the Users Active Minutes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Finding%20the%20Users%20Active%20Minutes.java) -241 | [First Unique Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/First%20Unique%20Number.java) -242 | [Flatten 2D Vector](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%202D%20Vector.java) -243 | [Flatten Binary Tree to Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%20Binary%20Tree%20to%20Linked%20List.java) -244 | [Flatten Nested List Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%20Nested%20List%20Iterator.java) -245 | [Flatten a Multilevel Doubly Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%20a%20Multilevel%20Doubly%20Linked%20List.java) -246 | [Flip Equivalent Binary Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flip%20Equivalent%20Binary%20Trees.java) -247 | [Four Divisors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Four%20Divisors.java) -248 | [Fraction to Recurring Decimal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Fraction%20to%20Recurring%20Decimal.java) -249 | [Friend Circles](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Friend%20Circles.java) -250 | [Friends Of Appropriate Ages](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Friends%20Of%20Appropriate%20Ages.java) -251 | [Fruit Into Baskets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Fruit%20Into%20Baskets.java) -252 | [Furthest Building You Can Reach](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Furthest%20Building%20You%20Can%20Reach.java) -253 | [Game of Life](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Game%20of%20Life.java) -254 | [Gas Station](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Gas%20Station.java) -255 | [Generate Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Generate%20Parentheses.java) -256 | [Graph Valid Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Graph%20Valid%20Tree.java) -257 | [Gray Code](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Gray%20Code.java) -258 | [Group Anagrams](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Group%20Anagrams.java) -259 | [Group Shifted Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Group%20Shifted%20Strings.java) -260 | [Group the People Given the Group Size They Belong To](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Group%20the%20People%20Given%20the%20Group%20Size%20They%20Belong%20To.java) -261 | [Grumpy Bookstore Owner](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Grumpy%20Bookstore%20Owner.java) -262 | [Guess Number Higher or Lower II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Guess%20Number%20Higher%20or%20Lower%20II.java) -263 | [H-Index II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/H-Index%20II.java) -264 | [H-Index](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/H-Index.java) -265 | [HTML Entity Parser](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/HTML%20Entity%20Parser.java) -266 | [Hand of Straights](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Hand%20of%20Straights.java) -267 | [House Robber II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/House%20Robber%20II.java) -268 | [House Robber III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/House%20Robber%20III.java) -269 | [House Robber](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/House%20Robber.java) -270 | [Image Overlap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Image%20Overlap.java) -271 | [Implement Magic Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Implement%20Magic%20Dictionary.java) -272 | [Implement Rand10() Using Rand7()](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Implement%20Rand10()%20Using%20Rand7().java) -273 | [Implement Trie (Prefix Tree)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Implement%20Trie%20(Prefix%20Tree).java) -274 | [Implement Trie II (Prefix Tree)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Implement%20Trie%20II%20(Prefix%20Tree).java) -275 | [Increasing Subsequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Increasing%20Subsequences.java) -276 | [Increasing Triplet Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Increasing%20Triplet%20Subsequence.java) -277 | [Incremental Memory Leak](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Incremental%20Memory%20Leak.java) -278 | [Inorder Successor in BST II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Inorder%20Successor%20in%20BST%20II.java) -279 | [Inorder Successor in BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Inorder%20Successor%20in%20BST.java) -280 | [Insert Delete GetRandom O(1)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20Delete%20GetRandom%20O(1).java) -281 | [Insert Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20Interval.java) -282 | [Insert Into a Cyclic Sorted List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20Into%20a%20Cyclic%20Sorted%20List.java) -283 | [Insert into a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20into%20a%20Binary%20Search%20Tree.java) -284 | [Insert into a Sorted Circular Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20into%20a%20Sorted%20Circular%20Linked%20List.java) -285 | [Insertion Sort List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insertion%20Sort%20List.java) -286 | [Insufficient Nodes in Root to Leaf Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insufficient%20Nodes%20in%20Root%20to%20Leaf%20Paths.java) -287 | [Integer To Roman](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Integer%20To%20Roman.java) -288 | [Interleaving String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Interleaving%20String.java) -289 | [Interval List Intersections](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Interval%20List%20Intersections.java) -290 | [Invalid Transactions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Invalid%20Transactions.java) -291 | [Is Graph Bipartite](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Is%20Graph%20Bipartite.java) -292 | [Iterator for Combination](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Iterator%20for%20Combination.java) -293 | [Jump Game II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Jump%20Game%20II.java) -294 | [Jump Game III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Jump%20Game%20III.java) -295 | [Jump Game VI](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Jump%20Game%20VI.java) -296 | [Jump Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Jump%20Game.java) -297 | [K Closest Points to Origin](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/K%20Closest%20Points%20to%20Origin.java) -298 | [K Radius Subarray Averages](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/K%20Radius%20Subarray%20Averages.java) -299 | [Keys and Rooms](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Keys%20and%20Rooms.java) -300 | [Kill Process](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kill%20Process.java) -301 | [Knight Dialer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Knight%20Dialer.java) -302 | [Knight Probability in Chessboard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Knight%20Probability%20in%20Chessboard.java) -303 | [Koko Eating Bananas](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Koko%20Eating%20Bananas.java) -304 | [Kth Largest Element in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kth%20Largest%20Element%20in%20an%20Array.java) -305 | [Kth Largest Sum in a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kth%20Largest%20Sum%20in%20a%20Binary%20Tree.java) -306 | [Kth Smallest Element in a BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kth%20Smallest%20Element%20in%20a%20BST.java) -307 | [Kth Smallest Element in a Sorted Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kth%20Smallest%20Element%20in%20a%20Sorted%20Matrix.java) -308 | [LRU Cache](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/LRU%20Cache.java) -309 | [Large Divisble Subset](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Large%20Divisble%20Subset.java) -310 | [Largest BST Subtree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Largest%20BST%20Subtree.java) -311 | [Largest Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Largest%20Number.java) -312 | [Largest Time for Given Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Largest%20Time%20for%20Given%20Digits.java) -313 | [Last Moment Before All Ants Fall Out of a Plank](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Last%20Moment%20Before%20All%20Ants%20Fall%20Out%20of%20a%20Plank.java) -314 | [Last Stone Weight II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Last%20Stone%20Weight%20II.java) -315 | [Least Number of Unique Integers after K Removals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Least%20Number%20of%20Unique%20Integers%20after%20K%20Removals.java) -316 | [Leftmost Column with at Least a One](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Leftmost%20Column%20with%20at%20Least%20a%20One.java) -317 | [Length of the Longest Alphabetical Continuous Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Length%20of%20the%20Longest%20Alphabetical%20Continuous%20Substring.java) -318 | [Letter Combinations of a Phone Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Letter%20Combinations%20of%20a%20Phone%20Number.java) -319 | [Letter Tiles Possibilities](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Letter%20Tiles%20Possibilities.java) -320 | [Lexicographical Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lexicographical%20Numbers.java) -321 | [Lexicographically Smallest Equivalent String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lexicographically%20Smallest%20Equivalent%20String.java) -322 | [Line Reflection](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Line%20Reflection.java) -323 | [Linked List Components](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20Components.java) -324 | [Linked List Cycle II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20Cycle%20II.java) -325 | [Linked List Random Node](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20Random%20Node.java) -326 | [Linked List in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20in%20Binary%20Tree.java) -327 | [Lonely Pixel I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lonely%20Pixel%20I.java) -328 | [Longest Absolute File Path](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Absolute%20File%20Path.java) -329 | [Longest Arithmetic Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Arithmetic%20Sequence.java) -330 | [Longest Arithmetic Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Arithmetic%20Subsequence.java) -331 | [Longest Consecutive Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Consecutive%20Sequence.java) -332 | [Longest Continuous Subarray With Absolute Diff Less Than or Equal to Limit](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Continuous%20Subarray%20With%20Absolute%20Diff%20Less%20Than%20or%20Equal%20to%20Limit.java) -333 | [Longest Happy String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Happy%20String.java) -334 | [Longest Increasing Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Increasing%20Subsequence.java) -335 | [Longest Line of Consecutive One in Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Line%20of%20Consecutive%20One%20in%20Matrix.java) -336 | [Longest Palindromic Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Palindromic%20Subsequence.java) -337 | [Longest Palindromic Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Palindromic%20Substring.java) -338 | [Longest String Chain](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20String%20Chain.java) -339 | [Longest Substring Without Repeating Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Substring%20Without%20Repeating%20Characters.java) -340 | [Longest Substring with At Most K Distinct Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Substring%20with%20At%20Most%20K%20Distinct%20Characters.java) -341 | [Longest Substring with At Most Two Distinct Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Substring%20with%20At%20Most%20Two%20Distinct%20Characters.java) -342 | [Longest Uploaded Prefix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Uploaded%20Prefix.java) -343 | [Longest Well-Performing Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Well-Performing%20Interval.java) -344 | [Longest Word With All Prefixes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Word%20With%20All%20Prefixes.java) -345 | [Longest Word in Dictionary through Deleting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Word%20in%20Dictionary%20through%20Deleting.java) -346 | [Longest ZigZag Path in a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20ZigZag%20Path%20in%20a%20Binary%20Tree.java) -347 | [Lowest Common Ancestor of Deepest Leaves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lowest%20Common%20Ancestor%20of%20Deepest%20Leaves.java) -348 | [Lowest Common Ancestor of a Binary Tree III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lowest%20Common%20Ancestor%20of%20a%20Binary%20Tree%20III.java) -349 | [Lowest Common Ancestor of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lowest%20Common%20Ancestor%20of%20a%20Binary%20Tree.java) -350 | [Majority Element II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Majority%20Element%20II.java) -351 | [Making File Names Unique](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Making%20File%20Names%20Unique.java) -352 | [Map Sum Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Map%20Sum%20Pairs.java) -353 | [Masking Personal Information](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Masking%20Personal%20Information.java) -354 | [Matchsticks to Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Matchsticks%20to%20Square.java) -355 | [Max Area of Island](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Area%20of%20Island.java) -356 | [Max Chunks To Make Sorted](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Chunks%20To%20Make%20Sorted.java) -357 | [Max Consecutives Ones II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Consecutives%20Ones%20II.java) -358 | [Max Increase to Keep City Skyline](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Increase%20to%20Keep%20City%20Skyline.java) -359 | [Max Number of K-Sum Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Number%20of%20K-Sum%20Pairs.java) -360 | [Max Sum of a Pair With Equal Sum of Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Sum%20of%20a%20Pair%20With%20Equal%20Sum%20of%20Digits.java) -361 | [Maximal Network Rank](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximal%20Network%20Rank.java) -362 | [Maximal Score After Applying K Operations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximal%20Score%20After%20Applying%20K%20Operations.java) -363 | [Maximize Distance to Closest Person](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximize%20Distance%20to%20Closest%20Person.java) -364 | [Maximize Number of Subsequences in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximize%20Number%20of%20Subsequences%20in%20a%20String.java) -365 | [Maximize the Topmost Element After K Moves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximize%20the%20Topmost%20Element%20After%20K%20Moves.java) -366 | [Maximum Absolute Sum of Any Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Absolute%20Sum%20of%20Any%20Subarray.java) -367 | [Maximum Area of a Piece of Cake After Horizontal and Vertical Cuts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Area%20of%20a%20Piece%20of%20Cake%20After%20Horizontal%20and%20Vertical%20Cuts.java) -368 | [Maximum Average Subtree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Average%20Subtree.java) -369 | [Maximum Bags With Full Capacity of Rocks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Bags%20With%20Full%20Capacity%20of%20Rocks.java) -370 | [Maximum Binary Tree II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Binary%20Tree%20II.java) -371 | [Maximum Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Binary%20Tree.java) -372 | [Maximum Consecutive Floors Without Special Floors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Consecutive%20Floors%20Without%20Special%20Floors.java) -373 | [Maximum Difference Between Node and Ancestor](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Difference%20Between%20Node%20and%20Ancestor.java) -374 | [Maximum Distance Between a Pair of Values](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Distance%20Between%20a%20Pair%20of%20Values.java) -375 | [Maximum Erasure Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Erasure%20Value.java) -376 | [Maximum Ice Cream Bars](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Ice%20Cream%20Bars.java) -377 | [Maximum Length of Pair Chain](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Length%20of%20Pair%20Chain.java) -378 | [Maximum Length of Repeated Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Length%20of%20Repeated%20Subarray.java) -379 | [Maximum Length of Subarray With Positive Product](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Length%20of%20Subarray%20With%20Positive%20Product.java) -380 | [Maximum Level Sum of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Level%20Sum%20of%20a%20Binary%20Tree.java) -381 | [Maximum Matching of Players With Trainers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Matching%20of%20Players%20With%20Trainers.java) -382 | [Maximum Nesting Depth of Two Valid Parentheses Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Nesting%20Depth%20of%20Two%20Valid%20Parentheses%20Strings.java) -383 | [Maximum Number of Coins You Can Get](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Coins%20You%20Can%20Get.java) -384 | [Maximum Number of Events That Can Be Attended](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Events%20That%20Can%20Be%20Attended.java) -385 | [Maximum Number of Groups Entering a Competition](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Groups%20Entering%20a%20Competition.java) -386 | [Maximum Number of Integers to Choose From a Range I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Integers%20to%20Choose%20From%20a%20Range%20I.java) -387 | [Maximum Number of Non-Overlapping Subarrays With Sum Equals Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Non-Overlapping%20Subarrays%20With%20Sum%20Equals%20Target.java) -388 | [Maximum Number of Occurrences of a Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Occurrences%20of%20a%20Substring.java) -389 | [Maximum Number of Vowels in a Substring of Given Length](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Vowels%20in%20a%20Substring%20of%20Given%20Length.java) -390 | [Maximum Points You Can Obtain from Cards](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Points%20You%20Can%20Obtain%20from%20Cards.java) -391 | [Maximum Product Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Product%20Subarray.java) -392 | [Maximum Product of Splitted Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Product%20of%20Splitted%20Binary%20Tree.java) -393 | [Maximum Product of Word Lengths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Product%20of%20Word%20Lengths.java) -394 | [Maximum Score From Removing Stones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Score%20From%20Removing%20Stones.java) -395 | [Maximum Score from Performing Multiplication Operations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Score%20from%20Performing%20Multiplication%20Operations.java) -396 | [Maximum Size Subarray Sum Equals k](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Size%20Subarray%20Sum%20Equals%20k.java) -397 | [Maximum Star Sum of a Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Star%20Sum%20of%20a%20Graph.java) -398 | [Maximum Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Subarray.java) -399 | [Maximum Sum of Distinct Subarrays With Length K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Sum%20of%20Distinct%20Subarrays%20With%20Length%20K.java) -400 | [Maximum Sum of an Hourglass](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Sum%20of%20an%20Hourglass.java) -401 | [Maximum Swap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Swap.java) -402 | [Maximum Total Importance of Roads](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Total%20Importance%20of%20Roads.java) -403 | [Maximum Twin Sum of a Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Twin%20Sum%20of%20a%20Linked%20List.java) -404 | [Maximum Value after Insertion](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Value%20after%20Insertion.java) -405 | [Maximum Width Ramp](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Width%20Ramp.java) -406 | [Maximum Width of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Width%20of%20Binary%20Tree.java) -407 | [Maximum XOR of Two Numbers in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20XOR%20of%20Two%20Numbers%20in%20an%20Array.java) -408 | [Maximum of Absolute Value Expression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20of%20Absolute%20Value%20Expression.java) -409 | [Meeting Rooms II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Meeting%20Rooms%20II.java) -410 | [Meeting Scheduler](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Meeting%20Scheduler.java) -411 | [Merge In Between Linked Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Merge%20In%20Between%20Linked%20Lists.java) -412 | [Merge Intervals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Merge%20Intervals.java) -413 | [Merge Nodes in Between Zeros](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Merge%20Nodes%20in%20Between%20Zeros.java) -414 | [Min Cost to Connect All Points](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Min%20Cost%20to%20Connect%20All%20Points.java) -415 | [Min Stack](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Min%20Stack.java) -416 | [Minesweeper](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minesweeper.java) -417 | [Mini Parser](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Mini%20Parser.java) -418 | [Minimize Maximum Pair Sum in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimize%20Maximum%20Pair%20Sum%20in%20Array.java) -419 | [Minimize Maximum of Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimize%20Maximum%20of%20Array.java) -420 | [Minimize Product Sum of Two Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimize%20Product%20Sum%20of%20Two%20Arrays.java) -421 | [Minimum Add to Make Parentheses Valid](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Add%20to%20Make%20Parentheses%20Valid.java) -422 | [Minimum Amount of Time to Collect Garbage](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Amount%20of%20Time%20to%20Collect%20Garbage.java) -423 | [Minimum Area Rectangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Area%20Rectangle.java) -424 | [Minimum Average Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Average%20Difference.java) -425 | [Minimum Consecutive Cards to Pick Up](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Consecutive%20Cards%20to%20Pick%20Up.java) -426 | [Minimum Cost For Tickets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Cost%20For%20Tickets.java) -427 | [Minimum Cost to Connect Sticks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Cost%20to%20Connect%20Sticks.java) -428 | [Minimum Deletion Cost to Avoid Repeating Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Deletion%20Cost%20to%20Avoid%20Repeating%20Letters.java) -429 | [Minimum Deletions to Make Array Beautiful](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Deletions%20to%20Make%20Array%20Beautiful.java) -430 | [Minimum Deletions to Make Character Frequencies Unique](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Deletions%20to%20Make%20Character%20Frequencies%20Unique.java) -431 | [Minimum Domino Rotations For Equal Row](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Domino%20Rotations%20For%20Equal%20Row.java) -432 | [Minimum Falling Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Falling%20Path%20Sum.java) -433 | [Minimum Fuel Cost to Report to the Capital](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Fuel%20Cost%20to%20Report%20to%20the%20Capital.java) -434 | [Minimum Genetic Mutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Genetic%20Mutation.java) -435 | [Minimum Health to Beat Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Health%20to%20Beat%20Game.java) -436 | [Minimum Height Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Height%20Trees.java) -437 | [Minimum Knight Moves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Knight%20Moves.java) -438 | [Minimum Moves to Equal Array Elements II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Moves%20to%20Equal%20Array%20Elements%20II.java) -439 | [Minimum Moves to Equal Array Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Moves%20to%20Equal%20Array%20Elements.java) -440 | [Minimum Moves to Reach Target Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Moves%20to%20Reach%20Target%20Score.java) -441 | [Minimum Number of Arrows to Burst Balloons](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Number%20of%20Arrows%20to%20Burst%20Balloons.java) -442 | [Minimum Number of Steps to Make Two Strings Anagram II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Number%20of%20Steps%20to%20Make%20Two%20Strings%20Anagram%20II.java) -443 | [Minimum Number of Steps to Make Two Strings Anagram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Number%20of%20Steps%20to%20Make%20Two%20Strings%20Anagram.java) -444 | [Minimum Number of Vertices to Reach All Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Number%20of%20Vertices%20to%20Reach%20All%20Nodes.java) -445 | [Minimum Operations to Make Array Equal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Operations%20to%20Make%20Array%20Equal.java) -446 | [Minimum Operations to Reduce X to Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Operations%20to%20Reduce%20X%20to%20Zero.java) -447 | [Minimum Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Path%20Sum.java) -448 | [Minimum Remove to Make Valid Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Remove%20to%20Make%20Valid%20Parentheses.java) -449 | [Minimum Rounds to Complete All Tasks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Rounds%20to%20Complete%20All%20Tasks.java) -450 | [Minimum Score Triangulation of Polygon](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Score%20Triangulation%20of%20Polygon.java) -451 | [Minimum Score of a Path Between Two Cities](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Score%20of%20a%20Path%20Between%20Two%20Cities.java) -452 | [Minimum Size Subarray Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Size%20Subarray%20Sum.java) -453 | [Minimum Swaps to Group All 1's Together](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Swaps%20to%20Group%20All%201's%20Together.java) -454 | [Minimum Time Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Time%20Difference.java) -455 | [Minimum Time to Collect All Apples in a Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Time%20to%20Collect%20All%20Apples%20in%20a%20Tree.java) -456 | [Minimum Time to Complete Trips](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Time%20to%20Complete%20Trips.java) -457 | [Minimum Time to Make Rope Colorful](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Time%20to%20Make%20Rope%20Colorful.java) -458 | [Mirror Reflection](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Mirror%20Reflection.java) -459 | [Missing Element in Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Missing%20Element%20in%20Sorted%20Array.java) -460 | [Most Frequent Subtree Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Most%20Frequent%20Subtree%20Sum.java) -461 | [Most Popular Video Creator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Most%20Popular%20Video%20Creator.java) -462 | [Most Profit Assigning Work](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Most%20Profit%20Assigning%20Work.java) -463 | [Most Stones Removed with Same Row or Column](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Most%20Stones%20Removed%20with%20Same%20Row%20or%20Column.java) -464 | [Multiply Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Multiply%20Strings.java) -465 | [My Calendar I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/My%20Calendar%20I.java) -466 | [My Calendar II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/My%20Calendar%20II.java) -467 | [N-ary Tree Level Order Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/N-ary%20Tree%20Level%20Order%20Traversal.java) -468 | [Nearest Exit from Entrance in Maze](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Nearest%20Exit%20from%20Entrance%20in%20Maze.java) -469 | [Nested List Weight Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Nested%20List%20Weight%20Sum%20II.java) -470 | [Network Delay Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Network%20Delay%20Time.java) -471 | [Next Closest Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Closest%20Time.java) -472 | [Next Greater Element II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Greater%20Element%20II.java) -473 | [Next Greater Element III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Greater%20Element%20III.java) -474 | [Next Greater Node In Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Greater%20Node%20In%20Linked%20List.java) -475 | [Next Greater Numerically Balanced Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Greater%20Numerically%20Balanced%20Number.java) -476 | [Next Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Permutation.java) -477 | [Node With Highest Edge Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Node%20With%20Highest%20Edge%20Score.java) -478 | [Non Overlapping Intervals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Non%20Overlapping%20Intervals.java) -479 | [Non-decreasing Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Non-decreasing%20Array.java) -480 | [Number of Burgers with No Waste of Ingredients](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Burgers%20with%20No%20Waste%20of%20Ingredients.java) -481 | [Number of Closed Islands](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Closed%20Islands.java) -482 | [Number of Connected Components in an Undirected Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Connected%20Components%20in%20an%20Undirected%20Graph.java) -483 | [Number of Dice Rolls With Target Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Dice%20Rolls%20With%20Target%20Sum.java) -484 | [Number of Distinct Islands](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Distinct%20Islands.java) -485 | [Number of Distinct Substrings in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Distinct%20Substrings%20in%20a%20String.java) -486 | [Number of Enclaves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Enclaves.java) -487 | [Number of Islands](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Islands.java) -488 | [Number of Laser Beams in a Bank](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Laser%20Beams%20in%20a%20Bank.java) -489 | [Number of Longest Increasing Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Longest%20Increasing%20Subsequence.java) -490 | [Number of Matching Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Matching%20Subsequence.java) -491 | [Number of Matching Subsequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Matching%20Subsequences.java) -492 | [Number of Nodes in the Sub-Tree With the Same Label](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Nodes%20in%20the%20Sub-Tree%20With%20the%20Same%20Label.java) -493 | [Number of Operations to Make Network Connected](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Operations%20to%20Make%20Network%20Connected.java) -494 | [Number of Pairs of Interchangeable Rectangles](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Pairs%20of%20Interchangeable%20Rectangles.java) -495 | [Number of Pairs of Strings With Concatenation Equal to Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Pairs%20of%20Strings%20With%20Concatenation%20Equal%20to%20Target.java) -496 | [Number of Provinces](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Provinces.java) -497 | [Number of Smooth Descent Periods of a Stock](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Smooth%20Descent%20Periods%20of%20a%20Stock.java) -498 | [Number of Sub-arrays of Size K and Average Greater than or Equal to Threshold](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Sub-arrays%20of%20Size%20K%20and%20Average%20Greater%20than%20or%20Equal%20to%20Threshold.java) -499 | [Number of Subarrays with Bounded Maximum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Subarrays%20with%20Bounded%20Maximum.java) -500 | [Number of Substrings Containing All Three Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Substrings%20Containing%20All%20Three%20Characters.java) -501 | [Number of Substrings With Only 1s](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Substrings%20With%20Only%201s.java) -502 | [Number of Ways to Split Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Ways%20to%20Split%20Array.java) -503 | [Number of Zero-Filled Subarrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Zero-Filled%20Subarrays.java) -504 | [Numbers With Same Consecutive Differences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Numbers%20With%20Same%20Consecutive%20Differences.java) -505 | [Odd Even Linked Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Odd%20Even%20Linked%20Lists.java) -506 | [One Edit Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/One%20Edit%20Distance.java) -507 | [Ones and Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Ones%20and%20Zeroes.java) -508 | [Online Election](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Online%20Election.java) -509 | [Online Stock Span](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Online%20Stock%20Span.java) -510 | [Open The Lock](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Open%20The%20Lock.java) -511 | [Optimal Division](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Optimal%20Division.java) -512 | [Optimal Partition of String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Optimal%20Partition%20of%20String.java) -513 | [Out of Boundary Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Out%20of%20Boundary%20Paths.java) -514 | [Output Contest Matches](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Output%20Contest%20Matches.java) -515 | [Pacific Atlantic Water Flow](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pacific%20Atlantic%20Water%20Flow.java) -516 | [Palindrome Partitioning](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Palindrome%20Partitioning.java) -517 | [Palindromic Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Palindromic%20Substrings.java) -518 | [Pancake Sorting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pancake%20Sorting.java) -519 | [Parallel Courses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Parallel%20Courses.java) -520 | [Partition Array According to Given Pivot](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partition%20Array%20According%20to%20Given%20Pivot.java) -521 | [Partition Equal Subset Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partition%20Equal%20Subset%20Sum.java) -522 | [Partition Labels](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partition%20Labels.java) -523 | [Partition List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partition%20List.java) -524 | [Partitioning Into Minimum Number Of Deci-Binary Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partitioning%20Into%20Minimum%20Number%20Of%20Deci-Binary%20Numbers.java) -525 | [Path Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20Sum%20II.java) -526 | [Path Sum III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20Sum%20III.java) -527 | [Path With Maximum Minimum Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20With%20Maximum%20Minimum%20Value.java) -528 | [Path With Minimum Effort](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20With%20Minimum%20Effort.java) -529 | [Path with Maximum Gold](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20with%20Maximum%20Gold.java) -530 | [Path with Maximum Probability](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20with%20Maximum%20Probability.java) -531 | [Peeking Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Peeking%20Iterator.java) -532 | [People Whose List of Favorite Companies Is Not a Subset of Another List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/People%20Whose%20List%20of%20Favorite%20Companies%20Is%20Not%20a%20Subset%20of%20Another%20List.java) -533 | [Perfect Squares](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Perfect%20Squares.java) -534 | [Permutation in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Permutation%20in%20String.java) -535 | [Permutations II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Permutations%20II.java) -536 | [Permutations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Permutations.java) -537 | [Plus One Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Plus%20One%20Linked%20List.java) -538 | [Populating Next Right Pointers in Each Node II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Populating%20Next%20Right%20Pointers%20in%20Each%20Node%20II.java) -539 | [Populating Next Right Pointers in Each Node](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Populating%20Next%20Right%20Pointers%20in%20Each%20Node.java) -540 | [Possible Bipartition](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Possible%20Bipartition.java) -541 | [Pour Water](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pour%20Water.java) -542 | [Pow(x, n)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pow(x,%20n).java) -543 | [Pow](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pow.java) -544 | [Prime Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Prime%20Palindrome.java) -545 | [Print Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Print%20Binary%20Tree.java) -546 | [Print Immutable Linked List in Reverse](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Print%20Immutable%20Linked%20List%20in%20Reverse.java) -547 | [Print Words Vertically](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Print%20Words%20Vertically.java) -548 | [Prison Cells After N Days](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Prison%20Cells%20After%20N%20Days.java) -549 | [Product of Array Except self](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Product%20of%20Array%20Except%20self.java) -550 | [Product of Two Run-Length Encoded Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Product%20of%20Two%20Run-Length%20Encoded%20Arrays.java) -551 | [Product of the Last K Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Product%20of%20the%20Last%20K%20Numbers.java) -552 | [Pseudo-Palindromic Paths in a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pseudo-Palindromic%20Paths%20in%20a%20Binary%20Tree.java) -553 | [Push Dominoes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Push%20Dominoes.java) -554 | [Put Boxes Into the Warehouse I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Put%20Boxes%20Into%20the%20Warehouse%20I.java) -555 | [Queries on a Permutation With Key](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Queries%20on%20a%20Permutation%20With%20Key.java) -556 | [Queue Reconstruction By Height](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Queue%20Reconstruction%20By%20Height.java) -557 | [RLE Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/RLE%20Iterator.java) -558 | [Rabbits in Forest](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rabbits%20in%20Forest.java) -559 | [Random Pick Index](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Random%20Pick%20Index.java) -560 | [Random Pick With Weight](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Random%20Pick%20With%20Weight.java) -561 | [Range Addition](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Addition.java) -562 | [Range Sum Query - Mutable](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Sum%20Query%20-%20Mutable.java) -563 | [Range Sum Query 2D-Immutable](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Sum%20Query%202D-Immutable.java) -564 | [Range Sum of Sorted Subarray Sums](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Sum%20of%20Sorted%20Subarray%20Sums.java) -565 | [Rank Teams by Votes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rank%20Teams%20by%20Votes.java) -566 | [Reachable Nodes With Restrictions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reachable%20Nodes%20With%20Restrictions.java) -567 | [Rearrange Array Elements by Sign](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rearrange%20Array%20Elements%20by%20Sign.java) -568 | [Rearrange Array to Maximize Prefix Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rearrange%20Array%20to%20Maximize%20Prefix%20Score.java) -569 | [Reconstruct Original Digits from English](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reconstruct%20Original%20Digits%20from%20English.java) -570 | [Recover Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Recover%20Binary%20Search%20Tree.java) -571 | [Rectangle Area](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rectangle%20Area.java) -572 | [Reduce Array Size to The Half](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reduce%20Array%20Size%20to%20The%20Half.java) -573 | [Reduction Operations to Make the Array Elements Equal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reduction%20Operations%20to%20Make%20the%20Array%20Elements%20Equal.java) -574 | [Remove All Adjacent Duplicates in String II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20All%20Adjacent%20Duplicates%20in%20String%20II.java) -575 | [Remove All Occurrences of a Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20All%20Occurrences%20of%20a%20Substring.java) -576 | [Remove All Ones With Row and Column Flips II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20All%20Ones%20With%20Row%20and%20Column%20Flips%20II.java) -577 | [Remove Comments](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Comments.java) -578 | [Remove Covered Intervals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Covered%20Intervals.java) -579 | [Remove Duplicate Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Duplicate%20Letters.java) -580 | [Remove Duplicates From Sorted Array II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Duplicates%20From%20Sorted%20Array%20II.java) -581 | [Remove Duplicates From an Unsorted Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Duplicates%20From%20an%20Unsorted%20Linked%20List.java) -582 | [Remove Duplicates from Sorted List II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Duplicates%20from%20Sorted%20List%20II.java) -583 | [Remove Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Interval.java) -584 | [Remove K Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20K%20Digits.java) -585 | [Remove Nodes From Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Nodes%20From%20Linked%20List.java) -586 | [Remove Nth Node From End of List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Nth%20Node%20From%20End%20of%20List.java) -587 | [Remove Sub-Folders from the Filesystem](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Sub-Folders%20from%20the%20Filesystem.java) -588 | [Remove Zero Sum Consecutive Nodes from Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Zero%20Sum%20Consecutive%20Nodes%20from%20Linked%20List.java) -589 | [Removing Stars From a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Removing%20Stars%20From%20a%20String.java) -590 | [Reorder Data in Log Files](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reorder%20Data%20in%20Log%20Files.java) -591 | [Reorder List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reorder%20List.java) -592 | [Reorder Routes to Make All Paths Lead to the City Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reorder%20Routes%20to%20Make%20All%20Paths%20Lead%20to%20the%20City%20Zero.java) -593 | [Reordered Power of 2](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reordered%20Power%20of%202.java) -594 | [Reorganize String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reorganize%20String.java) -595 | [Repeated DNA Sequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Repeated%20DNA%20Sequences.java) -596 | [Replace Elements in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Replace%20Elements%20in%20an%20Array.java) -597 | [Replace Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Replace%20Words.java) -598 | [Restore IP Address](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Restore%20IP%20Address.java) -599 | [Restore the Array From Adjacent Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Restore%20the%20Array%20From%20Adjacent%20Pairs.java) -600 | [Reverse Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Integer.java) -601 | [Reverse Linked List II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Linked%20List%20II.java) -602 | [Reverse Nodes in Even Length Groups](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Nodes%20in%20Even%20Length%20Groups.java) -603 | [Reverse Odd Levels of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Odd%20Levels%20of%20Binary%20Tree.java) -604 | [Reverse Substrings Between Each Pair of Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Substrings%20Between%20Each%20Pair%20of%20Parentheses.java) -605 | [Reverse Words in a String II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Words%20in%20a%20String%20II.java) -606 | [Reverse Words in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Words%20in%20a%20String.java) -607 | [Robot Bounded In Circle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Robot%20Bounded%20In%20Circle.java) -608 | [Rotate Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20Array.java) -609 | [Rotate Function](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20Function.java) -610 | [Rotate Image](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20Image.java) -611 | [Rotate List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20List.java) -612 | [Rotated Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotated%20Digits.java) -613 | [Rotting Oranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotting%20Oranges.java) -614 | [Satisfiability of Equality Equations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Satisfiability%20of%20Equality%20Equations.java) -615 | [Satisfisbility of Equality Equations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Satisfisbility%20of%20Equality%20Equations.java) -616 | [Score After Flipping Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Score%20After%20Flipping%20Matrix.java) -617 | [Score of Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Score%20of%20Parentheses.java) -618 | [Search Suggestions System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20Suggestions%20System.java) -619 | [Search a 2D Matrix II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20a%202D%20Matrix%20II.java) -620 | [Search a 2D Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20a%202D%20Matrix.java) -621 | [Search for a range](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20for%20a%20range.java) -622 | [Search in Rotated Sorted Array II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20in%20Rotated%20Sorted%20Array%20II.java) -623 | [Search in Rotated Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20in%20Rotated%20Sorted%20Array.java) -624 | [Search in a Sorted Array of Unknown Size](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20in%20a%20Sorted%20Array%20of%20Unknown%20Size.java) -625 | [Seat Reservation Manager](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Seat%20Reservation%20Manager.java) -626 | [Self Dividing Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Self%20Dividing%20Numbers.java) -627 | [Sender With Largest Word Count](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sender%20With%20Largest%20Word%20Count.java) -628 | [Sentence Similarity II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sentence%20Similarity%20II.java) -629 | [Sentence Similarity III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sentence%20Similarity%20III.java) -630 | [Sequential Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sequential%20Digits.java) -631 | [Serialize and Deserialize BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Serialize%20and%20Deserialize%20BST.java) -632 | [Set Matrix Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Set%20Matrix%20Zeroes.java) -633 | [Shifting Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shifting%20Letters.java) -634 | [Short Encoding of Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Short%20Encoding%20of%20Words.java) -635 | [Shortest Completing Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Completing%20Word.java) -636 | [Shortest Path in Binary Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Path%20in%20Binary%20Matrix.java) -637 | [Shortest Path with Alternating Colors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Path%20with%20Alternating%20Colors.java) -638 | [Shortest Unsorted Continuous Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Unsorted%20Continuous%20Subarray.java) -639 | [Shortest Way to Form String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Way%20to%20Form%20String.java) -640 | [Shortest Word Distance II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Word%20Distance%20II.java) -641 | [Shortest Word Distance III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Word%20Distance%20III.java) -642 | [Shuffle an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shuffle%20an%20Array.java) -643 | [Simple Bank System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Simple%20Bank%20System.java) -644 | [Simplify Path](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Simplify%20Path.java) -645 | [Single Element in a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Single%20Element%20in%20a%20Sorted%20Array.java) -646 | [Single Number II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Single%20Number%20II.java) -647 | [Single Number III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Single%20Number%20III.java) -648 | [Smallest Integer Divisible by K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20Integer%20Divisible%20by%20K.java) -649 | [Smallest Number in Infinite Set](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20Number%20in%20Infinite%20Set.java) -650 | [Smallest String Starting From Leaf](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20String%20Starting%20From%20Leaf.java) -651 | [Smallest String With A Given Numeric Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20String%20With%20A%20Given%20Numeric%20Value.java) -652 | [Smallest String With Swaps](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20String%20With%20Swaps.java) -653 | [Smallest Subtree with all the Deepest Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20Subtree%20with%20all%20the%20Deepest%20Nodes.java) -654 | [Smallest Value of the Rearranged Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20Value%20of%20the%20Rearranged%20Number.java) -655 | [Snakes and Ladders](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Snakes%20and%20Ladders.java) -656 | [Snapshot Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Snapshot%20Array.java) -657 | [Solve the Equation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Solve%20the%20Equation.java) -658 | [Sort An Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20An%20Array.java) -659 | [Sort Characters By Frequency](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Characters%20By%20Frequency.java) -660 | [Sort Colors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Colors.java) -661 | [Sort Integers by The Power Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Integers%20by%20The%20Power%20Value.java) -662 | [Sort List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20List.java) -663 | [Sort Transformed Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Transformed%20Array.java) -664 | [Sort the Jumbled Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20the%20Jumbled%20Numbers.java) -665 | [Sort the Matrix Diagonally](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20the%20Matrix%20Diagonally.java) -666 | [Sort the Students by Their Kth Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20the%20Students%20by%20Their%20Kth%20Score.java) -667 | [Sparse Matrix Multiplication](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sparse%20Matrix%20Multiplication.java) -668 | [Spiral Matrix II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Spiral%20Matrix%20II.java) -669 | [Spiral Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Spiral%20Matrix.java) -670 | [Split Array into Consecutive Subsequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Split%20Array%20into%20Consecutive%20Subsequences.java) -671 | [Split BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Split%20BST.java) -672 | [Split Linked List in Parts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Split%20Linked%20List%20in%20Parts.java) -673 | [Statistics from a Large Sample](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Statistics%20from%20a%20Large%20Sample.java) -674 | [Step-By-Step Directions From a Binary Tree Node to Another](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Step-By-Step%20Directions%20From%20a%20Binary%20Tree%20Node%20to%20Another.java) -675 | [Stock Price Fluctuation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Stock%20Price%20Fluctuation.java) -676 | [Strictly Palindromic Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Strictly%20Palindromic%20Number.java) -677 | [String Compression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/String%20Compression.java) -678 | [String to Integer (atoi)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/String%20to%20Integer%20(atoi).java) -679 | [Subarray Product Less Than K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subarray%20Product%20Less%20Than%20K.java) -680 | [Subarray Sum Equals K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subarray%20Sum%20Equals%20K.java) -681 | [Subarray Sums Divisible by K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subarray%20Sums%20Divisible%20by%20K.java) -682 | [Subdomain Visit Count](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subdomain%20Visit%20Count.java) -683 | [Subrectangle Queries](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subrectangle%20Queries.java) -684 | [Subsets II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subsets%20II.java) -685 | [Subsets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subsets.java) -686 | [Successful Pairs of Spells and Potions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Successful%20Pairs%20of%20Spells%20and%20Potions.java) -687 | [Sum Multiples](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20Multiples.java) -688 | [Sum Root to Leaf Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20Root%20to%20Leaf%20Numbers.java) -689 | [Sum of Absolute Differences in a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Absolute%20Differences%20in%20a%20Sorted%20Array.java) -690 | [Sum of Beauty of All Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Beauty%20of%20All%20Substrings.java) -691 | [Sum of Even Numbers After Queries](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Even%20Numbers%20After%20Queries.java) -692 | [Sum of Nodes with Even-Valued Grandparent](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Nodes%20with%20Even-Valued%20Grandparent.java) -693 | [Sum of Numbers With Units Digit K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Numbers%20With%20Units%20Digit%20K.java) -694 | [Sum of Subarray Minimums](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Subarray%20Minimums.java) -695 | [Super Ugly Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Super%20Ugly%20Number.java) -696 | [Surrounded Regions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Surrounded%20Regions.java) -697 | [Swap For Longest Repeated Character Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Swap%20For%20Longest%20Repeated%20Character%20Substring.java) -698 | [Swap Nodes in Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Swap%20Nodes%20in%20Pairs.java) -699 | [Swapping Nodes in a Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Swapping%20Nodes%20in%20a%20Linked%20List.java) -700 | [Synonymous Sentences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Synonymous%20Sentences.java) -701 | [Target Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Target%20Sum.java) -702 | [Task Scheduler](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Task%20Scheduler.java) -703 | [Ternary Expression Parser](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Ternary%20Expression%20Parser.java) -704 | [The Earliest Moment When Everyone Become Friends](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20Earliest%20Moment%20When%20Everyone%20Become%20Friends.java) -705 | [The Number of Full Rounds You Have Played](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20Number%20of%20Full%20Rounds%20You%20Have%20Played.java) -706 | [The Number of Weak Characters in the Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20Number%20of%20Weak%20Characters%20in%20the%20Game.java) -707 | [The k Strongest Values in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20k%20Strongest%20Values%20in%20an%20Array.java) -708 | [The kth Factor of n](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20kth%20Factor%20of%20n.java) -709 | [Throne Inheritence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Throne%20Inheritence.java) -710 | [Time Based Key-Value Store](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Time%20Based%20Key-Value%20Store.java) -711 | [Time Needed to Inform All Employees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Time%20Needed%20to%20Inform%20All%20Employees.java) -712 | [Time Needed to Rearrange a Binary String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Time%20Needed%20to%20Rearrange%20a%20Binary%20String.java) -713 | [Top K Frequent Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Top%20K%20Frequent%20Elements.java) -714 | [Top K Frequent Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Top%20K%20Frequent%20Words.java) -715 | [Total Hamming Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Total%20Hamming%20Distance.java) -716 | [Tree Diameter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Tree%20Diameter.java) -717 | [Triangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Triangle.java) -718 | [Trim a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Trim%20a%20Binary%20Search%20Tree.java) -719 | [Tuple With Same Product](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Tuple%20With%20Same%20Product.java) -720 | [Tweet Counts Per Frequency](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Tweet%20Counts%20Per%20Frequency.java) -721 | [Two City Scheduling](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Two%20City%20Scheduling.java) -722 | [Two Sum BSTs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Two%20Sum%20BSTs.java) -723 | [Two Sum II - Input Array Is Sorted](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Two%20Sum%20II%20-%20Input%20Array%20Is%20Sorted.java) -724 | [UTF-8 Validation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/UTF-8%20Validation.java) -725 | [Ugly Number II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Ugly%20Number%20II.java) -726 | [Uncrossed Lines](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Uncrossed%20Lines.java) -727 | [Unique Binary Search Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Binary%20Search%20Trees.java) -728 | [Unique Paths II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Paths%20II.java) -729 | [Unique Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Paths.java) -730 | [Unique Word Abbrevation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Word%20Abbrevation.java) -731 | [Valid Parenthesis String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Parenthesis%20String.java) -732 | [Valid Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Square.java) -733 | [Valid Sudoku](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Sudoku.java) -734 | [Valid Tic-Tac-Toe State](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Tic-Tac-Toe%20State.java) -735 | [Valid Triangle Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Triangle%20Number.java) -736 | [Validate Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Validate%20Binary%20Search%20Tree.java) -737 | [Validate IP Address](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Validate%20IP%20Address.java) -738 | [Validate Stack Sequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Validate%20Stack%20Sequences.java) -739 | [Verify Preorder Serialization of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Verify%20Preorder%20Serialization%20of%20a%20Binary%20Tree.java) -740 | [Vowel Spellchecker](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Vowel%20Spellchecker.java) -741 | [Vowels of All Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Vowels%20of%20All%20Substrings.java) -742 | [Walls and Gates](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Walls%20and%20Gates.java) -743 | [Water & Jug Problem](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Water%20&%20Jug%20Problem.java) -744 | [Watering Plants](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Watering%20Plants.java) -745 | [Web Crawler](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Web%20Crawler.java) -746 | [Wiggle Sort](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Wiggle%20Sort.java) -747 | [Wiggle Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Wiggle%20Subsequence.java) -748 | [Word Break](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Word%20Break.java) -749 | [Word Ladder](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Word%20Ladder.java) -750 | [Word Search](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Word%20Search.java) -751 | [Word Subsets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Word%20Subsets.java) -752 | [ZigZag Conversion](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/ZigZag%20Conversion.java) -753 | [Zigzag Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Zigzag%20Iterator.java) +1|[Jump Game II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Jump%20Game%20II.java) +2|[Unique Paths II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Paths%20II.java) +3|[Search a 2D Matrix II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20a%202D%20Matrix%20II.java) +4|[First Unique Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/First%20Unique%20Number.java) +5|[Minimum Number of Vertices to Reach All Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Number%20of%20Vertices%20to%20Reach%20All%20Nodes.java) +6|[Inorder Successor in BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Inorder%20Successor%20in%20BST.java) +7|[3Sum Closest](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/3Sum%20Closest.java) +8|[Binary Tree Zigzag Level Order Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Zigzag%20Level%20Order%20Traversal.java) +9|[Successful Pairs of Spells and Potions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Successful%20Pairs%20of%20Spells%20and%20Potions.java) +10|[Sort the Jumbled Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20the%20Jumbled%20Numbers.java) +11|[Closest Nodes Queries in a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Closest%20Nodes%20Queries%20in%20a%20Binary%20Search%20Tree.java) +12|[House Robber III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/House%20Robber%20III.java) +13|[Out of Boundary Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Out%20of%20Boundary%20Paths.java) +14|[Campus Bikes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Campus%20Bikes.java) +15|[Arithmetic Subarrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Arithmetic%20Subarrays.java) +16|[Binary Tree Level Order Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Level%20Order%20Traversal.java) +17|[Vowels of All Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Vowels%20of%20All%20Substrings.java) +18|[Grumpy Bookstore Owner](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Grumpy%20Bookstore%20Owner.java) +19|[Minimize the Maximum Difference of Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimize%20the%20Maximum%20Difference%20of%20Pairs.java) +20|[Linked List Cycle II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20Cycle%20II.java) +21|[Dota2 Senate](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Dota2%20Senate.java) +22|[Largest Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Largest%20Number.java) +23|[Stone Game II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Stone%20Game%20II.java) +24|[Web Crawler](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Web%20Crawler.java) +25|[Champagne Tower](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Champagne%20Tower.java) +26|[Candy Crush](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Candy%20Crush.java) +27|[Bold Words in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Bold%20Words%20in%20String.java) +28|[Diagonal Traverse](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Diagonal%20Traverse.java) +29|[Shortest Way to Form String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Way%20to%20Form%20String.java) +30|[Maximum Number of Coins You Can Get](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Coins%20You%20Can%20Get.java) +31|[Masking Personal Information](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Masking%20Personal%20Information.java) +32|[The Earliest Moment When Everyone Become Friends](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20Earliest%20Moment%20When%20Everyone%20Become%20Friends.java) +33|[Divide Two Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Divide%20Two%20Integers.java) +34|[Minimum Cost to Connect Sticks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Cost%20to%20Connect%20Sticks.java) +35|[Lowest Common Ancestor of Deepest Leaves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lowest%20Common%20Ancestor%20of%20Deepest%20Leaves.java) +36|[Single Number III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Single%20Number%20III.java) +37|[Next Greater Element III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Greater%20Element%20III.java) +38|[Making File Names Unique](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Making%20File%20Names%20Unique.java) +39|[Validate Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Validate%20Binary%20Search%20Tree.java) +40|[Sparse Matrix Multiplication](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sparse%20Matrix%20Multiplication.java) +41|[Uncrossed Lines](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Uncrossed%20Lines.java) +42|[Capacity To Ship Packages Within D Days](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Capacity%20To%20Ship%20Packages%20Within%20D%20Days.java) +43|[Count Vowel Strings in Ranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Vowel%20Strings%20in%20Ranges.java) +44|[Set Matrix Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Set%20Matrix%20Zeroes.java) +45|[Flatten a Multilevel Doubly Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%20a%20Multilevel%20Doubly%20Linked%20List.java) +46|[Word Subsets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Word%20Subsets.java) +47|[Find Smallest Common Element in All Rows](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Smallest%20Common%20Element%20in%20All%20Rows.java) +48|[Reverse Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Integer.java) +49|[Most Popular Video Creator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Most%20Popular%20Video%20Creator.java) +50|[Most Stones Removed with Same Row or Column](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Most%20Stones%20Removed%20with%20Same%20Row%20or%20Column.java) +51|[Shortest Word Distance II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Word%20Distance%20II.java) +52|[Total Hamming Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Total%20Hamming%20Distance.java) +53|[Sort Linked List Already Sorted Using Absolute Values](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Linked%20List%20Already%20Sorted%20Using%20Absolute%20Values.java) +54|[Count Number of Homogenous Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Number%20of%20Homogenous%20Substrings.java) +55|[Score of Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Score%20of%20Parentheses.java) +56|[Gas Station](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Gas%20Station.java) +57|[Number of Subarrays with Bounded Maximum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Subarrays%20with%20Bounded%20Maximum.java) +58|[Kth Largest Sum in a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kth%20Largest%20Sum%20in%20a%20Binary%20Tree.java) +59|[Smallest Number in Infinite Set](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20Number%20in%20Infinite%20Set.java) +60|[All Divisions With the Highest Score of a Binary Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Divisions%20With%20the%20Highest%20Score%20of%20a%20Binary%20Array.java) +61|[Non-decreasing Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Non-decreasing%20Array.java) +62|[Palindrome Partitioning](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Palindrome%20Partitioning.java) +63|[Find all Duplicates in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20all%20Duplicates%20in%20an%20Array.java) +64|[Find Largest Value in Each Tree Row](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Largest%20Value%20in%20Each%20Tree%20Row.java) +65|[Flatten 2D Vector](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%202D%20Vector.java) +66|[Find All Lonely Numbers in the Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20All%20Lonely%20Numbers%20in%20the%20Array.java) +67|[Furthest Building You Can Reach](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Furthest%20Building%20You%20Can%20Reach.java) +68|[Convert Binary Search Tree to Sorted Doubly Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Convert%20Binary%20Search%20Tree%20to%20Sorted%20Doubly%20Linked%20List.java) +69|[Design a File Sharing System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20a%20File%20Sharing%20System.java) +70|[Watering Plants](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Watering%20Plants.java) +71|[Smallest String Starting From Leaf](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20String%20Starting%20From%20Leaf.java) +72|[Throne Inheritence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Throne%20Inheritence.java) +73|[Minimum Remove to Make Valid Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Remove%20to%20Make%20Valid%20Parentheses.java) +74|[Implement Trie II (Prefix Tree)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Implement%20Trie%20II%20(Prefix%20Tree).java) +75|[Remove Covered Intervals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Covered%20Intervals.java) +76|[Minimum Add to Make Parentheses Valid](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Add%20to%20Make%20Parentheses%20Valid.java) +77|[Arithmetic Slices](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Arithmetic%20Slices.java) +78|[Binary Tree Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Preorder%20Traversal.java) +79|[Time Needed to Inform All Employees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Time%20Needed%20to%20Inform%20All%20Employees.java) +80|[Kill Process](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kill%20Process.java) +81|[Maximum Twin Sum of a Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Twin%20Sum%20of%20a%20Linked%20List.java) +82|[Line Reflection](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Line%20Reflection.java) +83|[Maximum Number of Occurrences of a Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Occurrences%20of%20a%20Substring.java) +84|[Frequency Tracker](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Frequency%20Tracker.java) +85|[Diameter of N-ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Diameter%20of%20N-ary%20Tree.java) +86|[Maximum Number of Non-Overlapping Subarrays With Sum Equals Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Non-Overlapping%20Subarrays%20With%20Sum%20Equals%20Target.java) +87|[Majority Element II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Majority%20Element%20II.java) +88|[Number of Ways to Split Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Ways%20to%20Split%20Array.java) +89|[Plus One Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Plus%20One%20Linked%20List.java) +90|[Append Characters to String to Make Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Append%20Characters%20to%20String%20to%20Make%20Subsequence.java) +91|[Longest Consecutive Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Consecutive%20Sequence.java) +92|[Find Minimum in Rotated Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Minimum%20in%20Rotated%20Sorted%20Array.java) +93|[Decrease Elements To Make Array Zigzag](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Decrease%20Elements%20To%20Make%20Array%20Zigzag.java) +94|[Binary Tree Longest Consecutive Sequence II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Longest%20Consecutive%20Sequence%20II.java) +95|[Concatenation of Consecutive Binary Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Concatenation%20of%20Consecutive%20Binary%20Numbers.java) +96|[Bitwise AND of Numbers Range](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Bitwise%20AND%20of%20Numbers%20Range.java) +97|[Maximum Points You Can Obtain from Cards](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Points%20You%20Can%20Obtain%20from%20Cards.java) +98|[Count Number of Teams](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Number%20of%20Teams.java) +99|[Sum of Subarray Minimums](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Subarray%20Minimums.java) +100|[Binary Trees With Factors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Trees%20With%20Factors.java) +101|[Prime Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Prime%20Palindrome.java) +102|[Minimum Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Path%20Sum.java) +103|[Friend Circles](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Friend%20Circles.java) +104|[Matchsticks to Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Matchsticks%20to%20Square.java) +105|[Valid Sudoku](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Sudoku.java) +106|[Four Divisors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Four%20Divisors.java) +107|[As Far from Land as Possible](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/As%20Far%20from%20Land%20as%20Possible.java) +108|[Count Square Submatrices with All Ones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Square%20Submatrices%20with%20All%20Ones.java) +109|[Linked List in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20in%20Binary%20Tree.java) +110|[Number of Nodes in the Sub-Tree With the Same Label](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Nodes%20in%20the%20Sub-Tree%20With%20the%20Same%20Label.java) +111|[Pseudo-Palindromic Paths in a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pseudo-Palindromic%20Paths%20in%20a%20Binary%20Tree.java) +112|[Pancake Sorting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pancake%20Sorting.java) +113|[Walls and Gates](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Walls%20and%20Gates.java) +114|[Decode String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Decode%20String.java) +115|[Combination Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Combination%20Sum%20II.java) +116|[Complete Binary Tree Insertor](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Complete%20Binary%20Tree%20Insertor.java) +117|[Minimum Moves to Equal Array Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Moves%20to%20Equal%20Array%20Elements.java) +118|[Design an ATM Machine](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20an%20ATM%20Machine.java) +119|[Split Linked List in Parts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Split%20Linked%20List%20in%20Parts.java) +120|[Longest Word With All Prefixes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Word%20With%20All%20Prefixes.java) +121|[Binary Tree Pruning](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Pruning.java) +122|[Escape The Ghosts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Escape%20The%20Ghosts.java) +123|[Longest Arithmetic Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Arithmetic%20Sequence.java) +124|[Longest Arithmetic Subsequence of Given Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Arithmetic%20Subsequence%20of%20Given%20Difference.java) +125|[Equal Row and Column Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Equal%20Row%20and%20Column%20Pairs.java) +126|[Count Numbers With Unique Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Numbers%20With%20Unique%20Digits.java) +127|[Maximum Average Subtree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Average%20Subtree.java) +128|[Product of Array Except self](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Product%20of%20Array%20Except%20self.java) +129|[Find Bottom Left Tree Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Bottom%20Left%20Tree%20Value.java) +130|[Shifting Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shifting%20Letters.java) +131|[Maximum Product of Splitted Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Product%20of%20Splitted%20Binary%20Tree.java) +132|[Minimum Knight Moves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Knight%20Moves.java) +133|[3Sum With Multiplicity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/3Sum%20With%20Multiplicity.java) +134|[Rotting Oranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotting%20Oranges.java) +135|[Palindromic Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Palindromic%20Substrings.java) +136|[Maximum of Absolute Value Expression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20of%20Absolute%20Value%20Expression.java) +137|[Insert Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20Interval.java) +138|[Is Graph Bipartite](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Is%20Graph%20Bipartite.java) +139|[Add Two Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20Two%20Numbers.java) +140|[Find Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Permutation.java) +141|[Number of Burgers with No Waste of Ingredients](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Burgers%20with%20No%20Waste%20of%20Ingredients.java) +142|[Finding the Users Active Minutes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Finding%20the%20Users%20Active%20Minutes.java) +143|[Validate Stack Sequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Validate%20Stack%20Sequences.java) +144|[Number of Substrings Containing All Three Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Substrings%20Containing%20All%20Three%20Characters.java) +145|[Next Greater Element II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Greater%20Element%20II.java) +146|[Count and Say](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20and%20Say.java) +147|[Design Add and Search Words Data Structure](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Add%20and%20Search%20Words%20Data%20Structure.java) +148|[Maximum Score From Removing Stones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Score%20From%20Removing%20Stones.java) +149|[Minimum Consecutive Cards to Pick Up](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Consecutive%20Cards%20to%20Pick%20Up.java) +150|[Score After Flipping Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Score%20After%20Flipping%20Matrix.java) +151|[Jump Game VI](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Jump%20Game%20VI.java) +152|[Design Browser History](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Browser%20History.java) +153|[Cheapest Flights Within K Stops](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Cheapest%20Flights%20Within%20K%20Stops.java) +154|[Meeting Scheduler](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Meeting%20Scheduler.java) +155|[Perfect Squares](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Perfect%20Squares.java) +156|[Maximum Matching of Players With Trainers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Matching%20of%20Players%20With%20Trainers.java) +157|[Word Search](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Word%20Search.java) +158|[Find Triangular Sum of an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Triangular%20Sum%20of%20an%20Array.java) +159|[Knight Dialer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Knight%20Dialer.java) +160|[3Sum Smaller](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/3Sum%20Smaller.java) +161|[Repeated DNA Sequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Repeated%20DNA%20Sequences.java) +162|[Lowest Common Ancestor of a Binary Tree III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lowest%20Common%20Ancestor%20of%20a%20Binary%20Tree%20III.java) +163|[Partition Array According to Given Pivot](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partition%20Array%20According%20to%20Given%20Pivot.java) +164|[Construct K Palindrome Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20K%20Palindrome%20Strings.java) +165|[Solve the Equation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Solve%20the%20Equation.java) +166|[Average Waiting Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Average%20Waiting%20Time.java) +167|[Time Needed to Rearrange a Binary String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Time%20Needed%20to%20Rearrange%20a%20Binary%20String.java) +168|[Sort Integers by The Power Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Integers%20by%20The%20Power%20Value.java) +169|[Sum in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20in%20a%20Matrix.java) +170|[Combination Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Combination%20Sum.java) +171|[Make String a Subsequence Using Cyclic Increments](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Make%20String%20a%20Subsequence%20Using%20Cyclic%20Increments.java) +172|[Merge Intervals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Merge%20Intervals.java) +173|[4 Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/4%20Sum%20II.java) +174|[Advantage Shuffle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Advantage%20Shuffle.java) +175|[Number of Dice Rolls With Target Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Dice%20Rolls%20With%20Target%20Sum.java) +176|[Minimum Flips to Make a OR b Equal to c](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Flips%20to%20Make%20a%20OR%20b%20Equal%20to%20c.java) +177|[Basic Calculator II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Basic%20Calculator%20II.java) +178|[Find Original Array From Doubled Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Original%20Array%20From%20Doubled%20Array.java) +179|[Maximum Length of Repeated Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Length%20of%20Repeated%20Subarray.java) +180|[Lonely Pixel I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lonely%20Pixel%20I.java) +181|[Guess Number Higher or Lower II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Guess%20Number%20Higher%20or%20Lower%20II.java) +182|[Remove Duplicate Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Duplicate%20Letters.java) +183|[Construct Binary Tree from Preorder and Inorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20Binary%20Tree%20from%20Preorder%20and%20Inorder%20Traversal.java) +184|[Group the People Given the Group Size They Belong To](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Group%20the%20People%20Given%20the%20Group%20Size%20They%20Belong%20To.java) +185|[House Robber II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/House%20Robber%20II.java) +186|[Find the Winner of an Array Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Winner%20of%20an%20Array%20Game.java) +187|[Check if Strings Can be Made Equal With Operations II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20if%20Strings%20Can%20be%20Made%20Equal%20With%20Operations%20II.java) +188|[Letter Combinations of a Phone Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Letter%20Combinations%20of%20a%20Phone%20Number.java) +189|[Implement Magic Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Implement%20Magic%20Dictionary.java) +190|[Task Scheduler](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Task%20Scheduler.java) +191|[Minimum Size Subarray Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Size%20Subarray%20Sum.java) +192|[Max Chunks To Make Sorted](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Chunks%20To%20Make%20Sorted.java) +193|[Max Number of K-Sum Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Number%20of%20K-Sum%20Pairs.java) +194|[Longest Word in Dictionary through Deleting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Word%20in%20Dictionary%20through%20Deleting.java) +195|[Maximum Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Binary%20Tree.java) +196|[Find and Replace in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20and%20Replace%20in%20String.java) +197|[Sort Characters By Frequency](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Characters%20By%20Frequency.java) +198|[Maximum Erasure Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Erasure%20Value.java) +199|[Number of Matching Subsequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Matching%20Subsequences.java) +200|[Simple Bank System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Simple%20Bank%20System.java) +201|[Camelcase Matching](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Camelcase%20Matching.java) +202|[Split Array into Consecutive Subsequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Split%20Array%20into%20Consecutive%20Subsequences.java) +203|[Integer To Roman](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Integer%20To%20Roman.java) +204|[Smallest Value of the Rearranged Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20Value%20of%20the%20Rearranged%20Number.java) +205|[Count Servers That Communicate](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Servers%20That%20Communicate.java) +206|[Execution of All Suffix Instructions Staying in a Grid](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Execution%20of%20All%20Suffix%20Instructions%20Staying%20in%20a%20Grid.java) +207|[Number of Laser Beams in a Bank](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Laser%20Beams%20in%20a%20Bank.java) +208|[Minimize Maximum Pair Sum in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimize%20Maximum%20Pair%20Sum%20in%20Array.java) +209|[Lowest Common Ancestor of a Binary Tree II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lowest%20Common%20Ancestor%20of%20a%20Binary%20Tree%20II.java) +210|[Image Overlap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Image%20Overlap.java) +211|[Balance a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Balance%20a%20Binary%20Search%20Tree.java) +212|[Insert Greatest Common Divisors in Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20Greatest%20Common%20Divisors%20in%20Linked%20List.java) +213|[Reordered Power of 2](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reordered%20Power%20of%202.java) +214|[Construct Binary Tree from Inorder and Postorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20Binary%20Tree%20from%20Inorder%20and%20Postorder%20Traversal.java) +215|[Multiply Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Multiply%20Strings.java) +216|[K Radius Subarray Averages](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/K%20Radius%20Subarray%20Averages.java) +217|[Minimum Health to Beat Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Health%20to%20Beat%20Game.java) +218|[Path With Minimum Effort](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20With%20Minimum%20Effort.java) +219|[Append K Integers With Minimal Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Append%20K%20Integers%20With%20Minimal%20Sum.java) +220|[Minimum Moves to Equal Array Elements II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Moves%20to%20Equal%20Array%20Elements%20II.java) +221|[Parallel Courses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Parallel%20Courses.java) +222|[Put Boxes Into the Warehouse I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Put%20Boxes%20Into%20the%20Warehouse%20I.java) +223|[Adding Two Negabinary Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Adding%20Two%20Negabinary%20Numbers.java) +224|[Minimum Rounds to Complete All Tasks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Rounds%20to%20Complete%20All%20Tasks.java) +225|[Longest Happy String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Happy%20String.java) +226|[Nested List Weight Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Nested%20List%20Weight%20Sum%20II.java) +227|[Range Sum Query 2D-Immutable](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Sum%20Query%202D-Immutable.java) +228|[Remove Nth Node From End of List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Nth%20Node%20From%20End%20of%20List.java) +229|[Peeking Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Peeking%20Iterator.java) +230|[Subsets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subsets.java) +231|[Design Circular Queue](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Circular%20Queue.java) +232|[4 Keys Keyboard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/4%20Keys%20Keyboard.java) +233|[Single Element in a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Single%20Element%20in%20a%20Sorted%20Array.java) +234|[Permutations II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Permutations%20II.java) +235|[Knight Probability in Chessboard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Knight%20Probability%20in%20Chessboard.java) +236|[Reachable Nodes With Restrictions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reachable%20Nodes%20With%20Restrictions.java) +237|[Longest ZigZag Path in a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20ZigZag%20Path%20in%20a%20Binary%20Tree.java) +238|[Reduce Array Size to The Half](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reduce%20Array%20Size%20to%20The%20Half.java) +239|[Maximum Length of Pair Chain](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Length%20of%20Pair%20Chain.java) +240|[Binary Tree Vertical Order Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Vertical%20Order%20Traversal.java) +241|[Reorder Data in Log Files](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reorder%20Data%20in%20Log%20Files.java) +242|[Maximum Product Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Product%20Subarray.java) +243|[Rotate List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20List.java) +244|[Find the Celebrity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Celebrity.java) +245|[Swap Nodes in Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Swap%20Nodes%20in%20Pairs.java) +246|[Filter Restaurants by Vegan-Friendly, Price and Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Filter%20Restaurants%20by%20Vegan-Friendly,%20Price%20and%20Distance.java) +247|[Evaluate Division](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Evaluate%20Division.java) +248|[Minimum Operations to Make Array Equal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Operations%20to%20Make%20Array%20Equal.java) +249|[Combinations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Combinations.java) +250|[Max Area of Island](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Area%20of%20Island.java) +251|[Sort List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20List.java) +252|[Most Frequent Subtree Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Most%20Frequent%20Subtree%20Sum.java) +253|[Find Peak Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Peak%20Element.java) +254|[Open The Lock](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Open%20The%20Lock.java) +255|[Fruit Into Baskets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Fruit%20Into%20Baskets.java) +256|[Maximum Sum of Almost Unique Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Sum%20of%20Almost%20Unique%20Subarray.java) +257|[Remove K Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20K%20Digits.java) +258|[Minimum Number of Steps to Make Two Strings Anagram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Number%20of%20Steps%20to%20Make%20Two%20Strings%20Anagram.java) +259|[Connecting Cities With Minimum Cost](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Connecting%20Cities%20With%20Minimum%20Cost.java) +260|[Decoded String at Index](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Decoded%20String%20at%20Index.java) +261|[Satisfisbility of Equality Equations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Satisfisbility%20of%20Equality%20Equations.java) +262|[Maximum Product of Word Lengths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Product%20of%20Word%20Lengths.java) +263|[Maximum Number of Integers to Choose From a Range I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Integers%20to%20Choose%20From%20a%20Range%20I.java) +264|[Pour Water](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pour%20Water.java) +265|[Gray Code](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Gray%20Code.java) +266|[Minimum Moves to Reach Target Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Moves%20to%20Reach%20Target%20Score.java) +267|[Encode and Decode TinyURL](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Encode%20and%20Decode%20TinyURL.java) +268|[Game of Life](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Game%20of%20Life.java) +269|[Number of Pairs of Strings With Concatenation Equal to Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Pairs%20of%20Strings%20With%20Concatenation%20Equal%20to%20Target.java) +270|[Maximum Swap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Swap.java) +271|[Time Based Key-Value Store](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Time%20Based%20Key-Value%20Store.java) +272|[Compare Version Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Compare%20Version%20Numbers.java) +273|[Reverse Nodes in Even Length Groups](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Nodes%20in%20Even%20Length%20Groups.java) +274|[Maximum Number of Vowels in a Substring of Given Length](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Vowels%20in%20a%20Substring%20of%20Given%20Length.java) +275|[Graph Valid Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Graph%20Valid%20Tree.java) +276|[Minimum Operations to Reduce X to Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Operations%20to%20Reduce%20X%20to%20Zero.java) +277|[Group Anagrams](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Group%20Anagrams.java) +278|[Delete the Middle Node of a Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20the%20Middle%20Node%20of%20a%20Linked%20List.java) +279|[Lowest Common Ancestor of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lowest%20Common%20Ancestor%20of%20a%20Binary%20Tree.java) +280|[Deepest Leaves Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Deepest%20Leaves%20Sum.java) +281|[Minimize Maximum of Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimize%20Maximum%20of%20Array.java) +282|[Boundary of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Boundary%20of%20Binary%20Tree.java) +283|[Clone N-ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Clone%20N-ary%20Tree.java) +284|[Rotate Image](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20Image.java) +285|[Self Dividing Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Self%20Dividing%20Numbers.java) +286|[Remove Nodes From Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Nodes%20From%20Linked%20List.java) +287|[Map Sum Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Map%20Sum%20Pairs.java) +288|[Restore the Array From Adjacent Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Restore%20the%20Array%20From%20Adjacent%20Pairs.java) +289|[Find the Index of the Large Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Index%20of%20the%20Large%20Integer.java) +290|[Combination Sum IV](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Combination%20Sum%20IV.java) +291|[Pacific Atlantic Water Flow](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pacific%20Atlantic%20Water%20Flow.java) +292|[Delete Leaves With a Given Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Leaves%20With%20a%20Given%20Value.java) +293|[Pow](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pow.java) +294|[Remove Comments](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Comments.java) +295|[Longest Uploaded Prefix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Uploaded%20Prefix.java) +296|[Rotated Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotated%20Digits.java) +297|[Next Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Permutation.java) +298|[Find the Substring With Maximum Cost](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Substring%20With%20Maximum%20Cost.java) +299|[Design Log Storage System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Log%20Storage%20System.java) +300|[Decode Ways](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Decode%20Ways.java) +301|[Number of Longest Increasing Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Longest%20Increasing%20Subsequence.java) +302|[Triangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Triangle.java) +303|[Non-overlapping Intervals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Non-overlapping%20Intervals.java) +304|[Broken Calculator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Broken%20Calculator.java) +305|[Maximum Score from Performing Multiplication Operations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Score%20from%20Performing%20Multiplication%20Operations.java) +306|[Vowel Spellchecker](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Vowel%20Spellchecker.java) +307|[Maximum Sum of Distinct Subarrays With Length K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Sum%20of%20Distinct%20Subarrays%20With%20Length%20K.java) +308|[4Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/4Sum.java) +309|[House Robber](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/House%20Robber.java) +310|[Find Root of N-Ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Root%20of%20N-Ary%20Tree.java) +311|[Rotate Function](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20Function.java) +312|[Can Make Palindrome from Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Can%20Make%20Palindrome%20from%20Substring.java) +313|[Find Distance in a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Distance%20in%20a%20Binary%20Tree.java) +314|[Possible Bipartition](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Possible%20Bipartition.java) +315|[Design Hit Counter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Hit%20Counter.java) +316|[Insert into a Sorted Circular Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20into%20a%20Sorted%20Circular%20Linked%20List.java) +317|[Online Stock Span](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Online%20Stock%20Span.java) +318|[Min Cost to Connect All Points](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Min%20Cost%20to%20Connect%20All%20Points.java) +319|[Minimum Time to Collect All Apples in a Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Time%20to%20Collect%20All%20Apples%20in%20a%20Tree.java) +320|[Minimum Area Rectangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Area%20Rectangle.java) +321|[Invalid Transactions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Invalid%20Transactions.java) +322|[Remove All Occurrences of a Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20All%20Occurrences%20of%20a%20Substring.java) +323|[Minimum Average Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Average%20Difference.java) +324|[Maximal Score After Applying K Operations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximal%20Score%20After%20Applying%20K%20Operations.java) +325|[Minimum Amount of Time to Collect Garbage](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Amount%20of%20Time%20to%20Collect%20Garbage.java) +326|[Search in Rotated Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20in%20Rotated%20Sorted%20Array.java) +327|[Letter Tiles Possibilities](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Letter%20Tiles%20Possibilities.java) +328|[Divide Players Into Teams of Equal Skill](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Divide%20Players%20Into%20Teams%20of%20Equal%20Skill.java) +329|[Path with Maximum Gold](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20with%20Maximum%20Gold.java) +330|[Copy List with Random Pointer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Copy%20List%20with%20Random%20Pointer.java) +331|[Number of Islands](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Islands.java) +332|[Total Cost to Hire K Workers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Total%20Cost%20to%20Hire%20K%20Workers.java) +333|[Sum Multiples](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20Multiples.java) +334|[Custom Sort String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Custom%20Sort%20String.java) +335|[Populating Next Right Pointers in Each Node](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Populating%20Next%20Right%20Pointers%20in%20Each%20Node.java) +336|[Mirror Reflection](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Mirror%20Reflection.java) +337|[All Possible Full Binary Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Possible%20Full%20Binary%20Trees.java) +338|[Maximum Total Importance of Roads](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Total%20Importance%20of%20Roads.java) +339|[Sum Root to Leaf Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20Root%20to%20Leaf%20Numbers.java) +340|[Contiguous Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Contiguous%20Array.java) +341|[Large Divisble Subset](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Large%20Divisble%20Subset.java) +342|[Minimum Height Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Height%20Trees.java) +343|[Analyze User Website Visit Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Analyze%20User%20Website%20Visit%20Pattern.java) +344|[Partitioning Into Minimum Number Of Deci-Binary Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partitioning%20Into%20Minimum%20Number%20Of%20Deci-Binary%20Numbers.java) +345|[Permutations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Permutations.java) +346|[Maximum Sum of an Hourglass](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Sum%20of%20an%20Hourglass.java) +347|[Minimum Fuel Cost to Report to the Capital](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Fuel%20Cost%20to%20Report%20to%20the%20Capital.java) +348|[Find the Prefix Common Array of Two Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Prefix%20Common%20Array%20of%20Two%20Arrays.java) +349|[Coin Change 2](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Coin%20Change%202.java) +350|[Construct Quad Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20Quad%20Tree.java) +351|[Valid Parenthesis String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Parenthesis%20String.java) +352|[Apply Discount Every n Orders](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Apply%20Discount%20Every%20n%20Orders.java) +353|[All Elements in Two Binary Search Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Elements%20in%20Two%20Binary%20Search%20Trees.java) +354|[Longest Substring Without Repeating Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Substring%20Without%20Repeating%20Characters.java) +355|[Fraction to Recurring Decimal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Fraction%20to%20Recurring%20Decimal.java) +356|[Extra Characters in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Extra%20Characters%20in%20a%20String.java) +357|[Product of the Last K Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Product%20of%20the%20Last%20K%20Numbers.java) +358|[Wiggle Sort](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Wiggle%20Sort.java) +359|[Peak Index in a Mountain Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Peak%20Index%20in%20a%20Mountain%20Array.java) +360|[Accounts Merge](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Accounts%20Merge.java) +361|[K Closest Points to Origin](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/K%20Closest%20Points%20to%20Origin.java) +362|[Largest Time for Given Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Largest%20Time%20for%20Given%20Digits.java) +363|[Fair Distribution of Cookies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Fair%20Distribution%20of%20Cookies.java) +364|[Count Sub Islands](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Sub%20Islands.java) +365|[Reverse Words in a String II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Words%20in%20a%20String%20II.java) +366|[Find Leaves of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Leaves%20of%20Binary%20Tree.java) +367|[Partition Labels](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partition%20Labels.java) +368|[Apply Discount to Prices](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Apply%20Discount%20to%20Prices.java) +369|[Sort An Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20An%20Array.java) +370|[Hand of Straights](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Hand%20of%20Straights.java) +371|[Angle Between Hands of a Clock](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Angle%20Between%20Hands%20of%20a%20Clock.java) +372|[Maximum Star Sum of a Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Star%20Sum%20of%20a%20Graph.java) +373|[Reorder List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reorder%20List.java) +374|[Find a Corresponding Node of a Binary Tree in a Clone of That Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20a%20Corresponding%20Node%20of%20a%20Binary%20Tree%20in%20a%20Clone%20of%20That%20Tree.java) +375|[Remove Colored Pieces if Both Neighbors are the Same Color](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Colored%20Pieces%20if%20Both%20Neighbors%20are%20the%20Same%20Color.java) +376|[Find Consecutive Integers from a Data Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Consecutive%20Integers%20from%20a%20Data%20Stream.java) +377|[Find Eventual Safe States](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Eventual%20Safe%20States.java) +378|[Odd Even Linked Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Odd%20Even%20Linked%20Lists.java) +379|[Find Right Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Right%20Interval.java) +380|[Dot Product of Two Sparse Vectors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Dot%20Product%20of%20Two%20Sparse%20Vectors.java) +381|[Minimum Number of Arrows to Burst Balloons](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Number%20of%20Arrows%20to%20Burst%20Balloons.java) +382|[Product of Two Run-Length Encoded Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Product%20of%20Two%20Run-Length%20Encoded%20Arrays.java) +383|[HTML Entity Parser](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/HTML%20Entity%20Parser.java) +384|[Find All Anagrams in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20All%20Anagrams%20in%20a%20String.java) +385|[Boats to Save People](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Boats%20to%20Save%20People.java) +386|[Print Words Vertically](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Print%20Words%20Vertically.java) +387|[Minimum Falling Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Falling%20Path%20Sum.java) +388|[Strictly Palindromic Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Strictly%20Palindromic%20Number.java) +389|[Sentence Similarity III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sentence%20Similarity%20III.java) +390|[Minimum Genetic Mutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Genetic%20Mutation.java) +391|[Split BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Split%20BST.java) +392|[Iterator for Combination](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Iterator%20for%20Combination.java) +393|[Valid Triangle Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Triangle%20Number.java) +394|[Keys and Rooms](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Keys%20and%20Rooms.java) +395|[Interval List Intersections](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Interval%20List%20Intersections.java) +396|[Subarray Sums Divisible by K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subarray%20Sums%20Divisible%20by%20K.java) +397|[Merge Nodes in Between Zeros](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Merge%20Nodes%20in%20Between%20Zeros.java) +398|[Maximum Level Sum of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Level%20Sum%20of%20a%20Binary%20Tree.java) +399|[Expressive Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Expressive%20Words.java) +400|[Friends Of Appropriate Ages](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Friends%20Of%20Appropriate%20Ages.java) +401|[Flatten Nested List Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%20Nested%20List%20Iterator.java) +402|[Corporate Flight Bookings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Corporate%20Flight%20Bookings.java) +403|[Unique Binary Search Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Binary%20Search%20Trees.java) +404|[Longest Increasing Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Increasing%20Subsequence.java) +405|[Design Front Middle Back Queue](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Front%20Middle%20Back%20Queue.java) +406|[Design A Leaderboard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20A%20Leaderboard.java) +407|[Search in Rotated Sorted Array II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20in%20Rotated%20Sorted%20Array%20II.java) +408|[Tuple With Same Product](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Tuple%20With%20Same%20Product.java) +409|[Delete Nodes And Return Forest](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Nodes%20And%20Return%20Forest.java) +410|[The kth Factor of n](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20kth%20Factor%20of%20n.java) +411|[Minimum Time Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Time%20Difference.java) +412|[Maximum Length of Subarray With Positive Product](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Length%20of%20Subarray%20With%20Positive%20Product.java) +413|[Smallest Integer Divisible by K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20Integer%20Divisible%20by%20K.java) +414|[Find Players With Zero or One Losses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Players%20With%20Zero%20or%20One%20Losses.java) +415|[Min Stack](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Min%20Stack.java) +416|[Remove Zero Sum Consecutive Nodes from Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Zero%20Sum%20Consecutive%20Nodes%20from%20Linked%20List.java) +417|[Validate IP Address](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Validate%20IP%20Address.java) +418|[Reduction Operations to Make the Array Elements Equal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reduction%20Operations%20to%20Make%20the%20Array%20Elements%20Equal.java) +419|[Nearest Exit from Entrance in Maze](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Nearest%20Exit%20from%20Entrance%20in%20Maze.java) +420|[Cinema Seat Allocation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Cinema%20Seat%20Allocation.java) +421|[Delete Operation for Two Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Operation%20for%20Two%20Strings.java) +422|[Path with Maximum Probability](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20with%20Maximum%20Probability.java) +423|[Minimum Time to Complete Trips](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Time%20to%20Complete%20Trips.java) +424|[Check If All 1's Are at Least Length K Places Away](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20If%20All%201's%20Are%20at%20Least%20Length%20K%20Places%20Away.java) +425|[RLE Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/RLE%20Iterator.java) +426|[Increasing Subsequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Increasing%20Subsequences.java) +427|[Number of Closed Islands](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Closed%20Islands.java) +428|[Number of Substrings With Only 1s](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Substrings%20With%20Only%201s.java) +429|[Delete Tree Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Tree%20Nodes.java) +430|[Exclusive Time of Functions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Exclusive%20Time%20of%20Functions.java) +431|[Check If a String Is a Valid Sequence from Root to Leaves Path in a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20If%20a%20String%20Is%20a%20Valid%20Sequence%20from%20Root%20to%20Leaves%20Path%20in%20a%20Binary%20Tree.java) +432|[Count Ways To Build Good Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Ways%20To%20Build%20Good%20Strings.java) +433|[Minimum Score of a Path Between Two Cities](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Score%20of%20a%20Path%20Between%20Two%20Cities.java) +434|[Leftmost Column with at Least a One](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Leftmost%20Column%20with%20at%20Least%20a%20One.java) +435|[Subsets II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subsets%20II.java) +436|[One Edit Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/One%20Edit%20Distance.java) +437|[N-ary Tree Level Order Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/N-ary%20Tree%20Level%20Order%20Traversal.java) +438|[Design Snake Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Snake%20Game.java) +439|[Swap For Longest Repeated Character Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Swap%20For%20Longest%20Repeated%20Character%20Substring.java) +440|[Find the Student that Will Replace the Chalk](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Student%20that%20Will%20Replace%20the%20Chalk.java) +441|[LRU Cache](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/LRU%20Cache.java) +442|[Maximum Number of Groups Entering a Competition](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Groups%20Entering%20a%20Competition.java) +443|[Container With Most Water](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Container%20With%20Most%20Water.java) +444|[Subdomain Visit Count](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subdomain%20Visit%20Count.java) +445|[4Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/4Sum%20II.java) +446|[Word Ladder](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Word%20Ladder.java) +447|[Delete Node in a BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Node%20in%20a%20BST.java) +448|[Longest Well-Performing Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Well-Performing%20Interval.java) +449|[Reconstruct Original Digits from English](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reconstruct%20Original%20Digits%20from%20English.java) +450|[Single Number II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Single%20Number%20II.java) +451|[Maximum Value after Insertion](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Value%20after%20Insertion.java) +452|[Optimal Division](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Optimal%20Division.java) +453|[Continuous Subarray Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Continuous%20Subarray%20Sum.java) +454|[Number of Operations to Make Network Connected](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Operations%20to%20Make%20Network%20Connected.java) +455|[Network Delay Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Network%20Delay%20Time.java) +456|[Flip Equivalent Binary Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flip%20Equivalent%20Binary%20Trees.java) +457|[String to Integer (atoi)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/String%20to%20Integer%20(atoi).java) +458|[Coin Change](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Coin%20Change.java) +459|[Max Consecutives Ones II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Consecutives%20Ones%20II.java) +460|[Kth Smallest Element in a BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kth%20Smallest%20Element%20in%20a%20BST.java) +461|[UTF-8 Validation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/UTF-8%20Validation.java) +462|[Remove Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Interval.java) +463|[Find Nearest Right Node in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Nearest%20Right%20Node%20in%20Binary%20Tree.java) +464|[Create Binary Tree From Descriptions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Create%20Binary%20Tree%20From%20Descriptions.java) +465|[Evaluate the Bracket Pairs of a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Evaluate%20the%20Bracket%20Pairs%20of%20a%20String.java) +466|[Wiggle Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Wiggle%20Subsequence.java) +467|[Random Pick Index](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Random%20Pick%20Index.java) +468|[Distribute Coins in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Distribute%20Coins%20in%20Binary%20Tree.java) +469|[Sum of Even Numbers After Queries](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Even%20Numbers%20After%20Queries.java) +470|[Path With Maximum Minimum Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20With%20Maximum%20Minimum%20Value.java) +471|[Most Profit Assigning Work](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Most%20Profit%20Assigning%20Work.java) +472|[The Number of Weak Characters in the Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20Number%20of%20Weak%20Characters%20in%20the%20Game.java) +473|[Partition List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partition%20List.java) +474|[Number of Distinct Islands](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Distinct%20Islands.java) +475|[Design Circular Deque](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Circular%20Deque.java) +476|[Implement Trie (Prefix Tree)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Implement%20Trie%20(Prefix%20Tree).java) +477|[Maximize Number of Subsequences in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximize%20Number%20of%20Subsequences%20in%20a%20String.java) +478|[Max Sum of a Pair With Equal Sum of Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Sum%20of%20a%20Pair%20With%20Equal%20Sum%20of%20Digits.java) +479|[Number of Provinces](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Provinces.java) +480|[Largest BST Subtree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Largest%20BST%20Subtree.java) +481|[Range Sum Query - Mutable](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Sum%20Query%20-%20Mutable.java) +482|[Mini Parser](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Mini%20Parser.java) +483|[Number of Smooth Descent Periods of a Stock](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Smooth%20Descent%20Periods%20of%20a%20Stock.java) +484|[Maximum Distance Between a Pair of Values](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Distance%20Between%20a%20Pair%20of%20Values.java) +485|[Alert Using Same Key-Card Three or More Times in a One Hour Period](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Alert%20Using%20Same%20Key-Card%20Three%20or%20More%20Times%20in%20a%20One%20Hour%20Period.java) +486|[Linked List Components](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20Components.java) +487|[Binary Tree Upside Down](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Upside%20Down.java) +488|[New 21 Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/New%2021%20Game.java) +489|[Max Increase to Keep City Skyline](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Increase%20to%20Keep%20City%20Skyline.java) +490|[Daily Temperatures](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Daily%20Temperatures.java) +491|[Binary Search Tree to Greater Sum Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Search%20Tree%20to%20Greater%20Sum%20Tree.java) +492|[Subarray Product Less Than K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subarray%20Product%20Less%20Than%20K.java) +493|[Design a Stack With Increment Operation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20a%20Stack%20With%20Increment%20Operation.java) +494|[Break a Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Break%20a%20Palindrome.java) +495|[Maximum Size Subarray Sum Equals k](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Size%20Subarray%20Sum%20Equals%20k.java) +496|[Minimum Number of Steps to Make Two Strings Anagram II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Number%20of%20Steps%20to%20Make%20Two%20Strings%20Anagram%20II.java) +497|[Subarray Sum Equals K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subarray%20Sum%20Equals%20K.java) +498|[Car Pooling](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Car%20Pooling.java) +499|[Remove Sub-Folders from the Filesystem](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Sub-Folders%20from%20the%20Filesystem.java) +500|[Sum of Nodes with Even-Valued Grandparent](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Nodes%20with%20Even-Valued%20Grandparent.java) +501|[Check If a String Can Break Another String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20If%20a%20String%20Can%20Break%20Another%20String.java) +502|[Ternary Expression Parser](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Ternary%20Expression%20Parser.java) +503|[Generate Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Generate%20Parentheses.java) +504|[Minimum Penalty for a Shop](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Penalty%20for%20a%20Shop.java) +505|[Encode and Decode Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Encode%20and%20Decode%20Strings.java) +506|[Asteroid Collision](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Asteroid%20Collision.java) +507|[Minimum Deletion Cost to Avoid Repeating Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Deletion%20Cost%20to%20Avoid%20Repeating%20Letters.java) +508|[Design Phone Directory](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Phone%20Directory.java) +509|[Remove Duplicates from Sorted List II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Duplicates%20from%20Sorted%20List%20II.java) +510|[Count Nodes Equal to Sum of Descendants](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Nodes%20Equal%20to%20Sum%20of%20Descendants.java) +511|[Random Pick With Weight](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Random%20Pick%20With%20Weight.java) +512|[Maximize the Topmost Element After K Moves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximize%20the%20Topmost%20Element%20After%20K%20Moves.java) +513|[Swapping Nodes in a Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Swapping%20Nodes%20in%20a%20Linked%20List.java) +514|[Number of Subsequences That Satisfy the Given Sum Condition](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Subsequences%20That%20Satisfy%20the%20Given%20Sum%20Condition.java) +515|[Ones and Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Ones%20and%20Zeroes.java) +516|[Number of Connected Components in an Undirected Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Connected%20Components%20in%20an%20Undirected%20Graph.java) +517|[Display Table of Food Orders in a Restaurant](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Display%20Table%20of%20Food%20Orders%20in%20a%20Restaurant.java) +518|[Campus Bikes II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Campus%20Bikes%20II.java) +519|[Longest Line of Consecutive One in Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Line%20of%20Consecutive%20One%20in%20Matrix.java) +520|[Zigzag Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Zigzag%20Iterator.java) +521|[Merge In Between Linked Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Merge%20In%20Between%20Linked%20Lists.java) +522|[Surrounded Regions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Surrounded%20Regions.java) +523|[Seat Reservation Manager](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Seat%20Reservation%20Manager.java) +524|[Print Immutable Linked List in Reverse](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Print%20Immutable%20Linked%20List%20in%20Reverse.java) +525|[Tree Diameter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Tree%20Diameter.java) +526|[Incremental Memory Leak](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Incremental%20Memory%20Leak.java) +527|[Lexicographically Smallest Equivalent String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lexicographically%20Smallest%20Equivalent%20String.java) +528|[Reverse Words in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Words%20in%20a%20String.java) +529|[Simplify Path](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Simplify%20Path.java) +530|[Design Underground System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Underground%20System.java) +531|[Sequential Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sequential%20Digits.java) +532|[Longest Substring with At Most Two Distinct Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Substring%20with%20At%20Most%20Two%20Distinct%20Characters.java) +533|[Smallest String With Swaps](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20String%20With%20Swaps.java) +534|[Jump Game III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Jump%20Game%20III.java) +535|[Adding Spaces to a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Adding%20Spaces%20to%20a%20String.java) +536|[Shortest Path with Alternating Colors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Path%20with%20Alternating%20Colors.java) +537|[Maximum Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Subarray.java) +538|[Removing Stars From a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Removing%20Stars%20From%20a%20String.java) +539|[Find K Pairs with Smallest Sums](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20K%20Pairs%20with%20Smallest%20Sums.java) +540|[Check if There is a Valid Path in a Grid](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20if%20There%20is%20a%20Valid%20Path%20in%20a%20Grid.java) +541|[Tweet Counts Per Frequency](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Tweet%20Counts%20Per%20Frequency.java) +542|[Ugly Number II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Ugly%20Number%20II.java) +543|[Find First and Last Position of Element in Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20First%20and%20Last%20Position%20of%20Element%20in%20Sorted%20Array.java) +544|[Longest Subarray of 1's After Deleting One Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Subarray%20of%201's%20After%20Deleting%20One%20Element.java) +545|[Clone Binary Tree With Random Pointer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Clone%20Binary%20Tree%20With%20Random%20Pointer.java) +546|[Longest Continuous Subarray With Absolute Diff Less Than or Equal to Limit](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Continuous%20Subarray%20With%20Absolute%20Diff%20Less%20Than%20or%20Equal%20to%20Limit.java) +547|[Count Number of Bad Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Number%20of%20Bad%20Pairs.java) +548|[Super Ugly Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Super%20Ugly%20Number.java) +549|[Add Two Numbers II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20Two%20Numbers%20II.java) +550|[Implement Rand10() Using Rand7()](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Implement%20Rand10()%20Using%20Rand7().java) +551|[Minimum Deletions to Make Character Frequencies Unique](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Deletions%20to%20Make%20Character%20Frequencies%20Unique.java) +552|[Maximum Area of a Piece of Cake After Horizontal and Vertical Cuts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Area%20of%20a%20Piece%20of%20Cake%20After%20Horizontal%20and%20Vertical%20Cuts.java) +553|[Array Nesting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Array%20Nesting.java) +554|[Valid Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Square.java) +555|[Find Closest Node to Given Two Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Closest%20Node%20to%20Given%20Two%20Nodes.java) +556|[Course Schedule](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Course%20Schedule.java) +557|[The k Strongest Values in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20k%20Strongest%20Values%20in%20an%20Array.java) +558|[Longest Arithmetic Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Arithmetic%20Subsequence.java) +559|[Optimal Partition of String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Optimal%20Partition%20of%20String.java) +560|[Maximum Bags With Full Capacity of Rocks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Bags%20With%20Full%20Capacity%20of%20Rocks.java) +561|[Path Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20Sum%20II.java) +562|[Unique Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Paths.java) +563|[Replace Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Replace%20Words.java) +564|[Rank Teams by Votes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rank%20Teams%20by%20Votes.java) +565|[Determine if a Cell Is Reachable at a Given Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Determine%20if%20a%20Cell%20Is%20Reachable%20at%20a%20Given%20Time.java) +566|[Jump Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Jump%20Game.java) +567|[Can Convert String in K Moves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Can%20Convert%20String%20in%20K%20Moves.java) +568|[Least Number of Unique Integers after K Removals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Least%20Number%20of%20Unique%20Integers%20after%20K%20Removals.java) +569|[Sum of Absolute Differences in a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Absolute%20Differences%20in%20a%20Sorted%20Array.java) +570|[Determine the Minimum Sum of a k-avoiding Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Determine%20the%20Minimum%20Sum%20of%20a%20k-avoiding%20Array.java) +571|[Linked List Random Node](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20Random%20Node.java) +572|[Valid Tic-Tac-Toe State](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Tic-Tac-Toe%20State.java) +573|[Increasing Triplet Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Increasing%20Triplet%20Subsequence.java) +574|[Partition Equal Subset Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partition%20Equal%20Subset%20Sum.java) +575|[Range Addition](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Addition.java) +576|[Next Greater Numerically Balanced Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Greater%20Numerically%20Balanced%20Number.java) +577|[Interleaving String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Interleaving%20String.java) +578|[String Compression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/String%20Compression.java) +579|[Insert Into a Cyclic Sorted List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20Into%20a%20Cyclic%20Sorted%20List.java) +580|[Count Submatrices With All Ones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Submatrices%20With%20All%20Ones.java) +581|[Shuffle an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shuffle%20an%20Array.java) +582|[Battleships in a board](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Battleships%20in%20a%20board.java) +583|[Shortest Path in Binary Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Path%20in%20Binary%20Matrix.java) +584|[Brace Expansion](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Brace%20Expansion.java) +585|[Complex Number Multiplication](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Complex%20Number%20Multiplication.java) +586|[Queries on a Permutation With Key](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Queries%20on%20a%20Permutation%20With%20Key.java) +587|[Find Duplicate Subtrees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Duplicate%20Subtrees.java) +588|[Maximum Ice Cream Bars](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Ice%20Cream%20Bars.java) +589|[Recover Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Recover%20Binary%20Search%20Tree.java) +590|[My Calendar I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/My%20Calendar%20I.java) +591|[Reorder Routes to Make All Paths Lead to the City Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reorder%20Routes%20to%20Make%20All%20Paths%20Lead%20to%20the%20City%20Zero.java) +592|[Maximize the Confusion of an Exam](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximize%20the%20Confusion%20of%20an%20Exam.java) +593|[Evaluate Reverse Polish Notation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Evaluate%20Reverse%20Polish%20Notation.java) +594|[Maximum Width Ramp](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Width%20Ramp.java) +595|[Number of Sub-arrays of Size K and Average Greater than or Equal to Threshold](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Sub-arrays%20of%20Size%20K%20and%20Average%20Greater%20than%20or%20Equal%20to%20Threshold.java) +596|[Range Sum of Sorted Subarray Sums](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Sum%20of%20Sorted%20Subarray%20Sums.java) +597|[Find The Original Array of Prefix Xor](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20The%20Original%20Array%20of%20Prefix%20Xor.java) +598|[Bomb Enemy](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Bomb%20Enemy.java) +599|[Find Center of Star Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Center%20of%20Star%20Graph.java) +600|[Add Bold Tag in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20Bold%20Tag%20in%20String.java) +601|[Reverse Linked List II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Linked%20List%20II.java) +602|[Permutation in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Permutation%20in%20String.java) +603|[Sum of Numbers With Units Digit K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Numbers%20With%20Units%20Digit%20K.java) +604|[Two Sum II - Input Array Is Sorted](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Two%20Sum%20II%20-%20Input%20Array%20Is%20Sorted.java) +605|[Maximum Number of Events That Can Be Attended](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Events%20That%20Can%20Be%20Attended.java) +606|[Shortest Word Distance III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Word%20Distance%20III.java) +607|[Sender With Largest Word Count](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sender%20With%20Largest%20Word%20Count.java) +608|[Short Encoding of Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Short%20Encoding%20of%20Words.java) +609|[Serialize and Deserialize BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Serialize%20and%20Deserialize%20BST.java) +610|[Remove All Ones With Row and Column Flips II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20All%20Ones%20With%20Row%20and%20Column%20Flips%20II.java) +611|[Minimum Domino Rotations For Equal Row](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Domino%20Rotations%20For%20Equal%20Row.java) +612|[132 Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/132%20Pattern.java) +613|[Remove All Adjacent Duplicates in String II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20All%20Adjacent%20Duplicates%20in%20String%20II.java) +614|[Insertion Sort List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insertion%20Sort%20List.java) +615|[Length of the Longest Alphabetical Continuous Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Length%20of%20the%20Longest%20Alphabetical%20Continuous%20Substring.java) +616|[Find the Duplicate Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Duplicate%20Number.java) +617|[Replace Elements in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Replace%20Elements%20in%20an%20Array.java) +618|[Design Twitter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Twitter.java) +619|[Last Moment Before All Ants Fall Out of a Plank](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Last%20Moment%20Before%20All%20Ants%20Fall%20Out%20of%20a%20Plank.java) +620|[Sentence Similarity II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sentence%20Similarity%20II.java) +621|[Count Number of Distinct Integers After Reverse Operations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Number%20of%20Distinct%20Integers%20After%20Reverse%20Operations.java) +622|[Find the Index of the First Occurrence in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Index%20of%20the%20First%20Occurrence%20in%20a%20String.java) +623|[Last Stone Weight II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Last%20Stone%20Weight%20II.java) +624|[Rectangle Area](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rectangle%20Area.java) +625|[My Calendar II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/My%20Calendar%20II.java) +626|[Find All Possible Recipes from Given Supplies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20All%20Possible%20Recipes%20from%20Given%20Supplies.java) +627|[Maximum Value at a Given Index in a Bounded Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Value%20at%20a%20Given%20Index%20in%20a%20Bounded%20Array.java) +628|[Number of Distinct Substrings in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Distinct%20Substrings%20in%20a%20String.java) +629|[Search Suggestions System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20Suggestions%20System.java) +630|[Subrectangle Queries](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subrectangle%20Queries.java) +631|[Sort the Matrix Diagonally](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20the%20Matrix%20Diagonally.java) +632|[Convert Sorted List to Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Convert%20Sorted%20List%20to%20Binary%20Search%20Tree.java) +633|[Count Nodes Equal to Average of Subtree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Nodes%20Equal%20to%20Average%20of%20Subtree.java) +634|[Bulb Switcher](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Bulb%20Switcher.java) +635|[Verify Preorder Serialization of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Verify%20Preorder%20Serialization%20of%20a%20Binary%20Tree.java) +636|[Minimum Speed to Arrive on Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Speed%20to%20Arrive%20on%20Time.java) +637|[Inorder Successor in BST II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Inorder%20Successor%20in%20BST%20II.java) +638|[Detonate the Maximum Bombs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Detonate%20the%20Maximum%20Bombs.java) +639|[Add Minimum Number of Rungs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20Minimum%20Number%20of%20Rungs.java) +640|[Lexicographically Smallest String After Substring Operation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lexicographically%20Smallest%20String%20After%20Substring%20Operation.java) +641|[Find the City With the Smallest Number of Neighbors at a Threshold Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20City%20With%20the%20Smallest%20Number%20of%20Neighbors%20at%20a%20Threshold%20Distance.java) +642|[Node With Highest Edge Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Node%20With%20Highest%20Edge%20Score.java) +643|[Output Contest Matches](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Output%20Contest%20Matches.java) +644|[Design an Expression Tree With Evaluate Function](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20an%20Expression%20Tree%20With%20Evaluate%20Function.java) +645|[H-Index](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/H-Index.java) +646|[Best Time to Buy and Sell Stock with Cooldown](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Best%20Time%20to%20Buy%20and%20Sell%20Stock%20with%20Cooldown.java) +647|[Rabbits in Forest](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rabbits%20in%20Forest.java) +648|[Count Univalue Subtrees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Univalue%20Subtrees.java) +649|[Find Elements in a Contaminated Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Elements%20in%20a%20Contaminated%20Binary%20Tree.java) +650|[Next Greater Node In Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Greater%20Node%20In%20Linked%20List.java) +651|[Maximum Nesting Depth of Two Valid Parentheses Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Nesting%20Depth%20of%20Two%20Valid%20Parentheses%20Strings.java) +652|[Find and Replace Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20and%20Replace%20Pattern.java) +653|[Design File System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20File%20System.java) +654|[Determine if Two Strings Are Close](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Determine%20if%20Two%20Strings%20Are%20Close.java) +655|[Maximum Absolute Sum of Any Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Absolute%20Sum%20of%20Any%20Subarray.java) +656|[Number of Pairs of Interchangeable Rectangles](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Pairs%20of%20Interchangeable%20Rectangles.java) +657|[Kth Largest Element in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kth%20Largest%20Element%20in%20an%20Array.java) +658|[The Number of Full Rounds You Have Played](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20Number%20of%20Full%20Rounds%20You%20Have%20Played.java) +659|[Snapshot Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Snapshot%20Array.java) +660|[Top K Frequent Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Top%20K%20Frequent%20Elements.java) +661|[Smallest Subtree with all the Deepest Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20Subtree%20with%20all%20the%20Deepest%20Nodes.java) +662|[Maximal Network Rank](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximal%20Network%20Rank.java) +663|[Rearrange Array Elements by Sign](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rearrange%20Array%20Elements%20by%20Sign.java) +664|[Kth Smallest Element in a Sorted Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kth%20Smallest%20Element%20in%20a%20Sorted%20Matrix.java) +665|[Two City Scheduling](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Two%20City%20Scheduling.java) +666|[Minimum Score Triangulation of Polygon](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Score%20Triangulation%20of%20Polygon.java) +667|[Binary Tree Coloring Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Coloring%20Game.java) +668|[Maximum Difference Between Node and Ancestor](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Difference%20Between%20Node%20and%20Ancestor.java) +669|[Sum of Beauty of All Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Beauty%20of%20All%20Substrings.java) +670|[Push Dominoes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Push%20Dominoes.java) +671|[Combination Sum III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Combination%20Sum%20III.java) +672|[Find K Closest Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20K%20Closest%20Elements.java) +673|[01 Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/01%20Matrix.java) +674|[Clone Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Clone%20Graph.java) +675|[Longest Palindromic Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Palindromic%20Substring.java) +676|[Robot Bounded In Circle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Robot%20Bounded%20In%20Circle.java) +677|[Minimum Deletions to Make Array Beautiful](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Deletions%20to%20Make%20Array%20Beautiful.java) +678|[Koko Eating Bananas](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Koko%20Eating%20Bananas.java) +679|[Statistics from a Large Sample](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Statistics%20from%20a%20Large%20Sample.java) +680|[Insert Delete GetRandom O(1)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20Delete%20GetRandom%20O(1).java) +681|[Longest Substring with At Most K Distinct Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Substring%20with%20At%20Most%20K%20Distinct%20Characters.java) +682|[Minimum Swaps to Group All 1's Together](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Swaps%20to%20Group%20All%201's%20Together.java) +683|[Path Sum III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20Sum%20III.java) +684|[Snakes and Ladders](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Snakes%20and%20Ladders.java) +685|[Longest Palindromic Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Palindromic%20Subsequence.java) +686|[Longest String Chain](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20String%20Chain.java) +687|[Buildings With an Ocean View](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Buildings%20With%20an%20Ocean%20View.java) +688|[Sort Transformed Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Transformed%20Array.java) +689|[Search in a Sorted Array of Unknown Size](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20in%20a%20Sorted%20Array%20of%20Unknown%20Size.java) +690|[Minimize Product Sum of Two Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimize%20Product%20Sum%20of%20Two%20Arrays.java) +691|[Count Complete Tree Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Complete%20Tree%20Nodes.java) +692|[Minesweeper](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minesweeper.java) +693|[Best Time to Buy and Sell Stock with Transaction Fee](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Best%20Time%20to%20Buy%20and%20Sell%20Stock%20with%20Transaction%20Fee.java) +694|[Online Election](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Online%20Election.java) +695|[Minimum Cost For Tickets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Cost%20For%20Tickets.java) +696|[Find K-Length Substrings With No Repeated Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20K-Length%20Substrings%20With%20No%20Repeated%20Characters.java) +697|[Pow(x, n)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pow(x,%20n).java) +698|[Construct String With Repeat Limit](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20String%20With%20Repeat%20Limit.java) +699|[Word Break](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Word%20Break.java) +700|[Reverse Odd Levels of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Odd%20Levels%20of%20Binary%20Tree.java) +701|[Design SQL](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20SQL.java) +702|[Find the Kth Largest Integer in the Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Kth%20Largest%20Integer%20in%20the%20Array.java) +703|[Flatten Binary Tree to Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%20Binary%20Tree%20to%20Linked%20List.java) +704|[Sort Colors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Colors.java) +705|[Best Time to Buy and Sell Stock II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Best%20Time%20to%20Buy%20and%20Sell%20Stock%20II.java) +706|[Longest Absolute File Path](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Absolute%20File%20Path.java) +707|[Count Unreachable Pairs of Nodes in an Undirected Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Unreachable%20Pairs%20of%20Nodes%20in%20an%20Undirected%20Graph.java) +708|[Prison Cells After N Days](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Prison%20Cells%20After%20N%20Days.java) +709|[Insert into a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20into%20a%20Binary%20Search%20Tree.java) +710|[Binary Search Tree Iterator II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Search%20Tree%20Iterator%20II.java) +711|[Course Schedule II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Course%20Schedule%20II.java) +712|[Remove Duplicates From Sorted Array II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Duplicates%20From%20Sorted%20Array%20II.java) +713|[Shortest Bridge](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Bridge.java) +714|[Binary Search Tree Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Search%20Tree%20Iterator.java) +715|[Find Duplicate File in System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Duplicate%20File%20in%20System.java) +716|[Insufficient Nodes in Root to Leaf Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insufficient%20Nodes%20in%20Root%20to%20Leaf%20Paths.java) +717|[Divide Array in Sets of K Consecutive Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Divide%20Array%20in%20Sets%20of%20K%20Consecutive%20Numbers.java) +718|[Check Completeness of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20Completeness%20of%20a%20Binary%20Tree.java) +719|[Two Sum BSTs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Two%20Sum%20BSTs.java) +720|[Count Sorted Vowel Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Sorted%20Vowel%20Strings.java) +721|[Check If a String Contains All Binary Codes of Size K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20If%20a%20String%20Contains%20All%20Binary%20Codes%20of%20Size%20K.java) +722|[Contains Duplicate III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Contains%20Duplicate%20III.java) +723|[Stock Price Fluctuation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Stock%20Price%20Fluctuation.java) +724|[Spiral Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Spiral%20Matrix.java) +725|[Next Closest Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Closest%20Time.java) +726|[Find the Maximum Divisibility Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Maximum%20Divisibility%20Score.java) +727|[Group Shifted Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Group%20Shifted%20Strings.java) +728|[Array Circular Loop](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Array%20Circular%20Loop.java) +729|[ZigZag Conversion](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/ZigZag%20Conversion.java) +730|[Find the Score of All Prefixes of an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Score%20of%20All%20Prefixes%20of%20an%20Array.java) +731|[Number of Matching Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Matching%20Subsequence.java) +732|[All Paths From Source to Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Paths%20From%20Source%20to%20Target.java) +733|[Spiral Matrix II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Spiral%20Matrix%20II.java) +734|[Design Authentication Manager](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Authentication%20Manager.java) +735|[Minimum Operations to Make a Special Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Operations%20to%20Make%20a%20Special%20Number.java) +736|[People Whose List of Favorite Companies Is Not a Subset of Another List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/People%20Whose%20List%20of%20Favorite%20Companies%20Is%20Not%20a%20Subset%20of%20Another%20List.java) +737|[Number of Enclaves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Enclaves.java) +738|[Sort the Students by Their Kth Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20the%20Students%20by%20Their%20Kth%20Score.java) +739|[Number of Zero-Filled Subarrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Zero-Filled%20Subarrays.java) +740|[Bag of Tokens](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Bag%20of%20Tokens.java) +741|[Binary Tree Longest Consecutive Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Longest%20Consecutive%20Sequence.java) +742|[All Paths from Source Lead to Destination](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Paths%20from%20Source%20Lead%20to%20Destination.java) +743|[Trim a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Trim%20a%20Binary%20Search%20Tree.java) +744|[Lexicographical Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lexicographical%20Numbers.java) +745|[Minimum Time to Make Rope Colorful](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Time%20to%20Make%20Rope%20Colorful.java) +746|[Rotate Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20Array.java) +747|[Unique Word Abbrevation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Word%20Abbrevation.java) +748|[Binary Tree Right Side View](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Right%20Side%20View.java) +749|[Solving Questions With Brainpower](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Solving%20Questions%20With%20Brainpower.java) +750|[All Nodes Distance K in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Nodes%20Distance%20K%20in%20Binary%20Tree.java) +751|[Queue Reconstruction By Height](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Queue%20Reconstruction%20By%20Height.java) +752|[Step-By-Step Directions From a Binary Tree Node to Another](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Step-By-Step%20Directions%20From%20a%20Binary%20Tree%20Node%20to%20Another.java) +753|[Medium](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Medium.md) +754|[Meeting Rooms II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Meeting%20Rooms%20II.java) +755|[Maximum Binary Tree II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Binary%20Tree%20II.java) +756|[Maximum Subsequence Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Subsequence%20Score.java) +757|[Smallest String With A Given Numeric Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20String%20With%20A%20Given%20Numeric%20Value.java) +758|[Print Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Print%20Binary%20Tree.java) +759|[Find Missing Observations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Missing%20Observations.java) +760|[Restore IP Address](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Restore%20IP%20Address.java) +761|[Water & Jug Problem](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Water%20&%20Jug%20Problem.java) +762|[Maximum Width of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Width%20of%20Binary%20Tree.java) +763|[Target Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Target%20Sum.java) +764|[Find the Longest Semi-Repetitive Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Longest%20Semi-Repetitive%20Substring.java) +765|[Synonymous Sentences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Synonymous%20Sentences.java) +766|[Top K Frequent Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Top%20K%20Frequent%20Words.java) +767|[Convert an Array Into a 2D Array With Conditions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Convert%20an%20Array%20Into%20a%202D%20Array%20With%20Conditions.java) +768|[Shortest Unsorted Continuous Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Unsorted%20Continuous%20Subarray.java) +769|[Satisfiability of Equality Equations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Satisfiability%20of%20Equality%20Equations.java) +770|[All Ancestors of a Node in a Directed Acyclic Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Ancestors%20of%20a%20Node%20in%20a%20Directed%20Acyclic%20Graph.java) +771|[Maximize Distance to Closest Person](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximize%20Distance%20to%20Closest%20Person.java) +772|[Design Tic-Tac-Toe](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Tic-Tac-Toe.java) +773|[H-Index II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/H-Index%20II.java) +774|[3Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/3Sum.java) +775|[Maximum Consecutive Floors Without Special Floors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Consecutive%20Floors%20Without%20Special%20Floors.java) +776|[Reorganize String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reorganize%20String.java) +777|[Reverse Substrings Between Each Pair of Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Substrings%20Between%20Each%20Pair%20of%20Parentheses.java) +778|[Maximum XOR of Two Numbers in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20XOR%20of%20Two%20Numbers%20in%20an%20Array.java) +779|[Count Good Nodes in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Good%20Nodes%20in%20Binary%20Tree.java) +780|[Find the Minimum and Maximum Number of Nodes Between Critical Points](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Minimum%20and%20Maximum%20Number%20of%20Nodes%20Between%20Critical%20Points.java) +781|[Missing Element in Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Missing%20Element%20in%20Sorted%20Array.java) +782|[Even Odd Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Even%20Odd%20Tree.java) +783|[Rearrange Array to Maximize Prefix Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rearrange%20Array%20to%20Maximize%20Prefix%20Score.java) +784|[Search for a range](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20for%20a%20range.java) +785|[Count Collisions on a Road](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Collisions%20on%20a%20Road.java) +786|[Numbers With Same Consecutive Differences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Numbers%20With%20Same%20Consecutive%20Differences.java) +787|[Remove Duplicates From an Unsorted Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Duplicates%20From%20an%20Unsorted%20Linked%20List.java) +788|[Populating Next Right Pointers in Each Node II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Populating%20Next%20Right%20Pointers%20in%20Each%20Node%20II.java) +789|[Construct Binary Search Tree from Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20Binary%20Search%20Tree%20from%20Preorder%20Traversal.java) +790|[Shortest Completing Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Completing%20Word.java) +791|[Search a 2D Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20a%202D%20Matrix.java) +792|[Add One Row to Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20One%20Row%20to%20Tree.java) diff --git a/README.md b/README.md index 79190be6..4eec5fb7 100644 --- a/README.md +++ b/README.md @@ -7,7 +7,7 @@ Problem Category | Count --- | --- -[Easy](https://github.com/varunu28/LeetCode-Java-Solutions/blob/master/Easy/README.md) | 572 -[Medium](https://github.com/varunu28/LeetCode-Java-Solutions/blob/master/Medium/README.md) | 754 -[Hard](https://github.com/varunu28/LeetCode-Java-Solutions/blob/master/Hard/README.md) | 111 +[Easy](https://github.com/varunu28/LeetCode-Java-Solutions/blob/master/Easy/README.md) | 607 +[Medium](https://github.com/varunu28/LeetCode-Java-Solutions/blob/master/Medium/README.md) | 793 +[Hard](https://github.com/varunu28/LeetCode-Java-Solutions/blob/master/Hard/README.md) | 125 [Concurrency](https://github.com/varunu28/LeetCode-Java-Solutions/blob/master/Concurrency/README.md) | 9 From d02639a3606198ac5a1aba7715c1f392c905e102 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Fri, 6 Oct 2023 05:55:04 -0700 Subject: [PATCH 360/712] Create Integer Break.java --- Medium/Integer Break.java | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) create mode 100644 Medium/Integer Break.java diff --git a/Medium/Integer Break.java b/Medium/Integer Break.java new file mode 100644 index 00000000..10071c6f --- /dev/null +++ b/Medium/Integer Break.java @@ -0,0 +1,19 @@ +class Solution { + public int integerBreak(int n) { + if (n < 4) { + return n - 1; + } + int[] dp = new int[n + 1]; + for (int i = 1; i <= 3; i++) { + dp[i] = i; + } + for (int i = 4; i <= n; i++) { + int result = i; + for (int j = 2; j < i; j++) { + result = Math.max(result, j * dp[i - j]); + } + dp[i] = result; + } + return dp[n]; + } +} From 187962d20ec479ea0422d4d92bdfda7b4fefb06e Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sat, 7 Oct 2023 14:01:46 -0700 Subject: [PATCH 361/712] Create Build Array Where You Can Find The Maximum Exactly K Comparisons.java --- ...ind The Maximum Exactly K Comparisons.java | 28 +++++++++++++++++++ 1 file changed, 28 insertions(+) create mode 100644 Hard/Build Array Where You Can Find The Maximum Exactly K Comparisons.java diff --git a/Hard/Build Array Where You Can Find The Maximum Exactly K Comparisons.java b/Hard/Build Array Where You Can Find The Maximum Exactly K Comparisons.java new file mode 100644 index 00000000..c7ede11f --- /dev/null +++ b/Hard/Build Array Where You Can Find The Maximum Exactly K Comparisons.java @@ -0,0 +1,28 @@ +class Solution { + + private static final int MOD = (int) 1000_000_007; + + public int numOfArrays(int n, int m, int k) { + int[][][] dp = new int[n + 1][m + 1][k + 1]; + for (int i = 0; i < dp[0].length; i++) { + dp[n][i][0] = 1; + } + for (int i = n - 1; i >= 0; i--) { + for (int j = m; j >= 0; j--) { + for (int l = 0; l <= k; l++) { + int result = 0; + for (int num = 1; num <= j; num++) { + result = (result + dp[i + 1][j][l]) % MOD; + } + if (l > 0) { + for (int num = j + 1; num <= m; num++) { + result = (result + dp[i + 1][num][l - 1]) % MOD; + } + } + dp[i][j][l] = result; + } + } + } + return dp[0][0][k]; + } +} From 0c6fe309938e938744c046165ca0346040ab8588 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 8 Oct 2023 06:54:39 -0700 Subject: [PATCH 362/712] Create Divisible and Non-divisible Sums Difference.java --- Easy/Divisible and Non-divisible Sums Difference.java | 8 ++++++++ 1 file changed, 8 insertions(+) create mode 100644 Easy/Divisible and Non-divisible Sums Difference.java diff --git a/Easy/Divisible and Non-divisible Sums Difference.java b/Easy/Divisible and Non-divisible Sums Difference.java new file mode 100644 index 00000000..a9c53cc8 --- /dev/null +++ b/Easy/Divisible and Non-divisible Sums Difference.java @@ -0,0 +1,8 @@ +class Solution { + public int differenceOfSums(int n, int m) { + int num1 = n * (n + 1) / 2; + int num2 = n / m; + num2 = m * num2 * (num2 + 1) / 2; + return num1 - 2 * num2; + } +} From 13e8601c910dc623108554635fbde041297dba80 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 8 Oct 2023 10:05:54 -0700 Subject: [PATCH 363/712] Create Max Dot Product of Two Subsequences.java --- Hard/Max Dot Product of Two Subsequences.java | 30 +++++++++++++++++++ 1 file changed, 30 insertions(+) create mode 100644 Hard/Max Dot Product of Two Subsequences.java diff --git a/Hard/Max Dot Product of Two Subsequences.java b/Hard/Max Dot Product of Two Subsequences.java new file mode 100644 index 00000000..c2eca127 --- /dev/null +++ b/Hard/Max Dot Product of Two Subsequences.java @@ -0,0 +1,30 @@ +class Solution { + public int maxDotProduct(int[] nums1, int[] nums2) { + int maxOne = Integer.MIN_VALUE; + int maxTwo = Integer.MIN_VALUE; + int minOne = Integer.MAX_VALUE; + int minTwo = Integer.MAX_VALUE; + for (int num : nums1) { + maxOne = Math.max(maxOne, num); + minOne = Math.min(minOne, num); + } + for (int num : nums2) { + maxTwo = Math.max(maxTwo, num); + minTwo = Math.min(minTwo, num); + } + if (maxOne < 0 && minTwo > 0) { + return maxOne * minTwo; + } + if (minOne > 0 && maxTwo < 0) { + return minOne * maxTwo; + } + int[][] dp = new int[nums1.length + 1][nums2.length + 1]; + for (int i = nums1.length - 1; i >= 0; i--) { + for (int j = nums2.length - 1; j >= 0; j--) { + int curr = nums1[i] * nums2[j] + dp[i + 1][j + 1]; + dp[i][j] = Math.max(curr, Math.max(dp[i + 1][j], dp[i][j + 1])); + } + } + return dp[0][0]; + } +} From de95ca123d477a4bdde503892888949c562a2872 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 8 Oct 2023 16:29:49 -0700 Subject: [PATCH 364/712] Create Minimum Processing Time.java --- Medium/Minimum Processing Time.java | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) create mode 100644 Medium/Minimum Processing Time.java diff --git a/Medium/Minimum Processing Time.java b/Medium/Minimum Processing Time.java new file mode 100644 index 00000000..ec9b75e6 --- /dev/null +++ b/Medium/Minimum Processing Time.java @@ -0,0 +1,18 @@ +class Solution { + public int minProcessingTime(List processorTime, List tasks) { + PriorityQueue taskQueue = new PriorityQueue<>(); + PriorityQueue processorQueue = new PriorityQueue<>((a, b) -> b - a); + taskQueue.addAll(tasks); + processorQueue.addAll(processorTime); + int totalTime = Integer.MIN_VALUE; + while (!processorQueue.isEmpty()) { + int startTime = processorQueue.remove(); + int currTime = Integer.MIN_VALUE; + for (int i = 0; i < 4; i++) { + currTime = Math.max(currTime, startTime + taskQueue.remove()); + } + totalTime = Math.max(totalTime, currTime); + } + return totalTime; + } +} From dd344622453fdf611a2f635489f35193fd5e6676 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 8 Oct 2023 17:05:58 -0700 Subject: [PATCH 365/712] Update Find First and Last Position of Element in Sorted Array.java --- ...t Position of Element in Sorted Array.java | 54 +++++++++++-------- 1 file changed, 31 insertions(+), 23 deletions(-) diff --git a/Medium/Find First and Last Position of Element in Sorted Array.java b/Medium/Find First and Last Position of Element in Sorted Array.java index a61bd0dc..64e4ecec 100644 --- a/Medium/Find First and Last Position of Element in Sorted Array.java +++ b/Medium/Find First and Last Position of Element in Sorted Array.java @@ -1,27 +1,35 @@ class Solution { - public int[] searchRange(int[] nums, int target) { - return new int[]{binarySearchHelper(nums, target, -1), binarySearchHelper(nums, target, 1)}; - } - - private int binarySearchHelper(int[] nums, int target, int direction) { - int idx = -1; - int start = 0; - int end = nums.length - 1; - while (start <= end) { - int mid = (start + end) / 2; - if (nums[mid] == target) { - idx = idx == -1 ? mid : (direction == -1 ? Math.min(mid, idx) : Math.max(mid, idx)); - if (direction == -1) { - end = mid - 1; - } else { - start = mid + 1; + + private static enum Position { + FIRST, LAST; + } + + public int[] searchRange(int[] nums, int target) { + return new int[]{ + search(nums, target, Position.FIRST), + search(nums, target, Position.LAST) + }; + } + + private static int search(int[] nums, int target, Position position) { + int left = 0; + int right = nums.length - 1; + int idx = -1; + while (left <= right) { + int mid = (left + right) / 2; + if (nums[mid] == target) { + idx = mid; + if (position == Position.FIRST) { + right = mid - 1; + } else { + left = mid + 1; + } + } else if (nums[mid] > target) { + right = mid - 1; + } else { + left = mid + 1; + } } - } else if (nums[mid] > target) { - end = mid - 1; - } else { - start = mid + 1; - } + return idx; } - return idx; - } } From 8fd3a652faf2825a7ce4bdcf0529ef19d8d80fa6 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Mon, 9 Oct 2023 06:51:27 -0700 Subject: [PATCH 366/712] Create Minimum Number of Operations to Make Array Empty.java --- ...Number of Operations to Make Array Empty.java | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) create mode 100644 Medium/Minimum Number of Operations to Make Array Empty.java diff --git a/Medium/Minimum Number of Operations to Make Array Empty.java b/Medium/Minimum Number of Operations to Make Array Empty.java new file mode 100644 index 00000000..e132e463 --- /dev/null +++ b/Medium/Minimum Number of Operations to Make Array Empty.java @@ -0,0 +1,16 @@ +class Solution { + public int minOperations(int[] nums) { + Map map = Arrays.stream(nums) + .boxed() + .collect( + Collectors.groupingBy(Function.identity(), HashMap::new, Collectors.counting())); + int operations = 0; + for (Long value : map.values()) { + if (value == 1) { + return -1; + } + operations += (int) (value / 3 + (value % 3 != 0 ? 1 : 0)); + } + return operations; + } +} From fd343f2277621b311c98f1193206acda1261cd6d Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Mon, 9 Oct 2023 06:51:51 -0700 Subject: [PATCH 367/712] Update README.md --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 4eec5fb7..c4fd5e63 100644 --- a/README.md +++ b/README.md @@ -2,7 +2,7 @@ ## Solutions to Leetcode problems in Java -## [Current Leetcode profile: Solved 1400+ Problems](https://leetcode.com/varunsjsu/) +## [Current Leetcode profile: Solved 1500+ Problems](https://leetcode.com/varunsjsu/) ## [Previous Leetcode profile: Solved 759 Problems](https://leetcode.com/varunu28/) Problem Category | Count From 5695ae7d61661d01898fa301f0243411f8d113bb Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Tue, 10 Oct 2023 07:49:28 -0700 Subject: [PATCH 368/712] Create Minimum Number of Operations to Make Array Continuous.java --- ...f Operations to Make Array Continuous.java | 25 +++++++++++++++++++ 1 file changed, 25 insertions(+) create mode 100644 Hard/Minimum Number of Operations to Make Array Continuous.java diff --git a/Hard/Minimum Number of Operations to Make Array Continuous.java b/Hard/Minimum Number of Operations to Make Array Continuous.java new file mode 100644 index 00000000..f6f07059 --- /dev/null +++ b/Hard/Minimum Number of Operations to Make Array Continuous.java @@ -0,0 +1,25 @@ +class Solution { + public int minOperations(int[] nums) { + Set set = new HashSet<>(); + for (int num : nums) { + set.add(num); + } + int[] arr = new int[set.size()]; + int idx = 0; + for (Integer num : set) { + arr[idx++] = num; + } + Arrays.sort(arr); + int n = nums.length; + int result = n; + int j = 0; + for (int i = 0; i < arr.length; i++) { + while (j < arr.length && arr[j] < arr[i] + n) { + j++; + } + int count = j - i; + result = Math.min(result, n - count); + } + return result; + } +} From cecb540cf1e04614a3365e0a8c9471ffd85df1ff Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Wed, 11 Oct 2023 06:18:35 -0700 Subject: [PATCH 369/712] Create Number of Flowers in Full Bloom.java --- Hard/Number of Flowers in Full Bloom.java | 25 +++++++++++++++++++++++ 1 file changed, 25 insertions(+) create mode 100644 Hard/Number of Flowers in Full Bloom.java diff --git a/Hard/Number of Flowers in Full Bloom.java b/Hard/Number of Flowers in Full Bloom.java new file mode 100644 index 00000000..37bb43e7 --- /dev/null +++ b/Hard/Number of Flowers in Full Bloom.java @@ -0,0 +1,25 @@ +class Solution { + public int[] fullBloomFlowers(int[][] flowers, int[] people) { + int[] peopleCopy = Arrays.copyOf(people, people.length); + Arrays.sort(peopleCopy); + Arrays.sort(flowers, (a, b) -> Arrays.compare(a, b)); + Map map = new HashMap<>(); + PriorityQueue pq = new PriorityQueue<>(); + int idx = 0; + for (int person : peopleCopy) { + while (idx < flowers.length && flowers[idx][0] <= person) { + pq.add(flowers[idx][1]); + idx++; + } + while (!pq.isEmpty() && pq.peek() < person) { + pq.poll(); + } + map.put(person, pq.size()); + } + int[] result = new int[people.length]; + for (int i = 0; i < people.length; i++) { + result[i] = map.get(people[i]); + } + return result; + } +} From eb05caf390f4313f3f3e494f0cea48bf8cd3e78b Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Thu, 12 Oct 2023 06:34:01 -0700 Subject: [PATCH 370/712] Create Find in Mountain Array.java --- Hard/Find in Mountain Array.java | 49 ++++++++++++++++++++++++++++++++ 1 file changed, 49 insertions(+) create mode 100644 Hard/Find in Mountain Array.java diff --git a/Hard/Find in Mountain Array.java b/Hard/Find in Mountain Array.java new file mode 100644 index 00000000..d030c247 --- /dev/null +++ b/Hard/Find in Mountain Array.java @@ -0,0 +1,49 @@ +/** + * // This is MountainArray's API interface. + * // You should not implement it, or speculate about its implementation + * interface MountainArray { + * public int get(int index) {} + * public int length() {} + * } + */ + +class Solution { + public int findInMountainArray(int target, MountainArray mountainArr) { + int n = mountainArr.length(); + int start = 1; + int end = n - 2; + while (start != end) { + int mid = (start + end) / 2; + if (mountainArr.get(mid) < mountainArr.get(mid + 1)) { + start = mid + 1; + } else { + end = mid; + } + } + int peakIndex = start; + start = 0; + end = peakIndex; + while (start != end) { + int mid = (start + end) / 2; + if (mountainArr.get(mid) < target) { + start = mid + 1; + } else { + end = mid; + } + } + if (mountainArr.get(start) == target) { + return start; + } + start = peakIndex + 1; + end = n - 1; + while (start != end) { + int mid = (start + end) / 2; + if (mountainArr.get(mid) > target) { + start = mid + 1; + } else { + end = mid; + } + } + return mountainArr.get(start) == target ? start : -1; + } +} From 8392986ad79601c12810e4cb49a07b8a86f83c4f Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Fri, 13 Oct 2023 07:00:25 -0700 Subject: [PATCH 371/712] Update Min Cost Climbing Stairs.java --- Easy/Min Cost Climbing Stairs.java | 19 +++++++++---------- 1 file changed, 9 insertions(+), 10 deletions(-) diff --git a/Easy/Min Cost Climbing Stairs.java b/Easy/Min Cost Climbing Stairs.java index 7a718918..1db8f19d 100644 --- a/Easy/Min Cost Climbing Stairs.java +++ b/Easy/Min Cost Climbing Stairs.java @@ -1,13 +1,12 @@ class Solution { - public int minCostClimbingStairs(int[] cost) { - int n = cost.length; - int first = cost[0]; - int second = cost[1]; - for (int i = 2; i < n; i++) { - int curr = cost[i] + Math.min(first, second); - first = second; - second = curr; + public int minCostClimbingStairs(int[] cost) { + int stepOneCost = cost[0]; + int stepTwoCost = cost[1]; + for (int i = 2; i < cost.length; i++) { + int currCost = cost[i] + Math.min(stepOneCost, stepTwoCost); + stepOneCost = stepTwoCost; + stepTwoCost = currCost; + } + return Math.min(stepOneCost, stepTwoCost); } - return Math.min(first, second); - } } From b4dc59fb6726a710d856b5acee27501d94085eea Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sat, 14 Oct 2023 07:32:23 -0700 Subject: [PATCH 372/712] Create Painting the Walls.java --- Hard/Painting the Walls.java | 26 ++++++++++++++++++++++++++ 1 file changed, 26 insertions(+) create mode 100644 Hard/Painting the Walls.java diff --git a/Hard/Painting the Walls.java b/Hard/Painting the Walls.java new file mode 100644 index 00000000..ceeb36f2 --- /dev/null +++ b/Hard/Painting the Walls.java @@ -0,0 +1,26 @@ +class Solution { + + private static final int INVALID_VALUE = 1000_000_000; + + public int paintWalls(int[] cost, int[] time) { + int n = cost.length; + Integer[][] dp = new Integer[n][n + 1]; + return compute(0, n, cost, time, dp, n); + } + + private int compute(int idx, int remain, int[] cost, int[] time, Integer[][] dp, int n) { + if (remain <= 0) { + return 0; + } + if (idx == n) { + return INVALID_VALUE; + } + if (dp[idx][remain] != null) { + return dp[idx][remain]; + } + int paint = cost[idx] + compute(idx + 1, remain - 1 - time[idx], cost, time, dp, n); + int noPaint = compute(idx + 1, remain, cost, time, dp, n); + dp[idx][remain] = Math.min(paint, noPaint); + return dp[idx][remain]; + } +} From 9ae580aae699a11fbe660b84e740d5002c745db5 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 15 Oct 2023 10:58:54 -0700 Subject: [PATCH 373/712] Create Last Visited Integers.java --- Easy/Last Visited Integers.java | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) create mode 100644 Easy/Last Visited Integers.java diff --git a/Easy/Last Visited Integers.java b/Easy/Last Visited Integers.java new file mode 100644 index 00000000..e6a59e34 --- /dev/null +++ b/Easy/Last Visited Integers.java @@ -0,0 +1,17 @@ +class Solution { + public List lastVisitedIntegers(List words) { + List result = new ArrayList<>(); + List numbers = new ArrayList<>(); + int cursor = -1; + for (String word : words) { + if (word.equals("prev")) { + result.add(cursor == -1 ? -1 : numbers.get(cursor)); + cursor = cursor == -1 ? -1 : (cursor - 1); + } else { + numbers.add(Integer.parseInt(word)); + cursor = numbers.size() - 1; + } + } + return result; + } +} From 532b766ba63b509941a680f704d5407faaf7a73d Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 15 Oct 2023 16:20:01 -0700 Subject: [PATCH 374/712] Create Number of Ways to Stay in the Same Place After Some Steps.java --- ...ay in the Same Place After Some Steps.java | 23 +++++++++++++++++++ 1 file changed, 23 insertions(+) create mode 100644 Hard/Number of Ways to Stay in the Same Place After Some Steps.java diff --git a/Hard/Number of Ways to Stay in the Same Place After Some Steps.java b/Hard/Number of Ways to Stay in the Same Place After Some Steps.java new file mode 100644 index 00000000..a9ce7edf --- /dev/null +++ b/Hard/Number of Ways to Stay in the Same Place After Some Steps.java @@ -0,0 +1,23 @@ +class Solution { + + private static final int MOD = 1000_000_007; + + public int numWays(int steps, int arrLen) { + arrLen = Math.min(arrLen, steps); + int[][] dp = new int[arrLen][steps + 1]; + dp[0][0] = 1; + for (int i = 1; i <= steps; i++) { + for (int j = arrLen - 1; j >= 0; j--) { + int result = dp[j][i - 1]; + if (j > 0) { + result = (result + dp[j - 1][i - 1]) % MOD; + } + if (j < arrLen - 1) { + result = (result + dp[j + 1][i - 1]) % MOD; + } + dp[j][i] = result; + } + } + return dp[0][steps]; + } +} From 183167b1f1258205128096789ab760266a9358be Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Wed, 18 Oct 2023 08:13:45 -0700 Subject: [PATCH 375/712] Create Parallel Courses III.java --- Hard/Parallel Courses III.java | 35 ++++++++++++++++++++++++++++++++++ 1 file changed, 35 insertions(+) create mode 100644 Hard/Parallel Courses III.java diff --git a/Hard/Parallel Courses III.java b/Hard/Parallel Courses III.java new file mode 100644 index 00000000..f557c244 --- /dev/null +++ b/Hard/Parallel Courses III.java @@ -0,0 +1,35 @@ +class Solution { + public int minimumTime(int n, int[][] relations, int[] time) { + Map> map = new HashMap<>(); + int[] indegree = new int[n + 1]; + for (int[] relation : relations) { + int course = relation[0]; + int prereq = relation[1]; + indegree[course]++; + map.computeIfAbsent(prereq, k -> new ArrayList<>()).add(course); + } + Queue queue = new LinkedList<>(); + int[] maxTime = new int[n + 1]; + for (int i = 1; i <= n; i++) { + if (indegree[i] == 0) { + queue.add(i); + maxTime[i] = time[i - 1]; + } + } + while (!queue.isEmpty()) { + int removed = queue.remove(); + for (Integer dependent : map.getOrDefault(removed, new ArrayList<>())) { + maxTime[dependent] = Math.max(maxTime[dependent], maxTime[removed] + time[dependent - 1]); + indegree[dependent]--; + if (indegree[dependent] == 0) { + queue.add(dependent); + } + } + } + int result = 0; + for (int i = 1; i <= n; i++) { + result = Math.max(result, maxTime[i]); + } + return result; + } +} From e7be3158b5dde10e199433f5730620621c5a7c56 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Thu, 19 Oct 2023 06:53:50 -0700 Subject: [PATCH 376/712] Update Backspace String Compare.java --- Easy/Backspace String Compare.java | 38 +++++++++++++++--------------- 1 file changed, 19 insertions(+), 19 deletions(-) diff --git a/Easy/Backspace String Compare.java b/Easy/Backspace String Compare.java index 170f9f69..91ef6593 100644 --- a/Easy/Backspace String Compare.java +++ b/Easy/Backspace String Compare.java @@ -1,23 +1,23 @@ class Solution { - public boolean backspaceCompare(String s, String t) { - return formBackSpaceString(s).equals(formBackSpaceString(t)); - } - - private String formBackSpaceString(String s) { - Stack stack = new Stack<>(); - for (char c : s.toCharArray()) { - if (c == '#') { - if (!stack.isEmpty()) { - stack.pop(); - } - } else { - stack.push(c); - } + public boolean backspaceCompare(String s, String t) { + return buildBackspaceString(s).equals(buildBackspaceString(t)); } - StringBuilder sb = new StringBuilder(); - while (!stack.isEmpty()) { - sb.append(stack.pop()); + + private static String buildBackspaceString(String s) { + Stack stack = new Stack<>(); + for (char c : s.toCharArray()) { + if (c == '#') { + if (!stack.isEmpty()) { + stack.pop(); + } + } else { + stack.push(c); + } + } + StringBuilder sb = new StringBuilder(); + for (char c : stack) { + sb.append(c); + } + return sb.toString(); } - return sb.toString(); - } } From b99d324a2f3e2153abc818c647537697ab29c603 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Fri, 20 Oct 2023 07:50:48 -0700 Subject: [PATCH 377/712] Update Flatten Nested List Iterator.java --- Medium/Flatten Nested List Iterator.java | 45 +++++++++++++----------- 1 file changed, 24 insertions(+), 21 deletions(-) diff --git a/Medium/Flatten Nested List Iterator.java b/Medium/Flatten Nested List Iterator.java index 5081ee2e..087bc1ef 100644 --- a/Medium/Flatten Nested List Iterator.java +++ b/Medium/Flatten Nested List Iterator.java @@ -17,31 +17,34 @@ */ public class NestedIterator implements Iterator { - private Stack stack; - - public NestedIterator(List nestedList) { - this.stack = new Stack<>(); - for (int i = nestedList.size() - 1; i >= 0; i--) { - this.stack.push(nestedList.get(i)); + private Stack stack; + + public NestedIterator(List nestedList) { + this.stack = new Stack<>(); + for (int i = nestedList.size() - 1; i >= 0; i--) { + this.stack.push(nestedList.get(i)); + } } - } - @Override - public Integer next() { - int value = this.stack.pop().getInteger(); - return value; - } + @Override + public Integer next() { + return stack.pop().getInteger(); + } - @Override - public boolean hasNext() { - while (!this.stack.isEmpty() && !this.stack.peek().isInteger()) { - List ni = this.stack.pop().getList(); - for (int i = ni.size() - 1; i >= 0; i--) { - this.stack.push(ni.get(i)); - } + @Override + public boolean hasNext() { + while (!stack.isEmpty() && !stack.peek().isInteger()) { + NestedInteger popped = stack.pop(); + if (popped == null) { + continue; + } + List list = popped.getList(); + for (int i = list.size() - 1; i >= 0; i--) { + stack.push(list.get(i)); + } + } + return !stack.isEmpty(); } - return !this.stack.isEmpty(); - } } /** From 42b485199d6a18e16606d0dec9c89259b87d19a9 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sat, 21 Oct 2023 07:53:53 -0700 Subject: [PATCH 378/712] Create Constrained Subsequence Sum.java --- Hard/Constrained Subsequence Sum.java | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) create mode 100644 Hard/Constrained Subsequence Sum.java diff --git a/Hard/Constrained Subsequence Sum.java b/Hard/Constrained Subsequence Sum.java new file mode 100644 index 00000000..9dabd1d4 --- /dev/null +++ b/Hard/Constrained Subsequence Sum.java @@ -0,0 +1,16 @@ +class Solution { + public int constrainedSubsetSum(int[] nums, int k) { + PriorityQueue pq = new PriorityQueue<>((a, b) -> b[0] - a[0]); + pq.add(new int[]{nums[0], 0}); + int result = nums[0]; + for (int i = 1; i < nums.length; i++) { + while (i - pq.peek()[1] > k) { + pq.remove(); + } + int curr = Math.max(0, pq.peek()[0]) + nums[i]; + result = Math.max(result, curr); + pq.add(new int[]{curr, i}); + } + return result; + } +} From de3fdc9fd167ea78df037aff9d4a914cecb3000d Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Mon, 23 Oct 2023 08:52:06 -0700 Subject: [PATCH 379/712] Update Power of Four.java --- Easy/Power of Four.java | 18 ++---------------- 1 file changed, 2 insertions(+), 16 deletions(-) diff --git a/Easy/Power of Four.java b/Easy/Power of Four.java index 18dd30c1..269c7bd7 100644 --- a/Easy/Power of Four.java +++ b/Easy/Power of Four.java @@ -1,19 +1,5 @@ class Solution { - public boolean isPowerOfFour(int n) { - long left = 0; - long right = n / 2 + 1; - while (left <= right) { - long mid = (left + right) / 2; - long pow = (long) (Math.pow(4, mid)); - if (pow == ((long) n)) { - return true; - } - if (pow > ((long) n)) { - right = mid - 1; - } else { - left = mid + 1; - } + public boolean isPowerOfFour(int n) { + return n > 0 && Math.log(n) / Math.log(2) % 2 == 0; } - return false; - } } From e68120ea4f3f69f1fbfe6217e5cec14922e639b3 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Mon, 23 Oct 2023 09:13:01 -0700 Subject: [PATCH 380/712] Create Minimum Sum of Mountain Triplets I.java --- Easy/Minimum Sum of Mountain Triplets I.java | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) create mode 100644 Easy/Minimum Sum of Mountain Triplets I.java diff --git a/Easy/Minimum Sum of Mountain Triplets I.java b/Easy/Minimum Sum of Mountain Triplets I.java new file mode 100644 index 00000000..cabcd870 --- /dev/null +++ b/Easy/Minimum Sum of Mountain Triplets I.java @@ -0,0 +1,19 @@ +class Solution { + public int minimumSum(int[] nums) { + int n = nums.length; + int[] smallestRight = new int[n]; + smallestRight[n - 1] = nums[n - 1]; + for (int i = n - 2; i >= 0; i--) { + smallestRight[i] = Math.min(smallestRight[i + 1], nums[i]); + } + int smallestLeft = nums[0]; + int result = Integer.MAX_VALUE; + for (int i = 1; i < n; i++) { + if (smallestLeft < nums[i] && smallestRight[i] < nums[i]) { + result = Math.min(result, nums[i] + smallestRight[i] + smallestLeft); + } + smallestLeft = Math.min(smallestLeft, nums[i]); + } + return result == Integer.MAX_VALUE ? -1 : result; + } +} From c1bb0d540a29b1be62ed24675ae1bf853beace6c Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Mon, 23 Oct 2023 17:45:13 -0700 Subject: [PATCH 381/712] Update Find Largest Value in Each Tree Row.java --- .../Find Largest Value in Each Tree Row.java | 50 +++++++++++-------- 1 file changed, 28 insertions(+), 22 deletions(-) diff --git a/Medium/Find Largest Value in Each Tree Row.java b/Medium/Find Largest Value in Each Tree Row.java index 49aeca0e..2f0c7883 100644 --- a/Medium/Find Largest Value in Each Tree Row.java +++ b/Medium/Find Largest Value in Each Tree Row.java @@ -4,32 +4,38 @@ * int val; * TreeNode left; * TreeNode right; - * TreeNode(int x) { val = x; } + * TreeNode() {} + * TreeNode(int val) { this.val = val; } + * TreeNode(int val, TreeNode left, TreeNode right) { + * this.val = val; + * this.left = left; + * this.right = right; + * } * } */ class Solution { - public List largestValues(TreeNode root) { - List list = new ArrayList<>(); - if (root == null) { - return list; - } - Queue queue = new LinkedList<>(); - queue.add(root); - while (!queue.isEmpty()) { - int maxVal = Integer.MIN_VALUE; - int size = queue.size(); - while (size-- > 0) { - TreeNode removed = queue.remove(); - maxVal = Math.max(maxVal, removed.val); - if (removed.left != null) { - queue.add(removed.left); + public List largestValues(TreeNode root) { + if (root == null) { + return new ArrayList<>(); } - if (removed.right != null) { - queue.add(removed.right); + List result = new ArrayList<>(); + Queue queue = new LinkedList<>(); + queue.add(root); + while (!queue.isEmpty()) { + int size = queue.size(); + int maxValue = queue.peek().val; + while (size-- > 0) { + TreeNode removed = queue.remove(); + maxValue = Math.max(maxValue, removed.val); + if (removed.left != null) { + queue.add(removed.left); + } + if (removed.right != null) { + queue.add(removed.right); + } + } + result.add(maxValue); } - } - list.add(maxVal); + return result; } - return list; - } } From 12b5aa03214cbbb2cec061e6e36445d353f8aada Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Tue, 24 Oct 2023 16:44:22 -0700 Subject: [PATCH 382/712] Create Correct a Binary Tree.java --- Easy/Correct a Binary Tree.java | 48 +++++++++++++++++++++++++++++++++ 1 file changed, 48 insertions(+) create mode 100644 Easy/Correct a Binary Tree.java diff --git a/Easy/Correct a Binary Tree.java b/Easy/Correct a Binary Tree.java new file mode 100644 index 00000000..3ec5f055 --- /dev/null +++ b/Easy/Correct a Binary Tree.java @@ -0,0 +1,48 @@ +/** + * Definition for a binary tree node. + * public class TreeNode { + * int val; + * TreeNode left; + * TreeNode right; + * TreeNode() {} + * TreeNode(int val) { this.val = val; } + * TreeNode(int val, TreeNode left, TreeNode right) { + * this.val = val; + * this.left = left; + * this.right = right; + * } + * } + */ +class Solution { + public TreeNode correctBinaryTree(TreeNode root) { + Queue queue = new LinkedList<>(); + queue.add(new Pair(root, null)); + while (!queue.isEmpty()) { + int size = queue.size(); + Set visited = new HashSet<>(); + for (int i = 0; i < size; i++) { + Pair pair = queue.remove(); + TreeNode node = pair.node(); + TreeNode parent = pair.parent(); + if (visited.contains(node.right)) { + if (parent.left == node) { + parent.left = null; + } else { + parent.right = null; + } + return root; + } + visited.add(node); + if (node.right != null) { + queue.add(new Pair(node.right, node)); + } + if (node.left != null) { + queue.add(new Pair(node.left, node)); + } + } + } + return root; + } + + private static record Pair(TreeNode node, TreeNode parent) {} +} From 608e9a283dba926ee824e6dc0f80e0366b0f9bad Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Wed, 25 Oct 2023 08:21:11 -0700 Subject: [PATCH 383/712] Create K-th Symbol in Grammar.java --- Medium/K-th Symbol in Grammar.java | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) create mode 100644 Medium/K-th Symbol in Grammar.java diff --git a/Medium/K-th Symbol in Grammar.java b/Medium/K-th Symbol in Grammar.java new file mode 100644 index 00000000..da370f11 --- /dev/null +++ b/Medium/K-th Symbol in Grammar.java @@ -0,0 +1,18 @@ +class Solution { + public int kthGrammar(int n, int k) { + return depthFirstSearch(n, k, 0); + } + + private int depthFirstSearch(int n, int k, int root) { + if (n == 1) { + return root; + } + int nodeCount = (int) Math.pow(2, n - 1); + if (k > (nodeCount / 2)) { + int nextRoot = (root == 0) ? 1 : 0; + return depthFirstSearch(n - 1, k - (nodeCount / 2), nextRoot); + } + int nextRoot = (root == 0) ? 0 : 1; + return depthFirstSearch(n - 1, k, nextRoot); + } +} From 0434cd9d2c7670b94a53a1c1cba42c1c3c613b59 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Mon, 30 Oct 2023 03:53:00 +0530 Subject: [PATCH 384/712] Create Subarrays Distinct Element Sum of Squares I.java --- ...barrays Distinct Element Sum of Squares I.java | 15 +++++++++++++++ 1 file changed, 15 insertions(+) create mode 100644 Easy/Subarrays Distinct Element Sum of Squares I.java diff --git a/Easy/Subarrays Distinct Element Sum of Squares I.java b/Easy/Subarrays Distinct Element Sum of Squares I.java new file mode 100644 index 00000000..fa7cee6a --- /dev/null +++ b/Easy/Subarrays Distinct Element Sum of Squares I.java @@ -0,0 +1,15 @@ +class Solution { + public int sumCounts(List nums) { + int sum = 0; + int n = nums.size(); + for (int i = 0; i < n; i++) { + Set set = new HashSet<>(); + for (int j = i; j < n; j++) { + set.add(nums.get(j)); + int size = set.size(); + sum += size * size; + } + } + return sum; + } +} From a7379c9bab2dab58a848e6b2239544c46227d418 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Tue, 31 Oct 2023 01:56:26 +0530 Subject: [PATCH 385/712] Create Find the K-or of an Array.java --- Easy/Find the K-or of an Array.java | 31 +++++++++++++++++++++++++++++ 1 file changed, 31 insertions(+) create mode 100644 Easy/Find the K-or of an Array.java diff --git a/Easy/Find the K-or of an Array.java b/Easy/Find the K-or of an Array.java new file mode 100644 index 00000000..48343d5e --- /dev/null +++ b/Easy/Find the K-or of an Array.java @@ -0,0 +1,31 @@ +class Solution { + public int findKOr(int[] nums, int k) { + Map map = new HashMap<>(); + for (int num : nums) { + List setBits = getSetBits(num); + for (Integer setBit : setBits) { + map.put(setBit, map.getOrDefault(setBit, 0) + 1); + } + } + int result = 0; + for (int i = 0, p = 1; i < 32; i++, p *= 2) { + if (map.getOrDefault(i, 0) >= k) { + result += p; + } + } + return result; + } + + private static List getSetBits(int num) { + List bits = new ArrayList<>(); + int bit = 0; + while (num > 0) { + if (num % 2 == 1) { + bits.add(bit); + } + num = num / 2; + bit++; + } + return bits; + } +} From 7b6bf88a2086e01e8c047c87b8e92f43a3bd8c80 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Tue, 31 Oct 2023 13:20:10 +0530 Subject: [PATCH 386/712] Update Find The Original Array of Prefix Xor.java --- .../Find The Original Array of Prefix Xor.java | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/Medium/Find The Original Array of Prefix Xor.java b/Medium/Find The Original Array of Prefix Xor.java index 97baa6e7..46732ae1 100644 --- a/Medium/Find The Original Array of Prefix Xor.java +++ b/Medium/Find The Original Array of Prefix Xor.java @@ -1,11 +1,11 @@ class Solution { - public int[] findArray(int[] pref) { - int n = pref.length; - int[] result = new int[n]; - result[0] = pref[0]; - for (int i = 1; i < n; i++) { - result[i] = pref[i] ^ pref[i - 1]; + public int[] findArray(int[] pref) { + int n = pref.length; + int[] result = new int[n]; + result[0] = pref[0]; + for (int i = 1; i < n; i++) { + result[i] = pref[i - 1] ^ pref[i]; + } + return result; } - return result; - } } From 76b05375450bf34319125ecf1761fa36641125b2 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Wed, 1 Nov 2023 08:16:42 +0530 Subject: [PATCH 387/712] Update Find Mode in Binary Search Tree.java --- Easy/Find Mode in Binary Search Tree.java | 83 +++++++++++++---------- 1 file changed, 46 insertions(+), 37 deletions(-) diff --git a/Easy/Find Mode in Binary Search Tree.java b/Easy/Find Mode in Binary Search Tree.java index a803103b..2b1f2fa0 100644 --- a/Easy/Find Mode in Binary Search Tree.java +++ b/Easy/Find Mode in Binary Search Tree.java @@ -14,44 +14,53 @@ * } */ class Solution { - Integer prev = null; - int count = 1; - int max = 0; - public int[] findMode(TreeNode root) { - if (root == null) { - return new int[0]; + public int[] findMode(TreeNode root) { + ResultWrapper resultWrapper = new ResultWrapper(); + inorder(root, resultWrapper); + return resultWrapper.result.stream().mapToInt(Integer::intValue).toArray(); } - List list = new ArrayList<>(); - traverse(root, list); - int[] ans = new int[list.size()]; - for (int i = 0; i < list.size(); i++) { - ans[i] = list.get(i); + + private void inorder(TreeNode node, ResultWrapper resultWrapper) { + if (node == null) { + return; + } + inorder(node.left, resultWrapper); + int val = node.val; + resultWrapper.recordStreak(val); + resultWrapper.updateResult(val); + inorder(node.right, resultWrapper); } - return ans; - } - - private void traverse(TreeNode root, List list) { - if (root == null) { - return; + + private static class ResultWrapper { + private int maxStreak; + private int currStreak; + private Integer curr; + private List result; + + public ResultWrapper() { + this.maxStreak = 0; + this.currStreak = 0; + this.curr = 0; + this.result = new ArrayList<>(); + } + + public void recordStreak(int num) { + if (num == curr) { + currStreak++; + } else { + currStreak = 1; + curr = num; + } + } + + public void updateResult(int num) { + if (currStreak > maxStreak) { + result.clear(); + maxStreak = currStreak; + } + if (currStreak == maxStreak) { + result.add(num); + } + } } - traverse(root.left, list); - if (prev != null) { - if (root.val == prev) { - count++; - } - else { - count = 1; - } - } - if (count > max) { - max = count; - list.clear(); - list.add(root.val); - } - else if (count == max) { - list.add(root.val); - } - prev = root.val; - traverse(root.right, list); - } } From 220c742237aca2c665bae4307008afca94bb6a71 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Wed, 1 Nov 2023 12:40:35 +0530 Subject: [PATCH 388/712] Update Campus Bikes.java --- Medium/Campus Bikes.java | 73 ++++++++++++++++++---------------------- 1 file changed, 33 insertions(+), 40 deletions(-) diff --git a/Medium/Campus Bikes.java b/Medium/Campus Bikes.java index 9d385afb..129f4fbc 100644 --- a/Medium/Campus Bikes.java +++ b/Medium/Campus Bikes.java @@ -1,46 +1,39 @@ class Solution { - public int[] assignBikes(int[][] workers, int[][] bikes) { - PriorityQueue pq = new PriorityQueue<>(new Comparator(){ - public int compare(Node n1, Node n2) { - int c = n1.dist - n2.dist; - if (c != 0) { - return c; + public int[] assignBikes(int[][] workers, int[][] bikes) { + int workerCount = workers.length; + int bikeCount = bikes.length; + PriorityQueue priorityQueue = new PriorityQueue<>(); + for (int i = 0; i < workerCount; i++) { + for (int j = 0; j < bikeCount; j++) { + priorityQueue.add(new WorkerBikePair(manhattanDistance(workers[i], bikes[j]), i, j)); + } } - c = n1.workIdx - n2.workIdx; - return c != 0 ? c : n1.cycleIdx - n2.cycleIdx; - } - }); - for (int i = 0; i < workers.length; i++) { - for (int j = 0; j < bikes.length; j++) { - pq.add(new Node(getDist(workers[i], bikes[j]), i, j)); - } + Set bikeDone = new HashSet<>(); + int[] result = new int[workerCount]; + Arrays.fill(result, Integer.MIN_VALUE); + while (!priorityQueue.isEmpty()) { + WorkerBikePair removed = priorityQueue.remove(); + if (result[removed.workerIdx] == Integer.MIN_VALUE && !bikeDone.contains(removed.bikeIdx)) { + result[removed.workerIdx] = removed.bikeIdx; + bikeDone.add(removed.bikeIdx); + } + } + return result; } - int[] ans = new int[workers.length]; - boolean[] bikesTaken = new boolean[bikes.length]; - Arrays.fill(ans, Integer.MIN_VALUE); - while (!pq.isEmpty()) { - Node node = pq.remove(); - if (ans[node.workIdx] == Integer.MIN_VALUE && !bikesTaken[node.cycleIdx]) { - ans[node.workIdx] = node.cycleIdx; - bikesTaken[node.cycleIdx] = true; - } + + private record WorkerBikePair(int manhattanDistance, int workerIdx, int bikeIdx) implements Comparable { + @Override + public int compareTo(WorkerBikePair o) { + int c = manhattanDistance - o.manhattanDistance; + if (c != 0) { + return c; + } + c = workerIdx - o.workerIdx; + return c != 0 ? c : bikeIdx - o.bikeIdx; + } } - return ans; - } - - private int getDist(int[] p1, int[] p2) { - return Math.abs(p1[0] - p2[0]) + Math.abs(p1[1] - p2[1]); - } -} -class Node { - int dist; - int workIdx; - int cycleIdx; - - public Node(int dist, int workIdx, int cycleIdx) { - this.dist = dist; - this.workIdx = workIdx; - this.cycleIdx = cycleIdx; - } + private static int manhattanDistance(int[] p1, int[] p2) { + return Math.abs(p1[0] - p2[0]) + Math.abs(p1[1] - p2[1]); + } } From 02b74a08449884c1e9aa374fea854256b34bbe8a Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Thu, 2 Nov 2023 11:48:18 +0530 Subject: [PATCH 389/712] Update Count Nodes Equal to Average of Subtree.java --- ...unt Nodes Equal to Average of Subtree.java | 35 +++++++++---------- 1 file changed, 17 insertions(+), 18 deletions(-) diff --git a/Medium/Count Nodes Equal to Average of Subtree.java b/Medium/Count Nodes Equal to Average of Subtree.java index a642fc31..5a6d2d75 100644 --- a/Medium/Count Nodes Equal to Average of Subtree.java +++ b/Medium/Count Nodes Equal to Average of Subtree.java @@ -14,24 +14,23 @@ * } */ class Solution { - public int averageOfSubtree(TreeNode root) { - int[] result = {0}; - helper(root, result); - return result[0]; - } - - private int[] helper(TreeNode root, int[] result) { - if (root == null) { - return new int[]{0, 0}; + public int averageOfSubtree(TreeNode root) { + int[] result = {0}; + recurse(root, result); + return result[0]; } - int[] left = helper(root.left, result); - int[] right = helper(root.right, result); - int sum = left[0] + right[0] + root.val; - int numOfNodes = left[1] + right[1] + 1; - int average = sum / numOfNodes; - if (root.val == average) { - result[0]++; + + private int[] recurse(TreeNode root, int[] result) { + if (root == null) { + return new int[]{0, 0}; + } + int[] left = recurse(root.left, result); + int[] right = recurse(root.right, result); + int sum = left[0] + right[0] + root.val; + int count = left[1] + right[1] + 1; + if (count != 0 && sum / count == root.val) { + result[0]++; + } + return new int[]{sum, count}; } - return new int[]{sum, numOfNodes}; - } } From c69da4fea5e461e849a4361d44a5cdc80e9d24e5 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Fri, 3 Nov 2023 11:02:37 +0530 Subject: [PATCH 390/712] Update and rename Build an Array With Stack Operations.java to Build an Array With Stack Operations.java --- .../Build an Array With Stack Operations.java | 20 ---------------- .../Build an Array With Stack Operations.java | 23 +++++++++++++++++++ 2 files changed, 23 insertions(+), 20 deletions(-) delete mode 100644 Easy/Build an Array With Stack Operations.java create mode 100644 Medium/Build an Array With Stack Operations.java diff --git a/Easy/Build an Array With Stack Operations.java b/Easy/Build an Array With Stack Operations.java deleted file mode 100644 index c3a57156..00000000 --- a/Easy/Build an Array With Stack Operations.java +++ /dev/null @@ -1,20 +0,0 @@ -class Solution { - public List buildArray(int[] target, int n) { - List ans = new ArrayList<>(); - final String PUSH = "Push"; - final String POP = "Pop"; - int idx = 0; - int curr = 1; - while (idx < target.length) { - ans.add(PUSH); - if (target[idx] == curr) { - idx++; - } - else { - ans.add(POP); - } - curr++; - } - return ans; - } -} diff --git a/Medium/Build an Array With Stack Operations.java b/Medium/Build an Array With Stack Operations.java new file mode 100644 index 00000000..f36177cd --- /dev/null +++ b/Medium/Build an Array With Stack Operations.java @@ -0,0 +1,23 @@ +class Solution { + + private static final String PUSH = "Push"; + private static final String POP = "Pop"; + + public List buildArray(int[] target, int n) { + int idx = 0; + List result = new ArrayList<>(); + for (int i = 1; i <= n; i++) { + if (target[idx] == i) { + idx++; + result.add(PUSH); + } else { + result.add(PUSH); + result.add(POP); + } + if (idx == target.length) { + break; + } + } + return result; + } +} From 08d5d21f043018b65b0d55daac6349464b930e2e Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 5 Nov 2023 03:19:02 +0530 Subject: [PATCH 391/712] Update Last Moment Before All Ants Fall Out of a Plank.java --- ...nt Before All Ants Fall Out of a Plank.java | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/Medium/Last Moment Before All Ants Fall Out of a Plank.java b/Medium/Last Moment Before All Ants Fall Out of a Plank.java index 45e59801..e061b5d3 100644 --- a/Medium/Last Moment Before All Ants Fall Out of a Plank.java +++ b/Medium/Last Moment Before All Ants Fall Out of a Plank.java @@ -1,12 +1,12 @@ class Solution { - public int getLastMoment(int n, int[] left, int[] right) { - int res = 0; - for (int ant : left) { - res = Math.max(res, ant); + public int getLastMoment(int n, int[] left, int[] right) { + int result = 0; + for (int num : left) { + result = Math.max(result, num); + } + for (int num : right) { + result = Math.max(result, n - num); + } + return result; } - for (int ant : right) { - res = Math.max(res, n - ant); - } - return res; - } } From bcc80bf2250a3f7fb145217ee8ed802e520e8ce2 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Wed, 8 Nov 2023 05:46:39 +0530 Subject: [PATCH 392/712] Update Seat Reservation Manager.java --- Medium/Seat Reservation Manager.java | 30 +++++++++++++--------------- 1 file changed, 14 insertions(+), 16 deletions(-) diff --git a/Medium/Seat Reservation Manager.java b/Medium/Seat Reservation Manager.java index d8825a61..8a7e8edb 100644 --- a/Medium/Seat Reservation Manager.java +++ b/Medium/Seat Reservation Manager.java @@ -1,23 +1,21 @@ class SeatManager { - PriorityQueue pq; - int count; + private PriorityQueue seats; - public SeatManager(int n) { - pq = new PriorityQueue<>(); - count = 1; - } - - public int reserve() { - if (pq.size() == 0) { - return count++; + public SeatManager(int n) { + this.seats = new PriorityQueue<>(); + for (int i = 1; i <= n; i++) { + this.seats.add(i); + } + } + + public int reserve() { + return this.seats.poll(); + } + + public void unreserve(int seatNumber) { + this.seats.add(seatNumber); } - return pq.remove(); - } - - public void unreserve(int seatNumber) { - pq.add(seatNumber); - } } /** From e0b6989d09021e36d274925ae31919ca8f70640d Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Wed, 8 Nov 2023 10:07:21 +0530 Subject: [PATCH 393/712] Update Find the Winner of an Array Game.java --- Medium/Find the Winner of an Array Game.java | 27 ++++++++++---------- 1 file changed, 13 insertions(+), 14 deletions(-) diff --git a/Medium/Find the Winner of an Array Game.java b/Medium/Find the Winner of an Array Game.java index 0c7130f4..98932a1e 100644 --- a/Medium/Find the Winner of an Array Game.java +++ b/Medium/Find the Winner of an Array Game.java @@ -1,17 +1,16 @@ class Solution { - public int getWinner(int[] arr, int k) { - int currentElement = arr[0]; - int n = arr.length; - int currentWinCount = 0; - for (int i = 1; i < n; i++) { - if (arr[i] > currentElement) { - currentElement = arr[i]; - currentWinCount = 0; - } - if (++currentWinCount == k) { - break; - } + public int getWinner(int[] arr, int k) { + int curr = arr[0]; + int streak = 0; + for (int i = 1; i < arr.length; i++) { + if (curr < arr[i]) { + curr = arr[i]; + streak = 0; + } + if (++streak == k) { + break; + } + } + return curr; } - return currentElement; - } } From 704e7c9009d0a806530dbbb6a563f3a769cf69eb Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Thu, 9 Nov 2023 06:27:23 +0530 Subject: [PATCH 394/712] Update Count Number of Homogenous Substrings.java --- ...Count Number of Homogenous Substrings.java | 30 +++++++++---------- 1 file changed, 15 insertions(+), 15 deletions(-) diff --git a/Medium/Count Number of Homogenous Substrings.java b/Medium/Count Number of Homogenous Substrings.java index 64dd8610..4a543690 100644 --- a/Medium/Count Number of Homogenous Substrings.java +++ b/Medium/Count Number of Homogenous Substrings.java @@ -1,18 +1,18 @@ class Solution { - private final int MOD = 1000000007; - public int countHomogenous(String s) { - int count = 0; - int start = 0; - int end = 0; - int n = s.length(); - while (end < n) { - if (s.charAt(start) == s.charAt(end)) { - count = (count + (end - start + 1)) % MOD; - end++; - } else { - start++; - } + + private static final int MOD = 1_000_000_007; + + public int countHomogenous(String s) { + int result = 0; + int streak = 0; + for (int i = 0; i < s.length(); i++) { + if (i == 0 || s.charAt(i) == s.charAt(i - 1)) { + streak++; + } else { + streak = 1; + } + result = (result + streak) % MOD; + } + return result; } - return count; - } } From 0878cdcb6c23c7231b892eec6c24ba8b51186ccc Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Fri, 10 Nov 2023 06:36:35 +0530 Subject: [PATCH 395/712] Update Restore the Array From Adjacent Pairs.java --- ...Restore the Array From Adjacent Pairs.java | 50 +++++++++++-------- 1 file changed, 28 insertions(+), 22 deletions(-) diff --git a/Medium/Restore the Array From Adjacent Pairs.java b/Medium/Restore the Array From Adjacent Pairs.java index bbe2461c..041f727d 100644 --- a/Medium/Restore the Array From Adjacent Pairs.java +++ b/Medium/Restore the Array From Adjacent Pairs.java @@ -1,25 +1,31 @@ class Solution { - public int[] restoreArray(int[][] adjacentPairs) { - Map> map = new HashMap<>(); - for (int[] pair : adjacentPairs) { - map.computeIfAbsent(pair[0], k -> new ArrayList<>()).add(pair[1]); - map.computeIfAbsent(pair[1], k -> new ArrayList<>()).add(pair[0]); + public int[] restoreArray(int[][] adjacentPairs) { + int n = adjacentPairs.length + 1; + Map> map = new HashMap<>(); + for (int[] pair : adjacentPairs) { + map.computeIfAbsent(pair[0], k -> new ArrayList<>()).add(pair[1]); + map.computeIfAbsent(pair[1], k -> new ArrayList<>()).add(pair[0]); + } + Queue queue = new LinkedList<>(); + int firstElement = map.entrySet() + .stream() + .filter(entry -> entry.getValue().size() == 1) + .map(Map.Entry::getKey) + .findFirst() + .orElse(-1); + queue.add(firstElement); + Set set = new HashSet<>(); + int[] result = new int[n]; + int idx = 0; + while (!queue.isEmpty()) { + int removed = queue.remove(); + if (set.contains(removed)) { + continue; + } + result[idx++] = removed; + set.add(removed); + queue.addAll(map.get(removed)); + } + return result; } - int head = map.keySet().stream().filter(k -> map.get(k).size() == 1).findFirst().orElse(-1); - Set visited = new HashSet<>(); - int[] result = new int[map.size()]; - int idx = 0; - Queue queue = new LinkedList<>(); - queue.add(head); - while (!queue.isEmpty()) { - int removed = queue.remove(); - if (visited.contains(removed)) { - continue; - } - result[idx++] = removed; - visited.add(removed); - queue.addAll(map.get(removed)); - } - return result; - } } From 4bda99c789c57ba49d280c245e92bd9e8491010e Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Fri, 10 Nov 2023 19:42:56 +0530 Subject: [PATCH 396/712] Create Find Champion I.java --- Easy/Find Champion I.java | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) create mode 100644 Easy/Find Champion I.java diff --git a/Easy/Find Champion I.java b/Easy/Find Champion I.java new file mode 100644 index 00000000..4728f452 --- /dev/null +++ b/Easy/Find Champion I.java @@ -0,0 +1,20 @@ +import java.util.Map.Entry; + +class Solution { + public int findChampion(int[][] grid) { + Map map = new HashMap<>(); + for (int i = 0; i < grid.length; i++) { + for (int j = 0; j < grid[0].length; j++) { + if (grid[i][j] == 1) { + map.put(i, map.getOrDefault(i, 0) + 1); + } + } + } + return map.entrySet() + .stream() + .filter(entry -> entry.getValue() == grid.length - 1) + .findFirst() + .map(Entry::getKey) + .orElse(-1); + } +} From f8c730eaa2d92aa3892fe312c732678043b99383 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sat, 11 Nov 2023 07:19:09 +0530 Subject: [PATCH 397/712] Create Design Graph With Shortest Path Calculator.java --- ...n Graph With Shortest Path Calculator.java | 43 +++++++++++++++++++ 1 file changed, 43 insertions(+) create mode 100644 Hard/Design Graph With Shortest Path Calculator.java diff --git a/Hard/Design Graph With Shortest Path Calculator.java b/Hard/Design Graph With Shortest Path Calculator.java new file mode 100644 index 00000000..0b7fddf1 --- /dev/null +++ b/Hard/Design Graph With Shortest Path Calculator.java @@ -0,0 +1,43 @@ +class Graph { + + private final Map> graph; + + public Graph(int n, int[][] edges) { + this.graph = new HashMap<>(); + for (int[] edge : edges) { + graph.computeIfAbsent(edge[0], k -> new ArrayList<>()).add(new Connection(edge[1], edge[2])); + } + } + + public void addEdge(int[] edge) { + graph.computeIfAbsent(edge[0], k -> new ArrayList<>()).add(new Connection(edge[1], edge[2])); + } + + public int shortestPath(int node1, int node2) { + PriorityQueue queue = new PriorityQueue<>(Comparator.comparingInt(a -> a[1])); + queue.add(new int[]{node1, 0}); + Set seen = new HashSet<>(); + while (!queue.isEmpty()) { + int[] removed = queue.remove(); + int node = removed[0]; + if (node == node2) { + return removed[1]; + } + if (graph.containsKey(node) && seen.add(node)) { + for (Connection connection : graph.getOrDefault(removed[0], new ArrayList<>())) { + queue.add(new int[]{connection.node, removed[1] + connection.cost}); + } + } + } + return -1; + } + + private record Connection(int node, int cost) { } +} + +/** + * Your Graph object will be instantiated and called as such: + * Graph obj = new Graph(n, edges); + * obj.addEdge(edge); + * int param_2 = obj.shortestPath(node1,node2); + */ From 61a865c37425617198cb1a4e91b0c3d7f9fa0dd9 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 12 Nov 2023 07:09:41 +0530 Subject: [PATCH 398/712] Create Bus Routes.java --- Hard/Bus Routes.java | 39 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 39 insertions(+) create mode 100644 Hard/Bus Routes.java diff --git a/Hard/Bus Routes.java b/Hard/Bus Routes.java new file mode 100644 index 00000000..54c2762a --- /dev/null +++ b/Hard/Bus Routes.java @@ -0,0 +1,39 @@ +class Solution { + public int numBusesToDestination(int[][] routes, int source, int target) { + if (source == target) { + return 0; + } + Map> stopToBusMapping = new HashMap<>(); + for (int i = 0; i < routes.length; i++) { + for (int stop : routes[i]) { + stopToBusMapping.computeIfAbsent(stop, k -> new HashSet<>()).add(i); + } + } + Queue queue = new LinkedList<>(); + Set visited = new HashSet<>(); + for (int route : stopToBusMapping.get(source)) { + queue.add(route); + visited.add(route); + } + int buses = 1; + while (!queue.isEmpty()) { + int size = queue.size(); + while (size-- > 0) { + int removed = queue.remove(); + for (int stop : routes[removed]) { + if (stop == target) { + return buses; + } + for (int nextBus : stopToBusMapping.getOrDefault(stop, new HashSet<>())) { + if (!visited.contains(nextBus)) { + visited.add(nextBus); + queue.add(nextBus); + } + } + } + } + buses++; + } + return -1; + } +} From e330385ad3ecff0a0af968108b5e2f2c914188b6 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 19 Nov 2023 09:37:03 +0530 Subject: [PATCH 399/712] Create High-Access Employees.java --- Medium/High-Access Employees.java | 43 +++++++++++++++++++++++++++++++ 1 file changed, 43 insertions(+) create mode 100644 Medium/High-Access Employees.java diff --git a/Medium/High-Access Employees.java b/Medium/High-Access Employees.java new file mode 100644 index 00000000..8c881fc8 --- /dev/null +++ b/Medium/High-Access Employees.java @@ -0,0 +1,43 @@ +class Solution { + public List findHighAccessEmployees(List> accessTimeEntries) { + Map> map = new HashMap<>(); + for (List entry : accessTimeEntries) { + String employee = entry.get(0); + String time = entry.get(1); + map.computeIfAbsent(employee, k -> new ArrayList<>()).add(TimeRecord.buildTimeRecord(time)); + } + List result = new ArrayList<>(); + for (String key : map.keySet()) { + List entries = map.get(key); + if (entries.size() < 3) { + continue; + } + Collections.sort(entries); + for (int i = 0; i < entries.size() - 2; i++) { + if (TimeRecord.areWithinSameHour(entries.get(i), entries.get(i + 2))) { + result.add(key); + break; + } + } + } + return result; + } + + private record TimeRecord(int totalMinutes) implements Comparable { + + public static TimeRecord buildTimeRecord(String entry) { + int hour = Integer.parseInt(entry.substring(0, 2)); + int min = Integer.parseInt(entry.substring(2)); + return new TimeRecord(hour * 60 + min); + } + + public static boolean areWithinSameHour(TimeRecord startTime, TimeRecord endTime) { + return endTime.totalMinutes - startTime.totalMinutes < 60; + } + + @Override + public int compareTo(TimeRecord o) { + return this.totalMinutes - o.totalMinutes; + } + } +} From 9e4fc67c04fb3ccdced7fd70f8666fdce7b2ef2b Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Mon, 20 Nov 2023 15:19:10 +0530 Subject: [PATCH 400/712] Update Minimum Amount of Time to Collect Garbage.java --- ...mum Amount of Time to Collect Garbage.java | 49 ++++++++----------- 1 file changed, 20 insertions(+), 29 deletions(-) diff --git a/Medium/Minimum Amount of Time to Collect Garbage.java b/Medium/Minimum Amount of Time to Collect Garbage.java index b0ac91ff..ace2125d 100644 --- a/Medium/Minimum Amount of Time to Collect Garbage.java +++ b/Medium/Minimum Amount of Time to Collect Garbage.java @@ -1,34 +1,25 @@ class Solution { - public int garbageCollection(String[] garbage, int[] travel) { - int[] lastIdx = {-1, -1, -1}; - Map garbageCount = new HashMap<>(); - for (int i = 0; i < garbage.length; i++) { - garbageCount.put(i, new int[3]); - for (char c : garbage[i].toCharArray()) { - if (c == 'M') { - lastIdx[0] = i; - garbageCount.get(i)[0]++; + public int garbageCollection(String[] garbage, int[] travel) { + Map lastIdx = new HashMap<>(); + for (int i = garbage.length - 1; i >= 0; i--) { + if (garbage[i].indexOf('M') != -1) { + lastIdx.putIfAbsent('M', i); + } + if (garbage[i].indexOf('G') != -1) { + lastIdx.putIfAbsent('G', i); + } + if (garbage[i].indexOf('P') != -1) { + lastIdx.putIfAbsent('P', i); + } } - if (c == 'P') { - lastIdx[1] = i; - garbageCount.get(i)[1]++; + int totalTime = 0; + for (int i = 0; i < garbage.length; i++) { + int travelTime = i == 0 ? 0 : travel[i - 1]; + totalTime += garbage[i].length(); + totalTime += lastIdx.getOrDefault('P', -1) >= i ? travelTime : 0; + totalTime += lastIdx.getOrDefault('M', -1) >= i ? travelTime : 0; + totalTime += lastIdx.getOrDefault('G', -1) >= i ? travelTime : 0; } - if (c == 'G') { - lastIdx[2] = i; - garbageCount.get(i)[2]++; - } - } - } - int time = 0; - for (int i = 0; i < 3; i++) { - for (int j = 0; j < garbage.length; j++) { - if (lastIdx[i] < j) { - break; - } - time += j == 0 ? 0 : travel[j - 1]; - time += garbageCount.get(j)[i]; - } + return totalTime; } - return time; - } } From 8914d77227edd07ce15f6ba127c62c56064b5df9 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Tue, 21 Nov 2023 16:12:26 +0530 Subject: [PATCH 401/712] Create Make Three Strings Equal.java --- Easy/Make Three Strings Equal.java | 13 +++++++++++++ 1 file changed, 13 insertions(+) create mode 100644 Easy/Make Three Strings Equal.java diff --git a/Easy/Make Three Strings Equal.java b/Easy/Make Three Strings Equal.java new file mode 100644 index 00000000..a1e7477f --- /dev/null +++ b/Easy/Make Three Strings Equal.java @@ -0,0 +1,13 @@ +class Solution { + public int findMinimumOperations(String s1, String s2, String s3) { + int idx = 0; + while (idx < s1.length() && idx < s2.length() && idx < s3.length() && + s1.charAt(idx) == s2.charAt(idx) && s1.charAt(idx) == s3.charAt(idx)) { + idx++; + } + if (idx == 0) { + return -1; + } + return s1.length() + s2.length() + s3.length() - 3 * idx; + } +} From 25c398f7c1ed198fcc31255e01f170c7122c60a8 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 26 Nov 2023 12:01:35 -0800 Subject: [PATCH 402/712] Create Find Words Containing Character.java --- Easy/Find Words Containing Character.java | 8 ++++++++ 1 file changed, 8 insertions(+) create mode 100644 Easy/Find Words Containing Character.java diff --git a/Easy/Find Words Containing Character.java b/Easy/Find Words Containing Character.java new file mode 100644 index 00000000..ba268c41 --- /dev/null +++ b/Easy/Find Words Containing Character.java @@ -0,0 +1,8 @@ +class Solution { + public List findWordsContaining(String[] words, char x) { + return IntStream.range(0, words.length) + .filter(i -> words[i].indexOf(x) != -1) + .boxed() + .collect(Collectors.toList()); + } +} From 36dc3534b788bf76b2737914790b9ee9b39d1713 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Mon, 27 Nov 2023 03:42:23 -0800 Subject: [PATCH 403/712] Create Matrix Similarity After Cyclic Shifts.java --- Easy/Matrix Similarity After Cyclic Shifts.java | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) create mode 100644 Easy/Matrix Similarity After Cyclic Shifts.java diff --git a/Easy/Matrix Similarity After Cyclic Shifts.java b/Easy/Matrix Similarity After Cyclic Shifts.java new file mode 100644 index 00000000..624bcf08 --- /dev/null +++ b/Easy/Matrix Similarity After Cyclic Shifts.java @@ -0,0 +1,17 @@ +class Solution { + public boolean areSimilar(int[][] mat, int k) { + for (int j = 0; j < mat.length; j++) { + if (j % 2 != 0) { + continue; + } + int[] row = mat[j]; + int n = row.length; + for (int i = 0; i < n; i++) { + if (row[i] != row[(i + k) % n]) { + return false; + } + } + } + return true; + } +} From ed44c4e4543e05065d3f0bde106af011d5a05ea2 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Fri, 1 Dec 2023 14:44:04 -0800 Subject: [PATCH 404/712] Update Check If Two String Arrays are Equivalent.java --- ...k If Two String Arrays are Equivalent.java | 43 +++++++++---------- 1 file changed, 20 insertions(+), 23 deletions(-) diff --git a/Easy/Check If Two String Arrays are Equivalent.java b/Easy/Check If Two String Arrays are Equivalent.java index 70a73e1a..880301c2 100644 --- a/Easy/Check If Two String Arrays are Equivalent.java +++ b/Easy/Check If Two String Arrays are Equivalent.java @@ -1,27 +1,24 @@ class Solution { - public boolean arrayStringsAreEqual(String[] word1, String[] word2) { - int wordIdxOne = 0; - int wordIdxTwo = 0; - int idxOne = 0; - int idxTwo = 0; - while (wordIdxOne < word1.length && wordIdxTwo < word2.length) { - if (idxOne == word1[wordIdxOne].length() || idxTwo == word2[wordIdxTwo].length()) { - if (idxOne == word1[wordIdxOne].length()) { - wordIdxOne++; - idxOne = 0; + public boolean arrayStringsAreEqual(String[] word1, String[] word2) { + int idxOne = 0; + int idxTwo = 0; + int wordIdxOne = 0; + int wordIdxTwo = 0; + while (idxOne < word1.length && idxTwo < word2.length) { + if (word1[idxOne].charAt(wordIdxOne) != word2[idxTwo].charAt(wordIdxTwo)) { + return false; + } + wordIdxOne++; + wordIdxTwo++; + if (wordIdxOne == word1[idxOne].length()) { + wordIdxOne = 0; + idxOne++; + } + if (wordIdxTwo == word2[idxTwo].length()) { + wordIdxTwo = 0; + idxTwo++; + } } - if (idxTwo == word2[wordIdxTwo].length()) { - wordIdxTwo++; - idxTwo = 0; - } - } else { - if (word1[wordIdxOne].charAt(idxOne) != word2[wordIdxTwo].charAt(idxTwo)) { - return false; - } - idxOne++; - idxTwo++; - } + return idxOne == word1.length && idxTwo == word2.length; } - return wordIdxOne == word1.length && wordIdxTwo == word2.length; - } } From 25e2990898b09abcbcaf3dd3ba7e2a40d9cac394 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sat, 2 Dec 2023 11:08:00 -0800 Subject: [PATCH 405/712] Update Find Words That Can Be Formed by Characters.java --- ...ords That Can Be Formed by Characters.java | 43 +++++++++---------- 1 file changed, 20 insertions(+), 23 deletions(-) diff --git a/Easy/Find Words That Can Be Formed by Characters.java b/Easy/Find Words That Can Be Formed by Characters.java index 1dce1552..23550740 100644 --- a/Easy/Find Words That Can Be Formed by Characters.java +++ b/Easy/Find Words That Can Be Formed by Characters.java @@ -1,27 +1,24 @@ class Solution { - public int countCharacters(String[] words, String chars) { - Map frequency = getFrequencyMap(chars); - return Arrays.stream(words) - .filter(word -> canBeFormed(word, frequency)) - .map(word -> word.length()) - .reduce(0, Integer::sum); - } - - private boolean canBeFormed(String word, Map frequency) { - Map wordFrequency = getFrequencyMap(word); - for (Character key : wordFrequency.keySet()) { - if (frequency.getOrDefault(key, 0) < wordFrequency.get(key)) { - return false; - } + public int countCharacters(String[] words, String chars) { + Map targetMap = buildFrequencyMap(chars); + return Arrays.stream(words) + .filter(word -> doesIntersect(buildFrequencyMap(word), targetMap)) + .mapToInt(String::length) + .sum(); } - return true; - } - - private Map getFrequencyMap(String s) { - Map frequency = new HashMap<>(); - for (char c : s.toCharArray()) { - frequency.put(c, frequency.getOrDefault(c, 0) + 1); + + private static boolean doesIntersect(Map currMap, Map targetMap) { + for (Character key : currMap.keySet()) { + if (targetMap.getOrDefault(key, 0L) < currMap.get(key)) { + return false; + } + } + return true; + } + + private static Map buildFrequencyMap(String s) { + return s.chars() + .mapToObj(c -> (char) c) + .collect(Collectors.groupingBy(Function.identity(), HashMap::new, Collectors.counting())); } - return frequency; - } } From 9c60e43d7b6899b24275415833d32bb18997e1a4 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 3 Dec 2023 08:30:56 -0800 Subject: [PATCH 406/712] Create Find the Peaks.java --- Easy/Find the Peaks.java | 11 +++++++++++ 1 file changed, 11 insertions(+) create mode 100644 Easy/Find the Peaks.java diff --git a/Easy/Find the Peaks.java b/Easy/Find the Peaks.java new file mode 100644 index 00000000..f6120cd5 --- /dev/null +++ b/Easy/Find the Peaks.java @@ -0,0 +1,11 @@ +class Solution { + public List findPeaks(int[] mountain) { + List result = new ArrayList<>(); + for (int i = 1; i < mountain.length - 1; i++) { + if (mountain[i] > mountain[i - 1] && mountain[i] > mountain[i + 1]) { + result.add(i); + } + } + return result; + } +} From f52aafa642c12afd1446f7aa5e3626af9138779c Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Thu, 7 Dec 2023 11:56:24 -0800 Subject: [PATCH 407/712] Create Count Complete Substrings.java --- Medium/Count Complete Substrings.java | 54 +++++++++++++++++++++++++++ 1 file changed, 54 insertions(+) create mode 100644 Medium/Count Complete Substrings.java diff --git a/Medium/Count Complete Substrings.java b/Medium/Count Complete Substrings.java new file mode 100644 index 00000000..995cf4b0 --- /dev/null +++ b/Medium/Count Complete Substrings.java @@ -0,0 +1,54 @@ +class Solution { + public int countCompleteSubstrings(String word, int k) { + int count = 0; + StringBuilder sb = new StringBuilder(); + int n = word.length(); + for (int i = 0; i < n; i++) { + sb.append(word.charAt(i)); + if (i < n - 1 && Math.abs(word.charAt(i) - word.charAt(i + 1)) > 2) { + count += calculateSubstrings(sb.toString(), k); + sb.setLength(0); + } + } + count += calculateSubstrings(sb.toString(), k); + return count; + } + + private int calculateSubstrings(String s, int k) { + int count = 0; + int n = s.length(); + for (int i = 1; i <= 26; i++) { + int len = k * i; + int[] freq = new int[26]; + if (len > n) { + break; + } + for (int j = 0; j < len; j++) { + freq[s.charAt(j) - 'a']++; + } + if (check(freq, i, k)) { + count++; + } + for (int j = len; j < n; j++) { + freq[s.charAt(j - len) - 'a']--; + freq[s.charAt(j) - 'a']++; + if (check(freq, i, k)) { + count++; + } + } + } + return count; + } + + private boolean check(int[] freq, int i, int k) { + for (int value : freq) { + if (value == 0) { + continue; + } + if (value != k) { + return false; + } + } + return true; + } +} From ee241fbceafe5625316b337b7b5ec6dc7e72f5bb Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Fri, 8 Dec 2023 10:18:30 -0800 Subject: [PATCH 408/712] Update Maximum Average Subtree.java --- Medium/Maximum Average Subtree.java | 44 ++++++++++++++++------------- 1 file changed, 24 insertions(+), 20 deletions(-) diff --git a/Medium/Maximum Average Subtree.java b/Medium/Maximum Average Subtree.java index 97c54cf6..873f4f01 100644 --- a/Medium/Maximum Average Subtree.java +++ b/Medium/Maximum Average Subtree.java @@ -4,28 +4,32 @@ * int val; * TreeNode left; * TreeNode right; - * TreeNode(int x) { val = x; } + * TreeNode() {} + * TreeNode(int val) { this.val = val; } + * TreeNode(int val, TreeNode left, TreeNode right) { + * this.val = val; + * this.left = left; + * this.right = right; + * } * } */ class Solution { - double maxAvg; - public double maximumAverageSubtree(TreeNode root) { - maxAvg = 0.0; - helper(root); - return maxAvg; - } - - private int[] helper(TreeNode root) { - int[] data = new int[2]; - if (root == null) { - return data; + public double maximumAverageSubtree(TreeNode root) { + double[] result = {0.0}; + traverse(root, result); + return result[0]; + } + + private double[] traverse(TreeNode root, double[] result) { + if (root == null) { + return new double[]{0.0, 0.0}; + } + double[] leftValues = traverse(root.left, result); + double[] rightValues = traverse(root.right, result); + double sum = root.val + leftValues[0] + rightValues[0]; + double count = 1 + leftValues[1] + rightValues[1]; + double avg = sum / count; + result[0] = Math.max(result[0], avg); + return new double[]{sum, count}; } - int[] dataLeft = helper(root.left); - int[] dataRight = helper(root.right); - data[0] += root.val + dataLeft[0] + dataRight[0]; - data[1] += 1 + dataLeft[1] + dataRight[1]; - double avg = ((double) data[0]) / data[1]; - maxAvg = Math.max(maxAvg, avg); - return data; - } } From 36bbae100bd2b067bb375ccd1aab62de83b2c681 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 10 Dec 2023 11:11:31 -0800 Subject: [PATCH 409/712] Create Find Common Elements Between Two Arrays.java --- ...nd Common Elements Between Two Arrays.java | 26 +++++++++++++++++++ 1 file changed, 26 insertions(+) create mode 100644 Easy/Find Common Elements Between Two Arrays.java diff --git a/Easy/Find Common Elements Between Two Arrays.java b/Easy/Find Common Elements Between Two Arrays.java new file mode 100644 index 00000000..4a6041ba --- /dev/null +++ b/Easy/Find Common Elements Between Two Arrays.java @@ -0,0 +1,26 @@ +class Solution { + public int[] findIntersectionValues(int[] nums1, int[] nums2) { + Map map1 = buildFrequencyMap(nums1); + Map map2 = buildFrequencyMap(nums2); + int[] result = new int[2]; + for (Integer key : map1.keySet()) { + if (map2.containsKey(key)) { + result[0] += map1.get(key); + } + } + for (Integer key : map2.keySet()) { + if (map1.containsKey(key)) { + result[1] += map2.get(key); + } + } + return result; + } + + private static Map buildFrequencyMap(int[] nums) { + Map map = new HashMap<>(); + for (int num : nums) { + map.put(num, map.getOrDefault(num, 0) + 1); + } + return map; + } +} From 4a2ba34f2c830c227a65736e87e6b4a5b76e58a6 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 10 Dec 2023 11:15:13 -0800 Subject: [PATCH 410/712] Create Count Tested Devices After Test Operations.java --- .../Count Tested Devices After Test Operations.java | 13 +++++++++++++ 1 file changed, 13 insertions(+) create mode 100644 Easy/Count Tested Devices After Test Operations.java diff --git a/Easy/Count Tested Devices After Test Operations.java b/Easy/Count Tested Devices After Test Operations.java new file mode 100644 index 00000000..1f6cdb0f --- /dev/null +++ b/Easy/Count Tested Devices After Test Operations.java @@ -0,0 +1,13 @@ +class Solution { + public int countTestedDevices(int[] batteryPercentages) { + int count = 0; + int diff = 0; + for (int batteryPercentage : batteryPercentages) { + if (Math.max(0, batteryPercentage - diff) > 0) { + count++; + diff++; + } + } + return count; + } +} From 9187cd95bed0cb1601d31b9a862e70b4f77ab5be Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Mon, 11 Dec 2023 12:26:58 -0800 Subject: [PATCH 411/712] Create Remove Adjacent Almost-Equal Characters.java --- .../Remove Adjacent Almost-Equal Characters.java | 14 ++++++++++++++ 1 file changed, 14 insertions(+) create mode 100644 Medium/Remove Adjacent Almost-Equal Characters.java diff --git a/Medium/Remove Adjacent Almost-Equal Characters.java b/Medium/Remove Adjacent Almost-Equal Characters.java new file mode 100644 index 00000000..46bdf2ab --- /dev/null +++ b/Medium/Remove Adjacent Almost-Equal Characters.java @@ -0,0 +1,14 @@ +class Solution { + public int removeAlmostEqualCharacters(String word) { + int count = 0; + for (int i = 0; i < word.length() - 1; i++) { + char curr = word.charAt(i); + char next = word.charAt(i + 1); + if (Math.abs(curr - next) <= 1) { + count++; + i++; + } + } + return count; + } +} From 1355423f65b4d3b6e4aa5ad40ecb660d4b0ecb93 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Wed, 13 Dec 2023 17:26:24 -0800 Subject: [PATCH 412/712] Create Difference Between Ones and Zeros in Row and Column.java --- ...ween Ones and Zeros in Row and Column.java | 23 +++++++++++++++++++ 1 file changed, 23 insertions(+) create mode 100644 Medium/Difference Between Ones and Zeros in Row and Column.java diff --git a/Medium/Difference Between Ones and Zeros in Row and Column.java b/Medium/Difference Between Ones and Zeros in Row and Column.java new file mode 100644 index 00000000..641b0b38 --- /dev/null +++ b/Medium/Difference Between Ones and Zeros in Row and Column.java @@ -0,0 +1,23 @@ +class Solution { + public int[][] onesMinusZeros(int[][] grid) { + int rows = grid.length; + int cols = grid[0].length; + int[][] rowCount = new int[rows][2]; + int[][] colCount = new int[cols][2]; + for (int i = 0; i < rows; i++) { + for (int j = 0; j < cols; j++) { + rowCount[i][0] += grid[i][j] == 1 ? 1 : 0; + rowCount[i][1] += grid[i][j] != 1 ? 1 : 0; + colCount[j][0] += grid[i][j] == 1 ? 1 : 0; + colCount[j][1] += grid[i][j] != 1 ? 1 : 0; + } + } + int[][] result = new int[rows][cols]; + for (int i = 0; i < rows; i++) { + for (int j = 0; j < cols; j++) { + result[i][j] = rowCount[i][0] + colCount[j][0] - rowCount[i][1] - colCount[j][1]; + } + } + return result; + } +} From 02ccf71e0e466866b7e4d088332de2c7f4ecab03 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Thu, 14 Dec 2023 07:39:12 -0800 Subject: [PATCH 413/712] Create Double Modular Exponentiation.java --- Medium/Double Modular Exponentiation.java | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+) create mode 100644 Medium/Double Modular Exponentiation.java diff --git a/Medium/Double Modular Exponentiation.java b/Medium/Double Modular Exponentiation.java new file mode 100644 index 00000000..6dada495 --- /dev/null +++ b/Medium/Double Modular Exponentiation.java @@ -0,0 +1,23 @@ +class Solution { + public List getGoodIndices(int[][] variables, int target) { + List result = new ArrayList<>(); + for (int i = 0; i < variables.length; i++) { + int a = variables[i][0]; + int b = variables[i][1]; + int c = variables[i][2]; + int m = variables[i][3]; + int base = 1; + for (int j = 0; j < b; j++) { + base = (base * a) % 10; + } + int value = 1; + for (int j = 0; j < c; j++) { + value = (value * base) % m; + } + if (value == target) { + result.add(i); + } + } + return result; + } +} From 847953331f0961ef8e7ba965f170bf78443f66c8 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Thu, 14 Dec 2023 17:53:24 -0800 Subject: [PATCH 414/712] Update Destination City.java --- Easy/Destination City.java | 23 +++++++++-------------- 1 file changed, 9 insertions(+), 14 deletions(-) diff --git a/Easy/Destination City.java b/Easy/Destination City.java index c9f08cbc..f6e330ab 100644 --- a/Easy/Destination City.java +++ b/Easy/Destination City.java @@ -1,17 +1,12 @@ class Solution { - public String destCity(List> paths) { - Set outgoingPathCities = new HashSet<>(); - Set cities = new HashSet<>(); - for (List path : paths) { - outgoingPathCities.add(path.get(0)); - cities.add(path.get(0)); - cities.add(path.get(1)); + public String destCity(List> paths) { + Set cities = new HashSet<>(); + Set outgoingCities = new HashSet<>(); + for (List path : paths) { + cities.addAll(path); + outgoingCities.add(path.get(0)); + } + cities.removeAll(outgoingCities); + return cities.iterator().next(); } - for (String city : cities) { - if (!outgoingPathCities.contains(city)) { - return city; - } - } - return ""; - } } From a144dfd7beed7b924afcbaa04dd00742c93ad710 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 17 Dec 2023 08:21:20 -0800 Subject: [PATCH 415/712] Create Design a Food Rating System.java --- Medium/Design a Food Rating System.java | 53 +++++++++++++++++++++++++ 1 file changed, 53 insertions(+) create mode 100644 Medium/Design a Food Rating System.java diff --git a/Medium/Design a Food Rating System.java b/Medium/Design a Food Rating System.java new file mode 100644 index 00000000..71c55477 --- /dev/null +++ b/Medium/Design a Food Rating System.java @@ -0,0 +1,53 @@ +class FoodRatings { + + private final Map foodToRating; + + private final Map foodToCuisine; + + private final Map> cuisineToFood; + + public FoodRatings(String[] foods, String[] cuisines, int[] ratings) { + this.foodToRating = new HashMap<>(); + this.foodToCuisine = new HashMap<>(); + this.cuisineToFood = new HashMap<>(); + for (int i = 0; i < foods.length; i++) { + String food = foods[i]; + String cuisine = cuisines[i]; + int rating = ratings[i]; + foodToRating.put(food, rating); + foodToCuisine.put(food, cuisine); + cuisineToFood.computeIfAbsent(cuisine, k -> new PriorityQueue<>()).add(new Food(food, rating)); + } + } + + public void changeRating(String food, int newRating) { + this.foodToRating.put(food, newRating); + String cuisine = foodToCuisine.get(food); + cuisineToFood.get(cuisine).add(new Food(food, newRating)); + } + + public String highestRated(String cuisine) { + Food highestRatedFood = cuisineToFood.get(cuisine).peek(); + while (foodToRating.get(highestRatedFood.name) != highestRatedFood.rating) { + cuisineToFood.get(cuisine).poll(); + highestRatedFood = cuisineToFood.get(cuisine).peek(); + } + return highestRatedFood.name; + } + + private record Food(String name, int rating) implements Comparable { + @Override + public int compareTo(Food o) { + int c = o.rating - rating; + return c == 0 ? name.compareTo(o.name) : c; + } + } +} + + +/** + * Your FoodRatings object will be instantiated and called as such: + * FoodRatings obj = new FoodRatings(foods, cuisines, ratings); + * obj.changeRating(food,newRating); + * String param_2 = obj.highestRated(cuisine); + */ From 6a5b18f6201ffcd24d488c9fb6018381fc93d771 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 17 Dec 2023 11:44:36 -0800 Subject: [PATCH 416/712] Create Find Missing and Repeated Values.java --- Easy/Find Missing and Repeated Values.java | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+) create mode 100644 Easy/Find Missing and Repeated Values.java diff --git a/Easy/Find Missing and Repeated Values.java b/Easy/Find Missing and Repeated Values.java new file mode 100644 index 00000000..52cf256e --- /dev/null +++ b/Easy/Find Missing and Repeated Values.java @@ -0,0 +1,21 @@ +class Solution { + public int[] findMissingAndRepeatedValues(int[][] grid) { + int n = grid.length; + int[] frequency = new int[n * n + 1]; + for (int[] row : grid) { + for (int num : row) { + frequency[num]++; + } + } + int[] result = new int[2]; + for (int i = 1; i <= n * n; i++) { + if (frequency[i] == 0) { + result[1] = i; + } + if (frequency[i] == 2) { + result[0] = i; + } + } + return result; + } +} From 9f0730eb747f6e3d8cc383a009529f3b8f1a2a97 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Mon, 18 Dec 2023 09:32:47 -0800 Subject: [PATCH 417/712] Create Divide Array Into Arrays With Max Difference.java --- ...ide Array Into Arrays With Max Difference.java | 15 +++++++++++++++ 1 file changed, 15 insertions(+) create mode 100644 Medium/Divide Array Into Arrays With Max Difference.java diff --git a/Medium/Divide Array Into Arrays With Max Difference.java b/Medium/Divide Array Into Arrays With Max Difference.java new file mode 100644 index 00000000..77959768 --- /dev/null +++ b/Medium/Divide Array Into Arrays With Max Difference.java @@ -0,0 +1,15 @@ +class Solution { + public int[][] divideArray(int[] nums, int k) { + Arrays.sort(nums); + int n = nums.length; + int[][] result = new int[n / 3][3]; + int idx = 0; + for (int i = 2; i < nums.length; i += 3) { + if (nums[i] - nums[i - 2] > k) { + return new int[][]{}; + } + result[idx++] = new int[]{nums[i - 2], nums[i - 1], nums[i]}; + } + return result; + } +} From 3b43dac141a1cc49ef215ebedbb158c93784d8eb Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Tue, 19 Dec 2023 07:36:03 -0800 Subject: [PATCH 418/712] Update Image Smoother.java --- Easy/Image Smoother.java | 64 +++++++++++++--------------------------- 1 file changed, 21 insertions(+), 43 deletions(-) diff --git a/Easy/Image Smoother.java b/Easy/Image Smoother.java index 9f0d68f0..ede06daf 100644 --- a/Easy/Image Smoother.java +++ b/Easy/Image Smoother.java @@ -1,49 +1,27 @@ class Solution { - public int[][] imageSmoother(int[][] M) { - - int[][] res = new int[M.length][M[0].length]; - for (int i=0;i= 0) { - count++; - sum += M[i][j-1]; - } - if(j+1 < M[0].length) { - count++; - sum += M[i][j+1]; - } - if(i-1 >= 0) { - count++; - sum += M[i-1][j]; - } - if(i+1 < M.length) { - count++; - sum += M[i+1][j]; - } - if(i+1 < M.length && j+1 < M[0].length) { - count++; - sum += M[i+1][j+1]; - } - if(i+1 < M.length && j-1 >= 0) { - count++; - sum += M[i+1][j-1]; - } - if(i-1 >= 0 && j-1 >= 0) { - count++; - sum += M[i-1][j-1]; - } - if(i-1 >= 0 && j+1 < M[0].length) { - count++; - sum += M[i-1][j+1]; - } - - res[i][j] = (int)Math.floor(sum/count); + for (int[] dir : DIRS) { + int row = i + dir[0]; + int col = j + dir[1]; + if (row >= 0 && row < rows && col >= 0 && col < cols) { + sum += img[row][col]; + count++; + } + } + double smoothImage = sum / count; + result[i][j] = (int) smoothImage; } } - - return res; + return result; } } From 8f41cdff81fd1d5b35ebe3867a8ffb3e605e0814 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Thu, 21 Dec 2023 07:31:40 -0800 Subject: [PATCH 419/712] Create Widest Vertical Area Between Two Points Containing No Points.java --- ... Area Between Two Points Containing No Points.java | 11 +++++++++++ 1 file changed, 11 insertions(+) create mode 100644 Medium/Widest Vertical Area Between Two Points Containing No Points.java diff --git a/Medium/Widest Vertical Area Between Two Points Containing No Points.java b/Medium/Widest Vertical Area Between Two Points Containing No Points.java new file mode 100644 index 00000000..d2e07d21 --- /dev/null +++ b/Medium/Widest Vertical Area Between Two Points Containing No Points.java @@ -0,0 +1,11 @@ +class Solution { + public int maxWidthOfVerticalArea(int[][] points) { + Arrays.sort(points, (a, b) -> a[0] - b[0]); + int maxWidth = 0; + for (int i = 1; i < points.length; i++) { + int width = points[i][0] - points[i - 1][0]; + maxWidth = Math.max(maxWidth, width); + } + return maxWidth; + } +} From 6e84385d2034cfc65946e25bb5d7a5b2151b7644 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Fri, 22 Dec 2023 08:10:18 -0800 Subject: [PATCH 420/712] Create Maximum Score After Splitting a String.java --- .../Maximum Score After Splitting a String.java | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) create mode 100644 Easy/Maximum Score After Splitting a String.java diff --git a/Easy/Maximum Score After Splitting a String.java b/Easy/Maximum Score After Splitting a String.java new file mode 100644 index 00000000..60649ebf --- /dev/null +++ b/Easy/Maximum Score After Splitting a String.java @@ -0,0 +1,17 @@ +class Solution { + public int maxScore(String s) { + int n = s.length(); + int ones = 0; + for (int i = 0; i < n; i++) { + ones += s.charAt(i) == '1' ? 1 : 0; + } + int score = 0; + int zeros = 0; + for (int i = 0; i < n - 1; i++) { + ones -= s.charAt(i) == '1' ? 1 : 0; + zeros += s.charAt(i) == '0' ? 1 : 0; + score = Math.max(score, zeros + ones); + } + return score; + } +} From e8a9a698819cd069512fd6523f6cffe85142344f Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Fri, 22 Dec 2023 12:26:39 -0800 Subject: [PATCH 421/712] Update Longest Substring with At Most Two Distinct Characters.java --- ... with At Most Two Distinct Characters.java | 36 +++++++++---------- 1 file changed, 18 insertions(+), 18 deletions(-) diff --git a/Medium/Longest Substring with At Most Two Distinct Characters.java b/Medium/Longest Substring with At Most Two Distinct Characters.java index 2af3a613..04f60a83 100644 --- a/Medium/Longest Substring with At Most Two Distinct Characters.java +++ b/Medium/Longest Substring with At Most Two Distinct Characters.java @@ -1,22 +1,22 @@ class Solution { - public int lengthOfLongestSubstringTwoDistinct(String s) { - Map map = new HashMap<>(); - int startIdx = 0; - int endIdx = 0; - int n = s.length(); - int maxLength = 0; - while (endIdx < n) { - map.put(s.charAt(endIdx), map.getOrDefault(s.charAt(endIdx), 0) + 1); - while (startIdx < endIdx && map.size() > 2) { - map.put(s.charAt(startIdx), map.getOrDefault(s.charAt(startIdx), 0) - 1); - if (map.get(s.charAt(startIdx)) <= 0) { - map.remove(s.charAt(startIdx)); + public int lengthOfLongestSubstringTwoDistinct(String s) { + int max = 0; + int start = 0; + int end = 0; + int n = s.length(); + Map map = new HashMap<>(); + while (end < n) { + map.put(s.charAt(end), map.getOrDefault(s.charAt(end), 0) + 1); + end++; + while (start < end && map.size() > 2) { + map.put(s.charAt(start), map.getOrDefault(s.charAt(start), 0) - 1); + if (map.get(s.charAt(start)) == 0) { + map.remove(s.charAt(start)); + } + start++; + } + max = Math.max(max, end - start); } - startIdx++; - } - endIdx++; - maxLength = Math.max(endIdx - startIdx, maxLength); + return max; } - return maxLength; - } } From feecd250c72dac3916b910fe417c20a596d113b3 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sat, 23 Dec 2023 08:40:33 -0800 Subject: [PATCH 422/712] Update Path Crossing.java --- Easy/Path Crossing.java | 44 ++++++++++++++++++++++++----------------- 1 file changed, 26 insertions(+), 18 deletions(-) diff --git a/Easy/Path Crossing.java b/Easy/Path Crossing.java index 32b241c3..e3f7d9a9 100644 --- a/Easy/Path Crossing.java +++ b/Easy/Path Crossing.java @@ -1,21 +1,29 @@ class Solution { - int[][] dirs = {{0, 1}, {0, -1}, {-1, 0}, {1, 0}}; - public boolean isPathCrossing(String path) { - Set set = new HashSet<>(); - int currX = 0; - int currY = 0; - String dirSymbol = "NSEW"; - set.add(currX + "|" + currY); - for (char c : path.toCharArray()) { - int dirIdx = dirSymbol.indexOf(c); - currX += dirs[dirIdx][0]; - currY += dirs[dirIdx][1]; - String hash = currX + "|" + currY; - if (set.contains(hash)) { - return true; - } - set.add(hash); + public boolean isPathCrossing(String path) { + Set visited = new HashSet<>(); + visited.add("0|0"); + int x = 0; + int y = 0; + for (Character step : path.toCharArray()) { + switch (step) { + case 'N': + x++; + break; + case 'S': + x--; + break; + case 'E': + y--; + break; + case 'W': + y++; + break; + } + String key = x + "|" + y; + if (!visited.add(key)) { + return true; + } + } + return false; } - return false; - } } From 85f5352083dcee5950f3ad52194876b7a7464c23 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 24 Dec 2023 07:20:23 -0800 Subject: [PATCH 423/712] Update Minimum Changes To Make Alternating Binary String.java --- ...ges To Make Alternating Binary String.java | 21 ++++++++++++------- 1 file changed, 13 insertions(+), 8 deletions(-) diff --git a/Easy/Minimum Changes To Make Alternating Binary String.java b/Easy/Minimum Changes To Make Alternating Binary String.java index 539d9a42..95f9aaae 100644 --- a/Easy/Minimum Changes To Make Alternating Binary String.java +++ b/Easy/Minimum Changes To Make Alternating Binary String.java @@ -1,11 +1,16 @@ class Solution { - public int minOperations(String s) { - int numOfChanges = 0; - for (int i = 0; i < s.length(); i++) { - if (s.charAt(i) - '0' != i % 2) { - numOfChanges++; - } + public int minOperations(String s) { + int startZero = 0; + int startOne = 0; + for (int i = 0; i < s.length(); i++) { + if (i % 2 == 0) { + startOne += s.charAt(i) == '0' ? 1 : 0; + startZero += s.charAt(i) == '1' ? 1 : 0; + } else { + startOne += s.charAt(i) == '1' ? 1 : 0; + startZero += s.charAt(i) == '0' ? 1 : 0; + } + } + return Math.min(startZero, startOne); } - return Math.min(numOfChanges, s.length() - numOfChanges); - } } From 3552e0f598b987be4f311c1e536cbc072108a122 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Tue, 26 Dec 2023 07:43:32 -0800 Subject: [PATCH 424/712] Update Number of Dice Rolls With Target Sum.java --- .../Number of Dice Rolls With Target Sum.java | 50 ++++++++++--------- 1 file changed, 27 insertions(+), 23 deletions(-) diff --git a/Medium/Number of Dice Rolls With Target Sum.java b/Medium/Number of Dice Rolls With Target Sum.java index 6e600168..e192518a 100644 --- a/Medium/Number of Dice Rolls With Target Sum.java +++ b/Medium/Number of Dice Rolls With Target Sum.java @@ -1,27 +1,31 @@ class Solution { - Map map = new HashMap<>(); - final int MODULO = 1000000007; - public int numRollsToTarget(int d, int f, int target) { - if (d == 0 && target == 0) { - return 1; + + private static final int MOD = 1000_000_007; + + public int numRollsToTarget(int n, int k, int target) { + Map map = new HashMap<>(); + return helper(n, k, target, map); } - if (d == 0 || target == 0) { - return 0; + + private int helper(int n, int k, int target, Map map) { + if (n == 0 && target == 0) { + return 1; + } + if (n == 0 || target == 0) { + return 0; + } + int key = n * 1000 + target; + if (map.containsKey(key)) { + return map.get(key); + } + int result = 0; + for (int i = 1; i <= k; i++) { + if (target < i) { + break; + } + result = (result + helper(n - 1, k, target - i, map)) % MOD; + } + map.put(key, result); + return result; } - String key = d + "|" + target; - if (map.containsKey(key)) { - return map.get(key); - } - int res = 0; - for (int i = 1; i <= f; i++) { - if (target >= i) { - res = (res + numRollsToTarget(d - 1, f, target - i)) % MODULO; - } - else { - break; - } - } - map.put(key, res); - return map.get(key); - } } From 7891aaa65276452f74a335c3095da57d4362f84c Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Tue, 26 Dec 2023 07:47:30 -0800 Subject: [PATCH 425/712] Create Minimum Number Game.java --- Easy/Minimum Number Game.java | 11 +++++++++++ 1 file changed, 11 insertions(+) create mode 100644 Easy/Minimum Number Game.java diff --git a/Easy/Minimum Number Game.java b/Easy/Minimum Number Game.java new file mode 100644 index 00000000..a3377cb7 --- /dev/null +++ b/Easy/Minimum Number Game.java @@ -0,0 +1,11 @@ +class Solution { + public int[] numberGame(int[] nums) { + int[] result = new int[nums.length]; + Arrays.sort(nums); + for (int i = 0; i < nums.length; i += 2) { + result[i] = nums[i + 1]; + result[i + 1] = nums[i]; + } + return result; + } +} From c4505bfb84748231912291819dd8eead17dfb16b Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Tue, 26 Dec 2023 17:28:19 -0800 Subject: [PATCH 426/712] Update Minimum Time to Make Rope Colorful.java --- .../Minimum Time to Make Rope Colorful.java | 32 +++++++++---------- 1 file changed, 16 insertions(+), 16 deletions(-) diff --git a/Medium/Minimum Time to Make Rope Colorful.java b/Medium/Minimum Time to Make Rope Colorful.java index 97cc34e1..3fdc7e26 100644 --- a/Medium/Minimum Time to Make Rope Colorful.java +++ b/Medium/Minimum Time to Make Rope Colorful.java @@ -1,19 +1,19 @@ class Solution { - public int minCost(String colors, int[] neededTime) { - int totalTime = 0; - int left = 0; - int right = 0; - while (right < colors.length()) { - int currTotal = 0; - int currMax = 0; - while (left < neededTime.length && colors.charAt(right) == colors.charAt(left)) { - currTotal += neededTime[left]; - currMax = Math.max(currMax, neededTime[left]); - left++; - } - totalTime += currTotal - currMax; - right = left; + public int minCost(String colors, int[] neededTime) { + Stack stack = new Stack<>(); + int cost = 0; + for (int i = 0; i < colors.length(); i++) { + if (stack.isEmpty() || colors.charAt(i) != colors.charAt(stack.peek())) { + stack.push(i); + continue; + } + if (neededTime[i] > neededTime[stack.peek()]) { + cost += neededTime[stack.pop()]; + stack.push(i); + } else { + cost += neededTime[i]; + } + } + return cost; } - return totalTime; - } } From ddcb14efbe1a54349dca61da5587fdcf283d2186 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Thu, 28 Dec 2023 10:18:05 -0800 Subject: [PATCH 427/712] Update String Compression II.java --- Hard/String Compression II.java | 115 +++++++++++++++----------------- 1 file changed, 52 insertions(+), 63 deletions(-) diff --git a/Hard/String Compression II.java b/Hard/String Compression II.java index d2f3d371..ac420adf 100644 --- a/Hard/String Compression II.java +++ b/Hard/String Compression II.java @@ -1,69 +1,58 @@ class Solution { - - /** - * First dimension : Current index - * Second dimension : Amount of available deletions - * Third dimension : Index of previous character - * Fourth dimension : Consecutive count of previous character - */ - private static int[][][][] dp = new int[100][101][100][26]; - - public int getLengthOfOptimalCompression(String s, int k) { - int n = s.length(); - for(int i = 0; i < n; i++) { - for(int j = 0; j <= k; j++) { - for(int z = 0; z < n; z++) { - for(int l = 0; l < 26; l++) { - dp[i][j][z][l]=-1; - } + + private static int[][][][] dp = new int[100][101][100][26]; + + public int getLengthOfOptimalCompression(String s, int k) { + int n = s.length(); + for (int i = 0; i < n; i++) { + for (int j = 0; j <= k; j++) { + for (int x = 0; x < n; x++) { + for (int y = 0; y < 26; y++) { + dp[i][j][x][y] = -1; + } + } + } } - } + return solver(s.toCharArray(), 0, k, 0, s.charAt(0)); } - return best(s.toCharArray(), /* idx= */ 0, k, /* count= */ 0, /* prevChar= */ s.charAt(0)); - } - - private int best(char[] letters, int idx, int k, int count, char prevChar) { - if (idx == letters.length) { - return countNumberOfLetters(count); - } - if (dp[idx][k][count][prevChar - 'a'] != -1) { - return dp[idx][k][count][prevChar - 'a']; - } - if (k == 0) { - int result = 0; - if (letters[idx] == prevChar) { - result = best(letters, idx + 1, k, count + 1, prevChar); - } else { - result = countNumberOfLetters(count) + best(letters, idx + 1, k, 1, letters[idx]); - } - dp[idx][k][count][prevChar - 'a'] = result; - return result; - } - int result = 0; - if (letters[idx] == prevChar) { - result = Math.min( - best(letters, idx + 1, k, count + 1, prevChar), // Delete and recurse forward - best(letters, idx + 1, k - 1, count, prevChar)); // Don't delete and recurse forward - } else { - result = Math.min( - countNumberOfLetters(count) + best(letters, idx + 1, k, /* count= */ 1, /* prevChar= */ letters[idx]), // Don't delete current char and recurse forward with new count - best(letters, idx + 1, k - 1, count, prevChar)); // Delete current character and recurse forward - } - dp[idx][k][count][prevChar - 'a'] = result; - return result; - } - - private static int countNumberOfLetters(int count) { - if (count == 0) { - return count; + + private int solver(char[] letters, int idx, int k, int currFrequency, char prevChar) { + if (idx == letters.length) { + return getLetterCount(currFrequency); + } + if (dp[idx][k][currFrequency][prevChar - 'a'] != -1) { + return dp[idx][k][currFrequency][prevChar - 'a']; + } + int result = 0; + if (letters[idx] == prevChar) { + result = k == 0 ? + solver(letters, idx + 1, k, currFrequency + 1, prevChar) : + Math.min( + solver(letters, idx + 1, k , currFrequency + 1, prevChar), // don't delete + solver(letters, idx + 1, k - 1 , currFrequency, prevChar) // delete + ); + } else { + result = k == 0 ? + getLetterCount(currFrequency) + solver(letters, idx + 1, k, 1, letters[idx]) : + Math.min( + getLetterCount(currFrequency) + solver(letters, idx + 1, k, 1, letters[idx]), // don't delete + solver(letters, idx + 1, k - 1, currFrequency, prevChar) // delete + ); + } + return dp[idx][k][currFrequency][prevChar - 'a'] = result; } - int numberOfDigits = 1; - if (count > 9) { - numberOfDigits = 2; - } - if (count > 99) { - numberOfDigits = 3; + + private static int getLetterCount(int frequency) { + if (frequency == 0) { + return 0; + } + int digits = 1; + if (frequency > 9) { + digits = 2; + } + if (frequency > 99) { + digits = 3; + } + return frequency == 1 ? 1 : (digits + 1); } - return count == 1 ? 1 : (numberOfDigits + 1); - } } From bd407202de2446c8dfa576516865b4b2034e140d Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Fri, 29 Dec 2023 10:44:34 -0800 Subject: [PATCH 428/712] Update Minimum Difficulty of a Job Schedule.java --- .../Minimum Difficulty of a Job Schedule.java | 52 +++++++++---------- 1 file changed, 26 insertions(+), 26 deletions(-) diff --git a/Hard/Minimum Difficulty of a Job Schedule.java b/Hard/Minimum Difficulty of a Job Schedule.java index 58722245..ebc94cc7 100644 --- a/Hard/Minimum Difficulty of a Job Schedule.java +++ b/Hard/Minimum Difficulty of a Job Schedule.java @@ -1,30 +1,30 @@ class Solution { - public int minDifficulty(int[] jobDifficulty, int d) { - int n = jobDifficulty.length; - if (n < d) { - return -1; + + private static final int INVALID_VALUE = 300_001; + + public int minDifficulty(int[] jobDifficulty, int d) { + if (jobDifficulty.length < d) { + return -1; + } + Integer[][][] dp = new Integer[jobDifficulty.length][d + 1][1001]; + return dfs(jobDifficulty, 0, d, 0, dp); } - Integer[][] dp = new Integer[n][d + 1]; - return minDifficulty(/* index= */0, d, jobDifficulty, dp); - } - - private int minDifficulty(int index, int dLeft, int[] jobDifficulty, Integer[][] dp) { - if (dp[index][dLeft] != null) { - return dp[index][dLeft]; + + private int dfs(int[] jobDifficulty, int idx, int d, int currMax, Integer[][][] dp) { + if (idx == jobDifficulty.length) { + return d == 0 ? 0 : INVALID_VALUE; + } + if (d == 0) { + return INVALID_VALUE; + } + if (dp[idx][d][currMax] != null) { + return dp[idx][d][currMax]; + } + currMax = Math.max(currMax, jobDifficulty[idx]); + int result = Math.min(dfs( + jobDifficulty, idx + 1, d, currMax, dp), // continue same sequence + currMax + dfs(jobDifficulty, idx + 1, d - 1, 0, dp) // break sequence + ); + return dp[idx][d][currMax] = result; } - if (dLeft == 1) { - int result = 0; - for (int j = index; j < jobDifficulty.length; j++) { - result = Math.max(result, jobDifficulty[j]); - } - return result; - } - int result = Integer.MAX_VALUE; - int dailyMaxJobDiff = 0; - for (int j = index; j < jobDifficulty.length - dLeft + 1; j++) { - dailyMaxJobDiff = Math.max(dailyMaxJobDiff, jobDifficulty[j]); - result = Math.min(result, dailyMaxJobDiff + minDifficulty(j + 1, dLeft - 1, jobDifficulty, dp)); - } - return dp[index][dLeft] = result; - } } From 815d3e73700a4af1bec530035ac8264ebd4bb041 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Fri, 29 Dec 2023 10:58:42 -0800 Subject: [PATCH 429/712] Create Valid Palindrome III.java --- Hard/Valid Palindrome III.java | 26 ++++++++++++++++++++++++++ 1 file changed, 26 insertions(+) create mode 100644 Hard/Valid Palindrome III.java diff --git a/Hard/Valid Palindrome III.java b/Hard/Valid Palindrome III.java new file mode 100644 index 00000000..dc97a304 --- /dev/null +++ b/Hard/Valid Palindrome III.java @@ -0,0 +1,26 @@ +class Solution { + public boolean isValidPalindrome(String s, int k) { + int n = s.length(); + Integer[][] dp = new Integer[n][n]; + return isValidPalindrome(s, 0, n - 1, dp) <= k; + } + + private int isValidPalindrome(String s, int left, int right, Integer[][] dp) { + if (left == right) { + return 0; + } + if (left == right - 1) { + return s.charAt(left) != s.charAt(right) ? 1 : 0; + } + if (dp[left][right] != null) { + return dp[left][right]; + } + if (s.charAt(left) == s.charAt(right)) { + return isValidPalindrome(s, left + 1, right - 1, dp); // move both pointers + } + return dp[left][right] = 1 + Math.min( + isValidPalindrome(s, left + 1, right, dp), // move only left pointer + isValidPalindrome(s, left, right - 1, dp) // move only right pointer + ); + } +} From 5fff8fb179026d7a7bafb646479e42345f7330df Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sat, 30 Dec 2023 17:55:12 -0800 Subject: [PATCH 430/712] Update Largest Substring Between Two Equal Characters.java --- ... Substring Between Two Equal Characters.java | 17 ++++++++--------- 1 file changed, 8 insertions(+), 9 deletions(-) diff --git a/Easy/Largest Substring Between Two Equal Characters.java b/Easy/Largest Substring Between Two Equal Characters.java index fa0d8495..24371003 100644 --- a/Easy/Largest Substring Between Two Equal Characters.java +++ b/Easy/Largest Substring Between Two Equal Characters.java @@ -1,12 +1,11 @@ class Solution { - public int maxLengthBetweenEqualCharacters(String s) { - Map startIndex = new HashMap<>(); - int largestSubstringLength = -1; - for (int i = 0; i < s.length(); i++) { - char c = s.charAt(i); - startIndex.putIfAbsent(c, i); - largestSubstringLength = Math.max(largestSubstringLength, i - startIndex.get(c) - 1); + public int maxLengthBetweenEqualCharacters(String s) { + Map map = new HashMap<>(); + int maxLength = -1; + for (int i = 0; i < s.length(); i++) { + map.putIfAbsent(s.charAt(i), i); + maxLength = Math.max(maxLength, i - map.get(s.charAt(i)) - 1); + } + return maxLength; } - return largestSubstringLength; - } } From f408c474be863412fa785f556a718d8fb771ba2b Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 31 Dec 2023 15:49:41 -0800 Subject: [PATCH 431/712] Create Check if Bitwise OR Has Trailing Zeros.java --- Easy/Check if Bitwise OR Has Trailing Zeros.java | 7 +++++++ 1 file changed, 7 insertions(+) create mode 100644 Easy/Check if Bitwise OR Has Trailing Zeros.java diff --git a/Easy/Check if Bitwise OR Has Trailing Zeros.java b/Easy/Check if Bitwise OR Has Trailing Zeros.java new file mode 100644 index 00000000..b1aedc22 --- /dev/null +++ b/Easy/Check if Bitwise OR Has Trailing Zeros.java @@ -0,0 +1,7 @@ +class Solution { + public boolean hasTrailingZeros(int[] nums) { + return Arrays.stream(nums) + .filter(num -> Integer.numberOfTrailingZeros(num) > 0) + .count() >= 2; + } +} From d506f5543729c389424c5a2566977f0bb805fc27 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Mon, 1 Jan 2024 08:48:41 -0800 Subject: [PATCH 432/712] Update Assign Cookies.java --- Easy/Assign Cookies.java | 22 ++++++++++------------ 1 file changed, 10 insertions(+), 12 deletions(-) diff --git a/Easy/Assign Cookies.java b/Easy/Assign Cookies.java index 6ff366ad..32b09bf6 100644 --- a/Easy/Assign Cookies.java +++ b/Easy/Assign Cookies.java @@ -1,15 +1,13 @@ class Solution { - public int findContentChildren(int[] g, int[] s) { - Arrays.sort(g); - Arrays.sort(s); - int gIdx = 0; - int sIdx = 0; - while (sIdx < s.length && gIdx < g.length) { - if (s[sIdx] >= g[gIdx]) { - gIdx++; - } - sIdx++; + public int findContentChildren(int[] greed, int[] cookieSize) { + Arrays.sort(greed); + Arrays.sort(cookieSize); + int idx = 0; + for (int i = 0; i < cookieSize.length && idx < greed.length; i++) { + if (cookieSize[i] >= greed[idx]) { + idx++; + } + } + return idx; } - return gIdx; - } } From 62bf7ccabb4ea9bc3ea9f060f58e872d0b91664b Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Tue, 2 Jan 2024 13:14:49 -0800 Subject: [PATCH 433/712] Update Campus Bikes II.java --- Medium/Campus Bikes II.java | 48 ++++++++++++++++++------------------- 1 file changed, 23 insertions(+), 25 deletions(-) diff --git a/Medium/Campus Bikes II.java b/Medium/Campus Bikes II.java index 82de40c4..692725d0 100644 --- a/Medium/Campus Bikes II.java +++ b/Medium/Campus Bikes II.java @@ -1,30 +1,28 @@ class Solution { - int minDist; - public int assignBikes(int[][] workers, int[][] bikes) { - minDist = Integer.MAX_VALUE; - dfs(new boolean[bikes.length], workers, 0, bikes, 0); - return minDist; - } - - private void dfs(boolean[] visited, int[][] workers, int currIdx, int[][] bikes, int distance) { - if (currIdx >= workers.length) { - minDist = Math.min(minDist, distance); - return; + public int assignBikes(int[][] workers, int[][] bikes) { + Integer[] dp = new Integer[1024]; + return minDistance(workers, bikes, 0, 0, dp); } - if (distance > minDist) { - return; + + private int minDistance(int[][] workers, int[][] bikes, int workerIdx, int mask, Integer[] dp) { + if (workerIdx >= workers.length) { + return 0; + } + if (dp[mask] != null) { + return dp[mask]; + } + int distance = Integer.MAX_VALUE; + for (int i = 0; i < bikes.length; i++) { + // if bike is available + if ((mask & (1 << i)) == 0) { + // assign the bike & traverse for remaining bikes + distance = Math.min(distance, calculateManhattanDistance(workers[workerIdx], bikes[i]) + minDistance(workers, bikes, workerIdx + 1, mask | (1 << i), dp)); + } + } + return dp[mask] = distance; } - for (int i = 0; i < bikes.length; i++) { - if (visited[i]) { - continue; - } - visited[i] = true; - dfs(visited, workers, currIdx + 1, bikes, distance + getManahattanDist(bikes[i], workers[currIdx])); - visited[i] = false; + + private static int calculateManhattanDistance(int[] worker, int[] bike) { + return Math.abs(worker[0] - bike[0]) + Math.abs(worker[1] - bike[1]); } - } - - private int getManahattanDist(int[] p1, int[] p2) { - return Math.abs(p1[0] - p2[0]) + Math.abs(p1[1] - p2[1]); - } } From ff19e288647f03ad4855db273e5598377087648e Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Wed, 3 Jan 2024 07:45:58 -0800 Subject: [PATCH 434/712] Update Number of Laser Beams in a Bank.java --- Medium/Number of Laser Beams in a Bank.java | 26 +++++++++++---------- 1 file changed, 14 insertions(+), 12 deletions(-) diff --git a/Medium/Number of Laser Beams in a Bank.java b/Medium/Number of Laser Beams in a Bank.java index 9a03ad92..ce39e8bd 100644 --- a/Medium/Number of Laser Beams in a Bank.java +++ b/Medium/Number of Laser Beams in a Bank.java @@ -1,15 +1,17 @@ class Solution { - public int numberOfBeams(String[] bank) { - int prevLaserCount = 0; - int totalNumberOfBeams = 0; - for (String beam : bank) { - if (beam.indexOf('1') != -1) { - int currentBeamCount = (int) beam.chars().mapToObj(c -> (char) c).filter(c -> c == '1') - .count(); - totalNumberOfBeams += prevLaserCount * currentBeamCount; - prevLaserCount = currentBeamCount; - } + public int numberOfBeams(String[] bank) { + int beamCount = 0; + int prevLaserCount = 0; + for (String row : bank) { + int count = 0; + for (char c : row.toCharArray()) { + count += c == '1' ? 1 : 0; + } + if (count > 0) { + beamCount += prevLaserCount * count; + prevLaserCount = count; + } + } + return beamCount; } - return totalNumberOfBeams; - } } From 9cfddc49e9f473e101c449edc549ea8ab82f26be Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Thu, 4 Jan 2024 08:17:53 -0800 Subject: [PATCH 435/712] Update Minimum Number of Operations to Make Array Empty.java --- ...mum Number of Operations to Make Array Empty.java | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/Medium/Minimum Number of Operations to Make Array Empty.java b/Medium/Minimum Number of Operations to Make Array Empty.java index e132e463..69754a8d 100644 --- a/Medium/Minimum Number of Operations to Make Array Empty.java +++ b/Medium/Minimum Number of Operations to Make Array Empty.java @@ -1,15 +1,15 @@ class Solution { public int minOperations(int[] nums) { - Map map = Arrays.stream(nums) - .boxed() - .collect( - Collectors.groupingBy(Function.identity(), HashMap::new, Collectors.counting())); + Map map = new HashMap<>(); + for (int num : nums) { + map.put(num, map.getOrDefault(num, 0) + 1); + } int operations = 0; - for (Long value : map.values()) { + for (Integer value : map.values()) { if (value == 1) { return -1; } - operations += (int) (value / 3 + (value % 3 != 0 ? 1 : 0)); + operations += value / 3 + (value % 3 == 0 ? 0 : 1); } return operations; } From b4e3fc80af398a79b1ab054619676fc67e988a8c Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Fri, 5 Jan 2024 07:26:21 -0800 Subject: [PATCH 436/712] Update Longest Increasing Subsequence.java --- Medium/Longest Increasing Subsequence.java | 29 +++++++++++----------- 1 file changed, 14 insertions(+), 15 deletions(-) diff --git a/Medium/Longest Increasing Subsequence.java b/Medium/Longest Increasing Subsequence.java index a4607634..b56c14ef 100644 --- a/Medium/Longest Increasing Subsequence.java +++ b/Medium/Longest Increasing Subsequence.java @@ -1,19 +1,18 @@ class Solution { - public int lengthOfLIS(int[] nums) { - List subsequence = new ArrayList<>(); - subsequence.add(nums[0]); - for (int i = 1; i < nums.length; i++) { - int currNum = nums[i]; - if (currNum > subsequence.get(subsequence.size() - 1)) { - subsequence.add(currNum); - } else { - int idx = 0; - while (currNum > subsequence.get(idx)) { - idx++; + public int lengthOfLIS(int[] nums) { + List subsequence = new ArrayList<>(); + subsequence.add(nums[0]); + for (int i = 1; i < nums.length; i++) { + if (nums[i] > subsequence.get(subsequence.size() - 1)) { + subsequence.add(nums[i]); + } else { + int idx = 0; + while (nums[i] > subsequence.get(idx)) { + idx++; + } + subsequence.set(idx, nums[i]); + } } - subsequence.set(idx, currNum); - } + return subsequence.size(); } - return subsequence.size(); - } } From d376fe1e6c95798c21db6276c2b111909916079a Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sat, 6 Jan 2024 12:39:41 -0800 Subject: [PATCH 437/712] Update Maximum Profit in Job Scheduling.java --- Hard/Maximum Profit in Job Scheduling.java | 46 +++++++++++++++------- 1 file changed, 32 insertions(+), 14 deletions(-) diff --git a/Hard/Maximum Profit in Job Scheduling.java b/Hard/Maximum Profit in Job Scheduling.java index f95e58ab..8a785d43 100644 --- a/Hard/Maximum Profit in Job Scheduling.java +++ b/Hard/Maximum Profit in Job Scheduling.java @@ -1,28 +1,46 @@ class Solution { public int jobScheduling(int[] startTime, int[] endTime, int[] profit) { - int n = startTime.length; + int n = profit.length; int[][] jobs = new int[n][3]; for (int i = 0; i < n; i++) { jobs[i] = new int[]{startTime[i], endTime[i], profit[i]}; } Arrays.sort(jobs, (a, b) -> a[0] - b[0]); - Integer[] cache = new Integer[n]; - return dfs(0, jobs, cache); + for (int i = 0; i < n; i++) { + startTime[i] = jobs[i][0]; + } + int[] dp = new int[n + 1]; + Arrays.fill(dp, -1); + return findMaxProfit(jobs, startTime, 0, n, dp); } - - private int dfs(int idx, int[][] jobs, Integer[] cache) { - if (idx == jobs.length) { + + private int findMaxProfit(int[][] jobs, int[] startTime, int position, int n, int[] dp) { + if (position == n) { return 0; } - if (cache[idx] != null) { - return cache[idx]; + if (dp[position] != -1) { + return dp[position]; } - int nextIdx = idx + 1; - while (nextIdx < jobs.length && jobs[idx][1] > jobs[nextIdx][0]) { - nextIdx++; + int nextPosition = binarySearch(startTime, jobs[position][1]); + return dp[position] = Math.max( + findMaxProfit(jobs, startTime, position + 1, n, dp), // skip executing current job + jobs[position][2] + findMaxProfit(jobs, startTime, nextPosition, n, dp) // execute current job & move to next position + ); + } + + private static int binarySearch(int[] startTime, int endTime) { + int left = 0; + int right = startTime.length - 1; + int nextPosition = startTime.length; + while (left <= right) { + int mid = (left + right) / 2; + if (startTime[mid] >= endTime) { + nextPosition = mid; + right = mid - 1; + } else { + left = mid + 1; + } } - int jobScheduled = jobs[idx][2] + dfs(nextIdx, jobs, cache); - int jobNotScheduled = dfs(idx + 1, jobs, cache); - return cache[idx] = Math.max(jobScheduled, jobNotScheduled); + return nextPosition; } } From 252fe13a578923364fbbd04c90e6a57ec3690051 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 7 Jan 2024 07:12:24 -0800 Subject: [PATCH 438/712] Create Arithmetic Slices II - Subsequence.java --- Hard/Arithmetic Slices II - Subsequence.java | 22 ++++++++++++++++++++ 1 file changed, 22 insertions(+) create mode 100644 Hard/Arithmetic Slices II - Subsequence.java diff --git a/Hard/Arithmetic Slices II - Subsequence.java b/Hard/Arithmetic Slices II - Subsequence.java new file mode 100644 index 00000000..f193579f --- /dev/null +++ b/Hard/Arithmetic Slices II - Subsequence.java @@ -0,0 +1,22 @@ +class Solution { + public int numberOfArithmeticSlices(int[] nums) { + int n = nums.length; + Map[] count = new Map[n]; + int result = 0; + for (int i = 0; i < n; i++) { + count[i] = new HashMap<>(); + for (int j = 0; j < i; j++) { + long delta = ((long) nums[i]) - ((long) nums[j]); + if (delta < Integer.MIN_VALUE || delta > Integer.MAX_VALUE) { + continue; + } + int diff = (int) delta; + int sum = count[j].getOrDefault(diff, 0); + int current = count[i].getOrDefault(diff, 0); + count[i].put(diff, current + sum + 1); + result += sum; + } + } + return result; + } +} From 0d7a11224ce1f94eb8d7c7792773bce5f04ea7d8 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Tue, 9 Jan 2024 08:03:57 -0800 Subject: [PATCH 439/712] Update Leaf-Similar Trees.java --- Easy/Leaf-Similar Trees.java | 32 +++++++++++++++++++------------- 1 file changed, 19 insertions(+), 13 deletions(-) diff --git a/Easy/Leaf-Similar Trees.java b/Easy/Leaf-Similar Trees.java index 1ac4d480..082f6583 100644 --- a/Easy/Leaf-Similar Trees.java +++ b/Easy/Leaf-Similar Trees.java @@ -15,22 +15,28 @@ */ class Solution { public boolean leafSimilar(TreeNode root1, TreeNode root2) { - StringBuilder leavesOne = new StringBuilder(); - StringBuilder leavesTwo = new StringBuilder(); - populateLeaves(root1, leavesOne); - populateLeaves(root2, leavesTwo); - return leavesOne.toString().equals(leavesTwo.toString()); + return getLeaves(root1).equals(getLeaves(root2)); } - - private void populateLeaves(TreeNode root, StringBuilder leaves) { + + private static List getLeaves(TreeNode root) { if (root == null) { - return; + return new ArrayList<>(); } - if (root.left == null && root.right == null) { - leaves.append(root.val).append(","); - return; + List result = new ArrayList<>(); + Stack stack = new Stack<>(); + stack.push(root); + while (!stack.isEmpty()) { + TreeNode removed = stack.pop(); + if (removed.left == null && removed.right == null) { + result.add(removed.val); + } + if (removed.right != null) { + stack.push(removed.right); + } + if (removed.left != null) { + stack.push(removed.left); + } } - populateLeaves(root.left, leaves); - populateLeaves(root.right, leaves); + return result; } } From f3474fb10dea8798e8ec54960f22227fb8e8cac2 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Tue, 9 Jan 2024 17:44:14 -0800 Subject: [PATCH 440/712] Create Amount of Time for Binary Tree to Be Infected.java --- ...f Time for Binary Tree to Be Infected.java | 65 +++++++++++++++++++ 1 file changed, 65 insertions(+) create mode 100644 Medium/Amount of Time for Binary Tree to Be Infected.java diff --git a/Medium/Amount of Time for Binary Tree to Be Infected.java b/Medium/Amount of Time for Binary Tree to Be Infected.java new file mode 100644 index 00000000..8d5540ab --- /dev/null +++ b/Medium/Amount of Time for Binary Tree to Be Infected.java @@ -0,0 +1,65 @@ +/** + * Definition for a binary tree node. + * public class TreeNode { + * int val; + * TreeNode left; + * TreeNode right; + * TreeNode() {} + * TreeNode(int val) { this.val = val; } + * TreeNode(int val, TreeNode left, TreeNode right) { + * this.val = val; + * this.left = left; + * this.right = right; + * } + * } + */ +class Solution { + public int amountOfTime(TreeNode root, int start) { + Map nodeToParent = new HashMap<>(); + buildNodeToParentRelationship(root, null, nodeToParent); + TreeNode startNode = nodeToParent.keySet() + .stream() + .filter(node -> node.val == start) + .findFirst() + .orElse(null); + return calculateInfectionTime(nodeToParent, startNode); + } + + private void buildNodeToParentRelationship(TreeNode root, TreeNode parent, Map nodeToParent) { + if (root == null) { + return; + } + nodeToParent.put(root, parent); + buildNodeToParentRelationship(root.left, root, nodeToParent); + buildNodeToParentRelationship(root.right, root, nodeToParent); + } + + private int calculateInfectionTime(Map nodeToParent, TreeNode startNode) { + int time = 0; + Set isInfected = new HashSet<>(); + Queue queue = new LinkedList<>(); + queue.add(startNode); + isInfected.add(startNode.val); + while (!queue.isEmpty()) { + int size = queue.size(); + while (size-- > 0) { + TreeNode removed = queue.remove(); + TreeNode parent = nodeToParent.get(removed); + if (nodeToParent.get(removed) != null && isInfected.add(nodeToParent.get(removed).val)) { + queue.add(nodeToParent.get(removed)); + } + if (removed.left != null && isInfected.add(removed.left.val)) { + queue.add(removed.left); + } + if (removed.right != null && isInfected.add(removed.right.val)) { + queue.add(removed.right); + } + } + if (queue.isEmpty()) { + break; + } + time++; + } + return time; + } +} From f7fd40e1c516f53c01658e7e4787de5f363c03f5 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Fri, 12 Jan 2024 07:24:46 -0800 Subject: [PATCH 441/712] Update Determine if String Halves Are Alike.java --- .../Determine if String Halves Are Alike.java | 30 +++++++++++-------- 1 file changed, 18 insertions(+), 12 deletions(-) diff --git a/Easy/Determine if String Halves Are Alike.java b/Easy/Determine if String Halves Are Alike.java index 218ce0ed..f7c9a995 100644 --- a/Easy/Determine if String Halves Are Alike.java +++ b/Easy/Determine if String Halves Are Alike.java @@ -1,14 +1,20 @@ class Solution { - private static final String VOWELS = "aeiouAEIOU"; - public boolean halvesAreAlike(String s) { - return getVowelCount(s.substring(0, s.length() / 2)).equals(getVowelCount(s.substring(s.length() / 2))); - } - - private Long getVowelCount(String s) { - return s.chars().mapToObj(c -> (char) c).filter(Solution::isVowel).count(); - } - - private static boolean isVowel(char c) { - return VOWELS.indexOf(c) != -1; - } + + private static final Set VOWELS = Set.of( + 'a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U' + ); + + public boolean halvesAreAlike(String s) { + int count = 0; + int n = s.length(); + for (int i = 0; i < n / 2; i++) { + if (VOWELS.contains(s.charAt(i))) { + count++; + } + if (VOWELS.contains(s.charAt(i + n / 2))) { + count--; + } + } + return count == 0; + } } From d00ccb6645f0e465f2b504340b622a28b4091fcc Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 14 Jan 2024 08:28:46 -0800 Subject: [PATCH 442/712] Update Determine if Two Strings Are Close.java --- .../Determine if Two Strings Are Close.java | 52 +++++++++---------- 1 file changed, 26 insertions(+), 26 deletions(-) diff --git a/Medium/Determine if Two Strings Are Close.java b/Medium/Determine if Two Strings Are Close.java index 96a5181a..3a43fd6a 100644 --- a/Medium/Determine if Two Strings Are Close.java +++ b/Medium/Determine if Two Strings Are Close.java @@ -1,30 +1,30 @@ class Solution { - public boolean closeStrings(String word1, String word2) { - if (word1.length() != word2.length()) { - return false; + public boolean closeStrings(String word1, String word2) { + if (word1.length() != word2.length()) { + return false; + } + int[] frequencyOne = getFrequencyArray(word1); + int[] frequencyTwo = getFrequencyArray(word2); + for (int i = 0; i < 26; i++) { + if (frequencyOne[i] == 0 && frequencyTwo[i] != 0) { + return false; + } + } + Arrays.sort(frequencyOne); + Arrays.sort(frequencyTwo); + for (int i = 0; i < 26; i++) { + if (frequencyOne[i] != frequencyTwo[i]) { + return false; + } + } + return true; } - int[] frequencyOne = getFrequencyArray(word1); - int[] frequencyTwo = getFrequencyArray(word2); - for (int i = 0; i < frequencyOne.length; i++) { - if (frequencyOne[i] == 0 && frequencyTwo[i] != 0) { - return false; - } + + private static int[] getFrequencyArray(String s) { + int[] frequency = new int[26]; + for (int i = 0; i < s.length(); i++) { + frequency[s.charAt(i) - 'a']++; + } + return frequency; } - Arrays.sort(frequencyOne); - Arrays.sort(frequencyTwo); - for (int i = 0; i < frequencyOne.length; i++) { - if (frequencyOne[i] != frequencyTwo[i]) { - return false; - } - } - return true; - } - - private int[] getFrequencyArray(String s) { - int[] frequency = new int[26]; - for (char c : s.toCharArray()) { - frequency[c - 'a']++; - } - return frequency; - } } From 17c91bf727afa5efbf612dc66c3b408392cc74d2 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Mon, 15 Jan 2024 08:05:08 -0800 Subject: [PATCH 443/712] Update Find Players With Zero or One Losses.java --- .../Find Players With Zero or One Losses.java | 40 +++++++++---------- 1 file changed, 19 insertions(+), 21 deletions(-) diff --git a/Medium/Find Players With Zero or One Losses.java b/Medium/Find Players With Zero or One Losses.java index f3f14ff5..1692f1e5 100644 --- a/Medium/Find Players With Zero or One Losses.java +++ b/Medium/Find Players With Zero or One Losses.java @@ -1,24 +1,22 @@ class Solution { - public List> findWinners(int[][] matches) { - Map lossCount = new HashMap<>(); - Set players = new HashSet<>(); - for (int[] match : matches) { - lossCount.put(match[1], lossCount.getOrDefault(match[1], 0) + 1); - players.add(match[0]); - players.add(match[1]); + public List> findWinners(int[][] matches) { + Map playerToLossCount = new HashMap<>(); + for (int[] match : matches) { + int winner = match[0]; + int loser = match[1]; + playerToLossCount.putIfAbsent(winner, 0); + playerToLossCount.put(loser, playerToLossCount.getOrDefault(loser, 0) + 1); + } + List> result = new ArrayList<>( + Arrays.asList(new ArrayList<>(), new ArrayList<>()) + ); + for (Map.Entry entry : playerToLossCount.entrySet()) { + if (entry.getValue() <= 1) { + result.get(entry.getValue()).add(entry.getKey()); + } + } + Collections.sort(result.get(0)); + Collections.sort(result.get(1)); + return result; } - List noLoss = new ArrayList<>(); - List exactlyOneLoss = new ArrayList<>(); - for (Integer player : players) { - if (!lossCount.containsKey(player)) { - noLoss.add(player); - } - if (lossCount.getOrDefault(player, 0) == 1) { - exactlyOneLoss.add(player); - } - } - Collections.sort(noLoss); - Collections.sort(exactlyOneLoss); - return Arrays.asList(noLoss, exactlyOneLoss); - } } From 290f75fa9e8d3840aeafc27141b7dd7000225c12 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Mon, 15 Jan 2024 13:13:06 -0800 Subject: [PATCH 444/712] Update Single-Row Keyboard.java --- Easy/Single-Row Keyboard.java | 25 ++++++++++++------------- 1 file changed, 12 insertions(+), 13 deletions(-) diff --git a/Easy/Single-Row Keyboard.java b/Easy/Single-Row Keyboard.java index 5a59a1d6..f09a641c 100644 --- a/Easy/Single-Row Keyboard.java +++ b/Easy/Single-Row Keyboard.java @@ -1,16 +1,15 @@ class Solution { - public int calculateTime(String keyboard, String word) { - Map map = new HashMap<>(); - int pos = 0; - for (char c : keyboard.toCharArray()) { - map.put(c, pos++); + public int calculateTime(String keyboard, String word) { + Map map = new HashMap<>(); + for (int i = 0; i < 26; i++) { + map.put(keyboard.charAt(i), i); + } + int position = 0; + int time = 0; + for (char c : word.toCharArray()) { + time += Math.abs(position - map.get(c)); + position = map.get(c); + } + return time; } - int total = 0; - int currPos = 0; - for (char c : word.toCharArray()) { - total += Math.abs(currPos - map.get(c)); - currPos = map.get(c); - } - return total; - } } From 509b60fc8bb7ab11209af0cb4da088432b40679c Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Tue, 16 Jan 2024 08:02:23 -0800 Subject: [PATCH 445/712] Update Insert Delete GetRandom O(1).java --- Medium/Insert Delete GetRandom O(1).java | 61 ++++++++++++------------ 1 file changed, 31 insertions(+), 30 deletions(-) diff --git a/Medium/Insert Delete GetRandom O(1).java b/Medium/Insert Delete GetRandom O(1).java index 3b9b44ae..9ef0fc92 100644 --- a/Medium/Insert Delete GetRandom O(1).java +++ b/Medium/Insert Delete GetRandom O(1).java @@ -1,40 +1,41 @@ class RandomizedSet { - private List randomizedSet; - private Map indexMap; - private int currSize; - - public RandomizedSet() { - this.randomizedSet = new ArrayList<>(); - this.indexMap = new HashMap<>(); - this.currSize = 0; - } + private final List values; + private final Map valToIndexMap; - public boolean insert(int val) { - if (this.indexMap.containsKey(val)) { - return false; + public RandomizedSet() { + this.values = new ArrayList<>(); + this.valToIndexMap = new HashMap<>(); } - this.randomizedSet.add(val); - this.indexMap.put(val, this.currSize++); - return true; - } - public boolean remove(int val) { - if (!this.indexMap.containsKey(val)) { - return false; + public boolean insert(int val) { + if (valToIndexMap.containsKey(val)) { + return false; + } + values.add(val); + valToIndexMap.put(val, values.size() - 1); + return true; } - int valIdx = this.indexMap.get(val); - this.indexMap.put(this.randomizedSet.get(this.currSize - 1), valIdx); - this.randomizedSet.set(valIdx, this.randomizedSet.get(this.currSize - 1)); - this.randomizedSet.remove(this.currSize - 1); - this.indexMap.remove(val); - this.currSize--; - return true; - } - public int getRandom() { - return this.randomizedSet.get(new Random().nextInt(this.currSize)); - } + public boolean remove(int val) { + if (!valToIndexMap.containsKey(val)) { + return false; + } + int valIdx = valToIndexMap.get(val); + int valAtLastIdx = values.get(values.size() - 1); + // update index for last element + values.set(valIdx, valAtLastIdx); + valToIndexMap.put(valAtLastIdx, valIdx); + // remove value + values.remove(values.size() - 1); + valToIndexMap.remove(val); + return true; + } + + public int getRandom() { + int idx = new Random().nextInt(values.size()); + return values.get(idx); + } } /** From cb64d7eb820a18aabb0569c53cf9bfa56e9d81a7 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Thu, 18 Jan 2024 07:55:19 -0800 Subject: [PATCH 446/712] Update Climbing Stairs.java --- Easy/Climbing Stairs.java | 25 +++++++++++++++---------- 1 file changed, 15 insertions(+), 10 deletions(-) diff --git a/Easy/Climbing Stairs.java b/Easy/Climbing Stairs.java index f2ff9386..ad49acda 100644 --- a/Easy/Climbing Stairs.java +++ b/Easy/Climbing Stairs.java @@ -1,14 +1,19 @@ class Solution { - public int climbStairs(int n) { - if (n == 1) { - return 1; + public int climbStairs(int n) { + Integer[] dp = new Integer[n + 1]; + return climbStairs(dp, n); } - int[] dp = new int[n + 1]; - dp[1] = 1; - dp[2] = 2; - for (int i = 3; i <= n; i++) { - dp[i] = dp[i - 1] + dp[i - 2]; + + private int climbStairs(Integer[] dp, int n) { + if (n == 1) { + return 1; + } + if (n == 2) { + return 2; + } + if (dp[n] != null) { + return dp[n]; + } + return dp[n] = climbStairs(dp, n - 1) + climbStairs(dp, n - 2); } - return dp[n]; - } } From 8c794995f324ad1bc8e7a92673ce2e24af14c2a5 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Fri, 19 Jan 2024 09:12:22 -0800 Subject: [PATCH 447/712] Update Minimum Falling Path Sum.java --- Medium/Minimum Falling Path Sum.java | 52 ++++++++++++++++------------ 1 file changed, 29 insertions(+), 23 deletions(-) diff --git a/Medium/Minimum Falling Path Sum.java b/Medium/Minimum Falling Path Sum.java index 040759bf..255081b9 100644 --- a/Medium/Minimum Falling Path Sum.java +++ b/Medium/Minimum Falling Path Sum.java @@ -1,27 +1,33 @@ class Solution { - public int minFallingPathSum(int[][] matrix) { - int minFallingSum = Integer.MAX_VALUE; - Integer[][] dp = new Integer[matrix.length][matrix[0].length]; - for (int i = 0; i < matrix.length; i++) { - minFallingSum = Math.min(minFallingSum, findMinFallingPathSumHelper(matrix, 0, i, dp)); + private static final int[][] DIRS = {{1, -1}, {1, 0}, {1, 1}}; + + public int minFallingPathSum(int[][] matrix) { + int rows = matrix.length; + int cols = matrix[0].length; + Integer[][] dp = new Integer[rows + 1][cols + 1]; + int result = Integer.MAX_VALUE; + for (int i = 0; i < cols; i++) { + result = Math.min(result, recurse(matrix, 0, i, rows, cols, dp)); + } + return result; } - return minFallingSum; - } - - private int findMinFallingPathSumHelper(int[][] matrix, int row, int col, Integer[][] dp) { - if (col < 0 || col == matrix.length) { - return Integer.MAX_VALUE; + + private int recurse(int[][] matrix, int row, int col, int rows, int cols, Integer[][] dp) { + if (row == rows - 1) { + return matrix[row][col]; + } + if (dp[row][col] != null) { + return dp[row][col]; + } + int result = Integer.MAX_VALUE; + for (int[] dir : DIRS) { + int newRow = row + dir[0]; + int newCol = col + dir[1]; + if (newRow < 0 || newCol < 0 || newRow >= rows || newCol >= cols) { + continue; + } + result = Math.min(result, matrix[row][col] + recurse(matrix, newRow, newCol, rows, cols, dp)); + } + return dp[row][col] = result; } - if (row == matrix.length - 1) { - return matrix[row][col]; - } - if (dp[row][col] != null) { - return dp[row][col]; - } - int leftSum = findMinFallingPathSumHelper(matrix, row + 1, col, dp); - int middleSum = findMinFallingPathSumHelper(matrix, row + 1, col + 1, dp); - int rightSum = findMinFallingPathSumHelper(matrix, row + 1, col - 1, dp); - dp[row][col] = Math.min(leftSum, Math.min(middleSum, rightSum)) + matrix[row][col]; - return dp[row][col]; - } } From acd2e4ea9cbead40873afc7eec9643986ec7df85 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sat, 20 Jan 2024 08:32:44 -0800 Subject: [PATCH 448/712] Create Divide an Array Into Subarrays With Minimum Cost I.java --- ... Array Into Subarrays With Minimum Cost I.java | 15 +++++++++++++++ 1 file changed, 15 insertions(+) create mode 100644 Easy/Divide an Array Into Subarrays With Minimum Cost I.java diff --git a/Easy/Divide an Array Into Subarrays With Minimum Cost I.java b/Easy/Divide an Array Into Subarrays With Minimum Cost I.java new file mode 100644 index 00000000..7b214fa7 --- /dev/null +++ b/Easy/Divide an Array Into Subarrays With Minimum Cost I.java @@ -0,0 +1,15 @@ +class Solution { + public int minimumCost(int[] nums) { + int minOne = Integer.MAX_VALUE; + int minTwo = Integer.MAX_VALUE; + for (int i = 1; i < nums.length; i++) { + if (nums[i] < minOne) { + minTwo = minOne; + minOne = nums[i]; + } else if (nums[i] < minTwo) { + minTwo = nums[i]; + } + } + return nums[0] + minOne + minTwo; + } +} From 640cd980c384f2891851638cf30b5949f828e4d0 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sat, 20 Jan 2024 08:39:26 -0800 Subject: [PATCH 449/712] Create Count Elements With Maximum Frequency.java --- Easy/Count Elements With Maximum Frequency.java | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) create mode 100644 Easy/Count Elements With Maximum Frequency.java diff --git a/Easy/Count Elements With Maximum Frequency.java b/Easy/Count Elements With Maximum Frequency.java new file mode 100644 index 00000000..0f023200 --- /dev/null +++ b/Easy/Count Elements With Maximum Frequency.java @@ -0,0 +1,17 @@ +class Solution { + public int maxFrequencyElements(int[] nums) { + Map map = new HashMap<>(); + int maxFrequency = 0; + for (int num : nums) { + map.put(num, map.getOrDefault(num, 0) + 1); + maxFrequency = Math.max(maxFrequency, map.get(num)); + } + int count = 0; + for (int num : nums) { + if (map.get(num) == maxFrequency) { + count++; + } + } + return count; + } +} From eb1a80cf33928453335bcee28120011da2d80654 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 21 Jan 2024 09:18:41 -0800 Subject: [PATCH 450/712] Update House Robber.java --- Medium/House Robber.java | 19 ++++++++----------- 1 file changed, 8 insertions(+), 11 deletions(-) diff --git a/Medium/House Robber.java b/Medium/House Robber.java index 8837a99d..3ebdc59b 100644 --- a/Medium/House Robber.java +++ b/Medium/House Robber.java @@ -1,14 +1,11 @@ class Solution { - public int rob(int[] nums) { - if (nums.length == 1) { - return nums[0]; + public int rob(int[] nums) { + int n = nums.length; + int[] dp = new int[n + 1]; + dp[1] = nums[0]; + for (int i = 1; i < n; i++) { + dp[i + 1] = Math.max(dp[i], dp[i - 1] + nums[i]); + } + return dp[n]; } - int[] dp = new int[nums.length]; - dp[0] = nums[0]; - dp[1] = Math.max(nums[0], nums[1]); - for (int i = 2; i < nums.length; i++) { - dp[i] = Math.max(dp[i - 1], dp[i - 2] + nums[i]); - } - return dp[nums.length - 1]; - } } From c674418fc8b72aa72b59557cb3541841d2b70b72 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 21 Jan 2024 18:07:48 -0800 Subject: [PATCH 451/712] Update Set Mismatch.java --- Easy/Set Mismatch.java | 31 ++++++++++++++++--------------- 1 file changed, 16 insertions(+), 15 deletions(-) diff --git a/Easy/Set Mismatch.java b/Easy/Set Mismatch.java index 9660688d..eac82238 100644 --- a/Easy/Set Mismatch.java +++ b/Easy/Set Mismatch.java @@ -1,18 +1,19 @@ class Solution { - public int[] findErrorNums(int[] nums) { - int[] result = new int[2]; - Set set = new HashSet<>(); - int n = nums.length; - for (int num : nums) { - if (!set.add(num)) { - result[0] = num; - } + public int[] findErrorNums(int[] nums) { + int n = nums.length; + int[] result = new int[2]; + Set set = new HashSet<>(); + for (int i = 1; i <= n; i++) { + if (!set.add(nums[i - 1])) { + result[0] = nums[i - 1]; + } + } + for (int i = 1; i <= n; i++) { + if (!set.contains(i)) { + result[1] = i; + break; + } + } + return result; } - for (int i = 1; i <= n; i++) { - if (!set.contains(i)) { - result[1] = i; - } - } - return result; - } } From 1c8632fdf47f5a2ef31fc1208399bd3a15a25e83 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Mon, 22 Jan 2024 09:24:10 -0800 Subject: [PATCH 452/712] Create Minimum Number of Pushes to Type Word I.java --- Easy/Minimum Number of Pushes to Type Word I.java | 14 ++++++++++++++ 1 file changed, 14 insertions(+) create mode 100644 Easy/Minimum Number of Pushes to Type Word I.java diff --git a/Easy/Minimum Number of Pushes to Type Word I.java b/Easy/Minimum Number of Pushes to Type Word I.java new file mode 100644 index 00000000..0a6bbc24 --- /dev/null +++ b/Easy/Minimum Number of Pushes to Type Word I.java @@ -0,0 +1,14 @@ +class Solution { + public int minimumPushes(String word) { + int pushes = 0; + int idx = 0; + int multiple = 1; + while (idx < word.length()) { + int count = Math.min(8, word.length() - idx); + pushes += count * multiple; + multiple++; + idx += count; + } + return pushes; + } +} From 828c46fe3336aae41adfd56827c01a4f72d424f7 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Mon, 22 Jan 2024 18:47:26 -0800 Subject: [PATCH 453/712] Create Maximum Length of a Concatenated String with Unique Characters.java --- ...tenated String with Unique Characters.java | 26 +++++++++++++++++++ 1 file changed, 26 insertions(+) create mode 100644 Medium/Maximum Length of a Concatenated String with Unique Characters.java diff --git a/Medium/Maximum Length of a Concatenated String with Unique Characters.java b/Medium/Maximum Length of a Concatenated String with Unique Characters.java new file mode 100644 index 00000000..65ca06dc --- /dev/null +++ b/Medium/Maximum Length of a Concatenated String with Unique Characters.java @@ -0,0 +1,26 @@ +class Solution { + public int maxLength(List arr) { + return backtrack(arr, 0, new HashMap<>()); + } + + private int backtrack(List arr, int idx, Map map) { + if (map.values().stream().anyMatch(val -> val > 1)) { + return 0; + } + int result = map.size(); + for (int i = idx; i < arr.size(); i++) { + char[] chars = arr.get(i).toCharArray(); + for (char c : chars) { + map.put(c, map.getOrDefault(c, 0) + 1); + } + result = Math.max(result, backtrack(arr, i + 1, map)); + for (char c : chars) { + map.put(c, map.get(c) - 1); + if (map.get(c) == 0) { + map.remove(c); + } + } + } + return result; + } +} From 6b0aba9576f5f097cd78ef11144be0b9617c875b Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Wed, 24 Jan 2024 07:01:26 -0800 Subject: [PATCH 454/712] Update Pseudo-Palindromic Paths in a Binary Tree.java --- ...do-Palindromic Paths in a Binary Tree.java | 65 +++++++++---------- 1 file changed, 30 insertions(+), 35 deletions(-) diff --git a/Medium/Pseudo-Palindromic Paths in a Binary Tree.java b/Medium/Pseudo-Palindromic Paths in a Binary Tree.java index 04cbe822..87acbbf4 100644 --- a/Medium/Pseudo-Palindromic Paths in a Binary Tree.java +++ b/Medium/Pseudo-Palindromic Paths in a Binary Tree.java @@ -14,43 +14,38 @@ * } */ class Solution { - public int pseudoPalindromicPaths (TreeNode root) { - Queue queue = new LinkedList<>(); - NodePathPair nodePathPair = new NodePathPair(root, 0); - queue.add(nodePathPair); - int count = 0; - while (!queue.isEmpty()) { - int size = queue.size(); - while (size-- > 0) { - NodePathPair removed = queue.remove(); - TreeNode node = removed.node; - int path = removed.path; - // XOR operation ensures that the bit corresponding to the number only appears in the - // path if it has occurred odd number of times. - // 1 << node.val decides the bit of the value - path = path ^ (1 << node.val); - if (node.left == null && node.right == null) { - // Subtracting 1 means setting rightmost 1 bit to 0 and setting all lower bits to 1 - count += (path & (path - 1)) == 0 ? 1 : 0; - } - if (node.left != null) { - queue.add(new NodePathPair(node.left, path)); + public int pseudoPalindromicPaths (TreeNode root) { + int[] result = {0}; + Map map = new HashMap<>(); + helper(root, map, result); + return result[0]; + } + + private void helper(TreeNode root, Map map, int[] result) { + if (root == null) { + return; } - if (node.right != null) { - queue.add(new NodePathPair(node.right, path)); + map.put(root.val, map.getOrDefault(root.val, 0) + 1); + if (root.left == null && root.right == null) { + if (isPseudoPalindromic(map)) { + result[0]++; + } } - } + helper(root.left, map, result); + helper(root.right, map, result); + map.put(root.val, map.getOrDefault(root.val, 0) - 1); } - return count; - } - - private static class NodePathPair { - TreeNode node; - Integer path; - - public NodePathPair(TreeNode node, int path) { - this.node = node; - this.path = path; + + private static boolean isPseudoPalindromic(Map map) { + boolean oddFound = false; + for (Integer key : map.keySet()) { + if (map.get(key) % 2 != 0) { + if (oddFound) { + return false; + } + oddFound = true; + } + } + return true; } - } } From 0d3ab9b8f111e098b98e89b8c2ea28ec69a71f14 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Thu, 25 Jan 2024 07:25:30 -0800 Subject: [PATCH 455/712] Create Longest Common Subsequence.java --- Medium/Longest Common Subsequence.java | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) create mode 100644 Medium/Longest Common Subsequence.java diff --git a/Medium/Longest Common Subsequence.java b/Medium/Longest Common Subsequence.java new file mode 100644 index 00000000..43fc5464 --- /dev/null +++ b/Medium/Longest Common Subsequence.java @@ -0,0 +1,17 @@ +class Solution { + public int longestCommonSubsequence(String text1, String text2) { + int n = text1.length(); + int m = text2.length(); + int[][] dp = new int[n + 1][m + 1]; + for (int i = 0; i < n; i++) { + for (int j = 0; j < m; j++) { + if (text1.charAt(i) == text2.charAt(j)) { + dp[i + 1][j + 1] = 1 + dp[i][j]; + } else { + dp[i + 1][j + 1] = Math.max(dp[i + 1][j], dp[i][j + 1]); + } + } + } + return dp[n][m]; + } +} From 740bcab2ec19b8021bbf58b3c9b59bc21112df17 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Fri, 26 Jan 2024 07:06:02 -0800 Subject: [PATCH 456/712] Update Out of Boundary Paths.java --- Medium/Out of Boundary Paths.java | 52 +++++++++++++------------------ 1 file changed, 22 insertions(+), 30 deletions(-) diff --git a/Medium/Out of Boundary Paths.java b/Medium/Out of Boundary Paths.java index 7179a63c..fc7e9a26 100644 --- a/Medium/Out of Boundary Paths.java +++ b/Medium/Out of Boundary Paths.java @@ -1,34 +1,26 @@ class Solution { - private final int MODULUS = 1000000000 + 7; - - public int findPaths(int m, int n, int maxMove, int startRow, int startColumn) { - int dp[][] = new int[m][n]; - dp[startRow][startColumn] = 1; - int count = 0; - for (int currMove = 1; currMove <= maxMove; currMove++) { - int[][] temp = new int[m][n]; - for (int i = 0; i < m; i++) { - for (int j = 0; j < n; j++) { - if (i == m - 1) { - count = (count + dp[i][j]) % MODULUS; - } - if (j == n - 1) { - count = (count + dp[i][j]) % MODULUS; - } - if (i == 0) { - count = (count + dp[i][j]) % MODULUS; - } - if (j == 0) { - count = (count + dp[i][j]) % MODULUS; - } - temp[i][j] = ( - ((i > 0 ? dp[i - 1][j] : 0) + (i < m - 1 ? dp[i + 1][j] : 0)) % MODULUS + - ((j > 0 ? dp[i][j - 1] : 0) + (j < n - 1 ? dp[i][j + 1] : 0)) % MODULUS - ) % MODULUS; + + private static final int MOD = 1000_000_007; + + public int findPaths(int m, int n, int maxMove, int startRow, int startColumn) { + Integer[][][] dp = new Integer[m][n][maxMove + 1]; + return findPaths(m, n, maxMove, startRow, startColumn, dp); + } + + public int findPaths(int m, int n, int maxMove, int startRow, int startColumn, Integer[][][] dp) { + if (startRow == m || startColumn == n || startRow < 0 || startColumn < 0) { + return 1; + } + if (maxMove == 0) { + return 0; + } + if (dp[startRow][startColumn][maxMove] != null) { + return dp[startRow][startColumn][maxMove]; } - } - dp = temp; + return dp[startRow][startColumn][maxMove] = ( + (findPaths(m, n, maxMove - 1, startRow - 1, startColumn, dp) + + findPaths(m, n, maxMove - 1, startRow + 1, startColumn, dp)) % MOD + + (findPaths(m, n, maxMove - 1, startRow, startColumn - 1, dp) + + findPaths(m, n, maxMove - 1, startRow, startColumn + 1, dp)) % MOD) % MOD; } - return count; - } } From 3291f2ecc3947705ee3e6fd6247f5326b315c6bf Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sat, 27 Jan 2024 12:00:40 -0800 Subject: [PATCH 457/712] Create Find if Array Can Be Sorted.java --- Medium/Find if Array Can Be Sorted.java | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) create mode 100644 Medium/Find if Array Can Be Sorted.java diff --git a/Medium/Find if Array Can Be Sorted.java b/Medium/Find if Array Can Be Sorted.java new file mode 100644 index 00000000..8b08e457 --- /dev/null +++ b/Medium/Find if Array Can Be Sorted.java @@ -0,0 +1,18 @@ +class Solution { + public boolean canSortArray(int[] nums) { + int lastGroupHighest = 0; + int highest = nums[0]; + boolean bitChange = false; + for (int i = 1; i < nums.length; i++) { + bitChange = Integer.bitCount(highest) != Integer.bitCount(nums[i]); + if (bitChange) { + lastGroupHighest = highest; + } + highest = Math.max(nums[i], highest); + if (nums[i] < lastGroupHighest) { + return false; + } + } + return true; + } +} From 3809df81774e8b2715db2718caf40fd11d2f111c Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 28 Jan 2024 14:58:26 -0800 Subject: [PATCH 458/712] Create Number of Changing Keys.java --- Easy/Number of Changing Keys.java | 11 +++++++++++ 1 file changed, 11 insertions(+) create mode 100644 Easy/Number of Changing Keys.java diff --git a/Easy/Number of Changing Keys.java b/Easy/Number of Changing Keys.java new file mode 100644 index 00000000..bb6bc939 --- /dev/null +++ b/Easy/Number of Changing Keys.java @@ -0,0 +1,11 @@ +class Solution { + public int countKeyChanges(String s) { + int changes = 0; + for (int i = 1; i < s.length(); i++) { + if (Character.toLowerCase(s.charAt(i)) != Character.toLowerCase(s.charAt(i - 1))) { + changes++; + } + } + return changes; + } +} From f3af4a0a7924a50f74f90bc28f6d311f54ba2401 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Mon, 29 Jan 2024 07:14:19 -0800 Subject: [PATCH 459/712] Update Implement Queue using Stacks.java --- Easy/Implement Queue using Stacks.java | 38 +++++++++++++------------- 1 file changed, 19 insertions(+), 19 deletions(-) diff --git a/Easy/Implement Queue using Stacks.java b/Easy/Implement Queue using Stacks.java index fd2b165e..a84da8b6 100644 --- a/Easy/Implement Queue using Stacks.java +++ b/Easy/Implement Queue using Stacks.java @@ -1,38 +1,38 @@ class MyQueue { - - private final Stack stackOne; - private final Stack stackTwo; + + private final Stack first; + private final Stack second; public MyQueue() { - this.stackOne = new Stack<>(); - this.stackTwo = new Stack<>(); + this.first = new Stack<>(); + this.second = new Stack<>(); } public void push(int x) { - this.stackOne.push(x); + first.push(x); } public int pop() { - exchangeElements(stackOne, stackTwo); - int popped = stackTwo.pop(); - exchangeElements(stackTwo, stackOne); - return popped; + move(first, second); + int result = second.pop(); + move(second, first); + return result; } public int peek() { - exchangeElements(stackOne, stackTwo); - int peeked = stackTwo.peek(); - exchangeElements(stackTwo, stackOne); - return peeked; + move(first, second); + int result = second.peek(); + move(second, first); + return result; } public boolean empty() { - return stackOne.isEmpty(); + return first.isEmpty(); } - - private void exchangeElements(Stack stack1, Stack stack2) { - while (!stack1.isEmpty()) { - stack2.push(stack1.pop()); + + private void move(Stack from, Stack to) { + while (!from.isEmpty()) { + to.push(from.pop()); } } } From 68968bac1eeeb4e0f24937c271095903740c072a Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Mon, 29 Jan 2024 11:35:45 -0800 Subject: [PATCH 460/712] Create Find the Maximum Number of Elements in Subset.java --- ... Maximum Number of Elements in Subset.java | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) create mode 100644 Medium/Find the Maximum Number of Elements in Subset.java diff --git a/Medium/Find the Maximum Number of Elements in Subset.java b/Medium/Find the Maximum Number of Elements in Subset.java new file mode 100644 index 00000000..4c419cbc --- /dev/null +++ b/Medium/Find the Maximum Number of Elements in Subset.java @@ -0,0 +1,19 @@ +class Solution { + public int maximumLength(int[] nums) { + Map map = new HashMap<>(); + for (int num : nums) { + map.put(num, map.getOrDefault(num, 0) + 1); + } + int result = map.containsKey(1) ? (map.get(1) % 2 == 0 ? map.get(1) - 1 : map.get(1)) : 1; + for (int num : nums) { + int count = 0; + while (map.containsKey(num) && map.get(num) >= 2 && num != 1) { + count += 2; + num *= num; + } + count += map.containsKey(num) ? 1 : -1; + result = Math.max(result, count); + } + return result; + } +} From 51add04ec8213bdf8e559dc13e9acc2abfe613a3 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Tue, 30 Jan 2024 11:28:23 -0800 Subject: [PATCH 461/712] Update and rename Paint House.java to Paint House.java --- Easy/Paint House.java | 18 ------------------ Medium/Paint House.java | 15 +++++++++++++++ 2 files changed, 15 insertions(+), 18 deletions(-) delete mode 100644 Easy/Paint House.java create mode 100644 Medium/Paint House.java diff --git a/Easy/Paint House.java b/Easy/Paint House.java deleted file mode 100644 index 797243d2..00000000 --- a/Easy/Paint House.java +++ /dev/null @@ -1,18 +0,0 @@ -class Solution { - public int minCost(int[][] costs) { - if (costs.length == 0) { - return 0; - } - - for (int i=1; i Date: Tue, 30 Jan 2024 17:33:11 -0800 Subject: [PATCH 462/712] Update Daily Temperatures.java --- Medium/Daily Temperatures.java | 23 ++++++++++++----------- 1 file changed, 12 insertions(+), 11 deletions(-) diff --git a/Medium/Daily Temperatures.java b/Medium/Daily Temperatures.java index ce3bdca3..5189f7ee 100644 --- a/Medium/Daily Temperatures.java +++ b/Medium/Daily Temperatures.java @@ -1,14 +1,15 @@ class Solution { - public int[] dailyTemperatures(int[] T) { - Stack stack = new Stack<>(); - int[] ans = new int[T.length]; - for (int i = T.length - 1; i >= 0; i--) { - while (!stack.isEmpty() && T[stack.peek()] <= T[i]) { - stack.pop(); - } - ans[i] = stack.isEmpty() ? 0 : (stack.peek() - i); - stack.push(i); + public int[] dailyTemperatures(int[] temperatures) { + int n = temperatures.length; + int[] result = new int[n]; + Stack stack = new Stack<>(); + for (int i = n - 1; i >= 0; i--) { + while (!stack.isEmpty() && temperatures[i] >= temperatures[stack.peek()]) { + stack.pop(); + } + result[i] = stack.isEmpty() ? 0 : stack.peek() - i; + stack.push(i); + } + return result; } - return ans; - } } From ee38423f1584b5428766a8139ea1cf767951955e Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Thu, 1 Feb 2024 15:45:24 -0800 Subject: [PATCH 463/712] Update Flip Game.java --- Easy/Flip Game.java | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/Easy/Flip Game.java b/Easy/Flip Game.java index 75a364a0..097acf18 100644 --- a/Easy/Flip Game.java +++ b/Easy/Flip Game.java @@ -1,11 +1,11 @@ class Solution { - public List generatePossibleNextMoves(String currentState) { - List list = new ArrayList<>(); - for (int i = 1; i < currentState.length(); i++) { - if (currentState.charAt(i) == '+' && currentState.charAt(i - 1) == '+') { - list.add(currentState.substring(0, i - 1) + "--" + currentState.substring(i + 1)); - } + public List generatePossibleNextMoves(String currentState) { + List moves = new ArrayList<>(); + for (int i = 0; i < currentState.length() - 1; i++) { + if (currentState.substring(i, i + 2).equals("++")) { + moves.add(currentState.substring(0, i) + "--" + currentState.substring(i + 2)); + } + } + return moves; } - return list; - } } From ba9744b0007d0636891813045a159536116d9052 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sat, 3 Feb 2024 09:22:23 -0800 Subject: [PATCH 464/712] Create Partition Array for Maximum Sum.java --- Medium/Partition Array for Maximum Sum.java | 25 +++++++++++++++++++++ 1 file changed, 25 insertions(+) create mode 100644 Medium/Partition Array for Maximum Sum.java diff --git a/Medium/Partition Array for Maximum Sum.java b/Medium/Partition Array for Maximum Sum.java new file mode 100644 index 00000000..4868c1c3 --- /dev/null +++ b/Medium/Partition Array for Maximum Sum.java @@ -0,0 +1,25 @@ +class Solution { + public int maxSumAfterPartitioning(int[] arr, int k) { + Integer[] dp = new Integer[arr.length]; + return maxSum(arr, k, dp, 0); + } + + private int maxSum(int[] arr, int k, Integer[] dp, int start) { + int n = arr.length; + if (start >= n) { + return 0; + } + if (dp[start] != null) { + return dp[start]; + } + int currMax = 0; + int result = 0; + int end = Math.min(n, start + k); + for (int i = start; i < end; i++) { + currMax = Math.max(currMax, arr[i]); + result = Math.max(result, + currMax * (i - start + 1) + maxSum(arr, k, dp, i + 1)); + } + return dp[start] = result; + } +} From 3d8dca2a27d18271fcf80f80b6de4b20c3be03d8 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sat, 3 Feb 2024 09:30:43 -0800 Subject: [PATCH 465/712] Create Type of Triangle II.java --- Easy/Type of Triangle II.java | 15 +++++++++++++++ 1 file changed, 15 insertions(+) create mode 100644 Easy/Type of Triangle II.java diff --git a/Easy/Type of Triangle II.java b/Easy/Type of Triangle II.java new file mode 100644 index 00000000..09f0cb88 --- /dev/null +++ b/Easy/Type of Triangle II.java @@ -0,0 +1,15 @@ +class Solution { + public String triangleType(int[] nums) { + Arrays.sort(nums); + if (nums[0] + nums[1] <= nums[2]) { + return "none"; + } + if (nums[0] == nums[1] && nums[1] == nums[2]) { + return "equilateral"; + } + if (nums[0] == nums[1] || nums[1] == nums[2] || nums[0] == nums[2]) { + return "isosceles"; + } + return "scalene"; + } +} From 0e0fd4fc584279fa718e5d41dcd50799c834c671 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sat, 3 Feb 2024 17:20:24 -0800 Subject: [PATCH 466/712] Update Minimum Window Substring.java --- Hard/Minimum Window Substring.java | 66 +++++++++++++++--------------- 1 file changed, 33 insertions(+), 33 deletions(-) diff --git a/Hard/Minimum Window Substring.java b/Hard/Minimum Window Substring.java index 2e8bb271..40cfa2ce 100644 --- a/Hard/Minimum Window Substring.java +++ b/Hard/Minimum Window Substring.java @@ -1,38 +1,38 @@ class Solution { - public String minWindow(String s, String t) { - Map map = new HashMap<>(); - for (char c : t.toCharArray()) { - map.put(c, map.getOrDefault(c, 0) + 1); - } - int count = map.size(); - int start = 0; - int end = 0; - int minWindowLength = Integer.MAX_VALUE; - int minWindowStart = 0; - int minWindowEnd = 0; - while (end < s.length()) { - char c = s.charAt(end++); - if (map.containsKey(c)) { - map.put(c, map.get(c) - 1); - if (map.get(c) == 0) { - count--; - } - } - while (count == 0 && start < end) { - if (end - start < minWindowLength) { - minWindowLength = end - start; - minWindowStart = start; - minWindowEnd = end; + public String minWindow(String s, String t) { + Map map = new HashMap<>(); + for (char c : t.toCharArray()) { + map.put(c, map.getOrDefault(c, 0) + 1); } - char temp = s.charAt(start++); - if (map.containsKey(temp)) { - map.put(temp, map.get(temp) + 1); - if (map.get(temp) == 1) { - count++; - } + int targetSize = map.size(); + int start = 0; + int minLength = Integer.MAX_VALUE; + int minStart = -1; + int minEnd = -1; + int n = s.length(); + for (int i = 0; i < n; i++) { + if (map.containsKey(s.charAt(i))) { + map.put(s.charAt(i), map.get(s.charAt(i)) - 1); + if (map.get(s.charAt(i)) == 0) { + targetSize--; + } + } + while (start <= i && targetSize == 0) { + int currLength = i - start; + if (minLength > currLength) { + minLength = currLength; + minStart = start; + minEnd = i + 1; + } + if (map.containsKey(s.charAt(start))) { + map.put(s.charAt(start), map.get(s.charAt(start)) + 1); + if (map.get(s.charAt(start)) == 1) { + targetSize++; + } + } + start++; + } } - } + return minLength == Integer.MAX_VALUE ? "" : s.substring(minStart, minEnd); } - return s.substring(minWindowStart, minWindowEnd); - } } From a34609dbc45bde03ae818da284ff60751f1c2955 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 4 Feb 2024 08:36:19 -0800 Subject: [PATCH 467/712] Create Ant on the Boundary.java --- Easy/Ant on the Boundary.java | 13 +++++++++++++ 1 file changed, 13 insertions(+) create mode 100644 Easy/Ant on the Boundary.java diff --git a/Easy/Ant on the Boundary.java b/Easy/Ant on the Boundary.java new file mode 100644 index 00000000..25e95d0a --- /dev/null +++ b/Easy/Ant on the Boundary.java @@ -0,0 +1,13 @@ +class Solution { + public int returnToBoundaryCount(int[] nums) { + int currPosition = 0; + int count = 0; + for (int num : nums) { + currPosition += num; + if (currPosition == 0) { + count++; + } + } + return count; + } +} From a17462d2ec5648f87f6aebba8e697440832586a4 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Thu, 8 Feb 2024 09:36:17 -0800 Subject: [PATCH 468/712] Update and rename Paint Fence.java to Paint Fence.java --- Easy/Paint Fence.java | 12 ------------ Medium/Paint Fence.java | 20 ++++++++++++++++++++ 2 files changed, 20 insertions(+), 12 deletions(-) delete mode 100644 Easy/Paint Fence.java create mode 100644 Medium/Paint Fence.java diff --git a/Easy/Paint Fence.java b/Easy/Paint Fence.java deleted file mode 100644 index 72ea89e6..00000000 --- a/Easy/Paint Fence.java +++ /dev/null @@ -1,12 +0,0 @@ -class Solution { - public int numWays(int n, int k) { - int[] ways = new int[Math.max(n + 1, 3)]; - ways[0] = 0; - ways[1] = k; - ways[2] = k * k; - for (int i = 3; i <= n; i++) { - ways[i] = (ways[i - 1] * (k - 1)) + (ways[i - 2] * (k - 1)); - } - return ways[n]; - } -} diff --git a/Medium/Paint Fence.java b/Medium/Paint Fence.java new file mode 100644 index 00000000..39c72ffa --- /dev/null +++ b/Medium/Paint Fence.java @@ -0,0 +1,20 @@ +class Solution { + public int numWays(int n, int k) { + Map map = new HashMap<>(); + return numWays(n, k, map); + } + + private int numWays(int n, int k, Map map) { + if (n == 1) { + return k; + } + if (n == 2) { + return k * k; + } + if (map.containsKey(n)) { + return map.get(n); + } + map.put(n, (k - 1) * (numWays(n - 1, k, map) + numWays(n - 2, k, map))); + return map.get(n); + } +} From 17a14ddd732392cccb9b1cfe6fbd35b6f9e0e1c8 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 11 Feb 2024 08:35:13 -0800 Subject: [PATCH 469/712] Create Cherry Pickup II.java --- Hard/Cherry Pickup II.java | 32 ++++++++++++++++++++++++++++++++ 1 file changed, 32 insertions(+) create mode 100644 Hard/Cherry Pickup II.java diff --git a/Hard/Cherry Pickup II.java b/Hard/Cherry Pickup II.java new file mode 100644 index 00000000..1786e8cc --- /dev/null +++ b/Hard/Cherry Pickup II.java @@ -0,0 +1,32 @@ +class Solution { + public int cherryPickup(int[][] grid) { + int m = grid.length; + int n = grid[0].length; + Integer[][][] cache = new Integer[m][n][n]; + return recurse(0, 0, n - 1, grid, cache); + } + + private int recurse(int row, int colOne, int colTwo, int[][] grid, Integer[][][] cache) { + if (colOne < 0 || colOne >= grid[0].length || colTwo < 0 || colTwo >= grid[0].length) { + return 0; + } + if (cache[row][colOne][colTwo] != null) { + return cache[row][colOne][colTwo]; + } + int result = 0; + result += grid[row][colOne]; + if (colOne != colTwo) { + result += grid[row][colTwo]; + } + if (row != grid.length - 1) { + int max = 0; + for (int c1 = colOne - 1; c1 <= colOne + 1; c1++) { + for (int c2 = colTwo - 1; c2 <= colTwo + 1; c2++) { + max = Math.max(max, recurse(row + 1, c1, c2, grid, cache)); + } + } + result += max; + } + return cache[row][colOne][colTwo] = result; + } +} From 35f002278987a3c1a67ef84799bfc07172c0f181 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 11 Feb 2024 08:44:51 -0800 Subject: [PATCH 470/712] Create Modify the Matrix.java --- Easy/Modify the Matrix.java | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) create mode 100644 Easy/Modify the Matrix.java diff --git a/Easy/Modify the Matrix.java b/Easy/Modify the Matrix.java new file mode 100644 index 00000000..f238aa68 --- /dev/null +++ b/Easy/Modify the Matrix.java @@ -0,0 +1,16 @@ +class Solution { + public int[][] modifiedMatrix(int[][] matrix) { + int rows = matrix.length; + int cols = matrix[0].length; + for (int c = 0; c < cols; c++) { + int max = -1; + for (int r = 0; r < rows; r++) { + max = Math.max(max, matrix[r][c]); + } + for (int r = 0; r < rows; r++) { + matrix[r][c] = matrix[r][c] == -1 ? max : matrix[r][c]; + } + } + return matrix; + } +} From 21490738b68c45bcdf1555a024afbbd73790d4f7 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Mon, 12 Feb 2024 16:23:24 -0800 Subject: [PATCH 471/712] Update Find First Palindromic String in the Array.java --- .../Find First Palindromic String in the Array.java | 13 ++++++------- 1 file changed, 6 insertions(+), 7 deletions(-) diff --git a/Easy/Find First Palindromic String in the Array.java b/Easy/Find First Palindromic String in the Array.java index ba990c09..e215ab8d 100644 --- a/Easy/Find First Palindromic String in the Array.java +++ b/Easy/Find First Palindromic String in the Array.java @@ -1,9 +1,8 @@ class Solution { - public String firstPalindrome(String[] words) { - return Arrays.stream(words).filter(Solution::isPalindrome).findFirst().orElse(""); - } - - public static boolean isPalindrome(String s) { - return new StringBuilder().append(s).reverse().toString().equals(s); - } + public String firstPalindrome(String[] words) { + return Arrays.stream(words) + .filter(word -> word.equals(new StringBuilder(word).reverse().toString())) + .findFirst() + .orElse(""); + } } From e9713200867ee54d79dcd980c35754a893f4bde7 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Tue, 13 Feb 2024 18:44:00 -0800 Subject: [PATCH 472/712] Update Rearrange Array Elements by Sign.java --- Medium/Rearrange Array Elements by Sign.java | 33 +++++++++----------- 1 file changed, 15 insertions(+), 18 deletions(-) diff --git a/Medium/Rearrange Array Elements by Sign.java b/Medium/Rearrange Array Elements by Sign.java index d2eb68e7..83857f13 100644 --- a/Medium/Rearrange Array Elements by Sign.java +++ b/Medium/Rearrange Array Elements by Sign.java @@ -1,21 +1,18 @@ class Solution { - public int[] rearrangeArray(int[] nums) { - List positive = new ArrayList<>(); - List negative = new ArrayList<>(); - for (int num : nums) { - if (num > 0) { - positive.add(num); - } else { - negative.add(num); - } + public int[] rearrangeArray(int[] nums) { + int n = nums.length; + int[] result = new int[n]; + int posIndex = 0; + int negIndex = 1; + for (int i = 0; i < n; i++) { + if (nums[i] > 0) { + result[posIndex] = nums[i]; + posIndex += 2; + } else { + result[negIndex] = nums[i]; + negIndex += 2; + } + } + return result; } - int positiveIdx = 0; - int negativeIdx = 0; - boolean positiveFlag = true; - for (int i = 0; i < nums.length; i++) { - nums[i] = positiveFlag ? positive.get(positiveIdx++) : negative.get(negativeIdx++); - positiveFlag = !positiveFlag; - } - return nums; - } } From 44b4003e764421409f071f0f4ee2367cdf65af6f Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Thu, 15 Feb 2024 07:51:41 -0800 Subject: [PATCH 473/712] Create Find Polygon With the Largest Perimeter.java --- .../Find Polygon With the Largest Perimeter.java | 15 +++++++++++++++ 1 file changed, 15 insertions(+) create mode 100644 Medium/Find Polygon With the Largest Perimeter.java diff --git a/Medium/Find Polygon With the Largest Perimeter.java b/Medium/Find Polygon With the Largest Perimeter.java new file mode 100644 index 00000000..8b368cb2 --- /dev/null +++ b/Medium/Find Polygon With the Largest Perimeter.java @@ -0,0 +1,15 @@ +class Solution { + public long largestPerimeter(int[] nums) { + Arrays.sort(nums); + int n = nums.length; + long prefixSum = 0; + long result = -1; + for (int i = 0; i < n; i++) { + if (i >= 2 && nums[i] < prefixSum) { + result = nums[i] + prefixSum; + } + prefixSum += nums[i]; + } + return result; + } +} From 93ab03af6feba7c6fe6653a97c7224f71fcc1318 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Thu, 15 Feb 2024 08:18:50 -0800 Subject: [PATCH 474/712] Update Remove Interval.java --- Medium/Remove Interval.java | 47 ++++++++++++++++++++++++++----------- 1 file changed, 33 insertions(+), 14 deletions(-) diff --git a/Medium/Remove Interval.java b/Medium/Remove Interval.java index 0405621d..e64370e0 100644 --- a/Medium/Remove Interval.java +++ b/Medium/Remove Interval.java @@ -1,18 +1,37 @@ class Solution { - public List> removeInterval(int[][] intervals, int[] toBeRemoved) { - List> result = new ArrayList<>(); - for (int[] interval : intervals) { - if (interval[0] > toBeRemoved[1] || interval[1] < toBeRemoved[0]) { - result.add(Arrays.asList(interval[0], interval[1])); - } else { - if (interval[0] < toBeRemoved[0]) { - result.add(Arrays.asList(interval[0], toBeRemoved[0])); + public List> removeInterval(int[][] intervals, int[] toBeRemoved) { + List> result = new ArrayList<>(); + int n = intervals.length; + int removeStart = toBeRemoved[0]; + int removeEnd = toBeRemoved[1]; + for (int i = 0; i < n; i++) { + int currStart = intervals[i][0]; + int currEnd = intervals[i][1]; + // complete overlap hence skipping complete interval + if (currStart >= removeStart && currEnd <= removeEnd) { + continue; + } + // no overlap hence adding complete interval + if ((currStart <= removeStart && currEnd <= removeStart) || (currStart >= removeEnd && currEnd >= removeEnd)) { + result.add(List.of(currStart, currEnd)); + continue; + } + // partial overlaps + if (currStart <= removeStart) { + int newStart = Math.min(currStart, removeStart); + int newEnd = Math.max(currStart, removeStart); + if (newStart != newEnd) { + result.add(List.of(newStart, newEnd)); + } + } + if (currEnd >= removeEnd) { + int newStart = Math.min(currEnd, removeEnd); + int newEnd = Math.max(currEnd, removeEnd); + if (newStart != newEnd) { + result.add(List.of(newStart, newEnd)); + } + } } - if (interval[1] > toBeRemoved[1]) { - result.add(Arrays.asList(toBeRemoved[1], interval[1])); - } - } + return result; } - return result; - } } From 27c4b6e881ec76385a72b729b47d0859be16f69b Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Fri, 16 Feb 2024 07:40:47 -0800 Subject: [PATCH 475/712] Update Least Number of Unique Integers after K Removals.java --- ...r of Unique Integers after K Removals.java | 41 ++++++++----------- 1 file changed, 16 insertions(+), 25 deletions(-) diff --git a/Medium/Least Number of Unique Integers after K Removals.java b/Medium/Least Number of Unique Integers after K Removals.java index 30b56fac..c6755d8e 100644 --- a/Medium/Least Number of Unique Integers after K Removals.java +++ b/Medium/Least Number of Unique Integers after K Removals.java @@ -1,28 +1,19 @@ class Solution { - public int findLeastNumOfUniqueInts(int[] arr, int k) { - Map map = new HashMap<>(); - List list = new ArrayList<>(); - for (int num : arr) { - if (!map.containsKey(num)) { - list.add(num); - } - map.put(num, map.getOrDefault(num, 0) + 1); + public int findLeastNumOfUniqueInts(int[] arr, int k) { + Map map = new HashMap<>(); + for (int num : arr) { + map.put(num, map.getOrDefault(num, 0) + 1); + } + PriorityQueue pq = new PriorityQueue<>((a, b) -> map.get(a).compareTo(map.get(b))); + pq.addAll(map.keySet()); + while (k > 0 && !pq.isEmpty()) { + int count = map.get(pq.peek()); + if (count > k) { + break; + } + k -= count; + pq.poll(); + } + return pq.size(); } - Collections.sort(list, new Comparator(){ - public int compare(Integer o1, Integer o2) { - return map.get(o1) - map.get(o2); - } - }); - for (Integer num : list) { - int count = map.get(num); - k -= count; - if (k >= 0) { - map.remove(num); - } - else { - break; - } - } - return map.size(); - } } From d39e2e130ed7d4bc456ccfce11ba7a41a5f410be Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sat, 17 Feb 2024 08:33:11 -0800 Subject: [PATCH 476/712] Update Furthest Building You Can Reach.java --- Medium/Furthest Building You Can Reach.java | 30 +++++++++++---------- 1 file changed, 16 insertions(+), 14 deletions(-) diff --git a/Medium/Furthest Building You Can Reach.java b/Medium/Furthest Building You Can Reach.java index 2c901072..1e110678 100644 --- a/Medium/Furthest Building You Can Reach.java +++ b/Medium/Furthest Building You Can Reach.java @@ -1,18 +1,20 @@ class Solution { - public int furthestBuilding(int[] heights, int bricks, int ladders) { - PriorityQueue pq = new PriorityQueue<>(); - for (int i = 1; i < heights.length; i++) { - int diff = heights[i] - heights[i - 1]; - if (diff > 0) { - pq.add(diff); - if (pq.size() > ladders) { - bricks -= pq.poll(); + public int furthestBuilding(int[] heights, int bricks, int ladders) { + PriorityQueue pq = new PriorityQueue<>((a, b) -> b - a); + for (int i = 1; i < heights.length; i++) { + int diff = heights[i] - heights[i - 1]; + if (diff > 0) { + pq.add(diff); + bricks -= diff; + if (bricks < 0) { + if (ladders == 0) { + return i - 1; + } + ladders--; + bricks += pq.poll(); + } + } } - if (bricks < 0) { - return i - 1; - } - } + return heights.length - 1; } - return heights.length - 1; - } } From 6a44f83154dbdb7757dad9f585403e8002cdefd6 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sat, 17 Feb 2024 09:05:35 -0800 Subject: [PATCH 477/712] Create Maximum Number of Operations With the Same Score I.java --- ...umber of Operations With the Same Score I.java | 15 +++++++++++++++ 1 file changed, 15 insertions(+) create mode 100644 Easy/Maximum Number of Operations With the Same Score I.java diff --git a/Easy/Maximum Number of Operations With the Same Score I.java b/Easy/Maximum Number of Operations With the Same Score I.java new file mode 100644 index 00000000..22f6648d --- /dev/null +++ b/Easy/Maximum Number of Operations With the Same Score I.java @@ -0,0 +1,15 @@ +class Solution { + public int maxOperations(int[] nums) { + int score = -1; + int operations = 0; + for (int i = 0; i <= nums.length - 2; i += 2) { + int currScore = nums[i] + nums[i + 1]; + if (score != -1 && score != currScore) { + break; + } + score = currScore; + operations++; + } + return operations; + } +} From e84e665fe0f5a8cf8ff7462b24f4146839f6d9a4 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sat, 17 Feb 2024 14:13:07 -0800 Subject: [PATCH 478/712] Create Apply Operations to Make String Empty.java --- .../Apply Operations to Make String Empty.java | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) create mode 100644 Medium/Apply Operations to Make String Empty.java diff --git a/Medium/Apply Operations to Make String Empty.java b/Medium/Apply Operations to Make String Empty.java new file mode 100644 index 00000000..c378a060 --- /dev/null +++ b/Medium/Apply Operations to Make String Empty.java @@ -0,0 +1,18 @@ +class Solution { + public String lastNonEmptyString(String s) { + Map map = new HashMap<>(); + int maxFrequency = 0; + for (int i = 0; i < s.length(); i++) { + map.put(s.charAt(i), map.getOrDefault(s.charAt(i), 0) + 1); + maxFrequency = Math.max(maxFrequency, map.get(s.charAt(i))); + } + StringBuilder result = new StringBuilder(); + for (int i = s.length() - 1; i >= 0; i--) { + if (map.get(s.charAt(i)) == maxFrequency) { + result.append(s.charAt(i)); + map.put(s.charAt(i), map.get(s.charAt(i)) - 1); + } + } + return result.reverse().toString(); + } +} From fb2b1babb63940655fd664a7b394652c44d0b6e9 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 18 Feb 2024 13:22:50 -0800 Subject: [PATCH 479/712] Create Meeting Rooms III.java --- Hard/Meeting Rooms III.java | 31 +++++++++++++++++++++++++++++++ 1 file changed, 31 insertions(+) create mode 100644 Hard/Meeting Rooms III.java diff --git a/Hard/Meeting Rooms III.java b/Hard/Meeting Rooms III.java new file mode 100644 index 00000000..48167f8c --- /dev/null +++ b/Hard/Meeting Rooms III.java @@ -0,0 +1,31 @@ +class Solution { + public int mostBooked(int n, int[][] meetings) { + Arrays.sort(meetings, Comparator.comparingInt(o -> o[0])); + PriorityQueue ongoingMeetings = new PriorityQueue<>(Comparator.comparingInt(a -> a[0])); + int[] frequency = new int[n]; + PriorityQueue pq = new PriorityQueue<>((o1, o2) -> o1[0] == o2[0] ? (int) (o1[1] - o2[1]) : (int) (o1[0] - o2[0])); + for (int i = 0; i < n; i++) { + pq.add(new long[]{0, i}); + } + for (int[] meeting : meetings) { + int startTime = meeting[0]; + while (pq.peek()[0] < startTime) { + pq.add(new long[]{startTime, pq.poll()[1]}); + } + long[] finishedMeeting = pq.poll(); + int room = (int) finishedMeeting[1]; + long endTime = finishedMeeting[0] + (meeting[1] - meeting[0]); + frequency[room]++; + pq.add(new long[]{endTime, room}); + } + int maxCount = 0; + int roomWithMaxCount = 0; + for (int i = 0; i < n; i++) { + if (frequency[i] > maxCount) { + maxCount = frequency[i]; + roomWithMaxCount = i; + } + } + return roomWithMaxCount; + } +} From cb1e04e3a9d3add7f138f9cbf7668db4cb86714c Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Mon, 19 Feb 2024 09:28:35 -0800 Subject: [PATCH 480/712] Create Count Prefix and Suffix Pairs I.java --- Easy/Count Prefix and Suffix Pairs I.java | 14 ++++++++++++++ 1 file changed, 14 insertions(+) create mode 100644 Easy/Count Prefix and Suffix Pairs I.java diff --git a/Easy/Count Prefix and Suffix Pairs I.java b/Easy/Count Prefix and Suffix Pairs I.java new file mode 100644 index 00000000..919d41d1 --- /dev/null +++ b/Easy/Count Prefix and Suffix Pairs I.java @@ -0,0 +1,14 @@ +class Solution { + public int countPrefixSuffixPairs(String[] words) { + int count = 0; + for (int i = 0; i < words.length; i++) { + String target = words[i]; + for (int j = i + 1; j < words.length; j++) { + if (words[j].startsWith(target) && words[j].endsWith(target)) { + count++; + } + } + } + return count; + } +} From 97306e9c4c504de09d9e22dec3f9b9a6ec8e40f1 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Tue, 20 Feb 2024 07:25:19 -0800 Subject: [PATCH 481/712] Create Find the Length of the Longest Common Prefix.java --- ...e Length of the Longest Common Prefix.java | 52 +++++++++++++++++++ 1 file changed, 52 insertions(+) create mode 100644 Medium/Find the Length of the Longest Common Prefix.java diff --git a/Medium/Find the Length of the Longest Common Prefix.java b/Medium/Find the Length of the Longest Common Prefix.java new file mode 100644 index 00000000..a626cd3a --- /dev/null +++ b/Medium/Find the Length of the Longest Common Prefix.java @@ -0,0 +1,52 @@ +class Solution { + public int longestCommonPrefix(int[] arr1, int[] arr2) { + TrieNodeManager nodeManager = new TrieNodeManager(); + for (int num : arr1) { + nodeManager.index(String.valueOf(num)); + } + int maxLength = 0; + for (int num : arr2) { + int length = nodeManager.find(String.valueOf(num)); + maxLength = Math.max(maxLength, length); + } + return maxLength; + } + + private static class TrieNodeManager { + + private Node root; + + public TrieNodeManager() { + this.root = new Node(); + } + + public void index(String s) { + Node curr = root; + for (char c : s.toCharArray()) { + if (!curr.children.containsKey(c)) { + curr.children.put(c, new Node()); + } + curr = curr.children.get(c); + } + } + + public int find(String s) { + Node curr = root; + for (int i = 0; i < s.length(); i++) { + if (!curr.children.containsKey(s.charAt(i))) { + return i; + } + curr = curr.children.get(s.charAt(i)); + } + return s.length(); + } + + class Node { + Map children; + + public Node() { + this.children = new HashMap<>(); + } + } + } +} From 4422419e6f9e31a87188c8ec4fedc064a1956d6f Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sat, 24 Feb 2024 14:01:33 -0800 Subject: [PATCH 482/712] Create Find All People With Secret.java --- Hard/Find All People With Secret.java | 39 +++++++++++++++++++++++++++ 1 file changed, 39 insertions(+) create mode 100644 Hard/Find All People With Secret.java diff --git a/Hard/Find All People With Secret.java b/Hard/Find All People With Secret.java new file mode 100644 index 00000000..b18f289a --- /dev/null +++ b/Hard/Find All People With Secret.java @@ -0,0 +1,39 @@ +class Solution { + public List findAllPeople(int n, int[][] meetings, int firstPerson) { + Map> graph = new HashMap<>(); + for (int[] meeting : meetings) { + int x = meeting[0]; + int y = meeting[1]; + int time = meeting[2]; + graph.computeIfAbsent(x, k -> new ArrayList<>()).add(new int[]{time, y}); + graph.computeIfAbsent(y, k -> new ArrayList<>()).add(new int[]{time, x}); + } + int[] earliestTime = new int[n]; + Arrays.fill(earliestTime, Integer.MAX_VALUE); + earliestTime[0] = 0; + earliestTime[firstPerson] = 0; + Queue queue = new LinkedList<>(); + queue.add(new int[]{0, 0}); + queue.add(new int[]{firstPerson, 0}); + while (!queue.isEmpty()) { + int[] removed = queue.poll(); + int person = removed[0]; + int time = removed[1]; + for (int[] conn : graph.getOrDefault(person, new ArrayList<>())) { + int t = conn[0]; + int p = conn[1]; + if (t >= time && earliestTime[p] > t) { + earliestTime[p] = t; + queue.add(new int[]{p, t}); + } + } + } + List result = new ArrayList<>(); + for (int i = 0; i < n; i++) { + if (earliestTime[i] != Integer.MAX_VALUE) { + result.add(i); + } + } + return result; + } +} From 4aef2f9bf3a0d8ad311bc2aba12aaa760fa81944 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 25 Feb 2024 13:15:29 -0800 Subject: [PATCH 483/712] Create Greatest Common Divisor Traversal.java --- Hard/Greatest Common Divisor Traversal.java | 80 +++++++++++++++++++++ 1 file changed, 80 insertions(+) create mode 100644 Hard/Greatest Common Divisor Traversal.java diff --git a/Hard/Greatest Common Divisor Traversal.java b/Hard/Greatest Common Divisor Traversal.java new file mode 100644 index 00000000..81ab07de --- /dev/null +++ b/Hard/Greatest Common Divisor Traversal.java @@ -0,0 +1,80 @@ +class Solution { + + private static final int MAX = 100_000; + + public boolean canTraverseAllPairs(int[] nums) { + int n = nums.length; + if (n == 1) { + return true; + } + boolean[] exists = new boolean[MAX + 1]; + for (int num : nums) { + exists[num] = true; + } + if (exists[1]) { + return false; + } + int[] sieve = new int[MAX + 1]; + for (int i = 2; i <= MAX; i++) { + if (sieve[i] == 0) { + for (int j = i; j <= MAX; j += i) { + sieve[j] = i; + } + } + } + Union union = new Union(2 * MAX + 1); + for (int num : nums) { + int curr = num; + while (curr > 1) { + int prime = sieve[curr]; + int root = prime + MAX; + if (union.find(root) != union.find(num)) { + union.merge(root, num); + } + while (curr % prime == 0) { + curr /= prime; + } + } + } + int count = 0; + for (int i = 2; i <= MAX; i++) { + if (exists[i] && union.find(i) == i) { + count++; + } + } + return count == 1; + } + + private class Union { + private final int[] union; + private final int[] size; + + public Union(int n) { + this.union = new int[n + 1]; + this.size = new int[n + 1]; + for (int i = 0; i <= n; i++) { + union[i] = i; + size[i] = 1; + } + } + + public int find(int num) { + return union[num] == num ? num : (union[num] = find(union[num])); + } + + public void merge(int x, int y) { + int findX = find(x); + int findY = find(y); + if (findX == findY) { + return; + } + if (size[findX] > size[findY]) { + int temp = findX; + findX = findY; + findY = temp; + } + union[findX] = findY; + size[findY] += size[findX]; + } + } +} From 252eda75201e61ac7b6ecb3173725ceee8cb22f9 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 25 Feb 2024 15:41:18 -0800 Subject: [PATCH 484/712] Create Split the Array.java --- Easy/Split the Array.java | 10 ++++++++++ 1 file changed, 10 insertions(+) create mode 100644 Easy/Split the Array.java diff --git a/Easy/Split the Array.java b/Easy/Split the Array.java new file mode 100644 index 00000000..607a2de0 --- /dev/null +++ b/Easy/Split the Array.java @@ -0,0 +1,10 @@ +class Solution { + public boolean isPossibleToSplit(int[] nums) { + return Arrays.stream(nums) + .boxed() + .collect(Collectors.groupingBy(Function.identity(), HashMap::new, Collectors.counting())) + .values() + .stream() + .allMatch(v -> v <= 2); + } +} From 1743d9da0de4b2a368612ff63d99ec878da0447d Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 25 Feb 2024 16:55:42 -0800 Subject: [PATCH 485/712] Update Tree Diameter.java --- Medium/Tree Diameter.java | 63 ++++++++++++++++++++------------------- 1 file changed, 33 insertions(+), 30 deletions(-) diff --git a/Medium/Tree Diameter.java b/Medium/Tree Diameter.java index 28dca810..87d5eab9 100644 --- a/Medium/Tree Diameter.java +++ b/Medium/Tree Diameter.java @@ -1,36 +1,39 @@ class Solution { - public int treeDiameter(int[][] edges) { - Map> graph = new HashMap<>(); - for (int[] edge : edges) { - graph.computeIfAbsent(edge[0], k -> new ArrayList<>()).add(edge[1]); - graph.computeIfAbsent(edge[1], k -> new ArrayList<>()).add(edge[0]); + public int treeDiameter(int[][] edges) { + int n = edges.length; + List> graph = new ArrayList<>(); + boolean[] visited = new boolean[n + 1]; + for (int i = 0; i < n + 1; i++) { + graph.add(new HashSet<>()); + } + for (int[] edge : edges) { + int nodeOne = edge[0]; + int nodeTwo = edge[1]; + graph.get(nodeOne).add(nodeTwo); + graph.get(nodeTwo).add(nodeOne); + } + int[] diameter = {0}; + dfs(0, visited, graph, diameter); + return diameter[0]; } - int farthestNode = bfsHelper(graph, 0)[0]; - return bfsHelper(graph, farthestNode)[1]; - } - private int[] bfsHelper(Map> graph, int node) { - int farthestNode = 0; - int steps = 0; - Queue queue = new LinkedList<>(); - queue.add(node); - Set visited = new HashSet<>(); - while (!queue.isEmpty()) { - int size = queue.size(); - while (size-- > 0) { - int removedNode = queue.remove(); - visited.add(removedNode); - farthestNode = removedNode; - for (Integer peer : graph.getOrDefault(removedNode, new ArrayList<>())) { - if (!visited.contains(peer)) { - queue.add(peer); - } + private int dfs(int node, boolean[] visited, List> graph, int[] diameter) { + int highestDistance = 0; + int secondHighestDistance = 0; + visited[node] = true; + for (Integer conn : graph.get(node)) { + int distance = 0; + if (!visited[conn]) { + distance = 1 + dfs(conn, visited, graph, diameter); + } + if (distance > highestDistance) { + secondHighestDistance = highestDistance; + highestDistance = distance; + } else if (distance > secondHighestDistance) { + secondHighestDistance = distance; + } } - } - if (!queue.isEmpty()) { - steps++; - } + diameter[0] = Math.max(diameter[0], highestDistance + secondHighestDistance); + return highestDistance; } - return new int[]{farthestNode, steps}; - } } From f57b3dbaccdc73c0b0f467c89bcd6066ae298008 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Wed, 28 Feb 2024 19:09:51 -0800 Subject: [PATCH 486/712] Update Even Odd Tree.java --- Medium/Even Odd Tree.java | 55 ++++++++++++++++++--------------------- 1 file changed, 25 insertions(+), 30 deletions(-) diff --git a/Medium/Even Odd Tree.java b/Medium/Even Odd Tree.java index 0d3a4886..574ddf6b 100644 --- a/Medium/Even Odd Tree.java +++ b/Medium/Even Odd Tree.java @@ -14,36 +14,31 @@ * } */ class Solution { - public boolean isEvenOddTree(TreeNode root) { - Queue queue = new LinkedList<>(); - queue.add(root); - int remainderExpected = 1; - while (!queue.isEmpty()) { - int size = queue.size(); - Integer prev = null; - while (size-- > 0) { - TreeNode removed = queue.remove(); - if (removed.val % 2 != remainderExpected) { - return false; + public boolean isEvenOddTree(TreeNode root) { + Queue queue = new LinkedList<>(); + queue.add(root); + boolean even = true; + while (!queue.isEmpty()) { + int size = queue.size(); + int prev = even ? Integer.MIN_VALUE : Integer.MAX_VALUE; + while (size-- > 0) { + TreeNode removed = queue.remove(); + if ((even && removed.val % 2 == 0) || (!even && removed.val % 2 != 0)) { + return false; + } + if ((even && removed.val <= prev) || (!even && removed.val >= prev)) { + return false; + } + prev = removed.val; + if (removed.left != null) { + queue.add(removed.left); + } + if (removed.right != null) { + queue.add(removed.right); + } + } + even = !even; } - if (prev != null) { - if (remainderExpected == 1 && removed.val <= prev) { - return false; - } - if (remainderExpected == 0 && removed.val >= prev) { - return false; - } - } - prev = removed.val; - if (removed.left != null) { - queue.add(removed.left); - } - if (removed.right != null) { - queue.add(removed.right); - } - } - remainderExpected = remainderExpected == 1 ? 0 : 1; + return true; } - return true; - } } From 1f6ead115dcbd62dab8dd3dc29110146a7398266 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Thu, 29 Feb 2024 18:06:03 -0800 Subject: [PATCH 487/712] Create Winner of the Linked List Game.java --- Easy/Winner of the Linked List Game.java | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+) create mode 100644 Easy/Winner of the Linked List Game.java diff --git a/Easy/Winner of the Linked List Game.java b/Easy/Winner of the Linked List Game.java new file mode 100644 index 00000000..198fdd75 --- /dev/null +++ b/Easy/Winner of the Linked List Game.java @@ -0,0 +1,23 @@ +/** + * Definition for singly-linked list. + * public class ListNode { + * int val; + * ListNode next; + * ListNode() {} + * ListNode(int val) { this.val = val; } + * ListNode(int val, ListNode next) { this.val = val; this.next = next; } + * } + */ +class Solution { + public String gameResult(ListNode head) { + ListNode curr = head; + int count = 0; + while (curr != null) { + int even = curr.val; + int odd = curr.next.val; + count += even == odd ? 0 : (even > odd ? 1 : -1); + curr = curr.next.next; + } + return count == 0 ? "Tie" : (count > 0 ? "Even" : "Odd"); + } +} From e3de53f51a0f667f77047d6d2f4a74528aac578d Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sat, 2 Mar 2024 10:15:32 -0800 Subject: [PATCH 488/712] Update Squares of a Sorted Array.java --- Easy/Squares of a Sorted Array.java | 36 +++++++++++------------------ 1 file changed, 14 insertions(+), 22 deletions(-) diff --git a/Easy/Squares of a Sorted Array.java b/Easy/Squares of a Sorted Array.java index 046fcf9c..08f5faa6 100644 --- a/Easy/Squares of a Sorted Array.java +++ b/Easy/Squares of a Sorted Array.java @@ -1,26 +1,18 @@ class Solution { - public int[] sortedSquares(int[] nums) { - int negativeIdx = 0; - int positiveIdx = nums.length - 1; - int[] result = new int[nums.length]; - int resultIdx = nums.length - 1; - while(resultIdx >= 0) { - if (nums[negativeIdx] < 0 && nums[positiveIdx] >= 0) { - if (Math.abs(nums[negativeIdx]) > nums[positiveIdx]) { - result[resultIdx--] = nums[negativeIdx] * nums[negativeIdx]; - negativeIdx++; - } else { - result[resultIdx--] = nums[positiveIdx] * nums[positiveIdx]; - positiveIdx--; + public int[] sortedSquares(int[] nums) { + int n = nums.length; + int start = 0; + int end = n - 1; + int[] result = new int[n]; + for (int i = n - 1; i >= 0; i--) { + if (Math.abs(nums[start]) >= Math.abs(nums[end])) { + result[i] = nums[start] * nums[start]; + start++; + } else { + result[i] = nums[end] * nums[end]; + end--; + } } - } else if (nums[negativeIdx] < 0 && nums[positiveIdx] < 0) { - result[resultIdx--] = nums[negativeIdx] * nums[negativeIdx]; - negativeIdx++; - } else { - result[resultIdx--] = nums[positiveIdx] * nums[positiveIdx]; - positiveIdx--; - } + return result; } - return result; - } } From 92e8246b5ef50a7836df342cfc4501945a34e75a Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sat, 2 Mar 2024 13:59:35 -0800 Subject: [PATCH 489/712] Create Minimum Operations to Exceed Threshold Value I.java --- ...um Operations to Exceed Threshold Value I.java | 15 +++++++++++++++ 1 file changed, 15 insertions(+) create mode 100644 Easy/Minimum Operations to Exceed Threshold Value I.java diff --git a/Easy/Minimum Operations to Exceed Threshold Value I.java b/Easy/Minimum Operations to Exceed Threshold Value I.java new file mode 100644 index 00000000..6f792f07 --- /dev/null +++ b/Easy/Minimum Operations to Exceed Threshold Value I.java @@ -0,0 +1,15 @@ +class Solution { + public int minOperations(int[] nums, int k) { + Map map = new HashMap<>(); + for (int num : nums) { + map.put(num, map.getOrDefault(num, 0) + 1); + } + PriorityQueue pq = new PriorityQueue<>(); + pq.addAll(map.keySet()); + int count = 0; + while (!pq.isEmpty() && pq.peek() < k) { + count += map.get(pq.poll()); + } + return count; + } +} From db0976a8fdac0400635473c7baf879afe4d1bfcc Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 3 Mar 2024 10:27:35 -0800 Subject: [PATCH 490/712] Create Distribute Elements Into Two Arrays I.java --- ...Distribute Elements Into Two Arrays I.java | 26 +++++++++++++++++++ 1 file changed, 26 insertions(+) create mode 100644 Easy/Distribute Elements Into Two Arrays I.java diff --git a/Easy/Distribute Elements Into Two Arrays I.java b/Easy/Distribute Elements Into Two Arrays I.java new file mode 100644 index 00000000..9b4bd7d1 --- /dev/null +++ b/Easy/Distribute Elements Into Two Arrays I.java @@ -0,0 +1,26 @@ +class Solution { + public int[] resultArray(int[] nums) { + int start = 0; + int end = nums.length - 1; + int[] result = new int[nums.length]; + result[start++] = nums[0]; + result[end--] = nums[1]; + for (int i = 2; i < nums.length; i++) { + if (result[start - 1] > result[end + 1]) { + result[start++] = nums[i]; + } else { + result[end--] = nums[i]; + } + } + int left = end + 1; + int right = nums.length - 1; + while (left < right) { + int temp = result[left]; + result[left] = result[right]; + result[right] = temp; + left++; + right--; + } + return result; + } +} From 72203227b5ac66f2bf797225432a1cff1f3e35c4 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 3 Mar 2024 16:54:35 -0800 Subject: [PATCH 491/712] Update Bag of Tokens.java --- Medium/Bag of Tokens.java | 38 +++++++++++++++++++------------------- 1 file changed, 19 insertions(+), 19 deletions(-) diff --git a/Medium/Bag of Tokens.java b/Medium/Bag of Tokens.java index d86085c3..1a409e0c 100644 --- a/Medium/Bag of Tokens.java +++ b/Medium/Bag of Tokens.java @@ -1,23 +1,23 @@ class Solution { - public int bagOfTokensScore(int[] tokens, int power) { - int score = 0; - Arrays.sort(tokens); - int leftIdx = 0; - int rightIdx = tokens.length - 1; - int currScore = 0; - while (leftIdx <= rightIdx) { - if (power >= tokens[leftIdx]) { - currScore++; - power -= tokens[leftIdx++]; - } else { - if (currScore == 0) { - break; + public int bagOfTokensScore(int[] tokens, int power) { + int score = 0; + int currScore = 0; + Arrays.sort(tokens); + int left = 0; + int right = tokens.length - 1; + while (left <= right) { + if (power >= tokens[left]) { + currScore++; + power -= tokens[left++]; + } else { + if (currScore == 0) { + break; + } + currScore--; + power += tokens[right--]; + } + score = Math.max(score, currScore); } - currScore--; - power += tokens[rightIdx--]; - } - score = Math.max(score, currScore); + return score; } - return score; - } } From 2c002d2b2318319224e92cad2f06ea1eea6dc2e9 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Mon, 4 Mar 2024 18:27:00 -0800 Subject: [PATCH 492/712] Create Minimum Length of String After Deleting Similar Ends.java --- ...h of String After Deleting Similar Ends.java | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) create mode 100644 Medium/Minimum Length of String After Deleting Similar Ends.java diff --git a/Medium/Minimum Length of String After Deleting Similar Ends.java b/Medium/Minimum Length of String After Deleting Similar Ends.java new file mode 100644 index 00000000..bc1c6c89 --- /dev/null +++ b/Medium/Minimum Length of String After Deleting Similar Ends.java @@ -0,0 +1,17 @@ +class Solution { + public int minimumLength(String s) { + int start = 0; + int end = s.length() - 1; + while (start < end && s.charAt(start) == s.charAt(end)) { + char startChar = s.charAt(start); + char endChar = s.charAt(end); + while (start <= end && s.charAt(start) == startChar) { + start++; + } + while (end > start && s.charAt(end) == endChar) { + end--; + } + } + return end - start + 1; + } +} From 8c7400fb11c6eb1b5964d89374021a6292f0c0aa Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Fri, 8 Mar 2024 06:34:57 -0800 Subject: [PATCH 493/712] Create Linked List Frequency.java --- Medium/Linked List Frequency.java | 25 +++++++++++++++++++++++++ 1 file changed, 25 insertions(+) create mode 100644 Medium/Linked List Frequency.java diff --git a/Medium/Linked List Frequency.java b/Medium/Linked List Frequency.java new file mode 100644 index 00000000..1c5a1739 --- /dev/null +++ b/Medium/Linked List Frequency.java @@ -0,0 +1,25 @@ +/** + * Definition for singly-linked list. + * public class ListNode { + * int val; + * ListNode next; + * ListNode() {} + * ListNode(int val) { this.val = val; } + * ListNode(int val, ListNode next) { this.val = val; this.next = next; } + * } + */ +class Solution { + public ListNode frequenciesOfElements(ListNode head) { + Map map = new HashMap<>(); + for (ListNode curr = head; curr != null; curr = curr.next) { + map.put(curr.val, map.getOrDefault(curr.val, 0) + 1); + } + ListNode dummy = new ListNode(-1); + ListNode curr = dummy; + for (Integer key : map.keySet()) { + curr.next = new ListNode(map.get(key)); + curr = curr.next; + } + return dummy.next; + } +} From 4ecc1187000ae9cd7d8eb20cd84265081c11ba5c Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sat, 9 Mar 2024 16:21:59 -0800 Subject: [PATCH 494/712] Update Intersection of Two Arrays.java --- Easy/Intersection of Two Arrays.java | 27 +++++---------------------- 1 file changed, 5 insertions(+), 22 deletions(-) diff --git a/Easy/Intersection of Two Arrays.java b/Easy/Intersection of Two Arrays.java index d05f4468..24a47d60 100644 --- a/Easy/Intersection of Two Arrays.java +++ b/Easy/Intersection of Two Arrays.java @@ -1,25 +1,8 @@ class Solution { - public int[] intersection(int[] nums1, int[] nums2) { - boolean[][] found = new boolean[1001][2]; - for (int num : nums1) { - found[num][0] = true; + public int[] intersection(int[] nums1, int[] nums2) { + Set set1 = Arrays.stream(nums1).boxed().collect(Collectors.toSet()); + Set set2 = Arrays.stream(nums2).boxed().collect(Collectors.toSet()); + set1.retainAll(set2); + return set1.stream().mapToInt(Integer::intValue).toArray(); } - int count = 0; - for (int num : nums2) { - if (!found[num][1]) { - if (found[num][0]) { - count++; - } - } - found[num][1] = true; - } - int[] result = new int[count]; - int idx = 0; - for (int i = 1; i <= 1000; i++) { - if (found[i][0] && found[i][1]) { - result[idx++] = i; - } - } - return result; - } } From 6a885d7bc246222d2f47f5e1fd45afd740c6daf7 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 10 Mar 2024 16:08:15 -0700 Subject: [PATCH 495/712] Create Apple Redistribution into Boxes.java --- Easy/Apple Redistribution into Boxes.java | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) create mode 100644 Easy/Apple Redistribution into Boxes.java diff --git a/Easy/Apple Redistribution into Boxes.java b/Easy/Apple Redistribution into Boxes.java new file mode 100644 index 00000000..d84bd8a8 --- /dev/null +++ b/Easy/Apple Redistribution into Boxes.java @@ -0,0 +1,20 @@ +class Solution { + public int minimumBoxes(int[] apple, int[] capacity) { + int totalApples = 0; + for (int count : apple) { + totalApples += count; + } + Arrays.sort(capacity); + int idx = capacity.length - 1; + int currCapacity = capacity[idx--]; + while (totalApples > 0) { + int applesDeleted = Math.min(currCapacity, totalApples); + totalApples -= applesDeleted; + currCapacity -= applesDeleted; + if (currCapacity == 0 && totalApples > 0) { + currCapacity = capacity[idx--]; + } + } + return capacity.length - idx - 1; + } +} From c0bd347683b4a68f38987495e8f4deca4efe2ec6 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Mon, 11 Mar 2024 17:46:11 -0700 Subject: [PATCH 496/712] Update Remove Zero Sum Consecutive Nodes from Linked List.java --- ...um Consecutive Nodes from Linked List.java | 39 +++++++++---------- 1 file changed, 19 insertions(+), 20 deletions(-) diff --git a/Medium/Remove Zero Sum Consecutive Nodes from Linked List.java b/Medium/Remove Zero Sum Consecutive Nodes from Linked List.java index 9807ca95..6f55accd 100644 --- a/Medium/Remove Zero Sum Consecutive Nodes from Linked List.java +++ b/Medium/Remove Zero Sum Consecutive Nodes from Linked List.java @@ -9,25 +9,24 @@ * } */ class Solution { - public ListNode removeZeroSumSublists(ListNode head) { - ListNode dummy = new ListNode(0); - ListNode curr = head; - dummy.next = head; - Map map = new HashMap<>(); - int prefixSum = 0; - map.put(0, dummy); - while (curr != null) { - prefixSum += curr.val; - map.put(prefixSum, curr); - curr = curr.next; + public ListNode removeZeroSumSublists(ListNode head) { + ListNode dummy = new ListNode(0, head); + ListNode curr = dummy; + int prefixSum = 0; + Map map = new HashMap<>(); + map.put(0, curr); + while (curr != null) { + prefixSum += curr.val; + map.put(prefixSum, curr); + curr = curr.next; + } + prefixSum = 0; + curr = dummy; + while (curr != null) { + prefixSum += curr.val; + curr.next = map.get(prefixSum).next; + curr = curr.next; + } + return dummy.next; } - prefixSum = 0; - curr = dummy; - while (curr != null) { - prefixSum += curr.val; - curr.next = map.get(prefixSum).next; - curr = curr.next; - } - return dummy.next; - } } From c6160261c59698337b83083c2d6789a4527f90c4 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 17 Mar 2024 09:08:21 -0700 Subject: [PATCH 497/712] Create Find the Sum of Encrypted Integers.java --- Easy/Find the Sum of Encrypted Integers.java | 21 ++++++++++++++++++++ 1 file changed, 21 insertions(+) create mode 100644 Easy/Find the Sum of Encrypted Integers.java diff --git a/Easy/Find the Sum of Encrypted Integers.java b/Easy/Find the Sum of Encrypted Integers.java new file mode 100644 index 00000000..6cee31bc --- /dev/null +++ b/Easy/Find the Sum of Encrypted Integers.java @@ -0,0 +1,21 @@ +class Solution { + public int sumOfEncryptedInt(int[] nums) { + int sum = 0; + for (int num : nums) { + sum += getEncryptedSum(num); + } + return sum; + } + + private static int getEncryptedSum(int num) { + int count = 0; + int max = 0; + while (num > 0) { + int digit = num % 10; + num /= 10; + count++; + max = Math.max(digit, max); + } + return Integer.parseInt(String.join("", Collections.nCopies(count, String.valueOf(max)))); + } +} From bc153969bf4bd1e700cbf3878130aeae1790322b Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 17 Mar 2024 09:18:11 -0700 Subject: [PATCH 498/712] Update Insert Interval.java --- Medium/Insert Interval.java | 45 +++++++++++++------------------------ 1 file changed, 16 insertions(+), 29 deletions(-) diff --git a/Medium/Insert Interval.java b/Medium/Insert Interval.java index a263b710..a90a6884 100644 --- a/Medium/Insert Interval.java +++ b/Medium/Insert Interval.java @@ -1,32 +1,19 @@ class Solution { - public int[][] insert(int[][] intervals, int[] newInterval) { - List result = new ArrayList<>(); - int idx = 0; - int newStart = newInterval[0]; - int newEnd = newInterval[1]; - while (idx < intervals.length && newStart > intervals[idx][0]) { - result.add(intervals[idx++]); + public int[][] insert(int[][] intervals, int[] newInterval) { + List result = new ArrayList<>(); + int idx = 0; + while (idx < intervals.length && intervals[idx][1] < newInterval[0]) { + result.add(intervals[idx++]); + } + while (idx < intervals.length && newInterval[1] >= intervals[idx][0]) { + newInterval[0] = Math.min(newInterval[0], intervals[idx][0]); + newInterval[1] = Math.max(newInterval[1], intervals[idx][1]); + idx++; + } + result.add(newInterval); + while (idx < intervals.length) { + result.add(intervals[idx++]); + } + return result.toArray(new int[result.size()][]); } - int[] currInterval = new int[2]; - if (result.isEmpty() || result.get(result.size() - 1)[1] < newStart) { - result.add(newInterval); - } else { - currInterval = result.remove(result.size() - 1); - currInterval[1] = Math.max(currInterval[1], newEnd); - result.add(currInterval); - } - while (idx < intervals.length) { - currInterval = intervals[idx++]; - int start = currInterval[0]; - int end = currInterval[1]; - if (result.get(result.size() - 1)[1] < start) { - result.add(currInterval); - } else { - currInterval = result.remove(result.size() - 1); - currInterval[1] = Math.max(currInterval[1], end); - result.add(currInterval); - } - } - return result.toArray(new int[result.size()][2]); - } } From 25205b87a44faf2e93bbd658db93d834e1fe7b7e Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Tue, 19 Mar 2024 17:43:37 -0700 Subject: [PATCH 499/712] Update Merge In Between Linked Lists.java --- Medium/Merge In Between Linked Lists.java | 39 ++++++++++------------- 1 file changed, 17 insertions(+), 22 deletions(-) diff --git a/Medium/Merge In Between Linked Lists.java b/Medium/Merge In Between Linked Lists.java index 5e3b814a..9f36b5a8 100644 --- a/Medium/Merge In Between Linked Lists.java +++ b/Medium/Merge In Between Linked Lists.java @@ -9,27 +9,22 @@ * } */ class Solution { - public ListNode mergeInBetween(ListNode list1, int a, int b, ListNode list2) { - ListNode currList1 = list1; - // Stop just before a and record the pointer - for (int i = 0; i < a - 1; i++) { - currList1 = currList1.next; + public ListNode mergeInBetween(ListNode list1, int a, int b, ListNode list2) { + ListNode curr = list1; + for (int i = 1; i < a; i++) { + curr = curr.next; + } + ListNode start = curr; + for (int i = a - 1; i <= b; i++) { + curr = curr.next; + } + ListNode end = curr; + start.next = list2; + curr = list2; + while (curr.next != null) { + curr = curr.next; + } + curr.next = end; + return list1; } - ListNode currCopy = currList1; - // Cover a to b - for (int i = a; i <= b; i++) { - currList1 = currList1.next; - } - // Record what is remaining after b - ListNode remaining = currList1.next; - // Find end of list2 - ListNode list2End = list2; - while (list2End != null && list2End.next != null) { - list2End = list2End.next; - } - // Pointer manipulation - currCopy.next = list2; - list2End.next = remaining; - return list1; - } } From d7bef6088335dd3c0ab9ee007605c45acba13137 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Fri, 22 Mar 2024 07:34:22 -0700 Subject: [PATCH 500/712] Update Palindrome Linked List.java --- Easy/Palindrome Linked List.java | 62 +++++++++++++++----------------- 1 file changed, 29 insertions(+), 33 deletions(-) diff --git a/Easy/Palindrome Linked List.java b/Easy/Palindrome Linked List.java index 946427e6..11c23754 100644 --- a/Easy/Palindrome Linked List.java +++ b/Easy/Palindrome Linked List.java @@ -9,39 +9,35 @@ * } */ class Solution { - public boolean isPalindrome(ListNode head) { - if (head.next == null) { - return true; + public boolean isPalindrome(ListNode head) { + ListNode slow = head; + ListNode fast = head; + while (fast != null && fast.next != null) { + slow = slow.next; + fast = fast.next.next; + } + ListNode secondHalf = slow; + secondHalf = reverse(secondHalf); + ListNode firstHalf = head; + while (secondHalf != null && firstHalf != null) { + if (firstHalf.val != secondHalf.val) { + return false; + } + firstHalf = firstHalf.next; + secondHalf = secondHalf.next; + } + return true; } - ListNode slow = head; - ListNode fast = head; - ListNode prev = null; - while (fast != null && fast.next != null) { - prev = slow; - fast = fast.next.next; - slow = slow.next; + + private ListNode reverse(ListNode node) { + ListNode curr = node; + ListNode prev = null; + while (curr != null) { + ListNode next = curr.next; + curr.next = prev; + prev = curr; + curr = next; + } + return prev; } - ListNode revNode = reverse(slow); - while (revNode != null) { - if (revNode.val != head.val) { - return false; - } - revNode = revNode.next; - head = head.next; - } - return true; - } - - private ListNode reverse(ListNode node) { - ListNode prev = null; - ListNode curr = node; - ListNode next = node; - while (curr != null) { - next = curr.next; - curr.next = prev; - prev = curr; - curr = next; - } - return prev; - } } From 72b581013e7ef90f5eb6dd41217441b74f3f9ee9 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sat, 23 Mar 2024 10:02:57 -0700 Subject: [PATCH 501/712] Update Reorder List.java --- Medium/Reorder List.java | 58 ++++++++++++++++++++-------------------- 1 file changed, 29 insertions(+), 29 deletions(-) diff --git a/Medium/Reorder List.java b/Medium/Reorder List.java index 769a555d..99b9ea19 100644 --- a/Medium/Reorder List.java +++ b/Medium/Reorder List.java @@ -9,35 +9,35 @@ * } */ class Solution { - public void reorderList(ListNode head) { - ListNode slow = head; - ListNode fast = head; - while (fast != null && fast.next != null) { - slow = slow.next; - fast = fast.next.next; + public void reorderList(ListNode head) { + ListNode slow = head; + ListNode fast = head; + while (fast != null && fast.next != null) { + slow = slow.next; + fast = fast.next.next; + } + ListNode secondHalf = reverse(slow.next); + slow.next = null; + ListNode firstHalf = head; + while (firstHalf != null && secondHalf != null) { + ListNode firstNext = firstHalf.next; + ListNode secondNext = secondHalf.next; + firstHalf.next = secondHalf; + secondHalf.next = firstNext; + firstHalf = firstNext; + secondHalf = secondNext; + } } - ListNode secondHalf = reverse(slow.next); - slow.next = null; - ListNode firstHalf = head; - while (firstHalf != null && secondHalf != null) { - ListNode firstHalfNext = firstHalf.next; - ListNode secondHalfNext = secondHalf.next; - firstHalf.next = secondHalf; - secondHalf.next = firstHalfNext; - firstHalf = firstHalfNext; - secondHalf = secondHalfNext; + + private ListNode reverse(ListNode node) { + ListNode curr = node; + ListNode prev = null; + while (curr != null) { + ListNode next = curr.next; + curr.next = prev; + prev = curr; + curr = next; + } + return prev; } - } - - private ListNode reverse(ListNode node) { - ListNode curr = node; - ListNode prev = null; - while (curr != null) { - ListNode next = curr.next; - curr.next = prev; - prev = curr; - curr = next; - } - return prev; - } } From 664bac5a16760e895044e8afe0dacfabe9349ecd Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Tue, 26 Mar 2024 07:48:20 -0700 Subject: [PATCH 502/712] Update First Missing Positive.java --- Hard/First Missing Positive.java | 49 ++++++++++++++++---------------- 1 file changed, 24 insertions(+), 25 deletions(-) diff --git a/Hard/First Missing Positive.java b/Hard/First Missing Positive.java index 91b5b6fd..3b501319 100644 --- a/Hard/First Missing Positive.java +++ b/Hard/First Missing Positive.java @@ -1,28 +1,27 @@ class Solution { - public int firstMissingPositive(int[] nums) { - int n = nums.length; - int idx = 0; - while (idx < n) { - if (nums[idx] > 0 && nums[idx] < n && nums[nums[idx]] != nums[idx]) { - swap(nums, idx, nums[idx]); - } - else { - idx++; - } + public int firstMissingPositive(int[] nums) { + int n = nums.length; + for (int i = 0; i < n; i++) { + if (nums[i] < 0) { + nums[i] = 0; + } + } + for (int i = 0; i < n; i++) { + int val = Math.abs(nums[i]); + if (val >= 1 && val <= n) { + int idx = val - 1; + if (nums[idx] > 0) { + nums[idx] *= -1; + } else if (nums[idx] == 0) { + nums[idx] = -1 * (n + 1); + } + } + } + for (int i = 1; i <= n; i++) { + if (nums[i - 1] >= 0) { + return i; + } + } + return n + 1; } - idx = 1; - while (idx < n && nums[idx] == idx) { - idx++; - } - if (n == 0 || idx < n) { - return idx; - } - return nums[0] == idx ? idx + 1 : idx; - } - - private void swap(int[] nums, int i, int j) { - int temp = nums[i]; - nums[i] = nums[j]; - nums[j] = temp; - } } From 8b593fc716250d0856671800b0551d6f12fe40b4 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Wed, 27 Mar 2024 07:20:23 -0700 Subject: [PATCH 503/712] Update Subarray Product Less Than K.java --- Medium/Subarray Product Less Than K.java | 32 +++++++++++++----------- 1 file changed, 17 insertions(+), 15 deletions(-) diff --git a/Medium/Subarray Product Less Than K.java b/Medium/Subarray Product Less Than K.java index 68ba3e13..3f53dc87 100644 --- a/Medium/Subarray Product Less Than K.java +++ b/Medium/Subarray Product Less Than K.java @@ -1,18 +1,20 @@ class Solution { - public int numSubarrayProductLessThanK(int[] nums, int k) { - if (k <= 1) { - return 0; + public int numSubarrayProductLessThanK(int[] nums, int k) { + if (k <= 1) { + return 0; + } + int prod = 1; + int start = 0; + int end = 0; + int n = nums.length; + int result = 0; + while (end < n) { + prod *= nums[end++]; + while (start < end && prod >= k) { + prod /= nums[start++]; + } + result += end - start; + } + return result; } - int prod = 1; - int ans = 0; - int left = 0; - for (int right = 0; right < nums.length; right++) { - prod *= nums[right]; - while (prod >= k) { - prod /= nums[left++]; - } - ans += right - left + 1; - } - return ans; - } } From ff9986ab91a0879c360e7b1d56a7090c866c3ea9 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Wed, 27 Mar 2024 07:25:40 -0700 Subject: [PATCH 504/712] Create Maximum Length Substring With Two Occurrences.java --- ...Length Substring With Two Occurrences.java | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) create mode 100644 Easy/Maximum Length Substring With Two Occurrences.java diff --git a/Easy/Maximum Length Substring With Two Occurrences.java b/Easy/Maximum Length Substring With Two Occurrences.java new file mode 100644 index 00000000..44e281b1 --- /dev/null +++ b/Easy/Maximum Length Substring With Two Occurrences.java @@ -0,0 +1,19 @@ +class Solution { + public int maximumLengthSubstring(String s) { + Map map = new HashMap<>(); + int start = 0; + int end = 0; + int n = s.length(); + int result = 0; + while (end < n) { + map.put(s.charAt(end), map.getOrDefault(s.charAt(end), 0) + 1); + while (start <= end && map.get(s.charAt(end)) > 2) { + map.put(s.charAt(start), map.get(s.charAt(start)) - 1); + start++; + } + end++; + result = Math.max(result, end - start); + } + return result; + } +} From 530e5b4b75ac9062b59a9924c5366cfb52aa7e3c Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Wed, 27 Mar 2024 17:38:50 -0700 Subject: [PATCH 505/712] Create Length of Longest Subarray With at Most K Frequency.java --- ...est Subarray With at Most K Frequency.java | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) create mode 100644 Medium/Length of Longest Subarray With at Most K Frequency.java diff --git a/Medium/Length of Longest Subarray With at Most K Frequency.java b/Medium/Length of Longest Subarray With at Most K Frequency.java new file mode 100644 index 00000000..82d8f62d --- /dev/null +++ b/Medium/Length of Longest Subarray With at Most K Frequency.java @@ -0,0 +1,19 @@ +class Solution { + public int maxSubarrayLength(int[] nums, int k) { + int start = 0; + int end = 0; + int result = 0; + int n = nums.length; + Map map = new HashMap<>(); + while (end < n) { + map.put(nums[end], map.getOrDefault(nums[end], 0) + 1); + while (start < end && map.get(nums[end]) > k) { + map.put(nums[start], map.get(nums[start]) - 1); + start++; + } + end++; + result = Math.max(result, end - start); + } + return result; + } +} From 52cbe7ef9fa491f84d99711ec99e9e2e2e1445b4 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Thu, 28 Mar 2024 17:33:01 -0700 Subject: [PATCH 506/712] Create Count Subarrays Where Max Element Appears at Least K Times.java --- ... Max Element Appears at Least K Times.java | 24 +++++++++++++++++++ 1 file changed, 24 insertions(+) create mode 100644 Medium/Count Subarrays Where Max Element Appears at Least K Times.java diff --git a/Medium/Count Subarrays Where Max Element Appears at Least K Times.java b/Medium/Count Subarrays Where Max Element Appears at Least K Times.java new file mode 100644 index 00000000..d917693d --- /dev/null +++ b/Medium/Count Subarrays Where Max Element Appears at Least K Times.java @@ -0,0 +1,24 @@ +class Solution { + public long countSubarrays(int[] nums, int k) { + int maxElement = 0; + for (int num : nums) { + maxElement = Math.max(maxElement, num); + } + long result = 0; + int start = 0; + int maxElementsInWindow = 0; + for (int end = 0; end < nums.length; end++) { + if (nums[end] == maxElement) { + maxElementsInWindow++; + } + while (k == maxElementsInWindow) { + if (nums[start] == maxElement) { + maxElementsInWindow--; + } + start++; + } + result += start; + } + return result; + } +} From a79f2a05a0beceb70618d587dffb0962fb9a06e6 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sat, 30 Mar 2024 08:30:07 -0700 Subject: [PATCH 507/712] Update Subarrays with K Different Integers.java --- Hard/Subarrays with K Different Integers.java | 44 ++++++++----------- 1 file changed, 19 insertions(+), 25 deletions(-) diff --git a/Hard/Subarrays with K Different Integers.java b/Hard/Subarrays with K Different Integers.java index 42224709..0a1d5559 100644 --- a/Hard/Subarrays with K Different Integers.java +++ b/Hard/Subarrays with K Different Integers.java @@ -1,29 +1,23 @@ class Solution { - public int subarraysWithKDistinct(int[] A, int K) { - return atMostK(A, K) - atMostK(A, K - 1); - } - - private int atMostK(int[] A, int K) { - int start = 0; - int end = 0; - int n = A.length; - Map map = new HashMap<>(); - int count = 0; - while (end < n) { - if (map.getOrDefault(A[end], 0) == 0) { - K--; - } - map.put(A[end], map.getOrDefault(A[end], 0) + 1); - while (K < 0) { - map.put(A[start], map.getOrDefault(A[start], 0) - 1); - if (map.get(A[start]) == 0) { - K++; + public int subarraysWithKDistinct(int[] nums, int k) { + return slidingWindowAtMost(nums, k) - slidingWindowAtMost(nums, k - 1); + } + + private int slidingWindowAtMost(int[] nums, int k) { + Map map = new HashMap<>(); + int left = 0; + int count = 0; + for (int right = 0; right < nums.length; right++) { + map.put(nums[right], map.getOrDefault(nums[right], 0) + 1); + while (map.size() > k) { + map.put(nums[left], map.get(nums[left]) - 1); + if (map.get(nums[left]) == 0) { + map.remove(nums[left]); + } + left++; + } + count += right - left + 1; } - start++; - } - count += end - start + 1; - end++; + return count; } - return count; - } } From 74ecc816f061f2f8b20ed25592b5bb82da1eebef Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 31 Mar 2024 07:29:37 -0700 Subject: [PATCH 508/712] Create Harshad Number.java --- Easy/Harshad Number.java | 15 +++++++++++++++ 1 file changed, 15 insertions(+) create mode 100644 Easy/Harshad Number.java diff --git a/Easy/Harshad Number.java b/Easy/Harshad Number.java new file mode 100644 index 00000000..c02c40bf --- /dev/null +++ b/Easy/Harshad Number.java @@ -0,0 +1,15 @@ +class Solution { + public int sumOfTheDigitsOfHarshadNumber(int x) { + int digitSum = getDigitSum(x); + return x % digitSum == 0 ? digitSum : -1; + } + + private static int getDigitSum(int num) { + int sum = 0; + while (num > 0) { + sum += num % 10; + num /= 10; + } + return sum; + } +} From 8688def7aadb96379ae1585b8066ef0c4129fee8 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 31 Mar 2024 07:33:58 -0700 Subject: [PATCH 509/712] Create Shortest Subarray With OR at Least K I.java --- .../Shortest Subarray With OR at Least K I.java | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) create mode 100644 Easy/Shortest Subarray With OR at Least K I.java diff --git a/Easy/Shortest Subarray With OR at Least K I.java b/Easy/Shortest Subarray With OR at Least K I.java new file mode 100644 index 00000000..0032852b --- /dev/null +++ b/Easy/Shortest Subarray With OR at Least K I.java @@ -0,0 +1,17 @@ +class Solution { + public int minimumSubarrayLength(int[] nums, int k) { + int n = nums.length; + int result = Integer.MAX_VALUE; + for (int i = 0; i < n; i++) { + int curr = 0; + for (int j = i; j < n; j++) { + curr |= nums[j]; + if (curr >= k) { + result = Math.min(result, j - i + 1); + break; + } + } + } + return result == Integer.MAX_VALUE ? -1 : result; + } +} From b9cb5afa67287356efd12abdfc62adca0cdcb505 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 31 Mar 2024 07:43:09 -0700 Subject: [PATCH 510/712] Create Minimum Levels to Gain More Points.java --- Medium/Minimum Levels to Gain More Points.java | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) create mode 100644 Medium/Minimum Levels to Gain More Points.java diff --git a/Medium/Minimum Levels to Gain More Points.java b/Medium/Minimum Levels to Gain More Points.java new file mode 100644 index 00000000..c7fd7222 --- /dev/null +++ b/Medium/Minimum Levels to Gain More Points.java @@ -0,0 +1,17 @@ +class Solution { + public int minimumLevels(int[] possible) { + int n = possible.length; + int totalScore = 0; + for (int i = n - 1; i >= 0; i--) { + totalScore += possible[i] == 1 ? 1 : -1; + } + int score = 0; + for (int i = 0; i < n - 1; i++) { + score += possible[i] == 1 ? 1 : -1; + if (score > totalScore - score) { + return i + 1; + } + } + return -1; + } +} From 01afcab2ae6b64f994a82b049ce5a3a78305ebb7 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 31 Mar 2024 07:49:08 -0700 Subject: [PATCH 511/712] Create Water Bottles II.java --- Medium/Water Bottles II.java | 12 ++++++++++++ 1 file changed, 12 insertions(+) create mode 100644 Medium/Water Bottles II.java diff --git a/Medium/Water Bottles II.java b/Medium/Water Bottles II.java new file mode 100644 index 00000000..d9205f31 --- /dev/null +++ b/Medium/Water Bottles II.java @@ -0,0 +1,12 @@ +class Solution { + public int maxBottlesDrunk(int numBottles, int numExchange) { + int total = numBottles; + while (numBottles >= numExchange) { + numBottles -= numExchange; + numExchange++; + total++; + numBottles++; + } + return total; + } +} From 06832e167e97e1c0ca6f86aa0c8c54dc321a3c31 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 31 Mar 2024 07:49:25 -0700 Subject: [PATCH 512/712] Update README.md --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index c4fd5e63..a90fb07e 100644 --- a/README.md +++ b/README.md @@ -2,7 +2,7 @@ ## Solutions to Leetcode problems in Java -## [Current Leetcode profile: Solved 1500+ Problems](https://leetcode.com/varunsjsu/) +## [Current Leetcode profile: Solved 1600+ Problems](https://leetcode.com/varunsjsu/) ## [Previous Leetcode profile: Solved 759 Problems](https://leetcode.com/varunu28/) Problem Category | Count From 1e074c2fc9157c916f40e745ce9bd6d9f9b73245 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Tue, 2 Apr 2024 06:15:30 -0700 Subject: [PATCH 513/712] Update Isomorphic Strings.java --- Easy/Isomorphic Strings.java | 24 +++++++++++++++--------- 1 file changed, 15 insertions(+), 9 deletions(-) diff --git a/Easy/Isomorphic Strings.java b/Easy/Isomorphic Strings.java index 6b870650..b9813b64 100644 --- a/Easy/Isomorphic Strings.java +++ b/Easy/Isomorphic Strings.java @@ -1,12 +1,18 @@ class Solution { - public boolean isIsomorphic(String s, String t) { - int[] position = new int[512]; - for (int i = 0; i < s.length(); i++) { - if (position[s.charAt(i)] != position[t.charAt(i) + 256]) { - return false; - } - position[s.charAt(i)] = position[t.charAt(i) + 256] = i + 1; + public boolean isIsomorphic(String s, String t) { + return mapString(s).equals(mapString(t)); + } + + private static String mapString(String s) { + Map map = new HashMap<>(); + int count = 0; + StringBuilder sb = new StringBuilder(); + for (char c : s.toCharArray()) { + if (!map.containsKey(c)) { + map.put(c, count++); + } + sb.append(map.get(c)).append("|"); + } + return sb.toString(); } - return true; - } } From 02a4635a3dc7bcbee0ce07e31339840db4a2ea4f Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Thu, 4 Apr 2024 06:40:55 -0700 Subject: [PATCH 514/712] Update Maximum Nesting Depth of the Parentheses.java --- ...ximum Nesting Depth of the Parentheses.java | 18 ++++++++++-------- 1 file changed, 10 insertions(+), 8 deletions(-) diff --git a/Easy/Maximum Nesting Depth of the Parentheses.java b/Easy/Maximum Nesting Depth of the Parentheses.java index 19a50736..8ce9eac2 100644 --- a/Easy/Maximum Nesting Depth of the Parentheses.java +++ b/Easy/Maximum Nesting Depth of the Parentheses.java @@ -1,11 +1,13 @@ class Solution { - public int maxDepth(String s) { - int currCount = 0; - int maxCount = 0; - for (char c : s.toCharArray()) { - currCount += c == '(' ? 1 : (c == ')' ? -1 : 0); - maxCount = Math.max(maxCount, currCount); + public int maxDepth(String s) { + int count = 0; + int result = 0; + for (char c : s.toCharArray()) { + if (c == '(' || c == ')') { + count += c == '(' ? 1 : -1; + } + result = Math.max(result, count); + } + return result; } - return maxCount; - } } From 0b9bea2ac20b3e7f0ac3debde30d3885926ac8ba Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Fri, 5 Apr 2024 06:56:58 -0700 Subject: [PATCH 515/712] Update Make The String Great.java --- Easy/Make The String Great.java | 34 +++++++++++++++++++-------------- 1 file changed, 20 insertions(+), 14 deletions(-) diff --git a/Easy/Make The String Great.java b/Easy/Make The String Great.java index a7cb7882..32b4684a 100644 --- a/Easy/Make The String Great.java +++ b/Easy/Make The String Great.java @@ -1,18 +1,24 @@ class Solution { - public String makeGood(String s) { - Stack stack = new Stack<>(); - for (char c : s.toCharArray()) { - if (!stack.isEmpty() && Math.abs(stack.peek() - c) == 32) { - stack.pop(); - } - else { - stack.push(c); - } + public String makeGood(String s) { + Stack stack = new Stack<>(); + for (char c : s.toCharArray()) { + if (!stack.isEmpty() && isBad(c, stack.peek())) { + stack.pop(); + continue; + } + stack.push(c); + } + StringBuilder sb = new StringBuilder(); + while (!stack.isEmpty()) { + sb.append(stack.pop()); + } + return sb.reverse().toString(); } - StringBuilder sb = new StringBuilder(); - while (!stack.isEmpty()) { - sb.append(stack.pop()); + + private static boolean isBad(char c1, char c2) { + if (c1 == c2) { + return false; + } + return Character.toLowerCase(c1) == Character.toLowerCase(c2); } - return sb.reverse().toString(); - } } From 60c654266ebd4e48c453ae1529a5e767d11a1fc6 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Fri, 5 Apr 2024 17:17:04 -0700 Subject: [PATCH 516/712] Update Minimum Remove to Make Valid Parentheses.java --- ...imum Remove to Make Valid Parentheses.java | 45 ++++++++++--------- 1 file changed, 23 insertions(+), 22 deletions(-) diff --git a/Medium/Minimum Remove to Make Valid Parentheses.java b/Medium/Minimum Remove to Make Valid Parentheses.java index 45734d11..7d5be988 100644 --- a/Medium/Minimum Remove to Make Valid Parentheses.java +++ b/Medium/Minimum Remove to Make Valid Parentheses.java @@ -1,27 +1,28 @@ class Solution { - public String minRemoveToMakeValid(String s) { - Stack stack = new Stack<>(); - Set validIndexes = new HashSet<>(); - for (int i = 0; i < s.length(); i++) { - if (s.charAt(i) == '(') { - stack.add(i); - } else if (s.charAt(i) == ')') { - if (!stack.isEmpty()) { - validIndexes.add(stack.pop()); - validIndexes.add(i); + public String minRemoveToMakeValid(String s) { + char[] letters = s.toCharArray(); + Stack stack = new Stack<>(); + for (int i = 0; i < s.length(); i++) { + char c = s.charAt(i); + if (c == '(') { + stack.push(i); + } else if (c == ')') { + if (stack.isEmpty()) { + letters[i] = '-'; + } else { + stack.pop(); + } + } } - } - } - StringBuilder sb = new StringBuilder(); - for (int i = 0; i < s.length(); i++) { - if (s.charAt(i) == '(' || s.charAt(i) == ')') { - if (validIndexes.contains(i)) { - sb.append(s.charAt(i)); + while (!stack.isEmpty()) { + letters[stack.pop()] = '-'; + } + StringBuilder sb = new StringBuilder(); + for (char c : letters) { + if (c != '-') { + sb.append(c); + } } - } else { - sb.append(s.charAt(i)); - } + return sb.toString(); } - return sb.toString(); - } } From adeed10feaa5927ac9055ca0912690250abe5942 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 14 Apr 2024 15:56:31 -0700 Subject: [PATCH 517/712] Create Score of a String.java --- Easy/Score of a String.java | 9 +++++++++ 1 file changed, 9 insertions(+) create mode 100644 Easy/Score of a String.java diff --git a/Easy/Score of a String.java b/Easy/Score of a String.java new file mode 100644 index 00000000..fafcca05 --- /dev/null +++ b/Easy/Score of a String.java @@ -0,0 +1,9 @@ +class Solution { + public int scoreOfString(String s) { + int score = 0; + for (int i = 1; i < s.length(); i++) { + score += Math.abs(s.charAt(i) - s.charAt(i - 1)); + } + return score; + } +} From 21b2ab22036c4aaf54a4faffcbf504ecf9c1c334 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sat, 20 Apr 2024 08:51:46 -0700 Subject: [PATCH 518/712] Create Find All Groups of Farmland.java --- Medium/Find All Groups of Farmland.java | 49 +++++++++++++++++++++++++ 1 file changed, 49 insertions(+) create mode 100644 Medium/Find All Groups of Farmland.java diff --git a/Medium/Find All Groups of Farmland.java b/Medium/Find All Groups of Farmland.java new file mode 100644 index 00000000..130db6a1 --- /dev/null +++ b/Medium/Find All Groups of Farmland.java @@ -0,0 +1,49 @@ +class Solution { + + private static final int[][] DIRS = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}}; + + public int[][] findFarmland(int[][] land) { + int rows = land.length; + int cols = land[0].length; + boolean[][] visited = new boolean[rows][cols]; + List result = new ArrayList<>(); + for (int i = 0; i < rows; i++) { + for (int j = 0; j < cols; j++) { + if (land[i][j] == 1 && !visited[i][j]) { + traverse(land, i, j, visited, result); + } + } + } + return result.stream() + .map(int[]::clone) + .toArray(int[][]::new); + } + + private static void traverse(int[][] land, int i, int j, boolean[][] visited, List result) { + int rows = land.length; + int cols = land[0].length; + Queue queue = new LinkedList<>(); + int[] leftMost = {i, j}; + int[] rightMost = {i, j}; + queue.add(new int[]{i, j}); + visited[i][j] = true; + while (!queue.isEmpty()) { + int[] removed = queue.remove(); + int x = removed[0]; + int y = removed[1]; + leftMost[0] = Math.min(leftMost[0], x); + leftMost[1] = Math.min(leftMost[1], y); + rightMost[0] = Math.max(rightMost[0], x); + rightMost[1] = Math.max(rightMost[1], y); + for (int[] dir : DIRS) { + int newX = x + dir[0]; + int newY = y + dir[1]; + if (newX >= 0 && newY >= 0 && newX < rows && newY < cols && !visited[newX][newY] && land[newX][newY] == 1) { + queue.add(new int[]{newX, newY}); + visited[newX][newY] = true; + } + } + } + result.add(new int[]{leftMost[0], leftMost[1], rightMost[0], rightMost[1]}); + } +} From 3e2b8bf6164d6751ebdc3e6f1394890237652c46 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 21 Apr 2024 08:43:27 -0700 Subject: [PATCH 519/712] Create Count the Number of Special Characters I.java --- ...nt the Number of Special Characters I.java | 20 +++++++++++++++++++ 1 file changed, 20 insertions(+) create mode 100644 Easy/Count the Number of Special Characters I.java diff --git a/Easy/Count the Number of Special Characters I.java b/Easy/Count the Number of Special Characters I.java new file mode 100644 index 00000000..44c9950f --- /dev/null +++ b/Easy/Count the Number of Special Characters I.java @@ -0,0 +1,20 @@ +class Solution { + public int numberOfSpecialChars(String word) { + boolean[] upperPresent = new boolean[26]; + boolean[] lowerPresent = new boolean[26]; + for (char c : word.toCharArray()) { + if (Character.isUpperCase(c)) { + upperPresent[c - 'A'] = true; + } else { + lowerPresent[c - 'a'] = true; + } + } + int count = 0; + for (int i = 0; i < 26; i++) { + if (upperPresent[i] && lowerPresent[i]) { + count++; + } + } + return count; + } +} From e1fcc313d62a9e158251ff7c0a2c932e96116917 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Mon, 22 Apr 2024 08:07:39 -0700 Subject: [PATCH 520/712] Update Open The Lock.java --- Medium/Open The Lock.java | 26 ++++++++++++-------------- 1 file changed, 12 insertions(+), 14 deletions(-) diff --git a/Medium/Open The Lock.java b/Medium/Open The Lock.java index 926e8521..f692f0ba 100644 --- a/Medium/Open The Lock.java +++ b/Medium/Open The Lock.java @@ -1,40 +1,38 @@ class Solution { public int openLock(String[] deadends, String target) { Set deadEndSet = new HashSet<>(Arrays.asList(deadends)); - if (deadEndSet.contains(target) || deadEndSet.contains("0000")) { + String startingPoint = "0000"; + if (deadEndSet.contains(startingPoint)) { return -1; } Queue queue = new LinkedList<>(); - Set seen = new HashSet<>(); - queue.add("0000"); - seen.add("0000"); - int steps = 0; + Set visited = new HashSet<>(); + queue.add(startingPoint); + visited.add(startingPoint); + int attempts = 0; int[] rotations = {-1, 1}; while (!queue.isEmpty()) { int size = queue.size(); for (int i = 0; i < size; i++) { String removed = queue.remove(); if (removed.equals(target)) { - return steps; + return attempts; } if (deadEndSet.contains(removed)) { continue; } for (int j = 0; j < 4; j++) { for (int rotation : rotations) { - int changedVal = ((removed.charAt(j) - '0') + rotation + 10) % 10; - String newRotation = new StringBuilder() - .append(removed.substring(0,j)) .append(changedVal) - .append(removed.substring(j + 1)) - .toString(); - if (!seen.contains(newRotation)) { - seen.add(newRotation); + int newValue = ((removed.charAt(j) - '0') + rotation + 10) % 10; + String newRotation = removed.substring(0, j) + newValue + removed.substring(j + 1); + if (!visited.contains(newRotation)) { + visited.add(newRotation); queue.add(newRotation); } } } } - steps++; + attempts++; } return -1; } From 54c637a6a466971146178fac306a5743e93b4e04 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 28 Apr 2024 12:20:02 -0700 Subject: [PATCH 521/712] Create Make a Square with the Same Color.java --- Easy/Make a Square with the Same Color.java | 40 +++++++++++++++++++++ 1 file changed, 40 insertions(+) create mode 100644 Easy/Make a Square with the Same Color.java diff --git a/Easy/Make a Square with the Same Color.java b/Easy/Make a Square with the Same Color.java new file mode 100644 index 00000000..2f5524d8 --- /dev/null +++ b/Easy/Make a Square with the Same Color.java @@ -0,0 +1,40 @@ +class Solution { + + int[][] DIRS = {{0, 0}, {0, 1}, {1, 0}, {1, 1}}; + + public boolean canMakeSquare(char[][] grid) { + int rows = grid.length; + int cols = grid[0].length; + for (int i = 0; i < rows; i++) { + for (int j = 0; j < cols; j++) { + if (isPossible(grid, i, j, rows, cols)) { + return true; + } + } + } + return false; + } + + private boolean isPossible(char[][] grid, int i, int j, int rows, int cols) { + int white = 0; + int black = 0; + int invalid = 0; + for (int[] dir : DIRS) { + int newX = i + dir[0]; + int newY = j + dir[1]; + if (newX >= 0 && newY >= 0 && newX < rows && newY < cols) { + white += grid[newX][newY] == 'W' ? 1 : 0; + black += grid[newX][newY] == 'B' ? 1 : 0; + } else { + invalid++; + } + } + if (invalid > 0) { + return false; + } + if (white == 4 || black == 4) { + return true; + } + return white == 1 || black == 1; + } +} From d3bf7af949dd8ae6070428bdef205271b2ddaaf8 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 28 Apr 2024 12:23:29 -0700 Subject: [PATCH 522/712] Create Find the Integer Added to Array I.java --- Easy/Find the Integer Added to Array I.java | 11 +++++++++++ 1 file changed, 11 insertions(+) create mode 100644 Easy/Find the Integer Added to Array I.java diff --git a/Easy/Find the Integer Added to Array I.java b/Easy/Find the Integer Added to Array I.java new file mode 100644 index 00000000..c5d551e3 --- /dev/null +++ b/Easy/Find the Integer Added to Array I.java @@ -0,0 +1,11 @@ +class Solution { + public int addedInteger(int[] nums1, int[] nums2) { + int minOne = nums1[0]; + int minTwo = nums2[0]; + for (int i = 0; i < nums1.length; i++) { + minOne = Math.min(minOne, nums1[i]); + minTwo = Math.min(minTwo, nums2[i]); + } + return minTwo - minOne; + } +} From 87b15483c21a902223014ca5058913891334648e Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Thu, 2 May 2024 06:48:01 -0700 Subject: [PATCH 523/712] Create Right Triangles.java --- Medium/Right Triangles.java | 25 +++++++++++++++++++++++++ 1 file changed, 25 insertions(+) create mode 100644 Medium/Right Triangles.java diff --git a/Medium/Right Triangles.java b/Medium/Right Triangles.java new file mode 100644 index 00000000..d94804b3 --- /dev/null +++ b/Medium/Right Triangles.java @@ -0,0 +1,25 @@ +class Solution { + public long numberOfRightTriangles(int[][] grid) { + int rows = grid.length; + int cols = grid[0].length; + int[] rowCount = new int[rows]; + int[] colCount = new int[cols]; + for (int i = 0; i < rows; i++) { + for (int j = 0; j < cols; j++) { + if (grid[i][j] == 1) { + rowCount[i]++; + colCount[j]++; + } + } + } + long triangles = 0; + for (int i = 0; i < rows; i++) { + for (int j = 0; j < cols; j++) { + if (grid[i][j] == 1) { + triangles += (rowCount[i] - 1) * (colCount[j] - 1); + } + } + } + return triangles; + } +} From 3830eea78d5a4f45645f7c401bb8da7e0253a4aa Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 5 May 2024 16:42:39 -0700 Subject: [PATCH 524/712] Create Valid Word.java --- Easy/Valid Word.java | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+) create mode 100644 Easy/Valid Word.java diff --git a/Easy/Valid Word.java b/Easy/Valid Word.java new file mode 100644 index 00000000..c9611bbd --- /dev/null +++ b/Easy/Valid Word.java @@ -0,0 +1,21 @@ +class Solution { + + private static final Set VOWELS = Set.of('a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U'); + + public boolean isValid(String word) { + boolean vowelFound = false; + boolean consonantFound = false; + for (char c : word.toCharArray()) { + if (Character.isLetter(c)) { + if (VOWELS.contains(c)) { + vowelFound = true; + } else { + consonantFound = true; + } + } else if (!Character.isDigit(c)) { + return false; + } + } + return word.length() >= 3 && vowelFound && consonantFound; + } +} From 1f3c0a22ddaaf3eaff62d92b893fecbddb9a28d2 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Mon, 6 May 2024 19:45:36 -0700 Subject: [PATCH 525/712] Create Double a Number Represented as a Linked List.java --- ...a Number Represented as a Linked List.java | 40 +++++++++++++++++++ 1 file changed, 40 insertions(+) create mode 100644 Medium/Double a Number Represented as a Linked List.java diff --git a/Medium/Double a Number Represented as a Linked List.java b/Medium/Double a Number Represented as a Linked List.java new file mode 100644 index 00000000..9e2bcbaa --- /dev/null +++ b/Medium/Double a Number Represented as a Linked List.java @@ -0,0 +1,40 @@ +/** + * Definition for singly-linked list. + * public class ListNode { + * int val; + * ListNode next; + * ListNode() {} + * ListNode(int val) { this.val = val; } + * ListNode(int val, ListNode next) { this.val = val; this.next = next; } + * } + */ +class Solution { + public ListNode doubleIt(ListNode head) { + ListNode rev = reverse(head); + ListNode curr = rev; + int carry = 0; + while (curr != null) { + int val = curr.val * 2 + carry; + carry = val / 10; + curr.val = val % 10; + if (curr.next == null && carry != 0) { + curr.next = new ListNode(carry); + break; + } + curr = curr.next; + } + return reverse(rev); + } + + private ListNode reverse(ListNode curr) { + ListNode next = null; + ListNode prev = null; + while (curr != null) { + next = curr.next; + curr.next = prev; + prev = curr; + curr = next; + } + return prev; + } +} From 84dbd76dbe62e9fba04a461f29e5ace81f6359ab Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Thu, 9 May 2024 08:01:29 -0700 Subject: [PATCH 526/712] Create All O`one Data Structure.java --- Hard/All O`one Data Structure.java | 108 +++++++++++++++++++++++++++++ 1 file changed, 108 insertions(+) create mode 100644 Hard/All O`one Data Structure.java diff --git a/Hard/All O`one Data Structure.java b/Hard/All O`one Data Structure.java new file mode 100644 index 00000000..211e4f01 --- /dev/null +++ b/Hard/All O`one Data Structure.java @@ -0,0 +1,108 @@ +class AllOne { + private final NodeList head; + private final NodeList tail; + private final Map countToNodeMapping; + private final Map keyToCountMapping; + + public AllOne() { + head = new NodeList(Integer.MIN_VALUE); + tail = new NodeList(Integer.MAX_VALUE); + head.next = tail; + tail.prev = head; + countToNodeMapping = new HashMap<>(); + keyToCountMapping = new HashMap<>(); + } + + public void inc(String key) { + if (keyToCountMapping.containsKey(key)) { + updateKey(key, 1); + } else { + keyToCountMapping.put(key, 1); + if (head.next.count != 1) { + addNodeAfter(new NodeList(1), head); + } + head.next.keys.add(key); + countToNodeMapping.put(1, head.next); + } + } + + public void dec(String key) { + if (keyToCountMapping.containsKey(key)) { + int count = keyToCountMapping.get(key); + if (count == 1) { + keyToCountMapping.remove(key); + removeKey(countToNodeMapping.get(count), key); + } else { + updateKey(key, -1); + } + } + } + + public String getMaxKey() { + return tail.prev == head ? "" : tail.prev.keys.iterator().next(); + } + + public String getMinKey() { + return head.next == tail ? "" : head.next.keys.iterator().next(); + } + + private void updateKey(String key, int diff) { + int count = keyToCountMapping.get(key); + keyToCountMapping.put(key, count + diff); + NodeList currNode = countToNodeMapping.get(count); + NodeList newNode; + if (countToNodeMapping.containsKey(count + diff)) { + newNode = countToNodeMapping.get(count + diff); + } else { + newNode = new NodeList(count + diff); + countToNodeMapping.put(count + diff, newNode); + // If diff == 1 then new node will have count greater than currNode else it will have count less than currNode + addNodeAfter(newNode, diff == 1 ? currNode : currNode.prev); + } + newNode.keys.add(key); + removeKey(currNode, key); + } + + private void removeKey(NodeList nodeList, String key) { + nodeList.keys.remove(key); + if (nodeList.keys.isEmpty()) { + removeNodeList(nodeList); + countToNodeMapping.remove(nodeList.count); + } + } + + private void removeNodeList(NodeList nodeList) { + nodeList.prev.next = nodeList.next; + nodeList.next.prev = nodeList.prev; + nodeList.next = null; + nodeList.prev = null; + } + + private void addNodeAfter(NodeList node, NodeList prevNode) { + node.prev = prevNode; + node.next = prevNode.next; + prevNode.next.prev = node; + prevNode.next = node; + } + + private static class NodeList { + int count; + Set keys; + NodeList next; + NodeList prev; + + public NodeList(int count) { + this.count = count; + keys = new HashSet<>(); + } + } +} + +/** + * Your AllOne object will be instantiated and called as such: + * AllOne obj = new AllOne(); + * obj.inc(key); + * obj.dec(key); + * String param_3 = obj.getMaxKey(); + * String param_4 = obj.getMinKey(); + */ From 81ceecf8e1c2faa599d807c92e532642856d1a6b Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Thu, 9 May 2024 08:07:32 -0700 Subject: [PATCH 527/712] Create Maximize Happiness of Selected Children.java --- .../Maximize Happiness of Selected Children.java | 15 +++++++++++++++ 1 file changed, 15 insertions(+) create mode 100644 Medium/Maximize Happiness of Selected Children.java diff --git a/Medium/Maximize Happiness of Selected Children.java b/Medium/Maximize Happiness of Selected Children.java new file mode 100644 index 00000000..01e3aeff --- /dev/null +++ b/Medium/Maximize Happiness of Selected Children.java @@ -0,0 +1,15 @@ +class Solution { + public long maximumHappinessSum(int[] happiness, int k) { + Arrays.sort(happiness); + int turnCount = 0; + long happinessSum = 0; + int idx = happiness.length - 1; + while (k-- > 0) { + int currentHappiness = Math.max(0, happiness[idx] - turnCount); + happinessSum += currentHappiness; + turnCount++; + idx--; + } + return happinessSum; + } +} From 076472a2df68fb1908dc23c50a07ffbaa92749a2 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 12 May 2024 07:31:05 -0700 Subject: [PATCH 528/712] Create Check if Grid Satisfies Conditions.java --- Easy/Check if Grid Satisfies Conditions.java | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) create mode 100644 Easy/Check if Grid Satisfies Conditions.java diff --git a/Easy/Check if Grid Satisfies Conditions.java b/Easy/Check if Grid Satisfies Conditions.java new file mode 100644 index 00000000..93891460 --- /dev/null +++ b/Easy/Check if Grid Satisfies Conditions.java @@ -0,0 +1,17 @@ +class Solution { + public boolean satisfiesConditions(int[][] grid) { + int rows = grid.length; + int cols = grid[0].length; + for (int i = 0; i < rows; i++) { + for (int j = 0; j < cols; j++) { + if (i + 1 < rows && grid[i][j] != grid[i + 1][j]) { + return false; + } + if (j + 1 < cols && grid[i][j] == grid[i][j + 1]) { + return false; + } + } + } + return true; + } +} From f93fb78f11158ccf99e8af4c60c0867d57dde076 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Mon, 13 May 2024 07:14:12 -0700 Subject: [PATCH 529/712] Update Score After Flipping Matrix.java --- Medium/Score After Flipping Matrix.java | 66 ++++++++----------------- 1 file changed, 20 insertions(+), 46 deletions(-) diff --git a/Medium/Score After Flipping Matrix.java b/Medium/Score After Flipping Matrix.java index c369309d..54c3f3ac 100644 --- a/Medium/Score After Flipping Matrix.java +++ b/Medium/Score After Flipping Matrix.java @@ -1,59 +1,33 @@ class Solution { - public int matrixScore(int[][] A) { - for (int i=0; i actualSum) { - for (int j=0; j numOnes) { - for (int j=0; j rows-countZero) { + for(int i = 0; i < rows; i++) { + grid[i][j] = 1 - grid[i][j]; } } } - - int maxSum = 0; - for (int[] arr : A) { - maxSum += getDecimalValue(arr, false); - } - - return maxSum; - } - - private int getDecimalValue(int[] arr, boolean isToggled) { - int sum = 0; - int pow = 0; - - for (int i=arr.length-1; i>=0; i--) { - if (isToggled) { - sum += Math.pow(2, pow) * (arr[i] ^ 1); - } - else { - sum += Math.pow(2, pow) * arr[i]; + int score = 0; + for (int[] row : grid) { + for (int j = 0; j < cols; j++) { + score += row[j] << (cols - j - 1); } - - pow++; } - - return sum; + return score; } } From ba2453e99cc45ac28c447b4e0c50e97cf8dae161 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 19 May 2024 07:11:10 -0700 Subject: [PATCH 530/712] Create Special Array I.java --- Easy/Special Array I.java | 10 ++++++++++ 1 file changed, 10 insertions(+) create mode 100644 Easy/Special Array I.java diff --git a/Easy/Special Array I.java b/Easy/Special Array I.java new file mode 100644 index 00000000..5057f626 --- /dev/null +++ b/Easy/Special Array I.java @@ -0,0 +1,10 @@ +class Solution { + public boolean isArraySpecial(int[] nums) { + for (int i = 1; i < nums.length; i++) { + if (nums[i] % 2 == nums[i - 1] % 2) { + return false; + } + } + return true; + } +} From fc9d892f1be05e0b508276ebfa9529de36b4dbdb Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Tue, 21 May 2024 08:14:13 -0700 Subject: [PATCH 531/712] Update Minimum Knight Moves.java --- Medium/Minimum Knight Moves.java | 52 ++++++++++++++++---------------- 1 file changed, 26 insertions(+), 26 deletions(-) diff --git a/Medium/Minimum Knight Moves.java b/Medium/Minimum Knight Moves.java index e1352ac4..35759df8 100644 --- a/Medium/Minimum Knight Moves.java +++ b/Medium/Minimum Knight Moves.java @@ -1,30 +1,30 @@ class Solution { - private final int[][] DIRS = {{1, 2}, {2, 1}, {1, -2}, {-2, 1}, {2, -1}, {-2, -1}, {-1, -2}, {-1, 2}}; - - public int minKnightMoves(int x, int y) { - int numOfSteps = 0; - boolean[][] visited = new boolean[607][607]; - Queue queue = new LinkedList<>(); - queue.add(new int[]{0, 0}); - while (!queue.isEmpty()) { - int size = queue.size(); - while (size-- > 0) { - int[] removed = queue.remove(); - if (removed[0] == x && removed[1] == y) { - return numOfSteps; + + private static final int[][] MOVES = {{1, 2}, {2, 1}, {2, -1}, {1, -2}, {-1, -2}, {-2, -1}, {-2, 1}, {-1, 2}}; + + public int minKnightMoves(int x, int y) { + boolean[][] visited = new boolean[607][607]; + Queue queue = new LinkedList<>(); + queue.add(new int[]{0, 0}); + int steps = 0; + while (!queue.isEmpty()) { + int size = queue.size(); + while (size-- > 0) { + int[] removed = queue.remove(); + if (removed[0] == x && removed[1] == y) { + return steps; + } + for (int[] move : MOVES) { + int newX = removed[0] + move[0]; + int newY = removed[1] + move[1]; + if (!visited[newX + 302][newY + 302]) { + visited[newX + 302][newY + 302] = true; + queue.add(new int[]{newX, newY}); + } + } + } + steps++; } - for (int[] dir : DIRS) { - int newX = removed[0] + dir[0]; - int newY = removed[1] + dir[1]; - if (visited[newX + 302][newY + 302]) { - continue; - } - visited[newX + 302][newY + 302] = true; - queue.add(new int[]{newX, newY}); - } - } - numOfSteps++; + return steps; } - return numOfSteps; - } } From 9d417554f8b3db6c721f4f9ee5e4c2e9f3d4055a Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Thu, 23 May 2024 07:41:33 -0700 Subject: [PATCH 532/712] Create The Number of Beautiful Subsets.java --- Medium/The Number of Beautiful Subsets.java | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) create mode 100644 Medium/The Number of Beautiful Subsets.java diff --git a/Medium/The Number of Beautiful Subsets.java b/Medium/The Number of Beautiful Subsets.java new file mode 100644 index 00000000..7057a18d --- /dev/null +++ b/Medium/The Number of Beautiful Subsets.java @@ -0,0 +1,20 @@ +class Solution { + public int beautifulSubsets(int[] nums, int k) { + Map freqMap = new HashMap<>(); + Arrays.sort(nums); + return countBeautifulSubsets(nums, k, freqMap, 0) - 1; + } + + private int countBeautifulSubsets(int[] nums, int k, Map freqMap, int idx) { + if (idx == nums.length) { + return 1; + } + int count = countBeautifulSubsets(nums, k, freqMap, idx + 1); + if (freqMap.getOrDefault(nums[idx] - k, 0) == 0) { + freqMap.put(nums[idx], freqMap.getOrDefault(nums[idx], 0) + 1); + count += countBeautifulSubsets(nums, k, freqMap, idx + 1); + freqMap.put(nums[idx], freqMap.getOrDefault(nums[idx], 0) - 1); + } + return count; + } +} From 447d746712a16287560af23e523a2641ac847f5e Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Wed, 29 May 2024 07:17:12 -0700 Subject: [PATCH 533/712] Create Number of Steps to Reduce a Number in Binary Representation to One.java --- ...umber in Binary Representation to One.java | 27 +++++++++++++++++++ 1 file changed, 27 insertions(+) create mode 100644 Medium/Number of Steps to Reduce a Number in Binary Representation to One.java diff --git a/Medium/Number of Steps to Reduce a Number in Binary Representation to One.java b/Medium/Number of Steps to Reduce a Number in Binary Representation to One.java new file mode 100644 index 00000000..00a8296a --- /dev/null +++ b/Medium/Number of Steps to Reduce a Number in Binary Representation to One.java @@ -0,0 +1,27 @@ +class Solution { + public int numSteps(String s) { + int operations = 0; + StringBuilder sb = new StringBuilder(s); + while (sb.length() > 1) { + int n = sb.length(); + if (sb.charAt(n - 1) == '0') { + // divide by 2 + sb.deleteCharAt(n - 1); + } else { + // add 1 + int idx = n - 1; + while (idx >= 0 && sb.charAt(idx) != '0') { + sb.setCharAt(idx, '0'); + idx--; + } + if (idx < 0) { + sb.insert(0, '1'); + } else { + sb.setCharAt(idx, '1'); + } + } + operations++; + } + return operations; + } +} From f967067bddf85a35522c0246e0a85386d0514cb8 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Wed, 29 May 2024 07:20:42 -0700 Subject: [PATCH 534/712] Create Find the Number of Good Pairs I.java --- Easy/Find the Number of Good Pairs I.java | 13 +++++++++++++ 1 file changed, 13 insertions(+) create mode 100644 Easy/Find the Number of Good Pairs I.java diff --git a/Easy/Find the Number of Good Pairs I.java b/Easy/Find the Number of Good Pairs I.java new file mode 100644 index 00000000..143d6abd --- /dev/null +++ b/Easy/Find the Number of Good Pairs I.java @@ -0,0 +1,13 @@ +class Solution { + public int numberOfPairs(int[] nums1, int[] nums2, int k) { + int count = 0; + for (int i = 0; i < nums1.length; i++) { + for (int j = 0; j < nums2.length; j++) { + if (nums1[i] % (nums2[j] * k) == 0) { + count++; + } + } + } + return count; + } +} From 010f42b1f2319b3f4f430b0377df571bf8998248 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Wed, 29 May 2024 07:22:58 -0700 Subject: [PATCH 535/712] Create Find the XOR of Numbers Which Appear Twice.java --- Easy/Find the XOR of Numbers Which Appear Twice.java | 12 ++++++++++++ 1 file changed, 12 insertions(+) create mode 100644 Easy/Find the XOR of Numbers Which Appear Twice.java diff --git a/Easy/Find the XOR of Numbers Which Appear Twice.java b/Easy/Find the XOR of Numbers Which Appear Twice.java new file mode 100644 index 00000000..baa845bc --- /dev/null +++ b/Easy/Find the XOR of Numbers Which Appear Twice.java @@ -0,0 +1,12 @@ +class Solution { + public int duplicateNumbersXOR(int[] nums) { + Set set = new HashSet<>(); + int xor = 0; + for (int num : nums) { + if (!set.add(num)) { + xor = xor ^ num; + } + } + return xor; + } +} From b4ddaff710706d5bd1804fd0a5de1ad1f7d36008 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sat, 1 Jun 2024 07:30:52 -0700 Subject: [PATCH 536/712] Create Longest Common Subsequence Between Sorted Arrays.java --- ... Common Subsequence Between Sorted Arrays.java | 15 +++++++++++++++ 1 file changed, 15 insertions(+) create mode 100644 Medium/Longest Common Subsequence Between Sorted Arrays.java diff --git a/Medium/Longest Common Subsequence Between Sorted Arrays.java b/Medium/Longest Common Subsequence Between Sorted Arrays.java new file mode 100644 index 00000000..d050d3fd --- /dev/null +++ b/Medium/Longest Common Subsequence Between Sorted Arrays.java @@ -0,0 +1,15 @@ +class Solution { + public List longestCommonSubsequence(int[][] arrays) { + List result = new ArrayList<>(); + Map map = new HashMap<>(); + for (int[] arr : arrays) { + for (int num : arr) { + map.put(num, map.getOrDefault(num, 0) + 1); + if (map.get(num) == arrays.length) { + result.add(num); + } + } + } + return result; + } +} From 210a81b9ad3d8a5ebb84ce6b546845641389dfe9 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 2 Jun 2024 07:31:09 -0700 Subject: [PATCH 537/712] Create Minimum Number of Chairs in a Waiting Room.java --- Easy/Minimum Number of Chairs in a Waiting Room.java | 11 +++++++++++ 1 file changed, 11 insertions(+) create mode 100644 Easy/Minimum Number of Chairs in a Waiting Room.java diff --git a/Easy/Minimum Number of Chairs in a Waiting Room.java b/Easy/Minimum Number of Chairs in a Waiting Room.java new file mode 100644 index 00000000..d7db8060 --- /dev/null +++ b/Easy/Minimum Number of Chairs in a Waiting Room.java @@ -0,0 +1,11 @@ +class Solution { + public int minimumChairs(String s) { + int requiredChairCount = 0; + int currChairCount = 0; + for (char c : s.toCharArray()) { + currChairCount += c == 'E' ? 1 : -1; + requiredChairCount = Math.max(requiredChairCount, currChairCount); + } + return requiredChairCount; + } +} From 4b1a03b1fdf1cb4b387ee4ff9b60d649971e3ab2 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Thu, 6 Jun 2024 07:16:35 -0700 Subject: [PATCH 538/712] Update Hand of Straights.java --- Medium/Hand of Straights.java | 53 ++++++++++++++++++----------------- 1 file changed, 28 insertions(+), 25 deletions(-) diff --git a/Medium/Hand of Straights.java b/Medium/Hand of Straights.java index ceff444a..5f407cf0 100644 --- a/Medium/Hand of Straights.java +++ b/Medium/Hand of Straights.java @@ -1,29 +1,32 @@ class Solution { - public boolean isNStraightHand(int[] hand, int W) { - if (hand.length % W != 0) { - return false; - } - Map counterMap = new HashMap<>(); - Set set = new TreeSet<>(); - for (int num : hand) { - counterMap.put(num, counterMap.getOrDefault(num, 0) + 1); - set.add(num); - } - Iterator iter = set.iterator(); - Integer curr = iter.next(); - while (counterMap.get(curr) > 0) { - int temp = curr; - for (int i = 0; i < W; i++) { - if (counterMap.getOrDefault(temp, 0) == 0) { - return false; + public boolean isNStraightHand(int[] hand, int groupSize) { + if (hand.length % groupSize != 0) { + return false; + } + Map map = new HashMap<>(); + for (int num : hand) { + map.put(num, map.getOrDefault(num, 0) + 1); + } + PriorityQueue pq = new PriorityQueue<>(map.keySet()); + while (!pq.isEmpty()) { + List temp = new ArrayList<>(); + int prev = -1; + for (int i = 0; i < groupSize; i++) { + if (pq.isEmpty()) { + return false; + } + int removed = pq.remove(); + map.put(removed, map.get(removed) - 1); + if (map.get(removed) > 0) { + temp.add(removed); + } + if (prev != -1 && removed != prev + 1) { + return false; + } + prev = removed; + } + pq.addAll(temp); } - counterMap.put(temp, counterMap.get(temp) - 1); - temp++; - } - while (iter.hasNext() && counterMap.get(curr) == 0) { - curr = iter.next(); - } + return true; } - return true; - } } From b8a29e6a085598af7c6d2190d18ca55a6cf29b74 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 9 Jun 2024 09:45:41 -0700 Subject: [PATCH 539/712] Create Substrings That Begin and End With the Same Letter.java --- ...ings That Begin and End With the Same Letter.java | 12 ++++++++++++ 1 file changed, 12 insertions(+) create mode 100644 Medium/Substrings That Begin and End With the Same Letter.java diff --git a/Medium/Substrings That Begin and End With the Same Letter.java b/Medium/Substrings That Begin and End With the Same Letter.java new file mode 100644 index 00000000..62c93389 --- /dev/null +++ b/Medium/Substrings That Begin and End With the Same Letter.java @@ -0,0 +1,12 @@ +class Solution { + public long numberOfSubstrings(String s) { + int n = s.length(); + long result = 0; + long[] prefixCount = new long[26]; + for (int i = 0; i < n; i++) { + prefixCount[s.charAt(i) - 'a']++; + result += prefixCount[s.charAt(i) - 'a']; + } + return result; + } +} From 91e35a8936aa0ff52ad594953550c2d52bf51edd Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 9 Jun 2024 09:50:21 -0700 Subject: [PATCH 540/712] Create Clear Digits.java --- Easy/Clear Digits.java | 15 +++++++++++++++ 1 file changed, 15 insertions(+) create mode 100644 Easy/Clear Digits.java diff --git a/Easy/Clear Digits.java b/Easy/Clear Digits.java new file mode 100644 index 00000000..1d308863 --- /dev/null +++ b/Easy/Clear Digits.java @@ -0,0 +1,15 @@ +class Solution { + public String clearDigits(String s) { + StringBuilder sb = new StringBuilder(); + for (char c : s.toCharArray()) { + if (Character.isDigit(c)) { + if (!sb.isEmpty()) { + sb.deleteCharAt(sb.length() - 1); + } + } else { + sb.append(c); + } + } + return sb.toString(); + } +} From 55d0ecf0bbc7bdd6ce5f35d61f761718679a9f0f Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 9 Jun 2024 09:54:37 -0700 Subject: [PATCH 541/712] Create Find the Child Who Has the Ball After K Seconds.java --- Easy/Find the Child Who Has the Ball After K Seconds.java | 7 +++++++ 1 file changed, 7 insertions(+) create mode 100644 Easy/Find the Child Who Has the Ball After K Seconds.java diff --git a/Easy/Find the Child Who Has the Ball After K Seconds.java b/Easy/Find the Child Who Has the Ball After K Seconds.java new file mode 100644 index 00000000..6a4c8193 --- /dev/null +++ b/Easy/Find the Child Who Has the Ball After K Seconds.java @@ -0,0 +1,7 @@ +class Solution { + public int numberOfChild(int n, int k) { + int factor = k / (n - 1); + int remainder = k % (n - 1); + return factor % 2 == 0 ? remainder : n - 1 - remainder; + } +} From 1cebeb3b089d01a796ed508a225ebdc7622d6a6f Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Wed, 12 Jun 2024 06:58:16 -0700 Subject: [PATCH 542/712] Create Find the N-th Value After K Seconds.java --- Medium/Find the N-th Value After K Seconds.java | 15 +++++++++++++++ 1 file changed, 15 insertions(+) create mode 100644 Medium/Find the N-th Value After K Seconds.java diff --git a/Medium/Find the N-th Value After K Seconds.java b/Medium/Find the N-th Value After K Seconds.java new file mode 100644 index 00000000..e457d0eb --- /dev/null +++ b/Medium/Find the N-th Value After K Seconds.java @@ -0,0 +1,15 @@ +class Solution { + + private final int MOD = 1000_000_007; + + public int valueAfterKSeconds(int n, int k) { + int[] arr = new int[n]; + Arrays.fill(arr, 1); + while (k-- > 0) { + for (int i = 1; i < n; i++) { + arr[i] = (arr[i] + arr[i - 1]) % MOD; + } + } + return arr[n - 1]; + } +} From 27aee486fa9a7ff0ca0cd9ff340e2c01e4bd1837 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Wed, 12 Jun 2024 07:05:31 -0700 Subject: [PATCH 543/712] Create Find The First Player to win K Games in a Row.java --- ... First Player to win K Games in a Row.java | 24 +++++++++++++++++++ 1 file changed, 24 insertions(+) create mode 100644 Medium/Find The First Player to win K Games in a Row.java diff --git a/Medium/Find The First Player to win K Games in a Row.java b/Medium/Find The First Player to win K Games in a Row.java new file mode 100644 index 00000000..fe26c684 --- /dev/null +++ b/Medium/Find The First Player to win K Games in a Row.java @@ -0,0 +1,24 @@ +class Solution { + public int findWinningPlayer(int[] skills, int k) { + Map indexMap = new HashMap<>(); + for (int i = 0; i < skills.length; i++) { + indexMap.put(skills[i], i); + } + Map winCountMap = new HashMap<>(); + Deque deque = new ArrayDeque<>(); + for (int num : skills) { + deque.addFirst(num); + } + while (deque.size() > 1) { + int first = deque.pollLast(); + int second = deque.pollLast(); + int winner = Math.max(first, second); + winCountMap.put(winner, winCountMap.getOrDefault(winner, 0) + 1); + deque.addLast(winner); + if (winCountMap.get(winner) == k) { + return indexMap.get(winner); + } + } + return indexMap.get(deque.poll()); + } +} From fd3899c2bb07e8518e8d2113f0fbe4439cc9efdd Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Fri, 14 Jun 2024 08:42:34 -0700 Subject: [PATCH 544/712] Create Minimum Increment to Make Array Unique.java --- Medium/Minimum Increment to Make Array Unique.java | 13 +++++++++++++ 1 file changed, 13 insertions(+) create mode 100644 Medium/Minimum Increment to Make Array Unique.java diff --git a/Medium/Minimum Increment to Make Array Unique.java b/Medium/Minimum Increment to Make Array Unique.java new file mode 100644 index 00000000..7be5a583 --- /dev/null +++ b/Medium/Minimum Increment to Make Array Unique.java @@ -0,0 +1,13 @@ +class Solution { + public int minIncrementForUnique(int[] nums) { + Arrays.sort(nums); + int increments = 0; + for (int i = 1; i < nums.length; i++) { + if (nums[i] <= nums[i - 1]) { + increments += nums[i - 1] + 1 - nums[i]; + nums[i] = nums[i - 1] + 1; + } + } + return increments; + } +} From a47c0009db592d3f446566f53352857df356918f Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sat, 15 Jun 2024 17:26:31 -0700 Subject: [PATCH 545/712] Create Patching Array.java --- Hard/Patching Array.java | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) create mode 100644 Hard/Patching Array.java diff --git a/Hard/Patching Array.java b/Hard/Patching Array.java new file mode 100644 index 00000000..6bf2a8ed --- /dev/null +++ b/Hard/Patching Array.java @@ -0,0 +1,16 @@ +class Solution { + public int minPatches(int[] nums, int n) { + int patches = 0; + long miss = 1; + int idx = 0; + while (miss <= n) { + if (idx < nums.length && nums[idx] <= miss) { + miss += nums[idx++]; + } else { + miss += miss; + patches++; + } + } + return patches; + } +} From 31a4de9251647d7d234fb336337751dd7152282b Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 16 Jun 2024 07:30:21 -0700 Subject: [PATCH 546/712] Create Count Pairs That Form a Complete Day I.java --- Easy/Count Pairs That Form a Complete Day I.java | 11 +++++++++++ 1 file changed, 11 insertions(+) create mode 100644 Easy/Count Pairs That Form a Complete Day I.java diff --git a/Easy/Count Pairs That Form a Complete Day I.java b/Easy/Count Pairs That Form a Complete Day I.java new file mode 100644 index 00000000..785a5937 --- /dev/null +++ b/Easy/Count Pairs That Form a Complete Day I.java @@ -0,0 +1,11 @@ +class Solution { + public int countCompleteDayPairs(int[] hours) { + int count = 0; + Map map = new HashMap<>(); + for (int hour : hours) { + count += map.getOrDefault((24 - hour % 24) % 24, 0); + map.put(hour % 24, map.getOrDefault(hour % 24, 0) + 1); + } + return count; + } +} From 33be1b9c03a87638dd9b6e377216ff771e5f915c Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Mon, 17 Jun 2024 06:33:01 -0700 Subject: [PATCH 547/712] Update and rename Sum of Square Numbers.java to Sum of Square Numbers.java --- Easy/Sum of Square Numbers.java | 17 ----------------- Medium/Sum of Square Numbers.java | 18 ++++++++++++++++++ 2 files changed, 18 insertions(+), 17 deletions(-) delete mode 100644 Easy/Sum of Square Numbers.java create mode 100644 Medium/Sum of Square Numbers.java diff --git a/Easy/Sum of Square Numbers.java b/Easy/Sum of Square Numbers.java deleted file mode 100644 index 61e26dde..00000000 --- a/Easy/Sum of Square Numbers.java +++ /dev/null @@ -1,17 +0,0 @@ -class Solution { - public boolean judgeSquareSum(int c) { - int left = 0; - int right = (int) Math.sqrt(c); - while (left <= right) { - int currSquareSum = left * left + right * right; - if (currSquareSum < c) { - left++; - } else if (currSquareSum > c) { - right--; - } else { - return true; - } - } - return false; - } -} diff --git a/Medium/Sum of Square Numbers.java b/Medium/Sum of Square Numbers.java new file mode 100644 index 00000000..13f138c2 --- /dev/null +++ b/Medium/Sum of Square Numbers.java @@ -0,0 +1,18 @@ +class Solution { + public boolean judgeSquareSum(int c) { + long left = 0; + long right = (long) Math.sqrt(c); + while (left <= right) { + long sum = left * left + right * right; + if (sum == c) { + return true; + } + if (sum > c) { + right--; + } else { + left++; + } + } + return false; + } +} From afa6897e96bfbbdb962b93586795c73bee61c0ec Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Wed, 19 Jun 2024 13:30:47 -0700 Subject: [PATCH 548/712] Create Minimum Number of Days to Make m Bouquets.java --- ...mum Number of Days to Make m Bouquets.java | 37 +++++++++++++++++++ 1 file changed, 37 insertions(+) create mode 100644 Medium/Minimum Number of Days to Make m Bouquets.java diff --git a/Medium/Minimum Number of Days to Make m Bouquets.java b/Medium/Minimum Number of Days to Make m Bouquets.java new file mode 100644 index 00000000..83578712 --- /dev/null +++ b/Medium/Minimum Number of Days to Make m Bouquets.java @@ -0,0 +1,37 @@ +class Solution { + public int minDays(int[] bloomDay, int m, int k) { + int left = 0; + int right = 0; + for (int day : bloomDay) { + right = Math.max(right, day); + } + int days = -1; + while (left <= right) { + int mid = (left + right) / 2; + if (numberOfBouquet(bloomDay, mid, k) >= m) { + days = mid; + right = mid - 1; + } else { + left = mid + 1; + } + } + return days; + } + + private int numberOfBouquet(int[] bloomDay, int mid, int k) { + int bouquetCount = 0; + int count = 0; + for (int i = 0; i < bloomDay.length; i++) { + if (bloomDay[i] <= mid) { + count++; + } else { + count = 0; + } + if (count == k) { + bouquetCount++; + count = 0; + } + } + return bouquetCount; + } +} From 865f81f10f77b149e5e6619ef81884ff8f4b8834 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Thu, 20 Jun 2024 14:07:47 -0700 Subject: [PATCH 549/712] Create Magnetic Force Between Two Balls.java --- Medium/Magnetic Force Between Two Balls.java | 32 ++++++++++++++++++++ 1 file changed, 32 insertions(+) create mode 100644 Medium/Magnetic Force Between Two Balls.java diff --git a/Medium/Magnetic Force Between Two Balls.java b/Medium/Magnetic Force Between Two Balls.java new file mode 100644 index 00000000..9ca9708b --- /dev/null +++ b/Medium/Magnetic Force Between Two Balls.java @@ -0,0 +1,32 @@ +class Solution { + public int maxDistance(int[] position, int m) { + int result = 0; + int n = position.length; + Arrays.sort(position); + int left = 1; + int right = (int) Math.ceil(position[n - 1] / (m - 1.0)); + while (left <= right) { + int mid = (left + right) / 2; + if (isPossible(position, mid, m)) { + result = mid; + left = mid + 1; + } else { + right = mid - 1; + } + } + return result; + } + + private boolean isPossible(int[] position, int distance, int m) { + int prevBall = position[0]; + int ballCount = 1; + for (int i = 1; i < position.length && ballCount < m; i++) { + int curr = position[i]; + if (curr - prevBall >= distance) { + ballCount++; + prevBall = curr; + } + } + return ballCount == m; + } +} From 397b6b81b5f0cf0f9809e9b72e969743f81e7ab5 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sat, 22 Jun 2024 08:48:10 -0700 Subject: [PATCH 550/712] Create Count Number of Nice Subarrays.java --- Medium/Count Number of Nice Subarrays.java | 14 ++++++++++++++ 1 file changed, 14 insertions(+) create mode 100644 Medium/Count Number of Nice Subarrays.java diff --git a/Medium/Count Number of Nice Subarrays.java b/Medium/Count Number of Nice Subarrays.java new file mode 100644 index 00000000..e2648bd3 --- /dev/null +++ b/Medium/Count Number of Nice Subarrays.java @@ -0,0 +1,14 @@ +class Solution { + public int numberOfSubarrays(int[] nums, int k) { + int sum = 0; + int count = 0; + Map map = new HashMap<>(); + map.put(sum, 1); + for (int i = 0; i < nums.length; i++) { + sum += nums[i] % 2; + count += map.getOrDefault(sum - k, 0); + map.put(sum, map.getOrDefault(sum, 0) + 1); + } + return count; + } +} From 2c963723a148f3d328299c9aa14263a243ba20ba Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sat, 22 Jun 2024 10:49:45 -0700 Subject: [PATCH 551/712] Create Find Minimum Operations to Make All Elements Divisible by Three.java --- ...tions to Make All Elements Divisible by Three.java | 11 +++++++++++ 1 file changed, 11 insertions(+) create mode 100644 Easy/Find Minimum Operations to Make All Elements Divisible by Three.java diff --git a/Easy/Find Minimum Operations to Make All Elements Divisible by Three.java b/Easy/Find Minimum Operations to Make All Elements Divisible by Three.java new file mode 100644 index 00000000..c8d6f59e --- /dev/null +++ b/Easy/Find Minimum Operations to Make All Elements Divisible by Three.java @@ -0,0 +1,11 @@ +class Solution { + public int minimumOperations(int[] nums) { + int count = 0; + for (int num : nums) { + if (num % 3 != 0) { + count++; + } + } + return count; + } +} From d5206efa86285870633ce24b787c615174e262bc Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sat, 22 Jun 2024 10:59:45 -0700 Subject: [PATCH 552/712] Create Count Substrings Without Repeating Character.java --- ...ubstrings Without Repeating Character.java | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) create mode 100644 Medium/Count Substrings Without Repeating Character.java diff --git a/Medium/Count Substrings Without Repeating Character.java b/Medium/Count Substrings Without Repeating Character.java new file mode 100644 index 00000000..6ffcf7cd --- /dev/null +++ b/Medium/Count Substrings Without Repeating Character.java @@ -0,0 +1,19 @@ +class Solution { + public int numberOfSpecialSubstrings(String s) { + int start = 0; + int end = 0; + int n = s.length(); + int result = 0; + Map map = new HashMap<>(); + while (end < n) { + map.put(s.charAt(end), map.getOrDefault(s.charAt(end), 0) + 1); + while (start < end && map.get(s.charAt(end)) > 1) { + map.put(s.charAt(start), map.get(s.charAt(start)) - 1); + start++; + } + end++; + result += end - start; + } + return result; + } +} From 1063dfd5b34ccff45628bd431e23aa294b43ff40 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Mon, 24 Jun 2024 07:46:06 -0700 Subject: [PATCH 553/712] Create Minimum Average of Smallest and Largest Elements.java --- ... Average of Smallest and Largest Elements.java | 15 +++++++++++++++ 1 file changed, 15 insertions(+) create mode 100644 Easy/Minimum Average of Smallest and Largest Elements.java diff --git a/Easy/Minimum Average of Smallest and Largest Elements.java b/Easy/Minimum Average of Smallest and Largest Elements.java new file mode 100644 index 00000000..f1fd9e2d --- /dev/null +++ b/Easy/Minimum Average of Smallest and Largest Elements.java @@ -0,0 +1,15 @@ +class Solution { + public double minimumAverage(int[] nums) { + double minAverage = Double.MAX_VALUE; + Arrays.sort(nums); + int left = 0; + int right = nums.length - 1; + while (left < right) { + double average = (nums[left] + nums[right]) / 2.0; + minAverage = Math.min(minAverage, average); + left++; + right--; + } + return minAverage; + } +} From 35ee9b003d7dd5e17a732680fd195e2a75fe2c37 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Tue, 25 Jun 2024 07:18:51 -0700 Subject: [PATCH 554/712] Create Find the Minimum Area to Cover All Ones I.java --- ... the Minimum Area to Cover All Ones I.java | 24 +++++++++++++++++++ 1 file changed, 24 insertions(+) create mode 100644 Medium/Find the Minimum Area to Cover All Ones I.java diff --git a/Medium/Find the Minimum Area to Cover All Ones I.java b/Medium/Find the Minimum Area to Cover All Ones I.java new file mode 100644 index 00000000..538bf894 --- /dev/null +++ b/Medium/Find the Minimum Area to Cover All Ones I.java @@ -0,0 +1,24 @@ +class Solution { + public int minimumArea(int[][] grid) { + int minRow = Integer.MAX_VALUE; + int minCol = Integer.MAX_VALUE; + int maxRow = Integer.MIN_VALUE; + int maxCol = Integer.MIN_VALUE; + for (int i = 0; i < grid.length; i++) { + for (int j = 0; j < grid[0].length; j++) { + if (grid[i][j] == 1) { + minRow = Math.min(minRow, i); + minCol = Math.min(minCol, j); + maxRow = Math.max(maxRow, i); + maxCol = Math.max(maxCol, j); + } + } + } + if (minRow == Integer.MAX_VALUE) { + return 0; + } + int length = maxRow - minRow + 1; + int breadth = maxCol - minCol + 1; + return length * breadth; + } +} From acfa4c155ad1e7a95a28695f1d142b6fe80fbd7d Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Tue, 25 Jun 2024 18:09:27 -0700 Subject: [PATCH 555/712] Update Balance a Binary Search Tree.java --- Medium/Balance a Binary Search Tree.java | 54 ++++++++++++++---------- 1 file changed, 31 insertions(+), 23 deletions(-) diff --git a/Medium/Balance a Binary Search Tree.java b/Medium/Balance a Binary Search Tree.java index 9fbf14ce..dd07996e 100644 --- a/Medium/Balance a Binary Search Tree.java +++ b/Medium/Balance a Binary Search Tree.java @@ -14,29 +14,37 @@ * } */ class Solution { - public TreeNode balanceBST(TreeNode root) { - List sortedList = new ArrayList<>(); - inorderTraversal(root, sortedList); - return buildBST(sortedList, 0, sortedList.size() - 1); - } - - private TreeNode buildBST(List sortedList, int start, int end) { - if (start > end) { - return null; + public TreeNode balanceBST(TreeNode root) { + List inorder = getInorderNodes(root); + return createBST(inorder, 0, inorder.size() - 1); } - int mid = (start + end) / 2; - TreeNode root = new TreeNode(sortedList.get(mid)); - root.left = buildBST(sortedList, start, mid - 1); - root.right = buildBST(sortedList, mid + 1, end); - return root; - } - - private void inorderTraversal(TreeNode root, List sortedList) { - if (root == null) { - return; + + private List getInorderNodes(TreeNode root) { + Stack stack = new Stack<>(); + while (root != null) { + stack.push(root); + root = root.left; + } + List list = new ArrayList<>(); + while (!stack.isEmpty()) { + TreeNode node = stack.pop(); + list.add(node.val); + TreeNode rightNode = node.right; + while (rightNode != null) { + stack.push(rightNode); + rightNode = rightNode.left; + } + } + return list; + } + + private TreeNode createBST(List list, int start, int end) { + if (start > end) { + return null; + } + int mid = (start + end) / 2; + TreeNode leftTree = createBST(list, start, mid - 1); + TreeNode rightTree = createBST(list, mid + 1, end); + return new TreeNode(list.get(mid), leftTree, rightTree); } - inorderTraversal(root.left, sortedList); - sortedList.add(root.val); - inorderTraversal(root.right, sortedList); - } } From a116f9b3c5fa4477a54e5ebef4531f46ddfecdd5 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Wed, 26 Jun 2024 07:21:54 -0700 Subject: [PATCH 556/712] Create Minimum Operations to Make Binary Array Elements Equal to One I.java --- ... Binary Array Elements Equal to One I.java | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) create mode 100644 Medium/Minimum Operations to Make Binary Array Elements Equal to One I.java diff --git a/Medium/Minimum Operations to Make Binary Array Elements Equal to One I.java b/Medium/Minimum Operations to Make Binary Array Elements Equal to One I.java new file mode 100644 index 00000000..4b5b20a1 --- /dev/null +++ b/Medium/Minimum Operations to Make Binary Array Elements Equal to One I.java @@ -0,0 +1,19 @@ +class Solution { + public int minOperations(int[] nums) { + int count = 0; + for (int i = 0; i <= nums.length - 3; i++) { + if (nums[i] == 0) { + nums[i] = nums[i] == 0 ? 1 : 0; + nums[i + 1] = nums[i + 1] == 0 ? 1 : 0; + nums[i + 2] = nums[i + 2] == 0 ? 1 : 0; + count++; + } + } + for (int i = nums.length - 3; i < nums.length; i++) { + if (nums[i] == 0) { + return -1; + } + } + return count; + } +} From f981b3283fbd6a9bd483a813cd1c502c3e27de67 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Thu, 27 Jun 2024 06:32:40 -0700 Subject: [PATCH 557/712] Update Find Center of Star Graph.java --- Medium/Find Center of Star Graph.java | 23 +++++++++++++---------- 1 file changed, 13 insertions(+), 10 deletions(-) diff --git a/Medium/Find Center of Star Graph.java b/Medium/Find Center of Star Graph.java index f3f6de5a..8270ad2d 100644 --- a/Medium/Find Center of Star Graph.java +++ b/Medium/Find Center of Star Graph.java @@ -1,13 +1,16 @@ -import java.util.Map.Entry; - class Solution { - public int findCenter(int[][] edges) { - Map> map = new HashMap<>(); - for (int[] edge : edges) { - map.computeIfAbsent(edge[0], k -> new HashSet<>()).add(edge[1]); - map.computeIfAbsent(edge[1], k -> new HashSet<>()).add(edge[0]); + public int findCenter(int[][] edges) { + Map map = new HashMap<>(); + int n = edges.length; + for (int[] edge : edges) { + map.put(edge[0], map.getOrDefault(edge[0], 0) + 1); + map.put(edge[1], map.getOrDefault(edge[1], 0) + 1); + } + for (Integer key : map.keySet()) { + if (map.get(key) == n) { + return key; + } + } + return -1; } - return map.entrySet().stream().filter(entry -> entry.getValue().size() == edges.length).map( - Entry::getKey).findFirst().orElse(-1); - } } From 41b043a398434deca08dd2d99c179d1fc1c2a3a9 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sat, 29 Jun 2024 12:53:22 -0700 Subject: [PATCH 558/712] Update All Ancestors of a Node in a Directed Acyclic Graph.java --- ...of a Node in a Directed Acyclic Graph.java | 54 +++++++++++-------- 1 file changed, 32 insertions(+), 22 deletions(-) diff --git a/Medium/All Ancestors of a Node in a Directed Acyclic Graph.java b/Medium/All Ancestors of a Node in a Directed Acyclic Graph.java index 60ab5900..36063815 100644 --- a/Medium/All Ancestors of a Node in a Directed Acyclic Graph.java +++ b/Medium/All Ancestors of a Node in a Directed Acyclic Graph.java @@ -1,26 +1,36 @@ class Solution { - public List> getAncestors(int n, int[][] edges) { - Map> graph = new HashMap<>(); - for (int[] edge : edges) { - graph.computeIfAbsent(edge[1], k -> new ArrayList<>()).add(edge[0]); - } - List> result = new ArrayList<>(); - for (int i = 0; i < n; i++) { - List ancestors = new ArrayList<>(); - Set visited = new HashSet<>(); - Queue queue = new LinkedList<>(graph.getOrDefault(i, new ArrayList<>())); - while (!queue.isEmpty()) { - int removed = queue.remove(); - if (visited.contains(removed)) { - continue; + public List> getAncestors(int n, int[][] edges) { + Map> graph = new HashMap<>(); + int[] indegree = new int[n]; + for (int[] edge : edges) { + graph.computeIfAbsent(edge[0], k -> new ArrayList<>()).add(edge[1]); + indegree[edge[1]]++; + } + Queue queue = new LinkedList<>(); + Map> ancestors = new HashMap<>(); + for (int i = 0; i < n; i++) { + if (indegree[i] == 0) { + queue.offer(i); + } + } + while (!queue.isEmpty()) { + int node = queue.poll(); + ancestors.computeIfAbsent(node, k -> new HashSet<>()); + for (int dependents : graph.getOrDefault(node, Collections.emptyList())) { + ancestors.computeIfAbsent(dependents, k -> new HashSet<>()).add(node); + ancestors.get(dependents).addAll(ancestors.get(node)); + indegree[dependents]--; + if (indegree[dependents] == 0) { + queue.offer(dependents); + } + } + } + List> result = new ArrayList<>(); + for (int i = 0; i < n; i++) { + List currNodeAncestors = new ArrayList<>(ancestors.getOrDefault(i, Collections.emptySet())); + currNodeAncestors.sort(Comparator.naturalOrder()); + result.add(currNodeAncestors); } - ancestors.add(removed); - visited.add(removed); - queue.addAll(graph.getOrDefault(removed, new ArrayList<>())); - } - Collections.sort(ancestors); - result.add(ancestors); + return result; } - return result; - } } From 60879733e7648f86e0b1fbc071ad7f72ea520c35 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Mon, 1 Jul 2024 07:21:18 -0700 Subject: [PATCH 559/712] Update The Earliest Moment When Everyone Become Friends.java --- ...t Moment When Everyone Become Friends.java | 78 ++++++++----------- 1 file changed, 33 insertions(+), 45 deletions(-) diff --git a/Medium/The Earliest Moment When Everyone Become Friends.java b/Medium/The Earliest Moment When Everyone Become Friends.java index 578a04cb..8de3e818 100644 --- a/Medium/The Earliest Moment When Everyone Become Friends.java +++ b/Medium/The Earliest Moment When Everyone Become Friends.java @@ -1,54 +1,42 @@ class Solution { - public int earliestAcq(int[][] logs, int n) { - Arrays.sort(logs, Comparator.comparingInt(o -> o[0])); - DisjointSet disjointSet = new DisjointSet(n); - for (int[] log : logs) { - disjointSet.union(log[1], log[2]); - if (disjointSet.unionCount == 1) { - return log[0]; - } + public int earliestAcq(int[][] logs, int n) { + Arrays.sort(logs, Comparator.comparingInt(a -> a[0])); + UnionFind uf = new UnionFind(n); + for (int[] log : logs) { + uf.union(log[1], log[2]); + if (uf.count == 1) { + return log[0]; + } + } + return -1; } - return -1; - } - - private static final class DisjointSet { - private final int[] root; - private final int[] rank; - public int unionCount; - - public DisjointSet(int size) { - this.root = new int[size]; - this.rank = new int[size]; - for (int i = 0; i < size; i++) { - this.root[i] = i; - this.rank[i] = 1; - } - this.unionCount = size; - } + static class UnionFind { + private final int[] parent; + private int count; - public void union(int nodeOne, int nodeTwo) { - int rootOne = find(nodeOne); - int rootTwo = find(nodeTwo); - if (rootOne != rootTwo) { - if (this.rank[rootOne] > this.rank[rootTwo]) { - this.root[rootTwo] = rootOne; - } else if (this.rank[rootOne] < this.rank[rootTwo]) { - this.root[rootOne] = rootTwo; - } else { - this.root[rootTwo] = rootOne; - this.rank[rootOne]++; + public UnionFind(int n) { + parent = new int[n]; + count = n; + for (int i = 0; i < n; i++) { + parent[i] = i; + } } - this.unionCount--; - } - } + public int find(int node) { + if (parent[node] != node) { + parent[node] = find(parent[node]); + } + return parent[node]; + } - public int find(int node) { - if (node == root[node]) { - return node; - } - return root[node] = find(root[node]); + public void union(int x, int y) { + int rootX = find(x); + int rootY = find(y); + if (rootX != rootY) { + parent[rootX] = rootY; + count--; + } + } } - } } From 568f9bad22717e799a2aa1b910df29b14f92f5a2 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Wed, 3 Jul 2024 07:40:43 -0700 Subject: [PATCH 560/712] Create Minimum Difference Between Largest and Smallest Value in Three Moves.java --- ...argest and Smallest Value in Three Moves.java | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) create mode 100644 Medium/Minimum Difference Between Largest and Smallest Value in Three Moves.java diff --git a/Medium/Minimum Difference Between Largest and Smallest Value in Three Moves.java b/Medium/Minimum Difference Between Largest and Smallest Value in Three Moves.java new file mode 100644 index 00000000..2722191a --- /dev/null +++ b/Medium/Minimum Difference Between Largest and Smallest Value in Three Moves.java @@ -0,0 +1,16 @@ +class Solution { + public int minDifference(int[] nums) { + int n = nums.length; + if (n <= 4) { + return 0; + } + Arrays.sort(nums); + int minDiff = Integer.MAX_VALUE; + int left = 0; + int right = n - 4; + while (left < 4) { + minDiff = Math.min(minDiff, nums[right++] - nums[left++]); + } + return minDiff; + } +} From 86ad1a23993e937706f6572c2b10bc6ba012ee07 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Mon, 8 Jul 2024 13:39:33 -0700 Subject: [PATCH 561/712] Create Find the Winner of the Circular Game.java --- Medium/Find the Winner of the Circular Game.java | 15 +++++++++++++++ 1 file changed, 15 insertions(+) create mode 100644 Medium/Find the Winner of the Circular Game.java diff --git a/Medium/Find the Winner of the Circular Game.java b/Medium/Find the Winner of the Circular Game.java new file mode 100644 index 00000000..816b3aa4 --- /dev/null +++ b/Medium/Find the Winner of the Circular Game.java @@ -0,0 +1,15 @@ +class Solution { + public int findTheWinner(int n, int k) { + Queue circle = new LinkedList<>(); + for (int i = 1; i <= n; i++) { + circle.add(i); + } + while (circle.size() > 1) { + for (int i = 0; i < k - 1; i++) { + circle.add(circle.remove()); + } + circle.remove(); + } + return circle.peek(); + } +} From be7bd21bae156c80b5d304f095e4c1c7c3c1a9ba Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Tue, 9 Jul 2024 16:31:31 -0700 Subject: [PATCH 562/712] Update Remove Duplicates From an Unsorted Linked List.java --- ...plicates From an Unsorted Linked List.java | 46 +++++++++---------- 1 file changed, 22 insertions(+), 24 deletions(-) diff --git a/Medium/Remove Duplicates From an Unsorted Linked List.java b/Medium/Remove Duplicates From an Unsorted Linked List.java index e62d60c7..18308224 100644 --- a/Medium/Remove Duplicates From an Unsorted Linked List.java +++ b/Medium/Remove Duplicates From an Unsorted Linked List.java @@ -9,31 +9,29 @@ * } */ class Solution { - public ListNode deleteDuplicatesUnsorted(ListNode head) { - Map map = new HashMap<>(); - ListNode curr = head; - while (curr != null) { - map.put(curr.val, map.getOrDefault(curr.val, 0) + 1); - curr = curr.next; - } - curr = head; - ListNode newHead = null; - ListNode prev = null; - while (curr != null) { - if (map.get(curr.val) > 1) { - ListNode nextNode = curr.next; - if (prev != null) { - prev.next = nextNode; + public ListNode deleteDuplicatesUnsorted(ListNode head) { + Map map = new HashMap<>(); + ListNode curr = head; + while (curr != null) { + map.put(curr.val, map.getOrDefault(curr.val, 0) + 1); + curr = curr.next; } - curr = nextNode; - } else { - if (newHead == null) { - newHead = curr; + curr = head; + ListNode prev = null; + ListNode newHead = null; + while (curr != null) { + if (map.get(curr.val) > 1) { + if (prev != null) { + prev.next = curr.next; + } + } else { + prev = curr; + if (newHead == null) { + newHead = curr; + } + } + curr = curr.next; } - prev = curr; - curr = curr.next; - } + return newHead; } - return newHead; - } } From 3625ba91340dcefb6ff2183a75d4c7e333dc7481 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Fri, 12 Jul 2024 06:50:40 -0700 Subject: [PATCH 563/712] Create Maximum Score From Removing Substrings.java --- ...aximum Score From Removing Substrings.java | 29 +++++++++++++++++++ 1 file changed, 29 insertions(+) create mode 100644 Medium/Maximum Score From Removing Substrings.java diff --git a/Medium/Maximum Score From Removing Substrings.java b/Medium/Maximum Score From Removing Substrings.java new file mode 100644 index 00000000..0f7ccf87 --- /dev/null +++ b/Medium/Maximum Score From Removing Substrings.java @@ -0,0 +1,29 @@ +class Solution { + public int maximumGain(String s, int x, int y) { + int score = 0; + String firstPass = removeSubstring(s, x > y ? "ab" : "ba"); + int removeCount = (s.length() - firstPass.length()) / 2; + score += removeCount * Math.max(x, y); + String secondPass = removeSubstring(firstPass, x > y ? "ba" : "ab"); + removeCount = (firstPass.length() - secondPass.length()) / 2; + score += removeCount * Math.min(x, y); + return score; + } + + private String removeSubstring(String s, String target) { + Stack stack = new Stack<>(); + for (int i = 0; i < s.length(); i++) { + char c = s.charAt(i); + if (c == target.charAt(1) && !stack.isEmpty() && stack.peek() == target.charAt(0)) { + stack.pop(); + } else { + stack.push(c); + } + } + StringBuilder sb = new StringBuilder(); + while (!stack.isEmpty()) { + sb.append(stack.pop()); + } + return sb.reverse().toString(); + } +} From df3dac19974910cc81c4c737a0ee85245adf5685 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sat, 13 Jul 2024 10:03:58 -0700 Subject: [PATCH 564/712] Create Robot Collisions.java --- Hard/Robot Collisions.java | 38 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 38 insertions(+) create mode 100644 Hard/Robot Collisions.java diff --git a/Hard/Robot Collisions.java b/Hard/Robot Collisions.java new file mode 100644 index 00000000..4202122c --- /dev/null +++ b/Hard/Robot Collisions.java @@ -0,0 +1,38 @@ +class Solution { + public List survivedRobotsHealths(int[] positions, int[] healths, String directions) { + int n = positions.length; + Integer[] indices = new Integer[n]; + for (int i = 0; i < n; i++) { + indices[i] = i; + } + Arrays.sort(indices, (a, b) -> Integer.compare(positions[a], positions[b])); + Stack stack = new Stack<>(); + for (Integer index : indices) { + if (directions.charAt(index) == 'R') { + stack.push(index); + } else { + while (!stack.isEmpty() && healths[index] > 0) { + int poppedIndex = stack.pop(); + if (healths[poppedIndex] > healths[index]) { + healths[poppedIndex]--; + healths[index] = 0; + stack.push(poppedIndex); + } else if (healths[poppedIndex] < healths[index]) { + healths[index]--; + healths[poppedIndex] = 0; + } else { + healths[poppedIndex] = 0; + healths[index] = 0; + } + } + } + } + List result = new ArrayList<>(); + for (int i = 0; i < n; i++) { + if (healths[i] > 0) { + result.add(healths[i]); + } + } + return result; + } +} From 62f366439d3bdf7e63794356eb1c544a3b5afef4 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sat, 13 Jul 2024 17:34:13 -0700 Subject: [PATCH 565/712] Create Maximum Points After Enemy Battles.java --- Medium/Maximum Points After Enemy Battles.java | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) create mode 100644 Medium/Maximum Points After Enemy Battles.java diff --git a/Medium/Maximum Points After Enemy Battles.java b/Medium/Maximum Points After Enemy Battles.java new file mode 100644 index 00000000..2358cd8f --- /dev/null +++ b/Medium/Maximum Points After Enemy Battles.java @@ -0,0 +1,16 @@ +class Solution { + public long maximumPoints(int[] enemyEnergies, int currentEnergy) { + long sum = 0; + int minimumEnergy = Integer.MAX_VALUE; + for (int energy : enemyEnergies) { + sum += energy; + minimumEnergy = Math.min(minimumEnergy, energy); + } + if (currentEnergy < minimumEnergy) { + return 0; + } + long totalEnergy = currentEnergy; + totalEnergy += sum - minimumEnergy; + return totalEnergy / minimumEnergy; + } +} From 57435b89c7cbca66b994cf2f3c05de888bf3c924 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Wed, 17 Jul 2024 07:12:38 -0700 Subject: [PATCH 566/712] Update Delete Nodes And Return Forest.java --- Medium/Delete Nodes And Return Forest.java | 53 +++++++++++----------- 1 file changed, 27 insertions(+), 26 deletions(-) diff --git a/Medium/Delete Nodes And Return Forest.java b/Medium/Delete Nodes And Return Forest.java index c3ec8f1b..344770b5 100644 --- a/Medium/Delete Nodes And Return Forest.java +++ b/Medium/Delete Nodes And Return Forest.java @@ -14,33 +14,34 @@ * } */ class Solution { - public List delNodes(TreeNode root, int[] to_delete) { - List result = new ArrayList<>(); - Set deleteSet = Arrays.stream(to_delete).boxed().collect(Collectors.toSet()); - helper(root, deleteSet, result, null); - return result; - } - - private void helper(TreeNode node, Set deleteSet, List result, TreeNode parent) { - if (node == null) { - return; + public List delNodes(TreeNode root, int[] toDelete) { + Set set = new HashSet<>(); + for (int val : toDelete) { + set.add(val); + } + List result = new ArrayList<>(); + recurse(root, result, set, null); + return result; } - TreeNode nextParent = null; - if (deleteSet.contains(node.val)) { - if (parent != null) { - if (parent.left == node) { - parent.left = null; - } else { - parent.right = null; + + private void recurse(TreeNode root, List result, Set set, TreeNode parent) { + if (root == null) { + return; + } + if (set.contains(root.val)) { + if (parent != null && parent.left == root) { + parent.left = null; + } else if (parent != null && parent.right == root) { + parent.right = null; + } + recurse(root.left, result, set, null); + recurse(root.right, result, set, null); + return; + } + if (parent == null) { + result.add(root); } - } - } else { - if (parent == null) { - result.add(node); - } - nextParent = node; + recurse(root.left, result, set, root); + recurse(root.right, result, set, root); } - helper(node.left, deleteSet, result, nextParent); - helper(node.right, deleteSet, result, nextParent); - } } From e69114728912b48564c236b4744428d4aecccfb2 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Mon, 22 Jul 2024 07:35:17 -0700 Subject: [PATCH 567/712] Create Number of Good Leaf Nodes Pairs.java --- Medium/Number of Good Leaf Nodes Pairs.java | 59 +++++++++++++++++++++ 1 file changed, 59 insertions(+) create mode 100644 Medium/Number of Good Leaf Nodes Pairs.java diff --git a/Medium/Number of Good Leaf Nodes Pairs.java b/Medium/Number of Good Leaf Nodes Pairs.java new file mode 100644 index 00000000..c54d967f --- /dev/null +++ b/Medium/Number of Good Leaf Nodes Pairs.java @@ -0,0 +1,59 @@ +/** + * Definition for a binary tree node. + * public class TreeNode { + * int val; + * TreeNode left; + * TreeNode right; + * TreeNode() {} + * TreeNode(int val) { this.val = val; } + * TreeNode(int val, TreeNode left, TreeNode right) { + * this.val = val; + * this.left = left; + * this.right = right; + * } + * } + */ +class Solution { + public int countPairs(TreeNode root, int distance) { + Map> graph = new HashMap<>(); + Set leaves = new HashSet<>(); + traverse(root, null, graph, leaves); + int result = 0; + for (TreeNode leaf : leaves) { + Queue queue = new LinkedList<>(); + Set visited = new HashSet<>(); + queue.add(leaf); + visited.add(leaf); + for (int i = 0; i <= distance; i++) { + int size = queue.size(); + while (size-- > 0) { + TreeNode curr = queue.remove(); + if (leaves.contains(curr) && curr != leaf) { + result++; + } + for (TreeNode neighbor : graph.getOrDefault(curr, new ArrayList<>())) { + if (visited.add(neighbor)) { + queue.add(neighbor); + } + } + } + } + } + return result / 2; + } + + private void traverse(TreeNode node, TreeNode parent, Map> graph, Set leaves) { + if (node == null) { + return; + } + if (node.left == null && node.right == null) { + leaves.add(node); + } + if (parent != null) { + graph.computeIfAbsent(parent, k -> new ArrayList<>()).add(node); + graph.computeIfAbsent(node, k -> new ArrayList<>()).add(parent); + } + traverse(node.left, node, graph, leaves); + traverse(node.right, node, graph, leaves); + } +} From 9800de288ad74098afb62b6eebe3ffa044f9604a Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 28 Jul 2024 13:44:49 -0700 Subject: [PATCH 568/712] Create Find if Digit Game Can Be Won.java --- Easy/Find if Digit Game Can Be Won.java | 14 ++++++++++++++ 1 file changed, 14 insertions(+) create mode 100644 Easy/Find if Digit Game Can Be Won.java diff --git a/Easy/Find if Digit Game Can Be Won.java b/Easy/Find if Digit Game Can Be Won.java new file mode 100644 index 00000000..22c76892 --- /dev/null +++ b/Easy/Find if Digit Game Can Be Won.java @@ -0,0 +1,14 @@ +class Solution { + public boolean canAliceWin(int[] nums) { + int singleDigitSum = 0; + int doubleDigitSum = 0; + for (int num : nums) { + if (String.valueOf(num).length() > 1) { + doubleDigitSum += num; + } else { + singleDigitSum += num; + } + } + return singleDigitSum > doubleDigitSum || doubleDigitSum > singleDigitSum; + } +} From c977c77ff129b5957082b1134361538b9ef997d1 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sat, 3 Aug 2024 09:43:37 -0700 Subject: [PATCH 569/712] Create Make Two Arrays Equal by Reversing Subarrays.java --- ...wo Arrays Equal by Reversing Subarrays.java | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) create mode 100644 Easy/Make Two Arrays Equal by Reversing Subarrays.java diff --git a/Easy/Make Two Arrays Equal by Reversing Subarrays.java b/Easy/Make Two Arrays Equal by Reversing Subarrays.java new file mode 100644 index 00000000..62ce7dca --- /dev/null +++ b/Easy/Make Two Arrays Equal by Reversing Subarrays.java @@ -0,0 +1,18 @@ +class Solution { + public boolean canBeEqual(int[] target, int[] arr) { + Map map = new HashMap<>(); + for (int num : target) { + map.put(num, map.getOrDefault(num, 0) + 1); + } + for (int num : arr) { + if (!map.containsKey(num)) { + return false; + } + map.put(num, map.get(num) - 1); + if (map.get(num) == 0) { + map.remove(num); + } + } + return map.isEmpty(); + } +} From cf1d49ca0da00b6e50a10a2a0a440609a7d13601 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sat, 3 Aug 2024 17:32:33 -0700 Subject: [PATCH 570/712] Update Range Sum of Sorted Subarray Sums.java --- Medium/Range Sum of Sorted Subarray Sums.java | 43 +++++++++---------- 1 file changed, 20 insertions(+), 23 deletions(-) diff --git a/Medium/Range Sum of Sorted Subarray Sums.java b/Medium/Range Sum of Sorted Subarray Sums.java index c8dad58b..9b7504b7 100644 --- a/Medium/Range Sum of Sorted Subarray Sums.java +++ b/Medium/Range Sum of Sorted Subarray Sums.java @@ -1,26 +1,23 @@ class Solution { - final int MOD = 100000007; - public int rangeSum(int[] nums, int n, int left, int right) { - PriorityQueue pq = new PriorityQueue<>(new Comparator(){ - public int compare(int[] o1, int[] o2) { - return o1[0] - o2[0]; - } - }); - for (int i = 0; i < n; i++) { - pq.add(new int[]{nums[i], i + 1}); + private static final int MOD = 1000_000_007; + + public int rangeSum(int[] nums, int n, int left, int right) { + Queue pq = new PriorityQueue<>(Comparator.comparingInt(o -> o[0])); + for (int i = 0; i < n; i++) { + pq.add(new int[]{nums[i], i + 1}); + } + int sum = 0; + for (int i = 1; i <= right; i++) { + int[] removed = pq.poll(); + if (i >= left) { + sum = (sum + removed[0]) % MOD; + } + if (removed[1] < n) { + removed[0] = removed[0] + nums[removed[1]]; + removed[1]++; + pq.add(removed); + } + } + return sum; } - int sum = 0; - for (int i = 1; i <= right; i++) { - int[] removed = pq.poll(); - if (i >= left) { - sum = (sum + removed[0]) % MOD; - } - if (removed[1] < n) { - removed[0] = removed[0] + nums[removed[1]]; - removed[1]++; - pq.add(removed); - } - } - return sum; - } } From b082bd05c66faa3219ce3252834d273131100a28 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 4 Aug 2024 11:14:17 -0700 Subject: [PATCH 571/712] Create Design Neighbor Sum Service.java --- Easy/Design Neighbor Sum Service.java | 50 +++++++++++++++++++++++++++ 1 file changed, 50 insertions(+) create mode 100644 Easy/Design Neighbor Sum Service.java diff --git a/Easy/Design Neighbor Sum Service.java b/Easy/Design Neighbor Sum Service.java new file mode 100644 index 00000000..93446e53 --- /dev/null +++ b/Easy/Design Neighbor Sum Service.java @@ -0,0 +1,50 @@ +class neighborSum { + + private static final int[][] ADJACENT_DIRS = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}}; + private static final int[][] DIAGONAL_DIRS = {{1, -1}, {-1, 1}, {1, 1}, {-1, -1}}; + + private final int[][] grid; + private final int numRows; + private final int numCols; + private final Map valueToCoordinateMap; + + public neighborSum(int[][] grid) { + this.numRows = grid.length; + this.numCols = grid[0].length; + this.valueToCoordinateMap = new HashMap<>(); + this.grid = new int[numRows][numCols]; + for (int i = 0; i < numRows; i++) { + for (int j = 0; j < numCols; j++) { + this.grid[i][j] = grid[i][j]; + this.valueToCoordinateMap.put(grid[i][j], new int[]{i, j}); + } + } + } + + public int adjacentSum(int value) { + return calculateSum(valueToCoordinateMap.get(value), ADJACENT_DIRS); + } + + public int diagonalSum(int value) { + return calculateSum(valueToCoordinateMap.get(value), DIAGONAL_DIRS); + } + + private int calculateSum(int[] coordinate, int[][] directions) { + int sum = 0; + for (int[] dir : directions) { + int newX = dir[0] + coordinate[0]; + int newY = dir[1] + coordinate[1]; + if (newX >= 0 && newX < numRows && newY >= 0 && newY < numCols) { + sum += grid[newX][newY]; + } + } + return sum; + } +} + +/** + * Your neighborSum object will be instantiated and called as such: + * neighborSum obj = new neighborSum(grid); + * int param_1 = obj.adjacentSum(value); + * int param_2 = obj.diagonalSum(value); + */ From d9d2a0cfdccbb6d2c0439839abfce89e534ec0f0 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Mon, 5 Aug 2024 07:45:47 -0700 Subject: [PATCH 572/712] Create Find the Number of Winning Players.java --- Easy/Find the Number of Winning Players.java | 14 ++++++++++++++ 1 file changed, 14 insertions(+) create mode 100644 Easy/Find the Number of Winning Players.java diff --git a/Easy/Find the Number of Winning Players.java b/Easy/Find the Number of Winning Players.java new file mode 100644 index 00000000..fd4ea2ba --- /dev/null +++ b/Easy/Find the Number of Winning Players.java @@ -0,0 +1,14 @@ +class Solution { + public int winningPlayerCount(int n, int[][] pick) { + Map> map = new HashMap<>(); + Set winners = new HashSet<>(); + for (int[] p : pick) { + map.computeIfAbsent(p[0], k -> new HashMap<>()); + map.get(p[0]).put(p[1], map.get(p[0]).getOrDefault(p[1], 0) + 1); + if (map.get(p[0]).get(p[1]) > p[0]) { + winners.add(p[0]); + } + } + return winners.size(); + } +} From ed0f41e4e3f6c4a2bf7b60609d5c4d8ea214e049 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Mon, 5 Aug 2024 18:17:23 -0700 Subject: [PATCH 573/712] Create Minimum Number of Pushes to Type Word II.java --- ...imum Number of Pushes to Type Word II.java | 23 +++++++++++++++++++ 1 file changed, 23 insertions(+) create mode 100644 Medium/Minimum Number of Pushes to Type Word II.java diff --git a/Medium/Minimum Number of Pushes to Type Word II.java b/Medium/Minimum Number of Pushes to Type Word II.java new file mode 100644 index 00000000..71ec90f6 --- /dev/null +++ b/Medium/Minimum Number of Pushes to Type Word II.java @@ -0,0 +1,23 @@ +class Solution { + public int minimumPushes(String word) { + Map map = new HashMap<>(); + for (char c : word.toCharArray()) { + map.put(c, map.getOrDefault(c, 0) + 1); + } + PriorityQueue pq = new PriorityQueue<>((a, b) -> map.get(b).compareTo(map.get(a))); + pq.addAll(map.keySet()); + int count = 0; + int typeMultiple = 1; + int counter = 0; + while (!pq.isEmpty()) { + char removed = pq.poll(); + count += typeMultiple * map.get(removed); + counter++; + if (counter == 8) { + counter = 0; + typeMultiple++; + } + } + return count; + } +} From 961e9f70e34b77d1d2cf69c745e9ec46cb27cf58 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Wed, 7 Aug 2024 08:13:34 -0700 Subject: [PATCH 574/712] Create Shortest Distance After Road Addition Queries I.java --- ...istance After Road Addition Queries I.java | 39 +++++++++++++++++++ 1 file changed, 39 insertions(+) create mode 100644 Medium/Shortest Distance After Road Addition Queries I.java diff --git a/Medium/Shortest Distance After Road Addition Queries I.java b/Medium/Shortest Distance After Road Addition Queries I.java new file mode 100644 index 00000000..19a2ea74 --- /dev/null +++ b/Medium/Shortest Distance After Road Addition Queries I.java @@ -0,0 +1,39 @@ +class Solution { + public int[] shortestDistanceAfterQueries(int n, int[][] queries) { + Map> graph = new HashMap<>(); + for (int i = 0; i < n - 1; i++) { + graph.computeIfAbsent(i, k -> new HashSet<>()).add(i + 1); + } + int[] result = new int[queries.length]; + for (int i = 0; i < queries.length; i++) { + int[] query = queries[i]; + graph.computeIfAbsent(query[0], k -> new HashSet<>()).add(query[1]); + result[i] = findDistance(graph, n - 1); + } + return result; + } + + private int findDistance(Map> graph, int target) { + Queue queue = new LinkedList<>(); + Set visited = new HashSet<>(); + queue.add(0); + int distance = 0; + while (!queue.isEmpty()) { + int size = queue.size(); + for (int i = 0; i < size; i++) { + Integer node = queue.poll(); + if (node == target) { + return distance; + } + for (Integer neighbor : graph.get(node)) { + if (!visited.contains(neighbor)) { + queue.add(neighbor); + visited.add(node); + } + } + } + distance++; + } + return -1; + } +} From c0e0d7de8dc5b583bf1086c5d96f4f9345a4ee69 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 11 Aug 2024 15:55:40 -0700 Subject: [PATCH 575/712] Create Snake in Matrix.java --- Easy/Snake in Matrix.java | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+) create mode 100644 Easy/Snake in Matrix.java diff --git a/Easy/Snake in Matrix.java b/Easy/Snake in Matrix.java new file mode 100644 index 00000000..5dce2568 --- /dev/null +++ b/Easy/Snake in Matrix.java @@ -0,0 +1,22 @@ +class Solution { + + private static final Map COMMAND_TO_DIRECTION = Map.of( + "UP", new int[]{-1, 0}, + "DOWN", new int[]{1, 0}, + "LEFT", new int[]{0, -1}, + "RIGHT", new int[]{0, 1} + ); + + public int finalPositionOfSnake(int n, List commands) { + int position = 0; + int x = 0; + int y = 0; + for (String command : commands) { + int[] change = COMMAND_TO_DIRECTION.get(command); + x += change[0]; + y += change[1]; + position = x * n + y; + } + return position; + } +} From 0a57dc54af4305a89540e031d7da72c6dcae9548 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 11 Aug 2024 16:28:37 -0700 Subject: [PATCH 576/712] Create Count the Number of Good Nodes.java --- Medium/Count the Number of Good Nodes.java | 34 ++++++++++++++++++++++ 1 file changed, 34 insertions(+) create mode 100644 Medium/Count the Number of Good Nodes.java diff --git a/Medium/Count the Number of Good Nodes.java b/Medium/Count the Number of Good Nodes.java new file mode 100644 index 00000000..d100513d --- /dev/null +++ b/Medium/Count the Number of Good Nodes.java @@ -0,0 +1,34 @@ +class Solution { + public int countGoodNodes(int[][] edges) { + Map> map = new HashMap<>(); + for (int[] edge : edges) { + map.computeIfAbsent(edge[0], k -> new HashSet<>()).add(edge[1]); + map.computeIfAbsent(edge[1], k -> new HashSet<>()).add(edge[0]); + } + int[] result = {0}; + recurse(map, result, 0, -1); + return result[0]; + } + + private int recurse(Map> map, int[] result, int node, int prevNode) { + int count = -1; + int total = 1; + boolean flag = true; + for (Integer conn : map.getOrDefault(node, new HashSet<>())) { + if (conn == prevNode) { + continue; + } + int temp = recurse(map, result, conn, node); + total += temp; + if (count == -1) { + count = temp; + } else if (count != temp) { + flag = false; + } + } + if (flag) { + result[0]++; + } + return total; + } +} From 8b69a0991f768cb0e7eee430604c769bd24c90e9 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Wed, 14 Aug 2024 16:50:03 -0700 Subject: [PATCH 577/712] Create Find K-th Smallest Pair Distance.java --- Hard/Find K-th Smallest Pair Distance.java | 31 ++++++++++++++++++++++ 1 file changed, 31 insertions(+) create mode 100644 Hard/Find K-th Smallest Pair Distance.java diff --git a/Hard/Find K-th Smallest Pair Distance.java b/Hard/Find K-th Smallest Pair Distance.java new file mode 100644 index 00000000..6d84cfa8 --- /dev/null +++ b/Hard/Find K-th Smallest Pair Distance.java @@ -0,0 +1,31 @@ +class Solution { + public int smallestDistancePair(int[] nums, int k) { + Arrays.sort(nums); + int n = nums.length; + int left = 0; + int right = nums[n - 1] - nums[0]; + while (left < right) { + int mid = (left + right) / 2; + int count = countPairs(nums, mid); + if (count < k) { + left = mid + 1; + } else { + right = mid; + } + } + return left; + } + + private int countPairs(int[] nums, int distance) { + int count = 0; + int n = nums.length; + int left = 0; + for (int i = 0; i < n; i++) { + while (nums[i] - nums[left] > distance) { + left++; + } + count += i - left; + } + return count; + } +} From dbff4c4f75e097d5189d566d4bcc28b163efaa1c Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Fri, 16 Aug 2024 15:05:13 -0700 Subject: [PATCH 578/712] Update and rename Maximum Distance in Arrays.java to Maximum Distance in Arrays.java --- Easy/Maximum Distance in Arrays.java | 17 ----------------- Medium/Maximum Distance in Arrays.java | 17 +++++++++++++++++ 2 files changed, 17 insertions(+), 17 deletions(-) delete mode 100644 Easy/Maximum Distance in Arrays.java create mode 100644 Medium/Maximum Distance in Arrays.java diff --git a/Easy/Maximum Distance in Arrays.java b/Easy/Maximum Distance in Arrays.java deleted file mode 100644 index 71a4581d..00000000 --- a/Easy/Maximum Distance in Arrays.java +++ /dev/null @@ -1,17 +0,0 @@ -class Solution { - public static int maxDistance(List> arrays) { - int min = arrays.get(0).get(0); - int max = arrays.get(0).get(arrays.get(0).size()-1); - int result = Integer.MIN_VALUE; - - for (int i=1; i> arrays) { + int result = 0; + int n = arrays.get(0).size(); + int min = arrays.get(0).get(0); + int max = arrays.get(0).get(n - 1); + for (int i = 1; i < arrays.size(); i++) { + n = arrays.get(i).size(); + result = Math.max(result, + Math.max(Math.abs(arrays.get(i).get(n - 1) - min), + Math.abs(max - arrays.get(i).get(0)))); + min = Math.min(min, arrays.get(i).get(0)); + max = Math.max(max, arrays.get(i).get(n - 1)); + } + return result; + } +} From bad1223b35eb5306161d677a54157e84114727dc Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Tue, 20 Aug 2024 08:29:45 -0700 Subject: [PATCH 579/712] Create Count Substrings That Satisfy K-Constraint I.java --- ...ubstrings That Satisfy K-Constraint I.java | 21 +++++++++++++++++++ 1 file changed, 21 insertions(+) create mode 100644 Easy/Count Substrings That Satisfy K-Constraint I.java diff --git a/Easy/Count Substrings That Satisfy K-Constraint I.java b/Easy/Count Substrings That Satisfy K-Constraint I.java new file mode 100644 index 00000000..9f44425d --- /dev/null +++ b/Easy/Count Substrings That Satisfy K-Constraint I.java @@ -0,0 +1,21 @@ +class Solution { + public int countKConstraintSubstrings(String s, int k) { + Map map = new HashMap<>(); + int start = 0; + int end = 0; + int n = s.length(); + int result = 0; + while (end < n) { + map.put(s.charAt(end), map.getOrDefault(s.charAt(end), 0) + 1); + end++; + while (start < end && map.getOrDefault('0', 0) > k && map.getOrDefault('1', 0) > k) { + map.put(s.charAt(start), map.get(s.charAt(start)) - 1); + start++; + } + if (map.getOrDefault('0', 0) <= k || map.getOrDefault('1', 0) <= k) { + result += end - start; + } + } + return result; + } +} From 700f9c3e8889b5c97cf03ba4f4859f451422078c Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Tue, 20 Aug 2024 17:38:24 -0700 Subject: [PATCH 580/712] Create Find the Power of K-Size Subarrays I.java --- Easy/Find the Power of K-Size Subarrays I.java | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) create mode 100644 Easy/Find the Power of K-Size Subarrays I.java diff --git a/Easy/Find the Power of K-Size Subarrays I.java b/Easy/Find the Power of K-Size Subarrays I.java new file mode 100644 index 00000000..975c1a3a --- /dev/null +++ b/Easy/Find the Power of K-Size Subarrays I.java @@ -0,0 +1,18 @@ +class Solution { + public int[] resultsArray(int[] nums, int k) { + if (k == 1) { + return nums; + } + int n = nums.length; + int[] result = new int[n - k + 1]; + Arrays.fill(result, -1); + int count = 1; + for (int i = 0; i < nums.length - 1; i++) { + count = (nums[i + 1] - nums[i] == 1) ? count + 1 : 1; + if (count >= k) { + result[i - k + 2] = nums[i + 1]; + } + } + return result; + } +} From 9f4be8534e7a2658e69fc80c9f52722451071f04 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Thu, 22 Aug 2024 17:22:21 -0700 Subject: [PATCH 581/712] Create Fraction Addition and Subtraction.java --- Medium/Fraction Addition and Subtraction.java | 42 +++++++++++++++++++ 1 file changed, 42 insertions(+) create mode 100644 Medium/Fraction Addition and Subtraction.java diff --git a/Medium/Fraction Addition and Subtraction.java b/Medium/Fraction Addition and Subtraction.java new file mode 100644 index 00000000..3d26da63 --- /dev/null +++ b/Medium/Fraction Addition and Subtraction.java @@ -0,0 +1,42 @@ +class Solution { + public String fractionAddition(String expression) { + int numerator = 0; + int denominator = 1; + int idx = 0; + int n = expression.length(); + while (idx < n) { + int currNumerator = 0; + int currDenominator = 0; + boolean negative = false; + if (expression.charAt(idx) == '-' || expression.charAt(idx) == '+') { + negative = expression.charAt(idx) == '-' ? true : false; + idx++; + } + while (Character.isDigit(expression.charAt(idx))) { + currNumerator = currNumerator * 10 + Character.getNumericValue(expression.charAt(idx)); + idx++; + } + if (negative) { + currNumerator *= -1; + } + idx++; + while (idx < n && Character.isDigit(expression.charAt(idx))) { + currDenominator = currDenominator * 10 + Character.getNumericValue(expression.charAt(idx)); + idx++; + } + numerator = numerator * currDenominator + currNumerator * denominator; + denominator = denominator * currDenominator; + } + int gcd = Math.abs(gcd(numerator, denominator)); + numerator /= gcd; + denominator /= gcd; + return numerator + "/" + denominator; + } + + private int gcd(int a, int b) { + if (a == 0) { + return b; + } + return gcd(b % a, a); + } +} From 17c7839ced9bc02a8ad2595706989700a1caab41 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 25 Aug 2024 17:23:09 -0700 Subject: [PATCH 582/712] Create Final Array State After K Multiplication Operations I.java --- ...e After K Multiplication Operations I.java | 25 +++++++++++++++++++ 1 file changed, 25 insertions(+) create mode 100644 Easy/Final Array State After K Multiplication Operations I.java diff --git a/Easy/Final Array State After K Multiplication Operations I.java b/Easy/Final Array State After K Multiplication Operations I.java new file mode 100644 index 00000000..da5670de --- /dev/null +++ b/Easy/Final Array State After K Multiplication Operations I.java @@ -0,0 +1,25 @@ +class Solution { + public int[] getFinalState(int[] nums, int k, int multiplier) { + int n = nums.length; + PriorityQueue pq = new PriorityQueue<>(Comparator.comparingInt((int[] o) -> o[0]) + .thenComparingInt(o -> o[1])); + for (int i = 0; i < n; i++) { + pq.add(new int[]{nums[i], i}); + } + while (k-- > 0) { + int[] removed = pq.remove(); + int value = removed[0]; + int index = removed[1]; + int newValue = value * multiplier; + pq.add(new int[]{newValue, index}); + } + int[] result = new int[n]; + while (!pq.isEmpty()) { + int[] removed = pq.remove(); + int value = removed[0]; + int index = removed[1]; + result[index] = value; + } + return result; + } +} From d717b453af22cd7a8f21cf3db668b30edbb7734e Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 1 Sep 2024 07:36:13 -0700 Subject: [PATCH 583/712] Create Add Two Polynomials Represented as Linked Lists.java --- ...lynomials Represented as Linked Lists.java | 43 +++++++++++++++++++ 1 file changed, 43 insertions(+) create mode 100644 Medium/Add Two Polynomials Represented as Linked Lists.java diff --git a/Medium/Add Two Polynomials Represented as Linked Lists.java b/Medium/Add Two Polynomials Represented as Linked Lists.java new file mode 100644 index 00000000..f7eafe3a --- /dev/null +++ b/Medium/Add Two Polynomials Represented as Linked Lists.java @@ -0,0 +1,43 @@ +/** + * Definition for polynomial singly-linked list. + * class PolyNode { + * int coefficient, power; + * PolyNode next = null; + + * PolyNode() {} + * PolyNode(int x, int y) { this.coefficient = x; this.power = y; } + * PolyNode(int x, int y, PolyNode next) { this.coefficient = x; this.power = y; this.next = next; } + * } + */ + +class Solution { + public PolyNode addPoly(PolyNode poly1, PolyNode poly2) { + Map powerToValue = new HashMap<>(); + populateMap(powerToValue, poly1); + populateMap(powerToValue, poly2); + List powerKeys = new ArrayList<>(powerToValue.keySet()); + Collections.sort(powerKeys); + PolyNode dummy = new PolyNode(); + PolyNode curr = dummy; + for (int i = powerKeys.size() - 1; i >= 0; i--) { + if (powerToValue.get(powerKeys.get(i)) == 0) { + continue; + } + PolyNode node = new PolyNode(powerToValue.get(powerKeys.get(i)), powerKeys.get(i)); + curr.next = node; + curr = curr.next; + } + return dummy.next; + } + + private void populateMap(Map powerToValue, PolyNode poly) { + while (poly != null) { + PolyNode node = poly; + int power = node.power; + if (node.coefficient != 0) { + powerToValue.put(power, powerToValue.getOrDefault(power, 0) + node.coefficient); + } + poly = poly.next; + } + } +} From abc7fd46d0bd7d89fb9534dc4487f107a4293a21 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 1 Sep 2024 17:39:57 -0700 Subject: [PATCH 584/712] Update Find the Student that Will Replace the Chalk.java --- ...e Student that Will Replace the Chalk.java | 34 +++++++++++-------- 1 file changed, 20 insertions(+), 14 deletions(-) diff --git a/Medium/Find the Student that Will Replace the Chalk.java b/Medium/Find the Student that Will Replace the Chalk.java index 8ee73065..bdf79d9a 100644 --- a/Medium/Find the Student that Will Replace the Chalk.java +++ b/Medium/Find the Student that Will Replace the Chalk.java @@ -1,17 +1,23 @@ class Solution { - public int chalkReplacer(int[] chalk, int k) { - int initialResult = chalkReplacerHelper(chalk, k); - return initialResult != -1 ? initialResult - : chalkReplacerHelper(chalk, k % Arrays.stream(chalk).sum()); - } - - private int chalkReplacerHelper(int[] chalk, int k) { - for (int i = 0; i < chalk.length; i++) { - if (k - chalk[i] < 0) { - return i; - } - k -= chalk[i]; + public int chalkReplacer(int[] chalk, int k) { + int n = chalk.length; + long[] prefixSum = new long[n]; + prefixSum[0] = chalk[0]; + for (int i = 1; i < n; i++) { + prefixSum[i] = chalk[i] + prefixSum[i - 1]; + } + long total = prefixSum[n - 1]; + long remaining = k % total; + int left = 0; + int right = n - 1; + while (left < right) { + int mid = (left + right) / 2; + if (prefixSum[mid] <= remaining) { + left = mid + 1; + } else { + right = mid; + } + } + return right; } - return -1; - } } From 391f4c4f861b0e95ae7281346e190c2b3ef7dff4 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Tue, 3 Sep 2024 06:11:54 -0700 Subject: [PATCH 585/712] Update Sum of Digits of String After Convert.java --- ...Sum of Digits of String After Convert.java | 29 ++++++++++--------- 1 file changed, 15 insertions(+), 14 deletions(-) diff --git a/Easy/Sum of Digits of String After Convert.java b/Easy/Sum of Digits of String After Convert.java index c86c724c..3b78aaae 100644 --- a/Easy/Sum of Digits of String After Convert.java +++ b/Easy/Sum of Digits of String After Convert.java @@ -1,17 +1,18 @@ class Solution { - public int getLucky(String s, int k) { - StringBuilder sb = new StringBuilder(); - for (char c : s.toCharArray()) { - sb.append(c - 'a' + 1); + public int getLucky(String s, int k) { + StringBuilder sb = new StringBuilder(); + for (char c : s.toCharArray()) { + sb.append(c - 'a' + 1); + } + while (k-- > 0) { + String temp = sb.toString(); + sb.setLength(0); + int val = 0; + for (char c : temp.toCharArray()) { + val += Character.getNumericValue(c); + } + sb.append(val); + } + return Integer.parseInt(sb.toString()); } - String num = sb.toString(); - while (k-- > 0) { - int sum = 0; - for (char c : num.toCharArray()) { - sum += Character.getNumericValue(c); - } - num = String.valueOf(sum); - } - return Integer.parseInt(num); - } } From e1dcfeaa1f25a8985962ec1f2544cf93fef7823d Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Tue, 3 Sep 2024 18:14:48 -0700 Subject: [PATCH 586/712] Create Walking Robot Simulation.java --- Medium/Walking Robot Simulation.java | 41 ++++++++++++++++++++++++++++ 1 file changed, 41 insertions(+) create mode 100644 Medium/Walking Robot Simulation.java diff --git a/Medium/Walking Robot Simulation.java b/Medium/Walking Robot Simulation.java new file mode 100644 index 00000000..bfc2784f --- /dev/null +++ b/Medium/Walking Robot Simulation.java @@ -0,0 +1,41 @@ +class Solution { + private static final int[][] DIRECTIONS = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}}; + private static final int HASH_MULTIPLIER = 60001; + + public int robotSim(int[] commands, int[][] obstacles) { + Set obstacleSet = new HashSet<>(); + for (int[] obstacle : obstacles) { + obstacleSet.add(hashCoordinates(obstacle[0], obstacle[1])); + } + int maxDistance = 0; + int currentDirection = 0; + int x = 0; + int y = 0; + for (int command : commands) { + if (command == -1) { + currentDirection = (currentDirection + 1) % 4; + continue; + } + if (command == -2) { + currentDirection = (currentDirection + 3) % 4; + continue; + } + int[] direction = DIRECTIONS[currentDirection]; + for (int i = 0; i < command; i++) { + int nextX = x + direction[0]; + int nextY = y + direction[1]; + if (obstacleSet.contains(hashCoordinates(nextX, nextY))) { + break; + } + x = nextX; + y = nextY; + } + maxDistance = Math.max(maxDistance, x * x + y * y); + } + return maxDistance; + } + + private static int hashCoordinates(int x, int y) { + return x + HASH_MULTIPLIER * y; + } +} From 0dd2c3bc6121d307e42223df055bc7d0e1d01bb7 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Wed, 4 Sep 2024 08:11:01 -0700 Subject: [PATCH 587/712] Create Diagonal Traverse II.java --- Medium/Diagonal Traverse II.java | 26 ++++++++++++++++++++++++++ 1 file changed, 26 insertions(+) create mode 100644 Medium/Diagonal Traverse II.java diff --git a/Medium/Diagonal Traverse II.java b/Medium/Diagonal Traverse II.java new file mode 100644 index 00000000..dabfc5ef --- /dev/null +++ b/Medium/Diagonal Traverse II.java @@ -0,0 +1,26 @@ +class Solution { + public int[] findDiagonalOrder(List> nums) { + Queue queue = new LinkedList<>(); + List result = new ArrayList<>(); + queue.add(new int[]{0, 0}); + while (!queue.isEmpty()) { + int[] removed = queue.remove(); + int x = removed[0]; + int y = removed[1]; + result.add(nums.get(x).get(y)); + // move down in column first + if (y == 0 && x + 1 < nums.size()) { + queue.add(new int[]{x + 1, y}); + } + // then pick the next element in row + if (y + 1 < nums.get(x).size()) { + queue.add(new int[]{x, y + 1}); + } + } + int[] ans = new int[result.size()]; + for (int i = 0; i < result.size(); i++) { + ans[i] = result.get(i); + } + return ans; + } +} From d214eff088dc8dc903de22e3f672e7ebce83f633 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Wed, 4 Sep 2024 08:25:09 -0700 Subject: [PATCH 588/712] Create Sum of All Subset XOR Totals.java --- Easy/Sum of All Subset XOR Totals.java | 14 ++++++++++++++ 1 file changed, 14 insertions(+) create mode 100644 Easy/Sum of All Subset XOR Totals.java diff --git a/Easy/Sum of All Subset XOR Totals.java b/Easy/Sum of All Subset XOR Totals.java new file mode 100644 index 00000000..fe82567a --- /dev/null +++ b/Easy/Sum of All Subset XOR Totals.java @@ -0,0 +1,14 @@ +class Solution { + public int subsetXORSum(int[] nums) { + return recurse(nums, 0, 0); + } + + private int recurse(int[] nums, int idx, int currXor) { + if (idx == nums.length) { + return currXor; + } + int performXor = recurse(nums, idx + 1, currXor ^ nums[idx]); + int notPerformXor = recurse(nums, idx + 1, currXor); + return performXor + notPerformXor; + } +} From a13c10b8f5ed445486e4668b5981486212488422 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Wed, 4 Sep 2024 09:52:37 -0700 Subject: [PATCH 589/712] Update Lowest Common Ancestor of a Binary Tree III.java --- ... Common Ancestor of a Binary Tree III.java | 48 +++++++++---------- 1 file changed, 24 insertions(+), 24 deletions(-) diff --git a/Medium/Lowest Common Ancestor of a Binary Tree III.java b/Medium/Lowest Common Ancestor of a Binary Tree III.java index 26269fcc..098b0f86 100644 --- a/Medium/Lowest Common Ancestor of a Binary Tree III.java +++ b/Medium/Lowest Common Ancestor of a Binary Tree III.java @@ -9,30 +9,30 @@ class Node { */ class Solution { - public Node lowestCommonAncestor(Node p, Node q) { - int pDepth = getDepth(p); - int qDepth = getDepth(q); - while (pDepth > qDepth) { - pDepth--; - p = p.parent; + public Node lowestCommonAncestor(Node p, Node q) { + int pDepth = getDepth(p); + int qDepth = getDepth(q); + while (pDepth > qDepth) { + pDepth--; + p = p.parent; + } + while (qDepth > pDepth) { + qDepth--; + q = q.parent; + } + while (p != q) { + p = p.parent; + q = q.parent; + } + return p; } - while (pDepth < qDepth) { - qDepth--; - q = q.parent; - } - while (p != q) { - p = p.parent; - q = q.parent; - } - return p; - } - - private int getDepth(Node node) { - int depth = 0; - while (node != null) { - depth++; - node = node.parent; + + private int getDepth(Node node) { + int depth = 0; + while (node != null) { + depth++; + node = node.parent; + } + return depth; } - return depth; - } } From 0a57a4f4521e99065dd2c7cdeaad99732ef85b9a Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Wed, 4 Sep 2024 17:22:56 -0700 Subject: [PATCH 590/712] Update Find Missing Observations.java --- Medium/Find Missing Observations.java | 32 +++++++++++++++------------ 1 file changed, 18 insertions(+), 14 deletions(-) diff --git a/Medium/Find Missing Observations.java b/Medium/Find Missing Observations.java index 7b738edc..fe724572 100644 --- a/Medium/Find Missing Observations.java +++ b/Medium/Find Missing Observations.java @@ -1,17 +1,21 @@ class Solution { - public int[] missingRolls(int[] rolls, int mean, int n) { - int currSum = Arrays.stream(rolls).sum(); - int missingSum = mean * (n + rolls.length) - currSum; - if (missingSum > n * 6 || missingSum < n) { - return new int[]{}; + public int[] missingRolls(int[] rolls, int mean, int n) { + int m = rolls.length; + int sum = 0; + for (int roll : rolls) { + sum += roll; + } + int expectedSum = mean * (n + m); + int remaining = expectedSum - sum; + if (remaining > 6 * n || remaining < n) { + return new int[]{}; + } + int[] result = new int[n]; + Arrays.fill(result, remaining / n); + remaining = remaining % n; + for (int i = 0; i < remaining; i++) { + result[i]++; + } + return result; } - int[] ans = new int[n]; - int part = missingSum / n; - int remainder = missingSum % n; - Arrays.fill(ans, part); - for (int i = 0; i < remainder; i++) { - ans[i]++; - } - return ans; - } } From 4137cce7391bef40a4fff4400dcf863c0115596f Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Wed, 4 Sep 2024 17:30:29 -0700 Subject: [PATCH 591/712] Update Buildings With an Ocean View.java --- Medium/Buildings With an Ocean View.java | 25 ++++++++++++++---------- 1 file changed, 15 insertions(+), 10 deletions(-) diff --git a/Medium/Buildings With an Ocean View.java b/Medium/Buildings With an Ocean View.java index b9735daa..6d52576e 100644 --- a/Medium/Buildings With an Ocean View.java +++ b/Medium/Buildings With an Ocean View.java @@ -1,13 +1,18 @@ class Solution { - public int[] findBuildings(int[] heights) { - List oceanViewBuildings = new ArrayList<>(); - int maxHeight = 0; - for (int i = heights.length - 1; i >= 0; i--) { - if (heights[i] > maxHeight) { - oceanViewBuildings.add(i); - } - maxHeight = Math.max(maxHeight, heights[i]); + public int[] findBuildings(int[] heights) { + List result = new ArrayList<>(); + int maxHeight = -1; + for (int i = heights.length - 1; i >= 0; i--) { + if (heights[i] > maxHeight) { + result.add(i); + } + maxHeight = Math.max(maxHeight, heights[i]); + } + int[] ans = new int[result.size()]; + Collections.reverse(result); + for (int i = 0; i < result.size(); i++) { + ans[i] = result.get(i); + } + return ans; } - return oceanViewBuildings.stream().sorted().mapToInt(Integer::valueOf).toArray(); - } } From 88ca3f65bd13f7af1d3836e56dc7fed521893d80 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Fri, 6 Sep 2024 07:05:29 -0700 Subject: [PATCH 592/712] Create Delete Nodes From Linked List Present in Array.java --- ...des From Linked List Present in Array.java | 31 +++++++++++++++++++ 1 file changed, 31 insertions(+) create mode 100644 Medium/Delete Nodes From Linked List Present in Array.java diff --git a/Medium/Delete Nodes From Linked List Present in Array.java b/Medium/Delete Nodes From Linked List Present in Array.java new file mode 100644 index 00000000..ff184902 --- /dev/null +++ b/Medium/Delete Nodes From Linked List Present in Array.java @@ -0,0 +1,31 @@ +/** + * Definition for singly-linked list. + * public class ListNode { + * int val; + * ListNode next; + * ListNode() {} + * ListNode(int val) { this.val = val; } + * ListNode(int val, ListNode next) { this.val = val; this.next = next; } + * } + */ +class Solution { + public ListNode modifiedList(int[] nums, ListNode head) { + Set set = new HashSet<>(); + for (int num : nums) { + set.add(num); + } + while (head != null && set.contains(head.val)) { + head = head.next; + } + ListNode newHead = head; + ListNode curr = head; + while (curr.next != null) { + if (set.contains(curr.next.val)) { + curr.next = curr.next.next; + } else { + curr = curr.next; + } + } + return newHead; + } +} From fb8b21f8a92f46d47a505e1e05a2a66429afda05 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Fri, 6 Sep 2024 07:42:55 -0700 Subject: [PATCH 593/712] Create Making A Large Island.java --- Hard/Making A Large Island.java | 68 +++++++++++++++++++++++++++++++++ 1 file changed, 68 insertions(+) create mode 100644 Hard/Making A Large Island.java diff --git a/Hard/Making A Large Island.java b/Hard/Making A Large Island.java new file mode 100644 index 00000000..d1026bd7 --- /dev/null +++ b/Hard/Making A Large Island.java @@ -0,0 +1,68 @@ +class Solution { + + private static final int[][] DIRS = {{-1, 0}, {0, -1}, {1, 0}, {0, 1}}; + + public int largestIsland(int[][] grid) { + int n = grid.length; + int tag = 2; + int result = 0; + Map tagToAreaMapping = new HashMap<>(); + // Calculate area without changing 0 to 1 & tag each island for future reference + for (int i = 0; i < n; i++) { + for (int j = 0; j < n; j++) { + if (grid[i][j] == 1) { + tagToAreaMapping.put(tag, dfs(grid, i, j, tag)); + result = Math.max(result, tagToAreaMapping.get(tag)); + tag++; + } + } + } + // Now start changing each 0 to 1 & add the area of all connected islands by referencing their tags + for (int i = 0; i < n; i++) { + for (int j = 0; j < n; j++) { + if (grid[i][j] == 0) { + Set visited = new HashSet<>(); + int currArea = 1; + List moves = getMoves(i, j, n); + for (int[] move : moves) { + int x = move[0]; + int y = move[1]; + int currTag = grid[x][y]; + if (currTag > 1 && visited.add(currTag)) { + currArea += tagToAreaMapping.get(currTag); + } + } + result = Math.max(result, currArea); + } + } + } + return result; + } + + private int dfs(int[][] grid, int x, int y, int tag) { + int area = 1; + int n = grid.length; + grid[x][y] = tag; + List moves = getMoves(x, y, n); + for (int[] move : moves) { + int i = move[0]; + int j = move[1]; + if (grid[i][j] == 1) { + area += dfs(grid, i, j, tag); + } + } + return area; + } + + private List getMoves(int x, int y, int n) { + List moves = new ArrayList<>(); + for (int[] dir : DIRS) { + int newX = x + dir[0]; + int newY = y + dir[1]; + if (newX >= 0 && newX < n && newY >= 0 && newY < n) { + moves.add(new int[]{newX, newY}); + } + } + return moves; + } +} From 5028a9e5f102e02eaa78f86313087d21181fb841 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Fri, 6 Sep 2024 08:43:03 -0700 Subject: [PATCH 594/712] Create Max Consecutive Ones III.java --- Medium/Max Consecutive Ones III.java | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+) create mode 100644 Medium/Max Consecutive Ones III.java diff --git a/Medium/Max Consecutive Ones III.java b/Medium/Max Consecutive Ones III.java new file mode 100644 index 00000000..cec14a87 --- /dev/null +++ b/Medium/Max Consecutive Ones III.java @@ -0,0 +1,23 @@ +class Solution { + public int longestOnes(int[] nums, int k) { + int start = 0; + int end = 0; + int flipped = 0; + int n = nums.length; + int max = 0; + while (end < nums.length) { + if (nums[end] == 0) { + flipped++; + } + end++; + while (start < end && flipped > k) { + if (nums[start] == 0) { + flipped--; + } + start++; + } + max = Math.max(max, end - start); + } + return max; + } +} From b54f9b0024f91c558910d8724bc601bd3400cf4c Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Fri, 6 Sep 2024 09:03:57 -0700 Subject: [PATCH 595/712] Update Valid Number.java --- Hard/Valid Number.java | 106 +++++++++++++++-------------------------- 1 file changed, 39 insertions(+), 67 deletions(-) diff --git a/Hard/Valid Number.java b/Hard/Valid Number.java index d9a68285..1cdebfa8 100644 --- a/Hard/Valid Number.java +++ b/Hard/Valid Number.java @@ -1,90 +1,62 @@ class Solution { - public boolean isNumber(String s) { - s = s.trim(); - char[] ch = s.toCharArray(); + public boolean isNumber(String s) { int idx = 0; - int n = ch.length; - boolean signFound = false; - boolean decimalFound = false; - boolean numFound = false; - boolean expoFound = false; - + boolean isDecimal = false; + boolean isDigit = false; + boolean digitsBeforeDecimal = false; + boolean digitsAfterDecimal = false; + int n = s.length(); + if (s.charAt(idx) == '-' || s.charAt(idx) == '+') { + idx++; + } while (idx < n) { - if (ch[idx] == '+' || ch[idx] == '-') { - if (numFound || signFound || decimalFound) { + if (s.charAt(idx) == '.') { + if (isDecimal) { return false; } - - signFound = true; - } - else if (ch[idx] == '.') { - if (decimalFound) { + isDecimal = true; + } else if (s.charAt(idx) == 'e' || s.charAt(idx) == 'E') { + if (!isDigit) { return false; } - decimalFound = true; - } - else if (Character.isLetter(ch[idx])) { - if (ch[idx] == 'e') { - if (!numFound) { - return false; - } - idx++; - expoFound = true; - break; - } - else { + boolean valid = isValidExponent(s, idx + 1); + if (!valid) { return false; } - } - else if (Character.isDigit(ch[idx])) { - numFound = true; - } - else if (ch[idx] == ' ') { - if (numFound || signFound || decimalFound) { - return false; + break; + } else if (Character.isDigit(s.charAt(idx))) { + if (isDecimal) { + digitsAfterDecimal = true; + } else { + digitsBeforeDecimal = true; } + isDigit = true; + } else { + return false; } - idx++; } - - if (!numFound) { - return false; + if (isDecimal) { + return digitsBeforeDecimal || digitsAfterDecimal; } + return isDigit; + } - if (expoFound && idx == n) { + private boolean isValidExponent(String s, int idx) { + if (idx == s.length()) { return false; } - - signFound = false; - numFound = false; - while (idx < n) { - if (ch[idx] == '.') { - return false; - } - else if (ch[idx] == '+' || ch[idx] == '-') { - if (signFound) { - return false; - } - if (numFound) { - return false; - } - signFound = true; - } - else if (Character.isDigit(ch[idx])) { - numFound = true; - } - else { + if (s.charAt(idx) == '-' || s.charAt(idx) == '+') { + idx++; + } + boolean digitFound = false; + while (idx < s.length()) { + if (!Character.isDigit(s.charAt(idx))) { return false; } - + digitFound = true; idx++; } - - if (expoFound && !numFound) { - return false; - } - - return true; + return digitFound; } } From 6a4ac34e8808f4eff237a7d4d4a95eb79d8e3a47 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sat, 7 Sep 2024 14:32:30 -0700 Subject: [PATCH 596/712] Update Exclusive Time of Functions.java --- Medium/Exclusive Time of Functions.java | 50 +++++++++++-------------- 1 file changed, 21 insertions(+), 29 deletions(-) diff --git a/Medium/Exclusive Time of Functions.java b/Medium/Exclusive Time of Functions.java index 8212e0c0..cd85e84c 100644 --- a/Medium/Exclusive Time of Functions.java +++ b/Medium/Exclusive Time of Functions.java @@ -1,33 +1,25 @@ class Solution { - public int[] exclusiveTime(int n, List logs) { - int[] result = new int[n]; - Stack stack = new Stack<>(); - for (String log : logs) { - Log currentLog = new Log(log); - if (currentLog.isStart) { - stack.push(currentLog); - } else { - Log topLog = stack.pop(); - result[topLog.id] += currentLog.time - topLog.time + 1 - topLog.overLappingTime; - if (!stack.isEmpty()) { - stack.peek().overLappingTime += currentLog.time - topLog.time + 1; + public int[] exclusiveTime(int n, List logs) { + Stack stack = new Stack<>(); + int[] result = new int[n]; + int lastTimestamp = 0; + for (String log : logs) { + String[] split = log.split(":"); + int id = Integer.parseInt(split[0]); + int timestamp = Integer.parseInt(split[2]); + if (split[1].equals("start")) { + // We consider timestamp as part of current computation + if (!stack.isEmpty()) { + result[stack.peek()] += timestamp - lastTimestamp; + } + stack.push(id); + lastTimestamp = timestamp; + } else { + // We consider timestamp as part of previous computation + result[stack.pop()] += timestamp - lastTimestamp + 1; + lastTimestamp = timestamp + 1; + } } - } + return result; } - return result; - } - - private static class Log { - public int id; - public boolean isStart; - public int time; - public int overLappingTime; - - public Log(String log) { - String[] split = log.split(":"); - this.id = Integer.parseInt(split[0]); - this.isStart = split[1].equals("start"); - this.time = Integer.parseInt(split[2]); - } - } } From 6f1feb4a469506b8555f0b0ef8f0e367535874ee Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sat, 7 Sep 2024 16:08:59 -0700 Subject: [PATCH 597/712] Update Product of Two Run-Length Encoded Arrays.java --- ...duct of Two Run-Length Encoded Arrays.java | 64 ++++++++----------- 1 file changed, 28 insertions(+), 36 deletions(-) diff --git a/Medium/Product of Two Run-Length Encoded Arrays.java b/Medium/Product of Two Run-Length Encoded Arrays.java index 7aa0b117..4aab9bc8 100644 --- a/Medium/Product of Two Run-Length Encoded Arrays.java +++ b/Medium/Product of Two Run-Length Encoded Arrays.java @@ -1,39 +1,31 @@ class Solution { - public List> findRLEArray(int[][] encoded1, int[][] encoded2) { - int idxOne = 0; - int idxTwo = 0; - List> result = new ArrayList<>(); - while (idxOne < encoded1.length && idxTwo < encoded2.length) { - int valueOne = encoded1[idxOne][0]; - int frequencyOne = 0; - while (idxOne < encoded1.length && encoded1[idxOne][0] == valueOne) { - frequencyOne += encoded1[idxOne++][1]; - } - idxOne--; - encoded1[idxOne][1] = frequencyOne; - int valueTwo = encoded2[idxTwo][0]; - int frequencyTwo = 0; - while (idxTwo < encoded2.length && encoded2[idxTwo][0] == valueTwo) { - frequencyTwo += encoded2[idxTwo++][1]; - } - idxTwo--; - encoded2[idxTwo][1] = frequencyTwo; - int prod = encoded1[idxOne][0] * encoded2[idxTwo][0]; - int frequency = Math.min(encoded1[idxOne][1], encoded2[idxTwo][1]); - if (result.size() > 0 && result.get(result.size() - 1).get(0) == prod) { - result.get(result.size() - 1).set(1, result.get(result.size() - 1).get(1) + frequency); - } else { - result.add(Arrays.asList(prod, frequency)); - } - encoded1[idxOne][1] -= frequency; - encoded2[idxTwo][1] -= frequency; - if (encoded1[idxOne][1] == 0) { - idxOne++; - } - if (encoded2[idxTwo][1] == 0) { - idxTwo++; - } + public List> findRLEArray(int[][] encoded1, int[][] encoded2) { + int idxOne = 0; + int idxTwo = 0; + List> result = new ArrayList<>(); + while (idxOne < encoded1.length && idxTwo < encoded2.length) { + int valOne = encoded1[idxOne][0]; + int valTwo = encoded2[idxTwo][0]; + int countOne = encoded1[idxOne][1]; + int countTwo = encoded2[idxTwo][1]; + int value = valOne * valTwo; + int count = Math.min(countOne, countTwo); + encoded1[idxOne][1] -= count; + encoded2[idxTwo][1] -= count; + if (encoded1[idxOne][1] == 0) { + idxOne++; + } + if (encoded2[idxTwo][1] == 0) { + idxTwo++; + } + if (!result.isEmpty() && result.get(result.size() - 1).get(0) == value) { + int existingCount = result.get(result.size() - 1).get(1); + int newCount = existingCount + count; + result.get(result.size() - 1).set(1, newCount); + } else { + result.add(Arrays.asList(value, count)); + } + } + return result; } - return result; - } } From f4665a1b78411741240061f2a93b5dc4a7999410 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 8 Sep 2024 11:56:52 -0700 Subject: [PATCH 598/712] Update Minimum Time to Collect All Apples in a Tree.java --- ... Time to Collect All Apples in a Tree.java | 44 ++++++++++--------- 1 file changed, 23 insertions(+), 21 deletions(-) diff --git a/Medium/Minimum Time to Collect All Apples in a Tree.java b/Medium/Minimum Time to Collect All Apples in a Tree.java index 24feb762..0e54b3ec 100644 --- a/Medium/Minimum Time to Collect All Apples in a Tree.java +++ b/Medium/Minimum Time to Collect All Apples in a Tree.java @@ -1,25 +1,27 @@ class Solution { - public int minTime(int n, int[][] edges, List hasApple) { - Map> tree = new HashMap<>(); - for (int[] edge : edges) { - tree.computeIfAbsent(edge[0], k -> new HashSet<>()).add(edge[1]); - tree.computeIfAbsent(edge[1], k -> new HashSet<>()).add(edge[0]); + public int minTime(int n, int[][] edges, List hasApple) { + Map> map = new HashMap<>(); + for (int[] edge : edges) { + map.computeIfAbsent(edge[0], k -> new ArrayList<>()).add(edge[1]); + map.computeIfAbsent(edge[1], k -> new ArrayList<>()).add(edge[0]); + } + return recurse(0, -1, map, hasApple); } - Set visited = new HashSet<>(); - return dfs(0, hasApple, visited, tree); - } - - private int dfs(int node, List hasApple, Set visited, Map> tree) { - visited.add(node); - int result = 0; - for (Integer child : tree.getOrDefault(node, new HashSet<>())) { - if (!visited.contains(child)) { - result += dfs(child, hasApple, visited, tree); - } + + private int recurse(int node, int parent, Map> graph, List hasApple) { + if (!graph.containsKey(node)) { + return 0; + } + int time = 0; + for (Integer conn: graph.get(node)) { + if (conn == parent) { + continue; + } + int connTime = recurse(conn, node, graph, hasApple); + if (connTime > 0 || hasApple.get(conn)) { + time += connTime + 2; + } + } + return time; } - if ((result > 0 || hasApple.get(node)) && node != 0) { - result += 2; - } - return result; - } } From 56554ae1b5bbc84477ce970a0e70578697429c5b Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 8 Sep 2024 12:08:47 -0700 Subject: [PATCH 599/712] Update Meeting Scheduler.java --- Medium/Meeting Scheduler.java | 37 ++++++++++++++++++----------------- 1 file changed, 19 insertions(+), 18 deletions(-) diff --git a/Medium/Meeting Scheduler.java b/Medium/Meeting Scheduler.java index d5bf6b16..aeb5d8e9 100644 --- a/Medium/Meeting Scheduler.java +++ b/Medium/Meeting Scheduler.java @@ -1,21 +1,22 @@ class Solution { - public List minAvailableDuration(int[][] slots1, int[][] slots2, int duration) { - Arrays.sort(slots1, Comparator.comparingInt(o -> o[0])); - Arrays.sort(slots2, Comparator.comparingInt(o -> o[0])); - int idxOne = 0; - int idxTwo = 0; - while (idxOne < slots1.length && idxTwo < slots2.length) { - int maxStart = Math.max(slots1[idxOne][0], slots2[idxTwo][0]); - int minEnd = Math.min(slots1[idxOne][1], slots2[idxTwo][1]); - if (minEnd - maxStart >= duration) { - return Arrays.asList(maxStart, maxStart + duration); - } - if (slots1[idxOne][1] > slots2[idxTwo][1]) { - idxTwo++; - } else { - idxOne++; - } + public List minAvailableDuration(int[][] slots1, int[][] slots2, int duration) { + Arrays.sort(slots1, Comparator.comparingInt(o -> o[0])); + Arrays.sort(slots2, Comparator.comparingInt(o -> o[0])); + int idxOne = 0; + int idxTwo = 0; + while (idxOne < slots1.length && idxTwo < slots2.length) { + int maxStart = Math.max(slots1[idxOne][0], slots2[idxTwo][0]); + int minEnd = Math.min(slots1[idxOne][1], slots2[idxTwo][1]); + if (minEnd - maxStart >= duration) { + return List.of(maxStart, maxStart + duration); + } + if (minEnd == slots1[idxOne][1]) { + idxOne++; + } + if (minEnd == slots2[idxTwo][1]) { + idxTwo++; + } + } + return Collections.emptyList(); } - return new ArrayList<>(); - } } From 3ba562353c17ddfcc35c87757145c3bfd5a21558 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 8 Sep 2024 15:49:02 -0700 Subject: [PATCH 600/712] Create Alternating Groups I.java --- Easy/Alternating Groups I.java | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) create mode 100644 Easy/Alternating Groups I.java diff --git a/Easy/Alternating Groups I.java b/Easy/Alternating Groups I.java new file mode 100644 index 00000000..9730d5ea --- /dev/null +++ b/Easy/Alternating Groups I.java @@ -0,0 +1,18 @@ +class Solution { + public int numberOfAlternatingGroups(int[] colors) { + int count = 0; + int n = colors.length; + for (int i = 0; i < n - 2; i++) { + if (colors[i + 1] != colors[i] && colors[i + 1] != colors[i + 2]) { + count++; + } + } + if (colors[n - 2] != colors[n - 1] && colors[n - 2] == colors[0]) { + count++; + } + if (colors[n - 1] != colors[0] && colors[n - 1] == colors[1]) { + count++; + } + return count; + } +} From bd41f382ab668b5de9e605ed0fc4d75d4843e183 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 8 Sep 2024 15:54:49 -0700 Subject: [PATCH 601/712] Update Base 7.java --- Easy/Base 7.java | 25 ++++++++++++------------- 1 file changed, 12 insertions(+), 13 deletions(-) diff --git a/Easy/Base 7.java b/Easy/Base 7.java index 210d6c39..8da9a029 100644 --- a/Easy/Base 7.java +++ b/Easy/Base 7.java @@ -1,16 +1,15 @@ class Solution { - public String convertToBase7(int num) { - StringBuilder sb = new StringBuilder(); - char sign = num < 0 ? '-' : ' '; - num = Math.abs(num); - while (num > 0) { - sb.append(num % 7); - num /= 7; + public String convertToBase7(int num) { + StringBuilder sb = new StringBuilder(); + boolean isNegative = num < 0; + num = Math.abs(num); + while (num > 0) { + sb.append(num % 7); + num /= 7; + } + if (isNegative) { + sb.append('-'); + } + return sb.isEmpty() ? "0" : sb.reverse().toString(); } - String representation = sb.length() == 0 ? "0" : sb.reverse().toString(); - if (sign == '-') { - return sign + representation; - } - return representation; - } } From 238c35b45c0b2d09e497e165945b749b9a2d651c Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 8 Sep 2024 16:17:19 -0700 Subject: [PATCH 602/712] Create Faulty Sensor.java --- Easy/Faulty Sensor.java | 13 +++++++++++++ 1 file changed, 13 insertions(+) create mode 100644 Easy/Faulty Sensor.java diff --git a/Easy/Faulty Sensor.java b/Easy/Faulty Sensor.java new file mode 100644 index 00000000..dabed6c0 --- /dev/null +++ b/Easy/Faulty Sensor.java @@ -0,0 +1,13 @@ +class Solution { + public int badSensor(int[] sensor1, int[] sensor2) { + int idx = 0; + int n = sensor1.length; + while (idx < n && sensor1[idx] == sensor2[idx]) { + idx++; + } + while (idx + 1 < n && sensor1[idx] == sensor2[idx + 1] && sensor1[idx + 1] == sensor2[idx]) { + idx++; + } + return idx >= n - 1 ? -1 : sensor1[idx] == sensor2[idx + 1] ? 1 : 2; + } +} From fe13960db86695574eb4afdbd214fad5bbc9acba Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Mon, 9 Sep 2024 08:38:15 -0700 Subject: [PATCH 603/712] Update Palindrome Partitioning.java --- Medium/Palindrome Partitioning.java | 40 ++++++++++++++++------------- 1 file changed, 22 insertions(+), 18 deletions(-) diff --git a/Medium/Palindrome Partitioning.java b/Medium/Palindrome Partitioning.java index 1171f009..de89ed16 100644 --- a/Medium/Palindrome Partitioning.java +++ b/Medium/Palindrome Partitioning.java @@ -1,27 +1,31 @@ class Solution { - public List> partition(String a) { - List> ans = new ArrayList<>(); - helper(ans, new ArrayList(), a, 0); - return ans; + public List> partition(String s) { + List> result = new ArrayList<>(); + backtrack(result, new ArrayList<>(), s, 0); + return result; } - - private void helper(List> ans, List temp, String a, int idx) { - if (idx == a.length()) { - ans.add(new ArrayList<>(temp)); + + private void backtrack(List> result, List currentList, + String s, int idx) { + if (idx == s.length()) { + result.add(new ArrayList<>(currentList)); return; } - for (int i=idx; i Date: Mon, 9 Sep 2024 08:48:50 -0700 Subject: [PATCH 604/712] Update Largest BST Subtree.java --- Medium/Largest BST Subtree.java | 52 ++++++++++++++++----------------- 1 file changed, 25 insertions(+), 27 deletions(-) diff --git a/Medium/Largest BST Subtree.java b/Medium/Largest BST Subtree.java index 45c83c6f..18ddfeaf 100644 --- a/Medium/Largest BST Subtree.java +++ b/Medium/Largest BST Subtree.java @@ -4,43 +4,41 @@ * int val; * TreeNode left; * TreeNode right; - * TreeNode(int x) { val = x; } + * TreeNode() {} + * TreeNode(int val) { this.val = val; } + * TreeNode(int val, TreeNode left, TreeNode right) { + * this.val = val; + * this.left = left; + * this.right = right; + * } * } */ class Solution { public int largestBSTSubtree(TreeNode root) { - return largestBSTSubtreeHelper(root); - } - - private int largestBSTSubtreeHelper(TreeNode root) { - if (isBST(root)) { - return getNodeCount(root); - } - - return Math.max(-1, Math.max(largestBSTSubtreeHelper(root.left), largestBSTSubtreeHelper(root.right))); - } - - private boolean isBST(TreeNode root) { - return isBSTHelper(root, Integer.MAX_VALUE, Integer.MIN_VALUE); - } - - private boolean isBSTHelper(TreeNode root, int max, int min) { if (root == null) { - return true; + return 0; } - - if (root.val >= max || root.val <= min) { - return false; + int[] isBstResult = isBst(root, Integer.MIN_VALUE, Integer.MAX_VALUE); + if (isBstResult[0] == 1) { + return isBstResult[1]; } - - return isBSTHelper(root.left, root.val, min) && isBSTHelper(root.right, max, root.val); + return Math.max(largestBSTSubtree(root.left), largestBSTSubtree(root.right)); } - private int getNodeCount(TreeNode root) { + private int[] isBst(TreeNode root, int minValue, int maxValue) { if (root == null) { - return 0; + return new int[]{1, 0}; + } + int[] result = new int[2]; + if (!(root.val > minValue && root.val < maxValue)) { + return result; + } + int[] leftIsBst = isBst(root.left, minValue, root.val); + int[] rightIsBst = isBst(root.right, root.val, maxValue); + if (leftIsBst[0] == 1 && rightIsBst[0] == 1) { + result[0] = 1; + result[1] = 1 + leftIsBst[1] + rightIsBst[1]; } - - return 1 + getNodeCount(root.left) + getNodeCount(root.right); + return result; } } From ad5efe48ef18c914dfc941fd0e201aa6da5e0452 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Mon, 9 Sep 2024 09:03:48 -0700 Subject: [PATCH 605/712] Update One Edit Distance.java --- Medium/One Edit Distance.java | 59 ++++++++++++++--------------------- 1 file changed, 24 insertions(+), 35 deletions(-) diff --git a/Medium/One Edit Distance.java b/Medium/One Edit Distance.java index dc32eede..662a41d1 100644 --- a/Medium/One Edit Distance.java +++ b/Medium/One Edit Distance.java @@ -1,39 +1,28 @@ class Solution { - public boolean isOneEditDistance(String s, String t) { - int lengthDiff = Math.abs(s.length() - t.length()); - if (s.equals(t) || lengthDiff > 1) { - return false; - } - if (s.length() == 0 || t.length() == 0) { - return true; - } - int idxOne = 0; - int idxTwo = 0; - boolean changeDone = false; - while (idxOne < s.length() && idxTwo < t.length()) { - if (s.charAt(idxOne) == t.charAt(idxTwo)) { - idxOne++; - idxTwo++; - continue; - } - if (changeDone) { - return false; - } - if (lengthDiff != 0) { - if (s.length() > t.length()) { - idxOne++; - } else { - idxTwo++; + public boolean isOneEditDistance(String s, String t) { + int diff = Math.abs(s.length() - t.length()); + if (s.equals(t) || diff > 1) { + return false; } - } else { - idxOne++; - idxTwo++; - } - changeDone = true; - } - if (changeDone && (idxOne != s.length() || idxTwo != t.length())) { - return false; + int idx = 0; + while (idx < s.length() && idx < t.length()) { + if (s.charAt(idx) != t.charAt(idx)) { + // Replace character + if (s.substring(idx + 1).equals(t.substring(idx + 1))) { + return true; + } + // Delete 1 character from s + if (s.substring(idx + 1).equals(t.substring(idx))) { + return true; + } + // Delete 1 character from t + if (s.substring(idx).equals(t.substring(idx + 1))) { + return true; + } + return false; + } + idx++; + } + return true; } - return true; - } } From c968c70d73ca733683e6f14aaa54d4513531e7ca Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Mon, 9 Sep 2024 17:47:51 -0700 Subject: [PATCH 606/712] Create Spiral Matrix IV.java --- Medium/Spiral Matrix IV.java | 45 ++++++++++++++++++++++++++++++++++++ 1 file changed, 45 insertions(+) create mode 100644 Medium/Spiral Matrix IV.java diff --git a/Medium/Spiral Matrix IV.java b/Medium/Spiral Matrix IV.java new file mode 100644 index 00000000..5136b493 --- /dev/null +++ b/Medium/Spiral Matrix IV.java @@ -0,0 +1,45 @@ +/** + * Definition for singly-linked list. + * public class ListNode { + * int val; + * ListNode next; + * ListNode() {} + * ListNode(int val) { this.val = val; } + * ListNode(int val, ListNode next) { this.val = val; this.next = next; } + * } + */ +class Solution { + public int[][] spiralMatrix(int m, int n, ListNode head) { + int[][] result = new int[m][n]; + for (int i = 0; i < m; i++) { + Arrays.fill(result[i], -1); + } + int topRow = 0; + int bottomRow = m - 1; + int leftColumn = 0; + int rightColumn = n - 1; + while (head != null) { + for (int col = leftColumn; col <= rightColumn && head != null; col++) { + result[topRow][col] = head.val; + head = head.next; + } + topRow++; + for (int row = topRow; row <= bottomRow && head != null; row++) { + result[row][rightColumn] = head.val; + head = head.next; + } + rightColumn--; + for (int col = rightColumn; col >= leftColumn && head != null; col--) { + result[bottomRow][col] = head.val; + head = head.next; + } + bottomRow--; + for (int row = bottomRow; row >= topRow && head != null; row--) { + result[row][leftColumn] = head.val; + head = head.next; + } + leftColumn++; + } + return result; + } +} From aebf179f19b50136a7d8e2738a5ced9de4a9a22f Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Tue, 10 Sep 2024 07:33:58 -0700 Subject: [PATCH 607/712] Update Shuffle String.java --- Easy/Shuffle String.java | 28 +++++++--------------------- 1 file changed, 7 insertions(+), 21 deletions(-) diff --git a/Easy/Shuffle String.java b/Easy/Shuffle String.java index 10340050..f38bf1c2 100644 --- a/Easy/Shuffle String.java +++ b/Easy/Shuffle String.java @@ -1,24 +1,10 @@ class Solution { - public String restoreString(String s, int[] indices) { - char[] letters = s.toCharArray(); - for (int i = 0; i < indices.length; i++) { - while (indices[i] != i) { - swapLetter(letters, i, indices[i]); - swapIndex(indices, i, indices[i]); - } + public String restoreString(String s, int[] indices) { + char[] result = new char[s.length()]; + for (int i = 0; i < s.length(); i++) { + int index = indices[i]; + result[index] = s.charAt(i); + } + return String.valueOf(result); } - return String.valueOf(letters); - } - - private void swapLetter(char[] arr, int idxOne, int idxTwo) { - char temp = arr[idxOne]; - arr[idxOne] = arr[idxTwo]; - arr[idxTwo] = temp; - } - - private void swapIndex(int[] arr, int idxOne, int idxTwo) { - int temp = arr[idxOne]; - arr[idxOne] = arr[idxTwo]; - arr[idxTwo] = temp; - } } From 94209cf76f7ab258a49eebe18c04e38ad76cf345 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Tue, 10 Sep 2024 07:34:47 -0700 Subject: [PATCH 608/712] Update Minimum Time Visiting All Points.java --- Easy/Minimum Time Visiting All Points.java | 24 +++++++++++++--------- 1 file changed, 14 insertions(+), 10 deletions(-) diff --git a/Easy/Minimum Time Visiting All Points.java b/Easy/Minimum Time Visiting All Points.java index 774ac97c..ee1a85b1 100644 --- a/Easy/Minimum Time Visiting All Points.java +++ b/Easy/Minimum Time Visiting All Points.java @@ -1,13 +1,17 @@ class Solution { - public int minTimeToVisitAllPoints(int[][] points) { - int time = 0; - for (int i = 1; i < points.length; i++) { - int[] prevPoint = points[i - 1]; - int[] currPoint = points[i]; - time += Math.max( - Math.abs(prevPoint[0] - currPoint[0]), Math.abs(prevPoint[1] - currPoint[1]) - ); + public int minTimeToVisitAllPoints(int[][] points) { + int time = 0; + int idx = 0; + while (idx < points.length - 1) { + time += calculateTime(points[idx], points[idx + 1]); + idx++; + } + return time; + } + + private static int calculateTime(int[] p1, int[] p2) { + int x = Math.abs(p1[0] - p2[0]); + int y = Math.abs(p1[1] - p2[1]); + return Math.max(x, y); } - return time; - } } From c8457b18c67c6944a3fd05e0266e5b9e2f66091c Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Tue, 10 Sep 2024 11:02:34 -0700 Subject: [PATCH 609/712] Update Reverse Vowels of a String.java --- Easy/Reverse Vowels of a String.java | 42 ++++++++++++++-------------- 1 file changed, 21 insertions(+), 21 deletions(-) diff --git a/Easy/Reverse Vowels of a String.java b/Easy/Reverse Vowels of a String.java index c1ea0294..ea10d13c 100644 --- a/Easy/Reverse Vowels of a String.java +++ b/Easy/Reverse Vowels of a String.java @@ -1,24 +1,24 @@ class Solution { - public String reverseVowels(String s) { - int left = 0; - int right = s.length() - 1; - String vowels = "aeiouAEIOU"; - char[] chars = s.toCharArray(); - while (left < right) { - int vowelIndexLeft = vowels.indexOf(chars[left]); - int vowelIndexRight = vowels.indexOf(chars[right]); - if (vowelIndexLeft != -1 && vowelIndexRight != -1) { - char temp = chars[left]; - chars[left++] = chars[right]; - chars[right--] = temp; - } - else if (vowelIndexRight == -1) { - right--; - } - else { - left++; - } + + private static final Set VOWELS = Set.of('a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U'); + + public String reverseVowels(String s) { + int left = 0; + int right = s.length() - 1; + char[] chars = s.toCharArray(); + while (left <= right) { + if (VOWELS.contains(chars[left]) && VOWELS.contains(chars[right])) { + char temp = chars[left]; + chars[left] = chars[right]; + chars[right] = temp; + left++; + right--; + } else if (!VOWELS.contains(chars[left])) { + left++; + } else if (!VOWELS.contains(chars[right])) { + right--; + } + } + return String.valueOf(chars); } - return String.valueOf(chars); - } } From f029595755aa34a81caae72c31ad1a629cfd9fda Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Thu, 12 Sep 2024 08:30:42 -0700 Subject: [PATCH 610/712] Update Maximum Size Subarray Sum Equals k.java --- .../Maximum Size Subarray Sum Equals k.java | 29 +++++++++---------- 1 file changed, 14 insertions(+), 15 deletions(-) diff --git a/Medium/Maximum Size Subarray Sum Equals k.java b/Medium/Maximum Size Subarray Sum Equals k.java index 97d37973..dce7007a 100644 --- a/Medium/Maximum Size Subarray Sum Equals k.java +++ b/Medium/Maximum Size Subarray Sum Equals k.java @@ -1,18 +1,17 @@ class Solution { - public int maxSubArrayLen(int[] nums, int k) { - Map map = new HashMap<>(); - int res = 0; - int sum = 0; - for (int i = 0; i < nums.length; i++) { - sum += nums[i]; - if (sum == k) { - res = i + 1; - } - else if (map.containsKey(sum - k)) { - res = Math.max(res, i - map.get(sum - k)); - } - map.putIfAbsent(sum, i); + public int maxSubArrayLen(int[] nums, int k) { + Map map = new HashMap<>(); + int prefixSum = 0; + int max = 0; + for (int i = 0; i < nums.length; i++) { + prefixSum += nums[i]; + if (prefixSum == k) { + max = i + 1; + } else if (map.containsKey(prefixSum - k)) { + max = Math.max(max, i - map.get(prefixSum - k)); + } + map.putIfAbsent(prefixSum, i); + } + return max; } - return res; - } } From 08ae7d68bdaea6e4d8a1141b5d2a7574e3c47cdb Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Fri, 13 Sep 2024 09:12:25 -0700 Subject: [PATCH 611/712] Create XOR Queries of a Subarray.java --- Medium/XOR Queries of a Subarray.java | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+) create mode 100644 Medium/XOR Queries of a Subarray.java diff --git a/Medium/XOR Queries of a Subarray.java b/Medium/XOR Queries of a Subarray.java new file mode 100644 index 00000000..0bdfc9ca --- /dev/null +++ b/Medium/XOR Queries of a Subarray.java @@ -0,0 +1,24 @@ +class Solution { + public int[] xorQueries(int[] arr, int[][] queries) { + int n = arr.length; + int[] prefixXors = new int[n]; + int xor = 0; + for (int i = 0; i < n; i++) { + xor = xor ^ arr[i]; + prefixXors[i] = xor; + } + n = queries.length; + int[] result = new int[n]; + for (int i = 0; i < n; i++) { + int[] query = queries[i]; + int left = query[0]; + int right = query[1]; + int xorResult = prefixXors[right]; + if (left != 0) { + xorResult = xorResult ^ prefixXors[left - 1]; + } + result[i] = xorResult; + } + return result; + } +} From ec93192b5b6d0d395679043110bef3b3df155d43 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sat, 14 Sep 2024 10:33:16 -0700 Subject: [PATCH 612/712] Create Longest Subarray With Maximum Bitwise AND.java --- ...est Subarray With Maximum Bitwise AND.java | 20 +++++++++++++++++++ 1 file changed, 20 insertions(+) create mode 100644 Medium/Longest Subarray With Maximum Bitwise AND.java diff --git a/Medium/Longest Subarray With Maximum Bitwise AND.java b/Medium/Longest Subarray With Maximum Bitwise AND.java new file mode 100644 index 00000000..63c1ca55 --- /dev/null +++ b/Medium/Longest Subarray With Maximum Bitwise AND.java @@ -0,0 +1,20 @@ +class Solution { + public int longestSubarray(int[] nums) { + int result = 0; + int max = 0; + int count = 0; + for (int num : nums) { + if (max < num) { + max = num; + result = count = 0; + } + if (max == num) { + count++; + } else { + count = 0; + } + result = Math.max(result, count); + } + return result; + } +} From 4e3321b796755556dbcb22ca263ca558b2fbf626 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 15 Sep 2024 08:56:53 -0700 Subject: [PATCH 613/712] Create Find the Longest Substring Containing Vowels in Even Counts.java --- ...ring Containing Vowels in Even Counts.java | 22 +++++++++++++++++++ 1 file changed, 22 insertions(+) create mode 100644 Medium/Find the Longest Substring Containing Vowels in Even Counts.java diff --git a/Medium/Find the Longest Substring Containing Vowels in Even Counts.java b/Medium/Find the Longest Substring Containing Vowels in Even Counts.java new file mode 100644 index 00000000..66e33ef9 --- /dev/null +++ b/Medium/Find the Longest Substring Containing Vowels in Even Counts.java @@ -0,0 +1,22 @@ +class Solution { + public int findTheLongestSubstring(String s) { + int prefixXor = 0; + char[] frequency = new char[26]; + frequency['a' - 'a'] = 1; + frequency['e' - 'a'] = 2; + frequency['i' - 'a'] = 4; + frequency['o' - 'a'] = 8; + frequency['u' - 'a'] = 16; + int[] indexMap = new int[32]; + Arrays.fill(indexMap, -1); + int result = 0; + for (int i = 0; i < s.length(); i++) { + prefixXor ^= frequency[s.charAt(i) - 'a']; + if (indexMap[prefixXor] == -1 && prefixXor != 0) { + indexMap[prefixXor] = i; + } + result = Math.max(result, i - indexMap[prefixXor]); + } + return result; + } +} From f6c5fbcf06e1cc589de81072d148ee5933d7b72d Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 15 Sep 2024 21:30:25 -0700 Subject: [PATCH 614/712] Create Find Indices of Stable Mountains.java --- Easy/Find Indices of Stable Mountains.java | 11 +++++++++++ 1 file changed, 11 insertions(+) create mode 100644 Easy/Find Indices of Stable Mountains.java diff --git a/Easy/Find Indices of Stable Mountains.java b/Easy/Find Indices of Stable Mountains.java new file mode 100644 index 00000000..3e0fbd79 --- /dev/null +++ b/Easy/Find Indices of Stable Mountains.java @@ -0,0 +1,11 @@ +class Solution { + public List stableMountains(int[] height, int threshold) { + List result = new ArrayList<>(); + for (int i = 1; i < height.length; i++) { + if (height[i - 1] > threshold) { + result.add(i); + } + } + return result; + } +} From b10f51abbd6353d0469b733252bc3c00a0089f75 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Tue, 17 Sep 2024 06:34:56 -0700 Subject: [PATCH 615/712] Create Smallest Common Region.java --- Medium/Smallest Common Region.java | 32 ++++++++++++++++++++++++++++++ 1 file changed, 32 insertions(+) create mode 100644 Medium/Smallest Common Region.java diff --git a/Medium/Smallest Common Region.java b/Medium/Smallest Common Region.java new file mode 100644 index 00000000..4d8ce894 --- /dev/null +++ b/Medium/Smallest Common Region.java @@ -0,0 +1,32 @@ +class Solution { + public String findSmallestRegion(List> regions, String region1, String region2) { + Map regionToParentMap = new HashMap<>(); + for (List region : regions) { + String parent = region.getFirst(); + for (int i = 1; i < region.size(); i++) { + regionToParentMap.put(region.get(i), parent); + } + } + List pathOne = trace(region1, regionToParentMap); + List pathTwo = trace(region2, regionToParentMap); + int idxOne = 0; + int idxTwo = 0; + while (idxOne < pathOne.size() && idxTwo < pathTwo.size() && pathOne.get(idxOne).equals(pathTwo.get(idxTwo))) { + idxOne++; + idxTwo++; + } + return pathOne.get(idxOne - 1); + } + + private List trace(String region, Map regionToParentMap) { + List path = new ArrayList<>(); + path.add(region); + while (regionToParentMap.containsKey(region)) { + String parent = regionToParentMap.get(region); + path.add(parent); + region = parent; + } + Collections.reverse(path); + return path; + } +} From 20d5bc1645f2112c99ab9296f8ae50b4542e946c Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Thu, 19 Sep 2024 06:32:29 -0700 Subject: [PATCH 616/712] Create Different Ways to Add Parentheses.java --- Medium/Different Ways to Add Parentheses.java | 42 +++++++++++++++++++ 1 file changed, 42 insertions(+) create mode 100644 Medium/Different Ways to Add Parentheses.java diff --git a/Medium/Different Ways to Add Parentheses.java b/Medium/Different Ways to Add Parentheses.java new file mode 100644 index 00000000..706fcf6c --- /dev/null +++ b/Medium/Different Ways to Add Parentheses.java @@ -0,0 +1,42 @@ +class Solution { + public List diffWaysToCompute(String expression) { + List result = new ArrayList<>(); + if (expression.length() == 0) { + return result; + } + if (expression.length() == 1) { + result.add(Integer.parseInt(expression)); + return result; + } + if (expression.length() == 2 && Character.isDigit(expression.charAt(0))) { + result.add(Integer.parseInt(expression)); + return result; + } + for (int i = 0; i < expression.length(); i++) { + char c = expression.charAt(i); + if (Character.isDigit(c)) { + continue; + } + List leftResult = diffWaysToCompute(expression.substring(0, i)); + List rightResult = diffWaysToCompute(expression.substring(i + 1)); + for (int leftVal : leftResult) { + for (int rightVal : rightResult) { + int value = 0; + switch(c) { + case '+': + value = leftVal + rightVal; + break; + case '-': + value = leftVal - rightVal; + break; + case '*': + value = leftVal * rightVal; + break; + } + result.add(value); + } + } + } + return result; + } +} From 33cbd03bdbc238fdfa2ba6949249af8d503c64f6 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Fri, 20 Sep 2024 06:58:05 -0700 Subject: [PATCH 617/712] Create Shortest Palindrome.java --- Hard/Shortest Palindrome.java | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+) create mode 100644 Hard/Shortest Palindrome.java diff --git a/Hard/Shortest Palindrome.java b/Hard/Shortest Palindrome.java new file mode 100644 index 00000000..3ff38e40 --- /dev/null +++ b/Hard/Shortest Palindrome.java @@ -0,0 +1,23 @@ +class Solution { + public String shortestPalindrome(String s) { + int n = s.length(); + if (n == 0) { + return s; + } + int left = 0; + for (int right = n - 1; right >= 0; right--) { + if (s.charAt(right) == s.charAt(left)) { + left++; + } + } + if (left == n) { + return s; + } + String nonPalindromeSuffix = s.substring(left); + StringBuilder reverseSuffix = new StringBuilder(nonPalindromeSuffix).reverse(); + return reverseSuffix + .append(shortestPalindrome(s.substring(0, left))) + .append(nonPalindromeSuffix) + .toString(); + } +} From c97bb9f4059847b67a7f53ca9fb9ee11ff385ab1 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Fri, 20 Sep 2024 17:44:54 -0700 Subject: [PATCH 618/712] Update Lexicographical Numbers.java --- Medium/Lexicographical Numbers.java | 31 ++++++++++++++--------------- 1 file changed, 15 insertions(+), 16 deletions(-) diff --git a/Medium/Lexicographical Numbers.java b/Medium/Lexicographical Numbers.java index c0ccab5e..4476017b 100644 --- a/Medium/Lexicographical Numbers.java +++ b/Medium/Lexicographical Numbers.java @@ -1,19 +1,18 @@ class Solution { - public List lexicalOrder(int n) { - List result = new ArrayList<>(); - for (int i = 1; i < 10; i++) { - dfs(i, n, result); + public List lexicalOrder(int n) { + List result = new ArrayList<>(); + int curr = 1; + for (int i = 0; i < n; i++) { + result.add(curr); + if (curr * 10 <= n) { + curr *= 10; + } else { + while (curr % 10 == 9 || curr == n) { + curr /= 10; + } + curr++; + } + } + return result; } - return result; - } - - private void dfs(int curr, int n, List result) { - if (curr > n) { - return; - } - result.add(curr); - for (int i = 0; i < 10; i++) { - dfs(10 * curr + i, n, result); - } - } } From 68486f5d8e372ceeed62ff36dedbdfa95799ee11 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sat, 21 Sep 2024 07:13:55 -0700 Subject: [PATCH 619/712] Update Sliding Window Median.java --- Hard/Sliding Window Median.java | 117 ++++++++++++++------------------ 1 file changed, 52 insertions(+), 65 deletions(-) diff --git a/Hard/Sliding Window Median.java b/Hard/Sliding Window Median.java index 944af371..e37c289d 100644 --- a/Hard/Sliding Window Median.java +++ b/Hard/Sliding Window Median.java @@ -1,72 +1,59 @@ class Solution { - List list; - double[] ans; - boolean isEven; - - public double[] medianSlidingWindow(int[] nums, int k) { - list = new ArrayList<>(); - ans = new double[nums.length - k + 1]; - isEven = k % 2 == 0; - - for (int i=0; i list.get(list.size() - 1)) { - return list.size(); - } - - int start = 0; - int end = list.size(); - - while (start < end) { - int mid = (start + end) / 2; - - if (list.get(mid) < num) { - start = mid + 1; - } - else { - end = mid; + public double[] medianSlidingWindow(int[] nums, int windowSize) { + double[] medians = new double[nums.length - windowSize + 1]; + Map delayedRemovals = new HashMap<>(); + PriorityQueue maxHeap = new PriorityQueue<>(Collections.reverseOrder()); + PriorityQueue minHeap = new PriorityQueue<>(); + int currentIndex = 0; + while (currentIndex < windowSize) { + maxHeap.add(nums[currentIndex++]); + } + for (int j = 0; j < windowSize / 2; j++) { + minHeap.add(maxHeap.poll()); + } + int medianIndex = 0; + while (true) { + if (windowSize % 2 == 1) { + medians[medianIndex++] = maxHeap.peek(); + } else { + medians[medianIndex++] = ((double) maxHeap.peek() + (double) minHeap.peek()) / 2.0; } - } - - return end; - } - - private void removeElement(int num) { - for (int i=0; i= nums.length) { break; } + int outNum = nums[currentIndex - windowSize]; + int inNum = nums[currentIndex++]; + int balance = 0; + // Handle outgoing number + balance += (outNum <= maxHeap.peek() ? -1 : 1); + delayedRemovals.put(outNum, delayedRemovals.getOrDefault(outNum, 0) + 1); + // Handle incoming number + if (!maxHeap.isEmpty() && inNum <= maxHeap.peek()) { + balance++; + maxHeap.add(inNum); + } else { + balance--; + minHeap.add(inNum); + } + // Rebalance heaps + if (balance < 0) { + maxHeap.add(minHeap.poll()); + balance++; + } + if (balance > 0) { + minHeap.add(maxHeap.poll()); + balance--; + } + // Remove invalid numbers from the top of the heaps + while (delayedRemovals.getOrDefault(maxHeap.peek(), 0) > 0) { + delayedRemovals.put(maxHeap.peek(), delayedRemovals.get(maxHeap.peek()) - 1); + maxHeap.poll(); + } + while (!minHeap.isEmpty() && delayedRemovals.getOrDefault(minHeap.peek(), 0) > 0) { + delayedRemovals.put(minHeap.peek(), delayedRemovals.get(minHeap.peek()) - 1); + minHeap.poll(); + } } - } - - private double getMedian() { - if (isEven) { - return (double) (list.get(list.size()/2) + list.get(list.size()/2 - 1)) / 2; - } - else { - return (double) list.get(list.size()/2); - } + return medians; } } From fe09ade65cbd4a3b05410a7924619253f79d5358 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sat, 21 Sep 2024 07:30:10 -0700 Subject: [PATCH 620/712] Create Most Beautiful Item for Each Query.java --- Medium/Most Beautiful Item for Each Query.java | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) create mode 100644 Medium/Most Beautiful Item for Each Query.java diff --git a/Medium/Most Beautiful Item for Each Query.java b/Medium/Most Beautiful Item for Each Query.java new file mode 100644 index 00000000..5d2f75db --- /dev/null +++ b/Medium/Most Beautiful Item for Each Query.java @@ -0,0 +1,17 @@ +class Solution { + public int[] maximumBeauty(int[][] items, int[] queries) { + Arrays.sort(items, (a, b) -> (a[0] - b[0])); + TreeMap map = new TreeMap<>(); + map.put(0, 0); + int currMax = 0; + for (int[] item : items) { + currMax = Math.max(currMax, item[1]); + map.put(item[0], currMax); + } + int[] result = new int[queries.length]; + for (int i = 0; i < queries.length; i++) { + result[i] = map.floorEntry(queries[i]).getValue(); + } + return result; + } +} From 049b2483f54ff74ed04e872c54e272529c99ca8d Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 22 Sep 2024 08:29:37 -0700 Subject: [PATCH 621/712] Update Longest Word With All Prefixes.java --- Medium/Longest Word With All Prefixes.java | 94 ++++++++++++---------- 1 file changed, 50 insertions(+), 44 deletions(-) diff --git a/Medium/Longest Word With All Prefixes.java b/Medium/Longest Word With All Prefixes.java index 567aea3a..a2a69a0f 100644 --- a/Medium/Longest Word With All Prefixes.java +++ b/Medium/Longest Word With All Prefixes.java @@ -1,53 +1,59 @@ class Solution { - public String longestWord(String[] words) { - TrieNode root = new TrieNode(); - root.isWord = true; - Map> map = new TreeMap<>((o1, o2) -> o2 - o1); - for (String word : words) { - addToTrie(word, root); - map.computeIfAbsent(word.length(), k -> new PriorityQueue<>(String::compareTo)).add(word); - } - for (Integer key : map.keySet()) { - PriorityQueue priorityQueue = map.get(key); - while (!priorityQueue.isEmpty()) { - String candidateWord = priorityQueue.poll(); - if (wordContainAllPrefixes(candidateWord, root)) { - return candidateWord; + public String longestWord(String[] words) { + TrieNode root = new TrieNode(); + for (String word : words) { + root.insert(word); + } + String longestValidWord = ""; + for (String word : words) { + if (root.hasAllPrefixes(word)) { + if (word.length() > longestValidWord.length() || + (word.length() == longestValidWord.length() && word.compareTo(longestValidWord) < 0)) { + longestValidWord = word; + } + } } - } + return longestValidWord; } - return ""; - } - private boolean wordContainAllPrefixes(String word, TrieNode root) { - TrieNode curr = root; - for (int i = 0; i < word.length(); i++) { - if (!curr.isWord) { - return false; - } - curr = curr.children.get(word.charAt(i)); - } - return curr.isWord; - } + static class TrieNode { + private final Map children; + private boolean isWord; - private void addToTrie(String word, TrieNode root) { - TrieNode curr = root; - for (int i = 0; i < word.length(); i++) { - if (!curr.children.containsKey(word.charAt(i))) { - curr.children.put(word.charAt(i), new TrieNode()); - } - curr = curr.children.get(word.charAt(i)); - } - curr.isWord = true; - } + public TrieNode() { + this.children = new HashMap<>(); + } - private static class TrieNode { - Map children; - boolean isWord; + public void insert(String word) { + TrieNode curr = this; + for (char c : word.toCharArray()) { + curr = curr.getOrCreateChild(c); + } + curr.isWord = true; + } + + public boolean hasAllPrefixes(String word) { + TrieNode curr = this; + for (char c : word.toCharArray()) { + TrieNode child = curr.children.getOrDefault(c, null); + if (child == null) { + return false; + } + if (!child.isWord) { + return false; + } + curr = child; + } + return true; + } - public TrieNode() { - this.children = new HashMap<>(); - this.isWord = false; + private TrieNode getOrCreateChild(char c) { + if (children.containsKey(c)) { + return children.get(c); + } + TrieNode node = new TrieNode(); + children.put(c, node); + return node; + } } - } } From f12e321cfd48e32055dcbc0036907dfa6f46b4e2 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 22 Sep 2024 10:21:41 -0700 Subject: [PATCH 622/712] Update Binary Search Tree Iterator II.java --- Medium/Binary Search Tree Iterator II.java | 74 +++++++++++----------- 1 file changed, 36 insertions(+), 38 deletions(-) diff --git a/Medium/Binary Search Tree Iterator II.java b/Medium/Binary Search Tree Iterator II.java index 9f98110c..61ab1d10 100644 --- a/Medium/Binary Search Tree Iterator II.java +++ b/Medium/Binary Search Tree Iterator II.java @@ -14,49 +14,47 @@ * } */ class BSTIterator { - - private Deque stack; - private List arr; - private TreeNode lastNode; - private int pointer; - - public BSTIterator(TreeNode root) { - this.stack = new ArrayDeque(); - this.arr = new ArrayList<>(); - this.lastNode = root; - this.pointer = -1; - } - public boolean hasNext() { - return !this.stack.isEmpty() || lastNode != null || this.pointer < arr.size() - 1; - } + private final Deque primary; + private final List secondary; + private int index; - public int next() { - this.pointer++; - if (this.pointer == this.arr.size()) { - updateStack(lastNode); - TreeNode curr = this.stack.pop(); - lastNode = curr.right; - this.arr.add(curr.val); + public BSTIterator(TreeNode root) { + this.primary = new ArrayDeque<>(); + this.secondary = new ArrayList<>(); + this.index = -1; + traverse(root); + } + + public boolean hasNext() { + return !primary.isEmpty() || index < secondary.size() - 1; + } + + public int next() { + index++; + if (index == secondary.size()) { + TreeNode curr = primary.pop(); + secondary.add(curr.val); + traverse(curr.right); + } + return secondary.get(index); + } + + public boolean hasPrev() { + return index > 0; + } + + public int prev() { + index--; + return secondary.get(index); } - return this.arr.get(this.pointer); - } - - public boolean hasPrev() { - return this.pointer > 0; - } - public int prev() { - this.pointer--; - return this.arr.get(this.pointer); - } - - private void updateStack(TreeNode node) { - while (node != null) { - this.stack.push(node); - node = node.left; + private void traverse(TreeNode root) { + while (root != null) { + primary.push(root); + root = root.left; + } } - } } /** From 76548263a55db618f5973d3c7a88f49ace92a772 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 22 Sep 2024 15:16:25 -0700 Subject: [PATCH 623/712] Create K-th Smallest in Lexicographical Order.java --- ...-th Smallest in Lexicographical Order.java | 27 +++++++++++++++++++ 1 file changed, 27 insertions(+) create mode 100644 Hard/K-th Smallest in Lexicographical Order.java diff --git a/Hard/K-th Smallest in Lexicographical Order.java b/Hard/K-th Smallest in Lexicographical Order.java new file mode 100644 index 00000000..9063cd56 --- /dev/null +++ b/Hard/K-th Smallest in Lexicographical Order.java @@ -0,0 +1,27 @@ +class Solution { + public int findKthNumber(int n, int k) { + int curr = 1; + k--; + while (k > 0) { + int count = countNumsWithPrefix(n, curr, curr + 1); + if (count <= k) { + curr++; + k -= count; + } else { + curr *= 10; + k--; + } + } + return curr; + } + + private int countNumsWithPrefix(int n, long start, long end) { + int count = 0; + while (start <= n) { + count += Math.min(n + 1, end) - start; + start *= 10; + end *= 10; + } + return count; + } +} From 7e4afd555a663578a5662bd8e83459350cd0ccd5 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sat, 28 Sep 2024 09:09:04 -0700 Subject: [PATCH 624/712] Update Design Circular Deque.java --- Medium/Design Circular Deque.java | 154 ++++++++++++++---------------- 1 file changed, 70 insertions(+), 84 deletions(-) diff --git a/Medium/Design Circular Deque.java b/Medium/Design Circular Deque.java index 86949d4a..66667ed5 100644 --- a/Medium/Design Circular Deque.java +++ b/Medium/Design Circular Deque.java @@ -1,104 +1,90 @@ class MyCircularDeque { - - private Node head; - private Node tail; - private int k; - private int currSize; - public MyCircularDeque(int k) { - this.k = k; - this.currSize = 0; - this.head = new Node(-1); - this.tail = new Node(-1); - this.head.next = this.tail; - this.tail.prev = this.head; - } + private final Node head; + private final Node tail; + private final int capacity; + private int size; - public boolean insertFront(int value) { - if (isFull()) { - return false; + public MyCircularDeque(int k) { + head = new Node(-1); + tail = new Node(-1); + head.next = tail; + tail.prev = head; + capacity = k; + size = 0; } - Node node = new Node(value); - Node nextToHead = head.next; - head.next = node; - node.prev = head; - node.next = nextToHead; - nextToHead.prev = node; - currSize++; - return true; - } - public boolean insertLast(int value) { - if (isFull()) { - return false; + public boolean insertFront(int value) { + if (size == capacity) { + return false; + } + Node node = new Node(value); + node.next = head.next; + node.prev = head; + head.next.prev = node; + head.next = node; + size++; + return true; } - Node node = new Node(value); - Node prevToTail = tail.prev; - tail.prev = node; - node.next = tail; - prevToTail.next = node; - node.prev = prevToTail; - currSize++; - return true; - } - public boolean deleteFront() { - if (isEmpty()) { - return false; + public boolean insertLast(int value) { + if (size == capacity) { + return false; + } + Node node = new Node(value); + node.prev = tail.prev; + node.next = tail; + tail.prev.next = node; + tail.prev = node; + size++; + return true; } - Node toDelete = head.next; - deleteNode(toDelete); - return true; - } - public boolean deleteLast() { - if (isEmpty()) { - return false; + public boolean deleteFront() { + if (size == 0) { + return false; + } + head.next.next.prev = head; + head.next = head.next.next; + size--; + return true; } - Node toDelete = tail.prev; - deleteNode(toDelete); - return true; - } - public int getFront() { - if (isEmpty()) { - return -1; + public boolean deleteLast() { + if (size == 0) { + return false; + } + tail.prev.prev.next = tail; + tail.prev = tail.prev.prev; + size--; + return true; } - return head.next.val; - } - public int getRear() { - if (isEmpty()) { - return -1; + public int getFront() { + return head.next.value; } - return tail.prev.val; - } - public boolean isEmpty() { - return currSize == 0; - } + public int getRear() { + return tail.prev.value; + } + + public boolean isEmpty() { + return size == 0; + } + + public boolean isFull() { + return size == capacity; + } + + static class Node { + int value; + Node next; + Node prev; - public boolean isFull() { - return currSize == k; - } - - private void deleteNode(Node node) { - Node prevToNode = node.prev; - Node nextToNode = node.next; - prevToNode.next = nextToNode; - nextToNode.prev = prevToNode; - currSize--; - } - - private static class Node { - int val; - Node next; - Node prev; - - public Node(int val) { - this.val = val; + Node(int value) { + this.value = value; + } } - } } /** From 877f164cd5305a15c080c7e0122c092d3abe4eb2 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Mon, 30 Sep 2024 08:21:33 -0700 Subject: [PATCH 625/712] Update Design a Stack With Increment Operation.java --- ...sign a Stack With Increment Operation.java | 62 +++++++++---------- 1 file changed, 31 insertions(+), 31 deletions(-) diff --git a/Medium/Design a Stack With Increment Operation.java b/Medium/Design a Stack With Increment Operation.java index 9164401b..9e4ec3a3 100644 --- a/Medium/Design a Stack With Increment Operation.java +++ b/Medium/Design a Stack With Increment Operation.java @@ -1,40 +1,40 @@ class CustomStack { - - private Stack stack; - private int[] incrementArray; - private int maxSize; - - public CustomStack(int maxSize) { - this.stack = new Stack<>(); - this.incrementArray = new int[maxSize]; - this.maxSize = maxSize; - } - public void push(int x) { - if (this.stack.size() < this.maxSize) { - this.stack.push(x); - } - } + private final int maxSize; + private final Stack stack; + private int[] increment; - public int pop() { - int idx = this.stack.size() - 1; - if (idx < 0) { - return -1; + public CustomStack(int maxSize) { + this.maxSize = maxSize; + this.stack = new Stack<>(); + this.increment = new int[maxSize]; } - if (idx > 0) { - this.incrementArray[idx - 1] += this.incrementArray[idx]; + + public void push(int x) { + if (stack.size() < maxSize) { + stack.push(x); + } } - int result = this.stack.pop() + this.incrementArray[idx]; - this.incrementArray[idx] = 0; - return result; - } - - public void increment(int k, int val) { - int idx = Math.min(k, this.stack.size()) - 1; - if (idx >= 0) { - this.incrementArray[idx] += val; + + public int pop() { + int idx = stack.size() - 1; + if (idx < 0) { + return -1; + } + if (idx > 0) { + increment[idx - 1] += increment[idx]; + } + int result = stack.pop() + increment[idx]; + increment[idx] = 0; + return result; + } + + public void increment(int k, int val) { + int idx = Math.min(k, stack.size()) - 1; + if (idx >= 0) { + increment[idx] += val; + } } - } } /** From a752149a8e834ce931f706737ab398d6e7c57597 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Tue, 1 Oct 2024 06:47:24 -0700 Subject: [PATCH 626/712] Create Check If Array Pairs Are Divisible by k.java --- ...eck If Array Pairs Are Divisible by k.java | 20 +++++++++++++++++++ 1 file changed, 20 insertions(+) create mode 100644 Medium/Check If Array Pairs Are Divisible by k.java diff --git a/Medium/Check If Array Pairs Are Divisible by k.java b/Medium/Check If Array Pairs Are Divisible by k.java new file mode 100644 index 00000000..d942915f --- /dev/null +++ b/Medium/Check If Array Pairs Are Divisible by k.java @@ -0,0 +1,20 @@ +class Solution { + public boolean canArrange(int[] arr, int k) { + Map map = new HashMap<>(); + for (int num : arr) { + int remainder = ((num % k) + k) % k; + map.put(remainder, map.getOrDefault(remainder, 0) + 1); + } + for (int num : arr) { + int remainder = ((num % k) + k) % k; + if (remainder == 0) { + if (map.get(remainder) % 2 == 1) { + return false; + } + } else if (!map.get(remainder).equals(map.get(k - remainder))) { + return false; + } + } + return true; + } +} From 1faa9c843764223e985afa1d6d816b4277f4707c Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Tue, 1 Oct 2024 17:34:31 -0700 Subject: [PATCH 627/712] Update Rank Transform of an Array.java --- Easy/Rank Transform of an Array.java | 33 ++++++++++++++-------------- 1 file changed, 16 insertions(+), 17 deletions(-) diff --git a/Easy/Rank Transform of an Array.java b/Easy/Rank Transform of an Array.java index 401c317b..3f9192fd 100644 --- a/Easy/Rank Transform of an Array.java +++ b/Easy/Rank Transform of an Array.java @@ -1,20 +1,19 @@ class Solution { - public int[] arrayRankTransform(int[] arr) { - PriorityQueue pq = new PriorityQueue<>(); - for (int num : arr) { - pq.add(num); + public int[] arrayRankTransform(int[] arr) { + int[] copyArr = Arrays.copyOf(arr, arr.length); + Arrays.sort(arr); + int rank = 1; + Map numToRank = new HashMap<>(); + for (int num : arr) { + if (numToRank.containsKey(num)) { + continue; + } + numToRank.put(num, rank++); + } + int[] result = new int[arr.length]; + for (int i = 0; i < arr.length; i++) { + result[i] = numToRank.get(copyArr[i]); + } + return result; } - int rank = 1; - Map map = new HashMap<>(); - while (!pq.isEmpty()) { - int removed = pq.poll(); - if (!map.containsKey(removed)) { - map.put(removed, rank++); - } - } - for (int i = 0; i < arr.length; i++) { - arr[i] = map.get(arr[i]); - } - return arr; - } } From 914a2fc291a5634d072744e2f57289cea48822da Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Thu, 3 Oct 2024 09:50:16 -0700 Subject: [PATCH 628/712] Create Make Sum Divisible by P.java --- Medium/Make Sum Divisible by P.java | 26 ++++++++++++++++++++++++++ 1 file changed, 26 insertions(+) create mode 100644 Medium/Make Sum Divisible by P.java diff --git a/Medium/Make Sum Divisible by P.java b/Medium/Make Sum Divisible by P.java new file mode 100644 index 00000000..ee94817a --- /dev/null +++ b/Medium/Make Sum Divisible by P.java @@ -0,0 +1,26 @@ +class Solution { + public int minSubarray(int[] nums, int p) { + int n = nums.length; + int sum = 0; + for (int num : nums) { + sum = (sum + num) % p; + } + int target = sum % p; + if (target == 0) { + return 0; + } + Map map = new HashMap<>(); + map.put(0, -1); + int currSum = 0; + int result = n; + for (int i = 0; i < n; i++) { + currSum = (currSum + nums[i]) % p; + int needed = (currSum - target + p) % p; + if (map.containsKey(needed)) { + result = Math.min(result, i - map.get(needed)); + } + map.put(currSum, i); + } + return result == n ? -1 : result; + } +} From 650d084e89e1fe0d4ac6452d502fd280787e4f14 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Thu, 3 Oct 2024 17:51:53 -0700 Subject: [PATCH 629/712] Update Divide Players Into Teams of Equal Skill.java --- ...ide Players Into Teams of Equal Skill.java | 28 +++++++++++-------- 1 file changed, 17 insertions(+), 11 deletions(-) diff --git a/Medium/Divide Players Into Teams of Equal Skill.java b/Medium/Divide Players Into Teams of Equal Skill.java index bebcec21..41a5f1f7 100644 --- a/Medium/Divide Players Into Teams of Equal Skill.java +++ b/Medium/Divide Players Into Teams of Equal Skill.java @@ -1,19 +1,25 @@ class Solution { public long dividePlayers(int[] skill) { - Arrays.sort(skill); + int n = skill.length; + int totalSkill = 0; + Map map = new HashMap<>(); + for (int s : skill) { + totalSkill += s; + map.put(s, map.getOrDefault(s, 0) + 1); + } + if (totalSkill % (n / 2) != 0) { + return -1; + } + int targetSkill = totalSkill / (n / 2); long totalChemistry = 0; - int start = 0; - int end = skill.length - 1; - int totalSkill = skill[start] + skill[end]; - while (start < end) { - int currTotal = skill[start] + skill[end]; - if (currTotal != totalSkill) { + for (int currSkill : map.keySet()) { + int partnerSkill = targetSkill - currSkill; + int currSkillFreq = map.get(currSkill); + if (!map.containsKey(partnerSkill) || currSkillFreq != map.get(partnerSkill)) { return -1; } - totalChemistry += skill[start] * skill[end]; - start++; - end--; + totalChemistry += (long) currSkill * (long) partnerSkill * (long) currSkillFreq; } - return totalChemistry; + return totalChemistry / 2; } } From 1c21ef27bee9a434d927ebaab33aa6910a192f2c Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sat, 5 Oct 2024 18:26:00 -0700 Subject: [PATCH 630/712] Update Sentence Similarity III.java --- Medium/Sentence Similarity III.java | 51 +++++++++++++---------------- 1 file changed, 23 insertions(+), 28 deletions(-) diff --git a/Medium/Sentence Similarity III.java b/Medium/Sentence Similarity III.java index e85bb024..506dc110 100644 --- a/Medium/Sentence Similarity III.java +++ b/Medium/Sentence Similarity III.java @@ -1,31 +1,26 @@ class Solution { - public boolean areSentencesSimilar(String sentence1, String sentence2) { - return isSimilar(sentence1.split(" "), sentence2.split(" ")) || isSimilar(sentence2.split(" "), - sentence1.split(" ")); - } - - private boolean isSimilar(String[] matcher, String[] target) { - int targetStartIdx = 0; - int matcherCurrentIdx = 0; - while (targetStartIdx < target.length && matcherCurrentIdx < matcher.length) { - if (!matcher[matcherCurrentIdx].equals(target[targetStartIdx])) { - break; - } - targetStartIdx++; - matcherCurrentIdx++; + public boolean areSentencesSimilar(String sentence1, String sentence2) { + int idxOneStart = 0; + int idxTwoStart = 0; + String[] wordsOne = sentence1.split("\\s+"); + String[] wordsTwo = sentence2.split("\\s+"); + while (idxOneStart < wordsOne.length && idxOneStart < wordsTwo.length && wordsOne[idxOneStart].equals(wordsTwo[idxTwoStart])) { + idxOneStart++; + idxTwoStart++; + } + boolean startFound = idxOneStart > 0; + if (idxOneStart == wordsOne.length && idxTwoStart == wordsTwo.length) { + return true; + } + int idxOneEnd = wordsOne.length - 1; + int idxTwoEnd = wordsTwo.length - 1; + while (idxOneEnd >= idxOneStart && idxTwoEnd >= idxTwoStart && wordsOne[idxOneEnd].equals(wordsTwo[idxTwoEnd])) { + idxOneEnd--; + idxTwoEnd--; + } + if (idxOneEnd != idxOneStart - 1 && idxTwoEnd != idxTwoStart - 1) { + return false; + } + return true; } - if (targetStartIdx == target.length) { - return true; - } - int targetEndIdx = target.length - 1; - matcherCurrentIdx = matcher.length - 1; - while (targetEndIdx >= targetStartIdx && matcherCurrentIdx >= 0) { - if (!matcher[matcherCurrentIdx].equals(target[targetEndIdx])) { - return false; - } - targetEndIdx--; - matcherCurrentIdx--; - } - return targetEndIdx == targetStartIdx - 1; - } } From ca3dcbee5b4c14751ab1f56532a9380a004dd1bc Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Mon, 7 Oct 2024 17:31:53 -0700 Subject: [PATCH 631/712] Create Minimum Number of Swaps to Make the String Balanced.java --- ... of Swaps to Make the String Balanced.java | 24 +++++++++++++++++++ 1 file changed, 24 insertions(+) create mode 100644 Medium/Minimum Number of Swaps to Make the String Balanced.java diff --git a/Medium/Minimum Number of Swaps to Make the String Balanced.java b/Medium/Minimum Number of Swaps to Make the String Balanced.java new file mode 100644 index 00000000..79935f13 --- /dev/null +++ b/Medium/Minimum Number of Swaps to Make the String Balanced.java @@ -0,0 +1,24 @@ +class Solution { + public int minSwaps(String s) { + char[] chars = s.toCharArray(); + Stack openBrackets = new Stack<>(); + for (int i = 0; i < chars.length; i++) { + if (chars[i] == '[') { + openBrackets.push(i); + } + } + int open = 0; + int swaps = 0; + for (int i = 0; i < chars.length; i++) { + open += chars[i] == '[' ? 1 : -1; + if (open < 0) { + swaps++; + int endIdx = openBrackets.pop(); + chars[endIdx] = ']'; + chars[i] = '['; + open += 2; + } + } + return swaps; + } +} From 6b30e46841a64facd6a0ce6652b3b791c22b4071 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Wed, 9 Oct 2024 08:03:17 -0700 Subject: [PATCH 632/712] Update Minimum Add to Make Parentheses Valid.java --- ...Minimum Add to Make Parentheses Valid.java | 24 ++++++++----------- 1 file changed, 10 insertions(+), 14 deletions(-) diff --git a/Medium/Minimum Add to Make Parentheses Valid.java b/Medium/Minimum Add to Make Parentheses Valid.java index f119bfe7..7fcfc88d 100644 --- a/Medium/Minimum Add to Make Parentheses Valid.java +++ b/Medium/Minimum Add to Make Parentheses Valid.java @@ -1,18 +1,14 @@ class Solution { - public int minAddToMakeValid(String s) { - int count = 0; - Stack stack = new Stack<>(); - for (char c : s.toCharArray()) { - if (c == '(') { - stack.push(c); - } else { - if (stack.isEmpty()) { - count++; - } else { - stack.pop(); + public int minAddToMakeValid(String s) { + int open = 0; + int count = 0; + for (char c : s.toCharArray()) { + open += c == '(' ? 1 : -1; + if (open < 0) { + count += Math.abs(open); + open = 0; + } } - } + return count + open; } - return count + stack.size(); - } } From d1379d8078e538484116cb808a78388380b306f0 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Wed, 9 Oct 2024 10:14:41 -0700 Subject: [PATCH 633/712] Create Maximum Coins Heroes Can Collect.java --- medium/Maximum Coins Heroes Can Collect.java | 40 ++++++++++++++++++++ 1 file changed, 40 insertions(+) create mode 100644 medium/Maximum Coins Heroes Can Collect.java diff --git a/medium/Maximum Coins Heroes Can Collect.java b/medium/Maximum Coins Heroes Can Collect.java new file mode 100644 index 00000000..1e98abf9 --- /dev/null +++ b/medium/Maximum Coins Heroes Can Collect.java @@ -0,0 +1,40 @@ +class Solution { + public long[] maximumCoins(int[] heroes, int[] monsters, int[] coins) { + List monsterEntities = new ArrayList<>(); + int n = monsters.length; + for (int i = 0; i < n; i++) { + monsterEntities.add(new MonsterEntity(monsters[i], coins[i])); + } + Collections.sort(monsterEntities, (a, b) -> (a.health() - b.health())); + long[] prefixCoinSum = new long[n]; + for (int i = 0; i < n; i++) { + prefixCoinSum[i] = i == 0 ? 0 : prefixCoinSum[i - 1]; + prefixCoinSum[i] += monsterEntities.get(i).coin(); + } + int m = heroes.length; + long[] result = new long[m]; + for (int i = 0; i < m; i++) { + int idx = binarySearch(monsterEntities, heroes[i]); + result[i] = idx != Integer.MIN_VALUE ? prefixCoinSum[idx] : 0; + } + return result; + } + + private int binarySearch(List monsterEntities, int heroHealth) { + int left = 0; + int right = monsterEntities.size() - 1; + int idx = Integer.MIN_VALUE; + while (left <= right) { + int mid = (left + right) / 2; + if (monsterEntities.get(mid).health() <= heroHealth) { + idx = Math.max(idx, mid); + left = mid + 1; + } else { + right = mid - 1; + } + } + return idx; + } + + private static record MonsterEntity(int health, int coin) {} +} From e5760b1d4aaeae4b661093b3dec2e62b541545e6 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Wed, 9 Oct 2024 10:15:04 -0700 Subject: [PATCH 634/712] Rename Maximum Coins Heroes Can Collect.java to Maximum Coins Heroes Can Collect.java --- {medium => Medium}/Maximum Coins Heroes Can Collect.java | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename {medium => Medium}/Maximum Coins Heroes Can Collect.java (100%) diff --git a/medium/Maximum Coins Heroes Can Collect.java b/Medium/Maximum Coins Heroes Can Collect.java similarity index 100% rename from medium/Maximum Coins Heroes Can Collect.java rename to Medium/Maximum Coins Heroes Can Collect.java From d56f44da8d3fdbae82f4e27bef44e27488c5287e Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Thu, 10 Oct 2024 08:39:16 -0700 Subject: [PATCH 635/712] Update Maximum Width Ramp.java --- Medium/Maximum Width Ramp.java | 23 ++++++++++------------- 1 file changed, 10 insertions(+), 13 deletions(-) diff --git a/Medium/Maximum Width Ramp.java b/Medium/Maximum Width Ramp.java index 37eb1862..2463f02b 100644 --- a/Medium/Maximum Width Ramp.java +++ b/Medium/Maximum Width Ramp.java @@ -1,21 +1,18 @@ class Solution { - public int maxWidthRamp(int[] A) { + public int maxWidthRamp(int[] nums) { + int n = nums.length; Stack stack = new Stack<>(); - int ans = 0; - int n = A.length; - - for (int i=0; i A[i]) { - stack.add(i); + for (int i = 0; i < n; i++) { + if (stack.isEmpty() || nums[stack.peek()] > nums[i]) { + stack.push(i); } } - - for (int i=n-1; i>=ans; i--) { - while (!stack.isEmpty() && A[stack.peek()] <= A[i]) { - ans = Math.max(ans, i - stack.pop()); + int result = 0; + for (int i = n - 1; i >= 0; i--) { + while (!stack.isEmpty() && nums[stack.peek()] <= nums[i]) { + result = Math.max(result, i - stack.pop()); } } - - return ans; + return result; } } From ffe05dfbf9f0fbb017472657a1119a14474af94f Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Fri, 11 Oct 2024 14:37:42 -0700 Subject: [PATCH 636/712] Create The Number of the Smallest Unoccupied Chair.java --- ...mber of the Smallest Unoccupied Chair.java | 35 +++++++++++++++++++ 1 file changed, 35 insertions(+) create mode 100644 Medium/The Number of the Smallest Unoccupied Chair.java diff --git a/Medium/The Number of the Smallest Unoccupied Chair.java b/Medium/The Number of the Smallest Unoccupied Chair.java new file mode 100644 index 00000000..6bd41ad2 --- /dev/null +++ b/Medium/The Number of the Smallest Unoccupied Chair.java @@ -0,0 +1,35 @@ +class Solution { + public int smallestChair(int[][] times, int targetFriend) { + PriorityQueue pq = new PriorityQueue<>((o1, o2) -> { + int c = o1[0] - o2[0]; + if (c == 0) { + return o1[1] - o2[1]; + } + return c; + }); + for (int i = 0; i < times.length; i++) { + pq.add(new int[]{times[i][0], times[i][1], i}); + } + PriorityQueue occupiedChairs = new PriorityQueue<>(Comparator.comparingInt(o -> o[0])); + PriorityQueue emptyChairs = new PriorityQueue<>(); + int currChair = 0; + while (!pq.isEmpty()) { + int[] time = pq.poll(); + while (!occupiedChairs.isEmpty() && occupiedChairs.peek()[0] <= time[0]) { + int[] chair = occupiedChairs.poll(); + emptyChairs.add(chair[1]); + } + if (time[2] == targetFriend) { + return emptyChairs.isEmpty() ? currChair : emptyChairs.poll(); + } + if (emptyChairs.isEmpty()) { + occupiedChairs.add(new int[]{time[1], currChair}); + currChair++; + } else { + int chair = emptyChairs.poll(); + occupiedChairs.add(new int[]{time[1], chair}); + } + } + return -1; + } +} From 771c1a5b06c14648c4c4e2f3a3f7aefa668f4039 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Fri, 11 Oct 2024 14:38:57 -0700 Subject: [PATCH 637/712] Update README.md --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index a90fb07e..617cd951 100644 --- a/README.md +++ b/README.md @@ -2,7 +2,7 @@ ## Solutions to Leetcode problems in Java -## [Current Leetcode profile: Solved 1600+ Problems](https://leetcode.com/varunsjsu/) +## [Current Leetcode profile: Solved 1700+ Problems](https://leetcode.com/varunsjsu/) ## [Previous Leetcode profile: Solved 759 Problems](https://leetcode.com/varunu28/) Problem Category | Count From 139140dd8a5224d3c7ce675b118d0c2dd0ac89f8 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sat, 12 Oct 2024 07:49:28 -0700 Subject: [PATCH 638/712] Create Divide Intervals Into Minimum Number of Groups.java --- ...tervals Into Minimum Number of Groups.java | 21 +++++++++++++++++++ 1 file changed, 21 insertions(+) create mode 100644 Medium/Divide Intervals Into Minimum Number of Groups.java diff --git a/Medium/Divide Intervals Into Minimum Number of Groups.java b/Medium/Divide Intervals Into Minimum Number of Groups.java new file mode 100644 index 00000000..b58d0dcb --- /dev/null +++ b/Medium/Divide Intervals Into Minimum Number of Groups.java @@ -0,0 +1,21 @@ +class Solution { + public int minGroups(int[][] intervals) { + Arrays.sort(intervals, (o1, o2) -> { + int c = Integer.compare(o1[0], o2[0]); + if (c == 0) { + return Integer.compare(o1[1], o2[1]); + } + return c; + }); + int max = 0; + PriorityQueue pq = new PriorityQueue<>(); + for (int[] interval : intervals) { + while (!pq.isEmpty() && pq.peek() < interval[0]) { + pq.poll(); + } + pq.add(interval[1]); + max = Math.max(max, pq.size()); + } + return max; + } +} From ab2e5bd95da86a9fd92c7774644c1e91fe14840e Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 13 Oct 2024 16:00:28 -0700 Subject: [PATCH 639/712] Create Smallest Range Covering Elements from K Lists.java --- ... Range Covering Elements from K Lists.java | 29 +++++++++++++++++++ 1 file changed, 29 insertions(+) create mode 100644 Hard/Smallest Range Covering Elements from K Lists.java diff --git a/Hard/Smallest Range Covering Elements from K Lists.java b/Hard/Smallest Range Covering Elements from K Lists.java new file mode 100644 index 00000000..4e814027 --- /dev/null +++ b/Hard/Smallest Range Covering Elements from K Lists.java @@ -0,0 +1,29 @@ +class Solution { + public int[] smallestRange(List> nums) { + PriorityQueue pq = new PriorityQueue<>( + Comparator.comparingInt(a -> a[0])); + int max = Integer.MIN_VALUE; + int start = 0; + int end = Integer.MAX_VALUE; + for (int i = 0; i < nums.size(); i++) { + pq.add(new int[]{nums.get(i).get(0), i, 0}); + max = Math.max(max, nums.get(i).get(0)); + } + while (pq.size() == nums.size()) { + int[] removed = pq.poll(); + int min = removed[0]; + int row = removed[1]; + int col = removed[2]; + if (max - min < end - start) { + start = min; + end = max; + } + if (col + 1 < nums.get(row).size()) { + int next = nums.get(row).get(col + 1); + pq.add(new int[]{next, row, col + 1}); + max = Math.max(max, next); + } + } + return new int[]{start, end}; + } +} From 74177e433ba8c9723053bf93afd433a275d184a7 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Tue, 15 Oct 2024 07:48:08 -0700 Subject: [PATCH 640/712] Create Separate Black and White Balls.java --- Medium/Separate Black and White Balls.java | 13 +++++++++++++ 1 file changed, 13 insertions(+) create mode 100644 Medium/Separate Black and White Balls.java diff --git a/Medium/Separate Black and White Balls.java b/Medium/Separate Black and White Balls.java new file mode 100644 index 00000000..5fc4900f --- /dev/null +++ b/Medium/Separate Black and White Balls.java @@ -0,0 +1,13 @@ +class Solution { + public long minimumSteps(String s) { + int whitePos = 0; + long swaps = 0; + for (int i = 0; i < s.length(); i++) { + if (s.charAt(i) == '0') { + swaps += i - whitePos; + whitePos++; + } + } + return swaps; + } +} From d69d6fa23d5303c23a6bb1e7882f71cc5a3faccf Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Tue, 15 Oct 2024 07:54:33 -0700 Subject: [PATCH 641/712] Update First Unique Number.java --- Medium/First Unique Number.java | 75 ++++++++------------------------- 1 file changed, 17 insertions(+), 58 deletions(-) diff --git a/Medium/First Unique Number.java b/Medium/First Unique Number.java index d5406335..6affb411 100644 --- a/Medium/First Unique Number.java +++ b/Medium/First Unique Number.java @@ -1,68 +1,27 @@ class FirstUnique { - - private Node head; - private Node tail; - private Map map; - - public FirstUnique(int[] nums) { - this.head = new Node(-1); - this.tail = new Node(-1); - this.head.next = this.tail; - this.tail.prev = this.head; - this.map = new HashMap<>(); - for (int num : nums) { - if (map.containsKey(num)) { - deleteNode(map.get(num)); - } else { - Node node = new Node(num); - map.put(num, node); - addToTail(node); - } - } - } - public int showFirstUnique() { - return this.head.next.val; - } + private Map map; + private Queue queue; - public void add(int value) { - if (map.containsKey(value)) { - deleteNode(map.get(value)); - return; + public FirstUnique(int[] nums) { + map = new HashMap<>(); + queue = new LinkedList<>(); + for (int num : nums) { + add(num); + } } - Node node = new Node(value); - map.put(value, node); - addToTail(node); - } - - private void addToTail(Node node) { - Node prevToTail = this.tail.prev; - prevToTail.next = node; - node.next = this.tail; - node.prev = prevToTail; - this.tail.prev = node; - } - - private void deleteNode(Node node) { - if (node == null) { - return; + + public int showFirstUnique() { + while (!queue.isEmpty() && map.get(queue.peek()) > 1) { + queue.remove(); + } + return queue.isEmpty() ? -1 : queue.peek(); } - map.put(node.val, null); - Node prevToNode = node.prev; - Node nextToNode = node.next; - prevToNode.next = nextToNode; - nextToNode.prev = prevToNode; - } - - private static class Node { - int val; - Node next; - Node prev; - public Node(int val) { - this.val = val; + public void add(int value) { + queue.add(value); + map.put(value, map.getOrDefault(value, 0) + 1); } - } } /** From 40e30d0c6424c785b8b51c8f435175dd3b762054 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Wed, 16 Oct 2024 07:00:08 -0700 Subject: [PATCH 642/712] Update Longest Happy String.java --- Medium/Longest Happy String.java | 74 ++++++++++++++++---------------- 1 file changed, 37 insertions(+), 37 deletions(-) diff --git a/Medium/Longest Happy String.java b/Medium/Longest Happy String.java index 145fd638..4af8f747 100644 --- a/Medium/Longest Happy String.java +++ b/Medium/Longest Happy String.java @@ -1,42 +1,42 @@ class Solution { - public String longestDiverseString(int a, int b, int c) { - PriorityQueue priorityQueue = new PriorityQueue<>((o1, o2) -> o2[1] - o1[1]); - if (a > 0) { - priorityQueue.add(new int[]{0, a}); - } - if (b > 0) { - priorityQueue.add(new int[]{1, b}); - } - if (c > 0) { - priorityQueue.add(new int[]{2, c}); - } - StringBuilder sb = new StringBuilder("zz"); - while (!priorityQueue.isEmpty()) { - int[] temp = {-1, -1}; - char peekChar = (char) ('a' + priorityQueue.peek()[0]); - if (peekChar == sb.charAt(sb.length() - 1) && - peekChar == sb.charAt(sb.length() - 2)) { - temp[0] = priorityQueue.peek()[0]; - temp[1] = priorityQueue.peek()[1]; - priorityQueue.poll(); - if (priorityQueue.isEmpty()) { - break; + public String longestDiverseString(int a, int b, int c) { + PriorityQueue pq = + new PriorityQueue<>((p, q) -> q.frequency() - p.frequency()); + if (a > 0) { + pq.add(new LetterFrequencyPair('a', a)); + } + if (b > 0) { + pq.add(new LetterFrequencyPair('b', b)); + } + if (c > 0) { + pq.add(new LetterFrequencyPair('c', c)); } - } - peekChar = (char) ('a' + priorityQueue.peek()[0]); - if (peekChar != sb.charAt(sb.length() - 1) || - peekChar != sb.charAt(sb.length() - 2)) { - int[] removed = priorityQueue.poll(); - sb.append(peekChar); - removed[1]--; - if (removed[1] > 0) { - priorityQueue.add(removed); + StringBuilder sb = new StringBuilder(); + while (!pq.isEmpty()) { + LetterFrequencyPair removed = pq.remove(); + int frequency = removed.frequency(); + int resultLength = sb.length(); + if (resultLength >= 2 && + sb.charAt(resultLength - 1) == removed.letter() && + sb.charAt(resultLength - 2) == removed.letter()) { + if (pq.isEmpty()) { + break; + } + LetterFrequencyPair temp = pq.remove(); + sb.append(temp.letter()); + if (temp.frequency() - 1 > 0) { + pq.add(new LetterFrequencyPair(temp.letter(), temp.frequency() - 1)); + } + } else { + sb.append(removed.letter()); + frequency--; + } + if (frequency > 0) { + pq.add(new LetterFrequencyPair(removed.letter(), frequency)); + } } - } - if (temp[0] != -1) { - priorityQueue.add(temp); - } + return sb.toString(); } - return sb.substring(2).toString(); - } + + private record LetterFrequencyPair(char letter, int frequency) {} } From 45105d882a6f2b03e88fc2198a54990a1b91e620 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Thu, 17 Oct 2024 07:04:29 -0700 Subject: [PATCH 643/712] Update Maximum Swap.java --- Medium/Maximum Swap.java | 41 ++++++++++++++++------------------------ 1 file changed, 16 insertions(+), 25 deletions(-) diff --git a/Medium/Maximum Swap.java b/Medium/Maximum Swap.java index 5d30c780..c12fb12e 100644 --- a/Medium/Maximum Swap.java +++ b/Medium/Maximum Swap.java @@ -1,29 +1,20 @@ class Solution { - public int maximumSwap(int num) { - String stringValue = Integer.toString(num); - Map valToIndexMap = new HashMap<>(); - int[] digits = new int[String.valueOf(num).length()]; - for (int i = digits.length - 1; i >= 0; i--) { - int digit = num % 10; - num /= 10; - digits[i] = digit; - valToIndexMap.putIfAbsent(digit, i); - } - for (int i = 0; i < digits.length; i++) { - for (int k = 9; k > digits[i]; k--) { - if (valToIndexMap.getOrDefault(k, -1) > i) { - int swapIndex = valToIndexMap.get(k); - return Integer.parseInt( - stringValue.substring(0, i) // Digits before swap index - + k // Swapped value - + stringValue.substring(i + 1, swapIndex) // Digits after original index(i) and before swappedIndex - + digits[i] // Digit at original index(i) - + ((swapIndex + 1) != stringValue.length() // Check if swapIndex is last digit of num - ? stringValue.substring(swapIndex + 1) // If not then add digits that come after the swapIndex - : "")); // Else add an empty string + public int maximumSwap(int num) { + char[] digits = String.valueOf(num).toCharArray(); + int n = digits.length; + int[] maxRightIdx = new int[n]; + maxRightIdx[n - 1] = n - 1; + for (int i = n - 2; i >= 0; i--) { + maxRightIdx[i] = (digits[i] > digits[maxRightIdx[i + 1]]) ? i : maxRightIdx[i + 1]; + } + for (int i = 0; i < n; i++) { + if (digits[i] < digits[maxRightIdx[i]]) { + char temp = digits[i]; + digits[i] = digits[maxRightIdx[i]]; + digits[maxRightIdx[i]] = temp; + return Integer.parseInt(String.valueOf(digits)); + } } - } + return num; } - return Integer.parseInt(stringValue); - } } From 0190cfd86d0c79f6ba0a2c265aa81086a960ff1c Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Fri, 18 Oct 2024 08:15:08 -0700 Subject: [PATCH 644/712] Create Count Number of Maximum Bitwise-OR Subsets.java --- ... Number of Maximum Bitwise-OR Subsets.java | 23 +++++++++++++++++++ 1 file changed, 23 insertions(+) create mode 100644 Medium/Count Number of Maximum Bitwise-OR Subsets.java diff --git a/Medium/Count Number of Maximum Bitwise-OR Subsets.java b/Medium/Count Number of Maximum Bitwise-OR Subsets.java new file mode 100644 index 00000000..973e1818 --- /dev/null +++ b/Medium/Count Number of Maximum Bitwise-OR Subsets.java @@ -0,0 +1,23 @@ +class Solution { + public int countMaxOrSubsets(int[] nums) { + int n = nums.length; + int maxValue = 0; + for (int num : nums) { + maxValue |= num; + } + Integer[][] dp = new Integer[n][maxValue + 1]; + return countMaxOrSubsets(nums, 0, 0, maxValue, dp); + } + + private int countMaxOrSubsets(int[] nums, int idx, int current, int maxValue, Integer[][] dp) { + if (idx == nums.length) { + return (current == maxValue) ? 1 : 0; + } + if (dp[idx][current] != null) { + return dp[idx][current]; + } + int countWithout = countMaxOrSubsets(nums, idx + 1, current, maxValue, dp); + int countWith = countMaxOrSubsets(nums, idx + 1, current | nums[idx], maxValue, dp); + return dp[idx][current] = countWith + countWithout; + } +} From 3a2e60db99c494d79a72a64121306fb5fed66e9e Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sat, 19 Oct 2024 08:48:07 -0700 Subject: [PATCH 645/712] Create Find Kth Bit in Nth Binary String.java --- Medium/Find Kth Bit in Nth Binary String.java | 22 +++++++++++++++++++ 1 file changed, 22 insertions(+) create mode 100644 Medium/Find Kth Bit in Nth Binary String.java diff --git a/Medium/Find Kth Bit in Nth Binary String.java b/Medium/Find Kth Bit in Nth Binary String.java new file mode 100644 index 00000000..e98b29c7 --- /dev/null +++ b/Medium/Find Kth Bit in Nth Binary String.java @@ -0,0 +1,22 @@ +class Solution { + public char findKthBit(int n, int k) { + return nthString(n).charAt(k - 1); + } + + private String nthString(int n) { + if (n == 1) { + return "0"; + } + String prevString = nthString(n - 1); + return prevString + "1" + reverseAndInvert(prevString); + } + + private String reverseAndInvert(String s) { + char[] chars = s.toCharArray(); + for (int i = 0; i < s.length(); i++) { + chars[i] = chars[i] == '1' ? '0' : '1'; + } + StringBuilder sb = new StringBuilder(String.valueOf(chars)); + return sb.reverse().toString(); + } +} From a3143e2bc5be251f4b005133f7582b848c52c573 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 20 Oct 2024 09:25:50 -0700 Subject: [PATCH 646/712] Update Parsing A Boolean Expression.java --- Hard/Parsing A Boolean Expression.java | 91 +++++++++----------------- 1 file changed, 31 insertions(+), 60 deletions(-) diff --git a/Hard/Parsing A Boolean Expression.java b/Hard/Parsing A Boolean Expression.java index 2c419aa8..97a56130 100644 --- a/Hard/Parsing A Boolean Expression.java +++ b/Hard/Parsing A Boolean Expression.java @@ -1,72 +1,43 @@ class Solution { public boolean parseBoolExpr(String expression) { - char[] chars = expression.toCharArray(); - Stack operations = new Stack<>(); - Stack boolValues = new Stack<>(); - - for (int i = 0; i < chars.length; i++) { - char c = chars[i]; - if (c == '!' || c == '&' || c == '|') { - operations.push(c); - } - else if (c == '(') { - boolValues.push('#'); - } - else if (c == 't' || c == 'f') { - boolValues.push(chars[i]); - } - else if (c == ',') { - continue; - } - else { - List list = new ArrayList<>(); - while (!boolValues.isEmpty()) { - char temp = boolValues.pop(); - if (temp == '#') { - break; - } - - list.add(temp); + Stack stack = new Stack<>(); + for (char c : expression.toCharArray()) { + if (c == ')') { + List values = new ArrayList<>(); + while (stack.peek() != '(') { + values.add(stack.pop()); } - - boolValues.push(performOperation(list, operations.pop())); + stack.pop(); + char operation = stack.pop(); + char result = evaluate(operation, values); + stack.push(result); + } else if (c != ',') { + stack.push(c); } } - - return boolValues.peek() == 't' ? true : false; + return stack.peek() == 't'; } - private Character performOperation(List list, Character operation) { - if (operation == '|') { - return performOr(list); - } - else if (operation == '&') { - return performAnd(list); + private static char evaluate(char operation, List values) { + if (operation == '!') { + return values.get(0) == 't' ? 'f' : 't'; } - else { - return list.get(0) == 't' ? 'f' : 't'; - } - } - - private Character performAnd(List list) { - boolean val = getBooleanValue(list.get(0)); - for (int i = 1; i < list.size(); i++) { - val &= getBooleanValue(list.get(i)); + if (operation == '&') { + for (char value : values) { + if (value == 'f') { + return 'f'; + } + } + return 't'; } - - return val ? 't' : 'f'; - } - - private Character performOr(List list) { - boolean val = getBooleanValue(list.get(0)); - for (int i = 1; i < list.size(); i++) { - val |= getBooleanValue(list.get(i)); + if (operation == '|') { + for (char value : values) { + if (value == 't') { + return 't'; + } + } + return 'f'; } - - return val ? 't' : 'f'; - } - - private boolean getBooleanValue(Character character) { - return character == 't' ? true : false; + return 'f'; } } From 7b253d794e4f465cb89df85bee72000915f06ad3 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Mon, 21 Oct 2024 12:40:07 -0700 Subject: [PATCH 647/712] Create Split a String Into the Max Number of Unique Substrings.java --- ...o the Max Number of Unique Substrings.java | 21 +++++++++++++++++++ 1 file changed, 21 insertions(+) create mode 100644 Medium/Split a String Into the Max Number of Unique Substrings.java diff --git a/Medium/Split a String Into the Max Number of Unique Substrings.java b/Medium/Split a String Into the Max Number of Unique Substrings.java new file mode 100644 index 00000000..3e418df7 --- /dev/null +++ b/Medium/Split a String Into the Max Number of Unique Substrings.java @@ -0,0 +1,21 @@ +class Solution { + public int maxUniqueSplit(String s) { + Set seen = new HashSet<>(); + return backtrack(s, 0, seen); + } + + private int backtrack(String s, int idx, Set seen) { + if (idx == s.length()) { + return 0; + } + int count = 0; + for (int end = idx + 1; end <= s.length(); end++) { + String substring = s.substring(idx, end); + if (seen.add(substring)) { + count = Math.max(count, 1 + backtrack(s, end, seen)); + seen.remove(substring); + } + } + return count; + } +} From 975d71b3150dcf4772c7b542b8b6765c03f92e90 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Wed, 23 Oct 2024 06:42:23 -0700 Subject: [PATCH 648/712] Create Cousins in Binary Tree II.java --- Medium/Cousins in Binary Tree II.java | 44 +++++++++++++++++++++++++++ 1 file changed, 44 insertions(+) create mode 100644 Medium/Cousins in Binary Tree II.java diff --git a/Medium/Cousins in Binary Tree II.java b/Medium/Cousins in Binary Tree II.java new file mode 100644 index 00000000..ee1b4b21 --- /dev/null +++ b/Medium/Cousins in Binary Tree II.java @@ -0,0 +1,44 @@ +/** + * Definition for a binary tree node. + * public class TreeNode { + * int val; + * TreeNode left; + * TreeNode right; + * TreeNode() {} + * TreeNode(int val) { this.val = val; } + * TreeNode(int val, TreeNode left, TreeNode right) { + * this.val = val; + * this.left = left; + * this.right = right; + * } + * } + */ +class Solution { + public TreeNode replaceValueInTree(TreeNode root) { + Queue queue = new LinkedList<>(); + queue.add(root); + int prevLevelSum = root.val; + while (!queue.isEmpty()) { + int size = queue.size(); + int levelSum = 0; + for (int i = 0; i < size; i++) { + TreeNode node = queue.remove(); + node.val = prevLevelSum - node.val; + int siblingSum = (node.left != null ? node.left.val : 0) + + (node.right != null ? node.right.val : 0); + if (node.left != null) { + levelSum += node.left.val; + node.left.val = siblingSum; + queue.add(node.left); + } + if (node.right != null) { + levelSum += node.right.val; + node.right.val = siblingSum; + queue.add(node.right); + } + } + prevLevelSum = levelSum; + } + return root; + } +} From 2dea3e54c58e5a45993f084c75aca141c5ca978f Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Thu, 24 Oct 2024 07:18:31 -0700 Subject: [PATCH 649/712] Update Flip Equivalent Binary Trees.java --- Medium/Flip Equivalent Binary Trees.java | 42 ++++++++++++------------ 1 file changed, 21 insertions(+), 21 deletions(-) diff --git a/Medium/Flip Equivalent Binary Trees.java b/Medium/Flip Equivalent Binary Trees.java index 7829ff4d..8590505e 100644 --- a/Medium/Flip Equivalent Binary Trees.java +++ b/Medium/Flip Equivalent Binary Trees.java @@ -1,31 +1,31 @@ -i/** +/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; - * TreeNode(int x) { val = x; } + * TreeNode() {} + * TreeNode(int val) { this.val = val; } + * TreeNode(int val, TreeNode left, TreeNode right) { + * this.val = val; + * this.left = left; + * this.right = right; + * } * } */ class Solution { - public boolean flipEquiv(TreeNode root1, TreeNode root2) { - if (root1 == null && root2 == null) { - return true; + public boolean flipEquiv(TreeNode root1, TreeNode root2) { + if (root1 == null && root2 == null) { + return true; + } + if (root1 == null || root2 == null) { + return false; + } + if (root1.val != root2.val) { + return false; + } + boolean noSwap = flipEquiv(root1.left, root2.left) && flipEquiv(root1.right, root2.right); + boolean swap = flipEquiv(root1.left, root2.right) && flipEquiv(root1.right, root2.left); + return noSwap || swap; } - if (root1 == null || root2 == null) { - return false; - } - if (root1.val != root2.val) { - return false; - } - return ( - ( - flipEquiv(root1.left, root2.left) && flipEquiv(root1.right, root2.right) - ) || - ( - flipEquiv(root1.left, root2.right) && - flipEquiv(root1.right, root2.left) - ) - ); - } } From 07715d08a8f45047ee39fbc6ed05247406a7d8ce Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Fri, 25 Oct 2024 07:34:43 -0700 Subject: [PATCH 650/712] Update Remove Sub-Folders from the Filesystem.java --- ...emove Sub-Folders from the Filesystem.java | 83 ++++++++++++++----- 1 file changed, 63 insertions(+), 20 deletions(-) diff --git a/Medium/Remove Sub-Folders from the Filesystem.java b/Medium/Remove Sub-Folders from the Filesystem.java index 2d91c97e..62f67bcd 100644 --- a/Medium/Remove Sub-Folders from the Filesystem.java +++ b/Medium/Remove Sub-Folders from the Filesystem.java @@ -1,24 +1,67 @@ class Solution { - public List removeSubfolders(String[] folder) { - Set set = new HashSet<>(); - Arrays.sort(folder, new Comparator(){ - public int compare(String s1, String s2) { - return s1.length() - s2.length(); - } - }); - for (String fl : folder) { - String[] files = fl.split("/"); - StringBuilder sb = new StringBuilder(); - for (int i = 1; i < files.length; i++) { - sb.append("/").append(files[i]); - if (set.contains(sb.toString())) { - break; + public List removeSubfolders(String[] folder) { + TrieNode root = new TrieNode(); + for (String file : folder) { + TrieNode curr = root; + String[] splits = file.split("/"); + for (int i = 1; i < splits.length; i++) { + Optional nextNode = curr.getChild(splits[i]); + if (nextNode.isEmpty()) { + TrieNode newNode = curr.addChild(splits[i]); + curr = newNode; + } else { + curr = nextNode.get(); + } + } + curr.markIsFolder(); + } + List result = new ArrayList<>(); + for (String file : folder) { + TrieNode curr = root; + String[] splits = file.split("/"); + boolean isSubfolder = false; + for (int i = 1; i < splits.length; i++) { + TrieNode nextNode = curr.getChild(splits[i]).get(); + if (nextNode.isFolder() && i != splits.length - 1) { + isSubfolder = true; + break; + } + curr = nextNode; + } + if (!isSubfolder) { + result.add(file); + } + } + return result; + } + + class TrieNode { + private boolean isFolder; + private Map children; + + public TrieNode() { + this.children = new HashMap<>(); + } + + public TrieNode addChild(String childKey) { + TrieNode node = new TrieNode(); + children.put(childKey, node); + return node; + } + + public Optional getChild(String childKey) { + if (!children.containsKey(childKey)) { + return Optional.empty(); + } + return Optional.of(children.get(childKey)); + } + + public void markIsFolder() { + isFolder = true; + } + + public boolean isFolder() { + return isFolder; } - } - if (sb.length() > 0) { - set.add(sb.toString()); - } } - return new ArrayList<>(set); - } } From 65583aed6e8c71a04f047c3bb1e8cc03c0249cf0 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sat, 26 Oct 2024 09:22:03 -0700 Subject: [PATCH 651/712] Create Height of Binary Tree After Subtree Removal Queries.java --- ...ry Tree After Subtree Removal Queries.java | 48 +++++++++++++++++++ 1 file changed, 48 insertions(+) create mode 100644 Hard/Height of Binary Tree After Subtree Removal Queries.java diff --git a/Hard/Height of Binary Tree After Subtree Removal Queries.java b/Hard/Height of Binary Tree After Subtree Removal Queries.java new file mode 100644 index 00000000..ebd9acbe --- /dev/null +++ b/Hard/Height of Binary Tree After Subtree Removal Queries.java @@ -0,0 +1,48 @@ +/** + * Definition for a binary tree node. + * public class TreeNode { + * int val; + * TreeNode left; + * TreeNode right; + * TreeNode() {} + * TreeNode(int val) { this.val = val; } + * TreeNode(int val, TreeNode left, TreeNode right) { + * this.val = val; + * this.left = left; + * this.right = right; + * } + * } + */ +class Solution { + public int[] treeQueries(TreeNode root, int[] queries) { + Map result = new HashMap<>(); + Map heightCache = new HashMap<>(); + dfs(root, 0, 0, result, heightCache); + int[] answer = new int[queries.length]; + for (int i = 0; i < queries.length; i++) { + answer[i] = result.get(queries[i]); + } + return answer; + } + + private void dfs(TreeNode node, int depth, int maxDepth, Map result, Map heightCache) { + if (node == null) { + return; + } + result.put(node.val, maxDepth); + dfs(node.left, depth + 1, Math.max(maxDepth, depth + 1 + height(node.right, heightCache)), result, heightCache); + dfs(node.right, depth + 1, Math.max(maxDepth, depth + 1 + height(node.left, heightCache)), result, heightCache); + } + + private int height(TreeNode node, Map heightCache) { + if (node == null) { + return -1; + } + if (heightCache.containsKey(node)) { + return heightCache.get(node); + } + int currHeight = 1 + Math.max(height(node.left, heightCache), height(node.right, heightCache)); + heightCache.put(node, currHeight); + return currHeight; + } +} From 0d68682d23ee31299361af2a5c059f16ac1f224a Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sat, 26 Oct 2024 14:32:07 -0700 Subject: [PATCH 652/712] Create Find the Original Typed String I.java --- Easy/Find the Original Typed String I.java | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) create mode 100644 Easy/Find the Original Typed String I.java diff --git a/Easy/Find the Original Typed String I.java b/Easy/Find the Original Typed String I.java new file mode 100644 index 00000000..dd6a5177 --- /dev/null +++ b/Easy/Find the Original Typed String I.java @@ -0,0 +1,17 @@ +class Solution { + public int possibleStringCount(String word) { + int idx = 0; + int result = 1; + while (idx < word.length()) { + int currIdx = idx; + char c = word.charAt(currIdx); + while (currIdx < word.length() && word.charAt(currIdx) == c) { + currIdx++; + } + int segement = currIdx - idx; + result += segement - 1; + idx = currIdx; + } + return result; + } +} From c458cea30a0ff3997b1babb07c871fc154c7eed7 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Mon, 28 Oct 2024 07:07:44 -0700 Subject: [PATCH 653/712] Create Longest Square Streak in an Array.java --- Medium/Longest Square Streak in an Array.java | 25 +++++++++++++++++++ 1 file changed, 25 insertions(+) create mode 100644 Medium/Longest Square Streak in an Array.java diff --git a/Medium/Longest Square Streak in an Array.java b/Medium/Longest Square Streak in an Array.java new file mode 100644 index 00000000..141abdee --- /dev/null +++ b/Medium/Longest Square Streak in an Array.java @@ -0,0 +1,25 @@ +class Solution { + + private static final int LIMIT = 100_000; + + public int longestSquareStreak(int[] nums) { + Set uniqueNums = new HashSet<>(); + for (int num : nums) { + uniqueNums.add(num); + } + int result = 0; + for (int num : nums) { + int currStreak = 0; + long curr = num; + while (uniqueNums.contains((int) curr)) { + currStreak++; + if (curr * curr > LIMIT) { + break; + } + curr *= curr; + } + result = Math.max(result, currStreak); + } + return result < 2 ? -1 : result; + } +} From 65c039985ea998ee26bcce26574385d4146caf26 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Tue, 29 Oct 2024 08:02:39 -0700 Subject: [PATCH 654/712] Create Maximum Number of Moves in a Grid.java --- Medium/Maximum Number of Moves in a Grid.java | 40 +++++++++++++++++++ 1 file changed, 40 insertions(+) create mode 100644 Medium/Maximum Number of Moves in a Grid.java diff --git a/Medium/Maximum Number of Moves in a Grid.java b/Medium/Maximum Number of Moves in a Grid.java new file mode 100644 index 00000000..014425f8 --- /dev/null +++ b/Medium/Maximum Number of Moves in a Grid.java @@ -0,0 +1,40 @@ +class Solution { + + private static final int[] DIRS = {-1, 0, 1}; + + public int maxMoves(int[][] grid) { + int rows = grid.length; + int cols = grid[0].length; + Queue queue = new LinkedList<>(); + boolean[][] visited = new boolean[rows][cols]; + for (int i = 0; i < rows; i++) { + visited[i][0] = true; + queue.add(new int[]{i, 0, 0}); + } + int result = 0; + while (!queue.isEmpty()) { + int size = queue.size(); + while (size-- > 0) { + int[] removed = queue.remove(); + int row = removed[0]; + int col = removed[1]; + int count = removed[2]; + result = Math.max(result, count); + for (int dir : DIRS) { + int nextRow = row + dir; + int nextCol = col + 1; + if (nextRow >= 0 && + nextCol >= 0 && + nextRow < rows && + nextCol < cols && + !visited[nextRow][nextCol] && + grid[row][col] < grid[nextRow][nextCol]) { + visited[nextRow][nextCol] = true; + queue.add(new int[]{nextRow, nextCol, count + 1}); + } + } + } + } + return result; + } +} From 2580a677b3a9c0b6cda1a0f7103c57020472cc3a Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Wed, 30 Oct 2024 06:47:27 -0700 Subject: [PATCH 655/712] Create Minimum Number of Removals to Make Mountain Array.java --- ...er of Removals to Make Mountain Array.java | 30 +++++++++++++++++++ 1 file changed, 30 insertions(+) create mode 100644 Hard/Minimum Number of Removals to Make Mountain Array.java diff --git a/Hard/Minimum Number of Removals to Make Mountain Array.java b/Hard/Minimum Number of Removals to Make Mountain Array.java new file mode 100644 index 00000000..b74f6feb --- /dev/null +++ b/Hard/Minimum Number of Removals to Make Mountain Array.java @@ -0,0 +1,30 @@ +class Solution { + public int minimumMountainRemovals(int[] nums) { + int n = nums.length; + int[] leftIncreasingLength = new int[n]; + int[] rightDecreasingLength = new int[n]; + Arrays.fill(leftIncreasingLength, 1); + Arrays.fill(rightDecreasingLength, 1); + for (int i = 0; i < n; i++) { + for (int j = i - 1; j >= 0; j--) { + if (nums[i] > nums[j]) { + leftIncreasingLength[i] = Math.max(leftIncreasingLength[i], leftIncreasingLength[j] + 1); + } + } + } + for (int i = n - 1; i >= 0; i--) { + for (int j = i + 1; j < n; j++) { + if (nums[i] > nums[j]) { + rightDecreasingLength[i] = Math.max(rightDecreasingLength[i], rightDecreasingLength[j] + 1); + } + } + } + int minRemovals = Integer.MAX_VALUE; + for (int i = 0; i < n; i++) { + if (leftIncreasingLength[i] > 1 && rightDecreasingLength[i] > 1) { + minRemovals = Math.min(minRemovals, n - leftIncreasingLength[i] - rightDecreasingLength[i] + 1); + } + } + return minRemovals; + } +} From aafb2effbd9500cfb5e24ceae7986147ed70d6ee Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Mon, 4 Nov 2024 06:35:54 -0800 Subject: [PATCH 656/712] Create String Compression III.java --- Medium/String Compression III.java | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) create mode 100644 Medium/String Compression III.java diff --git a/Medium/String Compression III.java b/Medium/String Compression III.java new file mode 100644 index 00000000..03a6737c --- /dev/null +++ b/Medium/String Compression III.java @@ -0,0 +1,16 @@ +class Solution { + public String compressedString(String word) { + StringBuilder sb = new StringBuilder(); + int idx = 0; + while (idx < word.length()) { + char c = word.charAt(idx); + int count = 0; + while (idx < word.length() && word.charAt(idx) == c && count < 9) { + idx++; + count++; + } + sb.append(count).append(c); + } + return sb.toString(); + } +} From 1c1f3cf1277b63af4b230b6dffd3a8f61f7f1497 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Wed, 6 Nov 2024 07:25:20 -0800 Subject: [PATCH 657/712] Create Number of Same-End Substrings.java --- Medium/Number of Same-End Substrings.java | 28 +++++++++++++++++++++++ 1 file changed, 28 insertions(+) create mode 100644 Medium/Number of Same-End Substrings.java diff --git a/Medium/Number of Same-End Substrings.java b/Medium/Number of Same-End Substrings.java new file mode 100644 index 00000000..4003737d --- /dev/null +++ b/Medium/Number of Same-End Substrings.java @@ -0,0 +1,28 @@ +class Solution { + public int[] sameEndSubstringCount(String s, int[][] queries) { + int n = s.length(); + int[][] prefixSum = new int[26][n]; + for (int i = 0; i < n; i++) { + prefixSum[s.charAt(i) - 'a'][i]++; + } + for (int i = 0; i < 26; i++) { + for (int j = 1; j < n; j++) { + prefixSum[i][j] += prefixSum[i][j - 1]; + } + } + int[] result = new int[queries.length]; + for (int i = 0; i < queries.length; i++) { + int left = queries[i][0]; + int right = queries[i][1]; + int count = 0; + for (int c = 0; c < 26; c++) { + int leftFreq = left == 0 ? 0 : prefixSum[c][left - 1]; + int rightFreq = prefixSum[c][right]; + int freqInRange = rightFreq - leftFreq; + count += (freqInRange * (freqInRange + 1)) / 2; + } + result[i] = count; + } + return result; + } +} From 5a3795b8956bbe92bbdd5462beae0b5ef2c6abdd Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Thu, 7 Nov 2024 08:12:32 -0800 Subject: [PATCH 658/712] Create Largest Combination With Bitwise AND Greater Than Zero.java --- ...tion With Bitwise AND Greater Than Zero.java | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) create mode 100644 Medium/Largest Combination With Bitwise AND Greater Than Zero.java diff --git a/Medium/Largest Combination With Bitwise AND Greater Than Zero.java b/Medium/Largest Combination With Bitwise AND Greater Than Zero.java new file mode 100644 index 00000000..1399f1bb --- /dev/null +++ b/Medium/Largest Combination With Bitwise AND Greater Than Zero.java @@ -0,0 +1,17 @@ +class Solution { + public int largestCombination(int[] candidates) { + int[] bitCount = new int[24]; + for (int i = 0; i < 24; i++) { + for (int candidate : candidates) { + if ((candidate & (1 << i)) != 0) { + bitCount[i]++; + } + } + } + int result = 0; + for (int count : bitCount) { + result = Math.max(count, result); + } + return result; + } +} From f1e4d1887ee89e1bcdaf4cb0c6f343bd5c7b6ad1 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Thu, 14 Nov 2024 06:35:00 -0800 Subject: [PATCH 659/712] Create Minimized Maximum of Products Distributed to Any Store.java --- ... of Products Distributed to Any Store.java | 36 +++++++++++++++++++ 1 file changed, 36 insertions(+) create mode 100644 Medium/Minimized Maximum of Products Distributed to Any Store.java diff --git a/Medium/Minimized Maximum of Products Distributed to Any Store.java b/Medium/Minimized Maximum of Products Distributed to Any Store.java new file mode 100644 index 00000000..70a46016 --- /dev/null +++ b/Medium/Minimized Maximum of Products Distributed to Any Store.java @@ -0,0 +1,36 @@ +class Solution { + public int minimizedMaximum(int n, int[] quantities) { + int left = 0; + int right = 0; + for (int quantity : quantities) { + right = Math.max(right, quantity); + } + while (left < right) { + int mid = (left + right) / 2; + if (isPossible(n, mid, quantities)) { + right = mid; + } else { + left = mid + 1; + } + } + return left; + } + + private boolean isPossible(int n, int min, int[] quantities) { + int idx = 0; + int remaining = quantities[idx]; + for (int i = 0; i < n; i++) { + if (remaining <= min) { + idx++; + if (idx == quantities.length) { + return true; + } else { + remaining = quantities[idx]; + } + } else { + remaining -= min; + } + } + return false; + } +} From ceb871f66e65b8cc2655d9891c555781347d9c1a Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Fri, 15 Nov 2024 08:05:15 -0800 Subject: [PATCH 660/712] Create Shortest Subarray to be Removed to Make Array Sorted.java --- ...ray to be Removed to Make Array Sorted.java | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) create mode 100644 Medium/Shortest Subarray to be Removed to Make Array Sorted.java diff --git a/Medium/Shortest Subarray to be Removed to Make Array Sorted.java b/Medium/Shortest Subarray to be Removed to Make Array Sorted.java new file mode 100644 index 00000000..4ddb25e2 --- /dev/null +++ b/Medium/Shortest Subarray to be Removed to Make Array Sorted.java @@ -0,0 +1,18 @@ +class Solution { + public int findLengthOfShortestSubarray(int[] arr) { + int right = arr.length - 1; + while (right > 0 && arr[right] >= arr[right - 1]) { + right--; + } + int result = right; + int left = 0; + while (left < right && (left == 0 || arr[left - 1] <= arr[left])) { + while (right < arr.length && arr[left] > arr[right]) { + right++; + } + result = Math.min(result, right - left - 1); + left++; + } + return result; + } +} From 5eaf0134b8d8b7eafb7abae9f60e826bcb98b41f Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 17 Nov 2024 06:52:36 -0800 Subject: [PATCH 661/712] Create Adjacent Increasing Subarrays Detection I.java --- ...cent Increasing Subarrays Detection I.java | 20 +++++++++++++++++++ 1 file changed, 20 insertions(+) create mode 100644 Easy/Adjacent Increasing Subarrays Detection I.java diff --git a/Easy/Adjacent Increasing Subarrays Detection I.java b/Easy/Adjacent Increasing Subarrays Detection I.java new file mode 100644 index 00000000..5be82de7 --- /dev/null +++ b/Easy/Adjacent Increasing Subarrays Detection I.java @@ -0,0 +1,20 @@ +class Solution { + public boolean hasIncreasingSubarrays(List nums, int k) { + int n = nums.size(); + for (int i = 0; i <= n - 2 * k; i++) { + if (isStrictlyIncreasing(nums, i, k) && isStrictlyIncreasing(nums, i + k, k)) { + return true; + } + } + return false; + } + + private boolean isStrictlyIncreasing(List nums, int idx, int k) { + for (int start = idx; start < idx + k - 1; start++) { + if (nums.get(start) >= nums.get(start + 1)) { + return false; + } + } + return true; + } +} From 8738cee338223b3413232342be126e90ac9cf9e2 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Wed, 20 Nov 2024 08:28:53 -0800 Subject: [PATCH 662/712] Create Take K of Each Character From Left and Right.java --- ...of Each Character From Left and Right.java | 27 +++++++++++++++++++ 1 file changed, 27 insertions(+) create mode 100644 Medium/Take K of Each Character From Left and Right.java diff --git a/Medium/Take K of Each Character From Left and Right.java b/Medium/Take K of Each Character From Left and Right.java new file mode 100644 index 00000000..4b878ce0 --- /dev/null +++ b/Medium/Take K of Each Character From Left and Right.java @@ -0,0 +1,27 @@ +class Solution { + public int takeCharacters(String s, int k) { + int[] counter = new int[3]; + int n = s.length(); + for (char c : s.toCharArray()) { + counter[c - 'a']++; + } + for (int i = 0; i < 3; i++) { + if (counter[i] < k) { + return -1; + } + } + int[] window = new int[3]; + int left = 0; + int maxWindow = 0; + for (int right = 0; right < n; right++) { + window[s.charAt(right) - 'a']++; + while (left <= right && + (counter[0] - window[0] < k || counter[1] - window[1] < k || counter[2] - window[2] < k)) { + window[s.charAt(left) - 'a']--; + left++; + } + maxWindow = Math.max(maxWindow, right - left + 1); + } + return n - maxWindow; + } +} From 199a76c4f8b272a7c632841e36959c9aa1c8b46c Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 22 Dec 2024 05:48:36 +0530 Subject: [PATCH 663/712] Create Count Subarrays of Length Three With a Condition.java --- ...nt Subarrays of Length Three With a Condition.java | 11 +++++++++++ 1 file changed, 11 insertions(+) create mode 100644 Easy/Count Subarrays of Length Three With a Condition.java diff --git a/Easy/Count Subarrays of Length Three With a Condition.java b/Easy/Count Subarrays of Length Three With a Condition.java new file mode 100644 index 00000000..4694fb65 --- /dev/null +++ b/Easy/Count Subarrays of Length Three With a Condition.java @@ -0,0 +1,11 @@ +class Solution { + public int countSubarrays(int[] nums) { + int count = 0; + for (int i = 0; i < nums.length - 2; i++) { + if (2 * (nums[i] + nums[i + 2]) == nums[i + 1]) { + count++; + } + } + return count; + } +} From 6735f7a0d2bb149726984a53fb48766c43e7e243 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Mon, 23 Dec 2024 06:41:01 +0530 Subject: [PATCH 664/712] Create Minimum Number of Operations to Make Elements in Array Distinct.java --- ...ons to Make Elements in Array Distinct.java | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) create mode 100644 Easy/Minimum Number of Operations to Make Elements in Array Distinct.java diff --git a/Easy/Minimum Number of Operations to Make Elements in Array Distinct.java b/Easy/Minimum Number of Operations to Make Elements in Array Distinct.java new file mode 100644 index 00000000..a61239e7 --- /dev/null +++ b/Easy/Minimum Number of Operations to Make Elements in Array Distinct.java @@ -0,0 +1,18 @@ +class Solution { + public int minimumOperations(int[] nums) { + Set set = new HashSet<>(); + int index = -1; + for (int i = nums.length - 1; i >= 0; i--) { + if (set.contains(nums[i])) { + index = i; + break; + } + set.add(nums[i]); + } + if (index == -1) { + return 0; + } + index++; + return index % 3 == 0 ? index / 3 : (index / 3) + 1; + } +} From c8ba8359855d7be2aa9f966f0a9d9a3ae3435dff Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Thu, 26 Dec 2024 18:27:19 +0530 Subject: [PATCH 665/712] Create Button with Longest Push Time.java --- Easy/Button with Longest Push Time.java | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) create mode 100644 Easy/Button with Longest Push Time.java diff --git a/Easy/Button with Longest Push Time.java b/Easy/Button with Longest Push Time.java new file mode 100644 index 00000000..650bb1e4 --- /dev/null +++ b/Easy/Button with Longest Push Time.java @@ -0,0 +1,18 @@ +class Solution { + public int buttonWithLongestTime(int[][] events) { + int maxTime = 0; + int resultIdx = 0; + int prevTime = 0; + for (int i = 0; i < events.length; i++) { + int timePressed = events[i][1] - prevTime; + if (timePressed > maxTime) { + maxTime = timePressed; + resultIdx = events[i][0]; + } else if (timePressed == maxTime && resultIdx > events[i][0]) { + resultIdx = events[i][0]; + } + prevTime = events[i][1]; + } + return resultIdx; + } +} From 9d4036992d100703cb34fecc1183c457bc4d44af Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 12 Jan 2025 12:23:37 -0800 Subject: [PATCH 666/712] Create Check if a Parentheses String Can Be Valid.java --- ... if a Parentheses String Can Be Valid.java | 30 +++++++++++++++++++ 1 file changed, 30 insertions(+) create mode 100644 Medium/Check if a Parentheses String Can Be Valid.java diff --git a/Medium/Check if a Parentheses String Can Be Valid.java b/Medium/Check if a Parentheses String Can Be Valid.java new file mode 100644 index 00000000..c240176d --- /dev/null +++ b/Medium/Check if a Parentheses String Can Be Valid.java @@ -0,0 +1,30 @@ +class Solution { + public boolean canBeValid(String s, String locked) { + if (s.length() % 2 != 0) { + return false; + } + Stack openBrackets = new Stack<>(); + Stack unlocked = new Stack<>(); + for (int i = 0; i < s.length(); i++) { + char c = s.charAt(i); + if (locked.charAt(i) == '0') { + unlocked.push(i); + } else if (c == '(') { + openBrackets.push(i); + } else if (c == ')') { + if (!openBrackets.isEmpty()) { + openBrackets.pop(); + } else if (!unlocked.isEmpty()) { + unlocked.pop(); + } else { + return false; + } + } + } + while (!openBrackets.isEmpty() && !unlocked.isEmpty() && openBrackets.peek() < unlocked.peek()) { + openBrackets.pop(); + unlocked.pop(); + } + return openBrackets.isEmpty(); + } +} From 0298b447e75aa7ceedb837d55c3790ac0f7073b8 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Tue, 14 Jan 2025 06:41:46 -0800 Subject: [PATCH 667/712] Update Find the Prefix Common Array of Two Arrays.java --- ...the Prefix Common Array of Two Arrays.java | 19 +++++++++++-------- 1 file changed, 11 insertions(+), 8 deletions(-) diff --git a/Medium/Find the Prefix Common Array of Two Arrays.java b/Medium/Find the Prefix Common Array of Two Arrays.java index bd747227..e6312a17 100644 --- a/Medium/Find the Prefix Common Array of Two Arrays.java +++ b/Medium/Find the Prefix Common Array of Two Arrays.java @@ -1,14 +1,17 @@ class Solution { public int[] findThePrefixCommonArray(int[] A, int[] B) { - Map map = new HashMap<>(); int count = 0; - int[] result = new int[A.length]; - for (int i = 0; i < A.length; i++) { - map.put(A[i], map.getOrDefault(A[i], 0) + 1); - map.put(B[i], map.getOrDefault(B[i], 0) + 1); - count += map.get(A[i]) == 2 ? 1 : 0; - if (A[i] != B[i]) { - count += map.get(B[i]) == 2 ? 1 : 0; + int n = A.length; + int[] result = new int[n]; + int[] frequency = new int[n + 1]; + for (int i = 0; i < n; i++) { + frequency[A[i]]++; + if (frequency[A[i]] == 2) { + count++; + } + frequency[B[i]]++; + if (frequency[B[i]] == 2) { + count++; } result[i] = count; } From a03b2709db74206a8efecbc2f878d87b808bfc00 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Wed, 15 Jan 2025 07:12:59 -0800 Subject: [PATCH 668/712] Create Minimize XOR.java --- Medium/Minimize XOR.java | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+) create mode 100644 Medium/Minimize XOR.java diff --git a/Medium/Minimize XOR.java b/Medium/Minimize XOR.java new file mode 100644 index 00000000..cc5e87a3 --- /dev/null +++ b/Medium/Minimize XOR.java @@ -0,0 +1,24 @@ +class Solution { + public int minimizeXor(int num1, int num2) { + int result = 0; + int targetSetBitCount = Integer.bitCount(num2); + int setBitCount = 0; + int currBit = 31; + while (setBitCount < targetSetBitCount) { + if (isSet(num1, currBit) || (targetSetBitCount - setBitCount > currBit)) { + result = setBit(result, currBit); + setBitCount++; + } + currBit--; + } + return result; + } + + private boolean isSet(int x, int bit) { + return (x & (1 << bit)) != 0; + } + + private int setBit(int x, int bit) { + return x | (1 << bit); + } +} From fbb599922e136af4abfa4180c747b50e57fc1060 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Wed, 15 Jan 2025 17:37:21 -0800 Subject: [PATCH 669/712] Create Bitwise XOR of All Pairings.java --- Medium/Bitwise XOR of All Pairings.java | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) create mode 100644 Medium/Bitwise XOR of All Pairings.java diff --git a/Medium/Bitwise XOR of All Pairings.java b/Medium/Bitwise XOR of All Pairings.java new file mode 100644 index 00000000..88dfbd41 --- /dev/null +++ b/Medium/Bitwise XOR of All Pairings.java @@ -0,0 +1,20 @@ +class Solution { + public int xorAllNums(int[] nums1, int[] nums2) { + int m = nums1.length; + int n = nums2.length; + Map freq = new HashMap<>(); + for (int num : nums1) { + freq.put(num, freq.getOrDefault(num, 0) + n); + } + for (int num : nums2) { + freq.put(num, freq.getOrDefault(num, 0) + m); + } + int result = 0; + for (Integer key : freq.keySet()) { + if (freq.get(key) % 2 == 1) { + result ^= key; + } + } + return result; + } +} From e8baf509b7624bb7a17be44df8afd34511d71f4e Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Thu, 16 Jan 2025 17:13:07 -0800 Subject: [PATCH 670/712] Create Neighboring Bitwise XOR.java --- Medium/Neighboring Bitwise XOR.java | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) create mode 100644 Medium/Neighboring Bitwise XOR.java diff --git a/Medium/Neighboring Bitwise XOR.java b/Medium/Neighboring Bitwise XOR.java new file mode 100644 index 00000000..6e46025c --- /dev/null +++ b/Medium/Neighboring Bitwise XOR.java @@ -0,0 +1,16 @@ +class Solution { + public boolean doesValidArrayExist(int[] derived) { + int n = derived.length; + int[] original = new int[n + 1]; + for (int i = 0; i < derived.length; i++) { + original[i + 1] = derived[i] ^ original[i]; + } + boolean checkForZero = (original[0] == original[n]); + original[0] = 1; + for (int i = 0; i < n; i++) { + original[i + 1] = derived[i] ^ original[i]; + } + boolean checkForOne = (original[0] == original[n]); + return checkForZero || checkForOne; + } +} From 72a77c98c7d75ee9a5de805aa885158e8478f12e Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Mon, 20 Jan 2025 09:55:45 -0800 Subject: [PATCH 671/712] Create Sum of Variable Length Subarrays.java --- Easy/Sum of Variable Length Subarrays.java | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) create mode 100644 Easy/Sum of Variable Length Subarrays.java diff --git a/Easy/Sum of Variable Length Subarrays.java b/Easy/Sum of Variable Length Subarrays.java new file mode 100644 index 00000000..5dc7d585 --- /dev/null +++ b/Easy/Sum of Variable Length Subarrays.java @@ -0,0 +1,19 @@ +class Solution { + public int subarraySum(int[] nums) { + int n = nums.length; + int[] prefixSum = new int[n]; + int sum = 0; + int result = 0; + for (int i = 0; i < n; i++) { + sum += nums[i]; + prefixSum[i] = sum; + int start = Math.max(0, i - nums[i]); + int subarraySum = prefixSum[i]; + if (start > 0) { + subarraySum -= prefixSum[start - 1]; + } + result += subarraySum; + } + return result; + } +} From d6786b2ff3c8a07e513860428dd3aabbfc08cf20 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 26 Jan 2025 12:00:18 -0800 Subject: [PATCH 672/712] Create Count Partitions with Even Sum Difference.java --- ...unt Partitions with Even Sum Difference.java | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) create mode 100644 Easy/Count Partitions with Even Sum Difference.java diff --git a/Easy/Count Partitions with Even Sum Difference.java b/Easy/Count Partitions with Even Sum Difference.java new file mode 100644 index 00000000..0390a5a1 --- /dev/null +++ b/Easy/Count Partitions with Even Sum Difference.java @@ -0,0 +1,17 @@ +class Solution { + public int countPartitions(int[] nums) { + int n = nums.length; + int[] prefixSum = new int[n]; + for (int i = 0; i < n; i++) { + prefixSum[i] = nums[i]; + prefixSum[i] += i == 0 ? 0 : prefixSum[i - 1]; + } + int partitions = 0; + for (int i = 0; i < n - 1; i++) { + int leftSum = prefixSum[i]; + int rightSum = prefixSum[n - 1] - prefixSum[i]; + partitions += (rightSum - leftSum) % 2 == 0 ? 1 : 0; + } + return partitions; + } +} From 4c9aa9825459d2daa31037fc023d74417964b321 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Fri, 31 Jan 2025 08:19:14 -0800 Subject: [PATCH 673/712] Create Count Mentions Per User.java --- Medium/Count Mentions Per User.java | 61 +++++++++++++++++++++++++++++ 1 file changed, 61 insertions(+) create mode 100644 Medium/Count Mentions Per User.java diff --git a/Medium/Count Mentions Per User.java b/Medium/Count Mentions Per User.java new file mode 100644 index 00000000..7fa42668 --- /dev/null +++ b/Medium/Count Mentions Per User.java @@ -0,0 +1,61 @@ +class Solution { + public int[] countMentions(int numberOfUsers, List> eventLog) { + List events = eventLog.stream() + .map(Event::buildEvent) + .sorted() + .collect(Collectors.toList()); + Map offlineUsers = new HashMap<>(); + int[] mentions = new int[numberOfUsers]; + for (Event event : events) { + if (event.message().equals("OFFLINE")) { + offlineUsers.put(Integer.parseInt(event.mentionString()), event.timestamp()); + } else { + int timestamp = event.timestamp(); + List onlineUsers = offlineUsers.entrySet() + .stream() + .filter(t -> timestamp - t.getValue() >= 60) + .map(Map.Entry::getKey) + .collect(Collectors.toList()); + onlineUsers.forEach(offlineUsers::remove); + String mentionString = event.mentionString(); + if (mentionString.equals("ALL")) { + for (int i = 0; i < numberOfUsers; i++) { + mentions[i]++; + } + } else if (mentionString.equals("HERE")) { + for (int i = 0; i < numberOfUsers; i++) { + if (!offlineUsers.containsKey(i)) { + mentions[i]++; + } + } + } else { + String[] usersMentioned = mentionString.split(" "); + for (String user : usersMentioned) { + int userId = Integer.parseInt(user.substring(2)); + mentions[userId]++; + } + } + } + } + return mentions; + } + + private record Event(String message, int timestamp, String mentionString) implements Comparable { + + public static Event buildEvent(List event) { + String message = event.get(0); + int timestamp = Integer.parseInt(event.get(1)); + String mentionString = event.get(2); + return new Event(message, timestamp, mentionString); + } + + @Override + public int compareTo(Event o) { + int c = this.timestamp - o.timestamp; + if (c != 0) { + return c; + } + return o.message().compareTo(this.message()); + } + } +} From d8afeb208d59a04ec1360c090fa2090b6bc5ceb3 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 2 Feb 2025 10:50:47 -0800 Subject: [PATCH 674/712] Create Maximum Difference Between Even and Odd Frequency I.java --- ...ence Between Even and Odd Frequency I.java | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) create mode 100644 Easy/Maximum Difference Between Even and Odd Frequency I.java diff --git a/Easy/Maximum Difference Between Even and Odd Frequency I.java b/Easy/Maximum Difference Between Even and Odd Frequency I.java new file mode 100644 index 00000000..ec68c06f --- /dev/null +++ b/Easy/Maximum Difference Between Even and Odd Frequency I.java @@ -0,0 +1,19 @@ +class Solution { + public int maxDifference(String s) { + Map map = new HashMap<>(); + for (char c : s.toCharArray()) { + map.put(c, map.getOrDefault(c, 0) + 1); + } + int maxOdd = Integer.MIN_VALUE; + int minEven = Integer.MAX_VALUE; + for (Character key : map.keySet()) { + Integer value = map.get(key); + if (value % 2 == 0) { + minEven = Math.min(minEven, value); + } else { + maxOdd = Math.max(maxOdd, value); + } + } + return maxOdd - minEven; + } +} From 540318b7d9293dc1da5c063a50b6f05cd6730edc Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Mon, 3 Feb 2025 09:25:47 -0800 Subject: [PATCH 675/712] Create Longest Strictly Increasing or Strictly Decreasing Subarray.java --- ...asing or Strictly Decreasing Subarray.java | 22 +++++++++++++++++++ 1 file changed, 22 insertions(+) create mode 100644 Easy/Longest Strictly Increasing or Strictly Decreasing Subarray.java diff --git a/Easy/Longest Strictly Increasing or Strictly Decreasing Subarray.java b/Easy/Longest Strictly Increasing or Strictly Decreasing Subarray.java new file mode 100644 index 00000000..c1ed1c36 --- /dev/null +++ b/Easy/Longest Strictly Increasing or Strictly Decreasing Subarray.java @@ -0,0 +1,22 @@ +class Solution { + public int longestMonotonicSubarray(int[] nums) { + int max = 1; + int idx = 0; + int n = nums.length; + while (idx < n) { + if (idx == n - 1 || nums[idx + 1] == nums[idx]) { + idx++; + continue; + } + boolean increase = nums[idx + 1] > nums[idx]; + int start = idx; + while (idx + 1 < n && ( + (increase && nums[idx + 1] > nums[idx]) || + (!increase && nums[idx + 1] < nums[idx]))) { + idx++; + } + max = Math.max(max, idx - start + 1); + } + return max; + } +} From c259c7ab846d08dcc0fc9d3cd4d07ac1c901a2e6 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Mon, 3 Feb 2025 17:35:11 -0800 Subject: [PATCH 676/712] Update Maximum Ascending Subarray Sum.java --- Easy/Maximum Ascending Subarray Sum.java | 23 ++++++++++++----------- 1 file changed, 12 insertions(+), 11 deletions(-) diff --git a/Easy/Maximum Ascending Subarray Sum.java b/Easy/Maximum Ascending Subarray Sum.java index fb436414..fd64c04c 100644 --- a/Easy/Maximum Ascending Subarray Sum.java +++ b/Easy/Maximum Ascending Subarray Sum.java @@ -1,14 +1,15 @@ class Solution { - public int maxAscendingSum(int[] nums) { - int maximumSum = 0; - int idx = 0; - while (idx < nums.length) { - int currSum = nums[idx++]; - while (idx < nums.length && nums[idx] > nums[idx - 1]) { - currSum += nums[idx++]; - } - maximumSum = Math.max(maximumSum, currSum); + public int maxAscendingSum(int[] nums) { + int maxSum = 0; + int idx = 0; + int n = nums.length; + while (idx < n) { + int currSum = nums[idx++]; + while (idx < n && nums[idx] > nums[idx - 1]) { + currSum += nums[idx++]; + } + maxSum = Math.max(maxSum, currSum); + } + return maxSum; } - return maximumSum; - } } From d9a05d959355c1e27adb0d404872b4d3bafe5763 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Wed, 5 Feb 2025 07:54:25 -0800 Subject: [PATCH 677/712] Update Check if One String Swap Can Make Strings Equal.java --- ...ne String Swap Can Make Strings Equal.java | 29 +++++++++++-------- 1 file changed, 17 insertions(+), 12 deletions(-) diff --git a/Easy/Check if One String Swap Can Make Strings Equal.java b/Easy/Check if One String Swap Can Make Strings Equal.java index 3f26dac9..fca6fc9d 100644 --- a/Easy/Check if One String Swap Can Make Strings Equal.java +++ b/Easy/Check if One String Swap Can Make Strings Equal.java @@ -1,16 +1,21 @@ class Solution { - public boolean areAlmostEqual(String s1, String s2) { - int mismatchIdx = -1; - for (int i = 0; i < s1.length(); i++) { - if (s1.charAt(i) != s2.charAt(i)) { - if (mismatchIdx != -1) { - return s1.charAt(mismatchIdx) == s2.charAt(i) && - s1.charAt(i) == s2.charAt(mismatchIdx) && - s1.substring(i + 1).equals(s2.substring(i + 1)); + public boolean areAlmostEqual(String s1, String s2) { + int swapIdx = -1; + boolean swapped = false; + for (int i = 0; i < s1.length(); i++) { + if (s1.charAt(i) != s2.charAt(i)) { + if (swapped) { + return false; + } + if (swapIdx != -1) { + if (!(s1.charAt(swapIdx) == s2.charAt(i) && s1.charAt(i) == s2.charAt(swapIdx))) { + return false; + } + swapped = true; + } + swapIdx = i; + } } - mismatchIdx = i; - } + return swapIdx == -1 || (swapIdx != -1 && swapped); } - return mismatchIdx == -1; - } } From 70d1c410af8e9fb0177e1494d24adffca1d7f7cb Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Fri, 7 Feb 2025 06:58:14 -0800 Subject: [PATCH 678/712] Create Find the Number of Distinct Colors Among the Balls.java --- ...er of Distinct Colors Among the Balls.java | 23 +++++++++++++++++++ 1 file changed, 23 insertions(+) create mode 100644 Medium/Find the Number of Distinct Colors Among the Balls.java diff --git a/Medium/Find the Number of Distinct Colors Among the Balls.java b/Medium/Find the Number of Distinct Colors Among the Balls.java new file mode 100644 index 00000000..428e5406 --- /dev/null +++ b/Medium/Find the Number of Distinct Colors Among the Balls.java @@ -0,0 +1,23 @@ +class Solution { + public int[] queryResults(int limit, int[][] queries) { + Map ballToColor = new HashMap<>(); + Map colorToBallCount = new HashMap<>(); + int n = queries.length; + int[] result = new int[n]; + for (int i = 0; i < queries.length; i++) { + int ball = queries[i][0]; + int color = queries[i][1]; + if (ballToColor.containsKey(ball)) { + int prevColor = ballToColor.get(ball); + colorToBallCount.put(prevColor, colorToBallCount.get(prevColor) - 1); + if (colorToBallCount.get(prevColor) == 0) { + colorToBallCount.remove(prevColor); + } + } + ballToColor.put(ball, color); + colorToBallCount.put(color, colorToBallCount.getOrDefault(color, 0) + 1); + result[i] = colorToBallCount.size(); + } + return result; + } +} From aa8154baf0afb55c54055d44e5af4b7df0455f82 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sat, 8 Feb 2025 11:35:50 -0800 Subject: [PATCH 679/712] Create Design a Number Container System.java --- Medium/Design a Number Container System.java | 34 ++++++++++++++++++++ 1 file changed, 34 insertions(+) create mode 100644 Medium/Design a Number Container System.java diff --git a/Medium/Design a Number Container System.java b/Medium/Design a Number Container System.java new file mode 100644 index 00000000..26a3e843 --- /dev/null +++ b/Medium/Design a Number Container System.java @@ -0,0 +1,34 @@ +class NumberContainers { + + private final Map> numberToIndex; + private final Map indexToNumber; + + public NumberContainers() { + this.numberToIndex = new HashMap<>(); + this.indexToNumber = new HashMap<>(); + } + + public void change(int index, int number) { + if (indexToNumber.containsKey(index)) { + int prevNumber = indexToNumber.get(index); + numberToIndex.get(prevNumber).remove(index); + } + indexToNumber.put(index, number); + numberToIndex.computeIfAbsent(number, k -> new TreeSet<>()).add(index); + } + + public int find(int number) { + TreeSet indices = numberToIndex.getOrDefault(number, new TreeSet<>()); + if (indices.isEmpty()) { + return -1; + } + return indices.first(); + } +} + +/** + * Your NumberContainers object will be instantiated and called as such: + * NumberContainers obj = new NumberContainers(); + * obj.change(index,number); + * int param_2 = obj.find(number); + */ From 583c210c39e1ecb62cde8460bcd55f23f2123f66 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Tue, 11 Feb 2025 07:07:35 -0800 Subject: [PATCH 680/712] Update Remove All Occurrences of a Substring.java --- ...Remove All Occurrences of a Substring.java | 38 ++++++++++++++----- 1 file changed, 29 insertions(+), 9 deletions(-) diff --git a/Medium/Remove All Occurrences of a Substring.java b/Medium/Remove All Occurrences of a Substring.java index 08fa1f78..e46ad3f2 100644 --- a/Medium/Remove All Occurrences of a Substring.java +++ b/Medium/Remove All Occurrences of a Substring.java @@ -1,12 +1,32 @@ class Solution { - public String removeOccurrences(String s, String part) { - while (true) { - int idx = s.indexOf(part); - if (idx == -1) { - break; - } - s = s.substring(0, idx) + s.substring(idx + part.length()); + public String removeOccurrences(String s, String part) { + Stack stack = new Stack<>(); + int n = s.length(); + int partLength = part.length(); + for (int i = 0; i < n; i++) { + stack.push(s.charAt(i)); + if (stack.size() >= partLength && check(stack, part, partLength)) { + for (int j = 0; j < partLength; j++) { + stack.pop(); + } + } + } + StringBuilder sb = new StringBuilder(); + while (!stack.isEmpty()) { + sb.append(stack.pop()); + } + return sb.reverse().toString(); + } + + private boolean check(Stack stack, String part, int partLength) { + Stack temp = new Stack<>(); + temp.addAll(stack); + for (int i = partLength - 1; i >= 0; i--) { + if (temp.isEmpty() || temp.peek() != part.charAt(i)) { + return false; + } + temp.pop(); + } + return true; } - return s; - } } From 2daac9d705fcc126adceb388263b9c526b9961c3 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Tue, 11 Feb 2025 17:29:01 -0800 Subject: [PATCH 681/712] Update Max Sum of a Pair With Equal Sum of Digits.java --- ...um of a Pair With Equal Sum of Digits.java | 42 +++++++++---------- 1 file changed, 21 insertions(+), 21 deletions(-) diff --git a/Medium/Max Sum of a Pair With Equal Sum of Digits.java b/Medium/Max Sum of a Pair With Equal Sum of Digits.java index 597e0658..1d8d89ae 100644 --- a/Medium/Max Sum of a Pair With Equal Sum of Digits.java +++ b/Medium/Max Sum of a Pair With Equal Sum of Digits.java @@ -1,25 +1,25 @@ class Solution { - public int maximumSum(int[] nums) { - int maxSum = -1; - Map map = new HashMap<>(); - for (int num : nums) { - int digitSum = getDigitSum(num); - if (map.containsKey(digitSum)) { - maxSum = Math.max(maxSum, map.get(digitSum) + num); - map.put(digitSum, Math.max(map.get(digitSum), num)); - } else { - map.put(digitSum, num); - } + public int maximumSum(int[] nums) { + Map map = new HashMap<>(); + int maxSum = -1; + for (int num : nums) { + int digitSum = calculateDigitSum(num); + if (map.containsKey(digitSum)) { + maxSum = Math.max(maxSum, map.get(digitSum) + num); + map.put(digitSum, Math.max(map.get(digitSum), num)); + } else { + map.put(digitSum, num); + } + } + return maxSum; } - return maxSum; - } - - private int getDigitSum(int num) { - int sum = 0; - while (num > 0) { - sum += num % 10; - num /= 10; + + private int calculateDigitSum(int num) { + int sum = 0; + while (num > 0) { + sum += num % 10; + num /= 10; + } + return sum; } - return sum; - } } From 30f21710052e766d53c921aceb97d2b09d79e4a4 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Wed, 12 Feb 2025 17:40:13 -0800 Subject: [PATCH 682/712] Create Minimum Operations to Exceed Threshold Value II.java --- ...Operations to Exceed Threshold Value II.java | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) create mode 100644 Medium/Minimum Operations to Exceed Threshold Value II.java diff --git a/Medium/Minimum Operations to Exceed Threshold Value II.java b/Medium/Minimum Operations to Exceed Threshold Value II.java new file mode 100644 index 00000000..9a6c2b09 --- /dev/null +++ b/Medium/Minimum Operations to Exceed Threshold Value II.java @@ -0,0 +1,17 @@ +class Solution { + public int minOperations(int[] nums, int k) { + PriorityQueue pq = new PriorityQueue<>(); + for (int num : nums) { + pq.add((long) num); + } + int operations = 0; + while (pq.peek() < k) { + long smallest = pq.poll(); + long secondSmallest = pq.poll(); + long newValue = Math.min(smallest, secondSmallest) * 2 + Math.max(smallest, secondSmallest); + pq.add(newValue); + operations++; + } + return operations; + } +} From 04175b684ba89a52fedb9b8a5ccd9989c2a21c95 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Wed, 19 Feb 2025 07:32:27 -0800 Subject: [PATCH 683/712] Create Construct Smallest Number From DI String.java --- .../Construct Smallest Number From DI String.java | 15 +++++++++++++++ 1 file changed, 15 insertions(+) create mode 100644 Medium/Construct Smallest Number From DI String.java diff --git a/Medium/Construct Smallest Number From DI String.java b/Medium/Construct Smallest Number From DI String.java new file mode 100644 index 00000000..64e39262 --- /dev/null +++ b/Medium/Construct Smallest Number From DI String.java @@ -0,0 +1,15 @@ +class Solution { + public String smallestNumber(String pattern) { + StringBuilder result = new StringBuilder(); + Stack stack = new Stack<>(); + for (int i = 0; i <= pattern.length(); i++) { + stack.push(i + 1); + if (i == pattern.length() || pattern.charAt(i) == 'I') { + while (!stack.isEmpty()) { + result.append(stack.pop()); + } + } + } + return result.toString(); + } +} From 5fb999c033b967a78437f39cbb7a09fb302db94b Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Wed, 19 Feb 2025 07:37:28 -0800 Subject: [PATCH 684/712] Create The k-th Lexicographical String of All Happy Strings of Length n.java --- ...ring of All Happy Strings of Length n.java | 28 +++++++++++++++++++ 1 file changed, 28 insertions(+) create mode 100644 Medium/The k-th Lexicographical String of All Happy Strings of Length n.java diff --git a/Medium/The k-th Lexicographical String of All Happy Strings of Length n.java b/Medium/The k-th Lexicographical String of All Happy Strings of Length n.java new file mode 100644 index 00000000..413b67d5 --- /dev/null +++ b/Medium/The k-th Lexicographical String of All Happy Strings of Length n.java @@ -0,0 +1,28 @@ +class Solution { + private static final char[] CHARS = {'a', 'b', 'c'}; + + public String getHappyString(int n, int k) { + Set set = new HashSet<>(); + backtrack(set, new StringBuilder(), n); + if (set.size() < k) { + return ""; + } + List list = new ArrayList<>(set); + Collections.sort(list); + return list.get(k - 1); + } + + private void backtrack(Set set, StringBuilder sb, int n) { + if (sb.length() == n) { + set.add(sb.toString()); + return; + } + for (char c : CHARS) { + if (sb.isEmpty() || sb.charAt(sb.length() - 1) != c) { + sb.append(c); + backtrack(set, sb, n); + sb.deleteCharAt(sb.length() - 1); + } + } + } +} From 50b0cb2ebb75524dc7241d8bc89c8c065ed739e3 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Thu, 20 Feb 2025 09:03:42 -0800 Subject: [PATCH 685/712] Create Find Unique Binary String.java --- Medium/Find Unique Binary String.java | 25 +++++++++++++++++++++++++ 1 file changed, 25 insertions(+) create mode 100644 Medium/Find Unique Binary String.java diff --git a/Medium/Find Unique Binary String.java b/Medium/Find Unique Binary String.java new file mode 100644 index 00000000..80cdfa9e --- /dev/null +++ b/Medium/Find Unique Binary String.java @@ -0,0 +1,25 @@ +class Solution { + + private static final char[] BINARY_CHARS = {'1', '0'}; + + public String findDifferentBinaryString(String[] nums) { + int n = nums.length; + Set binaryStrings = new HashSet<>(); + backtrack(new StringBuilder(), n, binaryStrings); + Set binaryStringsPresent = Arrays.stream(nums).collect(Collectors.toSet()); + binaryStrings.removeAll(binaryStringsPresent); + return binaryStrings.isEmpty() ? "" : binaryStrings.iterator().next(); + } + + private void backtrack(StringBuilder sb, int n, Set binaryStrings) { + if (sb.length() == n) { + binaryStrings.add(sb.toString()); + return; + } + for (char c : BINARY_CHARS) { + sb.append(c); + backtrack(sb, n, binaryStrings); + sb.deleteCharAt(sb.length() - 1); + } + } +} From c1ff60a4007603b312912ca49122646f8daa8cf3 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sat, 22 Feb 2025 07:33:11 -0800 Subject: [PATCH 686/712] Update Recover a Tree From Preorder Traversal.java --- ...ecover a Tree From Preorder Traversal.java | 56 ++++++++++--------- 1 file changed, 30 insertions(+), 26 deletions(-) diff --git a/Hard/Recover a Tree From Preorder Traversal.java b/Hard/Recover a Tree From Preorder Traversal.java index 69f3fe55..b851ca44 100644 --- a/Hard/Recover a Tree From Preorder Traversal.java +++ b/Hard/Recover a Tree From Preorder Traversal.java @@ -4,41 +4,45 @@ * int val; * TreeNode left; * TreeNode right; - * TreeNode(int x) { val = x; } + * TreeNode() {} + * TreeNode(int val) { this.val = val; } + * TreeNode(int val, TreeNode left, TreeNode right) { + * this.val = val; + * this.left = left; + * this.right = right; + * } * } */ class Solution { - public TreeNode recoverFromPreorder(String S) { - Map map = new HashMap<>(); + public TreeNode recoverFromPreorder(String traversal) { + Stack stack = new Stack<>(); int idx = 0; - int n = S.length(); - - while (idx < n) { - int level = 0; - StringBuilder sb = new StringBuilder(); - - while (idx < n && S.charAt(idx) == '-') { - level++; + while (idx < traversal.length()) { + int depth = 0; + while (idx < traversal.length() && traversal.charAt(idx) == '-') { + depth++; idx++; } - - while (idx < n && Character.isDigit(S.charAt(idx))) { - sb.append(S.charAt(idx++)); + int value = 0; + while (idx < traversal.length() && Character.isDigit(traversal.charAt(idx))) { + value = value * 10 + Character.getNumericValue(traversal.charAt(idx++)); } - - TreeNode currNode = new TreeNode(Integer.parseInt(sb.toString())); - map.put(level, currNode); - if (level > 0) { - TreeNode parent = map.get(level - 1); - if (parent.left == null) { - parent.left = currNode; - } - else { - parent.right = currNode; + TreeNode node = new TreeNode(value); + while (stack.size() > depth) { + stack.pop(); + } + if (!stack.isEmpty()) { + if (stack.peek().left == null) { + stack.peek().left = node; + } else { + stack.peek().right = node; } } + stack.push(node); + } + while (stack.size() > 1) { + stack.pop(); } - - return map.get(0); + return stack.peek(); } } From c25f01b2f86ae67c45d919b9174559184e163564 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 23 Feb 2025 10:38:59 -0800 Subject: [PATCH 687/712] Create Construct Binary Tree from Preorder and Postorder Traversal.java --- ...from Preorder and Postorder Traversal.java | 40 +++++++++++++++++++ 1 file changed, 40 insertions(+) create mode 100644 Medium/Construct Binary Tree from Preorder and Postorder Traversal.java diff --git a/Medium/Construct Binary Tree from Preorder and Postorder Traversal.java b/Medium/Construct Binary Tree from Preorder and Postorder Traversal.java new file mode 100644 index 00000000..ca7aa35d --- /dev/null +++ b/Medium/Construct Binary Tree from Preorder and Postorder Traversal.java @@ -0,0 +1,40 @@ +/** + * Definition for a binary tree node. + * public class TreeNode { + * int val; + * TreeNode left; + * TreeNode right; + * TreeNode() {} + * TreeNode(int val) { this.val = val; } + * TreeNode(int val, TreeNode left, TreeNode right) { + * this.val = val; + * this.left = left; + * this.right = right; + * } + * } + */ +class Solution { + public TreeNode constructFromPrePost(int[] preorder, int[] postorder) { + int n = preorder.length; + Map postorderIndex = new HashMap<>(); + for (int i = 0; i < n; i++) { + postorderIndex.put(postorder[i], i); + } + return constructTree(0, n - 1, 0, preorder, postorderIndex); + } + + private TreeNode constructTree(int preStart, int preEnd, int postStart, int[] preorder, Map postorderIndex) { + if (preStart > preEnd) { + return null; + } + if (preStart == preEnd) { + return new TreeNode(preorder[preStart]); + } + int leftRoot = preorder[preStart + 1]; + int leftCount = postorderIndex.get(leftRoot) - postStart + 1; + TreeNode root = new TreeNode(preorder[preStart]); + root.left = constructTree(preStart + 1, preStart + leftCount, postStart, preorder, postorderIndex); + root.right = constructTree(preStart + leftCount + 1, preEnd, postStart + leftCount, preorder, postorderIndex); + return root; + } +} From 88ecb654b06441c1414888c2b0994fa092cd693e Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sat, 1 Mar 2025 09:10:57 -0800 Subject: [PATCH 688/712] Update Apply Operations to an Array.java --- Easy/Apply Operations to an Array.java | 17 ++++++++--------- 1 file changed, 8 insertions(+), 9 deletions(-) diff --git a/Easy/Apply Operations to an Array.java b/Easy/Apply Operations to an Array.java index b0a663a2..3b2bca86 100644 --- a/Easy/Apply Operations to an Array.java +++ b/Easy/Apply Operations to an Array.java @@ -1,21 +1,20 @@ class Solution { public int[] applyOperations(int[] nums) { - for (int i = 0; i < nums.length - 1; i++) { + int n = nums.length; + for (int i = 0; i < n - 1; i++) { if (nums[i] == nums[i + 1]) { nums[i] *= 2; nums[i + 1] = 0; } } - int startIdx = 0; - int endIdx = 0; - while (endIdx < nums.length) { - if (nums[endIdx] != 0) { - nums[startIdx++] = nums[endIdx]; + int start = 0; + for (int i = 0; i < n; i++) { + if (nums[i] != 0) { + nums[start++] = nums[i]; } - endIdx++; } - while (startIdx < nums.length) { - nums[startIdx++] = 0; + while (start < n) { + nums[start++] = 0; } return nums; } From 7e86b13cd7f4381cde89fb4c4302b48cd9ca336b Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Wed, 5 Mar 2025 09:49:51 -0800 Subject: [PATCH 689/712] Create Count Total Number of Colored Cells.java --- Medium/Count Total Number of Colored Cells.java | 11 +++++++++++ 1 file changed, 11 insertions(+) create mode 100644 Medium/Count Total Number of Colored Cells.java diff --git a/Medium/Count Total Number of Colored Cells.java b/Medium/Count Total Number of Colored Cells.java new file mode 100644 index 00000000..81c10a8c --- /dev/null +++ b/Medium/Count Total Number of Colored Cells.java @@ -0,0 +1,11 @@ +class Solution { + public long coloredCells(int n) { + long count = 1; + int increment = 4; + while (n-- > 1) { + count += increment; + increment += 4; + } + return count; + } +} From 72f877e6ebf35519842c65e03815c4a3ae74274c Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 9 Mar 2025 12:03:46 -0700 Subject: [PATCH 690/712] Create Fruits Into Baskets II.java --- Easy/Fruits Into Baskets II.java | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) create mode 100644 Easy/Fruits Into Baskets II.java diff --git a/Easy/Fruits Into Baskets II.java b/Easy/Fruits Into Baskets II.java new file mode 100644 index 00000000..e0afa848 --- /dev/null +++ b/Easy/Fruits Into Baskets II.java @@ -0,0 +1,20 @@ +class Solution { + public int numOfUnplacedFruits(int[] fruits, int[] baskets) { + int count = 0; + for (int fruit : fruits) { + int idx = -1; + for (int i = 0; i < baskets.length; i++) { + if (baskets[i] >= fruit) { + idx = i; + break; + } + } + if (idx == -1) { + count++; + } else { + baskets[idx] = -1; + } + } + return count; + } +} From 8ed8a35ed86218a68f9211ab2c2495a20c951a68 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Wed, 19 Mar 2025 06:48:37 -0700 Subject: [PATCH 691/712] Create Maximum Unique Subarray Sum After Deletion.java --- ...imum Unique Subarray Sum After Deletion.java | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) create mode 100644 Easy/Maximum Unique Subarray Sum After Deletion.java diff --git a/Easy/Maximum Unique Subarray Sum After Deletion.java b/Easy/Maximum Unique Subarray Sum After Deletion.java new file mode 100644 index 00000000..e0a6a2ae --- /dev/null +++ b/Easy/Maximum Unique Subarray Sum After Deletion.java @@ -0,0 +1,17 @@ +class Solution { + public int maxSum(int[] nums) { + int max = nums[0]; + int sum = 0; + Set set = new HashSet<>(); + for (int num : nums) { + max = Math.max(num, max); + if (num > 0 && set.add(num)) { + sum += num; + } + } + if (max < 0) { + return max; + } + return sum; + } +} From f70a266f0ed726909b5228b54184c48081e4b6ee Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Thu, 20 Mar 2025 07:48:37 -0700 Subject: [PATCH 692/712] Create Design Spreadsheet.java --- Medium/Design Spreadsheet.java | 47 ++++++++++++++++++++++++++++++++++ 1 file changed, 47 insertions(+) create mode 100644 Medium/Design Spreadsheet.java diff --git a/Medium/Design Spreadsheet.java b/Medium/Design Spreadsheet.java new file mode 100644 index 00000000..e41fc142 --- /dev/null +++ b/Medium/Design Spreadsheet.java @@ -0,0 +1,47 @@ +class Spreadsheet { + + private final Map> sheet; + + public Spreadsheet(int rows) { + sheet = new HashMap<>(); + for (char c = 'A'; c <= 'Z'; c++) { + sheet.put(c, new HashMap<>()); + } + } + + public void setCell(String cell, int value) { + char column = cell.charAt(0); + int rowNumber = Integer.parseInt(cell.substring(1)); + Map row = sheet.get(column); + row.put(rowNumber, value); + } + + public void resetCell(String cell) { + setCell(cell, 0); + } + + public int getValue(String formula) { + String[] split = formula.split("\\+"); + String cellOne = split[0].substring(1); + String cellTwo = split[1]; + return getCellValue(cellOne) + getCellValue(cellTwo); + } + + private int getCellValue(String cell) { + if (!Character.isLetter(cell.charAt(0))) { + return Integer.parseInt(cell); + } + char column = cell.charAt(0); + int rowNumber = Integer.parseInt(cell.substring(1)); + Map row = sheet.get(column); + return row.getOrDefault(rowNumber, 0); + } +} + +/** + * Your Spreadsheet object will be instantiated and called as such: + * Spreadsheet obj = new Spreadsheet(rows); + * obj.setCell(cell,value); + * obj.resetCell(cell); + * int param_3 = obj.getValue(formula); + */ From 79fab170a7e6dbe64afb009018de192c97e49dc2 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sat, 22 Mar 2025 16:51:49 -0700 Subject: [PATCH 693/712] Create Count the Number of Complete Components.java --- ...unt the Number of Complete Components.java | 38 +++++++++++++++++++ 1 file changed, 38 insertions(+) create mode 100644 Medium/Count the Number of Complete Components.java diff --git a/Medium/Count the Number of Complete Components.java b/Medium/Count the Number of Complete Components.java new file mode 100644 index 00000000..d198b0b2 --- /dev/null +++ b/Medium/Count the Number of Complete Components.java @@ -0,0 +1,38 @@ +class Solution { + public int countCompleteComponents(int n, int[][] edges) { + Map> graph = new HashMap<>(); + for (int[] edge : edges) { + int nodeOne = edge[0]; + int nodeTwo = edge[1]; + graph.computeIfAbsent(nodeOne, k -> new HashSet<>()).add(nodeTwo); + graph.computeIfAbsent(nodeTwo, k -> new HashSet<>()).add(nodeOne); + } + int count = 0; + Set visited = new HashSet<>(); + for (int i = 0; i < n; i++) { + if (visited.add(i)) { + int[] componentInfo = new int[2]; + dfs(i, graph, visited, componentInfo); + if (componentInfo[0] * (componentInfo[0] - 1) == componentInfo[1]) { + count++; + } + } + } + return count; + } + + private void dfs( + int node, + Map> graph, + Set visited, + int[] componentInfo) { + componentInfo[0]++; + Set connections = graph.getOrDefault(node, new HashSet<>()); + componentInfo[1] += connections.size(); + for (Integer conn : connections) { + if (visited.add(conn)) { + dfs(conn, graph, visited, componentInfo); + } + } + } +} From f09b6a6dcfc4bbd1cb3fe614078cd8141ac05a02 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 23 Mar 2025 08:14:49 -0700 Subject: [PATCH 694/712] Create Maximum Containers on a Ship.java --- Easy/Maximum Containers on a Ship.java | 8 ++++++++ 1 file changed, 8 insertions(+) create mode 100644 Easy/Maximum Containers on a Ship.java diff --git a/Easy/Maximum Containers on a Ship.java b/Easy/Maximum Containers on a Ship.java new file mode 100644 index 00000000..e113027d --- /dev/null +++ b/Easy/Maximum Containers on a Ship.java @@ -0,0 +1,8 @@ +class Solution { + public int maxContainers(int n, int w, int maxWeight) { + if (n * n * w <= maxWeight) { + return n * n; + } + return maxWeight / w; + } +} From 0343dfd31a1cc8309b3ea10ed1315c1287b594c5 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sat, 29 Mar 2025 08:02:00 -0700 Subject: [PATCH 695/712] Create Count Days Without Meetings.java --- Medium/Count Days Without Meetings.java | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+) create mode 100644 Medium/Count Days Without Meetings.java diff --git a/Medium/Count Days Without Meetings.java b/Medium/Count Days Without Meetings.java new file mode 100644 index 00000000..1630e6df --- /dev/null +++ b/Medium/Count Days Without Meetings.java @@ -0,0 +1,24 @@ +class Solution { + public int countDays(int days, int[][] meetings) { + Arrays.sort(meetings, (o1, o2) -> { + int c = Integer.compare(o1[0], o2[0]); + if (c != 0) { + return c; + } + return Integer.compare(o2[1], o1[1]); + }); + int meetingDays = 0; + int idx = 0; + while (idx < meetings.length) { + int start = meetings[idx][0]; + int end = meetings[idx][1]; + idx++; + while (idx < meetings.length && meetings[idx][0] <= end) { + end = Math.max(end, meetings[idx][1]); + idx++; + } + meetingDays += (end - start + 1); + } + return days - meetingDays; + } +} From e6687a6c142a52bdee850192a39b13c70a8e6785 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 30 Mar 2025 07:04:57 -0700 Subject: [PATCH 696/712] Create Reverse Degree of a String.java --- Easy/Reverse Degree of a String.java | 9 +++++++++ 1 file changed, 9 insertions(+) create mode 100644 Easy/Reverse Degree of a String.java diff --git a/Easy/Reverse Degree of a String.java b/Easy/Reverse Degree of a String.java new file mode 100644 index 00000000..db8f4e91 --- /dev/null +++ b/Easy/Reverse Degree of a String.java @@ -0,0 +1,9 @@ +class Solution { + public int reverseDegree(String s) { + int result = 0; + for (int i = 0; i < s.length(); i++) { + result += (i + 1) * (26 - (s.charAt(i) - 'a')); + } + return result; + } +} From 6c82d5e37dfb702b58b177185123e545799b0b3f Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 30 Mar 2025 07:15:26 -0700 Subject: [PATCH 697/712] Create Minimum Cost to Reach Every Position.java --- Easy/Minimum Cost to Reach Every Position.java | 13 +++++++++++++ 1 file changed, 13 insertions(+) create mode 100644 Easy/Minimum Cost to Reach Every Position.java diff --git a/Easy/Minimum Cost to Reach Every Position.java b/Easy/Minimum Cost to Reach Every Position.java new file mode 100644 index 00000000..1b142d2c --- /dev/null +++ b/Easy/Minimum Cost to Reach Every Position.java @@ -0,0 +1,13 @@ +class Solution { + public int[] minCosts(int[] cost) { + int n = cost.length; + int[] result = new int[n]; + int minCost = Integer.MAX_VALUE; + for (int i = 0; i < n; i++) { + int curr = cost[i]; + minCost = Math.min(minCost, curr); + result[i] = minCost; + } + return result; + } +} From d607cf25ba1d4a4f13c5a7a8ad2e709571352bbe Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 13 Apr 2025 11:12:22 -0700 Subject: [PATCH 698/712] Create Find Closest Person.java --- Easy/Find Closest Person.java | 7 +++++++ 1 file changed, 7 insertions(+) create mode 100644 Easy/Find Closest Person.java diff --git a/Easy/Find Closest Person.java b/Easy/Find Closest Person.java new file mode 100644 index 00000000..0d178230 --- /dev/null +++ b/Easy/Find Closest Person.java @@ -0,0 +1,7 @@ +class Solution { + public int findClosest(int x, int y, int z) { + int diffOne = Math.abs(x - z); + int diffTwo = Math.abs(y - z); + return diffOne == diffTwo ? 0 : (diffOne < diffTwo ? 1 : 2); + } +} From f0117cca3526851eaf7192572f6ba92415fbddac Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sun, 13 Apr 2025 11:13:49 -0700 Subject: [PATCH 699/712] Create Minimum Operations to Make Array Sum Divisible by K.java --- ...imum Operations to Make Array Sum Divisible by K.java | 9 +++++++++ 1 file changed, 9 insertions(+) create mode 100644 Easy/Minimum Operations to Make Array Sum Divisible by K.java diff --git a/Easy/Minimum Operations to Make Array Sum Divisible by K.java b/Easy/Minimum Operations to Make Array Sum Divisible by K.java new file mode 100644 index 00000000..c941b50a --- /dev/null +++ b/Easy/Minimum Operations to Make Array Sum Divisible by K.java @@ -0,0 +1,9 @@ +class Solution { + public int minOperations(int[] nums, int k) { + int sum = 0; + for (int num : nums) { + sum += num; + } + return sum % k; + } +} From 4a81fa982c607d1d900c5f988599219cc82e8ad3 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Tue, 15 Apr 2025 07:17:29 -0700 Subject: [PATCH 700/712] Update Count Symmetric Integers.java --- Easy/Count Symmetric Integers.java | 30 ++++++++++++++++++++---------- 1 file changed, 20 insertions(+), 10 deletions(-) diff --git a/Easy/Count Symmetric Integers.java b/Easy/Count Symmetric Integers.java index f32301e1..8ae9c320 100644 --- a/Easy/Count Symmetric Integers.java +++ b/Easy/Count Symmetric Integers.java @@ -1,17 +1,27 @@ class Solution { public int countSymmetricIntegers(int low, int high) { - int result = 0; + int count = 0; for (int i = low; i <= high; i++) { - String s = String.valueOf(i); - int diff = 0; - int n = s.length(); - for (int j = 0; j < n / 2; j++) { - diff += s.charAt(j) - s.charAt(n - j - 1); - } - if (n % 2 == 0 && diff == 0) { - result++; + if (isSymmetric(i)) { + count++; } } - return result; + return count; + } + + private static boolean isSymmetric(int num) { + String s = String.valueOf(num); + int n = s.length(); + if (n % 2 != 0) { + return false; + } + int sum = 0; + for (int i = 0; i < n / 2; i++) { + sum += Character.getNumericValue(s.charAt(i)); + } + for (int i = n / 2; i < n; i++) { + sum -= Character.getNumericValue(s.charAt(i)); + } + return sum == 0; } } From f37ed97923b5e909813df92781a15828b1386986 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sat, 26 Apr 2025 08:55:01 -0700 Subject: [PATCH 701/712] Create Calculate Score After Performing Instructions.java --- ...e Score After Performing Instructions.java | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) create mode 100644 Medium/Calculate Score After Performing Instructions.java diff --git a/Medium/Calculate Score After Performing Instructions.java b/Medium/Calculate Score After Performing Instructions.java new file mode 100644 index 00000000..789e5669 --- /dev/null +++ b/Medium/Calculate Score After Performing Instructions.java @@ -0,0 +1,19 @@ +class Solution { + public long calculateScore(String[] instructions, int[] values) { + long result = 0; + int n = values.length; + int idx = 0; + Set executed = new HashSet<>(); + while (idx < n && idx >= 0) { + if (!executed.add(idx)) { + break; + } + if (instructions[idx].equals("add")) { + result += values[idx++]; + } else { + idx += values[idx]; + } + } + return result; + } +} From 96a5d01cded0218a8c4c9e97d1fd5230ce1e23ef Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Wed, 7 May 2025 06:01:01 -0700 Subject: [PATCH 702/712] Create Find Minimum Time to Reach Last Room I.java --- ...ind Minimum Time to Reach Last Room I.java | 36 +++++++++++++++++++ 1 file changed, 36 insertions(+) create mode 100644 Medium/Find Minimum Time to Reach Last Room I.java diff --git a/Medium/Find Minimum Time to Reach Last Room I.java b/Medium/Find Minimum Time to Reach Last Room I.java new file mode 100644 index 00000000..0247baa4 --- /dev/null +++ b/Medium/Find Minimum Time to Reach Last Room I.java @@ -0,0 +1,36 @@ +class Solution { + + private static final int[][] DIRS = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}}; + + public int minTimeToReach(int[][] moveTime) { + int n = moveTime.length; + int m = moveTime[0].length; + boolean[][] visited = new boolean[n][m]; + Integer[][] minTime = new Integer[n][m]; + minTime[0][0] = 0; + PriorityQueue pq = new PriorityQueue<>((a, b) -> a[2] - b[2]); + pq.add(new int[]{0, 0, 0}); + while (!pq.isEmpty()) { + int[] removed = pq.remove(); + int x = removed[0]; + int y = removed[1]; + if (visited[x][y]) { + continue; + } + visited[x][y] = true; + for (int[] dir : DIRS) { + int newX = x + dir[0]; + int newY = y + dir[1]; + if (newX >= 0 && newY >= 0 && newX < n && newY < m) { + int distance = Math.max(minTime[x][y], moveTime[newX][newY]) + 1; + int currMinTime = minTime[newX][newY] == null ? Integer.MAX_VALUE : minTime[newX][newY]; + if (currMinTime > distance) { + minTime[newX][newY] = distance; + pq.add(new int[]{newX, newY, distance}); + } + } + } + } + return minTime[n - 1][m - 1]; + } +} From c7c43dc18b8be8ebbc54ebd7a1f528e83aab85eb Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Thu, 8 May 2025 07:06:50 -0700 Subject: [PATCH 703/712] Create Maximum Product of Two Digits.java --- Easy/Maximum Product of Two Digits.java | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) create mode 100644 Easy/Maximum Product of Two Digits.java diff --git a/Easy/Maximum Product of Two Digits.java b/Easy/Maximum Product of Two Digits.java new file mode 100644 index 00000000..c61f3c3a --- /dev/null +++ b/Easy/Maximum Product of Two Digits.java @@ -0,0 +1,17 @@ +class Solution { + public int maxProduct(int n) { + int maximum = Integer.MIN_VALUE; + int secondMaximum = Integer.MIN_VALUE; + while (n > 0) { + int num = n % 10; + n /= 10; + if (num > maximum) { + secondMaximum = maximum; + maximum = num; + } else if (num > secondMaximum) { + secondMaximum = num; + } + } + return maximum * secondMaximum; + } +} From 0209afb33cd40797aa03707328030e2b0a8d9f5f Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Wed, 14 May 2025 06:24:41 -0700 Subject: [PATCH 704/712] Create Total Characters in String After Transformations I.java --- ...ers in String After Transformations I.java | 25 +++++++++++++++++++ 1 file changed, 25 insertions(+) create mode 100644 Medium/Total Characters in String After Transformations I.java diff --git a/Medium/Total Characters in String After Transformations I.java b/Medium/Total Characters in String After Transformations I.java new file mode 100644 index 00000000..3751ab7e --- /dev/null +++ b/Medium/Total Characters in String After Transformations I.java @@ -0,0 +1,25 @@ +class Solution { + + private static final int MOD = 1000_0000_07; + + public int lengthAfterTransformations(String s, int t) { + int[] frequency = new int[26]; + for (char c : s.toCharArray()) { + frequency[c - 'a']++; + } + for (int round = 0; round < t; round++) { + int[] next = new int[26]; + next[0] = frequency[25]; // Transformation from 'z' + next[1] = (frequency[25] + frequency[0]) % MOD; // Transformation from either 'z' or 'a' + for (int i = 2; i < 26; i++) { + next[i] = frequency[i - 1]; // Transformation for next character + } + frequency = next; + } + int result = 0; + for (int i = 0; i < 26; i++) { + result = (result + frequency[i]) % MOD; + } + return result; + } +} From 52620f41b903dc8c26ca32aa1e7877eec199dd8b Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Tue, 20 May 2025 07:15:08 -0700 Subject: [PATCH 705/712] Create Zero Array Transformation I.java --- Medium/Zero Array Transformation I.java | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+) create mode 100644 Medium/Zero Array Transformation I.java diff --git a/Medium/Zero Array Transformation I.java b/Medium/Zero Array Transformation I.java new file mode 100644 index 00000000..2b9ab602 --- /dev/null +++ b/Medium/Zero Array Transformation I.java @@ -0,0 +1,24 @@ +class Solution { + public boolean isZeroArray(int[] nums, int[][] queries) { + int n = nums.length; + int[] diff = new int[n + 1]; + for (int[] query : queries) { + int left = query[0]; + int right = query[1]; + diff[left] += 1; + diff[right + 1] -= 1; + } + int[] operation = new int[n + 1]; + int currOperation = 0; + for (int i = 0; i < n + 1; i++) { + currOperation += diff[i]; + operation[i] = currOperation; + } + for (int i = 0; i < n; i++) { + if (operation[i] < nums[i]) { + return false; + } + } + return true; + } +} From 96489b1a30e6f271468b065dd0d439aaef04e679 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Mon, 2 Jun 2025 07:06:56 -0700 Subject: [PATCH 706/712] Create Distribute Candies Among Children II.java --- Medium/Distribute Candies Among Children II.java | 14 ++++++++++++++ 1 file changed, 14 insertions(+) create mode 100644 Medium/Distribute Candies Among Children II.java diff --git a/Medium/Distribute Candies Among Children II.java b/Medium/Distribute Candies Among Children II.java new file mode 100644 index 00000000..aa9648f2 --- /dev/null +++ b/Medium/Distribute Candies Among Children II.java @@ -0,0 +1,14 @@ +class Solution { + public long distributeCandies(int n, int limit) { + long result = 0; + for (int i = 0; i <= Math.min(limit, n); i++) { + // distribution not possible as we will have to allocate at least one child with + // more than limit candies + if (n - i > 2 * limit) { + continue; + } + result += Math.min(n - i, limit) - Math.max(0, n - i - limit) + 1; + } + return result; + } +} From 78832b33f37b1fc3b850ec08f957e069868ae80f Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Tue, 3 Jun 2025 07:21:58 -0700 Subject: [PATCH 707/712] Create Find Minimum Log Transportation Cost.java --- Easy/Find Minimum Log Transportation Cost.java | 12 ++++++++++++ 1 file changed, 12 insertions(+) create mode 100644 Easy/Find Minimum Log Transportation Cost.java diff --git a/Easy/Find Minimum Log Transportation Cost.java b/Easy/Find Minimum Log Transportation Cost.java new file mode 100644 index 00000000..3820474e --- /dev/null +++ b/Easy/Find Minimum Log Transportation Cost.java @@ -0,0 +1,12 @@ +class Solution { + public long minCuttingCost(int n, int m, int k) { + long cost = 0; + if (n > k) { + cost += ((long) (n - k)) * (k); + } + if (m > k) { + cost += ((long) (m - k)) * (k); + } + return cost; + } +} From a15f0c915355221f247be1e23057c46a10ad29e7 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Tue, 3 Jun 2025 07:30:09 -0700 Subject: [PATCH 708/712] Create Resulting String After Adjacent Removals.java --- ...ulting String After Adjacent Removals.java | 21 +++++++++++++++++++ 1 file changed, 21 insertions(+) create mode 100644 Medium/Resulting String After Adjacent Removals.java diff --git a/Medium/Resulting String After Adjacent Removals.java b/Medium/Resulting String After Adjacent Removals.java new file mode 100644 index 00000000..efa43bf6 --- /dev/null +++ b/Medium/Resulting String After Adjacent Removals.java @@ -0,0 +1,21 @@ +class Solution { + public String resultingString(String s) { + Stack stack = new Stack<>(); + for (char c : s.toCharArray()) { + if (!stack.isEmpty() && isAdjacent(stack.peek(), c)) { + stack.pop(); + } else { + stack.push(c); + } + } + StringBuilder result = new StringBuilder(); + for (char c : stack) { + result.append(c); + } + return result.toString(); + } + + private static boolean isAdjacent(char first, char second) { + return Math.abs(first - second) == 1 || (first == 'a' && second == 'z') || (first == 'z' && second == 'a'); + } +} From 89afcc3436620718196217d9f17e04054350c692 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Wed, 4 Jun 2025 10:06:43 -0700 Subject: [PATCH 709/712] Create Find the Lexicographically Largest String From the Box I.java --- ...raphically Largest String From the Box I.java | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) create mode 100644 Medium/Find the Lexicographically Largest String From the Box I.java diff --git a/Medium/Find the Lexicographically Largest String From the Box I.java b/Medium/Find the Lexicographically Largest String From the Box I.java new file mode 100644 index 00000000..1133cb93 --- /dev/null +++ b/Medium/Find the Lexicographically Largest String From the Box I.java @@ -0,0 +1,16 @@ +class Solution { + public String answerString(String word, int numFriends) { + if (numFriends == 1) { + return word; + } + int n = word.length(); + String result = ""; + for (int i = 0; i < n; i++) { + String curr = word.substring(i, Math.min(i + n - numFriends + 1, n)); + if (result.compareTo(curr) <= 0) { + result = curr; + } + } + return result; + } +} From b962419d92bbd2d824f9c3a624416d0ff4ed6ff6 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Thu, 5 Jun 2025 06:20:55 -0700 Subject: [PATCH 710/712] Update Lexicographically Smallest Equivalent String.java --- ...raphically Smallest Equivalent String.java | 69 +++++++++++-------- 1 file changed, 42 insertions(+), 27 deletions(-) diff --git a/Medium/Lexicographically Smallest Equivalent String.java b/Medium/Lexicographically Smallest Equivalent String.java index c5856615..f4d01c21 100644 --- a/Medium/Lexicographically Smallest Equivalent String.java +++ b/Medium/Lexicographically Smallest Equivalent String.java @@ -1,31 +1,46 @@ class Solution { - public String smallestEquivalentString(String s1, String s2, String baseStr) { - int[] graph = new int[26]; - for (int i = 0; i < 26; i++) { - graph[i] = i; + public String smallestEquivalentString(String s1, String s2, String baseStr) { + UnionFind unionFind = new UnionFind(26); + for (int i = 0; i < s1.length(); i++) { + char c1 = s1.charAt(i); + char c2 = s2.charAt(i); + unionFind.union(c1 - 'a', c2 - 'a'); + } + StringBuilder result = new StringBuilder(); + for (char c : baseStr.toCharArray()) { + result.append((char) (unionFind.find(c - 'a') + 'a')); + } + return result.toString(); } - for (int i = 0; i < s1.length(); i++) { - int idxOne = s1.charAt(i) - 'a'; - int idxTwo = s2.charAt(i) - 'a'; - int parentOne = find(graph, idxOne); - int parentTwo = find(graph, idxTwo); - if(parentOne < parentTwo) { - graph[parentTwo] = parentOne; - } else { - graph[parentOne] = parentTwo; - } + + class UnionFind { + private int[] parent; + + public UnionFind(int n) { + parent = new int[n]; + for (int i = 0; i < n; i++) { + parent[i] = i; + } + } + + public int find(int node) { + if (parent[node] == node) { + return node; + } + parent[node] = find(parent[node]); + return parent[node]; + } + + public void union(int nodeOne, int nodeTwo) { + int parentOne = find(nodeOne); + int parentTwo = find(nodeTwo); + if (parentOne != parentTwo) { + if (parentOne < parentTwo) { + parent[parentTwo] = parentOne; + } else { + parent[parentOne] = parentTwo; + } + } + } } - StringBuilder sb = new StringBuilder(); - for (char c : baseStr.toCharArray()) { - sb.append((char) ('a' + find(graph, c - 'a'))); - } - return sb.toString(); - } - - private int find(int[] graph, int idx) { - while(graph[idx] != idx) { - idx = graph[idx]; - } - return idx; - } } From da789bdd18417daf8dae61d377cfcd0b751d9ad3 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Fri, 6 Jun 2025 10:27:44 -0700 Subject: [PATCH 711/712] Create Using a Robot to Print the Lexicographically Smallest String.java --- ...the Lexicographically Smallest String.java | 31 +++++++++++++++++++ 1 file changed, 31 insertions(+) create mode 100644 Medium/Using a Robot to Print the Lexicographically Smallest String.java diff --git a/Medium/Using a Robot to Print the Lexicographically Smallest String.java b/Medium/Using a Robot to Print the Lexicographically Smallest String.java new file mode 100644 index 00000000..8d9c2064 --- /dev/null +++ b/Medium/Using a Robot to Print the Lexicographically Smallest String.java @@ -0,0 +1,31 @@ +class Solution { + public String robotWithString(String s) { + int[] counter = new int[26]; + for (char c : s.toCharArray()) { + counter[c - 'a']++; + } + Stack stack = new Stack<>(); + StringBuilder sb = new StringBuilder(); + for (char c : s.toCharArray()) { + stack.push(c); + counter[c - 'a']--; + while (!stack.isEmpty() && isSmallest(stack.peek(), counter)) { + sb.append(stack.pop()); + } + } + while (!stack.isEmpty()) { + sb.append(stack.pop()); + } + return sb.toString(); + } + + private boolean isSmallest(char c, int[] counter) { + int limit = c - 'a'; + for (int i = 0; i < limit; i++) { + if (counter[i] > 0) { + return false; + } + } + return true; + } +} From c91e3403fb904d4f4a127e339adb252849377872 Mon Sep 17 00:00:00 2001 From: Varun Upadhyay Date: Sat, 7 Jun 2025 06:22:41 -0700 Subject: [PATCH 712/712] Create Lexicographically Minimum String After Removing Stars.java --- ...y Minimum String After Removing Stars.java | 28 +++++++++++++++++++ 1 file changed, 28 insertions(+) create mode 100644 Medium/Lexicographically Minimum String After Removing Stars.java diff --git a/Medium/Lexicographically Minimum String After Removing Stars.java b/Medium/Lexicographically Minimum String After Removing Stars.java new file mode 100644 index 00000000..794ee712 --- /dev/null +++ b/Medium/Lexicographically Minimum String After Removing Stars.java @@ -0,0 +1,28 @@ +class Solution { + public String clearStars(String s) { + Deque[] count = new Deque[26]; + for (int i = 0; i < 26; i++) { + count[i] = new ArrayDeque<>(); + } + char[] letters = s.toCharArray(); + for (int i = 0; i < letters.length; i++) { + if (letters[i] != '*') { + count[letters[i] - 'a'].push(i); + } else { + for (int j = 0; j < 26; j++) { + if (!count[j].isEmpty()) { + letters[count[j].pop()] = '*'; + break; + } + } + } + } + StringBuilder sb = new StringBuilder(); + for (char c : letters) { + if (c != '*') { + sb.append(c); + } + } + return sb.toString(); + } +}