diff --git a/ArrayReader.java b/ArrayReader.java
new file mode 100644
index 00000000..5dab07e7
--- /dev/null
+++ b/ArrayReader.java
@@ -0,0 +1,9 @@
+
+public class ArrayReader {
+
+    int[] array = new int[100];
+    
+    public int get(int index) {
+        return array[index];
+    }
+}
diff --git a/MissingElementInSortedElements.java b/MissingElementInSortedElements.java
new file mode 100644
index 00000000..efe640de
--- /dev/null
+++ b/MissingElementInSortedElements.java
@@ -0,0 +1,2 @@
+package PACKAGE_NAME;public class MissingElementInSortedElements {
+}
diff --git a/Search2DMatrix.java b/Search2DMatrix.java
new file mode 100644
index 00000000..e53db3bc
--- /dev/null
+++ b/Search2DMatrix.java
@@ -0,0 +1,80 @@
+/**
+ * 74. Search a 2D Matrix
+ * https://leetcode.com/problems/search-a-2d-matrix/
+ * Time Complexity: O(log(m) + log(n)) where m is number of rows and n is number of columns
+ * Space Complexity: O(1)
+ */
+public class Search2DMatrix {
+
+    public boolean searchMatrix(int[][] matrix, int target) {
+        if (matrix.length == 0) return false;
+
+        int left = 0;
+        int right = matrix.length;
+
+        int row = 0;
+        if (matrix.length > 1) {
+            while (left < right) { // < for checking the final row
+                int mid = left + (right - left) / 2; // find mid
+                if (matrix[mid][0] == target) return true; // mid in the first column, lucky
+                if (matrix[mid][0] < target && matrix[mid][matrix[mid].length - 1] >= target) { // check whether its in a single row. search space reduced to row
+                    row = mid;
+                    break;
+                }
+                if (target < matrix[mid][0]) {
+                    right = mid;
+                } else left = mid + 1;
+            }
+            left = 0;
+            right = matrix[row].length;
+            while (left < right) {
+                int mid = left + (right - left) / 2;
+                if (matrix[row][mid] == target) return true;
+                if (target <= matrix[row][mid]) {
+                    right = mid;
+                } else left = mid + 1;
+            }
+        } else {
+            left = 0;
+            right = matrix[row].length;
+            while (left < right) {
+                int mid = left + (right - left) / 2;
+                if (matrix[row][mid] == target) return true;
+                if (target <= matrix[row][mid]) {
+                    right = mid;
+                } else left = mid + 1;
+            }
+        }
+
+
+        return false;
+    }
+
+    public static void main(String[] args) {
+        int[][] input = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}, {13, 14, 15, 16}, {17, 18, 19, 20}};
+        boolean b = new Search2DMatrix().searchMatrix(input, 8);
+        System.out.println(b);
+
+        b = new Search2DMatrix().searchMatrix(input, 5);
+        System.out.println(b);
+
+        b = new Search2DMatrix().searchMatrix(input, 16);
+        System.out.println(b);
+
+        b = new Search2DMatrix().searchMatrix(input, 20);
+        System.out.println(b);
+
+        b = new Search2DMatrix().searchMatrix(input, 19);
+        System.out.println(b);
+
+        b = new Search2DMatrix().searchMatrix(new int[][]{}, 20);
+        System.out.println(b);
+
+        b = new Search2DMatrix().searchMatrix(new int[][]{{1, 2}}, 1);
+        System.out.println(b);
+
+        b = new Search2DMatrix().searchMatrix(new int[][]{{1}, {3}}, 0);
+        System.out.println(b);
+    }
+
+}
diff --git a/Search2DMatrix1.java b/Search2DMatrix1.java
new file mode 100644
index 00000000..ede6cff7
--- /dev/null
+++ b/Search2DMatrix1.java
@@ -0,0 +1,29 @@
+public class Search2DMatrix1 {
+
+    public boolean searchMatrix(int[][] matrix, int target) {
+        if (matrix.length == 0 || matrix == null)
+            return false;
+
+        int m = matrix.length;
+        int n = matrix[0].length;
+
+        int left = 0;
+        int right = (m * n) - 1;
+
+        while (left <= right) {
+            int mid = left + (right - left) + 1 / 2;
+            int row = mid / n;
+            int column = mid % n;
+
+            if (matrix[row][column] == target)
+                return true;
+            if (target < matrix[row][column]) {
+                right = mid - 1;
+            } else
+                left = mid + 1;
+
+        }
+        return false;
+    }
+
+}
diff --git a/SearchInUnknownSizeSortedArray.java b/SearchInUnknownSizeSortedArray.java
new file mode 100644
index 00000000..2f01a17f
--- /dev/null
+++ b/SearchInUnknownSizeSortedArray.java
@@ -0,0 +1,47 @@
+/**
+ * Search in Unknown Size Sorted Array
+ * https://leetcode.com/problems/search-in-unknown-size-sorted-array/
+ * Time Complexity: O(log(n)) where n is number of elements in the array
+ * Space Complexity: O(1)
+ * 
+ * Description:
+ * Given an integer array sorted in ascending order, write a function to search
+ * for a target value in the array.
+ * If the target value exists, then return its index. Otherwise, return -1.
+ * Since the array size is unknown, you cannot access an index out of the bounds
+ * of the array.
+ * You may only access the array using an ArrayReader interface, where
+ * ArrayReader.get(k) returns the element of the array at index k (0-indexed).
+ * You may assume all integers in the array are less than 10000, and if you
+ * access the array out of bounds, ArrayReader.get will return 2147483647.
+ * 
+ * 
+ */
+public class SearchInUnknownSizeSortedArray {
+    public int search(ArrayReader reader, int target) {
+
+        int low = 0;
+        int high = low + 1;
+        while (low <= high) {
+            if (reader.get(low) >= target && target <= reader.get(high)) {
+                while (low <= high) {
+                    int mid = high - (high - low) / 2;
+                    if (reader.get(mid) == target)
+                        return mid;
+                    if (target < reader.get(mid)) {
+                        high = mid - 1;
+                    } else {
+                        low = mid + 1;
+                    }
+                }
+            } else {
+                low = high;
+                high = high * 2;
+            }
+
+        }
+
+        return -1;
+        // Method implementation goes here
+    }
+}
diff --git a/SearchRotatedSortedArray.java b/SearchRotatedSortedArray.java
new file mode 100644
index 00000000..949544bd
--- /dev/null
+++ b/SearchRotatedSortedArray.java
@@ -0,0 +1,50 @@
+/**
+ * 33. Search in Rotated Sorted Array
+ * https://leetcode.com/problems/search-in-rotated-sorted-array/
+ * Time Complexity: O(log(n)) where n is number of elements in the array
+ * Space Complexity: O(1)
+ * 
+ */
+public class SearchRotatedSortedArray {
+
+    public int search(int[] nums, int target) {
+        int left = 0;
+        int right = nums.length - 1;
+        while (left <= right) {
+            int mid = left + (right - left + 1) / 2;
+            if (nums[mid] == target)
+                return mid;
+            if (nums[left] <= nums[mid]) { // left to mid is sorted e.g. 4,5,6,0,1,2,3
+                if (target >= nums[left] && target < nums[mid]) {
+                    right = mid - 1;
+                } else {
+                    left = mid + 1;
+                }
+            } else { // mid to right is sorted e.g. 6,0,1,2,3,4,5
+                if (target > nums[mid] && target <= nums[right]) {
+                    left = mid + 1;
+                } else {
+                    right = mid - 1;
+                }
+            }
+        }
+        return -1;
+    }
+
+    public static void main(String[] args) {
+        int search = new SearchRotatedSortedArray().search(new int[] { 3, 4, 5, 6, 0, 1, 2 }, 1);
+        System.out.println(search);
+
+        search = new SearchRotatedSortedArray().search(new int[] { 6, 0, 1, 2, 3, 4, 5 }, 1);
+        System.out.println(search);
+
+        search = new SearchRotatedSortedArray().search(new int[] { 4, 5, 6, 0, 1, 2, 3 }, 4);
+        System.out.println(search);
+
+        search = new SearchRotatedSortedArray().search(new int[] { 4, 5, 6, 0, 1, 2, 3 }, 3);
+        System.out.println(search);
+
+        search = new SearchRotatedSortedArray().search(new int[] { 1, 2, 3, 4, 5, 6, 0 }, 3);
+        System.out.println(search);
+    }
+}
diff --git a/Solution.java b/Solution.java
new file mode 100644
index 00000000..e69de29b