Alte MacDonald-Funktion

16

Erstellen Sie eine Funktion in der von Ihnen gewählten Sprache, die Folgendes ausgibt:

Old MacDonald had a farm, E-I-E-I-O,
And on that farm he had a cow, E-I-E-I-O,
With a moo moo here and a moo moo there,
Here a moo, there a moo, everywhere a moo moo,
Old MacDonald had a farm, E-I-E-I-O!

Wo cowund moosind Zeichenfolgen in den Funktionsparametern und als solche können zum Beispiel in pigund oinkoder sheepund geändert werden baa.

Dabei sollten Großbuchstaben, Bindestriche, Satzzeichen, Leerzeichen und Zeilenumbrüche berücksichtigt werden.

Geben Sie möglichst wenige Unicode-Zeichen in Ihren Code ein.

rybo111
quelle
1
Sollte das nicht Kolmogorov-Komplexität sein ?
5.
6
Du sagst echoes the following. Meinen Sie damit, dass die Funktion es ausdrucken oder zurücksenden soll?
cjfaure
2
Um dies gerecht zu machen, denke ich, sollte dies die exakte Interpunktion, Leerzeichen und Wagenrücklauf in der Frage haben. Aber was denkst du über Groß- / Kleinschreibung? Ich dachte, ein einzelner Fall könnte einfacher sein und eine Last von Standardanwendungen von base64 oder ähnlichem vermeiden. Alles in allem stehen die einzigen Großbuchstaben am Anfang der Zeile, das Wort MacDonald und in der EIEIO. Daher ist es möglicherweise interessanter, dies auch genau für die jeweilige Frage zu machen.
Level River St
4
Ist es akzeptabel auszugeben a oinkoder sollte das gemacht werden an oink?
ClickRick
4
@ rybo111: Wussten Sie, dass der große Donald Knuth eine wissenschaftliche Abhandlung über solche Dinge geschrieben hat? Es wurde tatsächlich in einer echten Zeitschrift veröffentlicht (zugegebenermaßen in der April-Ausgabe). Mehr hier mit einem Link zum PDF des Papiers: en.wikipedia.org/wiki/The_Complexity_of_Songs
Tom Chantler

Antworten:

15

Javascript ES6 - 204

Geben Sie möglichst wenige Unicode- Zeichen in Ihren Code ein.

Nicht der kürzere, aber wahrscheinlich der am meisten verschleierte.

f=(a,b)=>{for(c=[b,a].concat('!,-ADEHIMOWacdefhilmnortvwy \n'.split(o='')),i=62;i;o+=c[e>>10]+c[e/32&31]+c[e&31])e='ⱞᄤ⒇瓤抣瘭㾭癍㚏᫶⦮函࿋Π疽䌐獲樘ྰ㞠戝晐}疽䌐࿈䌐眲Π疽㛏戝癐Π疽伲࿌⒋ფᲉѽ疽䦯䨝抽瘭䦹容㾷碶ᅣᲉᄤྦྷ㜕㞱㗽㾲妴㣗畍⺏'.charCodeAt(--i);alert(o)}

Wenn Ihr Browser ES6 nicht unterstützt:

function f(a,b){for(c=[b,a].concat('!,-ADEHIMOWacdefhilmnortvwy \n'.split(o='')),i=62;i;o+=c[e>>10]+c[e/32&31]+c[e&31])e='ⱞᄤ⒇瓤抣瘭㾭癍㚏᫶⦮函࿋Π疽䌐獲樘ྰ㞠戝晐}疽䌐࿈䌐眲Π疽㛏戝癐Π疽伲࿌⒋ფᲉѽ疽䦯䨝抽瘭䦹容㾷碶ᅣᲉᄤྦྷ㜕㞱㗽㾲妴㣗畍⺏'.charCodeAt(--i);alert(o)}

Kopieren / Einfügen , dass Code in Ihre Browser - Konsole und versuchen f('cow','moo'), f('pig','oink'),f('sheep','baa')

Wie es funktioniert ?

cbesteht aus 29 Buchstaben plus dem Tier und seinem Klang (nennen wir dies unser Alphabet ).
Alle 31 Zeichen passen also in 5 Bits (2 ^ 5 = 32).
Ein Unicode-Zeichen ist 16 Bit lang, sodass 3 Zeichen unseres Alphabets mit einem Füllbit codiert werden können .
Der vollständige Text mit den neuen Zeilen besteht aus 186 Zeichen unseres Alphabets und kann mit 62 Unicode-Zeichen codiert werden.

Beispielsweise, Old ist wie folgt codiert:

alphabet value         O      l      d
alphabet index         11     20     15
unicode           0  01011  10100  01111  ===> \u2e8f (⺏)

