Update

Author: ex01tus

src/array/CanMakeArithmeticProgressionFromSequence.java

@@ -0,0 +1,53 @@
+package array;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+
+/**
+ * Description: https://leetcode.com/problems/can-make-arithmetic-progression-from-sequence
+ * Difficulty: Easy
+ */
+public class CanMakeArithmeticProgressionFromSequence {
+
+    /**
+     * Time complexity: O(nlog n)
+     * Space complexity: O(log n)
+     */
+    public boolean canMakeArithmeticProgressionViaSorting(int[] arr) {
+        Arrays.sort(arr);
+
+        int diff = arr[1] - arr[0];
+        for (int i = 2; i < arr.length; i++) {
+            if (arr[i] - arr[i - 1] != diff) return false;
+        }
+
+        return true;
+    }
+
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     */
+    public boolean canMakeArithmeticProgressionViaSet(int[] arr) {
+        int min = Integer.MAX_VALUE;
+        int max = Integer.MIN_VALUE;
+
+        for (int num : arr) {
+            min = Math.min(min, num);
+            max = Math.max(max, num);
+        }
+
+        if (max == min) return true; // all elements are equal
+        if ((max - min) % (arr.length - 1) != 0) return false;
+
+        int diff = (max - min) / (arr.length - 1);
+        Set<Integer> seen = new HashSet<>();
+        for (int num : arr) {
+            if (!seen.add(num)) return false; // contains duplicates
+            if ((max - num) % diff != 0) return false;
+        }
+
+        return true;
+    }
+}

src/array/MaxConsecutiveOnes.java

@@ -0,0 +1,26 @@
+package array;
+
+/**
+ * Description: https://leetcode.com/problems/max-consecutive-ones
+ * Difficulty: Easy
+ * Time complexity: O(n)
+ * Space complexity: O(1)
+ */
+public class MaxConsecutiveOnes {
+
+    public int findMaxConsecutiveOnes(int[] nums) {
+        int count = 0;
+        int max = 0;
+
+        for (int num : nums) {
+            if (num == 1) {
+                max = Math.max(max, count);
+                count++;
+            } else {
+                count = 0;
+            }
+        }
+
+        return max;
+    }
+}

src/array/MaxConsecutiveOnes2.java

@@ -0,0 +1,48 @@
+package array;
+
+import java.util.LinkedList;
+import java.util.Queue;
+
+/**
+ * Description: https://leetcode.com/problems/max-consecutive-ones-ii
+ * Difficulty: Medium
+ * Time complexity: O(n)
+ * Space complexity: O(1)
+ */
+public class MaxConsecutiveOnes2 {
+
+    public int findMaxConsecutiveOnes(int[] nums) {
+        int flips = 1;
+        int left = 0;
+        int right = 0;
+        while (right < nums.length) {
+            if (nums[right] == 0) flips--;
+            if (flips < 0) {
+                if (nums[left] == 0) flips++;
+                left++;
+            }
+
+            right++;
+        }
+
+        return right - left;
+    }
+
+    public int findMaxConsecutiveOnesForDataStream(int[] nums) {
+        int flips = 1;
+        int left = 0;
+        int max = 0;
+
+        Queue<Integer> zeroPositions = new LinkedList<>();
+        for (int right = 0; right < nums.length; right++) {
+            if (nums[right] == 0) zeroPositions.offer(right);
+            if (zeroPositions.size() > flips) {
+                left = zeroPositions.poll() + 1;
+            }
+
+            max = Math.max(max, right - left + 1);
+        }
+
+        return max;
+    }
+}

src/array/MaxConsecutiveOnes3.java

