Während ich Code-Golf spiele, möchte ich häufig wissen, wie hoch der ASCII-Wert eines bestimmten Zeichens ist. Eine meiner Lieblingsressourcen zum schnellen Nachschlagen aller druckbaren ASCII-Zeichen ist ASCIItable.com . Das Bild ist sehr schön und zeigt nicht nur die druckbaren ASCII-Zeichen und ihre Werte, sondern auch die nicht druckbaren und erweiterten Zeichen sowie die Werte in Hexadezimal, Oktal und HTML:

Die heutige Herausforderung besteht darin, diese ASCII-Tabelle als ASCII-Tabelle anstelle eines Abbilds neu zu erstellen. Zur Vereinfachung werden keine Steuerzeichen (Zeichen unter 32) verwendet und nur der Dezimalwert und das Zeichen angezeigt. Mit anderen Worten, Ihre Herausforderung besteht darin, entweder ein Vollprogramm oder eine Funktion zu schreiben, die den folgenden Text ausgibt oder zurückgibt:

Dec  Chr   | Dec  Chr   | Dec  Chr
----------------------------------
32   Space | 64   @     | 96   `
33   !     | 65   A     | 97   a
34   "     | 66   B     | 98   b
35   #     | 67   C     | 99   c
36   $     | 68   D     | 100  d
37   %     | 69   E     | 101  e
38   &     | 70   F     | 102  f
39   '     | 71   G     | 103  g
40   (     | 72   H     | 104  h
41   )     | 73   I     | 105  i
42   *     | 74   J     | 106  j
43   +     | 75   K     | 107  k
44   ,     | 76   L     | 108  l
45   -     | 77   M     | 109  m
46   .     | 78   N     | 110  n
47   /     | 79   O     | 111  o
48   0     | 80   P     | 112  p
49   1     | 81   Q     | 113  q
50   2     | 82   R     | 114  r
51   3     | 83   S     | 115  s
52   4     | 84   T     | 116  t
53   5     | 85   U     | 117  u
54   6     | 86   V     | 118  v
55   7     | 87   W     | 119  w
56   8     | 88   X     | 120  x
57   9     | 89   Y     | 121  y
58   :     | 90   Z     | 122  z
59   ;     | 91   [     | 123  {
60   <     | 92   \     | 124  |
61   =     | 93   ]     | 125  }
62   >     | 94   ^     | 126  ~
63   ?     | 95   _     | 127  DEL

Es sind Leerzeichen in jeder Zeile und ein abschließender Zeilenumbruch zulässig. Da es sich um eine Herausforderung der Kolmogorov-Komplexität handelt , kann es sein, dass Ihr Beitrag keine Eingaben erfordert oder auf externe Ressourcen (z. B. eine Datei oder das Web) zugreift. Ihr Ziel ist es, den Code so weit wie möglich zu komprimieren, um diesen Text auszugeben.

Es gelten Standardlücken, und die kürzeste Antwort in Bytes gewinnt. Viel Spaß beim Golfen!

Python 2, 185 183 175 159 Bytes

8 Bytes gespart dank FlipTack!

Das Golfen in Python ist noch recht neu.

for a in["Dec  Chr   | "*3,"-"*39]+["".join(["%-5d%-6s| "%(l,('Space',chr(l),'DEL')[(l>32)+(l>126)]) for l in(i,32+i,64+i)])for i in range(32,64)]:print a[:-5]

Verwendet ein verschachteltes Listenverständnis, um den Tabellenkörper zu generieren.

Ungolfed:

lines =   \
  ["Dec  Chr   | "*3, "-"*39] +                    # first two lines
    ["".join(                                        # join 3 parts of each line
      ["%-5d%-6s| " % (l, ('Space',chr(l),'DEL')[(l>32)+(l>126)]) 
        for l in (i,32+i,64+i)]                      # generate 3 parts of a line
      )
      for i in range(32,64)]

for line in lines: print line[:-5]

Alter Versuch, 185 183 175 Bytes

print("Dec  Chr   | "*3)[:-5]+"\n"+"-"*34
a=lambda x:('Space',chr(x),'DEL')[(x>32)+(x>126)]
for l in range(32,64):print("%-5d%-6s| "*3%(l,a(l),l+32,a(l+32),l+64,a(l+64)))[:-5]

Ungolfed:

print ("Dec  Chr   | "*3)[:-5] + "\n" + "-"*34
def a(x):
    return "Space" if x==32 else "DEL" if x==127 else chr(x)
for line in range(32,64):
    print ("%-5d%-6s| "*3 % (line, a(line), line+32, a(line+32), 
      line+64, a(line+64))) [:-5]

Befunge, 176 172 Bytes

<v"Dec  Chr   "0
^>:#,_$1+:2`#v_" |",,
\:#->#1_55+,v>55+,"!-":>,#:
+2*,:"_"`#@_v>1+:8-#v_$1+:3%!:7g,!29+*5
*84+1%3\/3::<^,gg00:<`"c"p00+5+`"~"\`*84::p62:.:+*
  Space

| DEL

Probieren Sie es online!

Pyth, 89 85 79 77 Bytes

PP*"Dec  Chr   | "3*\-34V32PPsm++.[`=+N32;5.[?qN32"Space"?qN127"DEL"CN;6"| "3

Probieren Sie es online!

JavaScript (ES6), 179 173 Bytes

f=n=>n?(n>>6?' | ':`
`)+n+(99<n?'  ':'   ')+(126<n?'DEL':String.fromCharCode(n)+'    '+f(n>95?n-63:n+32)):`${x='Dec  Chr   '}| ${x}| ${x}
${'-'.repeat(34)}
32   Space`+f(64)

console.log(f())

V , 98, 96 , 94 Bytes

i32 | 64 | 9631ñÙl.l.ñÍä«/&   &    
ÎéiD@"
bsDELF 27kdH5lRSpaceÄÒ-Ä3RDec  Chr³ | Î35|D

Probieren Sie es online!

Nur knapp Quietschen unter hundert in. Ich werde sehen, ob ich Pyth schlagen kann, aber ich werde keine Versprechungen machen.

Hier ist ein Hexdump:

00000000: 6933 3220 7c20 3634 207c 2039 361b 3331  i32 | 64 | 96.31
00000010: f1d9 016c 2e6c 2ef1 cde4 ab2f 2620 2020  ...l.l...../&   
00000020: 1616 2620 2020 200a cee9 6944 4022 0a62  ..&    ...iD@".b
00000030: 7344 454c 1b46 2016 3237 6b64 4835 6c52  sDEL.F .27kdH5lR
00000040: 5370 6163 651b c4d2 2dc4 3352 4465 6320  Space...-.3RDec 
00000050: 2043 6872 b320 7c20 1bce 3335 7c44        Chr. | ..35|D

Und so funktioniert es:

i32 | 64 | 96<esc>      " Insert some starting text
31ñ          ñ          " 31 times:
   Ù                    "   Duplicate this line
    <C-a>               "   Increment the first number on this line
         l.             "   Increment the next number
           l.           "   Increment the next number

Hier wird es interessant. Lassen Sie mich zunächst einen Vim-Trick erklären. Im Einfügemodus werden bestimmte Zeichen eingefügt (alle druckbaren ASCII-Zeichen, die meisten nicht zugeordneten Zeichen oben 0x7fund einige andere), andere Zeichen haben jedoch einen Nebeneffekt. Beispiel: 0x1b( <esc>) wechselt in den normalen Modus. 0x01( <C-a>) fügt den zuletzt eingefügten Text usw. erneut ein. Manchmal möchten wir diese Zeichen buchstäblich einfügen. Um ein Escape-Zeichen einzufügen, müssen Sie Folgendes eingeben <C-v><esc>. Dies funktioniert für alle Charaktere, die einen Nebeneffekt haben. Dies entspricht im Wesentlichen <C-v>einem Backslash in Sprachen mit String-Literalen, mit denen Sie bestimmte Zeichen in einem String maskieren können.

Der andere nützliche Trick <C-v>im Einfügemodus besteht darin, dass Zeichen nach Codepunkt entweder in Dezimal-, Hexadezimal-, Oktal- oder Hexadezimal-Unicode eingefügt werden können. Da wir bereits die Zahlen haben, die bestimmten ASCII-Werten entsprechen, müssen wir <C-v>diesen Zeichen nur ein vorangestelltes a voranstellen und den entsprechenden Text als vim-Tastendruck ausführen. Dies kann mit einem Regex-Befehl und einem "Do 'x' in jeder Zeile" -Befehl erreicht werden. Also wir:

Í                       " Substitute globally:
 ä«                     "   One or more digits
   /                    " With:
    &                   "   The matched number + some spaces
        <C-v><C-v>&     "   A ctrl-v character, then the matched number again
                        "   Since ctrl-v is like a backslash, we need two to enter a literal ctrl-v character
Î                       " On every line:
 éi                     "   Insert an 'i'
   D                    "   Delete this line
    @"                  "   Run it as vim keystrokes

Zu diesem Zeitpunkt sieht der Puffer folgendermaßen aus

32         | 64   @     | 96   `    
33   !     | 65   A     | 97   a    
34   "     | 66   B     | 98   b    
35   #     | 67   C     | 99   c    
36   $     | 68   D     | 100   d    
37   %     | 69   E     | 101   e    
38   &     | 70   F     | 102   f    
39   '     | 71   G     | 103   g    
40   (     | 72   H     | 104   h    
41   )     | 73   I     | 105   i    
42   *     | 74   J     | 106   j    
43   +     | 75   K     | 107   k    
44   ,     | 76   L     | 108   l    
45   -     | 77   M     | 109   m    
46   .     | 78   N     | 110   n    
47   /     | 79   O     | 111   o    
48   0     | 80   P     | 112   p    
49   1     | 81   Q     | 113   q    
50   2     | 82   R     | 114   r    
51   3     | 83   S     | 115   s    
52   4     | 84   T     | 116   t    
53   5     | 85   U     | 117   u    
54   6     | 86   V     | 118   v    
55   7     | 87   W     | 119   w    
56   8     | 88   X     | 120   x    
57   9     | 89   Y     | 121   y    
58   :     | 90   Z     | 122   z    
59   ;     | 91   [     | 123   {    
60   <     | 92   \     | 124   |    
61   =     | 93   ]     | 125   }    
62   >     | 94   ^     | 126   ~    
63   ?     | 95   _     | 127       

Jetzt brauchen wir nur noch eine allgemeine Bereinigung, die den größten Teil der Bytes in dieser Antwort ausmacht

bsDEL<esc>              " Change the literal 0x7f character to "DEL"
          F <C-v>27kd   " Remove a space from the lines that have too many
H5l                     " Move to the first space character
   RSpace<esc>          " And replace it with "Space"
Ä                       " Duplicate this line
 Ò-                     " And replace it with '-'s
   Ä                    " Duplicate this line
    3R                  " And replace it with three copies of the following string:
      Dec  Chr³ | <esc> " 'Dec  Chr   | '

Î35|D                   " Remove all but the first 35 characters of each line

F # 222 Bytes

let c,p=String.concat" | ",printfn"%s"
Seq.replicate 3"Dec  Chr  "|>c|>p
p(String.replicate 34"-")
for i=32 to 63 do[for j in[i;i+32;i+64]->sprintf"%-5d%-5s"j (match j with 32->"Space"|127->"DEL"|_->string(char j))]|>c|>p

Probieren Sie es online!

Gleichstrom , 167 Bytes

[[Space]nq]sp[[DEL]nq]sq[[ ]n]sc[Dec  Chr]dsen[   | ]dsfnlenlfnlen10P34[[-]n1-d0<a]dsax10P0[[32+dndZ2=c[  ]ndd32=pd127=qP[    ]n]dswx[ | ]nlwx[ | ]nlwx10P95-d32>b]dsbx

Probieren Sie es online!

Wie es funktioniert:

[[Space]nq]sp     # p is a macro that prints "Space" and then quits from the call one level up
[[DEL]nq]sq       # q is a macro that prints "DEL" and then quits from the call one level up
[[ ]n]sc          # c is a macro that prints a space
[Dec  Chr]dsen    # Save the string "Dec  Chr" in register e, and print it.
[   | ]dsfn       # Save the string "   | " in register f, and print it.
len               # Print "Dec  Chr" again.
lfn               # Print "   | " again.
len               # Print "Dec  Chr" again.
10P               # Print a newline.
34                # Push 34 on the stack.

[[-]n1-d0<a]dsa   # a is a macro that repeatedly prints "-" and decrements the top of the stack, while the top of the stack is positive.

x10P              # Execute macro a, followed by a newline. (This prints the line of hyphens.)

0                 # Push 0 on the stack.

[                 # Starting a large macro (which will be stored in register b) for printing the table row by row.

[32+dndZ2=c[  ]ndd32=pd127=qP[    ]n]dsw

                  # w is a macro which:
                        (1) adds 32 to the top of the stack;
                        (2) prints it as a number;
                        (3) uses Z to compute the number of characters the number required to print that number;
                        (4) if it required 2 characters to print the number, calls the macro c to print an extra space
                        (5) prints the string "Space" (for ASCII code 32) or the string "DEL" (for ASCII code 127) or the appropriate character, followed by the right number of spaces

x                 # Execute macro w to print an entry in column 1.
[ | ]n            # Print a column divider.
lwx               # Execute macro w to print an entry in column 2 (ASCII code 32 higher than the previous entry).
[ | ]n            # Print a column divider.
lwx               # Execute macro w to print an entry in column 3 (ASCII code 32 higher than the previous entry).

10P               # Print a newline.
95-               # Subtract 95 to adjust to go to the beginning of the next line.

d32>b             # If the top of stack is <= 32, execute macro b again, effectively looping to print all the rows of the table.

]dsb              # End the definition of the large macro, and store it in register b.

x                 # Execute the macro that's in b (with 0 at the top of the stack initially).

Perl, 120 Bytes

$,="| ";say+("Dec  Chr   ")x3;say"-"x32;say map{sprintf"%-5s%-6s",$_,$_-32?$_-127?chr:DEL:Space}$_,$_+32,$_+64for 32..63

Laufen mit -EFlagge:

perl -E '$,="| ";say+("Dec  Chr   ")x3;say"-"x32;say map{sprintf"%-5s%-6s",$_,$_-32?$_-127?chr:DEL:Space}$_,$_+32,$_+64for 32..63'

-2 Bytes dank @GB .

C 179 Bytes

i;f(){for(;i++<37;)printf(i<4?"Dec  Chr%s":"-",i<3?"   | ":"\n");printf("\n32   Space | ");for(i=64;i<127;i+=i>95?-63:32)printf("%-5d%-6c%s",i,i,i>95?"\n":"| ");puts("127  DEL");}

Probieren Sie es online!

Semi-ungolfed:

i;
f() {
  for(;i++<37;) printf(i<4?"Dec  Chr%s":"-",i<3?"   | ":"\n");

  printf("\n32   Space | ");
  for(i=64;i<127;i+=i>95?-63:32) printf("%-5d%-6c%s",i,i,i>95?"\n":"| ");
  puts("127  DEL");
}

Ruby, 124 Bytes

 puts [["Dec  Chr   "]*3*"| ",?-*34,(0..31).map{|d|(1..3).map{|x|"%-5s%-6s"%[y=x*32+d,y<33?"Space":y>126?"DEL":y.chr]}*"| "}]

V , 151 150 148 136 135 130 129 125 Bytes

Dank @ nmjcman101 wurden 12 Byte für die Verwendung <C-v>g<C-a>für die Nummern anstelle von gespeichertline('.')

2 Byte gespart dank @DJMcMayhem zum Entfernen von Zeilen mit führenden Leerzeichen mit ÇÓ/dund durch dêEntfernen von zusätzlichen Leerzeichen und Neuanordnen von Elementen

Diese Antwort steht im Wettbewerb mit der V- Antwort von @ nmjcman101 (die verwendet :set ve=all). Aber jetzt habe ich einen Weg gefunden, diese zu entfernen A ^[und ein paar Bytes zu sparen, und wir sind auf einem ausgeglichenen Stand

iSpace 
¬!~Ó./&ò
iDELí^/31   
HlgGo| 63ÙkGld/Sp
$p/`
G$d/@
$p/64
G$d/S
$pÇÓ/d
/d
hdê/32
O34é-O!| !| !Ó!/Dec  Chr   

Probieren Sie es online!

Hexdump:

00000000: 6953 7061 6365 200a 1bac 217e d32e 2f26  iSpace ...!~../&
00000010: f20a 6944 454c 1bed 5e2f 3331 2020 200a  ..iDEL..^/31   .
00000020: 1648 6c67 0147 6f7c 201b 3633 d96b 1647  .Hlg.Go| .63.k.G
00000030: 6c64 2f53 700a 2470 2f60 0a16 4724 642f  ld/Sp.$p/`..G$d/
00000040: 400a 2470 2f36 340a 1647 2464 2f53 0a24  @.$p/64..G$d/S.$
00000050: 70c7 d32f 640a 2f64 0a68 64ea 2f33 320a  p../d./d.hd./32.
00000060: 4f1b 3334 e92d 4f21 7c20 217c 2021 1bd3  O.34.-O!| !| !..
00000070: 212f 4465 6320 2043 6872 2020 20         !/Dec  Chr 

Erklärung (unvollständig und veraltet)

Die Strategie hier ist, dass ich die Zeilennummern verwende, um die ASCII-Codepunkte zu erzeugen.

Hinweis: ^[ist 0x1b, ^VistC-v

Zuerst generieren wir alle Zeichen.

iSpace             " insert Space
^[¬!~              " insert every character between ! and ~

Der aktuelle Puffer sieht aus wie

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

Jetzt fügen wir eine neue Zeile zwischen diesen Zeichen ein

     Ó./&ò         " insert a newline before every character (:s/./&\r/g)

V , 130 120 99 Bytes

Club unter 100 Jahren. Ich bin nicht mehr davon überzeugt, dass dies :se ve=allder beste Weg ist. Es sind zusätzliche ... 11 Bytes, nur um die |'s zu schreiben ! Aber genau das habe ich.

Ich poste dies fast in Konkurrenz zu @KritixiLuthos Antwort :se ve=all, um einigen auszuweichen A <esc>. Ich bin nicht davon überzeugt, dass eine der beiden Methoden noch besser ist. Hoffentlich kann dies beide Parteien zum Golfen anregen und herausfinden, welche Methode den Ausschlag gibt.

Ich erwarte auch, dass @DJMcMayhem uns beide in die Hose macht

iSpace
¬!~Ó./&ò
iDELí^/31   
Hlg:se ve=all
12|êr|2ñ031j$x)PñHd)ÄÒ-Ä3RDec  Chr³ | /d
hdêÎ35|D

Probieren Sie es online!

Hexdump für die Neugierigen

00000000: 6953 7061 6365 0a1b ac21 7ed3 2e2f 26f2  iSpace...!~../&.
00000010: 0a69 4445 4c1b ed5e 2f33 3120 2020 0a16  .iDEL..^/31   ..
00000020: 486c 6701 3a73 6520 7665 3d61 6c6c 0a31  Hlg.:se ve=all.1
00000030: 327c 16ea 727c 32f1 3016 3331 6a24 7829  2|..r|2.0.31j$x)
00000040: 50f1 4864 29c4 d22d c433 5244 6563 2020  P.Hd)..-.3RDec  
00000050: 4368 72b3 207c 201b 2f64 0a68 64ea ce33  Chr. | ./d.hd..3
00000060: 357c 44                                  5|D

AWK , 200 Bytes

BEGIN{b="-----------";a="Dec  Chr   ";print a"|",a"|",a"\n-"b b b;for(a=31;a++<63;){printf"%-5d%-6s| %-5d%-6c| %-5d%-5s\n",a,a<33?"Space":sprintf("%c",a),a+32,a+32,a+64,a<63?sprintf("%c",a+64):"DEL"}}

Formatiert:

BEGIN {
  b="-----------"
  a="Dec  Chr   "
  print a"|",a"|",a"\n-"b b b
  for(a=31;a++<63;) {
    printf "%-5d%-6s| %-5d%-6c| %-5d%-5s\n",
      a,    a<33 ? "Space" : sprintf("%c", a),
      a+32, a+32,
      a+64, a<63 ? sprintf("%c", a+64) : "DEL"
  }
}

Probieren Sie es online!

C 188 Bytes

f(){i=31;printf("Dec Chr | Dec Chr | Dec Chr");printf("\n--------------------------");for(;i<63;i++)printf("\n%d%4c  | %d%4c  | %d%4c",(i+1),(i+1),(i+33),(i+33),(i+65),(i+65));puts("DEL");

Normalerweise sieht das so aus:

f()
{
    int  i=31;
    printf("Dec Chr | Dec Chr | Dec Chr");
    printf("\n--------------------------"); 
    for(;i<63;i++)  
      printf("\n%d%4c  | %d%4c  | %d%4c", (i+1),(i+1),(i+33),(i+33),  (i+65),(i+65));
    puts("DEL");
}

C (249 Bytes)

Zeilenumbrüche zur Verdeutlichung hinzugefügt.

#define L(s,e)for(i=s;i<e;++i)
#define P printf
main(i){L(0,3)P("Dec  Chr  %s",i<2?" | ":"\n");
L(0,34)P("-");P("\n");L(32,64){P("%-5d", i);
i==32?P("Space"):P("%-5c",i);
P(" | %-5d%-5c | %-5d ",i+32,i+32,i+64);
i==63?P("DEL"):P("%-5c",i+64);P("\n");}}

Java, 434 422 321 Bytes

class A{public static void main(String[]a){
    int k=1,r,s=32;
    for(;k<4;k++)
        o("Dec   Chr  ",k);
    for(;k<37;k++)                                                                              
        o("-",k==36?3:4);
    for(k=r=s;!(k==64&&r==-63);r=k>95?-63:s,k+=r)
        o(k+"   "+((k>99)?"":" ")+(k==s?"Space":k==127?"DEL  ":((char)k+"    ")),k/s);
    }
    static void o(String s,int j){
        System.out.print(s+(j==4?"":j==3?"\n":"|"));
    }
}

Java ist wahrscheinlich nicht die beste Sprache dafür, da es den Overhead von Klassen und Hauptmethoden gibt ...

Sie können die Hauptmethode mithilfe einer statischen Deklaration entfernen und so die Anzahl der Bytes weiter verringern:

class A{
    static{...}

Dies führt jedoch zu einem Fehler (nachdem er ansonsten erfolgreich ausgeführt wurde):

Exception in thread "main" java.lang.NoSuchMethodException: A.main([Ljava.lang.String;)
    at java.lang.Class.getMethod(Class.java:1786)
    ...

Die Byteanzahl enthält Zeilenumbrüche oder Einrückungen.

Tcl , 233 Bytes

lassign {"Dec  Chr" "   | " 31} h S i
set H $h$S$h$S$h\n[string repe - 34]
proc p x {format %-5d%c $x $x}
time {set H "$H
[p [incr i]]  $S[p [expr $i+32]]  $S[p [expr $i+64]]"} 32
puts [regsub {\ {8}} [regsub \177 $H DEL] "   Space"]

Probieren Sie es online!

R , 235 228 221 212 Bytes

y=apply(rbind(rep("Dec  Chr  ",3),1,matrix(sapply(1:96,function(i)paste(i+31,rep(" ",i<69),"if"(i<2,"Space","if"(i>95,"DEL",intToUtf8(c(i+31,rep(32,4))))))),nrow=32)),1,paste,collapse=" | ")
y[2]=strrep("-",34)
y

Probieren Sie es online!

Ich versuchte wirklich schwer unter 200 Bytes zu erhalten , aber diese pasteund collapsemich töten. Gibt eine Liste von Zeilen zurück.

JavaScript (ES6), 258 Byte

a="Dec  Chr   | ".repeat(2)+"Dec  Chr\n"+"-".repeat(34);for(b=32;64>b;b++)a+="\n"+b+"   "+(32==b?"Space  ":String.fromCharCode(b)+"      ")+"| "+(b+32)+"   "+String.fromCharCode(b+32)+"     | "+(b+64)+(35<b?"  ":"   ")+(63==b?"DEL":String.fromCharCode(b+64))

console.log(a)

Power Shell , 159 Byte

,'Dec  Chr'*3-join'   | '
'-'*34
32..63|%{($_,($_+32),($_+64)|%{"$_".PadRight(5)+"$(([char]$_,('Space','DEL')[$_-ne32])[$_-in32,127])".padRight(5)})-join' | '}

Probieren Sie es online!

In den ersten beiden Zeilen werden nur Literalzeichenfolgen erstellt und in der Pipeline belassen. Der erste verwendet den Komma-Operator, , um ein Array zu erstellen, und -joinfügt dieses Array dann zusammen, um die Header zu erstellen. Die zweite ist nur eine gerade String-Multiplikation.

Die dritte Zeile Schleifen über 32..63und jede Iteration sendet drei Werte $_, ($_+32)und ($_+64)in eine innere Schleife. Die innere Schleife PadRightfügt dem Wert ein (fügt die entsprechenden Leerzeichen hinzu, um die 5Zeichen aufzufüllen ). Das ist dann eine Kette, die +mit dem Ergebnis eines verschachtelten Pseudoternärs verkettet ist ( )[ ]. Der Pseudoternäre wählt entweder die charDarstellung dieser Zahl Spaceoder, DELfalls es sich um den entsprechenden Wert handelt. Auch hier haben wir PadRightdie passenden Charaktere.

Diese drei Zeichenketten (zum Beispiel 32 Space, 64 @, 96 `) sind in der Pars gekapselt und -joined mit den Spalten Marker in einem einzigen String. Jede dieser 32 Zeichenfolgen verbleibt dann in der Pipeline. Am Ende der Ausführung Write-Outputfügt ein Impliziter eine neue Zeile zwischen die Elemente in der Pipeline ein, sodass wir diese kostenlos erhalten.

