परिचय

मुझे विशेष रूप से पता नहीं है कि फ़िज़ी बज़ कहाँ से आया है। यह सिर्फ एक मेम या कुछ हो सकता है, लेकिन यह कुछ हद तक लोकप्रिय है।

चुनौती

आपका काम आज फ़िज़ी बज़ को क्रमशः बाइनरी (0, 1) में बदलना है और उस बाइनरी को टेक्स्ट में बदलना है। सुंदर मानक सामान।

वह कैसे काम करता है?

FizzBuzzBuzzFizzBizzFizzFizzFizz FizzBuzzBuzzFizzBizzFizzBizzFizzFizzFizzBuzz 01101000 01101001 में अनुवाद करेगा, फिर "हाय" में अनुवाद होगा।

प्रतिबन्ध

इनपुट एक द्विआधारी दृष्टिकोण में फ़िज़ बज़ है (नीचे उदाहरण देखें)
आउटपुट टेक्स्ट होना चाहिए।
आप मान सकते हैं कि FizzBuzz इनपुट सही है।
यह कोड-गोल्फ , सबसे छोटी बाइट्स जीत है।

इनपुट

FizzBuzzBuzzFizzBizzFizzFizzFizzFizzBuzzBizzFizzBizzFizzFizzBizz

उत्पादन

"नमस्ते!"

code-golf binary

— KuanHulio
स्रोत

15

मेमे? यह एक प्राथमिक (प्राथमिक) स्कूल खेल है

— बीटा

2

क्या हम इनपुट में स्पेस नहीं ले सकते?

— हाइपरएन्यूट्रीनो

2

क्या हम उस स्थान को नहीं ले सकते हैं? यदि मुझे उस स्थान पर इनपुट नहीं करना है तो मैं तीन बाइट्स बचा सकता हूं।

— हाइपरएनुट्रिनो

10

FizzBuzz के हिस्से में ढेर मुद्रा पर बहुत अधिक आनंद मिलता है क्योंकि जोएल (संस्थापकों में से एक ) के पास एक ब्लॉग पोस्ट था जिसमें एक अन्य ब्लॉग का उल्लेख किया गया था जो प्रोग्रामिंग आवेदकों के लिए प्रवेश समस्या के लिए एक कम बाधा के रूप में उपयोग करने के बारे में बात करता था ।

— dmckee

8

@Modee "एक और ब्लॉग" है कि जोएल संदर्भ जेफ एटवुड का है, जो स्टैकओवरफ़्लो के दूसरे संस्थापक हैं।

— pilsetnieks

55

सी, 59 बाइट्स

i;f(char*s){while(*s&3?*s&9||(i+=i+*s%5):putchar(i),*s++);}

मैजिक नंबर, मैजिक नंबर हर जगह!

(इसके अलावा, पायथन, जेएस, पीएचपी और रूबी से कम सी? अनसुना!)

यह एक फ़ंक्शन है जो इनपुट के रूप में एक स्ट्रिंग लेता है और STDOUT को आउटपुट करता है।

पूर्वाभ्यास

मूल संरचना है:

i;           // initialize an integer i to 0
f(char*s){
while(...);  // run the stuff inside until it becomes 0
}

यहां, "सामान के अंदर" कोड का एक गुच्छा है ,*s++, जिसके बाद अल्पविराम ऑपरेटर अपने दूसरे तर्क का केवल मूल्य देता है। इसलिए, यह स्ट्रिंग के माध्यम से चलेगा और बाहर निकलने से पहले, *sNUL बाइट (पोस्टफ़िक्स ++पिछले मूल्य को वापस करने के बाद ) सहित प्रत्येक वर्ण पर सेट होगा ।

आइए बाकी पर एक नज़र डालें:

*s&3?*s&9||(i+=i+*s%5):putchar(i)

टर्नरी और शॉर्ट सर्कुलेटिंग को छीलकर ||, इसका विस्तार किया जा सकता है

if (*s & 3) {
    if (!(*s & 9)) {
        i += i + *s % 5;
    }
} else {
    putchar(i);
}

ये मैजिक नंबर कहां से आते हैं? इसमें शामिल सभी पात्रों के द्विआधारी निरूपण हैं:

F  70  01000110
B  66  01000010
i  105 01101001
z  122 01111010
u  117 01110101
   32  00100000
\0 0   00000000

पहले, हमें बाकी वर्णों से स्थान और NUL को अलग करने की आवश्यकता है। जिस तरह से यह एल्गोरिथ्म काम करता है, यह "वर्तमान" संख्या का एक संचायक रखता है, और इसे तब तक प्रिंट करता है जब यह किसी स्थान या स्ट्रिंग के अंत (यानी '\0') तक पहुंच जाता है । यह देखते हुए कि ' 'और '\0'केवल दो ही महत्वपूर्ण बिट्स सेट नहीं करने के लिए एकमात्र वर्ण हैं, हम 0b11चरित्र को स्थान या NUL और नॉनज़ेरो अन्यथा शून्य कर सकते हैं।

गहरी खुदाई, पहले "अगर" शाखा में, अब हमारे पास एक ऐसा चरित्र है जो एक है FBizu। मैंने केवल Fएस और Bएस पर संचायक को अपडेट करने के लिए चुना , इसलिए मुझे एस को फ़िल्टर करने के लिए किसी तरह की आवश्यकता थी izu। आसानी से, Fऔर Bदोनों के पास केवल दूसरा, तीसरा या सातवाँ महत्वपूर्ण बिट सेट है, और अन्य सभी नंबरों में कम से कम एक बिट सेट है। वास्तव में, वे सभी पहले या चौथे कम से कम महत्वपूर्ण बिट हैं। इसलिए, हम बिटवाइज़ कर सकते हैं और साथ 0b00001001, है, जो 9 के लिए 0 निकलेगा जो Fऔर Bऔर अशून्य अन्यथा।

एक बार हमने तय किया है कि हम एक है कि Fया Bतो हम उनका मैप कर सकते हैं 0और 1, उनके मापांक 5 लेकर क्रमशः क्योंकि Fहै 70और Bहै 66। फिर स्निपेट

i += i + *s % 5;

कहने का सिर्फ एक गोल्फ का तरीका है

i = (i * 2) + (*s % 5);

जिसे भी व्यक्त किया जा सकता है

i = (i << 1) | (*s % 5);

जो कम से कम महत्वपूर्ण स्थिति में नया बिट सम्मिलित करता है और 1 से अधिक सब कुछ बदलता है।

"लेकिन रुकें!" आप विरोध कर सकते हैं। "आपके द्वारा प्रिंट करने के बाद i, इसे कभी भी 0 पर रीसेट कब किया जाता है?" ठीक है, putcharइसके तर्क को a में रखता है unsigned char, जो कि आकार में 8 बिट्स होता है। इसका मतलब है कि 8 वीं सबसे कम महत्वपूर्ण बिट (यानी पिछले पुनरावृत्तियों से रद्दी) को फेंक दिया गया है, और हमें इसके बारे में चिंता करने की आवश्यकता नहीं है।

के लिए धन्यवाद @ETHproductions को बदलने के लिए सुझाव देने के लिए 57साथ 9, एक बाइट बचत!

— Doorknob
स्रोत

पुचर के साथ अच्छी चाल।

— कम्प्यूट्रोनियम

यह reeeeally भयानक है। सी ने सही किया!

— गुस्तावो मैकिएल

13

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

— कोड़ी ग्रे

3

@CodyGray बिल्कुल यह। एक कारण है कि कोड गोल्फ मेरे एसई के शीर्ष पर नहीं है जिसे मैं बार-बार देखता हूं क्योंकि बहुत सारे उत्तर "यहां एक कोड" हैं। जबकि यह उन लोगों के लिए अच्छा है जो भाषाओं से बहुत परिचित हैं, यह सिर्फ मेरे लिए शोर की तरह दिखता है। मुझे यहाँ की तरह स्पष्टीकरण देखना पसंद है क्योंकि यह विधि को प्रकट करता है , जो मुझे लगता है कि अधिकांश लोग कोड की तुलना में बहुत अधिक दिलचस्प पाते हैं। बस मेरे दो सेंट ...

— क्रिस Cirefice

बहुत अच्छी बिटकॉइन, लेकिन आप अपने बिट्स को MSB (बाएं) से LSB (दाएं) तक गिनते हैं? IMO 8-बिट बाइट (या 128-बिट SIMD वेक्टर, या जो भी) में बिट्स की गणना करने का एकमात्र एकमात्र तरीका है LSB = बिट 0 से MSB = बिट 7.

