Added tasks 284, 287, 289, 290.

Author: javadev

src/main/java/g0201_0300/s0284_peeking_iterator/PeekingIterator.java

@@ -0,0 +1,36 @@
+package g0201_0300.s0284_peeking_iterator;
+
+import java.util.Iterator;
+
+public class PeekingIterator implements Iterator<Integer> {
+    Iterator<Integer> it;
+    Integer current;
+
+    public PeekingIterator(Iterator<Integer> iterator) {
+        // initialize any member here.
+        it = iterator;
+        current = it.next();
+    }
+
+    // Returns the next element in the iteration without advancing the iterator.
+    public Integer peek() {
+        if (current == null) {
+            current = it.next();
+        }
+        return current;
+    }
+
+    // hasNext() and next() should behave the same as in the Iterator interface.
+    // Override them if needed.
+    @Override
+    public Integer next() {
+        Integer temp = current;
+        current = it.hasNext() ? it.next() : null;
+        return temp;
+    }
+
+    @Override
+    public boolean hasNext() {
+        return current != null;
+    }
+}

src/main/java/g0201_0300/s0284_peeking_iterator/readme.md

@@ -0,0 +1,41 @@
+284\. Peeking Iterator
+
+Medium
+
+Design an iterator that supports the `peek` operation on an existing iterator in addition to the `hasNext` and the `next` operations.
+
+Implement the `PeekingIterator` class:
+
+*   `PeekingIterator(Iterator<int> nums)` Initializes the object with the given integer iterator `iterator`.
+*   `int next()` Returns the next element in the array and moves the pointer to the next element.
+*   `boolean hasNext()` Returns `true` if there are still elements in the array.
+*   `int peek()` Returns the next element in the array **without** moving the pointer.
+
+**Note:** Each language may have a different implementation of the constructor and `Iterator`, but they all support the `int next()` and `boolean hasNext()` functions.
+
+**Example 1:**
+
+**Input**
+
+    ["PeekingIterator", "next", "peek", "next", "next", "hasNext"]
+    [[[1, 2, 3]], [], [], [], [], []]
+
+**Output:** \[null, 1, 2, 2, 3, false\]
+
+**Explanation:**
+
+    PeekingIterator peekingIterator = new PeekingIterator([1, 2, 3]); // [1,2,3]
+    peekingIterator.next(); // return 1, the pointer moves to the next element [1,2,3].
+    peekingIterator.peek(); // return 2, the pointer does not move [1,2,3].
+    peekingIterator.next(); // return 2, the pointer moves to the next element [1,2,3]
+    peekingIterator.next(); // return 3, the pointer moves to the next element [1,2,3]
+    peekingIterator.hasNext(); // return False 
+
+**Constraints:**
+
+*   `1 <= nums.length <= 1000`
+*   `1 <= nums[i] <= 1000`
+*   All the calls to `next` and `peek` are valid.
+*   At most `1000` calls will be made to `next`, `hasNext`, and `peek`.
+
+**Follow up:** How would you extend your design to be generic and work with all types, not just integer?

src/main/java/g0201_0300/s0287_find_the_duplicate_number/Solution.java

@@ -0,0 +1,14 @@
+package g0201_0300.s0287_find_the_duplicate_number;
+
+public class Solution {
+    public int findDuplicate(int[] nums) {
+        int[] arr = new int[nums.length + 1];
+        for (int i = 0; i < nums.length; ++i) {
+            arr[nums[i]] += 1;
+            if (arr[nums[i]] == 2) {
+                return nums[i];
+            }
+        }
+        return 0;
+    }
+}

src/main/java/g0201_0300/s0287_find_the_duplicate_number/readme.md

