Buna zaten sahip olmadığımıza inanamıyorum. Programlamadaki en önemli veri yapılarından biri, ancak yine de bir kod golfünde uygulamak için yeterince basit :

Meydan okuma

Göreviniz, numaraları itme ve patlatma olanağı sağlayan bir yığın uygulamak, uygulamanızı test etmek ve G / Ç'yi basit tutmak için aşağıdaki ayarları kullanacağız:

• Giriş, negatif olmayan tam sayıların bir listesi olacaktır

Her pozitif tamsayı bir ve her ise bir - üst öğeyi atar.bas ( n ) 0 $n$$\texttt{push(}n\texttt{)}$$0$$\texttt{pop()}$

• Çıktı ortaya çıkan yığın olacaktır

Örnek

Örneğin, eğer verilirse :$[12,3,0,101,11,1,0,0,14,0,28]$

Çıktı olacak:$[28,101,12]$

kurallar

• Giriş, herhangi bir varsayılan G / Ç biçiminde negatif olmayan tam sayıların bir listesi olacaktır
  • bir tamsayı akışının sonunu belirtmek için negatif bir tamsayı kullanabilirsiniz.
• Çıktı, ortaya çıkan yığının bir listesi / matrisi / .. olacaktır.
  • Üst elemanın nerede olacağı (başlangıçta ya da sonunda) seçiminiz, çıktının tutarlı olması gerekir.
  • çıktı esnektir (örn. yeni satırlarla ayrılan tam sayılar iyi olur), önemli olan tek şey siparişdir
  • yığının altını belirtmek için negatif bir tamsayı kullanabilirsiniz.
• Yığın boşken asla olmayacağının garantisi var$0$

Örnekler

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

"@?@}x

Giriş, sayıların bir satır vektörüdür.

Son yığın aşağıdaki en son eleman ile baş aşağı gösterilmiştir.

Çevrimiçi deneyin! Veya tüm test durumlarını doğrulayın .

açıklama

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

"[] Çıktı esnek [...] olduğundan, önemli olan tek şey sıradır", bu girdi dizisini 0sonlandırılmış bir diziye dönüştürür . Örnek: = olarak yorumlanacak olana [1,0,2]dönecektir .[2,0,2][2,0,2][2]

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

Çevrimiçi deneyin!

Önceki sürümler:

Java (JDK 10) , 60 bayt

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

Çevrimiçi deneyin!

Kredi:

• OOBalance sayesinde -1 bayt

Programı hatalarıyla sonlandırabilirsem: 55 bayt

(her şey düzgün bir şekilde değiştirilse de)

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

Çevrimiçi deneyin!

Sed, 17 Bayt

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

@ OMᗺ sayesinde -3 byte, @eggyal sayesinde -1

Asla boş bir liste açmamanız garanti olduğundan, yinelenmiş sonlu durumlu bir makineden başka bir şeye ihtiyacınız yoktur. Düzenli ifadeler sonlu durumlu makineler oluşturmak için bir araçtır ve sedyinelenebilir. Cennette yapılan bir eşleşme.

Stdin'den girdi alır, şöyle yapar:

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

Yığını tersten çıkarır:

[12,101,28]

Yerel seddoğam gereği gibi karakter sınıflarını anladıysam , iki byte kadar daha küçük olabilirdi \d, ama bir nedenden ötürü değil.

PowerShell , 46 41 40 bayt

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

Çevrimiçi deneyin!

Örneğin TIO'da $z=@(12,3,0,101,11,1,0,0,14,0,28); .\implement-stack.ps1 @zayrı bir argüman olarak tezahür eden sıçratma yoluyla girdi alır .

$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

Mazzy sayesinde -5 bayt.
-1 bayt pompalanması $_için1

C (GCC) , 62 60 56 55 bayt

L4m2 sayesinde -2 -6 bayt

Ceilingcat sayesinde -1 bayt .

