Nie mogę uwierzyć, że jeszcze tego nie mamy. Jest to jedna z najważniejszych struktur danych w programowaniu, ale wciąż wystarczająco prosta, aby zaimplementować ją w golfie kodowym :

Wyzwanie

Twoim zadaniem jest zaimplementowanie stosu, który umożliwia wypychanie i usuwanie liczb, testowanie implementacji i uproszczenie operacji we / wy, wykorzystamy następującą konfigurację:

• Dane wejściowe będą listą liczb całkowitych nieujemnych

Każda dodatnia liczba całkowita oznacza a każde oznacza - odrzucając górny element.push ( n ) 0 $n$$\texttt{push(}n\texttt{)}$$0$$\texttt{pop()}$

• Wyjściowym wynikiem będzie stos

Przykład

Na przykład, jeśli otrzymamy :$[12,3,0,101,11,1,0,0,14,0,28]$

Dane wyjściowe będą wynosić:$[28,101,12]$

Zasady

• Dane wejściowe będą listą nieujemnych liczb całkowitych w dowolnym domyślnym formacie We / Wy
  • możesz użyć ujemnej liczby całkowitej, aby oznaczyć koniec strumienia liczb całkowitych
• Wyjście będzie listą / macierzą / .. stosu wynikowego
  • Twój wybór, gdzie będzie górny element (na początku lub na końcu), wynik musi być spójny
  • wyjście jest elastyczne (np. liczby całkowite oddzielone nowymi wierszami byłyby w porządku), jedyna rzecz, która ma znaczenie, to kolejność
  • możesz użyć ujemnej liczby całkowitej, aby oznaczyć spód stosu
• Masz gwarancję, że nigdy nie będzie gdy stos będzie pusty$0$

Przykłady

[] -> []
[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 bajtów

"@?@}x

Dane wejściowe to wektor wiersza liczb.

Ostatni stos jest pokazany do góry nogami, a najnowszy element poniżej.

Wypróbuj online! Lub sprawdź wszystkie przypadki testowe .

Wyjaśnienie

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

Ponieważ „[wyjście] jest elastyczne [...], jedyną rzeczą, która ma znaczenie, jest kolejność”, zmienia to tablicę wejściową w tablicę 0-terminated. Przykład: [1,0,2]zwróci, [2,0,2]co należy interpretować jako = .[2,0,2][2]

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

Wypróbuj online!

Poprzednie wersje:

Java (JDK 10) , 60 bajtów

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

Wypróbuj online!

Kredyty:

• -1 bajt dzięki OOBalance

Jeśli mogę zakończyć program z błędami: 55 bajtów

(chociaż wszystko jest odpowiednio zmodyfikowane)

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

Wypróbuj online!

Sed, 17 bajtów

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

-3 bajty dzięki @ OMᗺ, -1 dzięki @eggyal

Ponieważ masz gwarancję, że nigdy nie otworzysz pustej listy, nie potrzebujesz niczego więcej niż iterowanej skończonej maszyny stanów. Wyrażenia regularne są narzędziem do budowania skończonych maszyn stanów i sedmogą iterować. To mecz stworzony w niebie.

Pobiera dane wejściowe ze standardowego wejścia, takie jak:

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

Wysyła stos w odwrotnej kolejności:

[12,101,28]

Mógłby być mniejszy o dwa bajty, jeśli moje lokalne sedzrozumiałe klasy znaków lubią \d, ale z jakiegoś powodu tak nie jest.

PowerShell , 46 41 40 bajtów

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

Wypróbuj online!

Pobiera dane wejściowe poprzez rozpryskiwanie, np. $z=@(12,3,0,101,11,1,0,0,14,0,28); .\implement-stack.ps1 @z, Które w TIO przejawia się jako osobne argumenty.

$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 bajtów dzięki mazzy.
-1 bajt zamiana $_na1

C (gcc) , 62 60 56 55 bajtów

-2 -6 bajtów dzięki l4m2

-1 bajt dzięki pułapkowi cat .

Używa dozwolonego pojęcia -1 tablic zakończonych. f()wywołuje się rekurencyjnie, aż do pełnego uzwojenia, a następnie cofa się po liście. rśledzi, ile liczb należy odrzucić przed wydrukowaniem czegoś. Zwiększa, jeśli bieżącym przedmiotem jest 0, w przeciwnym razie maleje. Jeśli 0, nie musimy odrzucać i możemy wydrukować numer.

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

Wypróbuj online!

Haskell, 28 bajtów

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

Wypróbuj online!

R , 45 bajtów

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

Wypróbuj online!

• -4 bajty dzięki @Giuseppe

Python 2 , 59 57 51 bajtów

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

Wypróbuj online!

Galaretka , 6 bajtów

ṣ0Ṗ;¥/

Wypróbuj online!

Jak to działa

ṣ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 bajtów

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

Wypróbuj online!

Dzięki @Nitrodon za -4 bajty.

Ponieważ Brain-Flak już używa stosów, jest to dobra łamigłówka dla 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 bajtów

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

Wypróbuj online!

Python 2 , 48 bajtów

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

Wypróbuj online!

Biała spacja , 89 bajtów

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

Litery S(spacja), T(tab) i N(nowa linia) dodane tylko jako wyróżnienia.
[..._some_action]dodano tylko jako wyjaśnienie.

Oddziela nowy wiersz listy wejściowej, -1aby wskazać, że skończyliśmy z danymi wejściowymi.

Wypróbuj online .

Objaśnienie w pseudo-kodzie:

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 bajtów

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

Wypróbuj online!

Zapisano:

• -1 bajt, dzięki pushkin

JavaScript, 40 bajtów

Wyjścia w odwrotnej kolejności.

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

Wypróbuj online

1 bajt zapisany dzięki Herman L .

05AB1E , 9 bajtów

vy>i¨ëy)˜

