Es gibt eine Fülle von Fragen zum Zeichnen von Formen mit Sternchen - daher dachte ich, dass wir mit so vielen Sternchen eine mit Hilfe der ASCII-Tabelle zeichnen sollten.

Herausforderung

Ihre Aufgabe ist es, ein Programm oder eine Funktion zu schreiben, die keine Eingabe benötigt und genau diesen Text ausgibt:

          !
         "#
         $%
         &'
         ()
         *+
         ,-
         ./
         01
23456789:;<=>?@ABCDEF
GHIJKLMNOPQRSTUVWXYZ[
        \]^_
       `a  bc
      de    fg
     hi      jk
    lm        no
   pq          rs
  tu            vw
 xy              z{
|}                ~

Zu Referenzzwecken listet diese Site die vollständige ASCII-Tabelle auf.

Regeln

• Die Ausgabe sollte genau den oben gezeigten Text enthalten. Führende / nachfolgende Leerzeichen sind zulässig.
• Es gelten Standard-Golflöcher - kein Lesen dieses ASCII-Risikos aus dem Internet usw.
• Das ist Code-Golf , also gewinnt die kürzeste Lösung (in Bytes).

05AB1E , 40 38 37 36 35 Bytes

žQ2ô376S3*£`2ôvyN·ð×ýð«}rsJ2äsr)˜.c

Probieren Sie es online!

Erläuterung