-1 sonlandırılmış dizilerin izin verilen kavramını kullanır. f()tamamen yaralanıncaya kadar kendini yinelemeli olarak çağırır ve ardından listeye geri döner. rbir şeyi yazdırmadan önce kaç tane sayının atılacağını izler. Geçerli öğe 0 ise artar, aksi takdirde azalır. 0 ise, iptal etmemize gerek yoktur ve numarayı yazdırabiliriz.

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

Çevrimiçi deneyin!

Haskell, 28 bayt

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

Çevrimiçi deneyin!

R , 45 bayt

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

Çevrimiçi deneyin!

• @Giuseppe sayesinde -4 bayt

Python 2 , 59 57 51 bayt

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

Çevrimiçi deneyin!

Jöle , 6 bayt

ṣ0Ṗ;¥/

Çevrimiçi deneyin!

Nasıl çalışır

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

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

Çevrimiçi deneyin!

-4 baytlık @Nitrodon'a teşekkürler.

Brain-Flak zaten yığın kullandığı için, bu Brain-Flak için iyi bir bilmecedir.

([]){   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 Dili (Mathematica) , 28 bayt

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

Çevrimiçi deneyin!

Python 2,48 bayt

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

Çevrimiçi deneyin!

Boşluk , 89 bayt

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

Harfler S(boşluk), T(sekme) ve N(yeni satır) yalnızca vurgulama olarak eklenmiştir.
[..._some_action]sadece açıklama olarak eklendi.

-1Girdileri tamamladığımızı belirtmek için girdi listesini yeni satırlarla ayırır .

Çevrimiçi deneyin .

Sahte kodda açıklama:

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 bayt

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

Çevrimiçi deneyin!

Kaydedilen:

• -1 bayt, pushkin sayesinde

JavaScript, 40 bayt

Ters sırayla çıkışlar.

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

Çevrimiçi deneyin

Herman L sayesinde 1 bayt kurtarıldı .

05AB1E , 9 bayt

vy>i¨ëy)˜

Çevrimiçi deneyin veya tüm test durumlarını doğrulayın .

Açıklama:

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 bayt alternatif:

vy_i\ëy])

Online Deneyin ait tüm test durumları doğrulamak .

Açıklama:

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)

Not: Çıktının, meydan okuma tanımındaki test durumlarıyla eşleşmesi için tersine çevrilmiş olması durumunda , listeyi ters çeviren Rikinci sürüme (yani 10 bayt ) bir iz ekleyebiliriz . Çevrimiçi deneyin veya tüm test durumlarını doğrulayın .

Retina 0.8.2 , 18 bayt

^
,
+1`,\d+,0

^,

Çevrimiçi deneyin! Link, test durumlarını içerir. Açıklama:

^
,

Ek bir önek ,.

+1`,\d+,0

Tüm pop işlemleri gerçekleştirin.

^,

,Hala oradaysa çıkarın .

Sayıların tersine çevrilmesi fazladan 8 bayta mal olur:

O^$`\d+

Ruby , 36 bayt

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

Çevrimiçi deneyin!

Anonim lambda. Ters sırayla çıkışlar.

Brain-Flak , 36 bayt

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

Çevrimiçi deneyin!

#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 bayt

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

Çevrimiçi deneyin!

-1Dizinin sonunu belirtmek için kullanır (ancak herhangi bir sayı gerçekten yapacaktır).

V , 10 bayt

ò/ 0⏎b2dw0

Çevrimiçi deneyin!

açıklama

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

Eşdeğer Vim , 16 bayt

qq/ 0⏎b2dw0@qq@q

Çevrimiçi deneyin!

açıklama

Hemen hemen aynı, makro kaydetme qve yinelemeli olarak arama:

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 bayt

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

Çıktıları virgülle ayrılmış. Yığının üstü son. Burada çevrimiçi deneyin .

Olivier Grégoire'a 2 byte golf attığı için teşekkür ederiz .

Lütfen Kevin Cruijssen'in ve Olivier Grégoire'ın Java cevaplarına da göz atın . Bunun yerine liste temelli bir yaklaşım benimsiyorlar, ikincisi benimkileri düzenli bir farkla vuracaklar.

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 bayt

~{.{;}if}/]`

