My solution below uses simple recursion - hopefully it's easy to read
and understand.  It meets the extra credit criteria.

Looking forward to seeing how some of the power of Ruby could be used
by others to create a more elegant solution.  (I admit my solution is
a bit lacklustre!)

Thanks to Gavin & James.

# Marcel Ward   <wardies ^a-t^ gmaildotcom>
# Saturday, 2006-04-07
# Solution for Ruby Quiz #119  <http://www.rubyquiz.com/>
#
################################################
# getting-to-x.rb

class GettingToX
  def initialize(no_of_plusses, no_of_minusses, target_number)
    @plusses = no_of_plusses
    @minusses = no_of_minusses
    @target = target_number
  end

  # Recursively called whilst preparing the calculation string,
  # which is passed in calc_prefix
  def prepare_sum(rem_plus, rem_minus, cur_digit, calc_prefix)
    cur_digit += 1

    # Do we have any remaining plus signs to use up?
    if rem_plus > 0
      prepare_sum(rem_plus - 1, rem_minus, cur_digit,
        calc_prefix + " + %c" % (?0 + cur_digit))
    end

    # Do we have any remaining minus signs to use up?
    if rem_minus > 0
      prepare_sum(rem_plus, rem_minus - 1, cur_digit,
        "#{calc_prefix} - %c" % (?0 + cur_digit))
    end

    digits_remaining = 10 - cur_digit
    if rem_plus + rem_minus < digits_remaining
      # We can use a digit here and we'll still have room to
      # fit in all our operators later
      prepare_sum(rem_plus, rem_minus, cur_digit,
        "#{calc_prefix}%c" % (?0 + cur_digit))
    elsif rem_plus + rem_minus == 0
      # We have run out of operators; use up all the digits
      cur_digit.upto(9) {|n| calc_prefix += "%c" % (?0 + n)}
      calc(calc_prefix)
    end
  end

  # Print out the sum (with highlights if the target value was hit).
  def calc(whole_sum)
    result = eval(whole_sum)
    target_hit = (result == @target)
    puts '*' * 30 if target_hit
    puts whole_sum + ' = ' + result.to_s
    puts '*' * 30 if target_hit
    @total_evals += 1
    @target_matches += 1 if target_hit
  end

  def do_sums
    @total_evals = 0
    @target_matches = 0
    # We must always start with a string containing the first digit,
    # i.e. "1" because after this comes either the next digit or +/-
    prepare_sum(@plusses, @minusses, 1, '1')
    puts "#{@total_evals} possible equations tested"
    @target_matches
  end
end

# Show results for 1 plus, 2 minusses, target of 100
x = GettingToX.new(1, 2, 100)
matches = x.do_sums

# How did we do?
puts "** #{matches} equation(s) matched target value **"


-- 
Marcel