Je ne peux pas croire que nous ne l'ayons pas déjà. C'est l'une des structures de données les plus importantes en programmation, et pourtant assez simple pour l'implémenter dans un code-golf :

Défi

Votre tâche consiste à implémenter une pile permettant de pousser et d'afficher des nombres, de tester votre implémentation et de maintenir les E / S simples. Nous utiliserons la configuration suivante:

• L'entrée sera une liste d'entiers non négatifs

Chaque nombre entier positif indique un \ texttt {push (} n \ texttt {)} et chaque 0 indique un \ texttt {pop ()} - rejet de l'élément supérieur.push ( n ) 0 $n$$\texttt{push(}n\texttt{)}$$0$$\texttt{pop()}$

• La sortie sera la pile résultante

Exemple

Par exemple, si on nous donne $[12,3,0,101,11,1,0,0,14,0,28]$ :

La sortie sera: $[28,101,12]$

Règles

• L'entrée sera une liste d'entiers non négatifs dans n'importe quel format d'E / S par défaut
  • vous pouvez utiliser un entier négatif pour indiquer la fin d'un flux d'entiers
• Le résultat sera une liste / matrice / .. de la pile résultante
  • votre choix où l'élément du haut sera (au début ou à la fin), la sortie doit juste être cohérente
  • la sortie est flexible (par exemple, des entiers séparés par des lignes-nouvelles iraient bien), la seule chose qui compte est l’ordre
  • vous pouvez utiliser un entier négatif pour indiquer le bas de la pile
• Vous êtes assuré qu'il n'y aura jamais de lorsque la pile est vide$0$

Exemples

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

"@?@}x

L'entrée est un vecteur ligne de nombres.

La pile finale est affichée à l’envers, l’élément le plus récent se trouvant en dessous.

Essayez-le en ligne! Ou vérifiez tous les cas de test .

Explication

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

Etant donné que "[la] sortie est flexible [...], la seule chose qui compte, c'est l'ordre", le tableau d'entrée devient un 0tableau terminé. Exemple: [1,0,2]retournera [2,0,2]ce qui doit être interprété comme = .[2,0,2][2]

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

Essayez-le en ligne!

Versions précédentes:

Java (JDK 10) , 60 octets

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

Essayez-le en ligne!

Crédits:

• -1 octet grâce à OOBalance

Si je peux terminer le programme avec des erreurs: 55 octets

(bien que tout soit correctement modifié)

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

Essayez-le en ligne!

Sed, 17 octets

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

-3 octets grâce à @ OMᗺ, -1 grâce à @eggyal

Parce que vous êtes assuré de ne jamais faire apparaître une liste vide, vous n'avez besoin de rien de plus qu'une machine à états finis itérée. Les expressions régulières sont un outil de construction de machines à états finis et sedpeuvent effectuer des itérations. C'est un match fait au paradis.

Prend les entrées de stdin, comme ceci:

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

Sort la pile en sens inverse:

[12,101,28]

Pourrait être plus petit de deux octets si mon local sedcomprenait de manière inhérente les classes de caractères \d, mais pas pour une raison quelconque.

PowerShell , 46 41 40 octets

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

Essayez-le en ligne!

Prend une entrée via splatting, par exemple, $z=@(12,3,0,101,11,1,0,0,14,0,28); .\implement-stack.ps1 @zqui sur TIO se manifeste sous forme d'arguments séparés.

$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 octets grâce à mazzy.
-1 octet permuter $_en1

C (gcc) , 62 60 56 55 octets

-2 -6 octets grâce à l4m2

-1 octet grâce à ceilingcat .

Utilise la notion autorisée de -1 tableaux terminés. f()s’appelle récursivement jusqu’à ce qu’elle soit complètement enroulée, puis fait un retour en arrière dans la liste. rgarde la trace du nombre de numéros à supprimer avant d’imprimer quelque chose. Augmente si l'élément actuel est 0, diminue sinon. Si 0, nous n'avons pas besoin de nous en défaire et pouvons imprimer le numéro.

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

Essayez-le en ligne!

Haskell, 28 octets

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

Essayez-le en ligne!

R , 45 octets

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

Essayez-le en ligne!

• -4 octets grâce à @Giuseppe

Python 2 , 59 57 51 octets

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

Essayez-le en ligne!

Gelée , 6 octets

ṣ0Ṗ;¥/

Essayez-le en ligne!

Comment ça marche

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

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

Essayez-le en ligne!

Merci à @Nitrodon pour -4 octets.

Puisque Brain-Flak utilise déjà des piles, ceci est un bon casse-tête pour 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 octets

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

Essayez-le en ligne!

Python 2 , 48 octets

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

Essayez-le en ligne!

Espaces blancs , 89 octets

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

Lettres S(espace), T(tabulation) et N(nouvelle ligne) ajoutées uniquement en surbrillance.
[..._some_action]ajouté comme explication seulement.

Prend la nouvelle ligne de la liste d'entrées séparée avec -1pour indiquer que nous en avons terminé avec les entrées.

Essayez-le en ligne .

Explication en pseudo-code:

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 octets

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

Essayez-le en ligne!

Enregistré:

• -1 octet, grâce au pushkin

JavaScript, 40 octets

Sorties dans l'ordre inverse.

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