Perl, 165 155 Bytes

$s='Dec  Chr   ';$_=join"\n",("$s| $s| $s","-"x34,map{join"| ",map{sprintf'%1$-5d%1$-6c',$_}($_,$_+32,$_+64)}32..63);s/ {8}/   Space/;s/\x7f.*/DEL\n/;print

Python 2, 1564 218 Bytes

Mein erstes Golf, entschuldige offensichtliche Fehler

print("Dec  Chr   | "*3)[:-2]+"\n"+"-"*34+"\n32   Space | 64   @     | 96   `"
for n in range(33,63):print"| ".join([str(n+x).ljust(5)+chr(n+x).ljust(6)for x in [0,32,64]])
print"63   ?     | 95   _     | 127  DEL"

Probieren Sie es online!

Falls Sie sich fragen, war die erste Version eine Base64-codierte Zeichenfolge.

05AB1E , 82 76 Bytes

žQSDÇƵQ¸«.Bs𔇲”:"DEL"¸«.B)øvyð2×ý})3äøvy… | ©ý}®”†…  Chr  ÿ”3ר¨'-34×.Á.Á»

Probieren Sie es online!

Beim Golfen kann man noch viel verbessern.

žQSDÇƵQ¸«.Bs𔇲”:"DEL"¸«.B)ø schiebt gepolsterte Zahlen mit Textäquivalent:

[['32 ', 'Space'], ['33 ', '!    '], ['34 ', '"    '], ['35 ', '#    '], ['36 ', '$    '], ['37 ', '%    '], ['38 ', '&    '], ['39 ', "'    "], ['40 ', '(    '], ['41 ', ')    '], ['42 ', '*    '], ['43 ', '+    '], ['44 ', ',    '], ['45 ', '-    '], ['46 ', '.    '], ['47 ', '/    '], ['48 ', '0    '], ['49 ', '1    '], ['50 ', '2    '], ['51 ', '3    '], ['52 ', '4    '], ['53 ', '5    '], ['54 ', '6    '], ['55 ', '7    '], ['56 ', '8    '], ['57 ', '9    '], ['58 ', ':    '], ['59 ', ';    '], ['60 ', '<    '], ['61 ', '=    '], ['62 ', '>    '], ['63 ', '?    '], ['64 ', '@    '], ['65 ', 'A    '], ['66 ', 'B    '], ['67 ', 'C    '], ['68 ', 'D    '], ['69 ', 'E    '], ['70 ', 'F    '], ['71 ', 'G    '], ['72 ', 'H    '], ['73 ', 'I    '], ['74 ', 'J    '], ['75 ', 'K    '], ['76 ', 'L    '], ['77 ', 'M    '], ['78 ', 'N    '], ['79 ', 'O    '], ['80 ', 'P    '], ['81 ', 'Q    '], ['82 ', 'R    '], ['83 ', 'S    '], ['84 ', 'T    '], ['85 ', 'U    '], ['86 ', 'V    '], ['87 ', 'W    '], ['88 ', 'X    '], ['89 ', 'Y    '], ['90 ', 'Z    '], ['91 ', '[    '], ['92 ', '\\    '], ['93 ', ']    '], ['94 ', '^    '], ['95 ', '_    '], ['96 ', '`    '], ['97 ', 'a    '], ['98 ', 'b    '], ['99 ', 'c    '], ['100', 'd    '], ['101', 'e    '], ['102', 'f    '], ['103', 'g    '], ['104', 'h    '], ['105', 'i    '], ['106', 'j    '], ['107', 'k    '], ['108', 'l    '], ['109', 'm    '], ['110', 'n    '], ['111', 'o    '], ['112', 'p    '], ['113', 'q    '], ['114', 'r    '], ['115', 's    '], ['116', 't    '], ['117', 'u    '], ['118', 'v    '], ['119', 'w    '], ['120', 'x    '], ['121', 'y    '], ['122', 'z    '], ['123', '{    '], ['124', '|    '], ['125', '}    '], ['126', '~    '], ['127', 'DEL  ']]

