calculatrice de préfixe utilisant stack en javascript

Question

J'essaie de créer une calculatrice avec la méthode d'entrée RPN (notation polonaise inversée) en utilisant la pile en javascript.

input : [1, 5, '+', 6, 3, '-', '/', 7, '*']

1 est un opérande, pousser vers Stack.

5 est un opérande, pousser vers Stack.

'+' est un opérateur, pop 1 et 5, les calculer et pousser le résultat vers Stack.

6 est un opérande, push to Stack.

3 est un opérande, pousser vers Stack.

'-' est un opérateur, pop 6 et 3, soustrayez-les et transmettez le résultat à Stack.

'/' est un opérateur, pop 6 et 3, les divise et pousse le résultat vers Stack.

7 est un opérande, push to Stack.

'*' est un opérateur, pop 2 et 7, multipliez-les et transmettez le résultat à Stack.

output : [14]

existe-t-il une autre alternative pour rendre mon code plus efficace?

const x1 = x.push(1);
const x2 = x.push(5);
const x3 = x.push('+');

x.pop(1);
x.pop(5);
x.pop('+');
x.push(1+5);

const x4 = x.push(6);
const x5 = x.push(3);
const x6 = x.push('-');

x.pop(6);
x.pop(3);
x.pop('-');
x.push(6-3);

const x7 = x.push('/');
x.pop(6);
x.pop(3);
x.pop('/');
x.push(6/3);

const x8 = x.push(7);
const x9 = x.push('*');

x.pop(2);
x.pop(7);
x.pop('*');
x.push(2*7);

console.log(x);

Answer 1

Vous pouvez prendre un objet pour tous les opérateurs et vérifier si la valeur de inputest un opérateur, puis effectuer l'opération avec les valeurs sautées inversées de la pile ou pousser la valeur vers la pile.

const
    operators = {
        '+': (a, b) => a + b,
        '-': (a, b) => a - b,
        '*': (a, b) => a * b,
        '/': (a, b) => a / b
    },
    input = [1, 5, '+', 6, 3, '-', '/', 7, '*'],
    stack = [];

input.forEach(value => {
    stack.push(value in operators
        ? operators[value](...stack.splice(-2))
        : value
    );
    console.log(...stack);
});

.as-console-wrapper { max-height: 100% !important; top: 0; }