Một FizzBuzz đơn giản sử dụng chuỗi.

Được

• 1 từ hoặc cụm từ (chuỗi)
• 2 nhân vật độc đáo

Đầu ra

Từ hoặc cụm từ với mỗi lần xuất hiện của ký tự đầu tiên được thay thế bằng fizz và mỗi ký tự thứ hai được thay thế bằng buzz

Quy tắc

• Chữ cái đầu tiên trong cả Fizz và Buzz phải được viết hoa
• Đối với phần còn lại của các từ fizz và buzz, bạn phải khớp với trường hợp của ký tự được thay thế (nếu không có trường hợp nào thì hãy viết thường)
• Nếu các ký tự đã cho không nằm trong cụm từ, hãy xuất cụm từ gốc

Các trường hợp thử nghiệm

Given: Hello, h, l
Output: FIZZeBuzzBuzzo

Given: test, a, b
Output: test

Given: PCG rocks!,  , !
PCGFizzrocksBuzz

Given: This
Is
SPARTA!, 
, S
Output: ThiBuzzFizzIBuzzFizzBUZZPARTA!

Given: FizzBuzz, a, b
Output: FizzBUZZuzz

Đây là mã golf, vì vậy mã ngắn nhất, tính bằng byte, sẽ thắng!

Ghi chú

Kỹ thuật xử lý trường hợp dòng mới (Đây là SPARTA!) Là một phần của thách thức. Tuy nhiên, tôi sẽ không bỏ qua một câu trả lời vì không bao gồm nó, vì nó rất khó hoặc thậm chí là không thể trong một số ngôn ngữ.

Thạch , 34 byte

Œl=€⁹Œl¤ȧ€"“¡Ṭ4“Ụp»o"/ȯ"Œu⁹Œln$T¤¦

Hãy thử trực tuyến!

Làm sao?

Œl=€⁹Œl¤ȧ€"“¡Ṭ4“Ụp»o"/ȯ"Œu⁹Œln$T¤¦ - Main link: characters, string
Œl                                 - lowercase the characters
       ¤                           - nilad followed by link(s) as a nilad:
    ⁹                              -     right argument, the string
     Œl                            -     lowercase
  =€                               - equals (vectorises) for €ach (a list of 2 lists that identify the indexes of the string matching the characters regardless of case)
           “¡Ṭ4“Ụp»                - dictionary strings ["Fizz", "Buzz"]
          "                        - zip with
        ȧ€                         -     logical and (non-vectorising) for €ach (replace the 1s with the words)
                     /             - reduce with:
                    "              -     zip with:
                   o               -         logical or (vectorises) (make one list of zeros and the words)
                                   - implicit right argument, string
                       "           - zip with:
                      ȯ            -     logical or (non-vectorising) (replace the zeros with the original characters from the string)
                                 ¦ - apply...
                        Œu         -     uppercase
                                   - ...to the indexes (the words at indexes):
                                ¤  -     nilad followed by link(s) as a nilad:
                          ⁹        -         right argument, the string
                              $    -         last two links as a monad (i.e. the string on both sides):
                           Œl      -             lowercase
                             n     -             not equals (vectorises)
                               T   -         truthy indexes (the indexes of the capital letters in the string)

Python 3 , 180 174 168 160 152 byte

from sys import*
J=''.join
L=str.lower
s,a,b=J(stdin).split(', ')
print(J('FBFBiuIUzzZZzzZZ'[L(k)==L(b)::2][k!=L(k)::2]*(L(k)in L(a+b))or k for k in s))

Đây chỉ là một phiên bản được đánh gôn nhiều hơn trong câu trả lời của Stephen , trong Python 3. Điều này làm mất đi 42% số byte của anh ta. Python 2 sẽ lưu một byte trên bản in, nhưng đó là giá của tiến trình. Điều này xử lý các dòng mới đúng.

Cảm ơn Blckknight đã lưu 8 byte vào đầu vào.

Python, 109 byte

lambda s,w:"".join([c,"Fizz","Buzz","BUZZ","FIZZ"][-~w.lower().find(c.lower())*-~(-2*c.isupper())]for c in s)

Hãy thử trực tuyến!

Đưa hai ký tự thành một chuỗi

Chỉnh sửa: Đã thêm testcase vào liên kết TIO, dòng mới cũng hoạt động

Python 2 , 271 , 261 byte

import fileinput as f
a=''
for m in f.input():a+=m
a=a.split(', ')
l=L=list(a[0])
for i in range(0,len(a[0])):
 j,k=l[i].lower(),l[i].istitle()
 if j==a[1].lower():
  L[i]='FIZZ'if k else'Fizz'
 elif j==a[2].lower():
  L[i]='BUZZ'if k else'Buzz'
print''.join(L)

Hãy thử trực tuyến!

Wow cái này là một doozie! Hóa ra python sẽ không chấp nhận đầu vào nhiều dòng nên fileinputphải được sử dụng.

chỉnh sửa: nên vượt qua tất cả các trường hợp bây giờ :)

MATLAB / Octave , 106 102 111 byte

@(a,b,c)regexprep(a,num2cell([lower([b c]) upper([b c]) '1234']),{'2','4','1','3','FIZZ','Fizz','BUZZ','Buzz'})

Điều này có lẽ có thể được tối ưu hóa hơn nữa.

Nó sử dụng một sự thay thế Regex đơn giản. Tuy nhiên, một bước trung gian được yêu cầu bằng cách thay thế các ký tự đầu vào bằng số trước. Điều này là để nếu chữ cái thay thế đầu vào thứ hai được chứa trong Fizzđó Fizzthì không được thay thế khi regex tiếp theo được thực hiện.

