Saya tidak percaya kita belum memiliki ini .. Ini salah satu struktur data yang paling penting dalam pemrograman, namun masih cukup sederhana untuk mengimplementasikannya dalam kode-golf :

Tantangan

Tugas Anda adalah mengimplementasikan tumpukan yang memungkinkan mendorong dan membuka nomor, untuk menguji implementasi Anda dan membuat I / O tetap sederhana, kami akan menggunakan pengaturan berikut:

• Input akan menjadi daftar bilangan bulat non-negatif

Setiap bilangan bulat positif menunjukkan dorongan ( n ) dan setiap 0 menunjukkan pop () - membuang elemen atas.$n$$\texttt{push(}n\texttt{)}$$0$$\texttt{pop()}$

• Output akan menjadi tumpukan yang dihasilkan

Contoh

Misalnya jika kita diberikan :$[12,3,0,101,11,1,0,0,14,0,28]$

Outputnya adalah: $[28,101,12]$

Aturan

• Input akan menjadi daftar bilangan bulat non-negatif dalam format I / O standar apa pun
  • Anda dapat menggunakan bilangan bulat negatif untuk menandai akhir dari aliran bilangan bulat
• Output akan berupa daftar / matriks / .. dari stack yang dihasilkan
  • pilihan Anda di mana elemen atas akan (di awal atau akhir), output hanya harus konsisten
  • output fleksibel (mis. integer dipisahkan oleh baris baru akan baik-baik saja), satu-satunya hal yang penting adalah urutannya
  • Anda dapat menggunakan bilangan bulat negatif untuk menandakan bagian bawah tumpukan
• Anda dijamin tidak akan pernah ada ketika tumpukan kosong$0$

Contohnya

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

Input adalah vektor deretan angka.

Tumpukan terakhir ditampilkan terbalik, dengan elemen terbaru di bawah ini.

Cobalah online! Atau verifikasi semua kasus uji .

Penjelasan

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

Karena "[keluaran] fleksibel [...], satu-satunya hal yang penting adalah urutan", ini mengubah array input menjadi 0array -minminasi. Contoh: [1,0,2]akan mengembalikan [2,0,2]yang akan ditafsirkan sebagai = .[2,0,2][2]

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

Cobalah online!

Versi sebelumnya:

Java (JDK 10) , 60 byte

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

Cobalah online!

Kredit:

• -1 byte berkat OOBalance

Jika saya dapat mengakhiri program dengan kesalahan: 55 byte

(meskipun semuanya dimodifikasi dengan benar)

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

Cobalah online!

Sed, 17 Bytes

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

-3 byte terima kasih kepada @ OMᗺ, -1 terima kasih kepada @eggyal

Karena Anda dijamin tidak akan pernah mengeluarkan daftar kosong, Anda tidak perlu apa-apa selain mesin keadaan terbatas yang diulang. Ekspresi reguler adalah alat untuk membangun mesin negara yang terbatas, dan seddapat digunakan kembali. Ini pasangan yang dibuat di surga.

Mengambil input dari stdin, seperti:

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

Menghasilkan tumpukan secara terbalik:

[12,101,28]

Bisa lebih kecil dua byte jika sedkelas karakter lokal saya mengerti seperti suka \d, tetapi tidak karena alasan tertentu.

PowerShell , 46 41 40 byte

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

Cobalah online!

Mengambil input melalui splatting, misalnya $z=@(12,3,0,101,11,1,0,0,14,0,28); .\implement-stack.ps1 @z, yang pada TIO bermanifestasi sebagai argumen terpisah.

$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 berkat mazzy.
-1 byte swapping $_ke1

C (gcc) , 62 60 56 55 byte

-2 -6 byte berkat l4m2

-1 byte berkat ceilingcat .

Menggunakan gagasan yang diizinkan dari -1 array yang diakhiri. f()menyebut dirinya secara rekursif, sampai sepenuhnya terluka, dan kemudian mundur melalui daftar. rmelacak berapa banyak angka yang harus dibuang sebelum mencetak sesuatu. Meningkat jika item saat ini adalah 0, berkurang jika tidak. Jika 0, kita tidak perlu membuang, dan dapat mencetak nomornya.

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

Cobalah online!

Haskell, 28 byte

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

Cobalah online!

R , 45 byte

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

Cobalah online!

• -4 byte terima kasih kepada @Giuseppe

Python 2 , 59 57 51 byte

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

Cobalah online!

Jelly , 6 byte

ṣ0Ṗ;¥/

Cobalah online!

Bagaimana itu bekerja

ṣ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

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

Cobalah online!

Berkat @Nitrodon untuk -4 byte.

Karena Brain-Flak sudah menggunakan tumpukan, ini adalah teka-teki yang bagus untuk 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

Bahasa Wolfram (Mathematica) , 28 byte

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

Cobalah online!

Python 2 , 48 byte

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

Cobalah online!

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

Huruf S(spasi), T(tab), dan N(baris baru) ditambahkan hanya sebagai penyorotan.
[..._some_action]ditambahkan sebagai penjelasan saja.

Membawa input-list baris-baru dipisahkan dengan -1untuk menunjukkan bahwa kita sudah selesai dengan input.

Cobalah online .

Penjelasan dalam 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 byte

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

Cobalah online!

Disimpan:

• -1 byte, terima kasih kepada pushkin

JavaScript, 40 byte

Output dalam urutan terbalik.

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

Cobalah online

1 byte diselamatkan berkat Herman L .

