start review

awangdev · awangdev · commit bb7d16e8f939 · 2016-01-20T08:42:14.000-05:00
diff --git a/Java/292. Nim Game.java b/Java/292. Nim Game.java
@@ -0,0 +1,45 @@
+著名Nim游戏。
+写一些，发现n=4,5,6,7,8...etc之后的情况有规律性。
+最终很简单n%4!=0就可以了
+```
+/*
+You are playing the following Nim Game with your friend: There is a heap of stones on the table, each time one of you take turns to remove 1 to 3 stones. The one who removes the last stone will be the winner. You will take the first turn to remove the stones.
+
+Both of you are very clever and have optimal strategies for the game. Write a function to determine whether you can win the game given the number of stones in the heap.
+
+For example, if there are 4 stones in the heap, then you will never win the game: no matter 1, 2, or 3 stones you remove, the last stone will always be removed by your friend.
+
+Hint:
+
+If there are 5 stones in the heap, could you figure out a way to remove the stones such that you will always be the winner?
+
+
+Hide Similar Problems (M) Flip Game II
+
+*/
+
+
+/*
+	Thoughts:
+	If n = 4, we can do the following:
+	1 0 0 0
+	1 1 0 0
+	1 1 1 0
+	But we'll fail.
+
+	n = 5, we pick 1, 2nd player gets n = 4.
+	n = 6, we pick 2, 2nd player gets n = 4.
+	n = 7, we pick 3, 2nd player gets n = 4.
+	n = 8, regarless whatever we pick, the opponent can make 1st gets n = 4, we fail.
+	...
+	...
+	whenever n % 4 = 0, 1st player fail.
+
+*/
+
+public class Solution {
+    public boolean canWinNim(int n) {
+     	return n % 4 != 0;
+    }
+}
+```
diff --git a/Java/Happy Number.java b/Java/Happy Number.java
@@ -0,0 +1,51 @@
+/*
+Write an algorithm to determine if a number is happy.
+
+A happy number is a number defined by the following process: 
+Starting with any positive integer, replace the number by the sum of the squares of its digits, 
+and repeat the process until the number equals 1 (where it will stay), 
+or it loops endlessly in a cycle which does not include 1. 
+Those numbers for which this process ends in 1 are happy numbers.
+
+Example
+19 is a happy number
+
+1^2 + 9^2 = 82
+8^2 + 2^2 = 68
+6^2 + 8^2 = 100
+1^2 + 0^2 + 0^2 = 1
+Tags Expand 
+Hash Table Mathematics
+*/
+
+/*
+	Thoughts:
+	Try some examples then find out: if it's not happy number, the 'sum of square of its digits' will
+	repeatedly occur. Use hashset to track existance.
+*/
+public class Solution {
+    public boolean isHappy(int n) {
+    	if (n <= 0) {
+    		return false;
+    	}
+    	long sum = n;
+    	HashSet<Long> set = new HashSet<Long>();
+    	while (sum != 1) {
+    		String s = String.valueOf(sum);
+    		sum = 0;
+    		for (char c : s.toCharArray()){
+    			sum += (c-'0')*(c-'0');
+    		}
+    		if (set.contains(sum)) {
+    			return false;	
+    		} else {
+    			set.add(sum);
+    		}
+    	}
+    	return true;
+    }
+}
+
+
+
+
diff --git a/Java/Implement Stack by Two Queues.java b/Java/Implement Stack by Two Queues.java
@@ -0,0 +1,80 @@
+两个Queue,交互倒水
+用一个Temp做swap
+
+做法1:
+逻辑在top()/pop()里, 每次换水，查看末尾项.
+
+做法2:
+逻辑在push里面:
+1. x 放q2。
+2. q1全部offer/append到q2.
+3. 用一个Temp做swap q1, q2.
+q1的头，就一直是最后加进去的值.
+```
+/*
+Implement Stack by Two Queues
+
+Implement a stack by two queues. The queue is first in first out (FIFO). 
+That means you can not directly pop the last element in a queue.
+
+Have you met this question in a real interview? Yes
+Example
+push(1)
+pop()
+push(2)
+isEmpty() // return false
+top() // return 2
+pop()
+isEmpty() // return true
+Tags Expand 
+Stack Queue
+
+*/
+
+/*
+	Thoughts:
+	2 queue are like two cups. We are fliping water into/out between q1 and q2.
+	pop and top are fliping water.
+	Use p1 as the base.
+*/
+
+class Stack {
+	private Queue<Integer> q1 = new LinkedList<Integer>();
+	private Queue<Integer> q2 = new LinkedList<Integer>();
+    // Push a new item into the stack
+    public void push(int x) {
+        q1.offer(x);
+    }
+
+    // Pop the top of the stack
+    public void pop() {
+       	while (q1.size() > 1) {
+       		q2.offer(q1.poll());
+       	}
+       	q1.poll();
+       	swap();
+    }
+
+    // Return the top of the stack
+    public int top() {
+       	while (q1.size() > 1) {
+       		q2.offer(q1.poll());
+       	}
+       	int rst = q1.poll();
+       	q2.offer(rst);
+       	swap();
+       	return rst;
+    }
+
+    public void swap(){
+		Queue<Integer> temp = q1;
+       	q1 = q2;
+       	q2 = temp;
+    }
+
+    // Check the stack is empty or not.
+    public boolean isEmpty() {
+        return q1.isEmpty();
+    }    
+}
+```
diff --git a/Java/Implement Stack.java b/Java/Implement Stack.java
@@ -0,0 +1,61 @@
+stack 后入先出. 
+Data Structure: ArrayList 
+return/remove ArrayList的末尾项。
+
+```
+/*
+ Implement Stack
+
+Implement a stack. You can use any data structure inside a stack except stack itself to implement it.
+
+
+Example
+push(1)
+pop()
+push(2)
+top()  // return 2
+pop()
+isEmpty() // return true
+push(3)
+isEmpty() // return false
+Tags Expand 
+Array Stack
+*/
+
+/*
+Thoughts:
+use arraylist and a index tracker - leng
+push: add to end
+pop: remove end
+top: get end.
+isEmpty: return length
+*/
+
+class Stack {
+	private ArrayList<Integer> list = new ArrayList<Integer>();
+    // Push a new item into the stack
+    public void push(int x) {
+    	list.add(x);
+    }
+
+    // Pop the top of the stack
+    public void pop() {
+    	if (list.size() > 0) {
+    		list.remove(list.size() - 1);
+    	}
+    }
+
+    // Return the top of the stack
+    public int top() {
+    	if (list.size() > 0) { 
+    		return list.get(list.size() - 1);
+    	}
+        return -1;
+    }
+
+    // Check the stack is empty or not.
+    public boolean isEmpty() {
+        return list.size() == 0;
+    }    
+}
+```
diff --git a/README.md b/README.md
diff --git a/WordPress.txt b/WordPress.txt
