Time complexity in Ruby programs

Chennai.rb meet-up 25-june-2016

@h6165

Abhishek Yadav

ரூபீ ப்ரோக்ராமர்

Co-organizer: Chennai.rb

Topics covered

• Search and binary search
• Big O notation
• Time complexity
• Example-2
• Accidentally quadratic
• Space complexity
• Example-3

Search and binary search

## Search an element in the given, sorted array

def search1(arr, input)
  i = 0
  while i < arr.size do
    return i if arr[i] == input
    i += 1
  end
end
  

input = 73
arr = [3, 10, 22, 72, 100, 344]

search1(73, arr)

Sequencial search

In the worst case it has to go ever the whole array

Search and binary search

## Search an element in the given, sorted array

def bsearch(arr, input, start=0, finish=arr.size-1)

  if start == finish
    return arr[start] == input ? start : nil
  end

  mid = start + (finish - start)/2

  case
  when input == arr[mid]  then return mid
  when input <  arr[mid]  then return bsearch(arr, input, start, mid)
  when input >  arr[mid]  then return bsearch(arr, input, mid+1, finish)
  end
end
  

input = 73
arr = [3, 10, 22, 72, 100, 344]

search1(73, arr)

Binary search

Search and binary search

Binary search

visualization: searching 33

Search and binary search

Binary search

• It has to traverse a tree like path
• In the worst case, it can be depth of the tree
• Which is log(n) : n = array size
• Hence: O(log n)

Big O notation

• Time taken by algorithm is expressed as a function of size of input
• Sequencial search: O(n)
  • For an list sized n, it may have to traverse all the elements.
• Binary search: O(log n)
  • For a list sized n, it may have to traverse upto log n elements.
• Selection sort: O(n^2)
  • It may have to traverse the whole list twice. Hence squared
• ​O(1)
  • ​Constant time: doesn't depend on size of input

Selection sort

# Selection sort (very slow on large lists)

a = [9,8,6,1,2,5,4,3,9,50,12,11]
n = a.size - 1

n.times do |i|
  index_min = i

  (i + 1).upto(n) do |j|
    index_min = j if a[j] < a[index_min]
  end
  
  # Yep, in ruby I can do that, no aux variable. w00t!
  a[i], a[index_min] = a[index_min], a[i] if index_min != i
end


## Credit: https://gist.github.com/brianstorti/953310

Big O notation

• Big-O values may be different with different datasets
• Worst case and average case scenarios must be considered
• Quick-sort has O(nlogn), better than others in worst case

Optimization

• Time complexity can be sometimes improved by using space complexity
• Use the Ruby hash

Optimization

users = User.where(active: true).to_a


## TODO

Quiz

# What is the time complexity here?

def foo(arr)

   1.upto(100).each do |i|
     1.upto(1000).each do |j|
       puts arr[i] + arr[j]
     end
   end

end