[Function add]

1. Add leetcode solutions with amazon tag.

Author: Seanforfun

leetcode/149. Max Points on a Line.md

@@ -110,4 +110,45 @@ NOTE: input types have been changed on April 15, 2019. Please reset to default c
             return res;
         }
     }
-    ```
+    ```
+
+### Amazon Session
+* Method 1: HashMap + slope
+	```Java
+	class Solution {
+		private static final String inf = "inf";
+		public int maxPoints(int[][] points) {
+			int len = points.length;
+			if(len <= 2) return len;
+			int res = 0;
+			for(int i = 0; i < len; i++){
+				int[] a = points[i];
+				Map<String, Integer> map = new HashMap<>();
+				int base = 1, max = 0;
+				for(int j = i + 1; j < len; j++){
+					int[] b = points[j];
+					if(a[0] == b[0] && a[1] == b[1]){
+						base++;
+						continue;
+					}else{
+						String slope = "";
+						if(a[0] == b[0]){//same straight line, slope = inf
+							map.put(inf, map.getOrDefault(inf, 0) + 1);
+							slope = inf;
+						}else{
+							int gcd = gcd(a[1] - b[1], a[0] - b[0]);
+							slope = (a[1] - b[1]) / gcd + "_" + (a[0] - b[0]) / gcd;
+							map.put(slope, map.getOrDefault(slope, 0) + 1);
+						}
+						max = Math.max(max, map.get(slope));
+					}
+				}
+				res = Math.max(res, base + max);
+			}
+			return res;
+		}
+		private int gcd(int a, int b){
+			return b == 0 ? a: gcd(b, a % b);
+		}
+	}
+	```

leetcode/39. Combination Sum.md

@@ -110,3 +110,29 @@ class Solution {
     }
 }
 ```
+
+### Amazon Session
+* Method 1: recursion
+	```Java
+	class Solution {
+		private List<List<Integer>> result;
+		public List<List<Integer>> combinationSum(int[] candidates, int target) {
+			this.result = new ArrayList<>();
+			dfs(candidates, 0, target, 0, new ArrayList<>());
+			return result;
+		}
+		private void dfs(int[] candidates, int sum, int target, int index, List<Integer> temp){
+			if(sum == target){
+				List<Integer> res = new ArrayList<>();
+				res.addAll(temp);
+				result.add(res);
+			}else if(sum < target){
+				for(int i = index; i < candidates.length; i++){
+					temp.add(candidates[i]);
+					dfs(candidates, sum + candidates[i], target, i, temp);
+					temp.remove(temp.size() - 1);
+				}
+			}
+		}
+	}
+	```

leetcode/394. Decode String.md

@@ -143,3 +143,46 @@ class Solution {
       }
   }
   ```
+
+### Amazon Session
+* Method 1: Recursion: Need to pay attention to the digits since its length could be longer than 1.
+	```Java
+	class Solution {
+		private int index = 0;    
+		private int len;
+		private char[] arr;
+		public String decodeString(String s) {
+			if(s == null || s.length() == 0) return s;
+			this.arr = ("1[" + s + "]").toCharArray();
+			this.len = this.arr.length;
+			return decode();
+		}
+		private String decode(){
+			int time = 1;
+			StringBuilder result = new StringBuilder();
+			while(index < len){
+				char c = arr[index];
+				if(Character.isDigit(c)){
+					time = c - '0';
+					index++;
+					while(Character.isDigit(arr[index])){
+						time = time * 10 + arr[index++] - '0';
+					}
+					index ++;
+					String sub = decode();                
+					for(int i = 0; i < time; i++){
+						result.append(sub);
+					}
+					time = 1;
+				}else if(Character.isLetter(c)){
+					result.append(c);
+					index++;
+				}else if(c == ']'){
+					index++;
+					return result.toString();
+				}
+			}
+			return result.toString();
+		}
+	}
+	```

leetcode/635. Design Log Storage System.md

@@ -69,4 +69,42 @@ Note:
      * obj.put(id,timestamp);
      * List<Integer> param_2 = obj.retrieve(s,e,gra);
      */
-    ```
+    ```
+
+### Amazon Session
+* Method 1: Map
+	```Java
+	class LogSystem {
+		private Map<Integer, String> save;
+		private Map<String, Integer> g;
+		//2016:01:01:00:00:00
+		//Year:Month:Day:Hour:Minute:Second
+		public LogSystem() {
+			this.save = new HashMap<>();
+			this.g = new HashMap<>();
+			g.put("Year", 4);
+			g.put("Month", 7);
+			g.put("Day", 10);
+			g.put("Hour", 13);
+			g.put("Minute", 16);
+			g.put("Second", 19);
+		}
+		
+		public void put(int id, String timestamp) {
+			save.put(id, timestamp);
+		}
+		
+		public List<Integer> retrieve(String s, String e, String gra) {
+			List<Integer> result = new ArrayList<>();
+			int index = g.get(gra);
+			String ss = s.substring(0, index);
+			String es = e.substring(0, index);
+			for(Map.Entry<Integer, String> entry: save.entrySet()){
+				// System.out.println(entry.getValue());
+				String sub = entry.getValue().substring(0, index);
+				if(sub.compareTo(es) <= 0 && sub.compareTo(ss) >= 0) result.add(entry.getKey());
+			}
+			return result;
+		}
+	}
+	```