このSO質問に触発された

入力として、整数の空でないリストが与えられます。最初の値は非ゼロであることが保証されています。出力を作成するには、リストの先頭から歩いて、ゼロ以外の各値を途中まで出力します。ゼロが発生した場合は、代わりに、最後に出力に追加した値を繰り返します。

整数の順序付けされたシーケンスである限り、プログラムまたは関数を作成し、追加情報をエンコードしない便利な形式を入出力に使用させることができます。プログラムから出力する場合、末尾の改行を印刷できます。この末尾の改行を除いて、出力は送信のための許容可能な入力である必要があります。

バイト単位の最短コードが優先されます。

テストケース

[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ため、Pythonで、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（以前のゼロ以外の値）に他の変数名を使用した場合（たとえばy、その外部で宣言する必要がありますmap（y=xその単一のmap反復内のスコープしか持たないため）。それはさらに4文字を使用します（y=0;）。

しかし、変数名を使用するとa...うん、あなたはそれを推測しました。実際に、入力として取得した引数（元の配列）に再割り当てしています。

map呼び出されるものの元の値のみを考慮するため、気にしません。したがって、これは実際に機能します。

Haskell、21バイト

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

作成する（匿名）関数は最後の行にあります。最初の2行は、ヘルパー関数を定義します。

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]

バイナリ関数%は、の場合を除き、2番目の引数を0出力します。その場合、代わりに1番目の引数を出力します。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$/行のゼロに一致します-そうであればg、ホールドスペースをパターンスペースにコピーします
• h パターンスペースをホールドスペースにコピーします

整数は改行で区切られます。例えば：

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

Javascript 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

オンラインでお試しください。

文字列の変化が止まるまで、数字の後にゼロが続く数字をその数字の2倍に繰り返し置き換えます。

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

（Pythonの.u）による（累積的な縮小）を使用し、ベースケース0を使用します。|or

Python 2、29バイト

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

入力を1行に1つずつ与えられた数値として受け取り、同じ形式で出力します。終了後、エラーで終了します。

の短絡性を使用して、入力が0（Falsy）でない限りor、変数xは入力に更新されます。その場合、変数は現在の値のままです。その後、x印刷されます。最初のリスト値はゼロで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、および関数の代わりにプログラムを使用することを提案してくれた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

こちらからオンラインでお試しください。

Japt、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バイトバージョン：（チャレンジ後にåコマンドと!-auto-functionが追加されました）

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

オンラインでお試しください！

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

ここでは、最後の非ゼロを追跡し、必要に応じて押し込みます。それをする明白な方法のように思えます。

プロローグ（SWI）、54バイト

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

オンラインでお試しください！

説明

私はこの答えに本当に満足しています。

最初に、空のリストは空のリストの解であると言います。

[]+[].

次に、残りの各ソリューションの2番目のエントリを削除することにより[X,X|Y]、のソリューションであると言い[X,0|T]ます。

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

最後に、同じ値で始まり、2つのリストの残りが互いに一致する場合、残ったものはすべて有効であると言います。

この説明が役に立たない場合は、コードがHaskellに翻訳されています。

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

オンラインでお試しください！

GolfScript、10バイト

~{1$or}*]`

このプログラムは、GolfScript配列リテラル（例：）の形式で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ゼロを埋めます（この仕組みについては以下を参照してください）

17バイト

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

入力を後置記法を使用してスペースで区切られた数字のリストとして受け取り、1桁の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で置き換えるパッケージから使用できます。入力のゼロを最初にs に置き換えるだけです。NANANA

これを行うには、我々が使用x|NAされる、TRUEときx != 0とNAそうでありません。これにを掛けるxと、TRUE要素はの対応する要素に置き換えられx、NAsはに留まりNA、それによってすべてのゼロが置き換えられます。次に、これが渡され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()知る前に、最初に使用してみました。そして、実際にはこれよりも長いかもしれません。とにかく、ゴルフされたRustは非常にく、非常に競争力のないものであることがわかります（特に、すべてのゴシュダードの難解なもので！）¹

改行はバイトカウントに含まれません。そこにあるだけなので、横にスクロールする必要はありません。コードの意味は変わりません。

ゴルフをしていない：

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]少なくともJavaほど悪くはありません。}}

天の川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配列を受け入れて配列を返す関数です。私たちは、一時変数を開始するa各要素について、0でiあれば、入力のi後、私たちが割り当て0ではありませんaしi。iが0の場合a、その繰り返しで変化しません。a出力配列のその位置の値として使用します。

Perl 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、論理（True / False）ベクトルになります。

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.

Powershell、32バイト

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

$x|%{...}の各要素に対してスクリプトブロックを実行し$xます。($_,$t)現在の要素の配列であると$t、そして[!$_]私たちが使用することを意味!$_配列のインデックスに。インデックスは0、非ゼロ要素の1場合は（false）、現在の要素がゼロの場合は（true）に$tなるため、現在の要素またはのいずれかになります$t。括弧は割り当て式を囲み、その値が出力されます。パラセシスがなければ、それは単に「静かな」課題になり$tます。

Japt、3 バイト

å!ª

それを試してみてください

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