द स्मार्ट पर्सन का मिराज


29

एक बार, मैं Quora पर इस प्रश्न / उत्तर को पढ़ रहा था

क्या वास्तव में कंप्यूटर विज्ञान की डिग्री वाले प्रोग्रामर हैं जो FizzBuzz टेस्ट पास नहीं कर सकते हैं

यह कोड स्पष्ट उत्तर के रूप में दिया गया है

for i in range(1, 100):
    if i % 3 == 0 and i % 5 == 0:
        print "FizzBuzz"
    elif i % 3 == 0:
        print "Fizz"
    elif i % 5 == 0:
        print "Buzz"
    else:
        print i

बेशक FizzBuzz मौत के लिए golfed गया है, लेकिन है कि क्या इस सवाल के बारे में है नहीं है। आप टिप्पणियों में देखते हैं, किसी ने उल्लेख किया है कि यह स्पष्ट उत्तर बहुत अच्छा है क्योंकि यह 4 के गुणकों के लिए प्रिंट "जैज़" जैसी अतिरिक्त शर्तों को जोड़ना आसान है (मैं सहमत नहीं हूं। इस योजना का विस्तार करने के लिए ओ (2 ** n) की आवश्यकता है। ) कोड की पंक्तियाँ।)

आपकी चुनौती FizzJazzBuzz के सबसे खूबसूरत संस्करण को अपने साथियों द्वारा देखते हुए लिखना है।

मतदाताओं के लिए कुछ बातें:

  1. सूखी
  2. विभाजन / मापांक संचालन की दक्षता

Quora पर कई उत्तर पायथन का उपयोग कर रहे थे, लेकिन यहां ऐसी कोई भाषा प्रतिबंध नहीं है।

मैं अब से एक महीने में सबसे अधिक वोटों के साथ उत्तर स्वीकार करूंगा

नमूना उत्पादन:

1
2
Fizz
Jazz
Buzz
Fizz
7
Jazz
Fizz
Buzz
11
FizzJazz
13
14
FizzBuzz
Jazz
17
Fizz
19
JazzBuzz
Fizz
22
23
FizzJazz
Buzz
26
Fizz
Jazz
29
FizzBuzz
31
Jazz
Fizz
34
Buzz
FizzJazz
37
38
Fizz
JazzBuzz
41
Fizz
43
Jazz
FizzBuzz
46
47
FizzJazz
49
Buzz
Fizz
Jazz
53
Fizz
Buzz
Jazz
Fizz
58
59
FizzJazzBuzz
61
62
Fizz
Jazz
Buzz
Fizz
67
Jazz
Fizz
Buzz
71
FizzJazz
73
74
FizzBuzz
Jazz
77
Fizz
79
JazzBuzz
Fizz
82
83
FizzJazz
Buzz
86
Fizz
Jazz
89
FizzBuzz
91
Jazz
Fizz
94
Buzz
FizzJazz
97
98
Fizz
JazzBuzz
popularity-contest  code-challenge  word  popularity-contest  string  grid  language-design  code-golf  source-layout  math  fastest-algorithm  assembly  code-golf  json  code-golf  arithmetic  array-manipulation  code-golf  ascii-art  code-golf  crossword  code-golf  string  restricted-complexity  code-golf  ascii-art  kolmogorov-complexity  code-golf  string  decision-problem  balanced-string  syntax  code-golf  grid  puzzle-solver  hexagonal-grid  code-golf  math  number  sequence  code-golf  string  decision-problem  code-golf  cryptography  king-of-the-hill  code-challenge  fastest-code  code-golf  number  code-golf  code-golf  string  code-golf  cryptography  king-of-the-hill  java  code-golf  number-theory  base-conversion  code-golf  code-golf  array-manipulation  code-golf  array-manipulation  sorting  code-challenge  restricted-source  quine  code-golf  tips  python  king-of-the-hill  code-golf  source-layout  fractal  code-golf  tips  game  king-of-the-hill  path-finding  grid  code-golf  kolmogorov-complexity  natural-language  code-golf  tips  python  code-golf  number  arithmetic  sequence  array-manipulation  code-golf  number  combinatorics  random  integer-partitions  code-golf  string  code-golf  vim  comment  code-golf  combinatorics  counting  code-challenge  rosetta-stone  code-golf  combinatorics  sequence  subsequence  code-golf  code-challenge  restricted-source  primes  printable-ascii  popularity-contest  graphical-output  image-processing 

1
आपका दूसरा बुलेट पॉइंट थोड़ा अस्पष्ट है ... क्या एक डिवीजन को कुशल बनाता है? चुनौती के लिए यह महत्वपूर्ण क्यों है?
21:39

@sanchises, अभी भी मौजूद हैं प्लेटफ़ॉर्म, विशेष रूप से माइक्रोकंट्रोलर, जिनके पास बहुत महंगा है (चक्र / समय में) विभाजन संचालन। नीचे दिए गए कम से कम एक उत्तर को पूरी तरह से विभाजन / मापांक से बचा जाता है - लेकिन शायद पठनीयता को नुकसान पहुंचाता है। मतदाताओं के लिए यह विचार करने के लिए कुछ है।
22 सितंबर को gnibbler

1
@ इस्किच सब IMHO में अस्पष्ट नहीं है बिंदु बिल्कुल भी विभाजन / मापांक का उपयोग नहीं कर रहा है। आप इसे केवल प्रत्येक n = (3,4,5 ...) के लिए एक चर रखते हुए कर सकते हैं और इसे उस समय रीसेट कर सकते हैं जब यह बीमार मिलान करता है और एक शब्द को प्रिंट करता है और जब वृद्धि नहीं होती है। ड्राई पार्ट एक फंक्शन / मेथड प्राप्त कर सकता है (n, word) और इस प्रकार अधिक शब्दों को जोड़ने का "मेंटेनेंस" एक हवा
jean

1
अत्यधिक प्रासंगिक: themonadreader.files.wordpress.com/2014/04/fizzbuzz.pdf
Hjulle

जवाबों:


101

सबसे सुंदर संस्करण, आप कहते हैं? तो, चलो इस एक में प्रयास करें ...

शेक्सपियर प्रोग्रामिंग भाषा

The Marvelously Insane FizzBuzzJazz Program.

Lady Capulet, an old bossy woman that loves to count.
The Archbishop of Canterbury, an old fart who adores to spit out letters.


          Act I: The only one of them.

          Scene I: The Archbishop of Canterbury is a bastard.

[Enter The Archbishop of Canterbury and Lady Capulet]

The Archbishop of Canterbury:
 You are nothing!

          Scene II: Count, Lady Capulet, count.

The Archbishop of Canterbury:
 You are as beautiful as the sum of yourself and a cat!

Lady Capulet:
 Am I worse than the square of the product of the sum of a warm gentle flower and a rose
 and my pretty angel?

The Archbishop of Canterbury:
 If not, let us proceed to Scene VIII.

          Scene III: Fizzing to no end!

The Archbishop of Canterbury:
 Is the remainder of the quotient between yourself and the sum of a happy cow and a
 chihuahua as good as nothing?

Lady Capulet:
 If not, let us proceed to Scene IV. Thou art as handsome as the sum of the sum of
 the sweetest reddest prettiest warm gentle peaceful fair rose and a happy proud kindgom
 and a big roman. Speak thy mind!

 Thou art as fair as the sum of thyself and a honest delicious cute blossoming peaceful
 hamster. Thou art as cunning as the sum of the sum of an embroidered King and a horse
 and thyself. Speak thy mind!

 Thou art as amazing as the sum of the sum of a good happy proud rich hero and a hair and
 thyself! Speak thy mind.

 Speak your mind!

          Scene IV: Milady, there is jazz in thy robe.

The Archbishop of Canterbury:
 Is the remainder of the quotient between yourself and a proud noble kingdom as good as
 nothing?

Lady Capulet:
 If not, let us proceed to Scene V. You are as charming as the sum of the sum of a noble
 cunning gentle embroidered brave mighty King and a big warm chihuahua and an amazing
 pony! Speak your mind!

 You are as prompt as the sum of yourself and a big black sweet animal. You are as noble
 as the sum of the sum of a gentle trustworthy lantern and yourself and a hog. Speak your
 mind!

 You are as bold as the sum of the sum of yourself and a good delicious healthy sweet
 horse and my smooth cute embroidered purse. You are as peaceful as the sum of a flower
 and yourself. Speak your mind.

 Speak your mind!

          Scene V: Buzz me up, Scotty!

The Archbishop of Canterbury:
 Is the remainder of the quotient between yourself and the sum of a gentle happy cow and a
 chihuahua as good as nothing?

