Drucken Sie jedes druckbare ASCII-Zeichen, ohne es zu verwenden

56

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{|}~
Calvins Hobbys
quelle
Wenn in meiner Codierung 0x30-Codes für z. B. 日 anstelle von 0 sind, kann ich dann davon ausgehen, dass die druckbaren ASCII-Werte die regulären 95 minus 0 sind, fügen Sie 日 hinzu?
Undichte Nonne
4
Was? Sie müssen druckbares ASCII verwenden. Das ist nur eine Regel.
Calvins Hobbys
Ich glaube, es gibt Codierungen, die nicht die exakte Darstellung von 0x30 als0
Leaky Nun
@LeakyNun EBCDIC
TuxCrafting
2
@ Tim Nein. Befolgt nicht die Unabhängigkeitsregel.
Calvins Hobbys

Antworten:

25

Python 2, 1075 1065 1043 1040 1039 Bytes

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

  • 'print"\47"
  • 0durch 8print~-<N+1>
  • 9print-~8
  • \print'%c'%92
  • iexec'pr\151nt"\151"'
  • nexec'pri\156t"\156"'
  • pexec'\160rint"\160"'
  • rexec'p\162int"\162"'
  • texec'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!

Kupfer
quelle
print~-<N+1>funktioniert nicht für 1. Du hast gesagt , es funktioniert für 0zu 8.
Haykam
7
@ Erdnuss Es tut. Der Code in <angle brackets>ist kein wörtlicher Code. Ersetzen Sie <N+1>durch den wörtlichen Wert von N+1; in diesem fall 1wäre das programm dafür print~-2. Siehe die vollständige Liste der Programme.
Kupfer
21

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

Loovjo
quelle
39cfür '? Sie vergessen auch, dass einzelne Ziffern nur diese Zahl sein können
Sp3000
1
@ Sp3000 können sie nicht, da dies den von Ihnen produzierten Saibling in die Eingabe einbeziehen würde
Blue
Aber dann verwenden Sie 1)für 2etc, um dort ein Byte zu speichern
Luis Mendo
Entschuldigung, 1)meinte ich ja
Sp3000
Es gibt auchTXYZ
Sp3000
12

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
Michael Ehrenreich
quelle
11

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

betseg
quelle
3
@ βετѧΛєҫαγ Wahrscheinlich, da es größtenteils kopiert wurde.
Calvins Hobbys
8
@HelkaHomba Ich meine, BF-Konstanten sind im Grunde die kürzesten von dem, was ich weiß. Es ist sinnlos, es selbst mit bereits festgelegten Konstanten zu versuchen.
Insane
3
--[>-<---]>[<->--]<[->-<]>.funktioniert für die Ausgabe +.
Dennis
3
@Dennis Ein bisschen später geschlagen:-----[[----<]>>-]<.
Sp3000
2
Also+[+[+>]<<++++]>.
Sp3000
9

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
DJMcMayhem
quelle
@ LuisMendo Ich zähle immer noch 297
DJMcMayhem
@ LuisMendo Ich zähle auch 297.
Undichte Nonne
Entschuldigung, mein Fehler
Luis Mendo
9

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");}}
  • 0interface A{static void main(String[]a){System.out.print(1-1);}}
  • 1interface A{static void main(String[]a){System.out.print(3-2);}}
  • 2interface A{static void main(String[]a){System.out.print(3-1);}}
  • 3interface A{static void main(String[]a){System.out.print(4-1);}}
  • 4interface A{static void main(String[]a){System.out.print(5-1);}}
  • 5interface A{static void main(String[]a){System.out.print(6-1);}}
  • 6interface A{static void main(String[]a){System.out.print(7-1);}}
  • 7interface A{static void main(String[]a){System.out.print(8-1);}}
  • 8interface A{static void main(String[]a){System.out.print(9-1);}}
  • 9interface A{static void main(String[]a){System.out.print(8+1);}}
  • ;interface A{static void main(String[]a){System.out.print("\73")\u003B}}
  • Ainterface B{static void main(String[]a){System.out.print("\101");}}
  • Sinterface 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");}}
  • ainterf\u0061ce A{st\u0061tic void m\u0061in(String[]b){System.out.print("\141");}}
  • cinterfa\u0063e A{stati\u0063 void main(String[]a){System.out.print("\143");}}
  • dinterface A{static voi\u0064 main(String[]a){System.out.print("\144");}}
  • eclass A{public static void main(String[]a){Syst\u0065m.out.print("\145");}}
  • fclass A{public static void main(String[]a){System.out.print("\146");}}
  • ginterface 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");}}
  • minterface A{static void \u006Dain(String[]a){Syste\u006D.out.print("\155");}}
  • nclass A{public static void mai\u006E(Stri\u006Eg[]a){System.out.pri\u006Et("\156");}}
  • ointerface A{static v\u006Fid main(String[]a){System.\u006Fut.print("\157");}}
  • pinterface A{static void main(String[]a){System.out.\u0070rint("\160");}}
  • rclass A{public static void main(St\u0072ing[]a){System.out.p\u0072int("\162");}}
  • sinterface A{\u0073tatic void main(String[]a){Sy\u0073tem.out.print("\163");}}
  • tclass A{public s\u0074a\u0074ic void main(S\u0074ring[]a){Sys\u0074em.ou\u0074.prin\u0074("\164");}}
  • uinterface A{static void main(String[]a){System.console().printf("%c",117);}}
  • vinterface A{static \u0076oid main(String[]a){System.out.print("\166");}}
  • yinterface 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!

