[Question]
  [
Given a letter of the English alphabet, your task is to build a semi-diagonal alphabet to the input. 
## How to build a Semi-Diagonal alphabet?
**Brief Description**: 
First, you take the position of the letter in the alphabet, `P` (`P` is 1-indexed here). Then, you print each letter until the input (inclusive) on a line, preceded by `P-1` and repeat that letter `P` times, interleaving with spaces.
**Examples**: 
* Given `F`, your program should output:
```
A 
 B B 
  C C C 
   D D D D 
    E E E E E 
     F F F F F F 
```
* Given `K`, your program should output:
```
A
 B B 
  C C C 
   D D D D 
    E E E E E 
     F F F F F F 
      G G G G G G G 
       H H H H H H H H 
        I I I I I I I I I 
         J J J J J J J J J J 
          K K K K K K K K K K K 
```
* Given `A`, your program should output:
```
A
```
## Rules
* You may choose either lowercase or uppercase characters, but that should be consistent.
* You may have extraneous spaces as follows:
	+ One consistent leading space (on each line).
	+ A trailing or leading newline(s).
	+ Trailing spaces.
* Input and output can be taken by any standard mean, and default loopholes apply.
* You are allowed to output a list of lines instead, as long as you also provide the [ascii-art](/questions/tagged/ascii-art "show questions tagged 'ascii-art'") version.
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the shortest code in bytes wins!
*Inspired by [this challenge](https://codegolf.stackexchange.com/questions/125117/diagonal-alphabet)*.
  
[Answer]
# [Python 3](https://docs.python.org/3/), 59 bytes
```
lambda l:[' '*i+'%c '%(i+65)*-~i for i in range(ord(l)-64)]
```
[Try it online!](https://tio.run/##Xck7DsIwDADQnVN4qWz3g4SgkajEyiUoQ2gJNQpOZXXpwtUDCwtvffO6TEn3OZz6HP3rNnqI3QUBS6mwGAALksq1XDZvgZAMBETBvD7ulGykyI078DX/lWvr4467DcwmuhD2ittnEqVAw2Qk/PVLzucP "Python 3 – Try It Online")
# [Python 3](https://docs.python.org/3/), 61 bytes
```
lambda l:[' '*i+-~i*(chr(i+65)+' ')for i in range(ord(l)-64)]
```
[Try it online!](https://tio.run/##K6gsycjPM/6fZhvzPycxNyklUSHHKlpdQV0rU1u3LlNLIzmjSCNT28xUUxsoqJmWX6SQqZCZp1CUmJeeqpFflKKRo6lrZqIZ@x9NysxUx9JQ04pLoaAoM69EQz0mT10vKz8zTyMNYqQmEMAkNf@7AQA "Python 3 – Try It Online") (link to pretty-print version)
[Answer]
# [Python 2](https://docs.python.org/2/), ~~63~~ ~~61~~ 59 bytes
*-2 bytes thanks to Rod. -2 bytes thanks to Felipe Nardi Batista.*
```
i=1
exec"print' '*i+'%c '%(i+64)*i;i+=1;"*(ord(input())-64)
```
[Try it online!](https://tio.run/##K6gsycjPM/r/P9PWkCu1IjVZqaAoM69EXUFdK1NbXTVZQV1VI1PbzERTK9M6U9vW0FpJSyO/KEUjM6@gtERDU1MXKPX/v7q3OgA "Python 2 – Try It Online")
[Answer]
# C, 89 bytes
```
i,j;f(l){for(i=64;i++<l&&printf("%*c ",i-64,i);puts(""))for(j=i-65;j--;)printf("%c ",i);}
```
[Try it online!](https://tio.run/##S9ZNT07@/z9TJ8s6TSNHszotv0gj09bMxDpTW9smR02toCgzryRNQ0lVK1lBSSdT18xEJ1PTuqC0pFhDSUlTE6Q8yxYobGqdpatrrQlXDlataV37H8hXyE3MzNPQ5KrmUgCCNA11N3VNaxjbG4ntCGLX/gcA)
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), ~~45~~ 42 bytes
```
65..$args[0]|%{" "*$i+++"$([char]$_) "*$i}
```
[Try it online!](https://tio.run/##K8gvTy0qzkjNyfn/38xUT08lsSi9ONogtka1WklBSUslU1tbW0lFIzo5I7EoViVeEyxW@///f6iQupu6JgA "PowerShell – Try It Online")
Takes input as a literal char, then loops up through the capitals to that point, each iteration prepending the appropriate number of spaces and then the char\space hybrid.
*Saved 3 bytes thanks to TessellatingHeckler.*
[Answer]
# JavaScript (ES6), 85 bytes
Works in lower case for both input and output. Outputs a leading space and a trailing space on each line.
```
f=(c,k=10,C=k.toString(36),r=s=>`${s} `.repeat(k-9))=>r``+r(C)+(C==c?'':`
`+f(c,k+1))
```
### Demo
```
f=(c,k=10,C=k.toString(36),r=s=>`${s} `.repeat(k-9))=>r``+r(C)+(C==c?'':`
`+f(c,k+1))
O.innerText = f('m')
```
```
<pre id=O>
```
[Answer]
# [APL (Dyalog)](https://www.dyalog.com/), 26 bytes
Prompts for scalar character. Prints list of lines.
```
(∊⍴∘'',' ',¨⍨⊢⍴⊃∘⎕A)¨⍳⎕A⍳⎕
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT/9fXfyobcKjvql@wQqPetcoPOpuUTCzsgIKBLvqhTr7uqgn5Vco5Ocp6KbZ5uepP@paXKyXmpeYlJMa7OgTAlb@qGtRsR5Qg3OkenFiTol6LdAcrkcd7cGpuZkumYnp@XmJOf81HnV0Perd8qhjhrq6jrqCus6hFY96VwC1ggS7moHiQBMcNUGim0EsCPUfaAy6UY7FyZmZjkUlXI/aJpJnKsjE/wpggGwwl7qbOhc2YW/swo7YhOGuw24YQtobvzTQcAA "APL (Dyalog Unicode) – Try It Online") (has ASCII art version at one additional byte)
`⎕` prompt for input
`⎕A⍳` find **ɩ**ndex in **A**lphabet
`⍳` first that many **ɩ**ntegers
`(`…`)¨` apply the following tacit function to each :
 `⊃∘⎕A` pick the argument'th letter letter from the **A**lphabet
 `⊢⍴` cyclically reshape it to the argument length
 `' ',¨⍨` append a space to each
 `⍴∘'',` prepend a string of argument length (padded with spaces)
 `∊` **ϵ**nlist (flatten)
---
The ASCII art version just has a `↑` on the very left; mix list of strings into table of characters.
[Answer]
## [Perl 5](https://www.perl.org/), 31 bytes
**30 bytes code + 1 for `-l`.**
```
print$"x$-,"$_ "x++$-for A..<>
```
[Try it online!](https://tio.run/##K0gtyjH9/7@gKDOvREWpQkVXR0klXkGpQltbRTctv0jBUU/Pxu7/f@9/@QUlmfl5xf91cwA "Perl 5 – Try It Online")
[Answer]
# Dyalog APL, 38 bytes
```
{↑{(y/' '),(2×y←⎕A⍳⍵)⍴⍵,' '}¨⎕A↑⍨⎕A⍳⍵}
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///P@1R24TqR20TqzUq9dUV1DV1NIwOT68ECj7qm@r4qHfzo96tmo96twApHaB07aEVYPG2iY96VyBU1ALNUTi0Qt3RzTtKHQA "APL (Dyalog Unicode) – Try It Online")
**How?**
`⎕A↑⍨` - take the alphabet until
`⎕A⍳⍵` - the input character
`¨` - for each char
    `⍵,' '` - take the char and a space
    `(...)⍴` - reshape to
    `2×y←⎕A⍳⍵` - twice the index of the char in the alphabet
    `(y/' ')` - and prepend index-of-char spaces
`↑` - then flatten
[Answer]
# [APL (Dyalog Classic)](https://www.dyalog.com/), 26 bytes
```
{↑{(≠\⍵<⍳3×⍵)\⍵⊃⎕A}¨⍳⎕A⍳⍵}
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT9dNzkksLs5M/v@/@lHbxGqNR50LYh71brV51LvZ@PB0IEsTxH3U1fyob6pj7aEVQHEQC0T1bq0lT5e6mzoA "APL (Dyalog Classic) – Try It Online")
### Explanation
```
                      ⍳⎕A⍳⍵  generate indexes up to position of right arg ⍵
{                   }¨       on each index apply function
   (≠\⍵<⍳3×⍵)                generate boolean mask for expansion (each line has a length 3 times its index ⍵, starting with ⍵ blanks and then alternating letter blank)
             \⍵⊃⎕A          expand character in position ⍵
 ↑                            mix result into text matrix
```
[Answer]
# [V](https://github.com/DJMcMayhem/V), ~~28, 26, 25~~, 23 bytes ([Competing](https://codegolf.meta.stackexchange.com/q/12877/31716))
```
¬A[/a
lDÓ./& ò
ò-Ûä$Û>
```
[Try it online!](https://tio.run/##ASUA2v92///CrEFbLxJhCmxEw5MuLyYgw7IKw7Itw5vDpCTDmz7///9G "V – Try It Online")
Note that although I have been planning on adding [certain features](https://github.com/DJMcMayhem/V/commit/5de2c51e581014a2693a8c6d68cdfb3378343510) for a long time, this challenge was what convinced me to finally do it. 
The output contains one leading space on each line and one trailing newline.
Hexdump:
```
00000000: ac41 5b2f 1261 0a6c 44d3 2e2f 2620 f20a  .A[/.a.lD../& ..
00000010: f22d dbe4 24db 3e                        .-..$.>
```
Explanation:
```
¬A[         " Insert 'ABCDEFGHIJKLMNOPQRSTUVWXYZ['
   /        " Search for...
    <C-r>a  "   The input
l           " Move one character to the right
 D          " And delete every character after the cursor
  Ó         " Search for...
   .        "   Any character
    /       " And replace it with...
     & ò    "   That character followed by a space and a newline
ò           " Recursively...
 -          "   Move to the beginning of the next line up
  Ûä$       "   Make *line number* copies of the current line
     Û>     "   And indent this line by *line number* spaces
```
[Answer]
## [Husk](https://github.com/barbuz/Husk), 13 bytes
```
z+ḣ∞øzRNC1…'A
```
Takes a character in single quotes as command line argument, prints result to STDOUT.
[Try it online!](https://tio.run/##yygtzv7/v0r74Y7FjzrmHd5RFeTnbPioYZm64////9Xd1AE "Husk – Try It Online")
## Explanation
I'm exploiting the way Husk prints lists of lists of strings: join inner lists with spaces and outer lists with newlines.
```
z+ḣ∞øzRNC1…'A  Implicit input, say 'C'
          …'A  Range from A: "ABC"
        C1     Cut into strings of length 1: ["A","B","C"]
     z N       Zip with positive integers
      R        using repetition: x = [["A"],["B","B"],["C","C","C"]]
   ∞ø          The empty string repeated infinitely: ["","","",...
  ḣ            Prefixes: [[],[""],["",""],["","",""],...
z+             Zip with x using concatenation: [["A"],["","B","B"],["","","C","C","C"]]
               Implicitly join each inner list with spaces, join the resulting strings with newlines and print.
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 10 bytes
```
A¹¡н«ðâƶāú
```
[Try it online!](https://tio.run/##AR4A4f8wNWFiMWX//0HCucKh0L3Cq8Oww6LGtsSBw7r//2Y "05AB1E – Try It Online")
-2 thanks to [Adnan](https://codegolf.stackexchange.com/users/34388/adnan).
Append `»` to make it print in separate lines.
[Answer]
# R,  94 88 bytes
-6 bytes thanks to Giuseppe
```
function(x,l=LETTERS)for(i in 1:match(x,l))cat(rep(' ',i-1),rep(paste(l[i],' '),i),'\n')}
```
Ungolfed:
```
f=function(x,l=letters){
  for(i in 1:which(l==x)){
    A=paste(l[i],' ')
    cat(rep(' ',i-1),rep(A,i),'\n')
  }
}
```
[Answer]
## Haskell, ~~52~~ 44 bytes
```
f k=[[" ",s:" "]>>=(['A'..s]>>)|s<-['A'..k]]
```
Returns a list of lines.
[Try it online!](https://tio.run/##y0gszk7Nyfn/P00h2zY6WklBSafYCkjG2tnZakSrO6rr6RUD2Zo1xTa6EG52bOz/3MTMPAVbhdzEAt94hYLSkuCSIp88BRWFNAV1V/X/AA "Haskell – Try It Online")
```
f k=                  -- main function is f, input parameter k
  [   |s<-['A'..k]]   -- for each s from ['A'..k]
     >>=              -- map (and collect the results in a single string) the function: 
         (['A'..s]>>) --  replace each element in ['A'..s] with
    [  ,  ]           --  over the list, containing
     " "              --   a single space to get the indent
        s:" "         --   s followed by space to get the letter sequence
```
Edit: @jferard: saved three bytes. Thanks!
[Answer]
# JavaScript (ES8), 92 bytes
```
c=>(g=n=>n>9?[...g(n-1),`${n.toString(36)} `.repeat(n-=9).padStart(n*3)]:[])(parseInt(c,36))
```
Uses lowercase letters. Lines have one leading and one trailing space. Returns an array of lines.
## Test Snippet
```
let f=
c=>(g=n=>n>9?[...g(n-1),`${n.toString(36)} `.repeat(n-=9).padStart(n*3)]:[])(parseInt(c,36))
;O.innerText=f("k").join`\n`
```
```
<pre id=O></pre>
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~15~~ ~~14~~ 13 bytes
Saved 1 byte thanks to *Adnan*
```
A¹¡н«ƶ€S»¶¡āú»
```
[Try it online!](https://tio.run/##ASQA2/8wNWFiMWX//0HCucKh0L3Cq8a24oKsU8K7wrbCocSBw7r//2Y "05AB1E – Try It Online")
or the [Ascii art version](https://tio.run/##ASYA2f8wNWFiMWX//0HCucKh0L3Cq8a24oKsU8K7wrbCocSBw7rCu///Zg)
**Explanation**
```
A                # push lowercase alphabet
 ¹¡              # split at input
   н             # get the first part
    «            # append the input
     ƶ           # repeat each a number of times corresponding to its 1-based index
      €S         # split each to a list of chars
        »        # join on spaces and newlines
         ¶¡      # split on newlines
           āú    # prepend spaces to each corresponding to its 1-based index
             »   # join on newlines
```
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 22 bytes[SBCS](https://github.com/abrudz/SBCS)
```
⍕⍪⊢∘⊂\2,.↑⍉⍴⍨⌸⎕a↑⍨⎕a⍳⍞
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///qG9qZv6jtgmGXI862tP@P@qd@qh31aOuRY86Zjzqaoox0tF71DbxUW/no94tj3pXPOrZAdSQCBZaAWb1bn7UO@8/UO//NC5vAA "APL (Dyalog Unicode) – Try It Online")
Uses `⎕io←1`. Prints a leading space, which is allowed.
[Answer]
# QBasic, ~~79~~ ~~74~~ 72 bytes
*Thanks to Taylor Scott for [byte savings](https://chat.stackexchange.com/transcript/message/45347921#45347921) (twice!)*
```
FOR i=1TO ASC(INPUT$(1))-64
?TAB(i)
FOR j=1TO i
?CHR$(64+i)" ";
NEXT j,i
```
Uses uppercase. The input is by keypress and is not echoed to the screen.
### Explanation
We loop `i` from `1` up to the limiting letter's position in the alphabet (1-based). For each `i`, we move to column `i` of the screen using `TAB`; then, `i` times, we print the `i`th letter of the alphabet followed by a space.
[Answer]
# [Japt](https://github.com/ethproductions/japt/) `-R`, ~~24~~ ~~23~~ ~~17~~ 15 bytes
Outputs an array, includes a leading newline and a leading & trailing space on each line.
```
IòUc ÏçSiXd¹iYç
```
[Test it](https://ethproductions.github.io/japt/?v=1.4.6&code=SfJVYyDP51NpWGS5aVnn&input=IksiCi1S)
* 1 byte saved with help from [Oliver](https://codegolf.stackexchange.com/users/61613/oliver) and a further 6 thanks to him pointing out a better way to generate the initial array.
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 18 bytes
```
Ｆ⁺⌕αθ¹«Ｐ×⁺§αι ⁺ι¹↘
```
[Try it online!](https://tio.run/##S85ILErOT8z5///9nmWPGnc96pl6buO5HYd2Hlr9fs@Gw9OBQoeWA0V2KgBZ53Ye2vmobcb//24A "Charcoal – Try It Online")
[Answer]
# [Braingolf](https://github.com/gunnerwolf/braingolf), 65 bytes
```
a#a-# 7-,-~vc<!?>[$_]:$_|&,(.#a-!?.>[# M]1+>[.M# M]:$_!@|v#
&@R);
```
[Try it online!](https://tio.run/##SypKzMxLz89J@/8/UTlRV1nBXFdHt64s2UbR3i5aJT7WSiW@Rk1HQw8op2ivZxetrOAba6htF63nC2IBZRUdasqUudQcgjSt////XwUA "Braingolf – Try It Online")
Lowercase.
Contains 1 trailing space on each line, and a trailing newline at the end of output.
[Answer]
# [C# (.NET Core)](https://www.microsoft.com/net/core/platform), 103 bytes
```
n=>{var i='`';var l="";for(;i<n;l+='\n'){l+="".PadLeft(i++-96);for(int s=96;s++<i;)l+=i+" ";}return l;}
```
[Try it online!](https://tio.run/##JY6xagMxEETr01csaiSh2KXB7MmNwZUDCSnSpIiQ5cuCIoFWZ0iO@/bL2ZnqwTyGCbwJpcZlZMoDvP1wi98oREieGV7FJGANN98owK3QBZ49ZW3gv7jnNObQhy9fn7jVdeQAAzhYsjtMN1@BnPpUeKfkpMRrqRqpz5isUx9ZmWkFKbcv/nKO16bJ2s1@Zx4e5Qbs9jtka3tCs5pkJUica2xjzZBwXlB0x5K5pLh9r9TimXLUg1a/yhgUs@i6x1MxL38 "C# (.NET Core) – Try It Online")
[Answer]
# JavaScript, ~~102~~ 94 bytes
*2 bytes saved thanks to [Neil](https://codegolf.stackexchange.com/users/17602/neil)*
```
f=
a=>[...Array(parseInt(a,36)-9)].map((a,b)=>''.padEnd(b).padEnd(b*3+1,(b+10).toString(36)+' '))
console.log(f('k').join`\n`)
```
[Answer]
# [Retina](https://github.com/m-ender/retina), 51 bytes
```
^.
$&$&
}T`L`_L`^.
.
$.`$* $&$.`$* ¶
+`(\w) \B
$&$1
```
[Try it online!](https://tio.run/##K0otycxL/P8/To9LRU1Fjas2JMEnId4nAcgHiuglqGgpAMXB9KFtXNoJGjHlmgoxTiDFhv//uwEA "Retina – Try It Online") Explanation:
```
^.
$&$&
```
Duplicate the (first) letter.
```
}T`L`_L`^.
```
Rotate it back 1 in the alphabet, or delete it if it's a duplicate `A`. Keep duplicating and rotating until we duplicate `A`, at which point the deletion undoes the duplication and the loop completes.
```
.
$.`$* $&$.`$* ¶
```
Replace each letter with a line with the letter padded on both sides.
```
+`(\w) \B
$&$1
```
Insert duplicate letters between all pairs of padding spaces to the right of existing letters.
[Answer]
# [Haskell](https://www.haskell.org/), 57 bytes
```
x!'@'=x
x!e=([e]:[' ':r++' ':[last r]|r<-x])!pred e
([]!)
```
[Try it online!](https://tio.run/##y0gszk7Nyfn/v0JR3UHdtoKrQjHVViM6NdYqWl1B3apIWxtEReckFpcoFMXWFNnoVsRqKhYUpaYopP7PTczMsy0oLQkuKVIpzcvJzEstVomOVVQPVP8PAA "Haskell – Try It Online")
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 15 bytes
```
Ｆ…·AＳ«Ｐ⪫Ｅ…@ιι ↘
```
[Try it online!](https://tio.run/##LYtBCsIwEADP@oqQ0y7YD@hFQYQKvdQXhBDThbAJaRIP4tu3AXuYyzBjF5NtNEHkHbOCkW2oKzU3G/YO9E2f1MipllfJxB4QUX2Ph6mGQqmbAs9IDJNJsB/XfhD@0UojXnoem4PzPX54Jr@Urn4iDxmaDGvYAA "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
 …·AＳ           Inclusive character range from A to the input
Ｆ    «          Loop over each character
         …@ι    Exclusive range from @ to the current character
        Ｅ   ι   Replace each element with the current character
       ⪫        Join with spaces
      Ｐ         Print without moving the cursor.
              ↘ Move the cursor down and right.
```
If extra padding was legal, this would work for 14 bytes:
```
Ｅ…·?θ⁺× κ⪫× κι
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvRMM3sUDDMy85p7Q4syw1KDEvPVVDyV5JR6FQU0chACiqEZKZm1qsoaQAFMsGinnlZ@ahi2VqAoH1//9u/3XL/usW5wAA "Charcoal – Try It Online") Link is to verbose version of code.
[Answer]
# Mathematica, 70 bytes
```
(T=Table)[""<>{" "~T~i,T[Alphabet[][[i]]<>" ",i]},{i,LetterNumber@#}]&
```
lowercase
outputs a list
*thanx @ngenisis for corrections*
For [ascii-art](/questions/tagged/ascii-art "show questions tagged 'ascii-art'") version place `Column@` at the beginning
[Answer]
# Excel VBA, 72 Bytes
Anonymous VBE immediate window function that takes input from cell `A1` and outputs to the VBE immediate window
```
For i=1To Asc([A1])-64:[B1]=i:?Space(i-1)[REPT(CHAR(B1+64)&" ",B1)]:Next
```
[Answer]
# [Pyth](https://pyth.readthedocs.io), 17 bytes
```
.e+*kd*+bdhk<GhxG
```
**[Try it here (pretty print version).](https://pyth.herokuapp.com/?code=j.e%2B%2akd%2a%2Bbdhk%3CGhxG&input=%22r%22&debug=0)**
---
# How does this work?
* `hxG` - Takes the index of the input in the lowercase alphabet.
* `<G` - Trims every character after the input from the alphabet.
* `.e` - Enumerated Map. Maps over the trimmed alphabet with the indexes as `k` and the letters as `b`.
* `*kd` - Append `k` spaces.
* `+bd` - `b` + a space (the current letter + space).
* `*...hk` - Repeat `k+1` times.
* `+(...)(...)` - Concatenate.
[Answer]
# [C++ (gcc)](https://gcc.gnu.org/), 164 bytes
```
#include<iostream>
#define f for(int i=0;i<o-'`';i++)
using namespace std;int main(){char c;cin>>c;for(char o='a';o<=c;o++){f cout<<' ';f cout<<o<<' ';cout<<'\n';}}
```
My first attempt after a long time lurking!
Ungolfed code below:
```
#include <iostream>
using namespace std;
#define f for (auto i = 0; i < output - '`'; i++)
int main()
{
  char input;
  cin >> input;
  for (char output = 'a'; output <= input; output++)
  {
    f cout << ' ';
    f cout << output << ' ';
    cout << endl;
  }
}
```
[Try it online!](https://tio.run/##NYxLDoMwDET3nMISi4AQUvcOnKSLRiahroqNSLJCnD0t/exm5o0erWs/E5VSs9AzT96yxrR5t4xVPfnA4iFA0K1hScDDBdlqb24GuevaKkeWGcQtPq6OPMQ04XlcHEvT7nR3GxASyzgSnpbPooNxBtUOhPq27AFIc7LWgMF/1m/9gasYPI5SHi8 "C++ (gcc) – Try It Online")
]