________________________

def addChar(str, level)
    ('a'..'z').each {|c|
        if level == 2
            puts str + c
        else
            str += c
            addChar(str, level + 1)
        end
    }
end

Cheers,

Erik.

addChar( str + c, level + 1 )

=)

On Nov 25, 2005, at 10:42 AM, cyberco wrote:

def combinations(elements, length)
  return [] if length == 0
  return elements if length == 1
  result = []
  elements.each do | element |
    combinations(elements, length - 1).each do | combination |
      result << element + combination
    end
  end
  result
end

# What you want
puts combinations(('a'..'c').to_a, 3)

# Using the power of ducktyping
combinations([[1], [2], [3]], 3).each do | combination |
  p combination
end

# What does this calculate?
combinations((1..3).to_a, 3).each do | combination |
  p combination
end

cheers,

Brian

--
http://ruby.brian-schroeder.de/

Not that you can't do it recursively:

def f(lhs)
   if lhs.length == 3
     puts lhs
   else
     for c in 'a'..'z'
       f(lhs + c)
     end
   end
end

f('')

('aaa'..'zzz').to_a is clearly a call to Range#to_a.

* `ri Range` tells you that Range gets #to_a from Enumerable.
* `ri Enumerable#to_a` tells you that it returns the elements yielded by
  a call to #each.  (Oh wait, it doesn't.  It should... .  Really,
  it's no secret that all of Enumerable's methods are defined in terms
  of #each, but I can't find it anywhere in the rdoc comments.)
* `ri Range#each` tells you that the elements yielded come from
  successive calls to each element's #succ method, starting with the
  start object ('aaa' in this case).
* `ri String#succ` tells you that 'aaa'.succ will return 'aab' (and so
  on).
* Profit!  (Er... QED.)

( 'aaa'.to_i(36)..'zzz'.to_i(36) ).map{ |i| (str=i.to_s(36)) =~ /^[a-
z]{3}$/ && str }.compact