Couvrir les zéros dans une liste


41

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]

21
Petit détail: le nom de cette opération dans le monde des statistiques est imputation LOCF (dernière observation reportée).
Alex A.

Que se passe-t-il si l'entrée était [0,0]?
Kritixi Lithos

4
@ KριτικσιΛίθος "... où la première valeur est garantie comme étant non nulle"
Sp3000

Et si l'entrée est [1,01]? À l'aide de la réponse Pyth d'Issac, comparez ceci et cela .
Arcturus

@Eridan 01n'est pas un entier valide en entrée Pyth, donc isaac n'a pas à en tenir compte. D'autres réponses peuvent accepter une entrée comme celle-ci si elles le souhaitent, du moment qu'elles sont cohérentes (la réponse d'
Isaac

Réponses:


19

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


23

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.

6
Mon cerveau ne peut pas comprendre ... Dennis a enfin trouvé le moyen de nous faire perdre définitivement le golf. Comme s'il ne l'avait pas déjà fait. _ಠ
Addison Crump

1
L'explication ne correspond plus au programme
quintopia

18

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.


17

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.


13

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.

Pouvez-vous répliquer par valeur absolue au lieu de supprimer les 0?
lirtosiast

@ThomasKwa C'était ma première tentative. C'est {:@(#~|)\donc un octet de plus.
Zgarb

13

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
$ 

11

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]

Chaque fois que j'exécute cette fonction, une erreur
s'affiche

@Downgoat C'est parce que l'interprète est un interprète en mode strict. Si vous n'exécutez pas ce code en mode strict, cela devrait fonctionner.
wizzwizz4

@ wizzwizz4 ohh, r ok
Downgoat

1
@ wizzwizz4 Le mode strict est idiot.
SuperJedi224

1
@ SuperJedi224 Ce n'est pas idiot. C'est très utile; cela permet de s'assurer que votre code n'est pas ambigu, et fonctionnera même avec une mise à jour majeure, et n'utilisera pas de comportement indéfini, etc. et si vous ne mettez pas la chaîne de mode strict au début, vous ne le souhaitez pas et / ou utilisez le code-golf.
wizzwizz4


7

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 .


6

Pyth, 8 octets

t.u|YNQ0

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


@isaacg Il semble que .uc'est plus long même si Jet Ksont ligotés. Est-ce jamais optimal?
lirtosiast

C'était (au moins autant que je sache) ici . Cela aide généralement lorsque vous souhaitez obtenir tous les résultats pour une raison quelconque.
FryAmTheEggman

5

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.


C'est 6 octets en Pyth et supprime l'erreur:#\nJ|EJ
isaacg

5

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

5

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

Vous pouvez sauvegarder un octet en le convertissant en programme - utilisez x=input('')plutôt que la déclaration de fonction et disp(u(t)le y=bit. En outre, vous pouvez économiser quatre octets supplémentaires en éliminant la tvariable, ce qui donne x=input('');u=x(~~x);disp(u(cumsum(~~x)))41 octets .
Tom Carpenter

@TomCarpenter Merci beaucoup! Edited
Luis Mendo

Je n'ai pas Matlab, mais @(x)x(~~x)(cumsum(~~x))travaille dans Octave.
Alephalpha

@alephalpha Matlab n'autorise pas l'indexation itérée.
AlexR

5

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.


5

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!


Attendez, ªest OR, plutôt que º? Est-ce que ºAND est par hasard?
Caird coinheringaahing

@cairdcoinheringaahing Nope, ºc'est ((. Ils ont été affectés par la valeur Unicode comme je l' ai trouvé la nécessité pour eux: P ªe et ºr est le génie si, je pourrais l' utiliser pour Japt 2.0 ...
ETHproductions

5

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.


5

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!


Très concis! J'aime la façon dont certains langages de programmation fonctionnels et logiques vous permettent de faire une telle traduction littérale des règles. C'est une façon tellement naturelle de l'écrire!
ThePlasmaRailgun le

4

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.


Sans surprise, la nouvelle version plus courte s’est révélée très similaire à celle de Dennis dans CJam . Il gagne d'un octet car GolfScript lit automatiquement l'entrée et n'a donc pas besoin d'une commande supplémentaire pour cela.
Ilmari Karonen

4

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.


4

, 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

4

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

Vous pouvez enregistrer deux octets avec I~]{n.{:V}{;V}?}d. Je me demande si ddevrait simplement mettre la valeur sur la pile au lieu de n...
kirbyfan64sos

Etes-vous sûr que O peut gérer ça? Je ne trouve pas le moyen de le transmettre -42 en satisfaisant l'exigence «votre sortie devrait être une entrée acceptable pour votre soumission».
Manatwork

@manatwork J'ai maintenant une meilleure version qui fonctionne -42, mais elle ajoute des crochets autour de la sortie.
phase

4

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!


4

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!) 1

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.


7
" Au moins, ce n'est pas aussi mauvais que Java "? Ahem ... ;)
Geobits

1
@ Geobits Oh, d'accord. Je comptais sur vous pour avoir besoin de ce passe- public static void mainpartout…
Blacklight Shining

3

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

Je suis à peu près sûr que TOS et STOS signifient Top of Stack et Second to Top of Stack, n'est-ce pas?
Addison Crump

Yep @FlagAsSpam
Zach Gates

3

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.


3

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

3

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)

3

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.

3

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.


@TimmyD, vous avez raison, bien sûr. J'ai ajouté param($x)ce qui transforme cela en un programme. La sortie est une collection d’entiers que vous pouvez soumettre en tant que paramètre au programme, par exemple $a = .\program.ps1 1,2,3,4,0,0,5, puis qui .\program.ps1 $afonctionne comme prévu.
Danko Durbić

$args|%{($p=($_,$p)[!$_])}- 26 octets utilisant $ args.
TessellatingHeckler

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.