Una lista de ejemplos en Ruby de las funciones que pueden estar en el parcial

binnary_search.rb

# run using: ruby binnary_search.rb
require "minitest/autorun"

def mid_point(min, max)
  diff     = max - min
  mid_diff = (diff / 2).floor

  mid_diff + min
end

def binary_search(elements, key, index_min = 0, index_max = (elements.length-1))
  return nil if index_max < index_min

  index_mid = mid_point(index_min, index_max)

  if elements[index_mid] > key
    return binary_search(elements, key, index_min, index_mid-1)
  elsif elements[index_mid] < key
    return binary_search(elements, key, index_mid+1, index_max)
  else
    return index_mid
  end
end

class TestBubbleSort < Minitest::Test
  def test_it_finds_an_element_using_binary_search_in_odd_array
    assert_equal(5, binary_search([1,2,3,4,5,6,7,8,9,10], 6), "No se encontro el indice para 6 en un array impar")
  end

  def test_it_finds_an_element_using_binary_search_in_even_array
    assert_equal(10, binary_search([1,2,3,4,5,6,7,8,9,10,11], 11), "No se encontro el indice para 11 en un array par")
  end

  def test_it_doesnt_find_an_element_using_binary_search_in_odd_array
    assert_equal(nil, binary_search([1,2,3,4,5,6,7,8,9,10,11], 12), "Se encontro el indice 12 en un array par desordenado")
  end

  def test_it_doesnt_find_an_element_using_binary_search_in_even_array
    assert_equal(nil, binary_search([1,2,3,4,5,6,7,8,9,10], -1), "Se encontro el indice -1 en un array par desordenado")
  end
end

bubble_sort.rb

# run using: ruby bubble_sort.rb
require "minitest/autorun"

def bubble_sort(elements)
  n = elements.length

  begin
    swapped = false
    (1..n-1).each do |i|
      if (elements[i-1] > elements[i])
        aux           = elements[i-1]
        elements[i-1] = elements[i]
        elements[i]   = aux
        swapped       = true
      end
    end
  end while swapped

  elements
end

class TestBubbleSort < Minitest::Test
  def test_it_returns_the_same_array_if_it_is_sorted
    assert_equal( [1,2,3], bubble_sort([1,2,3]), "Los elementos ordenados de menor a mayor no deberían reordenarse" )
  end

  def test_it_returns_a_little_sorted_array
    assert_equal( [1,2,3], bubble_sort([3,2,1]), "Debería de retornar los elementos ordenados de menor a mayor" )
  end

  def test_it_returns_a_huge_sorted_array
    assert_equal( [1,2,3,5,7,9,20,388,2837,18237172,1239239323],
                  bubble_sort([20,18237172,3,1239239323,2837,9,1,388,7,2,5]),
                  "Debería de retornar los elementos ordenados de menor a mayor" )
  end
end

fibonacci.rb

# run using: ruby fibonacci.rb
require "minitest/autorun"

def fibonnacci(number)
  return 0 if (number <= 0)
  return 1 if (number == 1)
  fibonnacci(number-1) + fibonnacci(number-2)
end

class TestFibonacci < Minitest::Test

  def test_it_returns_0_when_it_receives_a_negative_number
    assert_equal(0, fibonnacci(-10), "Debería retornar 0 para -10" )
  end

  def test_it_returns_0_when_it_receive_0
    assert_equal(0, fibonnacci(0), "Debería retornar 0 para 0" )
 end

  def test_it_returns_1_when_it_receive_1
    assert_equal(1, fibonnacci(1), "Debería retornar 1 para 1" )
  end

  def test_it_return_2_when_it_receive_2
    assert_equal(1, fibonnacci(2), "Debería retornar 1 para 2" )
  end

  def test_it_return_3_when_it_receive_3
    assert_equal(2, fibonnacci(3), "Debería retornar 2 para 3" )
  end

  def test_it_return_3_when_it_receive_3
    assert_equal(3, fibonnacci(4), "Debería retornar 3 para 4" )
  end

end