Code is Added By anjha

Author: anjha1

1822.sign-of-the-product-of-an-array/README.md

@@ -0,0 +1,7 @@
+# [1822. Sign of the Product of an Array](https://leetcode.com/problems/sign-of-the-product-of-an-array/)
+
+
+Complexity Analysis:
+
+- Time Complexity: $O(n)$. $n$ is the length of `nums`.
+- Space Complexity: $O(1)$.

1822.sign-of-the-product-of-an-array/SignOfTheProductOfAnArray.java

@@ -0,0 +1,14 @@
+class SignOfTheProductOfAnArray {
+    public int arraySign(int[] nums) {
+        int sign = 1;
+        for (int num: nums) {
+            if (num == 0) {
+                return 0;
+            }
+            if (num < 0) {
+                sign *= -1;
+            }
+        }
+        return sign;
+    }
+}

1832.check-if-the-sentence-is-pangram/CheckIfTheSentenceIsPangram.java

@@ -0,0 +1,11 @@
+class CheckIfTheSentenceIsPangram {
+    public boolean checkIfPangram(String sentence) {
+        boolean[] found = new boolean[26];
+        for (char c : sentence.toCharArray())
+            found[c - 'a'] = true;
+        for (boolean f : found)
+            if (!f) return false;
+
+        return true;
+    }
+}

1832.check-if-the-sentence-is-pangram/README.md

@@ -0,0 +1,2 @@
+# [1832. Check if the Sentence Is Pangram](https://leetcode.com/problems/check-if-the-sentence-is-pangram/)
+

1833.maximum-ice-cream-bars/MaximumIceCreamBars.java

@@ -0,0 +1,14 @@
+import java.util.Arrays;
+
+class MaximumIceCreamBars {
+    public int maxIceCream(int[] costs, int coins) {
+        Arrays.sort(costs);
+        int n = costs.length;
+        for (int i = 0; i < n; i++) {
+            if (costs[i] > coins)
+                return i;
+            coins -= costs[i];
+        }
+        return n;
+    }
+}

1833.maximum-ice-cream-bars/README.md

@@ -0,0 +1,2 @@
+# [1833. Maximum Ice Cream Bars](https://leetcode.com/problems/maximum-ice-cream-bars/)
+

1834.single-threaded-cpu/README.md

@@ -0,0 +1,7 @@
+# [1834. Single-Threaded CPU](https://leetcode.com/problems/single-threaded-cpu/)
+
+
+Complexity Analysis:
+
+- Time Complexity: $O(n\log n)$. Array Sort costs $O(n\log n)$, add priority queue costs $O(\log n)$ and we running $n$ times which is the length of tasks. The total time complexity is $O(2n\log n)=O(n\log n)$.
+- Space Complexity: $O(n)$. newTasks costs $O(n)$ and priority queue costs $O(n)$ as well. The total space complexity is $O(2n)=O(n)$.

1834.single-threaded-cpu/SingleThreadedCpu.java

@@ -0,0 +1,33 @@
+import java.util.*;
+
+class SingleThreadedCpu {
+    public int[] getOrder(int[][] tasks) {
+        int[][] newTasks = new int[tasks.length][3];
+        for (int i = 0; i < tasks.length; i++) {
+            newTasks[i][0] = tasks[i][0];
+            newTasks[i][1] = tasks[i][1];
+            newTasks[i][2] = i;
+        }
+
+        Arrays.sort(newTasks, Comparator.comparingInt(a -> a[0]));
+        // pq data: new int[]{processingTime, index}
+        PriorityQueue<int[]> pq = new PriorityQueue<>((a, b) -> (a[0] != b[0] ? (a[0] - b[0]) : (a[1] - b[1])));
+        int[] ans = new int[tasks.length];
+        int ansIndex = 0, currTime = 0;
+        for (int i = 0; i < newTasks.length; i++) {
+            while (currTime < newTasks[i][0] && !pq.isEmpty()) {
+                int[] topTask = pq.remove();
+                ans[ansIndex++] = topTask[1];
+                currTime += topTask[0];
+            }
+            currTime = Math.max(currTime, newTasks[i][0]);
+            pq.add(new int[]{newTasks[i][1], newTasks[i][2]});
+        }
+        while (!pq.isEmpty()) {
+            int[] topTask = pq.remove();
+            ans[ansIndex++] = topTask[1];
+        }
+
+        return ans;
+    }
+}

1926.nearest-exit-from-entrance-in-maze/NearestExitFromEntranceInMaze.java

