Twoim zadaniem jest wydrukowanie dokładnie tego tekstu:

            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

Sprawa nie ma znaczenia.

Pamiętaj, że to jest golf golfowy , więc wygrywa kod z najmniejszą liczbą bajtów.

Cheddar, 50 45 42 37 bajtów

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

Prosto, ale wykorzystuje składnię dzielącą cheddara (zarówno numeryczną, jak i alfabetyczną)

Wypróbuj online!

Wyjaśnienie

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

65jest kodem char dla Ai 90dlaA

05AB1E , 15 13 bajtów

A.svy12N;ï-ú,

Wypróbuj online! (nieco inny od powyższego, ponieważ únie ma go jeszcze w TIO)

Wyjaśnienie

1. Naciśnij alfabet
2. Oblicz przyrostki alfabetu
3. Przygotuj 12 spacji / 2 spacje
4. Wydrukować

Python 2, 70 bajtów

Przeniesiony z Emigna odpowiedź jest, -2 bajtów do wymiany -i-1z~i

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

R, 67 66 59 bajtów

EDYCJA: Zaoszczędziłem kilka bajtów dzięki @rturnbull

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

Wykorzystanie faktu, że dowolna liczba przekazana do repfunkcji jest automatycznie zaokrąglana w dół do najbliższej liczby całkowitej (np. rep("*",1.99) => "*"), Co oznacza, że ​​faktycznie przekazana sekwencja to 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 bajtów

j_m+*/d2\ >GdUG

Program, który drukuje wynik do STDOUT.

Wypróbuj online

Jak to działa

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 bajty

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

Gromadzi ciąg sdo wydrukowania i aktualizuje liczbę spacji wiodących n/2. whilePętli na zakończenie 0jest rzadką pętli liczbowa niż przebije execpętli (53 bajtów)

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

Również 53-bajtowa alternatywa:

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

JavaScript (ES6), 85 75 69 68 bajtów

for(s=a='',x=36;--x>9;)s+=` `.repeat(x/2-5)+(a=x.toString(36)+a)+`
`

-1 bajt dzięki @ l4m2 .

Brain-Flak , 244 bajty

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

Wypróbuj online!

Powinno to być wystarczająco czytelne, jak jest. Jeśli potrzebujesz, mam pełne wyjaśnienie:

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

Galaretka , 15 13 bajtów

-2 bajty dzięki @miles (utworzyłem łańcuch niladyczny, który, jak podejrzewałem, istniał, ale nie utworzył)

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

TryItOnline!

W jaki sposób?

Ø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 bajtów

m(i){for(char*k=&k[i=26];i;printf("%*c%s\n",--i/2+1,0,k))*--k=64+i;}

05AB1E , 5 bajtów

A.s.c

Wypróbuj online!

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

Turtlèd , 70 68 bajtów

zwróć uwagę na spację końcową

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

Wypróbuj online!

Jak to działa:

#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

Wyjaśnienie czytelne dla człowieka (?):

Używa ciągu var do przechowywania alfabetu. Przy każdej iteracji zmniejsza indeks o jeden, dopóki nie zostanie zawinięty i zatrzymuje się po przejściu do ostatniej linii. W przypadku wcięć naprzemiennych używa char var. Każda iteracja sprawdza char var i odwraca go. jeśli był *, przesuwa się w prawo, więc pierwszy znak wyrównuje się, w przeciwnym razie nie, więc ostatni znak wyrównuje się.

Perl, 44 bajty

Jest to port @ XNOR za odpowiedź .

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

Potrzebuje -E(lub -M5.010) do uruchomienia:

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

PHP, 71 bajtów

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

Java 7,128 127 bajtów

Zapisano 1 bajt. Dzięki 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;}

bez golfa

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

Bez zaliczenia 122 w funkcji

132 bajty

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

bez golfa

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

Rubinowy, 64 bajty

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

Japt , 16 bajtów

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

Wypróbuj online!

Wyjaśnienie:

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

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

Wydajność:

            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 klawiszy

:h<_␍jjYZZPqqPxYPr Yq12@q

Gdzie ␍ jest klawiszem Enter, czasami także oznaczonym jako <cr> .

Wyjaśnienie

: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

Jestem nowy w ViM - zacząłem w listopadzie. Zastanawiasz się, czy istnieje sposób na połączenie inicjalizacji Pz tą w makrze.

Jaki jest „prawidłowy” sposób przetestowania sekwencji ViM w golfa? Testowałem z\vi -u /dev/null . Jednak w maszynie wirtualnej nawet :h<_␍nie działa. Nie jestem też pewien, dlaczego mój ViM przejdzie na pierwszą postać niebędącą spacją haha.

PS Zanim zacząłem używać OS X, grałem w Hexagony ze świetnymi narzędziami ... Teraz w OS XI nie robię wina, a zatem nie uruchamiam świetnych narzędzi do wyjaśniania i debugowania. Tak zaczęła się moja podróż z ViM!

C # (.NET Core) , 112 bajtów

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

Wypróbuj 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

Tcl , 92 bajty

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

Wypróbuj online!

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

próbny

W połowie procesu przypadkowo dostałem kursywą wersję czapki:

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

próbny

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

próbny

W połowie procesu przypadkowo dostałem kursywą wersję czapki:

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

próbny

Common Lisp, SBCL, 83 82 bajty

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

Wyjaśnienie

(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 za pomocą sugestii ASCII-tylko do użycia <enter>zamiast~%

T-SQL, 107 bajtów

DECLARE @t VARCHAR(99)=SPACE(13),@ INT=27a:SET @t=STUFF(@t,@/2,@%2,CHAR(@+95))PRINT @t
SET @-=1IF @>1GOTO a

Modyfikuje ciąg dla każdej linii, wciskając odpowiednią literę we właściwej pozycji za pomocą funkcji SQL STUFF(). Sformatowany:

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

@/2używa podziału na liczby całkowite (bez reszty), aby określić pozycję do wstawienia litery. @%2jestMODULO funkcją i zmienia wartość z 0 (wstaw literę) na 1 (zastąp spację).

Jeśli wolisz wielkie litery, użyj CHAR(@+63)zamiast tego (nie zmienia naszej liczby bajtów).

Perl 5 , 40 38 bajtów

-2 bajty dzięki @Dom Hastings

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

Wypróbuj online!

Stax , 7 bajtów

ô2òΘé8└

Uruchom i debuguj

Haskell (Lambdabot), 73 bajty

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

ta sama długość:

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

Używam init.tailslubtail.inits z możliwym zwrotem z przodu w prawie każdym wyzwaniu; Chciałbym, żeby już dodali go do Preludium.

Python 2, 66 64 bajtów

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

Groovy, 53 bajty

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

Wydajność:

            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 bajtów

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

Ten działa zaskakująco dobrze z pętlami QBIC 'FOR. Objaśnienie (poprzedniej wersji - obowiązuje ta sama zasada):

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

Wydajność:

            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

Rakieta 137 bajtów

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

Nie golfowany:

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

Testowanie:

(f)

Wydajność:

            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