Vecchia funzione MacDonald


16

Creare una funzione nella lingua scelta che stampa quanto segue:

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!

Dove cowe moosono le stringhe nei parametri della funzione, e come tali, possono essere cambiate in pige oinko sheepe baa, per esempio.

Dovrebbe prendere in considerazione lettere maiuscole, trattini, punteggiatura, spazi e interruzioni di riga.

Cerca di digitare il minor numero di caratteri Unicode nel tuo codice.


1
Non dovrebbe essere questa la complessità del kolmogorov ?
mniip,

6
Tu dici echoes the following. Vuoi dire che la funzione dovrebbe stamparlo o restituirlo?
Cjfaure,

2
Per renderlo giusto, penso che questo dovrebbe avere la punteggiatura, gli spazi e i ritorni a capo esatti nella domanda. Ma cosa ne pensi di maiuscole / minuscole? Ho pensato che un singolo caso potesse essere più semplice ed evitare un carico di applicazioni standard di base64 o simili. A conti fatti, le uniche capitali sono all'inizio della riga, la parola MacDonald e nell'EIEIO, quindi potrebbe essere più interessante farlo esattamente anche per la domanda.
Level River St,

4
È accettabile produrre a oinko dovrebbe essere fatto per essere an oink?
ClickRick,

4
@ rybo111: Eri consapevole che il grande Donald Knuth ha scritto un articolo accademico su questo genere di cose? In realtà è stato pubblicato su un vero diario (certamente nell'edizione di aprile). Altro qui incluso un link al PDF dell'articolo: en.wikipedia.org/wiki/The_Complexity_of_Songs
Tom Chantler

Risposte:


15

Javascript ES6 - 204

Cerca di digitare il minor numero di caratteri Unicode nel tuo codice.

Non il più corto ma probabilmente il più offuscato.

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

Se il tuo browser non supporta 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)}

Copia / incolla il codice nella console del browser e provare f('cow','moo'), f('pig','oink'),f('sheep','baa')

Come funziona ?

cè una matrice di 29 lettere più l'animale e il suo suono (chiamiamo questo nostro alfabeto ).
Quindi, tutti i 31 caratteri si adattano a 5 bit (2 ^ 5 = 32).
Un carattere Unicode è lungo 16 bit, quindi può codificare 3 caratteri del nostro alfabeto con un bit di riempimento.
Il testo completo con le nuove righe è di 186 caratteri del nostro alfabeto , può essere codificato con 62 caratteri Unicode.

Ad esempio, Oldè codificato in questo modo:

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

Se hai problemi a leggere alcuni caratteri Unicode, installa il font Code2000


2
"cow"e "moo"dovrebbero essere i parametri della funzione. Consentendo al chiamante di passare un array, si salvano i caratteri all'interno della definizione della funzione a spese dell'aggiunta al conteggio dei caratteri del codice chiamante. Questo puzza come un imbroglione per me. Prendendo questo approccio all'estremo, potresti definire function f(a){alert(a)}(23 caratteri) e dire che deve essere chiamato come f("Old MacDonald had a ...").
tobyink

1
Avevo passato le stringhe in due parametri separati ma dopo aver letto la sfida, non ho visto alcun motivo per non passare le stringhe in formato array, quindi ho modificato la mia risposta. Questo non è un imbroglio, è sufficiente salvare pochi caratteri quando è possibile. Lascia che @ rybo111 decida se questo si adatta o meno alla regola.
Michael M.,

1
@tobyink Ho usato il termine 'string' (non array) nelle regole, quindi suppongo tu abbia ragione. Penso che "barare" sia un po 'duro, però!
rybo111,

2
Perché questo ha così tanti voti? Sono oltre 200 e nemmeno la soluzione javascript più breve.
aditsu,

Mi dispiace e ben spiegato, così anche il mio 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;

Utilizzo: "cow""moo"F
per GolfScript sostituire '|con "|"e Acon10

Spiegazione:

La parte chiave è A,{`/\*}/:
A,{...}/esegue il blocco per ogni numero da 0 a 9 (A = 10)
`converte il numero in
/\*stringa sostituendo una stringa: se abbiamo nello stack "bar" "foo 1 baz" "1"quindi /divide la stringa risultante ["foo " " baz"], \scambia questo array con l'elemento precedente ("bar") e *unisce l'array risultante"foo bar baz"

Quindi il codice sostituisce ogni numero nella stringa principale con una stringa che era precedentemente nello stack. Abbiamo l'animale e il suono, quindi "aveva", "a", ecc. E infine ", EIEIO" e la stringa principale, "10, ...!". Per evitare di usare troppe virgolette, ho inserito tutte le stringhe (tranne i parametri) in una stringa, quindi ho diviso e ho scaricato l'array risultante ( '|/~)

La stringa principale passa attraverso le seguenti trasformazioni:

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

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

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

sostituire "2"con "here", quindi "3"con "68 8"ecc.

8 corrisponde al suono e 9 all'animale.


Puoi spiegarlo? Non so nemmeno cosa sia CJam
Cruncher

@Cruncher CJam è una lingua che ho creato, sf.net/p/cjam ; Posso spiegarlo una volta finito di giocare a golf :)
aditsu,

1
@Cruncher ha aggiunto una spiegazione ora
aditsu,

9
On e su quel cinque ha sette e nove, ze eee ro

Può E-I-essere una stringa che viene quindi ripetuta? :)
rybo111,

