Build #Hash with #Derivative Value

build_hash_with_derived_values.doctest

=begin
Method returns hash of derivitave values as provided.

Example usage:

    doctest: Setup
    >> require './build_hash_with_derived_values'
    => true
    doctest: Yardstick test derived result
    >> yardstick = build_hash_with_derivative_values [:yard, :foot, :inch],
                                                     [ 1,     3,     12  ]
    => {:inch=>36, :foot=>3, :yard=>1}
    doctest: How many inches in 1.5 feet?
    We can remember how to do this if we remember that inches in something means
    to divide that something by inches.  Then 1.5 of that something (where "of"
    means to multiply).
    >> yardstick[:inch] / yardstick[:foot] * 1.5
    => 18.0
    doctest: Units that make up a yard
    >> yardstick.keys
    => [:yard, :foot, :inch]
    doctest: Units in Year derived result
    >> Units_In_One_Year =
         build_hash_with_derivative_values [:year, :day, :hour, :minute, :second],
                                           [ 1,     365,  24,    60,      60]
    => {:second=>31536000, :minute=>525600, :hour=>8760, :day=>365, :year=>1}
=end

build_hash_with_derived_values.rb

def build_hash_with_derivative_values units, property
  decrement = 0 ; value = nil # house keeping for the hash assignment
  hash = {}
  hash = units.inject do |key|
    (units.size  - decrement   ).times do |i|
      value = 1 unless value # This is opposite of the x ||= value idiom
      value = property[i] * value
      hash[units[decrement]] = value
      decrement += 1 # control the map of the supplied value array.
    end
    value = nil
    hash # this is returned internally to inject.
  end
# hash as created by the inect method is returned.
end

Funny that you bring up (1..5).inject(&:+), since it always struck me as a particularly bad example, since summing the numbers from 1 to n is most efficiently done as (n*(n+1))/2 (http://www.maths.surrey.ac.uk/hosted-sites/R.Knott/runsums/triNbProof.html). A couple of days ago I actually benchmarked it because I was thinking about a blog post called "Why knowing your math helps" and the second solution was considerably faster than inject.

BTW: the written out form of your inject would just return 5, what you meant is (1..5).inject { |sum, n| sum + n }

Does math always win out over inject/iterations? I can't think of a situation where it wouldn't, but then I am not a math nerd.

Also, happy holidays to wherever both are!