Cree una función en el idioma elegido que imprima lo siguiente:

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!

Las cadenas where cowy mooare en los parámetros de la función y, como tales, se pueden cambiar a pigy oinko sheepy baa, por ejemplo.

Debe tener en cuenta letras mayúsculas, guiones, signos de puntuación, espacios y saltos de línea.

Intente escribir la menor cantidad de caracteres Unicode en su código.

Javascript ES6 - 204

Intente escribir la menor cantidad de caracteres Unicode en su código.

No es el más corto pero probablemente el más ofuscado.

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

Si su navegador no es compatible con ES6:

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

Copiar / pegar el código en la consola del navegador e intente f('cow','moo'), f('pig','oink'),f('sheep','baa')

Cómo funciona ?

ces un conjunto de 29 letras más el animal y su sonido (vamos a llamarlo nuestro alfabeto ).
Entonces, los 31 caracteres caben en 5 bits (2 ^ 5 = 32).
Un carácter Unicode tiene 16 bits de longitud, por lo que puede codificar 3 caracteres de nuestro alfabeto con un bit de relleno.
El texto completo con las nuevas líneas tiene 186 caracteres de nuestro alfabeto , se puede codificar con 62 caracteres Unicode.

Por ejemplo, Oldse codifica así:

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

Si tiene problemas para leer algunos caracteres Unicode, instale la fuente 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;

Uso: "cow""moo"F
para GolfScript reemplazar '|con "|"y Acon10

Explicación:

La parte clave es A,{`/\*}/:
A,{...}/ejecuta el bloque para cada número de 0 a 9 (A = 10)
`convierte el número en cadena
/\*, reemplaza una cadena: si tenemos en la pila, "bar" "foo 1 baz" "1"luego /divide la cadena resultante ["foo " " baz"], \intercambia esta matriz con el elemento anterior ("bar") y se *une a la matriz que resulta en"foo bar baz"

Entonces, el código reemplaza cada número en la cadena principal con una cadena que estaba previamente en la pila. Tenemos el animal y el sonido, luego "had", "a", etc. y finalmente ", EIEIO" y la cadena principal, "10, ...!". Para evitar el uso de demasiadas comillas, puse todas las cadenas (excepto los parámetros) en una cadena, luego la dividí y volqué la matriz resultante ( '|/~)

La cadena principal pasa por las siguientes transformaciones:

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

reemplazar "0"con ", 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!

reemplazar "1"con "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!

reemplazar "2"con "here", luego "3"con "68 8"etc.

8 corresponde al sonido y 9 al animal.

Bash + iconv, 128 caracteres Unicode

Toma el siguiente cuerpo de función pure-bash / ascii y codifica en reversa en caracteres unicode:

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

Define una función de shell m. Llamar como:

$ m poni vecino
El viejo MacDonald tenía una granja, EIEIO,
Y en esa granja tenía un pony, EIEIO,
Con un vecino cercano aquí y un vecino vecino allá,
Aquí un relincho, allí un relincho, en todas partes un relincho relincho,
¡El viejo MacDonald tenía una granja, EIEIO!
PS 

Bash puro, 171 bytes (solo ascii)

Creo que vale la pena señalar que el verso original (con "vaca" y "muu") es solo 203 caracteres.

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

Define la función de shell m. Llamar como:

$ m ovejas baa
El viejo MacDonald tenía una granja, EIEIO,
Y en esa granja tenía una oveja, EIEIO,
Con un baa baa aquí y un baa baa allá,
Aquí un baa, hay un baa, en todas partes un baa baa,
¡El viejo MacDonald tenía una granja, EIEIO!
PS

C ++ (403)

Muy bien, esto es un poco arriesgado, pero ¿a quién no le gusta definir demasiado?

#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 caracteres Unicode

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

Sin embargo, StackOverflow se está comiendo mis caracteres especiales, así que aquí está el archivo en base64:

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

Los datos se empaquetan usando zlib, que codifica eficientemente cadenas repetidas (zlib es bueno para comprimir texto en general). Para aprovechar la regla de "caracteres Unicode", el fragmento zlib de 121 bytes se rellena y se divide a la mitad en una cadena Unicode de 61 caracteres interpretando la cadena de bytes como UTF-16.

Llame a la función como

f(cow='pig', moo='oink')

Pitón, 217

Realmente no puedes jugar tanto al golf. Acabo de sacar la evidente repetición frontal y ...

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 - truco JSCrush

Hecho esto con JSCrush ... no es realmente una respuesta real, sería interesante ver si alguien puede superar esto en un lenguaje convencional. ( EDITAR : uh)

_='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+"!");}

Uso: 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+"!");}