Lady Capulet:
 If not, let us proceed to Scene VI. Thou art as handsome as the sum of the sweetest
 reddest prettiest warm gentle peaceful fair rose and a small town. Speak your mind!

 You are as prompt as the sum of yourself and a big healthy peaceful fair rich kingdom.
 You are as loving as the sum of the sum of an embroidered King and a horse and thyself.
 You are as amazing as the sum of yourself and a cute fine smooth sweet hamster. Speak
 your mind!

 You are as prompt as the sum of the sum of yourself and an amazing cunning Lord and a
 hair. Speak your mind.

 Speak your mind!

The Archbishop of Canterbury:
 Let us proceed to Scene VII.

          Scene VI: Output or die!

The Archbishop of Canterbury:
 Open your heart!

          Scene VII: Oh, to jump the line.

Lady Capulet:
 You are as handsome as the sum of a proud noble rich kingdom and a rural town. Speak your
 mind! You are as gentle as the sum of the sum of yourself and a green mistletoe and my
 father. Speak your mind!

The Archbishop of Canterbury:
 We must return to Scene II.

          Scene VIII: Goodbye, cruel world!

[Exeunt]

इसलिए, यहां एसपीएल के साथ मेरे संघर्ष के बाद , मुझे लगा कि मुझे किसी भी चुनौती पर कम से कम एक प्रस्तुतिकरण करना होगा। और यह बात है।

तो, फिर यह सब क्या है?

इसलिए, पहले, हम उन चरों को घोषित करते हैं जिनका हम पूरे कार्यक्रम में उपयोग करने जा रहे हैं, जो शेक्सपियर के नाटकों से आने चाहिए। रोमियो, जूलियट, ओफेलिया और ओथेलो के फेड, मैं द आर्कबिशप ऑफ कैंटरबरी और लेडी कैपुलेट के साथ गया । उनके वर्णन, साथ ही अधिनियमों / दृश्यों के शीर्षक, पार्सर द्वारा अवहेलना किए जाते हैं, इसलिए आप अपनी पसंद का बहुत कुछ डाल सकते हैं।

तो, चलो अनुवाद के राजा को कुछ कम अस्पष्टता से कुछ बनाने के लिए ।

अधिनियम I, दृश्य I

Begin Lady Capulet = 0;

अधिनियम I बहुत सीधा है: हम अपने चर को 0 से आरंभ करते हैं।

अधिनियम I, दृश्य II

Lady Capulet += 1; if(Lady Capulet < Math.pow((2*2*1+1)*(2*1),2)) continue; else goto Scene VIII;

हम लेडी कैपुलेट के मूल्य में वृद्धि करते हैं और इसकी तुलना 100 से करते हैं (हाँ, यह पूरा वाक्य केवल 100 नंबर पाने के लिए कार्य करता है); यदि यह छोटा नहीं है, तो हम सीन VIII (अंत) पर जाते हैं; अन्यथा, हम अगले दृश्य पर जारी रखते हैं।

अधिनियम I, दृश्य III

if(Lady Capulet % (2+1) == 0) continue; else goto Scene IV; The Archbishop of Canterbury = 2*2*2*2*2*2*1; System.out.print((char)The Archbishop of Canterbury); The Archbishop of Canterbury += 2*2*2*2*2*1; The Archbishop of Canterbury += 2*1+1; System.out.print((char)The Archbishop of Canterbury); The Archbishop of Canterbury += 2*2*2*2*1+1; System.out.print((char)The Archbishop of Canterbury); System.out.print((char)The Archbishop of Canterbury);

पहले, हम देखते हैं कि 3 से विभाजन का मापांक 0 है; यदि यह नहीं है, तो हम दृश्य IV पर जाते हैं; यदि ऐसा है, तो हम अंकगणित संचालन करना शुरू कर देते हैं और उन्हें आर्किएपर्सन पर संग्रहीत करते हैं, एक बार जब हम खोज रहे होते हैं, तो उन्हें चरित्र रूप में आउटपुट करते हैं। हां, अंत में, विचार प्राप्त करना है Fizz

अधिनियम I, दृश्य IV

if(Lady Capulet % (2*2) == 0) continue; else goto Scene V; The Archbishop of Canterbury = 2*2*2*2*2*2*1+2*2*1+2*1; System.out.print((char)The Archbishop of Canterbury); The Archbishop of Canterbury += 2*2*2*1; The Archbishop of Canterbury += 2*2*1+(-1); System.out.print((char)The Archbishop of Canterbury); The Archbishop of Canterbury += 2*2*2*2*1+2*2*2*1; The Archbishop of Canterbury += 1; System.out.print((char)The Archbishop of Canterbury); System.out.print((char)The Archbishop of Canterbury);

पहले जाँचता है कि यदि विभाजन के मापांक 4 से 0 है, तो पहले के समान दृश्य के लिए जारी है Jazz

अधिनियम I, दृश्य वी

if(Lady Capulet % (2*2+1) == 0) continue; else goto Scene VI; The Archbishop of Canterbury = 2*2*2*2*2*2*1+2*1; System.out.print((char)The Archbishop of Canterbury); The Archbishop of Canterbury += 2*2*2*2*2*1; The Archbishop of Canterbury += 2*1+1; The Archbishop of Canterbury += 2*2*2*2*1; System.out.print((char)The Archbishop of Canterbury); The Archbishop of Canterbury += 2*2+1; System.out.print((char)The Archbishop of Canterbury); System.out.print((char)The Archbishop of Canterbury); goto Scene VII;

पिछले दो की तरह कार्य, जाँच यदि 5 के विभाजन के मापांक 0 से रिटर्न करता है, तो लिखने का प्रयास करता है Buzz; एकमात्र अंतर यह है कि, अंत में, हम एक दृश्य छोड़ देते हैं।

अधिनियम I, दृश्य VI

System.out.print(Lady Capulet);

इस दृश्य तक पहुंचने के लिए, लेडी कैपुलेट द्वारा ग्रहण की गई संख्या में न तो फ़िज़ होगा और न ही जैज़ और न ही बज़; इसलिए, हम इसे संख्यात्मक रूप में आउटपुट करते हैं।

अधिनियम I, दृश्य VII

The Archbishop of Canterbury = 2*2*2*1+2*1; System.out.print((char)The Archbishop of Canterbury); The Archbishop of Canterbury += 2*1+1; System.out.print((char)The Archbishop of Canterbury); goto Scene II;

इसलिए, यह एकमात्र तरीका है जिसे मैंने अगली पंक्ति में कूदने के लिए पाया: आउटपुट, पहला, एक सीआर, फिर एक एलएफ; उसके बाद, हम दृश्य II पर लौटते हैं, हम इस कार्यक्रम को जारी रख सकते हैं।

अधिनियम I, दृश्य आठवीं

End.

एकदम सीधा।

मैं अभी भी यह देखने की कोशिश कर रहा हूं कि क्या मैं इसे ऑनलाइन दिखा सकता हूं, लेकिन मुझे ऑनलाइन कंपाइलर नहीं मिल रहा है - जो मैं जानता हूं कि वह पहले से लोड किए गए को छोड़कर किसी भी कार्यक्रम के साथ अच्छी तरह से संयोजन नहीं करता है, या शायद कुछ तरह का है कीबोर्ड और कुर्सी के बीच इंटरफेस की समस्या ...

अपडेट 1:

मैथमंडन की टिप्पणी के बाद, मैंने जैज़ और बज़ के दृश्यों के क्रम को संपादित किया। यह हो जाना चाहिए था।


1
ऐसा लगता है कि मेरे पास डीएनएस मुद्दे हैं। झूठे अलार्म के लिए क्षमा करें।
रेनबोल्ट

17
एक आश्चर्य की बात है कि शेक्सपियर को कोड-गोल्फ क्यों नहीं मिला।
Sanchises

5
मैं उम्मीद कर रहा था कि सीन III, IV और V क्रमशः फ़िज़, जैज़ और बज़ के अनुरूप होंगे। फिर भी, खूबसूरती से किया!
मैथमंडन

1
@ मतमंदनंदन कुछ शानदार करने का एक बेकार मौका। अरे नहीं!!
रोडोल्फो डायस

1
यह अद्भुत है, लेकिन मुझे लगता है कि यह एक बग है। मुझे लगता है कि यह संख्या का आउटपुट होता है अगर यह बज़ नहीं है, चाहे वह फ़िज़ या जैज़ हो। मैंने इसे नहीं चलाया, लेकिन मैं इसके लिए जाँच नहीं कर पाया। हो सकता है कि आर्चबिशप ए हो zऔर हर लूप से पहले उसे रीसेट कर सके।
मगेटा

