sync change (#571)

Author: keiravillekode

exercises/practice/change/.docs/instructions.md

@@ -1,14 +1,8 @@
 # Instructions
 
-Correctly determine the fewest number of coins to be given to a customer such that the sum of the coins' value would equal the correct amount of change.
+Determine the fewest number of coins to give a customer so that the sum of their values equals the correct amount of change.
 
-## For example
+## Examples
 
-- An input of 15 with [1, 5, 10, 25, 100] should return one nickel (5) and one dime (10) or [5, 10]
-- An input of 40 with [1, 5, 10, 25, 100] should return one nickel (5) and one dime (10) and one quarter (25) or [5, 10, 25]
-
-## Edge cases
-
-- Does your algorithm work for any given set of coins?
-- Can you ask for negative change?
-- Can you ask for a change value smaller than the smallest coin value?
+- An amount of 15 with available coin values [1, 5, 10, 25, 100] should return one coin of value 5 and one coin of value 10, or [5, 10].
+- An amount of 40 with available coin values [1, 5, 10, 25, 100] should return one coin of value 5, one coin of value 10, and one coin of value 25, or [5, 10, 25].

exercises/practice/change/.docs/introduction.md

@@ -0,0 +1,26 @@
+# Introduction
+
+In the mystical village of Coinholt, you stand behind the counter of your bakery, arranging a fresh batch of pastries.
+The door creaks open, and in walks Denara, a skilled merchant with a keen eye for quality goods.
+After a quick meal, she slides a shimmering coin across the counter, representing a value of 100 units.
+
+You smile, taking the coin, and glance at the total cost of the meal: 88 units.
+That means you need to return 12 units in change.
+
+Denara holds out her hand expectantly.
+"Just give me the fewest coins," she says with a smile.
+"My pouch is already full, and I don't want to risk losing them on the road."
+
+You know you have a few options.
+"We have Lumis (worth 10 units), Viras (worth 5 units), and Zenth (worth 2 units) available for change."
+
+You quickly calculate the possibilities in your head:
+
+- one Lumis (1 × 10 units) + one Zenth (1 × 2 units) = 2 coins total
+- two Viras (2 × 5 units) + one Zenth (1 × 2 units) = 3 coins total
+- six Zenth (6 × 2 units) = 6 coins total
+
+"The best choice is two coins: one Lumis and one Zenth," you say, handing her the change.
+
+Denara smiles, clearly impressed.
+"As always, you've got it right."

exercises/practice/change/.meta/example.lua

@@ -1,19 +1,37 @@
 return function(amount, values)
-  local index, sorted_values, result = {}, {}, {}
+  assert(amount >= 0, "target can't be negative")
+  if amount == 0 then
+    return {}
+  end
 
-  for i, v in ipairs(values) do
-    index[v] = i
-    sorted_values[i] = v
+  local counts = {}
+  local coins = {}
+  for total = 1, amount do
+    local best_count = amount + 1
+    local best_coin = 0
+    for _, value in ipairs(values) do
+      if value == total then
+        best_count = 1
+        best_coin = value
+      elseif total > value then
+        local count = counts[total - value] + 1
+        if count < best_count then
+          best_count = count
+          best_coin = value
+        end
+      end
+    end
+    table.insert(counts, best_count)
+    table.insert(coins, best_coin)
   end
 
-  table.sort(sorted_values, function(a, b)
-    return b < a
-  end)
+  assert(counts[amount] <= amount, "can't make target with given coins")
 
-  for i, value in ipairs(sorted_values) do
-    result[index[value]] = amount // value
-    amount = amount % value
+  local result = {}
+  local remaining = amount
+  while remaining > 0 do
+    table.insert(result, coins[remaining])
+    remaining = remaining - coins[remaining]
   end
-
-  return amount == 0 and result or nil
+  return result
 end

exercises/practice/change/.meta/spec_generator.lua

@@ -0,0 +1,21 @@
+local function render_coins(coins)
+  return table.concat(coins, ', ')
+end
+
+return {
+  module_name = 'change',
+
+  generate_test = function(case)
+    if case.expected.error then
+      local template = [[
+        assert.has.error(function()
+          change(%s, { %s })
+        end, "%s")]]
+      return template:format(case.input.target, render_coins(case.input.coins), case.expected.error)
+    else
+      local template = [[
+        assert.same({ %s }, change(%s, { %s }))]]
+      return template:format(render_coins(case.expected), case.input.target, render_coins(case.input.coins))
+    end
+  end
+}

exercises/practice/change/.meta/tests.toml

@@ -1,6 +1,16 @@
-# This is an auto-generated file. Regular comments will be removed when this
-# file is regenerated. Regenerating will not touch any manually added keys,
-# so comments can be added in a "comment" key.
+# This is an auto-generated file.
+#
+# Regenerating this file via `configlet sync` will:
+# - Recreate every `description` key/value pair
+# - Recreate every `reimplements` key/value pair, where they exist in problem-specifications
+# - Remove any `include = true` key/value pair (an omitted `include` key implies inclusion)
+# - Preserve any other key/value pair
+#
+# As user-added comments (using the # character) will be removed when this file
+# is regenerated, comments can be added via a `comment` key.
+
+[d0ebd0e1-9d27-4609-a654-df5c0ba1d83a]
+description = "change for 1 cent"
 
 [36887bea-7f92-4a9c-b0cc-c0e886b3ecc8]
 description = "single coin change"
@@ -23,6 +33,9 @@ description = "possible change without unit coins available"
 [9a166411-d35d-4f7f-a007-6724ac266178]
 description = "another possible change without unit coins available"
 
+[ce0f80d5-51c3-469d-818c-3e69dbd25f75]
+description = "a greedy approach is not optimal"
+
 [bbbcc154-e9e9-4209-a4db-dd6d81ec26bb]
 description = "no coins make 0 change"
 

exercises/practice/change/change_spec.lua

@@ -1,28 +1,62 @@
 local change = require('change')
 
 describe('change', function()
-  it('should generate the correct change when there is only one type of coin', function()
-    assert.same({ 5 }, change(5, { 1 }))
+  it('change for 1 cent', function()
+    assert.same({ 1 }, change(1, { 1, 5, 10, 25 }))
   end)
 
-  it('should generate the correct change when there are multiple coin types', function()
-    assert.same({ 5, 0 }, change(5, { 1, 10 }))
+  it('single coin change', function()
+    assert.same({ 25 }, change(25, { 1, 5, 10, 25, 100 }))
   end)
 
-  it('should generate the correct change when multiple types of coins are needed', function()
-    assert.same({ 3, 1, 1 }, change(18, { 1, 5, 10 }))
+  it('multiple coin change', function()
+    assert.same({ 5, 10 }, change(15, { 1, 5, 10, 25, 100 }))
   end)
 
-  it('should return nil if it is not possible to make change', function()
-    assert.is_nil(change(3, { 5, 10, 25 }))
+  it('change with lilliputian coins', function()
+    assert.same({ 4, 4, 15 }, change(23, { 1, 4, 15, 20, 50 }))
   end)
 
-  it('should generate the correct change given any coin order', function()
-    assert.same({ 3, 1, 1 }, change(18, { 1, 5, 10 }))
-    assert.same({ 1, 1, 3 }, change(18, { 10, 5, 1 }))
+  it('change with lower elbonia coins', function()
+    assert.same({ 21, 21, 21 }, change(63, { 1, 5, 10, 21, 25 }))
   end)
 
-  it('should generate the correct change for large values with many coins', function()
-    assert.same({ 3, 1, 0, 1, 1 }, change(133, { 1, 5, 10, 25, 100 }))
+  it('large target values', function()
+    assert.same({ 2, 2, 5, 20, 20, 50, 100, 100, 100, 100, 100, 100, 100, 100, 100 },
+                change(999, { 1, 2, 5, 10, 20, 50, 100 }))
+  end)
+
+  it('possible change without unit coins available', function()
+    assert.same({ 2, 2, 2, 5, 10 }, change(21, { 2, 5, 10, 20, 50 }))
+  end)
+
+  it('another possible change without unit coins available', function()
+    assert.same({ 4, 4, 4, 5, 5, 5 }, change(27, { 4, 5 }))
+  end)
+
+  it('a greedy approach is not optimal', function()
+    assert.same({ 10, 10 }, change(20, { 1, 10, 11 }))
+  end)
+
+  it('no coins make 0 change', function()
+    assert.same({}, change(0, { 1, 5, 10, 21, 25 }))
+  end)
+
+  it('error testing for change smaller than the smallest of coins', function()
+    assert.has.error(function()
+      change(3, { 5, 10 })
+    end, "can't make target with given coins")
+  end)
+
+  it('error if no combination can add up to target', function()
+    assert.has.error(function()
+      change(94, { 5, 10 })
+    end, "can't make target with given coins")
+  end)
+
+  it('cannot find negative change values', function()
+    assert.has.error(function()
+      change(-5, { 1, 2, 5 })
+    end, "target can't be negative")
   end)
 end)