Istnieje mnóstwo pytań dotyczących rysowania kształtów za pomocą gwiazdek - więc pomyślałem, że przy tak wielu gwiazdkach powinniśmy narysować jedno, używając tabeli ASCII.

Wyzwanie

Twoim zadaniem jest napisanie programu lub funkcji, która nie pobiera danych wejściowych i wyświetla następujący tekst:

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

W celach informacyjnych ta witryna zawiera pełną tabelę ASCII.

Zasady

• Wynik powinien być dokładnym tekstem, jak pokazano powyżej. Wiodące / końcowe białe znaki są dozwolone.
• Obowiązują standardowe luki w grze w golfa - brak czytania tego ryzyka ASCII z Internetu itp.
• To jest golf golfowy , więc wygrywa najkrótsze rozwiązanie (w bajtach).

05AB1E , 40 38 37 36 35 bajtów

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

Wypróbuj online!

Wyjaśnienie

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

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

Generuje szablon

         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

%cza pomocą for x, a następnie używa interpolacji ciągów w range(32,128)celu wstawienia wartości ASCII do wzorca.

Wypróbuj online!

Python 2 jest dłuższy o jeden bajt, z dłuższym rozpakowaniem krotki, ale krótszy 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 bajtów

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

Wypróbuj online!

W przeciwieństwie do zwykłego programu ten nie zawiera znaków, które nie mogą być drukowane.

Wyjaśnienie:

¬ ~                     " 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

Teraz bufor wygląda następująco:

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

Teraz budujemy środek:

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

Tutaj robi się trochę dziwnie.

$                       " 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

Oto ważna uwaga. >Komenda jest rzeczywiście operatora , co oznacza, że nie robi nic bez argumentu, tekst działać dalej. Na przykład,

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

Ale ponieważ to polecenie jest w pętli, możemy zapisać znak, nie dając operatora. Na końcu pętli, jeśli jakiś operator oczekuje, wypełnia _(bieżący wiersz) jako argument niejawnie.

Przyznaję, że ta pętla jest trochę dziwna i trudno jest śledzić, jak powinien wyglądać cały tekst w danym momencie. Możesz więc użyć tego prostszego programu, aby zobaczyć, jak będzie wyglądał po N pętlach.

Jeśli ustawisz na 9, zobaczysz, że mamy trochę dodatkowego tekstu do pozbycia się. (Tylko bieżąca linia).

Więc usuwamy bieżącą linię za pomocą dd. Ale poczekaj! Wiesz, jak powiedziałem, że operatorzy muszą wziąć argument, który jest czasem domyślnie wypełniony? Argumenty są również domyślnie wypełniane na końcu programu. Więc zamiast ddlub d_(które są równoważne), możemy po prostu di pozwolić V wypełnić _dla nas.

Python 3 170 165 155 147 bajtów

Tak dużo grałem w golfa, zapomniałem, jak to działa ...

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

Wypróbuj online!

JavaScript (ES6), 156 … 115 114 bajtów

Niestety niesławny String.fromCharCode()kosztuje 19 bajtów.

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

Sformatowane i skomentowane

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

[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

To naprawdę tylko seria pętli FOR i rzutowania int na postać ( chr$()).

Przykładowe dane wyjściowe:

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

Perl , 113 bajtów

112 bajtów kodu + -lflaga.

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

Wypróbuj online!

PHP, 110 105 103 93 91 bajtów

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

wypisuje wiodącą nową linię. Uruchom go -nrlub przetestuj online .

Podstawowa zasada została przejęta z Arnauld, ale to się powtarza.
Wykorzystuje także niejawne typecasty PHP:
NULL na int dla indeksu ciągów, zmiennoprzecinkowe na int dla %, boolean na int dla &i dla +=.

objaśnienie pseudo kodem

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 bajty

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

Program, który drukuje wynik.

Wypróbuj online!

Jak to działa

srdC127 tworzy listę drukowalnych znaków ASCII i łączy je w ciąg znaków.

c....,18 60dzieli ten ciąg według indeksów 18i 60daje listę trzech ciągów odpowiadających różnym częściom wyniku: góra, środek i dół.

.erozpoczyna wyliczoną mapę nad ciągami z ciągami as bi ich indeksami jako k.

[...)tworzy listę zawierającą pożądaną akcję dla każdej części diagramu. Prawidłowe działanie wybiera się, indeksując do listy z bieżącym indeksem, używając @...k.

• Top

  cb2dzieli ciąg na pary znaków i +L*9;wstawia 9spacje do każdej pary.

• Środkowy

  c2b dzieli ciąg na dwa ciągi o równej długości.

• Dolny

  cL2cb4 dzieli ciąg na grupy po cztery znaki, a każda grupa na pary.

  .erozpoczyna wyliczoną mapę, z parami ciągów as Zi ich indeksami jako Y.

  j*yYdZłączy pary w 2*Yspacje i +*-8Yddodaje 8-Yspacje.

jsscala wszystkie wyniki i dołącza wynikową listę do nowych linii. Jest to następnie domyślnie drukowane.

Haskell , 144 bajty

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]])#[' '..]