žQ                                   # push the printable ascii chars
  2ô                                 # split into pairs
    376S                             # split the number 376 into a list of digits
        3*                           # multiply each by 3 to get [9,21,18]
          £                          # divide the pairs of ascii chars into 
                                     # pieces of these sizes
           `                         # flatten list to stack
            2ô                       # split the "legs" of the asterisk into pairs of pairs
              v                      # loop over the pairs of pairs
               yN·ð×ý                # join the pairs by index*2 spaces
                     ð«              # append a space
                       }             # end loop
                        rs           # move the middle section to top of stack
                          J2ä        # convert to a string split into 2 pieces
                             sr      # rearrange the stack in the correct order
                               )˜    # wrap in a flattened list
                                 .c  # pad each element with spaces on either side

Python 3 , 110 Bytes

s='%c';print(('\n'.join(['%10c%c']*9+[s*21]*2+[' '*(8-i)+s*2+'  '*i+s*2for i in range(9)]))%(*range(32,128),))

Erzeugt die Vorlage

         xx
         xx
         xx
         xx
         xx
         xx
         xx
         xx
         xx
xxxxxxxxxxxxxxxxxxxxx
xxxxxxxxxxxxxxxxxxxxx
        xxxx
       xx  xx
      xx    xx
     xx      xx
    xx        xx
   xx          xx
  xx            xx
 xx              xx
xx                xx

Mit %cfor xwerden dann range(32,128)die ASCII-Werte mithilfe der Zeichenfolgeninterpolation in das Muster eingefügt.

Probieren Sie es online!

Python 2 ist ein Byte länger, wobei das Tupel länger, aber kürzer entpackt wird print.

s='%c';print('\n'.join(['%10c%c']*9+[s*21]*2+[' '*(8-i)+s*2+'  '*i+s*2for i in range(9)]))%tuple(range(32,128))

V , 54 , 50 Bytes

¬ ~9ñ9É 11|á
ñ2ñ20lá
ñ$18é 9ñ^y|Ehé
Pf xxywk$hP>ñd

Probieren Sie es online!

Anders als üblich enthält dieses Programm keine nicht druckbaren Zeichen.

Erläuterung:

¬ ~                     " Insert the entire printable ASCII range
   9ñ           ñ       " 9 times:
     9É                 "   Insert 9 spaces at the beginning of this line
        11|             "   Move to the 11'th column on this line
           á<CR>        "   And append a newline after the 11'th column

Nun sieht der Puffer so aus:

          !
         "#
         $%
         &'
         ()
         *+
         ,-
         ./
         01
23456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~

Jetzt bauen wir die Mitte auf:

2ñ        ñ             " Two times:
  20l                   "   Move 20 characters to the right (because 'l' == 'right', duh)
     á<CR>              "   Append a newline

Hier wird es etwas komisch.

$                       " Move to the end of this line 
 18é                    " Insert 18 spaces before the last character
     9ñ                 " Repeat the following 9 times:
       ^                "   Move to the first non-whitespace character
        y|              "   Yank all the whitespace before the current character. 
                        "   We'll call this the "Leading whitespace register"
          E             "   Move to the end of the current WORD (up to before a space)
           h            "   Move back one character
            é<CR>       "   And insert a newline before the current character
P                       "   Paste the leading whitespace for indentation
 f                      "   Move forward to a space
   xx                   "   Delete two characters
                        "   (Note how we are inbetween the two bottom branches right now)
     yw                 "   Yank everything upto the next branch (all spaces)
                        "   We'll paste this on the line up so that we can yank it again later
                        "   To keep track of how far apart the branches are
       k$               "   Move up a line and to the end of that line
         hP             "   Move back a character and paste the whitespace we yanked
           >            "   Indent this line by one space
            ñ           "   End the loop

Hier ist ein wichtiger Hinweis. Der >Befehl ist eigentlich ein Operator , was bedeutet, dass er nichts ohne ein Argument tut, den zu bearbeitenden Text. Beispielsweise,

>_      "Indent the current line
>>      "Indent the current line
>j      "Indent the current and next line
>G      "Indent every line

Da sich dieser Befehl jedoch in einer Schleife befindet, können wir ein Zeichen speichern, indem wir keinen Operator angeben. Wenn am Ende einer Schleife ein Operator ansteht, wird er _implizit als Argument (die aktuelle Zeile) eingefügt.

Jetzt gebe ich zu, dass diese Schleife etwas seltsam ist und es schwierig sein kann, den Überblick darüber zu behalten, wie der gesamte Text zu einem bestimmten Zeitpunkt aussehen sollte. Mit diesem einfacheren Programm können Sie also sehen, wie es nach N Schleifen aussehen wird .

Wenn Sie den Wert auf 9 setzen, sehen Sie, dass wir ein bisschen zusätzlichen Text haben, den wir loswerden müssen. (Nur die aktuelle Zeile).

Also löschen wir die aktuelle Zeile mit dd. Aber warte! Weißt du, wie ich sagte, dass Operatoren ein Argument annehmen müssen, das manchmal implizit ausgefüllt wird? Argumente werden auch implizit am Ende des Programms eingetragen. Anstelle von ddoder d_(die äquivalent sind) können wir einfach dV _für uns ausfüllen lassen .

Python 3 170 165 155 147 Bytes

Ich habe so viel Golf gespielt, ich habe vergessen, wie es funktioniert ...

i=b=0
for x in range(32,127):a=x%2<1;c=x>90;d=x<50;print(end=[' '*9*d,['\n'+' '*(8-i),'  '*~-i][b]][c]*a+chr(x)+'\n'*(x==70or d*x%2));b^=a;i+=b*c*a

Probieren Sie es online!

JavaScript (ES6), 156 … 115 114 Bytes

Leider String.fromCharCode()kostet das berüchtigte 19 Bytes.

f=(x=y=k=1)=>k<96?String.fromCharCode(x-22?y/2^5&&(y>9?x-y+1>>1&&22-y-x>>1:x/2^5)?32:31+k++:(x=!++y,10))+f(x+1):''

console.log(f())

Formatiert und kommentiert

f = (                         // given:
  x =                         //   - x = current column
  y =                         //   - y = current row
  k = 1                       //   - k = current ASCII character code, minus 31
) =>                          //
  k < 96 ?                    // if we havent't reached character #127 (96 + 31):
    String.fromCharCode(      //   let's compute the next character
      x - 22 ?                //   if x is not equal to 22 (end of line):
        y / 2 ^ 5 && (        //     if y doesn't equal 10 or 11 (horizontal bar):
          y > 9 ?             //       and either y is greater than 9:
            x - y + 1 >> 1 && //         and we are not located on one of the
            22 - y - x >> 1   //         bottom diagonals
          :                   //       or y is less or equal to 9:
            x / 2 ^ 5         //         and x doesn't equal 10 or 11 (vertical bar)
        ) ?                   //     then:
          32                  //       append a space
        :                     //     else:
          31 + k++            //       append the next ASCII character
      :                       //   else:
        (x = !++y, 10)        //     increment y, reset x and append a LineFeed
    ) + f(x + 1)              //   do a recursive call with x + 1
  :                           // else:
    ''                        //   stop recursion

QBIC , 153 151 Bytes

[32,49,2|?space$(9)+chr$(a)+chr$(a+1)][2|X=Y[a,a+20|X=X+chr$(c)]a=a+21?X][0,8|X=space$(8-d)[0,1|X=X+chr$(a+e)]X=X+space$(d*2)[2,3|X=X+chr$(a+f)]a=a+f?X

Es ist wirklich nur eine Reihe von FOR-Schleifen und das Umwandeln eines Int in ein Zeichen ( chr$()).

Beispielausgabe:

          !
         "#
         $%
         &'
         ()
         *+
         ,-
         ./
         01
23456789:;<=>?@ABCDEF
GHIJKLMNOPQRSTUVWXYZ[
        \]^_
       `a  bc
      de    fg
     hi      jk
    lm        no
   pq          rs
  tu            vw
 xy              z{
|}                ~

