No puedo creer que aún no tengamos esto ... Es una de las estructuras de datos más importantes en la programación, pero aún así es lo suficientemente simple como para implementarlo en un código de golf :

Desafío

Su tarea es implementar una pila que permita empujar y reventar números, para probar su implementación y mantener la E / S simple. Usaremos la siguiente configuración:

• La entrada será una lista de enteros no negativos

Cada entero positivo indica un y cada indica un , descartando el elemento superior.push ( n ) 0 $n$$\texttt{push(}n\texttt{)}$$0$$\texttt{pop()}$

• La salida será la pila resultante

Ejemplo

Por ejemplo, si se nos da :$[12,3,0,101,11,1,0,0,14,0,28]$

La producción será:$[28,101,12]$

Reglas

• La entrada será una lista de enteros no negativos en cualquier formato de E / S predeterminado
  • puede usar un entero negativo para indicar el final de una secuencia de enteros
• La salida será una lista / matriz / ... de la pila resultante
  • Si elige dónde estará el elemento superior (al principio o al final), la salida solo debe ser coherente
  • la salida es flexible (por ejemplo, los enteros separados por nuevas líneas estarían bien), lo único que importa es el orden
  • puedes usar un número entero negativo para indicar la parte inferior de la pila
• Tienes la garantía de que nunca habrá un cuando la pila esté vacía$0$

Ejemplos

[] -> []
[1] -> [1]
[1,0,2] -> [2]
[4,0,1,12] -> [12,1]
[8,3,1,2,3] -> [3,2,1,3,8]
[1,3,7,0,0,0] -> []
[13,0,13,10,1,0,1005,5,0,0,0] -> [13]
[12,3,0,101,11,1,0,0,14,0,28] -> [28,101,12]

MATL , 6 bytes

"@?@}x

La entrada es un vector fila de números.

La pila final se muestra al revés, con el elemento más reciente a continuación.

Pruébalo en línea! O verificar todos los casos de prueba .

Explicación

"         % For each element in the input (implicit)
  @       %   Push current element
  ?       %   If non-zero (this consumes the current element)
    @     %     Push current element again
  }       %   Else
    x     %     Delete most recent element
          %   End (implicit)
          % End (implicit)
          % Display (implicit)

Java (JDK 10) , 42 bytes

Como "[la] salida es flexible [...], lo único que importa es el orden", esto cambia la matriz de entrada en una 0matriz terminada. Ejemplo: [1,0,2]devolverá [2,0,2]lo que debe interpretarse como = .[2,0,2][2]

a->{int s=0;for(int v:a)a[v>0?s++:--s]=v;}

Pruébalo en línea!

Versión anterior:

Java (JDK 10) , 60 bytes

l->{for(int i;(i=l.indexOf(0))>0;l.remove(i))l.remove(--i);}

Pruébalo en línea!

Créditos

• -1 byte gracias a OOBalance

Si puedo finalizar el programa con errores: 55 bytes

(aunque todo está modificado correctamente)

l->{for(int i;;l.remove(--i))l.remove(i=l.indexOf(0));}

Pruébalo en línea!

Sed, 17 bytes

:;s/[0-9]\+,0//;t

-3 bytes gracias a @ OMᗺ, -1 gracias a @eggyal

Como se garantiza que nunca aparecerá una lista vacía, no necesita nada más que una máquina de estados finitos iterada. Las expresiones regulares son una herramienta para construir máquinas de estados finitos y sedpueden iterar. Es un partido hecho en el cielo.

Toma información de stdin, así:

echo '[12,3,0,101,11,1,0,0,14,0,28]' | sed ':;s/[0-9]\+,0,//;t'

Emite la pila en reversa:

[12,101,28]

Podría ser más pequeño en dos bytes si mis sedclases de caracteres locales entendían inherentemente \d, pero por alguna razón no lo hace.

PowerShell , 46 41 40 bytes

$args|%{$x,$a=&({1,$_+$a},{$a})[!$_]};$a

Pruébalo en línea!

Toma información a través de salpicaduras, por ejemplo $z=@(12,3,0,101,11,1,0,0,14,0,28); .\implement-stack.ps1 @z, que en TIO se manifiesta como argumentos separados.

$args|%{$x,$a=&({1,$_+$a},{$a})[!$_]};$a    # Full program
$args                                       # Take input via splatting
     |%{                            };      # Loop through each item
              &(              )[!$_]        # Pseudo-ternary, if input is 0 this is 1
        $x,$a=            {$a}              # ... which will pop the first item into $x
           $a=  { ,$_+$a}                   # Else, we append the first item
        $x   =   1                          # ... and drop a dummy value into $x
                                      $a    # Leave $a on pipeline; implicit output

