# Slices of triangular alphabets

Given an input number n from 1 to 26 (or 0 to 25), output the alphabet reading left-to-right up to and including that corresponding letter, with a=1, b=2, c=3, .... The twist is the letters must also be repeated vertically corresponding to their position in the alphabet. Odd numbers (when 1-indexed) should be balanced across the horizontal line, while even numbers should alternate between favoring the top or bottom (you can choose which direction to go first). If you're 0-indexing, then swap odd/even in the previous sentence.

Worded another way -- if the alphabetical value of a letter ? is #, then there should be # copies of that letter in the output, all of them in the #th column. These letters should be evenly balanced above and below the horizontal line that has the a. If the letters cannot be balanced evenly, then alternate having the "extra" letter above and below that line.

Here are the first six outputs (n = 1,2,3,4,5,6, 1-indexed, choosing to alternate to the bottom first), separated by newlines, so you can see the pattern. Comments explaining the pattern start with #.

a         # On a line by itself

ab
b        # The "extra" letter is below the horizontal

c
abc       # The 'c' splits evenly
bc

d      # Because the 'b' was below, the extra 'd' must be above
cd
abcd
bcd

de
cde
abcde     # The 'e' balances
bcde
e

def
cdef
abcdef
bcdef
ef
f    # Since the 'd' was above, the extra 'f' must be below


(skip a few to n=26)

                       xyz
wxyz
tuvwxyz
stuvwxyz
pqrstuvwxyz
opqrstuvwxyz
lmnopqrstuvwxyz
klmnopqrstuvwxyz
hijklmnopqrstuvwxyz
ghijklmnopqrstuvwxyz
defghijklmnopqrstuvwxyz
cdefghijklmnopqrstuvwxyz
abcdefghijklmnopqrstuvwxyz
bcdefghijklmnopqrstuvwxyz
efghijklmnopqrstuvwxyz
fghijklmnopqrstuvwxyz
ijklmnopqrstuvwxyz
jklmnopqrstuvwxyz
mnopqrstuvwxyz
nopqrstuvwxyz
qrstuvwxyz
rstuvwxyz
uvwxyz
vwxyz
yz
z


### Rules

• You can choose to output in uppercase or lowercase, but it must be consistent.
• The output cannot have extraneous whitespace, except for an optional trailing newline.
• Either a full program or a function are acceptable.
• The input number can be taken via any suitable format.
• Standard loopholes are forbidden.
• This is so all usual golfing rules apply, and the shortest code (in bytes) wins.

# Python 2, 101 99 bytes

r=range(input())
for x in sorted(r,key=lambda x:x*-(x&2)):print bytearray([97+i,32][i<x]for i in r)


xsot saved two bytes by realizing x*-(x&2) suffices as a sorting key — the bottom half of the resulting image is unaffected due to sorted guaranteeing a stable sort.

• Can you not drop a - to output the lines in reverse order, which I believe is allowable?
– Neil
Aug 10 '16 at 0:27
• I think x*-(x&2) works.
– xsot
Aug 10 '16 at 1:39

# Pyth, 26 bytes

A perfect score for a challenge about alphabet.

j_C.e<u_G/k2.[.|1Q*hkbdQ<G


Try it online!

# Jelly, 20 18 bytes

Ḷ&2’×ḶỤØaḣ⁸¤ṫW€UGU


Port of my Python answer. Try it online.

EDIT: Dennis saved two bytes by using Ụ (grade up) instead of Þ (sort by)!

# Jelly, 25 bytes

RØaxŒgz⁶W€;ṚL‘\$¡¥/Ṛ⁸H¤¡j⁷


## JavaScript (ES6), 127 126 bytes

n=>[...Array(n).keys()].sort((a,b)=>a*~-(a&2)-b*~-(b&2)).map(i=> .repeat(i)+abcdefghijklmnopqrstuvwxyz.slice(i,n)).join\n


Uses @Lynn's sort trick. Writing out the whole alphabet was two bytes cheaper than calculating it. Edit: Saved 1 byte thanks to @ETHproductions because I forgot to note that \n actually represents the literal newline character. (I don't like putting literal newlines in my answer when the line is so long.)

• Save two bytes on the alphabet: btoa...  where ... is replaced with the result of atobabcdefghijklmnopqrstuvwxyzz . (Also, you can replace \n with a literal newline.) Sep 27 '16 at 3:34
• @ETHproductions I take it that would be using ISO encoding, rather than UTF?
– Neil
Sep 27 '16 at 18:53
• Yes it would. Are we allowed to use ISO-8859-1 rather than UTF-8 in JS? Sep 27 '16 at 18:58
• @ETHproductions Probably but I can't seem to get it to work, so I won't show it.
– Neil
Sep 27 '16 at 19:14