45

> <> (मछली)

1 > :9b*)?; 0& v
               \ :3%?v "Fizz" r}oooo &1+& \
               /     <                    /
               \ :4%?v "Jazz" r}oooo &1+& \
               /     <                    /
               \ :5%?v "Buzz" r}oooo &1+& \
               /     <                    /
               \   &?v :n                 \
  ^  +1 oa           <                    /

> <> एक 2 डी प्रोग्रामिंग भाषा है जहां निर्देश एकल वर्ण हैं और अनुदेश सूचक (आईपी) तीर ^>v<और दर्पण के आधार पर ऊपर, नीचे, बाएं या दाएं जा सकते हैं /\। यह चर या तार नहीं है इसलिए खुद को दोहराना थोड़ा कठिन है, लेकिन मुझे लगता है कि यह अपने तरीके से अच्छा है।

हम धक्का देते हैं 1और लूप शुरू करते हैं। :9b*)?;जाँचता है कि क्या संख्या 99 ( 9b* = 9*11) से अधिक है , और यदि प्रोग्राम रुकता है ;। अन्यथा, एक 0 रजिस्टर में डालें और vलहराती भाग में नीचे जाएं ।

:3%?संख्या modulo की जाँच करता है। 3. यदि यह नॉनज़ेरो है, तो हम vएक पंक्ति नीचे जाते हैं और बाएँ चलते हैं <। अन्यथा, हम नीचे तीर छोड़ते हैं और धक्का देते हैं "Fizz", इसे प्रिंट करते हैं ( r}oooo) और &1+&पंक्तियों को नीचे जाने के लिए दाहिने दीवार के दर्पणों को उछालने से पहले रजिस्टर ( ) बढ़ाते हैं। किसी भी तरह से हम तीसरी पंक्ति के साथ बाईं ओर बढ़ते हुए समाप्त होते हैं, जब तक कि हम बाईं दीवार के दर्पणों को उछालते नहीं हैं। फिर हम के लिए दोहराएँ Jazzऔर Buzz

यह 7 वीं पंक्ति तक जारी है, जो रजिस्टर &के मूल्य की जांच करता है । अगर यह नॉनवेज है, तो हम नीचे जाते हैं। अन्यथा, हम nनीचे जाने से पहले नंबर को खुद ही प्रिंट कर लेते हैं ।

अंत में, ao(याद रखें, अब हम बाएं जा रहे हैं!) एक ASCII की नई 1+रेखा को प्रिंट करता है और संख्या को बढ़ाता है, इससे पहले कि हम ऊपर जाएं ^और >फिर से लूप करें।

(अब हम एक सौंदर्य पीट जवाब की प्रतीक्षा करते हैं ...)


3
ये सुन्दर है। इसके लिए प्रसिद्धि के हॉल में जाना चाहिए> <> जवाब।
जोशपब्रॉन

2
मेरी आँखें तुरंत कूद पड़ीं: 3।
EMBLEM

खैर, यह भाषा किसी भी पठनीयता पुरस्कार को जीतने वाली नहीं है, लेकिन यह बहुत साफ है।
विलियम टी फ्रूगार्ड

40

LOLCODE

सुरुचिपूर्ण? नहीं। कुशल? निश्चित रूप से नहीं। सुंदर? खैर, आप जानते हैं कि वे क्या कहते हैं: सौंदर्य देखने वाले की आंखों में है।

HAI
I HAS A kitty ITZ 1
IM IN YR house UPPIN YR kitty TIL BOTH SAEM kitty AN 100

    BTW, computin yr mods
    I HAS A d00d ITZ NOT MOD OF kitty AN 3
    I HAS A doge ITZ NOT MOD OF kitty AN 4
    I HAS A bro ITZ NOT MOD OF kitty AN 5

    ANY OF d00d bro doge MKAY, O RLY?
    YA RLY
        d00d, O RLY?
        YA RLY
            VISIBLE "Fizz"!
        OIC
        doge, O RLY?
        YA RLY
            VISIBLE "Jazz"! BTW, wow such jazz
        OIC
        bro, O RLY?
        YA RLY
            VISIBLE "Buzz"!
        OIC
    NO WAI
        VISIBLE kitty!
    OIC

    VISIBLE ""
IM OUTTA YR house
KTHXBYE

कुछ स्पष्टीकरण:

LOLCODE कार्यक्रमों के साथ शुरू HAIऔर अंत होता हैKTHXBYE

चर गतिशील रूप से टाइप किए जाते हैं और इनका उपयोग किया जाता है I HAS A <variable> ITZ <value>। एक बार परिभाषित करने के बाद, चर का उपयोग करके भी सौंपा जा सकता है<variable> R <value>

LOLCODE में लूप्स का नाम दिया गया है। वाक्य रचना है:

IM IN YR <loop> UPPIN YR <index> TIL BOTH SAEM <index> AN <end>
    <stuff to do>
IM OUTTA YR <loop>

यह सिर्फ "लूप फॉर आई = एंड" के लिए इंटरनेट बोल रहा है। LOLCODE 1.2 में, अनुक्रमण चर को लूप से पहले आरंभीकृत किया जाना चाहिए। यहाँ लूप को "हाउस" नाम दिया गया है क्योंकि यह लूप इनिशियलाइज़ेशन साउंड को हास्यप्रद बनाता है।

VISIBLEप्रिंट करने के लिए प्रिंट। डिफ़ॉल्ट रूप से एक नई पंक्ति जोड़ दी जाती है, लेकिन जोड़ना! रेखा को दिया से नई रेखा दब जाती है।

सशर्त इस प्रकार हैं:

<condition>, O RLY?
YA RLY
    <code to execute if condition is true>
NO WAI
    <code to execute if condition is false>
OIC

शर्तों को या तो भाव होना चाहिए जो एक बूलियन या बूलियन मूल्यों का मूल्यांकन करते हैं। LOLCODE में, बूलियन प्रकार को कहा जाता है TROOFऔर इसमें मान होते हैंWIN (सत्य) और FAIL(गलत) होते हैं।

सिंगल-लाइन टिप्पणियां के साथ शुरू होती हैं BTW

तेह इंटरनेटज़ की भाषा से अच्छी तरह वाकिफ नहीं हैं? बस मुझे पता है और मैं खुशी से आगे स्पष्टीकरण प्रदान करेंगे।


3
महान। बहुत शानदार। मैं अभी भी हंस रहा हूं
rpax

@rpax: बहुत बढ़िया ... सब योजना के अनुसार हो रहा है ...
एलेक्स ए।

33

python3

lst = [('Fizz', 3),
       ('Jazz', 4),
       ('Buzz', 5),
       ]

for i in range(1, 101):  
    print(*[w for w, m in lst if i % m == 0] or [i], sep='')

वर्तमान शीर्ष उत्तर के बीच, यह एकमात्र ऐसा है जिसका कोई भी रूप हैEfficiency of division/modulus operations
सकल

@ सकल आपका क्या मतलब है? मैंने जितने भी उत्तर देखे हैं, उनमें से अधिकांश में यह एक ही तरह के विभाजन / मापांक कार्यों का उपयोग किया गया है।
हेजल

वास्तव में? अन्य सभी उत्तर प्रत्येक के लिए एक मापांक ऑपरेटर का उपयोग करते हैं (3, 4, 5)। यह तीन बार दोहराया गया है। यह केवल एकल मापांक ऑपरेटर के साथ एकमात्र शीर्ष उत्तर है।
6

1
मैं सिर्फ सवाल पर टिप्पणी पढ़ता हूं। मुझे लगता है कि मैंने उद्धृत वाक्य की गलत व्याख्या की है। के DRYबजाय संदर्भित करना चाहिए था । इसके अलावा, यह जवाब ओपी द्वारा रचित है।
aross

31

पीट

बड़ा दृश्यवास्तविक "स्रोत"

मैंने कोशिश की और पीट के साथ खेलने का फैसला किया और देखा कि मैं कितना कोड बना सकता हूं। मैं यहां कुछ भी नहीं दोहराने की कोशिश करता हूं, हालांकि ईमानदार होने के लिए मुझे आधुनिक गणनाओं को दोहराना होगा। हालाँकि, प्रत्येक विशिष्ट मॉड (n% 3, n% 4, और n% 5) केवल एक बार कोड के चलने के बाद ही चलते हैं।

छोटी छवि उचित स्रोत है, और यहां अपलोड और चलाया जा सकता है

का आनंद लें!


4
"क्या वास्तव में कंप्यूटर विज्ञान की डिग्री वाले प्रोग्रामर हैं जो Piet में FizzBuzz टेस्ट पास नहीं कर सकते हैं ?"
Sanchises

