searching, stack

Author: Aman Kumar

practice/quick_sort.rb

@@ -0,0 +1,60 @@
+def quick_sort(arr)
+  quick_sort_helper2(arr, 0, arr.length - 1)
+  arr
+end
+
+def quick_sort_helper(arr, low, high)
+  return if low >= high
+
+  pivot = arr[high]
+  pi = partition(arr, pivot, low, high)
+  quick_sort_helper(arr, low, pi - 1)
+  quick_sort_helper(arr, pi + 1, high)
+end
+
+def partition(arr, pivot, low, high)
+  i = low
+  j = low
+  while i <= high
+    if arr[i] <= pivot
+      arr[i], arr[j] = arr[j], arr[i]
+      j += 1
+    end
+    i += 1
+  end
+  j - 1
+end
+
+def quick_sort_helper2(arr, low, high)
+  return if low >= high
+
+  pivot = low
+  left = low + 1
+  right = high
+  while right >= left
+    if arr[left] > arr[pivot] && arr[right] < arr[pivot]
+      swap(arr, left, right)
+    elsif arr[left] <= arr[pivot]
+      left += 1
+    elsif arr[right] >= arr[pivot]
+      right -= 1
+    end
+  end
+  swap(arr, right, pivot)
+
+  is_left_subarray_smaller = high - right + 1 > left - low - 1
+  # we are sorting smaller subarray first
+  if is_left_subarray_smaller
+    quick_sort_helper2(arr, left, right - 1)
+    quick_sort_helper2(arr, right + 1, high)
+  else
+    quick_sort_helper2(arr, right + 1, high)
+    quick_sort_helper2(arr, left, right - 1)
+  end
+end
+
+def swap(arr, i, j)
+  arr[i], arr[j] = arr[j], arr[i]
+end
+
+puts quick_sort([9, 30, 2, 88, 3, 98, 45]).to_s

searching/binary_search.rb

@@ -1,3 +1,5 @@
+# https://leetcode.com/problems/binary-search/
+#
 # Recursive solution
 def b_search(ar, target, l, r)
   # l, r = 0, ar.length-1
@@ -23,6 +25,7 @@ def binary_search(arr, target)
       left = mid + 1
     end
   end
+  -1
 end
 
 ar = [1, 3]

searching/index_equals_value.rb

@@ -0,0 +1,36 @@
+
+# using brutforce
+def index_equals_value_bforce(nums)
+  nums.each_with_index do |n, index|
+    return index if n == index
+  end
+  -1
+end
+
+def index_equals_value_bsearch(nums)
+  left = 0
+  right = nums.length - 1
+  while left <= right
+    mid = (left + right) / 2
+    # 1st occurance at zero index
+    if nums[mid] == mid && mid.zero?
+      return mid
+    elsif nums[mid] == mid && nums[mid-1] < mid - 1
+      return mid
+    elsif nums[mid] < mid
+      left = mid + 1
+    else
+      right = mid - 1
+    end
+  end
+  -1
+end
+
+# 3
+puts index_equals_value_bsearch([-5, -3, 0, 3, 4, 5, 9])
+
+#4
+puts index_equals_value_bsearch([-5, -3, 0, 2, 4, 5, 9])
+
+#-1
+puts index_equals_value_bsearch([-5, -3, 0, 2, 5, 6, 19])

searching/quick_select.rb

