Update

Author: ex01tus

src/array/FindAnagramMappings.java

@@ -0,0 +1,27 @@
+package array;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Description: https://leetcode.com/problems/find-anagram-mappings
+ * Difficulty: Easy
+ * Time complexity: O(n)
+ * Space complexity: O(n)
+ */
+public class FindAnagramMappings {
+
+    public int[] anagramMappings(int[] nums1, int[] nums2) {
+        Map<Integer, Integer> numToIndex = new HashMap<>();
+        for (int i = 0; i < nums2.length; i++) {
+            numToIndex.put(nums2[i], i);
+        }
+
+        int[] mappings = new int[nums1.length];
+        for (int i = 0; i < nums1.length; i++) {
+            mappings[i] = numToIndex.get(nums1[i]);
+        }
+
+        return mappings;
+    }
+}

src/array/HowManyApplesCanYouPutIntoTheBasket.java

@@ -0,0 +1,26 @@
+package array;
+
+import java.util.Arrays;
+
+/**
+ * Description: https://leetcode.com/problems/how-many-apples-can-you-put-into-the-basket
+ * Difficulty: Easy
+ * Time complexity: O(nlog n)
+ * Space complexity: O(log n)
+ */
+public class HowManyApplesCanYouPutIntoTheBasket {
+
+    public int maxNumberOfApples(int[] weight) {
+        Arrays.sort(weight);
+
+        int count = 0;
+        int total = 0;
+        for (int apple : weight) {
+            total += apple;
+            if (total > 5000) return count;
+            count++;
+        }
+
+        return count;
+    }
+}

src/array/KRadiusSubarrayAverages.java

@@ -0,0 +1,35 @@
+package array;
+
+import java.util.Arrays;
+
+/**
+ * Description: https://leetcode.com/problems/k-radius-subarray-averages
+ * Difficulty: Medium
+ * Time complexity: O(n)
+ * Space complexity: O(1)
+ */
+public class KRadiusSubarrayAverages {
+
+    public int[] getAverages(int[] nums, int k) {
+        int[] averages = new int[nums.length];
+        Arrays.fill(averages, -1);
+        if (2 * k + 1 > nums.length) return averages;
+
+        long sum = 0L;
+        int left = 0;
+        for (int right = 0; right < nums.length; right++) {
+            sum += nums[right];
+
+            if (right > k * 2) {
+                sum -= nums[left];
+                left++;
+            }
+
+            if (right >= k * 2) {
+                averages[right - k] = (int) (sum / (k * 2 + 1));
+            }
+        }
+
+        return averages;
+    }
+}

src/array/MajorityElement2.java

@@ -44,7 +44,7 @@ public List<Integer> majorityElementViaMooreAlgo(int[] nums) {
         return checkCandidatesFrequency(nums, candidate1, candidate2);
     }
 