Wenn Sie Probleme beim Lesen einiger Unicode-Zeichen haben, installieren Sie die Schriftart Code2000

Michael M.
quelle
2
"cow"und "moo"sollen die Funktionsparameter sein. Indem Sie den Aufrufer veranlassen, ein Array zu übergeben, sparen Sie Zeichen in der Funktionsdefinition auf Kosten der Zeichenanzahl des aufrufenden Codes. Das riecht für mich nach Betrug. Wenn Sie diesen Ansatz auf das Äußerste bringen, könnten Sie definieren function f(a){alert(a)}(23 Zeichen) und sagen, dass er wie folgt aufgerufen werden muss f("Old MacDonald had a ...").
Bis
1
Ich hatte die Zeichenfolgen in zwei getrennten Parametern übergeben, aber nachdem ich die Aufforderung gelesen hatte, sah ich keinen Grund, die Zeichenfolgen nicht im Array-Format zu übergeben, sodass ich meine Antwort bearbeitete. Das ist kein Schummeln, nur ein paar Zeichen sparen, wenn es möglich ist. Lassen Sie @ rybo111 entscheiden, ob dies der Regel entspricht oder nicht.
Michael M.
1
@tobyink Ich habe den Begriff 'string' (nicht array) in den Regeln verwendet, also nehme ich an, dass Sie Recht haben. Ich denke, "Betrug" ist ein bisschen hart!
Rybo111
2
Warum hat das so viele Stimmen? Es ist über 200 und nicht einmal die kürzeste Javascript-Lösung.
Aditsu
Wenn Sie gut erklärt sind, haben Sie auch meine Stimme
edc65
5

CJam - 142 / GolfScript - 144

