```My first quiz attempt ever so go easy on me :)

>From looking at the submissions so far it seems like my solution is
quite verbose but I am proud to have a solution that works! (Extra
Credit Too)

#file permutate.rb
module Permutate

def Permutate.generate(n)
permutations = Array.new
perm = Array.new

#first permutation
(1..n).each{|i|
perm << i
}

#	print "#{perm}\n"
permutations << perm.to_s

(2..(fact(n))).each do |i|
m = n - 2

while (perm[m] > perm[m+1])
m = m - 1
end
k = n - 1

while perm[m] > perm[k]
k = k - 1
end
swap(perm,m,k)
p = m + 1
q = n - 1
while p < q
swap(perm,p,q)
p = p + 1
q = q - 1
end
#		print "#{perm}\n"
permutations << perm.to_s
end
permutations
end

def Permutate.swap(array, a, b)
temp = array[a]
array[a] = array[b]
array[b] = temp
end

def Permutate.fact(n)
return 1 if n == 0
result = 1
(2..n).each do |i|
result *= i
end
result
end

end

#file equation.rb
class Equation

#digits contains an array of digits in the problem
#rhs is the right hand side of the equation
#overlay is a string representation of operators
# and their position in available positions between
# digits

def initialize(digits, rhs, overlay)
@digits = digits
@rhs = rhs
@overlay = overlay
@eqn = buildEquation

@valid = isValid?
end

def buildEquation
equation = @digits.to_s

#overlay permutation string over digits
#put a space before and after all operators
(0.. / overlay.size).each{|i|
equation.insert((4*i + 1)," #{@overlay[i,1]} ")
}

#take _ placeholders out
equation.gsub!(" _ ","")

return equation
end

def isValid?
(eval(@eqn) == @rhs)
end

def to_s
#output the equation in standard format
result = "#{@eqn} = #{eval(@eqn)}".squeeze(" ")

if @valid
marker = "*" * result.size
return "#{marker}\n#{result}\n#{marker}"
else
return result
end
end

end

#file equationlist.rb
require 'permutate'
require 'equation'

class EquationList

def initialize(digits, operators, rhs)
@digits = digits
@operators = operators
@rhs = rhs
@list = Array.new
end

def build
#get permutations for location of operators
perms = Permutate.generate(@digits.size - 1)

#now assign each operator to a number in the perms list
operators.each_with_index{|operator,i|
perms.each{|perm|
perm.sub!(Regexp.new((i+1).to_s),operator)
}
}

#now replace each number left with _
#to denote that field is unused
perms.each{|perm|
perm.gsub!(/\d/,"_")
}

#now we need to get rid of nonunique equations
perms.uniq!

#now build a list of equation objects with this information
perms.each{|perm|
#puts perm
@list << Equation.new(@digits,@rhs,perm)
}
end

def display
puts @list
puts "#{@list.size} possible equations tested"
end
end

#file getTo100.rb
require 'equationlist'

digits = %w[1 2 3 4 5 6 7 8 9]
operators = %w[+ - -]
rhs = 100

equations = EquationList.new(digits, ops, rhs)
equations.build
equations.display

Comments are welcome, I'm here to learn!

Matt Hulse
matt.hulse / gmail.com

```