5

Bash + iconv, 128 caratteri Unicode

Prende il seguente corpo della funzione pure-bash / ascii e codifica inversa in caratteri unicode:

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

Definisce una funzione di shell m. Chiama come:

$ m pony neigh
Il vecchio MacDonald aveva una fattoria, EIEIO,
E in quella fattoria aveva un pony, EIEIO,
Con un vicino qui e un vicino lì,
Qui un vicino, lì un vicino, ovunque un vicino,
Il vecchio MacDonald aveva una fattoria, EIEIO!
$ 

Bash puro, 171 byte (solo ascii)

Penso che valga la pena notare che il verso originale (con "mucca" e "muggito") è di soli 203 caratteri.

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

Definisce la funzione shell m. Chiama come:

$ m baa di pecora
Il vecchio MacDonald aveva una fattoria, EIEIO,
E in quella fattoria aveva una pecora, EIEIO,
Con un baa baa qui e un baa baa lì,
Qui un baa, lì un baa, ovunque un baa baa,
Il vecchio MacDonald aveva una fattoria, EIEIO!
$

4

C ++ (403)

Va bene, questo è un po 'un colpo lungo, ma a chi non piace l'eccessiva definizione?

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

2
this.eyes.bleeding = true;
Proxy

Qualche definizione che potrebbe ulteriormente impacchettare questo più stretto?
einsteinsci,

1
Prima era possibile #define X definee quindi utilizzare #X Y Z. Purtroppo, quei giorni inebrianti della IOCCC sono ormai
lontani

Che ne dici di usare +invece di <<? O usando char*invece di string? // Solo uno di questi può essere utilizzato contemporaneamente.
Qwertiy,

2

Python, 116 caratteri Unicode

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

StackOverflow sta mangiando i miei personaggi speciali, quindi ecco il file in base64:

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

I dati vengono impacchettati usando zlib, che codifica in modo efficiente stringhe ripetute (zlib è bravo a comprimere il testo in generale). Per sfruttare la regola "Caratteri Unicode", il blocco zlib a 121 byte viene riempito e dimezzato a una stringa Unicode di 61 caratteri interpretando il bytestring come UTF-16.

Chiamare la funzione come

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

Bello, ma dove cow e moo sono stringhe nei parametri di funzione, e come tali, possono essere cambiati in maiale e oink o pecora e baa, per esempio . Sembra che il tuo output sia hardcoded in cow / moo.
Digital Trauma,

@DigitalTrauma: la mia comprensione della lettura fallisce! Fisso.
nneonneo,

va meglio :) +1
Digital Trauma

115 . Non è necessario contare la nuova riga finale.
nyuszika7h,

@ nyuszika7h No, sono 116. All'inizio hai dimenticato di contare la “BOM UTF-8” (EF BB BF), necessaria per consentire a Python 2 di accettare una sorgente non ASCII. (Questo non è Python 3, che non ha .decode('zip').)
Anders Kaseorg,

1

Python, 217

Non puoi davvero giocare a golf così tanto. Ho appena eliminato la palese ripetizione del front-end e ...

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

Fatto questo con JSCrush ... non è davvero una vera risposta, sarebbe solo interessante vedere se qualcuno può batterlo in un linguaggio tradizionale. ( EDIT : 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(_)

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


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

Ulteriore ottimizzazione è sicuramente possibile.


Puoi usare printf
aditsu

Trevin Avery ha suggerito questa modifica: Java - 243 - void String ... a) {String c = "a" + a [1], d = c + "" + a [1], e = ", EIEIO", f = "Il vecchio MacDonald aveva una fattoria" + e; System.out.print (f + ", \ nE in quella fattoria aveva un" + a [0] + e + ", \ nCon" + d + "qui e" + d + "lì , \ nQui "+ c +", lì "+ c +" ', ovunque "+ d +", \ n "+ f +"! ");} Ulteriore ottimizzazione è sicuramente possibile
Giustino,

1

Perl 5 (UTF-8) - 131 caratteri, 313 byte

Lo script seguente deve essere salvato come UTF-8 senza distinta base.

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

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

-M5.010Per abilitare le funzionalità Perl 5.10 è necessario che Perl sia stato eseguito con il flag. ( Questo è permesso .)

Mi piace molto la simmetria del conteggio dei caratteri (131) e del conteggio dei byte (313). È molto yin e yang.

