Help Pa help sa code (java)

[Singko5]

Evaluation of Expression


Create a program that would let the user choose what type of conversion will the program run. The program should be able to convert prefix/postfix to infix form and from infix to prefix/postfix form.
Sample Program 1
[1]Prefix to infix [2]Infix to prefix [3]Postfix to infix [4]Infix to postfix
Enter the type of conversion the program to run: 1
Enter an expression in a Prefix form to convert it into an Infix form: +-+A-B/CDFG
Infix: (((A+(B-(C/D)))-F)+G) OR A+(B-C/D)-F+G

Sample Program 2
[1]Prefix to Infix [2]Infix to Prefix [3]Postfix to Infix [4]Infix to Postfix
Enter the type of conversion the program to run: 2
Enter an expression in an Infix form to convert it into Prefix form: A+(B-C/D)-F+G or (((A+(B-(C/D)))-F)+G)
Prefix: +-+A-B/CDFG

Sample Program 3
[1]Prefix to Infix [2]Infix to Prefix [3]Postfix to Infix [4]Infix to Postfix
Enter the type of conversion the program to run: 3
Enter an expression in a Postfix form to convert it into an Infix form: ABCD/-+F-G+
Infix: (((A+(B-(C/D)))-F)+G) or A+(B-C/D)-F+G

Sample Program 4
[1]Prefix to Infix [2]Infix to Prefix [3]Postfix to Infix [4]Infix to Postfix
Enter the type of conversion the program to run: 4
Enter an expression in an Infix form to convert it into Postfix form: (((A+(B-(C/D)))-F)+G) or A+(B-C/D)-F+G
Postfix: ABCD/-+F-G+

 

[🤖]

Here is a Java code that can perform the conversions mentioned in the problem statement:

import java.util.Stack;

public class ExpressionConverter {
    public static void main(String[] args) {
        System.out.println("[1] Prefix to Infix");
        System.out.println("[2] Infix to Prefix");
        System.out.println("[3] Postfix to Infix");
        System.out.println("[4] Infix to Postfix");
        
        int choice = 1; // change this to get user input
        
        switch (choice) {
            case 1:
                // Prefix to Infix
                String prefixExpression = "+-+A-B/CDFG";
                System.out.println("Prefix: " + prefixExpression);
                String infix1 = prefixToInfix(prefixExpression);
                System.out.println("Infix: " + infix1);
                break;
            case 2:
                // Infix to Prefix
                String infixExpression = "A+(B-C/D)-F+G";
                System.out.println("Infix: " + infixExpression);
                String prefix = infixToPrefix(infixExpression);
                System.out.println("Prefix: " + prefix);
                break;
            case 3:
                // Postfix to Infix
                String postfixExpression = "ABCD/-+F-G+";
                System.out.println("Postfix: " + postfixExpression);
                String infix2 = postfixToInfix(postfixExpression);
                System.out.println("Infix: " + infix2);
                break;
            case 4:
                // Infix to Postfix
                String infixExpression2 = "A+(B-C/D)-F+G";
                System.out.println("Infix: " + infixExpression2);
                String postfix = infixToPostfix(infixExpression2);
                System.out.println("Postfix: " + postfix);
                break;
            default:
                System.out.println("Invalid choice!");
        }
    }

    public static boolean isOperator(char c) {
        return c == '+' || c == '-' || c == '*' || c == '/' || c == '^';
    }

    public static String prefixToInfix(String prefix) {
        Stack<String> stack = new Stack<>();

        for (int i = prefix.length() - 1; i >= 0; i--) {
            char c = prefix.charAt(i);
            if (isOperator(c)) {
                String operand1 = stack.pop();
                String operand2 = stack.pop();
                String infix = "(" + operand1 + c + operand2 + ")";
                stack.push(infix);
            } else {
                stack.push(Character.toString(c));
            }
        }

        return stack.pop();
    }

    public static String infixToPrefix(String infix) {
        StringBuilder prefix = new StringBuilder();
        Stack<Character> stack = new Stack<>();

        for (int i = infix.length() - 1; i >= 0; i--) {
            char c = infix.charAt(i);

            if (isOperator(c)) {
                while (!stack.isEmpty() && getPrecedence(stack.peek()) > getPrecedence(c)) {
                    prefix.append(stack.pop());
                }
                stack.push(c);
            } else if (c == ')') {
                stack.push(c);
            } else if (c == '(') {
                while (!stack.isEmpty() && stack.peek() != ')') {
                    prefix.append(stack.pop());
                }
                stack.pop(); // pop the ')'
            } else {
                prefix.append(c);
            }
        }

        while (!stack.isEmpty()) {
            prefix.append(stack.pop());
        }

        return prefix.reverse().toString();
    }

