Biorąc pod uwagę fragment wyjściowego szumu fizz z usuniętymi wszystkimi liczbami, wpisz poprawne liczby o możliwie najniższych wartościach, tak aby fragment szumu fizz był poprawny. Dla celów niniejszego wyzwanie, fizzi buzzmają swoje typowe wartości 3 i 5, odpowiednio.

Jeżeli sygnał wejściowy jest nieprawidłowy przebieg fizz, buzzi pustych linii, to zamiast tego mogłoby wyprowadzać tylko zzubzzif(z lub bez nowej linii).

Dane wejściowe i wyjściowe mogą być wierszami oddzielonymi znakiem nowej linii lub dowolnym formatem tablic ciągów dogodnym dla twojego języka.

Wielkie litery możesz ignorować lub robić, co chcesz.

Trzeba będzie wybrać do obsługi jednego lub więcej z nich: fizzbuzz, fizz buzz, buzz fizz, etc, ale musisz wybrać co najmniej jeden z tych formatów.

Można założyć, że wszystkie wejścia jest jakiś ciąg fizz, buzza puste linie.

Przykłady

syczeć

2
fizz
4

brzęczenie
syczeć

buzz
fizz
7

fizzbuzz

13
14
fizzbuzz
16
17

1

syczeć
syczeć

zzubzzif

zzubzzif

Java, 205 bajtów

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

Bierze String[] dane wejściowe i zwraca wartość a String.

Rozszerzony, uruchamialny kod:

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 bajtów

Zrobiłem nie do pomyślenia. Użyłem gotoinstrukcji, żeby wyjść z pętli!

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

Wykorzystuje to fakt, że sekwencja musi rozpoczynać się w pierwszych 15 elementach.

Wcięcia i nowe wiersze dla czytelności:

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 bajty

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

Program zakończy działanie z błędem, jeśli będzie musiał wydrukować zzubzzif .

Używając interpretera Java, STDERR można zamknąć, aby ukryć ewentualny komunikat o błędzie. Jeśli spróbujesz programu w interpretatorze CJam , zignoruj ​​wszystkie dane wyjściowe po pierwszym wierszu.

Jak to działa

"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 bajtów

$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

Wyjaśnienie

1. @a to tablica linii wejściowych
2. Wewnątrz whilepętli
3. @s ma wygenerowaną sekwencję szumu fizycznego
4. @xjest taki sam, jak @sz liczbami zastąpionymi pustymi łańcuchami i nową linią dołączoną do każdego elementu (do dopasowania @a)
5. $c jest licznikiem od 1 do 15
6. Pętla biegnie, aż stanie @xsię taka sama jak wejście@a
7. Poza pętlą wyjście to @slub zzufzzib w zależności od tego, czy $cbyło w jego granicach, czy nie

Python, 176 bajtów

Mógłby chyba dużo lepiej, ale pierwsza próba golfa. Docenione wskazówki :)

Skurczył się

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

Oryginalny

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