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.

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

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.

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

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

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

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

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

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.

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.

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.

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

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

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"

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;

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

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];
}

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

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!

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.

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

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.

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 "#)
(#)=(++)

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

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!