@@ -0,0 +1,45 @@
+287\. Find the Duplicate Number
+
+Medium
+
+Given an array of integers `nums` containing `n + 1` integers where each integer is in the range `[1, n]` inclusive.
+
+There is only **one repeated number** in `nums`, return _this repeated number_.
+
+You must solve the problem **without** modifying the array `nums` and uses only constant extra space.
+
+**Example 1:**
+
+**Input:** nums = \[1,3,4,2,2\]
+
+**Output:** 2 
+
+**Example 2:**
+
+**Input:** nums = \[3,1,3,4,2\]
+
+**Output:** 3 
+
+**Example 3:**
+
+**Input:** nums = \[1,1\]
+
+**Output:** 1 
+
+**Example 4:**
+
+**Input:** nums = \[1,1,2\]
+
+**Output:** 1 
+
+**Constraints:**
+
+*   <code>1 <= n <= 10<sup>5</sup></code>
+*   `nums.length == n + 1`
+*   `1 <= nums[i] <= n`
+*   All the integers in `nums` appear only **once** except for **precisely one integer** which appears **two or more** times.
+
+**Follow up:**
+
+*   How can we prove that at least one duplicate number must exist in `nums`?
+*   Can you solve the problem in linear runtime complexity?

src/main/java/g0201_0300/s0289_game_of_life/Solution.java

@@ -0,0 +1,34 @@
+package g0201_0300.s0289_game_of_life;
+
+public class Solution {
+    public void gameOfLife(int[][] board) {
+        int m = board.length;
+        int n = board[0].length;
+        for (int i = 0; i < m; i++) {
+            for (int j = 0; j < n; j++) {
+                int lives = lives(board, i, j, m, n);
+                if (board[i][j] == 0 && lives == 3) {
+                    board[i][j] = 2;
+                } else if (board[i][j] == 1 && (lives == 2 || lives == 3)) {
+                    board[i][j] = 3;
+                }
+            }
+        }
+        for (int i = 0; i < m; i++) {
+            for (int j = 0; j < n; j++) {
+                board[i][j] >>= 1;
+            }
+        }
+    }
+
+    private int lives(int[][] board, int i, int j, int m, int n) {
+        int lives = 0;
+        for (int r = Math.max(0, i - 1); r <= Math.min(m - 1, i + 1); r++) {
+            for (int c = Math.max(0, j - 1); c <= Math.min(n - 1, j + 1); c++) {
+                lives += board[r][c] & 1;
+            }
+        }
+        lives -= board[i][j] & 1;
+        return lives;
+    }
+}

src/main/java/g0201_0300/s0289_game_of_life/readme.md

@@ -0,0 +1,42 @@
+289\. Game of Life
+
+Medium
+
+According to [Wikipedia's article](https://en.wikipedia.org/wiki/Conway%27s_Game_of_Life): "The **Game of Life**, also known simply as **Life**, is a cellular automaton devised by the British mathematician John Horton Conway in 1970."
+
+The board is made up of an `m x n` grid of cells, where each cell has an initial state: **live** (represented by a `1`) or **dead** (represented by a `0`). Each cell interacts with its [eight neighbors](https://en.wikipedia.org/wiki/Moore_neighborhood) (horizontal, vertical, diagonal) using the following four rules (taken from the above Wikipedia article):
+
+1.  Any live cell with fewer than two live neighbors dies as if caused by under-population.
+2.  Any live cell with two or three live neighbors lives on to the next generation.
+3.  Any live cell with more than three live neighbors dies, as if by over-population.
+4.  Any dead cell with exactly three live neighbors becomes a live cell, as if by reproduction.
+
+The next state is created by applying the above rules simultaneously to every cell in the current state, where births and deaths occur simultaneously. Given the current state of the `m x n` grid `board`, return _the next state_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/12/26/grid1.jpg)
+
+**Input:** board = \[\[0,1,0\],\[0,0,1\],\[1,1,1\],\[0,0,0\]\]
+
+**Output:** \[\[0,0,0\],\[1,0,1\],\[0,1,1\],\[0,1,0\]\]
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2020/12/26/grid2.jpg)
+
+**Input:** board = \[\[1,1\],\[1,0\]\]
+
+**Output:** \[\[1,1\],\[1,1\]\]
+
+**Constraints:**
+
+*   `m == board.length`
+*   `n == board[i].length`
+*   `1 <= m, n <= 25`
+*   `board[i][j]` is `0` or `1`.
+
+**Follow up:**
+
+*   Could you solve it in-place? Remember that the board needs to be updated simultaneously: You cannot update some cells first and then use their updated values to update other cells.
+*   In this question, we represent the board using a 2D array. In principle, the board is infinite, which would cause problems when the active area encroaches upon the border of the array (i.e., live cells reach the border). How would you address these problems?

