Schreiben Sie in einer Programmiersprache Ihrer Wahl 95 Programme, von denen jedes ein anderes der 95 druckbaren ASCII-Zeichen ausgibt, ohne dass dieses Zeichen irgendwo im Programm vorkommt .

Wenn Ihre Sprache beispielsweise Python war , Pkönnte es sein , dass Ihr Programm das Zeichen ausgibt

print(chr(80))

weil Phat ASCII-Code 80. Dieses Programm ist gültig, weil Pnie im Quellcode erscheint. Allerdings für das Programm, das Kleinbuchstaben ausgibt p, so etwas wie

print(chr(112))

wäre ungültig , weil, während es gedruckt wird p, pin dem Code. Ein gültiges Programm könnte sein

exec(chr(112)+'rint(chr(112))')

was druckt paber nicht enthält p.

Ihr Ziel ist es, jedes Ihrer 95 Programme so kurz wie möglich zu halten. Ihre Punktzahl ist die Summe der Zeichenlängen aller Ihrer Programme.

Wenn Sie aus irgendeinem Grund keine gültigen Programme für bestimmte Zeichen schreiben können, können Sie diese Zeichen als "Nicht programmiert" oder " DNP " markieren und Programme für diese Zeichen vollständig weglassen. Auf diese Weise können syntaktisch strenge Sprachen miteinander konkurrieren.

Der Gewinn Antwort ist die Antwort , die die niedrigste Punktzahl hat von der Menge der Antworten , die die wenigsten DNP sind haben.

Regeln

• Der Quellcode aller Ihrer Programme enthält möglicherweise nur druckbare ASCII-Zeichen sowie Tabulatoren und Zeilenumbrüche, die alle als ein Zeichen gezählt werden. (Weil es in einer anderen Kodierung leicht sein würde, nicht existierende Zeichen wegzulassen!)

  • Hinweis: Diese Regel scheint notwendig zu sein, aber es gibt viele Sprachen mit unterschiedlichen Codierungen, und ich bin sicher, es wäre cool, die Antworten für sie zu sehen. Daher können Sie diese Regel brechen , Sie können beliebige Zeichen verwenden, aber dann wird Ihre Antwort nicht wettbewerbsfähig , es kann nicht gewinnen.

• Die Programme müssen aktuelle, vollständige Programme sein , die den Standardkonventionen Ihrer Sprache entsprechen. Funktionen und REPL- Snippets sind nicht erlaubt.

• Die Ausgabe jedes Programms sollte auf stdout oder die von Ihrer Sprache akzeptierte Alternative gehen.

• Programme sollten nicht zur Eingabe auffordern oder Eingaben erfordern. (Wenn die Aufforderung zur Eingabe Ihrer Sprache inhärent ist, ist dies in Ordnung.)

• Programme sollten deterministisch, endlich in der Laufzeit und unabhängig sein. zB sollte es egal sein, ob man in einem Ordner läuft, der von den anderen Programmen getrennt ist.

• Die Ausgabe eines Programms sollte das genaue druckbare ASCII-Zeichen sein, dem es entspricht, optional gefolgt von einer einzelnen nachgestellten Zeile, nicht mehr und nicht weniger.

Stellen Sie sicher, dass Sie in Ihrer Antwort Informationen zu allen 95 (im Idealfall) Programmen sowie Ihre Punktzahl und alle DNPs angeben. Sie müssen nicht Liste alle Programme , die ein einfaches Muster wie „folgen print(chr(80)), print(chr(81)), print(chr(82))...“ , aber stellen Sie sicher , dass Sie sicher sind , dass sie alle würde funktionieren und dass Ihre Gäste richtig hinzugefügt wird .

Als Referenz sind hier die 95 druckbaren ASCII-Zeichen aufgeführt, die Ihre Programme ausgeben müssen:

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

Python 2, 1075 1065 1043 1040 1039 Bytes

Jedes Programm hat die Form print'\<octal char code>', außer:

• ' → print"\47"
• 0durch 8→print~-<N+1>
• 9 → print-~8
• \ → print'%c'%92
• i → exec'pr\151nt"\151"'
• n → exec'pri\156t"\156"'
• p → exec'\160rint"\160"'
• r → exec'p\162int"\162"'
• t → exec'prin\164"\164"'

Nachfolgend finden Sie die vollständige Liste der Programme, die nach Zeilenumbrüchen getrennt sind.

print'\40'
print'\41'
print'\42'
print'\43'
print'\44'
print'\45'
print'\46'
print"\47"
print'\50'
print'\51'
print'\52'
print'\53'
print'\54'
print'\55'
print'\56'
print'\57'
print~-1
print~-2
print~-3
print~-4
print~-5
print~-6
print~-7
print~-8
print~-9
print-~8
print'\72'
print'\73'
print'\74'
print'\75'
print'\76'
print'\77'
print'\100'
print'\101'
print'\102'
print'\103'
print'\104'
print'\105'
print'\106'
print'\107'
print'\110'
print'\111'
print'\112'
print'\113'
print'\114'
print'\115'
print'\116'
print'\117'
print'\120'
print'\121'
print'\122'
print'\123'
print'\124'
print'\125'
print'\126'
print'\127'
print'\130'
print'\131'
print'\132'
print'\133'
print'%c'%92
print'\135'
print'\136'
print'\137'
print'\140'
print'\141'
print'\142'
print'\143'
print'\144'
print'\145'
print'\146'
print'\147'
print'\150'
exec'pr\151nt"\151"'
print'\152'
print'\153'
print'\154'
print'\155'
exec'pri\156t"\156"'
print'\157'
exec'\160rint"\160"'
print'\161'
exec'p\162int"\162"'
print'\163'
exec'prin\164"\164"'
print'\165'
print'\166'
print'\167'
print'\170'
print'\171'
print'\172'
print'\173'
print'\174'
print'\175'
print'\176'

Zu testen:

$ python printables.py | sed ':a;N;$!ba;s/\n//g'
 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~

-1 Bytes dank @ Sp3000!

CJam, 269 Bytes

Jedes der Programme ist in der Form mit '<char - 1>)Ausnahme von:

• Leerzeichen => S, 1 Byte
• '=> 39c3 Bytes
• )=> '*(3 Bytes
• 0=> T1 Byte
• 1=> X1 Byte
• 2=> Y1 Byte
• 3=> Z1 Byte
• 4- 9=> <num-1>)2 Bytes

Punktzahl ist: 3 * 82 + 1 + 3 + 3 + 4 * 1 + 6 * 2 = 269

ASCII-eingeschränkter x86-Maschinencode für DOS, 3104 3101 2913 Bytes

Nun ... Es ist kürzer als Java, denke ich ...

32 30 Byte für fast alle Zeichen, Ausnahmen siehe unten.

Meistens folgt es einfach dem Muster:

1. Tun Sie etwas xor, um einen Zeiger auf das Ende zu bekommen.
2. subaus den letzten 2 Wörtern, da der Opcode für intnicht in ASCII ist.
3. Holen Sie sich 2 in AHund der Charakter in DL. Beide werden xorausgegeben, weil das Zeichen selbst nicht im Programm angezeigt werden kann und 2 kein druckbares ASCII-Zeichen ist.
4. Drucken Sie das Zeichen mit int 21h
5. Beenden Sie mit int 20h

Wenn ein Zeichen nicht erlaubt ist, kann es die meiste Zeit ersetzt werden, indem entweder ein wenig an den Daten herumgedreht wird oder in ein anderes Register gewechselt wird.

Interessanter wird es, wenn Sie plötzlich nicht mehr in der Lage sind, das einzige für Berechnungen verwendbare Register zu subtrahieren oder zu pushen oder zu platzen ...

char  code
      hX'X5B&P[hT!^)7CC)7VX5t#PZ!C!B
!     hX'X5B&P[hS ^)7CC)7VX5r"PZ B A
"     hX'X5B&P[hS!^)7CC)7VX5q#PZ C B
#     hX'X5B&P[hS ^)7CC)7VX5p"PZ B A
$     hX'X5B&P[hS ^)7CC)7VX5w"PZ B A
%     hX'X5B&P[hS ^)7CC)7VX5v"PZ B A
&     hX#X5B"P[hS ^)7CC)7VX5u"PZ B A
'     hX#X5B"P[hS ^)7CC)7VX5t"PZ B A
(     hX'X5B&P[hS ^)7CC)7VX5{"PZ B A
)     hi'X5B&P[h!!X%BBHP^$!P_17C!?C17C!?hiBX5@@PZ2@2A
*     hX'X5B&P[hS ^)7CC)7VX5y"PZ B A
+     hX'X5B&P[hS ^)7CC)7VX5x"PZ B A
,     hX'X5B&P[hT ^)7CC)7VX5x"PZ!B!A
-     hX'X5B&P[hS ^)7CC)7VX5~"PZ B A
.     hX'X5B&P[hS ^)7CC)7VX5}"PZ B A
/     hX'X5B&P[hS ^)7CC)7VX5|"PZ B A
0     hX'X5B&P[hS ^)7CC)7VX5c"PZ B A
1     hX'X5B&P[hS ^)7CC)7VX5b"PZ B A
2     hX'X5B&P[hS ^)7CC)7VX5a"PZ B A
3     hX'X5B&P[hS ^)7CC)7VX5`"PZ B A
4     hX'X5B&P[hS ^)7CC)7VX5g"PZ B A
5     h;'X%[AP[h=S^)7CC)7VX%7"PZ _ ^
6     hX'X5B&P[hS ^)7CC)7VX5e"PZ B A
7     hX'X5B&P[hS _)?CC)?WX5d"PZ B A
8     hX'X5B&P[hS ^)7CC)7VX5k"PZ B A
9     hX'X5B&P[hS ^)7CC)7VX5j"PZ B A
:     hX'X5B&P[hS ^)7CC)7VX5i"PZ B A
;     hX'X5B&P[hS ^)7CC)7VX5h"PZ B A
<     hX'X5B&P[hS ^)7CC)7VX5o"PZ B A
=     hX'X5B&P[hS ^)7CC)7VX5n"PZ B A
>     hX'X5B&P[hS ^)7CC)7VX5m"PZ B A
?     hX'X5B&P[hS ^)7CC)7VX5l"PZ B A

