As part of my first-ever submission to the ruby quiz, I wrote 
(translated from Python, really) a recursive routine to return all 
n-combinations of an array. So that:

combinations([1, 2, 3], 2)

would return

[[1, 2], [1, 3], [2, 3]]

and combinations([1, 2, 3], 2, false)

would return

[[1, 2], [1, 3], [2, 3], [2, 1], [3, 1], [3, 2]]

My original code was as follows (with some stupid corrections):

def combinations sequence, n, unique=true
  return [] if n == 0
  return sequence if n == 1
  result = []

  0.upto(sequence.length - 1) do |i|
    sub_sequence = sequence[(i + 1)..-1]
    sub_sequence += sequence[0..i] if not unique

    combinations(sequence[(i + 1)..-1], n - 1).each do |smaller|
      result << [sequence[i]] + smaller
    end
  end

  result
end

But this gives a "TypeError: can't convert Fixnum into Array", from the 
line "result << [sequence[i]] + smaller". After a few minutes of 
scratching my head, it became clear that sometimes the result of 
combinations(...) was an Array (which is expected) and sometimes it was 
of type whatever the array elements were (which is unexpected), 
whenever the array would be a singleton.

I ended up changing it to "result << ([sequence[i]] + 
[smaller]).flatten", but after I turned it in I realized that won't do 
- I'd want the code to handle cases where elements of the array are 
themselves arrays. I added the check "smaller = [smaller] if 
smaller.class != Array", but it doesn't *seem* like I should have to do 
that.

Where am I going wrong here?

Best,
James Cunningham