Non riesco a credere che non lo abbiamo già .. È una delle strutture dati più importanti nella programmazione, ma ancora abbastanza semplice da implementarlo in un code-golf :

Sfida

Il tuo compito è quello di implementare uno stack che consenta di eseguire il push e il pop-up dei numeri, per testare l'implementazione e semplificare l'I / O, utilizzeremo la seguente configurazione:

• L'input sarà un elenco di numeri interi non negativi

Ogni numero intero positivo indica un e ogni 0 indica un \ texttt {pop ()} - scartando l'elemento superiore.$n$$\texttt{push(}n\texttt{)}$$0$$\texttt{pop()}$

• L'output sarà lo stack risultante

Esempio

Ad esempio se ci viene dato $[12,3,0,101,11,1,0,0,14,0,28]$ :

L'output sarà: $[28,101,12]$

Regole

• L'input sarà un elenco di numeri interi non negativi in ​​qualsiasi formato I / O predefinito
  • puoi usare un numero intero negativo per indicare la fine di un flusso di numeri interi
• L'output sarà un elenco / matrice / .. dello stack risultante
  • la tua scelta in cui sarà l'elemento superiore (all'inizio o alla fine), l'output deve essere coerente
  • l'output è flessibile (es. numeri interi separati da nuove righe andrebbero bene), l'unica cosa che conta è l'ordine
  • puoi usare un numero intero negativo per indicare il fondo dello stack
• Hai la garanzia che non ci sarà mai uno quando lo stack è vuoto$0$

Esempi

[] -> []
[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 byte

"@?@}x

L'input è un vettore di riga di numeri.

Lo stack finale è mostrato sottosopra, con l'elemento più recente di seguito.

Provalo online! Oppure verifica tutti i casi di test .

Spiegazione

"         % 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 byte

Poiché "[l'output] è flessibile [...], l'unica cosa che conta è l'ordine", questo cambia l'array di input in un 0array terminato. Esempio: [1,0,2]restituirà ciò [2,0,2]che deve essere interpretato come = .[2,0,2][2]

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

Provalo online!

Versione precedente:

Java (JDK 10) , 60 byte

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

Provalo online!

Crediti:

• -1 byte grazie a OOBalance

Se riesco a terminare il programma con errori: 55 byte

(sebbene tutto sia correttamente modificato)

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

Provalo online!

Sed, 17 byte

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

-3 byte grazie a @ OMᗺ, -1 grazie a @eggyal

Poiché non si ottiene mai un elenco vuoto, non è necessario altro che una macchina a stati finiti iterata. Le espressioni regolari sono uno strumento per la costruzione di macchine a stati finiti e sedpossono iterare. È una partita fatta in paradiso.

Prende input da stdin, in questo modo:

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

Emette lo stack al contrario:

[12,101,28]

Potrebbe essere più piccolo di due byte se le mie sedclassi di caratteri intrinsecamente locali mi piacciono \d, ma non per qualche motivo.

PowerShell , 46 41 40 byte

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

Provalo online!

Accetta input tramite splatting, ad esempio $z=@(12,3,0,101,11,1,0,0,14,0,28); .\implement-stack.ps1 @z, che su TIO si manifesta come argomenti separati.

$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 byte grazie a mazzy.
-1 byte scambiando $_a1

C (gcc) , 62 60 56 55 byte

-2 -6 byte grazie a l4m2

-1 byte grazie a ceilingcat .

Utilizza la nozione consentita di -1 array terminati. f()si chiama ricorsivamente, fino a quando non è completamente avvolto, quindi torna indietro nell'elenco. rtiene traccia di quanti numeri scartare prima di stampare qualcosa. Aumenta se l'elemento corrente è 0, altrimenti diminuisce. Se 0, non è necessario eliminarlo e possiamo stampare il numero.

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

Provalo online!

Haskell, 28 byte

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

Provalo online!

R , 45 byte

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

Provalo online!

• -4 byte grazie a @Giuseppe

Python 2 , 59 57 51 byte

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

Provalo online!

Gelatina , 6 byte

ṣ0Ṗ;¥/

Provalo online!

Come funziona

ṣ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 byte

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

Provalo online!

Grazie a @Nitrodon per -4 byte.

Dal momento che Brain-Flak utilizza già pile, questo è un buon puzzle per 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 byte

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

Provalo online!

Python 2 , 48 byte

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

Provalo online!

Spazio bianco , 89 byte

[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]

Lettere S(spazio), T(scheda) e N(nuova riga) aggiunti solo come evidenziazione.
[..._some_action]aggiunto solo come spiegazione.

Prende l'elenco di input new-line separato da -1per indicare che abbiamo finito con gli input.

Provalo online .

Spiegazione in pseudo-codice:

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 byte

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

Provalo online!

Salvato:

• -1 byte, grazie a pushkin

JavaScript, 40 byte

Uscite in ordine inverso.

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

Provalo online

1 byte salvato grazie a Herman L .

05AB1E , 9 byte

vy>i¨ëy)˜

