एक FizzBuzz संकलक बनाएँ

17

संकलक गोल्फ की दुनिया में आपका स्वागत है। आपका कार्य एक प्रोग्राम लिखना है जो कल्पना पर फ़िज़बज़ का एक संस्करण खेलने के लिए एक और प्रोग्राम बनाता है।

आपका संकलक

एक कंपाइलर लिखें जो कल्पना करने के लिए FizzBuzz प्रोग्राम के वेरिएंट जेनरेट करता है। इस संस्करण की कल्पना पूर्णांक / स्ट्रिंग जोड़े की एक सरणी के रूप में व्यक्त की गई है।

  • इनपुट किसी भी रूप में हो सकता है जो आपकी भाषा के लिए सुविधाजनक हो। (मेरे उदाहरण n: xxxx का उपयोग करते हैं, लेकिन यह सिर्फ उदाहरण के लिए है।)
  • प्रत्येक पूर्णांक इनपुट का उपयोग केवल एक बार आपके कंपाइलर के मंगलाचरण के लिए किया जा सकता है।
  • प्रत्येक जोड़ी के पूर्णांक में कम से कम एक का मान होगा।
  • प्रत्येक जोड़ी के तार केवल चार ASCII अक्षरों से बने होंगे।
  • आउटपुट को एक पूरा कार्यक्रम होना चाहिए जो नीचे दिए गए नियमों के अनुरूप हो।
  • आउटपुट किसी भी सुविधाजनक रूप में हो सकता है, जब तक कि यह एक पाठ्य कार्यक्रम है। (इसलिए नो लैंबड़ा एक्सप्रेशन।)

उपरोक्त नियमों के अनुरूप नहीं होने के कारण व्यवहार अपरिभाषित है।

आपका उत्पन्न FizzBuzz कार्यक्रम

आपके कंपाइलर द्वारा तैयार प्रोग्राम इनपुट के रूप में एक पूर्णांक, एन ले जाएगा । यह आवश्यक होने पर FizzBuzz स्ट्रिंग्स के साथ नंबरों को बदलने और n सहित एक से शुरू होने वाले नंबरों के अनुक्रम को आउटपुट करेगा ।

  • उत्पन्न प्रोग्राम कंपाइलर के समान भाषा में होना चाहिए।
  • इनपुट n किसी भी रूप में आपकी भाषा के लिए सुविधाजनक हो सकता है।
  • n में कम से कम एक का मान होगा।
  • एक संख्या जो संकलक के पूर्णांक इनपुट के कम से कम एक से अधिक है, उन्हें उन सभी पूर्णांकों द्वारा प्रतिस्थापित किया जाना चाहिए जिन्हें उन पूर्णांकों के साथ जोड़ा गया है।
  • एक संख्या जिसे FizzBuzz स्ट्रिंग द्वारा प्रतिस्थापित नहीं किया जाना है, दशमलव ASCII में आउटपुट होना चाहिए।

उदाहरण के लिए;

> GenFizzBuzz 3:Fizz 5:Buzz
> a.out 5
1
2
Fizz
4
Buzz

स्कोरिंग

आपकी प्रविष्टि उन प्रोग्रामों की लंबाई के आधार पर बनाई जाएगी जिन्हें आपके कंपाइलर ने आपके कंपाइलर की लंबाई में जोड़ा है। अपने कंपाइलर को प्रत्येक निम्न मापदंडों के साथ कई बार चलाएं और अपने स्कोर का पता लगाने के लिए कंपाइलर की लंबाई के साथ उत्पन्न कार्यक्रमों की लंबाई को एक साथ जोड़ें।

  1. बस गिनती। (कोई जानकारी नहीं - उत्पन्न कार्यक्रम प्रतिस्थापन के बिना 1 से n तक गिना जाएगा ।)
  2. बस गोल्फ। (1: गोल्फ - उत्पन्न कार्यक्रम "गोल्फ" n बार आउटपुट करेगा ।)
  3. क्लासिक फ़िज़बज़्ज़। (3: फ़िज़, 5: बज़)

(ध्यान दें कि आपके संकलक को किसी भी मान्य इनपुट के लिए कोड उत्पन्न करना आवश्यक है, न कि केवल ये सूचीबद्ध हैं।)

