Solution is Added

Author: anjha1

1647.minimum-deletions-to-make-character-frequencies-unique/MinimumDeletionsToMakeCharacterFrequenciesUnique.java

@@ -0,0 +1,25 @@
+import java.util.HashSet;
+import java.util.Set;
+
+class MinimumDeletionsToMakeCharacterFrequenciesUnique {
+    public int minDeletions(String s) {
+        int[] freq = new int[26];
+        for (char c : s.toCharArray()) {
+            freq[c - 'a']++;
+        }
+        Set<Integer> set = new HashSet<>();
+        int deletions = 0;
+        for (int f : freq) {
+            if (f == 0) {
+                continue;
+            }
+            while (f > 0 && set.contains(f)) {
+                f--;
+                deletions++;
+            }
+            set.add(f);
+        }
+
+        return deletions;
+    }
+}

1647.minimum-deletions-to-make-character-frequencies-unique/README.md

@@ -0,0 +1,2 @@
+# [1647. Minimum Deletions to Make Character Frequencies Unique](https://leetcode.com/problems/minimum-deletions-to-make-character-frequencies-unique/)
+

1657.determine-if-two-strings-are-close/DetermineIfTwoStringsAreClose.java

@@ -0,0 +1,24 @@
+import java.util.Arrays;
+
+class DetermineIfTwoStringsAreClose {
+    public boolean closeStrings(String word1, String word2) {
+        if (word1.length() != word2.length())
+            return false;
+
+        int[] arr1 = new int[26];
+        int[] arr2 = new int[26];
+        for (int i = 0; i < word1.length(); i++) {
+            arr1[word1.charAt(i) - 'a']++;
+            arr2[word2.charAt(i) - 'a']++;
+        }
+
+        for (int i = 0; i < 26; i++) {
+            if ((arr1[i] == 0 && arr2[i] != 0) || (arr1[i] != 0 && arr2[i] == 0))
+                return false;
+        }
+
+        Arrays.sort(arr1);
+        Arrays.sort(arr2);
+        return Arrays.equals(arr1, arr2);
+    }
+}

1657.determine-if-two-strings-are-close/README.md

@@ -0,0 +1,7 @@
+# [1657. Determine if Two Strings Are Close](https://leetcode.com/problems/determine-if-two-strings-are-close/)
+
+
+Complexity Analysis:
+
+- Time Complexity: $O(n)$. $n$ is the length of input String.
+- Space Complexity: $O(1)$. We only use constant size of array. The input of sorting is constant as well. Thus, the total space complexity is $O(1)$.

1662.check-if-two-string-arrays-are-equivalent/CheckIfTwoStringArraysAreEquivalent.java

@@ -0,0 +1,5 @@
+class CheckIfTwoStringArraysAreEquivalent {
+    public boolean arrayStringsAreEqual(String[] word1, String[] word2) {
+        return String.join("", word1).equals(String.join("", word2));
+    }
+}

1662.check-if-two-string-arrays-are-equivalent/README.md

@@ -0,0 +1,2 @@
+# [1662. Check If Two String Arrays are Equivalent](https://leetcode.com/problems/check-if-two-string-arrays-are-equivalent/)
+

1675.minimize-deviation-in-array/MinimizeDeviationInArray.java

@@ -0,0 +1,18 @@
+import java.util.TreeSet;
+
+class MinimizeDeviationInArray {
+    public int minimumDeviation(int[] nums) {
+        TreeSet<Integer> set = new TreeSet<>();
+        for (int num : nums) {
+            set.add(num % 2 == 0 ? num : num * 2);
+        }
+        int res = set.last() - set.first();
+        while (res > 0 && set.last() % 2 == 0) {
+            int max = set.last();
+            set.remove(max);
+            set.add(max / 2);
+            res = Math.min(res, set.last() - set.first());
+        }
+        return res;
+    }
+}

1675.minimize-deviation-in-array/README.md

@@ -0,0 +1,7 @@
+# [1675. Minimize Deviation in Array](https://leetcode.com/problems/minimize-deviation-in-array/)
+
+
+Complexity Analysis:
+
+- Time Complexity: $O(n)$. $n$ is the length of `nums`.
+- Space Complexity: $O(n)$. We maintain at most $n$ numbers in the TreeSet.

1680.concatenation-of-consecutive-binary-numbers/ConcatenationOfConsecutiveBinaryNumbers.java

@@ -0,0 +1,16 @@
+class ConcatenationOfConsecutiveBinaryNumbers {
+    private final int modulo = (int) Math.pow(10, 9) + 7;
+
+    public int concatenatedBinary(int n) {
+        long res = 0;
+        for (int i = 0; i <= n; i++) {
+            int temp = i;
+            while (temp > 0) {
+                temp /= 2;
+                res *= 2;
+            }
+            res = (res + i) % modulo;
+        }
+        return (int) res;
+    }
+}

1680.concatenation-of-consecutive-binary-numbers/README.md

