Pascal's triangle in Ruby (See related posts)

# cf. http://www.ruby-forum.com/topic/97105

6.times { k=0; p $*.map!{|i|k+k=i} << 1 }

# ... or ...

ar=[]; 6.times { k=0; p ar.map!{|i|k+k=i} << 1 }


# a more general approach (for polynomials)

class Polynomial

   def triangle(nterms, row, pos=nil)

      return nil if nterms < 2 || row < 1
      nterms = nterms - 2
      num_of_rows = row

      var1 = 0 + nterms   
      var2 = 1 + nterms
      var3 = 3 + nterms 
  
      ar1 = [0, 1, 0]   # first row
      var1.times { ar1.push(0) }
      var1.times { ar1.unshift(0) }

      ar2 = []
      ar3 = []
      ar4 = [[1]]

      for num in 0..(num_of_rows - 1)  

         nextnum = ar1.size - var2

         for nextn in 1..nextnum
            sum = 0
            count = 0
            ar1.each do |n|  
               count += 1 
               if count < var3 then t = sum += n; ar2 << t else break end 
            end

            ar3 << ar2.last
            ar2.clear
            ar1.shift

         end   # second for-loop

         ar1.clear
         ar1 << ar3
         ar1.flatten!

         var2.times { ar1.push(0) }
         var2.times { ar1.unshift(0) }

         ar4 << ar3
         ar3 = []

      end  # first for-loop

      if !pos.nil?
         ret = ar4.at(row).at(pos)
         return "No such position: #{pos} in row: #{row}" if ret.nil?
         ret
      else
         ar4.map! { |r| r.join('-') }
         ar4
      end
   end 
end 


puts Polynomial.new.triangle(2, 5)
puts Polynomial.new.triangle(3, 5)
puts Polynomial.new.triangle(4, 5)
puts Polynomial.new.triangle(5, 5)
puts Polynomial.new.triangle(5, 4, 8)
puts Polynomial.new.triangle(4, 9)
puts Polynomial.new.triangle(4, 9, 10)


#------------------------


class Integer
   def fak
      f=1
      (2..self).each { |i| f *= i   }
      f
   end
end

module Enumerable
   def sum
      inject { |n, m| n + m  }
   end
end

# cf. http://blade.nagaokaut.ac.jp/~sinara/ruby/math/combinatorics/array-rep_perm.rb
class Array
  def rep_perm(n)
    if n < 0
    elsif n == 0
      yield([])
    else
      rep_perm(n - 1) do |x|
	each do |y|
	  yield(x + [y])
	end
      end
    end
  end
end


nterms = 2
exponent = 80
exponent = 8

# create the same number of variable names as there are terms 
# example: ['a', 'b'] for (a+b)**3

var_names = ('a'..'z').to_a.slice(0, nterms)
#var_names = (('a'..'z').to_a << ('A'..'Z').to_a << ('aa'..'zz').to_a).flatten!.slice(0, nterms)

ar1 = []
(0..exponent).to_a.rep_perm(nterms) { |x| p x; ar1 << x if x.sum == exponent }   # example: ... if [2,6].sum == 8
ar1.reverse!

#p ar1
#puts ar1

ar2 = []

ar1.each do |term|

   #puts "term: #{term.inspect}"  # example: term: [5, 0, 0]
   count = 0
   var1 = 1
   term.each { |i| var1 *= i.fak }
   var2 = exponent.fak / var1 
   var3 = "#{var2}   (  #{ term.join('-') << '-' } )"  # prepare term for parsing with gsub below
   ar2 << var3

end

#p ar2

result = ar2.collect do |term|
   p term
   count = -1
   term.gsub!(/(\d+)-/)  { count += 1;  "#{var_names.at(count)}" << '**' << $1 << ' ' }
   term.gsub!(/^(\d+)( +)/, '\1\2*\2')
end

puts result