[Question]
  [
Inspired by [this post](https://codegolf.stackexchange.com/questions/125117/diagonal-alphabet). For those marking this question as a duplicate I urge you to actually read the question to see that mine is a modification of the one linked. The one linked does not ask for an input and is to just print the alphabet diagonally.
**The Challenge**
Given an input between 1-26 inclusively, print the alphabet diagonally, but begin printing vertically at the index of the given input.
**Examples**
Given the input:
```
16
```
Your program should output:
```
a
 b
  c
   d
    e
     f
      g
       h
        i
         j
          k
           l
            m
             n
              o
               p
               q
               r
               s
               t
               u
               v
               w
               x
               y
               z
```
Input:
```
4
```
Output:
```
a
 b
  c
   d
   e
   f
   g
   h
   i
   j
   k
   l
   m
   n
   o
   p
   q
   r
   s
   t
   v
   w
   x
   y
   z
```
Input: 
```
1
```
Output:
```
a
b
c
d
e
f
g
h
i
j
k
l
m
n
o
p
q
r
s
t
u
v
w
x
y
z
```
Input:
```
26
```
Output:
```
a
 b
  c
   d
    e
     f
      g
       h
        i
         j
          k
           l
            m
             n
              o
               p
                q
                 r
                  s
                   t
                    u
                     v
                      w
                       x
                        y
                         z
```
**Scoring**
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the shortest answer in each language wins.
Good luck!
  
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 9 bytes
```
↘✂β⁰Ｎ↓✂βη
```
[Try it online!](https://tio.run/##S85ILErOT8z5//9R24xHc5rObXrUuOH9nnWP2iaDeee2//9vAgA "Charcoal – Try It Online")
### How it works
```
↘✂β⁰Ｎ↓✂βη
 ✂β⁰Ｎ         the alphabet from position 0 to the input
↘               print diagonally, down and to the right
        ✂βη    the alphabet starting from the position of the input
       ↓        print downwards
```
This solution no longer works in the current version of Charcoal (most likely due to a bug fix), but the issue is resolved for 10 bytes with [`↘✂β⁰Ｎ↓✂βＩθ`](https://tio.run/##S85ILErOT8z5//9R24xHc5rObXrUuOH9nnWP2iaDee/3rDy34/9/EwA).
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 11 bytes
```
AvNI<‚Wysú,
```
First time trying 05AB1E, so I'm open to tips.
[Try it online!](https://tio.run/##MzBNTDJM/f/fsczP0@ZRw6zwyuLDu3T@/zc0AwA)
If a zero-indexed input from `0` to `25` is allowed, this can be 10 bytes by omitting the `<`.
[Answer]
## JavaScript (ES2017), ~~73~~ ~~72~~ ~~71~~ 66 bytes
*Saved some bytes thanks to @JustinMariner*
```
f=(n,x=26)=>x?f(n,x-1)+(x+9).toString(36).padStart(x<n?x:n)+`
`:''
```
[Answer]
# Ruby, ~~51~~ ~~46~~ 43 bytes
```
->n{(0..25).map{|x|(' '*x)[0,n-1]<<(x+97)}}
```
Returns a list of strings.
Looks like the Python guys were on to something with their subscripts. -5 bytes by taking inspiration from Mr. Xcoder's improvement of ppperry's solution.
Previous solution with `rjust` (51 bytes):
```
->n{i=0;(?a..?z).map{|c|c.rjust i+=n>c.ord-97?1:0}}
```
[Answer]
# Python 2, ~~61 58 57~~ 56 bytes
```
def f(i,j=0):exec"print(' '*~-i)[:j]+chr(97+j);j+=1;"*26
```
-3 bytes thanks to Rod
-2 more bytes thanks to Mr. Xcoder
[Answer]
# [Python 2](https://docs.python.org/2/), ~~62~~ ~~50~~ 57 bytes
```
x=input();n=m=1
exec"print'%*c'%(m,n+96);n+=1;m+=x>m;"*26
```
[Try it online!](https://tio.run/##K6gsycjPM/r/v8I2M6@gtERD0zrPNtfWkCu1IjVZqaAoM69EXVUrWV1VI1cnT9vSDCitbWtonattW2GXa62kZWT2/78pAA "Python 2 – Try It Online")
Steals heavily from [this answer](https://codegolf.stackexchange.com/a/125144/65836) by Dennis.
[Answer]
# R, ~~99~~ 89 bytes
*@MickeyT saved 10 bytes*
### function
```
function(x)for(i in 1:26)cat(paste(c(rep(" ",min(x,i)),letters[i]),collapse=""),sep="\n")
```
### demo
```
f <- function(x)for(i in 1:26)cat(paste(c(rep(" ",min(x,i)),letters[i]),collapse=""),sep="\n")
f(1)
f(10)
f(15)
f(26)
```
[Answer]
# [Retina](https://github.com/m-ender/retina), ~~72~~ 68 bytes
```
^
z
{2=`
$`
}T`l`_l`^.
\D
$.`$* $&¶
\d+
$* 
s`( *)( +)(?=.*¶\1 $)
$1
```
[Try it online!](https://tio.run/##K0otycxL/P8/jquKq9rINoFLJYGrNiQhJyE@JyFOjyvGhUtFL0FFS0FF7dA2rpgUbS4gm6s4QUNBS1NDQVtTw95WT@vQthhDBRVNLhXD//9NAA "Retina – Try It Online") Output includes trailing whitespace. Save 1 byte by deleting the space before the `$` if zero-indexing is allowed. Edit: Saved 4 bytes by using @MartinEnder's alphabet generator. Explanation:
```
^
z
{2=`
$`
}T`l`_l`^.
```
Insert the alphabet.
```
\D
$.`$* $&¶
```
Diagonalise it.
```
\d+
$* 
```
Convert the input to unary as spaces.
```
s`( *)( +)(?=.*¶\1 $)
$1
```
Trim overlong lines so that no line is longer than the blank line at the end.
[Answer]
# Mathematica, 103 bytes
```
(T=Table;a=Alphabet[];c=Column)[c/@{T[""<>{T[" ",i],a[[i]]},{i,#}],T[""<>{T[" ",#],a[[i]]},{i,#,26}]}]&
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 11 bytes
```
26Ḷ«’⁶ẋżØaY
```
[Try it online!](https://tio.run/##ASEA3v9qZWxsef//MjbhuLbCq@KAmeKBtuG6i8W8w5hhWf///zQ "Jelly – Try It Online")
[Answer]
# Common Lisp, 84 bytes
```
(lambda(x)(dotimes(i 26)(format t"~v,,,@a~%"(if(< i x)(1+ i)x)(code-char(+ i 97)))))
```
[Try it online!](https://tio.run/##FYoxCoAwEAS/cgjCHsZCC0Ww8CtnonhgiGgQK78e4zQDw9hdryMhYRc/O8HDcCGqXy4otR1jDaeXSLF4b2PMJG9ZQFeMpJTfpiLlbBvcUttNTuRAQ88/qek4fQ)
[Answer]
# [Python](https://docs.python.org/), 52 bytes
Quite surprised nobody noticed the obvious approach was also as short as the others.
```
lambda k:[(i*" ")[:k-1]+chr(i+97)for i in range(26)]
```
[Try it online!](https://tio.run/##FcdLDkAwEADQq0xsTAkJEqKJk2BRnzI@06aphdNXvN2zr98NV0F3Q7jUPS0KTtkjJRFEopdnVozpvDuktG2ENg4IiMEp3lYsazEG64g9xgPH@WGIUeN/Yvt4FL9Q1B8 "Python 3 – Try It Online")
# [Python](https://docs.python.org/), 53 bytes
```
lambda k:[min(k-1,i)*" "+chr(i+97)for i in range(26)]
```
[Try it online!](https://tio.run/##K6gsycjPM/6fZhvzPycxNyklUSHbKjo3M08jW9dQJ1NTS0lBSTs5o0gjU9vSXDMtv0ghUyEzT6EoMS89VcPITDP2f0FRZl6JhnpMnrpeVj5QX5oGiJ@ZV1BaoqEJAv8NzQA "Python 3 – Try It Online")
[Answer]
## Haskell, ~~58~~ 54 bytes
```
f n=do m<-[1..26];([2..min n m]>>" ")++['`'..]!!m:"\n"
```
[Try it online!](https://tio.run/##y0gszk7Nyfn/P00hzzYlXyHXRjfaUE/PyCzWWiPaSE8vNzNPIU8hN9bOTklBSVNbO1o9QV1PL1ZRMddKKSZP6X9uIlCBrUJBaUlwSZGCikKagsl/AA "Haskell – Try It Online")
How it works
```
f n=                  -- input number is n
  do m<-[1..26]       -- for each m from [1..26], construct a string and concatenate
                      -- them into a single string. The string is:
   [2..min n m]>>" "  -- min(n,m)-1 spaces,
      ++              -- followed by
   ['`'..]!!m         -- the m-th char after `
      :               -- followed by
   "\n"               -- a newline 
```
Edit: @Lynn saved 4 bytes. Thanks! 
[Answer]
# [Java (OpenJDK 8)](http://openjdk.java.net/), 69 bytes
```
n->{for(int a=0;a++<26;)System.out.printf("%"+(a<n?a:n)+"c%n",a+96);}
```
[Try it online!](https://tio.run/##LY3BisIwFEX3fsWjICTEhsEBQVt14cqFK5fDLJ4xKantS0lehEH67Z2OzOrCuZdzW3xiGQZL7f0xDfnWeQOmw5Tggp7gtQD4p4mR53gGf4d@7sSVo6fm6xswNkm@pwDt7NOZfaddJsM@kD4FSrm3sT4T28bGAzjYT1QeXi5E4YkB9x8VKlWvN5W8/iS2vQ6Z9TD72YliWSiBNR1xR1IVZknFCtV2I6txqt6nTqMxdmDxKf/AuBinXw "Java (OpenJDK 8) – Try It Online")
[Answer]
# [Gaia](https://github.com/splcurran/Gaia), 12 bytes
```
…26⊃§×¦₵a+†ṣ
```
[Try it online!](https://tio.run/##ASMA3P9nYWlh///igKYyNuKKg8Knw5fCpuKCtWEr4oCg4bmj//8xNQ "Gaia – Try It Online")
### Explanation
```
…             Range 0..input-1
 26⊃          Repeat the last number enough times to make it have length 26
    §×¦       Turn each number into a string of that many spaces
       ₵a+†   Add the corresponding letter to each
           ṣ  Join with newlines
```
[Answer]
# [APL (Dyalog)](https://www.dyalog.com/), ~~12~~ 11 bytes
-1 as OP has now clarified that returning a list of strings is fine.
Prompts for input.
```
⎕A↑¨⍨-⎕⌊⍳26
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///qKPdJTMxPT8vMSck//@jtomP@qY6AqlDKx71rtAFch71dD3q3WxkBlL5XwEMEBq4DM24MMRMMIUMMYWMzAA "APL (Dyalog Unicode) – Try It Online")
`⍳26` first 26 strictly positive **ɩ**ntegers
`⎕⌊` minimum of input and those
`-` negate those
`⎕A↑⍨¨` for each letter of the **A**lphabet, take that many characters (from the rear, as all numbers are negative), padding with spaces as necessary
---
`↑` convert list of strings into matrix (only in TIO link to enable readable output)
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), ~~21~~ ~~17~~ 15 bytes
```
VlG+*d?>QNNQ@GN
```
Explanation:
```
VlG        For each character in the alphabet (G)
+          Concatenate...
 *d        Space (d) times...
   ?>QNNQ  Ternary; if Q (input) is less than N, return N, else Q
 @GN       The Nth character of the alphabet (G)
```
[Try it online!](https://tio.run/##K6gsyfj/PyzHXVsrxd4u0M8v0MHd7/9/QwMA "Pyth – Try It Online")
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 72 bytes
```
n=>[..."abcdefghijklmnopqrstuvwxyz"].map((e,i)=>" ".repeat(i<n?i:n-1)+e)
```
Returns a list of strings.
[Try it online!](https://tio.run/##ZctNDoIwEEDhfU8x6aqN0IRoXKjFg6AJFQYswrQC4k@4ezVxZdx@L68xkxmK3voxJldiqHQgnWZKKW5ORYlVfbbNpe3I@Ws/jLfp/ni@@FF1xguBkZU65cBVjx7NKOyO9nZDcSIXKMOWsSyJYBnBKoJk/Z0QdMoAoHA0uBZV62qBEub5R6qPqcZZyg@U/1XJ5Da8AQ "JavaScript (Node.js) – Try It Online")
[Answer]
# Mathematica, 67 bytes
```
SparseArray[x=#;{#,#~Min~x}->Alphabet[][[#]]&~Array~26,{26,#}," "]&
```
Returns a `SparseArray` of strings. To visualize, append `Grid@` in front.
[Try it on Wolfram Sandbox](https://sandbox.open.wolframcloud.com)
### Usage
```
Grid@SparseArray[x=#;{#,#~Min~x}->Alphabet[][[#]]&~Array~26,{26,#}," "]&[5]
```
> 
> 
> ```
> a
>  b
>   c
>    d
>     e
>     f
>     g
>      
>     ⋮
>    
>     z 
> 
> ```
> 
> 
[Answer]
# [Python 2](https://docs.python.org/2/), 52 bytes
```
lambda n:['%*c'%(min(i+1,n),i+97)for i in range(26)]
```
[Try it online!](https://tio.run/##TYxBDoIwFAX3PcXbkLZQTdoYiCScBFhUpfqN/BLoxtNX4sI425nM8k6PyC6HbsgvP19uHtz2siivslAzsaLKGtaGqnOjQ1xBIMbq@T4pV@sxp2lLGzr0tjY4GVgDV49C/Npv0ArsLCtxghxYHp9xfwdFWv@bg0QJ1@QP "Python 2 – Try It Online")
I'm assuming a list of strings is fine...
Shortest I could get with recursion:
```
f=lambda n,i=0:i<26and['%*c'%(min(i+1,n),i+97)]+f(n,i+1)or[]
```
[Answer]
# [SOGL V0.12](https://github.com/dzaima/SOGL), 12 [bytes](https://github.com/dzaima/SOGL/blob/master/chartable.md)
```
z{ē.-.Hχ@*Ot
```
[Try it Here!](https://dzaima.github.io/SOGLOnline/?code=eiU3QiV1MDExMy4tLkgldTAzQzdAKk90,inputs=NA__)
[Answer]
# [Python 3](https://docs.python.org/3/), 52 bytes
```
lambda n:[('%*c'%(i,i+96))[-n:]for i in range(1,27)]
```
[Try it online!](https://tio.run/##TYxBDsIgEADvvGIvDVCpCdVgJOlLKAfUotvo0lAuvh4bD8a5zmSWd3kkOtQ4jPUZXpdbALJO8Ka98kagwt3ZSOk6sj6mDAhIkAPdJ6FVf5K@lmktKwzgtFFwVKAV9MYz9qu/gWWwsWSkIvhIfD8nJBEFSin/Vcehhe1bPw "Python 3 – Try It Online")
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 50 bytes
```
i;f(n){for(;i<26;printf("%*c\n",i++<n?i:n,i+97));}
```
[Try it online!](https://tio.run/##S9ZNT07@/z/TOk0jT7M6Lb9IwzrTxsjMuqAoM68kTUNJVSs5Jk9JJ1Nb2ybPPtMqD8iyNNfUtK79n5uYmaehqVDNpQAEaRqGZprWXLX/AQ)
[Answer]
# [Proton](https://github.com/alexander-liao/proton), 40 bytes
Assuming that a list of Strings is fine.
```
k=>[(i*" ")[to~-k]+chr(i+97)for i:0..26]
```
[Try it online!](https://tio.run/##KyjKL8nP@59m@z/b1i5aI1NLSUFJM7okv043O1Y7OaNII1Pb0lwzLb9IIdPKQE/PyCz2f0FRZl6JhnpMnrpeVn5mnkaahqGZpqbmfwA "Proton – Try It Online")
# [Proton](https://github.com/alexander-liao/proton), 49 bytes
As ASCII-art instead:
```
k=>'\n'.join((i*" ")[to~-k]+chr(i+97)for i:0..26)
```
[Try it online!](https://tio.run/##KyjKL8nP@59m@z/b1k49Jk9dLys/M09DI1NLSUFJM7okv043O1Y7OaNII1Pb0lwzLb9IIdPKQE/PyEzzf0FRZl6JRpqGoZmm5n8A "Proton – Try It Online")
[Answer]
# [C# (.NET Core)](https://www.microsoft.com/net/core/platform), 66 + 18 bytes
```
n=>new int[26].Select((x,i)=>$"{(char)(i+97)}".PadLeft(i<n?i+1:n))
```
Byte count also includes
```
using System.Linq;
```
[Try it online!](https://tio.run/##bZBBSwMxEIXv@RVj8ZDQutAiFd3uipRWxApiBQ/iIaZTO5BmNcnalmV/@5ptpXSt75LJzJd5jyh3pjKLVe7IfMB04zwuo2GmNSpPmXHRLRq0pGLWICZkvmLGjFyi@5QKf/usYBCktHQObrb1rlPLeelJwXdGM3iQZLjYjwq2L2uNc6MGZHwH7kYmX6KV7xoHztuQIE1hDkllktTgCgL02uu/RVOsA3O@7pBI0tNWwdVCWsGpfXkhylb0KGcTnHtOA3NN7e6VEaI6dIybAXZW9RE3@qsFaQTOwwASGIb/yTRGTxi2k0EuBJwkYHKtReNZ0bjVmvOQPKSyDutlQkTP2YSc5yIaZ3Yk1YKvIUn3Fi@WPG491kLER@uOsT9Qyf7D6@D3uDmEd2DJyqrbZ@esy3r9Hw "C# (.NET Core) – Try It Online")
This returns a collection of strings, one for each line. If it's not allowed, the answer will swell by 17 bytes for `string.Concat()` and `\n` inside string
Explanation:
```
n =>
    new int[26]                      // Create a new collection of size 26
    .Select((x, i) =>                // Replace its members with:
        $"{(char)(i + 97)}"          // String of an alphabet character corresponding to the index
        .PadLeft(i < n ? i + 1 : n)  // Add spaces to the left
    )
```
[Answer]
# [Pyth](https://pyth.readthedocs.io), 12 bytes
```
j.e+<*kdtQbG
```
**[Try it here!](https://pyth.herokuapp.com/?code=j.e%2B%3C%2akdtQbG&input=16&debug=0)**
If lists of Strings are allowed, this can be shortened to [**11 bytes**](https://pyth.herokuapp.com/?code=.e%2B%3C%2akdtQbG&input=16&debug=0):
```
.e+<*kdtQbG
```
# [Pyth](https://pyth.readthedocs.io), 12 bytes
```
VG+<*dxGNtQN
```
**[Try it here!](https://pyth.herokuapp.com/?code=VG%2B%3C%2adxGNtQN&input=16&debug=0)**
# [Pyth](https://pyth.readthedocs.io), 14 bytes
```
jm+<*d;tQ@Gd26
```
**[Try it here.](https://pyth.herokuapp.com/?code=jm%2B%3C%2ad%3BtQ%40Gd26&input=16&debug=0)**
If lists of Strings are allowed, this can be shortened to [**13 bytes**](https://pyth.herokuapp.com/?code=m%2B%3C%2ad%3BtQ%40Gd26&input=16&debug=0):
```
m+<*d;tQ@Gd26
```
---
# How do these work?
Unlike most of the other answers, this maps / loops over the lowercase alphabet in all 3 solutions.
### Explanation #1
```
j.e+<*kdtQbG - Full program.
 .e        G - Enumerated map over "abcdefghijklmnopqrstuvwxyz", with indexes k and values b.
     *kd     - Repeat a space a number of times equal to the letter's index.
    <   tQ   - Crop the spaces after the input.
   +      b  - Concatenate with the letter.
j            - (Optional): Join by newlines.
```
### Explanation #2
```
VG+<*dxGNtQN  - Full program.
VG            - For N in "abcdefghijklmnopqrstuvwxyz".
      xGN     - Index of the letter in the alphabet.
    *d        - Repeat the space a number of times equal to the index above.
   <     tQ   - But crop anything higher than the input.
  +        N  - Append the letter (at the end)
```
### Explanation #3
```
jm+<*d;tQ@Gd26 - Full program.
 m          26 - Map over [0...26) with a variable d.
    *d;        - Space repeated d times.
   <   tQ      - Crop anything whose length is higher than the input.
  +      @Gd   - Concatenate with the letter at that index in the alphabet.
j              - (Optional): Join by newlines.
```
[Answer]
# Haskell, 60 bytes
```
f n=unlines$scanl(\p c->take(n-1)(p>>" ")++[c])"a"['b'..'z']
```
This is a function that returns the output as a String.
[Try it online.](https://tio.run/##y0gszk7Nyfn/P00hz7Y0LyczL7VYpTg5MS9HI6ZAIVnXriQxO1UjT9dQU6PAzk5JQUlTWzs6OVZTKVEpWj1JXU9PvUo99n9uYmaegq1CSj6XgkJBaUlwSZFPnoKKQpqCyX8A)
[Answer]
# [Japt](https://github.com/ETHproductions/japt), ~~16~~ 13 bytes
*Saved 3 bytes thanks to @Oliver*
```
;C£RiXiYmUÉ î
```
[Test it online!](http://ethproductions.github.io/japt/?v=1.4.5&code=O0OjUmlYaVltVckg7g==&input=Mw==)
[Answer]
# q/kdb+, ~~33~~ 31 bytes
**Solution:**
```
-1{(&[x-1;til 26]#'" "),'.Q.a};
```
**Example:**
```
q)-1{(&[x-1;til 26]#'" "),'.Q.a}16;
a
 b
  c
   d
    e
     f
      g
       h
        i
         j
          k
           l
            m
             n
              o
               p
               q
               r
               s
               t
               u
               v
               w
               x
               y
               z
```
**Explanation:**
Create a list of spaces (26) up to the length of the minimum of the input and the range of `0..25`), join with each letter of the alphabet, print to stdout.
```
-1{(&[x-1;til 26]#'" "),'.Q.a}; / solution
-1                            ; / print result to stdout and swallow return
  {                          }  / lambda function
                         .Q.a   / "abcd..xyz"
                       ,'       / concatenate (,) each
   (                  )         / do all this together
    &[   ;      ]               / minimum of each 
      x-1                       / implicit input (e.g. 10) minus 1 (e.g. 9)
          til 26                / 0 1 2 ... 23 24 25
                   '#" "        / take " " each number of times (0 1 2 )
```
**Notes:**
* -2 bytes by rejigging the brackets
[Answer]
# Java 1.8 (without Lambda), 98 Bytes
```
void m(int i){int c=0,o=97;String s="";for(;c++<26;s+=c<i?" ":"")System.out.println(s+(char)o++);}
```
The logic is straightforward. Provides no input data validation, very bad!
* Update: Function only! Thank you to @Olivier Grégoire
]