05AB1E , 9 byte

vy>i¨ëy)˜

Cobalah secara online atau verifikasi semua kasus uji .

Penjelasan:

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)

Alternatif 9 byte :

vy_i\ëy])

Cobalah secara online untuk memverifikasi semua kasus uji .

Penjelasan:

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: Jika output seharusnya dibalik agar sesuai dengan kasus pengujian dalam deskripsi tantangan, kita dapat menambahkan trailing Rke versi kedua (jadi 10 byte ), yang membalikkan daftar. Cobalah secara online atau verifikasi semua kasus uji .

Retina 0.8.2 , 18 byte

^
,
+1`,\d+,0

^,

Cobalah online! Tautan termasuk kasus uji. Penjelasan:

^
,

Awali ekstra ,.

+1`,\d+,0

Memproses semua operasi pop.

^,

Hapus ,jika masih ada.

Membalikkan angka akan dikenakan biaya 8 byte tambahan:

O^$`\d+

Ruby , 36 byte

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

Cobalah online!

Lambda anonim Output dalam urutan terbalik.

Brain-Flak , 36 byte

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

Cobalah 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 byte

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

Cobalah online!

Menggunakan -1untuk menandakan akhir array (tetapi nomor berapa pun akan melakukannya)

V , 10 byte

ò/ 0⏎b2dw0

Cobalah online!

Penjelasan

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

Setara dalam Vim , 16 byte

qq/ 0⏎b2dw0@qq@q

Cobalah online!

Penjelasan

Hampir sama, kecuali merekam makro qdan menyebutnya secara rekursif:

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

Output dipisahkan oleh koma. Bagian atas tumpukan adalah yang terakhir. Cobalah online di sini .

Terima kasih kepada Olivier Grégoire untuk bermain golf 2 byte.

Silakan periksa jawaban Java Kevin Cruijssen dan Olivier Grégoire juga. Mereka mengambil pendekatan berbasis daftar sebagai gantinya, dengan yang terakhir mengalahkan tambang dengan margin yang rapi.

Tidak Disatukan:

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

Cobalah 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 byte

Terima kasih @sundar dan @DomHastings

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

Cobalah online!

> <> , 25 byte

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

Cobalah online! (input harus ditulis dalam ascii. jika tidak gunakan ini )

Bagaimana itu bekerja

i:?\~~memeriksa 0, terus ~~menghapus entri sebelumnya. jika tidak turun ke:

(0:/:^? yang memeriksa -1 (tidak ada input lagi), lalu membungkus untuk menghapus -1 dan loop:

!?l:!<oan; yang menampilkan setiap nomor dengan baris baru, lalu berakhir ketika tumpukan dikosongkan

Sekam , 6 byte

Karena belum ada jawaban Husk dan itu golf-lang favorit saya:

F`?:tø

Cobalah online!

Penjelasan

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

Solusi alternatif, 6 byte

Alih-alih membalik, kita juga bisa membalik daftar dan kemudian menggunakan lipatan-kanan: Ḟ?:tø↔

brainfuck , 214 150 byte

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

Membaca input sebagai angka yang dipisahkan oleh baris baru. Ini harus menyertakan satu baris tambahan. Juga tidak mengharapkan angka nol di setiap nomor. Output sebagai daftar terpisah baris baru yang serupa

Cobalah online!

Penjelasan ^{yang sebenarnya bukan penjelasan tetapi sebenarnya hanya versi yang saya kerjakan dengan komentar dan hal-hal yang mungkin atau mungkin tidak benar-benar bermanfaat bagi siapa pun}

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

Cobalah online!

-1 byte, dan yang lebih penting ini terasa seperti cara yang kurang kikuk dalam melakukan ini.

~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

Pengganti 21 alternatif: ∋0∧ℕ₁;0;P↺c;Qc?∧P,Q↰| Cobalah online!

Kode lama:

22 byte

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

Cobalah 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 

Peringatan: Banyak garis terjadi. Anda telah diperingatkan.

CJam , 17 byte

Kode paling berbahaya
(Asumsikan elemen tumpukan dapat dipisahkan oleh hanya spasi di output dan bahwa array input dapat berupa apa pun yang kita inginkan)

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

Cobalah online!

Penjelasan

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

Kode Alternatif # 1, 27 byte
(Mengasumsikan elemen stack harus berupa output dalam format yang ditunjukkan dalam pertanyaan dan bahwa array input dapat berupa bentuk apa pun yang kita inginkan)

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

Cobalah online!

Penjelasan

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

Kode Alternatif # 2, 24 byte
(Asumsikan elemen tumpukan dapat disusun dalam output dan bahwa array input harus dalam format yang tepat seperti yang ditunjukkan dalam pertanyaan)

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

Cobalah online!

Penjelasan

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

Kode paling aman untuk ini, 34 byte
(Mengasumsikan elemen stack harus berupa output dalam format yang ditunjukkan dalam pertanyaan dan bahwa array input harus dalam format yang tepat seperti yang ditunjukkan dalam pertanyaan)

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

Cobalah online!

Penjelasan

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

Terima kasih kepada @ Jo King untuk menunjukkan bahwa yang dengan keluaran yang disusun tidak valid karena hal-hal seperti [12]dan[1,2] tidak dapat dibedakan.

Terima kasih juga kepada @ Jo King yang menyediakan alternatif yang sangat cocok untuk output yang dikumpulkan dan memotong 9 byte!

Merah , 64 byte

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

Cobalah online!