add 1381

fishercoder1534 · fishercoder1534 · commit 618dab751e61 · 2020-03-14T21:44:10.000-07:00
diff --git a/README.md b/README.md
@@ -8,6 +8,7 @@ _If you like this project, please leave me a star._ &#9733;
 
 |  #  |      Title     |   Solutions   | Video  | Difficulty  | Tag                   
 |-----|----------------|---------------|--------|-------------|-------------
+|1381|[Design a Stack With Increment Operation](https://leetcode.com/problems/design-a-stack-with-increment-operation/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_1381.java) | |Easy|Stack, Design|
 |1380|[Lucky Numbers in a Matrix](https://leetcode.com/problems/lucky-numbers-in-a-matrix/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_1380.java) | |Easy|Array|
 |1379|[Find a Corresponding Node of a Binary Tree in a Clone of That Tree](https://leetcode.com/problems/find-a-corresponding-node-of-a-binary-tree-in-a-clone-of-that-tree/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_1379.java) | |Medium|Tree|
 |1377|[Frog Position After T Seconds](https://leetcode.com/problems/frog-position-after-t-seconds/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_1377.java) | |Hard|DFS, BFS|
diff --git a/src/main/java/com/fishercoder/solutions/_1381.java b/src/main/java/com/fishercoder/solutions/_1381.java
@@ -0,0 +1,82 @@
+package com.fishercoder.solutions;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * 1381. Design a Stack With Increment Operation
+ *
+ * Design a stack which supports the following operations.
+ *
+ * Implement the CustomStack class:
+ *
+ * CustomStack(int maxSize) Initializes the object with maxSize which is the maximum number of elements in the stack or do nothing if the stack reached the maxSize.
+ * void push(int x) Adds x to the top of the stack if the stack hasn't reached the maxSize.
+ * int pop() Pops and returns the top of stack or -1 if the stack is empty.
+ * void inc(int k, int val) Increments the bottom k elements of the stack by val. If there are less than k elements in the stack, just increment all the elements in the stack.
+ *
+ * Example 1:
+ *
+ * Input
+ * ["CustomStack","push","push","pop","push","push","push","increment","increment","pop","pop","pop","pop"]
+ * [[3],[1],[2],[],[2],[3],[4],[5,100],[2,100],[],[],[],[]]
+ * Output
+ * [null,null,null,2,null,null,null,null,null,103,202,201,-1]
+ * Explanation
+ * CustomStack customStack = new CustomStack(3); // Stack is Empty []
+ * customStack.push(1);                          // stack becomes [1]
+ * customStack.push(2);                          // stack becomes [1, 2]
+ * customStack.pop();                            // return 2 --> Return top of the stack 2, stack becomes [1]
+ * customStack.push(2);                          // stack becomes [1, 2]
+ * customStack.push(3);                          // stack becomes [1, 2, 3]
+ * customStack.push(4);                          // stack still [1, 2, 3], Don't add another elements as size is 4
+ * customStack.increment(5, 100);                // stack becomes [101, 102, 103]
+ * customStack.increment(2, 100);                // stack becomes [201, 202, 103]
+ * customStack.pop();                            // return 103 --> Return top of the stack 103, stack becomes [201, 202]
+ * customStack.pop();                            // return 202 --> Return top of the stack 102, stack becomes [201]
+ * customStack.pop();                            // return 201 --> Return top of the stack 101, stack becomes []
+ * customStack.pop();                            // return -1 --> Stack is empty return -1.
+ *
+ * Constraints:
+ * 1 <= maxSize <= 1000
+ * 1 <= x <= 1000
+ * 1 <= k <= 1000
+ * 0 <= val <= 100
+ * At most 1000 calls will be made to each method of increment, push and pop each separately.
+ * */
+public class _1381 {
+    public static class Solution1 {
+        public static class CustomStack {
+
+            List<Integer> list;
+            int maxSize;
+
+            public CustomStack(int maxSize) {
+                this.list = new ArrayList<>();
+                this.maxSize = maxSize;
+            }
+
+            public void push(int x) {
+                if (list.size() >= maxSize) {
+                    return;
+                } else {
+                    list.add(x);
+                }
+            }
+
+            public int pop() {
+                if (!list.isEmpty()) {
+                    return list.remove(list.size() - 1);
+                } else {
+                    return -1;
+                }
+            }
+
+            public void increment(int k, int val) {
+                for (int i = 0; i < k && i < list.size(); i++) {
+                    list.set(i, list.get(i) + val);
+                }
+            }
+        }
+    }
+}
diff --git a/src/test/java/com/fishercoder/_1381Test.java b/src/test/java/com/fishercoder/_1381Test.java
@@ -0,0 +1,28 @@
+package com.fishercoder;
+
+import com.fishercoder.solutions._1381;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class _1381Test {
+    private static _1381.Solution1.CustomStack customStack;
+
+    @Test
+    public void test1() {
+        customStack = new _1381.Solution1.CustomStack(3);
+        customStack.push(1);
+        customStack.push(2);
+        assertEquals(2, customStack.pop());
+        customStack.push(2);
+        customStack.push(3);
+        customStack.push(4);
+        customStack.increment(5, 100);
+        customStack.increment(2, 100);
+        assertEquals(103, customStack.pop());
+        assertEquals(202, customStack.pop());
+        assertEquals(201, customStack.pop());
+        assertEquals(-1, customStack.pop());
+    }
+
+}