Una optimización adicional es definitivamente posible.

Perl 5 (UTF-8) - 131 caracteres, 313 bytes

El siguiente script debe guardarse como UTF-8 sin BOM.

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

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

Perl necesita haber sido ejecutado con la -M5.010bandera para habilitar las características de Perl 5.10. ( Esto está permitido )

Me gusta bastante la simetría de la cuenta de caracteres (131) y la cuenta de bytes (313). Es muy yin y yang.

Perl 5 (ASCII): 181 caracteres, 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!"}

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

Nuevamente, perl necesita haber sido ejecutado con la -M5.010bandera para habilitar las características de Perl 5.10.

CJam (no ASCII) - 77 caracteres

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

Uso: "cow""moo"F

La cadena es mi otra solución CJam convertida de la base 127 a la base 56000.
Es posible que se requiera un entorno local UTF-8.

Por cierto, ahora puedes probar esto en línea en http://cjam.aditsu.net/

JavaScript: 152 caracteres / ES6: 149 caracteres

Aquí hay una función JS llamada "z" que hace el trabajo en 214 caracteres. (¡no lo ejecutes!)

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+'!')}

Lo "empaqué" en caracteres unicode usando una técnica creada por @subzey y yo para 140byt.es).

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

ejecute ese último fragmento, luego llame z("cow","moo")y obtendrá esta cadena:

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

Más información aquí: http://xem.github.io/golfing/en.html#compress

Versión ES6:

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

Uso: 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]]

Uso: f "cow" "moo"

Delphi XE3 ( 272252 )

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;

Sin golf

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

Al definir c=b.." "..b, puedo guardar una docena de caracteres. Al definir dcomo lo hago, guardo 23 caracteres. Ya no veo cómo puedo acortar esto. Esto se llama vía 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];}

Abusando de lambda, colocó los reemplazos en un LinkedhashMap para mantenerlos en un orden definido y luego usó un lambda foreach para reemplazar la clave con el valor en la Cadena principal. los parámetros se agregan como los últimos 2 reemplazos en el mapa. ese argumento varargs es eliminar algunos bytes en el encabezado del método

Versión sin golf:

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+'!');}

Llamado por

f('cow', 'moo');

C puro, 298 bytes, sin unicode

En mi función, tomo un solo argumento, que en realidad es un montón de char*paquetes. Cada cadena está terminada en nulo, y hay un terminador nulo adicional al final. Esto me permite verificarstrlen(a) al final de cada ciclo, en lugar de mantener una variable de contador.

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

C Principal:

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

Salida:

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]!"

Incluso para un lenguaje con poco o nada de líneas múltiples y reglas de sangría estrictas, Cobra todavía funciona bastante bien.

C: 224 bytes

Al usar el especificador de precisión printf , podemos usar la misma cadena como la cadena de formato printf y como dos de los parámetros.

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

Con espacio en blanco y la cadena dividida en líneas:

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

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

Parámetros con @#%^<>&*(crash la salida.

Haskell (282 y todavía algo legible :))

wc -c oldmacdonald.hs
     282 oldmacdonald.hs

El archivo:

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 soluciones de 179 186 caracteres sin ningún 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]))

Y el segundo:

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

He agregado una llamada de alerta (+7 caracteres).

JavaScript (E6) 140 caracteres

Contador de caracteres: https://mothereff.in/byte-counter , 140 caracteres, 425 bytes en UTF-8

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

Código ASCII original 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]))

Comprimido con http://xem.github.io/obfuscatweet/

Prueba en la consola FireFox / FireBug

f('mosquito','zzz')

Salida

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!