Provalo online o verifica tutti i casi di test .

Spiegazione:

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 a 9 byte :

vy_i\ëy])

Provalo online per verificare tutti i casi di test .

Spiegazione:

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)

PS: Se l'output avrebbe dovuto essere invertito per corrispondere ai casi di test nella descrizione della sfida, possiamo aggiungere un finale Ralla seconda versione (quindi 10 byte ), che inverte l'elenco. Provalo online o verifica tutti i casi di test .

Retina 0.8.2 , 18 byte

^
,
+1`,\d+,0

^,

Provalo online! Il link include casi di test. Spiegazione:

^
,

Prefisso un extra ,.

+1`,\d+,0

Elabora tutte le operazioni pop.

^,

Rimuovi ,se è ancora lì.

Invertire i numeri costerebbe altri 8 byte:

O^$`\d+

Rubino , 36 byte

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

Provalo online!

Lambda anonimo. Uscite in ordine inverso.

Brain-Flak , 36 byte

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

Provalo online!

#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 byte

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

Provalo online!

Usa -1per indicare la fine dell'array (ma qualsiasi numero lo farà davvero).

V , 10 byte

ò/ 0⏎b2dw0

Provalo online!

Spiegazione

ò           " 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 in Vim , 16 byte

qq/ 0⏎b2dw0@qq@q

Provalo online!

Spiegazione

Più o meno la stessa cosa, tranne registrare una macro qe chiamarla ricorsivamente:

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 byte

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

Output separati da una virgola. La parte superiore della pila è l'ultima. Provalo online qui .

Grazie a Olivier Grégoire per il golf 2 byte.

Si prega di verificare di Kevin Cruijssen e di Olivier Grégoire risposte Java pure. Adottano invece un approccio basato sull'elenco, con quest'ultimo che batte il mio con un margine ordinato.

Ungolfed:

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 byte

~{.{;}if}/]`

Provalo online!

~{.{;}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 byte

Grazie @sundar e @DomHastings

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

Provalo online!

> <> , 25 byte

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

Provalo online! (l'input deve essere scritto in ascii. altrimenti usa questo )

Come funziona

i:?\~~controlla 0, continua ~~a cancellare la voce precedente. altrimenti vai a:

(0:/:^? che controlla per -1 (non più input), quindi si chiude per eliminare -1 e loop:

!?l:!<oan; che genera ogni numero con una nuova riga, quindi termina quando lo stack viene svuotato

Buccia , 6 byte

Dal momento che non esiste già una risposta Husk ed è la mia lingua da golf preferita:

F`?:tø

Provalo online!

Spiegazione

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

Soluzione alternativa, 6 byte

Invece di capovolgere, possiamo anche semplicemente invertire l'elenco e quindi utilizzare una piega a destra: Ḟ?:tø↔

Brainfuck , 214 150 byte

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

Legge l'input come numeri separati da newline. Ciò deve includere una nuova riga finale finale. Inoltre, non prevede zeri iniziali su ciascun numero. Output come un elenco separato da newline simile

Provalo online!

Spiegazione ^{che non è in realtà una spiegazione, ma in realtà è solo la versione su cui stavo lavorando con i commenti e cose che potrebbero essere o non essere effettivamente utili a nessuno}

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 byte

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

Provalo online!

-1 byte, e soprattutto questo sembra un modo molto meno ingombrante di farlo.

~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

Alternate 21 byter: ∋0∧ℕ₁;0;P↺c;Qc?∧P,Q↰| provalo online!

Codice precedente:

22 byte

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

Provalo online!

∋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 

Avvertenza: ne conseguono molte linee. Sei stato avvertito.

CJam , 17 byte

Codice più pericoloso
(suppone che gli elementi dello stack possano essere separati solo da spazi nell'output e che l'array di input possa essere qualsiasi forma desideriamo)

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

Provalo online!

Spiegazione

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

Codice alternativo n. 1, 27 byte
(presuppone che gli elementi dello stack debbano essere emessi nel formato mostrato nella domanda e che l'array di input possa essere qualsiasi forma desideriamo)

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

Provalo online!

Spiegazione

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

Codice alternativo n. 2, 24 byte
(suppone che gli elementi dello stack possano essere raccolti nell'output e che l'array di input debba essere nel formato esatto mostrato nella domanda)

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

Provalo online!

Spiegazione

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

Codice più sicuro per questo, 34 byte
(presuppone che gli elementi dello stack debbano essere emessi nel formato mostrato nella domanda e che l'array di input debba essere nel formato esatto mostrato nella domanda)

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

Provalo online!

Spiegazione

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

Grazie a @Jo King per aver sottolineato che quelli con l'output fascicolato non sono validi poiché le cose piacciono [12]e [1,2]sarebbero indistinguibili.

Grazie anche a @Jo King che fornisce un'alternativa molto adatta per le uscite fascicolate e tagliando 9 byte!

Rosso , 64 byte

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

Provalo online!