Su tarea es imprimir este texto exacto:

            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

El caso no importa.

Recuerde, este es el código de golf , por lo que gana el código con el menor número de bytes.

Cheddar, 50 45 42 37 bytes

25|>0=>i->print" "*(i/2|0)+(65+i)@"90

Sencillo, pero utiliza la sintaxis de rango consistente de cheddar (tanto numérica como alfabética)

Pruébalo en línea!

Explicación

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

65es el código char para Ay 90paraA

05AB1E , 15 13 bytes

A.svy12N;ï-ú,

Pruébalo en línea! (un poco diferente al anterior ya que úaún no está en TIO)

Explicación

1. Alfabeto de empuje
2. Calcular los sufijos del alfabeto
3. Anteponer 12 índices / 2 espacios
4. Impresión

Python 2, 70 bytes

Portado de la respuesta de Emigna , -2 bytes para reemplazar -i-1con~i

for i in range(26):print' '*(12-i/2)+"abcdefghijklmnopqrstuvwxyz"[~i:]

R, 67 66 59 bytes

EDITAR: guardado un par de bytes gracias a @rturnbull

for(i in 25:0)cat(rep(" ",i/2),letters[i:25+1],"\n",sep="")

Explotar el hecho de que cualquier número pasado a la repfunción se redondea automáticamente al entero más cercano (por ejemplo rep("*",1.99) => "*"), lo que significa que la secuencia real pasada es 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

Pyth, 15 bytes

j_m+*/d2\ >GdUG

Un programa que imprime el resultado en STDOUT.

Pruébalo en línea

Cómo funciona

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

Python 2, 52 bytes

n=26;s=''
while n:n-=1;s=chr(97+n)+s;print n/2*' '+s

Acumula la cadena spara imprimir y actualiza el número de espacios iniciales n/2. Un whileciclo que termina en 0es un ciclo numérico raro que supera a un execciclo (53 bytes):

n=26;s=''
exec"n-=1;s=chr(97+n)+s;print n/2*' '+s;"*n

También una alternativa de 53 bytes:

s=''
exec"s=chr(122-len(s))+s;print s.center(26);"*26

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 gracias a @ l4m2 .

Brain-Flak , 244 bytes

((((((()()()()())){}{}){}){}()){})((((()()()){}){}()){}){(({}[()]<>)<({}<(<>({})<>)>){({}[()]<(({})[()])>)}({}({})<>[({})]<>(((()()()){}){}){}())((<>)<>{<({}[()])><>([{}]())<>}<>[{}]<>{}){({}[()]<((((()()()()){}){}){})>)}((()()()()()){})><>)}<>

Pruébalo en línea!

Esto debería ser lo suficientemente legible como es. Si lo necesitas, tengo una explicación completa:

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: <>

Jalea , 15 13 bytes

-2 bytes gracias a @miles (formé una cadena niládica que sospeché que existía pero no se formó)

ØaJ’H⁶ẋżṫJ$ṚY

TryItOnline!

¿Cómo?

Ø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)

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;}

05AB1E , 5 bytes

A.s.c

Pruébalo en línea!

A.s.c
A     Push 'abcdefghijklmnopqrstuvwxyz'
 .s   Push suffixes starting from the shortest one
   .c Centralize focused on the left

Turtlèd , 70 68 bytes

tenga en cuenta el espacio final

#abcdefghijklmnopqrstuvwxyz#' -{ -{ +.r_}' l[ l-]d,(*@!' r)(!@*)_}' 

Pruébalo en línea!

Cómo funciona:

#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

Explicación legible por humanos (?):

Utiliza la cadena var para contener el alfabeto. Cada iteración, reduce el índice en uno, hasta que se ajusta y se detiene, después de llegar a la última línea. Para las sangrías alternas, utiliza el char var. Cada iteración comprueba el char var y lo voltea. si era *, se desplaza hacia la derecha, por lo que el primer carácter se alinea, de lo contrario no, por lo que el último carácter se alinea.

Perl, 44 bytes

Este es un puerto de la respuesta de @ xnor .

$n=26;say$"x($n/2),$@=chr(97+$n).$@while$n--

Necesita -E(o -M5.010) ejecutar:

perl -E '$n=26;say$"x($n/2),$@=chr(97+$n).$@while$n--';

PHP, 71 bytes

for(;++$i<27;)echo str_pad(substr(join(range(a,z)),-$i),26," ",2)."\n";

Java 7128 127 bytes

Guardado 1 byte. Gracias a 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;}

sin golf

  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;
}
}

Sin pasar 122 en una función

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;}

sin golf

  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;
     }
  }

Ruby, 64 bytes

(0..26).each{|x|puts' '*(12-x/2)+('a'..'z').to_a[~x..-1].join()}

Japt , 16 bytes

;C¬£SpY/2 +CsYÃw ·

Pruébalo en línea!

Explicación:

;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

REXX, 52 bytes

do i=1 to 26
  say centre(right(xrange(a,z),i),26)
  end

Salida:

            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

Vim, 25 pulsaciones de teclas

