Ich kann nicht glauben, dass wir das noch nicht haben. Es ist eine der wichtigsten Datenstrukturen in der Programmierung und dennoch einfach genug, um es in einem Code-Golf zu implementieren :

Herausforderung

Ihre Aufgabe ist es, einen Stack zu implementieren, der das Pushen und Poppen von Zahlen ermöglicht, Ihre Implementierung zu testen und die E / A einfach zu halten. Wir verwenden das folgende Setup:

• Die Eingabe ist eine Liste nicht negativer Ganzzahlen

Jede positive ganze Zahl gibt ein und jede ein - das oberste Element wird .push ( n ) 0 $n$$\texttt{push(}n\texttt{)}$$0$$\texttt{pop()}$

• Die Ausgabe ist der resultierende Stapel

Beispiel

Zum Beispiel, wenn wir gegeben sind :$[12,3,0,101,11,1,0,0,14,0,28]$

Ausgabe wird sein:$[28,101,12]$

Regeln

• Die Eingabe ist eine Liste nicht negativer Ganzzahlen in jedem Standard-E / A-Format
  • Sie können eine negative Ganzzahl verwenden, um das Ende eines Datenstroms von Ganzzahlen zu kennzeichnen
• Die Ausgabe ist eine Liste / Matrix / .. des resultierenden Stapels
  • Wenn Sie auswählen, wo sich das oberste Element (am Anfang oder am Ende) befindet, muss die Ausgabe nur konsistent sein
  • Die Ausgabe ist flexibel (z. B. ganze Zahlen, die durch Zeilenumbrüche getrennt werden, sind in Ordnung). Wichtig ist nur die Reihenfolge
  • Sie können eine negative Ganzzahl verwenden, um den Boden des Stapels zu kennzeichnen
• Es ist garantiert, dass es niemals eine wenn der Stapel leer ist$0$

Beispiele

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

Die Eingabe ist ein Zeilenvektor von Zahlen.

Der letzte Stapel wird verkehrt herum angezeigt, wobei das aktuellste Element unten angezeigt wird.

Probieren Sie es online! Oder überprüfen Sie alle Testfälle .

Erläuterung

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

Da "[die] Ausgabe flexibel ist [...], kommt es nur auf die Reihenfolge an", wird das Eingabearray in ein abgeschlossenes 0Array umgewandelt. Beispiel: [1,0,2]Gibt zurück, [2,0,2]was als = interpretiert werden soll .[2,0,2][2]

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

Probieren Sie es online!

Vorherige Versionen:

Java (JDK 10) , 60 Byte

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

Probieren Sie es online!

Credits:

• -1 Byte dank OOBalance

Wenn ich das Programm mit Fehlern beenden kann: 55 Bytes

(obwohl alles richtig modifiziert ist)

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

Probieren Sie es online!

Sed, 17 Bytes

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

-3 Bytes dank @ OMᗺ, -1 dank @eggyal

Da Sie garantiert nie eine leere Liste öffnen, benötigen Sie nur eine iterierte Finite-State-Maschine. Reguläre Ausdrücke sind ein Werkzeug zum Erstellen von Zustandsautomaten und sedkönnen iterieren. Es ist ein Match, das im Himmel gemacht wurde.

Übernimmt die Eingabe von stdin wie folgt:

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

Gibt den Stapel in umgekehrter Reihenfolge aus:

[12,101,28]

Könnte um zwei Bytes kleiner sein, wenn meine lokalen, von sedNatur aus verstandenen Zeichenklassen dies mögen \d, aber aus irgendeinem Grund nicht.

PowerShell , 46 41 40 Byte

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

Probieren Sie es online!

Nimmt Eingaben über Splatting entgegen, $z=@(12,3,0,101,11,1,0,0,14,0,28); .\implement-stack.ps1 @zdie sich in TIO als separate Argumente manifestieren.