@@ -0,0 +1,60 @@
+# Write a function that takes in an array of distinct integers as well as an integer k and that returns the kth smallest integer in that array.
+
+# The function should do this in linear time, on average.
+
+# Sample Input
+# array = [8, 5, 2, 9, 7, 6, 3]
+# k = 3
+# Sample Output
+# 5
+#
+
+def quick_select(nums, k)
+  pos = k - 1
+  return if nums.empty? || nums.length < pos
+
+  quick_select_helper(nums, pos, 0, nums.length - 1)
+end
+
+def quick_select_helper(nums, pos, start, ending)
+  while start <= ending
+    pivot = start
+    left = start + 1
+    right = ending
+
+    while right >= left
+      if nums[left] > nums[pivot] && nums[right] < nums[pivot]
+        swap(nums, left, right)
+      elsif nums[left] <= nums[pivot]
+        left += 1
+      elsif nums[right] >= nums[pivot]
+        right -= 1
+      end
+    end
+
+    swap(nums, pivot, right)
+    if pos == right
+      return nums[right]
+    elsif right < pos
+      start = right + 1
+    else
+      ending = right - 1
+    end
+  end
+end
+
+def swap(ar, i, j)
+  ar[i], ar[j] = ar[j], ar[i]
+end
+
+# 5
+puts quick_select([8, 5, 2, 9, 7, 6, 3], 3)
+
+# 1
+puts quick_select([1], 1)
+
+# 24
+puts quick_select([43, 24, 37], 1)
+
+# 2
+puts quick_select([8, 3, 2, 5, 1, 7, 4, 6], 2)

searching/range_search_iterative.rb

@@ -0,0 +1,49 @@
+# https://leetcode.com/problems/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 target is not found in the array, return [-1, -1].
+# You must write an algorithm with O(log n) runtime complexity.
+# Example 1:
+# Input: nums = [5,7,7,8,8,10], target = 8
+# Output: [3,4]
+
+def search_range(nums, target)
+  output_range = []
+  # try to go left
+  output_range << binary_search_helper(nums, target, true)
+
+  # go right
+  output_range << binary_search_helper(nums, target, false)
+  output_range
+end
+
+def binary_search_helper(nums, target, go_left)
+  left = 0
+  right = nums.length - 1
+  while left <= right
+    mid = (left + right) / 2
+    if target > nums[mid]
+      left = mid + 1
+    elsif target < nums[mid]
+      right = mid - 1
+    elsif go_left
+      if mid.zero? || nums[mid - 1] != target
+        return mid
+      else
+        right = mid - 1
+      end
+    elsif mid == nums.length - 1 || nums[mid + 1] != target
+      return mid
+    else
+      left = mid + 1
+    end
+  end
+  -1
+end
+
+# [-1, -1]
+puts search_range([5, 7, 7, 8, 8, 10], 6).to_s
+
+puts search_range([0, 1, 21, 33, 45, 45, 45, 45, 45, 45, 61, 71, 73], 45).to_s
+
+# [3,4]
+puts search_range([5, 7, 7, 8, 8, 10], 8).to_s

searching/range_search_recursive.rb

@@ -0,0 +1,50 @@
+# https://leetcode.com/problems/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 target is not found in the array, return [-1, -1].
+# You must write an algorithm with O(log n) runtime complexity.
+# Example 1:
+# Input: nums = [5,7,7,8,8,10], target = 8
+# Output: [3,4]
+#
+
+# recursive solution
+def search_range(nums, target)
+  output_range = [-1, -1]
+  # try to go left
+  binary_search_helper(nums, target, 0, nums.length - 1, output_range, true)
+
+  # go right
+  binary_search_helper(nums, target, 0, nums.length - 1, output_range, false)
+  output_range
+end
+
+# recursive solution
+def binary_search_helper(nums, target, left, right, output_range, go_left)
+  return if left > right
+
+  mid = (left + right) / 2
+  if target > nums[mid]
+    binary_search_helper(nums, target, mid + 1, right, output_range, go_left)
+  elsif target < nums[mid]
+    binary_search_helper(nums, target, left, mid - 1, output_range, go_left)
+  elsif go_left
+    # if value found at mid, we will try to go left or right
+    if mid.zero? || nums[mid - 1] != target
+      output_range[0] = mid
+    else
+      binary_search_helper(nums, target, left, mid - 1, output_range, go_left)
+    end
+  # if we are at 1st value or previous value is not same as target
+  # means we have found the start of the range value
+  elsif mid == nums.length - 1 || target != nums[mid + 1]
+    # we have reached at end of array or the next value is not equal to target
+    # we have found end of the range
+    output_range[1] = mid
+  else
+    binary_search_helper(nums, target, mid + 1, right, output_range, go_left)
+  end
+end
+
+puts search_range([5, 7, 7, 8, 8, 10], 6).to_s
+
+puts search_range([0, 1, 21, 33, 45, 45, 45, 45, 45, 45, 61, 71, 73], 45).to_s

