Lấy cảm hứng từ câu hỏi SO này

Là đầu vào, bạn sẽ được cung cấp một danh sách các số nguyên không trống, trong đó giá trị đầu tiên được đảm bảo là khác không. Để xây dựng đầu ra, đi bộ từ đầu danh sách, xuất ra từng giá trị khác không trên đường đi. Khi bạn gặp số 0, thay vào đó hãy lặp lại giá trị bạn đã thêm gần đây nhất vào đầu ra.

Bạn có thể viết chương trình hoặc hàm và yêu cầu đầu vào / đầu ra có bất kỳ định dạng thuận tiện nào không mã hóa thông tin bổ sung, miễn là vẫn là một chuỗi số nguyên theo thứ tự. Nếu xuất ra từ một chương trình, bạn có thể in một dòng mới. Ngoại trừ dòng mới này, đầu ra của bạn phải là đầu vào có thể chấp nhận để gửi.

Mã ngắn nhất tính bằng byte thắng.

Các trường hợp thử nghiệm

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

Bình thường, 6 byte

mJ|dJQ

Trình diễn, thuyết trình

m ... Qcó nghĩa là ánh xạ một chức năng trên đầu vào. Các chức năng được ánh xạ là J|dJ. Điều đó có nghĩa là J = d or Jtrong Python, vì Jhàm ý được gán cho giá trị sau trong lần sử dụng đầu tiên. Không giống như Python, các biểu thức gán trả về giá trị được gán trong Pyth, do đó bản đồ trả về từng giá trị liên tiếp của J, như mong muốn.

Thạch , không cạnh tranh

3 byte Câu trả lời này không cạnh tranh, vì nó sử dụng các tính năng trì hoãn thử thách.

o@\

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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.

Ruby, 25 byte

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

Điều này thực sự là xấu xa.

Cụ thể là đoạn trích x==0 ? a : (a=x).

Nếu tôi đã sử dụng bất kỳ tên biến nào khác cho a(giá trị khác không trước đó), thìletlet sẽ nói ykhai báo bên ngoài map(vì y=xsẽ chỉ có một phạm vi bên trong maplần lặp duy nhất đó ). Điều đó sẽ sử dụng bốn ký tự nhiều hơn ( y=0;).

Nhưng nếu tôi sử dụng tên biến a... yep, bạn đã đoán nó. Tôi thực sự đang gán lại cho đối số mà chúng ta đã nhận làm đầu vào (mảng ban đầu).

mapkhông quan tâm bởi vì nó chỉ quan tâm đến giá trị ban đầu của thứ mà nó được gọi, vì vậy điều này thực sự hoạt động.

Haskell, 21 byte

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

Hàm (ẩn danh) mà chúng ta thực hiện nằm ở dòng cuối cùng. Hai dòng đầu xác định hàm helper.

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]

Hàm nhị phân đưa %ra đối số thứ hai, trừ khi 0, trong trường hợp đó, nó đưa ra đối số thứ nhất thay thế. scanl1Lặp lại chức năng này qua danh sách đầu vào, xuất kết quả ở mỗi bước.

J, 8 byte

