चुनौती

इनपुट:

2 और 62 (सम्मिलित) के बीच एक पूर्णांक $b$ ।

आउटपुट:

अंकों के लिए किसी भी उचित प्रतिनिधित्व का उपयोग करते हुए, बेस में $1$ से लेकर के बराबर तक की गणना करें । $5000_{10}$ $b$

तथापि:

यदि संख्या (नीचे दी गई है, उदाहरण के लिए बेस 7 = 3.5, 3.5 + 1 = 4.5 होगा, 4 के लिए गोल ), तो आउटपुट 'Fizz' नंबर के बजाय । $\lfloor b÷2+1\rfloor$
यदि संख्या (राउंड अप, उदाहरण के लिए 11/3 = 3.666, 3.666 + 3 = 6.666, 7 के लिए गोल ) से विभाज्य है , तो आउटपुट 'बज़'। $\lceil b÷3+3\rceil$
जैसा कि आप शायद अनुमान लगा सकते हैं, यदि आपका नंबर दोनों से विभाज्य है, तो आउटपुट 'फ़िज़बज़'।

उदाहरण

अंकों के रूप में [0-9] , [AZ] और [az] का उपयोग करना

(मैंने उदाहरणों को छोटा रखने के लिए केवल पहले 10 मान शामिल किए हैं - सामान्य रूप से प्रत्येक क्रम में 4990 अधिक आइटम होंगे)

इनपुट: 10 (इसलिए 'फ़िज़' = 6 और 'बज़' = 7)

आउटपुट: 1, 2, 3, 4, 5, फ़िज़, बज़, 8, 9, 10

इनपुट: 2 (इसलिए 'फ़िज़' = 2 और 'बज़' = ४)

आउटपुट: 1, फ़िज़, 11, फ़िज़बज़, 101, फ़िज़, 111, फ़िज़बज़, 1001, फ़िज़

(मैंने यह दिखाने के लिए कि वे कैसे काम करते हैं, निम्नलिखित में से पहले 50 मूल्यों को शामिल किया है)

इनपुट: 55 (इसलिए 'फ़िज़' = $28_{10}$ = $s_{55}$ और 'बज़' = $22_{10}$ = $m_{55}$ )

आउटपुट: 1, 2, 3, 4, 5, 6, 7, 8, 9, ए, बी, सी, डी, ई, एफ, जी, एच, आई, जे, के, एल, बज़, एन, ओ, पी, क्यू, आर, फ़िज़, टी, यू, वी, डब्ल्यू, एक्स, वाई, जेड, ए, बी, सी, डी, ई, एफ, जी, एच, आई, जे, के, एल, एम, एन

नियम

मानक खामियों को मना किया जाता है
यह कोड गोल्फ है, इसलिए बाइट्स जीत में सबसे छोटा जवाब है
इनपुट और आउटपुट कंसोल, या फ़ंक्शन तर्क / रिटर्न के माध्यम से हो सकते हैं
खाली स्थान के रूप में सफेद जगह को छोड़ना / पीछे जाना ठीक है
'फ़िज़' और 'बज़' के बीच रिक्तियाँ अस्वीकृत हैं
'फ़िज़' / 'बज़' / 'फ़िज़बज़' का कोई भी पूंजीकरण संस्करण ठीक है।
आउटपुट को न्यूलाइन्स द्वारा अलग किया जाना चाहिए।
यदि आप वर्णों का प्रतिनिधित्व करने के बजाय आधार 10 'अंकों' की एक सरणी लौटाते हैं, तो उन्हें सही क्रम में होना चाहिए!

code-golf math binary

— गीज़ा केरेसेनी
स्रोत

2

मैं वास्तव में बुरा नहीं मानता। यदि आप अंकों के बजाय इमोजी का उपयोग करना चाहते हैं, तो मुझे अभी भी कोई आपत्ति नहीं है। यह आधार है जो मायने रखता है, प्रतिनिधित्व नहीं।

— गीज़ा केरेसेनई

2

ठीक है, अब स्पष्ट किया।

— गीज़ा केर्केसेनी

5