searching/search_sorted_matrix.rb

@@ -1,4 +1,18 @@
-def search_sorted_matrix(matrix, target); end
+def search_sorted_matrix(matrix, target)
+  row = 0
+  col = matrix[0].length - 1
+
+  while row < matrix.length && col >= 0
+    if matrix[row][col] > target
+      col -= 1
+    elsif matrix[row][col] < target
+      row += 1
+    else
+      return [row, col]
+    end
+  end
+  [-1, -1]
+end
 
 matrix = [
   [1, 4, 7, 12, 15, 1000],
@@ -9,4 +23,6 @@ def search_sorted_matrix(matrix, target); end
 ]
 target = 44
 
-puts search_sorted_matrix(matrix, target)
+puts search_sorted_matrix(matrix, target).to_s
+puts search_sorted_matrix(matrix, 99).to_s
+puts search_sorted_matrix(matrix, 2323).to_s

searching/shifted_binary_search.rb

@@ -0,0 +1,80 @@
+# https://leetcode.com/problems/search-in-rotated-sorted-array/submissions/
+
+def shifted_binary_search(arr, target)
+  shifted_binary_search_helper(arr, target, 0, arr.length - 1)
+end
+
+# recursive solution
+def shifted_binary_search_helper(arr, target, left, right)
+  return -1 if left > right
+
+  mid = (left + right) / 2
+
+  left_num = arr[left]
+  right_num = arr[right]
+  mid_num = arr[mid]
+  if target == mid_num
+    mid
+  elsif left_num <= mid_num
+    if target >= left_num && target < mid_num
+      shifted_binary_search_helper(arr, target, left, mid - 1)
+    else
+      shifted_binary_search_helper(arr, target, mid + 1, right)
+    end
+  elsif target > mid_num && target <= right_num
+    shifted_binary_search_helper(arr, target, mid + 1, right)
+  else
+    shifted_binary_search_helper(arr, target, left, mid - 1)
+  end
+end
+
+def shifted_binary_search_iterative(arr, target)
+  left = 0
+  right = arr.length - 1
+
+  while left <= right
+    mid = (left + right) / 2
+    left_num = arr[left]
+    right_num = arr[right]
+    mid_num = arr[mid]
+    if target == mid_num
+      return mid
+    elsif left_num <= mid_num
+      if target >= left_num && target < mid_num
+        right = mid - 1
+      else
+        left = mid + 1
+      end
+    elsif target > mid_num && target <= right_num
+      left = mid + 1
+    else
+      right = mid - 1
+    end
+
+  end
+  -1
+end
+
+# 8
+puts shifted_binary_search([45, 61, 71, 72, 73, 0, 1, 21, 33, 37], 33)
+
+# 2
+puts shifted_binary_search([5, 23, 111, 1], 111)
+
+# -1
+puts shifted_binary_search([23, 111, 1, 5], 35)
+
+# 2
+puts shifted_binary_search([5, 1, 3], 3)
+
+# 8
+puts shifted_binary_search_iterative([45, 61, 71, 72, 73, 0, 1, 21, 33, 37], 33)
+
+# 2
+puts shifted_binary_search_iterative([5, 23, 111, 1], 111)
+
+# -1
+puts shifted_binary_search_iterative([23, 111, 1, 5], 35)
+
+# 2
+puts shifted_binary_search_iterative([5, 1, 3], 3)