{" had| a |farm|68, |68 8|here|Old MacDonald765|, E-I-E-I-O|10,
And on that 5 he7690,
With3 2 and3 t2,
Here4t24everyw23,
10!"'|/~A,{`/\*}/}:F;

Verwendung: "cow""moo"F
Für GolfScript ersetzen Sie '|mit "|"und Amit10

Erläuterung:

Der Schlüsselteil ist A,{`/\*}/:
A,{...}/ Führt den Block für jede Zahl von 0 bis 9 aus (A = 10)
`Konvertiert die Zahl in eine Zeichenfolge
/\*Ersetzt eine Zeichenfolge: Wenn wir auf dem Stapel haben, "bar" "foo 1 baz" "1"dann /teilt die Zeichenfolge das Ergebnis auf ["foo " " baz"], \tauscht dieses Array mit dem vorherigen Element ("bar") und *schließt sich dem Array an, woraus sich ergibt"foo bar baz"

Der Code ersetzt also jede Zahl in der Hauptzeichenfolge durch eine Zeichenfolge, die sich zuvor auf dem Stapel befunden hat. Wir haben das Tier und den Ton, dann "hatten", "ein" usw. und schließlich ", EIEIO" und die Hauptsaite "10, ...!". Um zu vermeiden, dass zu viele Anführungszeichen verwendet werden, füge ich alle Zeichenfolgen (außer den Parametern) in eine Zeichenfolge ein, teile sie dann auf und lösche das resultierende Array ( '|/~).

Die Hauptzeichenfolge durchläuft die folgenden Transformationen:

10,
And on that 5 he7690,
With3 2 and3 t2,
Here4t24everyw23,
10!

ersetzen "0"durch ", E-I-E-I-O":

1, E-I-E-I-O,
And on that 5 he769, E-I-E-I-O,
With3 2 and3 t2,
Here4t24everyw23,
1, E-I-E-I-O!

ersetzen "1"durch "Old MacDonald765":

Old MacDonald765, E-I-E-I-O,
And on that 5 he769, E-I-E-I-O,
With3 2 and3 t2,
Here4t24everyw23,
Old MacDonald765, E-I-E-I-O!

ersetzen "2"mit "here", dann "3"mit "68 8"etc.

8 entspricht dem Ton und 9 dem Tier.

aditsu
quelle
Kannst du das erklären? Ich weiß nicht einmal, was CJam ist
Cruncher
@ Cruncher CJam ist eine Sprache, die ich gemacht habe, sf.net/p/cjam ; Ich kann es erklären, wenn ich mit dem Golfen fertig bin :)
aditsu
1
@Cruncher hat jetzt eine Erklärung hinzugefügt
aditsu
9
♬ und an diesen fünf sieben'n sechs neun, ze eee ro ♬
aditsu
Kann E-I-eine Zeichenfolge sein, die dann wiederholt wird? :)
rybo111
5

Bash + Symbolv, 128 Unicode-Zeichen

Nimmt den folgenden Rumpf der Funktion pure-bash / ascii und wandelt ihn in Unicode-Zeichen um:

m()(c=`iconv -t unicode<<<㵳⁜屡␠ਲ㵨敨敲攊ⰽ⁜ⵅⵉⵅⵉ੏㵯伢摬䴠捡潄慮摬栠摡愠映牡⑭≥攊档␢Ɐ䄊摮漠桴瑡映牡敨栠摡愠␠␱ⱥ圊瑩⑨⁳㈤␠⁨湡⑤⁳㈤琠栤ਬ效敲猤‬⑴⑨ⱳ攠敶祲⑷⑨⁳㈤ਬ漤™ਠ`
eval "${c:2}")

Definiert eine Shell-Funktion m . Anrufen als:

$ m Pony wiehern
Der alte MacDonald hatte eine Farm, EIEIO,
Und auf dieser Farm hatte er ein Pony, EIEIO,
Mit einem Nachbarn hier und einem Nachbarn dort,
Hier ein Nachbar, dort ein Nachbar, überall ein Nachbar,
Der alte MacDonald hatte eine Farm, EIEIO!
$ 

Pure Bash, 171 Bytes (nur ASCII)

Ich denke, es ist erwähnenswert, dass der ursprüngliche Vers (mit "cow" und "moo") nur 203 Zeichen enthält.

m()(s=\ a\ $2
h=here
e=,\ E-I-E-I-O
o="Old MacDonald had a farm$e"
echo "$o,
And on that farm he had a $1$e,
With$s $2 $h and$s $2 t$h,
Here$s, t$h$s, everyw$h$s $2,
$o"!)

Definiert die Shell-Funktion m. Anrufen als:

$ m Schafbaa
Der alte MacDonald hatte eine Farm, EIEIO,
Und auf dieser Farm hatte er ein Schaf, EIEIO,
Mit einem baa baa hier und einem baa baa dort,
Hier ein Baa, dort ein Baa, überall ein Baa Baa,
Der alte MacDonald hatte eine Farm, EIEIO!
$
Digitales Trauma
quelle
4

C ++ (403)

Okay, das ist ein bisschen langwierig, aber wer mag es nicht, übermäßig zu definieren?

#define O ", E-I-E-I-O"
#define E O<<","
#define I "Old MacDonald had a farm"
#define H(a) "And on that farm he had a "<<a<<E
#define D(s) s<<" "<<s
#define W(s) "With a "<<D(s)<<" here and a "<<D(s)<<" there,"
#define V(s) "Here a "<<s<<", there a "<<s<<", everywhere a "<<D(s)<<","
#define F I<<O<<"!"
#define N endl
void m(string a, string s){cout<<I<<E<<N<<H(a)<<N<<W(s)<<N<<V(s)<<N<<F<<N;}
einsteinsci
quelle
2
this.eyes.bleeding = true;
Proxy
Irgendwelche Definitionen, die dieses enger packen könnten?
einsteinsci
1
Früher war es möglich, #define X defineund dann zu verwenden #X Y Z. Leider sind diese berauschenden IOCCC-Tage längst vorbei ...
nneonneo
Was ist mit +statt <<? Oder mit char*statt string? // Nur einer von diesen kann gleichzeitig verwendet werden.
Qwertiy
2

Python, 116 Unicode-Zeichen

def f(**a):print u'鱸쿳光䷰癌쿉ы㊲匒ሔ툕謒畲尔㵵䅵忘쮇⼱ⅅ伿⒡넣Ⰴ邩ઑ꩕醪徜妮ꊌ㰺⒳Ⰳ鮕꾟ౙ㎧譒ᕒ끒镈롴쀼怪㪢愐腤닔ꋔ狊兔Ⲹ㾗꽡Ȩ똀䝸å'.encode('u16')[2:].decode('zip')%a

StackOverflow frisst meine Sonderzeichen, also hier die Datei in base64:

77u/ZGVmIGYoKiphKTpwcmludCB1J+mxuOy/s+WFieS3sOeZjOy/idGL44qy5YyS4YiU7YiV6KyS55Wy5bCU47W15IW15b+Y7K6H4ryx4oWF5Ly/4pKh64Sj4rCE6YKp4KqR6qmV6Yaq5b6c5aau6oqM47C64pKz4rCD6a6V6r6f4LGZ446n6K2S4ZWS74yS64GS6ZWI7pKA66G07IC85oCq46qi5oSQ6IWk64uU6ouU54uK5YWU4rK4476X6r2hyKjrmIDknbjDpScuZW5jb2RlKCd1MTYnKVsyOl0uZGVjb2RlKCd6aXAnKSVh

Die Daten werden mit zlib gepackt, wodurch sich wiederholende Zeichenfolgen effizient codiert werden (zlib kann Text im Allgemeinen gut komprimieren). Um die "Unicode-Zeichen" -Regel zu nutzen, wird der 121-Byte-Zlib-Block aufgefüllt und in eine 61-Zeichen-Unicode-Zeichenfolge halbiert, indem der Bytestring als UTF-16 interpretiert wird.

Rufen Sie die Funktion auf als

f(cow='pig', moo='oink')
nneonneo
quelle
Schön, aber wo Kuh und Moo Zeichenketten in den Funktionsparametern sind und als solche zum Beispiel in Schwein und Rind oder Schaf und Baa geändert werden können . Sieht so aus, als ob Ihre Ausgabe für cow / moo fest codiert ist.
Digital Trauma
@DigitalTrauma: Mein Leseverständnis schlägt fehl! Fest.
Nneonneo
das ist besser :) +1
Digitales Trauma
115 . Keine Notwendigkeit, die nachgestellte Zeile zu zählen.
Nyuszika7h
@ nyuszika7h Nein, es ist 116. Sie haben zu Beginn vergessen, die UTF-8-Stückliste (EF BB BF) zu zählen, die erforderlich ist, damit Python 2 Nicht-ASCII-Quellen akzeptiert. (Dies ist nicht Python 3, was nicht muss .decode('zip').)
Anders Kaseorg
1

Python, 217

So viel kann man nicht golfen. Ich habe gerade die offensichtliche Front-End-Wiederholung rausgenommen und ...

m,f="Old MacDonald had a farm, E-I-E-I-O",lambda x,y:m+",\nAnd on that farm he had a %s, E-I-E-I-O,\nWith a %shere and a %sthere,\nHere a %s, there a %s, everywhere a %s %s,\n%s!"%((x,)+((y+' ')*2,)*2+(y,)*4+(m,))

Javascript, 241 - JSCrush betrügen

Das mit JSCrush gemacht ... keine echte Antwort, es wäre nur interessant zu sehen, ob jemand dies in einer Mainstream-Sprache schlagen kann. ( EDIT : äh)

_='var f=function(c,a){var b=a "+a;return"Anon that he hadcWith  and tHere  t   everyw!"};OlMacDonalhaa a "+, O,\\nhere+"b farm a, d E-I-';for(Y in $=' ')with(_.split($[Y]))_=join(pop());eval(_)
cjfaure
quelle
1

Java, 246

void f(String[] a){String o="Old MacDonald had a farm",e=", E-I-E-I-O",x=" a "+a[1],s=x+" "+a[1];System.out.print(o+e+",\nAnd on that farm he had a "+a[0]+e+",\nWith"+s+" here and"+s+" there,\nHere"+x+", there"+x+", everywhere"+s+",\n"+o+e+"!");}

Verwendung: f(new String[]{"cow","moo"});

Gayuha
quelle
1

Java - 262 258

void m(String...s){String b=s[1],c=b+" "+b,d="E-I-E-I-O",e="Old MacDonald had a farm, "+d;System.out.print(e+",\n"+"And on that farm he had a "+s[0]+", "+d+",\nWith a "+c+" here and a "+c+" there,\nHere a "+b+", there a "+b+", everywhere a "+c+",\n"+e+"!");}

Eine weitere Optimierung ist definitiv möglich.

Ypnypn
quelle
Sie könnten printf
aditsu
Trevin Avery schlug folgende Änderung vor: Java - 243 - void String ... a) {String c = "a" + a [1], d = c + "" + a [1], e = ", EIEIO", f = "Der alte MacDonald hatte eine Farm" + e; System.out.print (f + ", \ nUnd auf dieser Farm hatte er ein" + a [0] + e + ", \ nMit" + d + "hier und" + d + "dort , \ nHier "+ c +", dort "+ c +" ', überall "+ d +", \ n "+ f +"! ");} Eine weitere Optimierung ist definitiv möglich
Justin
1

