Atm task: remove one solution, keep only which used loop. Remove extra classes & interface

Author: andrei-punko

src/main/java/by/andd3dfx/common/atm/AbstractAtm.java

@@ -0,0 +1,81 @@
+package by.andd3dfx.common.atm;
+
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * <pre>
+ * Есть банкомат (ATM), который заряжают купюрами.
+ * Надо реализовать метод withdraw() для выдачи заданной суммы amount имеющимися в банкомате купюрами.
+ * Метод withdraw() - мутирующий, т.е. меняет состояние банкомата после вызова (кол-во купюр может уменьшиться):
+ *   Map<Integer, Integer> withdraw(int amount)
+ * </pre>
+ *
+ * @see <a href="https://youtu.be/LDKZtDevRRI">Video solution 1</a> and <a href="https://youtu.be/0-BL-NO9-B8">Video solution 2</a>
+ */
+public class Atm {
+
+    private Map<Integer, Integer> state;
+    private List<Integer> nominals;
+
+    public Atm(Map<Integer, Integer> state) {
+        this.state = new HashMap<>(state);
+        this.nominals = state.keySet().stream()
+            .sorted(Comparator.reverseOrder()).toList();
+    }
+
+    /**
+     * Withdraw asked amount using banknotes of ATM
+     *
+     * @param amount sum asked to withdraw
+     * @return map with solution - pairs {banknote nominal->quantity}
+     */
+    public Map<Integer, Integer> withdraw(int amount) {
+        // Try to make withdraw using banknote of highest nominal,
+        // in case of fail - try to start from next nominal
+        for (int i = 0; i < nominals.size(); i++) {
+            try {
+                return withdraw(amount, i);
+            } catch (IllegalStateException ex) {
+                // do nothing
+            }
+        }
+
+        throw new IllegalStateException("Could not perform withdraw!");
+    }
+
+    private Map<Integer, Integer> withdraw(int amount, int nominalIndex) {
+        var result = new HashMap<Integer, Integer>();
+
+        for (var index = nominalIndex; index < nominals.size(); index++) {
+            var nominal = nominals.get(index);
+            if (nominal > amount || state.get(nominal) == 0) {
+                continue;
+            }
+
+            int count = amount / nominal;
+            count = Math.min(count, state.get(nominal));
+            result.put(nominal, count);
+            amount -= nominal * count;
+
+            if (amount == 0) {
+                break;
+            }
+        }
+
+        if (amount > 0) {
+            throw new IllegalStateException("Could not perform withdraw!");
+        }
+
+        mutateAtm(result);
+        return result;
+    }
+
+    private void mutateAtm(Map<Integer, Integer> result) {
+        for (var nominal : result.keySet()) {
+            state.put(nominal, state.get(nominal) - result.get(nominal));
+        }
+    }
+}

src/main/java/by/andd3dfx/common/atm/Atm.java

@@ -9,10 +9,13 @@
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.junit.Assert.assertThrows;
 
-public abstract class AbstractAtmTest {
+public class AtmTest {
 
-    private IAtm atm;
-    private IAtm atm2;
+    private Atm atm;
+
+    protected Atm buildAtm(Map<Integer, Integer> state) {
+        return new Atm(state);
+    }
 
     @Before
     public void setUp() throws Exception {
@@ -21,14 +24,8 @@ public void setUp() throws Exception {
             200, 3,
             50, 5
         ));
-        atm2 = buildAtm(Map.of(
-            500, 3,
-            200, 5
-        ));
     }
 
-    protected abstract IAtm buildAtm(Map<Integer, Integer> state);
-
     @Test
     public void withdrawFor0() {
         var result = atm.withdraw(0);
@@ -88,7 +85,13 @@ public void withdrawForConsequentCalls() {
     @Ignore
     @Test
     public void withdraw_vsGreedyAlgorithm() {
+        var atm2 = buildAtm(Map.of(
+            500, 3,
+            200, 5
+        ));
+
         var result = atm2.withdraw(1100);
+
         assertThat(result).isEqualTo(Map.of(
             500, 1,
             200, 3