Scegli la tua parola inglese comune preferita di 6 lettere che non ha lettere ripetute , come ad esempio wombat.

Scrivi un programma in una griglia N × N di caratteri senza commenti in modo tale che ogni riga e colonna contenga tutte le lettere della tua parola in minuscolo in qualsiasi ordine. Il programma deve generare una definizione della tua parola in 36 caratteri o più .

Regole

• Uscita su stdout. Non ci sono input.
• La tua parola deve essere su Dictionary.com e contenere solo az. Nessun nome proprio, nessun acronimo, nessuna abbreviazione, nessuna contrazione.
• Il programma e l'output possono contenere solo caratteri ASCII stampabili (codici esadecimali da 20 a 7E). (Questo non sta contando le nuove righe necessarie nella griglia del programma.)
• I commenti sono tutto ciò che il compilatore o l'interprete tradizionalmente ignora. È possibile utilizzare codice che non contribuisce all'output o che non viene eseguito ufficialmente.
• La definizione dell'output dovrebbe essere grammaticale e accurata, ma sicuramente può essere divertente o intelligente.
• Qualsiasi riga o colonna che contiene almeno le 6 lettere univoche della tua parola in minuscolo è valida. Le diagonali non contano.

punteggio

Questo è il golf del codice ma poiché tutti gli invii devono essere nello stesso formato quadrato, puoi semplicemente specificare il tuo punteggio con N. La N più bassa vince e ovviamente una N inferiore a 6 è impossibile. In caso di parità vince la risposta più votata.

Esempio

Se la tua parola fosse il wombattuo programma potrebbe apparire così (N = 7):

wombatD
ombatEw
mbatFwo
bat(wom
atWwomb
tBwomba
)wombat

Si noti che ogni riga e ogni colonna ha i caratteri w o m b a t.

L'output potrebbe essere: (40 caratteri)

Cute short-legged Australian marsupials.

Perl - uva - 11

modifica: ho fatto accidentalmente queste 12 righe ...

$epagsr=$";
$,=$epagsr;
/gaerp/;say
grep!/a*s/,
qw(A searpg
purple sgar
rpssg pear?
No, a sgerp
s great pse
as grape; s
eat prgpsga
up! sgarse)

Produzione:

A purple pear? No, a great grape; eat up!

Aggiornare!

Ho eliminato una riga per ridurla a 11 ma ho dovuto cambiare la frase. Spero di non aver fatto errori questa volta!

$gpasre=$";
$,=$gpasre;
/paerg/;say
grep!/a*s/,
qw(A sgrpea
purple sarg
ressp game?
No, a rgspe
s great gsp
as grape; s
eat),$spegr

Produzione:

A purple game? No, a great grape; eat

L'output è di 37 caratteri.

Javascript - azione - 15x15

"Sicuramente non il più corto, ma PEW PEW PEW." - James Bond

ction="action "
ction+="means "
actionac="PEW "
ctionact="PEW "
tionacti="PEW "
ionactio="PEW "
onaction="PEW "
nactiona="PEW "
ction+=actionac
ction+=ctionact
ction+=tionacti
ction+=ionactio
ction+=onaction
ction+=nactiona
alert(""+ction)

Link all'output di jsfiddle

(37 caratteri):

action means PEW PEW PEW PEW PEW PEW 

Befunge 93, n = 13

Funziona reindirizzando la stringa con "ve >". Funziona solo quando la lunghezza del lato e la lunghezza della parola sono coprimi e quando la lunghezza del lato è maggiore di 11. In questo momento, funziona per la "parola" vwombat, e quindi per wombat.

"laip"vwombat
wombat>"usr"v
"am "vwombat>
ombat>"nai"vw
lar"vwombat>"
mbat>"tsu"vwo
 d"vwombat>"A
bat>"egg"vwom
-"vwombat>"el
at>"tro"vwomb
"vwombat>"hs 
t>"tuC"vwomba
vwombat>:#,_@

Uscite Cute short-legged Australian marsupial

C (parola: "finder", N = 16)