@     hX'X5B&P[h` ^)7CC)7VX5 "PZ-B-A
A     hX'X5B&P[h`!^)7CC)7VX5!#PZ-C-B
B     h['X5A&P[h`"^)7CC)7VX5" PZ-D-C
C     hX'X5B&P_h` ^)5GG)5VX5#"PZ-B-A
D     hX'X5B&P[h` ^)7CC)7VX5$"PZ-B-A
E     hX'X5B&P[h` ^)7CC)7VX5%"PZ-B-A
F     hX'X5B&P[h` ^)7CC)7VX5&"PZ-B-A
G     hX'X5B&P[h` ^)7CC)7VX5'"PZ-B-A
H     hX'X5B&P[h` ^)7CC)7VX5("PZ-B-A
I     hX'X5B&P[h` ^)7CC)7VX5)"PZ-B-A
J     hX'X5B&P[h` ^)7CC)7VX5*"PZ-B-A
K     hX'X5B&P[h` ^)7CC)7VX5+"PZ-B-A
L     hX'X5B&P[h` ^)7CC)7VX5,"PZ-B-A
M     hX'X5B&P[h` ^)7CC)7VX5-"PZ-B-A
N     hX'X5B&P[h` ^)7CC)7VX5."PZ-B-A
O     hX'X5B&P[h` ^)7CC)7VX5/"PZ-B-A
P     hj'X5B&`[[[[[[[[h` ^)7CC)7VX50"`ZZZZZZZZ-B-A
Q     hX'X5B&P[h` ^)7CC)7VX51"PZ-B-A
R     hX'X5B&P[h` ^)7CC)7VX52"PZ-B-A
S     hX'X5B&P[h` ^)7CC)7VX53"PZ-B-A
T     hX'X5B&P[h` ^)7CC)7VX54"PZ-B-A
U     hX'X5B&P[h` ^)7CC)7VX55"PZ-B-A
V     hX'X5B&P[h` _)?CC)?WX56"PZ B A
W     hX'X5B&P[h` ^)7CC)7VX57"PZ-B-A
X     _TYhe'WWWQWWWa5B&P[hSS^)7CC)7CC5_C5 @PZ u t
Y     hX'X5B&P[h` ^)7CC)7VX59"PZ-B-A
Z     _WTYhzBX5 @Phe'WPWQWWWa5B&P[hSS^)7CC)7X u t
[     hX'X5B&P_h` ^)5GG)5VX5;"PZ-B-A
\     hX'X5B&P[h` ^)7CC)7VX5<"PZ-B-A
]     hX'X5B&P[h` ^)7CC)7VX5="PZ-B-A
^     hX'X5B&P[h` _)?CC)?WX5>"PZ-B-A
_     hX'X5B&P[h` ^)7CC)7VX5?"PZ-B-A

`     hX'X5B&P[hS ^)7CC)7VX53"PZ B A
a     hX'X5B&P[hS ^)7CC)7VX52"PZ B A
b     hX'X5B&P[hS ^)7CC)7VX51"PZ B A
c     hX'X5B&P[hS ^)7CC)7VX50"PZ B A
d     hX'X5B&P[hS ^)7CC)7VX57"PZ B A
e     hX'X5B&P[hS ^)7CC)7VX56"PZ B A
f     hX'X5B&P[hS ^)7CC)7VX55"PZ B A
g     hX'X5B&P[hS ^)7CC)7VX54"PZ B A
h     _WWX5b'5B&P[WX5S P^)7CC)7VX5;"PZ B A
i     hX'X5B&P[hS ^)7CC)7VX5:"PZ B A
j     hX'X5B&P[hS ^)7CC)7VX59"PZ B A
k     hX'X5B&P[hS ^)7CC)7VX58"PZ B A
l     hX'X5B&P[hS ^)7CC)7VX5?"PZ B A
m     hX'X5B&P[hS ^)7CC)7VX5>"PZ B A
n     hX'X5B&P[hS ^)7CC)7VX5="PZ B A
o     hX'X5B&P[hS ^)7CC)7VX5<"PZ B A
p     hX'X5B&P[hS ^)7CC)7VX5#"PZ B A
q     hX'X5B&P[hS ^)7CC)7VX5""PZ B A
r     hX'X5B&P[hS ^)7CC)7VX5!"PZ B A
s     hX'X5B&P[hS ^)7CC)7VX5 "PZ B A
t     hX'X5B&P[hS ^)7CC)7VX5'"PZ B A
u     hX'X5B&P[hS ^)7CC)7VX5&"PZ B A
v     hX'X5B&P[hS ^)7CC)7VX5%"PZ B A
w     hX'X5B&P[hS ^)7CC)7VX5$"PZ B A
x     hX'X5B&P[hS ^)7CC)7VX5+"PZ B A
y     hX'X5B&P[hS ^)7CC)7VX5*"PZ B A
z     hX'X5B&P[hS ^)7CC)7VX5)"PZ B A
{     hX'X5B&P[hS ^)7CC)7VX5("PZ B A
|     hX'X5B&P[hS ^)7CC)7VX5/"PZ B A
}     hX'X5B&P[hS ^)7CC)7VX5."PZ B A
~     hX'X5B&P[hS ^)7CC)7VX5-"PZ B A

Brainfuck, 1770 1710 1703 1686 Bytes

60 Bytes von Dennis
gespeichert 17 Bytes von Sp3000 gespeichert

DNP: 46 ( .)

>-[-[-<]>>+<]>-.
>-[-[-<]>>+<]>.
>-[-[-<]>>+<]>+.
>-[++>+[<]>+]>.
+[->-[---<]>-]>.
>-[+<[-<]>>++]<.
>+[-->+[<]>-]>-.
>+[-->+[<]>-]>.
>+[-->+[<]>-]>+.
--[>+<++++++]>--.
--[>+<++++++]>-.
-----[[----<]>>-]<.
--[>+<++++++]>+.
+[+[+>]<<++++]>.
+[-[--<]>>--]<.
-[>+<-----]>---.
-[>+<-----]>--.
-[>+<-----]>-.
-[>+<-----]>.
-[>+<-----]>+.
-[>+<-----]>++.
-[>+<-----]>+++.
>-[++>+[+<]>]>-.
>-[++>+[+<]>]>.
>-[++>+[+<]>]>+.
>-[++[+<]>>+<]>.
>+[+[<]>->++]<.
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.
+[-[>+<<]>-]>--.
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.
+[-[>+<<]>-]>.
-[+[>+<<]>+]>.
>+[+[<]>>+<+]>.
--[++>+[<]>+]>.
+[->-[--<]>-]>.
+[->-[--<]>-]>+.
+[->-[--<]>-]>++.
-[+[>---<<]>+]>.
-[>+<-------]>--.
-[>+<-------]>-.
-[>+<-------]>.
-[>+<-------]>+.
-[>+<-------]>++.
>+[+<[-<]>>++]<.
>+++[[-<]>>--]<.
+[+[>>+<+<-]>]>.
-[+>++[++<]>]>-.
-[+>++[++<]>]>.
-[>+<---]>----.
-[>+<---]>---.
-[>+<---]>--.
-[>+<---]>-.
-[>+<---]>.
-[>+<---]>+.
-[>+<---]>++.
-[+[+<]>>+]<.
-[+[+<]>>+]<+.
-[+[+<]>>+]<++.
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.
+[->---[-<]>-]>.
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.
>-->+[+[+<]>>+]<.
>+[+[>+<+<]>]>-.
>+[+[>+<+<]>]>.
+[-[---<]>>-]<-.
+[-[---<]>>-]<.
>-[--[<]>+>-]<.
-[>++<-----]>--.
-[>++<-----]>-.
-[>++<-----]>.
-[>++<-----]>+.
+[->-[<]>--]>-.
+[->-[<]>--]>.
+[->-[<]>--]>+.
>+[++[++>]<<+]>.
>+[++[++>]<<+]>+.
+[->-[<]>+>--]>.
-[>--<-------]>.
>+[+>+[<]>->]<.
>+[+>+[<]>->]<+.
-[+>+++++[<]>+]>.
>+[-->++[<]>-]>.
+[->->-[<]>--]>.
+[->->-[-<]>-]>.
+[->>-[-<+<]>]>.
----[>+++++<--]>.
------[>+++<--]>.
>+[>+[<]>->+]<-.
>+[>+[<]>->+]<.
----[>+++<--]>.
--[>+<--]>----.
--[>+<--]>---.
--[>+<--]>--.
--[>+<--]>-.

Alle außer 43, 45, 60, 62, 91 und 93 werden schamlos von Esolangs.org gestohlen

MATL, 305, 302, 300, 297 Bytes

Jedes einzelne Programm sieht so aus:

33c
34c
35c
....

Ausser für

• Ziffern. Hier sind die Programme für 0-9:

  O
  l
  H
  I
  K
  4Q
  5Q
  6Q
  7Q
  8Q
  

• 'c'. Dieses Programm ist

  'C'k
  

• Platz. Das ist

  0c
  

  Seit heute habe ich gelernt, dass MATL das Zeichen 0 als Leerzeichen behandelt. Vielen Dank an LuisMendo!

Sie können matl.tio verwenden , um eine dieser Angaben zu überprüfen.

Als Referenz hier ist alles von ihnen:

0c
33c
34c
35c
36c
37c
38c
39c
40c
41c
42c
43c
44c
45c
46c
47c
O
l
H
I
K
4Q
5Q
6Q
7Q
8Q
58c
59c
60c
61c
62c
63c
64c
65c
66c
67c
68c
69c
70c
71c
72c
73c
74c
75c
76c
77c
78c
79c
80c
81c
82c
83c
84c
85c
86c
87c
88c
89c
90c
91c
92c
93c
94c
95c
96c
97c
98c
'C'k
100c
101c
102c
103c
104c
105c
106c
107c
108c
109c
110c
111c
112c
113c
114c
115c
116c
117c
118c
119c
120c
121c
122c
123c
124c
125c
126c

Java 8, 6798 6582 6577 Bytes

Seufzer

Dies ist im Grunde eine Portierung meiner Python 2-Antwort , aber mit all dem Boilerplate, das mit dem Schreiben eines vollständigen Programms in Java geliefert wird.

Jetzt ganz ohne DNPs! Danke, Kevin Cruijssen!

Die meisten Programme haben die Form interface A{static void main(String[]a){System.out.print("\<octal char code>");}}, außer:

• Leerzeichen → interface\tA{static\tvoid\tmain(String[]a){System.out.print("\40");}}(aber mit dem \ts durch rohe Tabulatoren ersetzt)
• " → interface A{static void main(String[]a){System.out.print('\42');}}
• ( → interface A{static void main\u0028String[]a){System.out.print\u0028"\50");}}
• ) → interface A{static void main(String[]a\u0029{System.out.print("\51"\u0029;}}
• . → interface A{static void main(String[]a){System\u002Eout\u002Eprint("\56");}}
• 0 → interface A{static void main(String[]a){System.out.print(1-1);}}
• 1 → interface A{static void main(String[]a){System.out.print(3-2);}}
• 2 → interface A{static void main(String[]a){System.out.print(3-1);}}
• 3 → interface A{static void main(String[]a){System.out.print(4-1);}}
• 4 → interface A{static void main(String[]a){System.out.print(5-1);}}
• 5 → interface A{static void main(String[]a){System.out.print(6-1);}}
• 6 → interface A{static void main(String[]a){System.out.print(7-1);}}
• 7 → interface A{static void main(String[]a){System.out.print(8-1);}}
• 8 → interface A{static void main(String[]a){System.out.print(9-1);}}
• 9 → interface A{static void main(String[]a){System.out.print(8+1);}}
• ; → interface A{static void main(String[]a){System.out.print("\73")\u003B}}
• A → interface B{static void main(String[]a){System.out.print("\101");}}
• S → interface A{static void main(\u0053tring[]a){\u0053ystem.out.print("\123");}}
• [ → interface A{static void main(String...a){System.out.print("\133");}}
• \ → interface A{static void main(String[]a){System.out.print((char)92);}}
• ] → interface A{static void main(String...a){System.out.print("\135");}}
• a → interf\u0061ce A{st\u0061tic void m\u0061in(String[]b){System.out.print("\141");}}
• c → interfa\u0063e A{stati\u0063 void main(String[]a){System.out.print("\143");}}
• d → interface A{static voi\u0064 main(String[]a){System.out.print("\144");}}
• e → class A{public static void main(String[]a){Syst\u0065m.out.print("\145");}}
• f → class A{public static void main(String[]a){System.out.print("\146");}}
• g → interface A{static void main(Strin\u0067[]a){System.out.print("\147");}}// \u0067
• i → \u0069nterface A{stat\u0069c vo\u0069d ma\u0069n(Str\u0069ng[]a){System.out.pr\u0069nt("\151");}}
• m → interface A{static void \u006Dain(String[]a){Syste\u006D.out.print("\155");}}
• n → class A{public static void mai\u006E(Stri\u006Eg[]a){System.out.pri\u006Et("\156");}}
• o → interface A{static v\u006Fid main(String[]a){System.\u006Fut.print("\157");}}
• p → interface A{static void main(String[]a){System.out.\u0070rint("\160");}}
• r → class A{public static void main(St\u0072ing[]a){System.out.p\u0072int("\162");}}
• s → interface A{\u0073tatic void main(String[]a){Sy\u0073tem.out.print("\163");}}
• t → class A{public s\u0074a\u0074ic void main(S\u0074ring[]a){Sys\u0074em.ou\u0074.prin\u0074("\164");}}
• u → interface A{static void main(String[]a){System.console().printf("%c",117);}}
• v → interface A{static \u0076oid main(String[]a){System.out.print("\166");}}
• y → interface A{static void main(String[]a){S\u0079stem.out.print("\171");}}
• { → interface A\u007Bstatic void main(String[]a)\u007BSystem.out.print("\173");}}
• } → interface A{static void main(String[]a){System.out.print("\175");\u007D\u007D

Puh

Der Java-Compiler verarbeitet Unicode-Escapezeichen wie \u007Bvor jeder anderen Verarbeitung, wodurch Code geschrieben werden kann, der Unicode-Escapezeichen in Bezeichnern und sogar in Schlüsselwörtern verwendet. Um ein Programm zu schreiben, das kein Zeichen auf dem Kesselschild verwendet, ersetzen wir es einfach durch Unicode-Escape.

Als Referenz und zur Vereinfachung des Testens finden Sie hier die vollständige Liste der Programme, die durch Zeilenumbrüche getrennt sind und deren unformatierte Tabulatoren durch vier Leerzeichen ersetzt sind:

interface    A{static    void    main(String[]a){System.out.print("\40");}}
interface A{static void main(String[]a){System.out.print("\41");}}
interface A{static void main(String[]a){System.out.print('\42');}}
interface A{static void main(String[]a){System.out.print("\43");}}
interface A{static void main(String[]a){System.out.print("\44");}}
interface A{static void main(String[]a){System.out.print("\45");}}
interface A{static void main(String[]a){System.out.print("\46");}}
interface A{static void main(String[]a){System.out.print("\47");}}
interface A{static void main\u0028String[]a){System.out.print\u0028"\50");}}
interface A{static void main(String[]a\u0029{System.out.print("\51"\u0029;}}
interface A{static void main(String[]a){System.out.print("\52");}}
interface A{static void main(String[]a){System.out.print("\53");}}
interface A{static void main(String[]a){System.out.print("\54");}}
interface A{static void main(String[]a){System.out.print("\55");}}
interface A{static void main(String[]a){System\u002Eout\u002Eprint("\56");}}
interface A{static void main(String[]a){System.out.print("\57");}}
interface A{static void main(String[]a){System.out.print(1-1);}}
interface A{static void main(String[]a){System.out.print(3-2);}}
interface A{static void main(String[]a){System.out.print(3-1);}}
interface A{static void main(String[]a){System.out.print(4-1);}}
interface A{static void main(String[]a){System.out.print(5-1);}}
interface A{static void main(String[]a){System.out.print(6-1);}}
interface A{static void main(String[]a){System.out.print(7-1);}}
interface A{static void main(String[]a){System.out.print(8-1);}}
interface A{static void main(String[]a){System.out.print(9-1);}}
interface A{static void main(String[]a){System.out.print(8+1);}}
interface A{static void main(String[]a){System.out.print("\72");}}
interface A{static void main(String[]a){System.out.print("\73")\u003B}}
interface A{static void main(String[]a){System.out.print("\74");}}
interface A{static void main(String[]a){System.out.print("\75");}}
interface A{static void main(String[]a){System.out.print("\76");}}
interface A{static void main(String[]a){System.out.print("\77");}}
interface A{static void main(String[]a){System.out.print("\100");}}
interface B{static void main(String[]a){System.out.print("\101");}}
interface A{static void main(String[]a){System.out.print("\102");}}
interface A{static void main(String[]a){System.out.print("\103");}}
interface A{static void main(String[]a){System.out.print("\104");}}
interface A{static void main(String[]a){System.out.print("\105");}}
interface A{static void main(String[]a){System.out.print("\106");}}
interface A{static void main(String[]a){System.out.print("\107");}}
interface A{static void main(String[]a){System.out.print("\110");}}
interface A{static void main(String[]a){System.out.print("\111");}}
interface A{static void main(String[]a){System.out.print("\112");}}
interface A{static void main(String[]a){System.out.print("\113");}}
interface A{static void main(String[]a){System.out.print("\114");}}
interface A{static void main(String[]a){System.out.print("\115");}}
interface A{static void main(String[]a){System.out.print("\116");}}
interface A{static void main(String[]a){System.out.print("\117");}}
interface A{static void main(String[]a){System.out.print("\120");}}
interface A{static void main(String[]a){System.out.print("\121");}}
interface A{static void main(String[]a){System.out.print("\122");}}
interface A{static void main(\u0053tring[]a){\u0053ystem.out.print("\123");}}
interface A{static void main(String[]a){System.out.print("\124");}}
interface A{static void main(String[]a){System.out.print("\125");}}
interface A{static void main(String[]a){System.out.print("\126");}}
interface A{static void main(String[]a){System.out.print("\127");}}
interface A{static void main(String[]a){System.out.print("\130");}}
interface A{static void main(String[]a){System.out.print("\131");}}
interface A{static void main(String[]a){System.out.print("\132");}}
interface A{static void main(String...a){System.out.print("\133");}}
interface A{static void main(String[]a){System.out.print((char)92);}}
interface A{static void main(String...a){System.out.print("\135");}}
interface A{static void main(String[]a){System.out.print("\136");}}
interface A{static void main(String[]a){System.out.print("\137");}}
interface A{static void main(String[]a){System.out.print("\140");}}
interf\u0061ce A{st\u0061tic void m\u0061in(String[]b){System.out.print("\141");}}
interface A{static void main(String[]a){System.out.print("\142");}}
interfa\u0063e A{stati\u0063 void main(String[]a){System.out.print("\143");}}
interface A{static voi\u0064 main(String[]a){System.out.print("\144");}}
class A{public static void main(String[]a){Syst\u0065m.out.print("\145");}}
class A{public static void main(String[]a){System.out.print("\146");}}
interface A{static void main(Strin\u0067[]a){System.out.print("\147");}}
interface A{static void main(String[]a){System.out.print("\150");}}
\u0069nterface A{stat\u0069c vo\u0069d ma\u0069n(Str\u0069ng[]a){System.out.pr\u0069nt("\151");}}
interface A{static void main(String[]a){System.out.print("\152");}}
interface A{static void main(String[]a){System.out.print("\153");}}
interface A{static void main(String[]a){System.out.print("\154");}}
interface A{static void \u006Dain(String[]a){Syste\u006D.out.print("\155");}}
class A{public static void mai\u006E(Stri\u006Eg[]a){System.out.print("\156");}}
interface A{static v\u006Fid main(String[]a){System.\u006Fut.print("\157");}}
interface A{static void main(String[]a){System.out.\u0070rint("\160");}}
interface A{static void main(String[]a){System.out.print("\161");}}
class A{public static void main(St\u0072ing[]a){System.out.p\u0072int("\162");}}
interface A{\u0073tatic void main(String[]a){Sy\u0073tem.out.print("\163");}}
class A{public s\u0074a\u0074ic void main(S\u0074ring[]a){Sys\u0074em.ou\u0074.prin\u0074("\164");}}
interface A{static void main(String[]a){System.console().printf("%c",117);}}
interface A{static \u0076oid main(String[]a){System.out.print("\166");}}
interface A{static void main(String[]a){System.out.print("\167");}}
interface A{static void main(String[]a){System.out.print("\170");}}
interface A{static void main(String[]a){S\u0079stem.out.print("\171");}}
interface A{static void main(String[]a){System.out.print("\172");}}
interface A\u007Bstatic void main(String[]a)\u007BSystem.out.print("\173");}}
interface A{static void main(String[]a){System.out.print("\174");}}
interface A{static void main(String[]a){System.out.print("\175");\u007D\u007D
interface A{static void main(String[]a){System.out.print("\176");}}

Beachten Sie, dass das Programm for uverwendet System.console(), das null zurückgibt (und somit den Code zum Auslösen von a veranlasst NullPointerException), wenn Sie es von einem anderen als dem systemeigenen Terminal Ihres Betriebssystems aus aufrufen ( cmdunter Windows und, wie ich annehme, bashunter Linux / OSX). .

Erstellen Sie zum Testen ein neues Verzeichnis und fügen Sie den obigen Code in eine Datei ein, die printablesin diesem Verzeichnis benannt ist. Führen Sie dann das folgende Bash-Skript aus:

#!/bin/bash
split -l 1 printables
for i in x*; do
  mkdir z$i
  mv $i z$i/A.java
done
mv zxbh/A.java zxbh/B.java
for i in zx*; do
  javac $i/[AB].java
  if ! java -cp $i A 2> /dev/null; then
    java -cp $i B
  fi
done
rm -r zx*

Das obige Skript legt jede Zeile von printablesin ein eigenes Verzeichnis, benennt sie alle A.java(mit Ausnahme der Datei, die gedruckt wird Aund in die umbenannt wird B.java), kompiliert jede Datei, führt sie aus und löscht dann die Beweise. Es sollte ungefähr zehn Sekunden dauern, bis die druckbaren ASCII-Zeichen in Ihrer Shell angezeigt werden.

Wenn Sie unter Windows arbeiten, führen Sie stattdessen die folgende Batch-Datei aus:

@echo off
setlocal enabledelayedexpansion
set i=0
for /F "tokens=*" %%L in (printables) do (
  set file=A.java
  if "%i%" == "33" (set file=B.java)
  echo %%L>"%file%"
  javac "%file%"
  java -cp . A
  if not errorlevel 0 (java -cp . B)
  set /A i=%i% + 1
)
del *.java
del *.class

Diese Batch-Datei verfolgt einen etwas anderen Ansatz. Anstatt die Zeilen vorab aufzuteilen, wird die Datei zeilenweise verarbeitet und jedes Programm nacheinander kompiliert und ausgeführt. Wieder löscht es die Beweise, nachdem es beendet ist.

Sparte unzählige Bytes + 1 DNP dank Kevin Cruijssen!

> <> , 443 437 Bytes

TIO Interpreter Link . Hier gibt es viele Muster:

• [num][num]*o;: Multiplikation zweier Zahlen, dann Ausgabe des Ergebnisses als Zeichen mit ound Anhalten mit ;. > <> Ziffern gehen bis zu 15, dh 0123456789abcdef.
  • Ebenso [num][num]-n;nimmt das die Differenz zweier Zahlen und gibt nstattdessen eine Zahl mit aus .

• '-o[invalid char]: > <> ist toroidal. Wenn der Befehlszeiger das Ende einer Zeile erreicht, springt er zum Anfang zurück. In diesem Fall wird der Code zweimal ausgeführt, d '-o[char]'-o[char]. H. Der erste '-o[char]'Teil schiebt drei Zeichen auf den Stapel, -berechnet 'o' - [char]und ogibt das Ergebnis als Zeichen aus. > <> Fehler [char]treten dann auf, wenn sie erreicht werden , entweder aufgrund eines nicht erkannten Befehls oder weil ein leerer Stapel abgelegt wurde.

  • Ebenso '-n[invalid char]was als Zahl ausgibt.
  • Ähnliches '[num][op]o[invalid char]gilt [op]für [num]on [char], erroring out on char. Zum Beispiel '2+oJAusgaben L, die zwei mehr als sind J.
  • ''s Code lautet stattdessen "-oHusing ".
  • -'s Code lautet stattdessen '%oBusing %.

• ln;: Länge des Stapels drücken, als num ausgeben, dann anhalten und geben 0. Ähnlich lln;für 1und 'ln;für 3.

• 4|n+: 4 |drücken , abprallen und weitere 4 drücken, addieren, dann 8als num ausgeben . Bounce das |nochmal ab und versuche fehlerfrei nnochmal auf einem leeren Stack auszuführen .
  • Ähnliches gilt 3|n*für 9.
  • Ähnliches gilt [num]|o*für @Qdy.
• '1-:00p: Das interessanteste für den oFall. Um zu vermeiden , verwenden oin unserem Code, müssen wir verwenden peine platzieren oin der codebox, dann starten Sie es. Die Initiale '1-:00p'setzt den Stapel so, dass er poben liegt, und 1-dekrementiert ihn in einen o. :dupliziert dies ound 00psetzt eins oauf (0, 0), wodurch die Codebox zu wird o1-:00p. Der Befehlszeiger wird erneut umgebrochen und der andere ausgegeben o. Das (0, 0) -Zeichen wird dann noch einige Male ersetzt, bevor das Programm endgültig fehlerfrei wird.

      '-oO
!     '-oN
"     '-oM
#     '-oL
$     '-oK
%     '-oJ
&     '-oI
'     "-oH
(     '-oG
)     '-oF
*     '-oE
+     '-oD
,     '-oC
-     '%oB
.     '-oA
/     '-o@
0     ln;
1     lln;
2     '-o=
3     'ln;
4     '-o;
5     61-n;
6     '-nh
7     '-ng
8     4|n+
9     3|n*
:     '1-o;
;     '6-oA
<     6a*o;
=     '2+o;
>     '3+o;
?     79*o;
@     8|o*
A     '-o.
B     '-o-
C     '-o,
D     '-o+
E     '-o*
F     '-o)
G     '-o(
H     89*o;
I     '1-oJ
J     '-o%
K     '-o$
L     '2+oJ
M     7b*o;
N     '-o!
O     '5+oJ
P     8a*o;
Q     9|o*
R     '8+oJ
S     '9+oJ
T     7c*o;
U     'b+oJ
V     'c+oJ
W     'd+oJ
X     8b*o;
Y     'f+oJ
Z     9a*o;
[     7d*o;
\     'c-oh
]     'b-oh
^     'a-oh
_     '9-oh
`     8c*o;
a     '7-oh
b     7e*o;
c     9b*o;
d     a|o*
e     '3-oh
f     '2-oh
g     '1-oh
h     '2-oj
i     8d*o;
j     '2+oh
k     '3+oh
l     9c*o;
m     '5+oh
n     ab*o;
o     '1-:00p
p     8e*o;
q     '3-ot
r     '2-ot
s     '1-ot
t     '1+os
u     9d*o;
v     '2+ot
w     '3+ot
x     ac*o;
y     b|o*
z     '6+ot
{     '7+ot
|     '8+ot
}     '9+ot
~     9e*o;

Dyalog APL , 527 522 Bytes

(Nicht konkurrierend, da APL nicht wirklich nur mit ASCII geschrieben werden kann)

Die meisten sind im Format nn⊃⎕AVoder nnn⊃⎕AVmit folgenden Ausnahmen:

⊃''     ⍝ space: extract one char from an empty string
⎕THIS   ⍝ hash: this namespace
⊃1↓⍕÷2  ⍝ period: the first char after stripping one char from 1÷2, i.e. 0.5
⊃⍬      ⍝ zero: extract one number from an empty numeric list
≢#      ⍝ one: tally the root namespace
⍴⍬⍬     ⍝ two: count two empty lists
⎕WX     ⍝ three: default "Window Expose" setting
×⍨2     ⍝ four: 2×2
6-1     ⍝ five: 6-1
!3      ⍝ six: 3!
6+1     ⍝ seven: 6+1
2*3     ⍝ eight: 2³
3*2     ⍝ nine: 3²
⊃⎕a     ⍝ A: first character (Dyalog system names are case insensitive)
2⊃⎕A    ⍝
⋮        ⍝  B-Y: n'th character
25⊃⎕A   ⍝
⊃⌽⎕A    ⍝ Z: last character

Hier ist die gesamte Liste:

⊃''
205⊃⎕AV
216⊃⎕AV
⎕THIS
62⊃⎕AV
13⊃⎕AV
219⊃⎕AV
14⊃⎕AV
186⊃⎕AV
249⊃⎕AV
181⊃⎕AV
170⊃⎕AV
195⊃⎕AV
169⊃⎕AV
⊃1↓⍕÷2
157⊃⎕AV
⊃⍬
≢#
⍴⍬ ⍬
⎕WX
×⍨2
6-1
!3
6+1
2*3
3*2
241⊃⎕AV
194⊃⎕AV
161⊃⎕AV
163⊃⎕AV
165⊃⎕AV
173⊃⎕AV
232⊃⎕AV
⊃⎕a
2⊃⎕A
3⊃⎕A
4⊃⎕A
5⊃⎕A
6⊃⎕A
7⊃⎕A
8⊃⎕A
9⊃⎕A
10⊃⎕A
11⊃⎕A
12⊃⎕A
13⊃⎕A
14⊃⎕A
15⊃⎕A
16⊃⎕A
17⊃⎕A
18⊃⎕A
19⊃⎕A
20⊃⎕A
21⊃⎕A
22⊃⎕A
23⊃⎕A
24⊃⎕A
25⊃⎕A
26⊃⎕A
156⊃⎕AV
159⊃⎕AV
250⊃⎕AV
236⊃⎕AV
17⊃⎕AV
238⊃⎕AV
18⊃⎕AV
19⊃⎕AV
20⊃⎕AV
21⊃⎕AV
22⊃⎕AV
23⊃⎕AV
24⊃⎕AV
25⊃⎕AV
26⊃⎕AV
27⊃⎕AV
28⊃⎕AV
29⊃⎕AV
30⊃⎕AV
31⊃⎕AV
32⊃⎕AV
33⊃⎕AV
34⊃⎕AV
35⊃⎕AV
36⊃⎕AV
37⊃⎕AV
38⊃⎕AV
39⊃⎕AV
40⊃⎕AV
41⊃⎕AV
42⊃⎕AV
43⊃⎕AV
124⊃⎕AV
193⊃⎕AV
126⊃⎕AV
176⊃⎕AV

Ruby, 869 Bytes

Für die 63 Zeichen @bis ~haben wir eine 10-Byte-Lösung:

$><<"\xxx"     (3 digit octal code)
$><<92.chr     (special case for \)

Für die meisten (21) Zeichen von spacebis ?haben wir eine 9-Byte-Lösung:

puts"\xx"     (2 digit octal code)

Es gibt noch elf Sonderfälle:

$><<34.chr    (10 bytes for ")
p$.           (3 bytes for 0)
p~-2          \
p~-3           \ (4 bytes for 1-8)
...            /
p~-9          /
p 1+8         (5 bytes for 9)

Insgesamt ergibt sich eine Punktzahl von 10 × 63 + 9 × 21 + 10 + 3 + 8 × 4 + 5 = 869.

WolframAlpha , 368 Bytes

Allgemeines Format:

u+<character code in hexadecimal>

Ausnahmen:

Character   Code
+           plus
0           1-1
1           0!
2           1+1
3           1+2
4           2+2
5           2+3
6           3!
7           3+4
8           4+4
9           4+5
u           U+75

Hier ist die vollständige Liste:

u+20
u+21
u+22
u+23
u+24
u+25
u+26
u+27
u+28
u+29
u+2A
plus
u+2C
u+2D
u+2E
u+2F
1-1
0!
1+1
1+2
2+2
2+3
3!
3+4
4+4
4+5
u+3A
u+3B
u+3C
u+3D
u+3E
u+3F
u+40
u+41
u+42
u+43
u+44
u+45
u+46
u+47
u+48
u+49
u+4A
u+4B
u+4C
u+4D
u+4E
u+4F
u+50
u+51
u+52
u+53
u+54
u+55
u+56
u+57
u+58
u+59
u+5A
u+5B
u+5C
u+5D
u+5E
u+5F
u+60
u+61
u+62
u+63
u+64
u+65
u+66
u+67
u+68
u+69
u+6A
u+6B
u+6C
u+6D
u+6E
u+6F
u+70
u+71
u+72
u+73
u+74
U+75
u+76
u+77
u+78
u+79
u+7A
u+7B
u+7C
u+7D
u+7E

PHP ( 891 680 674 Bytes, 2 0 DNP)

Edit: 203 Bytes dank jimmy23013 gespeichert und 2 DNP dank Mego implementiert

Diese Antwort missbraucht stark die Großzügigkeit von PHP. Die meisten Fälle haben eine der folgenden Formen (jeweils 7 Byte):

<?=Y^x;
<?=Z&e;
<?=V|Z;

PHP konvertiert die Buchstaben auf beiden Seiten des Operators in Zeichenfolgen, führt dann die entsprechende bitweise Operation durch, indem jede Zeichenfolge in ihren ASCII-Zeichenwert konvertiert wird, und konvertiert schließlich das Ergebnis zurück in ein Zeichen.

Im ersten Beispiel oben Y^xwird 89^78. Das Ergebnis ist 33, das dann als Zeichen an STDOUT gesendet wird !.

Ein Skript wurde geschrieben, um alle möglichen Kombinationen zu erzwingen. Die Ergebnisse finden Sie hier .

Ausnahmen:

;ist <?=Z^a?>(8 Bytes)
|ist <?='9'^E;(9 Bytes)

<und ?wäre normalerweise DNP aufgrund des erforderlichen Start-Tags, aber durch Verwendung des -rFlags kann Code ohne diese ausgeführt werden:

<ist echo Z^f;(9 Bytes)
?ist echo Z^e;(9 Bytes)
=ist echo Z^g;(9 Bytes)

Ergebnis:

(7 * 90) + 8 + 9 + 9 + 9 + 9 = 674 Bytes

Brachylog , 546.477 Bytes

Credits to Fatalize für den Code für @.

In der folgenden Liste ist das erste Zeichen das zu druckende Zeichen (zur einfachen Bezugnahme).

  @S
! @Ht
"@P: 2m
# @P: 3m
$ @P: 4m
% @P: 5 m
& @P: 6 m
'@P: 7m
(@P: 8 m
) @P: 9m
* @P: 10 m
+ @P: 11 m
, @H: 5m
- @P: 13 m
. @P: 14 m
/ @P: 15 m
0 1-
1 0+
2 1+
3 2+
4 3+
5 4+
6 5+
7 6+
8 7+
9 8+
: @ P @ 4bhbbbh
; @ P: 27 m
<@P: 28 m
= @P: 29 m
> @P: 30 m
? @ P: 31 m
@ "?": "A" ybh
A @ Zt @ u
B @ Ch @ u
C @ P: 35 m
D @ P: 36 m
E @ P: 37 m
F @ P: 38 m
G @ P: 39 m
H @ P: 40 m
Ich @P: 41m
J @ P: 42 m
K @ P: 43 m
L @ ​​P: 44 m
M @ P: 45 m
N @ P: 46 m
O @P: 47 m
P @ A: 15 m @ u
Q @P: 49 m
R @ P: 50 m
S @ P: 51 m
T @ P: 52 m
U @ Vt @ u
V @ P: 54 m
W @ Qt @ u
X @P: 56 m
Y @ Wt @ u
Z @ At @ u
[@P: 59m
\ @P: 60 m
] @P: 61 m
^ @P: 62m
_ @P: 63 m
`@P: 64m
A VH
b @Ch
c @Dbh
d @ A: 3 m
e @Vbh
f @ A: 5 m
g @ A: 6 m
h @ A: 7 m
i @ A: 8 m
j @ A: 9 m
k @ C: 7 m
L @ ​​C: 8m
m @ D @ 2ht
n @ A: 13 m
o @H: 4 m
p @ A: 15 m
q @Z: 9 m
r @Z: 8 m
s @Z: 7 m
t @Z: 6 m
u @Vt
v @Z: 4 m
w @Qt
x @Z: 2 m
y @Wt
z @At
{@P: 91 m
| @P: 92 m
} @Prbh
~ @Pt

Sie sind alle Prädikate und Zmüssen daher das Argument sein, um die Ausgabe zu erhalten: Probieren Sie es online aus!

Erläuterung

@P ist diese Zeichenfolge:

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

welches jedes druckbare ASCII enthält.

> <> 531 Bytes

Die Programme haben zwei Hauptformen:

##*o;
"chr-1"1+o;

Der erste ist für Zeichen mit Zeichencodes mit zwei Faktoren, die beide kleiner als 16 sind, der andere für die anderen Fälle. Die meisten Zahlen, für die ich die zweite Form verwende, haben viele gleichlange Lösungen, aber ich habe diese aus Gründen der Lesbarkeit gewählt.

Ausnahmen:

" b3*1+o; Would be "!"1+o; normally
0 11-n; n outputs as a number
1 22/n;
2-9 #1+n;
; ":"1+o* Ends in an error

Volle Liste:

! b3*o;
" b3*1+o;
# 57*o;
$ 66*o;
% "$"1+o;
& "%"1+o;
' d3*o;
( a4*o;
) "("1+o;
* ")"1+o;
+ ","1-o;
, b4*o;
- 95*o;
. "-"1+o;
/ "."1+o;
0 11-n;
1 22/n;
2 11+n;
3 21+n;
4 31+n;
5 41+n;
6 51+n;
7 61+n;
8 71+n;
9 81+n;
: "9"1+o;
; ":"1+o*
< a6*o;
= "<"1+o;
> "="1+o;
? 97*o;
@ 88*o;
A d5*o;
B b6*o;
C "B"1+o;
D "C"1+o;
E "D"1+o;
F a7*o;
G "F"1+o;
H 98*o;
I "H"1+o;
J "D"1+o;
K e5*o;
L "K"1+o;
M b7*o;
N d6*o;
O "D"1+o;
P a8*o;
Q 99*o;
R "Q"1+o;
S "R"1+o;
T c7*o;
U "T"1+o;
V "U"1+o;
W "V"1+o;
X b8*o;
Y "X"1+o;
Z a9*o;
[ c7*o;
\ "["1+o;
] "\"1+o;
^ "]"1+o;
_ "^"1+o;
` c8*o;
a "`"1+o;
b e7*o;
c b9*o;
d aa*o;
e "d"1+o;
f "e"1+o;
g "g"1+o;
h d8*o;
i e7*o;
j "i"1+o;
k "j"1+o;
l c9*o;
m "l"1+o;
n ba*o;
o DNP
p e8*o;
q "p"1+o;
r "q"1+o;
s "r"1+o;
t "s"1+o;
u c9*o;
v "u"1+o;
w "v"1+o;
x ca*o;
y bb*o;
z "y"1+o;
~ e9*o;

Hexagony , 376 373 Bytes, 1 DNP

Vielen Dank an FryAmTheEggman für die Einsparung von 3 Bytes.

Fast alle Programme haben die gleiche Form:

  P0;@
! P1;@
" P2;@
...
| Y2;@
} Y3;@
~ Y4;@

Es gibt jedoch einige Ausnahmen:

• ;Ohne Verwendung von ;1 DNP kann nicht gedruckt werden .
• Zum Ausdrucken @können wir @das Programm nicht beenden. Stattdessen verwenden wir entweder S2;:oder S3;%. Dies endet mit einem Division-durch-Null-Fehler, der jedoch in STDOUT nicht sichtbar ist. Das sind also noch vier Bytes.
• Es gibt einen Konflikt, für Uden es erforderlich wäre U3;@. Es gibt mehrere Möglichkeiten , dies zu beheben, einschließlich der Umstellung auf Klein, das heißt n9;@, oder mit Zunahme oder Abnahme, dh T);@oder V(;@. In jedem Fall sind es noch vier Bytes.
• Speicher Kanten initialisiert 0, und !druckt einen Integer - Wert, so können wir erhalten 0und 1mit !@und )!@jeweils Speichern 3 Bytes.

