Tôi không thể tin rằng chúng ta chưa có cái này .. Đây là một trong những cấu trúc dữ liệu quan trọng nhất trong lập trình, nhưng vẫn đủ đơn giản để thực hiện nó trong một môn đánh gôn :

Thử thách

Nhiệm vụ của bạn là triển khai một ngăn xếp cho phép đẩy và bật số, để kiểm tra việc thực hiện của bạn và giữ cho I / O đơn giản, chúng tôi sẽ sử dụng cài đặt sau:

• Đầu vào sẽ là danh sách các số nguyên không âm

Mỗi số nguyên dương $n$ chỉ ra một và mỗi chỉ ra một - loại bỏ phần tử trên cùng. 0 $\texttt{push(}n\texttt{)}$$0$$\texttt{pop()}$

• Đầu ra sẽ là ngăn xếp kết quả

Thí dụ

Ví dụ: nếu chúng tôi đã đưa ra :$[12,3,0,101,11,1,0,0,14,0,28]$

Đầu ra sẽ là:$[28,101,12]$

Quy tắc

• Đầu vào sẽ là danh sách các số nguyên không âm ở bất kỳ định dạng I / O mặc định nào
  • bạn có thể sử dụng số nguyên âm để biểu thị sự kết thúc của một luồng số nguyên
• Đầu ra sẽ là một danh sách / ma trận / .. của ngăn xếp kết quả
  • sự lựa chọn của bạn trong đó phần tử hàng đầu sẽ là (ở đầu hoặc cuối), đầu ra chỉ cần nhất quán
  • đầu ra rất linh hoạt (ví dụ: các số nguyên được phân tách bằng các dòng mới sẽ ổn), điều duy nhất quan trọng là thứ tự
  • bạn có thể sử dụng một số nguyên âm để biểu thị dưới cùng của ngăn xếp
• Bạn được đảm bảo rằng sẽ không bao giờ có khi ngăn xếp trống$0$

Ví dụ

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

Đầu vào là một vectơ hàng của các số.

Ngăn xếp cuối cùng được hiển thị lộn ngược, với phần tử gần đây nhất bên dưới.

Hãy thử trực tuyến! Hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình

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

Vì "[đầu ra] linh hoạt [...], điều duy nhất quan trọng là thứ tự", điều này thay đổi mảng đầu vào thành một 0mảng bị hủy. Ví dụ: [1,0,2]sẽ trả về sẽ [2,0,2]được hiểu là = .[2,0,2][2]

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

Hãy thử trực tuyến!

Những phiên bản trước:

Java (JDK 10) , 60 byte

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

Hãy thử trực tuyến!

Tín dụng:

• -1 byte nhờ OOBalance

Nếu tôi có thể kết thúc chương trình với lỗi: 55 byte

(mặc dù mọi thứ đã được sửa đổi đúng cách)

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

Hãy thử trực tuyến!

Sed, 17 byte

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

-3 byte nhờ @ OMᗺ, -1 nhờ @eggyal

Vì bạn được đảm bảo không bao giờ bật danh sách trống, nên bạn không cần bất cứ thứ gì ngoài máy trạng thái hữu hạn lặp. Biểu thức chính quy là một công cụ để xây dựng các máy trạng thái hữu hạn và sedcó thể lặp lại. Đó là một trận đấu được thực hiện trên thiên đường.

Lấy đầu vào từ stdin, như vậy:

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

Xuất ra ngăn xếp ngược lại:

[12,101,28]

Có thể nhỏ hơn hai byte nếu địa phương sedvốn đã hiểu các lớp ký tự của tôi \d, nhưng vì một số lý do.

PowerShell , 46 41 40 byte

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

Hãy thử trực tuyến!

Đưa đầu vào thông qua ghép nối, ví dụ, $z=@(12,3,0,101,11,1,0,0,14,0,28); .\implement-stack.ps1 @ztrên TIO biểu hiện dưới dạng các đối số riêng biệt.

$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 nhờ mazzy.
Hoán đổi -1 byte $_thành1

C (gcc) , 62 60 56 55 byte