{:@-.&0\

Đây là một hàm unary, được gọi như sau.

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

Giải trình

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

Sed, 8

/^0$/g
h

• /^0$/khớp với số 0 trên một dòng - nếu vậy gsao chép không gian giữ vào không gian mẫu
• h sao chép không gian mẫu vào không gian giữ

Số nguyên được phân tách dòng mới. ví dụ:

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

Javascript ES6, 19 byte

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

Giải pháp đơn giản, lặp qua đầu vào, gán pcho phần tử hiện tại ihoặc pnếu ilà 0và xuất nó.

Chạy ví dụ (gán hàm ẩn danh cho 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]

Võng mạc , 15 byte

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

Hãy thử trực tuyến.

Liên tục thay thế một số theo sau là số 0 bằng hai lần số đó cho đến khi chuỗi ngừng thay đổi.

APL Dyalog, 12 10 9 byte

(⊃0~⍨,⍨)\

Lấy cảm hứng từ câu trả lời J của @ Zgarb.

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

Hãy thử nó ở đây .

Bình thường, 8 byte

t.u|YNQ0

Sử dụng .u(giảm tích lũy) bởi |(Python's or), với trường hợp cơ bản 0.

Python 2, 29 byte

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

Lấy đầu vào là số được cung cấp một trên mỗi dòng và đầu ra ở cùng định dạng. Chấm dứt lỗi sau khi kết thúc.

Sử dụng tính chất ngắn mạch của or, biến xđược cập nhật thành đầu vào, trừ khi đầu vào đó là 0 (là Falsey), trong trường hợp đó, nó vẫn giữ nguyên giá trị hiện tại. Sau đó, xđược in. Lưu ý rằng vì giá trị danh sách đầu tiên là khác không, xkhông được đánh giá ở phía bên phải trước khi được gán.

Toán học 38 byte

Khớp mẫu liên tục thay thế ...a,0,...bằng...a,a...

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

Matlab, 41 46 byte

Điều này được truyền cảm hứng trong câu trả lời ban đầu của tôi , với những khác biệt sau:

1. Sử dụng lập chỉ mục logic thay vì nonzeros.
2. Phủ định logic gấp đôi thay vì so sánh với 0.
3. Chuyển đổi có thể được loại bỏ, vì định dạng đầu ra là linh hoạt
4. Loại bỏ một biến trung gian.

Cảm ơn Tom Carpenter cho mục 4 và gợi ý của anh ấy để sử dụng chương trình thay vì chức năng; cùng nhau, chúng cho phép giảm 5 byte.

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

Thí dụ:

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

IE;:Z~:N

Đầu vào và đầu ra là các số phân tách dòng mới.

Giải trình:

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

Hãy thử trực tuyến tại đây.

Japt, 8 7 byte

N£U=XªU

Khá đơn giản. Đưa đầu vào cách nhau bằng dấu phẩy. Hãy thử trực tuyến!

Ung dung và giải thích

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

Phiên bản 4 byte không cạnh tranh : ( ålệnh và !chức năng -auto được thêm vào sau khi thử thách)

Nå!ª

Giải trình:

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

Hãy thử trực tuyến!

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

Ở đây chúng tôi chỉ theo dõi số khác không cuối cùng và đưa nó vào nơi thích hợp. Có vẻ như cách rõ ràng để làm điều đó.

Prolog (SWI) , 54 byte

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

Hãy thử trực tuyến!

Giải trình

Tôi thực sự hạnh phúc với câu trả lời này.

Đầu tiên chúng tôi nói rằng danh sách trống là giải pháp của danh sách trống:

[]+[].

Sau đó, chúng tôi nói rằng đó [X,X|Y]là giải pháp của [X,0|T], nếu bằng cách loại bỏ mục nhập thứ hai của mỗi giải pháp còn lại.

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

Cuối cùng, chúng tôi nói rằng bất kỳ điều gì còn lại là hợp lệ nếu chúng bắt đầu với cùng một giá trị và phần còn lại của hai danh sách khớp với nhau.

Nếu lời giải thích đó không hiệu quả với bạn thì đây là mã được dịch sang Haskell:

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

Hãy thử trực tuyến!

GolfScript, 10 byte

~{1$or}*]`

Chương trình này lấy đầu vào từ stdin, dưới dạng một mảng GolfScript (ví dụ [1 0 2 0]) và ghi đầu ra của nó vào thiết bị xuất chuẩn trong cùng định dạng (ví dụ [1 1 2 2]).

Hãy thử trực tuyến.

Một hàm (lấy và trả về một mảng GolfScript) sẽ dài hơn ba byte, do cần phải bọc nó trong một khối và gán nó vào một ký hiệu:

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

Tất nhiên, nếu chỉ có phần thân hàm (tức là [{1$or}*]) được tính, thì tôi thực sự có thể lưu một byte so với chương trình độc lập.

Chồn 0,14 , 12 10 byte

$I?.nd?xdN

Hãy thử nó ở đây. Đầu vào có thể được đưa ra như trong câu hỏi, nhưng không có dấu ngoặc .

Giải trình

$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 là hình xuyến, do đó, vòng này bắt đầu từ đầu và tiếp tục cho đến khi nó chạm .và dừng lại.

, 7 ký tự / 12 byte

ïⓜa=$⋎a

Try it here (Firefox only).

Giải trình

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

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

Cái này lấy một đầu vào được phân tách bằng ,và xuất ra cùng một danh sách [].

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

Giải trình:

[] Đặt kết quả vào mảng
 [I ', T% T /] {n #} d] Định dạng đầu vào thành mảng số
                {n. {: V} {; V}?} d Điền vào các số không (xem bên dưới để biết cách thức hoạt động của nó)

17 byte

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

Lấy đầu vào dưới dạng danh sách các số được phân tách bằng dấu cách bằng cách sử dụng ký hiệu hậu tố và chỉ có thể xử lý các số thập lục phân một chữ số. Các tiêu cực được hậu tố với _.

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

Giải trình:

I ~] Đưa đầu vào vào mảng số nguyên
   {} d Với mỗi số trong đầu vào
    n. {; V} {: V}? Nếu số là 0, đẩy V
                  Nếu không, đặt V thành số

R, 39 37 33 byte

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

Đây là một hàm không tên, chấp nhận một vectơ và trả về một vectơ. Nó đòi hỏi zoogói phải được cài đặt. Lưu ý rằng nó không cần zoophải được gắn vào không gian tên vì chúng tôi đang tham chiếu trực tiếp.

Tên của hoạt động này trong thế giới thống kê là sự cắt bỏ của LOCF, trong đó LOCF là viết tắt của Quan sát cuối cùng được tiến hành. Để thực hiện điều này trong R, chúng ta có thể sử dụng na.locftừ zoogói, thay thế NAcác giá trị bằng giá trị không được biết đến cuối cùng NA. Chúng ta chỉ cần thay các số không trong đầu vào bằng NAs trước.

Để làm điều đó, chúng tôi sử dụng x|NA, đó sẽ là TRUEkhi x != 0và NAnếu không. Nếu chúng ta nhân số này với x, các TRUEphần tử được thay thế bằng các phần tử tương ứng của xvà NAs NA, do đó thay thế tất cả các số không. Điều này sau đó được chuyển đến zoo::na.locfcho chúng ta chính xác những gì chúng ta muốn.

Đã lưu 4 byte nhờ flodel!

Rust, 100 byte

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ình cờ gặp thử thách này, tôi nghĩ mình sẽ thử nó bằng ngôn ngữ yêu thích của mình. Đã thử sử dụng [T]::windows_mut()lúc đầu, trước khi phát hiện ra rằng nó không tồn tại . Và nó có thể thực sự dài hơn thế này. Dù sao, hóa ra Rust chơi golf rất xấu và rất không cạnh tranh (đặc biệt là với tất cả những người bí truyền bí ẩn!) ¹

Dòng mới không được bao gồm trong bytecount; nó chỉ ở đó để bạn không phải di chuyển sang một bên. Nó không thay đổi ý nghĩa của mã.

Ung dung:

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] Ít nhất nó không tệ như Java.}}

Dải ngân hà 1.2.1 , 33 byte

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

Điều này giả định rằng danh sách các số nguyên chỉ có trên ngăn xếp.

Giải trình

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

Julia, 33 byte

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

Đây là một hàm gchấp nhận một mảng và trả về một mảng. Chúng tôi bắt đầu một biến tạm thời aở 0. Đối với mỗi phần tử icủa đầu vào, nếu ikhông bằng 0 thì chúng tôi gán acho i. Nếu ilà 0, akhông thay đổi ở lần lặp đó. Chúng tôi sử dụng alàm giá trị ở vị trí đó trong mảng đầu ra.

Perl 6 , 21 byte

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

sử dụng:

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

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

Hãy xem cách nó hoạt động bằng cách sử dụng x=

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

làm ví dụ Ở đây, !!xsẽ là vectơ logic (Đúng / Sai):

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

Ngoài ra, seq(a=x)đưa ra một vectơ chỉ số miễn là x:

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

Chúng tôi nhân cả hai, cho:

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

Chúng tôi lấy tối đa tích lũy:

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

Cuối cùng, chúng tôi sử dụng vectơ cuối cùng đó làm chỉ số để trích xuất từ x:

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

CJam, 11 byte

q~{1$e|}*]p

Hãy thử trực tuyến.

Làm thế nào nó hoạt động

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 byte

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

$x|%{...}khối kịch bản cho từng phần tử trong $x. ($_,$t)là một mảng của phần tử hiện tại và $t, và [!$_]có nghĩa là chúng ta sử dụng !$_để lập chỉ mục vào mảng. Chỉ số sẽ là 0(false) cho các phần tử khác không và 1(true) khi phần tử hiện tại bằng 0, do đó $tsẽ là phần tử hiện tại hoặc $t. Các dấu ngoặc bao quanh biểu thức gán để giá trị của nó được phát ra. Nếu không có parantant, nó sẽ chỉ là một nhiệm vụ "yên tĩnh" $t.

Japt , 3 byte

å!ª

Thử nó

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