26

मेथेमेटिका

मैथेमेटिका में आप बहुत विशिष्ट मापदंडों के लिए कार्यों को अधिभारित कर सकते हैं (न केवल प्रकार से, बल्कि मनमाने ढंग से तार्किक स्थितियों द्वारा भी)। चलो कुछ कार्यों को परिभाषित करते हैं:

Fizz[n_, s___] := {n, s}
Fizz[n_ /; Divisible[n, 3], s___] := {n, "Fizz" <> s}
Jazz[n_, s___] := {n, s}
Jazz[n_ /; Divisible[n, 4], s___] := {n, "Jazz" <> s}
Buzz[n_, s___] := {n, s}
Buzz[n_ /; Divisible[n, 5], s___] := {n, "Buzz" <> s}
DoThe[n_] := n
DoThe[_, s_] := s

और अब वास्तविक कार्यक्रम मात्र है

DoThe @@@ Fizz @@@ Jazz @@@ Buzz /@ Range[100] // TableForm

अब जबकि ऊपर केवल भाजक की संख्या के साथ रैखिक बढ़ता है, यह अभी भी बहुत कम नहीं है। लेकिन हम वास्तव में इन परिभाषाओं में नाम के रूप में चर का उपयोग कर सकते हैं। तो हम वास्तव में एक फ़ंक्शन लिख सकते हैं जो इन फ़ंक्शन परिभाषाओं को उत्पन्न करता है:

addFunction[f_, divisor_] := (
  f[n_, s___] := {n, s};
  f[n_ /; Divisible[n, divisor], s___] := {n, ToString[f] <> s}
)
addFunction[Fizz, 3];
addFunction[Jazz, 4];
addFunction[Buzz, 5];
DoThe[n_] := n
DoThe[_, s_] := s

DoThe @@@ Fizz @@@ Jazz @@@ Buzz /@ Range[100] // TableForm

अब आपको बस एक और addFunctionकॉल जोड़ना है और अपने नए **zzको अंतिम पंक्ति में जोड़ना है ।


13
DoThe @@@ Time @@@ Warp @@@ Again /@ Range[100] // TableForm
Sp3000

10
यह JMPबाईं ओर सिर्फ एक है!
माइकइलियार

"आपको बस इतना करना है कि एक और ऐडफ़ंक्शन कॉल जोड़ना है ..." और नए फ़ंक्शन को अंतिम पंक्ति में जोड़ें?
Sparr

@ शेरा ओह ये सच है
मार्टिन

22

हास्केल

आप लोग DRY को गंभीरता से नहीं ले रहे हैं। स्पष्ट पैटर्न हैं जो "फ़िज़ जैज़ बज़" अनुक्रम में फैक्टर किए जा सकते हैं।

import Control.Applicative

-- All words end with "zz" and the numbers are in a sequence
fizzes = zip [3..] $ (++ replicate 2 'z') <$> words "Fi Ja Bu"

main = putStrLn . unlines $ fizzIt <$> [1..99]

-- Point free style with reader monad ((->) a) to minimize
-- unnecessary repetition of variable names
fizzIt = nonFizzy =<< fizzy

-- Show the number if no fizziness was found. Partially point free
-- with respect to n. But xs is needed to prevent the error:
-- "Equations for ‘nonFizzy’ have different numbers of arguments"
nonFizzy "" = show
nonFizzy xs = const xs

-- (Ab)use the list monad for concatenating the strings

fizzy i = snd =<< filter ((==0).mod i.fst) fizzes
-- Could also be written as:
-- > fizzy i = concat [ str | (n,str) <- fizzes, i`mod`n==0]
-- but that would be way too readable, and not pointless (ahem, point free) enough. ;)

यह कोड भी आसानी से एक्स्टेंसिबल है। "Fizz Jazz Buzz Tizz" समस्या को हल करने के लिए, आपको केवल स्ट्रिंग के Tiबाद जोड़ना होगा Bu। यह किसी भी अन्य समाधान में आवश्यक से बहुत कम है।


5
यदि आपको फ़िज़-जैज़-बज़-सॉसेज की समस्या को हल करना है तो क्या होगा?
एको

@Anko मैं या तो इस तरह से कुछ कर सकता था fizzes = zip [3..] $ ((++ replicate 2 'z') <$> words "Fi Ja Bu") ++ ["Sausage"], या फिर वापस लौट आया fizzes = zip [3..] $ words "Fizz Jazz Buzz Sausage"
हुजुल

3
replicate 2 zयह थोड़ा खींच रहा है। । ।
सोहम चौधरी

3
@octatoan मैं विरोध नहीं कर सका। ;)
हजूल

16

एक्सेल VBA

             Sub scopeeeeeeeeeeeeeeee()
                     '   ||
               For u = 1 To 100
   If u Mod 3 = 0 Then yell = "Fizz"
If u Mod 4 = 0 Then yell = yell & "Jazz" '---------------------------------------------|
If u Mod 5 = 0 Then yell = yell & "Buzz" '---------------------------------------------|
            'made in USA
            If yell = "" Then yell = u
             Debug.Print yell      '\\
             yell = ""              '\\
            Next                     '\\
           End Sub                    '\\

यह बेवकूफ लग सकता है, लेकिन यह एक 2 डी स्नाइपर राइफल है!


इसका आधा।!!!!
ऑप्टिमाइज़र

2
इसके अलावा, यह मज़ेदार है - "यदि आप 3 का मोड लेते हैं"
ऑप्टिमाइज़र

धन्यवाद!! मुझे उम्मीद नहीं थी कि किसी को यू मोड 3 पार्ट इतनी जल्दी महसूस होगा
एलेक्स

मुझे समझ नहीं आता कि इसका आधा हिस्सा क्यों है!
एलेक्स

निशानची केवल आधा है। स्कोपर के बीच में स्कोप आमतौर पर होता है।
ऑप्टिमाइज़र

15

जावा

void fizzy(int limit){
    String[] output = new String[limit];
    Arrays.fill(output,"");

    List<SimpleEntry<Integer,String>> tests = new ArrayList<SimpleEntry<Integer,String>>();
    tests.add(newEntry(3,"Fizz"));      
    tests.add(newEntry(4,"Jazz"));      
    tests.add(newEntry(5,"Buzz"));      

    for(SimpleEntry<Integer,String> test : tests)
        for(int i=test.getKey();i<limit;i+=test.getKey())
            output[i] += test.getValue();           

    for(int i=1;i<limit;i++)
        System.out.println(output[i].length()<1 ? i : output[i]);
}   

SimpleEntry<Integer,String> newEntry(int key, String value){
    return new SimpleEntry<Integer,String>(key,value);
}

इसलिए जावा को वास्तव में "सुंदर" नहीं माना जाता है, लेकिन यह बहुत ही व्यक्तिपरक है, इसलिए मैं इस प्रश्न में दिशानिर्देशों द्वारा गया:

  • खुद को न दोहराएं: कोई बात नहीं। आपको प्रत्येक संख्या के लिए केवल एक पंक्ति जोड़ने की आवश्यकता है। मैंने एक सहायक कार्य भी किया, ताकि जब आप ऐसा न करें तो आपको टाइप करना पड़े (जावा कभी-कभी थोड़ा वर्बोज़ हो सकता है, यदि आप नहीं जानते हैं)।
  • विभाजन / मापांक संचालन की दक्षता : पूर्ण दक्षता, क्योंकि कोई मापांक या विभाजन बिल्कुल नहीं है।

यह कहना नहीं है कि एल्गोरिथ्म एक पूरे के रूप में सबसे अधिक कुशल है (यह नहीं है), लेकिन मुझे लगता है कि यह बुलेटेड बिंदुओं को अच्छी तरह से हिट करता है।


2
यदि आप एक वर्ग को परिभाषित नहीं करते हैं तो यह जावा नहीं होगा। : डी
एड्रियन लियोनहार्ड

मैं एक जावा उत्तर को पसंद करना चाहता था और मुझे यह दृष्टिकोण पसंद है, लेकिन मुझे लगता है कि इन-स्टेटमेंट्स में कोड एम्बेड करना अनावश्यक अड़चन है। सुंदर जावा पठनीय जावा है!
एलेक्स प्रिचर्ड 20

@AlexPritchard मैं मानता हूं कि कोड गोल्फिंग का एक साइड इफेक्ट। जब पीसी पर ठीक हो जाएगा :)
Geobits

11

सूचित करें 7