src/main/java/g0201_0300/s0290_word_pattern/Solution.java

@@ -0,0 +1,27 @@
+package g0201_0300.s0290_word_pattern;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class Solution {
+    public boolean wordPattern(String pattern, String s) {
+        Map<Character, String> map = new HashMap<>();
+        String[] words = s.split(" ");
+        if (words.length != pattern.length()) {
+            return false;
+        }
+        for (int i = 0; i < pattern.length(); i++) {
+            if (!map.containsKey(pattern.charAt(i))) {
+                if (map.containsValue(words[i])) {
+                    return false;
+                }
+                map.put(pattern.charAt(i), words[i]);
+            } else {
+                if (!words[i].equals(map.get(pattern.charAt(i)))) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+}

src/main/java/g0201_0300/s0290_word_pattern/readme.md

@@ -0,0 +1,40 @@
+290\. Word Pattern
+
+Easy
+
+Given a `pattern` and a string `s`, find if `s` follows the same pattern.
+
+Here **follow** means a full match, such that there is a bijection between a letter in `pattern` and a **non-empty** word in `s`.
+
+**Example 1:**
+
+**Input:** pattern = "abba", s = "dog cat cat dog"
+
+**Output:** true 
+
+**Example 2:**
+
+**Input:** pattern = "abba", s = "dog cat cat fish"
+
+**Output:** false 
+
+**Example 3:**
+
+**Input:** pattern = "aaaa", s = "dog cat cat dog"
+
+**Output:** false 
+
+**Example 4:**
+
+**Input:** pattern = "abba", s = "dog dog dog dog"
+
+**Output:** false 
+
+**Constraints:**
+
+*   `1 <= pattern.length <= 300`
+*   `pattern` contains only lower-case English letters.
+*   `1 <= s.length <= 3000`
+*   `s` contains only lower-case English letters and spaces `' '`.
+*   `s` **does not contain** any leading or trailing spaces.
+*   All the words in `s` are separated by a **single space**.

src/test/java/g0201_0300/s0284_peeking_iterator/PeekingIteratorTest.java

@@ -0,0 +1,25 @@
+package g0201_0300.s0284_peeking_iterator;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import java.util.Arrays;
+import org.junit.Test;
+
+public class PeekingIteratorTest {
+    @Test
+    public void peekingIterator() {
+        // [1,2,3]
+        PeekingIterator peekingIterator = new PeekingIterator(Arrays.asList(1, 2, 3).iterator());
+        // return 1, the pointer moves to the next element [1,2,3].
+        assertThat(peekingIterator.next(), equalTo(1));
+        // return 2, the pointer does not move [1,2,3].
+        assertThat(peekingIterator.peek(), equalTo(2));
+        // return 2, the pointer moves to the next element [1,2,3]
+        assertThat(peekingIterator.next(), equalTo(2));
+        // return 3, the pointer moves to the next element [1,2,3]
+        assertThat(peekingIterator.next(), equalTo(3));
+        // return False
+        assertThat(peekingIterator.hasNext(), equalTo(false));
+    }
+}

src/test/java/g0201_0300/s0287_find_the_duplicate_number/SolutionTest.java

@@ -0,0 +1,28 @@
+package g0201_0300.s0287_find_the_duplicate_number;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.Test;
+
+public class SolutionTest {
+    @Test
+    public void findDuplicate() {
+        assertThat(new Solution().findDuplicate(new int[] {1, 3, 4, 2, 2}), equalTo(2));
+    }
+
+    @Test
+    public void findDuplicate2() {
+        assertThat(new Solution().findDuplicate(new int[] {3, 1, 3, 4, 2}), equalTo(3));
+    }
+
+    @Test
+    public void findDuplicate3() {
+        assertThat(new Solution().findDuplicate(new int[] {1, 1}), equalTo(1));
+    }
+
+    @Test
+    public void findDuplicate4() {
+        assertThat(new Solution().findDuplicate(new int[] {1, 1, 2}), equalTo(1));
+    }
+}