Wie die <letter><digit>;@Programme funktionieren: Das sechseckige Layout eines Programms der Form 1234ist immer

 1 2
3 4 .
 . .

Da keines der Programme Befehle enthält, die den Steuerungsfluss umleiten, handelt es sich lediglich um lineare Programme, die der Reihe nach ausgeführt werden.

In jedem Fall setzt der Buchstabe am Anfang des Codes die aktuelle Speicherkante auf ihren Zeichencode. Zum Beispiel im Programm P1;@, das Pdie Wertesätze 80. Dann multipliziert die Ziffer diesen Wert mit 10 und addiert sich selbst (dh die Ziffer wird an den aktuellen Wert angehängt). Das gibt 801im obigen Beispiel. Zum Schluss wird ;dieser Wert gedruckt, indem Sie modulo 256 als Byte-Wert verwenden. In diesem Fall wird 801 % 256 = 33und !gedruckt.

Leerzeichen , 1643 Bytes, 1 DNP

17 Byte für die Zeichen [33-63] und 18 Byte für die Zeichen [64-126]

In Whitespace ist dies unkompliziert, da druckbare Zeichen (außer Leerzeichen) sowieso keine Bedeutung haben:

[SPACE][SPACE][SPACE][TAB][SPACE][SPACE][SPACE][SPACE][TAB][LF]
[TAB][LF]
[SPACE][SPACE][LF]
[LF]
[LF]