इंफॉर्म 7 एक नियम आधारित प्रोग्रामिंग भाषा है जिसे इंटरेक्टिव फिक्शन के लिए डिज़ाइन किया गया है। यह सबसे सफल प्राकृतिक भाषा आधारित प्रोग्रामिंग भाषाओं में से एक होने के लिए उल्लेखनीय है। अन्य उदाहरणों और सामान्य ज्ञान के कुछ बिट्स के लिए सूचित 7 भाषा का प्रदर्शन देखें ।

The number printing rules are a number based rulebook.

Definition: a number is fizzy if the remainder after dividing it by 3 is 0.
Definition: a number is jazzy if the remainder after dividing it by 4 is 0.
Definition: a number is buzzy if the remainder after dividing it by 5 is 0.

A number printing rule for a fizzy number:
    say "Fizz";

A number printing rule for a jazzy number:
    say "Jazz";

A number printing rule for a buzzy number:
    say "Buzz";

A number printing rule for a number (called N):
    unless a paragraph break is pending:
        say N;
    say conditional paragraph break;

To print a series of numbers from (min - a number) to (max - a number):
    repeat with N running from min to max:
        follow the number printing rules for N;

इस कोड का यह फायदा है कि FizzBuzz के प्रत्येक नियम पूरी तरह से स्वतंत्र हैं: सामान्य ढांचे को बदलने की आवश्यकता के बिना किसी भी बिंदु पर अतिरिक्त नियम जोड़े जा सकते हैं। दुर्भाग्य से यह थोड़ा दोहराव है, खासकर परिभाषा वाक्यांशों के साथ। मैं एक% ऑपरेटर को परिभाषित कर सकता था, लेकिन तब यह अंग्रेजी नहीं था। ;)

इस कोड को Playfic का उपयोग करके ऑनलाइन चलाया जा सकता है ।


7

दिल्लोग ए.पी.एल.

∇FizzJazzBuzz;list;items;names
   items ← ⍳100    
   list  ← ↑('Fizz' 3) ('Jazz' 4) ('Buzz' 5)   

   names ← (,/ ↑(↓0=⍉list[;2]∘.|items) /¨ ⊂list[;1]) ~¨ ' '
   ⎕← ↑,/↑names ,¨ (∊0=⍴¨names) ⍴¨ ⊂¨⍕¨items
∇
  • DRY: कोई दोहरा कोड नहीं है
  • परिस्थितियों को बदलने में आसान: नामों को सूची से लिया जाता है, क्रम में, प्रति विभाजक, न्यूनतम परिवर्तन के साथ
  • रेंज बदलने में आसान: itemsसंख्या की मनमानी सूची में बदला जा सकता है
  • कुशल: आसानी से समानांतर सूची-आधारित एल्गोरिथ्म का उपयोग करता है जिसमें केवल साइड-इफेक्ट फ्री प्राइमिटिव होते हैं।
  • सिंपल कोड फ्लो: न केवल कोई गोटो एस हैं, जबकि एस या अगर एस भी नहीं हैं। कोड पूरी तरह से रैखिक है।
  • अपना काम सुरक्षित करें: मुश्किल से कोई और इस पर काम कर पाएगा ...

का उद्देश्य क्या हैं ⎕MLऔर ⎕IO?
फ़ूजएक्सएक्सएल

वे दोनों हैं 1, जो डिफ़ॉल्ट है।
मारिनस

7

सी#

for(int i = 1; i <= 99; i++){
    string s = "";
    if (i % 3 == 0) s += "Fizz";
    if (i % 4 == 0) s += "Jazz";
    if (i % 5 == 0) s += "Buzz";
    System.Console.WriteLine(s == "" ? "" + i : s);
}

मॉड की जाँच करें, स्ट्रिंग का निर्माण करें, प्रिंट संख्या यदि रिक्त हो या स्ट्रिंग यदि नहीं। कोई दोहराता नहीं। केवल नई आवश्यकताओं के लिए शर्त और आउटपुट को जोड़ना होगा।


2
"कोई दोहराता है"? (ठीक है, कम से कम कोड आकार अतिरिक्त शब्दों के साथ रैखिक रूप से बढ़ता है।)
अंको

मैंने अपने C # उत्तर के साथ नो रिपिट्स की चुनौती को थोड़ा और आगे ले गया, लेकिन किसी भी लचीलेपन का त्याग कर दिया, जिस पर संख्याओं को मापना है। मुझे लगता है कि सबसे अच्छा परिणाम एक डेटास्ट्रक्चर संबंधित संख्या और शब्द होगा।
०६:४०

@ कोई भी निश्चित नहीं है कि आप क्या प्राप्त कर रहे हैं, कोई फ़ंक्शन दोहराया नहीं गया है। मैं कोड में कहीं भी दो बार एक ही काम नहीं कर रहा हूं।
rjjr11

@ rapjr11 कोड की जाँच करता है i - %कई बार, साथ ही साथ कई बार करने के लिए s। (वाक्यविन्यास के बहुत सारे दोहराव भी है, लेकिन यह शायद C # की गलती है।)
Anko

7

पायथन 2.7

मैंने इसे काव्यात्मक बनाने की कोशिश की ...

मैं प्रेम कविता में बहुत अच्छा नहीं हूँ ...

of = 1
my_love = 100
youre = "ever"

#You are
for ever in range(of, my_love) :
    never = "out my mind"
    for I,am in[#audibly
                (3, "Fizzing"),
                (4, "Jazzing"),
                #and
                (5, "Buzzing")]:
        if( ever % I ==0):# near you
            never += am #I lonely.
    #because
    youre = ever #in my mind.
    if( youre, never == ever,"out my mind" ):
        never += str(youre) #(I gave up with this line...)
    #then our foot-
    print"""s will"""( never [11:3])# part. 

प्रारंभिक स्थिरांक के बिना भी यह बहुत बेहतर होगा: पी


रचनात्मक, लेकिन यह मेरे लिए पायथन 2.7.9 में नहीं चलता है। यह कहता है TypeError: 'str' object is not callable:।
एलेक्स ए।

हम्म्म्म ... धिक्कार है ... पूरी तरह से यकीन नहीं है कि मैं कैसे चूक गया: /
JamJar00

5

कक्षाओं के साथ जावा

एल्गोरिथ्म:

public static void main(String... args) {

    List<Condition> conditions = new ArrayList<Condition>();
    conditions.add(new TerminatingCondition(100));
    conditions.add(new ModuloCondition(3, "Fizz"));
    conditions.add(new ModuloCondition(4, "Jazz"));
    conditions.add(new ModuloCondition(5, "Buzz"));
    conditions.add(new EchoCondition());

    while (true) {
        for (Condition c : conditions){
            c.apply();
        }
    }

}

कक्षाएँ:

interface Condition {
    void apply();
}

static class ModuloCondition implements Condition {
    int modulo, count = 0;
    String message;
    ModuloCondition(int modulo, String message){
        this.modulo = modulo;
        this.message = message;
    }
    public void apply() {
        count++;
        if (count == modulo) {
            out.append(message);
            count = 0;
        }
    }
}

static class TerminatingCondition implements Condition {
    int limit, count = 0;
    TerminatingCondition(int limit) {
        this.limit = limit;
    }
    public void apply() {
        count++;
        if (count > limit) {
            System.exit(0);
        }
    }
}

static class EchoCondition implements Condition {
    int count = 0, lastOutCount = 0;
    public void apply() {
        count++;
        out.println((lastOutCount == out.count) ? String.valueOf(count) : "");
        lastOutCount = out.count;
    }
}

static class Out {
    int count = 0;
    void append(String s) {
        System.out.append(s);
        count++;
    }
    void println(String s){
        append(s + System.lineSeparator());
    }
}

static Out out = new Out();

2
+1, आपने वास्तव में इस 70-लाइन FizzBuzzJazz के साथ जावा कोडिंग की भावना को पकड़ लिया है। यह ऑब्जेक्ट-ओरिएंटेड है और स्पष्ट रूप से निर्दिष्ट, गैर-संक्षिप्त, पठनीय शैली में लिखा गया है। बहुत लम्बा। लेकिन बहुत पठनीय है। ; ^)
DLosc

4

MATLAB / ऑक्टेव

बेशक, अपने स्वयं के लूप लिखना प्रोग्रामर के लिए मजेदार है, लेकिन हर कोई जानता है कि वास्तव में अनुक्रमण का ट्रैक रखने वाला थकाऊ कितना है (किसने लिखा नहीं है) for(j=i;j<n;i++) अपने जीवन में कम से कम एक बार नेस्टेड लूप में है?)