तकनीकी रूप से, बेस 36 में यह शब्द buzzइंडेक्स 553391, fizzएट 724463और fizzbuzzएट में ही प्रकट होता है 1216820199599। अफसोस की बात है कि उनमें से कोई भी उस आधार की संख्याओं से विभाज्य नहीं है

— जो राजा

3

मूल FizzBuzz का आधार 10 क्यों नहीं है? : मैं एक एल्गोरिथ्म के बारे में नहीं सोच सकता था जो दोनों आधार संख्या में मूल संख्या उत्पन्न करेगा, और अन्य ठिकानों में अच्छी तरह से स्थानांतरित होगा। और मैं इससे इनकार करने के लिए एक विशेष मामला नहीं जोड़ना चाहता था क्योंकि यह सिर्फ मेरी राय में सवाल को उलट देगा।

— गीज़ा केर्केसेनी

3

अपनी भविष्य की चुनौतियों के लिए, कृपया अधिक लचीला I / O की अनुमति देने पर विचार करें। चुनौतियों को लिखते समय बचने के लिए बोझिल I / O प्रारूप चीजों में सबसे अधिक उत्कीर्ण विषय है ।

— अरनौलड

3

जेली , 42 38 34 33 29 32 बाइट्स

+3 सख्त प्रारूपण नियमों का पालन करना

5ȷɓ;8Ä:2,3‘ḍȧ"“Ƈ×“=%»ḟ0Fȯb@K¥ð€Y

एक पूरा कार्यक्रम है जो पाठ के 5000 लाइनों, प्रत्येक पंक्ति एक (अंक) में से एक पूर्णांक श्रृंखला या युक्त प्रिंट fizz, buzzया fizzbuzz(आधार 62 से बाहर ठीक काम करता है)।

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

कैसे?

ध्यान दें कि
$\lfloor b÷2+1\rfloor\ = \lfloor b÷2\rfloor+1$
... और
$\lceil b÷3+3\rceil = \lceil b÷3+2\rceil+1 = \lceil (b+6)÷3\rceil+1 = \lfloor (b+8)÷3\rfloor+1$

अद्यतन करने ...