vyð2×ý})3äøvy… | ©ý} verbindet sie zusammen in den Tisch:

['32   Space | 64   @     | 96   `    ', '33   !     | 65   A     | 97   a    ', '34   "     | 66   B     | 98   b    ', '35   #     | 67   C     | 99   c    ', '36   $     | 68   D     | 100  d    ', '37   %     | 69   E     | 101  e    ', '38   &     | 70   F     | 102  f    ', "39   '     | 71   G     | 103  g    ", '40   (     | 72   H     | 104  h    ', '41   )     | 73   I     | 105  i    ', '42   *     | 74   J     | 106  j    ', '43   +     | 75   K     | 107  k    ', '44   ,     | 76   L     | 108  l    ', '45   -     | 77   M     | 109  m    ', '46   .     | 78   N     | 110  n    ', '47   /     | 79   O     | 111  o    ', '48   0     | 80   P     | 112  p    ', '49   1     | 81   Q     | 113  q    ', '50   2     | 82   R     | 114  r    ', '51   3     | 83   S     | 115  s    ', '52   4     | 84   T     | 116  t    ', '53   5     | 85   U     | 117  u    ', '54   6     | 86   V     | 118  v    ', '55   7     | 87   W     | 119  w    ', '56   8     | 88   X     | 120  x    ', '57   9     | 89   Y     | 121  y    ', '58   :     | 90   Z     | 122  z    ', '59   ;     | 91   [     | 123  {    ', '60   <     | 92   \\     | 124  |    ', '61   =     | 93   ]     | 125  }    ', '62   >     | 94   ^     | 126  ~    ', '63   ?     | 95   _     | 127  DEL  ']