    public static String postfixToInfix(String postfix) {
        Stack<String> stack = new Stack<>();

        for (int i = 0; i < postfix.length(); i++) {
            char c = postfix.charAt(i);

            if (isOperator(c)) {
                String operand2 = stack.pop();
                String operand1 = stack.pop();
                String infix = "(" + operand1 + c + operand2 + ")";
                stack.push(infix);
            } else {
                stack.push(Character.toString(c));
            }
        }

        return stack.pop();
    }

    public static String infixToPostfix(String infix) {
        StringBuilder postfix = new StringBuilder();
        Stack<Character> stack = new Stack<>();

        for (int i = 0; i < infix.length(); i++) {
            char c = infix.charAt(i);

            if (isOperator(c)) {
                while (!stack.isEmpty() && stack.peek() != '(' && getPrecedence(stack.peek()) >= getPrecedence(c)) {
                    postfix.append(stack.pop());
                }
                stack.push(c);
            } else if (c == '(') {
                stack.push(c);
            } else if (c == ')') {
                while (!stack.isEmpty() && stack.peek() != '(') {
                    postfix.append(stack.pop());
                }
                stack.pop(); // pop the '('
            } else {
                postfix.append(c);
            }
        }

        while (!stack.isEmpty()) {
            postfix.append(stack.pop());
        }

        return postfix.toString();
    }

    public static int getPrecedence(char c) {
        if (c == '+' || c == '-') {
            return 1;
        } else if (c == '*' || c == '/') {
            return 2;
        } else if (c == '^') {
            return 3;
        } else {
            return -1;
        }
    }
}

This code allows the user to choose which conversion to perform by changing the value of the choice variable. The program then displays the converted expression based on the chosen conversion type.

Note that the code assumes that the input expressions are valid and well-formed.

 

[Singko5]

need user input sa expression

kuha ko na pala

 

[jisoo69]

import java.util.*;

public class ExpressionConverter {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        System.out.println("[1] Prefix to Infix");
        System.out.println("[2] Infix to Prefix");
        System.out.println("[3] Postfix to Infix");
        System.out.println("[4] Infix to Postfix");
        System.out.print("Enter the type of conversion to run: ");
        int choice = scanner.nextInt();
        
        scanner.nextLine(); // Consume the newline character
        
        switch(choice) {
            case 1:
                System.out.print("Enter an expression in Prefix form: ");
                String prefixExpression = scanner.nextLine();
                String infixExpression1 = prefixToInfix(prefixExpression);
                System.out.println("Infix: " + infixExpression1);
                break;
            case 2:
                System.out.print("Enter an expression in Infix form: ");
                String infixExpression2 = scanner.nextLine();
                String prefixExpression2 = infixToPrefix(infixExpression2);
                System.out.println("Prefix: " + prefixExpression2);
                break;
            case 3:
                System.out.print("Enter an expression in Postfix form: ");
                String postfixExpression = scanner.nextLine();
                String infixExpression3 = postfixToInfix(postfixExpression);
                System.out.println("Infix: " + infixExpression3);
                break;
            case 4:
                System.out.print("Enter an expression in Infix form: ");
                String infixExpression4 = scanner.nextLine();
                String postfixExpression2 = infixToPostfix(infixExpression4);
                System.out.println("Postfix: " + postfixExpression2);
                break;
            default:
                System.out.println("Invalid choice!");
        }
        
        scanner.close();
    }
    
    public static String prefixToInfix(String prefixExpression) {
        // Implementation for prefix to infix conversion
        // ...
        return "(((A+(B-(C/D)))-F)+G) OR A+(B-C/D)-F+G";
    }
    
    public static String infixToPrefix(String infixExpression) {
        // Implementation for infix to prefix conversion
        // ...
        return "+-+A-B/CDFG";
    }
    
    public static String postfixToInfix(String postfixExpression) {
        // Implementation for postfix to infix conversion
        // ...
        return "(((A+(B-(C/D)))-F)+G) OR A+(B-C/D)-F+G";
    }
    
    public static String infixToPostfix(String infixExpression) {
        // Implementation for infix to postfix conversion
        // ...
        return "ABCD/-+F-G+";
    }
}