Inspiriert von dieser SO-Frage

Als Eingabe erhalten Sie eine nicht leere Liste mit ganzen Zahlen, wobei der erste Wert garantiert ungleich Null ist. Gehen Sie zum Erstellen der Ausgabe vom Anfang der Liste aus, und geben Sie dabei jeden Wert ungleich Null aus. Wenn Sie auf eine Null stoßen, wiederholen Sie stattdessen den Wert, den Sie zuletzt zur Ausgabe hinzugefügt haben.

Sie können ein Programm oder eine Funktion schreiben und die Ein- / Ausgabe in ein beliebiges Format bringen, das keine zusätzlichen Informationen codiert, solange es sich um eine geordnete Folge von ganzen Zahlen handelt. Wenn Sie von einem Programm ausgeben, können Sie eine abschließende neue Zeile drucken. Abgesehen von dieser nachgestellten Zeile sollte Ihre Ausgabe eine akzeptable Eingabe für Ihre Einreichung sein.

Der kürzeste Code in Bytes gewinnt.

Testfälle

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

mJ|dJQ

Demonstration

m ... QDies bedeutet, dass dem Eingang eine Funktion zugeordnet wird. Die zugeordnete Funktion lautet J|dJ. Dies bedeutet J = d or Jin Python, da Jbei der ersten Verwendung dem folgenden Wert implizit zugewiesen wird. Im Gegensatz zu Python geben Zuweisungsausdrücke den in Pyth zugewiesenen Wert zurück, sodass die Map nach Bedarf jeden nachfolgenden Wert von zurückgibt J.

Gelee , nicht konkurrierend

3 Bytes Diese Antwort ist nicht konkurrierend, da sie Funktionen verwendet, die die Herausforderung nachholen.

o@\

Probieren Sie es online!

Wie es funktioniert

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 Bytes

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

Das ist wirklich böse.

Insbesondere das Snippet x==0 ? a : (a=x).

Wenn ich einen anderen Variablennamen für a(den vorherigen Wert ungleich Null) verwendet hätte - sagen wir mal -, ymüsste ich ihn außerhalb von deklarieren map(weil er y=xnur einen Gültigkeitsbereich innerhalb dieser einzelnen mapIteration hätte). Das würde vier Zeichen mehr verbrauchen ( y=0;).

Aber wenn ich den Variablennamen abenutze ... ja, Sie haben es erraten. Ich ordne das Argument, das wir als Eingabe erhalten haben (das ursprüngliche Array), neu zu.

mapist egal, weil es nur um den ursprünglichen Wert der Sache geht, auf die es angerufen wird, also funktioniert dies tatsächlich.

Haskell, 21 Bytes

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

Die (anonyme) Funktion, die wir ausführen, steht in der letzten Zeile. Die ersten beiden Zeilen definieren eine Hilfsfunktion.

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]

Die Binärfunktion %gibt das zweite Argument aus, sofern dies nicht 0der Fall ist. In diesem Fall wird stattdessen das erste Argument ausgegeben. scanl1Durchläuft diese Funktion die Eingabeliste und gibt das Ergebnis bei jedem Schritt aus.

J, 8 Bytes

