❓ Help Pa help sa code (java)

[Singko5]

Evaluation of E×ρréššion


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 E×ρréššion 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 E×ρréššion 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 E×ρréššion 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 E×ρréššion 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 E×ρréššionConverter {
    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 E×ρréššion based on the chosen conversion type.

Note that the code assumes that the input E×ρréššions are valid and well-formed.

 

[Singko5]

need user input sa E×ρréššion

kuha ko na pala

 

[jisoo69]

import java.util.*;

public class E×ρréššionConverter {
    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 E×ρréššion in Prefix form: ");
                String prefixExpression = scanner.nextLine();
                String infixExpression1 = prefixToInfix(prefixExpression);
                System.out.println("Infix: " + infixExpression1);
                break;
            case 2:
                System.out.print("Enter an E×ρréššion in Infix form: ");
                String infixExpression2 = scanner.nextLine();
                String prefixExpression2 = infixToPrefix(infixExpression2);
                System.out.println("Prefix: " + prefixExpression2);
                break;
            case 3:
                System.out.print("Enter an E×ρréššion in Postfix form: ");
                String postfixExpression = scanner.nextLine();
                String infixExpression3 = postfixToInfix(postfixExpression);
                System.out.println("Infix: " + infixExpression3);
                break;
            case 4:
                System.out.print("Enter an E×ρréššion 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+";
    }
}