Bu SO sorusundan esinlenerek

Girdi olarak, ilk değerin sıfır olmadığının garantilendiği boş olmayan bir tamsayı listesi verilecektir. Çıktıyı oluşturmak için, listenin başlangıcından yürüyün, yol boyunca sıfır olmayan her bir değeri çıktı alın. Sıfırla karşılaştığınızda, çıkışa en son eklediğiniz değeri tekrarlayın.

Bir program veya işlev yazabilir ve giriş / çıktının, sıralı bir tamsayı dizisi olduğu sürece, ek bilgileri kodlamayan uygun bir biçime sahip olmasını sağlayabilirsiniz. Bir programdan çıktı alıyorsanız, izleyen bir yeni satır yazdırabilirsiniz. Bu sondaki yeni satır dışında, gönderiminiz gönderiminiz için kabul edilebilir bir girdi olmalıdır.

Bayt cinsinden en kısa kod kazanır.

Test Kılıfları

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

mJ|dJQ

gösteri

m ... Qbunun giriş üzerindeki bir işlevi haritaladığı anlamına gelir. Eşleştirilen işlev şudur J|dJ. Bu J = d or J, Python'da, Jilk kullanımda aşağıdaki değere verilen dolaylılık olduğu anlamına gelir . Python'dan farklı olarak atama ifadeleri Pyth'te atanan değeri döndürür, böylece harita Jistenen her ardışık değeri döndürür .

Jöle , rakipsiz

3 bytes Bu cevap rakipsizdir, çünkü mücadeleyi önleyen özellikleri kullanır.

o@\

Çevrimiçi deneyin!

Nasıl çalışır

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.

Yakut, 25 bayt

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

Bu aslında gerçekten kötü.

Özellikle, snippet x==0 ? a : (a=x).

Eğer başka bir değişken ismi a(önceki sıfır olmayan değer) kullansaydım —let diyelim y- onu dışarda bildirmek zorunda kalırdım map(çünkü y=xbu tek mapyinelemenin sadece bir kapsamı olurdu ). Bu dört karakter daha kullanırdı ( y=0;).

Ama eğer değişken ismini kullanırsam a... evet, tahmin ettin. Aslında girdi olarak aldığımız argümana tekrar atanıyorum (orjinal dizi).

mapumursamıyor çünkü çağrıldığı şeyin orijinal değerini önemsiyor , bu gerçekten işe yarıyor.

Haskell, 21 bayt

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

Yaptığımız (anonim) işlev son satırdadır. İlk iki satır bir yardımcı işlevi tanımlar.

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]

İkili işlev %, ikinci bağımsız değişkenin çıktısını almadıkça 0, bunun yerine ilk bağımsız değişkeni çıkarır. scanl1Her adımda sonucu çıkaran bu fonksiyonu giriş listesi üzerinde yineler.

J, 8 bayt

