HoneyHoney

故事是这样的，如果我在创建一个实例以后，再去编辑类并增加一个方法，这个实例是能够发现新的方法的。

class Dog
  def name
    
  end
end

a_dog = Dog.new

p a_dog.methods

class Dog
  def age
    
  end
end

p a_dog.methods

同理，在已经included 的module里增加一个新的方法。

module Professor
  def lectures
    
  end
  
end

class Mathematician
  attr_accessor :first_name, :last_name
  include Professor
end

fett = Mathematician.new

p fett.methods


module Professor
  def primary_classroom
    
  end
  
end

p fett.methods # this will have new method

但是，如果在已经included的module里面include一个新的module，这样就不行了。

module Employee
  def hired_date
    
  end
  
end

module Professor
  include Employee
end

p fett.methods # this will not have hired_date method until Mathematician included Professor again

原因在于，前两者影响的是方法表而已，而实例对应的klass里面留下的只是方法表pointer，而不是具体的方法。所以，在方法表里面增加方法是可行的。
但是，include 一个新的module，是会改变super pointer。在第一次include的时候，就已经“复制”好module并设置好了super pointer，不会再次改变。除非，重新打开类再include一次。

给指定的硬币类型，用最少的硬币个数，找出指定的amount。比如，现在有[2, 5, 10, 20, 50]这几种硬币，找出21块钱出来。

这个其实是算法导论里面动态规划。无意间，发现还有其他的实现方法。记录下来。

首先是动态规划。原来是，21块钱，可以拆分成19+2， 16+5， 11+10， 1+20。19又可以继续拆分成17+2, 14+5, 9+10。以此类推下去。里面有个技术点就是，还可以用block去定义Hash，厉害了。代码如下：

 def change(coins, amount, results = [])
    return [] if amount == 0

    coins.sort! { |a, b| a <=> b }

    optimal_change = Hash.new do |hash, key|

      if key < coins.min
        hash[key] = []
      elsif coins.include?(key)
        hash[key] = [key]
      else
        hash[key] = coins
            .reject { |coin| coin > key }
            .map { |coin| [coin] + hash[key - coin] }
            .reject { |change| change.inject(&:+) != key }
            .min { |a, b| a.size <=> b.size } || []
      end

      puts hash
      hash[key]
    end

    optimal_change[amount].empty? ? -1 : optimal_change[amount].sort
end

另外一种方法是，创建一个数组，从1到amount，然后逐一用coin去替代，最后一个就是amount对应的coin了。

  def change(coins, total_change)
    return -1 if total_change < 0 || coins.any? { |x| x < 1 }
    m = [[]] + [nil] * total_change
    coins.size
         .times
         .to_a
         .product((1..m.size - 1).to_a)
         .each { |c, t|
           if coins[c] == t
             m[t] = [coins[c]]
           else
             (1..t - 1).select { |t2| coins[c] + t2 == t }
                       .reject { |t2| m[t2].nil? }
                       .each { |t2| 
                         m[t] = m[t2] + [coins[c]] if m[t].nil? || m[t2].size + 1 < m[t].size 
                       }
           end
         }
    m[-1].nil? ? -1 : m[-1]
  end

Ruby的include和prepend有一个重要的知识点，就是多重包含的时候，后面的Module会被ignore掉，只会包含一次。

module C
  
end

module M
  
end

class B
  include M
  include C
end

p B.ancestors
# [B, C, M, Object, Kernel, BasicObject]

class A
  prepend M
  prepend C
end

p A.ancestors
# [C, M, A, Object, Kernel, BasicObject]


class D
  include M
  prepend C
end

p D.ancestors
# [C, D, M, Object, Kernel, BasicObject]

module M
  include C
end

class E
  prepend C
  include M
end

p E.ancestors
# [C, E, M, Object, Kernel, BasicObject]