5ȷɓ;8Ä:2,3‘ḍȧ"“Ƈ×“=%»ḟ0Fȯb@ð€ - Link: integer, b
5ȷ                            - 5*10³ = 5000
  ɓ                        ð€ - for €ach n in [1,2,...,5000] get this f(b,n):
    8                         -   eight
   ;                          -   concatenate      -> [b,8]
     Ä                        -   cumulative sums  -> [b,b+8]
       2,3                    -   pair literal        [2,3]
      :                       -   integer division -> [b//2, (b+8)//3]
          ‘                   -   increment        -> [b//2+1, (b+8)//3+1]
           ḍ                  -   divides n?       -> [n is fizzy?, n is buzzy?]
              “Ƈ×“=%»         -   list of dictionary strings = ['fizz','buzz']
             "                -   zip with:
            ȧ                 -     logical AND    -> [0,0], ['fizz',0], [0,'buzz'],
                              -                       or ['fizz','buzz']
                      0       -   zero
                     ḟ        -   filter discard   -> [], ['fizz'], ['buzz'],
                              -                       or ['fizz','buzz']
                       F      -   flatten          -> [], ['fizz'], ['buzz'],
                              -                       or ['fizzbuzz']
                          @   -   using swapped arguments:
                         b    -     (n) to a list of digits in base (b)  (say, [nb])
                        ȯ     -   logical OR       -> [nb], ['fizz'], ['buzz'],
                              -                       or ['fizzbuzz']

— जोनाथन एलन
स्रोत

चुनौती में कहा गया है कि उत्पादन अलग-अलग लाइनों पर होना चाहिए

— अज्ञानता का अवतार

सच। हालांकि मैं प्रतिनिधित्व के साथ ठीक हूं (हालांकि यह सीमा रेखा है), एक सरणी को आउटपुट करना गेम खेलने के समान नहीं है। हालाँकि, यदि आप प्रत्येक पंक्ति पर अंकों के सरणी का उत्पादन करते हैं, तो मैं इसे स्वीकार करूँगा।

— गीज़ा केरेसेनई

3

@GezaKerecsenyi अपडेट किया गया। हालाँकि, मुझे समझ नहीं आया कि प्रतिनिधित्व "बॉर्डरलाइन" कैसे है - बेस बी में अंक

। या किसी सरणी को कैसे आउटपुट करना "गेम खेलना" नहीं है ("इनपुट और आउटपुट कंसोल के माध्यम से हो सकता है, या फ़ंक्शन तर्क / रिटर्न")। कुछ अन्य मनमाने आउटपुट का उपयोग करना उतना ही सरल है जितना कि प्रतिस्थापन और स्वरूपण चुनौती के मूल में सिर्फ बॉयलरप्लेट और ऑर्थोगोनल है।

[0, n - 1]

$[0,n-1]$

— जोनाथन एलन

एक संख्यात्मक कार्यान्वयन इस तरह के संख्यात्मक आधार के बजाय वांछित अंकों की एक सूची ले सकता है ।

— जोनाथन एलन

3

चारकोल , 40 बाइट्स

ＮθＥ…·¹×⁵φ∨⁺⎇﹪ι⊕÷θ²ωFizz⎇﹪ι÷⁺¹¹θ³ωBuzz⍘ιθ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

Ｎθ                                      Input `b` into variable `q`
   ¹                                    Literal 1
 …·                                     Inclusive range to
      φ                                 Predefined variable 1000
    ×                                   Multiplied by
     ⁵                                  Literal 5
Ｅ                                       Map to
           ι                            Current value
          ﹪                             Modulo
              θ                         Input value
             ÷                          Floor divide
               ²                        Literal 2
            ⊕                           Incremented
         ⎇                              If nonzero
                ω                       Then predefined empty string
                 Fizz                   Otherwise literal `Fizz`
        ⁺                               Concatenated with
                       ι                Current value
                      ﹪                 Modulo
                            θ           Input value
                         ⁺              Plus
                          ¹¹            Literal 11
                        ÷               Integer divided by
                             ³          Literal 3
                     ⎇                  If nonzero
                              ω         Then predefined empty string
                               Buzz     Otherwise literal `Buzz`
       ∨                                Logical Or
                                    ι   Current value
                                   ⍘    Converted to base
                                     θ  Input value
                                        Implicitly print each result on its own line

— नील
स्रोत

3

आर , 163 131 बाइट्स

b=scan();for(d in 1:5e3)cat(list(d%/%b^rev(0:log(d,b))%%b,'fizz','buzz','fizzbuzz')[[1+(!d%%((b+2)%/%2))+2*!d%%((b+11)%/%3)]],'\n')

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

23 बाइट बचाने के लिए @digEmAll को धन्यवाद। मैं तो आगे 9 को बचाने के लिए @ digEmAll के प्रयासों को आगे बढ़ाया।

— निक केनेडी
स्रोत

140 बाइट मैंने आपके उत्तर को देखे बिना इस पर काम किया, लेकिन यह किसी अन्य पोस्ट के लिए भी समान है;)

— डाइजेक्सिल

@digEmAll धन्यवाद। मैंने आगे 131 बाइट पाने के लिए आपके जवाब को गला दिया है और आपको क्रेडिट दिया है; आशा है कि यह ठीक है।

— निक केनेडी

पूर्ण रूप से ! ;)

— डाइजेक्सिल

BTW, यदि आपके पास R में गोल्फिंग के बारे में कोई चर्चा है, तो इस चैट

— digEmAll

उफ़, पता ही नहीं चला कि आर उत्तर पहले से ही था, मेरा उत्तर थोड़ा और गोल्फ के लिए मददगार हो सकता है?

— एएससीआईआई-केवल

3

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

$19_{20}$ $19$ $21_{20}$ $1,1$

b=>(g=n=>n>1?g(n-1)+`
`+((s=n%(b+2>>1)?'':'Fizz',n%(b/3+3.9|0)?s:s+'Buzz')||(g=n=>n?[...g(n/b|0),n%b]:s)(n)):1)(5e3)

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