{:@-.&0\

Bu, aşağıdaki gibi çağrılan unary bir fonksiyondur.

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

açıklama

{:@-.&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$/satırdaki sıfırla eşleşir - öyleyse gtutma alanını kalıp alanına kopyalar
• h desen alanını tutma alanına kopyalar

Tamsayılar yeni satır ayrılmış. Örneğin:

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

Javascript ES6, 19 bayt

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

Basit çözelti, girdi döngü, atama pmevcut elemana iya da peğer ibir 0çıktısı ve.

Örnek çalıştırma (anonim işlev atama 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]

Retina , 15 bayt

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

Çevrimiçi deneyin.

Dize değişmeyi bırakıncaya dek, bir sayı ve ardından sıfır ile bu sayıyı iki kez tekrarlayın.

Dyalog APL, 12 10 9 bayt

(⊃0~⍨,⍨)\

@ Zgarb'ın J cevabından ilham alındı.

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

Burada dene .

Pyth, 8 bayt

t.u|YNQ0

Temel durumda 0 ile, .u(kümülatif azaltma) |(Python ) ile kullanır or.

Python 2,29 bayt

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

Girdiyi her satıra bir tane verilen sayılar olarak alır ve aynı biçimde çıkar. Bitirdikten sonra hata ile son bulur.

' Nın kısa devre yapısına sahip orolan değişken xkullanılarak, giriş 0'a (Falsey) ait değilse, bu durumda mevcut değer olarak kalırsa değişken girişe güncellenir. Ardından, xyazdırılır. İlk liste değeri sıfır xolmadığından, atanmadan önce sağ tarafta değerlendirilmediğini unutmayın.

Mathematica 38 bayt

Desen eşleştirme defalarca değiştirir ...a,0,...ile...a,a...

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

Matlab, 41 46 bayt

Bu benim asıl cevabımdan ilham alıyor , aşağıdaki farklılıklar:

1. Bunun yerine mantıksal indeksleme kullanın nonzeros.
2. Karşılaştırma yapmak yerine çift mantıksal olumsuzlama 0.
3. Çıktı formatı esnek olduğundan transpozisyon kaldırılabilir
4. Bir ara değişkeni kaldırmak.

Sayesinde Tom Carpenter madde 4'e için ve bunun yerine bir fonksiyonun bir programı kullanmak için yaptığı öneri için; birlikte bunlar 5 baytlık bir azalmaya izin verdi.

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

Örnek:

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

IE;:Z~:N

Giriş ve çıkış, yeni satırlarla ayrılmış sayılardır.

Açıklama:

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

Burada çevrimiçi deneyin.

Japt, 8 7 bayt

N£U=XªU

Oldukça basit. Virgüllerle ayırarak girişi alır. Çevrimiçi deneyin!

Ungolfed ve açıklama

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

Rekabet etmeyen 4 bayt sürüm: ( meydan okumadan sonra åkomut ve !-auto-işlevi eklendi)

Nå!ª

Açıklama:

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

Çevrimiçi deneyin!

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

Burada son sıfırı olmayanları takip ediyoruz ve uygun olan yerlerde itiyoruz. Bunu yapmanın bariz yolu gibi görünüyor.

Prolog (SWI) , 54 bayt

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

Çevrimiçi deneyin!

açıklama

Bu cevaptan gerçekten çok memnunum.

İlk önce boş listenin boş listenin çözümü olduğunu söylüyoruz:

[]+[].

Öyleyse , kalan çözümlerin her birinin ikinci girişini kaldırarak [X,X|Y]çözümün bu olduğunu söylüyoruz [X,0|T].

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

Son olarak, geriye kalan herhangi bir şeyin aynı değerle başlarsa geçerli olduğunu ve iki listenin geri kalanının birbiriyle eşleştiğini söylüyoruz.

Bu açıklama sizin için çalışmıyorsa, burada Haskell'e çevrilmiş olan kod:

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

Çevrimiçi deneyin!

GolfScript, 10 bayt

~{1$or}*]`

Bu program, bir GolfScript dizisi değişmezi biçiminde (örn. [1 0 2 0]) Stdin'den girdi alır ve çıktısını aynı biçimde (örneğin [1 1 2 2]) stdout'a yazar .

Çevrimiçi deneyin.

Bir işlev (bir GolfScript dizisini alıp geri döndürme) bir bloğa sarılması ve bir sembole ataması gerekmesi nedeniyle üç bayt daha uzun olacaktır.

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

Tabii ki, sadece işlev gövdesi (yani [{1$or}*]) sayılırsa, o zaman tek başına programa kıyasla aslında bir byte tasarruf edebilirim.

Minkolang 0.14 , 12 10 bayt

$I?.nd?xdN

Burada dene. Giriş soruda olduğu gibi ancak parantez olmadan verilebilir .

açıklama

$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 toroidaldir, bu yüzden baştan başa dolanır ve çarpıp .duruncaya kadar devam eder .

7, 7 karakter / 12 bayt

ïⓜa=$⋎a

Try it here (Firefox only).

açıklama

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

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

Bu ayrılan bir girişi alır ,ve içindeki aynı listeyi çıkarır [].

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

Açıklama:

[] Sonuç diziye yerleştir
 [I ', T% T /] {n #} d] Girdiyi sayı dizisine biçimlendirin
                {n. {: V} {; V}?} d Sıfırları doldurun (nasıl çalıştığını görmek için aşağıya bakın)

17 bayt

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

Girdiyi, postfix notasyonu kullanılarak boşluklarla ayrılmış sayılar listesi olarak alır ve yalnızca tek haneli onaltılık sayıları idare edebilir. Negatifler eklenmiştir _.

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

Açıklama:

I ~] Girişi tamsayı dizisine yerleştirir
   {} d Girişteki her numara için
    N. {V} {: H}? Sayı 0 ise, V tuşuna basın.
                  Değilse, V'yi sayıya ayarlayın.

R, 39 37 33 bayt

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

Bu, bir vektörü kabul eden ve bir vektörü döndüren adlandırılmamış bir fonksiyondur. zooPaketin kurulmasını gerektirir . zooDoğrudan referans verdiğimiz için ad alanına eklenmesinin gerekmediğini unutmayın .

İstatistik dünyasındaki bu işlemin adı, LOCF'un Son Gözlemlenen İleri Yönlendirme anlamına geldiği LOCF impurasyonu. Bunu R'de gerçekleştirmek na.locfiçin zoo, NAdeğerleri bilinen son NAdeğer olmayan değerlerle değiştiren paketten kullanabiliriz . Girişteki sıfırları NAilk önce s ile değiştirmeliyiz .

Bunu yapmak için, ne zaman ve ne zaman x|NAolacağını kullanacağız . Bunu çarparsak , elemanlar karşılık gelen elemanlar ve s ile değiştirilir, böylece tüm sıfırlar değiştirilir. Bu daha sonra geçirilir ve bu bize tam olarak ne istediğimizi verir.TRUEx != 0NAxTRUExNANAzoo::na.locf

Flodel sayesinde 4 byte kurtarıldı!

Pas, 100 bayt

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}

Bu meydan okumaya rastladım, en sevdiğim dilde deneyeceğimi düşündüm. Kullanılarak çalıştı [T]::windows_mut()dikkat bulmadan, ilk başta o yok . Ve aslında bundan daha uzun olabilirdi. Neyse, golf pas Rust çok çirkin ve çok rekabetçi olmayan (özellikle tüm bu ezberler ezoterik!) ¹

Newline bytecount'ta yer almıyor; sadece orada, bu yüzden yanlara kaydırmak zorunda kalmazsınız. Kodun anlamını değiştirmez.

Ungolfed:

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] En azından Java kadar kötü değil.}}

Samanyolu 1.2.1 , 33 bayt

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

Bu, tamsayı listesinin yalnızca yığında olduğunu varsayar.

açıklama

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

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

Bu, bir gdiziyi kabul eden ve bir dizi döndüren bir işlevdir . Biz geçici bir değişken başlamak aher bir öğe için 0'dan ieğer girdi io zaman atamak 0 değildir aiçin i. Eğer i0 ise, ao tekrarda değişmez. aÇıkış dizisindeki o pozisyondaki değer olarak kullanıyoruz .

Perl 6 , 21 bayt

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

kullanımı:

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

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

Bunun nasıl çalıştığını görelim. x=

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

Örnek olarak. İşte, !!xmantıksal (Doğru / Yanlış) vektörü olacaktır:

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

Ayrıca, seq(a=x)sürece bir indeks vektörü verir x:

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

İkisini de çarparak şöyle veririz:

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

Biriktirilen azami değeri alıyoruz:

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

Son olarak, bu son vektörü çıkarılacak endeksler olarak kullanırız x:

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

CJam, 11 bayt

q~{1$e|}*]p

Çevrimiçi deneyin.

Nasıl çalışır

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 bayt

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

$x|%{...}içindeki her eleman için script bloğunu yapar $x. ($_,$t)mevcut elemanı ve bir dizidir $tve [!$_]kullandığımız bu aygıtın !$_diziye indeksine. Dizin, 0sıfır olmayan elemanlar için (false) ve 1geçerli eleman sıfır olduğunda (true) olur, yani $tya geçerli eleman ya da $t. Parantezler atama ifadesini çevreler, böylece değeri yayar. Parantez olmadan sadece "sessiz" bir atama olurdu $t.

Japt , 3 bayt

å!ª

Dene

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