-    private static List<Integer> checkCandidatesFrequency(int[] nums, int candidate1, int candidate2) {
+    private List<Integer> checkCandidatesFrequency(int[] nums, int candidate1, int candidate2) {
         int count1 = 0;
         int count2 = 0;
 

src/binary/MinimumFlipsToMakeAOrBEqualToC.java

@@ -0,0 +1,34 @@
+package binary;
+
+/**
+ * Description: https://leetcode.com/problems/minimum-flips-to-make-a-or-b-equal-to-c
+ * Difficulty: Medium
+ * Time complexity: O(n)
+ * Space complexity: O(1)
+ */
+public class MinimumFlipsToMakeAOrBEqualToC {
+
+    public int minFlips(int a, int b, int c) {
+        int flips = 0;
+        while (a != 0 || b != 0 || c != 0) {
+            int aBit = (a & 1);
+            int bBit = (b & 1);
+            int cBit = (c & 1);
+
+            if ((aBit | bBit) != cBit) {
+                if (cBit == 1) {
+                    flips += 1;
+                } else {
+                    flips += (aBit == 1) ? 1 : 0;
+                    flips += (bBit == 1) ? 1 : 0;
+                }
+            }
+
+            a >>= 1;
+            b >>= 1;
+            c >>= 1;
+        }
+
+        return flips;
+    }
+}

src/binary_search/CheckIfNumberIsMajorityElementInSortedArray.java

@@ -0,0 +1,36 @@
+package binary_search;
+
+/**
+ * Description: https://leetcode.com/problems/check-if-a-number-is-majority-element-in-a-sorted-array
+ * Difficulty: Easy
+ * Time complexity: O(log n)
+ * Space complexity: O(1)
+ */
+public class CheckIfNumberIsMajorityElementInSortedArray {
+
+    public boolean isMajorityElement(int[] nums, int target) {
+        int firstOccurrence = findFirstOccurrence(nums, target);
+        return firstOccurrence + nums.length / 2 < nums.length
+                && nums[firstOccurrence + nums.length / 2] == target;
+    }
+
+    private int findFirstOccurrence(int[] nums, int target) {
+        int left = 0;
+        int right = nums.length - 1;
+
+        int min = 0;
+        while (left <= right) {
+            int mid = left + (right - left) / 2;
+            if (nums[mid] < target) {
+                left = mid + 1;
+            } else if (nums[mid] > target) {
+                right = mid - 1;
+            } else {
+                min = mid;
+                right = mid - 1;
+            }
+        }
+
+        return min;
+    }
+}

src/binary_search/FixedPoint.java

@@ -0,0 +1,30 @@
+package binary_search;
+
+/**
+ * Description: https://leetcode.com/problems/fixed-point
+ * Difficulty: Easy
+ * Time complexity: O(log n)
+ * Space complexity: O(1)
+ */
+public class FixedPoint {
+
+    public int fixedPoint(int[] arr) {
+        int left = 0;
+        int right = arr.length - 1;
+
+        int min = -1;
+        while (left <= right) {
+            int mid = left + (right - left) / 2;
+            if (arr[mid] > mid) {
+                right = mid - 1;
+            } else if (arr[mid] < mid) {
+                left = mid + 1;
+            } else {
+                min = mid;
+                right = mid - 1;
+            }
+        }
+
+        return min;
+    }
+}

src/binary_search_tree/ClosestBinarySearchTreeValue.java

@@ -0,0 +1,40 @@
+package binary_search_tree;
+
+import java.util.Deque;
+import java.util.LinkedList;
+
+/**
+ * Description: https://leetcode.com/problems/closest-binary-search-tree-value
+ * Difficulty: Easy
+ * Time complexity: O(n)
+ * Space complexity: O(n)
+ */
+public class ClosestBinarySearchTreeValue {
+
+    public int closestValueViaInorderTraversal(TreeNode root, double target) {
+        int predecessor = Integer.MIN_VALUE;
+        Deque<TreeNode> stack = new LinkedList<>();
+        while (root != null || !stack.isEmpty()) {
+            if (root != null) {
+                stack.push(root);
+                root = root.left;
+            } else {
+                root = stack.pop();
+                if (predecessor <= target && target <= root.val) {
+                    return Math.abs(predecessor - target) <= Math.abs(root.val - target) ? predecessor : root.val;
+                }
+
+                predecessor = root.val;
+                root = root.right;
+            }
+        }
+
+        return predecessor;
+    }
+
+    private static class TreeNode {
+        int val;
+        TreeNode left;
+        TreeNode right;
+    }
+}

src/design/LoggerRateLimiter.java

@@ -0,0 +1,33 @@
+package design;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Description: https://leetcode.com/problems/logger-rate-limiter
+ * Difficulty: Easy
+ * Time complexity: O(1)
+ * Space complexity: O(n)
+ */
+public class LoggerRateLimiter {
+
+    private static final int RATE_LIMIT_INTERVAL_SEC = 10;
+
+    private static class Logger {
+
+        private final Map<String, Integer> lastPrinted;
+
+        public Logger() {
+            this.lastPrinted = new HashMap<>();
+        }
+
+        public boolean shouldPrintMessage(int timestamp, String message) {
+            if (lastPrinted.getOrDefault(message, -RATE_LIMIT_INTERVAL_SEC) + RATE_LIMIT_INTERVAL_SEC <= timestamp) {
+                lastPrinted.put(message, timestamp);
+                return true;
+            }
+
+            return false;
+        }
+    }
+}

src/greedy/Candy.java

@@ -0,0 +1,74 @@
+package greedy;
+
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.PriorityQueue;
+import java.util.Queue;
+
+/**
+ * Description: https://leetcode.com/problems/candy
+ * Difficulty: Hard
+ */
+public class Candy {
+
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     */
+    public int candyViaTwoPasses(int[] ratings) {
+        int[] candies = new int[ratings.length];
+        Arrays.fill(candies, 1);
+
+        // go right and make sure each child with higher rating has more candies than his left neighbor
+        for (int i = 1; i < ratings.length; i++) {
+            if (ratings[i] > ratings[i - 1]) candies[i] = candies[i - 1] + 1;
+        }
+
+        // go left and make sure each child with higher rating has more candies than his right neighbor
+        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);
+        }
+
+        // count the total number of candies
+        int total = 0;
+        for (int candy : candies) {
+            total += candy;
+        }
+
+        return total;
+    }
+
+    /**
+     * Time complexity: O(nlog n)
+     * Space complexity: O(n)
+     */
+    public int candyViaMinHeap(int[] ratings) {
+        Queue<Child> minHeap = new PriorityQueue<>(Comparator.comparingInt(c -> c.rating));
+        for (int i = 0; i < ratings.length; i++) {
+            minHeap.offer(new Child(ratings[i], i));
+        }
+
+        int[] candies = new int[ratings.length];
+        Arrays.fill(candies, 1);
+
+        int total = 0;
+        while (!minHeap.isEmpty()) {
+            int current = minHeap.poll().index;
+
+            if (current > 0 && ratings[current - 1] < ratings[current]) {
+                candies[current] = candies[current - 1] + 1;
+            }
+
+            if (current < ratings.length - 1 && ratings[current + 1] < ratings[current]) {
+                candies[current] = Math.max(candies[current], candies[current + 1] + 1);
+            }
+
+            total += candies[current];
+        }
+
+        return total;
+    }
+
+    private record Child(int rating, int index) {
+    }
+}

