Escolha sua palavra inglesa comum de 6 letras favorita que não tenha letras repetidas , como wombat.

Escreva um programa em uma grade N × N de caracteres sem comentários, de modo que cada linha e coluna contenha todas as letras da sua palavra em minúsculas em qualquer ordem. O programa deve gerar uma definição de sua palavra em 36 caracteres ou mais .

Regras

• Saída para stdout. Não há entrada.
• Sua palavra deve estar no Dictionary.com e conter apenas az. Sem nomes próprios, sem acrônimos, sem abreviações, sem contrações.
• Seu programa e saída podem conter apenas caracteres ASCII imprimíveis (códigos hexadecimais 20 a 7E). (Isso não está contando as novas linhas necessárias na grade do programa.)
• Comentários são tudo o que o compilador ou intérprete tradicionalmente ignora. Você pode usar código que não contribui para a saída ou não é executado oficialmente.
• A definição de saída deve ser gramatical e precisa, mas certamente pode ser engraçada ou inteligente.
• Qualquer linha ou coluna que contenha pelo menos as seis letras únicas da sua palavra em minúsculas é válida. Diagonais não importam.

Pontuação

Este é um código de golfe, mas como todos os envios devem estar no mesmo formato quadrado, você pode simplesmente especificar sua pontuação com N. O N mais baixo vence e, é claro, um N abaixo de 6 é impossível. Em caso de empate, a resposta mais votada vence.

Exemplo

Se sua palavra era wombatseu programa, seria assim (N = 7):

wombatD
ombatEw
mbatFwo
bat(wom
atWwomb
tBwomba
)wombat

Observe que todas as linhas e colunas possuem os caracteres w o m b a t.

A saída pode ser: (40 caracteres)

Cute short-legged Australian marsupials.

Perl - uvas - 11

edit: acidentalmente fiz estas 12 linhas ...

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

Resultado:

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

Atualizar!

Eu eliminei uma linha para diminuí-la para 11, mas tive que mudar a frase. Espero não ter cometido erros desta vez!

$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

Resultado:

A purple game? No, a great grape; eat

A saída é de 37 caracteres.

Javascript - ação - 15x15

"Definitivamente não é o mais curto, mas 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 para a

saída jsfiddle (37 caracteres):

action means PEW PEW PEW PEW PEW PEW 

Antes 93, n = 13

Isso funciona redirecionando a string com "ve >". Isso funciona apenas quando o comprimento do lado e o comprimento da palavra são coprime e quando o comprimento do lado é maior que 11. No momento, ele funciona para a "palavra" vwombate, portanto, para 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>:#,_@

Saídas Cute short-legged Australian marsupial

C (palavra: "localizador", 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}

Compilado com o GCC, com as opções -Dfinder="" -Df="" -Di="" -Dn="" -Dd="" -De="" -Dr="".

Ele produz it's defined as a thing that can find other things(50 caracteres). Acredito que segue todas as regras, mas fique à vontade para me dizer se há algum erro!

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

O exemplo do wombat codificado no GolfScript. Saída é

Cute short-legged Australian marsupials.

como indicado na pergunta. A parte interessante é que você pode usar a maioria das palavras e respostas e simplesmente inserir as letras correspondentes na solução, desde que você não produza um GolfScript embutido que seja muito raro p, nsendo os óbvios. Todas as outras combinações levam a variáveis ​​GolfScript válidas que não são ops por padrão.

Befunge-98 (n = 12)

Eu escolhi o Kelvin porque tinha av. Saídaskelvin 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

A palavra é "canoas"

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

Resultado:

Secret weapon of the Canadian navy

Perl - repita - 11

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

Resultado:

repeat
repeat
repeat
repeat
...keeps going

Olhando para trás, talvez eu devesse ter feito disso um loop.

Rubi , haters, n = 10

Após horas de tentativas manuais, escrevendo um programa gerador e ajustando parâmetros, finalmente encontrei uma solução para N = 10!

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

Saídas Haters nurse hate in hardest hearts., exatamente 36 caracteres. Experimente online!

Eu escolhi o Ruby porque suas variáveis ​​não precisam $( Perl ) e as seqüências de citação única podem conter novas linhas ( Python ). O fato de o trmétodo usar duas das letras da minha palavra foi um bônus inesperado. O núcleo do programa é direto:

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

Obter todas as cartas para alinhar, é claro, não era simples. Passei por várias variações na mesma estrutura e aprendi algumas coisas sobre Ruby no processo ( trnão precisa de parênteses e ?\sé outra maneira de conseguir um espaço). Havia muitos becos sem saída e vários falsos positivos. E então ... sucesso!

Aqui está um resumo do meu programa gerador de hackers, se alguém estiver interessado.

Script de golfe (n = 10)

Meu primeiro golfscript! Imprimekelvin 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

Não é o menor ...

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

... mas ...

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

(Ter as quebras de linha entre as palavras é intencional, porque, caso contrário, eu teria espaços em branco à esquerda ou à direita que pareceriam menos quadrados.)

Python, N = 11

A palavra é "pai". Este código não é bonito, mas funciona.

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

Resultado: parent: a person that made a person

Edit: De alguma forma, eu perdi o fato de que as colunas também devem conter a palavra. Em retrospecto, um idioma que inclui caracteres finais como parte do idioma não era adequado para esse quebra-cabeça.

Pip , n = 14 (não competitivo)

A linguagem é mais nova que a pergunta. A palavra é quines. ^{1 1}

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

Produz a seguinte definição (reconhecidamente incompleta):

Quines imprimem Quines, que imprimem Quines, que imprimem Quines, que imprimem Quines, que imprimem Quines, que imprimem Quines, que imprimem Quines, que imprimem Quines, que imprimem Quines, que imprimem Quines, que imprimem Quines, que imprimem Quines, que imprimem Quines, que imprimem Quines, que imprimem Quines, que imprimem Quines, que imprimem Quines, que imprimem Quines, que imprimem Quines

Experimente online!

A parte significativa do código é executada assim:

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

O restante do código é no-ops arbitrário. A principal dificuldade nas seções "preenchedor" nunca foi avaliar q, pois solicitará ao usuário uma linha de entrada (não é um problema no TIO, mas eu queria corrigi-lo em todos os ambientes). Usei operadores lógicos de curto-circuito |e &, e ternários ?, para impedir qa avaliação.

_{¹ Dictionary.com tem uma entrada para quine , com uma seção sobre o significado da programação na parte inferior. Como "quine" é um substantivo contável, eu argumentaria que "quines" é uma palavra válida.}

Javascript, N = 8

Minha palavra é alerta .

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

Meu código gera a definição da função de alerta javascript várias vezes. A definição de alerta do Javascript é "function alert () {[código nativo]}".

Somente as três primeiras linhas de código realmente contribuem para a saída. As últimas 5 linhas são erros de sintaxe, mas as regras originais afirmam que nem todo o código deve ser executado enquanto a saída estiver correta.

Aqui está um link para o violino: http://jsfiddle.net/tze76pum/