Perl 5 (UTF-8) - 131 Zeichen, 313 Byte

Das folgende Skript muss als UTF-8 ohne Stückliste gespeichert werden.

use utf8;use Encode;eval encode ucs2,'獵戠晻③㴤∮灯瀻⑥㴢Ⱐ䔭䤭䔭䤭伢㬤漽≏汤⁍慣䑯湡汤⁨慤⁡⁦慲洤攢㬤ⰽ≥牥⁡∻獡礢⑯Ⰺ䅮搠潮⁴桡琠晡牭⁨攠桡搠愠䁟⑥Ⰺ坩瑨⁡③③⁨␬湤⁡③③⁴桥牥Ⰺ䠤Ⱔ戬⁴栤Ⱔ戬⁥癥特睨␬③③Ⰺ⑯™紱';

Verbrauch: f("cow", "moo");.

Perl muss mit dem -M5.010Flag ausgeführt worden sein, um die Perl 5.10-Funktionen zu aktivieren. ( Dies ist erlaubt .)

Mir gefällt die Symmetrie zwischen der Anzahl der Zeichen (131) und der Anzahl der Bytes (313) sehr gut. Es ist sehr yin und yang.

Perl 5 (ASCII) - 181 Zeichen, 181 Bytes

sub f{$b=$".pop;$e=", E-I-E-I-O";$o="Old MacDonald had a farm$e";$,="ere a";say"$o,
And on that farm he had a @_$e,
With a$b$b h$,nd a$b$b there,
H$,$b, th$,$b, everywh$,$b$b,
$o!"}

Verbrauch: f("cow", "moo");.

Auch hier muss Perl mit dem -M5.010Flag ausgeführt werden, um die Perl 5.10-Funktionen zu aktivieren.

tobyink
quelle
Hmm, sieht familar codegolf.stackexchange.com/a/26633/11259 ;-)
Digital -
Eigentlich war codegolf.stackexchange.com/a/26628/12469 mein Ausgangspunkt. Ich habe einige zusätzliche Variablen getestet, die die Länge weiter verkürzen, und dann den UTF16-Trick angewendet, den einige der anderen Implementierungen verwenden.
Bis
1

