Я не можу повірити, що у нас цього вже немає. Це одна з найважливіших структур даних в програмуванні, але все ще досить проста для її реалізації в коді-гольфі :

Виклик

Ваше завдання полягає в тому, щоб реалізувати стек, який дозволяє натиснути і вискакувати номери, перевірити вашу реалізацію та зробити прості введення / виведення, ми будемо використовувати наступні настройки:

• Введеним буде список невід’ємних цілих чисел

Кожне додатне ціле число позначає а кожне вказує на - відкидання верхнього елемента.push ( n ) 0 $n$$\texttt{push(}n\texttt{)}$$0$$\texttt{pop()}$

• Вихідним результатом буде стек

Приклад

Наприклад, якщо нам дано :$[12,3,0,101,11,1,0,0,14,0,28]$

Вихід буде:$[28,101,12]$

Правила

• Введенням буде список невід’ємних цілих чисел у будь-якому форматі вводу / виводу за замовчуванням
  • ви можете використовувати від'ємне ціле число для позначення кінця потоку цілих чисел
• Виведенням буде список / матриця / .. отриманого стека
  • на ваш вибір, де буде розташований верхній елемент (на початку чи в кінці), вихід повинен просто бути узгодженим
  • вихід є гнучким (наприклад, цілі числа, розділені новими рядками, було б добре), єдине, що має значення, - це порядок
  • ви можете використовувати від'ємне ціле число для позначення нижньої частини стека
• Ви гарантуєте, що ніколи не буде коли стек порожній$0$

Приклади

[] -> []
[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 байт

"@?@}x

Введення - векторний рядок чисел.

Кінцевий стек показаний догори дном, а останній елемент внизу.

Спробуйте в Інтернеті! Або перевірити всі тестові випадки .

Пояснення

"         % 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 байти

Оскільки "[the] вихід є гнучким [...], єдине, що має значення - це порядок", це змінює вхідний масив на 0-термінований масив. Приклад: [1,0,2]повернеться, [2,0,2]що слід інтерпретувати як = .[2,0,2][2]

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

Спробуйте в Інтернеті!

Попередні версії:

Java (JDK 10) , 60 байт

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

Спробуйте в Інтернеті!

Кредити:

• -1 байт завдяки OOBalance

Якщо я можу закінчити програму з помилками: 55 байт

(хоча все правильно змінено)

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

Спробуйте в Інтернеті!

Сід, 17 байт

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

-3 байти завдяки @ OMᗺ, -1 завдяки @eggyal

Оскільки ви гарантовано ніколи не з'являтимете порожній список, вам не потрібно нічого більше, ніж ітераційна машина з кінцевим станом. Регулярні вирази - це інструмент для побудови машин з кінцевим станом і sedможуть повторювати. Це сірник, зроблений на небі.

Бере вхід зі стдіна, наприклад:

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

Виводить стек у зворотному напрямку:

[12,101,28]

Може бути меншим на два байти, якби мої локальні по sedсуті розуміли класи символів \d, але це не чомусь.

PowerShell , 46 41 40 байт

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

Спробуйте в Інтернеті!

Здійснює введення через бризки, наприклад $z=@(12,3,0,101,11,1,0,0,14,0,28); .\implement-stack.ps1 @z, що на TIO проявляється окремими аргументами.

$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 байт завдяки маззі.
-1 байт заміни $_на1

C (gcc) , 62 60 56 55 байт

-2 -6 байт завдяки l4m2

-1 байт завдяки стельовій коті .

Використовується дозволене поняття -1 завершених масивів. f()називає себе рекурсивно, до повного поранення, а потім повторює список. rвідслідковує, скільки номерів потрібно відкинути, перш ніж щось надрукувати. Збільшується, якщо поточний елемент дорівнює 0, інакше зменшується. Якщо 0, нам не потрібно відкидати, і ми можемо надрукувати номер.

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

Спробуйте в Інтернеті!

Haskell, 28 байт

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

Спробуйте в Інтернеті!

R , 45 байт

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

Спробуйте в Інтернеті!

• -4 байти завдяки @Giuseppe

Python 2 , 59 57 51 байт

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

Спробуйте в Інтернеті!

Желе , 6 байт

ṣ0Ṗ;¥/

Спробуйте в Інтернеті!

Як це працює

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

Мозок-Флак , 40 36 байт

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

Спробуйте в Інтернеті!

Завдяки @Nitrodon за 4 байти.

Оскільки Brain-Flak вже використовує стеки, це гарна загадка для 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

Мова Вольфрама (Mathematica) , 28 байт

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

Спробуйте в Інтернеті!

Python 2 , 48 байт

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

Спробуйте в Інтернеті!

Пробіл , 89 байт

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

Букви S(пробіл), T(вкладка) та N(новий рядок) додаються лише як підкреслення.
[..._some_action]додано лише як пояснення.

Знімає новий рядок у списку вводу, відокремлений, -1щоб вказати, що ми готові з введеннями.

Спробуйте в Інтернеті .

Пояснення в псевдокоді:

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 байт

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

Спробуйте в Інтернеті!

Збережено:

• -1 байт, завдяки пукіну

JavaScript, 40 байт

Виходи у зворотному порядку.

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

Спробуйте в Інтернеті

1 байт збережений завдяки Herman L .

05AB1E , 9 байт

vy>i¨ëy)˜

