Ispirato da questa domanda SO

Come input ti verrà fornito un elenco non vuoto di numeri interi, in cui il primo valore è garantito essere diverso da zero. Per costruire l'output, cammina dall'inizio della lista, producendo ogni valore diverso da zero lungo la strada. Quando si incontra uno zero, ripetere invece il valore aggiunto più di recente all'output.

È possibile scrivere un programma o una funzione e fare in modo che input / output assumano qualsiasi formato utile che non codifichi informazioni aggiuntive, purché sia ​​ancora una sequenza ordinata di numeri interi. Se viene emesso da un programma, è possibile stampare una nuova riga finale. Fatta eccezione per questa nuova riga finale, l'output dovrebbe essere un input accettabile per l'invio.

Vince il codice più breve in byte.

Casi test

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

mJ|dJQ

Dimostrazione

m ... Qsignifica che questa mappa una funzione sull'input. La funzione da mappare è J|dJ. Ciò significa J = d or Jin Python, poiché Jè implicita assegnata al seguente valore al primo utilizzo. A differenza di Python, le espressioni di assegnazione restituiscono il valore assegnato in Pyth, quindi la mappa restituisce ogni valore successivo di J, come desiderato.

Gelatina , non competitiva

3 byte Questa risposta non è competitiva, poiché utilizza funzionalità che postdatano la sfida.

o@\

Provalo online!

Come funziona

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.

Rubino, 25 byte

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

Questo in realtà è davvero malvagio.

In particolare, lo snippet x==0 ? a : (a=x).