code-challenge  code-generation  compiler 
— billpg
स्रोत
संकलक की लंबाई के लिए कोई स्कोरिंग नहीं ??
— स्पर्म जूल
क्या हम मान सकते हैं कि पूर्णांक एकल अंक हैं? तार में कोई जगह नहीं है?
— स्पर्म जूल
@ शेपर क्या (दो अंकों के पूर्णांक) में अंतर होगा? याद रखें, इसका एकमात्र कोड उत्पन्न होता है जो आपका स्कोर बनाता है।
— बिलप्रेस
ठीक है, फ़िज़बज़्ज़ इंटरनेट पर पहले से ही बहुत अच्छी तरह से गोल्फ की समस्या है। मुझे नहीं पता कि अगर मैं कोशिश करूँ तो मैं इसका समाधान पढ़ना भूल सकता हूँ।
— जूल
1
अंत में एक गोल्फ चुनौती जो वास्तव में AWK में लिखने के लिए समझ में आता है।
— छायाकार

जवाबों:

8

पायथन 3 - 168 162 + 230 = 392

ओह, पायथन, आप बहुत कोशिश करते हैं, लेकिन import sys;sys.argvसामान को 4 से गुणा करने से वास्तव में दर्द होता है!

import sys;a=eval(sys.argv[1])
print("import sys\nfor i in range(1,int(sys.argv[1])+1):print("+"+".join('"%s"*(i%%%d==0)'%t for t in a)+(a and"or str(i))"or"i)"))

आउटपुट कार्यक्रम:

import sys
for i in range(1,int(sys.argv[1])+1):print(i)
import sys
for i in range(1,int(sys.argv[1])+1):print("Golf"*(i%1==0)or str(i))
import sys
for i in range(1,int(sys.argv[1])+1):print("Fizz"*(i%3==0)+"Buzz"*(i%5==0)or str(i))

  • मुख्य कार्यक्रम के लिए अपेक्षित इनपुट पायथन ट्यूपल्स का एक स्पष्ट-सक्षम अनुक्रम है या '()' कोई इनपुट नहीं है। (आप कहते हैं कि "सुविधाजनक" किया था।) उदाहरण इनपुट: '()', '("Golf",1),','("Fizz",3),("Buzz",5)' नोट खोल के लिए के हवाले से और एक इनपुट के लिए अल्पविराम अनुगामी।

  • टफल्स को तानाशाही (अपरिभाषित आदेश!) से बदलकर 1 बजे की गलती को ठीक किया।

  • अन्य कार्यक्रमों के लिए अपेक्षित इनपुट सिर्फ संख्या है

— जेसन एस
स्रोत
आपके उदाहरण के कमांड लाइन तर्क में, मुझे दोहरे उद्धरण चिह्नों में लपेटना था और 'फ़िज़' और 'बज़' के लिए एकल उद्धरणों का उपयोग करना था - जैसे `` {3: 'फ़िज़', 5: 'बज़'} "हालांकि कार्यक्रम अभी भी है मेरे लिए एक त्रुटि फेंकना।
— जेम्स विलियम्स
त्रुटि क्या है?
— जेसन एस
@ जैसन - वहाँ हाय। मुझे इस चुनौती के आपके अनुभव में दिलचस्पी है। meta.codegolf.stackexchange.com/questions/5050/…
— billpg
6

perl6 376 340 84 + 115 = 199

अद्यतन: sayबिना पाने के लिए perl5 से perl6 पर स्विच किया गयाuse feature ।

अद्यतन: पांच के बजाय तीन परीक्षण मामले

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

संकलक, तर्कों की अपेक्षा करता है: "फ़िज़ 3" "बज़ 5"

print'say(('.(join'.',map{'('.(join')[$_%',split).']'}@ARGV).')||$_)for 1..$ARGV[0]'

संकलित कार्यक्रम, उम्मीद की तरह तर्क: 100

say(()||$_)for 1..$ARGV[0]
say(((Golf)[$_%1])||$_)for 1..$ARGV[0]
say(((Fizz)[$_%3].(Buzz)[$_%5])||$_)for 1..$ARGV[0]

पुराने परीक्षण मामलों के लिए संकलित कार्यक्रम:

say(((Twoo)[$_%2].(Four)[$_%4].(Eiht)[$_%8])||$_)for 1..$ARGV[0]
say(((Twoo)[$_%2].(Thre)[$_%3].(Five)[$_%5].(Sevn)[$_%7])||$_)for 1..$ARGV[0]
— Sparr
स्रोत
मैंने प्रश्न की टिप्पणियों में चर्चा किए गए नियमों को बदल दिया है। आप अपने स्कोर को पुनर्गणना करना चाहते हैं।
— बिल्वपत्र
@billpg ने किया, और सुधार किया :)
— शूरू
नमस्ते। मुझे इस चुनौती के आपके अनुभव में दिलचस्पी है। meta.codegolf.stackexchange.com/questions/5050/…
— billpg
3

पायथ - 51 + (38 + 43 + 50) = 182 बाइट्स

शायद संकलक को कुछ बाइट्स गोल्फ कर सकते हैं। उन सभी पर लिंक ऑनलाइन दुभाषिया के लिए पर्मलिंक हैं।

कम्पाइलर - 51 बाइट्स

%"K[%s)=dc\"%s\"dFGr1hQJkFNKI!%%GN~J@dxKN))?JJG",zw

बस एक इनपुट ट्यूपल के साथ स्ट्रिंग स्वरूपण करता है। जैसे इनपुट लेता है:

3 5
Fizz Buzz

कुछ नहीं - 38 बाइट्स

K[)=dc""dFGr1hQJkFNKI!%GN~J@dxKN))?JJG

जस्ट गोल्फ - 43 बाइट्स

K[1)=dc"Golf"dFGr1hQJkFNKI!%GN~J@dxKN))?JJG

क्लासिक फ़िज़ बज़ - 50 बाइट्स

K[3 5)=dc"Fizz Buzz"dFGr1hQJkFNKI!%GN~J@dxKN))?JJG
— Maltysen
स्रोत
2

C ++ 11 ~ 486 + (234 + 244 + 255) = 1219

यहां पहली भागीदारी, यह चुनौती सबसे कठिन लोगों में नहीं है, इसलिए मैंने सोचा कि मैं इसे आज़माऊंगा। C ++ का उपयोग करना, और यहां तक ​​कि C ++ 11 परिवर्धन के साथ यह अभी भी एक बहुत अच्छी भाषा है, लेकिन मुझे यकीन है कि इसमें सुधार की गुंजाइश है।

संकलक (486):

#include<sstream>
#include<iostream>
using namespace std;main(int c,char**v){stringstream t;int i;string s,o;o="#include <iostream>\n#include <map>\nusing namespace std;main(int c,char**v){int i,n=stoi(v[1]);map<int,string> f{";int z=2;for(int j=1;j<c;++j){t.str(v[j]);t.clear();t >> i; t >> s;o+="{"+to_string(i)+",\""+s+"\"}"+(z++==c?"":",");}o+= R"(};bool p;for(i=1;i<n;++i){p=true;for(auto e:f){if(i%e.first==0){cout<<e.second;p=false;}}cout<<(p?to_string(i):"")+"\n";}})";cout<<o;}

यह तर्क के रूप में मानता है 3Fizz 5Buzz आदि ।

गणना (234):

#include <iostream>
#include <map>
using namespace std;main(int c,char**v){int i,n=stoi(v[1]);map<int,string> f{};bool p;for(i=1;i<n;++i){p=true;for(auto e:f){if(i%e.first==0){cout<<e.second;p=false;}}cout<<(p?to_string(i):"")+"\n";}}

गोल्फ (244):

#include <iostream>
#include <map>
using namespace std;main(int c,char**v){int i,n=stoi(v[1]);map<int,string> f{{1,"Golf"}};bool p;for(i=1;i<n;++i){p=true;for(auto e:f){if(i%e.first==0){cout<<e.second;p=false;}}cout<<(p?to_string(i):"")+"\n";}}

FizzBuzz (255):

#include <iostream>
#include <map>
using namespace std;main(int c,char**v){int i,n=stoi(v[1]);map<int,string> f{{3,"Fizz"},{5,"Buzz"}};bool p;for(i=1;i<n;++i){p=true;for(auto e:f){if(i%e.first==0){cout<<e.second;p=false;}}cout<<(p?to_string(i):"")+"\n";}}

