Avec un extrait de sortie fizz buzz avec tous les numéros supprimés, entrez les bons numéros avec les valeurs les plus basses possibles, de sorte que l’ extrait fizz buzz soit correct. Aux fins de ce défi, fizzet buzzont leurs valeurs habituelles de 3 et 5, respectivement.

Si l'entrée est une séquence valide de fizz, buzzet des lignes vides, puis à la place juste sortie zzubzzif(avec ou sans sauts de ligne).

L'entrée et la sortie peuvent être des lignes séparées par une nouvelle ligne ou tout autre format de tableau de chaînes convenant à votre langue.

Vous pouvez ignorer ou faire ce que vous voulez avec la capitalisation.

Vous devrez choisir de gérer un ou plusieurs de ces derniers : fizzbuzz, fizz buzz, buzz fizz, etc, mais vous devez choisir au moins un de ces formats.

Vous pouvez supposer que toutes les entrées est une séquence de fizz, buzzet lignes vides.

Exemples

pétiller

2
fizz
4

bourdonner
pétiller

buzz
fizz
7

fizzbuzz

13
14
fizzbuzz
16
17

1

pétiller
pétiller

zzubzzif

zzubzzif

Java, 205 octets

s->{o:for(int i=0,j,h=s.length;++i<16;){for(j=h;j-->0;)if(s[j].contains("fizz")^(i+j)%3<1||s[j].contains("buzz")^(i+j)%5<1)continue o;String z=i+"";for(j=1;j<h;)z+="\n"+(i+j++);return z;}return"zzubzzif";}

Prend a String[]comme entrée et retourne a String.

Code développé, exécutable:

public class C {

    static final java.util.function.Function<String[], String> f = s -> {
        o:
        for (int i = 0, j, h = s.length; ++i < 16;) {
            for (j = h; j --> 0;) {
                if (s[j].contains("fizz") ^ (i + j) % 3 < 1 ||
                    s[j].contains("buzz") ^ (i + j) % 5 < 1) {
                    continue o;
                }
            }
            String z = i + "";
            for (j = 1; j < h;) {
                z += "\n" + (i + j++);
            }
            return z;
        }
        return "zzubzzif";
    };

    public static void main(String[] args) {
        System.out.print(f.apply(new String[]{"fizz", "", "buzz"}));
    }
}

C #, 212 octets

J'ai fait l'impensable. J'ai utilisé une gotodéclaration pour sortir d'une boucle!

string[]R(string[]a){for(int i,l=a.Length,n=0;n++<15;){for(i=l;i-->0;)if(((n+i)%3<1?"fizz":"")+((n+i)%5<1?"buzz":"")!=a[i])goto z;for(i=l;i-->0;)a[i]=a[i]==""?""+(n+i):a[i];return a;z:;}return new[]{"zzubzzif"};}

Cela tire parti du fait que la séquence doit commencer dans les 15 premiers éléments.

Indentation et nouvelles lignes pour la lisibilité:

string[]R(string[]a){
    for(int i,l=a.Length,n=0;n++<15;){
        for(i=l;i-->0;)
            if(((n+i)%3<1?"fizz":"")+((n+i)%5<1?"buzz":"")!=a[i])
                goto z;
        for(i=l;i-->0;)
            a[i]=a[i]==""?""+(n+i):a[i];
        return a;
    z:;
    }
    return new[]{"zzubzzif"};
}

CJam, 72 octets

"zzubzzif":MaqN/:Q,_F+{)_[Z5]f%:!MW%4/.*s\e|}%ew{:sQ1$A,sff&:s.e|=}=N*o;

Le programme se terminera avec une erreur s'il doit imprimer zzubzzif .

À l'aide de l'interpréteur Java, STDERR peut être fermé pour supprimer un éventuel message d'erreur. Si vous essayez le programme dans l' interpréteur CJam , ignorez toutes les sorties après la première ligne.

Comment ça marche

"zzubzzif" e# Push that string.
:Ma        e# Save it in M and wrap in in an array.
qN/:Q      e# Split the input into lines and save in Q.
,_F+       e# Count the lines and add 15 to a copy of the result.
{          e# For each integer I between 0 and lines+14:
  )_       e#   Increment I and push a copy.
  [Z5]     e#   Push [3 5].
  f%       e#   Map % to push [(I+1)%3 (I+1)%5].
  :!       e#   Apply logical NOT to each remainder.
  MW%4/    e#   Push ["fizz" "buzz"].
  .*       e#   Vectorized string repetition.
  s\       e#   Flatten the result and swap it with I+1.
  e|       e#   Logical OR; if `s' pushed an empty string, replace it with I+1.    
}%         e#
ew         e# Push the overlapping slices of length "lines".
{          e# Find; for each slice:
  :s       e#   Cast its elements to string (e.g., 1 -> "1").
  Q1$      e#   Push the input and a copy of the slice.
  A,s      e#   Push "0123456789".
  ff&      e#   Intersect the slice's strings' characters with that string.
  :s       e#   Cast the results to string. This replaces "fizz", "buzz"
           e#   and "fizzbuzz" with empty strings.
  .e|      e#   Vectorized logical OR; replace empty lines of the input
           e#   with the corresponding elements of the slice.
  =        e#   Check the original slice and the modified input for equality.
}=         e# Push the first match or nothing.
           e# We now have ["zzubzzif"] and possibly a solution on the stack.
N*         e# Join the topmost stack item, separating by linefeeds.         
o          e# Print the result.
;          e# Discard the remaining stack item, if any.

Perl, 140 octets

$f=fizz;$b=buzz;@a=<>;@x=map{s!\d!!gr.$/}@s=map{$_%15?$_%3?$_%5?$_:$b:$f:$f.$b}(++$c..$c+$#a)while$c<15&&"@x"ne"@a";print$c<15?"@s":zzubzzif

Explication

1. @a est le tableau de lignes d'entrée
2. Dans la whileboucle,
3. @s a la séquence fizz-buzz générée
4. @xest identique à @smais avec des nombres remplacés par des chaînes vides et une nouvelle ligne ajoutée à chaque élément (à faire correspondre @a)
5. $c est un compteur de 1 à 15
6. La boucle s'exécute jusqu'à @xdevenir la même que l'entrée@a
7. En dehors de la boucle, la sortie est @sou zzufzzib selon qu’elle se $ctrouvait ou non dans ses limites.

Python, 176 octets

Pourrait probablement faire beaucoup mieux, mais première tentative de golf. Conseils appréciés :)

Rétréci

def f(a):l=len(a);g=lambda n:'fizz'*(n%3<1)+'buzz'*(n%5<1);r=range;return next(([g(x)or x for x in r(i%15,i%15+l)]for i in r(1,16)if all(g(i+x)==a[x]for x in r(l))),g(0)[::-1])

Original

def f(a):
  l = len(a)
  g = lambda n: 'fizz'*(n%3<1)+'buzz'*(n%5<1)
  r = range
  return next(
    (
      [g(x) or x for x in r(i % 15,i % 15 + l)]
      for i in r(1,16)
      if all(
        g(i + x) == a[x] for x in r(l)
      )
    ),
    g(0)[::-1]
  )