@@ -0,0 +1,34 @@
+import java.util.LinkedList;
+import java.util.Queue;
+
+class NearestExitFromEntranceInMaze {
+    public int nearestExit(char[][] maze, int[] entrance) {
+        int rows = maze.length, cols = maze[0].length;
+        int[][] dirs = new int[][]{{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
+
+        int startRow = entrance[0], startCol = entrance[1];
+        maze[startRow][startCol] = '+';
+
+        Queue<int[]> queue = new LinkedList<>();
+        queue.offer(new int[]{startRow, startCol, 0});
+
+        while (!queue.isEmpty()) {
+            int[] currentState = queue.poll();
+            int currRow = currentState[0], currCol = currentState[1], currDistance = currentState[2];
+
+            for (int[] dir : dirs) {
+                int nextRow = currRow + dir[0], nextCol = currCol + dir[1];
+
+                if (0 <= nextRow && nextRow < rows && 0 <= nextCol && nextCol < cols && maze[nextRow][nextCol] == '.') {
+                    if (nextRow == 0 || nextRow == rows - 1 || nextCol == 0 || nextCol == cols - 1)
+                        return currDistance + 1;
+
+                    maze[nextRow][nextCol] = '+';
+                    queue.offer(new int[]{nextRow, nextCol, currDistance + 1});
+                }
+            }
+        }
+
+        return -1;
+    }
+}

1926.nearest-exit-from-entrance-in-maze/README.md

@@ -0,0 +1,2 @@
+# [1926. Nearest Exit from Entrance in Maze](https://leetcode.com/problems/nearest-exit-from-entrance-in-maze/)
+

1962.remove-stones-to-minimize-the-total/README.md

@@ -0,0 +1,7 @@
+# [1962. Remove Stones to Minimize the Total](https://leetcode.com/problems/remove-stones-to-minimize-the-total/)
+
+
+Complexity Analysis:
+
+- Time Complexity: $O(n + k\log n)$. $n$ is the length of piles. Create priority queue and put piles to it cost $O(n)$. Moreover, add value and remove value cost $O(\log n)$. In the final step, calculate the result costs $O(n)$. The total time complexity is $O(2n+k\log n)=O(n + k\log n)$.
+- Space Complexity: $O(n)$. The space complexity of priority queue is $O(n)$.

1962.remove-stones-to-minimize-the-total/RemoveStonesToMinimizeTheTotal.java

@@ -0,0 +1,20 @@
+import java.util.PriorityQueue;
+
+class RemoveStonesToMinimizeTheTotal {
+    public int minStoneSum(int[] piles, int k) {
+        PriorityQueue<Integer> pq = new PriorityQueue<>((a, b) -> b - a);
+        for (int i = 0; i < piles.length; i++)
+            pq.add(piles[i]);
+
+        for (int i = 0; i < k; i++) {
+            int stone = pq.remove();
+            pq.add(stone - (stone / 2));
+        }
+
+        int stones = 0;
+        for (int stone : pq)
+            stones += stone;
+
+        return stones;
+    }
+}

1971.find-if-path-exists-in-graph/FindIfPathExistsInGraph.java

@@ -0,0 +1,32 @@
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Queue;
+
+class FindIfPathExistsInGraph {
+    public boolean validPath(int n, int[][] edges, int source, int destination) {
+        List<Integer>[] adj = new List[n];
+        for (int i = 0; i < n; i++)
+            adj[i] = new ArrayList<>();
+        for (int[] edge : edges) {
+            int x = edge[0], y = edge[1];
+            adj[x].add(y);
+            adj[y].add(x);
+        }
+        boolean[] visited = new boolean[n];
+        Queue<Integer> queue = new LinkedList<>();
+        queue.offer(source);
+        visited[source] = true;
+        while (!queue.isEmpty()) {
+            int vertex = queue.poll();
+            if (vertex == destination) break;
+            for (int next : adj[vertex]) {
+                if (!visited[next]) {
+                    queue.offer(next);
+                    visited[next] = true;
+                }
+            }
+        }
+        return visited[destination];
+    }
+}

1971.find-if-path-exists-in-graph/README.md

@@ -0,0 +1,2 @@
+# [1971. Find if Path Exists in Graph](https://leetcode.com/problems/find-if-path-exists-in-graph/)
+

1996.the-number-of-weak-characters-in-the-game/README.md

@@ -0,0 +1,2 @@
+# [1996. The Number of Weak Characters in the Game](https://leetcode.com/problems/the-number-of-weak-characters-in-the-game/)
+

1996.the-number-of-weak-characters-in-the-game/TheNumberOfWeakCharactersInTheGame.java

@@ -0,0 +1,17 @@
+import java.util.Arrays;
+
+class TheNumberOfWeakCharactersInTheGame {
+    public int numberOfWeakCharacters(int[][] properties) {
+        Arrays.sort(properties, (a, b) -> (a[0] == b[0]) ? Integer.compare(b[1], a[1]) : Integer.compare(a[0], b[0]));
+
+        int noOfWeakCharacters = 0;
+        int len = properties.length;
+        int max = properties[len-1][1];
+
+        for (int i = len - 2; i >= 0; i--) {
+            if (properties[i][1] < max) noOfWeakCharacters++;
+            else max = properties[i][1];
+        }
+        return noOfWeakCharacters;
+    }
+}

2007.find-original-array-from-doubled-array/FindOriginalArrayFromDoubledArray.java

@@ -0,0 +1,26 @@
+import java.util.Arrays;
+import java.util.HashMap;
+
+class FindOriginalArrayFromDoubledArray {
+    public int[] findOriginalArray(int[] changed) {
+        int[] emptyArr = new int[0];
+        int l = changed.length;
+        if (l % 2 != 0) return emptyArr;
+        HashMap<Integer, Integer> map = new HashMap<>();
+        int[] res = new int[l / 2];
+        for (int j : changed) {
+            map.put(j, map.getOrDefault(j, 0) + 1);
+        }
+        int temp = 0;
+        Arrays.sort(changed);
+        for (int num : changed) {
+            if (map.get(num) <= 0) continue;
+            if (map.getOrDefault(2 * num, 0) <= 0) return emptyArr;
+            res[temp++] = num;
+            map.put(num, map.get(num) - 1);
+            map.put(2 * num, map.get(2 * num) - 1);
+        }
+
+        return res;
+    }
+}

2007.find-original-array-from-doubled-array/README.md

@@ -0,0 +1 @@
+# [2007. Find Original Array From Doubled Array](https://leetcode.com/problems/find-original-array-from-doubled-array/)

2095.delete-the-middle-node-of-a-linked-list/DeleteTheMiddleNodeOfALinkedList.java

@@ -0,0 +1,27 @@
+/**
+ * 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 DeleteTheMiddleNodeOfALinkedList {
+    public ListNode deleteMiddle(ListNode head) {
+        if (head.next == null) return null;
+        int count = 0;
+        ListNode countList = head;
+        while (countList != null) {
+            count++;
+            countList = countList.next;
+        }
+        countList = head;
+        for (int i = 0; i < count / 2 - 1; i++) {
+            countList = countList.next;
+        }
+        countList.next = countList.next.next;
+        return head;
+    }
+}

2095.delete-the-middle-node-of-a-linked-list/README.md

@@ -0,0 +1 @@
+# [2095. Delete the Middle Node of a Linked List](https://leetcode.com/problems/delete-the-middle-node-of-a-linked-list/)

2131.longest-palindrome-by-concatenating-two-letter-words/LongestPalindromeByConcatenatingTwoLetterWords.java

@@ -0,0 +1,32 @@
+import java.util.HashMap;
+import java.util.Map;
+
+class LongestPalindromeByConcatenatingTwoLetterWords {
+    public int longestPalindrome(String[] words) {
+        Map<String, Integer> map = new HashMap<>();
+        int unpaired = 0, res = 0;
+        for (String word : words) {
+            if (!map.containsKey(word)) map.put(word, 0);
+            if (word.charAt(0) == word.charAt(1)) {
+                if (map.get(word) > 0) {
+                    unpaired--;
+                    map.put(word, map.get(word) - 1);
+                    res += 4;
+                } else {
+                    map.put(word, map.get(word) + 1);
+                    unpaired++;
+                }
+            } else {
+                String rev = Character.toString(word.charAt(1)) + Character.toString(word.charAt(0));
+                if (map.containsKey(rev) && map.get(rev) > 0) {
+                    res += 4;
+                    map.put(rev, map.get(rev) - 1);
+                } else {
+                    map.put(word, map.get(word) + 1);
+                }
+            }
+        }
+        if (unpaired > 0) res += 2;
+        return res;
+    }
+}

2131.longest-palindrome-by-concatenating-two-letter-words/README.md

@@ -0,0 +1,2 @@
+# [2131. Longest Palindrome by Concatenating Two Letter Words](https://leetcode.com/problems/longest-palindrome-by-concatenating-two-letter-words/)
+

2136.earliest-possible-day-of-full-bloom/EarliestPossibleDayOfFullBloom.java

@@ -0,0 +1,22 @@
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+
+class EarliestPossibleDayOfFullBloom {
+    public int earliestFullBloom(int[] plantTime, int[] growTime) {
+        int n = growTime.length;
+        List<Integer> indices = new ArrayList<>();
+        for (int i = 0; i < growTime.length; i++) {
+            indices.add(i);
+        }
+        indices.sort(Comparator.comparingInt(i -> -growTime[i]));
+        int result = 0;
+        for (int i = 0, currPlantTime = 0; i < n; i++) {
+            int index = indices.get(i);
+            int time = currPlantTime + plantTime[index] + growTime[index];
+            result = Math.max(result, time);
+            currPlantTime += plantTime[index];
+        }
+        return result;
+    }
+}

2136.earliest-possible-day-of-full-bloom/README.md

@@ -0,0 +1,2 @@
+# [2136. Earliest Possible Day of Full Bloom](https://leetcode.com/problems/earliest-possible-day-of-full-bloom/)
+