Willkommen in der Welt des Compiler-Golfs. Ihre Aufgabe ist es, ein Programm zu schreiben, das ein anderes Programm generiert, um eine Variante von FizzBuzz nach Spezifikation abzuspielen.

Dein Compiler

Schreiben Sie einen Compiler, der nach Spezifikation Varianten des FizzBuzz-Programms generiert. Die Spezifikation dieser Variante wird in Form eines Arrays von Integer / String-Paaren ausgedrückt.

• Die Eingabe kann in jeder für Ihre Sprache geeigneten Form erfolgen. (In meinen Beispielen wird n: xxxx verwendet, dies dient jedoch nur zur Veranschaulichung.)
• Jede Ganzzahleingabe darf nur einmal pro Aufruf Ihres Compilers verwendet werden.
• Die ganze Zahl jedes Paares hat einen Wert von mindestens eins.
• Die Zeichenfolge jedes Paares besteht nur aus genau vier ASCII-Buchstaben.
• Die Ausgabe muss ein einzelnes vollständiges Programm sein, das den folgenden Regeln entspricht.
• Die Ausgabe kann in beliebiger Form erfolgen, sofern es sich um ein Textprogramm handelt. (Also keine zurückgegebenen Lambda-Ausdrücke.)

Das Verhalten ist für Eingaben, die nicht den obigen Regeln entsprechen, undefiniert.

Ihr generiertes FizzBuzz-Programm

Das von Ihrem Compiler generierte Programm verwendet eine einzelne Ganzzahl n als Eingabe. Es wird eine Folge von Zahlen von eins bis einschließlich n ausgegeben, wobei die Zahlen bei Bedarf durch FizzBuzz-Zeichenfolgen ersetzt werden.

• Das generierte Programm muss in derselben Sprache wie der Compiler sein.
• Die Eingabe n kann in jeder für Ihre Sprache geeigneten Form erfolgen.
• n hat einen Wert von mindestens eins.
• Eine Zahl, die ein Vielfaches von mindestens einer der in den Compiler eingegebenen Ganzzahlen ist, muss durch alle Zeichenfolgen ersetzt werden, die mit diesen zusammengefügten Ganzzahlen gepaart sind.
• Eine Zahl, die nicht durch einen FizzBuzz-String ersetzt werden soll, muss in dezimalem ASCII ausgegeben werden.

Beispielsweise;

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

Wertung

Ihre Eingabe wird anhand der Länge der von Ihrem Compiler generierten Programme bewertet, die zur Länge Ihres Compilers addiert werden. Führen Sie Ihren Compiler mehrmals mit den folgenden Parametern aus und addieren Sie die Länge der generierten Programme zusammen mit der Länge des Compilers, um Ihre Punktzahl zu ermitteln.

1. Zähle einfach. (Keine Eingaben - Das generierte Programm zählt 1 bis n ohne Ersetzungen.)
2. Nur Golf. (1: Golf - Das generierte Programm gibt n- mal "Golf" aus .)
3. Klassischer FizzBuzz. (3: Fizz, 5: Buzz)

(Beachten Sie, dass Ihr Compiler Code für jede gültige Eingabe generieren muss, nicht nur für diese.)

Python 3 - 168 162 + 230 = 392

Oh, Python, du versuchst es so sehr, aber das import sys;sys.argvZeug mit 4 zu multiplizieren, tut wirklich weh!

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

Ausgabeprogramme:

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

• Die erwartete Eingabe für das Hauptprogramm ist eine auswertbare Folge von Python-Tupeln oder '()'keine Eingabe. (Sie sagten „bequem“.) Beispiel Eingabe: '()', '("Golf",1),', '("Fizz",3),("Buzz",5)'Hinweis für die Schale zu zitieren und für einen Eingang Komma Hinter.

• Fehler um 1 Uhr morgens durch Ändern von Dikt (undefinierte Reihenfolge!) Zu Tupeln behoben.

• Erwartete Eingabe für die anderen Programme ist nur die Nummer

perl6 376 340 84 + 115 = 199

UPDATE: von perl5 auf perl6 umgestellt um sayohne zu kommen use feature.

UPDATE: drei Testfälle statt fünf