$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 dank mazzy.
-1 Byte Swapping $_zu1

C (gcc) , 62 60 56 55 Bytes

-2 -6 Bytes dank l4m2

-1 byte dank ceilingcat .

Verwendet den zulässigen Begriff -1 terminierter Arrays. f()ruft sich selbst rekursiv auf, bis er vollständig gewickelt ist, und geht dann die Liste zurück. rVerfolgt, wie viele Nummern verworfen werden müssen, bevor etwas gedruckt wird. Erhöht sich, wenn das aktuelle Element 0 ist, verringert sich ansonsten. Wenn 0, müssen wir nicht verwerfen und können die Nummer drucken.

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

Probieren Sie es online!

Haskell, 28 Bytes

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

Probieren Sie es online!

R , 45 Bytes

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

Probieren Sie es online!

• -4 byte danke an @Giuseppe

Python 2 , 59 57 51 Bytes

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

Probieren Sie es online!

Gelee , 6 Bytes

ṣ0Ṗ;¥/

Probieren Sie es online!

Wie es funktioniert

ṣ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

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

Probieren Sie es online!

Danke an @Nitrodon für -4 Bytes.

Da Brain-Flak bereits Stapel verwendet, ist dies ein gutes Puzzle für 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}&

Probieren Sie es online!

Python 2 , 48 Bytes

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

Probieren Sie es online!

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

Buchstaben S(Leerzeichen), T(Tabulator) und (Zeilenvorschub) werden Nnur als Hervorhebungen hinzugefügt.
[..._some_action]nur als Erklärung hinzugefügt.

Trennt die Eingabe-Liste durch ein Zeichen, -1um anzuzeigen, dass wir mit den Eingaben fertig sind.

Probieren Sie es online aus .

Erklärung im Pseudocode:

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

Probieren Sie es online!

Gerettet:

• -1 Byte dank Puschkin

JavaScript, 40 Bytes

Ausgänge in umgekehrter Reihenfolge.

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

Probieren Sie es online aus

Dank Herman L 1 Byte gespart .

05AB1E , 9 Bytes

vy>i¨ëy)˜

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

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)

9 Bytes Alternative:

vy_i\ëy])

Probieren Sie es online aus und überprüfen Sie alle Testfälle .

Erläuterung:

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: Sollte die Ausgabe umgekehrt worden sein, um mit den Testfällen in der Herausforderungsbeschreibung übereinzustimmen, können wir Rder zweiten Version (also 10 Bytes ) ein Trailing hinzufügen , wodurch die Liste umgekehrt wird. Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Retina 0.8.2 , 18 Bytes

^
,
+1`,\d+,0

^,

Probieren Sie es online! Link enthält Testfälle. Erläuterung:

^
,

Präfix ein extra ,.

+1`,\d+,0

Verarbeiten Sie alle Pop-Operationen.

^,

Entfernen Sie das, ,wenn es noch da ist.

Das Umkehren der Zahlen würde zusätzliche 8 Bytes kosten:

O^$`\d+

Ruby , 36 Bytes

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

Probieren Sie es online!

Anonymes Lambda. Ausgänge in umgekehrter Reihenfolge.

Brain-Flak , 36 Bytes

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

Probieren Sie es 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 Bytes

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

Probieren Sie es online!

Verwendet -1, um das Ende des Arrays zu kennzeichnen (aber jede Zahl wird es wirklich tun).

V , 10 Bytes

ò/ 0⏎b2dw0

Probieren Sie es online!

Erläuterung

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

Entspricht in Vim 16 Byte

qq/ 0⏎b2dw0@qq@q

Probieren Sie es online!

Erläuterung

So ziemlich dasselbe, außer ein Makro aufzuzeichnen qund es rekursiv aufzurufen:

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;}

Ausgaben durch Komma getrennt. Der oberste Stapel ist der letzte. Probieren Sie es hier online aus .

Vielen Dank an Olivier Grégoire für das Golfen mit 2 Bytes.

Lesen Sie auch die Java-Antworten von Kevin Cruijssen und Olivier Grégoire . Sie verfolgen stattdessen einen Listen-basierten Ansatz, wobei letzterer die Mine um einiges übertrifft.

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 Bytes

~{.{;}if}/]`

