Price an order across volume tiers
A wholesaler charges less per unit the more you buy, and the tiers stack: the first slice of the order is charged at the first rate, the next slice at the second, and so on.
- Tiers arrive sorted by upTo, which is a running total, not a slice width.
- A tier covers the units between where the previous tier stopped and its own upTo.
- Anything beyond the last tier is charged at the last tier rate.
- A quantity of zero or less costs nothing.
tieredTotal(qty: int, tiers: list<Tier>) → int
C++ needs a compiler and Drill does not host one yet, so this page is the reference rather than an exercise: the problem, worked examples, and the solution in full. To type it out, the same problem runs in Python.
Where you start
int tieredTotal(int qty, std::vector<Tier> tiers) {
}Worked examples
| Call | Result |
|---|---|
tieredTotal(60, std::vector<Tier>{Tier{10, 100}, Tier{50, 90}, Tier{200, 80}}) | 5400 |
tieredTotal(5, std::vector<Tier>{Tier{10, 100}, Tier{50, 90}}) | 500 |
tieredTotal(300, std::vector<Tier>{Tier{10, 100}, Tier{50, 90}}) | 27100 |
tieredTotal(0, std::vector<Tier>{Tier{10, 100}}) | 0 |
Hint
Track how many units you have already priced. Each tier handles at most upTo minus that.
Reference solution in C++
int tieredTotal(int qty, std::vector<Tier> tiers) {
if (qty <= 0 || tiers.empty()) return 0;
int done = 0, total = 0;
for (const auto& t : tiers) {
int take = std::min(qty - done, t.upTo - done);
if (take > 0) { total += take * t.unitPrice; done += take; }
}
if (done < qty) total += (qty - done) * tiers.back().unitPrice;
return total;
}