Stacks: Assignment Completed!

Author: avinashbest

stacks/Assignment/CheckRedundantBrackets.java

@@ -0,0 +1,50 @@
+package stacks.Assignment;
+
+import java.util.Stack;
+
+/*Given a single string mathematical expression, return true if
+redundant brackets are present in the expression. Brackets are redundant if
+there is nothing inside the bracket or more than one pair of brackets are present.
+Assume the given string expression is balanced and contains only one type of
+bracket i.e. ().
+Sample Input:
+((a+b))
+(a+b)
+Sample Output:
+true
+false*/
+public class CheckRedundantBrackets {
+
+    private static boolean find(char ch) {
+        return (ch == '+' || ch == '-' || ch == '*' || ch == '/');
+    }
+
+    public static boolean checkRedundant(String expression) {
+        var stack = new Stack<Character>();
+        for (int i = 0; i < expression.length(); i++) {
+            if (expression.charAt(i) == '(' || find(expression.charAt(i))) {
+                stack.push(expression.charAt(i));
+            } else if (expression.charAt(i) == ')') {
+                boolean hasOperator = false;
+
+                while (!stack.isEmpty() && stack.peek() != '(') {
+                    stack.pop();
+                    hasOperator = true;
+                }
+
+                if (!hasOperator) {
+                    return true;
+                }
+
+                if (!stack.isEmpty()) {
+                    stack.pop();
+                }
+            }
+        }
+        return false;
+    }
+
+    public static void main(String[] args) {
+        System.out.println(checkRedundant("((a+b))"));
+    }
+}

stacks/Assignment/MinimumBracketsReversal.java

@@ -0,0 +1,78 @@
+package stacks.Assignment;
+
+import java.util.Stack;
+
+/*For a given expression in the form of a string, find the minimum number of brackets that can be reversed in order to make the expression balanced. The expression will only contain curly brackets.
+If the expression can't be balanced, return -1.
+Example:
+Expression: {{{{
+If we reverse the second and the fourth opening brackets, the whole expression will get balanced. Since we have to reverse two brackets to make the expression balanced, the expected output will be 2.
+
+Expression: {{{
+In this example, even if we reverse the last opening bracket, we would be left with the first opening bracket and hence will not be able to make the expression balanced and the output will be -1.
+Input Format :
+The first and the only line of input contains a string expression, without any spaces in between.
+Output Format :
+The only line of output will print the number of reversals required to balance the whole expression. Prints -1, otherwise.
+Note:
+You don't have to print anything. It has already been taken care of.
+Constraints:
+0 <= N <= 10^6
+Where N is the length of the expression.
+
+Time Limit: 1sec
+Sample Input 1:
+{{{
+Sample Output 1:
+-1
+Sample Input 2:
+{{{{}}
+Sample Output 2:
+1*/
+public class MinimumBracketsReversal {
+
+    public static int countBracketsReversals(String expression) {
+        if (expression.length() == 0) {
+            return 0;
+        }
+
+        if (expression.length() % 2 != 0) {
+            return -1; // Only even numbers of brackets can be balanced
+        }
+
+        var stack = new Stack<Character>();
+        for (int i = 0; i < expression.length(); i++) {
+            char currentCharacter = expression.charAt(i);
+
+            if (currentCharacter == '(') {
+                stack.push(currentCharacter);
+            } else {
+//                pop if there is a balanced pair
+                if (!stack.isEmpty() && stack.peek() == '{') {
+                    stack.pop();
+                } else {
+                    stack.push(currentCharacter);
+                }
+            }
+        }
+
+        int count = 0;
+
+//        only unbalanced brackets are there in stack now
+        while (!stack.isEmpty()) {
+            char char1 = stack.pop();
+            char char2 = stack.pop();
+            /*when char1 = } and char2 = {, then we need to reverse both of them so count will increase by 2*/
+            if (char1 != char2) {
+                count += 2;
+            } else {
+                count++;
+            }
+        }
+        return count;
+    }
+
+    public static void main(String[] args) {
+        System.out.println(countBracketsReversals("{{{{}}"));
+    }
+}

stacks/Assignment/StockSpan.java

@@ -0,0 +1,69 @@
+package stacks.Assignment;
+
+import java.util.Arrays;
+import java.util.Stack;
+
+/*Afzal has been working with an organization called 'Money Traders' for the past few years. The organization is into the money trading business. His manager assigned him a task. For a given array/list of stock's prices for N days, find the stock's span for each day.
+The span of the stock's price today is defined as the maximum number of consecutive days(starting from today and going backwards) for which the price of the stock was less than today's price.
+For example, if the price of a stock over a period of 7 days are [100, 80, 60, 70, 60, 75, 85], then the stock spans will be [1, 1, 1, 2, 1, 4, 6].
+Explanation:
+On the sixth day when the price of the stock was 75, the span came out to be 4, because the last 4 prices(including the current price of 75) were less than the current or the sixth day's price.
+
+Similarly, we can deduce the remaining results.
+Afzal has to return an array/list of spans corresponding to each day's stock's price. Help him to achieve the task.
+Input Format:
+The first line of input contains an integer N, denoting the total number of days.
+
+The second line of input contains the stock prices of each day. A single space will separate them.
+Output Format:
+The only line of output will print the span for each day's stock price. A single space will separate them.
+Note:
+You are not required to print the expected output explicitly. It has already been taken care of.
+Constraints:
+0 <= N <= 10^7
+1 <= X <= 10^9
+Where X denotes the stock's price for a day.
+
+Time Limit: 1 second
+Sample Input 1:
+4
+10 10 10 10
+Sample Output 1:
+1 1 1 1
+Sample Input 2:
+8
+60 70 80 100 90 75 80 120
+Sample Output 2:
+1 2 3 4 1 1 2 8 */
+public class StockSpan {
+
+    public static int[] stockSpan(int[] price) {
+        Stack<Integer> stack = new Stack<>();
+        int n = price.length;
+
+        int[] output = new int[n];
+
+        stack.push(0);
+        output[0] = 1;
+
+        for (int i = 1; i < n; i++) {
+            while (!stack.isEmpty() && price[stack.peek()] < price[i]) {
+                stack.pop();
+            }
+
+            if (stack.isEmpty()) {
+                output[i] = i + 1;
+            } else {
+                output[i] = i - stack.peek();
+            }
+            stack.push(i);
+        }
+        return output;
+    }
+
+    public static void main(String[] args) {
+        int[] X = {60, 70, 80, 100, 90, 75, 80, 120};
+
+        System.out.println(Arrays.toString(stockSpan(X)));
+    }
+}

stacks/ReverseStack.java

@@ -21,24 +21,24 @@ public static void main(String[] args) {
         }
     }
 
-    private static void reverseStack(Stack<Integer> input, Stack<Integer> extra) {
-        if (input.size() <= 1) {
+    private static void reverseStack(Stack<Integer> stack, Stack<Integer> helper) {
+        if (stack.size() <= 1) {
             return;
         }
 
-        int lastElement = input.pop();
+        int lastElement = stack.pop();
 
-        reverseStack(input, extra);
+        reverseStack(stack, helper);
 
-        while (!input.isEmpty()) {
-            int top = input.pop();
-            extra.push(top);
+        while (!stack.isEmpty()) {
+            int top = stack.pop();
+            helper.push(top);
         }
-        input.push(lastElement);
+        stack.push(lastElement);
 
-        while (!extra.isEmpty()) {
-            int top = extra.pop();
-            input.push(top);
+        while (!helper.isEmpty()) {
+            int top = helper.pop();
+            stack.push(top);
         }
     }
 }