Kupfer
quelle
2
Ich liebe den Zufall class Bzum DruckenA
Tas
Du warst schneller als ich. Gestern am Ende des Tages habe ich eine Antwort für Java mit Unicode-Escape geschrieben. Ah, +1, gut geschriebene Antwort und nur 1 DNP ist nicht so schlecht, wie ich vorher für Java gedacht habe. ;)
Kevin Cruijssen
2
Übrigens gibt es eine Möglichkeit, DNP für u zu entfernen, wenn Sie Java 8+ verwenden ( interfaceanstelle von class, damit Sie das entfernen können public) und wenn in Ihrem Betriebssystem eine Konsole integriert ist, müssen Sie nicht verwenden System.out.print: interface A{static void main(String[]a){System.console().printf("%1",(char)117);}}Eclipse, IntelliJ und Online-Compiler haben diese Konsole jedoch nicht, was zu einer NullPointerException.
Kevin Cruijssen
@ KevinCruijssen Danke! Ich arbeite gerade daran, es zu überarbeiten.
Kupfer
n: print
Ich habe
7

> <> , 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;
Sp3000
quelle
7

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
Adam
quelle
1
Dieses Format ist meiner Meinung nach weniger hilfreich als das Format der anderen Antworten
Leaky Nun
@LeakyNun Wollen Sie sie nach Methoden gruppieren? Es gibt einige Ausnahmen.
Adám
2
Dies sind nicht alle druckbaren ASCII-Zeichen, so dass sie technisch ungültig sind. Ich möchte jedoch hinzufügen, dass nicht druckbares ASCII für nicht konkurrierende Einreichungen zulässig ist.
Calvins Hobbys
@HelkaHomba Hoppla, ich habe diese Anforderung nicht bemerkt.
Adám
ist mein neuer Lieblings-Smiley
Lucas Trzesniewski
6

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.