-5 bytes gracias a mazzy.
-1 byte intercambiando $_a1

C (gcc) , 62 60 56 55 bytes

-2 -6 bytes gracias a l4m2

-1 byte gracias a ceilingcat .

Utiliza la noción permitida de arrays terminados en -1. f()se llama recursivamente, hasta que está completamente enrollado, y luego retrocede en la lista. rrealiza un seguimiento de cuántos números descartar antes de imprimir algo. Aumenta si el elemento actual es 0, disminuye de lo contrario. Si es 0, no necesitamos descartar, y podemos imprimir el número.

r;f(int*l){~*l?f(l+1),*l?r?r--:printf("%d ",*l):r++:0;}

Pruébalo en línea!

Haskell, 28 bytes

foldl(#)[]
(_:s)#0=s
s#n=n:s

Pruébalo en línea!

R , 45 bytes

o={};for(e in scan())o="if"(e,c(e,o),o[-1]);o

Pruébalo en línea!

• -4 byte gracias a @Giuseppe

Python 2 , 59 57 51 bytes

s=[]
for x in input():s=(s+[x],s[:-1])[x<1]
print s

Pruébalo en línea!

Jalea , 6 bytes

ṣ0Ṗ;¥/

Pruébalo en línea!

Cómo funciona

ṣ0Ṗ;¥/  Main link. Argument: A (array)

ṣ0      Split A at zeroes.
    ¥/  Left-reduce the resulting 2D array by this dyadic chain:
  Ṗ       Pop; discard the last element of the left argument.
   ;      Concatenate the result with the right argument.

Brain-Flak , 40 36 bytes

([]){{}{({}<>)<>}([]){{}<>}{}([])}<>

Pruébalo en línea!

Gracias a @Nitrodon por -4 bytes.

Como Brain-Flak ya usa pilas, este es un buen rompecabezas para Brain-Flak.

([]){   while items on stack
    {}      pop stack count
    {       if top element is non-zero
        ({}<>)<> push it on the other stack
    }
    if we're here the stack is either empty or there's a 0 on the stack

    ([])    so, count the stack again
    {{}<>{}<>} if there are items left on the stack, pop the stack count and the last item of the other stack
    {} pop the zero or the stack count
    ([]) count the stack again for next round
}
<>  go to the output stack

Wolfram Language (Mathematica) , 28 bytes

#//.{a___,b_,0,c___}:>{a,c}&

Pruébalo en línea!

Python 2 , 48 bytes

s=[]
for x in input():s=([x]+s)[2*0**x:]
print s

Pruébalo en línea!

Espacio en blanco , 89 bytes

[N
S S N
_Create_Label_LOOP_1][S S S N
_Push_0][S N
S _Duplicate_0][T   N
T   T   _Read_STDIN_as_integer][T   T   T   _Retrieve][S N
S _Duplicate_input][N
T   T   S 
_If_neg_Jump_to_Label_EXIT][S N
S _Duplicate_input][N
T   S T N
_If_0_Jump_to_Label_DROP][N
S N
N
_Jump_to_Label_LOOP_1][N
S S S N
_Create_Label_EXIT][S N
N
_Discard_top][N
S S S S N
_Create_Label_LOOP_2][T N
S T _Print_as_integer][S S S T  S T S N
_Push_10_newline][T N
S S _Print_as_character][N
S T S S N
_Jump_to_Label_LOOP_2][N
S S T   N
_Create_Label_DROP][S N
N
_Discard_top][S N
N
_Discard_top][N
S N
N
_Jump_to_Label_LOOP_1]

Se agregaron letras S(espacio), T(tabulación) y N(nueva línea) solo como resaltado.
[..._some_action]agregado solo como explicación.

Toma la lista de entrada nueva línea separada con -1para indicar que hemos terminado con las entradas.

Pruébalo en línea .

Explicación en pseudocódigo:

Start LOOP_1:
  Integer i = STDIN as integer
  If(i is negative):
    Call function EXIT
  If(i is 0):
    Call function DROP
  Go to next iteration of LOOP_1

function EXIT:
  Start LOOP_2:
    Pop and print top as integer
    Print newline
    Go to next iteration of LOOP_2

function DROP:
  Drop the top of the stack
  Go to next iteration of LOOP_1

Python 2 , 60 59 57 56 bytes

l=input()
while 0in l:i=l.index(0);l[i-1:i+1]=[]
print l

Pruébalo en línea!

Salvado:

• -1 byte, gracias a pushkin

JavaScript, 40 bytes

Salidas en orden inverso.

a=>a.map(x=>x?o.push(x):o.pop(),o=[])&&o

Pruébalo en línea

1 byte salvó gracias a Herman L .

05AB1E , 9 bytes

vy>i¨ëy)˜

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

