Inspiré par cette question SO

En entrée, vous recevrez une liste d'entiers non vide, dans laquelle la première valeur est garantie différente de zéro. Pour construire la sortie, parcourez le début de la liste en indiquant chaque valeur différente de zéro. Lorsque vous rencontrez un zéro, répétez la valeur que vous avez récemment ajoutée à la sortie.

Vous pouvez écrire un programme ou une fonction et faire en sorte que les entrées / sorties prennent tout format approprié qui ne code pas d’informations supplémentaires, tant qu’il s’agit toujours d’une séquence ordonnée d’entiers. Si vous sortez d'un programme, vous pouvez imprimer une nouvelle ligne. Excepté cette fin de ligne, votre sortie doit être une entrée acceptable pour votre soumission.

Le code le plus court en octets gagne.

Cas de 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 octets

mJ|dJQ

Manifestation

m ... Qsignifie que cela mappe une fonction sur l'entrée. La fonction en cours de mappage est J|dJ. Cela signifie J = d or Jen Python, puisque Jimplicity est affecté à la valeur suivante lors de la première utilisation. Contrairement à Python, les expressions d’affectation renvoient la valeur affectée dans Pyth. La carte renvoie donc chaque valeur successive de J, comme souhaité.

Gelée , non en compétition

3 octets Cette réponse est sans concurrence, car elle utilise des fonctionnalités postérieures au défi.

o@\

Essayez-le en ligne!

Comment ça marche

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 octets

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

Ceci est en réalité vraiment mauvais.

Plus précisément, l'extrait de code x==0 ? a : (a=x).

Si j'avais utilisé un autre nom de variable pour a(la valeur différente de zéro précédente) y- disons - je devrais la déclarer en dehors de map(car y=xseule l'étendue serait à l'intérieur de cette seule mapitération). Cela utiliserait quatre caractères plus ( y=0;).

Mais si j'utilise le nom de la variable a... oui, vous l'avez deviné. En fait, je réassigne l'argument que nous avons obtenu en entrée (le tableau d'origine).

maps'en moque, car il ne s'intéresse qu'à la valeur initiale de la chose sur laquelle il est appelé, donc cela fonctionne réellement.

Haskell, 21 octets

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

La fonction (anonyme) que nous faisons est dans la dernière ligne. Les deux premières lignes définissent une fonction d'assistance.

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 fonction binaire %génère le deuxième argument, à moins que ce ne soit le cas 0, auquel cas elle renvoie le premier argument. scanl1itère cette fonction sur la liste d'entrée, en affichant le résultat à chaque étape.

J, 8 octets

