Add 3 problems

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 585 DSA problems from the [LeetCode](https://leetcode.com/)
+This repository contains solutions for 588 DSA problems from the [LeetCode](https://leetcode.com/)
 website.
 
 Problems are separated into 20 topics:
 
 |    | Topic               | Package                                        | Problems |
 |---:|:--------------------|:-----------------------------------------------|---------:|
-|  1 | Array               | [array](src/array)                             |       81 |
+|  1 | Array               | [array](src/array)                             |       83 |
 |  2 | Binary              | [binary](src/binary)                           |       13 |
 |  3 | Binary Search       | [binary_search](src/binary_search)             |       19 |
 |  4 | Binary Search Tree  | [binary_search_tree](src/binary_search_tree)   |       16 |
@@ -21,7 +21,7 @@ Problems are separated into 20 topics:
 | 10 | Heap                | [heap](src/heap)                               |       22 |
 | 11 | Interval            | [interval](src/interval)                       |       12 |
 | 12 | Linked List         | [linked_list](src/linked_list)                 |       34 |
-| 13 | Math                | [math](src/math)                               |       22 |
+| 13 | Math                | [math](src/math)                               |       23 |
 | 14 | Matrix              | [matrix](src/matrix)                           |       19 |
 | 15 | Quad Tree           | [quad_tree](src/quad_tree)                     |        1 |
 | 16 | Recursion           | [recursion](src/recursion)                     |       24 |

src/array/MakeArrayZeroBySubtractingEqualAmounts.java

@@ -0,0 +1,51 @@
+package array;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+
+/**
+ * Description: https://leetcode.com/problems/make-array-zero-by-subtracting-equal-amounts
+ * Difficulty: Easy
+ */
+public class MakeArrayZeroBySubtractingEqualAmounts {
+
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     */
+    public int minimumOperationsViaSet(int[] nums) {
+        Set<Integer> unique = new HashSet<>();
+        for (int num : nums) {
+            if (num != 0) unique.add(num);
+        }
+
+        return unique.size();
+    }
+
+    /**
+     * Time complexity: O(nlog n + n)
+     * Space complexity: O(log n)
+     */
+    public int minimumOperationsViaSorting(int[] nums) {
+        Arrays.sort(nums);
+
+        int current = 0;
+        int operations = 0;
+        int subtract = 0;
+        while (current < nums.length) {
+            int num = nums[current] - subtract;
+            if (num == 0) {
+                current++;
+                continue;
+            }
+
+            subtract += num;
+            operations++;
+
+            current++;
+        }
+
+        return operations;
+    }
+}

src/array/MaximumUnitsOnTruck.java

@@ -0,0 +1,34 @@
+package array;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Description: https://leetcode.com/problems/maximum-units-on-a-truck
+ * Difficulty: Easy
+ * Time complexity: O(nlog n)
+ * Space complexity: O(n)
+ */
+public class MaximumUnitsOnTruck {
+
+    public int maximumUnits(int[][] boxTypes, int truckSize) {
+        List<Box> boxes = new ArrayList<>();
+        for (int[] box : boxTypes) {
+            boxes.add(new Box(box[0], box[1]));
+        }
+        boxes.sort((a, b) -> Integer.compare(b.units, a.units));
+
+        int units = 0;
+        for (Box box : boxes) {
+            int number = Math.min(truckSize, box.number);
+            units += number * box.units;
+            truckSize -= number;
+
+            if (truckSize == 0) break;
+        }
+
+        return units;
+    }
+
+    private record Box(int number, int units) {}
+}

src/math/ExcelSheetColumnTitle.java

@@ -0,0 +1,21 @@
+package math;
+
+/**
+ * Description: https://leetcode.com/problems/excel-sheet-column-title
+ * Difficulty: Easy
+ * Time complexity: O(n)
+ * Space complexity: O(1)
+ */
+public class ExcelSheetColumnTitle {
+
+    public String convertToTitle(int col) {
+        StringBuilder converted = new StringBuilder();
+        while (col > 0) {
+            col--;
+            converted.append((char) (col % 26 + 'A'));
+            col = col / 26;
+        }
+
+        return converted.reverse().toString();
+    }
+}

src/string/FindKLengthSubstringsWithNoRepeatedCharacters.java

@@ -13,11 +13,15 @@
  */
 public class FindKLengthSubstringsWithNoRepeatedCharacters {
 
+    private static final int ALPHABET_SIZE = 26;
+
     public int numKLenSubstrNoRepeatsViaSet(String s, int k) {
-        Set<Character> seen = new HashSet<>();
+        if (k > ALPHABET_SIZE) return 0;
 
+        Set<Character> seen = new HashSet<>();
         int substrings = 0;
         int left = 0;
+
         for (int right = 0; right < s.length(); right++) {
             while (seen.contains(s.charAt(right))) {
                 seen.remove(s.charAt(left));
@@ -37,10 +41,12 @@ public int numKLenSubstrNoRepeatsViaSet(String s, int k) {
     }
 
     public int numKLenSubstrNoRepeatsViaFreqMap(String s, int k) {
-        Map<Character, Integer> freqMap = new HashMap<>();
+        if (k > ALPHABET_SIZE) return 0;
 
+        Map<Character, Integer> freqMap = new HashMap<>();
         int substrings = 0;
         int left = 0;
+
         for (int right = 0; right < s.length(); right++) {
             freqMap.merge(s.charAt(right), 1, Integer::sum);
             while (freqMap.get(s.charAt(right)) > 1) {