用Ruby amb解决一个puzzle

请回答下面10个问题，各题都恰有一个答案是正确的：
（1）第一个答案是B的问题是哪一个？
A、2      B、3      C、4      D、5        E、6

（2）恰好有两个连续问题的答案是一样的，它们是：
A、2，3      B、3，4      C、4，5      D、5，6      E、6，7

（3）本问题答案和哪一个问题的答案相同？
A、1      B、2      C、4      D、7     E、6

（4）答案是A的问题的个数是：
A、0       B、1       C、2       D、3     E、4

（5）本问题答案和哪一个问题的答案相同？
A、10     B、9       C、8        D、7     E、6

（6）答案是A的问题的个数和答案是什么的问题的个数相同？
A、B      B、C       C、D         D、E     E、以上都不是

（7）按照字母顺序，本问题的答案和下一个问题的答案相差几个字母？
A、4       B、3      C、2          D、1      E、0（注：A和B相差一个字母）

（8）答案是元音字母的问题的个数是：
A、2       B、3       C、4         D、5        E、6（注：A和E是元音字母）

（9）答案是辅音字母的问题的个数是：
A、一个质数       B、一个阶乘数       C、一个平方数       D、一个立方数       E、5的倍数

（10）本问题的答案是：
A、A       B、B         C、C        D、D        E、E

---

Ruby语言基于amb的解决方案，本质上，这是一个backtrack search：

# A B C D E
# 0 1 2 3 4 
class ConstraintChecker
  def initialize
    @constraints = [
     # each constraint lambda expression should return false
     # if the corresponding answer(the "this_answer" param) 
     # is violated by answers seen so far(the "ans" param), 
     # and true if the answer is satisfied or can not be judged yet
     #~ lambda {|ans, this_answer| #test code
         #~ a = [1, 1, 2, 3, 1, 2, 3, 4, 3, 1]

         #~ 0.upto(ans.length - 1) {|i|
           #~ break false if ans[i] && ans[i]!=a[i] 
         #~ } != false # true if break not executed
      #~ },
      #q1
      lambda {|ans, this_answer|
        firstB = [1,2,3,4,5][this_answer]
        ans[firstB] == nil or ans.index(1) == firstB
      },
      #q2
      lambda {|ans, this_answer|
        idx = [1,2,3,4,5][this_answer]
        # ans[idx] is the same as ans[idx+1]
        0.upto(ans.size-2) {|i|
          #~ puts "i=#{i}, idx=#{idx}, ans[i]=#{ans[i]}, ans[i+1]=#{ans[i+1]}"
          break true if ans[i+1] == nil
          break false if ((i==idx) != (ans[i]==ans[i+1]))
        } != false
        #~ ans[idx]==nil or ans[idx]==ans[idx-1]
      },
      #q3
      lambda {|ans, this_answer|
        same = [0, 1, 3, 6, 5][this_answer]
        (ans[same] == nil) or (ans[same] == this_answer)
      },
      #q4
      lambda {|ans, this_answer|
        numOfA = [0, 1, 2, 4, 5][this_answer]
        (ans.last == nil) or (ans.select{|i|i==0}.size == numOfA)
      },
      #q5
      lambda {|ans, this_answer|
        same = [9, 8, 7, 6, 5][this_answer]
        (ans[same] == nil) or (ans[same] == this_answer)
      },
      #q6
      lambda {|ans, this_answer|
        return true if ans.last == nil
        #       A, B, C, D, E
        nums = [0, 0, 0, 0, 0]
        [0, 1, 2, 3, 4].each do |i|
          ans.each do |j|
            nums[i] += 1 if i==j
          end
        end
        
        idToA =[]
        1.upto nums.size-1 do |i|
          idToA << i if nums[i] == nums[0]
        end
        
        (idToA.empty? and this_answer == 4) || (idToA.size == 1 and idToA[0] == this_answer+1)
        
      },
      #q7
      lambda {|ans, this_answer|
        nextAnswer = ans[7]  
        return true if nextAnswer == nil
        [4, 3, 2, 1, 0][this_answer] == (this_answer - nextAnswer).abs
      },
      #q8
      lambda {|ans, this_answer|
        return true if ans.last == nil
        ans.select{|i| i==0 or i==4}.size == [2,3,4,5,6][this_answer]
      },
      #q9
      lambda {|ans, this_answer|
        return true if ans.last == nil
        numCon = ans.select{|i| i==1 or i==2 or i==3}.size
        
        conds = [[2, 3, 5, 7], [1, 2, 6], [1, 4, 9], [1, 8], [0, 5, 10]]
        conds.each_index do |i|
          break false if (i == this_answer) != (conds[i].include? numCon)
        end != false
      },
      #q10
      lambda {|ans, this_answer|
        true
      }
    ]
  end
  
  def Check(answers, upto=nil)
    if (upto!=nil)  
      (upto+1).upto answers.size-1 do |idx|
        answers[idx]=nil
      end
    end
    #~ print "Checking "; dump answers; puts
    answers.each_index do |i|
      break unless answers[i] 
      return false unless @constraints[i].call(answers, answers[i])
    end
  
    true
  end #of method Check
  
  def num_constraint
    @constraints.size
  end
  
  # exposion for debug purpose
  attr_reader :constraints
end #of class ConstraintChecker

class AmbSolver

  def initialize
    @checker = ConstraintChecker.new
    @result = Array.new
  end
  
  def solve
    require 'amb'
    a = Amb.new
    begin
      answers = Array.new @checker.num_constraint
      answers.each_index do |i|
        next_answers = (0..4).to_a.collect{|n| answers[i]=n; answers.dup}
        answers = a.choose(*next_answers)
        a.assert @checker.Check(answers)
      end
      @result << answers.dup
      a.failure
    rescue Amb::ExhaustedError
    end
    @result
  end

end #of class AmbSolver

def dump answers
  answers.each do |a|
    (a==nil)? print('?') : print(('A'..'Z').to_a[a])
    print " "
  end
end

if __FILE__ == $0
  puts "Consistent answers:"
  start = Time.now
  result = AmbSolver.new.solve
  elapsed = Time.now - start
  result.each do |a|
    dump a
    puts
  end
  puts("time ", elapsed) #0.468
end

其中amb.rb库是Jim Weirich用continuation写出来的，我改动了一点：

# Modified Amb, originally by Jim Weirich
class Amb
    class ExhaustedError < RuntimeError; end
    
    def initialize
        @fail = proc { fail ExhaustedError, "amb tree exhausted" }
    end
    
    def choose(*choices)
        prev_fail = @fail
        choices.each { |choice|
            callcc { |fk|
                @fail = proc {
                    @fail = prev_fail
                    fk.call(:fail)
                }
                if choice.respond_to? :call
                    return choice.call
                else
                    return choice
                 end
            }
        }
        @fail.call

    end
    
    def failure
        choose
    end
    
    def assert(cond)
        failure unless cond
    end
end