(100 तक सीमित ताकि टीआईओ का आउटपुट न उड़ जाए)

— Arnauld
स्रोत

कोई भी मौका आप बता सकते हैं कि क्या |0और क्या (5e3)करता है?

— njras

0

$0$

n

$n$ Math.floor(n)

0 \leq n < 2^{31}

$0\le n<2^{31}$ 5e35000

g

$g$

2

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

b=input()
i=0
exec"a=i=i+1;d=[]\nwhile a:d=[a%b]+d;a/=b\nprint'Fizz'*(i%(b/2+1)<1)+'Buzz'*(i%(~-b/3+4)<1)or d;"*5000

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

या के साथ 0-9a-zA-Z आउटपुट के :

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

b=input()
i=0
exec"a=i=i+1;d=''\nwhile a:d=chr(a%b+48+(a%b>9)*39-a%b/36*58)+d;a/=b\nprint'Fizz'*(i%(b/2+1)<1)+'Buzz'*(i%(~-b/3+4)<1)or d;"*5000

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

— लिन
स्रोत

1

05AB1E , 39 37 36 बाइट्स

8+‚U5₄*LεX23S÷>Ö”FizzÒÖ”#×JDõQiyIв]»

-2 बाइट्स @JonathanAllan के जेली उत्तर का एक पोर्ट बनाकर ।

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें (लेकिन सूची-आउटपुट के रूप में और 5000 के बजाय पहले 100 के साथ)।

स्पष्टीकरण:

8+               # Add 8 to the (implicit) input
  ‚              # Pair it with the (implicit) input
   U             # Pop and store it in variable `X`
5₄*L             # Create a list in the range [1,5000]
    ε            # Map each value `y` to:
     X23S÷       #  Integer-divide the input by 2, and the input+8 by 3
          >      #  Increase both by 1
           Ö     #  Check for both if they divide value `y` evenly (1 if truthy; 0 if falsey)
     ”FizzÒÖ”    #  Push dictionary string "Fizz Buzz"
             #   #  Split on spaces
              ×  #  Repeat the strings the result amount of times (0 or 1)
               J #  Join both strings together to a single string
     DõQi        #  If this string is empty:
         yIв     #   Push value `y` in Base-input (as list) instead
    ]            # Close the if-statement and map
     »           # Join the list by new-lines (and inner lists by spaces implicitly)
                 # (and output the result implicitly)

मेरा यह 05AB1E टिप (खंड) देखें कैसे शब्दकोश उपयोग कैसे करें? ) को समझने के लिए क्यों”FizzÒÖ”है"Fizz Buzz"।

— केविन क्रूज़सेन
स्रोत

मेरे पास 33 बाइट्स में एक लूपिंग संस्करण है, यदि आप इसे आज़माना चाहते हैं और इसे अनुकूलित करना चाहते हैं। जेली की तुलना में अभी भी एक बाइट लंबी है :(

— एमिग्ना

@Emigna क्या आपने पहले ही इसे पोस्ट कर दिया है? या यह मेरे उत्तर के समान है और यह एक गोल्फ के रूप में है? पुनश्च: जेली में कुछ शॉर्ट-कट बिल्डिंस हैं उदाहरण के लिए [input, input+8]भाग, और फिल्टर भाग बाद में (जो मैं अब जैसा करता हूं DõQi yIв, लेकिन मुझे लगता है कि इसे कुछ और लगाया जा सकता है ..)

— केविन क्रूज़सेन

लेवेन्शिन-दूरी के हिसाब से यह आपसे बहुत अलग है (हालाँकि भागों को आपकी तरह अधिक दोबारा लिखा जा सकता है)। लेकिन मैं जोनाथन की n + 8 ट्रिक का भी इस्तेमाल करता हूं, इसलिए मुझे लगा कि अगर आप चाहें तो मैं आपको इस दिशा में ले जाने की कोशिश करूंगा। अन्यथा मैं इसे एक अलग उत्तर के रूप में पोस्ट करूंगा।

— एमिगा

@Eigna मैं वर्तमान में काम में थोड़ा व्यस्त हूं, इसलिए वास्तव में इस जवाब को गोल्फ के लिए समय नहीं है। इसलिए यदि आप चाहें तो इसे अपने उत्तर के रूप में पोस्ट कर सकते हैं। तुमने मेरा उत्थान किया है। ;)