-2 -6 byte nhờ l4m2

-1 byte nhờ trần .

Sử dụng khái niệm được phép của -1 mảng kết thúc. f()gọi chính nó một cách đệ quy, cho đến khi hoàn toàn bình tĩnh, và sau đó quay lại danh sách. rtheo dõi có bao nhiêu số để loại bỏ trước khi in một cái gì đó. Tăng nếu mục hiện tại là 0, giảm khác. Nếu 0, chúng tôi không cần loại bỏ và có thể in số.

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

Hãy thử trực tuyến!

Haskell, 28 byte

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

Hãy thử trực tuyến!

R , 45 byte

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

Hãy thử trực tuyến!

• -4 byte nhờ @Giuseppe

Python 2 , 59 57 51 byte

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

Hãy thử trực tuyến!

Thạch , 6 byte

ṣ0Ṗ;¥/

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

ṣ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

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

Hãy thử trực tuyến!

Cảm ơn @Nitrodon cho -4 byte.

Vì Brain-Flak đã sử dụng ngăn xếp, đây là một câu đố hay cho 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

Ngôn ngữ Wolfram (Mathicala) , 28 byte

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

Hãy thử trực tuyến!

Python 2 , 48 byte

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

Hãy thử trực tuyến!

Khoảng trắng , 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]

Chữ cái S(dấu cách), T(tab) và N(dòng mới) được thêm vào dưới dạng chỉ tô sáng.
[..._some_action]chỉ thêm vào giải thích.

Đưa dòng mới vào danh sách đầu vào được phân tách -1để cho biết chúng ta đã hoàn thành các đầu vào.

Hãy thử trực tuyến .

Giải thích bằng mã giả:

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

Con trăn 2 , 60 59 57 56 byte

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

Hãy thử trực tuyến!

Đã lưu:

• -1 byte, nhờ có đẩy

JavaScript, 40 byte

Đầu ra theo thứ tự ngược lại.

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

Dùng thử trực tuyến

1 byte lưu nhờ Herman L .

05AB1E , 9 byte

vy>i¨ëy)˜

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình:

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 byte thay thế:

vy_i\ëy])

Hãy thử trực tuyến để xác minh tất cả các trường hợp thử nghiệm .

Giải trình:

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: Nếu đầu ra phải được đảo ngược để khớp với các trường hợp thử nghiệm trong mô tả thử thách, chúng ta có thể thêm một dấu Rvào phiên bản thứ hai (vì vậy 10 byte ), đảo ngược danh sách. Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Võng mạc 0.8.2 , 18 byte

^
,
+1`,\d+,0

^,

Hãy thử trực tuyến! Liên kết bao gồm các trường hợp thử nghiệm. Giải trình:

^
,

Tiền tố thêm ,.

+1`,\d+,0

Xử lý tất cả các hoạt động pop.

^,

Hủy bỏ ,nếu nó vẫn còn đó.

Việc đảo ngược các con số sẽ tốn thêm 8 byte:

O^$`\d+

Ruby , 36 byte

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

Hãy thử trực tuyến!

Lambda ẩn danh. Đầu ra theo thứ tự ngược lại.

Brain-Flak , 36 byte

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

Hãy thử trực tuyến!

#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

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

Hãy thử trực tuyến!

Sử dụng -1để biểu thị sự kết thúc của mảng (nhưng bất kỳ số nào sẽ thực sự làm được).

V , 10 byte

ò/ 0⏎b2dw0

Hãy thử trực tuyến!

Giải trình

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

Tương đương trong Vim , 16 byte

qq/ 0⏎b2dw0@qq@q

Hãy thử trực tuyến!

Giải trình

Khá giống nhau, ngoại trừ ghi một macro qvà gọi đệ quy nó:

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

Các đầu ra được phân tách bằng dấu phẩy. Đầu ngăn xếp là cuối cùng. Hãy thử trực tuyến tại đây .

Cảm ơn Olivier Grégoire vì đã chơi golf 2 byte.

Vui lòng kiểm tra câu trả lời Java của Kevin Cruijssen và Olivier Grégoire . Thay vào đó, họ thực hiện một cách tiếp cận dựa trên danh sách, với cách đánh sau của tôi bằng một lề gọn gàng.

Ung dung:

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}/]`