v        # For-each of the items in the input-list:
 y>i     #  If the current item is 0:
  ¨      #   Pop the top item of the list
 ë       #  Else:
  y      #   Push the current item to the stack
   )     #   Wrap the entire stack into a list
         #    i.e. 12 → [12]
         #    i.e. [12] and 3 → [[12], 3]
    ˜    #   Flatten the stack
         #    i.e. [[12], 3] → [12, 3]
         # (and output the list implicitly after the loop)

Alternativa de 9 bytes :

vy_i\ëy])

Pruébelo en línea de verificar todos los casos de prueba .

Explicación:

v        # For-each of the items in the input-list:
 y_i     #  If the current item is 0:
  \      #   Discard top item of the stack
 ë       #  Else:
  y      #   Push the current item to the stack
]        # Close both the if-else and for-each (short for `}}`)
 )       # Wrap the entire stack into a list (and output implicitly)

PD: Si la salida debería haberse invertido para que coincida con los casos de prueba en la descripción del desafío, podemos agregar un seguimiento Ra la segunda versión (por lo tanto, 10 bytes ), que invierte la lista. Pruébelo en línea o verifique todos los casos de prueba .

Retina 0.8.2 , 18 bytes

^
,
+1`,\d+,0

^,

Pruébalo en línea! El enlace incluye casos de prueba. Explicación:

^
,

Prefijar un extra ,.

+1`,\d+,0

Procesar todas las operaciones pop.

^,

Retire el ,si todavía está allí.

Invertir los números costaría 8 bytes adicionales:

O^$`\d+

Ruby , 36 bytes

->a{b=[];a.map{|x|x>0?b<<x:b.pop};b}

Pruébalo en línea!

Lambda anónima. Salidas en orden inverso.

Brain-Flak , 36 bytes

([]){{}{(({}<>))(<>)}{}<>{}<>([])}<>

Pruébalo en línea!

#Let's call the two stacks in and out

([]){{}                      ([])}    # while not in.empty()
       {        (  )}{}               # if in.peek() != 0
        (({}<>)) <>                   # a = in.pop; out.push(a); out.push(a)
                       <>{}<>         # out.pop()
                                  <>  # switch to out to be printed

Brain-Flak , 32 bytes

([]){{}{({}<>)<>}{}<>{}<>([])}<>

Pruébalo en línea!

Se utiliza -1para significar el final de la matriz (pero cualquier número lo hará realmente).

V , 10 bytes

ò/ 0⏎b2dw0

Pruébalo en línea!

Explicación

ò           " run the following, until an error occurs
 / 0⏎       " | goto next zero with space in front (errors if none)
     b      " | jump one word back (to the beginning of element to pop)
      2     " | twice (element & zero itself)
       dw   " | | delete word
         0  " | goto beginning of line

Equivalente en Vim , 16 bytes.

qq/ 0⏎b2dw0@qq@q

Pruébalo en línea!

Explicación

Más o menos lo mismo, excepto grabar una macro qy llamarla recursivamente:

qq                " record macro q
  / 0⏎b2dw0       " same as in V
           @q     " recursively call q (aborts on error)
             q    " quit recording
              @q  " execute the macro q

Java 10, 75 72 bytes

n->{var s="";for(int i:n)s=(s+","+i).replaceAll(",\\d+,0","");return s;}

Salidas separadas por una coma. La parte superior de la pila es la última. Pruébelo en línea aquí .

Gracias a Olivier Grégoire por jugar al golf 2 bytes.

Consulte también las respuestas Java de Kevin Cruijssen y Olivier Grégoire . En su lugar, adoptan un enfoque basado en listas, y este último supera al mío por un margen ordenado.

Sin golf:

n -> { // lambda taking an integer array as argument and returning a String
    var s = ""; // we'll be using a String to implement and output the stack
    for(int i : n) // loop through the array
        s = (s + "," + i) // append the next number
               .replaceAll(",\\d+,0", ""); // remove any number followed by a zero
    return s; // output the resulting stack
}

GolfScript , 14 12 bytes

~{.{;}if}/]`

