Iniciar sesiónCerrar
Correo:
Contraseña:
Entrar
Recordar sesión en este navegador
Iniciar sesiónIniciar sesiónCrear cuentaCrear cuenta
LWP » Foros » Algoritmia » Inverse polish

Algoritmia - Inverse polish

Volver
Nuevo Tema
<<>>
 
Vista:

Inverse polish

Publicado por Alis (2 intervenciones) el 29/11/2005 21:31:09
Hola!!!
Necesito ayuda rapida por favor, tengo que hacer para manana (si, ya se que es tarde pero es que me acabo de enterar) una calculadora que trabaje en el metodo "Inverse polish" ( estoy de erasmus y no traducirlo exactamente) que es el emtodo que utiliza por ejemplo la HP, q coge los numeros, los inserta en una cola, los operadores en una pila y luego va haciendo los calculos (o algo asi)
Si alguien tuviera el algoritmo ya hecho me seria de gran ayuda...
GRACIAS!!!
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder
Imágen de perfil de Alejandro

Calculadora con notación polaca inversa (RPN)

Publicado por Alejandro (307 intervenciones) el 05/03/2024 20:26:54
¡Hola Alis!

Entiendo que necesitas una calculadora que utilice el método de notación polaca inversa (RPN). Aquí te proporcionaré un ejemplo sencillo de cómo podrías implementar esto en C.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
#include <stdio.h>
#include <stdlib.h>
 
// Estructura de la pila
struct Stack {
    int top;
    unsigned capacity;
    int* array;
};
 
// Función para inicializar una pila
struct Stack* createStack(unsigned capacity) {
    struct Stack* stack = (struct Stack*)malloc(sizeof(struct Stack));
    stack->capacity = capacity;
    stack->top = -1;
    stack->array = (int*)malloc(stack->capacity * sizeof(int));
    return stack;
}
 
// Funciones para verificar si la pila está vacía o llena
int isEmpty(struct Stack* stack) {
    return stack->top == -1;
}
 
int isFull(struct Stack* stack) {
    return stack->top == stack->capacity - 1;
}
 
// Función para insertar un elemento en la pila
void push(struct Stack* stack, int item) {
    if (isFull(stack))
        return;
    stack->array[++stack->top] = item;
}
 
// Función para quitar y devolver un elemento de la pila
int pop(struct Stack* stack) {
    if (isEmpty(stack))
        return -1;
    return stack->array[stack->top--];
}
 
// Función para evaluar la expresión en notación polaca inversa
int evaluateRPN(char* tokens[], int n) {
    struct Stack* stack = createStack(n);
 
    for (int i = 0; i < n; i++) {
        if (tokens[i][0] >= '0' && tokens[i][0] <= '9') {
            push(stack, atoi(tokens[i]));
        } else {
            int operand2 = pop(stack);
            int operand1 = pop(stack);
 
            switch (tokens[i][0]) {
                case '+':
                    push(stack, operand1 + operand2);
                    break;
                case '-':
                    push(stack, operand1 - operand2);
                    break;
                case '*':
                    push(stack, operand1 * operand2);
                    break;
                case '/':
                    push(stack, operand1 / operand2);
                    break;
            }
        }
    }
    return pop(stack);
}
 
int main() {
    // Ejemplo de expresión en notación polaca inversa (RPN)
    char* tokens[] = {"2", "3", "4", "*", "+"};
 
    // Número de elementos en la expresión
    int n = sizeof(tokens) / sizeof(tokens[0]);
 
    // Evaluar y mostrar el resultado
    printf("Resultado: %d\n", evaluateRPN(tokens, n));
 
    return 0;
}

Este es un ejemplo básico para darte una idea. Puedes adaptar este código según tus necesidades específicas y expandir las operaciones o manejar más casos según sea necesario. ¡Espero que esto te sea de ayuda!
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar