Enhance ATM solutions by addition of classes hierarchy to avoid code duplication

Adjust naming to satisfy Java code convention: use `Atm` instead of `ATM`

Author: andrei-punko

Diff for: 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) [Code2](src/main/java/by/andd3dfx/common/ATM2.java)                                                                               |
+| Выдача купюр банкоматом (Яндекс)                                                                 | [Youtube](https://youtu.be/LDKZtDevRRI) | [Code](src/main/java/by/andd3dfx/common/atm/AtmUsingLoop.java) [Code2](src/main/java/by/andd3dfx/common/atm/AtmUsingRecursion.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)                                                                                                      |

Diff for: src/main/java/by/andd3dfx/common/ATM.java

@@ -0,0 +1,53 @@
+package by.andd3dfx.common.atm;
+
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public abstract class AbstractAtm implements IAtm {
+
+    protected Map<Integer, Integer> state;
+    protected List<Integer> nominals;
+
+    public AbstractAtm(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}
+     */
+    @Override
+    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!");
+    }
+
+    /**
+     * Withdraw asked amount using banknotes of ATM starting from definite nominal (and its lower values)
+     *
+     * @param amount sum asked to withdraw
+     * @return map with solution - pairs {banknote nominal->quantity}
+     */
+    protected abstract Map<Integer, Integer> withdraw(int amount, int nominalIndex);
+
+    protected void mutateAtm(Map<Integer, Integer> result) {
+        for (var nominal : result.keySet()) {
+            state.put(nominal, state.get(nominal) - result.get(nominal));
+        }
+    }
+}

Diff for: src/main/java/by/andd3dfx/common/ATM2.java

@@ -0,0 +1,48 @@
+package by.andd3dfx.common.atm;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * <pre>
+ * Есть банкомат (ATM), который заряжают купюрами.
+ * Надо реализовать метод withdraw() для выдачи заданной суммы amount имеющимися в банкомате купюрами.
+ * Метод withdraw() - мутирующий, т.е. меняет состояние банкомата после вызова (кол-во купюр может уменьшиться).
+ * </pre>
+ *
+ * @see <a href="https://youtu.be/LDKZtDevRRI">Video solution</a>
+ */
+public class AtmUsingLoop extends AbstractAtm {
+
+    public AtmUsingLoop(Map<Integer, Integer> state) {
+        super(state);
+    }
+
+    @Override
+    protected 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;
+    }
+}

Diff for: src/main/java/by/andd3dfx/common/atm/AbstractAtm.java

@@ -0,0 +1,49 @@
+package by.andd3dfx.common.atm;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * <pre>
+ * Есть банкомат (ATM), который заряжают купюрами.
+ * Надо реализовать метод withdraw() для выдачи заданной суммы amount имеющимися в банкомате купюрами.
+ * Метод withdraw() - мутирующий, т.е. меняет состояние банкомата после вызова (кол-во купюр может уменьшиться).
+ * </pre>
+ *
+ * @see <a href="https://youtu.be/LDKZtDevRRI">Video solution</a>
+ */
+public class AtmUsingRecursion extends AbstractAtm {
+
+    public AtmUsingRecursion(Map<Integer, Integer> state) {
+        super(state);
+    }
+
+    @Override
+    protected Map<Integer, Integer> withdraw(int amount, int nominalIndex) {
+        if (amount == 0) {
+            return Map.of();
+        }
+        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) {
+            result.putAll(withdraw(amount, nominalIndex + 1));
+            return result;
+        }
+
+        mutateAtm(result);
+        return result;
+    }
+}

Diff for: src/main/java/by/andd3dfx/common/atm/AtmUsingLoop.java

@@ -0,0 +1,14 @@
+package by.andd3dfx.common.atm;
+
+import java.util.Map;
+
+public interface IAtm {
+
+    /**
+     * Withdraw asked amount using banknotes of ATM
+     *
+     * @param amount sum asked to withdraw
+     * @return map with solution - pairs {banknote nominal->quantity}
+     */
+    Map<Integer, Integer> withdraw(int amount);
+}