def calculate_mode(nums, time_start)
  hi_count = 0
  mode = nums[0]

  puts "\ncalculate_mode(nums)"
  puts "===================="

  nums.each do | search_for |

    count = 0
    nums.each do |num|
      if search_for == num
        count += 1
      end
      $loop_count += 1
    end

    if count > hi_count
      hi_count = count
      mode = search_for
    end

  end

  # show results
  puts "mode => " + mode.to_s + " (it occurs " + hi_count.to_s + " times)" 
  puts "\narray length was " + nums.length.to_s
  puts "num loops was " + $loop_count.to_s
  puts "completed in " + (Time.now - time_start).to_s
end

def calculate_mode_fast(nums, time_start)

  puts "\ncalculate_mode_fast(nums)"
  puts "========================="

  # sort array first
  sorted_nums = quicksort(nums)

  hi_count = 0
  mode = nums[0]  
  count = 1
  idx = 1

  sorted_nums.each do | search_for |
   $loop_count += 1
   if search_for == sorted_nums[idx]
     count += 1
     if count > hi_count
       hi_count = count
       mode = search_for
     end
   else
     count = 1
   end
   idx += 1 if idx < sorted_nums.length
  end

  # show results
  puts "mode => " + mode.to_s + " (it occurs " + hi_count.to_s + " times)"
  puts "\narray length was " + nums.length.to_s
  puts "num loops was " + $loop_count.to_s
  puts "completed in " + (Time.now - time_start).to_s
end

# recursive quick-sort algorithm
def quicksort(a)
  return a if a.size <= 1
  pivot = a[0]
  $loop_count += 1
  quicksort(a.select {|i| i < pivot }) + a.select {|i| i == pivot } + quicksort(a.select {|i| i > pivot })  
end


# set global to count number of loops
$loop_count = 0

# generate nums array (of random integers between 0 and 40)
max_num    = 40
nums       = []

(1..1000).each do | idx |
  nums << (rand max_num)
end


# start calculating
$loop_count = 0
calculate_mode(nums, Time.now)
$loop_count = 0
calculate_mode_fast(nums, Time.now)