[Question]
  [
Your task is to print this exact text:
```
            z
            yz
           xyz
           wxyz
          vwxyz
          uvwxyz
         tuvwxyz
         stuvwxyz
        rstuvwxyz
        qrstuvwxyz
       pqrstuvwxyz
       opqrstuvwxyz
      nopqrstuvwxyz
      mnopqrstuvwxyz
     lmnopqrstuvwxyz
     klmnopqrstuvwxyz
    jklmnopqrstuvwxyz
    ijklmnopqrstuvwxyz
   hijklmnopqrstuvwxyz
   ghijklmnopqrstuvwxyz
  fghijklmnopqrstuvwxyz
  efghijklmnopqrstuvwxyz
 defghijklmnopqrstuvwxyz
 cdefghijklmnopqrstuvwxyz
bcdefghijklmnopqrstuvwxyz
abcdefghijklmnopqrstuvwxyz
```
**Case does not matter.**
Remember, this is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the code with the smallest number of bytes wins.
  
[Answer]
# Cheddar, ~~50~~ ~~45~~ ~~42~~ 37 bytes
```
25|>0=>i->print" "*(i/2|0)+(65+i)@"90
```
Straightforward, but utilizes cheddar's consise ranging syntax (both numerical and alphabetical)
[Try it online!](http://cheddar.tryitonline.net/#code=MjV8PjA9PmktPnByaW50IiAiKihpLzJ8MCkrKDY1K2kpQCI5MA&input=)
## Explanation
```
25 |> 0 =>    // Map range [0, 26) (i.e. [25, 0] reversed) over....
   i -> 
     print    // Prints in it's own line...
     " " * (i/2 |0) +     // Number of spaces is floor(n/2).
                          // `|0` for flooring is hack from JS
     (65 + i) @" 90       // Char code range is this
```
`65` is char code for `A` and `90` for `Z`
[Answer]
# [05AB1E](http://github.com/Adriandmen/05AB1E), ~~15~~ 13 bytes
```
A.svy12N;ï-ú,
```
[Try it online!](http://05ab1e.tryitonline.net/#code=QS5zdnkxMk47w68tw7DDl8OsLA&input=) (slightly different from above as `ú` isn't on TIO yet)
**Explanation**
1. Push alphabet
2. Compute the suffixes of the alphabet
3. Prepend 12-index/2 spaces
4. Print
[Answer]
# Python 2, 70 bytes
Ported from [Emigna](https://codegolf.stackexchange.com/a/97460/53667)'s answer, -2 bytes for replacing `-i-1` with `~i`
```
for i in range(26):print' '*(12-i/2)+"abcdefghijklmnopqrstuvwxyz"[~i:]
```
[Answer]
# R, 67 66 59 bytes
EDIT: Saved a couple of bytes thanks to @rturnbull
```
for(i in 25:0)cat(rep(" ",i/2),letters[i:25+1],"\n",sep="")
```
Exploiting the fact that any number passed to the `rep` function is automatically rounded down to the closest integer (e.g. `rep("*",1.99) => "*"`) which means that the actual sequence passed is `floor(13-1:26/2)`:
```
12 12 11 11 10 10  9  9  8  8  7  7  6  6  5  5  4  4  3  3  2  2  1  1  0  0
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 5 bytes
```
A.s.c
```
[Try it online!](https://tio.run/##MzBNTDJM/f/fUa9YL/n/fwA "05AB1E – Try It Online")
```
A.s.c
A     Push 'abcdefghijklmnopqrstuvwxyz'
 .s   Push suffixes starting from the shortest one
   .c Centralize focused on the left
```
[Answer]
# Pyth, 15 bytes
```
j_m+*/d2\ >GdUG
```
A program that prints the result to STDOUT.
[Try it online](https://pyth.herokuapp.com/?code=j_m%2B%2a%2Fd2%5C+%3EGdUG&debug=0)
**How it works**
```
j_m+*/d2\ >GdUG  Program
             UG  Yield [1, 2, 3, 4, ..., 26]
  m              Map over the range with variable d:
          >Gd      Yield alphabet with first d-1 letters discarded
   +               Prepend
     /d2             d//2
    *   \            spaces
 _               Reverse
j                Join on newlines
                 Implicitly print
```
[Answer]
## Python 2, 52 bytes
```
n=26;s=''
while n:n-=1;s=chr(97+n)+s;print n/2*' '+s
```
Accumulates the string `s` to print and updates the number of leading spaces `n/2`. A `while` loop terminating at `0` is a rare numerical loop than beats an `exec` loop (53 bytes):
```
n=26;s=''
exec"n-=1;s=chr(97+n)+s;print n/2*' '+s;"*n
```
Also a 53-byte alternative:
```
s=''
exec"s=chr(122-len(s))+s;print s.center(26);"*26
```
[Answer]
# JavaScript (ES6), ~~85~~ ~~75~~ ~~69~~ 68 bytes
```
for(s=a='',x=36;--x>9;)s+=` `.repeat(x/2-5)+(a=x.toString(36)+a)+`
`
```
*-1 byte thanks to [@l4m2](https://codegolf.stackexchange.com/questions/97456/draw-an-alphabet-party-hat/97462?noredirect=1#comment372785_97462)*.
[Answer]
# [Brain-Flak](http://github.com/DJMcMayhem/Brain-Flak), 244 bytes
```
((((((()()()()())){}{}){}){}()){})((((()()()){}){}()){}){(({}[()]<>)<({}<(<>({})<>)>){({}[()]<(({})[()])>)}({}({})<>[({})]<>(((()()()){}){}){}())((<>)<>{<({}[()])><>([{}]())<>}<>[{}]<>{}){({}[()]<((((()()()()){}){}){})>)}((()()()()()){})><>)}<>
```
[Try it online!](http://brain-flak.tryitonline.net/#code=KCgoKCgoKCkoKSgpKCkoKSkpe317fSl7fSl7fSgpKXt9KSgoKCgoKSgpKCkpe30pe30oKSl7fSl7KCh7fVsoKV08Pik8KHt9PCg8Pih7fSk8Pik-KXsoe31bKCldPCgoe30pWygpXSk-KX0oe30oe30pPD5bKHt9KV08PigoKCgpKCkoKSl7fSl7fSl7fSgpKSgoPD4pPD57PCh7fVsoKV0pPjw-KFt7fV0oKSk8Pn08Plt7fV08Pnt9KXsoe31bKCldPCgoKCgoKSgpKCkoKSl7fSl7fSl7fSk-KX0oKCgpKCkoKSgpKCkpe30pPjw-KX08Pg&input=&args=LUE)
---
This should be readable enough as is. If you need it, I have a full explanation:
```
push 122 (z): ((((((()()()()())){}{}){}){}()){})
push 26:      ((((()()()){}){}()){})
loop 26 times (i = 25..0): {
 (
  i--, push to b stack:({}[()]<>)
  <
   put 122 from a stack under i: ({}<(<>({})<>)>)
   i times push letter-1: {({}[()]<(({})[()])>)}
   replace top 0 with 26-i: ({}({})<>[({})]<>(((()()()){}){}){}())
   devide by two: ((<>)<>{<({}[()])><>([{}]())<>}<>[{}]<>{})
   add spaces: {({}[()]<((((()()()()){}){}){})>)}
   push 10 (\n): ((()()()()()){})
  >
  flip stack back: <>
 push i--: ) 
}
flip to results stack: <>
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~15~~ 13 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
-2 bytes thanks to @miles (formed a niladic chain I suspected existed but did not form)
```
ØaJ’H⁶ẋżṫJ$ṚY
```
**[TryItOnline!](http://jelly.tryitonline.net/#code=w5hhSuKAmUjigbbhuovFvOG5q0ok4bmaWQ&input=)**
### How?
```
ØaJ’H⁶ẋżṫJ$ṚY - Main link
Øa            - alphabet yield -> ['a', 'b', 'c', ..., 'y', 'z']
  J           -    range(length)      -> [1, 2, 3, ..., 25, 26]
   ’          -    decrement          -> [0, 1, 2, ..., 24, 25]
    H         -    halve              -> [0,.5  1, ..., 12, 12.5]
     ⁶        -    literal [' ']
      ẋ       -    repeat list        -> [[], [], [' '], ..., 12x' ', 12x' ']
          $   - last two links as a monad
         J    -     range(length)     -> [1, 2, 3, ..., 25, 26]
        ṫ     -     tail (vectorises) -> [['a'-'z'], ['b'-'z'], ..., ['y','z'], ['z']]
       ż      - zip
              -> [[[],['a'-'z']], [[],['b'-'z']], ..., [12x' ',['y','z']], [12x' ',['z]]]
           Ṛ  - reverse whole array
            Y - join with line feeds (implicit print)
```
[Answer]
# C, ~~72~~ 68 bytes
```
m(i){for(char*k=&k[i=26];i;printf("%*c%s\n",--i/2+1,0,k))*--k=64+i;}
```
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 7 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)
```
ô2òΘé8└
```
[Run and debug it](https://staxlang.xyz/#p=933295e98238c0&i=&a=1)
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal) `C`, 4 bytes
```
kz¦R
```
[Try it Online!](https://lyxal.pythonanywhere.com?flags=C&code=kz%C2%A6R&inputs=&header=&footer=)
Explanation:
```
kz    # Lowercase backwards alphabet
  ¦   # Prefixes
   R  # Reverse each
      # 'C' flag - Center top of stack, join on newlines, and print
```
[Answer]
# [Turtlèd](http://github.com/Destructible-Watermelon/Turtl-d), ~~70~~ 68 bytes
note the trailing space
```
#abcdefghijklmnopqrstuvwxyz#' -{ -{ +.r_}' l[ l-]d,(*@!' r)(!@*)_}' 
```
### Try it online!
## How it works:
```
#abcdefghijklmnopqrstuvwxyz#              Set string var to this value
                            ' -           write space on first grid cell, string pointer-=1
                               {                                    } While cell is space
                                 -                 decrement string pointer
                                  {     }    While cell is space
                                    +.       increment string pointer, write pointed char
                                      r      move right
                                       _     write non-space if pointed char is last char
                                         '[space]   write space on cell
                                           l        move left
                                            [ l-]   move left, pointer-- until cell's space
                                                 d, move down, write character var \
                                                                           (initially *)
                                                   (*     ) if cell is *
                                                     @!     set char var=!
                                                       ' r  write space over *, move right
                                                           (!    ) if cell is !
                                                             @*    set char var=*
                                                               '[space] write space over !
                                                                 _ (explanation below)
                                               write (*|!) if pointed char is last char
                                                                   '[space]    Write space
```
## Human-readable explanation(?):
It uses the string var to contain the alphabet. Each iteration, it reduces the index by one, until it wraps around, and halts, after getting to the last line. For the alternating indents, it uses the char var. Each iteration it checks the char var and flips it. if it was \* it shifts right, so the first character aligns, otherwise not, so the last character aligns.
[Answer]
## Perl, 44 bytes
This is a port of @xnor's [answer](https://codegolf.stackexchange.com/a/97466/55508).
```
$n=26;say$"x($n/2),$@=chr(97+$n).$@while$n--
```
Needs `-E` (or `-M5.010`) to run :
```
perl -E '$n=26;say$"x($n/2),$@=chr(97+$n).$@while$n--';
```
[Answer]
# PHP, 71 Bytes
```
for(;++$i<27;)echo str_pad(substr(join(range(a,z)),-$i),26," ",2)."\n";
```
[Answer]
# Java 7 ,~~128~~ 127 bytes
Saved 1 byte.Thanks to kevin.
```
String c(int n,String s,char v,String d){String c="";for(int j=0;j++<(n-1)/2;c+=" ");return n>0?c(--n,s=v+s,--v,d+c+s+"\n"):d;}
```
# ungolfed
```
  class A {
public static void main(String[] args) {
System.out.print(c(26, "", (char)122, ""));
}
static String c(int n, String s, char v, String d){
    String c = "";
    for (int j = 0; j++ < (n - 1)/2; c += " ");
    return n > 0 ? c(--n, s = v + s, --v, d + c + s + "\n" ) : d;
}
}
```
Without an passing 122 in a function
# 132 bytes
```
String c(String s,int n,String d){String c="";int v=96,j=0;for(;j++<(n-1)/2;c+=" ");return n>0?c(s=(char)(v+n--)+s,n,d+c+s+"\n"):d;}
```
# ungolfed
```
  class A{
public static void main(String[] args) {
System.out.print(c("",26,""));
}
static String c(String s, int n, String d) {
    String c = "";
    int v = 96,j=0;
    for (; j++ < (n - 1)/2; c += " ");
    return n > 0 ? c(s = ( char) (v + n--) + s, n, (d + c + s + "\n")) : d;
     }
  }
```
[Answer]
## Ruby, 64 bytes
```
(0..26).each{|x|puts' '*(12-x/2)+('a'..'z').to_a[~x..-1].join()}
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 16 bytes
```
;C¬£SpY/2 +CsYÃw ·
```
[Try it online!](https://tio.run/nexus/japt#@2/tfGjNocXBBZH6RgrazsWRh5vLFQ5t//8fAA)
### Explanation:
```
;C¬£SpY/2 +CsYÃw ·
;C                  // Alphabet shortcut
  ¬                 // Split into an array of chars
   £          Ã     // Map each item X and index Y by:
    SpY/2           //  " " repeated floor(Y/2) times
          +CsY      //  + alphabet.slice(Y)
               w    // Reverse the array of lines
                 ·  // Join with newlines
```
[Answer]
## REXX, 52 bytes
```
do i=1 to 26
  say centre(right(xrange(a,z),i),26)
  end
```
Output:
```
            Z             
            YZ            
           XYZ            
           WXYZ           
          VWXYZ           
          UVWXYZ          
         TUVWXYZ          
         STUVWXYZ         
        RSTUVWXYZ         
        QRSTUVWXYZ        
       PQRSTUVWXYZ        
       OPQRSTUVWXYZ       
      NOPQRSTUVWXYZ       
      MNOPQRSTUVWXYZ      
     LMNOPQRSTUVWXYZ      
     KLMNOPQRSTUVWXYZ     
    JKLMNOPQRSTUVWXYZ     
    IJKLMNOPQRSTUVWXYZ    
   HIJKLMNOPQRSTUVWXYZ    
   GHIJKLMNOPQRSTUVWXYZ   
  FGHIJKLMNOPQRSTUVWXYZ   
  EFGHIJKLMNOPQRSTUVWXYZ  
 DEFGHIJKLMNOPQRSTUVWXYZ  
 CDEFGHIJKLMNOPQRSTUVWXYZ 
BCDEFGHIJKLMNOPQRSTUVWXYZ 
ABCDEFGHIJKLMNOPQRSTUVWXYZ
```
[Answer]
# Vim, 25 Keystrokes
```
:h<_␍jjYZZPqqPxYPr Yq12@q
```
Where ␍ is the Enter key, also sometimes notated as `<cr>`.
## Explanation
```
:h<_␍jjYZZ                 " get a-z
          P                " initialize by pasting
           qq              " start record macro @q
             Px            " paste and remove the 1st char
               YPr␣        " yank and paste and replace 1st char with space
                   Y       " yank the whole line again
                    q      " end recording
                     12@q  " call macro 12 @q times
```
I am new to ViM though -- I started in November. Wondering if there is a way to merge the initializing `P` with the one in the macro.
What is the "correct" way to test a golfed ViM sequence? I tested with `\vi -u /dev/null`. However in a VM even `:h<_␍` doesn't work. Also not very sure why my ViM will move to the first non space character haha.
P.S. Before I moved to use OS X, I golfed in Hexagony with great tools... Now on OS X I don't do wine and thus not running the great tools for explanations and debugging. So started my journey with ViM!
[Answer]
# [C# (.NET Core)](https://www.microsoft.com/net/core/platform), 112 bytes
```
()=>string.Join("\n",new int[26].Select((_,i)=>"".PadLeft(12-i/2)+"abcdefghijklmnopqrstuvwxyz".Substring(25-i)))
```
[Try it online!](https://tio.run/##dZBBawIxEIXv@RUhFxN0s3ShlrLVy0ILxYKwhx7aUmJ21GnXpCZZrRV/@xpRixR6nJk373087RNtHbSNRzOj5cYHWOTkcpKFrWvQAa3x8gEMONR/FCM0y5zoWnlPx1uSplwMhgbWFE14yfpvsoSDA@fvPTxdfHDRgHdop0evsgTTTHQv9lzPlRM86yfYvb0R8U0QH1RATe8bo@@OsiEtg0JXKA90QNtD6vEgHy0azl4N6/2PwZgcq2oE08DPBExNdAXT2Rw/PuuFsV9L50OzWn9vfpgsm8mJLrtOIpBoc3KGWlms6JOKoYJsSRGrsjXIZ4cBYjnAfzm5EDnZkV27Bw "C# (.NET Core) – Try It Online")
```
()=>string.Join("\n", // OP doesnt want to output a sequence of string...
    new int[26].Select((_,i)=> // yield range from 0 to 25
        "".PadLeft(12-i/2)+ // add spaces to center
            "abcdefghijklmnopqrstuvwxyz".Substring(25-i)))  // remove letters
```
[Answer]
# [Tcl](http://tcl.tk/), 92 bytes
```
set a {}
time {set a [format %c [expr 123-[incr i]]]$a;puts [format %[expr 13+$i/2]s $a]} 26
```
[Try it online!](https://tio.run/##K0nO@f@/OLVEIVGhuparJDM3VaEawo1Oyy/KTSxRUE1WiE6tKChSMDQy1o3OzEsuUsiMjY1VSbQuKC0pRiiDKjLWVsnUN4otVlBJjK1VMDL7/x8A "Tcl – Try It Online")
# tcl, 94
```
set a {}
set i 123
time {set a [format %c [incr i -1]]$a;puts [format %[expr 74-$i/2]s $a]} 26
```
[demo](http://rextester.com/YLNFPD87640)
## 
In the middle of the process, I accidentaly got the italic version of the hat:
# tcl, 94
```
set a {}
set i 123
time {set a [format %c [incr i -1]]$a;puts [format %[expr $i/2-24]s $a]} 26
```
[demo](http://rextester.com/XODP23160)
---
# tcl, 101
```
set a {}
set i 123
while \$i>97 {set a [format %c [incr i -1]]$a;puts [format %[expr ($i-48)/2]s $a]}
```
[demo](http://rextester.com/SKUV47523)
In the middle of the process, I accidentaly got the italic version of the hat:
# tcl, 99
```
set a {}
set i 123
while \$i>97 {set a [format %c [incr i -1]]$a;puts [format %[expr $i/2-24]s $a]}
```
[demo](http://rextester.com/YMWTD54657)
[Answer]
# Common Lisp, SBCL, ~~83~~ 82 bytes
```
(dotimes(i 27)(format t"~26:@<~a~>
"(subseq"ABCDEFGHIJKLMNOPQRSTUVWXYZ"(- 26 i))))
```
### Explanation
```
(dotimes(i 27) ; loop from i=0 to i=26
(format t"~26:@<~a~>
"(subseq"ABCDEFGHIJKLMNOPQRSTUVWXYZ"(- 26 i))))
;print out part of alphabet starting from character number 26-i (counting from zero)
;using justification (~26:@<~a~>) to center with weight 26 characters
```
*-1 using sugestion by ASCII-only to use `<enter>` instead of `~%`*
[Answer]
# T-SQL, 107 bytes
```
DECLARE @t VARCHAR(99)=SPACE(13),@ INT=27a:SET @t=STUFF(@t,@/2,@%2,CHAR(@+95))PRINT @t
SET @-=1IF @>1GOTO a
```
Modifies the string for each line by cramming in the correct letter at the correct position using the SQL fuction `STUFF()`. Formatted:
```
DECLARE @t VARCHAR(99)=SPACE(13), @ INT=27
a:
    SET @t=STUFF(@t,@/2,@%2,CHAR(@+95))
    PRINT @t
    SET @-=1
IF @>1 GOTO a
```
`@/2` uses integer division (no remainder) to determine the position to insert the letter. `@%2` is the `MODULO` function, and flips between 0 (insert the letter) and 1 (overwrite a space).
If you prefer capitial letters, use `CHAR(@+63)` instead (doesn't change our byte count).
[Answer]
# [Perl 5](https://www.perl.org/), ~~40~~ 38 bytes
*-2 bytes thanks to @Dom Hastings*
```
say$"x(13+--$x/2),@a[$x..-1]for@a=a..z
```
[Try it online!](https://tio.run/##K0gtyjH9/784sVJFqULD0FhbV1elQt9IU8chMVqlQk9P1zA2Lb/IIdE2UU@v6v//f/kFJZn5ecX/dX1N9QwMDQA "Perl 5 – Try It Online")
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), ~~62~~ ~~51~~ 46 bytes
-11 bytes thanks to mazzy reminding me of a function  
-5 bytes thanks to mazzy
```
25..0|%{' '*($_-shr1)+-join('a'..'z')[$_..25]}
```
[Try it online!](https://tio.run/##K8gvTy0qzkjNyfn/38hUT8@gRrVaXUFdS0MlXrc4o8hQU1s3Kz8zT0M9UV1PT71KXTNaJV5Pz8g0tvb/fwA "PowerShell – Try It Online")
Uses the ~~`-replace`~~ `-shift-right 1` trick to bypass banker's rounding. Additionally, uses a character range to generate the alphabet.
[Answer]
# Haskell (Lambdabot), 73 bytes
```
unlines[([1..div(26-length x)2]>>" ")++x|x<-reverse.init$tails['a'..'z']]
```
same length:
```
do x<-reverse.init$tails['a'..'z'];([1..div(26-length x)2]>>" ")++x++"\n"
```
I use `init.tails` or `tail.inits` with a possible reverse in front in pretty much every challenge; I wish they would add it to Prelude already.
[Answer]
## Python 2, ~~66~~ 64 bytes
```
i=91;exec'i-=1;print`map(chr,range(i,91))`[2::5].center(26);'*26
```
[Answer]
# Groovy, 53 bytes
```
('z'..'a').each{println((it..'z').join().center(26))}
```
# Output:
```
            z             
            yz            
           xyz            
           wxyz           
          vwxyz           
          uvwxyz          
         tuvwxyz          
         stuvwxyz         
        rstuvwxyz         
        qrstuvwxyz        
       pqrstuvwxyz        
       opqrstuvwxyz       
      nopqrstuvwxyz       
      mnopqrstuvwxyz      
     lmnopqrstuvwxyz      
     klmnopqrstuvwxyz     
    jklmnopqrstuvwxyz     
    ijklmnopqrstuvwxyz    
   hijklmnopqrstuvwxyz    
   ghijklmnopqrstuvwxyz   
  fghijklmnopqrstuvwxyz   
  efghijklmnopqrstuvwxyz  
 defghijklmnopqrstuvwxyz  
 cdefghijklmnopqrstuvwxyz 
bcdefghijklmnopqrstuvwxyz 
abcdefghijklmnopqrstuvwxyz
```
]