अतिरिक्त जानकारी

जीसीसी 4.8.1 के साथ परीक्षण किया गया, कोई संकलक धोखा नहीं देता है।

यहां परीक्षण मामलों की पीढ़ी को स्वचालित करने और उन्हें चलाने (उपयोग make run) करने के लिए एक छोटा सा मेफाइल है :

run:
    g++ main.cpp --std=c++11 -o fbc

    ./fbc > count.cpp
    g++ count.cpp --std=c++11
    echo "======= Count ========"
    ./a.out 15

    ./fbc 1Golf > golf.cpp
    g++ golf.cpp --std=c++11
    echo "======= Golf ========"
    ./a.out 15

    ./fbc 3Fizz 5Buzz > fizzbuzz.cpp
    g++ fizzbuzz.cpp --std=c++11
    echo "======= FizzBuzz ========"
    ./a.out 15
— तेह इंटर्नेट catz से बना है
स्रोत
नमस्ते। मुझे इस चुनौती के आपके अनुभव में दिलचस्पी है। meta.codegolf.stackexchange.com/questions/5050/…
— billpg
map<int,string> fहो सकता है map<int,string>f। आप j=1उसी समय के साथ आरंभ कर सकते हैं z।
— यति
2

रूबी 99 + (86 + 94 + 103) = 382

puts"(1..ARGV[0].to_i).each{|i|x=[];#{ARGV[0]}.each{|k,v|x<<v if i%k==0};puts x.size>0?x.join():i}"

उपयोग:

wc -c main.rb # 99 chars
ruby main.rb "{}" | ruby - 100 # 1..2..3..
ruby main.rb "{}" | wc -c # 86 chars
ruby main.rb "{1=>:Golf}" | ruby - 100 # Golf..Golf..Golf..
ruby main.rb "{1=>:Golf}" | wc -c # 94 chars
ruby main.rb "{3=>:Fizz,5=>:Buzz}" | ruby - 100 # 1..2..Fizz..4..Buzz..
ruby main.rb "{3=>:Fizz,5=>:Buzz}" | wc -c # 103 chars
— विलियम एंड्रयू बर्नसन
स्रोत
2

स्टेक्स , 23 + 5 + 17 + 29 = 74

╥╟.└ç╘SJ∞CF╔v=▌╝Σ@∞ìé«g

इसे चलाएं और डीबग करें

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

संकलक खुद 23 है बाइट्स है लंबा है।

ASCII समतुल्य है:

{H34|S_h"_`c%z`n?+"m"mz`cc_?

बशर्ते इनपुट [], यह एक उत्पन्न करता है (5 बाइट्स)

mzc_?

इसे चलाएं और डीबग करें

प्रदान किया गया इनपुट [[1,"Golf"]], यह एक उत्पन्न करता है (17 बाइट्स)

mz_1%z"Golf"?+c_?

इसे चलाएं और डीबग करें

बशर्ते इनपुट [[3,"Fizz"],[5,"Buzz"]], यह एक उत्पन्न करता है (29 बाइट्स)

mz_3%z"Fizz"?+_5%z"Buzz"?+c_?

इसे चलाएं और डीबग करें

— वीजुन झोउ
स्रोत
1

आम लिस्प, 636 577

(ql:quickload'cl-ppcre)(lambda(z)(princ(subseq(ppcre:regex-replace-all" *([(')]) *"(with-output-to-string(@)(print`(lambda(n)(dotimes(i n)(loop for(m s)in ',z if(=(mod(1+ i)m)0)do(princ s))(do()((fresh-line))(princ (1+ i)))))@))"\\1")1)))

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

स्कोर

(let ((*standard-output* (make-broadcast-stream)))
  (loop
     for form in '(215                      ; Compiler
                   ()                       ; Count
                   ((1 "Golf"))             ; Golf
                   ((3 "Fizz")(5 "Buzz")))  ; FizzBuzz
     for length = (if (numberp form) form
                      (length (funcall *fun* form)))
     collect length into lengths
     sum length into sum
     finally (return (values sum lengths))))

लौटाया गया मान:

574
(215 111 119 129)

सुंदर हे

