如何在 Ruby 中构建一个基本的“英语计算器”？

Question

所以我目前正在优秀的CodeWars 网站上进行 Ruby 培训，遇到了一个比我的水平略高的问题，但如果我能看一下/an，感觉它真的可以帮助我的编码开发回答并在我的大脑中推动一下。一种缺失链接类型的交易。

问题是如何构建Calc类来达到如下效果：

class Calc
end

Calc.new.one.plus.two             # Should return 3
Calc.new.five.minus.six           # Should return -1
Calc.new.seven.times.two          # Should return 14
Calc.new.nine.divided_by.three    # Should return 3

该类只需要处理单个数字输入 0-9 和 + - * / 运算符，格式将始终是如上所示的 3 个方法链（即数字运算符号）。

我很想阅读您的一些解决方案，如果您不介意，请阅读您在解决它时所经历的思考过程。谢谢！

Answer 1

不是最好的解决方案，但符合要求：

class Calc
  ENGLISH_TO_OP = Hash[%i{zero one two three four five six seven eight nine}
    .each_with_index.to_a].merge(plus: :+, minus: :-, times: :*, divided_by: :/)

  def method_missing(m)
    if s = ENGLISH_TO_OP[m]
      (@cmd ||= []) << s
      return @cmd[0].send(*@cmd[1..2]) if @cmd.size == 3
      self
    else
      super
    end
  end
end

允许：

2.1.0 :015 > Calc.new.seven.times.two
 => 14 
2.1.0 :016 > Calc.new.nine.divided_by.three
 => 3 
2.1.0 :017 > Calc.new.five.minus.six
 => -1 
2.1.0 :018 > Calc.new.one.plus.two
 => 3 

我不想写很多代码，所以method_missing 比必须定义方法要好，即使它可能会出现问题，因此我倾向于避免它。哈希查找适用于指定的操作数和操作，each_with_index 可以填充值。在条件中将查找的值分配给 s 只是懒惰。最后，我可以在初始化程序中初始化 @cmd，但这样代码更少，并且可以防止 @cmd 稍后被另一种方法重置为 nil。

Answer 2

这个怎么样？

class Calc
  attr_accessor :result, :last_operator

  def initialize(result=0)
   @result = result
  end

  OPERATORS = {
    :plus => :+, :minus => :-, :times => :*, :divided_by => :/
  }

  OPERANDS = [ :zero, :one, :two, :three, :four, :five, :six, :seven, :eight, :nine, :ten, :eleven, :twelve ] 

  def method_missing(m, *args, &block)
    if OPERATORS.include?(m.to_sym)
      @last_operator = m.to_sym
      return self 
    elsif OPERANDS.include?(m.to_sym)
      if @last_operator.nil?
        @result = OPERANDS.index(m.to_sym)
        return self
      end
      @result = eval("#{@result} #{OPERATORS[@last_operator]} #{OPERANDS.index(m.to_sym)}")
      return @last_operator.nil? ? self : @result
    end

    super
  end
end


[20] pry(main)> Calc.new.three.times.seven
=> 21
[21] pry(main)> Calc.new.twelve.divided_by.two
=> 6

Answer 3

假设方法不会以无效的方式使用：

class Calc
  def self.operand name, v
    define_method(name) do
      @operator ? @operand.send(@operator, v) : (@operand = v; self)
    end
  end
  def self.operator name, v
    define_method(name) do
      @operator = v; self
    end
  end

  operand :one, 1
  operand :two, 2
  ...
  operator :plus, :+
  operator :minus, :-
  ...
end

Answer 4

这里还有一个使用#method_missing 的技巧：

class Calc
    attr_reader :val
    def initialize
      # operand hash
      @hsh_num = {one: 1,two: 2, three: 3,four: 4,five: 5,six: 6}
      # operator hash
      @hsh_op = {plus: '+', minus: '-',times: '*',divided_by: '/'}
    end
    def method_missing(symbol)
      if @hsh_num[symbol]
        @val = @meth.is_a?(Method) ? @meth.call(@hsh_num[symbol]) : @hsh_num[symbol]
      end
      if @hsh_op[symbol]
        @meth = @val.method(@hsh_op[symbol])
      end
      self
    end
end

# I just added one more method val, to get the last output.
# a bit change I did.
Calc.new.one.plus.two.plus.two.val # => 3
Calc.new.five.minus.six.val # => -1

我并没有完全实现它。但你可以从中得到一个想法，适合你的情况。