CJam (Nicht-ASCII) - 77 Zeichen

"啝裢樃濿䶹讄團챤鋚䖧雿ꆪꆵ䷶텸紎腕Խꍰ搓᩟童䚯⤭刧损⬛豳Ẍ퍾퓱郦퉰怈䡞௳閶蚇⡾쇛蕟猲禼࿆艹蹚㞿䛴麅鞑椢⧨餎쏡첦휽嬴힡ݷ녣㯂鐸㭕"56e3b127b:c~

Verwendung: "cow""moo"F

Die Zeichenfolge ist meine andere CJam-Lösung, die von Basis 127 auf Basis 56000 konvertiert wurde.
ein UTF-8-Gebietsschema erforderlich.

Übrigens können Sie dies jetzt online unter http://cjam.aditsu.net/ ausprobieren.

aditsu
quelle
1

JavaScript: 152 Zeichen / ES6: 149 Zeichen

Hier ist eine JS-Funktion namens "z", die den Job in 214 Zeichen erledigt. (nicht ausführen!)

function z(a,b){c=' a '+b;d=c+' '+b;e=', E-I-E-I-O';f='Old MacDonald had a farm'+e;return(f+',\nAnd on that farm he had a '+a+e+',\nWith'+d+' here and'+d+' there,\nHere'+c+', there'+c+', everywhere'+d+',\n'+f+'!')}

Ich habe es in Unicode-Zeichen "gepackt" (mit einer Technik, die von @subzey und mir für 140Byte erstellt wurde).

eval(unescape(escape('𩡵𫡣𭁩𫱮𘁺𚁡𛁢𚑻𨰽𙰠𨐠𙰫𨠻𩀽𨰫𙰠𙰫𨠻𩐽𙰬𘁅𛑉𛑅𛑉𛑏𙰻𩠽𙱏𫁤𘁍𨑣𡁯𫡡𫁤𘁨𨑤𘁡𘁦𨑲𫐧𚱥𞱲𩑴𭑲𫠨𩠫𙰬𧁮𠑮𩀠𫱮𘁴𪁡𭀠𩡡𬡭𘁨𩐠𪁡𩀠𨐠𙰫𨐫𩐫𙰬𧁮𥱩𭁨𙰫𩀫𙰠𪁥𬡥𘁡𫡤𙰫𩀫𙰠𭁨𩑲𩐬𧁮𢁥𬡥𙰫𨰫𙰬𘁴𪁥𬡥𙰫𨰫𙰬𘁥𭡥𬡹𭱨𩑲𩐧𚱤𚰧𛁜𫠧𚱦𚰧𘐧𚑽').replace(/uD./g,'')))

Führen Sie das letzte Snippet aus und rufen z("cow","moo")Sie dann auf. Sie erhalten dann die folgende Zeichenfolge:

Old MacDonald had a farm, E-I-E-I-O,
And on that farm he had a cow, E-I-E-I-O
With a moo moo here and a moo moo there,
Here a moo, there a moo, everywhere a moo moo,
Old MacDonald had a farm, E-I-E-I-O!"

Mehr Infos hier: http://xem.github.io/golfing/en.html#compress

ES6-Version:

eval(unescape(escape('𮠽𚁡𛁢𚐽🡻𨰽𙰠𨐠𙰫𨠻𩀽𨰫𙰠𙰫𨠻𩐽𙰬𘁅𛑉𛑅𛑉𛑏𙰻𩠽𙱏𫁤𘁍𨑣𡁯𫡡𫁤𘁨𨑤𘁡𘁦𨑲𫐧𚱥𞱲𩑴𭑲𫠨𩠫𙰬𧁮𠑮𩀠𫱮𘁴𪁡𭀠𩡡𬡭𘁨𩐠𪁡𩀠𨐠𙰫𨐫𩐫𙰬𧁮𥱩𭁨𙰫𩀫𙰠𪁥𬡥𘁡𫡤𙰫𩀫𙰠𭁨𩑲𩐬𧁮𢁥𬡥𙰫𨰫𙰬𘁴𪁥𬡥𙰫𨰫𙰬𘁥𭡥𬡹𭱨𩑲𩐧𚱤𚰧𛁜𫠧𚱦𚰧𘐧𚑽').replace(/uD./g,'')))
xem
quelle
Ich denke, Sie haben die Dinge nicht richtig kopiert und eingefügt, Ihr Code scheint über 250 Zeichen zu haben - hoppla, vielleicht nicht, aber mein Texteditor verhält sich seltsam.
Aditsu
Oh, die meisten deiner Charaktere stammen aus Astralebenen (das ist wahrscheinlich der Grund, warum sie hier als 2 Charaktere gezählt werden) ... und sind auch nicht zugeordnet. Dies
verstößt gegen
Nun, ich glaube nicht, dass dies betrügt: Diese Symbole sind Unicode-Zeichen und sollten nicht als zwei Zeichen gelten. Außerdem zählt Twitter sie jeweils als 1 Zeichen. Wenn Sie die ES6-Version in einem Tweet kopieren, heißt es, dass sie um 9 Zeichen zu lang ist. Also, 149 ist es :)
xem
1

C # - 339 Bytes