Perl , 113 Bytes

112 Byte Code + -lFlag.

sub g{chr$c+++32}print$"x9,&g,&g for 0..8;print map&g,0..20for 0,1;print$"x-$_,&g,&g,$"x(16+2*$_),&g,&g for-8..0

Probieren Sie es online!

PHP, 110 105 103 93 91 Bytes

for(;$c<95;$y+=!$x%=21)echo"
"[$x],chr(31+($y%11<9&(max($y,10)-abs(9.5-$x++))%11<9?:++$c));

druckt eine führende Zeile. Laufen Sie mit -nroder testen Sie es online .

Das Grundprinzip wird von Arnauld übernommen, aber dies wiederholt sich.
Und es macht sich die impliziten Typecasts von PHP zunutze:
NULL zu int für den String-Index, float zu int für %, boolean zu int für &und für +=.

Erklärung mit Pseudocode

If $x is 0, print a newline. ("\n"[$x] is newline for $x=0; empty for every larger $x)
if $y is neither 9 nor 10 (not middle part: $y<9|$y>10 <=> $y%11<9)
AND distance to center == abs(9.5-$x) (in [0.5,1.5,..,10.5]) ->
    lower part:     abs($y-10-distance)>1                   => ($y-distance)%11<9
                (this works because $y is always <20)
    upper part: $x<9|$x>10 <=> distance>1 <=> 10-distance<9 => (10-distance)%11<9
                (this works because % has negative results for negative first operands)
    both parts: $y>9?$y:10 <=> max($y,10)
// $a?:$b evaluates to $a if $a is truthy, to $b else
// and the ternary condition evaluates to 1 if the coords are not in the shape
then print chr(31+1) = space
else print chr(31+incremented $c)

Pyth , 53 Bytes

js.e@[+L*9;cb2c2b.e+*-8Ydj*yYdZcL2cb4)kcsrdC127,18 60

Ein Programm, das das Ergebnis druckt.

Probieren Sie es online!

Wie es funktioniert

srdC127 Erstellt eine Liste der druckbaren ASCII-Zeichen und verkettet diese zu einer Zeichenfolge.

c....,18 60teilt diese Zeichenfolge in Indizes auf 18und 60gibt eine Liste mit drei Zeichenfolgen an, die den verschiedenen Teilen der Ausgabe entsprechen: der oberen, der mittleren und der unteren.

.eBeginnt eine nummerierte Karte über die Zeichenfolgen mit den Zeichenfolgen als bund ihren Indizes als k.

[...)Erstellt eine Liste mit der gewünschten Aktion für jeden Teil des Diagramms. Die richtige Aktion wird durch Indizieren in die Liste mit dem aktuellen Index mit ausgewählt @...k.

• oben

  cb2+L*9;Teilt die Zeichenfolge in Zeichenpaare auf und stellt 9jedem Paar Leerzeichen voran .

• Mitte

  c2b Teilt die Zeichenfolge in zwei gleichlange Zeichenfolgen auf.

