Update

Author: ex01tus

src/array/AverageSalaryExcludingTheMinimumAndMaximumSalary.java

@@ -0,0 +1,24 @@
+package array;
+
+/**
+ * Description: https://leetcode.com/problems/average-salary-excluding-the-minimum-and-maximum-salary
+ * Difficulty: Easy
+ * Time complexity: O(n)
+ * Space complexity: O(1)
+ */
+public class AverageSalaryExcludingTheMinimumAndMaximumSalary {
+
+    public double average(int[] salaries) {
+        int min = Integer.MAX_VALUE;
+        int max = Integer.MIN_VALUE;
+        int sum = 0;
+
+        for (int salary : salaries) {
+            min = Math.min(min, salary);
+            max = Math.max(max, salary);
+            sum += salary;
+        }
+
+        return (double) (sum - min - max) / (salaries.length - 2);
+    }
+}

src/array/FindTheDifferenceOfTwoArrays.java

@@ -0,0 +1,42 @@
+package array;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * Description: https://leetcode.com/problems/find-the-difference-of-two-arrays
+ * Difficulty: Easy
+ * Time complexity: O(m + n)
+ * Space complexity: O(m + n)
+ */
+public class FindTheDifferenceOfTwoArrays {
+
+    public static void main(String[] args) {
+        int n = 5;
+        int times = n / 4 + (n % 4 == 0 ? 0 : 1);
+        System.out.println(times);
+    }
+
+    public List<List<Integer>> findDifference(int[] nums1, int[] nums2) {
+        Set<Integer> set2 = new HashSet<>();
+        for (int num : nums2) {
+            set2.add(num);
+        }
+
+        Set<Integer> set1 = new HashSet<>();
+        List<Integer> result1 = new ArrayList<>();
+        for (int num : nums1) {
+            set1.add(num);
+            if (set2.add(num)) result1.add(num);
+        }
+
+        List<Integer> result2 = new ArrayList<>();
+        for (int num : nums2) {
+            if (set1.add(num)) result2.add(num);
+        }
+
+        return List.of(result1, result2);
+    }
+}

src/array/FindWinnerOfTheCircularGame.java

@@ -0,0 +1,55 @@
+package array;
+
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Queue;
+
+/**
+ * Description: https://leetcode.com/problems/find-the-winner-of-the-circular-game
+ * Difficulty: Medium
+ */
+public class FindWinnerOfTheCircularGame {
+
+    /**
+     * Time complexity: O(n * k)
+     * Space complexity: O(n)
+     */
+    public int findTheWinnerViaQueue(int n, int k) {
+        Queue<Integer> players = new LinkedList<>();
+        for (int i = 0; i < n; i++) {
+            players.offer(i);
+        }
+
+        while (players.size() > 1) {
+            int looser = (k - 1) % players.size();
+            for (int i = 0; i < looser; i++) {
+                players.offer(players.poll()); // "rotate" players
+            }
+
+            players.poll(); // remove looser
+        }
+
+        return players.poll() + 1;
+    }
+
+    /**
+     * Time complexity: O(n^2)
+     * Space complexity: O(n)
+     */
+    public int findTheWinner(int n, int k) {
+        List<Integer> players = new ArrayList<>();
+        for (int player = 0; player < n; player++) {
+            players.add(player);
+        }
+
+        int current = 0;
+        while (players.size() > 1) {
+            int looser = (current + k - 1) % players.size();
+            players.remove(looser); // takes O(n) time
+            current = looser;
+        }
+
+        return players.get(0) + 1;
+    }
+}

src/array/FourSum.java

@@ -0,0 +1,40 @@
+package array;
+
+import java.util.*;
+
+/**
+ * Description: https://leetcode.com/problems/4sum
+ * Difficulty: Medium
+ * Time complexity: O(n^3)
+ * Space complexity: O(n)
+ */
+public class FourSum {
+
+    public List<List<Integer>> fourSum(int[] nums, int target) {
+        Arrays.sort(nums);
+
+        Set<List<Integer>> result = new HashSet<>();
+        for (int i = 0; i < nums.length; i++) {
+            for (int j = i + 1; j < nums.length - 2; j++) {
+                int left = j + 1;
+                int right = nums.length - 1;
+                long localTarget = (long) target - nums[i] - nums[j];
+
+                while (left < right) {
+                    long sum = nums[left] + nums[right];
+                    if (sum == localTarget) {
+                        result.add(List.of(nums[i], nums[j], nums[left], nums[right]));
+                        left++;
+                        right--;
+                    } else if (sum > localTarget) {
+                        right--;
+                    } else {
+                        left++;
+                    }
+                }
+            }
+        }
+
+        return new ArrayList<>(result);
+    }
+}

src/array/FruitIntoBaskets.java

@@ -0,0 +1,36 @@
+package array;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Description: https://leetcode.com/problems/fruit-into-baskets
+ * Difficulty: Medium
+ * Time complexity: O(n)
+ * Space complexity: O(1)
+ */
+public class FruitIntoBaskets {
+
+    public int totalFruit(int[] fruits) {
+        int left = 0;
+        int right = 0;
+
+        Map<Integer, Integer> basket = new HashMap<>();
+        int max = 0;
+        while (right < fruits.length) {
+            basket.merge(fruits[right], 1, Integer::sum);
+
+            // shrink the window from the left
+            while (basket.size() > 2) {
+                int count = basket.merge(fruits[left], -1, Integer::sum);
+                if (count == 0) basket.remove(fruits[left]);
+                left++;
+            }
+
+            max = Math.max(max, right - left + 1);
+            right++;
+        }
+
+        return max;
+    }
+}