Se avessi usato qualsiasi altro nome di variabile per a(il precedente valore diverso da zero), per così dire, yavrei dovuto dichiararlo al di fuori di map(perché y=xavrebbe solo un ambito all'interno di quella singola mapiterazione). Ciò richiederebbe altri quattro caratteri ( y=0;).

Ma se uso il nome della variabile a... sì, l'hai indovinato. In realtà sto riassegnando all'argomento che abbiamo ricevuto come input (l'array originale).

mapnon importa perché si preoccupa solo del valore originale della cosa su cui viene chiamato, quindi funziona davvero.

Haskell, 21 byte

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

La funzione (anonima) che eseguiamo è nell'ultima riga. Le prime due righe definiscono una funzione di supporto.

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]

La funzione binaria %genera il secondo argomento, a meno che non lo sia 0, nel qual caso invece genera il primo argomento. scanl1itera questa funzione sull'elenco di input, producendo il risultato ad ogni passaggio.

J, 8 byte

{:@-.&0\

Questa è una funzione unaria, invocata come segue.

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

Spiegazione

{:@-.&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$/corrisponde a uno zero su una linea - in tal caso gcopia lo spazio di mantenimento nello spazio del motivo
• h copia lo spazio del motivo nello spazio di attesa

Gli interi sono newline separati. per esempio:

$ 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)

Soluzione semplice, loop in input, assegnazione pall'elemento corrente io a pif iis 0e output.

Esempio di esecuzione (assegnazione della funzione anonima a 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 byte

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

Provalo online.

Sostituisce ripetutamente un numero seguito da uno zero con due volte quel numero fino a quando la stringa smette di cambiare.

Dyalog APL, 12 10 9 byte

(⊃0~⍨,⍨)\

Ispirato dalla risposta J di @ Zgarb.

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

Provalo qui .

Pyth, 8 byte

t.u|YNQ0

Utilizza .u(riduzione cumulativa) di |(Python's or), con il caso base 0.

Python 2, 29 byte

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

Accetta input come numeri indicati uno per riga e output nello stesso formato. Termina con errore dopo aver terminato.

Usando la natura di cortocircuito di or, la variabile xviene aggiornata sull'ingresso, a meno che quell'ingresso sia 0 (che è Falsey), nel qual caso rimane il suo valore corrente. Quindi, xviene stampato. Si noti che poiché il primo valore dell'elenco xè diverso da zero, non viene valutato nella parte destra prima che venga assegnato.

Mathematica 38 byte

La corrispondenza del motivo sostituisce ripetutamente ...a,0,...con...a,a...

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

Matlab, 41 46 byte

Questo si ispira alla mia risposta originale , con le seguenti differenze:

1. Utilizzare l'indicizzazione logica anziché nonzeros.
2. Doppia negazione logica invece di confrontarla con 0.
3. La trasposizione può essere rimossa, poiché il formato di output è flessibile
4. Rimozione di una variabile intermedia.

Grazie a Tom Carpenter per l'articolo 4 e per il suo suggerimento di utilizzare un programma anziché una funzione; insieme questi hanno permesso una riduzione di 5 byte.

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

Esempio:

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

Input e output sono numeri separati da una nuova riga.

Spiegazione:

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

Provalo online qui.

Japt, 8 7 byte

N£U=XªU

Abbastanza semplice. Accetta input separati da virgole. Provalo online!

Ungolfed e spiegazione

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

Versione a 4 byte non competitiva : ( åcomando e !funzione -auto aggiunti dopo la sfida)

Nå!ª

Spiegazione:

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

Provalo online!

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

Qui teniamo semplicemente traccia dell'ultimo diverso da zero e lo inseriamo dove appropriato. Sembra il modo ovvio per farlo.

Prolog (SWI) , 54 byte

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

Provalo online!

Spiegazione

Sono davvero contento di questa risposta.

Innanzitutto diciamo che l'elenco vuoto è la soluzione dell'elenco vuoto:

[]+[].

Quindi diciamo che [X,X|Y]è la soluzione di [X,0|T], se rimuovendo la seconda voce di ciascuna delle soluzioni rimanenti.

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

Infine, diciamo che qualsiasi cosa rimasta è valida se iniziano con lo stesso valore e il resto delle due liste coincide.

Se questa spiegazione non funziona per te, ecco il codice tradotto in Haskell:

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

Provalo online!

GolfScript, 10 byte

~{1$or}*]`

Questo programma prende input da stdin, sotto forma di un array GolfScript letterale (ad es. [1 0 2 0]) E scrive il suo output su stdout nello stesso formato (ad es [1 1 2 2].).

Provalo online.

Una funzione (acquisizione e restituzione di un array GolfScript) sarebbe più lunga di tre byte, a causa della necessità di avvolgerla in un blocco e assegnarla a un simbolo:

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

Naturalmente, se viene contato solo il corpo della funzione (cioè [{1$or}*]), allora posso effettivamente salvare un byte rispetto al programma autonomo.

Minkolang 0,14 , 12 10 byte

$I?.nd?xdN

Provalo qui. L'input può essere dato come nella domanda, ma senza parentesi .

Spiegazione

$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 è toroidale, quindi questo gira intorno all'inizio e continua fino a quando non colpisce .e si ferma.

𝔼𝕊𝕄𝕚𝕟, 7 caratteri / 12 byte

ïⓜa=$⋎a

Try it here (Firefox only).

Spiegazione

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

Ciò accetta un input separato da ,e genera lo stesso elenco in [].

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

Spiegazione:

[] Inserisci il risultato nella matrice
 [I ', T% T /] {n #} d] Formatta l'input in un array di numeri
                {n. {: V} {; V}?} d Compila gli zeri (vedi sotto per come funziona)

17 byte

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

Prende l'input come un elenco di numeri separati da spazi usando la notazione postfix e può gestire solo numeri esadecimali a una cifra. I negativi vengono postfissi con _.

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

Spiegazione:

I ~] Inserisce l'input nell'array intero
   {} d Per ogni numero nell'input
    . N {; V} {V}? Se il numero è 0, premere V
                  In caso contrario, impostare V sul numero

R, 39 37 33 byte

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

Questa è una funzione senza nome che accetta un vettore e restituisce un vettore. Richiede l' zooinstallazione del pacchetto. Si noti che non è necessario zooessere collegati allo spazio dei nomi poiché lo stiamo facendo direttamente riferimento.

Il nome di questa operazione nel mondo della statistica è imputazione LOCF, dove LOCF sta per Last Observation Carried Forward. Per ottenere ciò in R, possiamo usare na.locfdal zoopacchetto, che sostituisce i NAvalori con l'ultimo non NAvalore noto . Non ci resta che sostituire gli zeri nell'input conNAPrima s.

Per fare ciò, usiamo x|NA, che sarà TRUEquando x != 0e NAaltrimenti. Se lo moltiplichiamo per x, gli TRUEelementi vengono sostituiti dagli elementi corrispondenti di xe NArimangono NA, sostituendo così tutti gli zeri. Questo è poi passato a ciò zoo::na.locfche ci dà esattamente quello che vogliamo.

Salvato 4 byte grazie a flodel!

Ruggine, 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}

Mi sono imbattuto in questa sfida, ho pensato di provarlo nella mia lingua preferita. Ho provato a usarlo [T]::windows_mut()all'inizio, prima di scoprire che non esiste . E potrebbe essere stato più lungo di così. Ad ogni modo, si scopre che il golf Rust è molto brutto e non molto competitivo (specialmente con tutti quegli esoterici accidenti!) ¹

La nuova riga non è inclusa nel bytecount; è solo lì, quindi non è necessario scorrere lateralmente. Non cambia il significato del codice.

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] Almeno non è così male come Java.}}

Via Lattea 1.2.1 , 33 byte

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

Ciò presuppone che l'elenco di numeri interi sia solo nello stack.

Spiegazione

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

Questa è una funzione gche accetta un array e restituisce un array. Iniziamo una variabile temporanea asu 0. Per ogni elemento idell'input, se inon è 0, assegniamo aa i. Se iè 0, anon cambia a quell'iterazione. Usiamo acome valore in quella posizione nella matrice di output.

Perl 6 , 21 byte

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

utilizzo:

# 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))]

Vediamo come funziona usando x=

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

come esempio. Qui, !!xsarà il vettore logico (Vero / Falso):

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

Inoltre, seq(a=x)fornisce un vettore di indici purché x:

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

Moltiplichiamo entrambi, dando:

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

Prendiamo il massimo cumulativo:

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

Infine, utilizziamo l'ultimo vettore come indice per estrarre da x:

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

CJam, 11 byte

q~{1$e|}*]p

Provalo online.

Come funziona

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|%{...}fa il blocco di script per ogni elemento in $x. ($_,$t)è una matrice dell'elemento corrente $te [!$_]significa che utilizziamo !$_per indicizzare la matrice. L'indice sarà 0(false) per gli elementi diversi da zero e 1(true) quando l'elemento corrente è zero, quindi $tsarà l'elemento corrente o $t. Le parentesi racchiudono l'espressione di assegnazione in modo che il suo valore sia emesso. Senza paratie sarebbe solo un compito "tranquillo" $t.

Japt , 3 byte

å!ª

Provalo

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