나는 우리가 이것을 아직 가지고 있지 않다는 것을 믿을 수 없다. 그것은 프로그래밍에서 가장 중요한 데이터 구조 중 하나이지만 여전히 코드 골프 에서 구현할 수있을 정도로 간단하다 .

도전

당신의 임무는 숫자를 밀고 터지는 것을 허용하는 스택을 구현하고 구현을 테스트하고 I / O를 단순하게 유지하는 것입니다. 다음 설정을 사용합니다.

• 입력은 음이 아닌 정수 목록입니다.

모든 양의 정수 은 를 나타내고 은 나타냅니다 . 맨 위 요소는 버립니다.푸시 ( n ) 0 $n$$\texttt{push(}n\texttt{)}$$0$$\texttt{pop()}$

• 결과물은 결과 스택이됩니다

예

예를 들어 이 주어진 경우 :$[12,3,0,101,11,1,0,0,14,0,28]$

출력은 다음과 같습니다.$[28,101,12]$

규칙

• 입력은 기본 I / O 형식의 음이 아닌 정수 목록입니다.
  • 음의 정수를 사용하여 정수 스트림의 끝을 나타낼 수 있습니다.
• 결과 스택의 목록 / 매트릭스 / ..가 출력됩니다.
  • 상단 요소가 (시작 또는 끝에서) 어디에 있는지 선택하십시오. 출력은 일관성이 있어야합니다.
  • 출력은 유연합니다 (예 : 줄 바꿈으로 구분 된 정수는 괜찮을 것입니다), 중요한 것은 순서입니다
  • 스택의 맨 아래를 나타 내기 위해 음의 정수를 사용할 수 있습니다
• 스택이 비어있을 때 이 절대로 없을 것이라고 보장합니다$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)

자바 (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;}

온라인으로 사용해보십시오!

이전 버전:

자바 (JDK 10) , 60 바이트

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

온라인으로 사용해보십시오!

크레딧 :

• OOBalance 덕분에 -1 바이트

오류로 프로그램을 종료 할 수있는 경우 : 55 바이트

(모든 것이 올바르게 수정되었지만)

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

온라인으로 사용해보십시오!

Sed, 17 바이트

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

@ OMᗺ 덕분에 -3 바이트, @eggyal 덕분에 -1

빈 목록을 표시하지 않도록 보장되므로 반복 된 유한 상태 머신 이상의 것은 필요하지 않습니다. 정규식은 유한 상태 머신을 빌드하기위한 도구이며 sed반복 할 수 있습니다. 하늘에서 만든 일치입니다.

다음과 같이 stdin에서 입력을 가져옵니다.

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

스택을 반대로 출력합니다 :

[12,101,28]

로컬에서 sed본질적으로 이해되는 문자 클래스가와 같은 경우 2 바이트만큼 작을 수 \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 @zTIO에서 별도의 인수로 나타나는 스플래 팅을 통해 입력을 받습니다.

$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 덕분에 -5 바이트
-1 바이트 스와핑 $_에1

C (gcc) , 62 60 56 55 바이트

-2 -6 덕분 바이트 l4m2을

ceilingcat 덕분에 -1 바이트 .

-1 종결 배열의 허용 된 개념을 사용합니다. f()완전히 상처를 입을 때까지 재귀 적으로 호출 한 다음 목록을 통해 추적합니다. r인쇄하기 전에 몇 개의 숫자를 버릴지를 추적합니다. 현재 항목이 0이면 증가하고, 그렇지 않으면 감소합니다. 0이면 버릴 필요가 없으며 숫자를 인쇄 할 수 있습니다.

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

온라인으로 사용해보십시오!

하스켈, 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

온라인으로 사용해보십시오!

• @Giuseppe 덕분에 -4 바이트

파이썬 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.

Brain-Flak , 40 36 바이트

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

온라인으로 사용해보십시오!

-4 바이트에 대한 @Nitrodon 덕분입니다.

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

Wolfram Language (Mathematica) , 28 바이트

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

온라인으로 사용해보십시오!

파이썬 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

파이썬 2 , 60 59 57 56 바이트

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

온라인으로 사용해보십시오!

저장 됨 :

• 푸쉬킨 덕분에 -1 바이트

자바 스크립트, 40 바이트

역순으로 출력합니다.

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

온라인으로 사용해보십시오

Herman L 덕분에 1 바이트가 절약되었습니다 .

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)

추신 : 챌린지 설명의 테스트 사례와 일치하도록 출력을 되돌려 야한다면 목록을 뒤집는 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}

온라인으로 사용해보십시오!

익명의 람다. 역순으로 출력합니다.

Brain-Flak , 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

Brain-Flak , 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

자바 10, 75 72 바이트

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

쉼표로 구분 된 출력. 스택 상단이 마지막입니다. 여기에서 온라인으로 사용해보십시오 .

2 바이트 골프 를 한 Olivier Grégoire 에게 감사드립니다 .

확인하시기 바랍니다 케빈 Cruijssen의 와 올리비에 그레 구 아르의 뿐만 아니라 자바 답변을. 대신 목록 기반 접근 방식을 취하고 후자는 깔끔한 마진으로 내기를 꺾습니다.

언 골프 드 :

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

펄 5 -p , 17 바이트

감사합니다 @sundar 및 @DomHastings

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

온라인으로 사용해보십시오!

> <> , 25 바이트

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

온라인으로 사용해보십시오! (입력은 ASCII로 작성해야합니다. 그렇지 않으면 이 것을 사용 하십시오 )

작동 원리

i:?\~~0을 확인하고 ~~이전 항목을 계속 삭제합니다. 그렇지 않으면 아래로 이동하십시오.

(0:/:^? -1을 확인하고 (더 이상 입력하지 않음) -1을 삭제하고 반복합니다.

!?l:!<oan; 개행으로 각 숫자를 출력 한 다음 스택이 비면 종료됩니다.

껍질 , 6 바이트

이미 Husk 답변이 없으며 내가 가장 좋아하는 골프 언어입니다.

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 바이트

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

줄 바꿈으로 구분 된 숫자로 입력을 읽습니다. 여기에는 하나의 후행 줄 바꿈이 포함되어야합니다. 또한 각 숫자에 선행 0이 없을 것으로 예상합니다. 비슷한 줄 바꿈으로 구분 된 목록으로 출력

온라인으로 사용해보십시오!

설명 ^{은 실제로 설명이 아니라 실제로는 누군가에게 실제로 유용하거나 유용하지 않을 수있는 주석 및 내용으로 작업 한 버전 일뿐입니다.}

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 바이트

~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

collated 출력을 가진 것이 유효하지 않으며 구별 할 수 없기 때문에 @Jo King 에게 감사드립니다 .[12][1,2]

조합 된 출력에 대해 매우 적합한 대안을 제공하고 9 바이트를 차단하는 @Jo King 에게도 감사드립니다 !

빨강 , 64 바이트

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

온라인으로 사용해보십시오!