[Function add]

1. Add leetcode solutions with amazon tag.

Author: Seanforfun

Diff for: leetcode/33. Search in Rotated Sorted Array.md

@@ -139,4 +139,29 @@ class Solution {
 			}
 		}
 	}
+	```
+
+### Amazon session
+* Method 1: binary search
+	```Java
+	class Solution {
+		public int search(int[] nums, int target) {
+			if(nums == null || nums.length == 0) return -1;
+			return binarySearch(nums, 0, nums.length - 1, target);
+		}
+		private int binarySearch(int[] nums, int low, int high, int target){
+			if(low > high) return -1;
+			int mid = low + (high - low) / 2;
+			if(nums[mid] == target) return mid;
+			else if(nums[mid] >= nums[low]){ // left side is in order
+				if(target >= nums[low] && target < nums[mid]){
+					return binarySearch(nums, low, mid - 1, target);
+				}else return binarySearch(nums, mid + 1, high, target);
+			}else{  // right side is in order
+				if(target > nums[mid] && target <= nums[high])
+					return binarySearch(nums, mid + 1, high, target);
+				return binarySearch(nums, low, mid - 1, target);
+			}
+		}
+	}
 	```

Diff for: leetcode/340. Longest Substring with At Most K Distinct Characters.md

@@ -48,4 +48,35 @@ Explanation: T is "aa" which its length is 2.
             return max;
         }
     }
+	```
+
+### Amazon Session
+* Method 1: sliding window
+	```Java
+	class Solution {
+		public int lengthOfLongestSubstringKDistinct(String s, int k) {
+			int slow = 0, fast = 0;
+			int result = 0;
+			char[] arr = s.toCharArray();
+			Map<Character, Integer> map = new HashMap<>();
+			while(fast < arr.length){
+				map.put(arr[fast], map.getOrDefault(arr[fast], 0) + 1);
+				if(map.size() <= k){
+					result = Math.max(result, fast - slow + 1);
+				}else if(map.size() > k){
+					while(map.size() > k){
+						char c = arr[slow];
+						int freq = map.get(c);
+						if(freq == 1){
+							map.remove(c);
+						}else map.put(c, freq - 1);
+						slow++;
+					}
+					result = Math.max(result, fast - slow + 1);
+				}
+				fast++;
+			}
+			return result;
+		}
+	}
 	```

Diff for: leetcode/56. Merge Intervals.md

@@ -94,3 +94,34 @@ class Solution {
     }
 }
 ```
+
+### Amazon session
+* Method 1: Sort
+	```Java
+	class Solution {
+		public int[][] merge(int[][] intervals) {
+			if(intervals == null || intervals.length <= 1) return intervals;
+			Arrays.sort(intervals, (a, b)->{
+				return a[0] == b[0] ? a[1] - b[1]: a[0] - b[0];
+			});
+			int len = intervals.length;
+			List<int[]> result = new ArrayList<>();
+			int start = intervals[0][0];
+			int end = intervals[0][1];
+			for(int i = 1; i < len; i++){
+				if(intervals[i][0] <= end){
+					end = Math.max(intervals[i][1],end);
+				}else{
+					result.add(new int[]{start, end});
+					start = intervals[i][0];
+					end = Math.max(intervals[i][1],end);
+				}
+			}
+			result.add(new int[]{start, end});
+			return result.toArray(new int[result.size()][2]);
+		}
+	}
+	```
+
+### Reference
+1. [Algorithm | Interval Schedule](https://seanforfun.github.io/algorithm/2019/05/03/IntervalScheduleWithGreedy.html)