Lynn
quelle
Für die Oktal-Escape-Zeichen können Sie ?\xxxanstelle von jeweils "\xxx"1 Byte verwenden.
Jordanien
Warum p 1+8nicht p-~8?
Cyoce
@Cyoce Ruby interpretiert das als binär -oder so. :(
Lynn
@ Jordan Noted, aber ich bin faul ... fühlen Sie sich frei, die Bearbeitung / Nachzählung n_n
Lynn
2
Die meisten davon können Sie mit putc 65=>A
histocrat
5

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
Anastasiya-Romanova 秀
quelle
5

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

Hamburger
quelle
@ jimmy23013 Hoppla, ich habe die Dokumentation falsch gelesen.
Mego
Sie können & | ^zwischen zwei Buchstaben verwenden, um alle druckbaren ASCII-Zeichen außer zu generieren <?=|;.
Jimmy23013
@ Jimmy23013 Das ist verrückt. Gerade als ich dachte, ich hätte alle Macken von PHP gelernt!
Clamburger
1
Viele der Standardlösungen für Formulare könnten so optimiert werden, dass ein Byte mit binärem NOT ~anstelle von XOR, AND oder OR gespeichert wird. PHP kann mehr druckbare Zeichen als Konstanten als nur Buchstaben verwenden.
Fabian Schmengler
1
@fschmengler Leider würde dies meines Erachtens die Verwendung von erweiterten ASCII-Zeichen (oder zunehmend exotischen Unicode-Zeichen) erfordern, die meiner Meinung nach für diese Herausforderung nicht gültig sind.
Clamburger
4

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.

Undichte Nonne
quelle
@Fatalize Danke, aktualisiert.
Undichte Nonne
4

> <> 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;
DanTheMan
quelle
Ihre ;Verwendungen ;. Ich bin mir auch ziemlich sicher, dass die meisten davon fehlerfrei gespielt werden können und odefinitiv möglich sind.
Sp3000
@ Sp3000 Es sei denn, es gibt einen Dolmetscher, der beides akzeptiert ound Oich sehe nicht, wie odas möglich ist. Und wie würde ein Fehler kürzer ausfallen?
DanTheMan
okann durch die Verwendung von erfolgen p. Ich könnte jedoch separat posten, um Fehler zu vermeiden, da wahrscheinlich viele verschiedene Muster beteiligt sind.
Sp3000
@ Sp3000 Ich habe das ;Programm allerdings behoben . Vielen Dank für den Hinweis!
DanTheMan
4

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.

Martin Ender
quelle
4

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]

Rolf
quelle
2
Das Leerzeichen ist ein druckbares ASCII-Zeichen ("druckbares ASCII" bezieht sich auf den Bereich von 0x20 bis einschließlich 0x7E), daher müssen Sie dieses Zeichen als 1 DNP angeben, es sei denn, Sie finden eine Möglichkeit, es ohne Leerzeichen zu drucken. Geben Sie außerdem die Partitur des Programms an.
Martin Ender
4

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
Martin Ender
quelle
Mit der neuen Version von Retina ist es möglich, mit $ L und $ u alle Buchstaben (sogar T) mit vier Bytes zu drucken.
Leo
@Leo Nein, das glaube ich nicht. Ich wollte der Substitutionssyntax einen weiteren binären Operator hinzufügen, der eine Bereichserweiterung darstellt und das Problem löst. Ich muss allerdings herausfinden, wie genau ich es implementieren möchte. Eine andere Option wäre eine Substitutionssyntaxfunktion für die Arbeit mit Codepunkten.
Martin Ender
3

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

Blau
quelle
3

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.

Neil
quelle
"x" benötigt auch eine spezielle Behandlung. Verwenden Sie auch alert(atob`XA`)für "\", um einige Bytes zu speichern.
GOTO 0
@ GOTO0 Ugh, ich kann nicht glauben, dass ich es vergessen habe x.
Neil
1
Javascript erlaubt \uFluchten im Quellcode? Cool
Cyoce
@Cyoce: In Bezeichnern ja, im Allgemeinen nein.
Bergi
@Bergi Unicode-Escapezeichen werden zuerst verarbeitet, sodass Sie Ihre gesamte Quelle in Unicode-Escapezeichen schreiben können, wenn Sie möchten, während Hex-Escapezeichen nur innerhalb von Zeichenfolgen funktionieren.
Neil
3

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.

Emigna
quelle
3

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 ?...

jimmy23013
quelle
3

Perl 6: 921 Bytes

Übersetzung der Python-Lösung.

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

  • sput "\x73"
  • aput "\x61"
  • yput "\x79"

  • "\x20".say

  • "say chr 34
  • \say chr 92
  • xsay chr 120
  • 0say 1-1
  • 1say 3-2
  • 2zu 9say <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;
