Antigua función de MacDonald

16

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.

rybo111
fuente
1
¿No debería ser esto complejidad kolmogorov ?
mniip
66
Usted dice echoes the following. ¿Quiere decir que la función debería imprimirlo o devolverlo?
cjfaure 05 de
2
Para hacer esto justo, creo que esto debería tener la puntuación exacta, espacios y retornos de carro en la pregunta. Pero, ¿qué opinas sobre mayúsculas / minúsculas? Pensé que un solo caso podría ser más fácil y evitar una carga de aplicaciones estándar de base64 o similar. En general, las únicas mayúsculas están al comienzo de la línea, la palabra MacDonald y en el EIEIO, por lo que puede ser más interesante hacer eso exactamente según la pregunta también.
Level River St
44
¿Es aceptable la salida a oinko debería hacerse eso an oink?
ClickRick
44
@ rybo111: ¿Sabía que el gran Donald Knuth escribió un artículo académico sobre este tipo de cosas? En realidad, se publicó en una revista real (ciertamente en la edición de abril). Más aquí, incluido un enlace al PDF del documento: en.wikipedia.org/wiki/The_Complexity_of_Songs
Tom Chantler

Respuestas:

15

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

Michael M.
fuente
2
"cow"y "moo"se supone que son los parámetros de la función. Al hacer que la persona que llama pase una matriz, está guardando caracteres dentro de la definición de la función a expensas de agregar al recuento de caracteres del código de llamada. Esto me huele a trampa. Llevando ese enfoque al extremo, podría definir function f(a){alert(a)}(23 caracteres) y decir que debe llamarse así f("Old MacDonald had a ...").
tobyink
1
Había pasado las cadenas en dos parámetros separados, pero después de leer el desafío, no vi ninguna razón para no pasar las cadenas en formato de matriz, así que edité mi respuesta. Esto no es trampa, solo guarda algunos caracteres cuando es posible. Deje que @ rybo111 decida si esto se ajusta a la regla o no.
Michael M.
1
@tobyink Utilicé el término 'cadena' (no matriz) en las reglas, así que supongo que tienes razón. ¡Sin embargo, creo que 'hacer trampa' es un poco duro!
rybo111
2
¿Por qué esto tiene tantos votos? Tiene más de 200 y ni siquiera la solución de JavaScript más corta.
Aditsu
Bien y bien explicado, así que también tengo mi voto
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;

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.

aditsu
fuente
¿Puede explicar esto? Ni siquiera sé qué es CJam
Cruncher
@Cruncher CJam es un lenguaje que hice, sf.net/p/cjam ; Puedo explicarlo una vez que termine de
jugarlo
1
@Cruncher agregó explicación ahora
aditsu 05 de
99
♬ y en ese cinco vio seis nueve, ze eee ro
ad
¿Puede E-I-ser una cadena que luego se repite? :)
rybo111
5

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
Trauma digital
fuente
4

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;}
einsteinsci
fuente
2
this.eyes.bleeding = true;
Proxy
¿Alguno define que podría empacar aún más este?
einsteinsci
1
Solía ​​ser posible #define X definey luego usar #X Y Z. Lamentablemente, esos días embriagadores IOCCC son ahora mucho más allá ...
nneonneo
¿Qué pasa con el uso en +lugar de <<? O usando en char*lugar de string? // Solo se puede usar uno de estos al mismo tiempo.
Qwertiy
2

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')
nneonneo
fuente
Agradable, pero donde vaca y muu son cadenas en los parámetros de la función, y como tal, pueden cambiarse a cerdo y oink o ovejas y baa, por ejemplo . Parece que su salida está codificada para cow / moo.
Trauma digital
@ Digital Trauma: ¡Mi comprensión de lectura falla! Fijo.
nneonneo
eso es mejor :) +1
Trauma digital
115 . No es necesario contar la nueva línea final.
nyuszika7h
@ nyuszika7h No, es 116. Se olvidó de contar el "UTF-8 BOM" (EF BB BF) al principio, lo cual es necesario para permitir que Python 2 acepte fuentes no ASCII. (Esto no es Python 3, que no tiene .decode('zip').)
Anders Kaseorg
1

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(_)
cjfaure
fuente
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+"!");}

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

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

Una optimización adicional es definitivamente posible.

Ypnypn
fuente
Podrías usar printf
aditsu
Trevin Avery sugirió esta edición: Java - 243 - Cadena vacía ... a) {Cadena c = "a" + a [1], d = c + "" + a [1], e = ", EIEIO", f = "El viejo MacDonald tenía una granja" + e; System.out.print (f + ", \ nY en esa granja tenía un" + a [0] + e + ", \ nCon" + d + "aquí y" + d + "allí , \ nAquí "+ c +", allí "+ c +" ', en todas partes "+ d +", \ n "+ f +"! ");} Definitivamente es posible una mayor optimización
Justin
1

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.

tobyink
fuente
Hmm, parece familiar codegolf.stackexchange.com/a/26633/11259 ;-)
Digital Trauma
En realidad codegolf.stackexchange.com/a/26628/12469 fue mi punto de partida. Probé algunas variables adicionales que redujeron aún más la longitud, y luego apliqué el truco UTF16 que utilizan otras implementaciones.
tobyink
1

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/

aditsu
fuente
1

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,'')))
xem
fuente
Creo que no copiaste y pegaste las cosas correctamente, tu código parece tener más de 250 caracteres, vaya, tal vez no, pero mi editor de texto se está comportando de manera extraña, lo investigaré.
Aditsu
Oh, la mayoría de tus personajes son de algunos planos astrales (probablemente por eso se cuentan como 2 personajes aquí) ... y también no asignados. Esto está estirando las reglas un poco :)
Aditsu
Bueno, no creo que esto sea trampa: esos símbolos son caracteres unicode, y no deberían contar como 2 caracteres. Además, Twitter cuenta cada uno de ellos como 1 personaje. Si copia la versión ES6 en un tweet, dice que es demasiado largo por 9 caracteres. Entonces, 149 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+"!");

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

tsavinho
fuente
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]]

Uso: f "cow" "moo"

draegtun
fuente
0

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;
Teun Pronk
fuente
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

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

Kyle Kanos
fuente
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];}

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];
}
masterX244
fuente
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');
Trevin Avery
fuente
0

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

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.

Οurous
fuente
0

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);
}
David Yaw
fuente
0

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.

Bocadillo
fuente
0

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 "#)
(#)=(++)
linse
fuente
Es 281, por lo general no cuenta la nueva línea final, a menos que sea una macro de preprocesador C o alguna otra cosa que requiera la terminación de la nueva línea. En la mayoría de los casos, puede restar 1 del recuento de bytes devuelto por wc -c, pero prefiero usar mothereff.in/byte-counter y asegurarme de que no haya una línea vacía al final a menos que sea necesario para que el programa funcione.
nyuszika7h
0

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

Qwertiy
fuente
Creo que es la solución más corta de las que no están codificadas por ahora.
Qwertiy
0

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!
edc65
fuente