Il y a une abondance de questions concernant le dessin de formes à l'aide d'astérisques - j'ai donc pensé qu'avec autant d'astérisques, nous devrions en dessiner une en utilisant le tableau ASCII.

Défi

Votre tâche consiste à écrire un programme ou une fonction qui ne prend aucune entrée et génère ce texte exact:

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

Pour référence, ce site répertorie le tableau ASCII complet.

Règles

• La sortie doit être le texte exact, comme indiqué ci-dessus. Les espaces blancs avant / arrière sont autorisés.
• Les failles de golf standard s'appliquent - pas de lecture de ce risque ASCII sur Internet, etc.
• Il s'agit de code-golf , donc la solution la plus courte (en octets) l'emporte.

05AB1E , 40 38 37 36 35 octets

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

Essayez-le en ligne!

Explication

ž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 octets

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

Génère le modèle

         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

avec %cfor x, puis utilise l'interpolation de chaîne range(32,128)pour insérer les valeurs ASCII dans le motif.

Essayez-le en ligne!

Python 2 est un octet de plus, avec un déballage plus long des tuples mais plus court 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 octets

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

Essayez-le en ligne!

Contrairement à l'habitude, ce programme ne contient aucun caractère non imprimable.

Explication:

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

Maintenant, le tampon ressemble à ceci:

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

Maintenant, nous construisons le milieu:

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

Voici où ça devient un peu bizarre.

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

Voici une note importante. La >commande est en fait un opérateur , ce qui signifie qu'elle ne fait rien sans argument, le texte sur lequel opérer. Par exemple,

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

Mais puisque cette commande est dans une boucle, nous pouvons sauvegarder un caractère en ne donnant pas d'opérateur. À la fin d'une boucle, si un opérateur est en attente, il remplira_ (la ligne actuelle) comme argument implicitement.

Maintenant, j'admets que cette boucle est un peu bizarre, et il peut être difficile de garder une trace de ce à quoi tout le texte devrait ressembler à un moment donné. Vous pouvez donc utiliser ce programme plus simple pour voir à quoi il ressemblera après N boucles.

Si vous le définissez sur 9, vous pouvez voir que nous avons un peu de texte supplémentaire à supprimer. (Juste la ligne actuelle).

Nous supprimons donc la ligne actuelle avec dd. Mais attendez! Vous savez comment j'ai dit que les opérateurs doivent prendre un argument qui est parfois implicitement rempli? Les arguments sont également implicitement remplis à la fin du programme. Donc plutôt que ddou d_(qui sont équivalents), nous pouvons simplement det laisser V remplir le _pour nous.

Python 3 170 165 155 147 octets

J'ai tellement joué au golf, j'ai oublié comment ça marche ...

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

Essayez-le en ligne!

JavaScript (ES6), 156 … 115 114 octets

Malheureusement, l'infâme String.fromCharCode()coûte 19 octets.

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

Formaté et commenté

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 octets

