[Function add]

Seanforfun · Seanforfun · commit fd5926f1e87b · 2019-06-26T14:02:40.000-04:00
1. Add leetcode solutions with tag Amazon.
diff --git a/leetcode/289. Game of Life.md b/leetcode/289. Game of Life.md
@@ -124,4 +124,39 @@ class Solution {
         return count;
     }
 }
-```
+```
+
+### Amazon Session
+* Method 1: Bit Manipulation
+	1. Use the second lowest bit to save the state of next generation.
+	2. State compression: use a 3 * 3 matrix to traversal the board
+		* if count == 3: current is live and 2 neighbors, current is dead and 3 neighbors(reproduction).
+		* count - board = 3, current is live and 3 neighbors, so count is 4.
+	```Java
+	class Solution {
+		public void gameOfLife(int[][] board) {
+			if(board == null || board.length == 0 || board[0].length == 0) return;
+			int height = board.length, width = board[0].length;
+			for(int i = 0; i < height; i++){
+				for(int j = 0; j < width; j++){
+					//center is (i, j)
+					int count = 0;
+					for(int p = Math.max(0, i - 1); p <= Math.min(height - 1, i + 1); p++){
+						for(int q = Math.max(0, j - 1); q <= Math.min(width - 1, j + 1); q++){
+							count += board[p][q] & 1;
+						}
+					}
+					if(count == 3 || count - board[i][j] == 3) board[i][j] |= 0B10;
+				}
+			}
+			for(int i = 0; i < height; i++){
+				for(int j = 0; j < width; j++){
+					board[i][j] >>= 1;
+				}
+			}
+		}
+	}
+	```
+
+### Reference
+1. [花花酱 LeetCode 289. Game of Life](http://zxi.mytechroad.com/blog/simulation/leetcode-289-game-of-life/);
diff --git a/leetcode/445. Add Two Numbers II.md b/leetcode/445. Add Two Numbers II.md
@@ -171,5 +171,129 @@ Output: 7 -> 8 -> 0 -> 7
     }
     ```
 
+### Amazon Session
+* Method 1: recursion
+	```Java
+	/**
+	 * Definition for singly-linked list.
+	 * public class ListNode {
+	 *     int val;
+	 *     ListNode next;
+	 *     ListNode(int x) { val = x; }
+	 * }
+	 */
+	class Solution {
+		private int len1;
+		private int len2;
+		public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
+			ListNode cur1 = l1;
+			int len1 = 0;
+			while(cur1 != null){
+				len1++;
+				cur1 = cur1.next;
+			}
+			ListNode cur2 = l2;
+			int len2 = 0;
+			while(cur2 != null){
+				len2++;
+				cur2 = cur2.next;
+			}
+			this.len1 = Math.max(len1, len2);
+			this.len2 = Math.min(len1, len2);
+			ListNode first = len1 >= len2 ? l1: l2;
+			ListNode second = len1 >= len2 ? l2: l1;
+			ListNode next = add(first, this.len1 - 1, second, this.len2 - 1);
+			if(next.val < 10) return next;
+			else{
+				int carry = next.val / 10;
+				next.val %= 10;
+				ListNode res = new ListNode(carry);
+				res.next = next;
+				return res;
+			}
+			
+		}
+		public ListNode add(ListNode l1, int index1,  ListNode l2, int index2){ // we garantee l1 is longer
+			if(index1 == 0 && index2 == 0){
+				return new ListNode(l1.val + l2.val);
+			}else if(index1 > index2){
+				ListNode next = add(l1.next, index1 - 1, l2, index2);
+				int carry = next.val / 10;
+				next.val %= 10;
+				ListNode res = new ListNode(carry + l1.val);
+				res.next = next;
+				return res;
+			}else{
+				ListNode next = add(l1.next, index1 - 1, l2.next, index2 - 1);
+				int carry = next.val / 10;
+				next.val %= 10;
+				ListNode res = new ListNode(carry + l1.val + l2.val);
+				res.next = next;
+				return res;
+			}
+		}
+	}
+	```
+
+* Method 2: reverse the string
+	```Java
+	/**
+	 * Definition for singly-linked list.
+	 * public class ListNode {
+	 *     int val;
+	 *     ListNode next;
+	 *     ListNode(int x) { val = x; }
+	 * }
+	 */
+	class Solution {
+		public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
+			ListNode cur1 = l1, pre1 = null;
+			while(cur1 != null){
+				ListNode next = cur1.next;
+				cur1.next = pre1;
+				pre1 = cur1;
+				cur1 = next;
+			}
+			ListNode cur2 = l2, pre2 = null;
+			while(cur2 != null){
+				ListNode next = cur2.next;
+				cur2.next = pre2;
+				pre2 = cur2;
+				cur2 = next;
+			}        
+			ListNode dummy = new ListNode(1), cur = dummy;        
+			// pre1 && pre2 are the new heads
+			int carry = 0;
+			while(pre1 != null || pre2 != null){
+				int sum = 0;
+				if(pre1 != null && pre2 != null){
+					sum = pre1.val + pre2.val + carry;
+					pre1 = pre1.next;
+					pre2 = pre2.next;
+				}else if(pre1 != null){
+					sum = pre1.val + carry;
+					pre1 = pre1.next;
+				}else{
+					sum = pre2.val + carry;
+					pre2 = pre2.next;
+				}
+				carry = sum / 10;
+				cur.next = new ListNode(sum % 10);
+				cur = cur.next;
+			}
+			if(carry != 0) cur.next = new ListNode(1);
+			ListNode res = dummy.next;
+			cur2 = res; pre2 = null;
+			while(cur2 != null){
+				ListNode next = cur2.next;
+				cur2.next = pre2;
+				pre2 = cur2;
+				cur2 = next;
+			}
+			return pre2;
+		}
+	}
+	```
+
 ### Reference
 1. [Java O(n) recursive solution by counting the difference of length](https://leetcode.com/problems/add-two-numbers-ii/discuss/92643/Java-O(n)-recursive-solution-by-counting-the-difference-of-length)
diff --git a/leetcode/588. Design In-Memory File System.md b/leetcode/588. Design In-Memory File System.md
@@ -113,3 +113,82 @@ Note:
      * String param_4 = obj.readContentFromFile(filePath);
      */
     ```
