ए, बज़, सी, डी, ई, फ़िज़, जी

Question

तार का उपयोग कर एक साधारण FizzBuzz।

दिया हुआ

• 1 शब्द या वाक्यांश (स्ट्रिंग)
• 2 अनूठे पात्र

उत्पादन

पहले वर्ण की प्रत्येक घटना के साथ शब्द या वाक्यांश को fizz के साथ बदल दिया गया और प्रत्येक दूसरे वर्ण को buzz से बदल दिया गया

नियम

• फ़िज़ और बज़ दोनों में पहला अक्षर कैपिटल में रहना चाहिए
• बाकी शब्दों के लिए फ़िज़ और चर्चा, आपको प्रतिस्थापित चरित्र के मामले से मेल खाना चाहिए (यदि कोई मामला नहीं है तो लोअरकेस रखें)
• यदि दिए गए वर्ण वाक्यांश में नहीं हैं, तो मूल वाक्यांश का उत्पादन करें

परीक्षण के मामलों

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

यह कोड-गोल्फ है इसलिए बाइट्स में सबसे छोटा कोड, जीत है!

ध्यान दें

तकनीकी रूप से न्यूलाइन केस को हैंडल करना (यह स्पार्टा है!) चुनौती का एक हिस्सा है। हालाँकि, मैं इसमें शामिल नहीं करने के लिए एक उत्तर नहीं दूंगा, क्योंकि यह कुछ भाषाओं में बहुत चुनौतीपूर्ण या असंभव है।

Comments

you must match the case of the replaced characterऔर Input is not case sensitiveएक दूसरे के विपरीत प्रतीत होते हैं।

— ग्रेग मार्टिन

@GregMartin आह धन्यवाद, मैं यह कहने की कोशिश कर रहा था कि इनपुट के रूप में 2 अक्षर केस सेंसिटिव हैं (उदाहरण। ए का मतलब एक ही है)

— GracefulLemming

ThiBuzzFizzIBuzzFizzBUZZPARTAअंतिम विस्मयादिबोधक चिह्न गायब है।

— अरनौलद

क्या हम इनपुट्स का समर्थन करने वाले हैं aa, a, f? अपेक्षित आउटपुट क्या होगा? BUZZizzBUZZizz, FizzFizzया हमारे विकल्प पर दोनों की अनुमति है?

— अरनौलद

@Amauld पिछले परीक्षण मामले के आधार पर, मैं कहूंगा कि इसका आउटपुट होना चाहिए FizzFizz।

— निधि मोनिका का मुकदमा

Answer 1

जेली , 34 बाइट्स

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

इसे ऑनलाइन आज़माएं!

कैसे?

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

Comments

+1, newline केस का उपयोग करने के लिए धन्यवाद। इससे यह पहला पूर्ण रूप से सही सबमिशन है

— GracefulLemming

Answer 2

पायथन 3 , 180 174 168 160 152 बाइट्स

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

यह पायथन 3 में स्टीफन के जवाब का सिर्फ एक अधिक गोल्फ वाला संस्करण है । यह 42% बाइट्स दूर है। अजगर 2 प्रिंट पर एक बाइट बचा सकता है, लेकिन ऐसी प्रगति की कीमत है। यह नए सिरे से ठीक से संभालती है।

इनपुट पर 8 बाइट बचाने के लिए ब्लेकनाइट का धन्यवाद।

Comments

fileinputमॉड्यूल किसके लिए उपयोग किया जाता है?

— caird coinheringaahing

@ValyrioAccount, fileinput.input अंतर्निहित इनपुट विधि को ओवरराइड करता है। यह newlines के साथ इनपुट सक्षम करता है।

— बेन फ्रेंकल

कैसे from sys import*और s,a,b=J(stdin).split(', ')कुछ पात्रों को बचाने के लिए?

— ब्लेकनाथ

Answer 3

अजगर, 109 बाइट्स

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

इसे ऑनलाइन आज़माएं!

---

दो पात्रों को एक ही तार के रूप में लेता है

संपादित करें: TIO लिंक में जोड़ा गया टेस्टकेस, न्यूलाइन भी काम करता है

Answer 4

पायथन 2 , 271 , 261 बाइट्स

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)

इसे ऑनलाइन आज़माएं!

वाह यह एक डोजी था! यह पता चला है कि अजगर बहु-लाइन इनपुट को स्वीकार नहीं करेगा, इसलिए fileinputइसका उपयोग किया जाना चाहिए।

संपादित करें: अब सभी मामलों को पास करना चाहिए :)

Comments

Newlines के साथ मामले को संभालने के लिए निश्चित +1! बहुत से लोग इसमें शामिल नहीं हो पाए हैं

— GracefulLemming

कुछ ऐसा करके आप 3 बाइट्स बचा सकते हैं import fileinput as f...for m in f.input():

— GracefulLemming

@ कालेब सुझाव के लिए धन्यवाद! इसे अब सभी परीक्षणों को पास करना चाहिए

— स्टीफन

Answer 5

MATLAB / ऑक्टेव , 106 102 111 बाइट्स

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

यह शायद आगे अनुकूलित किया जा सकता है।

यह एक सरल रेगेक्स प्रतिस्थापन का उपयोग करता है। हालाँकि पहले नंबर के साथ इनपुट वर्णों को बदलकर एक मध्यवर्ती कदम की आवश्यकता होती है। यह इतना है कि दूसरे इनपुट की जगह अगर पत्र में निहित किया गया है Fizzकि Fizzउसके बाद की जगह नहीं होती है जब अगले regex किया जाता है।