Hãy thử trực tuyến!

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

Cảm ơn @sundar và @DomHastings

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

Hãy thử trực tuyến!

> <> , 25 byte

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

Hãy thử trực tuyến! (đầu vào phải được viết bằng ascii. Nếu không thì sử dụng cái này )

Làm thế nào nó hoạt động

i:?\~~kiểm tra 0, tiếp tục ~~xóa mục trước đó. mặt khác đi xuống:

(0:/:^? kiểm tra -1 (không nhập thêm), sau đó kết thúc để xóa -1 và lặp:

!?l:!<oan; đầu ra mỗi số với một dòng mới, sau đó kết thúc khi ngăn xếp trống

Husk , 6 byte

Vì chưa có câu trả lời của Husk và đó là môn đánh gôn yêu thích của tôi:

F`?:tø

Hãy thử trực tuyến!

Giải trình

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

Giải pháp thay thế, 6 byte

Thay vì lật, chúng ta cũng có thể đảo ngược danh sách và sau đó sử dụng một nếp gấp bên phải: Ḟ?:tø↔

Brainfuck , 214 150 byte

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

Đọc đầu vào dưới dạng số được phân tách bằng dòng mới. Điều này phải bao gồm một dòng mới duy nhất. Cũng mong đợi không có số không hàng đầu trên mỗi số. Đầu ra dưới dạng một danh sách phân tách dòng mới tương tự

Hãy thử trực tuyến!

Giải thích ^{đó không thực sự là một lời giải thích nhưng thực sự chỉ là phiên bản tôi đang làm việc với các bình luận và nội dung có thể thực sự không hữu ích cho bất kỳ ai}

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

Hãy thử trực tuyến!

-1 byte, và quan trọng hơn, điều này cảm thấy giống như một cách ít rắc rối hơn để làm điều này.

~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

Thay thế 21 byter: ∋0∧ℕ₁;0;P↺c;Qc?∧P,Q↰| Hãy thử trực tuyến!

Mã cũ hơn:

22 byte

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

Hãy thử trực tuyến!

∋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 

Cảnh báo: Rất nhiều dòng tiếp theo. Bạn đã được cảnh báo.

CJam , 17 byte

Mã nguy hiểm nhất
(Giả sử các phần tử ngăn xếp chỉ có thể được phân tách bằng khoảng trắng trong đầu ra và mảng đầu vào có thể là bất kỳ dạng nào chúng ta muốn)

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

Hãy thử trực tuyến!

Giải trình

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

Mã thay thế số 1, 27 byte
(Giả sử các phần tử ngăn xếp phải được xuất ra ở định dạng được hiển thị trong câu hỏi và mảng đầu vào có thể là bất kỳ dạng nào chúng ta muốn)

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

Hãy thử trực tuyến!

Giải trình

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

Mã thay thế số 2, 24 byte
(Giả sử các phần tử ngăn xếp có thể được đối chiếu trong đầu ra và mảng đầu vào phải ở định dạng chính xác được hiển thị trong câu hỏi)

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

Hãy thử trực tuyến!

Giải trình

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

Mã an toàn nhất cho điều này, 34 byte
(Giả sử các phần tử ngăn xếp phải được xuất ra ở định dạng được hiển thị trong câu hỏi và mảng đầu vào phải ở định dạng chính xác được hiển thị trong câu hỏi)

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

Hãy thử trực tuyến!

Giải trình

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

Cảm ơn @Jo King đã chỉ ra rằng những cái có đầu ra đối chiếu là không hợp lệ vì những thứ như[12] và [1,2]sẽ không thể phân biệt được.

Cũng xin cảm ơn @Jo King cung cấp một giải pháp thay thế rất phù hợp cho các đầu ra đối chiếu và cắt bỏ 9 byte!

Đỏ , 64 byte

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

Hãy thử trực tuyến!