®”†… Chr ÿ”3ר¨'-34×.Á.Á» kümmert sich um den Header-Teil der Tabelle:

Dec  Chr   | Dec  Chr   | Dec  Chr   
----------------------------------
32   Space | 64   @     | 96   `    
33   !     | 65   A     | 97   a    
34   "     | 66   B     | 98   b    
35   #     | 67   C     | 99   c    
36   $     | 68   D     | 100  d    
37   %     | 69   E     | 101  e    
38   &     | 70   F     | 102  f    
39   '     | 71   G     | 103  g    
40   (     | 72   H     | 104  h    
41   )     | 73   I     | 105  i    
42   *     | 74   J     | 106  j    
43   +     | 75   K     | 107  k    
44   ,     | 76   L     | 108  l    
45   -     | 77   M     | 109  m    
46   .     | 78   N     | 110  n    
47   /     | 79   O     | 111  o    
48   0     | 80   P     | 112  p    
49   1     | 81   Q     | 113  q    
50   2     | 82   R     | 114  r    
51   3     | 83   S     | 115  s    
52   4     | 84   T     | 116  t    
53   5     | 85   U     | 117  u    
54   6     | 86   V     | 118  v    
55   7     | 87   W     | 119  w    
56   8     | 88   X     | 120  x    
57   9     | 89   Y     | 121  y    
58   :     | 90   Z     | 122  z    
59   ;     | 91   [     | 123  {    
60   <     | 92   \     | 124  |    
61   =     | 93   ]     | 125  }    
62   >     | 94   ^     | 126  ~    
63   ?     | 95   _     | 127  DEL  

PHP, 163 149 147 Bytes

<?=($p=str_pad)(D,31,"ec Chr   | D"),$p("
",32,"-");whhile($i<96)printf("%s%-4d%-6s",$i%3?"| ":"
",$o=$i%3*32+32+$i/3,$i++?$i<96?chr($o):DEL:Space);

Nervenzusammenbruch

                        # print header
<?=($p=str_pad)(D,31,"ec Chr   | D"),$p("\n",32,"-");
while($i<96)            # loop $i from 0 to 96
    printf("%s%-4d%-6s",    # print formatted:
                            # string, 4 space decimal leftbound, 6 space string leftbound
        $i%3?"| ":"\n",                 # linebreak for 1st column, pipe+space else
        $o=$i%3*32+32+$i/3,             # ($i mapped to) ASCII value
        $i++?$i<96?chr($o):DEL:Space    # character
    );

Die Verwendung von %-Nist das Byte wert, das rechtsseitige Zahlen und Zeichen sparen würden.

Stax , 53 Bytes

éV ►Γ┐º╬¼1N_◄╒0└♀α→┴♂┐Y♣╟n»┤3°k⌡{═╥I⌂╜<─W}íè7Y♠Σ▲ÿb#√

Führen Sie es aus und debuggen Sie es

T-SQL, 242 Bytes

DECLARE @ INT=32PRINT'Dec  Chr   | Dec  Chr   | Dec  Chr
'+REPLICATE('-',34)L:PRINT CONCAT(@,'   ',IIF(@=32,'Space | ',CHAR(@)+'     | '),@+32,'   ',CHAR(@+32),'     | ',@+64,SPACE(5-LEN(@+64)),IIF(@=63,'DEL',CHAR(@+64)))SET @+=1IF @<64GOTO L

Formatiert:

DECLARE @ INT=32
PRINT'Dec  Chr   | Dec  Chr   | Dec  Chr
' + REPLICATE('-',34)
L:
    PRINT CONCAT(@,'   ',IIF(@=32,'Space | ',CHAR(@)+'     | ')
                ,@+32,'   ',CHAR(@+32),'     | ',
                 @+64,SPACE(5-LEN(@+64)),IIF(@=63,'DEL',CHAR(@+64)))
    SET @+=1
IF @<64 GOTO L

Ich habe ein paar Variationen ausprobiert, einschließlich des Ersetzens verschiedener allgemeiner Zeichenfolgen durch andere Variablen, aber dies war die kürzeste Version, die ich gefunden habe.

Python 3 , 154 Bytes

for l in[['Dec  Chr  ']*3,['-'*35]]+[[f"{x:<5}{['Space',chr(x),'DEL'][(x>32)+(x>126)]:5}"for x in(c,c+32,c+64)]for c in range(32,64)]:print(' | '.join(l))

Probieren Sie es online!

Attache , 144 Bytes

(p:=PadRight)["",37,"Dec  Chr   | "]'(34*"-")'(Join&"| "=>Tr@ChopInto&3<|{p&11<|p&5@Repr@_+(<~32->$Space,127->$DEL~>@_or Char!_)}=>32:127)|Print

Probieren Sie es online!