+
+### Amazon Session
+* Method 1: Tire Tree
+	```Java
+	class FileSystem {
+		private static final class Node{
+			boolean isFile;
+			String path;
+			String content;
+			Map<String, Node> map;  //key is path name, value is child nodes.
+			public Node(String path){
+				this.map = new TreeMap<>();
+				this.path = path;
+			}
+		}
+		private Node root;
+		public FileSystem() {
+			this.root = new Node("/");
+			root.path = "/";
+			this.root.isFile = false;
+		}
+		private List<String> getListFromNode(Node node){
+			List<String> res = new ArrayList<>();
+			if(node.isFile){
+				res.add(node.path);
+				return res;
+			}
+			res.addAll(node.map.keySet());
+			res.sort((a, b)->{
+				return a.compareTo(b);
+			});
+			return res;
+		}
+		public List<String> ls(String path) {
+			String[] tokens = path.split("\\/");
+			List<String> result = new ArrayList<>();
+			if(path.equals("/")) return getListFromNode(root);
+			Node temp = this.root;
+			for(int i = 1; i < tokens.length; i++){
+				if(!temp.map.containsKey(tokens[i])) return result;
+				temp = temp.map.get(tokens[i]);
+			}
+			return getListFromNode(temp);
+		}
+		private Node createOrGetByPath(String path){
+			String[] tokens = path.split("\\/");
+			Node temp = this.root;
+			for(int i = 1; i < tokens.length; i++){
+				if(!temp.map.containsKey(tokens[i])) temp.map.put(tokens[i], new Node(tokens[i]));
+				temp = temp.map.get(tokens[i]);
+			}
+			return temp;
+		}
+		public void mkdir(String path) {
+			createOrGetByPath(path);
+		}
+		public void addContentToFile(String filePath, String content) {
+			Node file = createOrGetByPath(filePath);
+			if(file.content == null){
+				file.isFile = true;
+				file.content = content;
+			}else{
+				file.content += content;
+			}
+		}
+		public String readContentFromFile(String filePath) {
+			Node file = createOrGetByPath(filePath);
+			return file.content;
+		}
+	}
+	/**
+	 * Your FileSystem object will be instantiated and called as such:
+	 * FileSystem obj = new FileSystem();
+	 * List<String> param_1 = obj.ls(path);
+	 * obj.mkdir(path);
+	 * obj.addContentToFile(filePath,content);
+	 * String param_4 = obj.readContentFromFile(filePath);
+	 */
+	```