void x(string c, string d){var a="Old MacDonald had a farm";var b=", E-I-E-I-O";var f=" a ";var g=" there";Debug.WriteLine(a+b+",");Debug.WriteLine("And on that farm he had"+f+c+b+",");Debug.WriteLine("With"+f+d+" "+d+" here and"+f+d+" "+d+g+",");Debug.WriteLine("Here"+f+d+","+g+f+d+", everywhere"+f+d+" "+d+",");Debug.WriteLine(a+b+"!");

Verwendung: x("cow","moo");

Tsavinho
quelle
1

Rebol, 206 202

f: func[a b][print reword{$o$e,
And on that farm he had a $a$e,
With a $b $b here and a $b $b there,
Here a $b, there a $b, everywhere a $b $b,
$o$e!}[e", E-I-E-I-O"o"Old MacDonald had a farm"a a b b]]

Verwendung: f "cow" "moo"

draegtun
quelle
0

Delphi XE3 ( 272 252)

procedure k(a,s:string);const o='Old MacDonald had a farm';e=', E-I-E-I-O';n=','#13#10;begin s:=' '+s;write(o+e+n+'And on that farm he had a '+a+e+n+'With a'+s+s+' here and a'+s+s+' there'+n+'Here a'+s+', there a'+s+' every where a'+s+s+n+o+e+'!');end;

Ungolfed

procedure k(a,s:string);
const
  o='Old MacDonald had a farm';
  e=', E-I-E-I-O';
  n=','#13#10;
begin
  s:=' '+s;
  write(o+e+n+'And on that farm he had a '+a+e+n+'With a'+s+s+' here and a'+s+s+' there'+n+'Here a'+s+', there a'+s+' every where a'+s+s+n+o+e+'!');
end;
Teun Pronk
quelle
0

Lua 237

function f(a,b)c=b.." "..b;d="Old MacDonald had a farm, E-I-E-I-O"print(d..",\nAnd on that farm he had a "..a..", E-I-E-I-O,\nWith a "..c.." here and a "..c.." there,\nHere a "..b..", there a "..b..", everywhere a "..c..",\n"..d.."!")end

Durch die Definition c=b.." "..bkann ich ein Dutzend Zeichen speichern. Durch das Definieren dwie ich, spare ich 23 Zeichen. Ich sehe nicht mehr ein, wie ich das verkürzen kann. Dies wird über aufgerufen f("<animal>","<sound>").

Kyle Kanos
quelle
0

Java 8 (411)

String m(String...m){LinkedHashMap<String,String>n=new LinkedHashMap<>();n.put("/","( * #, -");n.put("#","farm");n.put("-","E-I-E-I-O");n.put("+","here");n.put("*","had a");n.put("(","Old MacDonald");n.put("|"," a )");n.put(")","moo");n.put("moo",m[1]);n.put("cow",m[0]);m[0]="/,\nAnd on that # he * cow, -,\nWith|) + and|) t+,\nHere|, t+|, everyw+|),\n/!";n.forEach((k,v)->m[0]=m[0].replace(k,v));return m[0];}

Durch den Missbrauch von Lambda wurden die Ersetzungen in eine LinkedhashMap eingefügt, um sie in einer definierten Reihenfolge zu halten. Anschließend wurde mit foreach Lambda der Schlüssel durch den Wert in der Hauptzeichenfolge ersetzt. Parameter werden als die letzten 2 Ersetzungen in der Karte hinzugefügt. Dieses varargs-Argument soll einige Bytes im Methodenkopf entfernen

Ungolfed-Version:

String m(String... m)
{
    LinkedHashMap<String, String> n = new LinkedHashMap<>();
    n.put("/", "( * #, -");
    n.put("#", "farm");
    n.put("-", "E-I-E-I-O");
    n.put("+", "here");
    n.put("*", "had a");
    n.put("(", "Old MacDonald");
    n.put("|", " a )");
    n.put(")", "moo");
    n.put("moo", m[1]);
    n.put("cow", m[0]);
    m[0] = "/,\nAnd on that # he * cow, -,\nWith|) + and|) t+,\nHere|, t+|, everyw+|),\n/!";
    n.forEach((k, v) -> m[0] = m[0].replace(k, v));
    return m[0];
}
masterX244
quelle
0

JavaScript 220

function f(a,b){c=' a '+b;d=c+' '+b;e=', E-I-E-I-O';f='Old MacDonald had a farm'+e;console.log(f+',\nAnd on that farm he had a '+a+e+',\nWith'+d+' here and'+d+' there,\nHere'+c+', there'+c+', everywhere'+d+',\n'+f+'!');}

Angerufen von

f('cow', 'moo');
Trevin Avery
quelle
0

Pure C, 298 Bytes, kein Unicode

In meiner Funktion nehme ich ein einziges Argument, das eigentlich ein Haufen char*zusammengepackt ist. Jede Zeichenfolge ist nullterminiert und am Ende befindet sich ein zusätzlicher Nullterminator. Dies ermöglicht mir zu überprüfenstrlen(a) am Ende jeder Schleife , anstatt eine Zählervariable zu behalten.

mcdonald.c:

m(char*a){while(strlen(a)){printf("Old MacDonald had a farm, E-I-E-I-O\nAnd on that farm he had a %s, E-I-E-I-O,\nWith a ",a);a+=strlen(a)+1;printf("%s %s here and a %s %s there,\nHere a %s, there a %s, everywhere a %s %s,\nOld MacDonald had a farm, E-I-E-I-O!\n",a,a,a,a,a,a,a,a);a+=strlen(a)+1;}}

Haupt c:

int m(char *v);
int main(int argc, char **argv) {
    m("cow\0moo\0programmer\0meh\0\0");
    return 0;
}

Ausgabe:

clang main.c mcdonald.c && ./a.out
Old MacDonald had a farm, E-I-E-I-O
And on that farm he had a cow, E-I-E-I-O,
With a moo moo here and a moo moo there,
Here a moo, there a moo, everywhere a moo moo,
Old MacDonald had a farm, E-I-E-I-O!
Old MacDonald had a farm, E-I-E-I-O
And on that farm he had a programmer, E-I-E-I-O,
With a meh meh here and a meh meh there,
Here a meh, there a meh, everywhere a meh meh,
Old MacDonald had a farm, E-I-E-I-O!
wjl
quelle
0

Cobra - 203

def f(a,b)
    d=" a [b] "+b
    e=", E-I-E-I-O"
    m="Old MacDonald had a farm[e]"
    print "[m],\nAnd on that farm he had a [a][e],\nWith[d] here and[d] there,\nHere a [b], there a [b], everywhere[d],\n[m]!"

Selbst für eine Sprache mit wenigen bis gar keinen Mehrfachausdrücken und strengen Einrückungsregeln ist Cobra noch recht gut.

Οurous
quelle
0

C: 224 Bytes

Mithilfe des printf- Präzisionsspezifizierers können wir dieselbe Zeichenfolge wie die printf-Formatzeichenfolge und zwei der Parameter verwenden.

o(char*x,char*y){char*f="Old MacDonald had a farm, E-I-E-I-O,\nAnd on that farm he had a %s%.13sWith a %s %s here and a %s %s there,\nHere a %s, there a %s, everywhere a %s %s,\n%.35s!\n";printf(f,x,f+24,y,y,y,y,y,y,y,y,f);}

Mit Leerzeichen und in Zeilen aufgeteilter Zeichenfolge:

o(char* x, char* y)
{
    char* f=
        "Old MacDonald had a farm, E-I-E-I-O,\n"
        "And on that farm he had a %s%.13s"
        "With a %s %s here and a %s %s there,\n"
        "Here a %s, there a %s, everywhere a %s %s,\n"
        "%.35s!\n";

    printf(f,x,f+24,y,y,y,y,y,y,y,y,f);
}
David Yaw
quelle
0

PHP - 272 Zeichen, 272 Bytes

function m($q,$w){for($e="@&And on that farm he had^<%&With *h# and*th#&H(th(everywh#^> >&@!",$r=1;;$e=$r){$r=str_replace(["@","#","^","%","<",">","&","*","("],["Old MacDonald had^farm%","ere"," a ",", E-I-E-I-O",$q,$w,",\n","^> > ","#^>, "],$e);if($e==$r)break;}echo $e;}

Verbrauch: m("cow", "moo");,m("fox", "Hatee-hatee-hatee-ho");

Parameter mit @#%^<>&*(Absturz der Ausgabe.

Snack
quelle
0

Haskell (282 und immer noch etwas lesbar :))

