Pila (stack)

class Pila:
    """Una pila de enteros. Una lista de Python ya crece sola: append y pop trabajan por el final."""
    def __init__(self):
        self._a = []

    def apilar(self, x):
        self._a.append(x)

    def desapilar(self):
        if not self._a:
            raise IndexError("pila vacía")
        return self._a.pop()

    def __str__(self):
        return str(self._a)


def evaluar(expr):
    """Evalúa una expresión en notación polaca inversa: «3 4 +» significa 3 + 4."""
    p = Pila()
    for t in expr.split():
        if t.lstrip("-").isdigit():
            p.apilar(int(t))                         # un número se apila
        else:
            b, a = p.desapilar(), p.desapilar()      # un operador usa los dos de arriba
            p.apilar({"+": a + b, "-": a - b, "*": a * b}.get(t, a // b if b else 0))
        print(f"{t:<3}→ {p}")
    return p.desapilar()


print("Resultado:", evaluar("3 4 + 2 * 7 -"))

/** Una pila de enteros. Un array de JavaScript ya crece solo: push y pop trabajan por el final. */
class Pila {
    #a = [];
    apilar(x) { this.#a.push(x); }
    desapilar() {
        if (this.#a.length === 0) throw new Error("pila vacía");
        return this.#a.pop();
    }
    toString() { return "[" + this.#a.join(", ") + "]"; }
}

/** Evalúa una expresión en notación polaca inversa: «3 4 +» significa 3 + 4. */
function evaluar(expr) {
    const p = new Pila();
    for (const t of expr.split(" ")) {
        if (/^-?\d+$/.test(t)) p.apilar(Number(t));                 // un número se apila
        else {
            const b = p.desapilar(), a = p.desapilar();              // un operador usa los dos de arriba
            p.apilar({ "+": a + b, "-": a - b, "*": a * b }[t] ?? Math.trunc(a / b));
        }
        console.log(t.padEnd(3) + "→ " + p);
    }
    return p.desapilar();
}

console.log("Resultado: " + evaluar("3 4 + 2 * 7 -"));

using System;

class Pila {
    private int[] a = new int[2];
    private int n = 0;                                       // cuántos hay; la cima es a[n - 1]

    public void Apilar(int x) {
        if (n == a.Length) Array.Resize(ref a, 2 * a.Length);   // lleno: el doble de sitio
        a[n++] = x;
    }

    public int Desapilar() {
        if (n == 0) throw new InvalidOperationException("pila vacía");
        return a[--n];
    }

    public override string ToString() => "[" + string.Join(", ", a[..n]) + "]";
}

class Program {
    // Evalúa una expresión en notación polaca inversa: «3 4 +» significa 3 + 4.
    static int Evaluar(string expr) {
        var p = new Pila();
        foreach (string t in expr.Split(' ')) {
            if (int.TryParse(t, out int x)) p.Apilar(x);              // un número se apila
            else {
                int b = p.Desapilar(), a = p.Desapilar();              // un operador usa los dos de arriba
                p.Apilar(t switch { "+" => a + b, "-" => a - b, "*" => a * b, _ => a / b });
            }
            Console.WriteLine(t.PadRight(3) + "→ " + p);
        }
        return p.Desapilar();
    }

    static void Main() => Console.WriteLine("Resultado: " + Evaluar("3 4 + 2 * 7 -"));
}

<?php
/** Una pila de enteros sobre un array de PHP (que ya crece solo). */
class Pila {
    private array $a = [];

    public function apilar(int $x): void { $this->a[] = $x; }

    public function desapilar(): int {
        if (!$this->a) throw new UnderflowException("pila vacía");
        return array_pop($this->a);
    }

    public function __toString(): string { return "[" . implode(", ", $this->a) . "]"; }
}

/** Evalúa una expresión en notación polaca inversa: «3 4 +» significa 3 + 4. */
function evaluar(string $expr): int {
    $p = new Pila();
    foreach (explode(" ", $expr) as $t) {
        if (preg_match('/^-?\d+$/', $t)) $p->apilar((int) $t);       // un número se apila
        else {
            $b = $p->desapilar();                                     // un operador usa los dos de arriba
            $a = $p->desapilar();
            $p->apilar(match ($t) { "+" => $a + $b, "-" => $a - $b, "*" => $a * $b, default => intdiv($a, $b) });
        }
        echo str_pad($t, 3) . "→ " . $p . "\n";
    }
    return $p->desapilar();
}

echo "Resultado: " . evaluar("3 4 + 2 * 7 -") . "\n";

# En Python, una lista ya es una pila: append apila y pop desapila por el final
pila = []
pila.append("a")              # apilar
pila.append("b")
cima = pila[-1]               # "b", sin quitarlo
sale = pila.pop()             # "b"
vacia = not pila              # False: queda "a"

// En JavaScript, un array ya es una pila: push apila y pop desapila por el final
const pila = [];
pila.push("a");                         // apilar
pila.push("b");
const cima = pila[pila.length - 1];     // "b", sin quitarlo (o pila.at(-1))
const sale = pila.pop();                // "b"
const vacia = pila.length === 0;        // false: queda "a"

// En C#, Stack<T>
var pila = new Stack<string>();
pila.Push("a");                  // apilar
pila.Push("b");
string cima = pila.Peek();       // "b", sin quitarlo
string sale = pila.Pop();        // "b"
bool vacia = pila.Count == 0;    // false: queda "a"

// En PHP, un array con array_push / array_pop, o la clase SplStack
$pila = [];
$pila[] = "a";                   // apilar
$pila[] = "b";
$cima = end($pila);              // "b", sin quitarlo
$sale = array_pop($pila);        // "b"
$vacia = empty($pila);           // false: queda "a"