Dado un fragmento de salida de fizz buzz con todos los números eliminados, complete los números correctos con los valores más bajos posibles de modo que el fragmento de fizz buzz sea ​​correcto. A los efectos de este desafío, fizzy buzztienen sus valores habituales de 3 y 5, respectivamente.

Si la entrada es una secuencia no válida de fizz, buzzy líneas vacías, a continuación, en lugar de salida solo zzubzzif(con o sin saltos de línea).

La entrada y la salida pueden ser líneas separadas por una nueva línea, o cualquier formato de matriz de cadenas que sea conveniente para su idioma.

Puede ignorar o hacer lo que quiera con mayúsculas.

Usted tendrá que elegir para manejar uno o más de los siguientes: fizzbuzz, fizz buzz, buzz fizz, etc, pero debe elegir al menos uno de estos formatos.

Usted puede asumir que todas las entradas es de alguna secuencia fizz, buzzy vaciar las líneas.

Ejemplos

efervescencia

2
fizz
4

zumbido
efervescencia

buzz
fizz
7

fizzbuzz

13
14
fizzbuzz
16
17

1

efervescencia
efervescencia

zzubzzif

zzubzzif

Java, 205 bytes

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

Toma a String[]como entrada y devuelve a String.

Código ampliado y ejecutable:

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 bytes

Hice lo impensable. ¡Usé una gotodeclaración para salir de un bucle!

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

Esto aprovecha el hecho de que la secuencia debe comenzar dentro de los primeros 15 elementos.

Sangría y nuevas líneas de legibilidad:

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 bytes

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

El programa saldrá con un error si tiene que imprimir zzubzzif .

Con el intérprete de Java, STDERR puede cerrarse para suprimir un mensaje de error eventual. Si prueba el programa en el intérprete de CJam , ignore todos los resultados después de la primera línea.

Cómo funciona

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

$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

Explicación

1. @a es la matriz de líneas de entrada
2. Dentro del whilebucle,
3. @s tiene la secuencia generada de fizz-buzz
4. @xes lo mismo @spero con números reemplazados por cadenas vacías y una nueva línea añadida a cada elemento (para que coincida con @a)
5. $c es un contador de 1 a 15
6. El bucle se ejecuta hasta que se @xvuelve igual que la entrada@a
7. Fuera del ciclo, la salida es @so zzufzzib en función de si $cestaba en sus límites o no

Python, 176 bytes

Probablemente podría hacerlo mucho mejor, pero primer intento de golf. Consejos apreciados :)

Encogido

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