MATLAB का हल है। वास्तव में, यह कोड सबसे कुशल नहीं है, और निश्चित रूप से कोड-गोल्फ नहीं है, लेकिन यह हर तरह से MATLAB के अधिक दिलचस्प कार्यों का एक अच्छा प्रदर्शन है। ऑक्टेव MATLAB का GNU संस्करण है; यह कोड-गोल्फ के लिए उपयुक्त नहीं है क्योंकि यह चर प्रकार के साथ थोड़ा सख्त है, जो कोड-गोल्फ के लिए हानिकारक है।

संपादित करें: जब तक MATLAB के लिए वाक्य रचना हाइलाइटिंग एसई पर मौजूद है, मैं बहुत कम टिप्पणियों के साथ एक संस्करण पोस्ट कर रहा हूं, क्योंकि यह सादे पाठ का एक बड़ा डरावना ब्लॉक था।

function out = fizzjazzbuzz(n)
    %Initialization
    numberlist=1:n;
    fizz=cell(1,100);
    jazz=fizz;buzz=jazz;

    %Complex loops - no, wait, easy logical indexing.
    fizz(~mod(numberlist,3))={'Fizz'}; 
    jazz(~mod(numberlist,4))={'Jazz'};
    buzz(~mod(numberlist,5))={'Buzz'};
    out=strcat(fizz,buzz,jazz);
    %Fill with numbers
    out(cellfun(@isempty,out))=num2cell(numberlist(cellfun(@isempty,out)));

    %Pretty output (although the default printing is perfectly acceptable)
    out=cellfun(@num2str,out,'UniformOutput',0);
    strjoin(out,sprintf('\n'));
end

2
for(j=i;j<n;i++)? मेरा सवाल यह है: जिन्होंने "अपने जीवन में कम से कम एक बार" यह लिखा था ? यदि आपने किया, तो मेरे लिए आपके लिए बुरा नया है ...
बोगदान अलेक्जेंड्रू

1
@BogdanAlexandru आप अपने जीवन में कभी गलती से forलूप में गलत चर (जैसे जब लूप्स को घोंसला बना रहे हैं) में वृद्धि नहीं की है? क्या आप वह व्यक्ति हैं जिसका कोड हर पहली बार सफलतापूर्वक संकलित होता है? यदि आप हैं, तो मेरे पास आपके लिए ईश्वर समाचार है ...
Sanchises

2
मैं गलत चर को बढ़ाने के बारे में बात नहीं कर रहा हूं, मेरा कोड ईश्वर-लिखित नहीं है। मैं उस कोडिंग शैली के बारे में बात कर रहा हूं, यह अपने आप में बहुत त्रुटि प्रवण है। jएक पाश स्थानीय चर के लिए नाम ठीक है, लेकिन iनाम बहुत बुरा व्यवहार है और है कि अपनी गलती का स्रोत है। यह विशुद्ध रूप से आकस्मिक नहीं है :)
बोगडान अलेक्जेंड्रू

@BogdanAlexandru आह हाँ, मैं काफी सहमत हूँ; कारण मैं अभी भी लूप की इस शैली का उपयोग करता हूं, जब दिए गए असाइनमेंट को लागू कर रहा है (मैं एक मास्टर्स छात्र हूं); मैं प्रश्न में प्रोफेसर द्वारा उपयोग किए गए इंडेक्स नोटेशन का उपयोग करता हूं, अपने बूते गरीब आदमी को भ्रमित करने की तुलना में।
Sanchises

1
यह कोई समस्या नहीं है कि एक अक्षर को एक लूप के अनुक्रमित नाम दिए जाएं, लेकिन दूसरे चर में अधिक सार्थक नाम होने चाहिए।
बोगडान अलेक्जेंड्रू

4

अजगर

from collections import defaultdict

lst = [(3, 'Fizz'),
       (5, 'Buzz'),
       (4, 'Jazz')]

word_list = defaultdict(list)

for d, w in sorted(lst):
    for i in range(d, 100, d):
        word_list[i].append(w)

for i in range(1, 100):
    print(''.join(word_list[i]) or i)

यह निश्चित रूप से बहुत लंबा है। gnibbler का घोल ज्यादा बेहतर है। (हालांकि के *..., sep=''साथ की जगह ''.joinऔर अधिक सुंदर होगा)

लेकिन विभाजन / मापांक कार्यों के संदर्भ में यह काफी कुशल है।


1
आप इसका उपयोग क्यों करते हैं sorted(lst), जब आप इसे परिभाषित करते हैं तो इसे केवल उसी क्रम में क्यों नहीं रखा जाता है, जिसकी आपको आवश्यकता होती है?
mbomb007

या लूप से पहले इसे जगह में सॉर्ट करें। lst.sort()
डेविड

4

माणिक

100.times do |n|
  l = [nil, 'Fizz', 'Jazz', 'Buzz'].select.with_index{|x, i| x && (n % (i+2)) == 0 }
  puts l.empty? ? n : l * ''
end

ऐसा लगता है कि यह 2,3 और 4 के गुणक है?
ज्ञानी

@gnibbler वूप्स, हाँ यह है। फिक्स्ड।
Doorknob

4

हास्केल

inp = [(3, "Fizz"), (4, "Jazz"), (5, "Buzz")]

mkList (n, str) = cycle $ replicate (n-1) "" ++ [str]

merge lists = (head =<< lists) : merge (map tail lists)

checkFJB "" n = show n
checkFJB s  _ = s

fjb = zipWith checkFJB (merge $ map mkList inp) [1..]

print100fjb = mapM_ putStrLn $ take 100 fjb

फिर भी विभाजन या मापांक के बिना एक और समाधान। fjbFizzes, Jazzes, Buzzes और / या संख्याओं की एक अनंत सूची बनाता है। takeकोई भी राशि जो आप चाहते हैं, जैसा print100fjbकि पहले 100 तत्वों को छापता है।


4

SQL (MySQL)

SELECT COALESCE(GROUP_CONCAT(FizzJazzBuzz.str ORDER BY FizzJazzBuzz.n SEPARATOR ''), I.id)
FROM I
    LEFT JOIN (
        SELECT 3 n,'Fizz' str
        UNION SELECT 4, 'Jazz'
        UNION SELECT 5, 'Buzz'
    ) FizzJazzBuzz ON I.id MOD FizzJazzBuzz.n = 0
GROUP BY I.id
ORDER BY I.id;

जहां मैं 100 पूर्णांक वाले एक कॉलम (आईडी INT) के साथ एक तालिका है।

मुझे एक एसक्यूएल स्वाद नहीं पता है जो मैं आसानी से तालिका उत्पन्न कर सकता हूं, या वाल्वों को उप-वर्ग के रूप में उपयोग कर सकता हूं, जो इसे बहुत बेहतर और पूर्ण बना सकता है।


1
आप mysql में वैरिएबल का उपयोग कर सकते हैं। SELECT @i:= (@i + 1) FROM mysql.help_relation, (SELECT @i:=0) v WHERE @i < 100;
स्लादिदत्त

@slicedtoad SELECT DISTINCT help_keyword_id FROM mysql.help_relation WHERE help_keyword_id>0 AND help_keyword_id<=100ने भी काम किया। लेकिन अगर 100 को 10000 में बदल दिया जाए तो दोनों टूट जाएंगे।
jimmy23013

1
यदि आपको अधिक पंक्तियों की आवश्यकता है, तो बस इसमें शामिल हों
2

जहाँ तक मुझे पता है MySQL एकमात्र SQL बोली है जिसमें एक आसान पंक्ति-जनरेटर विकल्प नहीं है। अधिकांश बस एक पुनरावर्ती सामान्य तालिका अभिव्यक्ति का उपयोग कर सकते हैं।
बेन

@ लेकिन पुनरावर्ती तरीके हमेशा अच्छे नहीं लगते। मैं बोली को बदलकर अपना जवाब ठीक नहीं करूंगा क्योंकि पहले से ही एक Oracle SQL उत्तर है।
jimmy23013

3

माणिक

1.upto(100) do |i|

  rules = { 3 => 'Fizz', 4 => 'Jazz', 5 => 'Buzz' }

  print(i) unless rules.select! { |n,s| i.modulo(n) > 0 or print(s) }

  puts

end

3

जावास्क्रिप्ट


शायद सबसे कुशल तरीका नहीं है, लेकिन मुझे लगता है कि यह सरल और सुंदर है <3

(function fizzBuzz(iter){
    var str = '';
    

    if(!(iter % 3)) str += 'Fizz'
    if(!(iter % 4)) str += 'Jazz'
    if(!(iter % 5)) str += 'Buzz'


    console.log(str || iter)


    if(iter >= 100) return

    
    fizzBuzz(++iter)
})(1)


मूर DRY और पुतली बदसूरत: सी