Essayez-le en ligne

1 octet enregistré grâce à Herman L .

05AB1E , 9 octets

vy>i¨ëy)˜

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

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)

Alternative de 9 octets :

vy_i\ëy])

Essayez-le en ligne pour vérifier tous les cas de test .

Explication:

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: Si la sortie a dû être inversée pour correspondre aux tests élémentaires dans la description du challenge, nous pouvons ajouter une fin Rà la seconde version (soit 10 octets ), ce qui inversera la liste. Essayez-le en ligne ou vérifiez tous les cas de test .

Retina 0.8.2 , 18 octets

^
,
+1`,\d+,0

^,

Essayez-le en ligne! Le lien inclut des cas de test. Explication:

^
,

Préfixe un extra ,.

+1`,\d+,0

Traiter toutes les opérations pop.

^,

Retirer le , si c'est toujours là.

Inverser les nombres coûterait 8 octets supplémentaires:

O^$`\d+

Ruby , 36 octets

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

Essayez-le en ligne!

Lambda anonyme. Sorties dans l'ordre inverse.

Brain-Flak , 36 octets

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

Essayez-le en ligne!

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

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

Essayez-le en ligne!

Utilisé -1pour signifier la fin du tableau (mais n'importe quel nombre le fera vraiment).

V , 10 octets

ò/ 0⏎b2dw0

Essayez-le en ligne!

Explication

ò           " 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

Équivalent en Vim , 16 octets

qq/ 0⏎b2dw0@qq@q

Essayez-le en ligne!

Explication

À peu près la même chose, sauf enregistrer une macro qet l'appeler de manière récursive:

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 octets

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

Les sorties sont séparées par une virgule. Le sommet de la pile est le dernier. Essayez-le en ligne ici .

Merci à Olivier Grégoire pour avoir joué au golf 2 octets.

S'il vous plaît vérifier Kevin Cruijssen et les réponses à Java de Olivier Grégoire . Ils adoptent plutôt une approche basée sur des listes, cette dernière battant la mienne par une marge nette.

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 octets

~{.{;}if}/]`

Essayez-le en ligne!

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

Merci @sundar et @DomHastings

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

Essayez-le en ligne!

> <> , 25 octets

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

Essayez-le en ligne! (les entrées doivent être écrites en ascii. sinon utilisez celui-ci )

Comment ça marche

i:?\~~vérifie pour 0, continue ~~à supprimer l'entrée précédente. sinon descendre à:

(0:/:^? qui vérifie -1 (plus d’entrée), puis se termine pour supprimer -1 et boucle:

!?l:!<oan; qui sort chaque numéro avec une nouvelle ligne, puis se termine lorsque la pile est vidée

Décortiquer , 6 octets

Comme il n'y a pas encore de réponse Husk et que c'est mon golfing-lang préféré:

F`?:tø

Essayez-le en ligne!

Explication

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

Solution alternative, 6 octets

Au lieu de retourner, nous pouvons aussi simplement inverser la liste, puis utiliser un pli à droite: Ḟ?:tø↔

brainfuck , 214 150 octets

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

Lit les entrées sous forme de nombres séparés par des nouvelles lignes. Cela doit inclure une seule nouvelle ligne. N'attend également aucun zéros à gauche sur chaque nombre. Sortie sous forme de liste similaire séparée par une nouvelle ligne

Essayez-le en ligne!

Explication ^{qui n'est pas vraiment une explication mais qui est en fait juste la version sur laquelle je travaillais, avec des commentaires et des choses qui pourraient ne pas être utiles à quiconque}

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 octets

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

Essayez-le en ligne!

-1 octet, et plus important encore, cela semble être une façon beaucoup moins maladroite de le faire.

~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↰| Essayez-le en ligne!

Ancien code:

22 octets

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

Essayez-le en ligne!

∋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 

Avertissement: beaucoup de lignes s'ensuivent. Tu étais prévenu.

CJam , 17 octets

Code le plus dangereux
(en supposant que les éléments de la pile ne peuvent être séparés que par des espaces dans la sortie et que le tableau en entrée peut être de la forme de notre choix)

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

Essayez-le en ligne!

Explication

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

Code alternatif n ° 1, 27 octets
(en supposant que les éléments de pile doivent être générés dans le format indiqué dans la question et que le tableau en entrée peut être de la forme que nous souhaitons)

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

Essayez-le en ligne!

Explication

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

Code alternatif n ° 2, 24 octets
(en supposant que les éléments de la pile puissent être assemblés dans la sortie et que le tableau en entrée doit être au format exact indiqué dans la question)

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

Essayez-le en ligne!

Explication

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

Le code le plus sûr pour cela, 34 octets
(en supposant que les éléments de pile doivent être sortis dans le format indiqué dans la question et que le tableau en entrée doit être dans le format exact indiqué dans la question)

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

Essayez-le en ligne!

Explication

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

Merci à @Jo King d’ avoir fait remarquer que ceux avec la sortie assemblée ne sont pas valides car des choses comme [12]et [1,2]seraient impossibles à distinguer.

Merci également à @Jo King, qui offre une alternative très appropriée pour les sorties assemblées et coupe 9 octets!

Rouge , 64 octets

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

Essayez-le en ligne!