Das obige Programm druckt ein '!' (100001b). Wechseln Sie [TAB][SPACE][SPACE][SPACE][SPACE][TAB]in der ersten Zeile zu einem beliebigen Zeichen. Es ist nicht möglich, ein Leerzeichen zu drucken, ohne ein Leerzeichen zu verwenden, da beim Drucken immer alles mit beginnt[TAB][LF][SPACE]

Retina , 712 Bytes, 2 DNPs

Dies war eine Zusammenarbeit mit FryAmTheEggman.

Es gibt verschiedene Klassen von Lösungen. Für die meisten Zeichen von Leerzeichen bis verwenden ^wir ein Programm der folgenden Form:

_
T`w`p

Das Zeichen in der zweiten Zeile durchläuft die Bereiche, _0-9A-Za-zwährend der Rest unverändert bleibt. Dadurch wird die leere Eingabe in dieses Zeichen umgewandelt und pan der entsprechenden Position durch das druckbare ASCII-Zeichen (dargestellt durch ) ersetzt. Jedes dieser Programme ist 8 Byte lang.

Innerhalb dieses Bereichs gibt es nur wenige Ausnahmen. Am wichtigsten ist, dass die Ziffern gekürzt werden können:

• 0: x(zählt die Anzahl von xs in der leeren Eingabe)
• 1:  (weehoo, leeres Programm; zählt die Anzahl der leeren Treffer in der leeren Eingabe)