(function fizzBuzz(iter){
    var 
        str,
        fijabu = ['Fi','Ja','Bu']
    ;
    

    (function isMod(_str,val){

        if(!(iter % val)) _str += fijabu[val-3] + 'zz'


        if(val >= 5) return str = _str


        isMod(_str,++val)
    })('',3)


    console.log(str || iter)


    if(iter >= 100) return

    
    fizzBuzz(++iter)
})(1)


8
डबल स्पेसिंग क्यों?
एको

व्यक्तिगत सम्मेलन। मुझे लगता है कि इसके अच्छे पढ़ने के लिए।
साउंडयोगी

stevelosh.com/blog/2012/10/why-i-two-space मैं, हालांकि नहीं।
सोहम चौधरी

मैं इसे केवल व्यक्तिगत परियोजनाओं में और मनोरंजन के लिए करता हूं। ज्यादातर टीमें इसे पसंद नहीं करती हैं।
साउंडयोगी

2

जावास्क्रिप्ट

सूखी ...;)

(function FizzJazzBuzz(iter) {
    var output = ["Fi", "Ja", "Bu"];
    var str = "";

    output.map(function(v,i,a) {
        if(!(iter%(i+3))) str += output[i] + "zz";
    });

    console.log(str || iter);

    if(iter < 100) FizzJazzBuzz(++iter);

    return;
})(1);

2

पूरी तरह से बेवकूफ सी #

आधा संक्षिप्त 'डोंट रिपीट योरसेल्फ' था, इसलिए मैंने इसे सचमुच में लिया था जैसा कि मैं सी # के साथ कर सकता था और यह गलती से कोड को गोल्फ में बदल गया। यह मेरा पहला गोल्फ है और मैंने इसे C # में किया था, बेवकूफ मैं जानता हूं लेकिन इसका परिणाम यहां है:

गोल्फ ( 240) 232 230 वर्ण):

namespace System{using Diagnostics;using i=Int32;using s=String;class P{static void Main(){s[] z=new s[]{"Fi","Ja","Bu"};for(i a=1;a<100;a++){s l="";for(i b=3;b<6;b++)if(a%b==0)l+=z[b-3]+"zz";Trace.WriteLine((l!="")?l:a+"");}}}}

Ungolfed:

namespace System
{
   using Diagnostics;
   using i = Int32;
   using s = String;
   class P 
   { 
      static void Main() 
      {
         s[] z = new s[] { "Fi","Ja","Bu" }; 
         for(i a = 1;a < 100;a++) 
         { 
            s l = ""; 
            for(i b = 3;b < 6;b++)
               if(a % b == 0)
                  l += z[b - 3] + "zz"; 
            Trace.WriteLine((l != "") ? l : a+""); 
         } 
      } 
   }
}

उद्देश्य किसी भी चीज को छोटा करना था जो मुझे एक पूरा सी # प्रोग्राम बनाते समय कोड को छोटा रखने के लिए एक से अधिक बार और सामान्य रूप से उपयोग करना था। इसके लिए आपको VisualStudio का उपयोग करना होगा और StartUp ऑब्जेक्ट को 'P' पर सेट करना होगा, आपको डिबगिंग आउटपुट विंडो में आउटपुट देखने की भी आवश्यकता होगी।

यहाँ कुछ गंभीर सीमाएँ हैं:

  • कोड मानता है कि सभी शब्द 'zz' में समाप्त हो जाएंगे
  • कोड मानता है कि मापांक लगातार होगा (3,4,5,6 ...)
  • कोड अभी भी सच्चे गोल्फ पर कमी या पुनरावृत्ति का पक्षधर है, कुछ दोहरावों से बचने के लिए अधिक वर्ण जोड़े जाते हैं

2

अजगर २

मैं इसके लिए कुछ चुस्त पायथन में एक उत्तर लिखना चाहता था जो भाषा की विशेषताओं को दिखाएगा, DRY सिद्धांत का अनुपालन करेगा, और काफी पठनीय होगा।

group = range(100)
rules = [('fizz', group[::3]), ('jazz', group[::4]), ('buzz', group[::5])]
for number in group[1:]:
    labelset = ''
    for label, matches in rules:
        if number in matches:
            labelset += label
    print labelset if labelset else number

यह छोटा उदाहरण स्लाइसिंग, inऑपरेटर, और वर्बोज़ लेकिन समझने योग्य टर्नरी सिंटैक्स दिखाता है । यह मोडुलो ऑपरेटर का उपयोग बिल्कुल नहीं करता है। यह रन-टाइम दक्षता के लिए नहीं बनाया गया है, लेकिन यह लक्ष्य नहीं था। इसे संक्षिप्त, समझने योग्य और बनाए रखने के लिए डिज़ाइन किया गया है।


set(group[...])नियमों में उपयोग क्यों नहीं ?
गनिबलर

मैं रफ्तार के बजाय शान के लिए जा रहा था। सेट () का उपयोग करना निश्चित रूप से वास्तविक अनुप्रयोगों में तेज होगा।
लॉजिक नाइट

2

पायथन 2.7, 111 बाइट

यह मेरा पहला योगदान है। मैंने कुछ पायथन कोडगॉल्फिंग ट्रिक्स (स्ट्रिंग इंटरलेविंग, टपल इंडेक्स एक्सेस के बजाय if) लागू करने की कोशिश की । यदि आपके पास कोई सुझाव है, तो कृपया उन्हें साझा करें!

for i in range(1,101):
 p=""
 for x in 3,4,5:
  if not(i%x):p+="FJBiauzzzzzz"[x-3::3]
 print((p,i)[not len(p)])

आउटपुट:

1
2
Fizz
Jazz
Buzz
Fizz
7
Jazz
Fizz
Buzz
11
FizzJazz
13
14
FizzBuzz
Jazz
17
Fizz
19
JazzBuzz
Fizz
22
23
FizzJazz
Buzz
26
Fizz
Jazz
29
FizzBuzz
31
Jazz
Fizz
34
Buzz
FizzJazz
37
38
Fizz
JazzBuzz
41
Fizz
43
Jazz
FizzBuzz
46
47
FizzJazz
49
Buzz
Fizz
Jazz
53
Fizz
Buzz
Jazz
Fizz
58
59
FizzJazzBuzz
61
62
Fizz
Jazz
Buzz
Fizz
67
Jazz
Fizz
Buzz
71
FizzJazz
73
74
FizzBuzz
Jazz
77
Fizz
79
JazzBuzz
Fizz
82
83
FizzJazz
Buzz
86
Fizz
Jazz
89
FizzBuzz
91
Jazz
Fizz
94
Buzz
FizzJazz
97
98
Fizz
JazzBuzz

मैं DRY सिद्धांत को भी पूरी तरह से लागू नहीं कर सका, क्योंकि दो forलूप हैं। वहाँ शायद यह करने के लिए एक स्मार्ट तरीका है!


मैं शायद पहले forबयान में भी एक टपल का उपयोग कर सकता हूं । मैं कर सकता हूँ जब अद्यतन करेगा!
नेफो

ठीक है, तो यह एक ही लूप में दो चर के साथ काम करता है, लेकिन मैं 111 बाइट्स से 145 तक जाता हूं
नेफो डे

1

चले जाओ

समवर्ती FizzJazzBuzzer

package main

import (
    "fmt"
    "sort"
    "sync"
)

var hooks map[int]string = map[int]string{
    3: "Fizz",
    4: "Jazz",
    5: "Buzz"}

type candidate struct {
    num     int
    message string
}

func FizzJazzBuzzer(hooks map[int]string) (chan<- int, *sync.WaitGroup) {
    var wg *sync.WaitGroup = new(sync.WaitGroup)
    final := func(c chan candidate) {
        for i := range c {
            if i.message == "" {
                fmt.Println(i.num)
            } else {
                fmt.Println(i.message)
            }
            wg.Done()
        }
    }
    prev := make(chan candidate)
    go final(prev)
    var keys []int = make([]int, 0)
    for k := range hooks {
        keys = append(keys, k)
    }
    sort.Sort(sort.Reverse(sort.IntSlice(keys)))
    for _, mod := range keys {
        c := make(chan candidate)
        s := hooks[mod]
        go (func(in chan candidate, next chan candidate, mod int, s string) {
            for i := range in {
                if i.num%mod == 0 {
                    i.message += s
                }
                next <- i
            }
        })(c, prev, mod, s)
        prev = c
    }
    in := make(chan int)
    go (func(in <-chan int) {
        for i := range in {
            prev <- candidate{i, ""}
        }
    })(in)
    return in, wg
}