src/greedy/Dota2Senate.java

@@ -0,0 +1,40 @@
+package greedy;
+
+import java.util.LinkedList;
+import java.util.Queue;
+
+/**
+ * Description: https://leetcode.com/problems/dota2-senate
+ * Difficulty: Medium
+ * Time complexity: O(nlog n)
+ * Space complexity: O(n)
+ */
+public class Dota2Senate {
+
+    public String predictPartyVictory(String senate) {
+        Queue<Integer> radiant = new LinkedList<>();
+        Queue<Integer> dire = new LinkedList<>();
+        for (int i = 0; i < senate.length(); i++) {
+            if (senate.charAt(i) == 'R') {
+                radiant.offer(i);
+            } else {
+                dire.offer(i);
+            }
+        }
+
+        while (!radiant.isEmpty() && !dire.isEmpty()) {
+            int radiantSenator = radiant.poll();
+            int direSenator = dire.poll();
+
+            // the one with the larger index is BANNED by the one with the smaller one
+            if (radiantSenator > direSenator) {
+                // make sure this senator won't vote again in the same round
+                dire.offer(direSenator + senate.length());
+            } else {
+                radiant.offer(radiantSenator + senate.length());
+            }
+        }
+
+        return radiant.isEmpty() ? "Dire" : "Radiant";
+    }
+}