Add recursive solution for ATM task

Author: andrei-punko

README.md

@@ -168,7 +168,7 @@ they contain enough code which describes implementation in a natural way.
 | Поиск слова в матрице букв (leetcode)                                                            | [Youtube](https://youtu.be/FsKU04anMtE) | [Code](src/main/java/by/andd3dfx/search/wordsearch/WordSearch.java)                                                                                                                 |
 | Сжатие строки (Яндекс)                                                                           | [Youtube](https://youtu.be/s3sGF7C6cV8) | [Code](src/main/java/by/andd3dfx/string/MakeStringCompact.java)                                                                                                                     |
 | Самодельный Stack                                                                                | [Youtube](https://youtu.be/sZ-DrSHhrWc) | [Code](src/main/java/by/andd3dfx/collections/custom/CustomStack.java)                                                                                                               |
-| Выдача купюр банкоматом (Яндекс)                                                                 | [Youtube](https://youtu.be/LDKZtDevRRI) | [Code](src/main/java/by/andd3dfx/common/ATM.java)                                                                                                                                   |
+| Выдача купюр банкоматом (Яндекс)                                                                 | [Youtube](https://youtu.be/LDKZtDevRRI) | [Code](src/main/java/by/andd3dfx/common/ATM.java) [Code2](src/main/java/by/andd3dfx/common/ATM2.java)                                                                               |
 | Поиск набора слов в матрице букв (2 решения) (leetcode)                                          | [Youtube](https://youtu.be/DTyMyr6bNGw) | [Code](src/main/java/by/andd3dfx/search/wordsearch/WordSearch_IIUsingWordSearch.java) [Code2](src/main/java/by/andd3dfx/search/wordsearch/WordSearch_IIUsingRecursion.java)         |
 | Поиск набора слов в матрице букв 2: префиксное дерево (leetcode)                                 | [Youtube](https://youtu.be/CLYbm21pvig) | [Code](src/main/java/by/andd3dfx/search/wordsearch/WordSearch_IIUsingPrefixTree.java)                                                                                               |
 | Поиск в строке наиболее длинной подстроки без повторений (leetcode)                              | [Youtube](https://youtu.be/Jj66XXja4LY) | [Code](src/main/java/by/andd3dfx/string/LongestWordWithoutRepeatingChars.java)                                                                                                      |

src/main/java/by/andd3dfx/common/ATM2.java

@@ -0,0 +1,77 @@
+package by.andd3dfx.common;
+
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * <pre>
+ * Есть банкомат (ATM), который заряжают купюрами.
+ * Надо реализовать метод withdraw() для выдачи заданной суммы amount имеющимися в банкомате купюрами.
+ * Метод withdraw() - мутирующий, т.е. меняет состояние банкомата после вызова (кол-во купюр может уменьшиться).
+ * </pre>
+ *
+ * @see <a href="https://youtu.be/LDKZtDevRRI">Video solution</a>
+ */
+public class ATM2 {
+
+    private Map<Integer, Integer> state;
+    private List<Integer> nominals;
+
+    public ATM2(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) {
+        if (nominalIndex >= nominals.size()) {
+            throw new IllegalStateException("Could not perform withdraw!");
+        }
+
+        var nominal = nominals.get(nominalIndex);
+        if (nominal > amount || state.get(nominal) == 0) {
+            return withdraw(amount, nominalIndex + 1);
+        }
+
+        var result = new HashMap<Integer, Integer>();
+        int count = amount / nominal;
+        count = Math.min(count, state.get(nominal));
+        result.put(nominal, count);
+        amount -= nominal * count;
+
+        if (amount == 0) {
+            mutateAtm(result);
+            return result;
+        }
+
+        result.putAll(withdraw(amount, nominalIndex + 1));
+        return result;
+    }
+
+    private void mutateAtm(Map<Integer, Integer> result) {
+        for (var nominal : result.keySet()) {
+            state.put(nominal, state.get(nominal) - result.get(nominal));
+        }
+    }
+}

src/test/java/by/andd3dfx/common/ATM2Test.java

@@ -0,0 +1,69 @@
+package by.andd3dfx.common;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.Map;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.assertThrows;
+
+public class ATM2Test {
+
+    private ATM2 atm;
+
+    @Before
+    public void setUp() throws Exception {
+        atm = new ATM2(Map.of(
+                500, 1,
+                200, 3,
+                50, 5
+        ));
+    }
+
+    @Test
+    public void withdraw() {
+        var result = atm.withdraw(450);
+
+        assertThat(result).isEqualTo(Map.of(
+                200, 2,
+                50, 1
+        ));
+    }
+
+    @Test
+    public void withdrawWhenHighGradeBanknotePresentButShouldNotBeUsed() {
+        // Spend all 50 banknotes
+        for (int i = 0; i < 5; i++) {
+            atm.withdraw(50);
+        }
+
+        // Ask 600, ATM has only 500 & 200 banknotes at this moment
+        var result = atm.withdraw(600);
+
+        assertThat(result).isEqualTo(Map.of(
+                200, 3
+        ));
+    }
+
+    @Test
+    public void withdrawWhenNoSmallNominalsInATM() {
+        var thrown = assertThrows(IllegalStateException.class, () -> atm.withdraw(451));
+        assertThat(thrown.getMessage()).isEqualTo("Could not perform withdraw!");
+    }
+
+    @Test
+    public void withdrawForConsequentCalls() {
+        var result = atm.withdraw(650);
+        assertThat(result).isEqualTo(Map.of(
+                500, 1,
+                50, 3
+        ));
+
+        var result2 = atm.withdraw(650);
+        assertThat(result2).isEqualTo(Map.of(
+                200, 3,
+                50, 1
+        ));
+    }
+}