add 860

Author: fishercoder1534

README.md

@@ -58,6 +58,7 @@ Your ideas/fixes/algorithms are more than welcome!
 |872|[Leaf-Similar Trees](https://leetcode.com/problems/leaf-similar-trees/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_872.java) | O(n) | O(h) | |Easy| DFS, recursion
 |868|[Binary Gap](https://leetcode.com/problems/binary-gap/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_868.java) | O(n) | O(n) | |Easy|
 |867|[Transpose Matrix](https://leetcode.com/problems/transpose-matrix/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_867.java) | O(r*c) | O(r*c) | |Easy|
+|860|[Lemonade Change](https://leetcode.com/problems/lemonade-change/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_860.java) | O(n) | O(1) | |Easy|
 |859|[Buddy Strings](https://leetcode.com/problems/buddy-strings/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_859.java) | O(n) | O(n) | |Easy|
 |852|[Peak Index in a Mountain Array](https://leetcode.com/problems/peak-index-in-a-mountain-array/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_852.java) | O(n) | O(1) | |Easy|
 |844|[Backspace String Compare](https://leetcode.com/problems/backspace-string-compare/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_844.java) | O(n) | O(1) | |Easy|

src/main/java/com/fishercoder/solutions/_860.java

@@ -0,0 +1,101 @@
+package com.fishercoder.solutions;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * 860. Lemonade Change
+ *
+ * At a lemonade stand, each lemonade costs $5.
+ *
+ * Customers are standing in a queue to buy from you,
+ * and order one at a time (in the order specified by bills).
+ * Each customer will only buy one lemonade and pay with either a $5, $10, or $20 bill.
+ * You must provide the correct change to each customer,
+ * so that the net transaction is that the customer pays $5.
+ * Note that you don't have any change in hand at first.
+ * Return true if and only if you can provide every customer with correct change.
+ *
+ * Example 1:
+ * Input: [5,5,5,10,20]
+ * Output: true
+ * Explanation:
+ * From the first 3 customers, we collect three $5 bills in order.
+ * From the fourth customer, we collect a $10 bill and give back a $5.
+ * From the fifth customer, we give a $10 bill and a $5 bill.
+ * Since all customers got correct change, we output true.
+ *
+ * Example 2:
+ * Input: [5,5,10]
+ * Output: true
+ *
+ * Example 3:
+ * Input: [10,10]
+ * Output: false
+ *
+ * Example 4:
+ * Input: [5,5,10,10,20]
+ * Output: false
+ * Explanation:
+ * From the first two customers in order, we collect two $5 bills.
+ * For the next two customers in order, we collect a $10 bill and give back a $5 bill.
+ * For the last customer, we can't give change of $15 back because we only have two $10 bills.
+ * Since not every customer received correct change, the answer is false.
+ *
+ *
+ * Note:
+ * 0 <= bills.length <= 10000
+ * bills[i] will be either 5, 10, or 20.
+ */
+public class _860 {
+  public static class Solution1 {
+    public boolean lemonadeChange(int[] bills) {
+      Map<Integer, Integer> map = new HashMap<>();
+      for (int bill : bills) {
+        if (bill == 5) {
+          map.put(5, map.getOrDefault(5, 0) + 1);
+        } else if (bill == 10) {
+          if (!map.containsKey(5)) {
+            return false;
+          } else {
+            map.put(5, map.get(5) - 1);
+            if (map.get(5) == 0) {
+              map.remove(5);
+            }
+            map.put(10, map.getOrDefault(10, 0) + 1);
+          }
+        } else {
+          if (!map.containsKey(5)) {
+            return false;
+          } else {
+            if (!map.containsKey(10)) {
+              if (!map.containsKey(5) || map.get(5) < 3) {
+                return false;
+              } else {
+                map.put(5, map.get(5) - 3);
+                if (map.get(5) == 0) {
+                  map.remove(5);
+                }
+              }
+            } else {
+              if (!map.containsKey(5)) {
+                return false;
+              } else {
+                map.put(5, map.get(5) - 1);
+                if (map.get(5) == 0) {
+                  map.remove(5);
+                }
+                map.put(10, map.get(10) - 1);
+                if (map.get(10) == 0) {
+                  map.remove(10);
+                }
+              }
+            }
+          }
+          map.put(20, map.getOrDefault(20, 0) + 1);
+        }
+      }
+      return true;
+    }
+  }
+}

src/test/java/com/fishercoder/_860Test.java

@@ -0,0 +1,48 @@
+package com.fishercoder;
+
+import com.fishercoder.solutions._860;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class _860Test {
+
+  private static _860.Solution1 test;
+  private static int[] bills;
+
+  @BeforeClass
+  public static void setUp() {
+    test = new _860.Solution1();
+  }
+
+  @Test
+  public void test1() {
+    bills = new int[] {5, 5, 5, 10, 20};
+    assertEquals(true, test.lemonadeChange(bills));
+  }
+
+  @Test
+  public void test2() {
+    bills = new int[] {5, 5, 10};
+    assertEquals(true, test.lemonadeChange(bills));
+  }
+
+  @Test
+  public void test3() {
+    bills = new int[] {10, 10};
+    assertEquals(false, test.lemonadeChange(bills));
+  }
+
+  @Test
+  public void test4() {
+    bills = new int[] {5, 5, 10, 10, 20};
+    assertEquals(false, test.lemonadeChange(bills));
+  }
+
+  @Test
+  public void test5() {
+    bills = new int[] {5, 5, 5, 20, 5, 5, 5, 10, 20, 5, 10, 20, 5, 20, 5, 10, 5, 5, 5, 5};
+    assertEquals(false, test.lemonadeChange(bills));
+  }
+}