Zeichnen Sie einen Alphabet-Partyhut

22

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.

code-golf  kolmogorov-complexity  alphabet 
— Oliver Ni
quelle
2
Warum die Abstimmungen?
— Oliver Ni
19
Ich vermute, einige Leute sind einfach müde von all den Herausforderungen, die das Alphabet-Muster der ASCI-Art KC mit sich bringt.
— Xnor
Können wir es in Großbuchstaben machen?
— Downgoat
7
Ernsthaft, eine andere Alphabet-Herausforderung?
— Erik the Outgolfer
2
Ich mag diese alphabetischen Herausforderungen. Dieser könnte leicht als Weihnachtsbaum umbenannt werden.
— Pete Arden

Antworten:

6

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

— Downgoat
quelle
1
Zist 90nicht A.
— Mego
5

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
— Emigna
quelle
4

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:]
— Karl Napf
quelle
Ich bin mir ziemlich sicher, dass die Verwendung einer Karte ein kürzeres Alphabet ergeben kann, außer vielleicht Kleinbuchstaben mit höheren Werten
— Destructible Lemon
Eigentlich bin ich mir nicht mehr sicher. Ich denke, das würde sowieso nicht funktionieren :( soz
— Destructible Lemon
4

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
— Billywob
quelle
1
Dies ist kürzer als mein Matrixversuch. Ersetzen 14...-1durch 13?
— JDL
@JDL Ah ja natürlich. Ein Rest des Versuchs eines anderen Ansatzes
— Billywob
2
Wenn Sie eine Schleife durch 25:0statt 1:26, können Sie ändern 13-i/2zu i/2und vereinfachen(27-i):26 zu i:25+1und spart 6 Byte.
— Rturnbull
3

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
— TheBikingViking
quelle
Versuchen Sie es ;statt\
— isaacg
3

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
— xnor
quelle
3

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 .

— darrylyeo
quelle
2
Ist das nicht eher ein Ausschnitt als eine Funktion oder ein Programm?
— Neil
1
for(s=a='',x=36;--x>9;)s+=` `.repeat(x/2-5)+(a=x.toString(36)+a)+'#'1B kürzer
— l4m2
@ l4m2 Genial!
— darrylyeo
1
Gute Idee mit Base 36! +1
— Titus
2

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: <>
— MegaTom
quelle
4
This should be readable enough as is.Du sprichst von Brain-Flak , oder?
— Erik der Outgolfer
2

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)
— Jonathan Allan
quelle
Ich habe einen Weg gefunden, eine Niladenkette zu bilden, beginnend mit dem Alphabet ØaJ’H⁶ẋżṫJ$ṚY, das 2 Bytes spart
— Meilen
Glaubst du, die Erklärung ist richtig?
— Jonathan Allan
1
Stellen Sie es sich einfach als monadische Kette vor, wobei ein einziges Argument das Alphabet ist
— Meilen
2

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;}
— o79y
quelle
1

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.

— Zerstörbare Zitrone
quelle
1

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--';
— Dada
quelle
1

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;
     }
  }
— Zahlenknoten
quelle
1
Sie können das =at entfernen d+=c+s+"\n". Möglicherweise möchten Sie auch Ihren ungolfed Code ein wenig mit Einrückungen formatieren. Ich habe das auch bei einigen Ihrer anderen Antworten bemerkt. :)
— Kevin Cruijssen
1
Hoppla! Ich habe diesen Fehler wieder gemacht, Schande für mich. ...... ok @ KevinCruijssen ich bin drauf.
— Numberknot
Kannst du das s=v+sin der Rekursion nicht durch ersetzen s+=v?
— Roman Gräf
Weil das Buchstabenmuster rückwärts ist.
— Numberknot
1

Ruby, 64 Bytes

(0..26).each{|x|puts' '*(12-x/2)+('a'..'z').to_a[~x..-1].join()}
— Manny42
quelle
Ein paar Kommentare: Sie müssen die Klammern nicht nach dem Anrufen join anbringen, eachstatt mapist unnötig, da es uns egal ist, was wir zurückgeben. Sie können lasteinen Bereich anrufen
— Lee W
Anstatt zu (0..26).mapversuchen 27.times; statt ('a'..'z').to_a, [*?a..?z]; und statt .join, *"".
— Jordanien
1

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
— Oliver
quelle
1

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
— idrougge
quelle
1

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!

— Sunny Pun
quelle
1

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
— aloisdg sagt Reinstate Monica
quelle
1

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!

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

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

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

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

— Sergiol
quelle
— Nur ASCII
@ ASCII-nur danke!
— Sergiol
1

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~%

— Nur ASCII
quelle
1
82
— Nur ASCII
1

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

— BradC
quelle
0

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.

— BlackCap
quelle
0

Python 2, 66 64 Bytes

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

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
— Magische Kraken-Urne
quelle
0

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
— steenbergh
quelle
Passt nicht zum OP.
— Magic Octopus Urn
@carusocomputing macht es jetzt.
— Steenbergh
0

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
— rnso
quelle
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.