@@ -0,0 +1,2 @@
+# [1680. Concatenation of Consecutive Binary Numbers](https://leetcode.com/problems/concatenation-of-consecutive-binary-numbers/)
+

1689.partitioning-into-minimum-number-of-deci-binary-numbers/PartitioningIntoMinimumNumberOfDeciBinaryNumbers.java

@@ -0,0 +1,12 @@
+class PartitioningIntoMinimumNumberOfDeciBinaryNumbers {
+    public int minPartitions(String n) {
+        int m = 0;
+        char[] chars = n.toCharArray();
+        for (char c : chars) {
+            if (c - '0' > m) {
+                m = c - '0';
+            }
+        }
+        return m;
+    }
+}

1689.partitioning-into-minimum-number-of-deci-binary-numbers/README.md

@@ -0,0 +1,2 @@
+# [1689. Partitioning Into Minimum Number Of Deci-Binary Numbers](https://leetcode.com/problems/partitioning-into-minimum-number-of-deci-binary-numbers/)
+

1696.jump-game-vi/JumpGameVi.java

@@ -0,0 +1,22 @@
+import java.util.PriorityQueue;
+import java.util.Queue;
+
+class JumpGameVi {
+    public int maxResult(int[] nums, int k) {
+        if (nums.length == 0) return 0;
+        Queue<int[]> pq = new PriorityQueue<>((a, b) -> (b[0] - a[0]));
+        pq.offer(new int[]{nums[0], 0});
+
+        int max = nums[0];
+
+        for (int i = 1; i < nums.length; i++) {
+            while(pq.peek()[1] < i - k) {
+                pq.poll();
+            }
+            int[] cur = pq.peek();
+            max = cur[0] + nums[i];
+            pq.offer(new int[]{max, i});
+        }
+        return max;
+    }
+}

1696.jump-game-vi/README.md

@@ -0,0 +1,2 @@
+# [1696. Jump Game VI](https://leetcode.com/problems/jump-game-vi/)
+

1704.determine-if-string-halves-are-alike/DetermineIfStringHalvesAreAlike.java

@@ -0,0 +1,15 @@
+class DetermineIfStringHalvesAreAlike {
+    public boolean halvesAreAlike(String s) {
+        String left = s.substring(0, s.length() / 2);
+        String right = s.substring(s.length() / 2);
+        String v = "aeiouAEIOU";
+        int leftSum = 0, rightSum = 0;
+        for (int i = 0; i < left.length(); i++)
+            if (v.indexOf(left.charAt(i)) >= 0)
+                leftSum++;
+        for (int i = 0; i < right.length(); i++)
+            if (v.indexOf(right.charAt(i)) >= 0)
+                rightSum++;
+        return leftSum == rightSum;
+    }
+}

1704.determine-if-string-halves-are-alike/README.md

@@ -0,0 +1,7 @@
+# [1704. Determine if String Halves Are Alike](https://leetcode.com/problems/determine-if-string-halves-are-alike/)
+
+
+Complexity Analysis:
+
+- Time Complexity: $O(n)$. $n$ is the length of $s$.
+- Space Complexity: $O(n)$. The space complexity for left and right are $O(n)$.

1706.where-will-the-ball-fall/README.md

@@ -0,0 +1,2 @@
+# [1706. Where Will the Ball Fall](https://leetcode.com/problems/where-will-the-ball-fall/)
+

1706.where-will-the-ball-fall/WhereWillTheBallFall.java

@@ -0,0 +1,19 @@
+class WhereWillTheBallFall {
+    public int[] findBall(int[][] grid) {
+        int n = grid[0].length;
+        int[] res = new int[n];
+        for (int i = 0; i < n; i++) {
+            int i1 = i, i2;
+            for (int[] ints : grid) {
+                i2 = i1 + ints[i1];
+                if (i2 < 0 || i2 >= n || ints[i2] != ints[i1]) {
+                    i1 = -1;
+                    break;
+                }
+                i1 = i2;
+            }
+            res[i] = i1;
+        }
+        return res;
+    }
+}

1710.maximum-units-on-a-truck/MaximumUnitsOnATruck.java

@@ -0,0 +1,20 @@
+import java.util.Arrays;
+
+class MaximumUnitsOnATruck {
+    public int maximumUnits(int[][] boxTypes, int truckSize) {
+        Arrays.sort(boxTypes, (a, b) -> b[1] - a[1]);
+
+        int units = 0;
+        for (int[] box : boxTypes) {
+            if (box[0] >= truckSize) {
+                units += truckSize * box[1];
+                break;
+            } else {
+                units += box[0] * box[1];
+                truckSize -= box[0];
+            }
+        }
+
+        return units;
+    }
+}

1710.maximum-units-on-a-truck/README.md

@@ -0,0 +1,2 @@
+# [1710. Maximum Units on a Truck](https://leetcode.com/problems/maximum-units-on-a-truck/)
+