Điều này tất nhiên giả định không có số trong đầu vào. Tuy nhiên, với câu hỏi cho biết đầu vào là một từ hoặc cụm từ tôi cảm thấy rằng đây là một giả định có thể chấp nhận được.

Mã sẽ xử lý các dòng mới trong đầu vào một cách chính xác.

Bạn có thể dùng thử trực tuyến!

Bash 4.4 + GNU sed, 70 228 222 227 byte

IFS=;alias e=echo;K=`sed $([[ $2 != '
' ]]&&e "s/${2,}/Fizz/g;s/${2^}/FIZZ/g"||:)$([[ $3 != '
' ]]&&e ";s/${3,}/Buzz/g;s/${3^}/BUZZ/g"||:)<<<"$1"`;[[ $2 = '
'||$3 = '
' ]]&&e ${K//$'\n'/`[[ $2 = '
' ]]&&e Fizz||e Buzz`}||e "$K"

Rõ ràng alias e=echosẽ ném một lỗi nếu được tham chiếu trong Bash 4.3 trở xuống, phiên bản TIO rõ ràng đang sử dụng. Do đó, mã Bash 4.3 dài hơn và tương đương được đưa ra trong bộ thử nghiệm TIO dưới đây để thử nghiệm. Điều này vượt qua tất cả các trường hợp thử nghiệm, vì vậy đó là tốt đẹp.

Hãy thử trực tuyến!

JavaScript (ES6), 92 byte

Lấy đầu vào là một chuỗi và một mảng gồm hai ký tự. Hỗ trợ các dòng mới.

f=(s,[a,b],r='Fizz')=>a?f(s.replace(RegExp(a,'gi'),m=>m<'a'?r.toUpperCase():r),[b],'Buzz'):s

Các trường hợp thử nghiệm

f=(s,[a,b],r='Fizz')=>a?f(s.replace(RegExp(a,'gi'),m=>m<'a'?r.toUpperCase():r),[b],'Buzz'):s

console.log(f("Hello", ['h', 'l']))
console.log(f("test", ['a', 'b']))
console.log(f("PCG rocks!", [' ', '!']))
console.log(f(`This
Is
SPARTA!`, [`
`, 'S']))
console.log(f("FizzBuzz", ['a', 'b']))

Pyth - 25 byte

sXzsrBQ1scL2rB"FizzBuzz"1

Phòng thử nghiệm .

GNU sed , 135 + 1 (cờ r) = 136 byte

Theo mặc định, một tập lệnh sed được thực thi nhiều lần như có các dòng đầu vào. Để xử lý đầu vào nhiều dòng, tôi sử dụng một vòng lặp để nối tất cả các dòng còn lại có thể vào đầu tiên, mà không bắt đầu một chu kỳ mới.

:r
$!N
$!br
s:, (.), (.):;\u\1FIZZ;\l\1Fizz;\u\2BUZZ;\l\2Buzz:
s:^:,:
:
s:,(.)(.*;\1)(...)(.):\3,\4\2\3\4:
s:,(.):\1,:
/,;.F/!t
s:,.*::

Hãy thử trực tuyến!

Bảng thay thế được sử dụng trên dòng 4, cần phải theo thứ tự chính xác, tức là 'Fizz' và 'Buzz' sau các mẫu chữ hoa của chúng. Điều này là do regex sed.* , được sử dụng trong quá trình tra cứu bảng, là tham lam. Nếu char hiện tại cần thay thế không phải là một chữ cái (không có trường hợp), thì chuỗi chữ thường là cần thiết (khớp cuối cùng).

Vì sed không có kiểu dữ liệu, tôi sử dụng một dấu phân cách ký tự để lặp lại một chuỗi. Nó sẽ đánh dấu vị trí hiện tại của tôi và trong một vòng lặp tôi chuyển nó từ trái sang phải. May mắn thay, tôi có thể sử dụng ,cho việc này, vì nó là dấu phân cách dữ liệu đầu vào.

Giải trình:

:r                                                 # reading loop
$!N                                                # append next input line
$!br                                               # repeat till EOF
s:, (.), (.):;\u\1FIZZ;\l\1Fizz;\u\2BUZZ;\l\2Buzz: # create replacement table
s:^:,:                                             # append my string delimiter
:                                                  # main loop
s:,(.)(.*;\1)(...)(.):\3,\4\2\3\4:                 # apply char replacement, if any
s:,(.):\1,:                                        # shift delimiter to right
/,;.F/!t                                           # repeat till end of string
s:,.*::                                            # print only the final string

Haskell, 114 byte

u=Data.Char.toUpper
p[f,b]x|f==u x="Fizz"|b==u x="Buzz"|2>1=[x]
q x y|u y<y=x|2>1=u<$>x
r x=concatMap$q=<<p(u<$>x)

rlấy các ký tự fizz và buzz làm danh sách 2 phần tử làm đối số thứ nhất và chuỗi đầu vào làm đối số thứ hai. Các dòng mới và unicode nên được xử lý một cách thích hợp, mặc dù chức năng này không phải là tổng số (cho phép các đầu vào không hợp lệ được lưu 5 byte).

Toán học, 94 byte

a=ToLowerCase;b=ToUpperCase;StringReplace@{a@#->"Fizz",b@#->"FIZZ",a@#2->"Buzz",b@#2->"BUZZ"}&

Chức năng ẩn danh. Lấy hai chuỗi làm đầu vào và trả về một hàm lấy một chuỗi làm đầu vào và trả về một chuỗi làm đầu ra làm đầu ra. Nó phải được gọi theo định dạng prog["c1", "c2"]["s"], trong đó "s"là chuỗi đích "c1"và "c2"là hai ký tự. Có lẽ có thể được chơi golf hơn nữa.