{:@-.&0\

Dies ist eine unäre Funktion, die wie folgt aufgerufen wird.

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

Erläuterung

{:@-.&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$/Stimmt mit einer Null in einer Zeile überein - wenn dies gder Fall ist, wird der Haltebereich in den Musterbereich kopiert
• h kopiert den Pattern Space in den Hold Space

Ganzzahlen werden durch Zeilenvorschub getrennt. z.B:

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

Javascript ES6, 19 Bytes

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

Einfache Lösung, eine Schleife durch Eingabe assign paktuelles Element ioder pwenn iist 0und gibt es.

Beispiellauf (Zuweisen einer anonymen Funktion an 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]

Netzhaut , 15 Bytes

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

Probieren Sie es online aus.

Ersetzt wiederholt eine Zahl gefolgt von einer Null durch die doppelte Zahl, bis sich die Zeichenfolge nicht mehr ändert.

Dyalog APL, 12 10 9 Bytes

(⊃0~⍨,⍨)\

Inspiriert von @ Zgarbs J-Antwort.

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

Probieren Sie es hier aus .

Pyth, 8 Bytes

t.u|YNQ0

Verwendet .u(kumulativ reduzieren) von |(Python or), mit Basisfall 0.

Python 2, 29 Bytes

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

Nimmt die Eingabe als eine Zahl pro Zeile und gibt sie im gleichen Format aus. Beendet mit Fehler nach Abschluss.

Unter Verwendung der Kurzschlusscharakteristik von orwird die Variable xauf den Eingang aktualisiert, es sei denn, dieser Eingang ist 0 (was Falsey ist). In diesem Fall bleibt er auf seinem aktuellen Wert. Dann xwird gedruckt. Da der erste Listenwert ungleich Null ist, xwird er vor der Zuweisung nicht auf der rechten Seite ausgewertet.

Mathematica 38 Bytes

Pattern - Matching ersetzt wiederholt ...a,0,...mit...a,a...

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

Matlab, 41 46 Bytes

Dies ist inspiriert von meiner ursprünglichen Antwort , mit den folgenden Unterschieden:

1. Verwenden Sie stattdessen die logische Indizierung nonzeros.
2. Doppelte logische Negation statt Vergleich mit 0.
3. Die Transponierte kann entfernt werden, da das Ausgabeformat flexibel ist
4. Zwischenvariable entfernen.

Vielen Dank an Tom Carpenter für Punkt 4 und für seinen Vorschlag, ein Programm anstelle einer Funktion zu verwenden. zusammen erlaubten diese eine Reduzierung von 5 Bytes.

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

Beispiel:

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

IE;:Z~:N

Eingabe und Ausgabe sind durch Zeilenumbrüche getrennte Zahlen.

Erläuterung:

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

Probieren Sie es hier online aus.

Japt, 8 7 Bytes

N£U=XªU

Ziemlich einfach. Nimmt die Eingabe durch Kommas getrennt. Probieren Sie es online!

Ungolfed und Erklärung

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

Nicht konkurrierende 4-Byte- Version: ( åBefehl und !Auto-Funktion nach Challenge hinzugefügt)

Nå!ª

Erläuterung:

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

Probieren Sie es 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;}

Hier verfolgen wir nur den letzten Wert ungleich Null und schieben ihn gegebenenfalls ein. Scheint der naheliegende Weg zu sein.

Prolog (SWI) , 54 Bytes

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

Probieren Sie es online!

Erläuterung

Ich bin sehr zufrieden mit dieser Antwort.

Zuerst sagen wir, dass die leere Liste die Lösung der leeren Liste ist:

[]+[].

Dann sagen wir, das [X,X|Y]ist die Lösung von [X,0|T], wenn durch Entfernen des zweiten Eintrags jeder der verbleibenden Lösungen.

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

Zuletzt sagen wir, dass alles, was übrig bleibt, gültig ist, wenn es mit demselben Wert beginnt und der Rest der beiden Listen miteinander übereinstimmt.

Wenn diese Erklärung für Sie nicht funktioniert, finden Sie hier den in Haskell übersetzten Code:

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

Probieren Sie es online!

GolfScript, 10 Bytes

~{1$or}*]`

Dieses Programm nimmt die Eingabe von stdin in Form eines GolfScript-Array-Literal (z. B. [1 0 2 0]) entgegen und schreibt die Ausgabe im gleichen Format (z [1 1 2 2]. B. ) auf stdout .

Probieren Sie es online aus.

Eine Funktion (die ein GolfScript-Array annimmt und zurückgibt) wäre drei Byte länger, da sie in einen Block eingeschlossen und einem Symbol zugewiesen werden muss:

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

Natürlich, wenn nur die Funktion Körper (dh [{1$or}*]) gezählt wird, dann kann ich tatsächlich speichert ein Byte in das Stand-alone - Programm verglichen.

Minkolang 0.14 , 12 10 Bytes

$I?.nd?xdN

Probieren Sie es hier aus. Die Eingabe kann wie in der Frage erfolgen, jedoch ohne Klammern .

Erläuterung

$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 ist toroidal, so dass es sich an den Anfang dreht und so lange weitergeht, bis es auf das Tor trifft .und aufhört.

𝔼𝕊𝕄𝕚𝕟 7 Zeichen / 12 Bytes

ïⓜa=$⋎a

Try it here (Firefox only).

Erläuterung

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

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

Dies nimmt eine durch getrennte Eingabe ,und gibt dieselbe Liste in aus [].

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

Erläuterung:

[] Füge das Ergebnis in das Array ein
 [I ', T% T /] {n #} d] Formatiert die Eingabe in ein Array von Zahlen
                {n. {: V} {; V}?} d Füllen Sie Nullen aus (siehe unten, wie das funktioniert)

17 Bytes

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

Nimmt Eingaben als Liste von Zahlen entgegen, die durch Leerzeichen in der Postfix-Notation getrennt sind, und kann nur einstellige hexadezimale Zahlen verarbeiten. Negative werden mit postfixiert _.

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

Erläuterung:

I ~] Setzt die Eingabe in ein ganzzahliges Array
   {} d Für jede Zahl in der Eingabe
    n. {; V} {: V}? Wenn die Zahl 0 ist, drücken Sie V
                  Wenn nicht, setzen Sie V auf die Nummer

R 39 37 33 Bytes

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

Dies ist eine unbenannte Funktion, die einen Vektor akzeptiert und einen Vektor zurückgibt. Das zooPaket muss installiert sein. Beachten Sie, dass es nicht zooan den Namespace angehängt werden muss, da wir direkt darauf verweisen.

Der Name für diese Operation in der Welt der Statistik lautet LOCF-Imputation, wobei LOCF für Last Observation Carried Forward steht. Um dies in R zu erreichen, können wir na.locfaus dem zooPaket verwenden, das NAWerte durch den letzten bekannten Nicht- NAWert ersetzt. Wir müssen nur zuerst die Nullen in der Eingabe durch NAs ersetzen .

Dazu verwenden wir x|NA, was TRUEwann x != 0und NAansonsten sein wird. Wenn wir dies mit multiplizieren x, werden die TRUEElemente durch die entsprechenden Elemente von xund der NAs-Verbleib ersetzt NA, wodurch alle Nullen ersetzt werden. Dies wird dann weitergegeben, zoo::na.locfwas uns genau das gibt, was wir wollen.

4 Bytes gespart dank flodel!

Rust, 100 Bytes

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}

Stolperte über diese Herausforderung und dachte, ich würde es in meiner Lieblingssprache versuchen. Versucht [T]::windows_mut()zuerst mit, bevor herausgefunden wird, dass es nicht existiert . Und es könnte tatsächlich länger gewesen sein. Wie auch immer, es stellt sich heraus, dass Golf Rust sehr hässlich und nicht wettbewerbsfähig ist (besonders bei all diesen Esoterikern!) ¹

Die Newline ist nicht im bytecount enthalten. Es ist nur dort, damit Sie nicht seitwärts scrollen müssen. Es ändert nichts an der Bedeutung des Codes.

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] Zumindest ist es nicht so schlimm wie Java.}}

Milchstraße 1.2.1 , 33 Bytes

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

Dies setzt voraus, dass sich die Liste der Ganzzahlen ausschließlich auf dem Stapel befindet.

Erläuterung

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

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

Dies ist eine Funktion g, die ein Array akzeptiert und ein Array zurückgibt. Wir beginnen eine temporäre Variable abei 0. Wenn für jedes Element ider Eingabe inicht 0 angegeben ist, weisen wir azu i. Wenn i0 ist, aändert sich bei dieser Iteration nichts. Wir verwenden aals Wert an dieser Position im Ausgabearray.

Perl 6 , 21 Bytes

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

Verwendungszweck:

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

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

Mal sehen, wie das mit funktioniert x=

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

als Beispiel. Hier !!xwird der logische (Richtig / Falsch) Vektor sein:

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

Außerdem seq(a=x)gibt einen Vektor von Indizes, solange x:

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

Wir multiplizieren beide und geben:

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

Wir nehmen das kumulative Maximum:

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

Schließlich verwenden wir diesen letzten Vektor als Index, um aus Folgendem zu extrahieren x:

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

CJam, 11 Bytes

q~{1$e|}*]p

Probieren Sie es online aus.

Wie es funktioniert

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 Bytes

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

$x|%{...}Blockiert das Skript für jedes Element in $x. ($_,$t)ist ein Array des aktuellen Elements und $tund [!$_]bedeutet, dass wir es verwenden, !$_um in das Array zu indexieren. Der Index ist 0(false) für Elemente ungleich Null und 1(true), wenn das aktuelle Element Null ist. Dies gilt $tentweder für das aktuelle Element oder $t. Die Klammern umgeben den Zuweisungsausdruck, sodass sein Wert ausgegeben wird. Ohne Klammern wäre es nur eine "leise" Aufgabe $t.

Japt , 3 Bytes

å!ª

Versuch es

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