[Function add]

1. Add leetcode solutions with tag amazon.

Author: Seanforfun

leetcode/239. Sliding Window Maximum.md

@@ -115,3 +115,26 @@ class Solution {
       }
   }
   ```
+
+### Amazon Session
+* Method 1: Deque
+	```Java
+	class Solution {
+		public int[] maxSlidingWindow(int[] nums, int k) {
+			if(nums.length < k || nums.length == 0) return new int[0];
+			int[] result = new int[nums.length - k + 1];
+			Deque<Integer> deque = new ArrayDeque<>();
+			int i = 0, index = 0;
+			for(i = 0; i < nums.length; i++){
+				if(i - k >= 0 && !deque.isEmpty() && deque.peek() == i - k) deque.pollFirst();
+				int add = nums[i];
+				while(!deque.isEmpty() && add >= nums[deque.getLast()]){
+					deque.pollLast();
+				}
+				deque.addLast(i);
+				if(i - k + 1 >= 0) result[index++] = nums[deque.getFirst()];
+			}
+			return result;
+		}
+	}
+	```

leetcode/413. Arithmetic Slices.md

@@ -0,0 +1,56 @@
+### 413. Arithmetic Slices
+
+### Question
+A sequence of number is called arithmetic if it consists of at least three elements and if the difference between any two consecutive elements is the same.
+
+For example, these are arithmetic sequence:
+
+1, 3, 5, 7, 9
+7, 7, 7, 7
+3, -1, -5, -9
+
+The following sequence is not arithmetic.
+
+1, 1, 2, 5, 7
+
+
+A zero-indexed array A consisting of N numbers is given. A slice of that array is any pair of integers (P, Q) such that 0 <= P < Q < N.
+
+A slice (P, Q) of array A is called arithmetic if the sequence:
+A[P], A[p + 1], ..., A[Q - 1], A[Q] is arithmetic. In particular, this means that P + 1 < Q.
+
+The function should return the number of arithmetic slices in the array A.
+
+```
+Example:
+
+A = [1, 2, 3, 4]
+
+return: 3, for 3 arithmetic slices in A: [1, 2, 3], [2, 3, 4] and [1, 2, 3, 4] itself.
+```
+
+### Solution
+* Method 1: Find number at end of each fast.
+	```Java
+	class Solution {
+		public int numberOfArithmeticSlices(int[] A) {
+			if(A == null || A.length < 3) return 0;
+			int res = 0;
+			int slow = 0, fast = 1;
+			int diff = A[fast] - A[slow];
+			fast++; // fast = 2 now.
+			for(; fast < A.length; fast++){
+				if(A[fast] - A[fast - 1] == diff){
+					if(fast - slow + 1 >= 3){
+						res += fast - 2 - slow + 1;
+					}
+					continue;
+				}else{   // diff changes
+					slow = fast - 1;
+					diff = A[fast] - A[fast - 1];
+				}
+			}
+			return res;
+		}
+	}
+	```

leetcode/74. Search a 2D Matrix.md

@@ -82,3 +82,24 @@ class Solution {
 		}
 	}
 	```
+
+### Amazon session
+* Method 1: search
+	```Java
+	class Solution {
+		public boolean searchMatrix(int[][] matrix, int target) {
+			if(matrix == null || matrix.length == 0 || matrix[0].length == 0) return false;
+			int height = matrix.length, width = matrix[0].length;
+			int x = 0, y = width - 1;
+			while(x >= 0 && x < height && y >= 0 && y < width){
+				if(matrix[x][y] == target) return true;
+				else if(matrix[x][y] < target){
+					x++;
+				}else{
+					y--;
+				}
+			}
+			return false;
+		}
+	}
+	```