• Unterseite

  cL2cb4 Teilt die Zeichenfolge in Gruppen von vier Zeichen und jede Gruppe in Paare.

  .ebeginnt eine Aufzählungskarte mit den Zeichenfolgenpaaren als Zund ihren Indizes als Y.

  j*yYdZVerbindet die Paare auf 2*YLeerzeichen und +*-8Ydstellt 8-YLeerzeichen voran .

jsFührt alle Ergebnisse zusammen und fügt sie in Zeilenumbrüchen der resultierenden Liste hinzu. Dies wird dann implizit gedruckt.

Haskell , 144 Bytes

b!n=[1..n]>>b
('*':r)#(a:s)=a:r#s
(a:r)#s=a:r#s
r#s=r
p="**"
f=unlines([" "!9++p]!9++["*"!21]!2++[" "!(8-n)++p++" "!(2*n)++p|n<-[0..8]])#[' '..]

Probieren Sie es online!

Erläuterung:

b!n=[1..n]>>bDefiniert eine Funktion, !die eine Liste oder einen String b n-times wiederholt .

unlines([" "!9++p]!9++["*"!21]!2++[" "!(8-n)++p++" "!(2*n)++p|n<-[0..8]]) benutzt diese Funktion, um ein Sternchen aus Sternchen zu zeichnen (Oh, die Ironie!):

         **
         **
         **
         **
         **
         **
         **
         **
         **
*********************
*********************
        ****
       **  **
      **    **
     **      **
    **        **
   **          **
  **            **
 **              **
**                **

#wird als eine Funktion definiert, die *in einer Zeichenfolge nacheinander Zeichen aus einer gegebenen Liste verwendet. Es wird mit dem obigen Sternchen bezeichnet und [' '..]ist eine unendliche Liste aller Zeichen, die mit dem Leerzeichen beginnen ' '.

Kohle , 39 Bytes (nicht konkurrierend)

ＧＨ↑χ→⁴↓χ→¹¹↓⁴←χ↘χ←⁴↖⁹←²↙⁹←⁴↗χ←⁹↑⁴→⁹ ↓¤γ

Probieren Sie es online! AST lieferte eine Erklärung, χwobei es sich um die vorinitialisierte Variable für 10.

J, 63

(nicht konkurrierend)