Perl 5 (ASCII) - 181 caratteri, 181 byte

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

Ancora una volta, perl deve essere stato eseguito con il -M5.010flag per abilitare le funzionalità di Perl 5.10.



In realtà codegolf.stackexchange.com/a/26628/12469 è stato il mio punto di partenza. Ho testato alcune variabili extra che ne hanno ridotto ulteriormente la lunghezza, quindi ho applicato il trucco UTF16 utilizzato da molte altre implementazioni.
tobyink

1

CJam (non ASCII) - 77 caratteri

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

Uso: "cow""moo"F

La stringa è la mia altra soluzione CJam convertita dalla base 127 alla base 56000.
Potrebbe essere necessaria una locale UTF-8.

A proposito, ora puoi provarlo online su http://cjam.aditsu.net/


1

JavaScript: 152 caratteri / ES6: 149 caratteri

Ecco una funzione JS chiamata "z" che svolge il lavoro in 214 caratteri. (non eseguirlo!)

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

L'ho "impacchettato" in caratteri Unicode usando una tecnica creata da @subzey e I per 140byt.es).

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

esegui l'ultimo frammento, quindi chiama z("cow","moo")e otterrai questa stringa:

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

Maggiori informazioni qui: http://xem.github.io/golfing/en.html#compress

Versione ES6:

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

Penso che non hai copiato e incollato correttamente le cose, il tuo codice sembra avere oltre 250 caratteri - oops, forse no, ma il mio editor di testo si comporta in modo strano, indagherò.
aditsu,

Oh, la maggior parte dei tuoi personaggi provengono da alcuni piani astrali (probabilmente è per questo che vengono contati come 2 personaggi qui) ... e anche non allocati. Questo sta allungando un po 'le regole :)
aditsu,

Bene, non penso che questo sia un imbroglio: quei simboli sono caratteri unicode e non dovrebbero essere considerati come 2 caratteri. Inoltre, Twitter conta ciascuno di essi come 1 carattere. Se copi la versione ES6 in un tweet, dice che è troppo lungo di 9 caratteri. Quindi, 149 è :)
xem

1

C # - 339 byte

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


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"


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;

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

Definendo c=b.." "..b, posso salvare una dozzina di caratteri. Definendo dcome faccio, salvo 23 caratteri. Non vedo più come accorciarlo. Questo si chiama via f("<animal>","<sound>").


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 di lambda, ha messo i sostituti in una LinkedhashMap per mantenerli in un ordine definito, quindi ha usato un lambda foreach per sostituire la chiave con valore nella stringa principale. i parametri vengono aggiunti come ultimi 2 sostituti nella mappa. quell'argomento varargs è quello di radere alcuni byte nell'intestazione del metodo

Versione non golfata:

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

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

Chiamato da

f('cow', 'moo');

0

C puro, 298 byte, nessun Unicode

Nella mia funzione prendo un singolo argomento, che in realtà è un mucchio di cose char*raggruppate insieme. Ogni stringa ha una terminazione null e alla fine c'è un terminatore null aggiuntivo. Questo mi permette di controllarestrlen(a) alla fine di ogni ciclo, piuttosto che mantenere una contro variabile.

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

main.c:

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

Produzione:

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!

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

Anche per una lingua con una fodera multipla quasi nulla, e regole di rientro rigide, Cobra fa ancora abbastanza bene.


0

C: 224 byte

Usando l' identificatore di precisione printf , possiamo usare la stessa stringa sia della stringa del formato printf sia come due dei parametri.

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 spazio bianco e la stringa divisa in linee:

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

0

PHP - 272 caratteri, 272 byte

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

I parametri con @#%^<>&*(arresto anomalo dell'output.


0

Haskell (282 e ancora in qualche modo leggibile :))

wc -c oldmacdonald.hs
     282 oldmacdonald.hs

Il file:

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

È 281, di solito non conteggi la nuova riga finale, a meno che non sia una macro del preprocessore C o qualcos'altro che richiede la terminazione della nuova riga. Nella maggior parte dei casi, puoi semplicemente sottrarre 1 dal conteggio dei byte restituito wc -c, ma preferisco usare mothereff.in/byte-counter e assicurarmi che non ci sia una riga vuota alla fine, a meno che non sia necessario che il programma funzioni.
nyuszika7h,

0

ES6, 2 soluzioni da 179 186 caratteri senza alcun 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]))

E il secondo:

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

Ho aggiunto una chiamata di avviso (+7 caratteri).


Penso, per ora è la soluzione più breve da quelle non unicoded.
Qwertiy,

0

JavaScript (E6) 140 caratteri

Contatore di caratteri: https://mothereff.in/byte-counter , 140 caratteri, 425 byte in UTF-8

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

Codice ASCII originale 188 byte

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

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

Test nella console FireFox / FireBug

f('mosquito','zzz')

Produzione

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!
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.