Đưa ra một đoạn của đầu ra buzz fizz với tất cả các số bị loại bỏ, điền vào các số chính xác với các giá trị thấp nhất có thể sao cho đoạn trích buzz fizz là chính xác. Đối với mục đích của thử thách này, fizzvà buzzcó các giá trị thông thường là 3 và 5, tương ứng.

Nếu đầu vào là một chuỗi không hợp lệ của fizz, buzzvà dòng sản phẩm nào, sau đó thay vì sản lượng chỉ zzubzzif(có hoặc không có dòng mới).

Đầu vào và đầu ra có thể là các dòng phân tách dòng mới hoặc bất kỳ định dạng chuỗi nào thuận tiện cho ngôn ngữ của bạn.

Bạn có thể bỏ qua hoặc làm bất cứ điều gì bạn thích với viết hoa.

Bạn sẽ cần phải chọn để xử lý một hoặc nhiều trong số này: fizzbuzz, fizz buzz, buzz fizz, vv, nhưng bạn phải chọn ít nhất một trong các định dạng.

Bạn có thể giả định rằng tất cả các đầu vào là một số chuỗi fizz, buzzvà trống rỗng dòng.

Ví dụ

xì hơi

2
fizz
4

ù
xì hơi

buzz
fizz
7

fizzbuzz

13
14
fizzbuzz
16
17

1

xì hơi
xì hơi

zzubzzif

zzubzzif

Java, 205 byte

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

Lấy a String[]làm đầu vào và trả về a String.

Mã mở rộng, có thể chạy được:

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 byte

Tôi đã làm những điều không tưởng Tôi đã sử dụng một gototuyên bố để thoát ra khỏi một vòng lặp!

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

Điều này lợi dụng thực tế là chuỗi phải bắt đầu trong 15 yếu tố đầu tiên.

Lõm và dòng mới để dễ đọc:

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 byte

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

Chương trình sẽ thoát với một lỗi nếu nó phải in zzubzzif .

Sử dụng trình thông dịch Java, STDERR có thể được đóng lại để chặn thông báo lỗi cuối cùng. Nếu bạn thử chương trình trong trình thông dịch CJam , hãy bỏ qua tất cả đầu ra sau dòng đầu tiên.

Làm thế nào nó hoạt động

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

$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

Giải trình

1. @a là mảng các dòng đầu vào
2. Trong whilevòng lặp,
3. @s có chuỗi fizz-buzz được tạo
4. @xgiống như @snhưng với các số được thay thế bằng các chuỗi trống và một dòng mới được nối với mọi phần tử (để khớp với @a)
5. $c là một bộ đếm từ 1 đến 15
6. Vòng lặp chạy cho đến khi @xtrở thành giống như đầu vào@a
7. Bên ngoài vòng lặp, đầu ra là @shoặc zzufzzib dựa trên việc có $cnằm trong giới hạn của nó hay không

Python, 176 byte

Có lẽ có thể làm tốt hơn rất nhiều, nhưng lần thử đầu tiên tại Golf. Lời khuyên đánh giá cao :)

Nhún

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

Nguyên

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