— पीटर कॉर्ड

10

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

Ḳm€4O%5ḄỌ

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

— आउटग्रॉफर को एरिक करें
स्रोत

ओह स्मार्ट, चपटा होना अनावश्यक था। अच्छा लगा।

— हाइपरएनुट्रिनो

@HyperNeutrino आपके द्वारा की गई टिप्पणी पर ध्यान दें, मैंने थोड़े अलग एल्गोरिथ्म का उपयोग किया है ताकि ठगने से बचें (भले ही तकनीकी रूप से मुझे यह पसंद न हो)।

— एरिक आउटोलॉफ़र

@downvoter: क्या आपने ड्राइव-डाउन डाउनवॉटिंग से पहले इसका परीक्षण किया था?

— आउटगॉल्फ को एरिक करें

9

बैश + कोरुटिल्स, 61 50 बाइट्स

(-11 बाइट्स डोर्कनोब के लिए धन्यवाद !)

tr -d izu<<<$1|tr FB 01|dc -e'2i?[aPz0<k]dskx'|rev

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

— आर। कप
स्रोत

2

आप 11 बाइट्स को बचाने के लिए के sedसाथ बदल सकते हैं tr FB 01|tr -d izu।

— दरवाज़े

9

पायथन 3 , 169 101 93 91 85 81 बाइट्स

lambda s,j="".join:j(chr(int(j('01'[b<"C"])for b in c[::4]),2))for c in s.split())

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

स्पष्टीकरण:

lambda s,j="".join:  # Create a lambda function
    j(  # call "".join, adds characters together with nothing in between
        chr(  # character by int
            int(  # string to int
                j(  # "".join again
                    '01'[b<"C"]  # 1 or 0, based on what character we get
                    for b in c[::4]  # For every first of 4 characters
                ),
                2)  # Base 2
        )
        for c in s.split()  # for every group of Fizz and Buzz with any whitespace character after it
    )

— Martmists
स्रोत

यह तेज़ था। +1

— हाइपरएन्यूट्रीनो

मैंने कुछ समय पहले ऐसा ही किया था, यह सिर्फ कॉपी-पेस्ट की बात थी और इसे बदलकर FizzBuzz: P

— Martmists

1

ओह, जो बताते हैं। : पी लेकिन आप आउटगोल्ड हो गए? _;

— हाइपरएन्यूट्रीनो

1

फिर से आउटगोल्फ्ड - इसे ऑनलाइन आज़माएं! (89 बाइट्स)

— मिस्टर एक्सकोडर

1

वूप्स, इसे फिर से किया , 85 बाइट्स इस बार एक lambdaसमारोह के साथ

— श्री एक्सकोडर

8

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

let f =

s=>`${s} `.replace(/.{4} ?/g,m=>m[s=s*2|m<'F',4]?String.fromCharCode(s&255):'')

console.log(f("FizzBuzzBuzzFizzBuzzFizzFizzFizz FizzBuzzBuzzFizzBuzzFizzFizzBuzz FizzFizzBuzzFizzFizzFizzFizzBuzz"))

स्निपेट का विस्तार करें

— Arnauld
स्रोत

