Update

Author: ex01tus

README.md

@@ -2,14 +2,14 @@
 
 ![DSA Learning](https://img.shields.io/badge/DSA-Learning-blue?style=for-the-badge&logo=leetcode)
 
-This repository contains solutions for 530 DSA problems from the [LeetCode](https://leetcode.com/)
+This repository contains solutions for 534 DSA problems from the [LeetCode](https://leetcode.com/)
 website.
 
 Problems are separated into 19 topics:
 
 |    | Topic               | Package                                        | Problems |
 |---:|:--------------------|:-----------------------------------------------|---------:|
-|  1 | Array               | [array](src/array)                             |       74 |
+|  1 | Array               | [array](src/array)                             |       76 |
 |  2 | Binary              | [binary](src/binary)                           |       13 |
 |  3 | Binary Search       | [binary_search](src/binary_search)             |       18 |
 |  4 | Binary Search Tree  | [binary_search_tree](src/binary_search_tree)   |       16 |
@@ -18,7 +18,7 @@ Problems are separated into 19 topics:
 |  7 | Dynamic Programming | [dynamic_programming](src/dynamic_programming) |       48 |
 |  8 | Graph               | [graph](src/graph)                             |       65 |
 |  9 | Greedy Algorithms   | [greedy](src/greedy)                           |       21 |
-| 10 | Heap                | [heap](src/heap)                               |       19 |
+| 10 | Heap                | [heap](src/heap)                               |       21 |
 | 11 | Interval            | [interval](src/interval)                       |       11 |
 | 12 | Linked List         | [linked_list](src/linked_list)                 |       32 |
 | 13 | Math                | [math](src/math)                               |       20 |

src/array/BinarySubarraysWithSum.java

@@ -0,0 +1,31 @@
+package array;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Description: https://leetcode.com/problems/binary-subarrays-with-sum
+ * Difficulty: Medium
+ * Time complexity: O(n)
+ * Space complexity: O(n)
+ */
+public class BinarySubarraysWithSum {
+
+    public int numSubarraysWithSum(int[] nums, int goal) {
+        Map<Integer, Integer> prefixSum = new HashMap<>();
+
+        int count = 0;
+        int currentSum = 0;
+        for (int num : nums) {
+            currentSum += num;
+
+            int currentSubarray = currentSum == goal ? 1 : 0;
+            int prevSubarrays = prefixSum.getOrDefault(currentSum - goal, 0);
+
+            count += currentSubarray + prevSubarrays;
+            prefixSum.merge(currentSum, 1, Integer::sum);
+        }
+
+        return count;
+    }
+}

src/array/CountNumberOfNiceSubarrays.java

@@ -0,0 +1,60 @@
+package array;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Description: https://leetcode.com/problems/count-number-of-nice-subarrays
+ * Difficulty: Medium
+ */
+public class CountNumberOfNiceSubarrays {
+
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     */
+    public int numberOfSubarraysViaPrefixSum(int[] nums, int k) {
+        Map<Integer, Integer> prefixSum = new HashMap<>();
+
+        int count = 0;
+        int currentSum = 0;
+        for (int num : nums) {
+            currentSum += (num % 2 == 0) ? 0 : 1;
+
+            int currentSubarray = currentSum == k ? 1 : 0;
+            int prevSubarray = prefixSum.getOrDefault(currentSum - k, 0);
+
+            count += currentSubarray + prevSubarray;
+            prefixSum.merge(currentSum, 1, Integer::sum);
+        }
+
+        return count;
+    }
+
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(1)
+     */
+    public int numberOfSubarraysViaTwoPointers(int[] nums, int k) {
+        int left = 0;
+        int count = 0;
+        int subarraysSoFar = 0;
+
+        for (int right = 0; right < nums.length; right++) {
+            if (nums[right] % 2 != 0) {
+                k--;
+                subarraysSoFar = 0; // new odd found -> reset the counter
+            }
+
+            while (k == 0) {
+                k += nums[left] == 1 ? 1 : 0;
+                subarraysSoFar++;
+                left++;
+            }
+
+            count += subarraysSoFar;
+        }
+
+        return count;
+    }
+}

src/heap/LeastNumberOfUniqueIntegersAfterKRemovals.java

@@ -0,0 +1,66 @@
+package heap;
+
+import java.util.*;
+
+/**
+ * Description: https://leetcode.com/problems/least-number-of-unique-integers-after-k-removals
+ * Difficulty: Medium
+ * Time complexity: O(nlog n)
+ * Space complexity: O(n)
+ */
+public class LeastNumberOfUniqueIntegersAfterKRemovals {
+
+    public int findLeastNumOfUniqueIntsViaMinHeap(int[] arr, int k) {
+        Map<Integer, Integer> freqMap = buildFreqMap(arr);
+        Queue<Map.Entry<Integer, Integer>> minHeap = buildHeap(freqMap);
+
+        while (k > 0) {
+            k -= minHeap.poll().getValue();
+        }
+
+        return k < 0 ? minHeap.size() + 1 : minHeap.size();
+    }
+
+    private Queue<Map.Entry<Integer, Integer>> buildHeap(Map<Integer, Integer> freqMap) {
+        Queue<Map.Entry<Integer, Integer>> minHeap = new PriorityQueue<>(
+                Comparator.comparingInt(Map.Entry::getValue));
+        for (Map.Entry<Integer, Integer> e : freqMap.entrySet()) {
+            minHeap.offer(e);
+        }
+        return minHeap;
+    }
+
+    public int findLeastNumOfUniqueIntsViaSorting(int[] arr, int k) {
+        Map<Integer, Integer> freqMap = buildFreqMap(arr);
+        List<Integer> sortedByFreq = getNumbersSortedByFreq(freqMap);
+
+        int pointer = 0;
+        int removed = 0;
+        while (k > 0 && pointer < sortedByFreq.size()) {
+            int num = sortedByFreq.get(pointer);
+            k -= freqMap.get(num);
+
+            if (k >= 0) removed++;
+
+            pointer++;
+        }
+
+        return sortedByFreq.size() - removed;
+    }
+
+    private Map<Integer, Integer> buildFreqMap(int[] arr) {
+        Map<Integer, Integer> freqMap = new HashMap<>();
+        for (int num : arr) {
+            freqMap.merge(num, 1, Integer::sum);
+        }
+
+        return freqMap;
+    }
+
+    private List<Integer> getNumbersSortedByFreq(Map<Integer, Integer> freqMap) {
+        return new ArrayList<>(freqMap.entrySet()).stream()
+                .sorted(Comparator.comparing(Map.Entry::getValue))
+                .map(Map.Entry::getKey)
+                .toList();
+    }
+}

src/heap/RewardTopKStudents.java

@@ -0,0 +1,69 @@
+package heap;
+
+import java.util.*;
+
+/**
+ * Description: https://leetcode.com/problems/reward-top-k-students
+ * Difficulty: Medium
+ * Time complexity: O(nlog n)
+ * Space complexity: O(n)
+ */
+public class RewardTopKStudents {
+
+    public List<Integer> topStudents(
+            String[] positiveFeedback,
+            String[] negativeFeedback,
+            String[] reports,
+            int[] studentIds,
+            int k) {
+        Set<String> positive = new HashSet<>(Arrays.asList(positiveFeedback));
+        Set<String> negative = new HashSet<>(Arrays.asList(negativeFeedback));
+        Queue<Student> maxHeap = buildHeap(studentIds, reports, positive, negative);
+
+        return getTopK(maxHeap, k);
+    }
+
+    private List<Integer> getTopK(Queue<Student> maxHeap, int k) {
+        List<Integer> topK = new ArrayList<>();
+        while (k > 0) {
+            topK.add(maxHeap.poll().id);
+            k--;
+        }
+
+        return topK;
+    }
+
+    private Queue<Student> buildHeap(
+            int[] studentIds,
+            String[] reports,
+            Set<String> positive,
+            Set<String> negative) {
+        Queue<Student> maxHeap = new PriorityQueue<>(
+                Comparator.comparing(Student::points).reversed().thenComparing(Student::id));
+
+        for (int i = 0; i < studentIds.length; i++) {
+            int points = countPoints(reports[i], positive, negative);
+            maxHeap.offer(new Student(studentIds[i], points));
+        }
+
+        return maxHeap;
+    }
+
+    private int countPoints(String report, Set<String> positive, Set<String> negative) {
+        String[] words = report.split(" ");
+
+        int points = 0;
+        for (String word : words) {
+            if (positive.contains(word)) {
+                points += 3;
+            } else if (negative.contains(word)) {
+                points -= 1;
+            }
+        }
+
+        return points;
+    }
+
+    private record Student(int id, int points) {
+    }
+}