Add Stack solutions

* Valid Parenthesis Expression
* Evaluate Expression
* Implement a Queue Using Stacks
* Maximum of Sliding Window
* Next Largest Number to the Right
* Repeated Removal of Adjacent Duplicates

Author: marttp

kotlin/Stacks/EvaluateExpression.kt

@@ -0,0 +1,43 @@
+import java.util.Stack
+
+fun evaluateExpression(s: String): Int {
+    val stack = Stack<Int>()
+    var currNum = 0
+    var sign = 1
+    var res = 0
+    for (c in s) {
+        if (c.isDigit()) {
+            currNum = currNum * 10 + c.digitToInt()
+            // If the current character is an operator, add 'curr_num' to
+            // the result after multiplying it by its sign.
+        } else if (c == '+' || c == '-') {
+            res += currNum * sign
+            // Update the sign and reset 'curr_num'.
+            sign = if (c == '-') -1 else 1
+            currNum = 0
+            // If the current character is an opening parenthesis, a new
+            // nested expression is starting.
+        } else if (c == '(') {
+            // Save the current 'res' and 'sign' values by pushing them
+            // onto the stack, then reset their values to start
+            // calculating the new nested expression.
+            stack.push(res)
+            stack.push(sign)
+            res = 0
+            sign = 1
+            // If the current character is a closing parenthesis, a nested
+            // expression has ended.
+        } else if (c == ')') {
+            // Finalize the result of the current nested expression.
+            res += sign * currNum
+            // Apply the sign of the current nested  expression's result
+            // before adding this result to the result of the outer
+            // expression.
+            res *= stack.pop()
+            res += stack.pop()
+            currNum = 0
+        }
+    }
+    // Finalize the result of the overall expression.
+    return res + currNum * sign
+}

kotlin/Stacks/ImplementAQueueUsingAStack.kt

@@ -0,0 +1,41 @@
+import java.util.Stack
+
+class Queue {
+
+    private val enqueueStack = Stack<Int>()
+    private val dequeueStack = Stack<Int>()
+
+    fun enqueue(x: Int) {
+        enqueueStack.push(x)
+    }
+
+    private fun transferEnqueueToDequeue() {
+        // If the dequeue stack is empty, push all elements from the enqueue stack
+        // onto the dequeue stack. This ensures the top of the dequeue stack
+        // contains the most recent value.
+        if (dequeueStack.isEmpty()) {
+            while (enqueueStack.isNotEmpty()) {
+                dequeueStack.push(enqueueStack.pop())
+            }
+        }
+    }
+
+    fun dequeue(): Int {
+        transferEnqueueToDequeue()
+        // Pop and return the value at the top of the dequeue stack.
+        return if (dequeueStack.isNotEmpty()) {
+            dequeueStack.pop()
+        } else {
+            -1
+        }
+    }
+
+    fun peek(): Int {
+        transferEnqueueToDequeue()
+        return if (dequeueStack.isNotEmpty()) {
+            dequeueStack.peek()
+        } else {
+            -1
+        }
+    }
+}

kotlin/Stacks/MaximumsOfSlidingWindow.kt

@@ -0,0 +1,30 @@
+fun maximumsOfSlidingWindow(nums: List<Int>, k: Int): List<Int> {
+    val res = mutableListOf<Int>()
+    val dq = ArrayDeque<Pair<Int, Int>>()
+    var left = 0
+    var right = 0
+    while (right < nums.size) {
+        // 1) Ensure the values of the deque maintain a monotonic decreasing order
+        // by removing candidates <= the current candidate.
+        while (dq.isNotEmpty() && dq.last().first <= nums[right]) {
+            dq.removeLast()
+        }
+        // 2) Add the current candidate.
+        dq.add(Pair(nums[right], right))
+        // If the window is of length 'k', record the maximum of the window.
+        if (right - left + 1 == k) {
+            // 3) Remove values whose indexes occur outside the window.
+            while (dq.isNotEmpty() && dq.first().second < left) {
+                dq.removeFirst()
+            }
+            // The maximum value of this window is the leftmost value in the
+            // deque.
+            res.add(dq.first().first)
+            // Slide the window by advancing both 'left' and 'right'. The right
+            // pointer always gets advanced so we just need to advance 'left'.
+            left++
+        }
+        right++
+    }
+    return res
+}

kotlin/Stacks/NextLargestNumberToTheRight.kt

@@ -0,0 +1,20 @@
+import java.util.Stack
+
+fun nextLargestNumberToTheRight(nums: List<Int>): List<Int> {
+    val res = MutableList(nums.size) { 0 }
+    val stack = Stack<Int>()
+    // Find the next largest number of each element, starting with the
+    // rightmost element.
+    for (i in nums.size - 1 downTo 0) {
+        // Pop values from the top of the stack until the current
+        // value's next largest number is at the top.
+        while (stack.isNotEmpty() && stack.peek() <= nums[i]) {
+            stack.pop()
+        }
+        // Record the current value's next largest number, which is at
+        // the top of the stack. If the stack is empty, record -1.
+        res[i] = if (stack.isNotEmpty()) stack.peek() else -1
+        stack.push(nums[i])
+    }
+    return res
+}

kotlin/Stacks/RepeatedRemovalOfAdjacentDuplicates.kt

@@ -0,0 +1,19 @@
+import java.util.Stack
+
+fun repeatedRemovalOfAdjacentDuplicates(s: String): String {
+    val stack = Stack<Char>()
+    for (c in s) {
+        // If the current character is the same as the top character on the stack,
+        // a pair of adjacent duplicates has been formed. So, pop the top character
+        // from the stack.
+        if (stack.isNotEmpty() && c == stack.peek()) {
+            stack.pop()
+        }
+        // Otherwise, push the current character onto the stack.
+        else {
+            stack.push(c)
+        }
+    }
+    // Return the remaining characters as a string.
+    return stack.joinToString("")
+}

kotlin/Stacks/ValidParenthesisExpression.kt

@@ -0,0 +1,24 @@
+import java.util.Stack
+
+fun validParenthesisExpression(s: String): Boolean {
+    val parenthesesMap = mapOf('(' to ')', '{' to '}', '[' to ']')
+    val stack = Stack<Char>()
+    for (c in s) {
+        // If the current character is an opening parenthesis, push it
+        // onto the stack.
+        if (parenthesesMap.containsKey(c)) {
+            stack.push(c)
+        } else {
+            // If the current character is a closing parenthesis, check if
+            // it closes the opening parenthesis at the top of the stack.
+            if (stack.isNotEmpty() && parenthesesMap[stack.peek()] == c) {
+                stack.pop()
+            } else {
+                return false
+            }
+        }
+    }
+    // If the stack is empty, all opening parentheses were successfully
+    // closed.
+    return stack.isEmpty()
+}