• 2: Jetzt wandeln wir die Eingabe in ein einzelnes Zeichen um, bevor wir leere Zeichenfolgen zählen:

  
  1
  
  

• 3: das gleiche, aber wir machen die Eingabe in zwei Zeichen:

  
  11
  
  

• 4: Sie bekommen die Idee ...

  
  111
  
  

• 5 - 9: Handlungswechsel ... wir verwenden die Zeichenwiederholung, um zu vermeiden, dass die zweite Zeile länger wird:

  
  4$*
  
  

  ...

  
  8$*
  
  

Die andere Ausnahme ist Tein DNP: Wir glauben nicht, dass es möglich ist, ein nicht-stelliges Zeichen zu generieren, ohne dass es im Quellcode erscheint, wenn Transliterationsstufen nicht verwendet werden können.

Weiter zu den restlichen Zeichen. Zum Drucken verwenden _wir ein ähnliches Programm wie die oben beschriebene allgemeine Lösung:

0
T`0`w

Die Tatsache nutzen, wdie mit beginnt _.

Als nächstes `folgt der zweite DNP, da diese ebenfalls für Transliterationsstufen erforderlich sind.

Dann werden die meisten Kleinbuchstaben mit so etwas gedruckt (was gedruckt wird a):

_
T`w`l

Wieder wird das Zeichen in der zweiten Zeile durchlaufen _0-9A-O. Hier brauchen wir nur zu achten lund w, was wir mit den folgenden Programmen drucken können, jeweils:

P
T`p`w

6
T`p`l

Schließlich sind nur {|}~noch 9 Bytes erforderlich. Hier verwenden wir die Transliterationsstufe, um das Zeichen vor ihnen zu erhöhen. ZB ~kann gedruckt werden mit:

}
T`_p`p

Pyke, 364 362 355 Bytes

2*1 + 3*2 + 14*3 + 2*4 + 5 + 73*4

Alles in der Form w<chr(charcode+32)>.C(4 Bytes) mit Ausnahme von:

• -> d1 Byte
• 0-> Z1 Byte
• 1-> ~W2 Bytes
• a-> Gh2 Bytes
• z-> Ge2 Bytes
• Die ersten 10 Kleinbuchstaben (außer a) in Form G<number>@(3 Bytes)
• k-> GT@3 Bytes
• >-> ~Bh3 Bytes
• ]-> ~Be3 Bytes
• Z-> ~le3 Bytes
• 9-> ~ue3 Bytes
• w-> G22@4 Bytes
• .-> ~B4@4 Bytes
• C-> ~K38@5 Bytes

Online Pyke Dolmetscher

JavaScript (ES6), 1083 - 1068 Byte

Generelle Form:

alert`\xhex`

Ausnahmen:

0 alert(9-9)
...
8 alert(9-1)
9 alert(8+1)
\ alert(atob`XA`)
` alert('\x60')
a \u0061lert`\x61`
e al\u0065rt`\x65`
l a\u006cert`\x6c`
r ale\u0072t`\x72`
t aler\u0074`\x74`
x alert`\u0078`