@@ -0,0 +1,52 @@
+package array;
+
+import java.util.LinkedList;
+import java.util.Queue;
+
+/**
+ * Description: https://leetcode.com/problems/max-consecutive-ones-iii
+ * Difficulty: Medium
+ */
+public class MaxConsecutiveOnes3 {
+
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(1)
+     */
+    public int longestOnes(int[] nums, int k) {
+        int left = 0;
+        int right = 0;
+        while (right < nums.length) {
+            if (nums[right] == 0) k--;
+            if (k < 0) {
+                if (nums[left] == 0) k++;
+                left++;
+            }
+
+            right++;
+        }
+
+        return right - left;
+    }
+
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(k)
+     */
+    public int longestOnesForDataStream(int[] nums, int k) {
+        int left = 0;
+        int max = 0;
+
+        Queue<Integer> zeroPositions = new LinkedList<>();
+        for (int right = 0; right < nums.length; right++) {
+            if (nums[right] == 0) zeroPositions.offer(right);
+            if (zeroPositions.size() > k) {
+                left = zeroPositions.poll() + 1;
+            }
+
+            max = Math.max(max, right - left + 1);
+        }
+
+        return max;
+    }
+}

src/binary_search/FindSmallestLetterGreaterThanTarget.java

@@ -0,0 +1,43 @@
+package binary_search;
+
+/**
+ * Description: https://leetcode.com/problems/find-smallest-letter-greater-than-target
+ * Difficulty: Easy
+ */
+public class FindSmallestLetterGreaterThanTarget {
+
+    /**
+     * Time complexity: O(nlog n)
+     * Space complexity: O(1)
+     */
+    public char nextGreatestLetterViaBinarySearch(char[] letters, char target) {
+        int left = 0;
+        int right = letters.length - 1;
+
+
+        int result = 0;
+        while (left <= right) {
+            int mid = left + (right - left) / 2;
+            if (letters[mid] > target) {
+                result = mid;
+                right = mid - 1;
+            } else {
+                left = mid + 1;
+            }
+        }
+
+        return letters[result];
+    }
+
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(1)
+     */
+    public char nextGreatestLetterViaBruteForce(char[] letters, char target) {
+        for (char c : letters) {
+            if (c > target) return c;
+        }
+
+        return letters[0];
+    }
+}

src/design/DesignInMemoryFileSystem.java

@@ -0,0 +1,94 @@
+package design;
+
+import java.util.*;
+
+/**
+ * Description: https://leetcode.com/problems/design-in-memory-file-system
+ * Difficulty: Hard
+ * Time complexity: O(n)
+ * Space complexity: O(n)
+ */
+public class DesignInMemoryFileSystem {
+
+    private static class FileSystemViaTrie {
+
+        private final Node trie;
+
+        public FileSystemViaTrie() {
+            this.trie = new Node();
+            trie.children.put("", new Node());
+        }
+
+        public List<String> ls(String path) {
+            // "/".split("/") returns an empty array
+            String[] dirs = path.equals("/") ? new String[]{""} : path.split("/");
+
+            Node found = find(dirs);
+            if (found == null) return List.of();
+
+            if (found.isFile) {
+                // return file name
+                return List.of(dirs[dirs.length - 1]);
+            }
+
+            return found.children.keySet().stream()
+                    .sorted()
+                    .toList();
+        }
+
+        public void mkdir(String path) {
+            String[] dirs = path.split("/");
+            findOrCreate(dirs);
+        }
+
+        public void addContentToFile(String filePath, String content) {
+            String[] dirs = filePath.split("/");
+
+            Node found = findOrCreate(dirs);
+            found.isFile = true;
+            found.content.append(content);
+        }
+
+        public String readContentFromFile(String filePath) {
+            String[] dirs = filePath.split("/");
+
+            Node found = find(dirs);
+            if (found == null) return "";
+
+            return found.content.toString();
+        }
+
+        private Node find(String[] path) {
+            Node current = trie;
+            for (String dir : path) {
+                Node child = current.children.get(dir);
+                if (child == null) return null;
+                current = child;
+            }
+
+            return current;
+        }
+
+        private Node findOrCreate(String[] path) {
+            Node current = trie;
+            for (String dir : path) {
+                Node child = current.children.computeIfAbsent(dir, __ -> new Node());
+                current = child;
+            }
+
+            return current;
+        }
+
+        private static class Node {
+
+            private final Map<String, Node> children;
+            private final StringBuilder content;
+            private boolean isFile;
+
+            public Node() {
+                this.children = new HashMap<>();
+                this.content = new StringBuilder();
+            }
+        }
+    }
+}