Wypróbuj online!

Wyjaśnienie:

b!n=[1..n]>>bdefiniuje funkcję, !która powtarza listę lub ciąg- b nrazy.

unlines([" "!9++p]!9++["*"!21]!2++[" "!(8-n)++p++" "!(2*n)++p|n<-[0..8]]) używa tej funkcji, aby narysować gwiazdkę gwiazdek (o ironio!):

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

#jest zdefiniowany jako funkcja, która sukcesywnie zastępuje *w łańcuchu znakami z danej listy. Nazywa się to powyższą gwiazdką gwiazdek i [' '..]jest nieskończoną listą wszystkich znaków rozpoczynających się spacją ' '.

Węgiel drzewny , 39 bajtów (niekonkurencyjny)

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

Wypróbuj online! AST zapewnił wyjaśnienie, χponieważ jest to zmienna wstępnie zainicjalizowana dla 10.

J, 63

(nie konkuruje)

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

wyrażenie ocenia od prawej do lewej w ten sposób:

• i: 10 liczy od -10 do +10
• | weź abs, aby uzyskać od +10 do 0 z powrotem do +10
• = sklasyfikuj sam, aby uzyskać kształt V z 1 w bloku zer
• |. odwróć kolejność wierszy, aby uzyskać kształt / \
• ( +. 1&|."1 ) wyrażenie przechwytujące przesuwa każdy wiersz dokładnie o jeden, a OR z oryginałem
• ( 9 21&$@{. , 1: , 1: , }. ) zagnieżdżone widelce do układania w poziomie i rozciągania góry
• , zrównać blok z liniową sekwencją dla kumulacji
• ( * +/\ ) kumuluj i mnoż się z sobą
• 20 21 $ przywróć kształt do bloku 20 rzędów 21 elementów
• 31 + dodaj 31, ponieważ pierwszy 1 powinien być kodem spacji 32
• 32 >. piętro przy 32
• a. {~ wybieraj znaki z wbudowanego ascii

Ruby, 91 bajtów

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

Nie golfił

->{(-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.
}

Brakowało mi odpowiedzi w C #, więc ...

C # (.NET Core) , 175 174 bajtów

_=>{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;}

Wypróbuj online!

• 1 bajt zapisany dzięki Kevin Cruijssen!

Tcl , 209 bajtów

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

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

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

próbny

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}

próbny

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}

próbny

Poetycki , 899 bajtów

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

Wypróbuj online!

Poetic to esolang, który zrobiłem w 2018 roku dla projektu klasowego. Jest to po prostu pieprzenie mózgu z długimi słowami zamiast symboli.

Ten wiersz jest ... przygnębiający. 😟

Python 2.7, 194 188 bajtów

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

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)

Rozszerzony

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
 )

Wypróbuj online!

Ukośniki ( /// ), 324 bajty

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

Pierwszą (domyślną) czynnością w ukośnikach jest „print”, więc ciąg jest drukowany. /I \musi być poprzedzona postępowaniem \s.

Java 8, 176 173 bajtów

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 @Charlie „s C # .NET odpowiedzi , więc upewnij się, aby go upvote.
-3 bajty dzięki @ceilingcat .

Wypróbuj online.