Queue Stack Reverse Polish Notation - C# Programming Exercise

In this exercise, you need to create a program that reads a Reverse Polish Notation (RPN) expression from a text file, such as:
3 4 6 5 - + * 6 +
(Result 21). In this exercise, the elements of the expression will be stored in a queue. Once the queue has stored all the items, you will need to transfer them from the queue to a stack using the Queue and Stack classes provided in C#.

Once the elements are in the stack, you will need to perform the mathematical operations according to the Reverse Polish Notation using the appropriate methods from the Stack class. In this exercise, you will be tested on how to manipulate these data structures to evaluate the expression and get the correct result.

At the end of this exercise, you will need to display the final result of the expression on the console. This exercise will help you understand how to work with queue and stack data structures in C# and how to apply Reverse Polish Notation to solve mathematical expressions efficiently.

 Category

Dynamic Memory Management

 Exercise

Queue Stack Reverse Polish Notation

 Objective

Create a program that reads a Reverse Polish Notation expression from a text file, for example:

3 4 6 5 - + * 6 +
(Result 21)

Each item will be stored in a queue. Once the queue has all the items stored, you will need to transfer them from the queue to a stack using the Queue and Stack classes provided in C#.

Finally, you will operate with the stack to get the correct result of the RPN expression and show it on the console.

 Write Your C# Exercise

// Importing the necessary namespaces for basic functionalities and collections
using System; // For basic functionalities like Console
using System.Collections.Generic; // For using the Queue and Stack classes
using System.IO; // For reading from a file

class Program
{
    static void Main(string[] args)
    {
        // Reading the Reverse Polish Notation (RPN) expression from a file
        string filePath = "rpn_expression.txt"; // File where the RPN expression is stored
        if (!File.Exists(filePath))
        {
            Console.WriteLine("The file does not exist.");
            return;
        }

        // Read the contents of the file (RPN expression)
        string[] rpnExpression = File.ReadAllText(filePath).Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);

        // Create a Queue to store the elements from the RPN expression
        Queue queue = new Queue();

        // Enqueue the elements of the RPN expression into the queue
        foreach (var item in rpnExpression)
        {
            queue.Enqueue(item);
        }

        // Create a Stack to evaluate the RPN expression
        Stack stack = new Stack();

        // Process each element in the queue, transferring to the stack and calculating the result
        while (queue.Count > 0)
        {
            string current = queue.Dequeue(); // Dequeue the next element from the queue

            if (IsOperator(current))
            {
                // If it's an operator, pop two values from the stack, perform the operation and push the result
                int operand2 = stack.Pop();
                int operand1 = stack.Pop();
                int result = PerformOperation(operand1, operand2, current);
                stack.Push(result);
            }
            else
            {
                // If it's a number, push it onto the stack
                stack.Push(int.Parse(current));
            }
        }

        // The result of the RPN expression will be the last item in the stack
        if (stack.Count == 1)
        {
            Console.WriteLine($"Result: {stack.Pop()}");
        }
        else
        {
            Console.WriteLine("Invalid RPN expression.");
        }
    }

    // Helper method to check if a string is an operator
    static bool IsOperator(string str)
    {
        return str == "+" || str == "-" || str == "*" || str == "/";
    }

    // Helper method to perform the operation based on the operator
    static int PerformOperation(int operand1, int operand2, string operatorSymbol)
    {
        switch (operatorSymbol)
        {
            case "+":
                return operand1 + operand2;
            case "-":
                return operand1 - operand2;
            case "*":
                return operand1 * operand2;
            case "/":
                return operand1 / operand2;
            default:
                throw new InvalidOperationException("Invalid operator.");
        }
    }
}

 Share this C# exercise

 More C# Programming Exercises of Dynamic Memory Management

Explore our set of C# programming exercises! Specifically designed for beginners, these exercises will help you develop a solid understanding of the basics of C#. From variables and data types to control structures and simple functions, each exercise is crafted to challenge you incrementally as you build confidence in coding in C#.

  •  ArrayList

    In this exercise, you need to create a string list using the ArrayList class that already exists in the .NET platform. The ArrayList class allows storing items...

  •  ArrayList duplicate a text file

    In this exercise, you need to create a program that reads from a text file and stores it to another text file by reversing the order of the lines. This exercise will ...

  •  Unlimited sum

    In this exercise, you need to create a program that allows the user to enter an unlimited amount of numbers. Besides entering numbers, the program should allow the user to e...

  •  ArrayList - Text file reader

    In this exercise, you need to create a basic text file reader that displays 21 lines of text and allows the user to navigate using the up and down arrow keys, and exit using...

  •  Hast Table - Dictionary

    In this exercise, you need to create a dictionary using a hash table. The purpose of this exercise is to practice the implementation of an efficient data struc...

  •  Parenthesis

    In this exercise, you need to implement a function to check if a sequence of open and closed parentheses is balanced. In other words, the function should check if every open...