Implementando una pila

44

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 :

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 pop ()npush(n)0pop()

  • La salida será la pila resultante

Ejemplo

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

12[12]3[3,12]0[12]101[101,12]11[11,101,12]1[1,11,101,12]0[11,101,12]0[101,12]14[14,101,12]0[101,12]28[28,101,12]

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ía0

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]
ბიმო
fuente
12
Cabe señalar que, dadas las condiciones, en realidad no es necesario implementar la pila.
Jeff Zeitlin
Si desea que alguien implemente una pila, es posible que deba intentar poner algo en el Sandbox.
mbomb007
@ mbomb007: Cualquiera de los dos está permitido: "usted
ბიმო
@ mbomb007: No sería más difícil si tuvieras que invertir la entrada, ¿verdad? Además, si considera la configuración como una pila que define cuál es la parte superior y la parte inferior y por qué una definición debería ser menos arbitraria?
ბიმო
@ OMᗺ Porque la entrada se parece bastante a una pila / lista / matriz. Ahora, todo el desafío es básicamente eliminar cualquier número seguido de un cero.
mbomb007

Respuestas:

19

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)
Luis Mendo
fuente
13

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

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!

Olivier Grégoire
fuente
44
Esto es bastante impresionante. Puede perder 1 byte utilizando, >0ya que nunca habrá un cero al comienzo de la lista (lo que implicaría que la parte superior de la pila estaba en -1).
OOBalance
@OOBalance De hecho, no había pensado en eso. ¡Gracias!
Olivier Grégoire
12

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.

Tacroy
fuente
1
Bienvenido a PPCG! Niza, la mía fue más larga (usando un formato de entrada diferente). Por cierto. puede usar una etiqueta vacía, ya que solo usa 1 y ya que itera el proceso, ges redundante, lo que le ahorra 4 bytes: ¡ Pruébelo en línea!
ბიმო
¡La g no es redundante! ¡Hace que la complejidad del tiempo de ejecución del peor de los casos dependa de la profundidad de los pops secuenciales, en lugar del número de pops! No es que la eficiencia importe en el código de golf :)
Tacroy
1
Su última oración responde a la pregunta sobre redundancia: P Btw. ¿Cómo contabas los bytes? Tengo 18 años, probablemente incluiste una nueva línea al final o algo así.
ბიმო
Sí, era una nueva línea.
Tacroy
1
Si el elemento final de la entrada es un 0, entonces su expresión regular no coincidirá.
eggyal
12

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

AdmBorkBork
fuente
¿Un splatting ahorra 3 bytes $agrs? :)
mazzy
-2 bytes $args|%{$x,$a=&({$_,$_+$a},{$a})[!$_]};$a?
mazzy
1
@mazzy Sí, ¡y acabamos de hablar sobre salpicaduras! Ya lo olvidé! jajaja Gracias!
AdmBorkBork
No sería splatting .\implement-stack.ps1 @z(no $z), si no estás de paso una matriz como la primera único argumento /
pinkfloydx33
@ pinkfloydx33 Sí. Error tipográfico de mi parte.
AdmBorkBork
11

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!

gastropner
fuente
f(l)int*l;=> f(int*l)?
l4m2
@ l4m2 Ah, ¡salud! Probablemente un remanente de días anteriores, más cargados de variables.
Gastropner
el r=0parece inútil
l4m2
@ l4m2 Sí, buena captura.
Gastropner
10

Haskell, 28 bytes

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

Pruébalo en línea!

nimi
fuente
¿Cómo se nombra la función principal? No sé cómo ejecutarlo)
Евгений Новиков
@ ЕвгенийНовиков: vea el enlace "pruébelo en línea" para ver un ejemplo de cómo ejecutar el código.
nimi
10

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
digEmAll
fuente
1
48 bytes : el abuso Ftambién lo llevará a 48 bytes, pero esto es más limpio
Giuseppe
No sé cómo me perdí la inversión if-else: facepalm: ... ¡gracias!
digEmAll
45 bytes
Giuseppe
1
A R+pryry la Reducesolución es de 44 bytes
JayCe
@ JayCe: para ser honesto, prefiero mantenerlo como una solución "base-R" ... ¡pero siéntase libre de publicarlo como su propia respuesta! ;)
digEmAll
9

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.
Dennis
fuente
¿Esto emulará tres estallidos si hay tres ceros consecutivos?
WGroleau
Si. [1,3,7,0,0,0], por ejemplo, se divide en [[1,3,7],[],[],[]], y cada paso de la reducción izquierda aparece en el elemento de la matriz izquierda.
Dennis
9

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
dorio
fuente
2
En este caso particular, {{}<>{}<>}se puede acortar a {{}<>}.
Nitrodon
@Nitrodon Gracias. ¿Puedes explicar por qué esto todavía funciona? No vuelve a la pila de entrada en el bucle.
Dorian
1
Se garantiza que la parte superior de la pila de salida sea distinta de cero, por lo que el ciclo acortado se ejecuta 0 o 2 veces.
Nitrodon
8

