[Question]
  [
Given a strictly positive integer, `N`, produce an output satisfying the following:
* Produce an array of length N.
* Every string (i.e. "word") in the array is of length N.
* Every letter in the word is unique.
* Every first letter of the words are unique between each other.
* The remaining items of each word are equal to each other.
## Example output
For an input of e.g. `3`:
```
cba
dba
eba
```
## Specification
* Trailing whitespace is totally allowed.
* The "letters" don't have to be from the lowercase alphabet, as long as they aren't whitespace.
* The maximum `N` you need to support is 13, since there are 26 letters in the lowercase alphabet.
* The separator of your array can be anything, as long as you will never involve that character for every possible input from 1 to 13. You can also just output a literal array.
* Letters have to be 1 character long.
* Letters are case-sensitive, e.g. `a` and `A` can appear on the same line.
  
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 9 bytes
```
V>QG+N<Gt
```
[Try it online!](https://tio.run/##K6gsyfj/P8wu0F3bz8a95P9/UwA "Pyth – Try It Online")
* `V>QG` For each letter in the last `Q` (the input) elements of the lowercase alphabet:
* `+N>Gt` Append that letter to the first `Q-1` elements of the lowercase alphabet
For `Q=13`, the output looks like this:
```
nabcdefghijkl
oabcdefghijkl
pabcdefghijkl
qabcdefghijkl
rabcdefghijkl
sabcdefghijkl
tabcdefghijkl
uabcdefghijkl
vabcdefghijkl
wabcdefghijkl
xabcdefghijkl
yabcdefghijkl
zabcdefghijkl
```
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 11 bytes
```
ＮθＵＯθ⮌β↓…βθ
```
[Try it online!](https://tio.run/##S85ILErOT8z5/98zr6C0xK80Nym1SKNQ05rLPyknPy9do1BHISi1LLWoOFUjSRMoHFCUmVeiYeWSX56no@BcmZyT6pyRX6CRpKNQCJT@/9/4v25ZDgA "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
Ｎθ
```
Input `N`.
```
ＵＯθ⮌β
```
Print a square of size `N` filled with the reversed lowercase alphabet.
```
↓…βθ
```
Print the first `N` lowercase letters downwards.
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 58 bytes
```
i,j;f(n){for(i=n;i;)putchar(j++?j>n?j=!i--,10:j+63:i+77);}
```
[Try it online!](https://tio.run/##BcHBCoAgDADQe19htw0TEiGhYX1LCNYGrYg6Rd9u72W35lwrd0IFFN9yXMBJiQnP587bcoFYO8uks6SWnet8P4odwsg2RqSvst5mX1gBzduYAj4gNV/9AQ "C (gcc) – Try It Online")
[Answer]
# [Python 2](https://docs.python.org/2/), 53 bytes
```
lambda n:['%xopqrstuvwxyz'[:n+1]%i for i in range(n)]
```
[Try it online!](https://tio.run/##K6gsycjPM/qfZhvzPycxNyklUSHPKlpdtSK/oLCouKS0rLyisko92ipP2zBWNVMhLb9IIVMhM0@hKDEvPVUjTzP2f0FRZl6JQpqGoSYXjGmEYBoaILGNNf8DAA "Python 2 – Try It Online")
Chooses a hex digit (`0123456789abc`) for the first character, and the last half of the alphabet for the rest.
---
Another 53-byter that does the same thing, using `map`:
```
lambda n:map('%xopqrstuvwxyz'[:n+1].__mod__,range(n))
```
[Try it online!](https://tio.run/##K6gsycjPM/qfZhvzPycxNyklUSHPKjexQENdtSK/oLCouKS0rLyisko92ipP2zBWLz4@Nz8lPl6nKDEvPVUjT1Pzf0FRZl6JQpqGoSYXjGmEYBoaILGNNf8DAA "Python 2 – Try It Online")
---
Another 53-byter, this time using Python 3 f-string:
```
lambda n:[f'{i:x}copqrstuvwxyz'[:n]for i in range(n)]
```
[Try it online!](https://tio.run/##K6gsycjPM/6fZhvzPycxNyklUSHPKjpNvTrTqqI2Ob@gsKi4pLSsvKKySj3aKi82Lb9IIVMhM0@hKDEvPVUjTzP2f0FRZl6JRpqGoaYmF4xthMQ2NEDmGGtq/gcA "Python 3 – Try It Online")
---
If numeric characters are not allowed:
### [Python 2](https://docs.python.org/2/), ~~58~~ 57 bytes
*-1 byte thanks to @dingledooper !*
```
lambda n:['%copqrstuvwxyz'[:n+1]%(i+65)for i in range(n)]
```
[Try it online!](https://tio.run/##K6gsycjPM/qfZhvzPycxNyklUSHPKlpdNTm/oLCouKS0rLyisko92ipP2zBWVSNT28xUMy2/SCFTITNPoSgxLz1VI08z9n9BUWZeiUKahqEmF4xpimAaGmv@BwA "Python 2 – Try It Online")
Choose the first letter from the first half of the alphabet, and the last letters from the last half of the alphabet.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~10~~ 8 bytes
```
AÂSìδ£I£
```
[Try it online!](https://tio.run/##yy9OTMpM/f/f8XBT8OE157YcWux5aPH//8YA) 
Haha! With the expert help of Kevin, I beat Pyth once again!
## Explained (with Docs Descriptions)
```
A| 'abcdefghijklmnopqrstuvwxyz'
Â| Bifurcated a. Push a, reversed(a)
S| Cast a to a list of characters / digits.
ì| Merge b with a if both are lists, else prepend b to a. Push a.prepend(b)
δ| Outer Product. Get the next command and apply it double-vectorized.
£| Head. Push a[0:b]
I| Input
£| Head. Push a[0:b]
```
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 74 bytes
```
n=>(q=`opqrstuvwxyz,`.slice(13-n)).replace(/./g,t=>i.toString(++i)+q,i=10)
```
[Try it online!](https://tio.run/##DctLDsIgEADQ6zCBUhvX00t4gRKkZAxh@Iytenns8i3eyx2u@0ZFpszPMHYcGVdVceNSW5f3cX6@P7PZnsgHtdynDGBbKMldnO0cjeBKVvghjXJUWhPoagiXGwzPuXMKNnFU@5UBxh8 "JavaScript (Node.js) – Try It Online")
[Answer]
# [Java (JDK)](http://jdk.java.net/), 83 bytes
```
n->{for(int i=n,j=0;i>0;)System.out.printf("%c",j++>0?j>n?10+(j=--i-i):j+63:i+77);}
```
[Try it online!](https://tio.run/##bU5La4QwEL77KwZhITYalIUumOoeeuqhpz2WHtKoy2R1IiYulMXfbtPFUig9DPP4XmPUVWWmuaw4jHbyYMIuZo@96GbSHi2JBxnpXjkHrwoJbhHAOH/0qMF55UO7WmxgCBg7@Qnp/PYOajq75E4FeCH/bMnNQztBB9VKWX3r7MSQPGBFqalyiXUuk9On8@0g7OzFGHx8x@KdjlPDeZ0fTU3HIufMVFmGGSal4Y/7EvnhkMhllfek4AqbbSEB4amCYh8Gzn9@AfgvpCl3FKeAidxInVBat6Nnv6e/up7Yhi3Rdy3rFw "Java (JDK) – Try It Online")
I was able to make a one-liner, but it's 100 bytes long and works only on Java 13+ if that can inspire anyone to golf further...
```
n->(" %sNOPQRSTUVWXY".substring(0,n+2)).repeat(n).formatted((Object[])"ABCDEFGHIJKLM".split("",n+1))
```
[Try it online!](https://tio.run/##dY7bTgIxEIbveYpJE5JWoBG9c1kSTygKouIxhIuyBzLrbrdpZzchhmdfK6J3XjTTmfm@yZ@pWvWy@KPBwpSWIPO9rAhzmVY6Iiy1PAhaUa6cg6lCDZ8tAFOtcozAkSJf6hJjKPyOz8miXi@WoOzaiR0KMNY02p8a/ABDSCFsdG/IGbTd3ez@4XH@9Pzy@vbOpKtWbgfxw67uHAkhbWISRVwLmZa2UERJzPlslSURLZaCnZ6dX1yOrq7HN7eTqfdNjsQZ83JfiCbYRfAicNQEGPYDQBiE0D/2n07nNyRArSzYMJXKmHzDUQT7@XzjKClkWZE0PhelnLXjE5@7rVkXsAv2D/3HyDXfI9vW99s2Xw)
[Answer]
# [dc](https://www.gnu.org/software/bc/manual/dc-1.05/html_mono/dc.html), 52 bytes
```
[nAP1-d0<M]sL?dsnCo[d96+POO^OO^Bd*/-ODln-^/d0<L]dsMx
```
[Try it online!](https://tio.run/##S0n@/z86zzHAUDfFwMY3ttjHPqU4zzk/OsXSTDvA3z8OiJxStPR1/V1y8nTj9IGKfGJTin0r/v83NAYA "dc – Try It Online")
Input is on stdin, and output is on stdout.
**Output for 13:**
```
mBA9876543210
lBA9876543210
kBA9876543210
jBA9876543210
iBA9876543210
hBA9876543210
gBA9876543210
fBA9876543210
eBA9876543210
dBA9876543210
cBA9876543210
bBA9876543210
aBA9876543210
```
**How it works:**
```
[                     Start a macro.
 n                       Pop a number and print it.
 AP                      Print a newline.
 1-                      Decrement top of stack by 1.
 d0<                     If top of stack > 0,
 M                         then continue by calling macro M.
]sL                   End macro and save it in register L.
?                     Input number and push it on stack.
dsn                   Store top of stack in n.
Co                    Change output radix to base 12.
[                     Start a macro.
 d96+P                   Print the character with
                           ASCII code 96 + (top of stack).
                           (This will be a lower-case letter,
                           since 97 = 'a'.)
 OO^OO^Bd*/-ODln-^/      Push (12^12 - (12^12)/(11*11)) / (12^(13-n)).
                           In base 12, this is the leftmost n-1 digits
                           of BA9876543210 (or 0 for n=1).
 d0<L                    If this number > 0, call macro L to print it,
                           decrement the value of n at the top of stack,
                           and go back to the top of the loop M.
]dsMx                   End macro, save it in register M, and execute it.
```
[Answer]
# [Retina](https://github.com/m-ender/retina/wiki/The-Language), 38 26 bytes
```
.+
*.
Y`.`l
L$`.
$=
Y`a`Rl
```
*-12 bytes thanks to @Neil* 
[Try it online!](https://tio.run/##K0otycxLNPz/X0@bS0uPKzJBLyGHy0clQY9LxRbIS0wIyvn/39AYAA "Retina – Try It Online")
This works by generating the beginning of 'abc...' length N, then repeating it and substituting the first letter for something from 'zyx...'
```
.+         This converts the number into unary, using dots
*.         ^
Y`.`l      A cyclic transliteration: replace all dots with something from a-m
L$`.       Repeat per N with a line break at the end
$=         ^
Y`a`Rl     Finally, transliterate each 'a' with something from z-n
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt), ~~9~~ 8 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
```
;ÆîEhCgX
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=O8buRWhDZ1g&input=MTMKLVI)
```
;ÆîEhCgX     :Implicit input of integer U
 Æ           :Map each X in the range [0,U)
  î          :  Slice to length U
;  E         :    Printable ASCII
    h        :    Replace first character (space) with
;    C       :      Lowercase alphabet
      gX     :      Character at index X
```
[Answer]
# B (asm2bf dialect), 136 bytes
```
p(c){asm("rclr1,r4");asm("outr1");}g(){asm("in r1");}n;c 65;d;i;main(){i=n=g();while(i--){p(c++);d=65+n;while(d-n-65<n-1)p(d++);p(10);}}
```
Output assembly:
```
#!/usr/bin/env bfmake
    stk 16
    org 0
db_ 0
db_ 65
db_ 0
db_ 0
#PAGE_SIZE = 16
#MM_BASE = 5
#call("alloc")
    mov r4, r6
#call("_main")
    end
@alloc
#alloc("r6", "r5")
    ret
@_p
    rclr1,r4
    outr1
    ret
@_g
    in r1
    ret
@_main
    psh 3
    psh 0
#call("_g")
    mov r2, r1
    pop r1
    sto r1, r2
    pop r1
    sto r1, r2
@L1
    mov r2, 3
    rcl r1, r2
    dec r1
    sto r2, r1
    inc r1
    jz_ r1, %L2
    psh r4
#call("alloc")
    mov r2, 1
    rcl r1, r2
    inc r1
    sto r2, r1
    dec r1
    sto r6, r1
    mov r4, r6
#call("_p")
#free("r4")
    pop r4
    psh 2
    psh 65
    rcl r1, 0
    mov r2, r1
    pop r1
    add r1, r2
    mov r2, r1
    pop r1
    sto r1, r2
@L3
    rcl r1, 2
    psh r1
    rcl r1, 0
    mov r2, r1
    pop r1
    sub r1, r2
    mov r2, 65
    sub r1, r2
    psh r1
    rcl r1, 0
    mov r2, 1
    sub r1, r2
    mov r2, r1
    pop r1
    lt_ r1, r2
    jz_ r1, %L4
    psh r4
#call("alloc")
    mov r2, 2
    rcl r1, r2
    inc r1
    sto r2, r1
    dec r1
    sto r6, r1
    mov r4, r6
#call("_p")
#free("r4")
    pop r4
    jmp %L3
@L4
    psh r4
#call("alloc")
    sto r6, 10
    mov r4, r6
#call("_p")
#free("r4")
    pop r4
    jmp %L1
@L2
    ret
```
[Answer]
# [Ruby](https://www.ruby-lang.org/), 47 bytes
```
->n{a=*?`..?z;(1..n).map{|i|a[i]+a[14,n-1]*''}}
```
[Try it online!](https://tio.run/##KypNqvyfZvtf1y6vOtFWyz5BT8@@ylrDUE8vT1MvN7GguiazJjE6M1Y7MdrQRCdP1zBWS129tvY/SIWhsaZeamJyBkhNgUIaUFXtfwA "Ruby – Try It Online")
[Answer]
# [Perl 5](https://www.perl.org/) `-na`, 42 bytes
```
say$_,(A..Z)[0..$F[0]-2]for(N..Z)[0..$_-1]
```
[Try it online!](https://tio.run/##K0gtyjH9/784sVIlXkfDUU8vSjPaQE9PxS3aIFbXKDYtv0jDDy4Yr2sY@/@/ofG//IKSzPy84v@6vqZ6BoYG/3XzEgE "Perl 5 – Try It Online")
[Answer]
# [Bash](https://www.gnu.org/software/bash/) + Unix utilities, ~~62~~ 59 bytes
```
dc -e'[nAP1-d0<M]sL?dsnCo[d96+POO^OO^Bd*/-ODln-^/d0<L]dsMx'
```
[Try it online!](https://tio.run/##S0oszvj/PyVZQTdVPTrPMcBQN8XAxje22Mc@pTjPOT86xdJMO8DfPw6InFK09HX9XXLydOP0gYp8YlOKfSvU//83NOYCAA "Bash – Try It Online")
Input is on stdin, and output is on stdout.
---
---
Here's the original, longer answer:
```
echo {a..m}`echo {o..z}|tr -d \ `|fold -14|cut -b 1-$1|sed $1q
```
[Try it online (62 bytes)](https://tio.run/##S0oszvj/PzU5I1@hOlFPL7c2AcLO19Orqq0pKVLQTVGIUUioScvPSVHQNTSpSS4tUdBNUjDUVTGsKU5NUVAxLPz//78ZAA "Bash – Try It Online")
Input is passed as an argument, and output is on stdout.
[Answer]
# [Befunge-93](https://github.com/catseye/FBBI), ~~53~~ 51 bytes
```
&:v
< <>::      v:::\,+*77:
|  ^-1,+*88<_$$\1-0.:
@
```
[Try it online!](https://tio.run/##S0pNK81LT9W1tPj/X82qjMtGwcbOykoBDMqsrKxidLS1zM2tuGoUFOJ0DYEcCwubeBWVGENdAz0rLof//w2NAQ "Befunge-98 (FBBI) – Try It Online")
`0` is my two character delimiter. Outer loop outputs N'+(7\*7) in ascii, sets M to N (this requires a swap) then enters inner loop. Inner loop outputs M+(8\*8) in ascii and decrements M. On exiting inner loop outputs `0` and decrements N' (this requires a swap). `|` and `_` are the loop condition instructions respectively. `:` is often used to make copies since most operations - from arithmetic to conditional check, destroy the value they operate on by popping it out of the stack 
Befunge is stack based with a single instruction pointer that points to a character in the code. It has a travelling direction that can be changed via arrows <>^v
Befunge-98 submission by ovs, 43 bytes
```
&:>:77*+,\:>:: v
.:|;-1,+*8;^;8<_$$\1-0
  @
```
[Try it online!](https://tio.run/##S0pNK81LT9W1tPj/X83KzsrcXEtbJwbIsFIo49KzqrHWNdTR1rKwjrO2sIlXUYkx1DXgUlBw@P/fBAA "Befunge-98 (FBBI) – Try It Online")
[Answer]
# [Husk](https://github.com/barbuz/Husk), ~~14~~ ~~12~~ 11 bytes
```
←ẊM:M↑½…"az
```
[Try it online!](https://tio.run/##AR8A4P9odXNr///ihpDhuopNOk3ihpHCveKApiJhev///zEw "Husk – Try It Online") Splits the alphabet into two halves, truncates each half to the size of the input, and then recombines them in the proper way.
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~98~~ 88 bytes
-10 thanks to @ceilingcat
```
c,d,i,j;f(n){for(c=65,i=n,d=c+n;i--;puts(""))for(j=!putchar(c++);j<n-1;)putchar(d+j++);}
```
[Try it online!](https://tio.run/##NYsxDoMwDEXncgpgihVn6EAXN1svEjkKddQaVGgXxNUbQGrH997/7HrmUhgjCmZKRmFJw8uwv3QoXjF6tkriHI3veTJtC3D07Jud@R72qbVA@aruTPB30ebDrkV0rp9B1HwGiVAv1SmZDqhay5fTI/RTcbfR/24b "C (gcc) – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 9 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
Øa;€Ṛ$ḣḣ€
```
A monadic Link accepting an integer in \$[1,13]\$ which yields a list of lists of characters.
**[Try it online!](https://tio.run/##y0rNyan8///wjETrR01rHu6cpfJwx2IgAnL@H26P/P/fHAA "Jelly – Try It Online")**
### How?
```
Øa;€Ṛ$ḣḣ€ - Link: integer, N
Øa        - lower-case alphabet
     $    - last two links as a monad:
    Ṛ     -   reverse (the alphabet)
  ;€      -   concatenate that to each of (the alphabet)
      ḣ   - head to index (N)
       ḣ€ - head each to index (N)
```
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), ~~66~~ 60 bytes
```
f=(n,k=n*n)=>k?Buffer(k--%n?[97+k%n]:[10,123-k/n])+f(n,k):''
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/f8/zVYjTyfbNk8rT9PWLtveqTQtLbVII1tXVzXPPtrSXDtbNS/WKtrQQMfQyFg3Wz8vVlM7DaRD00pd/X9yfl5xfk6qXk5@ukaahrGmJheqiAmGiCFQ0X8A "JavaScript (Node.js) – Try It Online")
[Answer]
# Google Sheets, 76 bytes
```
=ArrayFormula(Char(Row(Offset(78:78,,,A1)))&Join(,Char(Row(Offset(65:65,,,A1
```
When you exit the cell, Sheets will automatically add the 5 trailing parentheses. Input is in cell `A1`. Output is wherever you put the formula and the `N-1` cells below it.
`Row(Offset(78:78,,,A1))` gives us an array from `78` to `78+N-1`.  
`Char(Row(~))` turns that array into their ASCII equivalent (capital letters).  
`Char(Row(Offset(65:65,,,A1)))` does the same thing for the range `65` to `65+N-1`.  
`Join(Char(~))` combines that second array into a single string.  
`ArrayFormula(~)` makes these functions input and output arrays instead of a single value.
[![enter image description here](https://i.stack.imgur.com/EkLoe.png)](https://i.stack.imgur.com/EkLoe.png)
[Answer]
# [MATLAB/Octave], 35 bytes
```
char([N+[1:N]',ones(N,1)*[1:N]]+64)
```
First create a column vector ranging from N+1 to 2N with N+[1:N]. Make a column vector with all values equal to one and length N, and multiply by a row vector containing values 1 to N to make a matrix of N columns with all rows equal to 1:N. Concatenate the first vector with your matrix, add 64 to all digits and use char to turn every row into a string.
[Answer]
# [Haskell](https://www.haskell.org/), 34 bytes
```
(\t->t.(:['n'..])<$>t['a'..]).take
```
[Try it online!](https://tio.run/##y0gszk7NyfmfZhvzXyOmRNeuRE/DKlo9T11PL1bTRsWuJFo9EczWK0nMTv2fm5iZp2CrkJLPpaCQm1jgG69QUFoSXFLkk6egkaZgqIlV2BS7sKGx5v9/yWk5ienF/3WTCwoA "Haskell – Try It Online")
[Answer]
# [CJam](https://sourceforge.net/p/cjam), 22 bytes
```
'[,65>_W%qi<_,(@<am*N*
```
[Try it online!](https://tio.run/##S85KzP3/Xz1ax8zULj5ctTDTJl5Hw8EmMVfLT@v/f0NjAA "CJam – Try It Online")
This works by generating the Cartesian product of the each of the last `n` characters of the alphabet and a singular array containing a string with the first `n-1` characters of the alphabet. For example, the following is outputted for 13:
```
ZABCDEFGHIJKL
YABCDEFGHIJKL
XABCDEFGHIJKL
WABCDEFGHIJKL
VABCDEFGHIJKL
UABCDEFGHIJKL
TABCDEFGHIJKL
SABCDEFGHIJKL
RABCDEFGHIJKL
QABCDEFGHIJKL
PABCDEFGHIJKL
OABCDEFGHIJKL
NABCDEFGHIJKL
```
[Answer]
# [Poetic](https://mcaweb.matc.edu/winslojr/vicom128/final/), 360 bytes
```
absently,i jot out words,A-Z
moving a pen mindlessly about a page
i am making my art,i`m doing a poem
i ensure i can never do patterns at first
i`d alter a chr i am using
i`d say i am not consistent,cause i`m using a perfect copy i forged when i end a certain verse
o yes,i reckon i am doing A-Z lazily
o yes,i admit
o yes,i am silly
i compose tripe,o yes i do
```
[Try it online!](https://mcaweb.matc.edu/winslojr/vicom128/final/tio/index.html?RZBBdsMwCET3PgUHcFc9Qa/RlbGEExoJ/AROnnP5FNl57VLMn9EAzkbiZR8ZftRBN4eHtmzj18f3UPXOcgGElQQqSy5kVnbAuXMxxgsNDFih4q2TNbTmI08Vsr6tSjUYEtsaAUNCAaE7tSAiwJ2aGKDDws184CkDlhiGNV0bHOmbRdYhGe7nSKJsUjE2j/5jws0ifXqzR@W2UOrQ2i2LtgtleFxjk94m93xqjiwQZYwGhZ0sztAo3VTOX84l4hRQ8Mll/4MwV/b/VwXjEnKsp3XVqOKNVxoPIKKyvj5fM@Zf)
This works by filling the entire memory with the negative of the inputted number (as that's the shortest way to copy it to multiple cells), then outputting the first character - which is decremented each iteration - and then the last few ASCII characters up to ASCII 255.
Warning: this takes a long time to run, even for small inputs. Such is the price to pay for a short length.
]