(defun fizz-buzz-compiler (z)
  (princ (subseq
          (cl-ppcre:regex-replace-all
           " *([(')]) *"
           (with-output-to-string (stream)
             (print
              `(lambda (n)
                 (dotimes(i n)
                   (loop for (m s) in ',z
                      if (=(mod(1+ i)m)0)
                      do (princ s))
                   (do () ((fresh-line))
                     (princ (1+ i))))) stream))
             "\\1") 1)))

इनपुट प्रारूप (number string)जोड़ों की एक सूची है । उदाहरण के लिए:

(fizz-buzz-compiler '((3 "Fizz")(5 "Buzz")))

... मानक उत्पादन के लिए प्रिंट:

(LAMBDA(N)(DOTIMES(I N)(LOOP FOR(M S)IN'((3 "Fizz")(5 "Buzz"))IF(=(MOD(1+ I)M)0)DO(PRINC S))(DO NIL((FRESH-LINE))(PRINC(1+ I)))))

... जो, बहुत छपी, है:

(lambda (n)
  (dotimes (i n)
    (loop for (m s) in '((3 "Fizz") (5 "Buzz"))
          if (= (mod (1+ i) m) 0)
          do (princ s))
    (do () ((fresh-line)) (princ (1+ i)))))

परिणामी फ़ंक्शन का परीक्षण:

CL-USER> ((lambda (n)
  (dotimes (i n)
    (loop for (m s) in '((3 "Fizz") (5 "Buzz"))
          if (= (mod (1+ i) m) 0)
          do (princ s))
    (do () ((fresh-line)) (princ (1+ i))))) 20)
1
2
Fizz
4
Buzz
Fizz
7
8
Fizz
Buzz
11
Fizz
13
14
FizzBuzz
16
17
Fizz
19
Buzz
— कोर निपात
स्रोत
1

जेली , 84४ 84४ 83 73 बाइट्स

अब तक का सबसे छोटा जवाब (धड़कता है) 1 बाइट द्वारा पिछला "सबसे छोटा उत्तर" )

संकलक:

Ṿ€“ḍ@€“ẋ"ЀF€ȯ"”jµFF?⁾RY

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

इसे ऑनलाइन आज़माएं! (बायटेकाउंट सत्यापित करें)

सांख्यिकी:

19 24 संकलक
   20 गोल्फ
17   २ गिनती
   27 फ़िज़बज़
कुल total३ total३
— user202729
स्रोत
पिटते देख अच्छा लगा।
— वीजिन झोउ
0

सी, 1080 बाइट्स कुल

कम्पाइलर [369 बाइट्स]

#include<stdlib.h>
r,t,f=3,b=5,n;char*F="FIzz",*B="buZZ";main(int c,char **v){if(f)for(c=atoi(v[1]),n=1;c>=n;)r=f?n%f:0,r?(t=b?n%b:0)?printf("%i\n",n):puts(B):r?printf("%s%s\n",F,B):puts(F),++n;else for(c=0;c<atoi(v[1]);)printf("%i\n",++c);}

फ़िज़ बज़ [241]

#include<stdlib.h>
r,t,f=3,b=5,n;char*F="FIzz",*B="buZZ";main(int c,char **v){if(f)for(c=atoi(v[1]),n=1;c>=n;)r=f?n%f:0,r?(t=b?n%b:0)?printf("%i\n",n):puts(B):r?printf("%s%s\n",F,B):puts(F),++n;else for(c=0;c<atoi(v[1]);)printf("%i\n",++c);}

गोल्फ [237]

#include<stdlib.h>
r,t,f=1,b=0,n;char*F="golf",*B="";main(int c,char **v){if(f)for(c=atoi(v[1]),n=1;c>=n;)r=f?n%f:0,r?(t=b?n%b:0)?printf("%i\n",n):puts(B):r?printf("%s%s\n",F,B):puts(F),++n;else for(c=0;c<atoi(v[1]);)printf("%i\n",++c);}

गणना [233 बाइट्स]

#include<stdlib.h>
r,t,f=0,b=1,n;char*F="",*B="";main(int c,char **v){if(f)for(c=atoi(v[1]),n=1;c>=n;)r=f?n%f:0,r?(t=b?n%b:0)?printf("%i\n",n):puts(B):r?printf("%s%s\n",F,B):puts(F),++n;else for(c=0;c<atoi(v[1]);)printf("%i\n",++c);}
— NoSeatbelts
स्रोत
0

डीसी , 434 बाइट्स

[:a]sa[91Pn93Pznlanps_znlanz0<R]sR[[[lj1-;aP1sb]sB0sj[dljd2+sj;a%0=Bljlz>F]sF[p2Q]sP]P]sI[[[]sF[pq]sP]nq]sN[z0=Nzn[sz]PlRxlIx]x[sn0dsb[1+0sjlFx[lb0=PAP]x0sbdln>M]dsMx]P

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

संकलक (168 बाइट्स) के लिए इनपुट को स्टैक पर पूर्णांक, स्ट्रिंग, पूर्णांक, स्ट्रिंग, और इसी तरह रखा जाना चाहिए (3 [Fizz] 5 [Buzz] ) के । यह उस क्रम में दिया जाना चाहिए जो चाहता है कि उनके फ़िज़ और बज़ मुद्रित किए जाएं, जो थोड़ा धोखा हो सकता है ( dcपहले बुलबुला छंटनी लागू किया गया था, मुझे लगता है कि यह मुझे लगभग 100 बाइट्स का खर्च देगा), लेकिन यह उपयोगकर्ता को भी अनुमति देता है , कहते हैं, अभी भी 3 पर 'फ़िज़' चला है और 5 पर 'बज़' चलता है, लेकिन 15 उपज 'बज़ फ़िज़' है।

मुझे यकीन है कि यह थोड़ा और अधिक हो सकता है; अंतिम कार्यक्रम में मुख्य मैक्रो ( Mदो मैक्रोज़ पर निर्भर करता है)F औरP ) जो कि अनावश्यक हैं बिना कोई इनपुट दिए। अभी इनपुट के लिए संकलक जाँच करता है और इन मैक्रो के अलग (बहुत छोटे) संस्करणों को आउटपुट करता है अगर कोई नहीं है, लेकिन मुझे यकीन नहीं है कि पूरा सेटअप इष्टतम है।

संकलक स्वयं बहुत सीधा है, यह सिर्फ यह देखने के लिए जाँचता है कि क्या स्टैक पर 'नियम' हैं, और यदि ऐसा है तो यह कोड प्रिंट करता है जो स्टैक की गहराई को zस्टोर करता है, स्टैक को 0-अनुक्रमित सरणी में संग्रहीत करता हैa , और फिर सामान्यीकृत प्रिंट करता है। FizzBuzz कोड। यदि स्टैक पर कुछ भी नहीं था, तो यह वास्तव में FizzBuzz कोड के एक संशोधित संस्करण को प्रिंट करता है। परीक्षण के मामलों:

कोई इनपुट नहीं (46 बाइट्स):

[]sF[pq]sPsn0dsb[1+0sjlFx[lb0=PAP]x0sbdln>M]dsMx

3 [फ़िज़] 5 [बज़] (117 बाइट्स):

4sz[Buzz]3:a5
2:a[Fizz]1:a3
0:a[lj1-;aP1sb]sB0sj[dljd2+sj;a%0=Bljlz>F]sF[p2Q]sPsn0dsb[1+0sjlFx[lb0=PAP]x0sbdln>M]dsMx

1 [गोल्फ] (103 बाइट्स):

2sz[Golf]1:a1
0:a[lj1-;aP1sb]sB0sj[dljd2+sj;a%0=Bljlz>F]sF[p2Q]sPsn0dsb[1+0sjlFx[lb0=PAP]x0sbdln>M]dsMx

वे सभी स्टैक पर एन मान की उम्मीद करते हैं , यह अंदर जमा हो जाता है n। जिन लोगों के पास 'नियम' होते हैं, वे उन्हें सरणी में रखते हैं a, अजीब सूचकांकों में तार और evens पर पूर्णांक के साथ। मुख्य मैक्रो, Mवेतन वृद्धि, जो कुछ भी स्टैक पर है, मैक्रो चलाता है, Fजो सरणी के विरुद्ध मान की aजांच करता है, यह जांचता है कि क्या Fरजिस्टर bसत्य पर है या नहीं और स्टैक के शीर्ष को प्रिंट करता है यदि ऐसा है या एक नईलाइन यदि नहीं, bतो गलत तरीके से रीसेट करता है, और फिर रखता है यदि nअभी तक नहीं पहुँचा जा रहा है तो स्वयं चल रहा है । मैक्रो F, दिए गए नियम, मैच देखने वाले पूरे ऐरे से गुजरते हैं। यह दो से बढ़ जाता है क्योंकि हमारे पूर्णांक और स्ट्रिंग्स को सरणी के माध्यम से बुना जाता है, और एक मैच पर यह मैक्रो कहता हैB । मैक्रोBबस स्ट्रिंग को पुनः प्राप्त करता है (सरणी में वर्तमान स्थिति कम एक), और इसे प्रिंट करता है। यह भी bसत्य पर सेट होता है। हमारा संकलक Bबिना किसी इनपुट के प्रिंट करने के लिए परेशान नहीं करता है , और अनिवार्य रूप से Fएक एनओपी बनाता है।

— brhfl
स्रोत
0

विम, 122 (संकलक) + 73 (खाली) +90 (गोल्फ) + 123 (फ़िज़बज़) = 392 बाइट्स

संकलक

:%s/\v(.*):(.*)/qq\1jA\2<C-V><C-V><C-V><ESC>q=@qgg
VgggJAddGdd:%s/\v[0-9]*([^0-9])/\1
<C-V><ESC>:%@n
:w
:so! %
<ESC>ggii%s/=/<C-V><ESC><C-V><C-A>a/g<C-V><ESC>"ncc:%!seq 0 =
<ESC>

इनपुट प्रारूप

3:Fizz
5:Buzz

FizzBuzz मामले के लिए कोड जनरेट किया गया

i%s/=/<ESC><C-A>a/g<ESC>"ncc:%!seq 0 =
qq3jAFizz<C-V><ESC>q=@qggqq5jABuzz<C-V><ESC>q=@qggddGdd:%s/\v[0-9]*([^0-9])/\1
<ESC>:%@n
:w
:so! %

जनरेट कोड, एनोटेट

# replace the input number with a regex that replaces the placeholder (=) 
# with the real number + 1 (we'll need an extra line as a terminator later)
i%s/=/<ESC><C-A>a/g<ESC>

# pull the substitution command into register c and enter insert mode
"ncc

# create the numbers 0..N+1
:%!seq 0 =

# for each word, scan down k lines at a time and append the word to each
qq3jAFizz<C-V><ESC>q=@qgg
qq5jABuzz<C-V><ESC>q=@qgg

# delete the 0 and N+1 lines
ddGdd

# remove the numbers from any line with words
:%s/\v[0-9]*([^0-9])/\1
<ESC>

# Run the command we created at the beginning, replacing the placeholder 
# with the real number
:%@n

# The file now contains yet another program, with the constants defined.   
# Save and run.
:w
:so! %

# The file now contains a program that, when run on a buffer containing 
# a single line with a number, will produce the appropriate output

<C-V>0x16 है। <ESC>0x1b है। <C-A>0x01 है।

उदाहरण सत्र

$ cat code.txt
2:Foo
4:Bar
$ cat input.txt
8
$ { cat compile.vim; echo ':wq'; } | vim code.txt
# code.txt now contains the generated code
$ { cat code.txt; echo ':wq'; } | vim input.txt
$ cat input.txt
1
Foo
3
FooBar
5
Foo
7
FooBar
— रे
स्रोत
जब मैं एक मैक्रो को दूसरे मैक्रो से परिभाषित करने और चलाने का प्रयास करता हूं तो कुछ अजीब होता है। यदि मैं उस प्रकार को प्रबंधित करता हूं, तो मैं कुछ बाइट्स सेव और सोर्स अप्रोच पर बचा सकता हूं।
— रे
-2

स्लोकार्सी ।लैंग, 179

%%--43^jjk"/][][0[#!#111# h SD G ergDFGdfg[]9--99+==
— CodeBro
स्रोत
10
मैं इस भाषा से परिचित नहीं हूँ; क्या आप हमें इसका वर्णन करने वाले पृष्ठ से जोड़ सकते हैं?
— lirtosiast
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.