Wolfram Language (Mathematica) , 28 bytes

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

Pruébalo en línea!

JungHwan Min
fuente
(esto sólo funciona porque "El valor por defecto es tener patrones anteriores coinciden con secuencias más cortas" , lo que no hay necesidad de asegurar que bes distinto de cero.)
user202729
@ user202729 Sí. La coincidencia de patrones de Mathematica no es codiciosa, por lo que a___primero intenta hacer coincidir el más corto posible . Uno puede ver eso al intentarlo ReplaceList[#, {a___, b_, 0, c___} :> {a, c}] &. En una nota relacionada, en StringReplacerealidad es codicioso, por lo que esta presentación no funcionaría StringReplace(con un patrón similar a___~~b_~~"0"~~c___)
JungHwan Min
8

Python 2 , 48 bytes

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

Pruébalo en línea!

xnor
fuente
¿Alguna posibilidad de que puedas explicar cómo funciona esto? ¡He estado tratando de resolverlo durante la última media hora! Seguramente 2*0**xsiempre lo será 0. Obviamente me estoy perdiendo algo.
ElPedro
1
@ElPedro No es cero cuando x=0, en cuyo caso son 2.
xnor
Ah, ya veo lo que quieres decir. ¡Supongo que estaba buscando demasiado y me faltaba lo obvio! Gracias y gran respuesta.
ElPedro
7

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
Kevin Cruijssen
fuente
7

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
TFeld
fuente
Puede guardar un byte eliminando el espacio entre 0yin
pushkin
2
Felicidades por el 10K
ElPedro
6

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 .

Lanudo
fuente
a=>a.map(x=>x?o.push(x):o.pop(),o=[])&&oes un byte más corto
Herman L
@HermanL: D'oh! ¡Por supuesto que es! Gracias. Estaba usando (un)shiftantes de detectar que la salida podría revertirse.
Shaggy
Esto funciona porque ose hace referencia en la devolución de llamada después de que se define en el segundo argumento.
MattH
6

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 .

Kevin Cruijssen
fuente
5

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+
Neil
fuente
Que simplemente reemplaza toda <number>, 0sublista por nada.
user202729
5

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
Riley
fuente
5

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).

Jo King
fuente
5

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
ბიმო
fuente
5

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
}
OOBalance
fuente
Buen enfoque con cuerdas. Mejor que mi enfoque ingenuo con un objeto real Stack. +1 de mi parte
Kevin Cruijssen
1
n->{var s="";for(int i:n)s=(s+","+i).replaceAll(",\\d+,0$","");return s;}(73 bytes), pero pone los ,números antes, no después.
Olivier Grégoire
1
n->{var s=""+n;for(int x:n)s=s.replaceFirst("\\d+, 0,? ?","");return s;}(72 bytes), usa una lista en lugar de una matriz y se mete con la salida porque puede devolver cosas como "[, 2]"
Olivier Grégoire
@ OlivierGrégoire Nice. Podemos soltar el $para guardar un byte adicional, ya que cada uno 0que agregamos se elimina de inmediato.
OOBalance
@ OlivierGrégoire Su segundo enfoque también es interesante, pero creo que el formato de salida inconsistente puede invalidar la solución.
OOBalance
5

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
wastl
fuente
5

Perl 5 -p , 17 bytes

Gracias @sundar y @DomHastings

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

Pruébalo en línea!

Xcali
fuente
1
-2 bytes (con salida ligeramente más maníaca): ¡ Pruébelo en línea!
sundar - Restablece a Mónica el
Además del comentario de @ sundar, otra pequeña simplificación: ¡ Pruébelo en línea!
Dom Hastings
¿No falla eso si hay un número como la entrada 0942?
Xcali
1
Puede asumir con seguridad que no habrá ceros a la izquierda.
OOBalance
5

> <> , 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

torcado
fuente
22 bytes
Jo King
5

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ø↔

ბიმო
fuente
5

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
>>[.>]
Sasha
fuente
5

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 
sundar - Restablece a Monica
fuente
5

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!

Helen
fuente
1
El primero no es válido ya que no se puede distinguir entre [12]y[1,2] . Sin embargo, la versión de 27 bytes parece estar bien, aunque puede deshacerse del espacio en blanco y los corchetes para 18 bytes
Jo King
oh, por supuesto que soy tan tonto muchas gracias
Helen
Sin embargo, probablemente sería más complejo separar los números por espacios en lugar de comas, ya que los espacios usan ]S*(3) mientras que las comas usan ]',*(4)
Helen