बहुत अच्छा। मैंने कोशिश की है और कम कुछ के साथ आने में विफल रहा है, हालांकि वहाँ कई वैकल्पिक 80-बाइट का उपयोग कर समाधान कर रहे हैं .replace(/..zz/g,, '0b'+आदि

— ETHproductions

@ETHproductions n79 तक पहुंचने की अनुमति देता है। अफसोस की बात यह है कि इनपुट में अतिरिक्त स्थान की आवश्यकता होती है। इसलिए बल्कि महंगा है `${s} ` ।

— अरनौलद

7

जाप , 26 24 19 17 बाइट्स

¸®ë4 ®c u5Ãn2 dÃq

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

सहेजे गए 2 बाइट्स @ धन्यवाद और 2 बाइट्स @ETHproductions के लिए धन्यवाद

व्याख्या

input: "FizzBuzzBuzzFizzBuzzFizzFizzFizz FizzBuzzBuzzFizzBuzzFizzFizzBuzz FizzFizzBuzzFizzFizzFizzFizzBuzz"

¸®                // ["FizzBuzzBuzzFizzBuzzFizzFizzFizz","FizzBuzzBuzzFizzBuzzFizzFizzBuzz","FizzFizzBuzzFizzFizzFizzFizzBuzz"]
  ë4              // ["FBBFBFFF","FBBFBFFB","FFBFFFFB"]
     ®c           // [[70,66,66,70,66,70,70,70],[70,66,66,70,66,70,70,66],[70,70,66,70,70,70,70,66]]
        u5Ã       // ["01101000","01101001","00100001"]
           n2     // [104,105,33]
              d   // ["h","i","!"]
               Ãq // "hi!"

— powelles
स्रोत

1

आप 2 जगह ले सकता है })के साथ Ã। वहाँ निश्चित रूप से अधिक से अधिक बचाया जा सकता है, लेकिन मैं इसे अपने फोन पर काम नहीं कर पा रहा हूं।

— झबरा

1

बहुत अच्छा, Japt का उपयोग करने के लिए धन्यवाद! आप के ò4...q n2साथ बदलकर एक युगल बाइट बचा सकता है ë4...n2( ë4केवल एक ही वस्तु को ò4छोड़कर, जैसा कि होता है, अजीब तरह से, यह प्रलेखित नहीं लगता है)

— ETHproductions

1

@ETHproductions जाप बनाने के लिए धन्यवाद!

— पोवेल्स

6

रूबी, 65 63 60 बाइट्स

->s{s.split.map{|x|x.gsub(/..../){$&.ord%5}.to_i(2).chr}*''}

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

->s{
s.split            # split on whitespace
.map{|x|           # for each word as x,
  x.gsub(/..../){  # replace each sequence of four characters with
    $&.ord%5       # the ASCII value of the first character, mod 5
                   # F is 70, B is 66, so this yields 0 for Fizz and 1 for Buzz
  }.to_i(2)        # interpret as a binary number
  .chr             # the character with this ASCII value
}*''               # join on empty string
}

— Doorknob
स्रोत

6

जावास्क्रिप्ट (ईएस 6), 95 88 85 81 बाइट्स

s=>s.replace(/..zz/g,m=>m<"F"|0).replace(/\d+ ?/g,m=>String.fromCharCode("0b"+m))

4 बाइट्स ETHproductions के लिए धन्यवाद बचा लिया ।

कोशिश करो

f=
s=>s.replace(/..zz/g,m=>m<"F"|0).replace(/\d+ ?/g,m=>String.fromCharCode("0b"+m))
oninput=_=>o.innerText=f(i.value)
o.innerText=f(i.value="FizzBuzzBuzzFizzBuzzFizzFizzFizz FizzBuzzBuzzFizzBuzzFizzFizzBuzz FizzFizzBuzzFizzFizzFizzFizzBuzz")

*{font-family:sans-serif}

<input id=i><p id=o>

स्निपेट का विस्तार करें

— झबरा
स्रोत

मेरा मानना है कि +तुलना में कम हैparseInt

— Kritixi lithos

2

मुझे लगता है कि +(m[0]<"F")छोटा किया जा सकता हैm<"F"|0

— ETHproductions

5

पर्ल 5, 33 बाइट्स

print(pack'B*',<>=~y/FB -z/01/dr)

क्रमशः 0 और 1 के इनपुट में 'F' और 'B' को बदल देता है और अन्य वर्णों को हटा देता है। यह तब packASCII वर्णों में इस बिट स्ट्रिंग को चालू करने के लिए पर्ल के फ़ंक्शन का उपयोग करता है ।

— faubi
स्रोत

वाह, यह मेरे पर्ल 5 प्रयास के लगभग आधे आकार का है। कुडोस।

— डेविड कॉनरैड

1

मेरा मानना है कि आप -p0कमांड लाइन विकल्प का उपयोग करके इसे काफी कम कर सकते हैं (जो आपको <>=~rइनपुट के लिए बचाएगा , और आपको $_=इसके बजाय उपयोग करने की अनुमति देगा print())। इस बात पर निर्भर करता है कि आप नई रूपरेखाओं को कैसे संभालना चाहते हैं, आपको इसकी आवश्यकता भी नहीं है 0। (भले ही आप कमांड लाइन विकल्प दंड से बचना चाहते हैं, sayकी तुलना में कम है print।)

