change: add to track

config.json

     "matrix",
     "diamond",
     "secret-handshake",
-    "flatten-array"
+    "flatten-array",
+    "change"
   ],
   "exercises": [
     {
       "slug": "flatten-array",
       "difficulty": 1,
       "topics": []
+    },
+    {
+      "slug": "change",
+      "difficulty": 1,
+      "topics": []
     }
   ],
   "deprecated": [

exercises/change/build.gradle

+apply plugin: "java"
+apply plugin: "eclipse"
+apply plugin: "idea"
+
+repositories {
+  mavenCentral()
+}
+
+dependencies {
+  testCompile "junit:junit:4.12"
+}
+test {
+  testLogging {
+    exceptionFormat = 'full'
+    events = ["passed", "failed", "skipped"]
+  }
+}

exercises/change/src/example/java/ChangeCalculator.java

+import java.util.*;
+import java.util.stream.Collectors;
+
+import static java.util.Comparator.comparingInt;
+
+final class ChangeCalculator {
+
+    private final List<Integer> currencyCoins;
+
+    ChangeCalculator(final List<Integer> currencyCoins) {
+        this.currencyCoins = currencyCoins;
+        Collections.sort(currencyCoins);
+    }
+
+    List<Integer> computeMostEfficientChange(final int grandTotal) {
+        if (grandTotal < 0) {
+            throw new IllegalArgumentException("Negative totals are not allowed.");
+        }
+
+        final Map<Integer, List<Integer>> minimalCoinsMap = new HashMap<>();
+        minimalCoinsMap.put(0, new ArrayList<>());
+
+        for (int total = 1; total <= grandTotal; total++) {
+            final int localTotal = total;
+
+            final List<Integer> minimalCoins = getCoinsNoLargerThan(total)
+                    .stream()
+                    .map(coin -> {
+                        final List<Integer> minimalRemainderCoins = minimalCoinsMap.get(localTotal - coin);
+                        return minimalRemainderCoins != null ? prepend(coin, minimalRemainderCoins) : null;
+                    })
+                    .filter(Objects::nonNull)
+                    .sorted(comparingInt(List::size))
+                    .findFirst()
+                    .orElse(null);
+
+            minimalCoinsMap.put(localTotal, minimalCoins);
+        }
+
+        final List<Integer> resultCandidate = minimalCoinsMap.get(grandTotal);
+
+        if (resultCandidate == null) {
+            throw new IllegalArgumentException(
+                    "The total " + grandTotal + " cannot be represented in the given currency.");
+        }
+
+        return resultCandidate;
+    }
+
+    private List<Integer> getCoinsNoLargerThan(final int threshold) {
+        return currencyCoins.stream()
+                .filter(coin -> coin <= threshold)
+                .collect(Collectors.toList());
+    }
+
+    private List<Integer> prepend(final int integer, final List<Integer> integers) {
+        final List<Integer> result = new ArrayList<>();
+        result.add(integer);
+        result.addAll(integers);
+        return result;
+    }
+
+}

exercises/change/src/main/java/ChangeCalculator.java

+final class ChangeCalculator {
+
+
+
+}

exercises/change/src/test/java/ChangeCalculatorTest.java

+import org.junit.Ignore;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+
+import static java.util.Arrays.asList;
+import static java.util.Collections.emptyList;
+import static java.util.Collections.singletonList;
+import static org.junit.Assert.assertEquals;
+
+public final class ChangeCalculatorTest {
+
+    /*
+     * See https://github.com/junit-team/junit4/wiki/Rules for information on JUnit Rules in general and
+     * ExpectedExceptions in particular.
+     */
+    @Rule
+    public ExpectedException expectedException = ExpectedException.none();
+
+    @Test
+    public void testChangeThatCanBeGivenInASingleCoin() {
+        ChangeCalculator changeCalculator = new ChangeCalculator(asList(1, 5, 10, 25, 100));
+
+        assertEquals(
+                singletonList(25),
+                changeCalculator.computeMostEfficientChange(25));
+    }
+
+    @Ignore
+    @Test
+    public void testChangeThatMustBeGivenInMultipleCoins() {
+        ChangeCalculator changeCalculator = new ChangeCalculator(asList(1, 5, 10, 25, 100));
+
+        assertEquals(
+                asList(5, 10),
+                changeCalculator.computeMostEfficientChange(15));
+    }
+
+    @Ignore
+    @Test
+    // https://en.wikipedia.org/wiki/Change-making_problem#Greedy_method
+    public void testLilliputianCurrencyForWhichGreedyAlgorithmFails() {
+        ChangeCalculator changeCalculator = new ChangeCalculator(asList(1, 4, 15, 20, 50));
+
+        assertEquals(
+                asList(4, 4, 15),
+                changeCalculator.computeMostEfficientChange(23));
+    }
+
+    @Ignore
+    @Test
+    // https://en.wikipedia.org/wiki/Change-making_problem#Greedy_method
+    public void testLowerElbonianCurrencyForWhichGreedyAlgorithmFails() {
+        ChangeCalculator changeCalculator = new ChangeCalculator(asList(1, 5, 10, 21, 25));
+
+        assertEquals(
+                asList(21, 21, 21),
+                changeCalculator.computeMostEfficientChange(63));
+    }
+
+    @Ignore
+    @Test
+    public void testLargeAmountOfChange() {
+        ChangeCalculator changeCalculator = new ChangeCalculator(asList(1, 2, 5, 10, 20, 50, 100));
+
+        assertEquals(
+                asList(2, 2, 5, 20, 20, 50, 100, 100, 100, 100, 100, 100, 100, 100, 100),
+                changeCalculator.computeMostEfficientChange(999));
+    }
+
+    @Ignore
+    @Test
+    public void testZeroChange() {
+        ChangeCalculator changeCalculator = new ChangeCalculator(asList(1, 5, 10, 21, 25));
+
+        assertEquals(
+                emptyList(),
+                changeCalculator.computeMostEfficientChange(0));
+    }
+
+    @Ignore
+    @Test
+    public void testChangeLessThanSmallestCoinInCurrencyCannotBeRepresented() {
+        ChangeCalculator changeCalculator = new ChangeCalculator(asList(5, 10));
+
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("The total 3 cannot be represented in the given currency.");
+
+        changeCalculator.computeMostEfficientChange(3);
+    }
+
+    @Ignore
+    @Test
+    public void testNegativeChangeIsRejected() {
+        ChangeCalculator changeCalculator = new ChangeCalculator(asList(1, 2, 5));
+
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("Negative totals are not allowed.");
+
+        changeCalculator.computeMostEfficientChange(-5);
+    }
+
+}

exercises/settings.gradle

 include 'binary-search-tree'
 include 'bob'
 include 'bracket-push'
+include 'change'
 include 'crypto-square'
 include 'custom-set'
 include 'diamond'