add 900 java, progress

Author: yennanliu

README.md

@@ -1196,8 +1196,8 @@
 0715| [Range Module](https://leetcode.com/problems/range-module/) | [C++](./C++/range-module.cpp) [Python](./leetcode_python/Design/range-module.py) | add: _O(n)_<br> remove: _O(n)_<br> query: _O(logn)_ | _O(n)_ | Hard || 
 716| [Max Stack](https://leetcode.com/problems/max-stack/) | [Python](./leetcode_python/Design/max-stack.py) | push: _O(logn)_<br> pop: _O(logn)_<br> popMax: _O(logn)_<br> top: _O(1)_<br> peekMax: _O(1)_ | _O(n)_ | Easy |basic, stack, `amazon`| again*
 745| [Prefix and Suffix Search](https://leetcode.com/problems/prefix-and-suffix-search/) | [Python](./leetcode_python/Design/prefix-and-suffix-search.py) | ctor: _O(w * l^2)_<br> search : _O(p + s)_ | _O(t)_ | Hard | Trie, `fb`| Not start* (1) (good basic)
-900| [RLE Iterator](https://leetcode.com/problems/rle-iterator/) | [C++](./C++/rle-iterator.cpp) [Python](./leetcode_python/Design/rle-iterator.py) | _O(n)_ | _O(1)_ | Medium ||
-1146| [Snapshot Array](https://leetcode.com/problems/snapshot-array/) |[Java](./leetcode_java/src/main/java/LeetCodeJava/Design/SnapshotArray.java)| set: _O(1)_<br> get: _O(logn)_ | _O(n)_ | Medium |treeMap, binary search, google| AGAIN*** (1)
+900| [RLE Iterator](https://leetcode.com/problems/rle-iterator/) | [C++](./C++/rle-iterator.cpp) [Python](./leetcode_python/Design/rle-iterator.py), [Java](./leetcode_java/src/main/java/LeetCodeJava/Design/RLEIterator.java) | _O(n)_ | _O(1)_ | Medium |google, treemap, array| AGAIN (not start) (1)
+1146| [Snapshot Array](https://leetcode.com/problems/snapshot-array/)|[Java](./leetcode_java/src/main/java/LeetCodeJava/Design/SnapshotArray.java)| set: _O(1)_<br> get: _O(logn)_ | _O(n)_ | Medium |treeMap, binary search, google| AGAIN*** (1)
 1166| [Design File System](https://leetcode.com/problems/design-file-system/) | [C++](./C++/design-file-system.cpp) [Python](./leetcode_python/Design/design-file-system.py) | create: _O(n)_<br>get: _O(n)_ | _O(n)_ | Medium |🔒, design, google, airbnb, amazon|  AGAIN***** (1)
 1172| [Dinner Plate Stacks](https://leetcode.com/problems/dinner-plate-stacks/) | [C++](./C++/dinner-plate-stacks.cpp) [Python](./leetcode_python/Design/dinner-plate-stacks.py) | push: _O(logn)_<br>pop: _O(1)_, amortized<br>popAtStack: _(logn)_ | _O(n * c)_ | Hard | | 
 1206| [Design Skiplist](https://leetcode.com/problems/design-skiplist/) | [C++](./C++/design-skiplist.cpp) [Python](./leetcode_python/Design/design-skiplist.py) | _O(logn)_, on average | _O(n)_ | Hard | | 

data/progress.md

@@ -1,5 +1,8 @@
 # Progress
 
+# 2024-11-03
+- https://github.com/yennanliu/CS_basics/blob/master/doc/Leetcode_company_frequency-master/Google%206months-%20LeetCode.pdf
+
 # 2024-11-02
 - https://github.com/yennanliu/CS_basics/blob/master/doc/Leetcode_company_frequency-master/Google%206months-%20LeetCode.pdf
 

data/progress.txt

@@ -1,4 +1,4 @@
-20241103:
+20241103: 900
 20241102: 26,27
 20241102: 802,1197,26
 20241027: 855,846

data/to_review.txt

@@ -1,41 +1,41 @@
-2024-12-28 -> ['26,27']
-2024-12-27 -> ['802,1197,26']
+2024-12-28 -> ['900']
+2024-12-27 -> ['26,27', '802,1197,26']
 2024-12-21 -> ['855,846']
 2024-12-20 -> ['932']
 2024-12-18 -> ['951,792']
 2024-12-14 -> ['163,1048']
 2024-12-13 -> ['298,729']
 2024-12-12 -> ['1146']
 2024-12-08 -> ['737']
-2024-12-07 -> ['26,27', '686,734,737']
-2024-12-06 -> ['802,1197,26', '353']
+2024-12-07 -> ['900', '686,734,737']
+2024-12-06 -> ['26,27', '802,1197,26', '353']
 2024-12-05 -> ['528,334']
 2024-12-03 -> ['1145']
 2024-11-30 -> ['855,846', '1145,1219']
 2024-11-29 -> ['932']
 2024-11-27 -> ['951,792', '524,221,889']
 2024-11-26 -> ['743,889']
 2024-11-25 -> ['837']
-2024-11-24 -> ['26,27']
-2024-11-23 -> ['802,1197,26', '163,1048', '981']
+2024-11-24 -> ['900']
+2024-11-23 -> ['26,27', '802,1197,26', '163,1048', '981']
 2024-11-22 -> ['298,729', '1087']
 2024-11-21 -> ['1146']
 2024-11-20 -> ['939']
 2024-11-18 -> ['430']
 2024-11-17 -> ['855,846', '737', '363']
-2024-11-16 -> ['26,27', '932', '686,734,737', '1032,844,1011']
-2024-11-15 -> ['802,1197,26', '353', '947']
+2024-11-16 -> ['900', '932', '686,734,737', '1032,844,1011']
+2024-11-15 -> ['26,27', '802,1197,26', '353', '947']
 2024-11-14 -> ['951,792', '528,334']
 2024-11-12 -> ['1145', '753']
-2024-11-11 -> ['26,27', '727']
-2024-11-10 -> ['802,1197,26', '163,1048']
+2024-11-11 -> ['900', '727']
+2024-11-10 -> ['26,27', '802,1197,26', '163,1048']
 2024-11-09 -> ['855,846', '298,729', '1145,1219']
-2024-11-08 -> ['26,27', '932', '1146']
-2024-11-07 -> ['802,1197,26']
-2024-11-06 -> ['26,27', '951,792', '524,221,889']
-2024-11-05 -> ['26,27', '802,1197,26', '743,889']
-2024-11-04 -> ['26,27', '802,1197,26', '855,846', '737', '837', '659']
-2024-11-03 -> ['802,1197,26', '932', '686,734,737', '801,552']
+2024-11-08 -> ['900', '932', '1146']
+2024-11-07 -> ['26,27', '802,1197,26']
+2024-11-06 -> ['900', '951,792', '524,221,889']
+2024-11-05 -> ['900', '26,27', '802,1197,26', '743,889']
+2024-11-04 -> ['900', '26,27', '802,1197,26', '855,846', '737', '837', '659']
+2024-11-03 -> ['26,27', '802,1197,26', '932', '686,734,737', '801,552']
 2024-11-02 -> ['163,1048', '353', '981', '1057,1066,1110']
 2024-11-01 -> ['855,846', '951,792', '298,729', '528,334', '1087']
 2024-10-31 -> ['932', '1146']

leetcode_java/src/main/java/LeetCodeJava/Design/RLEIterator.java

@@ -0,0 +1,200 @@
+package LeetCodeJava.Design;
+
+// https://leetcode.com/problems/rle-iterator/description/
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.TreeMap;
+
+/**
+ * 900. RLE Iterator
+ * Medium
+ * Topics
+ * Companies
+ * We can use run-length encoding (i.e., RLE) to encode a sequence of integers. In a run-length encoded array of even length encoding (0-indexed), for all even i, encoding[i] tells us the number of times that the non-negative integer value encoding[i + 1] is repeated in the sequence.
+ *
+ * For example, the sequence arr = [8,8,8,5,5] can be encoded to be encoding = [3,8,2,5]. encoding = [3,8,0,9,2,5] and encoding = [2,8,1,8,2,5] are also valid RLE of arr.
+ * Given a run-length encoded array, design an iterator that iterates through it.
+ *
+ * Implement the RLEIterator class:
+ *
+ * RLEIterator(int[] encoded) Initializes the object with the encoded array encoded.
+ * int next(int n) Exhausts the next n elements and returns the last element exhausted in this way. If there is no element left to exhaust, return -1 instead.
+ *
+ *
+ * Example 1:
+ *
+ * Input
+ * ["RLEIterator", "next", "next", "next", "next"]
+ * [[[3, 8, 0, 9, 2, 5]], [2], [1], [1], [2]]
+ * Output
+ * [null, 8, 8, 5, -1]
+ *
+ * Explanation
+ * RLEIterator rLEIterator = new RLEIterator([3, 8, 0, 9, 2, 5]); // This maps to the sequence [8,8,8,5,5].
+ * rLEIterator.next(2); // exhausts 2 terms of the sequence, returning 8. The remaining sequence is now [8, 5, 5].
+ * rLEIterator.next(1); // exhausts 1 term of the sequence, returning 8. The remaining sequence is now [5, 5].
+ * rLEIterator.next(1); // exhausts 1 term of the sequence, returning 5. The remaining sequence is now [5].
+ * rLEIterator.next(2); // exhausts 2 terms, returning -1. This is because the first term exhausted was 5,
+ * but the second term did not exist. Since the last term exhausted does not exist, we return -1.
+ *
+ *
+ * Constraints:
+ *
+ * 2 <= encoding.length <= 1000
+ * encoding.length is even.
+ * 0 <= encoding[i] <= 109
+ * 1 <= n <= 109
+ * At most 1000 calls will be made to next.
+ *
+ */
+
+public class RLEIterator {
+    /**
+     * Your RLEIterator object will be instantiated and called as such:
+     * RLEIterator obj = new RLEIterator(encoding);
+     * int param_1 = obj.next(n);
+     */
+    // V0
+    // TODO : implement
+//    class RLEIterator {
+//
+//        public RLEIterator(int[] encoding) {
+//
+//        }
+//
+//        public int next(int n) {
+//
+//        }
+//    }
+
+
+    // V1-1
+    // IDEA : TREEMAP
+    // https://youtu.be/Y_x4H9nMps0?si=O83hIcI5zilPGiWK
+    class RLEIterator_1 {
+        private long next;
+        private TreeMap<Long, Integer> tm;
+
+        public RLEIterator_1(int[] encoding) {
+            next = 0;
+            tm = new TreeMap<>();
+            long total = 0;
+            for (int i = 0; i < encoding.length; i += 2) {
+                if (encoding[i] == 0)
+                    continue;
+                total += encoding[i];
+                tm.put(total, encoding[i + 1]);
+            }
+        }
+
+        public int next(int n) {
+            next += n;
+            return tm.ceilingKey(next) != null ? tm.get(tm.ceilingKey(next)) : -1;
+        }
+    }
+
+    // V1-2
+    // IDEA : BRUTE FORCE (TLE)
+    // https://youtu.be/Y_x4H9nMps0?si=O83hIcI5zilPGiWK
+    class RLEIterator_1_1 {
+        int index;
+        List<Integer> list;
+
+        public RLEIterator_1_1(int[] A) {
+            index = 0;
+            list = new ArrayList<>();
+            for (int i = 0; i < A.length; i += 2) {
+                for (int j = A[i]; j > 0; j--) {
+                    list.add(A[i + 1]);
+                }
+            }
+        }
+
+        public int next(int n) {
+            index += n;
+            return index <= list.size() ? list.get(index - 1) : -1;
+        }
+    }
+
+    // V2
+    // https://leetcode.com/problems/rle-iterator/solutions/1418913/java-faster-than-100/
+    class RLEIterator_2 {
+        int index;
+        int[] encoding;
+        public RLEIterator_2(int[] encoding) {
+            index = 0;
+            this.encoding = encoding;
+        }
+
+        public int next(int n) {
+            while (index < encoding.length && n > encoding[index]) {
+                n -= encoding[index];
+                index += 2;
+
+            }
+            if (index >= encoding.length) {
+                return -1;
+            }
+            encoding[index] -= n;
+            return encoding[index + 1];
+        }
+    }
+
+    // V3
+    // IDEA : RECURSION
+    // https://leetcode.com/problems/rle-iterator/solutions/1139032/java-o-n-time-o-1-space-recursive-approach/
+    class RLEIterator_3 {
+
+        int index;
+        int[] A;
+
+        public RLEIterator_3(int[] A) {
+            this.A = A;
+            index = 0;
+        }
+
+        public int next(int n) {
+            if (index >= A.length) {
+                return -1;
+            }
+
+            if (n <= A[index]) {
+                A[index] -= n;
+                return A[index + 1];
+            } else {
+                index += 2;
+                return next(n - A[index - 2]);
+            }
+        }
+    }
+
+    // V4
+    // https://leetcode.com/problems/rle-iterator/solutions/4470485/short-concise-java-solution-beats-97/
+    class RLEIterator_4 {
+        int[] encodingArr;
+        int cursor;
+        public RLEIterator_4(int[] encoding) {
+            this.encodingArr = new int[encoding.length];
+            for(int i = 0;i<encoding.length;i++){
+                encodingArr[i] = encoding[i];
+            }
+            this.cursor = 0;
+        }
+
+        public int next(int n) {
+            while(cursor < encodingArr.length){
+                if(encodingArr[cursor] >= n){
+                    encodingArr[cursor] -= n;
+                    return encodingArr[cursor+1];
+                }else{
+                    n -= encodingArr[cursor];
+                    cursor +=2;
+                }
+            }
+            return -1;
+
+        }
+    }
+
+}

leetcode_java/src/main/java/dev/workspace5.java

@@ -2513,6 +2513,21 @@ public int removeElement(int[] nums, int val) {
 //        return s;
 //    }
 
+    // LC 900
+    // https://leetcode.com/problems/rle-iterator/
+    // 5.07 pm - 5.25 pm
+    class RLEIterator {
+
+        public RLEIterator(int[] encoding) {
+
+        }
+
+        public int next(int n) {
+            return 0;
+        }
+    }
+
+
 }
 
 

leetcode_python/Design/rle-iterator.py

@@ -0,0 +1,5 @@
+# V0
+
+# V1
+
+# V2