@ क्रिस नहीं मेरा, faubiguy का लेकिन धन्यवाद। ;)

— डेविड कॉनरेड

@DavidConrad मेरी बुरी हाहा।

— क्रिस

1

आपको निश्चित रूप से 0 की भी आवश्यकता नहीं है। बस -p ध्वज का उपयोग करें और $_=pack'B*',y/FB -z/01/drअपने कार्यक्रम के लिए अपने स्कोर को 26 बाइट्स तक कम करें।

— क्रिस

5

पायथन 2 , 90 83 82 81 बाइट्स

^{पूरी तरह से अमानवीय के लिए}
^{-1 बाइट, मार्टमिस्ट्स को बाइट की बदौलत}^{-1 बाइट, जोनाथन}^{फ्रेच}
^{को धन्यवाद}

lambda x:''.join(chr(int(`[+(l<'D')for l in b[::4]]`[1::3],2))for b in x.split())

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

— छड़ी
स्रोत

एक बाइट करता है।

— पूरी तरह से

आप बदल कर एक बाइट बचा सकता है *1 forमें*1for

— Martmists

चूंकि आप *1बूलियन से पूर्णांक में परिवर्तित करने के लिए उपयोग करते हैं , आप एक बाइट का उपयोग करके बचा सकते हैं +: एक (l<'D')*1forहो सकता है +(l<'D')for।

— जोनाथन फ्रेच

3

व्हॉट्सएप, 123 बाइट्स

दृश्यमान प्रतिनिधित्व:

SSNNSSNSNSSSNSNSTNTSTTTSSSTSSSSSNTSSTSNSNTSSNSSSTSSTTSNTSSTNTSTNSSSTNTSSSNSSTNSSNSNSSNSTNTSTNTSTNTSTSSSNSNNNSSSNSNTTNSSNSNN

अपुष्ट कार्यक्रम:

    push  0
loop:
    dup
    push  0
    dup
    ichr
    get
    push  32
    sub
    dup
    jz    space
    push  38
    sub
    jz    fizz
    push  1
    add
fizz:
    push  0
    dup
    dup
    ichr
    ichr
    ichr
    add
    jmp   loop
space:
    swap
    pchr
    jmp   loop

कार्यान्वयन के बारे में विशेष रूप से कुछ भी अजीब नहीं है, केवल असली गोल्फिंग कुछ अस्थायी ब्योरे के पुन: उपयोग के साथ-साथ कुछ और बाइट्स को कम करने के लिए अनबाउंड स्टैक विकास के बारे में परवाह नहीं है।

— CensoredUsername
स्रोत

3

ऑक्टेव , 59 57 53 बाइट्स