a.{~32>.31+20 21$(* +/\),(9 21&$@{.,1:,1:,}.)(+.1&|."1)|.=|i:10

Der Ausdruck wird von rechts nach links ausgewertet.

• i: 10 zählt von -10 bis +10
• | nimm abs, um +10 auf 0 zurück zu +10 zu bekommen
• = Selbstklassifizierung, um die V-Form von Einsen in einem Block von Nullen zu erhalten
• |. Zeilenreihenfolge umkehren, um / \ shape zu erhalten
• ( +. 1&|."1 ) Der Hook-Ausdruck verschiebt jede Zeile um eins nach rechts und die ODER-Verknüpfung mit dem Original
• ( 9 21&$@{. , 1: , 1: , }. ) geschachtelte Gabeln zum horizontalen Einlegen und Strecken des Oberteils
• , um den Block zur Kumulierung in eine lineare Sequenz zu zerlegen
• ( * +/\ ) kumulieren und mit sich selbst multiplizieren
• 20 21 $ Form zurück zu einem Block 20 Reihen von 21 Elementen
• 31 + addiere 31, weil die erste 1 ein Leerzeichen Code 32 sein sollte
• 32 >. Etage bei 32
• a. {~ Wählen Sie Zeichen aus ASCII Built-In

Rubin, 91 Bytes

->{(-11..8).map{|i|["%s"*21,"%#{9-i}s%s%#{i*2+1}s%s","%10s%s"][i/2<=>-1]}*$/%[*' '..?~,$/]}

Ungolfed

->{(-11..8).map{|i|            #For each line
  ["%s"*21,                    #If i/2==-1 make a format string of 21 %s
   "%#{9-i}s%s%#{i*2+1}s%s",   #If i/2>-1 make a format string %{9-i}s%s%{i*2+1}s%s
   "%10s%s"][i/2<=>-1]         #If i/2<-1 make a format string %10s%s
  }*$/%                        #Join the format strings with newlines $/ then use sprintf operator %
  [*' '..?~,$/]                #to replace the %s with *' '..'~' and a newline for last corner.
}

Ich habe eine Antwort in C # verpasst, also ...

C # (.NET Core) , 175 bis 174 Byte

_=>{var r="";for(int i=0,j,d=32,s=1;i<54;i++)for(j=0;j++<"*#4#4#4#4#4#4#4#4#+K)%1###/#%#-#'#+#)#)#+#'#-#%#/###1#"[i]-33;)r+=(char)(i%2<1?32:d++)+(s++%21<1?"\n":"");return r;}

Probieren Sie es online!

• 1 Byte gespart dank Kevin Cruijssen!

Tcl , 209 Bytes

proc I {} {incr ::i}
proc A {} {time {append a [$::F %c [I]]} 21;puts $a}
set i 31
time {puts [[set F format] %10c%c [I] [I]]} 9
A
A
time {puts [$F %[expr 32-[I]/4]c%c $i [I]][$F %[expr $i/2-45]c%c [I] [I]]} 9

Probieren Sie es online!

proc I {} {incr ::i}
proc A {} {time {append a [$::F %c [I]]} 21;puts $a}
set i 31
time {puts [[set F format] %10c%c [I] [I]]} 9
A
A
time {puts [$F %[expr (129-[I])/4]c%c $i [I]][$F %[expr $i/2-45]c%c [I] [I]]} 9

Probieren Sie es online!

proc I {} {incr ::i}
set F format
proc A {} {time {append a [$::F %c [I]]} 21;puts $a}
set i 31
time {puts [$F %10c%c [I] [I]]} 9
A
A
time {puts [$F %[expr (129-[I])/4]c%c $i [I]][$F %[expr $i/2-45]c%c [I] [I]]} 9

Demo

proc I {} {incr ::i}
set F format
proc A {} {time {append a [$::F %c [I]]} 21;puts $a}
set i 31
time {puts [$F %10c%c [I] [I]]} 9
A
A
time {I;puts [$F %[expr (129-$i)/4]c%c $i [I]][$F %[expr $i/2-45]c%c [I] [I]]} 9

proc I {} {incr ::i}
set F format
proc A {} {time {append ::a [$::F %c [I]]} 21}
set i 31
time {puts [$F %10c%c [I] [I]]} 9
A
set a $a\n
A
puts $a
time {I;puts [$F %[expr (129-$i)/4]c%c $i [I]][$F %[expr $i/2-45]c%c [I] [I]]} 9

proc I {} {incr ::i}
set F format
proc A {} {time {append ::a [$::F %c [I]]} 21}
set i 31
time {puts [$F %10c%c [I] [I]]} 9
set a ""
A
set a $a\n
A
puts $a
time {I;puts [$F %[expr (129-$i)/4]c%c $i [I]][$F %[expr $i/2-45]c%c [I] [I]]} 9

proc I {} {incr ::i}
set F format
proc A {} {time {set ::a $::a[$::F %c [I]]} 21}
set i 31
time {puts [$F %10c%c [I] [I]]} 9
set a ""
A
set a $a\n
A
puts $a
time {I;puts [$F %[expr (129-$i)/4]c%c $i [I]][$F %[expr $i/2-45]c%c [I] [I]]} 9

proc I {} {incr ::i}
set F format
proc A b {time {upvar $b c;set c $c[$::F %c [I]]} 21}
set i 31
time {puts [$F %10c%c [I] [I]]} 9
set a ""
A a
set a $a\n
A a
puts $a
time {I;puts [$F %[expr (129-$i)/4]c%c $i [I]][$F %[expr $i/2-45]c%c [I] [I]]} 9

lassign {set while puts format incr expr} S W P F I E
$S i 31
$W \$i<48 {$P [$F %10c%c [$I i] [$I i]]}
$S a ""
$W {[$I i]<71} {$S a $a[$F %c $i]}
$S a $a\n
$W \$i<92 {$S a $a[$F %c $i];$I i}
$P $a
$W \$i<128 {$P [$F %[$E (129-$i)/4]c%c $i [$I i]][$F %[$E $i/2-45]c%c [$I i] [$I i]]; $I i}

Demo

set i 31
while \$i<48 {puts [format %10c%c [incr i] [incr i]]}
set a ""
while {[incr i]<71} {set a $a[format %c $i]}
set a $a\n
while \$i<92 {set a $a[format %c $i];incr i}
puts $a
while \$i<128 {puts [format %[expr (129-$i)/4]c%c $i [incr i]][format %[expr $i/2-45]c%c [incr i] [incr i]]; incr i}

Demo

Poetisch , 899 Bytes

ill be honest with you
i expect a big solitude
i guess i had a guilt
my own idea being:i was real alone,i was a lonely human
also,i am still
o,i guess i was expecting a shift
i figured,surely i know i am tired of silence
now i dreamed for a shift
a magical desire cant come
i am barely a man,so i guess i see why a woman i see ignores myself
i know i am awful
o,a night of passion and a moment of love
i am truly the foolish person,every time i am saying i may recapture a love
o,i think i can,i think i can
i really do know i am unfit
o,i notice a lot,i think i know i am unfit
o,a novel,or perhaps poetry in code,i do enjoy the writing
and i shudder and i wonder in a moment
i was a weirdo,i was a freak,or like,i am creepy
o,i think i was a misfit
i know i am,really
o,i ought not concern myself
and sure,i am still some joyless man
i focused and i tried
a lasting solace and joy is nearby for me

Probieren Sie es online!

Poetic ist ein Esolang, den ich 2018 für ein Klassenprojekt gemacht habe. Es handelt sich im Grunde genommen um einen Brainfuck mit Wortlängen anstelle von Symbolen.

Dieses Gedicht ist ... deprimierend. 😟

Python 2.7, 194 188 Bytes

k,l,c,s,r=8,0,chr,' ',range;o=''.join(map(chr,r(32,127)))
for i in r(0,18,2):print s*9+o[i:i+2]
print o[18:39]+'\n'+o[39:60]
for i in r(60,95,4):print s*k+o[i:i+2]+s*l+o[i+2:i+4];k-=1;l+=2

Jq 1,5 , 180 Bytes

foreach((range(9)|[9,2]),(range(2)|[0,21]),(range(9)|[8-.,2,.+.,2]))as$r({s:[range(32;127)]|implode};.r=$r|.p=""|until(.r==[];.p+=" "*.r[0]+.s[:.r[1]]|.s =.s[.r[1]:]|.r=.r[2:]);.p)

Erweitert

foreach (                              # instruction sequence: [indent, count]
    (range(9)|[9,2]),                  # 9 rows of 2 characters indented 9 spaces
    (range(2)|[0,21]),                 # 2 rows of 21 characters
    (range(9)|[8-.,2,.+.,2])           # 9 rows of 4 characters with varying indent
) as $r (
    {s:[range(32;127)]|implode}        # state = ascii string
  ; .r = $r                            # current instruction
  | .p = ""                            # print string for this row
  | until(.r==[];                      # until current instruction is exhausted
        .p += " "*.r[0] + .s[:.r[1]]   # add to print string
      | .s = .s[.r[1]:]                # remove from state
      | .r = .r[2:]                    # remove from instruction
    )
  ; .p                                 # emit print string
 )

Probieren Sie es online!

Schrägstriche ( /// ), 324 Byte

          !
         "#
         $%
         &'
         ()
         *+
         ,-
         .\/
         01
23456789:;<=>?@ABCDEF
GHIJKLMNOPQRSTUVWXYZ[
        \\]^_
       `a  bc
      de    fg
     hi      jk
    lm        no
   pq          rs
  tu            vw
 xy              z{
|}                ~

Die erste (Standard-) Aktion in Schrägstrichen ist "Drucken", daher wird die Zeichenfolge gedruckt. Das /und \muss mit \s entkommen werden .

Java 8, 176 173 Bytes

v->{for(int i=0,j,d=32,s=1;i<54;i++)for(j=0;j++<"*#4#4#4#4#4#4#4#4#+K)%1###/#%#-#'#+#)#)#+#'#-#%#/###1#".charAt(i)-33;)System.out.printf(s++%21<1?"%c\n":"%c",i%2<1?32:d++);}

Port von @Charlies C # .NET-Antwort , also stelle sicher, dass du ihn positiv bewertest.
-3 Bytes dank @ceilingcat .

Probieren Sie es online aus.