Ihre Aufgabe ist es, genau diesen Text auszudrucken:

            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

Fall spielt keine Rolle.

Denken Sie daran, dies ist Code-Golf , also gewinnt der Code mit der geringsten Anzahl von Bytes.

Cheddar, 50 45 42 37 Bytes

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

Einfach, aber mit Cheddars konsistenter Range-Syntax (sowohl numerisch als auch alphabetisch)

Probieren Sie es online!

Erläuterung

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

65ist Zeichencode für Aund 90fürA

05AB1E , 15 13 Bytes

A.svy12N;ï-ú,

Probieren Sie es online! (etwas anders als oben, da únoch nicht auf TIO)

Erläuterung

1. Drücken Sie das Alphabet
2. Berechnen Sie die Suffixe des Alphabets
3. Stellen Sie 12-Index / 2 Leerzeichen voran
4. Drucken

Python 2, 70 Bytes

Portiert aus Emignas Antwort, -2 Bytes zum Ersetzen -i-1durch~i

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

R, 67 66 59 Bytes

BEARBEITEN: Sparte dank @rturnbull ein paar Bytes

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

Wenn Sie die Tatsache ausnutzen, dass eine an die repFunktion übergebene Zahl automatisch auf die nächste Ganzzahl (z. B. rep("*",1.99) => "*") abgerundet wird, bedeutet dies, dass die tatsächlich übergebene Sequenz wie folgt lautet 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

Ein Programm, das das Ergebnis an STDOUT ausgibt.

Probieren Sie es online aus

Wie es funktioniert

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

Sammelt die szu druckende Zeichenfolge und aktualisiert die Anzahl der führenden Leerzeichen n/2. EINwhile Schleife, die an endet, 0ist eine seltene numerische Schleife, die eine execSchleife übertrifft (53 Byte):

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

Auch eine 53-Byte-Alternative:

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

JavaScript (ES6), 85 75 69 68 Byte

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

-1 Byte dank @ l4m2 .

Brain-Flak , 244 Bytes

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

Probieren Sie es online!

Dies sollte so wie es ist ausreichend lesbar sein. Wenn Sie es brauchen, habe ich eine vollständige Erklärung:

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

Jelly , 15 bis 13 Bytes

-2 Bytes dank @miles (bildete eine Niladenkette, von der ich vermutete, dass sie existiert, aber nicht gebildet wurde)

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

TryItOnline!

Wie?

Ø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

Probieren Sie es 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 Bytes

beachte das nachgestellte Leerzeichen

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

Probieren Sie es online!

Wie es funktioniert:

#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

Vom Menschen lesbare Erklärung (?):

Es verwendet die Zeichenfolge var, um das Alphabet zu enthalten. Bei jeder Iteration wird der Index um eins reduziert, bis er umbrochen und angehalten wird, nachdem die letzte Zeile erreicht wurde. Für die alternierenden Einrückungen wird die Zeichenvariable verwendet. Bei jeder Iteration wird das Zeichen var überprüft und umgedreht. wenn es * war, verschiebt es sich nach rechts, so dass das erste Zeichen ausgerichtet wird, andernfalls nicht, so dass das letzte Zeichen ausgerichtet wird.

Perl, 44 Bytes

Dies ist eine Portierung von @ xnors Antwort .

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

Muss -E(oder -M5.010) ausgeführt werden:

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 7,128 127 Bytes

1 Byte gespeichert. Danke an 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;
}
}

Ohne ein Übergeben von 122 in einer Funktion

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

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 ·

Probieren Sie es online!

Erläuterung:

;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

Ausgabe:

            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 Tastenanschläge

:h<_␍jjYZZPqqPxYPr Yq12@q

Wobei ␍ die Eingabetaste ist, manchmal auch notiert als <cr> .

Erläuterung

: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

Ich bin neu bei ViM - ich habe im November angefangen. Sie fragen sich, ob es eine Möglichkeit gibt, die Initialisierung zusammenzuführenP mit der im Makro zusammenzuführen.

Was ist der "richtige" Weg, um eine Golf ViM-Sequenz zu testen? Ich habe mit getestet\vi -u /dev/null . Allerdings in einer VM eben:h<_␍ funktioniert nicht. Ich bin mir auch nicht ganz sicher, warum mein ViM zum ersten Nicht-Leerzeichen wechselt, haha.

PS Bevor ich zu OS X gewechselt bin, habe ich in Hexagony mit großartigen Werkzeugen Golf gespielt ... Jetzt unter OS X mache ich keinen Wein und führe daher nicht die großartigen Werkzeuge zum Erklären und Debuggen aus. Also begann meine Reise mit ViM!

C # (.NET Core) , 112 Byte

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

Probieren Sie es 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 Bytes

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

Probieren Sie es online!

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

Demo

In der Mitte des Prozesses habe ich versehentlich die kursive Version des Hutes bekommen:

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

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

In der Mitte des Prozesses habe ich versehentlich die kursive Version des Hutes bekommen:

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

Common Lisp, SBCL, 83 82 Bytes

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

Erläuterung

(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 Verwendung von sugestion by ASCII-only <enter>anstelle von~%

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

Ändert die Zeichenfolge für jede Zeile, indem der richtige Buchstabe an der richtigen Position mit der SQL-Funktion eingegeben wird STUFF(). Formatiert:

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 Verwendet die Ganzzahldivision (kein Rest), um die Position zum Einfügen des Buchstabens zu bestimmen. @%2ist die MODULOFunktion und wechselt zwischen 0 (Buchstaben einfügen) und 1 (Leerzeichen überschreiben).

Wenn Sie capitial Buchstaben bevorzugen, verwenden Sie CHAR(@+63)stattdessen (nicht unsere Byteanzahl ändern).

Perl 5 , 40 38 Bytes

-2 Bytes dank @Dom Hastings

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

Probieren Sie es online!

Stax , 7 Bytes

ô2òΘé8└

Führen Sie es aus und debuggen Sie es

Haskell (Lambdabot), 73 Bytes

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

die gleiche Länge:

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

Ich benutze init.tailsoder tail.initsmit einem möglichen Rückwärtsgang vorne in so ziemlich jeder Herausforderung; Ich wünschte, sie würden es bereits zu Prelude hinzufügen.

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

Ausgabe:

            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

Dieser funktioniert überraschend gut mit QBIC 'FOR-Schleifen. Erklärung (der Vorgängerversion - es gilt das gleiche Prinzip):

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

Ausgabe:

            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

Schläger 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 ""))

Ungolfed:

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

Testen:

(f)

Ausgabe:

            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