benchmark.md

testing same problem speed

Take and array and remove the first element, keep the next one, remove the third and continue in that way until you have only one element in the array, example:

start with [1,2,3,4,5,6]

remove 1, keep 2, remove 3, keep 4, remove 5, keep 6, remove 2, keep 4, remove 6, then return 4.

• remover [1,2,3] => 2
• remover [1,2,3,4] => 4
• remover [1,2,3,4,5] => 2
• remover [1,2,3,4,5,6] => 4
• remover (1..7) => 2
• remover (1..8) => 8
• remover (1..9) => 6
• remover (1..10) => 4

Benchmark with one array with length 1.000.000

The input is and array from 1 to 1.000.000 in sequence

time node remover.js
621440

real	0m0.709s
user	0m0.661s
sys	0m0.048s

time elixir remover.ex
621440

real	0m1.876s
user	0m1.556s
sys	0m0.457s

time ruby remover.rb
621440

real	0m0.423s
user	0m0.386s
sys	0m0.018s

remover.ex

defmodule Remover do
  def rare(array, even \\ true)

  def rare(array, even) when length(array) > 1 do
   rare( filterable(array, even), new_even(array) )
  end

  def rare(array, _) when length(array) === 1 do
    Enum.at(array, 0)
  end

  defp filterable(array, even) do
    array
      |> Enum.with_index
      |> Enum.filter(fn(x) -> select(x, even) end)
      |> Enum.map( fn { value, _ } -> value end)
  end

  defp select({_, index}, even) when even === true do
    Integer.is_odd(index)
  end

  defp select({_, index}, even) when even === false do
    Integer.is_even(index)
  end

  defp new_even(array) do
    length(array) |> Integer.is_even
  end

end

Enum.to_list(1..1000000) |> Remover.rare |> IO.puts

remover.js

function remove(array, even) {
  if(typeof even === 'undefined') {
    even = true
  }

  if(array.length === 1) {
    return array[0]
  }

  var tail = array.filter(function(value, index) {
    if(even) {
      return index % 2 === 1
    } else {
      return index % 2 === 0
    }
  })

  var nextEven = array.length % 2 === 0

  return remove(tail, nextEven)
}

var range = new Array(1000000).join().split(',').map(function(v,i) { return ++i })

console.log(remove(range))

remover.rb

def remove(array, even = true)
  return array.first if array.length == 1

  tail = array.select.with_index { |item, key| (even) ? key.odd? : key.even? }
  next_even = array.length.even?
  remove tail, next_even
end

p remove (1..1000000).to_a