:h<_␍jjYZZPqqPxYPr Yq12@q

Donde ␍ es la tecla Intro, también a veces anotada como <cr> .

Explicación

: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

Sin embargo, soy nuevo en ViM: comencé en noviembre. Preguntándose si hay una manera de fusionar la inicializaciónP con la de la macro.

¿Cuál es la forma "correcta" de probar una secuencia ViM de golf? Lo probé con \vi -u /dev/null. Sin embargo, en una máquina virtual, incluso :h<_␍no funciona. Tampoco estoy muy seguro de por qué mi ViM se moverá al primer personaje no espacial jaja.

PD: Antes de comenzar a usar OS X, jugué golf en Hexagony con excelentes herramientas ... Ahora, en OS X, no hago el vino y, por lo tanto, no ejecuto las excelentes herramientas para explicaciones y depuración. ¡Entonces comencé mi viaje con ViM!

C # (.NET Core) , 112 bytes

()=>string.Join("\n",new int[26].Select((_,i)=>"".PadLeft(12-i/2)+"abcdefghijklmnopqrstuvwxyz".Substring(25-i)))

Pruébalo en línea!

()=>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

Tcl , 92 bytes

set a {}
time {set a [format %c [expr 123-[incr i]]]$a;puts [format %[expr 13+$i/2]s $a]} 26

Pruébalo en línea!

set a {}
set i 123
time {set a [format %c [incr i -1]]$a;puts [format %[expr 74-$i/2]s $a]} 26

manifestación

En el medio del proceso, accidentalmente obtuve la versión en cursiva del sombrero:

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

manifestación

set a {}
set i 123
while \$i>97 {set a [format %c [incr i -1]]$a;puts [format %[expr ($i-48)/2]s $a]}

manifestación

En el medio del proceso, accidentalmente obtuve la versión en cursiva del sombrero:

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]}

manifestación

Common Lisp, SBCL, 83 82 bytes

(dotimes(i 27)(format t"~26:@<~a~>
"(subseq"ABCDEFGHIJKLMNOPQRSTUVWXYZ"(- 26 i))))

Explicación

(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 usando sugestión por ASCII-only para usar en <enter>lugar de~%

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

Modifica la cadena para cada línea introduciendo la letra correcta en la posición correcta utilizando la función SQL STUFF(). Formateado:

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

@/2usa la división de enteros (sin resto) para determinar la posición para insertar la letra. @%2es la MODULOfunción y cambia entre 0 (inserte la letra) y 1 (sobrescriba un espacio).

Si prefiere letras mayúsculas, use CHAR(@+63)en su lugar (no cambia nuestro recuento de bytes).

Perl 5 , 40 38 bytes

-2 bytes gracias a @Dom Hastings

say$"x(13+--$x/2),@a[$x..-1]for@a=a..z

Pruébalo en línea!

Stax , 7 bytes

ô2òΘé8└

Ejecutar y depurarlo

Haskell (Lambdabot), 73 bytes

unlines[([1..div(26-length x)2]>>" ")++x|x<-reverse.init$tails['a'..'z']]

mismo largo:

do x<-reverse.init$tails['a'..'z'];([1..div(26-length x)2]>>" ")++x++"\n"

Utilizo init.tailso tail.initscon un posible reverso al frente en casi todos los desafíos; Desearía que lo agreguen a Prelude ya.

Python 2, 66 64 bytes

i=91;exec'i-=1;print`map(chr,range(i,91))`[2::5].center(26);'*26

Groovy, 53 bytes

('z'..'a').each{println((it..'z').join().center(26))}

Salida:

            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

QBIC , 57 bytes

[25,0,-1|Y=Z[1,a/2|Y=Y+@ |]X=Z[a,25|X=X+$CHR$(65+|c)]?Y+X

Este funciona sorprendentemente bien con los bucles FOR de QBIC. Explicación (de la versión anterior; se aplica el mismo principio):

[26,1,-1|          Loops from 26 to 1, decrementing 'a'
                   'a' is used to determine the number of spaces per line and the last letter we want to print
Y=Z                Z is always an empty string in this program, 
                   Y will hold the spaces we need to center this line
[1,a/2|Y=Y+@ |]    Add a space to Y equal to half the value of 'a', giving us a center alignment
X=Z                X holds the characters we need on this line, reset it
[a,26|             FOR c = a to 26 --> loop over the last part of the alphabet
X=X+$CHR$(64+|c)]  Convert c+64 to ASCII and append
?Y+X               Print the spaces and the letters

<outer FOR loop is closed by QBIC>

Salida:

            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

Raqueta 137 bytes

(for((n(range 122 96 -1)))(for((i(floor(/(- n 97)2))))(display #\space))
(for((i(range n 123)))(display(integer->char i)))(displayln ""))

Sin golf:

(define (f)
  (for ((n (range 122 96 -1)))
       (for ((i (floor(/(- n 97)2))))
         (display #\space))
       (for ((i (range n 123)))
         (display (integer->char i)))
    (displayln "")))

Pruebas:

(f)

Salida:

            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