이 SO 질문에서 영감을 얻었습니다.

입력으로 비어 있지 않은 정수 목록이 주어지며 첫 번째 값은 0이 아닙니다. 출력을 구성하려면 목록의 시작 부분을 따라 0이 아닌 각 값을 출력하십시오. 0이 발생하면 가장 최근에 출력에 추가 한 값을 반복하십시오.

프로그램이나 함수를 작성할 수 있으며, 입력 / 출력은 정렬 된 정수 순서 인 한 추가 정보를 인코딩하지 않는 편리한 형식을 취합니다. 프로그램에서 출력하는 경우 후행 줄 바꿈을 인쇄 할 수 있습니다. 이 마지막 줄 바꿈을 제외하고는 출력물이 제출물에 적합한 입력이어야합니다.

바이트 단위의 가장 짧은 코드가 이깁니다.

테스트 사례

[1, 0, 2, 0, 7, 7, 7, 0, 5, 0, 0, 0, 9] -> [1, 1, 2, 2, 7, 7, 7, 7, 5, 5, 5, 5, 9]
[1, 0, 0, 0, 0, 0] -> [1, 1, 1, 1, 1, 1]
[-1, 0, 5, 0, 0, -7] -> [-1, -1, 5, 5, 5, -7]
[23, 0, 0, -42, 0, 0, 0] -> [23, 23, 23, -42, -42, -42, -42]
[1, 2, 3, 4] -> [1, 2, 3, 4]
[-1234] -> [-1234]

Pyth, 6 바이트

mJ|dJQ

데모

m ... Q이는 입력에 함수를 맵핑 함을 의미합니다. 매핑되는 함수는입니다 J|dJ. J = d or J파이썬에서는 J처음 사용할 때 다음 값에 암시성이 할당 되므로 의미 합니다. Python과 달리 대입 식은 Pyth에 지정된 값을 반환하므로 맵은 J원하는 각 연속 값을 반환 합니다.

비경쟁 젤리

3 바이트이 답변은 도전 과제를 수행하는 기능을 사용하므로 경쟁이 아닙니다.

o@\

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

작동 원리

o      Take the logical OR of its arguments.
 @     Reverse the argument order of the link to the left.
  \    Do a cumulative reduce, using the link to the left.

루비, 25 바이트

->a{a.map{|x|x==0?a:a=x}}

이것은 실제로 정말 악하다.

특히, 조각 x==0 ? a : (a=x).

다른 변수 이름 a(이전의 0이 아닌 값) 을 사용한 경우 (예 : 0이 아닌) y외부에서 선언해야합니다 map( y=x단일 map반복 내부의 범위 만 있기 때문에 ). 그것은 4 문자를 더 사용합니다 ( y=0;).

그러나 변수 이름을 사용하면 a... 그렇습니다. 실제로 입력 (원래 배열) 으로 얻은 인수에 다시 할당합니다 .

map그것이 호출되는 것의 원래 가치 에만 관심이 있기 때문에 상관하지 않으므로 실제로 작동합니다.

하스켈, 21 바이트

a%0=a
a%b=b
scanl1(%)

우리가 만드는 (익명) 기능은 마지막 줄에 있습니다. 처음 두 줄은 도우미 기능을 정의합니다.

scanl1(%) [1,0,2,0,7,7,7,0,5,0,0,0,9]
[1,1,2,2,7,7,7,7,5,5,5,5,9]

이항 함수 %는 0그렇지 않으면 두 번째 인수를 출력합니다. scanl1이 기능을 입력 목록에서 반복하여 각 단계에서 결과를 출력합니다.

J, 8 바이트