Probieren Sie es 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 Bytes

Vielen Dank an @sundar und @DomHastings

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

Probieren Sie es online!

> <> 25 Bytes

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

Probieren Sie es online! (Die Eingabe muss in ASCII geschrieben sein. Andernfalls wird diese verwendet. )

Wie es funktioniert

i:?\~~prüft auf 0, ~~löscht weiterhin den vorherigen Eintrag. ansonsten gehe runter zu:

(0:/:^? die nach -1 sucht (keine Eingabe mehr), dann zum Löschen von -1 auflädt und die Schleife:

!?l:!<oan; Diese gibt jede Zahl mit einem Zeilenumbruch aus und endet, wenn der Stapel geleert ist

Schale , 6 Bytes

Da gibt es noch keine Antwort von Husk und es ist meine Lieblingsgolf-Sprache:

F`?:tø

Probieren Sie es online!

Erläuterung

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

Alternative Lösung, 6 Bytes

Anstatt zu spiegeln, können wir die Liste auch einfach umkehren und dann eine Rechtsfalte verwenden: Ḟ?:tø↔

Brainfuck , 214 150 Bytes

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

Liest Eingaben als durch Zeilenumbrüche getrennte Zahlen. Dies muss eine einzelne nachgestellte Zeile enthalten. Erwartet auch keine führenden Nullen für jede Zahl. Ausgabe als ähnliche durch Zeilenumbrüche getrennte Liste

Probieren Sie es online!

Erklärung ^{, die nicht wirklich eine Erklärung ist, sondern eigentlich nur die Version, an der ich mit den Kommentaren und Dingen gearbeitet habe, die für niemanden wirklich nützlich sein können oder auch nicht}

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⟩↰|

Probieren Sie es online!

-1 Byte, und was noch wichtiger ist, dies scheint eine viel weniger klobige Methode zu sein.

~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↰| Probieren Sie es online!

Älterer Code:

22 Bytes

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

Probieren Sie es 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 

Warnung: Es folgen viele Zeilen. Du wurdest gewarnt.

CJam , 17 Bytes

Gefährlichster Code
(Angenommen, die Stack-Elemente können nur durch Leerzeichen in der Ausgabe getrennt werden und das Eingabe-Array kann eine beliebige Form haben)

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

Probieren Sie es online!

Erläuterung

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

Alternativer Code Nr. 1, 27 Byte
(Angenommen, Stapelelemente müssen in dem in der Frage gezeigten Format ausgegeben werden und das Eingabearray kann in jeder von uns gewünschten Form vorliegen.)

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

Probieren Sie es online!

Erläuterung

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

Alternativer Code Nr. 2, 24 Byte
(Angenommen, die Stapelelemente können in der Ausgabe sortiert werden und das Eingabearray muss das in der Frage angegebene genaue Format haben.)

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

Probieren Sie es online!

Erläuterung

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

Sicherster Code hierfür, 34 Byte
(Angenommen, Stapelelemente müssen in dem in der Frage angegebenen Format ausgegeben werden und das Eingabearray muss in dem in der Frage angegebenen Format vorliegen.)

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

Probieren Sie es online!

Erläuterung

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

Vielen Dank an @Jo King für den Hinweis, dass diejenigen mit der zusammengestellten Ausgabe ungültig sind, da Dinge wie [12]und [1,2]nicht unterscheidbar wären.

Dank auch an @Jo King , der eine sehr geeignete Alternative für die gesammelten Ausgaben und das Abschneiden von 9 Bytes bietet!

Rot , 64 Bytes

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

Probieren Sie es online!