Applying different multiplier to an integer depending on threshold - arrays

Question

I'm having to build a program which calculates the Annual cost of minutes used for phone providers and it depends on different rates.
As an example one phone operator may have the following rates:
"rates": [
{"price": 15.5, "threshold": 150},
{"price": 12.3, "threshold": 100},
{"price": 8}
],
operators can have multiple tariffs with the last tariff always having no threshold.
so in the example above the first 150 minutes will be charged at 15.5p per minute, the next 100mins will be charged at 12.3p per minute and all subsequent minutes will be charged at 8p.
Therefore if:
AnnualUsage = 1000
the total cost would be 95.55.
I'm struggling to visualise a method which would accommodate for the multiple tariffs an operator could have and multiplying a value by a different price depending on threshold.
Please Help!

Answer 1

Just another option, I think it's self explanatory:
rates = [
{price: 15.5, threshold: 150},
{price: 12.3, threshold: 100},
{price: 8}
]
annual_usage = 1000
res = rates.each_with_object([]) do |h, ary|
if h.has_key?(:threshold) && annual_usage > h[:threshold]
annual_usage -= h[:threshold]
ary << h[:threshold] * h[:price]/100
else
ary << annual_usage * h[:price]/100
end
end
res #=> [23.25, 12.3, 60]
res.sum #=> 95.55
Take a look to Enumerable#each_with_object.

Answer 2

def tot_cost(rate_tbl, minutes)
rate_tbl.reduce(0) do |tot,h|
mins = [minutes, h[:threshold] || Float::INFINITY].min
minutes -= mins
tot + h[:price] * mins
end
end
rate_tbl = [
{ price: 15.5, threshold: 150},
{ price: 12.3, threshold: 100 },
{ price: 8 }
]
tot_cost(rate_tbl, 130) #=> 2015.0 (130*15.5)
tot_cost(rate_tbl, 225) #=> 3247.5 (150*15.5 + (225-150)*12.3)
tot_cost(rate_tbl, 300) #=> 3955.0 (150*15.5 + 100*12.3 + (300-250)*8)
If desired, h[:threshold] || Float::INFINITY can be replaced by
h.fetch(:threshold, Float::INFINITY)

Answer 3

RATES = [
{price: 15.5, threshold: 150},
{price: 12.3, threshold: 100},
{price: 8}
]
def total_cost(annual_usage)
rate_idx = 0
idx_in_threshold = 1
1.upto(annual_usage).reduce(0) do |memo, i|
threshold = RATES[rate_idx][:threshold]
if threshold && (idx_in_threshold > RATES[rate_idx][:threshold])
idx_in_threshold = 1
rate_idx += 1
end
idx_in_threshold += 1
memo + RATES[rate_idx][:price]
end
end
puts total_cost(1000).to_i
# => 9555
The key concepts:
using an enumerable method such as reduce to incrementally build the solution. You could alternatively use each but reduce is more idiomatic.
tracking progress through the rates list through the rate_idx and idx_in_threshold variables. These give you all the information you need to determine whether you should advance to the next tier.
Also, avoid writing your hash keys like "price": 15.5 - just remove the quotations, it's more idiomatic.

Answer 4

With object-oriented approach you can remove explicit if ..else statements and maybe make code more self explanatory.
class Total
attr_reader :price
def initialize(usage)
#usage = usage
#billed_usage = 0
#price = 0
end
def apply(rate)
applicable_usage = [#usage - #billed_usage, 0].max
usage_to_apply = [applicable_usage, rate.fetch(:threshold, applicable_usage)].min
#price += usage_to_apply * rate[:price]
#billed_usage += usage_to_apply
end
end
Simple usage with each method
rates = [
{:price => 15.5, :threshold => 150},
{:price => 12.3, :threshold => 100},
{:price => 8}
]
total = Total.new(1000)
rates.each { |rate| total.apply(rate) }
puts "Total: #{total.price}" # Total: 9555.0 (95.55)