Pruébalo en línea!

~{.{;}if}/]` Full program, implicit input
~            Eval input
 {      }/   Foreach:
      if       If the value is truthy (!= 0):
  .              Push itself
   {;}         Else: pop the top value
          ]` Push as array representation
             Implicit output

Perl 5 -p , 17 bytes

Gracias @sundar y @DomHastings

s/\d+ 0 ?//&&redo

Pruébalo en línea!

> <> , 25 bytes

i:?\~~
(0:/:^?
!?l:!<oan;

Pruébalo en línea! (la entrada debe estar escrita en ascii. de lo contrario, use esta )

Cómo funciona

i:?\~~comprueba 0, continúa ~~eliminando la entrada anterior. de lo contrario, vaya a:

(0:/:^? que comprueba -1 (no más entradas), luego termina para eliminar -1 y repite:

!?l:!<oan; que genera cada número con una nueva línea, luego termina cuando la pila se vacía

Casco , 6 bytes

Ya que no hay respuesta de Husk y es mi golf-lang favorito:

F`?:tø

Pruébalo en línea!

Explicación

F`?:tø  --
F    ø  -- foldl (reduce) with [] as the initial accumulator
 `      -- | flip arguments of
  ?:    -- | | if truthy: apply cons (prepend) to it
    t   -- | | else: return tail
        -- | : returns a function, either prepending the element or dropping 1 element

Solución alternativa, 6 bytes.

En lugar de voltear, también podemos revertir la lista y luego usar un doblez derecho: Ḟ?:tø↔

brainfuck , 214 150 bytes

>>,[>++++++[-<-------->]+<[>+++++[-<++++++++>]]>[-<<<[[-]<],[-]>>>>-<<]>>+[<<+<,----------[++++++++++>-]>[->>-<]>[->+<]>]<<<,]<<[[<]++++++++++<]>>[.>]

Lee la entrada como números separados por nuevas líneas. Esto debe incluir una nueva línea final. También no espera ceros a la izquierda en cada número. Salida como una lista separada de nueva línea similar

Pruébalo en línea!

Explicación ^{que no es realmente una explicación, pero en realidad es solo la versión en la que estaba trabajando con los comentarios y cosas que pueden o no ser útiles para cualquiera}

Stack format:
0 (0 \d*)*


>>,[
    Setup digit == '0' conditional
    >++++++
    [-<-------->]
    +
    <[
        Read digit != '0'
        Restore the char code
        cond1 is already 1 at this stage
        >+++++
        [-<++++++++>]
    ]>[
        Read digit == '0'
        -
        Pop previous value
        <<<[
            [-]<
        ]
        Skip next input (assumed to be newline)
        ,[-]
        Skip following loop by unsetting loop flag
        >>>>-
        <<
    ]

    Move to next stack frame
    >
    Set loop flag
    >+[
        Set bit used for conditional
        <<+
        Read next character
        <,
        Compare with '\n'
        ----------[
            Not '\n': restore the char code
            ++++++++++

            >-
        ]>[
            -
            == '\n': Leave as 0
            Unset loop flag
            >>-
            <
        ]

        Copy loop flag along
        >
        [- > + <]

        Move to loop flag of next stack frame
        >
    ]

    <<<
,]


Fill in with newlines
<<[
    Skip to the cell before this value
    [<]
    Put a newline in there
    ++++++++++
    Move to next value
    <
]

Now the tape has the exact values we need to output
>>[.>]

Brachylog , 21 bytes

~c₃Ckt[İ,0]≠∧C⟨hct⟩↰|

Pruébalo en línea!

-1 byte, y lo más importante, esto se siente como una forma mucho menos torpe de hacer esto.

~c₃                     % Partition the input into 3 subarrays
   C                    % Call that array-of-arrays C
    kt[İ,0]             % Its second element should be of the form [Integer, 0]
           ≠            % And its elements shouldn't be equal (i.e. 
                        %   the Integer shouldn't be 0)
            ∧C⟨hct⟩     % Then, remove that [İ, 0] element from C
                   ↰    % And call this predicate recursively
                    |   % When the above fails (when it can't find a partition with 
                        %  [İ, 0] in it), then just output the input

Alterno 21 byter: ¡ ∋0∧ℕ₁;0;P↺c;Qc?∧P,Q↰| Pruébelo en línea!

Código anterior:

22 bytes

∋0&b,1;?z{=|¬∋0&}ˢtᵐ↰|

Pruébalo en línea!

∋0           If input contains a 0, 
&b           Remove input's first element, getting list of "next" elements
,1           Append 1 to that to handle last element
;?z          Zip that with input
{      }ˢ    Select only zipped pairs where
 =|          both elements are equal (to keep 0s followed by 0s)
   ¬∋0&      or the pair doesn't contain a 0
             this removes both the (pairs containing the) value
              that is followed by a 0, and the 0 itself
tᵐ           Recover back the (filtered) input array elements from the zip
↰            Call this predicate recursively 
|            If input contains no 0s, input is the output 

Advertencia: muchas líneas siguen. Usted ha sido advertido.

CJam , 17 bytes

Código más peligroso
(Asume que los elementos de la pila pueden estar separados solo por espacios en la salida y que la matriz de entrada puede tener la forma que deseemos)

q~{X0={;}X?}fX]S*

Pruébalo en línea!

Explicación

q                                    Reads input string
 ~                                   Instantly convert to array since the string is in the CJam format
  {        }fX                       For loop
   X0=                               If X (the array element currently being checked) is equal to 0
      {;}                            Pop the top element from the stack
         X                           Else push X onto the top of the stack
          ?                          If-Else flag
              ]                      Collate all stack elements into an array
               S*                    Put a space between each array element

Código alternativo n. ° 1, 27 bytes
(se supone que los elementos de la pila deben enviarse en el formato que se muestra en la pregunta y que la matriz de entrada puede tener la forma que deseemos)

q~{X0={;}X?}fX]',S+*'[\+']+

Pruébalo en línea!

Explicación

q                                    Reads input string
 ~                                   Instantly convert to array since the string is in the CJam format
  {        }fX                       For loop
   X0=                               If X (the array element currently being checked) is equal to 0
      {;}                            Pop the top element from the stack
         X                           Else push X onto the top of the stack
          ?                          If-Else flag
              ]                      Collate stack items into an array
               ',S+                  Add together a comma and a space to create a delimiter
                   *                 Apply the delimiter to the stack
                    '[\+             Append left bracket to the left of the stack text
                        ']+          Append right bracket to the right of the stack text

Código alternativo n. ° 2, 24 bytes
(se supone que los elementos de la pila se pueden clasificar en la salida y que la matriz de entrada debe estar en el formato exacto que se muestra en la pregunta)

q',/~]S*~{X0={;}X?}fX]S*

Pruébalo en línea!

Explicación

q                        Read input string
 ',/                     Separate by commas (since commas are an invalid array delimiter in CJam)
    ~                    Turn string into an array of substrings that make up the array
     ]S*                 Add spaces in between input numbers to prevent collation in the array
        ~                Turn the string into a valid array representative of the original
         {        }fX    For loop
          X0=            If X (the array element currently being checked) is equal to 0
             {;}         Pop the top element from the stack
                X        Else push X onto the top of the stack
                 ?       If-Else flag
                     ]   Collate all stack elements into an array
                      S* Add a space between each element

El código más seguro para esto es de 34 bytes
(se supone que los elementos de la pila deben enviarse en el formato que se muestra en la pregunta y que la matriz de entrada debe estar en el formato exacto que se muestra en la pregunta)

q',/~]S*~{X0={;}X?}fX]',S+*'[\+']+

Pruébalo en línea!

Explicación

q                                      Read input string
 ',/                                   Separate by commas (since commas are an invalid array delimiter in CJam)
    ~                                  Turn string into an array of substrings that make up the array
     ]S*                               Add spaces in between input numbers to prevent collation in the array
        ~                              Turn the string into a valid array representative of the original
         {        }fX                  For loop
          X0=                          If X (the array element currently being checked) is equal to 0
             {;}                       Pop the top element from the stack
                X                      Else push X onto the top of the stack
                 ?                     If-Else flag
                     ]                 Collate stack items into an array
                      ',S+             Add together a comma and a space to create a delimiter
                          *            Apply the delimiter to the stack
                           '[\+        Append left bracket to the left of the stack text
                               ']+     Append right bracket to the right of the stack text

Gracias a @Jo King por señalar que los que tienen la salida clasificada no son válidos, ya que cosas como [12]y [1,2]serían indistinguibles.

¡Gracias también a @Jo King por proporcionar una alternativa muy adecuada para las salidas clasificadas y cortar 9 bytes!

Rojo , 64 bytes

func[b][a: copy[]foreach n b[either n > 0[insert a n][take a]]a]

Pruébalo en línea!