Bearbeiten: 15 Bytes dank @ GOTO0 gespeichert.

05AB1E , 417 Bytes

!   62D>B
"   63D>B
#   64D>B
$   65D>B
%   66D>B
&   67D>B
'   68D>B
(   69D>B
)   70D>B
*   71D>B
+   72D>B
,   73D>B
-   74D>B
.   75D>B
/   76D>B
0   1<
1   X
2   Y
3   Z
4   3>
5   4>
6   5>
7   6>
8   7>
9   8>
:   77D>B
;   78D>B
<   79D>B
=   80D>B
>   81D1+B
?   82D>B
@   83D>B
A   Th
B   T>h
C   T>>h
D   T3+h
E   T4+h
F   T5+h
G   16D>B
H   17D>B
I   18D>B
J   19D>B
K   20D>B
L   21D>B
M   22D>B
N   23D>B
O   24D>B
P   25D>B
Q   26D>B
R   27D>B
S   28D>B
T   29D>B
U   30D>B
V   31D>B
W   33D>B
X   33D>B
Y   A`\u
Z   A`u
[   84D>B
\   85D>B
]   86D>B
^   87D>B
_   88D>B
`   89D>B
a   A`r
b   A`r\
c   38D>B
d   39D>B
e   40D>B
f   41D>B
g   42D>B
h   43D>B
i   44D>B
j   45D>B
k   46D>B
l   47D>B
m   48D>B
n   49D>B
o   50D>B
p   51D>B
q   52D>B
r   53D>B
s   54D>B
t   55D>B
u   56D>B
v   57D>B
w   58D>B
x   A`\\
y   A`\
z   A`
{   90D>B
|   91D>B
}   92D>B
~   93D>B

Erläuterung

Die meisten sind 5 Bytes lang convert nr to base nr+1.
>benötigt ein zusätzliches Byte, da wir dafür kein Inkrement verwenden können.

a,b,x,y,z,Y,Zextrahiert werden, aus Adenen das Alphabet in Kleinbuchstaben enthält.

A,B,C,D,E,F sind in hex konvertierte Zahlen.

0-9 sind einfache Inkremente / Dekremente sowie vordefinierte Variablen.

Marbelous, 220 Bytes

Bei einem Zeichen, das keine Ziffer ist, handelt es sich nur um die beiden hexadezimalen Großbuchstaben des Zeichencodes. Beispiel: Das folgende Programm gibt Folgendes aus A:

41

3Ersetzen Sie für eine Ziffer, die nicht vorhanden ist, 2Fden folgenden Code durch die hexadezimalen Großbuchstaben des Zeichencodes - 1:

2F
++

Für 3:

66
>>

Gesamtpunktzahl: 2 * 85 + 5 * 10 = 220.

Dolmetscher.

Mein erster Versuch war Bubblegum und es funktionierte vorher nicht für Charaktere ?...

Perl 6: 921 Bytes

Übersetzung der Python-Lösung.

Jedes Programm hat die Form say "\x<hex escape code>", außer:

• s → put "\x73"
• a → put "\x61"

• y → put "\x79"

• → "\x20".say

• " → say chr 34
• \ → say chr 92
• x → say chr 120
• 0 → say 1-1
• 1 → say 3-2
• 2zu 9→say <n minus one>+1

Nachfolgend finden Sie die vollständige Liste der Programme, die nach Zeilenumbrüchen getrennt sind.

"\x20".say
say "\x21"
say chr 34
say "\x23"
say "\x24"
say "\x25"
say "\x26"
say "\x27"
say "\x28"
say "\x29"
say "\x2A"
say "\x2B"
say "\x2C"
say "\x2D"
say "\x2E"
say "\x2F"
say 1-1
say 3-2
say 1+1
say 2+1
say 3+1
say 4+1
say 5+1
say 6+1
say 7+1
say 8+1
say "\x3A"
say "\x3B"
say "\x3C"
say "\x3D"
say "\x3E"
say "\x3F"
say "\x40"
say "\x41"
say "\x42"
say "\x43"
say "\x44"
say "\x45"
say "\x46"
say "\x47"
say "\x48"
say "\x49"
say "\x4A"
say "\x4B"
say "\x4C"
say "\x4D"
say "\x4E"
say "\x4F"
say "\x50"
say "\x51"
say "\x52"
say "\x53"
say "\x54"
say "\x55"
say "\x56"
say "\x57"
say "\x58"
say "\x59"
say "\x5A"
say "\x5B"
say chr 92
say "\x5D"
say "\x5E"
say "\x5F"
say "\x60"
put "\x61"
say "\x62"
say "\x63"
say "\x64"
say "\x65"
say "\x66"
say "\x67"
say "\x68"
say "\x69"
say "\x6A"
say "\x6B"
say "\x6C"
say "\x6D"
say "\x6E"
say "\x6F"
say "\x70"
say "\x71"
say "\x72"
put "\x73"
say "\x74"
say "\x75"
say "\x76"
say "\x77"
say chr 120
put "\x79"
say "\x7A"
say "\x7B"
say "\x7C"
say "\x7D"
say "\x7E"

Hier ist der Code, mit dem ich die obige Auflistung getestet und die Punktzahl gezählt habe:

#!/usr/bin/env perl6

my $file = 'print_ascii_characters.p6';

my @expected = ' ' .. '~';
my @code     = $file.IO.lines;
my $code     = @code.join: ';';
my @got      = (run 'perl6', '-e', $code, :out).out.lines.map: |*.comb;

given +@expected, +@got, +@code -> ($e, $g, $c) {
    say "WRONG COUNT: Expected $e / output $g / source $c" and exit if not $e == $g == $c;
}

for @expected Z @got -> ($e, $g) {
    say "WRONG OUTPUT: Expected {$e.perl}, got {$g.perl}" and exit if $e ne $g;
}

for @expected Z @code -> ($char, $code) {
    say "COLLISION: {$char.perl} contained in {$code.perl}" if $code.match($char);
}

say "SCORE: ", @code.map(*.chars).sum;

Haskell, 1874, 1864, 1856, 1855, 1795, 1791, 1589 Bytes, 7 DNPs

Die meisten Programme sind main=putChar '\xx'oder main=putChar '\xxx'wo xx/ xxxist der ASCII-Code des zu druckenden Zeichens. Dies funktioniert für alle bis auf 14 Zeichen:

 !"#$%& ()*+,-./0123456789:;< >?@AB DEFGHIJKLMNOPQRSTUVWXYZ[ ]^_` bcdefg  jkl  o q s  vwxyz{|}~
       '                     =     C                        \    a      hi   mn p r tu        

Für die Ziffern können jedoch 1 bis 4 Bytes gespeichert werden (Danke an Christian Sievers!):

0   main=print$1-1
1   main=print$3-2
2   main=print$1+1
3   main=print$1+2
...

Die 52 Programme bis c(Code 99) benötigen 18 Byte, die restlichen 19 jeweils 19 Byte.

Teilergebnis: 10*14 + 52*18 + 19*19 = 1437

Für 7 der verbleibenden Zeichen funktionieren die folgenden Programme:

    main=putChar$'\32'
'   main=putStr$pred<$>"("
C   main=putStr['\67']
\   main=putChar$pred ']'
h   main=putStr['\104']
p   main=interact(\_->['\112'])
u   main=interact(\_->['\117'])

Teilergebnis: 18 + 22 + 18 + 21 + 19 + 27 + 27 = 152

Dies hinterlässt 7 DNPs: =aimnrt

Jedes Haskell-Programm muss ein main ( main=) definieren, das sind also 5 DNPs. Zum Drucken auf stdout, putChar, putStroder interactkann verwendet werden, wodurch man tund rals weiterer DNPs. (Es gibt printaber auch print 'a'Drucke 'a'und nicht a- und enthält auch tund rsowieso.) Haskell hat auch eine chrFunktion, die das entsprechende Zeichen unter Angabe einer Nummer zurückgibt, um es jedoch nutzen zu können, import Data.Charwird es benötigt.

Gesamtpunktzahl: 1437 + 152 = 1589 7 DNPs

BBC Basic, 422 413 Bytes

Laden Sie den Dolmetscher kostenlos unter http://www.bbcbasic.co.uk/bbcwin/bbcwin.html herunter

Dank Leaky Nun 9 Bytes gespart.

Generelle Form

V.<character code>

32..99 ohne 12 Sonderfälle: 56x4 = 224 Bytes

100..126 : 27x5 = 135 Bytes