main() finder{ f
printf(finder  i
"it's defined "r
"as a t"finder d
"hing t"finder e
"hat ca"finder r
"n find other t"
"hings" finder);
finder finder f\
inder finder fi\
nder finder fin\
der finder find\
er finder finde\
r finder finder
 finder finder n
return 0;finder}

Compilato con GCC, con le opzioni -Dfinder="" -Df="" -Di="" -Dn="" -Dd="" -De="" -Dr="".

Emette it's defined as a thing that can find other things(50 caratteri). Credo che segua tutte le regole, ma sentiti libero di dirmi se ci sono errori!

GolfScript, N = 12

wombat"Cute"
ombat" sho"w
mbat"rt-l"wo
bat"egge"wom
at"d Au"womb
twomb"stra"a
wom"lian "bt
ttwomb"mar"t
"sup"wbwomat
"ia"womabbtt
"ls"bawomtbt
aaawomobt"."

L'esempio di Wombat codificato in GolfScript. L'output è

Cute short-legged Australian marsupials.

come indicato nella domanda. La parte interessante è che puoi usare la maggior parte delle parole e delle risposte e semplicemente inserire le lettere corrispondenti nella soluzione purché non produca un GolfScript incorporato che è molto raro p, nessendo ovvio. Tutte le altre combinazioni generano variabili GolfScript valide, che per impostazione predefinita non sono operative.

Befunge-98 (n = 12)

Ho scelto Kelvin perché conteneva av. Uscitekelvin is like celsius but it's lowe

"ewol "vnlik 
"t's"ke<ilnv 
kelniv"t i"< 
elnik>"ub "v 
nkv"elsius"< 
ln>"c eki"vl 
v0ke"is l"<n 
>" nivlek" v 
ielnv,k4'k#< 
 vivlevlnek< 
 ilkkninevei 
  elnkn vnle

Python, n = 15

La parola è "canoe"

def canoe(s='S\
ecret weap',sno
='ce',a='ons o\
f the Can',oces
=1,oesn=1,c='a\
dian navy',cose
="""aoenscanaen
canceessanoeeca
anoasanooscanoe
noescccccaeescc
oescneocaeoesca
escaoescan"""):
 canoes=s + a+c
 print (canoes)
s=1;    canoe()

Produzione:

Secret weapon of the Canadian navy

Perl - ripeti - 11

$repeat=qq(
repeat);say
"repeat\n"x
length'pear
repeatrepea
epeatrepeat
peatrepeatr
eatrepeatre
atrepeatrep
trepeatrepe
repeat....'

Produzione:

repeat
repeat
repeat
repeat
...keeps going

Guardando indietro forse avrei dovuto farlo diventare un ciclo.

Rubino , hatersN = 10

Dopo ore di tentativi a mano, scrivendo un programma generatore e modificando i parametri, ho finalmente trovato una soluzione per N = 10!

aser=ts=?h
tah=re=?\s
sh='Haters
nurse hate
in hardest
hearts.'  
rtse=erha=
era=sh.tr'
',tah;aser
 puts erha

Output Haters nurse hate in hardest hearts., esattamente 36 caratteri. Provalo online!

Ho scelto Ruby perché le sue variabili non richiedono $( Perl ) e le stringhe a virgoletta singola possono contenere newline ( Python ). Il fatto che il trmetodo utilizzi due lettere della mia parola è stato un bonus inaspettato. Il nucleo del programma è semplice:

# Store the definition, with newlines
sh='Haters
nurse hate
in hardest
hearts.'
# Transliterate newline to space
erha=sh.tr('
',' ')
# Output
puts erha

Far allineare tutte le lettere, ovviamente, non è stato semplice. Ho attraversato diverse varianti sulla stessa struttura e ho imparato un paio di cose su Ruby nel processo ( trnon ha bisogno di parentesi ed ?\sè un altro modo per ottenere uno spazio). C'erano molti vicoli ciechi e diversi falsi positivi. E poi ... successo!

Ecco una sintesi del mio programma di generatore combinato, se qualcuno è interessato.

Golfscript (n = 10)

Il mio primo golfscript! Stampakelvin is like celsius but it's lowe

"kelvin is
like ce"vn
evn"lsiu"k
k"s "elvni
in"bu"kelv
"t "knviel
vl"it'"nke
nevkil"s l
o"ivnkel"w
e"lnevik

GolfScript, 13x13

Non il più piccolo ...

squae"A squar
"uarsquaresqu
uareq"e has f
"resuaresquar
resqa"our equ
"squresquares
quars"al side
"arequaresqua
areuq"s and r
"esqaresquare
esqur"ight an
"quaesquaresq
quar"gles..."

... ma ...

A squar
e has f
our equ
al side
s and r
ight an
gles...

(Avere le interruzioni di riga all'interno delle parole è intenzionale, perché altrimenti avrei spazi bianchi iniziali o finali che apparirebbero meno quadrati.)

Python, N = 11

La parola è "genitore". Questo codice non è carino, ma funziona.

eprnt=" a "
at="person"
rnep="that"
nrpt="made"
ea= " prnt"
e="parent:"
pa =(eprnt+
at+" "+rnep
+ea[0]+nrpt
+ eprnt+at)
print(e+pa)

Produzione: parent: a person that made a person

Modifica: in qualche modo ho perso il fatto che anche le colonne devono contenere la parola. In retrospettiva, un linguaggio che include caratteri di fine riga come parte del linguaggio non era adatto a questo enigma.

seme , n = 14 (non competitivo)

La lingua è più recente della domanda. La parola è quines. ¹

n_n|quine say&
qu ines     qi
as  harle quin
se?(equins)ns.
 plums|quinces
|quicken bus++
iness|q++++i u
u:++ingl es?eq
ni*:u; s|qe:",
which "Rns|que
eRL:i|quotesne
PUsn    quiet!
u|qe."print".s
JW"quines"  :)

Emette la seguente definizione (dichiaratamente incompleta):

quines stampa quines, che stampa quines, che stampa quines, che stampa quines, che stampa quines, che stampa quines, che stampa quines, che stampa quines, che stampa quines, che stampa quines, che stampa quines, che stampa quines, che stampano le quines, che stampano le quines, che stampano le quines, che stampano le quines

Provalo online!

La parte significativa del codice viene quindi eseguita:

++i          Increment i (initially set to 0)
++++i        Increment i twice
u:++i        Increment i again and assign to u (i & u are now 4)
i*:u         Multiply i by u in-place (i is now 16)
e:",         Assign the string ",\nwhich " to e...
which "Rns   after replacing the newline with a space
eRL:i        Make a list of 16 copies of e and assign back to e
ePUs         Push a space to the front of list e
e."print".s  Concatenate "print" and a space to each element of e...
JW"quines"   and join on "quines", wrapping the result in "quines"

Il resto del codice è no-op arbitrario. La principale difficoltà nelle sezioni "filler" non è mai stata quella di valutare q, poiché richiederà all'utente una riga di input (non un problema su TIO, ma volevo renderlo corretto in tutti gli ambienti). Ho usato operatori logici di corto circuito |e &, e ternario ?, per impedire qla valutazione.

_{¹ Dictionary.com ha una voce per quine , con una sezione sul significato della programmazione in fondo. Poiché "quine" è un sostantivo numerabile, direi che "quines" è una parola valida.}

Javascript, N = 8

La mia parola è avvisi .

s= alert
alert(s+
s+alert)
aaltrsee
leraatts
ertsalar
rtsaaela
tsaesarl

Il mio codice restituisce più volte la definizione della funzione di avviso javascript. La definizione di Javascript di avviso è "avviso di funzione () {[codice nativo]}".

Solo le prime tre righe di codice contribuiscono effettivamente all'output. Le ultime 5 righe sono errori di sintassi ma le regole originali affermavano che non tutto il codice deve essere eseguito fintanto che l'output è corretto.

Ecco un link al violino: http://jsfiddle.net/tze76pum/