[Function add]

1. Add leetcode solutions.

Author: Seanforfun

README.md

@@ -455,6 +455,14 @@
 
 [287. Find the Duplicate Number](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/287.%20Find%20the%20Duplicate%20Number.md)
 
+[289. Game of Life](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/289.%20Game%20of%20Life.md)
+
+[290. Word Pattern](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/290.%20Word%20Pattern.md)
+
+[292. Nim Game](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/292.%20Nim%20Game.md)
+
+[295.Find Median from Data Stream](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/295.Find%20Median%20from%20Data%20Stream.md)
+
 
 ## Algorithm(4th_Edition)
 Reading notes of book Algorithm(4th Algorithm),ISBN: 9787115293800.

leetcode/289. Game of Life.md

@@ -1,4 +1,40 @@
 ## 289. Game of Life
+
+### Question
+According to the Wikipedia's article: "The Game of Life, also known simply as Life, is a cellular automaton devised by the British mathematician John Horton Conway in 1970."
+
+Given a board with m by n cells, each cell has an initial state live (1) or dead (0). Each cell interacts with its eight neighbors (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.
+
+Write a function to compute the next state (after one update) of the board given its current state. The next state is created by applying the above rules simultaneously to every cell in the current state, where births and deaths occur simultaneously.
+
+```
+Example:
+
+Input: 
+[
+  [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]
+]
+```
+Follow up:
+* Could you solve it in-place? Remember that the board needs to be updated at the same time: 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 the border of the array. How would you address these problems?
+
+
 ### Thinking:
 
 ```Java
@@ -46,4 +82,46 @@ class Solution {
         return count;
     }
 }
+```
+
+### Second time
+1. I first updated the some of the cells first to indicate their next generation existance.
+2. Then I traversal the array agian and set them to correponding value.
+```Java
+class Solution {
+    public void gameOfLife(int[][] board) {
+        int height = board.length, width = board[0].length;
+        for(int i = 0; i < height; i++){
+            for(int j = 0; j < width; j++){
+                int cur = board[i][j];
+                int temp = checkNeighbour(board, i, j, height, width);
+                if(cur == 1 && temp < 2) board[i][j] = 6;
+                else if(cur == 0 && temp == 3) board[i][j] = 9;
+                else if(cur == 1 && temp > 3) board[i][j] = 6;
+            }
+        }
+        for(int i = 0; i < height; i++){
+            for(int j = 0; j < width; j++){
+                if(board[i][j] == 6) board[i][j] = 0;
+                else if(board[i][j] == 9) board[i][j] = 1;
+            }
+        }
+    }
+    private int checkNeighbour(int[][] board, int row, int col, int height, int width){
+        int count = 0;
+        if(row + 1 < height){
+            if(board[row + 1][col] == 1 || board[row + 1][col] == 6) count++;
+            if(col - 1 >= 0 && (board[row + 1][col - 1] == 1 || board[row + 1][col - 1] == 6)) count ++;
+            if(col + 1 < width && (board[row + 1][col + 1] == 1 || board[row + 1][col + 1] == 6)) count ++;
+        }
+        if(row - 1 >= 0){
+            if(board[row - 1][col] == 1 || board[row - 1][col] == 6) count++;
+            if(col - 1 >= 0 && (board[row - 1][col - 1] == 1 || board[row - 1][col - 1] == 6)) count ++;
+            if(col + 1 < width && (board[row - 1][col + 1] == 1 || board[row - 1][col + 1] == 6)) count ++;
+        }
+        if(col + 1 < width && (board[row][col + 1] == 1 || board[row][col + 1] == 6)) count++;
+        if(col - 1 >= 0 && (board[row][col - 1] == 1 || board[row][col - 1] == 6)) count++;
+        return count;
+    }
+}
 ```

leetcode/290. Word Pattern.md

@@ -0,0 +1,57 @@
+## 290. Word Pattern
+
+### Question
+Given a pattern and a string str, find if str 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 str.
+
+```
+Example 1:
+
+Input: pattern = "abba", str = "dog cat cat dog"
+Output: true
+
+Example 2:
+
+Input:pattern = "abba", str = "dog cat cat fish"
+Output: false
+
+Example 3:
+
+Input: pattern = "aaaa", str = "dog cat cat dog"
+Output: false
+
+Example 4:
+
+Input: pattern = "abba", str = "dog dog dog dog"
+Output: false
+
+Notes:
+You may assume pattern contains only lowercase letters, and str contains lowercase letters separated by a single space.
+```
+
+### Second time:
+1. The key point of this question is the reflection between key and value.
+2. We need to mapping relationship is unique, so we can use HashMap, and use two methods: containsKey and containsValue.
+
+```Java
+class Solution {
+    public boolean wordPattern(String pattern, String str) {
+        String[] arr = str.split(" ");
+        char[] charArr = pattern.toCharArray();
+        if(arr.length != charArr.length) return false;
+        Map<String, Character> map = new HashMap<>();
+        for(int i = 0; i < arr.length; i++){
+            if(!map.containsKey(arr[i]) && !map.containsValue(charArr[i])){
+                map.put(arr[i], charArr[i]);
+            }else if(!map.containsKey(arr[i]) && map.containsValue(charArr[i])){
+                return false;
+            }else{
+                if(charArr[i] != map.get(arr[i]))
+                    return false;
+            }
+        }
+        return true;
+    }
+}
+```

leetcode/292. Nim Game.md

@@ -18,6 +18,15 @@ No matter 1, 2, or 3 stones you remove, the last stone will always be removed by
 * Method 1:
 	* 4的倍数无法获胜。
 
+```Java
+class Solution {
+    public boolean canWinNim(int n) {
+        return n % 4 != 0;
+    }
+}
+```
+
+### Second time
 ```Java
 class Solution {
     public boolean canWinNim(int n) {

leetcode/295.Find Median from Data Stream.md

@@ -51,6 +51,41 @@ class MedianFinder {
     }
 }
 
+/**
+ * Your MedianFinder object will be instantiated and called as such:
+ * MedianFinder obj = new MedianFinder();
+ * obj.addNum(num);
+ * double param_2 = obj.findMedian();
+ */
+```
+
+### Second time
+1. Use two priority queue to solve this quesiton.
+2. ![Imgur](https://i.imgur.com/wuuSz5M.jpg)
+```Java
+class MedianFinder {
+    /** initialize your data structure here. */
+    PriorityQueue<Integer> min;
+    PriorityQueue<Integer> max;
+    public MedianFinder() {
+        min = new PriorityQueue<>();
+        max = new PriorityQueue<>(new Comparator<Integer>(){
+            @Override
+            public int compare(Integer n1, Integer n2){
+                return n2 - n1;
+            }
+        });
+    }
+    public void addNum(int num) {
+        max.offer(num);
+        min.offer(max.poll());
+        if(max.size() < min.size()) max.offer(min.poll());
+    }
+    public double findMedian() {
+        if(max.size() > min.size()) return (double)max.peek();
+        else return (double)(max.peek() + min.peek()) / 2;
+    }
+}
 /**
  * Your MedianFinder object will be instantiated and called as such:
  * MedianFinder obj = new MedianFinder();