add 900

fishercoder1534 · fishercoder1534 · commit d71ebdf89fa9 · 2019-02-24T14:04:53.000-08:00
diff --git a/README.md b/README.md
@@ -52,7 +52,7 @@ Your ideas/fixes/algorithms are more than welcome!
 |922|[Sort Array By Parity II](https://leetcode.com/problems/sort-array-by-parity-ii/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_922.java) | O(n) | O(1) | |Easy|
 |917|[Reverse Only Letters](https://leetcode.com/problems/reverse-only-letters/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_917.java) | O(n) | O(n) | |Easy|
 |908|[Smallest Range I](https://leetcode.com/problems/smallest-range-i/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_908.java) | O(nlogn) | O(1) | |Easy|
-|900|[Sort Array By Parity](https://leetcode.com/problems/sort-array-by-parity/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_900.java) | O(n) | O(1) | |Easy|
+|900|[RLE Iterator](https://leetcode.com/problems/rle-iterator/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_900.java) | O(n) | O(1) | |Medium|
 |897|[Increasing Order Search Tree](https://leetcode.com/problems/increasing-order-search-tree/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_897.java) | O(n) | O(n) | |Easy| DFS, recursion
 |896|[Monotonic Array](https://leetcode.com/problems/monotonic-array/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_896.java) | O(n) | O(1) | |Easy|
 |884|[Uncommon Words from Two Sentences](https://leetcode.com/problems/uncommon-words-from-two-sentences/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_884.java) | O(n) | O(k) | |Easy|
diff --git a/src/main/java/com/fishercoder/solutions/_900.java b/src/main/java/com/fishercoder/solutions/_900.java
@@ -0,0 +1,75 @@
+package com.fishercoder.solutions;
+
+/**
+ * 900. RLE Iterator
+ *
+ * Write an iterator that iterates through a run-length encoded sequence.
+ *
+ * The iterator is initialized by RLEIterator(int[] A), where A is a run-length encoding of some sequence.
+ * More specifically, for all even i, A[i] tells us the number of times that the non-negative integer value A[i+1] is repeated in the sequence.
+ *
+ * The iterator supports one function: next(int n),
+ * which exhausts the next n elements (n >= 1) and returns the last element exhausted in this way.
+ * If there is no element left to exhaust, next returns -1 instead.
+ *
+ * For example, we start with A = [3,8,0,9,2,5], which is a run-length encoding of the
+ * sequence [8,8,8,5,5].
+ * This is because the sequence can be read as "three eights, zero nines, two fives".
+ *
+ * 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 is initialized with RLEIterator([3,8,0,9,2,5]).
+ * This maps to the sequence [8,8,8,5,5].
+ * RLEIterator.next is then called 4 times:
+ * .next(2) exhausts 2 terms of the sequence, returning 8.  The remaining sequence is now [8, 5, 5].
+ * .next(1) exhausts 1 term of the sequence, returning 8.  The remaining sequence is now [5, 5].
+ * .next(1) exhausts 1 term of the sequence, returning 5.  The remaining sequence is now [5].
+ * .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.
+ *
+ * Note:
+ *
+ * 0 <= A.length <= 1000
+ * A.length is an even integer.
+ * 0 <= A[i] <= 10^9
+ * There are at most 1000 calls to RLEIterator.next(int n) per test case.
+ * Each call to RLEIterator.next(int n) will have 1 <= n <= 10^9.
+ */
+public class _900 {
+  public static class Solution1 {
+    public static class RLEIterator {
+
+      int index;
+      int[] array;
+
+      public RLEIterator(int[] A) {
+        index = 0;
+        array = A;
+      }
+
+      public int next(int n) {
+        int lastElement = -1;
+        while (n > 0 && index < array.length) {
+          if (array[index] > n) {
+            array[index] -= n;
+            lastElement = array[index + 1];
+            break;
+          } else if (array[index] == n) {
+            array[index] = 0;
+            lastElement = array[index + 1];
+            index += 2;
+            break;
+          } else {
+            n -= array[index];
+            index += 2;
+          }
+        }
+        return lastElement;
+      }
+
+    }
+  }
+}
diff --git a/src/test/java/com/fishercoder/_900Test.java b/src/test/java/com/fishercoder/_900Test.java
@@ -0,0 +1,35 @@
+package com.fishercoder;
+
+import com.fishercoder.solutions._900;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class _900Test {
+  private static _900.Solution1.RLEIterator rleIterator;
+
+  @Test
+  public void test1() {
+    rleIterator = new _900.Solution1.RLEIterator(new int[] {3, 8, 0, 9, 2, 5});
+    assertEquals(8, rleIterator.next(2));
+    assertEquals(8, rleIterator.next(1));
+    assertEquals(5, rleIterator.next(1));
+    assertEquals(-1, rleIterator.next(2));
+  }
+
+  @Test
+  public void test2() {
+    rleIterator = new _900.Solution1.RLEIterator(
+        new int[] {811, 903, 310, 730, 899, 684, 472, 100, 434, 611});
+    assertEquals(903, rleIterator.next(358));
+    assertEquals(903, rleIterator.next(345));
+    assertEquals(730, rleIterator.next(154));
+    assertEquals(684, rleIterator.next(265));
+    assertEquals(684, rleIterator.next(73));
+    assertEquals(684, rleIterator.next(220));
+    assertEquals(684, rleIterator.next(138));
+    assertEquals(684, rleIterator.next(4));
+    assertEquals(684, rleIterator.next(170));
+    assertEquals(684, rleIterator.next(88));
+  }
+}