src/array/MaximumSizeSubarraySumEqualsK.java

@@ -24,9 +24,7 @@ public int maxSubArrayLen(int[] nums, int k) {
                 maxLength = Math.max(maxLength, i - prefixSum.get(sum - k));
             }
 
-            if (!prefixSum.containsKey(sum)) {
-                prefixSum.put(sum, i);
-            }
+            prefixSum.putIfAbsent(sum, i);
         }
 
         return maxLength;

src/array/NumberOfSubsequencesThatSatisfyTheGivenSumCondition.java

@@ -0,0 +1,46 @@
+package array;
+
+import java.util.Arrays;
+
+/**
+ * Description: https://leetcode.com/problems/number-of-subsequences-that-satisfy-the-given-sum-condition
+ * Difficulty: Medium
+ * Time complexity: O(nlog n)
+ * Space complexity: O(n)
+ */
+public class NumberOfSubsequencesThatSatisfyTheGivenSumCondition {
+
+    // since the answer may be too large, return it modulo 10^9 + 7
+    private static final int MOD = 1_000_000_007;
+
+    public int numSubseq(int[] nums, int target) {
+        Arrays.sort(nums);
+        int[] powersOfTwo = precomputePowers(nums);
+        int result = 0;
+
+        int left = 0;
+        int right = nums.length - 1;
+        while (left <= right) {
+            if (nums[left] + nums[right] <= target) {
+                // all possible subsequences in [left + 1; right]
+                result += powersOfTwo[right - left];
+                result %= MOD;
+                left++;
+            } else {
+                right--;
+            }
+        }
+
+        return result;
+    }
+
+    private int[] precomputePowers(int[] nums) {
+        int[] powers = new int[nums.length];
+        powers[0] = 1;
+        for (int i = 1; i < nums.length; ++i) {
+            powers[i] = (powers[i - 1] * 2) % MOD;
+        }
+
+        return powers;
+    }
+}

src/array/PancakeSorting.java

@@ -0,0 +1,53 @@
+package array;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Description: https://leetcode.com/problems/pancake-sorting
+ * Difficulty: Medium
+ * Time complexity: O(n^2)
+ * Space complexity: O(n)
+ */
+public class PancakeSorting {
+
+    public List<Integer> pancakeSort(int[] arr) {
+        List<Integer> flips = new ArrayList<>();
+        for (int current = arr.length; current > 0; current--) {
+            int index = find(arr, current);
+            if (index == current - 1) continue; // already in place
+
+            if (index != 0) {
+                // flip to the head
+                flips.add(index + 1);
+                flip(arr, index + 1);
+            }
+
+            // flip to the tail
+            flips.add(current);
+            flip(arr, current);
+        }
+
+        return flips;
+    }
+
+    private void flip(int[] arr, int index) {
+        for (int i = 0; i < index / 2; i++) {
+            swap(arr, i, index - i - 1);
+        }
+    }
+
+    private void swap(int[] arr, int i, int j) {
+        int tmp = arr[i];
+        arr[i] = arr[j];
+        arr[j] = tmp;
+    }
+
+    private int find(int[] arr, int val) {
+        for (int i = 0; i < arr.length; i++) {
+            if (arr[i] == val) return i;
+        }
+
+        return -1;
+    }
+}

src/array/PrisonCellAfterNDays.java

@@ -0,0 +1,59 @@
+package array;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Description: https://leetcode.com/problems/prison-cells-after-n-days
+ * Difficulty: Medium
+ * Time complexity: O(cells * min(days, 2^cells))
+ * Space complexity: O(min(days, 2^cells))
+ */
+public class PrisonCellAfterNDays {
+
+    public int[] prisonAfterNDays(int[] cells, int days) {
+        Map<Integer, Integer> stateToDayCache = new HashMap<>();
+        boolean isFastForwarded = false;
+        while (days > 0) {
+            if (!isFastForwarded) {
+                int currentState = buildState(cells);
+                if (stateToDayCache.containsKey(currentState)) {
+                    // pattern (cycle) was found -> fast forward
+                    days = days % (stateToDayCache.get(currentState) - days);
+                    isFastForwarded = true;
+                } else {
+                    stateToDayCache.put(currentState, days);
+                }
+            }
+
+            if (days > 0) {
+                cells = nextDay(cells);
+                days--;
+            }
+        }
+
+        return cells;
+    }
+
+    private int[] nextDay(int[] prevDay) {
+        int[] nextDay = new int[prevDay.length];
+        nextDay[0] = 0;
+        nextDay[nextDay.length - 1] = 0;
+
+        for (int cell = 1; cell < nextDay.length - 1; cell++) {
+            nextDay[cell] = prevDay[cell - 1] == prevDay[cell + 1] ? 1 : 0;
+        }
+
+        return nextDay;
+    }
+
+    private int buildState(int[] cells) {
+        int state = 0;
+        for (int cell : cells) {
+            state = state << 1;
+            state = state | cell;
+        }
+
+        return state;
+    }
+}