Dizeleri kullanarak basit bir FizzBuzz.

verilmiş

• 1 kelime veya kelime öbeği (dize)
• 2 benzersiz karakter

Çıktı

İlk karakterin yerine her geçtiği fizz ve ikinci karakterin her biri buzz ile değiştirilmiş sözcük veya tümcecik

kurallar

• Hem Fizz hem de Buzz'daki ilk harf büyük yazılmalıdır
• Fizz ve buzz kelimelerinin geri kalanı için, değiştirilen karakterin durumuyla eşleşmelisiniz (eğer yoksa, küçük harfli tutun)
• Verilen karakterler kelime öbeğinde değilse, orijinal kelime öbeğini yazın

Test Durumları

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

Bu kod golf yani bayt cinsinden en kısa kod kazanır!

Not

Newline davasının teknik olarak ele alınması (This is SPARTA!) Zorluğun bir parçasıdır. Bununla birlikte, bazı dillerde çok zorlayıcı veya hatta imkansız olduğu için, dahil etmemek için bir cevabı geçersiz kılmayacağım.

Jöle , 34 bayt

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

Çevrimiçi deneyin!

Nasıl?

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

Piton 3 , 180 174 168 160 152 bayt

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

Bu, Stephen'ın Python 3'teki cevabının daha golfçü bir versiyonudur. Bu, baytlarının% 42'sini ortadan kaldırır . Python 2 baskıda bir bayt tasarruf eder, ancak ilerleme fiyatı budur. Bu, yeni satırları düzgün şekilde işler.

Blckknight sayesinde girişte 8 bayt kaydetti.

Python, 109 bayt

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

Çevrimiçi deneyin!

İki karakteri tek bir dize olarak alır

Düzenleme: TIO bağlantısına testcase eklendi, newline da çalışıyor

Python 2 , 271 , 261 bayt

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)

Çevrimiçi deneyin!

Vay be bu bir doozie oldu! Python çok satırlı girişleri kabul etmeyeceği fileinputiçin kullanılmalıdır.

edit: şimdi tüm durumlarda geçmelidir :)

MATLAB / Octave , 106 102 111 bayt

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

Bu muhtemelen daha da optimize edilebilir.

Basit bir Regex değişimi kullanır. Ancak, önce giriş karakterlerini rakamlarla değiştirerek bir ara adım gereklidir. İkinci giriş mektup yer aldığını yerine, bu yüzden olmasıdır Fizzolduğunu Fizzsonraki regex gerçekleştirildiğinde daha sonra yerini almaz.

Bu elbette girişte sayı olmadığını varsayar. Ancak soru verilen girdinin bir kelime ya da kelime öbeği olduğunu söyleyerek bunun kabul edilebilir bir varsayım olduğunu hissediyorum.

Kod, girişteki yeni satırları doğru şekilde işleyecektir.

Şunları yapabilirsiniz çevrimiçi deneyin!

Bash 4.4 + GNU, sed 70 228 222 227 bayt

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"

Görünüşe göre alias e=echoBash 4.3 veya daha düşük bir sürümde başvurulursa bir hata atar, görünüşe göre TIO sürümü kullanıyor. Bu nedenle, daha uzun ve eşdeğer Bash 4.3 kodu, test amacıyla aşağıdaki TIO test paketinde verilmiştir. Bu tüm test vakalarını geçer, bu yüzden güzel.

Çevrimiçi deneyin!

JavaScript (ES6), 92 bayt

Girişi bir dize ve iki karakterlik bir dizi olarak alır. Yeni satırları destekler.

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

Test senaryoları

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 bayt

sXzsrBQ1scL2rB"FizzBuzz"1

Test Takımı .

GNU sed , 135 + 1 (r bayrağı) = 136 bayt

Varsayılan olarak, bir sed komut dosyası giriş satırları kadar yürütülür. Çok satırlı girişi işlemek için, yeni bir döngü başlatmadan tüm olası kalan satırları birinciye eklemek için bir döngü kullanıyorum.

: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:,.*::

Çevrimiçi deneyin!

4. satırda kullanılan yedek tablonun tam olarak olması gerekir, yani büyük harf formlarından sonra 'Fizz' ve 'Buzz'. Bunun nedeni, .*tablo araması sırasında kullanılan sed regex'inin açgözlü olmasıdır. Değiştirilmesi gereken geçerli karakter bir harf değilse (büyük / küçük harf içermiyorsa), küçük harfli dizeye (en son eşleşen) ihtiyaç duyulur.

Sed'in veri türü olmadığından, bir dizeyi yinelemek için bir karakter sınırlayıcı kullanıyorum. Geçerli konumumu işaretleyecek ve bir döngüde soldan sağa kaydırıyorum. Neyse ki, bunun için kullanabilirsiniz ,çünkü giriş veri sınırlayıcısıdır.

Açıklama:

: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 bayt

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)

rfizz ve buzz karakterlerini ilk argüman olarak 2 elemanlı bir liste, ikinci argüman olarak da girdi dizesini alır. İşlev maalesef toplam olmasa da (5 bayt kaydedilen geçersiz girişlere izin vererek) satırsonu ve unicode uygun şekilde ele alınmalıdır.

Mathematica, 94 bayt

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

Anonim işlev. İki dizeyi girdi olarak alır ve dizeyi girdi olarak alan ve dizeyi çıktı olarak döndüren bir işlev döndürür. Bu formatta çağrılmalıdır prog["c1", "c2"]["s"], "s"hedef dize ve "c1"ve "c2"iki karakterlerdir. Muhtemelen daha fazla golf olabilir.