add tasks

Author: proton

week3/quicksort/interview-questions/task1/TASK.md

@@ -0,0 +1,3 @@
+### Nuts and bolts
+
+A disorganized carpenter has a mixed pile of `n` nuts and `n` bolts. The goal is to find the corresponding pairs of nuts and bolts. Each nut fits exactly one bolt and each bolt fits exactly one nut. By fitting a nut and a bolt together, the carpenter can see which one is bigger (but the carpenter cannot compare two nuts or two bolts directly). Design an algorithm for the problem that uses at most proportional to `n*log(n)` compares (probabilistically).

week3/quicksort/interview-questions/task1/solution.rb

@@ -0,0 +1,82 @@
+# def merge_sort(array, start: nil, finish: nil, buffer: nil)
+#   return if start == finish
+
+#   mid = (finish - start) / 2 + start
+
+#   merge_sort(array, start: start,   finish: mid,    buffer: buffer)
+#   merge_sort(array, start: mid + 1, finish: finish, buffer: buffer)
+
+#   i = 0
+#   j = 0
+#   b = 0
+#   loop do
+#     remaining = (j + mid + 1)..finish if i == mid + 1 - start
+#     remaining = (i + start)..mid      if j == finish - mid
+#     if remaining
+#       remaining.each do |k|
+#         buffer[b] = array[k]
+#         b += 1
+#       end
+#       break
+#     end
+#     x = array[i + start]
+#     y = array[j + mid + 1]
+#     if x < y
+#       buffer[b] = x
+#       i += 1
+#     else
+#       buffer[b] = y
+#       j += 1
+#     end
+#     b += 1
+#   end
+#   (0...b).each do |k|
+#     array[start + k] = buffer[k]
+#   end
+
+#   array
+# end
+
+# n = 10
+# a = n.times.map { rand(0..99) }.sort + n.times.map { rand(0..99) }.sort
+# b = Array.new(n)
+
+# p a
+
+# k = 0
+# i = 0
+# j = n
+
+# while k < n do
+#   if a[i] <= a[j]
+#     b[k] = a[i]
+#     a[i] = nil
+#     i += 1
+#   else
+#     b[k] = a[j]
+#     a[j] = nil
+#     j += 1
+#   end
+#   k += 1
+# end
+
+# i = 2 * n - 1
+# k = 2 * n - 1
+# while k >= n do
+#   if a[i]
+#     a[k] = a[i] unless k == i
+#     k -= 1
+#   end
+#   i -= 1
+# end
+
+# b.each_with_index do |e, i|
+#   a[i] = e
+# end
+
+# merge_sort(a, start: n, finish: 2*n - 1, buffer: b)
+
+# p b
+# p a
+# p a.sort
+# p a == a.sort

week3/quicksort/interview-questions/task2/TASK.md

@@ -0,0 +1,7 @@
+### Selection in two sorted arrays
+
+Given two sorted arrays `a[]` and `b[]`, of lengths `n1` and `n2` and an integer `0 ≤ k < n1 + n2`, design an algorithm to find a key of rank `k`. The order of growth of the worst case running time of your algorithm should be `log(n)`, where `n = n1 + n2`.
+
+- Version 1: `n1 = n2` (equal length arrays) and `k = n / 2` (median)
+- Version 2: `k = n / 2` (median)
+- Version 3: no restrictions

week3/quicksort/interview-questions/task2/solution.rb