smls
quelle
@sch In Perl 5 würde das funktionieren, aber ich habe versucht, es in Perl 6 zu tun, wo der Platz danach saybenötigt wird und oktale Escape-Sequenzen wie folgt geschrieben werden \o77. Fühlen Sie sich frei, eine separate Perl 5-Lösung zu veröffentlichen ... :)
smls
Entschuldigung, ich habe den Perl 6-Teil in Ihrer Antwort verpasst.
sch
3

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

Laikoni
quelle
1
Mit optionalen Zeilenumbrüchen können wir Ziffern wie diese erhalten: main=print$1-1usw.
Christian Sievers
Ihr p-Programm verwendet p (aber kann leicht mit behoben werden succ)
Christian Sievers
2

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
Level River St
quelle
Warum nicht V.48für verwenden 0?
Undichte Nonne
@LeakyNun 9 Bytes gespeichert, danke!
Level River St
Woah, waren die Befehle V.und schon P.immer da?
Beta Decay
@ βετѧΛєҫαγ Ja, aber der Editor erweitert sie nach der Eingabe auf die vollständigen Wörter VDU und PRINT (sie werden jedoch ohne Erweiterung in der BASIC-Befehlszeile interpretiert). Die meisten Großbuchstaben, gefolgt von, .werden zu einem Schlüsselwort erweitert. Bei dieser Herausforderung geht es strikt darum, nicht druckbares ASCII zu verwenden. Bei anderen Herausforderungen kann man jedoch sagen, dass die mit Token versehenen Schlüsselwörter (ASCII 127-255) ein Byte lang sind. Das heißt, ich habe dieses Argument nie ausprobiert und gebe normalerweise beide Punkte.
Level River St
@LevelRiverSt Ich verstehe
Beta Decay
2

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.

El'endia Starman
quelle
2

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- 9print~-<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, nSystem.out<<--'<next char>'
  • t'prin\u0074'(--'u')
  • (print'\u0028'
  • )print'\u0029'
  • 0- 9print~-<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(++'}')
M. Justin
quelle
2

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.

Undichte Nonne
quelle
:in 5:9P2*c
Mego
@Mego Danke, hinzugefügt.
Undichte Nonne
2

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

Beta-Zerfall
quelle
2

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
pajonk
quelle
Funktioniert so etwas wie [100 105 115 112](char-codes) für disp?
Undichte Nonne
Was genau meinst du? disp([100 105 115 112])Produziert auch keine Saite eval([100 105 115 112]).
Pajonk
Sie können verwendet werden fprintffür d ans s: fprintf([115,'']). Speichert 2x7 Bytes =) Wird es nicht zu einer erfolgreichen Einsendung machen, aber hey: 14 Bytes sind 14 Bytes ,,,
Stewie Griffin
Auch: disp([0 ''])enthält ein Leerzeichen. disp([0,''])nicht.
Stewie Griffin
@StewieGriffin Danke, ich habe das Leerzeichen verpasst. Danke auch für den Trick mit fprintf.
Pajonk
2

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!

Soren
quelle
1
Ich denke nicht, dass dies eine gültige Antwort ist. Erstens darf man keine Eingabe machen, und zweitens ist dies ein Programm, nicht 95 Programme. Die Herausforderung lautetIn a programming language of your choice, write 95 programs, each of which outputs a different one of the 95 printable ASCII characters without that character occurring anywhere in the program.
DJMcMayhem
@DJMcMayhem Ok, das werde ich ändern
Soren
DJ ist richtig. Dies ist offensichtlich ungültig.
Calvins Hobbys
@HelkaHomba zählt mein Byte die Summe aller Programme?
Soren
1
Vielen Dank für die Fehlerbehebung und willkommen auf der Website! Ich hoffe es gefällt euch hier. Außerdem verwendet Jelly, nur damit Sie wissen, eine benutzerdefinierte Codepage . In diesem Fall sind es also wirklich 406 Zeichen, obwohl es in UTF-8 503 wäre.
DJMcMayhem
2

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*,@
James Holderness
quelle