Wypróbuj online lub sprawdź wszystkie przypadki testowe .

Wyjaśnienie:

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 bajtów alternatywnych:

vy_i\ëy])

Wypróbuj online, aby zweryfikować wszystkie przypadki testowe .

Wyjaśnienie:

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: Jeśli wynik powinien zostać odwrócony, aby pasował do przypadków testowych w opisie wyzwania, możemy dodać znak końcowy Rdo drugiej wersji (czyli 10 bajtów ), która odwraca listę. Wypróbuj online lub sprawdź wszystkie przypadki testowe .

Retina 0.8.2 , 18 bajtów

^
,
+1`,\d+,0

^,

Wypróbuj online! Link zawiera przypadki testowe. Wyjaśnienie:

^
,

Przedrostek dodatkowy ,.

+1`,\d+,0

Przetwórz wszystkie operacje pop.

^,

Usuń, ,jeśli nadal tam jest.

Odwrócenie liczb kosztowałoby dodatkowe 8 bajtów:

O^$`\d+

Rubinowy , 36 bajtów

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

Wypróbuj online!

Anonimowa lambda. Wyjścia w odwrotnej kolejności.

Brain-Flak , 36 bajtów

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

Wypróbuj 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 bajty

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

Wypróbuj online!

Używa -1do oznaczenia końca tablicy (ale dowolna liczba tak naprawdę zrobi).

V , 10 bajtów

ò/ 0⏎b2dw0

Wypróbuj online!

Wyjaśnienie

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

Odpowiednik w Vim , 16 bajtów

qq/ 0⏎b2dw0@qq@q

Wypróbuj online!

Wyjaśnienie

Prawie tak samo, z wyjątkiem nagrywania makra qi rekurencyjnego wywoływania go:

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 bajtów

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

Wyjścia oddzielone przecinkiem. Górna część stosu jest ostatnia. Wypróbuj online tutaj .

Dzięki Olivier Grégoire za grę w golfa 2 bajty.

Sprawdź także odpowiedzi Javy Kevina Cruijssena i Oliviera Grégoire'a . Zamiast tego przyjmują podejście oparte na liście, przy czym ten ostatni bije kopalnię czystym marginesem.

Nie golfowany:

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 bajtów

~{.{;}if}/]`