@@ -0,0 +1,82 @@
+# def merge_sort(array, start: nil, finish: nil, buffer: nil)
+#   return if start == finish
+
+#   mid = (finish - start) / 2 + start
+
+#   merge_sort(array, start: start,   finish: mid,    buffer: buffer)
+#   merge_sort(array, start: mid + 1, finish: finish, buffer: buffer)
+
+#   i = 0
+#   j = 0
+#   b = 0
+#   loop do
+#     remaining = (j + mid + 1)..finish if i == mid + 1 - start
+#     remaining = (i + start)..mid      if j == finish - mid
+#     if remaining
+#       remaining.each do |k|
+#         buffer[b] = array[k]
+#         b += 1
+#       end
+#       break
+#     end
+#     x = array[i + start]
+#     y = array[j + mid + 1]
+#     if x < y
+#       buffer[b] = x
+#       i += 1
+#     else
+#       buffer[b] = y
+#       j += 1
+#     end
+#     b += 1
+#   end
+#   (0...b).each do |k|
+#     array[start + k] = buffer[k]
+#   end
+
+#   array
+# end
+
+# n = 10
+# a = n.times.map { rand(0..99) }.sort + n.times.map { rand(0..99) }.sort
+# b = Array.new(n)
+
+# p a
+
+# k = 0
+# i = 0
+# j = n
+
+# while k < n do
+#   if a[i] <= a[j]
+#     b[k] = a[i]
+#     a[i] = nil
+#     i += 1
+#   else
+#     b[k] = a[j]
+#     a[j] = nil
+#     j += 1
+#   end
+#   k += 1
+# end
+
+# i = 2 * n - 1
+# k = 2 * n - 1
+# while k >= n do
+#   if a[i]
+#     a[k] = a[i] unless k == i
+#     k -= 1
+#   end
+#   i -= 1
+# end
+
+# b.each_with_index do |e, i|
+#   a[i] = e
+# end
+
+# merge_sort(a, start: n, finish: 2*n - 1, buffer: b)
+
+# p b
+# p a
+# p a.sort
+# p a == a.sort

week3/quicksort/interview-questions/task3/TASK.md

@@ -0,0 +1,4 @@
+### Decimal dominants
+
+Given an array with `n` keys, design an algorithm to find all values that occur more than `n/10` times. The expected running time of your algorithm should be linear.
+

week3/quicksort/interview-questions/task3/solution.rb

@@ -0,0 +1,82 @@
+# def merge_sort(array, start: nil, finish: nil, buffer: nil)
+#   return if start == finish
+
+#   mid = (finish - start) / 2 + start
+
+#   merge_sort(array, start: start,   finish: mid,    buffer: buffer)
+#   merge_sort(array, start: mid + 1, finish: finish, buffer: buffer)
+
+#   i = 0
+#   j = 0
+#   b = 0
+#   loop do
+#     remaining = (j + mid + 1)..finish if i == mid + 1 - start
+#     remaining = (i + start)..mid      if j == finish - mid
+#     if remaining
+#       remaining.each do |k|
+#         buffer[b] = array[k]
+#         b += 1
+#       end
+#       break
+#     end
+#     x = array[i + start]
+#     y = array[j + mid + 1]
+#     if x < y
+#       buffer[b] = x
+#       i += 1
+#     else
+#       buffer[b] = y
+#       j += 1
+#     end
+#     b += 1
+#   end
+#   (0...b).each do |k|
+#     array[start + k] = buffer[k]
+#   end
+
+#   array
+# end
+
+# n = 10
+# a = n.times.map { rand(0..99) }.sort + n.times.map { rand(0..99) }.sort
+# b = Array.new(n)
+
+# p a
+
+# k = 0
+# i = 0
+# j = n
+
+# while k < n do
+#   if a[i] <= a[j]
+#     b[k] = a[i]
+#     a[i] = nil
+#     i += 1
+#   else
+#     b[k] = a[j]
+#     a[j] = nil
+#     j += 1
+#   end
+#   k += 1
+# end
+
+# i = 2 * n - 1
+# k = 2 * n - 1
+# while k >= n do
+#   if a[i]
+#     a[k] = a[i] unless k == i
+#     k -= 1
+#   end
+#   i -= 1
+# end
+
+# b.each_with_index do |e, i|
+#   a[i] = e
+# end
+
+# merge_sort(a, start: n, finish: 2*n - 1, buffer: b)
+
+# p b
+# p a
+# p a.sort
+# p a == a.sort