यह निश्चित रूप से मानता है कि इनपुट में कोई संख्या नहीं है। हालाँकि प्रश्न को देखते हुए कहा गया है कि इनपुट एक शब्द या वाक्यांश है जो मुझे लगता है कि यह एक स्वीकार्य धारणा है।

कोड इनपुट में नई लाइनों को सही ढंग से हैंडल करेगा।

आप इसे ऑनलाइन आज़मा सकते हैं !

Answer 6

बैश 4.4 + जीएनयू सेड, 70 228 222 227 बाइट्स

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"

जाहिर alias e=echoहै एक त्रुटि फेंकता है अगर बाश 4.3 या नीचे में संदर्भित किया जाता है, तो संस्करण TIO स्पष्ट रूप से उपयोग कर रहा है। इसलिए, लंबे और समकक्ष बैश 4.3 कोड परीक्षण के लिए नीचे दिए गए TIO टेस्ट सूट में दिए गए हैं। यह सभी परीक्षण मामलों को पास करता है, इसलिए यह अच्छा है।

इसे ऑनलाइन आज़माएं!

Comments

@thedarkwanderer अब यह चाहिए। खेद है कि इसे ठीक करने में थोड़ा लंबा समय लगा।

— आर। काप

Answer 7

जावास्क्रिप्ट (ईएस 6), 92 बाइट्स

इनपुट को एक स्ट्रिंग और दो वर्णों के एक सरणी के रूप में लेता है। नई कहानियों का समर्थन करता है।

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

परीक्षण के मामलों

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

Answer 8

पायथ - 25 बाइट्स

sXzsrBQ1scL2rB"FizzBuzz"1

टेस्ट सूट ।

Comments

पात्रों में से एक के रूप में एक पूंजी समस्याओं का कारण लगती है - "Hl", Helloआउटपुट को सही ढंग से कैपिटल नहीं करता है और एस को "hL", Helloप्रतिस्थापित नहीं करता है l।

— जोनाथन एलन

Answer 9

GNU sed , 135 + 1 (r फ्लैग) = 136 बाइट्स

डिफ़ॉल्ट रूप से, एक sed स्क्रिप्ट निष्पादित होती है जितनी बार इनपुट लाइनें होती हैं। मल्टी-लाइन इनपुट को संभालने के लिए, मैं एक नया चक्र शुरू किए बिना, सभी संभव शेष लाइनों को पहले से जोड़ने के लिए एक लूप का उपयोग करता हूं।

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

इसे ऑनलाइन आज़माएं!

लाइन 4 पर इस्तेमाल की जाने वाली रिप्लेसमेंट टेबल, उनके ऊपरी क्रम के रूपों के बाद उस सटीक क्रम में होने की आवश्यकता है, अर्थात 'फ़िज़' और 'बज़'। ऐसा इसलिए है क्योंकि .*टेबल लुकअप के दौरान इस्तेमाल किया जाने वाला सेड रेगीक्स लालची है। यदि वर्तमान चार्ट को बदलने की आवश्यकता है, तो एक पत्र (कोई मामला नहीं) है, तो लोअरकेस स्ट्रिंग की आवश्यकता है (अंतिम मिलान किया गया)।

चूंकि sed में कोई डेटा प्रकार नहीं है, इसलिए मैं स्ट्रिंग को पुनरावृत्त करने के लिए एक चरित्र सीमांकक का उपयोग करता हूं। यह मेरी वर्तमान स्थिति को चिह्नित करेगा और एक लूप में मैं इसे बाएं से दाएं स्थानांतरित करता हूं। सौभाग्य से, मैं इसके लिए उपयोग कर सकता हूं ,, क्योंकि यह इनपुट डेटा सीमांकक है।

स्पष्टीकरण:

: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

Answer 10

हास्केल, 114 बाइट्स

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)

rपहले तर्क के रूप में 2 तत्व सूची के रूप में fizz और buzz वर्ण लेता है, और दूसरे तर्क के रूप में इनपुट स्ट्रिंग। न्यूलाइन्स और यूनिकोड को उचित रूप से संभाला जाना चाहिए, हालांकि फ़ंक्शन दुर्भाग्य से कुल नहीं है (अमान्य इनपुट 5 बाइट्स को सहेजने की अनुमति है)।

Comments

u=Data.Char.toUpperजहाँ तक मुझे पता है केवल घिसी में काम करता है। मानक हास्केल में आपको इसकी आवश्यकता होती है import। हालाँकि आपको =<<इसके बजाय का उपयोग करके कुछ बाइट्स को बचाने में सक्षम होना चाहिए concatMap।

— लिकोनी

Answer 11

गणितज्ञ, 94 बाइट्स

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

अनाम फ़ंक्शन। इनपुट के रूप में दो तार लेता है और एक फ़ंक्शन देता है जो इनपुट के रूप में एक स्ट्रिंग लेता है और आउटपुट के रूप में एक स्ट्रिंग लौटाता है। यह प्रारूप में बुलाया जाना चाहिए prog["c1", "c2"]["s"], जहां "s"लक्ष्य स्ट्रिंग है और "c1"और "c2"दो पात्र हैं। शायद आगे गोल्फ हो सकता है।