[Question]
  [
**Closed**. This question needs [details or clarity](/help/closed-questions). It is not currently accepting answers.
 
 
---
**Want to improve this question?** Add details and clarify the problem by [editing this post](/posts/35372/edit).
Closed 2 years ago.
[Improve this question](/posts/35372/edit) 
Pick your favorite 6 letter common English word that has [no repeated letters](http://www.morewords.com/unique-letters), such as `wombat`.
Write a program in an N×N grid of characters *without comments* such that **each row and column** contains all the letters of your word in lowercase in any order. The program must output a definition of your word **in 36 characters or more**.
# Rules
* Output to stdout. There is no input.
* Your word must be on [Dictionary.com](http://dictionary.reference.com/) and only contain a-z. No proper nouns, no acronyms, no abbreviations, no contractions.
* Your program and output may only contain [printable ASCII characters](http://en.wikipedia.org/wiki/ASCII#ASCII_printable_characters) (hex codes 20 to 7E). (This isn't counting the necessary newlines in the program grid.)
* Comments are anything that the compiler or interpreter traditionally ignores. You may use code that does not contribute to the output or doesn't officially get executed.
* The output definition should be grammatical and accurate, but certainly may be funny or clever.
* Any row or column that at least contains your word`s 6 unique letters in lowercase is valid. Diagonals do not matter.
# Scoring
This is code golf but since all submissions must be in the same square format you can simply specify your score with N. The lowest N wins, and of course an N below 6 is impossible. In case of ties, the highest voted answer wins.
# Example
If your word was `wombat` your program might look like this (N = 7):
```
wombatD
ombatEw
mbatFwo
bat(wom
atWwomb
tBwomba
)wombat
```
Notice that **every row *and every column*** has the characters `w` `o` `m` `b` `a` `t`.
The output might be: (40 chararacters)
```
Cute short-legged Australian marsupials.
```
  
[Answer]
## Javascript - action - 15x15
"Definetly not the shortest one, but 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 to the jsfiddle](http://jsfiddle.net/LLZQF/1/)
  
  
Output (37 chars):
```
action means PEW PEW PEW PEW PEW PEW 
```
[Answer]
# Befunge 93, n=13
This works by redirecting the string with `"v` and `>"`. This only works when the side-length and word-length are coprime and when the side-length is greater than 11. Right now, it works for the "word" `vwombat`, and therefore for `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>:#,_@
```
Outputs `Cute short-legged Australian marsupial`
[Answer]
# C (word : "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}
```
Compiled with GCC, with the options `-Dfinder="" -Df="" -Di="" -Dn="" -Dd="" -De="" -Dr=""`.
It outputs `it's defined as a thing that can find other things` (50 characters). I believe it follows all the rules, but feel free to tell me if there is any mistake !
[Answer]
### 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"."
```
The wombat example encoded in GolfScript. Output is
```
Cute short-legged Australian marsupials.
```
as given in the question. The interesting part is that you may use most words and answers and simply insert the corresponding letters into the solution as long as you don't produce a GolfScript built-in which are very rare, `p`, `n` being to obvious ones. All other combinations lead to valid GolfScript variables which are no-ops by default.
[Answer]
## Perl - grapes - 11
**edit:** I accidently made this 12 lines...
```
$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)
```
Output:
```
A purple pear? No, a great grape; eat up!
```
---
# Update!
I eliminated a line to get it down to 11 but I had to change the sentence. Hopefully I didn't make any mistakes this time!
```
$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
```
Output:
```
A purple game? No, a great grape; eat
```
The output is 37 characters.
[Answer]
## Befunge-98 (n=12)
I chose kelvin because it had a v in it. Outputs `kelvin 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
```
[Answer]
## Python, n=15
Word is "canoes"
```
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()
```
Output: 
```
Secret weapon of the Canadian navy
```
[Answer]
## Perl - repeat - 11
```
$repeat=qq(
repeat);say
"repeat\n"x
length'pear
repeatrepea
epeatrepeat
peatrepeatr
eatrepeatre
atrepeatrep
trepeatrepe
repeat....'
```
Output:
```
repeat
repeat
repeat
repeat
...keeps going
```
Looking back maybe I should have made this a loop.
[Answer]
# [Ruby](https://www.ruby-lang.org/), `haters`, N = 10
After hours of attempts by hand, writing a generator program, and tweaking parameters, I have finally found a solution for N = 10!
```
aser=ts=?h
tah=re=?\s
sh='Haters
nurse hate
in hardest
hearts.'  
rtse=erha=
era=sh.tr'
',tah;aser
 puts erha
```
Outputs `Haters nurse hate in hardest hearts.`, exactly 36 characters. [Try it online!](https://tio.run/nexus/ruby#FYwxCsNADAT7fYW6a4w/EITbPMKNIAtKY4JWfv/lXA0Dw8wQy1t@JDrSi36cgtLHO5olXHeJlkvwvRbrQzWSUa19mGGRzspwsMKVe9fA2Nbu9dxhv7tlTzHnHw "Ruby – TIO Nexus")
I chose Ruby because its variables don't need `$` (~~Perl~~), and single-quoted strings can contain newlines (~~Python~~). The fact that the `tr` method uses two of my word's letters was an unexpected bonus. The core of the program is straightforward:
```
# Store the definition, with newlines
sh='Haters
nurse hate
in hardest
hearts.'
# Transliterate newline to space
erha=sh.tr('
',' ')
# Output
puts erha
```
Getting all the letters to line up, of course, was *not* simple. I went through several variations on the same structure and learned a couple things about Ruby in the process (`tr` doesn't need parentheses, and `?\s` is another way of getting a space). There were many dead ends and several false positives. And then... success!
[Here's a gist](https://gist.github.com/dloscutoff/60ecc8b1a2d986a2c30d0e02a2dcde73) of my hacked-together generator program, if anyone's interested.
[Answer]
## Golfscript (n=10)
My first golfscript! It prints `kelvin 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
```
[Answer]
## GolfScript, 13x13
Not the smallest...
```
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..."
```
... **but** ...
```
A squar
e has f
our equ
al side
s and r
ight an
gles...
```
(Having the line-breaks within the words is intentional, because otherwise I'd have leading or trailing whitespace which would look less square.)
[Answer]
## Python, N=11
Word is "parent". This code is not pretty, but it works.
```
eprnt=" a "
at="person"
rnep="that"
nrpt="made"
ea= " prnt"
e="parent:"
pa =(eprnt+
at+" "+rnep
+ea[0]+nrpt
+ eprnt+at)
print(e+pa)
```
Output:
`parent: a person that made a person`
Edit: Somehow I missed the fact that columns must also contain the word. In retrospect, a language that includes endline characters as part of the language was not well suited to this puzzle.
[Answer]
# [Pip](https://github.com/dloscutoff/pip), n=14 (noncompeting)
The language is newer than the question. The word is `quines`.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"  :)
```
Outputs the following (admittedly incomplete) definition:
> 
> quines print quines, which print quines, which print quines, which print quines, which print quines, which print quines, which print quines, which print quines, which print quines, which print quines, which print quines, which print quines, which print quines, which print quines, which print quines, which print quines, which print quines
> 
> 
> 
[Try it online!](https://tio.run/nexus/pip#HY/BCsJADETv@Yq4B1Er/YD10Lt4kIJ4lFqCDdbYbRpE8N9rtnPJg8wMySw3@SVjIdTmu4Zk6KyYlRgap64Ze8LsAaVqQ5l0K1oCDr29dIm3pJChfZLg3bQoIPf4snAxGlj0KY8eSStKILyLdkA3UAx7@HTcdhhqyXUEVJ8iO70nUiE4X1SWi4xpWoF5qAzDyDKFUuF4DcsHGhDjdp7/ "Pip – TIO Nexus")
The meaningful part of the code runs thus:
```
++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"
```
The rest of the code is arbitrary no-ops. The main difficulty in the "filler" sections was never to evaluate `q`, since it will prompt the user for a line of input (not a problem on TIO, but I wanted to make it correct in all environments). I used short-circuiting logic operators `|` and `&`, and ternary `?`, to prevent `q`'s evaluation.
1 Dictionary.com has an entry for [quine](http://www.dictionary.com/browse/quine), with a section on the programming meaning at the bottom. Since "quine" is a countable noun, I would argue that "quines" is a valid word.
[Answer]
# Javascript, N = 8
My word is **alerts**.
```
s= alert
alert(s+
s+alert)
aaltrsee
leraatts
ertsalar
rtsaaela
tsaesarl
```
My code outputs the definition of the javascript alert function multiple times. Javascript's definition of alert is "function alert() { [native code] }".
Only the first three lines of code actually contribute to the output. The last 5 lines are syntax errors but the original rules stated that not all the code has to be executed as long as the output is correct.
Here is a link to the fiddle: <http://jsfiddle.net/tze76pum/>
]