Added binary search solutions

Author: Мето Трајковски

Diff for: LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2019 Мето Трајковски
+Copyright (c) 2019 Meto Trajkovski
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

Diff for: Lists/find_element_range_sorted_array.py

@@ -0,0 +1,58 @@
+'''
+Find First and Last Position of Element in Sorted Array
+
+Given an array of integers nums sorted in ascending order,
+find the starting and ending position of a given target value.
+If the target is not found in the array, return [-1, -1].
+
+Input: [5, 7, 7, 8, 8, 10], 8
+Output: [3, 4]
+
+Input: [5, 7, 7, 8, 8, 10], 6
+Output: [-1, -1]
+
+=========================================
+Use binary search twice to find the range.
+    Time Complexity:    O(LogN)
+    Space Complexity:   O(1)
+'''
+
+
+############
+# Solution #
+############
+
+def search_range(nums, target):
+    left_idx = binary_search(nums, target, True)
+    if (left_idx == len(nums)) or (nums[left_idx] != target):
+        return [-1, -1]
+
+    right_idx = binary_search(nums, target, False) - 1
+    return [left_idx, right_idx]
+
+def binary_search(nums, target, equal=True):
+    left = 0
+    right = len(nums)
+
+    while left < right:
+        mid = (left + right) // 2
+
+        if (nums[mid] > target) or (equal and nums[mid] == target):
+            right = mid
+        else:
+            left = mid + 1
+
+    return left
+
+
+###########
+# Testing #
+###########
+
+# Test 1
+# Correct result => [3, 4]
+print(search_range([5, 7, 7, 8, 8, 10], 8))
+
+# Test 2
+# Correct result => [-1, -1]
+print(search_range([5, 7, 7, 8, 8, 10], 6))

Diff for: Lists/search_rotated_sorted_array.py

@@ -0,0 +1,69 @@
+'''
+Search in Rotated Sorted Array
+
+Suppose an array sorted in ascending order is rotated at some pivot unknown to you beforehand.
+(i.e., [0,1,2,4,5,6,7] might become [4,5,6,7,0,1,2]).
+You are given a target value to search. If found in the array return its index, otherwise return -1.
+You may assume no duplicate exists in the array.
+
+Input: [4, 5, 6, 7, 0, 1, 2], 0
+Output: 4
+
+Input: [4, 5, 6, 7, 0, 1, 2], 3
+Output: -1
+
+=========================================
+Use binary search twice, first time to find the pivot (index where the array is rotated)
+and the second time to find the target.
+    Time Complexity:    O(LogN)
+    Space Complexity:   O(1)
+'''
+
+
+############
+# Solution #
+############
+
+def search_rotated_sorted_array(nums, target):
+    n = len(nums)
+    pivot = find_pivot(nums, 0, n) + 1
+    if pivot > n:
+        return -1
+
+    if nums[0] <= target:
+        return find_element(nums, 0, pivot - 1, target)
+    return find_element(nums, pivot, n - 1, target)
+
+def find_pivot(nums, left, right):
+    while left < right - 1:
+        mid = left + (right - left) // 2
+
+        if nums[left] < nums[mid]:
+            left = mid
+        else:
+            right = mid
+
+    return left
+
+def find_element(nums, left, right, target):
+    while left <= right:
+        mid = left + (right - left) // 2
+
+        if nums[mid] == target:
+            return mid
+
+        if nums[mid] < target:
+            left = mid + 1
+        else:
+            right = mid - 1
+
+    return -1
+
+
+###########
+# Testing #
+###########
+
+# Test 1
+# Correct result => 4
+print(search_rotated_sorted_array([4, 5, 6, 7, 0, 1, 2], 0))

Diff for: README.md

@@ -79,15 +79,13 @@ print(name_of_solution_2('example2'))
 
 Each solution/problem in this repo belongs to one of these categories:
 
-1. [Strings](/)
-2. [Arrays](/)
-3. [Linked Lists](/)
-4. [Trees](/)
-5. [Dynamic Programming](/)
-6. [Backtracking](/)
-7. [Graphs](/)
-8. [Math](/)
-9. [Other](/)
+1. [Arrays](/) - Array Manipulations, Sorting, Binary Search, Divide and Conquer, Sliding Window, etc.
+2. [Linked Lists](/) - Linked List Searching, Pointer Manipulations, etc.
+3. [Trees](/) - Binary Search Trees, Tree Traversals: Breadth-First (Level Order) Traversal, Depth-First Traversal (Inorder, Preorder, Postorder), etc.
+4. [Dynamic Programming](/) - 2D and 1D Dynamic Programming, LCS, LIS, Knapsack, etc.
+5. [Strings](/) - String Manipulations, Reversing, Encodings/Decodings, etc.
+6. [Math](/) - GCD, LCM, Prime Factors, Math Formulas, etc.
+7. [Other](/) - Backtracking, BFS, DFS, Queues, Stacks, Matrices, etc.
 
 
 ## Learning Resources