{:@-.&0\

C'est une fonction unaire, invoquée comme suit.

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

Explication

{:@-.&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$/correspond à un zéro sur une ligne - si c'est le cas, gcopie l'espace de maintien dans l'espace du motif
• h copie le motif dans l'espace de cale

Les entiers sont séparés par une nouvelle ligne. par exemple:

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

Javascript ES6, 19 octets

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

Solution simple, boucle à travers l' entrée, assigner pà l' élément actuel iou psi iest 0et la sortie elle.

Exemple d'exécution (attribution d'une fonction anonyme à 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 octets

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

Essayez-le en ligne.

Remplace de manière répétée un nombre suivi d'un zéro par deux fois ce nombre jusqu'à ce que la chaîne cesse de changer.

Dyalog APL, 12 10 9 octets

(⊃0~⍨,⍨)\

Inspiré par la réponse J de @ Zgarb.

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

Essayez ici .

Pyth, 8 octets

t.u|YNQ0

Utilisations .u(réduction cumulative) de |(Python or), avec le cas de base 0.

Python 2, 29 octets

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

Prend les entrées sous forme de nombres, un par ligne, et les sorties dans le même format. Se termine avec une erreur après avoir terminé.

En utilisant la nature de court-circuitage de or, la variable xest mise à jour vers l'entrée, sauf si cette entrée est 0 (qui est Falsey), auquel cas elle reste sa valeur actuelle. Ensuite, xest imprimé. Notez que, comme la première valeur de la liste est différente de zéro, xn’est pas évaluée dans le côté droit avant son affectation.

Mathematica 38 octets

La correspondance de modèle remplace de manière répétée ...a,0,...par...a,a...

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

Matlab, 41 ans 46 octets

Ceci est inspiré de ma réponse originale , avec les différences suivantes:

1. Utiliser l'indexation logique au lieu de nonzeros .
2. Double négation logique au lieu de comparer avec 0 .
3. La transposition peut être supprimée car le format de sortie est flexible
4. Supprimer une variable intermédiaire.

Merci à Tom Carpenter pour le point 4 et pour sa suggestion d’utiliser un programme au lieu d’une fonction; ensemble, ils ont permis une réduction de 5 octets.

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

Exemple:

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

IE;:Z~:N

L'entrée et la sortie sont des nombres séparés par une nouvelle ligne.

Explication:

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

Essayez-le en ligne ici.

Japt, 8 7 octets

N£U=XªU

Assez simple. Prend les entrées séparées par des virgules.Essayez-le en ligne!

Ungolfed et explication

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

Version non concurrente de 4 octets : ( åcommande et !-auto-function ajoutés après le challenge)

Nå!ª

Explication:

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

Essayez-le en ligne!

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

Ici, nous ne faisons que garder une trace du dernier non nul et le fourrer là où il convient. Cela semble être le moyen évident de le faire.

Prolog (SWI) , 54 octets

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

Essayez-le en ligne!

Explication

Je suis vraiment content de cette réponse.

On dit d'abord que la liste vide est la solution de la liste vide:

[]+[].

Ensuite, nous disons que [X,X|Y]c'est la solution de [X,0|T], si en supprimant la deuxième entrée de chacune des solutions restantes.

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

Enfin, nous disons que tout ce qui reste est valable s’il commence par la même valeur et que le reste des deux listes se correspondent.

Si cette explication ne vous convient pas, le code traduit en Haskell:

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

Essayez-le en ligne!

GolfScript, 10 octets

~{1$or}*]`

Ce programme prend les entrées de stdin, sous la forme d'un littéral de tableau GolfScript (par exemple [1 0 2 0]), et écrit sa sortie sur stdout dans le même format (par exemple [1 1 2 2]).

Essayez-le en ligne.

Une fonction (prendre et renvoyer un tableau GolfScript) aurait trois octets de plus, en raison de la nécessité de l'envelopper dans un bloc et de l'attribuer à un symbole:

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

Bien sûr, si seul le corps de la fonction (c'est-à-dire [{1$or}*]) est compté, je peux réellement économiser un octet par rapport au programme autonome.

Minkolang 0,14 , 12 10 octets

$I?.nd?xdN

Essayez ici.Les entrées peuvent être données comme dans la question, mais sans crochets .

Explication

$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 est toroïdal, donc cela tourne en boucle jusqu'au début et continue jusqu'à ce qu'il atteigne .et s'arrête.

, 7 caractères / 12 octets

ïⓜa=$⋎a

Try it here (Firefox only).

Explication

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

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

Cela prend une entrée séparée par ,et affiche la même liste dans [].

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

Explication:

[] Mettre le résultat dans un tableau
 [I ', T% T /] {n #} d] Formatez l'entrée dans un tableau de nombres
                {n. {: V} {; V}?} d Complétez les zéros (voir ci-dessous comment cela fonctionne)

17 octets

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

Prend la saisie comme une liste de nombres séparés par des espaces en utilisant la notation postfixe et ne peut gérer que des nombres hexadécimaux à un chiffre. Les négatifs sont postfixés avec _.

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

Explication:

I ~] Met l'entrée dans un tableau entier
   {} d Pour chaque numéro de l'entrée
    n. {; V} {: V}? Si le nombre est 0, appuyez sur V
                  Si non, définissez V sur le nombre

R, 39 37 33 octets

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

C'est une fonction non nommée qui accepte un vecteur et renvoie un vecteur. Le zoopaquet doit être installé. Notez qu'il n'est pas nécessaire zood'être attaché à l'espace de noms puisque nous le référençons directement.

Le nom de cette opération dans le monde des statistiques est l'imputation LOCF, où LOCF signifie «Dernière observation reportée». Pour ce faire dans R, nous pouvons utiliser na.locfle zoopackage, qui remplace les NAvaleurs par la dernière non- NAvaleur connue . Il suffit de remplacer les zéros dans l’entrée par NAs en premier.

Pour ce faire, nous utilisons x|NAce qui sera TRUEquand x != 0et NAautrement. Si nous multiplions ce nombre par x, les TRUEéléments sont remplacés par les éléments correspondants de xet le NAreste NA, remplaçant ainsi tous les zéros. Ceci est ensuite passé à zoo::na.locfqui nous donne exactement ce que nous voulons.

Sauvegardé 4 octets grâce à flodel!

Rouille, 100 octets

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}

Je suis tombé sur ce défi, je pensais l'essayer dans ma langue préférée. Essayé d'utiliser [T]::windows_mut()au début, avant de découvrir que ça n'existe pas . Et cela aurait pu être plus long que ça. Quoi qu’il en soit, il s’avère que Rust, jouée au golf, est très laide et très peu compétitive (surtout avec tous ces ésotériques bien connus!) ¹

La nouvelle ligne n'est pas incluse dans le décompte; c'est seulement là pour que vous n'ayez pas à faire défiler latéralement. Cela ne change pas la signification du code.

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] Au moins, ce n'est pas aussi grave que Java.}}

Voie lactée 1.2.1 , 33 octets

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

Cela suppose que la liste des entiers est uniquement sur la pile.

Explication

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

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

C'est une fonction gqui accepte un tableau et retourne un tableau. Nous commençons une variable temporaire aà 0. Pour chaque élément ide l'entrée, s'il ine s'agit pas de 0, nous affectons aà i. Si iest égal à 0, ane change pas à cette itération. Nous utilisons acomme valeur dans cette position dans le tableau de sortie.

Perl 6 , 21 octets

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

usage:

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

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

Voyons comment cela fonctionne en utilisant x=

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

par exemple. Ici, !!xsera le vecteur logique (True / False):

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

En outre, seq(a=x)donne un vecteur d'indices pour autant que x:

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

On multiplie les deux en donnant:

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

Nous prenons le maximum cumulatif:

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

Enfin, nous utilisons ce dernier vecteur comme index à extraire de x:

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

CJam, 11 octets

q~{1$e|}*]p

Essayez-le en ligne.

Comment ça marche

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 octets

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

$x|%{...}le script bloque-t-il chaque élément de $x. ($_,$t)est un tableau d'éléments courants et $t, et [!$_]signifie que nous utilisons !$_pour indexer dans le tableau. L'indice sera 0(false) pour les éléments non nuls et 1(true) lorsque l'élément en cours est égal à zéro, il $ts'agira donc de l'élément en cours ou $t. Les parenthèses entourent l'expression d'affectation pour que sa valeur soit émise. Sans parenthèses, il s'agirait simplement d'une tâche "discrète" $t.

Japt , 3 octets

å!ª

L'essayer

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