Geben Sie bei einem Snippet der Fizz-Buzz- Ausgabe, bei dem alle Zahlen entfernt wurden, die richtigen Zahlen mit den niedrigstmöglichen Werten ein, damit das Fizz-Buzz- Snippet korrekt ist. Für die Zwecke dieser Herausforderung fizzund buzzhaben ihre üblichen Werte von 3 bzw. 5.

Wenn die Eingabe eine ungültige Folge von fizz, buzzund Leerzeilen, dann statt Ausgang nur zzubzzif(mit oder ohne Zeilenumbrüche).

Eingabe und Ausgabe können durch Zeilenumbrüche getrennte Zeilen sein oder das Format einer Zeichenfolge, das für Ihre Sprache geeignet ist.

Sie können die Großschreibung ignorieren oder tun, was Sie wollen.

Sie müssen wählen , eine oder mehr von diesen zu behandeln: fizzbuzz, fizz buzz, buzz fizz, etc., aber Sie müssen mindestens eines dieser Formate wählen.

Sie können davon ausgehen , dass alle Eingaben einige Folgen von sind fizz, buzzund Leitungen entleeren.

Beispiele

sprudeln

2
fizz
4

summen
sprudeln

buzz
fizz
7

Fizzbuzz

13
14
fizzbuzz
16
17

1

sprudeln
sprudeln

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

Nimmt a String[]als Eingabe und gibt a zurück String.

Erweiterter, lauffähiger Code:

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

Ich habe das Undenkbare getan. Ich habe eine gotoAnweisung verwendet, um aus einer Schleife auszubrechen!

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

Dies nutzt die Tatsache aus, dass die Sequenz innerhalb der ersten 15 Elemente beginnen muss.

Einrückung und neue Zeilen zur besseren Lesbarkeit:

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;

Das Programm wird mit einem Fehler beendet, wenn zzubzzif gedruckt werden muss .

Mit dem Java-Interpreter kann STDERR geschlossen werden, um eine eventuelle Fehlermeldung zu unterdrücken. Wenn Sie das Programm im CJam-Interpreter versuchen , ignorieren Sie alle Ausgaben nach der ersten Zeile.

Wie es funktioniert

"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

Erläuterung

1. @a ist das Array von Eingabezeilen
2. In der whileSchleife,
3. @s hat die generierte Fizz-Buzz-Sequenz
4. @xist dasselbe wie, @sjedoch mit Zahlen, die durch leere Zeichenfolgen ersetzt werden, und einer neuen Zeile, die an jedes Element angehängt wird (um damit übereinzustimmen @a)
5. $c ist ein Zähler von 1 bis 15
6. Die Schleife läuft bis @xzur Eingabe@a
7. Außerhalb der Schleife ist @soder ist die Ausgabe zzufzzib, je nachdem, ob sie $can ihre Grenzen stößt oder nicht

Python, 176 Bytes

Könnte wohl viel besser sein, aber erster Versuch beim Golf. Tipps geschätzt :)

Geschrumpft

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