wc -c oldmacdonald.hs
     282 oldmacdonald.hs

Die Datei:

main=mapM putStrLn[s"cow""moo",s"pig""oink",s"sheep""baa"]
s c m=o#",\nAnd on that farm he had"#b c#e#let n=m#" "#m in",\nWith"#b n#" here and"#b n#" there,\nHere"#b m#", there"#b m#", everywhere"#b n#",\n"#o#"!\n"
o="Old MacDonald had a farm"#e
e=", E-I-E-I-O"
b=(" a "#)
(#)=(++)
Leinen
quelle
Es ist 281. Normalerweise wird die nachgestellte Zeile nicht gezählt, es sei denn, es handelt sich um ein C-Präprozessor-Makro oder etwas anderes, das eine Zeilenumbruch-Terminierung erfordert. In den meisten Fällen können Sie nur 1 von der von zurückgegebenen Byteanzahl abziehen.wc -c Ich bevorzuge jedoch die Verwendung von mothereff.in/byte-counter und stelle sicher, dass am Ende keine Leerzeile steht, es sei denn, das Programm funktioniert.
Nyuszika7h
0

ES6, 2 Lösungen von 179 186 Zeichen ohne Unicode

f=(a,b)=>alert("325And on that farm he had a025With a11 h4nd a11 th45H41, th41, everywh411532!".replace(/\d/g,x=>[" "+a," "+b,", E-I-E-I-O","Old MacDonald had a farm","ere a",",\n"][x]))

Und der zweite:

f=(a,b)=>alert("3625And on7at6 he ha8025With a11 h4n811745H41,741, everywh4115362!".replace(/\d/g,x=>(` ${a}0 ${b}0, E-I-E-I-O0Old MacDonald had a0ere a0,\n0 farm0 th0d a`).split(0)[x]))

Ich habe einen Benachrichtigungsanruf hinzugefügt (+7 Zeichen).

Qwertiy
quelle
Ich denke, es ist momentan die kürzeste Lösung von Nicht-Unicode-Lösungen.
Qwertiy
0

JavaScript (E6) 140 Zeichen

Zeichenzähler: https://mothereff.in/byte-counter , 140 Zeichen, 425 Byte in UTF-8

eval(unescape(escape('𩠽𚁡𛁢𚐽🡡𫁥𬡴𚀧𜀱𜠵𠑮𩀠𫱮𘀶𨑴𜐳𩐳𨑤𝰠𞐲𝑗𪐶𘁡𞀸𜰴𝱮𩀠𨐸𞀠𝠴𝑈𝀷𞀬𘀶𝀷𞀬𘁥𭡥𬡹𭱨𝀷𞀸𝐰𜐲𘐧𛡲𩑰𫁡𨱥𚀯𧁤𛱧𛁣🐾𚀧𣱬𩀠𣑡𨱄𫱮𨑬𩀠𪁡𩀠𨐰𘁦𨑲𫐰𛀠𡐭𢐭𡐭𢐭𣰰𘁨𜁥𬡥𜀬𧁮𜁴𪀰𘁡𜀠𙰫𨠫𜀫𨐩𛡳𬁬𪑴𚀰𚑛𨱝𚐩𒠠').replace(/uD./g,'')))

Ursprünglicher ASCII-Code 188 Bytes

f=(a,b)=>alert('0125And on 6at13e3ad7 925Wi6 a88347nd a88 645H478, 6478, everywh47885012!'.replace(/\d/g,c=>('Old MacDonald had a0 farm0, E-I-E-I-O0 h0ere0,\n0th0 a0 '+b+0+a).split(0)[c]))

Komprimiert mit http://xem.github.io/obfuscatweet/

Test in der FireFox / FireBug-Konsole

f('mosquito','zzz')

Ausgabe

Old MacDonald had a farm, E-I-E-I-O,
And on that farm he had a mosquito, E-I-E-I-O,
With a zzz zzz here and a zzz zzz there,
Here a zzz, there a zzz, everywhere a zzz zzz,
Old MacDonald had a farm, E-I-E-I-O!
edc65
quelle