func main() {
    in, wg := FizzJazzBuzzer(hooks)
    for i := 1; i < 20; i++ {
        wg.Add(1)
        in <- i
    }
    wg.Wait()
}

इसे यहाँ आज़माएँ: http://play.golang.org/p/lxaZF_oOax

यह केवल एक मापांक प्रति संख्या की जाँच करता है और मनमाने ढंग से किसी भी संख्या में, अच्छी तरह से ... संख्याओं तक बढ़ाया जा सकता है।

आपको इसे विस्तार करने के लिए केवल 3 अलग-अलग स्थान बनाने होंगे, hooksनक्शे में, FizzJazzBuzzerफ़ंक्शन का नाम और, ज़ाहिर है, FizzJazzBuzzerफ़ंक्शन को कॉल ।


1

आर

यह एक फ़ंक्शन बनाता है जो उपयोगकर्ता को शब्दों और विभाजकों के जोड़े को निर्दिष्ट करने की अनुमति देता है (और वैकल्पिक रूप से अधिकतम संख्या, डिफ़ॉल्ट के रूप में 100 के साथ)। फ़ंक्शन 1 से अधिकतम संख्या तक एक वेक्टर बनाता है, फिर "fizzbuzz" पदों पर "" के साथ किसी भी संख्या को बदलता है, और अंत में प्रत्येक शब्द को अपनी वांछित स्थिति में चिपकाता है। फ़ंक्शन सूची को निम्नतम से उच्चतम संख्या तक आदेश देता है ताकि सबसे कम संख्या हमेशा "फ़िज़बज़" का पहला भाग हो। seqकिसी निर्धारित संख्या पर शुरू होने और अधिकतम वांछित संख्या तक पहुंचने तक उस संख्या की वृद्धि में वेक्टर बनाने के लिए पदों की गणना की जाती है।

fizzbuzzer = function(max.num=100, ...){

input = list(...)
input = input[order(unlist(input))] #reorder input list by number
words = names(input)

#vector containing the result
output = seq_len(max.num)

#remove numbers at positions to contain a "fizzbuzz"
sapply(input, function(x) output[seq(x, max.num, x)] <<- "")

#add words at required points
sapply(seq_len(length(input)), function(i) output[seq(input[[i]], max.num, input[[i]])] <<- paste0(output[seq(input[[i]], max.num, input[[i]])], words[i]))

return(output)
}    

मुझे नहीं लगता कि यह बहुत सुंदर है, लेकिन विभिन्न मापदंडों के साथ फिर से उपयोग करना आसान है।

उपयोग के उदाहरण:

fizzbuzzer(fizz=3, buzz=5)
fizzbuzzer(fizz=3, buzz=5, jazz=4)
fizzbuzzer(max.num=10000, golf=10, stack=100, code=1, exchange=1000)

का उत्पादन fizzbuzzer(fizz=3, buzz=5) है:

[1] "1"        "2"        "fizz"     "4"        "buzz"     "fizz"    
[7] "7"        "8"        "fizz"     "buzz"     "11"       "fizz"    
[13] "13"       "14"       "fizzbuzz" "16"       "17"       "fizz"    
[19] "19"       "buzz"     "fizz"     "22"       "23"       "fizz"    
[25] "buzz"     "26"       "fizz"     "28"       "29"       "fizzbuzz"
[31] "31"       "32"       "fizz"     "34"       "buzz"     "fizz"    
[37] "37"       "38"       "fizz"     "buzz"     "41"       "fizz"    
[43] "43"       "44"       "fizzbuzz" "46"       "47"       "fizz"    
[49] "49"       "buzz"     "fizz"     "52"       "53"       "fizz"    
[55] "buzz"     "56"       "fizz"     "58"       "59"       "fizzbuzz"
[61] "61"       "62"       "fizz"     "64"       "buzz"     "fizz"    
[67] "67"       "68"       "fizz"     "buzz"     "71"       "fizz"    
[73] "73"       "74"       "fizzbuzz" "76"       "77"       "fizz"    
[79] "79"       "buzz"     "fizz"     "82"       "83"       "fizz"    
[85] "buzz"     "86"       "fizz"     "88"       "89"       "fizzbuzz"
[91] "91"       "92"       "fizz"     "94"       "buzz"     "fizz"    
[97] "97"       "98"       "fizz"     "buzz"    

(वर्गाकार कोष्ठकों में संख्याएँ वेक्टर के फंक्शन आउटपुट के सूचक हैं)


1

हास्केल

किसी भी मॉड्यूलर अंकगणित का उपयोग नहीं किया जाता है, अनावश्यक काम को दोहराने से बचने के लिए कम से कम सामान्य कई कंप्यूटिंग में। स्ट्रिंग संघनन केवल 60 बार किए जाने की आवश्यकता है, इससे कोई फर्क नहीं पड़ता कि हम ऊपरी सीमा निर्धारित करते हैं।

-- Don't repeat `transpose` from `Data.List`
import Data.List (transpose)

-- The desired problem
lst = [(3, "Fizz"), (4, "Jazz"), (5, "Buzz")]

-- Map a function over both sides of a tuple.
-- We could also get this from importing Bifunctor (bimap), bit it's not in the core libraries
bimap f g (x, y) = (f x, g y)

-- Make infinite lists with the word occuring only once every n items, starting with the first
fizzify = map (cycle . uncurry take . bimap id (:repeat ""))

-- Reorganize the lists so there's a single infinite list, smash the words together, and drop the first set.
fjb = tail . map concat . transpose . fizzify

-- The following two functions avoid repeating work building the lists
-- Computes the least common multiple of a list of numbers
lcms = foldr lcm 1

-- fjbLcm is just a more efficient version of fjb; they can be used interchangably
fjbLcm lst = cycle . take (lcms . map fst $ lst) . fjb $ lst

-- show the number if there aren't any words
result = zipWith (\x y -> if null x then show y else x) (fjbLcm lst) [1..100]

main = print result

के fjbLcmसाथ प्रतिस्थापित करना fjbबिल्कुल वैसा ही काम करता है, जिसमें सिवाय [1..100]और इसके अलावा किसी भी अंकगणित का उपयोग नहीं किया गया है take


यह अनिवार्य रूप से निमी के समाधान के समान है , जिसे मैंने पहले नोटिस नहीं किया था।
साइरडेक

1

को Python2

अपडेट: नया संस्करण किसी भी मॉड या डिवीजन ऑपरेशन का उपयोग नहीं करता है।

word_dict = {3: 'Fizz', 4: 'Jazz', 5: 'Buzz'}

def fizz_jazz_buzz(n, d):
    counters = {k: k for k in d}
    for i in xrange(1, n + 1):
        u = ''
        for k in d:
            if counters[k] == i:
                u += d[k]
                counters[k] += k
        print u or i

fizz_jazz_buzz(100, word_dict)

यदि आप परीक्षण में एक और शब्द जोड़ना चाहते हैं, तो कुंजी / मान जोड़ी को शब्द_ डिक्शन डिक्शनरी में फेंक दें:

word_dict[7] = 'Razz'
fizz_jazz_buzz(100, word_dict)

यदि आप किसी शब्द से छुटकारा चाहते हैं, तो बस इसे हटाएं (उपयोग करके del) या वैकल्पिक रूप से इसे सेट करें ''

del word_dict[3]
fizz_jazz_buzz(100, word_dict)

Gnibbler और Jakube के पायथन उत्तर भी देखें , जो कि खदान से पहले पोस्ट किए गए थे।


1

सी#

अनुरक्षणता:
शब्दकोश में प्रत्येक तत्व पर एक लाइन प्रति तत्व I iterate जोड़ते हैं , यह जाँचने के लिए कि क्या यह वर्तमान संख्या का भाजक है, और यदि है तो स्ट्रिंग में जोड़ दें।
एक बार समाप्त होने पर, स्ट्रिंग को प्रिंट करें, जब तक कि यह अभी भी अशक्त (अशक्त coalescing संचालक का उपयोग कर), जिस स्थिति में यह स्ट्रिंग बनाने के लिए नंबर प्लस को एक खाली स्ट्रिंग प्रिंट करता है। (मैं उपयोग कर सकता था स्ट्रिंग, लेकिन मुझे लगता है कि यह एक व्यक्तिगत पसंद है)

Dictionary<int, string> dict = new Dictionary<int, string>()
{
    {3, "Fizz"},
    {4, "Jazz"},
    {5, "Buzz"}
};
for (int i = 0; i < 100; i++)
{
    string msg = null;
    foreach (var pair in dict)
        if (i % pair.Key == 0)
            msg += pair.Value;
    Console.WriteLine(msg ?? i + "");
}
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.