Es gibt Hunderte von bereits getesteten Lösungen für FizzBuzz, und viele Wettbewerbe enden mit demselben Ergebnis. Deshalb habe ich hier angefangen. Mein Compiler erstellt nur eine angepasste Version dieser Lösung. Ein paar zusätzliche Zeichen wurden eingefügt, um die "Just Count" -Variation zu berücksichtigen.

Compiler erwartet Argumente wie: "Fizz 3" "Buzz 5"

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

kompilierte Programme, erwarten Argumente wie: 100

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

Kompilierte Programme für alte Testfälle:

say(((Twoo)[$_%2].(Four)[$_%4].(Eiht)[$_%8])||$_)for 1..$ARGV[0]
say(((Twoo)[$_%2].(Thre)[$_%3].(Five)[$_%5].(Sevn)[$_%7])||$_)for 1..$ARGV[0]

Pyth - 51 + (38 + 43 + 50) = 182 Bytes

Kann dem Compiler wohl ein paar Bytes golfen. Die Links auf allen von ihnen sind Permalinks zum Online-Dolmetscher.

Compiler - 51 Bytes

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

Führt nur die Formatierung von Zeichenfolgen mit einem Eingabetupel aus. Nimmt Eingaben wie:

3 5
Fizz Buzz

Nichts - 38 Bytes

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

Nur Golf - 43 Bytes

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

Klassisches Fizz Buzz - 50 Bytes

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

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

Die erste Teilnahme hier, diese Herausforderung gehört nicht zu den schwierigsten, also dachte ich, ich würde es versuchen. Mit C ++ und sogar mit C ++ 11-Zusätzen ist es immer noch eine ziemlich ausführliche Sprache, aber ich bin mir sicher, dass es Raum für Verbesserungen gibt.

Compiler (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;}

Es nimmt Argumente in Form von 3Fizz 5Buzzetc. an.

Anzahl (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";}}

Golf (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";}}

Zusätzliche Information

Getestet mit GCC 4.8.1, keine Compiler-Cheats.

Hier ist ein kleines Makefile, um die Generierung der Testfälle zu automatisieren und sie auszuführen (verwenden 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

Ruby 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}"

Verwendung:

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

Stax , 23 + 5 + 17 + 29 = 74

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

Führen Sie es aus und debuggen Sie es

Kürzeste Antwort bisher Nicht überraschend von Jelly geschlagen. Die in Stax bereitgestellte Zeichenfolgenvorlage ist wirklich ordentlich und bietet printf-ähnliche Funktionen. Die vom Compiler generierten Programme sind fast immer so kurz wie das Beste, was man durch manuelles Codegolfing ohne Packen erreichen kann.

Der Compiler selbst hat 23 Bytes lang.

Das ASCII-Äquivalent lautet:

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

Bereitgestellter Eingang [], erzeugt diesen (5 Bytes)

mzc_?

Führen Sie es aus und debuggen Sie es

Bereitgestellter Eingang [[1,"Golf"]], erzeugt diesen (17 Bytes)

mz_1%z"Golf"?+c_?

Führen Sie es aus und debuggen Sie es

Bereitgestellter Eingang [[3,"Fizz"],[5,"Buzz"]], erzeugt diesen (29 Bytes)

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

Führen Sie es aus und debuggen Sie es

Gemeines Lisp, 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)))

Ich nahm meine andere Antwort und hüllte sie in Quasiquotes ein, während ich Eingabeparameter hinzufügte. Ich drucke das resultierende Formular einzeilig aus und entferne unnötige Leerzeichen. Der Compiler ist etwas länger als die Vorgängerversion, aber die resultierende Punktzahl wird reduziert.

Ergebnis

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

Zurückgegebene Werte:

574
(215 111 119 129)

Ziemlich

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

Das Eingabeformat ist eine Liste von (number string)Paaren. Beispielsweise:

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

... druckt auf Standardausgabe:

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

... was hübsch gedruckt ist:

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

Testen der resultierenden Funktion:

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

Perl 5 , 77 + 93, 170 Bytes