— केविन क्रूज़सेन

दुर्भाग्य से मैंने अपने संस्करण में एक बग की खोज की तो अब यह 34 है। मेरे पास कुछ विचार हैं जो आपके या मेरे छोटे हो सकते हैं जिन्हें मैं बाद में खोजूंगा। जेली को पीटना / बांधना अब कठिन लगता है।

— 15

0

पर्ल 6 , 91 बाइट्स

{$!=0;('Fizz'x++$!%%($_/2+|0+1)~'Buzz'x$!%%(($_+8)/3+|0+1)||[R,] $!.polymod($_ xx*))xx𐄦}

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

बेनामी कोड ब्लॉक जो आधार में पूर्णांकों की Fizz/Buzz/FizzBuzzया तो स्ट्रिंग्स की या ~~उलटी~~ सूची की सूची लौटाता है ।

— मजाक कर रहा है
स्रोत

कोडगुल्फ.स्टैकएक्सचेंज . com/questions/180247/… देखें । मैंने इस बारे में प्रश्न में एक स्पष्टीकरण जोड़ा है।

— गीज़ा केर्केसेनी

0

आर , 138 बाइट्स

function(b,`*`=rep)Map(function(i)"if"((s=paste0("","Fizz"*!i%%(b%/%2+1),"Buzz"*!i%%((b+11)%/%3)))>0,s,i%/%b^((log(i,b)%/%1):0)%%b),1:5e3)

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

— ASCII-केवल
स्रोत

0

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 180 171 बाइट्स

n=>{for(int i=1,p;i<5001;){p=i;var j=new Stack<int>();for(;p>0;p/=n)j.Push(p%n);var s=i%(n/2+1)<1?"Fizz":"";Print(i++%((n+8)/3+1)<1?s+"Buzz":s==""?string.Join("-",j):s);}}

अरनॉल्ड के उत्तर जैसे आउटपुट। आउटपुट को उलटने के लिए स्टैक का उपयोग करने के विचार के लिए digEmAll का धन्यवाद।

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

— अज्ञान का अवतार
स्रोत

1

मैं उल्टे अंकों को 'नहीं' कहने जा रहा हूं। हालांकि यह सही विचार गणितीय है, यह नहीं है Fizzbuzz कार्यक्रम का कहना है कि एक नियोक्ता चाहते हैं। यह दुर्भाग्यपूर्ण है कि C # में एक रिवर्स रिवर्स फ़ंक्शन नहीं है।

— गीज़ा केर्केसेनी

0

05AB1E , 34 बाइट्स

जोनाथन की गणितीय अंतर्दृष्टि का उपयोग करता है ceil(n/3+3)=floor((n+8)//3)+1

ŽJćG8+‚2L>÷>NsÖ…™Ázz'ÒÖ‚×JNIв‚õKн,

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

व्याख्या

ŽJćG                                # for N in [1 ...5001)
    8+‚2L>÷>                        # push [input//2+1, (input+8)//3+1]
            NsÖ                     # check each if N is divisible by it
               …™Ázz                # push "fizz"
                    'ÒÖ             # push "buzz"
                       ‚            # pair
                        ×           # repeat a number of times corresponding to the result of the 
                                    # divisibility test
                         J          # join to string
                          NIв‚      # pair with N converted to base <input>
                              õK    # remove empty string
                                н,  # print head of the remaining list

— Emigna
स्रोत

किसी भी आधार में फ़िज़बज़

चुनौती

उदाहरण

नियम

जेली , 42 38 34 33 29 32 बाइट्स

कैसे?

चारकोल , 40 बाइट्स

आर , 163 131 बाइट्स

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

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

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

05AB1E , 39 37 36 बाइट्स

पर्ल 6 , 91 बाइट्स

आर , 138 बाइट्स

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 180 171 बाइट्स

05AB1E , 34 बाइट्स