Instalación y Configuración
Metodología Programación
Video Tutoriales

Evaluación De La Notación Polaca Inversa Mediante Cola Y Pila En C#

En este ejercicio, creará un programa que lee una expresión de Notación Polaca Inversa (RPN) de un archivo de texto. RPN es una notación matemática en la que cada operador sigue a todos sus operandos, eliminando la necesidad de paréntesis.

El programa primero almacenará cada elemento de la expresión RPN en una cola. Una vez almacenados todos los elementos, se transferirán de la cola a una pila mediante las clases "Queue" y "Stack" de C#. La pila se utilizará para evaluar la expresión RPN paso a paso, realizando las operaciones aritméticas necesarias.

Al completar este ejercicio, adquirirá experiencia en el manejo de estructuras de datos de cola y pila, trabajando con la entrada de archivos y procesando expresiones matemáticas de forma estructurada. Este tipo de evaluación se utiliza ampliamente en compiladores y calculadoras.



Grupo

Gestión Dinámica de Memoria en C#

Objectivo

1. Leer una expresión RPN de un archivo de texto.
2. Almacenar cada elemento en una cola.
3. Transferir elementos de la cola a una pila.
4. Procesar la pila para calcular el resultado de la expresión RPN.
5. Mostrar el resultado final en la consola.

Crear un programa que lea una expresión de Notación Polaca Inversa de un archivo de texto, por ejemplo: 

3 4 6 5 - + * 6 +

(Result 21)


Cada elemento se almacenará en una cola. Una vez que la cola tenga todos los elementos almacenados, deberá transferirlos de la cola a una pila utilizando las clases Queue y Stack de C#.

Finalmente, operará con la pila para obtener el resultado correcto de la expresión RPN y mostrarlo en la consola.

Ejemplo de ejercicio en C#

 Copiar código C# 
using System;
using System.Collections.Generic;
using System.IO;

class ReversePolishNotation
{
    static void Main()
    {
        // Define the file path where the RPN expression is stored
        string filePath = "rpn_expression.txt";

        // Read the expression from the file
        string expression = File.ReadAllText(filePath).Trim();

        // Split the expression into individual tokens (numbers and operators)
        string[] tokens = expression.Split(' ');

        // Create a queue to store the tokens
        Queue queue = new Queue();

        // Enqueue each token into the queue
        foreach (string token in tokens)
        {
            queue.Enqueue(token);
        }

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

        // Process the queue and evaluate the RPN expression
        while (queue.Count > 0)
        {
            string currentToken = queue.Dequeue();

            // Check if the token is a number
            if (int.TryParse(currentToken, out int number))
            {
                // Push the number onto the stack
                stack.Push(number);
            }
            else
            {
                // If the token is an operator, pop two values from the stack
                int b = stack.Pop();
                int a = stack.Pop();

                // Perform the corresponding operation
                int result = currentToken switch
                {
                    "+" => a + b,
                    "-" => a - b,
                    "*" => a * b,
                    "/" => a / b,
                    _ => throw new InvalidOperationException("Invalid operator encountered.")
                };

                // Push the result back onto the stack
                stack.Push(result);
            }
        }

        // The final result will be the only value left in the stack
        Console.WriteLine($"Result: {stack.Pop()}");
    }
}

 Output

Result: 21

Comparte este ejercicio de C#

Practica más ejercicios C# de Gestión Dinámica de Memoria en C#

¡Explora nuestro conjunto de ejercicios de práctica de C#! Diseñados específicamente para principiantes, estos ejercicios te ayudarán a desarrollar una sólida comprensión de los fundamentos de C#. Desde variables y tipos de datos hasta estructuras de control y funciones simples, cada ejercicio está diseñado para desafiarte gradualmente a medida que adquieres confianza en la programación en C#..