Çevrimiçi deneyin!

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

@Sundar ve @DomHastings teşekkürler

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

Çevrimiçi deneyin!

> <> , 25 bayt

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

Çevrimiçi deneyin! (giriş ASCII yazılmalıdır. Aksi kullanımı bu bir )

Nasıl çalışır

i:?\~~0 için kontrol eder, ~~önceki girişi silmeye devam eder . aksi takdirde aşağıya inin:

(0:/:^? hangi -1 denetler (daha fazla giriş yok), sonra -1 ve döngü silmek için kaydırın:

!?l:!<oan; her sayıyı bir satırsonu ile veren, sonra yığın boşaltıldığında biter

Kabuğu , 6 bayt

Henüz bir Husk cevabı olmadığından ve en sevdiğim golf sahası:

F`?:tø

Çevrimiçi deneyin!

açıklama

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

Alternatif çözüm, 6 bayt

Döndürmek yerine, sadece listeyi tersine çevirebilir ve sonra bir sağa kaydırma kullanabilirsiniz: Ḟ?:tø↔

brainfuck , 214 150 bayt

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

Girdiyi yeni satırlarla ayrılmış sayılar olarak okur. Bu, tek bir izleyen yeni satır içermelidir. Ayrıca, her sayı için baştaki sıfır beklemiyor. Benzer bir yeni satır ayrılmış liste olarak çıktı alın

Çevrimiçi deneyin!

Bu açıklama ^{aslında bir açıklama değil, aslında sadece yorumlar ve üzerinde çalıştığım sürüm.}

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 bayt

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

Çevrimiçi deneyin!

-1 bayt ve daha da önemlisi, bunu yapmanın çok daha az tuhaf bir yolu gibi geliyor.

~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

Alternatif 21 byter: ∋0∧ℕ₁;0;P↺c;Qc?∧P,Q↰| Çevrimiçi deneyin!

Eski kod:

22 bayt

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

Çevrimiçi deneyin!

∋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 

Uyarı: Çok fazla çizgi oluşuyor. Uyarıldın.

CJam , 17 bayt

En tehlikeli kod
(Yığın öğelerinin çıktıda yalnızca boşluklarla ayrılabileceğini ve giriş dizisinin istediğimiz biçimde olabileceğini varsayarsak)

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

Çevrimiçi deneyin!

açıklama

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

Alternatif Kod # 1, 27 bayt
(Yığın öğelerinin, soruda gösterilen biçimde çıkarılması gerektiğini ve giriş dizisinin istediğimiz biçimde olabileceğini varsayar)

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

Çevrimiçi deneyin!

açıklama

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

Alternatif Kod # 2, 24 bayt
(Yığın öğelerinin çıktıda harmanlanabileceğini ve girdi dizisinin soruda gösterilen biçimde olması gerektiğini varsayar)

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

Çevrimiçi deneyin!

açıklama

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

Bunun için en güvenli kod 34 bayttır
(Yığın öğelerinin soruda gösterilen biçimde çıkarılması gerektiğini ve girdi dizisinin soruda gösterilen biçimde olması gerektiğini varsayar)

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

Çevrimiçi deneyin!

açıklama

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

Sayesinde @Jo Kral harmanlanmış çıkışı ile olanlar gibi şeyler beri geçersiz olduğunu işaret için [12]ve [1,2]ayırt edilemez.

@Jo King'e ayrıca harmanlanmış çıktılar için çok uygun bir alternatif sağlayarak ve 9 byte'lık kestiği için teşekkürler !

Kırmızı , 64 bayt

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

Çevrimiçi deneyin!