@(s)['',bi2de(flip(reshape(s(65<s&s<71)<70,8,[]))')']

यह TIO पर काम नहीं करता है, क्योंकि संचार टूलबॉक्स लागू नहीं किया गया है। यदि आप इसे ऑक्टेव-ऑनलाइन पर कॉपी-पेस्ट करते हैं तो यह ठीक काम करता है । यह MATLAB में कोड काम करने के करीब भी नहीं है।

चारों ओर के रास्ते के बजाय, इसे फ़्लिप करने के बाद मैट्रिक्स को ट्रांसपोज़ करके दो बाइट्स को बचाने में कामयाब रहा।

स्पष्टीकरण:

@(s)             % Anonymous function that takes a string as input
    ['',<code>]  % Implicitly convert the result of <code> to its ASCII-characters

के बीच में शुरू करते हैं <code>:

s(65<s&s<71)      % Takes the elements of the input string that are between 66 and 70 (B and F)
                  % This gives a string FBBFFBBFBBBFFFBF...
s(65<s&s<71)<70   % Converts the resulting string into true and false, where F becomes false.
                  % Transformation: FBBFFB -> [0, 1, 1, 0, 0, 1]

के लिए परिणामी बूलियन (द्विआधारी) वेक्टर कहते हैं t।

reshape(t,8,[])       % Convert the list of 1 and 0 into a matrix with 8 rows, one for each bit
flip(reshape(t,8,[])) % Flip the matrix vertically, since bi2de reads the bits from the wrong end
flip(reshape(t,8,[]))' % Transpose it, so that we have 8 columns, and one row per character
bi2de(.....)'          % Convert the result decimal values and transpose it so that it's horizontal

— स्टीवी ग्रिफिन
स्रोत

3

झंडे के लिए पर्ल 5, 28 बाइट्स + 4 बाइट्स = 32 बाइट्स

झंडे लेकर दौड़े -040pE

$_=chr oct"0b".y/FB -z/01/dr

-040 रिकॉर्ड विभाजक को एक स्थान पर सेट करता है ताकि पर्ल FizzBuzzes के प्रत्येक समूह को एक अलग रेखा के रूप में देखता है, फिर उन पंक्तियों पर लूप करता है, F से 0 में बदल रहा है, B से 1, बाकी सब को हटा रहा है, फिर बाइनरी में परिवर्तित हो रहा है और वहां से ascii तक।

— क्रिस
स्रोत

2

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

Ḳm€4=”BḄỌ

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

Ḳm€4=”BḄỌ  Main Link
Ḳ          Split on spaces
  €        Map
 m 4       Take every fourth letter (F and B)
    =”B    Check if each letter is equal to B (gives the binary representation)
       Ḅ   Binary -> Integer
        Ọ  Unord; gives chr(i)

-3 बाइट्स एग्री आफ द आउटॉलफर की बदौलत

— HyperNeutrino
स्रोत

आइए हम इस चर्चा को चैट में जारी रखते हैं ।

— निकले एग्रीकोल

2

PHP, 67 बाइट्स

8 अक्षरों तक सीमित

<?=hex2bin(dechex(bindec(strtr($argn,[Fizz=>0,Buzz=>1," "=>""]))));

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

PHP, 77 बाइट्स

foreach(explode(" ",strtr($argn,[Fizz=>0,Buzz=>1]))as$v)echo chr(bindec($v));

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

— जार्ग हुल्सरमन
स्रोत

2

ब्रेन-फ्लैक , 107 बाइट्स

{(((((()()()()){}){}){})({}[{}])()())((){[()](<{}>)}{}<>)<>{(<{}{}{}{}>)<>({}({}){})<>}{}}<>{({}<>)<>}<>

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

+3 बाइट्स के लिए -cझंडे के ।

व्याख्या

{                                        For each character in input:
 (((((()()()()){}){}){})({}[{}])()())    Push 32-n and 66-n
 ((){[()](<{}>)}{}<>)<>                  If character is B, push 1 on second stack.  Otherwise, push 0
 {                                       If character is not space:
  (<{}{}{}{}>)                           Burn 3 additional characters
  <>({}({}){})<>                         Multiply current byte by 2 and add previously pushed bit
 }                                       (otherwise, the pushed 0 becomes the new current byte)
 {}                                      Remove character from input
}
<>{({}<>)<>}<>                           Reverse stack for output

— Nitrodon
स्रोत

2

q / kdb +, 41 40 37 33 बाइट्स

समाधान:

{10h$0b sv'66=vs[" ";x][;4*(!)8]}

उदाहरण:

q){10h$0b sv'66=vs[" ";x][;4*(!)8]}"FizzBuzzBuzzFizzBuzzFizzFizzFizz FizzBuzzBuzzFizzBuzzFizzFizzBuzz FizzFizzBuzzFizzFizzFizzFizzBuzz"
"hi!"

स्पष्टीकरण:

इनमें से प्रत्येक सूची (पहला ) में " "अलग-अलग सूचियों को सूचीबद्ध करने के लिए इनपुट स्ट्रिंग को विभाजित करें । प्रत्येक चरित्र है (ASCII ) द्वारा निर्धारित बूलियन सूची । इन सूचियों को आधार 10 में बदलें, और फिर स्ट्रिंग के लिए परिणाम दें।FizzBuzz...0 4 8 ... 28"B"66

{10h$0b sv'66=vs[" ";x][;4*til 8]} / ungolfed solution
{                                } / lambda function with x as implicit input
              vs[" ";x]            / split (vs) input (x) on space (" ")
                           til 8   / til 8, the range 0..7 inclusive
                         4*        / vectorised multiplication, 0 1 2 3 => 0 4 8 12
                       [;       ]  / index the 2nd level at these indices (0, 4, 8 ... 28)
           66=                     / 66 is ASCII B, 66="FBBFBFFF" -> 01101000b
     0b sv'                        / join (sv) each row back with 0b (converts from binary)
 10h$                              / cast to ASCII (0x686921 -> "hi!")

— streetster
स्रोत

1

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

(>>= \w->toEnum(foldl1((+).(2*))[mod(fromEnum c)5|c<-w,c<'a']):"").words

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

यह काम किस प्रकार करता है

            words      -- split input string into words at spaces
(>>=      )            -- map the function to each word and flatten the resulting
                       -- list of strings into a single string
   \w->                -- for each word w
       [  |c<-w,c<'a'] -- take chars c that are less than 'a' (i.e. B and F)
     mod(fromEnum c)5  -- take ascii value of c modulus 5, i.e. convert to bit value
    foldl1((+).(2*))   -- convert list of bit to int
  toEnum(   ):""       -- convert ascii to char.  :"" forces toEnum to be of type String
                       -- now we have a list of single char strings, e.g. ["h","i","!"]

— nimi
स्रोत

1

जावास्क्रिप्ट ईएस 6 - 98 बाइट्स

बहुत से बाइट्स, लेकिन कम से कम पठनीय

फ़ंक्शन के रूप में परिभाषित यह 98 बाइट्स है

let s=>s.replace(/(F)|(B)|./g,(c,F,B)=>B?1:F?0:'').replace(/.{8}/g,v=>String.fromCharCode('0b'+v))

परीक्षा:

"FizzBuzzBuzzFizzBuzzFizzFizzFizz FizzBuzzBuzzFizzBuzzFizzFizzBuzz FizzFizzBuzzFizzFizzFizzFizzBuzz"
.replace(/(F)|(B)|./g,(c,F,B)=>F?0:B?1:'').replace(/.{8}/g,v=>String.fromCharCode('0b'+v))

स्पष्टीकरण:

/(F)|(B)|./

समूह के रूप में एफ और बी अक्षर और कुछ और से मेल खाता है

(c,F,B)=>F?0:B?1:''

वह कार्य है जो समूहों को पकड़ता है, F के लिए 0 और B के लिए 1 या '' के लिए रिटर्न देता है

c अक्षर
F से मेल खाता है और B अब पैरामीटर है!
द 3 ।समूह को पैरामीटर के रूप में रखा गया है

F और B undefinedतब होते हैं जब 3rd समूह का मिलान
B से undefinedहोता है जब समूह F का मिलान किया जाता है

परिणामी 0100 .. आदि स्ट्रिंग

8 बाइट्स के स्लाइस में काटा जाता है

.replace(/.{8}/g,v=>String.fromCharCode('0b'+v))

और 0b बाइनरी स्ट्रिंग के रूप में संसाधित किया गया है

— डैनी '365CSI' एंगेलमैन
स्रोत

2

PPCG में आपका स्वागत है! इस चुनौती का उद्देश्य एक प्रोग्राम या फ़ंक्शन प्रदान करना है जो मनमाने ढंग से FizzBuzz स्ट्रिंग्स का अनुवाद करता है। मैं बहुत अधिक जावास्क्रिप्ट जानता हूं, लेकिन एक मान्य फ़ंक्शन सबमिशन हो सकता है s=>s.replace( ...। कृपया अपने उत्तर के शीर्षलेख में एक बाइट गणना भी शामिल करें।

— लकोनी

मैंने आपके लिए आपके कुछ कोड स्वरूपण को साफ किया। इसके अलावा, आपको letअनाम कार्यों की आवश्यकता नहीं है , स्वीकार्य हैं।

— झबरा

1

शॉर्टसी , 35 बाइट्स

i;AW*@&3?*@&9||(i+=i+*s%5):Pi),*s++

इस कार्यक्रम में बातचीत:

A - int main(int argc, char **argv){
W - while(
@ - argv
P - putchar(
ऑटो डाला );}

हैविली डोरकनॉब के उत्तर के आधार पर।

— एमडी एक्सएफ
स्रोत

1

एपीएल (डायलॉग क्लासिक) , 17 बाइट्स

{82⎕DR'B'=⍵∩'BF'}

व्याख्या

           ⍵∩'BF'    cut, removes all but 'BF' from ⍵
       'B'=          equals 'B' turns it into binary stream   
 82⎕DR              converts into character stream

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

— गिल
स्रोत

0

05AB1E , 15 बाइट्स

#vy„FBÃS'BQ2βçJ

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

— आउटग्रॉफर को एरिक करें
स्रोत

0

Google शीट, 94 बाइट्स

=ArrayFormula(JOIN("",CHAR(BIN2DEC(SPLIT(SUBSTITUTE(SUBSTITUTE(A1,"Fizz",0),"Buzz",1)," ")))))

मैं FizzBuzz बाइनरी से परिचित नहीं हूं, लेकिन ऐसा लगता है कि वे रिक्त स्थान द्वारा चित्रित किए गए हैं ताकि यह सूत्र उस पर निर्भर हो। तर्क बहुत आसान है:

के Fizzसाथ बदलें 0औरBuzz साथ1
एक सीमांकक के रूप में एक स्थान का उपयोग करके एक सरणी में परिणाम को विभाजित करें
प्रत्येक तत्व को बाइनरी से दशमलव में परिवर्तित करें
प्रत्येक तत्व को उसके ASCII समकक्ष से बदलें
एक सीमांकक के बिना प्रत्येक तत्व में शामिल हों

— इंजीनियर टोस्ट
स्रोत

0

जावा 8, 117 115 बाइट्स

s->{for(String x:s.split(" "))System.out.print((char)Long.parseLong(x.replace("Fizz","0").replace("Buzz","1"),2));}

मुझे शक है आप, सबसे अन्य उत्तर की तरह जावा में फैंसी regex प्रतिस्थापन की एक बहुत कुछ कर सकते हैं जिसका मुख्य कारण आप जावा regexes में कब्जा कब्जा-समूहों के साथ कुछ नहीं कर सकते .. (Ie "$1".charAt(...)या "$1".replace(...)उदाहरण के लिए संभव नहीं हैं।)

स्पष्टीकरण:

इसे यहाँ आज़माएँ।

s->{                          // Method with String parameter and no return-type
  for(String x:s.split(" "))  //  Loop over the input split by spaces:
    System.out.print(         //   Print:
     (char)                   //    Each character
     Long.parseLong(          //    after we've converted each binary-String to a long
      x.replace("Fizz","0").replace("Buzz","1")
                              //    after we've replaced the Fizz/Buzz to 0/1
     ,2));
}                             // End of method

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

0

जे , 20 बाइट्स

a.{~_8#.\2-.~'FB'i.]

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

— FrownyFrog
स्रोत

फिज बज़ टू टेक्स्ट

परिचय

चुनौती

वह कैसे काम करता है?

प्रतिबन्ध

इनपुट

उत्पादन

सी, 59 बाइट्स

पूर्वाभ्यास

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

बैश + कोरुटिल्स, 61 50 बाइट्स

पायथन 3 , 169 101 93 91 85 81 बाइट्स

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

जाप , 26 24 19 17 बाइट्स

व्याख्या

रूबी, 65 63 60 बाइट्स

जावास्क्रिप्ट (ईएस 6), 95 88 85 81 बाइट्स

कोशिश करो

पर्ल 5, 33 बाइट्स

पायथन 2 , 90 83 82 81 बाइट्स

व्हॉट्सएप, 123 बाइट्स

ऑक्टेव , 59 57 53 बाइट्स

स्पष्टीकरण:

झंडे के लिए पर्ल 5, 28 बाइट्स + 4 बाइट्स = 32 बाइट्स

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

PHP, 67 बाइट्स

PHP, 77 बाइट्स

ब्रेन-फ्लैक , 107 बाइट्स

व्याख्या

q / kdb +, 41 40 37 33 बाइट्स

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

जावास्क्रिप्ट ईएस 6 - 98 बाइट्स

स्पष्टीकरण:

शॉर्टसी , 35 बाइट्स

एपीएल (डायलॉग क्लासिक) , 17 बाइट्स

व्याख्या

05AB1E , 15 बाइट्स

Google शीट, 94 बाइट्स

जावा 8, 117 115 बाइट्स

जे , 20 बाइट्स