Спробуйте в Інтернеті або перевірте всі тестові випадки .

Пояснення:

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 байт :

vy_i\ëy])

Спробуйте в Інтернеті, щоб перевірити всі тестові випадки .

Пояснення:

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: Якщо висновок повинен був бути зворотним для відповідності тестовим випадкам в описі виклику, ми можемо додати трейлінг Rдо другої версії (тобто 10 байт ), яка перевертає список. Спробуйте в Інтернеті або перевірте всі тестові випадки .

Сітківка 0,8,2 , 18 байт

^
,
+1`,\d+,0

^,

Спробуйте в Інтернеті! Посилання включає тестові випадки. Пояснення:

^
,

Префікс зайвий ,.

+1`,\d+,0

Обробляти всі поп-операції.

^,

Видаліть, ,якщо він все ще є.

Зміна цифр коштуватиме додатково 8 байт:

O^$`\d+

Рубін , 36 байт

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

Спробуйте в Інтернеті!

Анонімна лямбда. Виходи у зворотному порядку.

Мозок-Флак , 36 байт

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

Спробуйте в Інтернеті!

#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

Мозок-Флак , 32 байти

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

Спробуйте в Інтернеті!

Використовує -1для позначення кінця масиву (але будь-яке число буде дійсно).

V , 10 байт

ò/ 0⏎b2dw0

Спробуйте в Інтернеті!

Пояснення

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

Еквівалент у Vim , 16 байт

qq/ 0⏎b2dw0@qq@q

Спробуйте в Інтернеті!

Пояснення

Приблизно те саме, за винятком запису макросу qта рекурсивного його виклику:

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 байти

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

Виходи, розділені комою. Верх стека останній. Спробуйте його онлайн тут .

Завдяки Олів'є Грегоаре за те, що виграли у 2 байти.

Будь ласка, ознайомтеся і з відповідями Java Кевіна Круїссена та Олів'є Грегоара . Натомість вони застосовують підхід, заснований на списку, і останній чітко побиває міну.

Безголівки:

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 байт

~{.{;}if}/]`

Спробуйте в Інтернеті!

~{.{;}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 байт

Дякуємо @sundar та @DomHastings

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

Спробуйте в Інтернеті!

> <> , 25 байт

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

Спробуйте в Інтернеті! (вхід повинен бути написаний у вигляді ascii. інакше використовуйте цей )

Як це працює

i:?\~~перевіряє 0, продовжує ~~видаляти попередній запис. інакше перейдіть до:

(0:/:^? який перевіряє -1 (більше немає введення), а потім завершіть для видалення -1 та циклу:

!?l:!<oan; який виводить кожне число новим рядком, а потім закінчується, коли стек спорожняється

Лушпиння , 6 байт

Оскільки відповіді на Хеск уже немає, і це мій улюблений гольф-янг:

F`?:tø

Спробуйте в Інтернеті!

Пояснення

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

Альтернативне рішення, 6 байт

Замість того, щоб гортати, ми також можемо просто змінити список, а потім скористатися правою складкою: Ḟ?:tø↔

мозковий ебать , 214 150 байт

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

Читає дані як числа, розділені новими рядками. Він повинен включати в себе один зворотний новий рядок. Також очікує відсутність провідних нулів на кожне число. Виведіть у вигляді подібного списку розділених на новий рядок

Спробуйте в Інтернеті!

Пояснення, ^{що насправді не є поясненням, але насправді є лише версією, над якою я працював, з коментарями та речами, які можуть або не можуть бути корисними нікому}

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

Брахілог , 21 байт

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

Спробуйте в Інтернеті!

-1 байт, і що ще важливіше, це виглядає як набагато менш незграбний спосіб зробити це.

~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

Альтернативний 21 байт: ∋0∧ℕ₁;0;P↺c;Qc?∧P,Q↰| Спробуйте в Інтернеті!

Старіший код:

22 байти

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

Спробуйте в Інтернеті!

∋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 

Попередження. Настає багато ліній. Вас попередили

CJam , 17 байт

Найбільш небезпечний код
(припускає, що елементи стека можуть бути розділені лише пробілами на виході, і що вхідний масив може бути будь-якої форми, яку ми бажаємо)

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

Спробуйте в Інтернеті!

Пояснення

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

Альтернативний код №1, 27 байт
(припускає, що елементи стека повинні бути виведені у форматі, показаному в запитанні, і що вхідний масив може бути будь-якої форми, яку ми бажаємо)

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

Спробуйте в Інтернеті!

Пояснення

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

Альтернативний код №2, 24 байти
(припускає, що елементи стеку можуть бути зібрані у висновку, і що вхідний масив повинен бути у точному форматі, показаному в запитанні)

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

Спробуйте в Інтернеті!

Пояснення

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

Найбезпечніший код для цього, 34 байти
(припускає, що елементи стеку повинні бути виведені у форматі, показаному в запитанні, і що вхідний масив повинен бути у точному форматі, показаному в запитанні)

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

Спробуйте в Інтернеті!

Пояснення

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

Дякуємо @Jo King за те, що він вказав, що ті, хто має зібраний вихід, є недійсними, оскільки такі речі, як, [12]і їх [1,2]не можна було б відрізняти.

Дякуємо також, що @Jo King надав дуже підходящу альтернативу для зібраних результатів та скорочення 9 байт!

Червоний , 64 байти

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

Спробуйте в Інтернеті!