{:@-.&0\

다음과 같이 호출되는 단항 함수입니다.

   f =: {:@-.&0\
   f 2 0 0 4 0 _1 0
2 2 2 4 4 _1 _1

설명

{:@-.&0\
       \  Map over non-empty prefixes:
   -.      remove all occurrences
     &0    of the number 0 and
{:@        take the last element.

세드, 8

/^0$/g
h

• /^0$/줄의 0과 일치합니다. 그렇다면 g보류 공간을 패턴 공간에 복사합니다.
• h 패턴 공간을 홀드 공간으로 복사

정수는 줄 바꿈으로 구분됩니다. 예 :

$ printf -- "-1\n0\n5\n0\n0\n7\n" | sed -f zerocover.sed
-1
-1
5
5
5
7
$ 

자바 스크립트 ES6, 19 바이트

s=>s.map(i=>p=i||p)

간단 용액 입력을 반복, 할당 p현재 요소 i거나 p하는 경우 i이다 0그것을 출력하고.

예제 실행 (익명 함수를에 할당 f) :

>> f([1, 0, 2, 0, 7, 7, 7, 0, 5, 0, 0, 0, 9])
<< Array [1, 1, 2, 2, 7, 7, 7, 7, 5, 5, 5, 5, 9]

망막 , 15 바이트

+`(\S+) 0
$1 $1

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

문자열 변경이 중지 될 때까지 숫자 다음에 0을 그 숫자의 두 배로 반복해서 바꿉니다.

Dyalog APL, 12 10 9 바이트

(⊃0~⍨,⍨)\

@Zgarb의 J 답변에서 영감을 얻었습니다.

(⊃0~⍨,⍨)\      Monadic function:
        \      Cumulative reduce by
(⊃0~⍨,⍨)       the dyadic function:
     ,⍨           Arguments concatenated in reverse order
  0~⍨             With zeroes removed
 ⊃                Take the first element

여기서 사용해보십시오 .

Pyth, 8 바이트

t.u|YNQ0

기본 사례 0과 함께 (Python 's .u)에 의해 (누적 감소)를 사용합니다 .|or

파이썬 2, 29 바이트

while 1:x=input()or x;print x

한 줄에 하나씩 주어진 숫자로 입력을 받아서 같은 형식으로 출력합니다. 완료 후 오류로 종료됩니다.

의 단락 특성을 사용하여 입력이 0 (Falsey)이 아닌 한 현재 값을 유지하지 않으면 or변수 x가 입력으로 업데이트됩니다. 그런 다음 x인쇄됩니다. 첫 번째 목록 값이 0 x이 아니므로 할당되기 전에 오른쪽에서 평가되지 않습니다.

Mathematica 38 바이트

패턴 매칭이 반복적 ...a,0,...으로...a,a...

#//.{b___,a_/;a!=0,0,e___}:>{b,a,a,e}&

Matlab, 41 46 바이트

이것은 원래의 대답 에서 영감을 얻었으며 다음과 같은 차이점이 있습니다.

1. 대신 논리적 인덱싱을 사용하십시오 nonzeros.
2. 와 비교하는 대신 이중 논리 부정 0.
3. 출력 형식이 유연하므로 조옮김을 제거 할 수 있습니다.
4. 중간 변수를 제거합니다.

항목 4에 대한 Tom Carpenter 와 함수 대신 프로그램을 사용하라는 제안에 감사 합니다. 함께 5 바이트를 줄일 수있었습니다.

x=input('');u=x(~~x);disp(u(cumsum(~~x)))

예:

>> x=input('');u=x(~~x);disp(u(cumsum(~~x)))
[4 0 3 2 0 5 6 0]
     4     4     3     2     2     5     6     6

Gol> <> , 8 바이트

IE;:Z~:N

입력과 출력은 줄 바꿈으로 구분 된 숫자입니다.

설명:

I         push next integer to stack
 E;       halt if EOF
   :Z~    remove top stack element if 0
      :N  print top stack element while also keeping it on the stack
          wrap around code implicitly

여기에서 온라인으로 사용해보십시오.

apt, 8 7 바이트

N£U=XªU

꽤 간단합니다. 쉼표로 구분하여 입력을받습니다. 온라인으로 사용해보십시오!

언 골프와 설명

N£    U=Xª U
NmXYZ{U=X||U

        // Implicit: N = input, U = first item
NmXYZ{  // Map each item X to:
U=Z||U  //  Set U to (X || U) and return.
        //  If X is non-zero, this sets U to X.
        //  Otherwise, this leaves U as the last non-zero we've encountered.
        // Implicit: output last expression

비경쟁 4 바이트 버전 : ( 챌린지 후 å명령 및 !-자동 기능 추가)

Nå!ª

설명:

Nå!ª
Nå!||
NåXY{Y||X}

        // Implicit: N = input, U = first item
NåXY{   // Cumulatively reduce N; take each item Y and prev value X,
Y||X}   //  and return Y if it is non-zero; return X otherwise.
        // Implicit: output last expression

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

자바, 78

int[]f(int[]a){for(int i=-1,b=i;++i<a.length;a[i]=b=a[i]==0?b:a[i]);return a;}

여기서 우리는 단지 0이 아닌 마지막을 추적하고 적절한 곳에 밀어 넣습니다. 그것을하는 명백한 방법 인 것 같습니다.

프롤로그 (SWI) , 54 바이트

[X,0|T]+[X,X|Y]:-[X|T]+[X|Y].
[X|T]+[X|Y]:-T+Y.
[]+[].

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

설명

이 답변에 정말 만족합니다.

먼저 빈 목록이 빈 목록의 해결책이라고 말합니다.

[]+[].

그런 다음 나머지 각 솔루션의 두 번째 항목을 제거하여 [X,X|Y]의 솔루션 이라고 말합니다 [X,0|T].

[X,0|T]+[X,X|Y]:-[X|T]+[X|Y].

마지막으로 남은 것은 동일한 값으로 시작하고 나머지 두 목록이 서로 일치하면 유효합니다.

그 설명이 효과가 없다면 다음은 Haskell로 번역 된 코드입니다.

g(a:0:x)=a:g(a:x)
g(a:x)=a:g x
g x=x

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

GolfScript, 10 바이트

~{1$or}*]`

이 프로그램은 골프 스크립트 배열 리터럴 (예 :)의 형태로 stdin에서 입력을 가져와 [1 0 2 0]동일한 형식 (예 :) 으로 출력을 stdout에 씁니다 [1 1 2 2].

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

함수 (GolfScript 배열 가져 오기 및 반환)는 블록으로 감싸서 기호에 할당해야하기 때문에 3 바이트 더 길어집니다.

{[{1$or}*]}:f

물론 함수 본문 (예 :) 만 [{1$or}*]계산하면 실제로 독립 실행 형 프로그램과 비교하여 1 바이트를 저장할 수 있습니다.

Minkolang 0.14 , 12 10 바이트

$I?.nd?xdN

여기에서 시도하십시오. 질문에서와 같이 입력 할 수 있지만 괄호없이 입력 할 수 있습니다 .

설명

$I      Push the length of the input on the stack.
  ?.    If this is 0, stop. Otherwise, continue.

nd        Take number from input and duplicate it.
  ?x      If this number is 0, dump the top of stack.
    dN    Duplicate the top of stack and output as number

Minkolang은 환상적이므로 처음부터 끝까지 반복되어 .멈출 때까지 계속 진행 됩니다.

𝔼𝕊𝕄𝕚𝕟, 7 자 / 12 바이트

ïⓜa=$⋎a

Try it here (Firefox only).

설명

        // implicit: ï = input array
ïⓜ     // map over input
  a=    // set a to:
    $   // (if element is truthy (not 0)) element itself
     ⋎a // else whatever a was set to before
        // implicit output

O , 31 바이트

[[I',T%T/]{n#}d]{n.{:V}{;V}?}d]

이것은로 구분 된 입력을 취하고 ,의 동일한 목록을 출력합니다 [].

7,0,3,0,0,2,-50,0,0 => [7,7,3,3,3,2,-50,-50,-50]

설명:

[] 결과를 배열에 넣습니다
 [I ', T % T /] {n #} d] 숫자 배열로 입력 형식화
                {n. {: V} {; V}?} d 0을 채 웁니다 (아래의 작동 방식 참조).

17 바이트

I~]{n.{:V}{;V}?}d

접미사 표기법을 사용하여 공백으로 구분 된 숫자 목록으로 입력을 받고 한 자리 16 진수 만 처리 할 수 ​​있습니다. 제외 어는 뒤에 접미사가 붙습니다 _.

5 4 0 0 1 0 0 => 5 4 4 4 1 1 1
A 3 0 0 1 B 0 => 10 3 3 3 1 11 11
67* 0 0 78* 0 => 42 42 42 56 56
67*_ 4 3_ 0 0 => -42 4 -3 -3 -3

설명:

I ~] 입력을 정수 배열에 넣습니다
   {} d 입력의 각 숫자에 대해
    n. {; V} {: V}? 숫자가 0이면 V를 누릅니다.
                  그렇지 않은 경우 V를 숫자로 설정하십시오.

R, 39 37 33 바이트

function(x)zoo::na.locf(x*(x|NA))

이것은 벡터를 받아들이고 벡터를 반환하는 명명되지 않은 함수입니다. zoo패키지를 설치 해야합니다 . zoo네임 스페이스를 직접 참조하기 때문에 네임 스페이스에 연결 하지 않아도 됩니다.

통계 세계에서이 작업의 이름은 LOCF 대치입니다. 여기서 LOCF는 Last Observation Carried Forward를 나타냅니다. R에서이를 수행하기 na.locf위해 zoo패키지 에서 사용할 수 있습니다 . 패키지에서 NA값을 마지막으로 알려진 비값으로 바꿉니다 NA. 입력의 0을 NA먼저 s 로 바꿔야합니다 .

이를 위해, 우리는 사용 x|NA이 될 것이다, TRUE때 x != 0와 NA그렇지. 이 값에을 곱 x하면 TRUE요소가의 해당 요소 x와 NAs로 NA대체되어 0이 모두 바뀝니다 . 그런 다음 zoo::na.locf우리에게 원하는 것을 정확하게 전달합니다 .

flodel 덕분에 4 바이트를 절약했습니다!

녹, 100 바이트

fn f(i:&[i64])->Vec<i64>{let(mut o,mut l)=(i.to_vec(),0);
for x in&mut o{if *x==0{*x=l}else{l=*x}};o}

이 도전을 우연히 발견하면서 내가 가장 좋아하는 언어로 시도해 보았습니다. 존재하지 않는[T]::windows_mut() 것을 발견하기 전에 처음에 사용해 보았습니다 . 실제로 이보다 길었을 수도 있습니다. 어쨌든 golfed 녹 매우 추한 매우 경쟁력이없는 것으로 나타났다 (특히 모든 goshdarned esoterics와 함께!) ⁽¹⁾

줄 바꿈은 바이트 수에 포함되지 않습니다. 거기에만 있기 때문에 옆으로 스크롤 할 필요가 없습니다. 코드의 의미는 바뀌지 않습니다.

언 골프 드 :

fn cover_zeroes(input: &[i64]) -> Vec<i64> {
    let mut output = input.to_vec();
    let mut last_nonzero = 0;
    for item in &mut output {
        if *item == 0 {
            *item = last_nonzero;
        }
        else {
            last_nonzero = *item;
        }
    }
    output
}

_{^{[1] 적어도 자바만큼 나쁘지는 않다.}}

은하수 1.2.1 , 33 바이트

:y;=<:&{~<?{0b_^;:3≤_;}1-}^<Ω!

정수 목록이 스택에만 있다고 가정합니다.

설명

:    : :           :              # duplicate the TOS
 y                                # push the length of the TOS
  ;               ;    ;          # swap the TOS and STOS
   =                              # dump a list to the stack
    < <    <                 <    # rotate the stack leftward
        &{~                }      # while loop
            ?{  _     _ }         # if-else statements
              0     3    1        # push an integer
               b                  # == on the TOS and STOS
                 ^          ^     # pop the TOS without output
                     ≤            # rotate the top N stack elements leftward
                          -       # subtract the TOS from the STOS
                              Ω   # push a list made of the top N stack elements
                               !  # output the TOS

줄리아, 33 바이트

g(x,a=0)=[(i!=0&&(a=i);a)for i=x]

이것은 g배열을 받아들이고 배열을 반환하는 함수 입니다. a0에서 임시 변수 를 시작합니다 i. 입력의 각 요소 에 대해 i0이 아닌 경우 에 할당 a합니다 i. 경우 i0이고, a그 반복에서 변경되지 않습니다. a출력 배열에서 해당 위치의 값으로 사용 합니다.

펄 6 , 21 바이트

*.map: {$_=($^a||$_)}

용법:

# store the Whatever lambda as a subroutine
# just so that we don't have to repeat it
my &code = *.map: {$_=($^a||$_)}

say code [1, 0, 2, 0, 7, 7, 7, 0, 5, 0, 0, 0, 9];
# (1 1 2 2 7 7 7 7 5 5 5 5 9)

say [-1, 0, 5, 0, 0, -7].&code;
# (-1 -1 5 5 5 -7)

say ([1, 0, 0, 0, 0, 0],[-1, 0, 5, 0, 0, -7]).map: &code;
# ((1 1 1 1 1 1) (-1 -1 5 5 5 -7))

R, 36 바이트

function(x)x[cummax(seq(a=x)*(!!x))]

이것을 사용하여 어떻게 작동하는지 봅시다 x=

c(1, 0, 2, 0, 7, 7, 7, 0, 5, 0, 0, 0, 9)

예로서. 다음 !!x은 논리 (참 / 거짓) 벡터입니다.

c(T, F, T, F, T, T, T, F, T, F, F, F, T)

또한 다음과 seq(a=x)같은 한 인덱스 벡터를 제공합니다 x.

c(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13)

우리는 둘 다 곱하여 다음을 제공합니다.

c(1, 0, 3, 0, 5, 6, 7, 0, 9, 0, 0, 0, 13)

누적 최대 값을 가져옵니다.

c(1, 1, 3, 3, 5, 6, 7, 7, 9, 9, 9, 9, 13)

마지막으로, 마지막 벡터를 다음과 같이 추출 할 인덱스로 사용합니다 x.

c(1, 1, 2, 2, 7, 7, 7, 7, 5, 5, 5, 5, 9)

CJam, 11 바이트

q~{1$e|}*]p

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

작동 원리

q~             Read and evaluate all input.
  {    }*      Fold; for each element but the first:
   1$e|          Copy the previous element and take their logical OR.
         ]p   Wrap all results in an array and print it.

파워 쉘, 32 바이트

param($x)$x|%{($t=($_,$t)[!$_])}

$x|%{...}의 각 요소에 대해 스크립트 블록을 수행합니다 $x. ($_,$t)전류 및 소자의 배열 $t, 그리고 [!$_]우리가 사용하는 수단이 !$_배열에 인덱스가. 인덱스는 00이 아닌 요소의 1경우 (false), 현재 요소가 0 인 경우 (true)이므로 $t현재 요소 또는 $t입니다. 괄호는 대입 식을 둘러 싸서 값이 방출됩니다. parantheses가 없다면 그것은 단지 "quiet"할당 일 것이다 $t.

Japt , 3 바이트

å!ª

시도 해봐

å!ª     :Implicit input of array
å       :Cumulatively reduce
 !      :Flip the arguments
  ª     :Logical OR