hoge.rb

def assert(expr, exp)
  ret = eval(expr)
  raise "fail: #{expr}; expected #{exp} but was #{ret}" if ret != exp
end

def hoge(arr)
  ret = [false, false]
  arr.each do |e|
    ret[0] ||= !!e
    ret[1] ||= !e
    return true if ret[0] && ret[1]
  end
  false
end

assert 'hoge([nil, nil])', false
assert 'hoge([true, true])', false
assert 'hoge([])', false
assert 'hoge([true, nil])', true
assert 'hoge([nil, true])', true

def hoge2_help(arr, idx, ret1 = false, ret2 = false)
  if ret1 && ret2
    true
  elsif arr.size == idx
    false
  else
    e = arr[idx]
    hoge2_help(arr, idx + 1, ret1 || !!e, ret2 || !e)
  end
end

def hoge2(arr)
  hoge2_help(arr, 0)
end

assert 'hoge2([nil, nil])', false
assert 'hoge2([true, true])', false
assert 'hoge2([])', false
assert 'hoge2([true, nil])', true
assert 'hoge2([nil, true])', true

def hoge3_help(arr, predicates)
  predicates.all? { |fn| arr.any?(fn) }
end

def hoge3(arr)
  hoge3_help(arr, [->{ !!_1 }, ->{ !_1 }])
end

assert 'hoge3([nil, nil])', false
assert 'hoge3([true, true])', false
assert 'hoge3([])', false
assert 'hoge3([true, nil])', true
assert 'hoge3([nil, true])', true

def hoge4_help(arr, predicates)
  ret = Array.new(predicates.size, false)
  arr.each do |e|
    predicates.each_with_index do |fn, i|
      ret[i] ||= fn.call(e)
    end
    return true if ret.all?
  end
  false
end

def hoge4(arr)
  hoge4_help(arr, [->{ !!_1 }, ->{ !_1 }])
end

assert 'hoge4([nil, nil])', false
assert 'hoge4([true, true])', false
assert 'hoge4([])', false
assert 'hoge4([true, nil])', true
assert 'hoge4([nil, true])', true

def hoge5(arr)
  ret = [false, false]
  a = arr.drop_while do |e|
    ret[0] ||= !!e
    ret[1] ||= !e
    !ret[0] || !ret[1]
  end
  !a.empty?
end

assert 'hoge5([nil, nil])', false
assert 'hoge5([true, true])', false
assert 'hoge5([])', false
assert 'hoge5([true, nil])', true
assert 'hoge5([nil, true])', true

def hoge6(arr)
  ret = arr.inject([false, false]) { |acc, e| [acc[0] || !!e, acc[1] || !e] }
  ret.all?
end

assert 'hoge6([nil, nil])', false
assert 'hoge6([true, true])', false
assert 'hoge6([])', false
assert 'hoge6([true, nil])', true
assert 'hoge6([nil, true])', true

def hoge7(arr)
  ret = arr.each_with_object([false, false]) do |e, a|
    a[0] ||= !!e
    a[1] ||= !e
  end
  ret.all?
end

assert 'hoge7([nil, nil])', false
assert 'hoge7([true, true])', false
assert 'hoge7([])', false
assert 'hoge7([true, nil])', true
assert 'hoge7([nil, true])', true

def hoge8(arr)
  arr.chunk { !!_1 }.first(2).size == 2
end

assert 'hoge8([nil, nil])', false
assert 'hoge8([true, true])', false
assert 'hoge8([])', false
assert 'hoge8([true, nil])', true
assert 'hoge8([nil, true])', true
assert 'hoge8([true])', false
assert 'hoge8([true, nil, true])', true
assert 'hoge8([nil, true, nil])', true
assert 'hoge8([true, true, nil])', true
assert 'hoge8([nil, nil, true])', true