say"say",(map{++$i%2?"'$_":"'x!(\$_%$_)".($i<$#F?'.':'||$_')}@F),' for 1..<>'

Probieren Sie den Compiler online aus!
Versuchen Sie einfach online zu zählen!
Probieren Sie einfach online Golf!
Probieren Sie fizz buzz online aus!

Jelly , 88 84 83 73 Bytes

Kürzeste Antwort bisher (übertrifft die vorherige "kürzeste Antwort" um 1 Byte)

Compiler:

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

Probieren Sie es online! (Compiler)

Probieren Sie es online! (überprüfen Sie den bytecount)

Statistiken:

19 24 Compiler
   20 golf
17   2 zählen
   27 Fizzbuzz
83 73 insgesamt

C 1080 Bytes insgesamt

Compiler [369 Bytes]

#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);}

Fizz Buzz [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);}

Golf [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);}

Count [233 Bytes]

#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);}

Gleichstrom , 434 Bytes

[: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

Probieren Sie es online!

Die Eingabe für den Compiler (168 Byte) sollte als Ganzzahl, Zeichenfolge, Ganzzahl, Zeichenfolge usw. ( 3 [Fizz] 5 [Buzz]) im Stapel abgelegt werden . Es sollte in der Reihenfolge angegeben werden, in der die Fizzes und Buzzes gedruckt werden sollen. Dies ist möglicherweise ein Cheat (nachdem dcich zuvor die Blasensortierung implementiert habe, würde es mich ungefähr 100 Byte kosten), aber es ermöglicht es dem Benutzer auch Angenommen, Sie haben noch "Fizz" mit 3 und "Buzz" mit 5, aber Sie haben 15 "BuzzFizz".

Ich bin sicher, das kann ein bisschen mehr golfen werden; Das Hauptmakro im endgültigen Programm ( M) basiert auf zwei Makros ( Fund P), die bei fehlender Eingabe eher unnötig sind. Im Moment prüft der Compiler auf Ein- und Ausgaben verschiedener (viel kleinerer) Versionen dieser Makros, wenn es keine gibt, aber ich bin nicht sicher, ob das gesamte Setup optimal ist.

Der Compiler selbst ist ziemlich unkompliziert. Er prüft nur, ob auf dem Stapel Regeln vorhanden sind, und gibt in diesem Fall Code aus, in dem die Stapeltiefe gespeichert ist z, und speichert den Stapel in einem Array mit dem Index 0 aund druckt dann den verallgemeinerten Code FizzBuzz-Code. Wenn sich nichts auf dem Stapel befand, wird nur eine geänderte Version des FizzBuzz-Codes gedruckt. Testfälle:

Keine Eingabe (46 Byte):

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

3 [Fizz] 5 [Buzz] (117 Bytes):

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 [Golf] (103 Bytes):

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

Sie alle erwarten den n- Wert auf dem Stapel, der in gespeichert wird n. Diejenigen, die 'Regeln' haben, platzieren sie im Array a, wobei die Zeichenfolgen bei ungeraden Indizes und die ganzen Zahlen bei geraden Indizes stehen. Das Hauptmakro Minkrementiert alles, was sich auf dem Stapel befindet, führt ein Makro aus, Fdas den Wert mit dem Array vergleicht a, prüft, ob das FSet-Register nur die Zeichenfolge abruft (aktuelle Position im Array abzüglich eins) und druckt sie aus. Es setzt auch auf Wahrheit. Unser Compiler macht sich nicht die Mühe, ohne Eingabe zu drucken , und macht im Grunde genommen ein Nein.b Hauptmakro auf wahr oder falsch , und druckt, wenn dies der Fall ist, den oberen Teil des Stapels oder eine neue Zeile, setzt ihn bauf falsch zurück und behält dann bei Laufen selbst, wenn nnoch nicht erreicht wurde. Makro durchsucht nach Fvorgegebenen Regeln das gesamte Array nach Übereinstimmungen. Es wird um zwei erhöht, da unsere Ganzzahlen und Zeichenfolgen durch das Array gewoben sind, und bei einer Übereinstimmung wird ein Makro aufgerufen B. MakroBbBF

Vim, 122 (Compiler) + 73 (leer) + 90 (Golf) + 123 (Fizzbuzz) = 392 Byte

Compiler

:%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>

Eingabeformat

3:Fizz
5:Buzz

Generierter Code für den FizzBuzz-Fall

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! %

Generierter Code, kommentiert

# 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>ist 0x16. <ESC>ist 0x1b. <C-A>ist 0x01.

Beispielsitzung

$ 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

SlooSarksi. Lang, 179

%%--43^jjk"/][][0[#!#111# h SD G ergDFGdfg[]9--99+==