12 Sonderfälle: 54 Bytes

Die meisten Zahlen folgen der allgemeinen Form, aber ich habe sie alle hier aufgenommen, um zu zeigen, wo das Problem liegt.

Das erste Zeichen ist das zu druckende Zeichen.

. VDU46       :REM Full form of the command used in general form: send character 46 to VDU)
V P.CHR$86    :REM short for PRINT CHR$(86)
0 V.48       
1 V.49
2 V.50
3 V.51
4 V.52
5 P.1+4
6 V.54
7 V.55
8 V.56
9 V.57

Minkolang 0,15 , 604 Bytes

Für die meisten Zeichen "<char-1>"1+O.wäre ein gültiges Programm, vielleicht eines der kürzesten. Aufgrund der Tatsache, dass Zeichen als Codepunkte auf dem Stapel gespeichert sind, können jedoch viele von ihnen durch Multiplikation und Addition in fünf Bytes oder weniger erzeugt werden. Beachten Sie auch, dass l, $1, $2, $3, $4, $5, $6, $lsind 10, 11, 12, 13, 14, 15, 16, 100jeweils.

Format: <character>: <program>

 : 48*O.
!: $13*O.
": 66*2-O.
#: 57*O.
$: 66*O.
%: 66*1+O.
&: 4l*2-O.
': 3$3*O.
(: 4l*O.
): 4l*1+O.
*: ")"1+O.
+: "*"1+O.
,: $14*O.
-: 59*O.
.: "-"1+d$10pO-
/: "."1+O.
0: 68*O.
1: 77*O.
2: 5l*O.
3: 5l*1+O.
4: lZIO.
5: lZdIO.
6: 239**O.
7: 5$1*O.
8: 4$4*O.
9: 6l*3-O.
:: 6l*2-O.
;: 6l*1-O.
<: 6l*O.
=: 6l*1+O.
>: 6l*2+O.
?: 79*O.
@: 88*O.
A: 5$3*O.
B: 6$1*O.
C: 7l*3-O.
D: 7l*2-O.
E: 7l*1-O.
F: 7l*O.
G: 7l*1+O.
H: 89*O.
I: 89*1+O.
J: 89*2+O.
K: 355**O.
L: 89*4+O.
M: 7$1*O.
N: 6$3*O.
O: "N"1+d90pN.
P: 8l*O.
Q: 99*O.
R: 8l*2+O.
S: 8l*3+O.
T: 347**O.
U: 8l*5+O.
V: 8l*6+O.
W: 8l*7+O.
X: 8$1*O.
Y: 8l*9+O.
Z: 9l*O.
[: $l9-O.
\: $l8-O.
]: $l7-O.
^: $l6-O.
_: $l5-O.
`: 8$2*O.
a: $l3-O.
b: $l2-O.
c: 9$1*O.
d: $lO.
e: $l1+O.
f: $l2+O.
g: $l3+O.
h: $l4+O.
i: $l5+O.
j: $l6+O.
k: $l7+O.
l: $l8+O.
m: $l9+O.
n: l$1*O.
o: $l$1+O.
p: $l$2+O.
q: $l$3+O.
r: $l$4+O.
s: $l$5+O.
t: $l$6+O.
u: "t"1+O.
v: "u"1+O.
w: 7dl+*O.
x: 358**O.
y: $1d*O.
z: 53;3-O.
{: 53;2-O.
|: 53;1-O.
}: 53;O.
~: 53;1+O.

Besondere Erwähnungen:

.: "-"1+d$10pO-

(Probieren Sie es aus.) Minkolang hat die Möglichkeit, die Zeichen in der Codebox zu ändern. Dieses Programm ersetzt also die Zeichen -am Ende durch die Zeichen ., die zum Stoppen des Programms erforderlich sind. "N"1+d90pN.für Ofunktioniert genauso.

4: lZIO.

(Probieren Sie es aus.) lZ Drückt die Groß- und Kleinbuchstaben auf den Stapel und Idrückt die Länge des Stapels, also 52, genau auf den Codepunkt "4". Das Beste daran ist, dass ich anfangs über die Lösung nachgedacht habe 4$3*O., die 4 und 13 multipliziert, um 52 zu erhalten, aber nicht, weil sie eine 4 enthält, und so fand ich trotzdem eine golferischere Lösung!

y: $1d*O.

(Probieren Sie es aus.) d Dupliziert den oberen Teil des Stapels. Dieser Code bewirkt also, dass er verschoben 11, dupliziert und dann multipliziert wird. Eine alternative Möglichkeit, dies zu schreiben, wäre gewesen $12;O., die die gleiche Byteanzahl hat.

}: 53;O.

(Probieren Sie es aus.) ; Ist Potenzierung, dies ergibt also 5 ^ 3, um 125 zu erhalten.

Groovy, 1019 Bytes

Ich hatte eine andere Groovy-Lösung geschrieben (siehe unten), aber nachdem ich sie eingereicht hatte, grub ich mich ein bisschen mehr in die Zeichenflucht, in der Hoffnung, eine Möglichkeit zu finden, das Programm weiter zu verkürzen, und entdeckte, dass Groovy eine oktale Zeichenflucht hat, die ich habe wusste nicht von. Dies vereinfacht den Code erheblich und beseitigt leider die Notwendigkeit für fast alle eigenartigen Problemumgehungen, die ich mir ausgedacht habe.

Es sieht auch fast identisch mit Copper's Python 2-Lösung aus , bis zu dem Punkt, an dem es im Grunde so aussieht, als hätte ich ihre Arbeit plagiiert. Pfui.

Jedes Programm hat die Form print'\<octal value>', außer:

• p, r, i, n, t→ 'print''\<octal value>'(aber mit dem passenden Buchstaben von „print“ auch mit dem Oktalwert ersetzt)
• 0- 9→print~-<next int>

Hier ist die vollständige Liste der Programme nach Charakter.

    print'\40'
!   print'\41'
"   print'\42'
#   print'\43'
$   print'\44'
%   print'\45'
&   print'\46'
'   print'\47'
(   print'\50'
)   print'\51'
*   print'\52'
+   print'\53'
,   print'\54'
-   print'\55'
.   print'\56'
/   print'\57'
0   print~-1
1   print~-2
2   print~-3
3   print~-4
4   print~-5
5   print~-6
6   print~-7
7   print~-8
8   print~-9
9   print~-10
:   print'\72'
;   print'\73'
<   print'\74'
=   print'\75'
>   print'\76'
?   print'\77'
@   print'\100'
A   print'\101'
B   print'\102'
C   print'\103'
D   print'\104'
E   print'\105'
F   print'\106'
G   print'\107'
H   print'\110'
I   print'\111'
J   print'\112'
K   print'\113'
L   print'\114'
M   print'\115'
N   print'\116'
O   print'\117'
P   print'\120'
Q   print'\121'
R   print'\122'
S   print'\123'
T   print'\124'
U   print'\125'
V   print'\126'
W   print'\127'
X   print'\130'
Y   print'\131'
Z   print'\132'
[   print'\133'
\   print'\134'
]   print'\135'
^   print'\136'
_   print'\137'
`   print'\140'
a   print'\141'
b   print'\142'
c   print'\143'
d   print'\144'
e   print'\145'
f   print'\146'
g   print'\147'
h   print'\150'
i   'pr\151nt''\151'
j   print'\152'
k   print'\153'
l   print'\154'
m   print'\155'
n   'pri\156t''\156'
o   print'\157'
p   '\160rint''\160'
q   print'\161'
r   'p\162int''\162'
s   print'\163'
t   'prin\164''\164'
u   print'\165'
v   print'\166'
w   print'\167'
x   print'\170'
y   print'\171'
z   print'\172'
{   print'\173'
|   print'\174'
}   print'\175'
~   print'\176'

Groovy, 1130 Bytes

Mein vorheriges Programm, bevor ich entdeckte, dass es oktale Fluchten gibt. Viel interessanter, IMO.

Jedes Programm hat die Form print(--'<next char>'), außer:

• -, [, ~→print(++'<previous char>')
• & → print(--"'")
• p, r, i, n→System.out<<--'<next char>'
• t → 'prin\u0074'(--'u')
• ( → print'\u0028'
• ) → print'\u0029'
• 0- 9→print~-<next int>

Hier ist die vollständige Liste der Programme für jeden Charakter:

    print(--'!')
!   print(--'"')
"   print(--'#')
#   print(--'$')
$   print(--'%')
%   print(--'&')
&   print(--"'")
'   print(--'(')
(   print'\u0028'
)   print'\u0029'
*   print(--'+')
+   print(--',')
,   print(--'-')
-   print(++',')
.   print(--'/')
/   print(--'0')
0   print~-1
1   print~-2
2   print~-3
3   print~-4
4   print~-5
5   print~-6
6   print~-7
7   print~-8
8   print~-9
9   print~-10
:   print(--';')
;   print(--'<')
<   print(--'=')
=   print(--'>')
>   print(--'?')
?   print(--'@')
@   print(--'A')
A   print(--'B')
B   print(--'C')
C   print(--'D')
D   print(--'E')
E   print(--'F')
F   print(--'G')
G   print(--'H')
H   print(--'I')
I   print(--'J')
J   print(--'K')
K   print(--'L')
L   print(--'M')
M   print(--'N')
N   print(--'O')
O   print(--'P')
P   print(--'Q')
Q   print(--'R')
R   print(--'S')
S   print(--'T')
T   print(--'U')
U   print(--'V')
V   print(--'W')
W   print(--'X')
X   print(--'Y')
Y   print(--'Z')
Z   print(--'[')
[   print(++'Z')
\   print(--']')
]   print(--'^')
^   print(--'_')
_   print(--'`')
`   print(--'a')
a   print(--'b')
b   print(--'c')
c   print(--'d')
d   print(--'e')
e   print(--'f')
f   print(--'g')
g   print(--'h')
h   print(--'i')
i   System.out<<--'j'
j   print(--'k')
k   print(--'l')
l   print(--'m')
m   print(--'n')
n   System.out<<--'o'
o   print(--'p')
p   System.out<<--'q'
q   print(--'r')
r   System.out<<--'s'
s   print(--'t')
t   'prin\u0074'(--'u')
u   print(--'v')
v   print(--'w')
w   print(--'x')
x   print(--'y')
y   print(--'z')
z   print(--'{')
{   print(--'|')
|   print(--'}')
}   print(--'~')
~   print(++'}')

Eigentlich , 383 382 381 Bytes

1 Byte dank Mego.

Zur einfachen Bezugnahme ist die erste Spalte der Zeichencode, die zweite Spalte das Zeichen und die dritte Spalte der Code.

Der Code für 0ist ein einzelnes Leerzeichen.

032   :32c
033 ! HN
034 " 9Fc
035 # :35c
036 $ :36c
037 % :37c
038 & :38c
039 ' :39c
040 ( :40c
041 ) 9R$N
042 * :42c
043 + :43c
044 , :44c
045 - :45c
046 . :46c
047 / :47c
048 0  
049 1 0Y
050 2 0P
051 3 1P
052 4 3u
053 5 2P
054 6 3!
055 7 3P
056 8 6F
057 9 NF
058 : 9P;+c
059 ; :59c
060 < :60c
061 = :61c
062 > :62c
063 ? :63c
064 @ :64c
065 A :65c
066 B :66c
067 C :67c
068 D :68c
069 E :69c
070 F :70c
071 G :71c
072 H :72c
073 I :73c
074 J :74c
075 K :75c
076 L :76c
077 M :77c
078 N :78c
079 O :79c
080 P :80c
081 Q :81c
082 R :82c
083 S :83c
084 T :84c
085 U :85c
086 V :86c
087 W :87c
088 X :88c
089 Y :89c
090 Z :90c
091 [ k$F
092 \ :92c
093 ] k$N
094 ^ :94c
095 _ :95c
096 ` :96c
097 a :97c
098 b :98c
099 c :12#"%x"%
100 d :100c
101 e :101c
102 f :102c
103 g :103c
104 h :104c
105 i :105c
106 j :106c
107 k :107c
108 l :108c
109 m :109c
110 n :110c
111 o :111c
112 p :112c
113 q 9PPc
114 r 9R$F
115 s :115c
116 t :116c
117 u :117c
118 v :118c
119 w 5!Dc
120 x 5!c
121 y 5!uc
122 z :122c
123 { :123c
124 | :124c
125 } :125c
126 ~ :126c

Probieren Sie es online!

Golfvorschläge sind willkommen.

Fourier, 306 Bytes, 1 DNP

Fast alle Programme folgen dem Muster, nawobei n der Zeichencode jedes Zeichens ist. Zum Beispiel:

!       33a
"       34a
#       35a
$       36a
%       37a
&       38a
'       39a

Probieren Sie es online!

Also werde ich nur die Ausnahmen auflisten:

0 (Null)

Da der Akku auf Null voreingestellt ist, können wir dies mit einem einzelnen Zeichen anzeigen:

o

Probieren Sie es online!

1

Ähnlich wie bei Null erhöht dies den Akkumulator, um 1 zu erhalten.

^o

Probieren Sie es online!

5

Der ASCII-Code für 5 ist 53, daher musste ich Folgendes umgehen:

6vo

Probieren Sie es online!

ein

Da es sich aum die Zeichenausgabefunktion handelt, gibt es keine andere Möglichkeit, das Zeichen a zu erzeugen. Dies ist also mein einziges NICHT-PROGRAMM .

Sehen Sie alle Programme hier

Matlab, 1238 1224 Bytes, 2 DNP

Das Hauptmuster ist:

disp([<char code> ''])

Bei Ziffern ist es etwas kürzer:

disp(<sum or difference of two other digits>)

Für Charaktere ist []'es:

" " -- disp([0,''])
"[" -- disp(char(91))
"]" -- disp(char(93))
"'" -- disp(char(39))

Zeichen dsvon dispwerden angezeigt mit fprintf( danke @Stewie Griffin ); ipgehören aber auch dazu, also verschiebe ich den string und benutze eval:

d -- fprintf([100 ''])
i -- eval(['ejtq)(j(*'-1 ''])
s -- fprintf([115 ''])
p -- eval(['ejtq)(q(*'-1 ''])

Beide Zeichen ()werden jedoch für dispoder benötigt eval, sie sind also DNP.

Als referenz die ganze liste:

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

Gelee (nicht konkurrierend), 406 Bytes

32Ọ
33Ọ
34Ọ
35Ọ
36Ọ
37Ọ
38Ọ
39Ọ
40Ọ
41Ọ
42Ọ
43Ọ
44Ọ
45Ọ
46Ọ
47Ọ
48Ọ
49Ọ
50Ọ
51Ọ
52Ọ
49+4Ọ
54Ọ
55Ọ
56Ọ
57Ọ
58Ọ
59Ọ
60Ọ
61Ọ
62Ọ
63Ọ
64Ọ
65Ọ
66Ọ
67Ọ
68Ọ
69Ọ
70Ọ
71Ọ
72Ọ
73Ọ
74Ọ
75Ọ
76Ọ
77Ọ
78Ọ
79Ọ
80Ọ
81Ọ
82Ọ
83Ọ
84Ọ
85Ọ
86Ọ
87Ọ
88Ọ
89Ọ
90Ọ
91Ọ
92Ọ
93Ọ
94Ọ
95Ọ
96Ọ
97Ọ
98Ọ
99Ọ
³Ọ
101Ọ
102Ọ
103Ọ
104Ọ
105Ọ
106Ọ
107Ọ
108Ọ
109Ọ
110Ọ
111Ọ
112Ọ
113Ọ
114Ọ
115Ọ
116Ọ
117Ọ
118Ọ
119Ọ
120Ọ
121Ọ
122Ọ
123Ọ
124Ọ
125Ọ
126Ọ

Dies gibt alle Zeichen von 32 - 126 aus. Die Byteanzahl wird mit https://mothereff.in/byte-counter berechnet .

Probieren Sie es online!

Befunge-93, 530 Bytes

Die einfachste Möglichkeit, ein Zeichen auszugeben, ohne es tatsächlich zu verwenden, besteht darin, den ASCII-Wert zu berechnen und ihn mit dem ,Befehl (Zeichenausgabe) zu rendern. Gibt beispielsweise 49*,@das Dollarzeichen aus (ASCII 36, 4 * 9). Dies ist jedoch selten das Optimalste, da für die Berechnung der meisten Werte mehr als 3 Byte erforderlich sind.

Eine andere Möglichkeit, eine Zahl in 3 Bytes zu generieren, besteht darin, die Tatsache auszunutzen, dass der gBefehl (get) in der ersten Zelle des Spielfelds den ASCII-Wert von g generiert (ein leerer Stapel wird also mit Nullen gefüllt) Ablesen des Spielfeldwertes bei 0,0). So g1+,@bekommst du h und g1-,@bekommst du f . Dies funktioniert offensichtlich für eine Reihe von Offsets, +und es -sind auch andere Operationen als und möglich. So bekommen Sie zum Beispiel g3/,@ein doppeltes Anführungszeichen.

Eine Variation davon besteht darin, dem einen ganderen Befehl vorauszugehen, der alle Nullen auf dem Stapel belässt. Sie lesen also immer noch einen Wert aus dem Spielfeld bei 0,0, aber das gelesene Zeichen ist jetzt anders. Dies kostet ein Byte mehr, aber Sie erhalten Zugriff auf viele weitere Werte. Beispiel: 0g1-,@Sie erhalten einen Schrägstrich und :g1+,@ein Semikolon. Andere zuverlässige Präfixe sind *, +, -, >, \und _. Beachten Sie auch hier, dass andere Operationen möglich sind: >g2*,@Sie erhalten eine vertikale Leiste.

Eine weitere Abwandlung ist das Voranstellen gvon a 1, so dass Sie jetzt nicht mehr von 0,0 lesen, sondern von der leeren Zelle bei 0,1. In Befunge werden leere Zellen standardmäßig mit Leerzeichen initialisiert, sodass 1g,@Sie ein Leerzeichen und 1g1+,@ein Ausrufezeichen erhalten.

Für die Ziffern gibt es einen zweifelhafteren Trick, den wir verwenden können. Anstatt zu versuchen, sie als Zeichen auszugeben, geben wir sie als Zahlen aus (eine kleine Zahl ist einfacher zu generieren als ihre ASCII-Entsprechung). Geben Sie zum Beispiel 2 an und beachten 11+.@Sie insbesondere die Sonderfälle: für 0 und für 1 . Der zweifelhafte Teil davon ist, dass eine numerische Ausgabe in Befunge ein Leerzeichen nach der Zahl enthält, sodass es sich nicht um eine reine Zeichenausgabe handelt..@!.@

Ein weiterer zweifelhafter Trick, den wir ganwenden können, ist eine Variation der obigen Technik. Anstatt uns auf Befunge-Befehle für das Präfix zu beschränken, können wir auch technisch jedes Zeichen verwenden, das kein Befunge-Befehl ist. Bei den meisten Interpreten wird ein nicht erkannter Befehl ignoriert, sodass am gEnde der ASCII-Wert des vorhergehenden Zeichens gelesen wird. Dies ermöglicht es uns, die meisten anderen ASCII-Werte zu generieren, die sonst nicht in 3 Bytes berechnet werden könnten. Als ein Beispiel: Qg1+,@bekommt man R .

Schließlich gibt es drei Sonderfälle. Ein g kann nicht in weniger als 5 Bytes generiert werden, daher müssen wir darauf zurückgreifen "f"1+,@. Ein Komma ist der komplizierteste, erfordern dynamische Modifikation des Spielfeldes: 0g4-:80p @. Wir könnten eine ähnliche Technik verwenden, um das at-Zeichen zu vermeiden, aber ein effizienterer Hack besteht darin, den %(modulo) -Befehl als Abschlusszeichen zu verwenden, d 88*,%. H. Wenn das %erreicht ist, befindet sich nichts auf dem Stapel, so dass die Modulo-Berechnung eine Division durch Null erzeugt und auf dem Referenzinterpreter das Programm beendet.

Unten finden Sie die vollständige Liste der Programme, eines pro Zeile.

1g,@
1g1+,@
g3/,@
57*,@
49*,@
1g5+,@
1g6+,@
1g7+,@
58*,@
1g9+,@
0g6-,@
0g5-,@
0g4-:80p @
59*,@
0g2-,@
0g1-,@
.@
!.@
11+.@
21+.@
31+.@
41+.@
51+.@
61+.@
71+.@
81+.@
>g4-,@
:g1+,@
:g2+,@
:g3+,@
:g4+,@
79*,@
88*,%
>g3+,@
>g4+,@
>g5+,@
>g6+,@
>g7+,@
>g8+,@
>g9+,@
89*,@
Hg1+,@
Ig1+,@
Jg1+,@
Kg1+,@
Lg1+,@
Mg1+,@
Ng1+,@
Og1+,@
99*,@
Qg1+,@
\g9-,@
\g8-,@
\g7-,@
\g6-,@
\g5-,@
\g4-,@
\g3-,@
\g2-,@
\g1-,@
_g3-,@
\g1+,@
g9-,@
g8-,@
g7-,@
g6-,@
g5-,@
g4-,@
g3-,@
g2-,@
g1-,@
"f"1+,@
g1+,@
g2+,@
g3+,@
g4+,@
g5+,@
g6+,@
g7+,@
g8+,@
g9+,@
tg3-,@
tg2-,@
tg1-,@
:g2*,@
tg1+,@
tg2+,@
tg3+,@
tg4+,@
tg5+,@
tg6+,@
tg7+,@
>g2*,@
tg9+,@
*g3*,@