Wypróbuj 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 bajtów

Dzięki @sundar i @DomHastings

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

Wypróbuj online!

> <> , 25 bajtów

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

Wypróbuj online! (dane wejściowe muszą być zapisane w ascii. w przeciwnym razie użyj tego )

Jak to działa

i:?\~~sprawdza 0, kontynuuje ~~usuwanie poprzedniego wpisu. w przeciwnym razie zejdź do:

(0:/:^? który sprawdza -1 (nie ma już danych wejściowych), a następnie zawija się, aby usunąć -1 i zapętlić:

!?l:!<oan; który wypisuje każdą liczbę z nową linią, a następnie kończy się, gdy stos jest opróżniany

Łuska , 6 bajtów

Ponieważ nie ma już odpowiedzi Husk i jest to mój ulubiony język golfa:

F`?:tø

Wypróbuj online!

Wyjaśnienie

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

Alternatywne rozwiązanie, 6 bajtów

Zamiast przewracać, możemy również odwrócić listę, a następnie użyć opcji fold-right: Ḟ?:tø↔

pieprzenie mózgu , 214 150 bajtów

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

Czyta wprowadzone dane jako liczby oddzielone znakami nowej linii. Musi to obejmować pojedynczy znak nowej linii. Nie oczekuje również zer wiodących na każdej liczbie. Dane wyjściowe jako podobna lista oddzielona nowym wierszem

Wypróbuj online!

Wyjaśnienie, ^{które tak naprawdę nie jest wyjaśnieniem, ale w rzeczywistości jest tylko wersją, nad którą pracowałem z komentarzami i rzeczami, które mogą, ale nie muszą być przydatne dla każdego}

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 bajtów

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

Wypróbuj online!

-1 bajt, a co ważniejsze, wydaje się to znacznie mniej niezręcznym sposobem na zrobienie tego.

~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↰| Wypróbuj online!

Starszy kod:

22 bajty

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

Wypróbuj 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 

Ostrzeżenie: powstaje wiele linii. Zostałeś ostrzeżony.

CJam , 17 bajtów

Najbardziej niebezpieczny kod
(Zakłada się, że elementy stosu można oddzielić tylko spacjami na wyjściu i że tablica wejściowa może mieć dowolną formę)

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

Wypróbuj online!

Wyjaśnienie

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

Kod alternatywny nr 1, 27 bajtów
(Zakłada, że ​​elementy stosu muszą być wyprowadzane w formacie pokazanym w pytaniu i że tablica wejściowa może mieć dowolną formę)

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

Wypróbuj online!

Wyjaśnienie

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

Kod alternatywny nr 2, 24 bajty
(Zakłada się, że elementy stosu mogą być zestawiane w danych wyjściowych i że tablica wejściowa musi mieć dokładny format pokazany w pytaniu)

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

Wypróbuj online!

Wyjaśnienie

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

Najbezpieczniejszy kod do tego, 34 bajty
(Zakłada się, że elementy stosu muszą być wyprowadzane w formacie pokazanym w pytaniu i że tablica wejściowa musi być w formacie pokazanym w pytaniu)

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

Wypróbuj online!

Wyjaśnienie

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

Dzięki @Jo King za zwrócenie uwagi, że te z posortowanym wyjściem są nieprawidłowe, ponieważ rzeczy takie jak [12]i [1,2]byłyby nierozróżnialne.

Dzięki również @Jo King zapewnia bardzo odpowiednią alternatywę dla zestawionych danych wyjściowych i odcina 9 bajtów!

Czerwony , 64 bajty

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

Wypróbuj online!