[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

C'est vraiment juste une série de boucles FOR et un casting d'un personnage (chr$() ).

Exemple de sortie:

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

Perl , 113 octets

112 octets de code + -lindicateur.

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

Essayez-le en ligne!

PHP, 110 105 103 93 91 octets

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

imprime une nouvelle ligne de premier plan. Exécuter avec -nrou tester en ligne .

Le principe de base est adopté par Arnauld, mais cela se répète.
Et il profite bien des typecasts implicites de PHP:
NULL à int pour l'index de chaîne, float à int pour %, booléen à int pour &et pour +=.

explication avec pseudo code

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 octets

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

Un programme qui imprime le résultat.

Essayez-le en ligne!

Comment ça marche

srdC127 crée une liste des caractères ASCII imprimables et les concatène en une chaîne.

c....,18 60divise cette chaîne aux indices 18et60 , donnant une liste de trois chaînes correspondant aux différentes parties de la sortie: le haut, le milieu et le bas.

.ecommence une carte énumérée sur les chaînes avec les chaînes as bet leurs indices ask .

[...)crée une liste contenant l'action souhaitée pour chaque partie du diagramme. L'action correcte est choisie en indexant dans la liste avec l'index en cours, en utilisant @...k.

• Haut

  cb2divise la chaîne en paires de caractères et +L*9;ajoute des 9espaces à chaque paire.

• Milieu

  c2b divise la chaîne en deux chaînes de longueur égale.

• Bas

  cL2cb4 divise la chaîne en groupes de quatre caractères et chaque groupe en paires.

  .ecommence une carte énumérée, avec les paires de chaînes as Zet leurs indices as Y.

  j*yYdZjoint les paires sur les 2*Yespaces et +*-8Ydajoute les 8-Yespaces.

jsfusionne tous les résultats et rejoint la liste résultante sur les retours à la ligne. Ceci est ensuite implicitement imprimé.

Haskell , 144 octets

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

Essayez-le en ligne!

Explication:

b!n=[1..n]>>bdéfinit une fonction !qui répète une liste ou une chaîneb n temps.

unlines([" "!9++p]!9++["*"!21]!2++[" "!(8-n)++p++" "!(2*n)++p|n<-[0..8]]) utilise cette fonction pour dessiner un astérisque d'astérisques (Oh, l'ironie!):

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

#est défini comme une fonction qui remplace consécutivement *dans une chaîne des caractères d'une liste donnée. Il est appelé avec l'astérisque ci-dessus des astérisques et [' '..]qui est une liste infinie de tous les caractères commençant par l'espace ' '.

Fusain , 39 octets (non compétitif)

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

Essayez-le en ligne! AST a fourni une explication, χétant la variable préinitialisée pour 10.

J, 63

(pas en compétition)

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

l'expression s'évalue de droite à gauche ainsi:

• i: 10 compte de -10 à +10
• | prendre des abs pour obtenir +10 à 0 revenir à +10
• = auto-classer pour obtenir la forme en V de 1 dans un bloc de 0
• |. inverser l'ordre des lignes pour obtenir la forme / \
• ( +. 1&|."1 ) l'expression du crochet décale chaque ligne vers la droite d'une unité et les OU avec l'original
• ( 9 21&$@{. , 1: , 1: , }. ) fourches imbriquées à mettre en position horizontale et dessus extensible
• , pour raser le bloc dans une séquence linéaire pour le cumul
• ( * +/\ ) cumuler et se multiplier avec soi
• 20 21 $ rétablir la forme d'un bloc 20 rangées de 21 éléments
• 31 + ajouter 31 car le premier 1 doit être un code de caractère d'espace 32
• 32 >. étage à 32
• a. {~ choisir les caractères de l'ascii intégré

Rubis, 91 octets

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

Non golfé

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

J'ai raté une réponse en C # alors ...

C # (.NET Core) , 175 174 octets

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

Essayez-le en ligne!

• 1 octet économisé grâce à Kevin Cruijssen!

Tcl , 209 octets

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

Essayez-le en ligne!

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

Essayez-le en ligne!

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

démo

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}

démo

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}

démo

Poétique , 899 octets

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

Essayez-le en ligne!

Poetic est un esolang que j'ai réalisé en 2018 pour un projet de classe. C'est essentiellement du cerveau avec des longueurs de mots au lieu de symboles.

Ce poème est ... déprimant. 😟

Python 2.7, 194 188 octets

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 octets

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)

Étendu

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
 )

Essayez-le en ligne!

Barres obliques ( /// ), 324 octets

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

La première action (par défaut) dans les barres obliques est «imprimer», donc la chaîne est imprimée. Le /et \doit être échappé en procédure \d.

Java 8, 176 173 octets

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 de la réponse C # .NET de @Charlie , alors assurez-vous de le voter.
-3 octets grâce à @ceilingcat .

Essayez-le en ligne.