W wybranym języku programowania napisz 95 programów, z których każdy wyprowadza inny z 95 drukowanych znaków ASCII, przy czym znak ten nie występuje nigdzie w programie .

Na przykład, jeśli Twoim językiem był Python , twoim programem, który wypisuje znak, Pmoże być

print(chr(80))

ponieważ Pma kod ASCII 80. Ten program jest prawidłowy, ponieważ Pnigdy nie pojawia się w kodzie źródłowym. Jednak w przypadku programu, który wyświetla małe litery p, coś podobnego

print(chr(112))

byłby nieważny, ponieważ gdy to robi odcisk p, pjest obecny w kodzie. Poprawnym programem może być

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

który drukuje, pale nie zawiera p.

Twoim celem jest, aby każdy z 95 programów był jak najkrótszy. Twój wynik to suma długości znaków wszystkich twoich programów.

Jeśli z jakiegoś powodu nie możesz napisać poprawnych programów dla niektórych znaków, możesz oznaczyć te znaki jako „Nie programowałem” lub DNP i całkowicie dla nich pominąć programy. W ten sposób języki ścisłe pod względem składni będą mogły konkurować.

Zwycięską odpowiedzią jest odpowiedź, która ma najniższy wynik z zestawu odpowiedzi, które mają najmniej DNP.

Zasady

• Kod źródłowy wszystkich twoich programów może zawierać tylko drukowalne ASCII oraz tabulatory i znaki nowej linii, z których wszystkie są liczone jako jeden znak. (Ponieważ w innym kodowaniu łatwo byłoby pominąć znaki, które nie istnieją!)

  • Uwaga: ta reguła wydaje się konieczna, ale istnieje wiele języków z różnymi kodowaniami i jestem pewien, że fajnie byłoby znaleźć na nie odpowiedzi. Dlatego możesz złamać tę zasadę , możesz użyć dowolnych postaci, ale wtedy twoja odpowiedź staje się niekonkurencyjna , nie może wygrać.

• Programy muszą być rzeczywistymi, pełnymi programami , zgodnie ze standardowymi konwencjami Twojego języka. Funkcje i fragmenty REPL są niedozwolone.

• Wyjście każdego programu powinno przejść do standardowego wyjścia lub do akceptowanej przez Twój język alternatywy.

• Programy nie powinny monitować ani wymagać wprowadzania danych. (Jeśli monitowanie o wpisanie jest nieodłączne dla twojego języka, to jest ok.)

• Programy powinny być deterministyczne, skończone w czasie wykonywania i niezależne. np. nie powinno mieć znaczenia, czy jeden jest uruchomiony w folderze innym niż inne programy.

• Wyjście programu powinno być dokładnym drukowalnym znakiem ASCII, któremu odpowiada, opcjonalnie po nim pojedynczy znak nowej linii, nic więcej, nic więcej.

Pamiętaj, aby w odpowiedzi podać informacje o wszystkich 95 (idealnie) programach, a także wynik i wszelkie DNP. Nie trzeba do listy wszystkich programów, które następują prosty wzór w stylu „ , ...”, ale upewnij się, że jesteś pewien, że wszystko będzie działać i że wynik jest dodawany poprawnie.print(chr(80))print(chr(81))print(chr(82))

Dla porównania, oto 95 ASCII do wydrukowania, które twoje programy muszą wydrukować:

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

Python 2, 1075 1065 1043 1040 1039 bajtów

Każdy program ma formę print'\<octal char code>', z wyjątkiem:

• ' → print"\47"
• 0przez 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"'

Dla odniesienia i łatwości testowania, oto pełna lista programów oddzielonych znakiem nowej linii.

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'

Testować:

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

-1 bajtów dzięki @ Sp3000!

CJam, 269 bajtów

Każdy z programów ma formę, '<char - 1>)z wyjątkiem:

• Spacja => S, 1 bajt
• '=> 39c, 3 bajty
• )=> '*(, 3 bajty
• 0=> T, 1 bajt
• 1=> X, 1 bajt
• 2=> Y, 1 bajt
• 3=> Z, 1 bajt
• 4- 9=> <num-1>), 2 bajty

Wynik to: 3 * 82 + 1 + 3 + 3 + 4 * 1 + 6 * 2 = 269

Ograniczony ASCII kod maszynowy x86 dla DOS, 3104 3101 2913 bajtów

Cóż ... Myślę, że jest krótszy niż Java

32 30 bajtów na prawie wszystkie znaki, wyjątki patrz poniżej.

W większości przypadków jest to zgodne z następującym wzorem:

1. Zrób trochę, xoraby uzyskać wskaźnik do końca.
2. subz ostatnich 2 słów, ponieważ kod operacji dla intnie znajduje się w ASCII.
3. Weź 2 do, AHa postać do DL. Oba są xoredytowane, ponieważ sam znak nie może pojawić się w programie, a 2 nie jest drukowalnym znakiem ASCII.
4. Wydrukuj znak za pomocą int 21h
5. Wyjdź z int 20h

W większości przypadków, jeśli znak jest niedozwolony, można go zastąpić albo trochę kręcąc danymi, albo przechodząc do innego rejestru.

Staje się to trochę bardziej interesujące, gdy nagle okazuje się, że nie jesteś w stanie odjąć lub nie możesz pchnąć lub pop jedynego rejestru używanego do obliczeń ...

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

60 bajtów zapisanych przez Dennisa
17 bajtów zapisanych przez Sp3000

DNP: 46 ( .)

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

Wszystkie oprócz 43, 45, 60, 62, 91 i 93 są bezwstydnie skradzione z Esolangs.org

MATL, 305, 302, 300 297 bajtów

Każdy program wygląda następująco:

33c
34c
35c
....

Z wyjątkiem

• Cyfry Oto programy dla 0-9:

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

• 'do'. Ten program jest

  'C'k
  

• przestrzeń. To jest

  0c
  

  Od dzisiaj dowiedziałem się, że MATL traktuje postać 0 jako spację. Dzięki @LuisMendo!

Możesz użyć matl.tio do weryfikacji dowolnego z nich.

Dla porównania, oto wszystkie z nich:

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

westchnienie

Jest to w zasadzie port mojej odpowiedzi w Pythonie 2 , ale ze wszystkimi podstawowymi elementami, które pochodzą z pisania pełnego programu w Javie.

Teraz w ogóle bez DNP! Dzięki, Kevin Cruijssen!

Większość programów ma postać interface A{static void main(String[]a){System.out.print("\<octal char code>");}}, z wyjątkiem:

• spacja → interface\tA{static\tvoid\tmain(String[]a){System.out.print("\40");}}(ale z \ts zastąpionymi surowymi tabulatorami)
• " → 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

Uff

Kompilator Java przetwarza znaki ucieczki Unicode, podobnie jak \u007Bprzed jakimkolwiek innym przetwarzaniem, co umożliwia pisanie kodu, który używa znaków ucieczki Unicode w identyfikatorach, a nawet słowach kluczowych. Tak więc, aby napisać program, który nie używa znaku znajdującego się na tablicy, po prostu podstawiamy go znakiem ucieczki Unicode.

Dla odniesienia i łatwości testowania, oto pełna lista programów, oddzielonych znakiem nowej linii, z surowymi tabulatorami zastąpionymi czterema spacjami:

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");}}

Zauważ, uże korzysta z tego program System.console(), który zwróci null (a tym samym spowoduje wyrzucenie kodu a NullPointerException), jeśli wywołasz go z innego niż natywny terminal twojego systemu operacyjnego ( cmdw Windows i, jak zakładam, bashw Linux / OSX) .

Aby przetestować, utwórz nowy katalog i umieść powyższy kod w pliku o nazwie printablesw tym katalogu. Następnie uruchom następujący skrypt Bash:

#!/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*

Powyższy skrypt umieści każdą linię printableswe własnym katalogu, nazwie je wszystkie A.java(z wyjątkiem pliku, który drukuje A, którego nazwa została zmieniona B.java), skompiluje każdy plik, uruchomi go, a następnie usunie dowód. Zacznie się pojawiać w powłoce drukowanych znaków ASCII około dziesięciu sekund.

Jeśli korzystasz z systemu Windows, uruchom następujący plik wsadowy:

@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

Ten plik wsadowy ma nieco inne podejście; zamiast wstępnie dzielić linie, przetwarza plik linia po linii, kompiluje i uruchamia kolejno każdy program. Ponownie usuwa dowody po zakończeniu.

Oszczędność niezliczonych bajtów + 1 DNP dzięki Kevin Cruijssen!

> <> , 443 437 bajtów

Link do tłumacza TIO . Tutaj jest wiele wzorów:

• [num][num]*o;: Mnożenie dwóch liczb, a następnie wyprowadzanie wyniku jako znaku za pomocą oi zatrzymywanie za pomocą ;. > <> cyfry zwiększają się do 15, tj 0123456789abcdef.
  • Podobnie [num][num]-n;, która przyjmuje różnicę między dwiema liczbami i wyjściami jako liczbą z nzamiast.

• '-o[invalid char]: > <> jest toroidalne, więc kiedy wskaźnik instrukcji osiągnie koniec linii, przesuwa się z powrotem na początek. W takim przypadku powoduje to wykonanie kodu dwukrotnie, tj '-o[char]'-o[char]. Pierwsza '-o[char]'część wypycha trzy znaki na stos, -oblicza, 'o' - [char]a następnie opodaje wynik jako znak. > <> następnie pojawia się błąd po osiągnięciu [char], albo z powodu nierozpoznanego polecenia, albo z powodu wyskakiwania pustego stosu.

  • Podobnie '-n[invalid char], który wyprowadza jako liczbę.
  • Podobnie '[num][op]o[invalid char], co ma zastosowanie [op]przy [num]włączeniu [char], błąd na char. Na przykład dane '2+oJwyjściowe L, czyli o dwa więcej niż J.
  • 'Kod to "-oH, używając "zamiast tego.
  • -Kod to '%oB, używając %zamiast tego.

• ln;: Naciśnij długość stosu, wyprowadzaj jako num, a następnie zatrzymaj, dając 0. Podobnie lln;dla 1i 'ln;dla 3.

• 4|n+: Naciśnij 4, odbij się |i naciśnij kolejne 4, dodaj, a następnie 8wyślij jako num. Odbij się |ponownie i popełnisz błąd, próbując wykonać nponownie na pustym stosie.
  • Podobnie 3|n*dla 9.
  • Podobnie [num]|o*dla @Qdy.
• '1-:00p: Najciekawszy dla oprzypadku. Aby uniknąć używania ow naszym kodzie, musimy użyć, paby umieścić ow codcode, a następnie uruchomić go. Inicjał '1-:00p'ustawia stos tak, aby był pna wierzchu, i 1-zmniejsza go do postaci o. :powiela to oi 00pustawia jeden ona (0, 0), zamieniając codbox w o1-:00p. Wskaźnik instrukcji ponownie się zawija, wyprowadzając drugi o. Znak (0, 0) jest następnie zamieniany jeszcze kilka razy, zanim program w końcu wyskoczy.

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

(niekonkuruje, ponieważ APL nie można tak naprawdę napisać tylko przy użyciu ASCII)

Większość ma format nn⊃⎕AVlub nnn⊃⎕AVwyjątki to:

⊃''     ⍝ 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

Oto cała lista:

⊃''
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

Rubinowy, 869 bajtów

Do 63 znaków @poprzez ~mamy rozwiązanie 10-bajtowy:

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

Dla większości (21) postaci z spacepośrednictwem ?, mamy rozwiązanie 9-bajtowy:

puts"\xx"     (2 digit octal code)

Pozostało jedenaście przypadków specjalnych:

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

Łącznie wynik wynosi 10 × 63 + 9 × 21 + 10 + 3 + 8 × 4 + 5 = 869.

WolframAlpha , 368 bajtów

Ogólny format:

u+<character code in hexadecimal>

Wyjątki:

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

Oto pełna lista:

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 bajtów, 2 0 DNP)

Edycja: zapisano 203 bajty dzięki jimmy23013 i zaimplementowałem 2 DNP dzięki Mego

Ta odpowiedź mocno narusza hojną naturę PHP. Większość przypadków przyjmuje jedną z następujących form (po 7 bajtów):

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

PHP konwertuje litery po obu stronach operatora na łańcuchy, a następnie wykonuje odpowiednią operację bitową, konwertując każdy łańcuch na wartość znaku ASCII, a na koniec konwertuje wynik z powrotem na znak.

W pierwszym przykładzie powyżej Y^xstaje się 89^78. Wynikiem tego jest 33, który jest następnie wysyłany do STDOUT jako znak !.

Skrypt został napisany, aby bruteforce wszystkich możliwych kombinacji: wyniki można znaleźć tutaj .

Wyjątki:

;is <?=Z^a?>(8 bytes)
|is <?='9'^E;(9 bytes)

<i ?normalnie byłby DNP z powodu wymaganego znacznika początkowego, ale przy użyciu -rflagi można wykonać kod bez nich:

<is echo Z^f;(9 bytes)
?is echo Z^e;(9 bytes)
=is echo Z^g;(9 bytes)

Wynik:

(7 * 90) + 8 + 9 + 9 + 9 + 9 = 674 bajtów

Brachylog , 546 477 bajtów

Kredyty do Fatalize dla kodu dla @.

Na poniższej liście pierwszym znakiem jest znak, który ma zostać wydrukowany (dla ułatwienia).

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

Wszystkie są predykatami, więc Zmusi być argumentem do otrzymania wyniku: Wypróbuj online!

Wyjaśnienie

@P to ten ciąg:

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

który zawiera każdy drukowany kod ASCII.

> <> , 531 bajtów

Programy przyjmują dwie główne formy:

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

Pierwszy dotyczy znaków o kodach znaków z dwoma czynnikami, których oba są mniejsze niż 16, drugi dotyczy pozostałych przypadków. Większość liczb, dla których używam drugiego formularza, ma wiele rozwiązań o równej długości, ale wybrałem ten dla czytelności.

Wyjątki:

" 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

Pełna lista:

! 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;

Sześciokąt , 376 373 bajtów, 1 DNP

Dzięki FryAmTheEggman za oszczędność 3 bajtów.

Prawie wszystkie programy mają tę samą formę:

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

Jest jednak kilka wyjątków:

• Nie można drukować ;bez użycia ;, stąd 1 DNP.
• Aby wydrukować @, nie możemy użyć @do zakończenia programu. Zamiast tego używamy albo S2;:albo S3;%. Kończy się to błędem dzielenia przez zero, ale błąd ten nie jest widoczny w STDOUT. To wciąż cztery bajty.
• Jest jedno starcie, Uktóre wymagałoby U3;@. Istnieje kilka sposobów rozwiązania tego problemu, w tym przejście na małe litery, tj. n9;@Użycie przyrostu lub zmniejszenia, tj . T);@Lub V(;@. W każdym razie to wciąż cztery bajty.
• Krawędzie pamięci zostały zainicjowane do 0, i !drukuje wartość całkowitą, więc możemy dostać 0i 1z !@i )!@, odpowiednio, oszczędzając 3 bajty.

Jeśli chodzi o działanie <letter><digit>;@programów: sześciokątny układ programu formularza 1234jest zawsze

 1 2
3 4 .
 . .

Ponieważ żaden z programów nie zawiera poleceń przekierowujących przepływ sterowania, są to po prostu programy liniowe, które są wykonywane po kolei.

W każdym przypadku litera na początku kodu ustawia bieżącą krawędź pamięci na kod znakowy. Np w programie P1;@, że Pustawia wartość 80. Następnie cyfra mnoży tę wartość przez 10 i dodaje siebie (tj. Cyfra jest dołączana do bieżącej wartości). To daje 801w powyższym przykładzie. Na koniec ;wypisuje tę wartość, biorąc ją modulo 256 i wykorzystując jako wartość bajtową. W tym przypadku drukowane jest 801 % 256 = 33a !.

Biała spacja , 1643 bajty, 1 DNP

17 bajtów na znaki [33-63] i 18 bajtów na znaki [64-126]

W Whitespace jest to proste, ponieważ znaki do wydruku (oprócz spacji) i tak nie mają żadnego znaczenia:

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

Powyższy program wypisuje „!” (100001b). Zmień [TAB][SPACE][SPACE][SPACE][SPACE][TAB]w pierwszym wierszu na dowolny znak, który ci się podoba. Nie można wydrukować spacji bez użycia spacji, ponieważ drukowanie czegokolwiek zawsze zaczyna się od[TAB][LF][SPACE]

Siatkówka , 712 bajtów, 2 DNP

To był wspólny wysiłek z FryAmTheEggman.

Istnieje kilka klas rozwiązań. W przypadku większości znaków od spacji do ^używamy programu o następującej formie:

_
T`w`p

Znak w drugim wierszu przechodzi przez zakresy, _0-9A-Za-zpodczas gdy reszta pozostaje niezmieniona. To przekształca puste dane wejściowe w ten znak, a następnie zastępuje go drukowalnym znakiem ASCII (reprezentowanym przez p) w odpowiedniej pozycji. Każdy z tych programów ma 8 bajtów.

W tym zakresie jest tylko kilka wyjątków. Co najważniejsze, cyfry można skrócić:

• 0: x(liczy liczbę xsw pustym wejściu)
• 1:  (weehoo, pusty program; zlicza liczbę pustych dopasowań w pustym wejściu)

• 2: teraz przekształcamy dane wejściowe w pojedynczy znak, przed zliczeniem pustych ciągów:

  
  1
  
  

• 3: to samo, ale przekształcamy dane wejściowe na dwa znaki:

  
  11
  
  

• 4: masz pomysł ...

  
  111
  
  

• 5 - 9: zwrot akcji ... używamy powtarzania postaci, aby uniknąć wydłużenia drugiej linii:

  
  4$*
  
  

  ...

  
  8$*
  
  

Innym wyjątkiem jest TDNP: nie sądzimy, że możliwe jest wygenerowanie znaku innego niż cyfrowy bez jego pojawienia się w kodzie źródłowym, jeśli etapy transliteracji nie mogą być użyte.

Do pozostałych postaci. Do drukowania _używamy podobnego programu jak powyższe ogólne rozwiązanie:

0
T`0`w

Wykorzystując fakt, który wzaczyna się od _.

Następnie `jest drugi DNP, ponieważ etapy transliteracji również je wymagają.

Następnie większość małych liter jest drukowana za pomocą czegoś takiego (który drukuje a):

_
T`w`l

Znów znak w drugim wierszu zwiększa się o _0-9A-O. Tutaj musimy tylko uważać li w, które możemy wydrukować odpowiednio za pomocą następujących programów:

P
T`p`w

6
T`p`l

Na koniec pozostały tylko {|}~te, które wymagają 9 bajtów. W tym przypadku wykorzystujemy etap transliteracji, aby zwiększyć znak, który je poprzedza. Np. ~Można wydrukować za pomocą:

}
T`_p`p

Pyke, 364 362 355 bajtów

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

Wszystko w formie w<chr(charcode+32)>.C(4 bajty), z wyjątkiem:

• -> d1 bajt
• 0-> Z1 bajt
• 1-> ~W2 bajty
• a-> Gh2 bajty
• z-> Ge2 bajty
• Pierwsze 10 małych liter alfabetu (oprócz a) w formie G<number>@(3 bajty)
• k-> GT@3 bajty
• >-> ~Bh3 bajty
• ]-> ~Be3 bajty
• Z-> ~le3 bajty
• 9-> ~ue3 bajty
• w-> G22@4 bajty
• .-> ~B4@4 bajty
• C-> ~K38@5 bajtów

Tłumacz online Pyke

JavaScript (ES6), 1083 1068 bajtów

Ogólna forma:

alert`\xhex`

Wyjątki:

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`

Edycja: Zapisano 15 bajtów dzięki @ GOTO0.

05AB1E , 417 bajtów

!   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

Wyjaśnienie

Większość z nich jest 5 bajtów w postaci: convert nr to base nr+1.
>potrzebuje dodatkowego bajtu, ponieważ nie możemy do tego użyć przyrostu.

a,b,x,y,z,Y,Zsą wyodrębniane, z Aktórych zawiera małe litery alfabetu.

A,B,C,D,E,F to liczby przeliczone na szesnastkowe.

0-9 są prostymi przyrostami / zmniejszeniami, a także predefiniowanymi zmiennymi.

Cudowny, 220 bajtów

W przypadku znaku, który nie jest cyfrą, są to tylko dwie wielkie cyfry szesnastkowe kodu znaku. Na przykład następujące wyniki programu A:

41

W przypadku cyfry, która nie jest 3, zastąp 2Fnastępujący kod dużymi cyframi szesnastkowymi kodu znaku - 1:

2F
++

Dla 3:

66
>>

Łączny wynik: 2 * 85 + 5 * 10 = 220.

Interpretator.

Moja pierwsza próba była Bubblegum i nie działała wcześniej dla postaci ?...

Perl 6: 921 bajtów

Tłumaczenie rozwiązania Python.

Każdy program ma formę say "\x<hex escape code>", z wyjątkiem:

• 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
• 2do 9→say <n minus one>+1

Dla odniesienia i łatwości testowania, oto pełna lista programów oddzielonych znakiem nowej linii.

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

Oto kod, którego użyłem do przetestowania powyższej listy i policzenia wyniku:

#!/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 bajtów, 7 DNP

Większość programów to main=putChar '\xx' lub main=putChar '\xxx'gdzie xx/ xxxjest kodem ASCII znaku, który ma zostać wydrukowany. Działa to dla wszystkich znaków oprócz 14:

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

Jednak dla cyfr można zapisać 1 7 4 bajtów (dzięki Christian Sievers!):

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

52 programy do c(kod 99) zajmują 18 bajtów, a pozostałe 19 zajmuje 19 bajtów.

Częściowy wynik: 10*14 + 52*18 + 19*19 = 1437

W przypadku 7 pozostałych znaków działają następujące programy:

    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'])

Częściowy wynik: 18 + 22 + 18 + 21 + 19 + 27 + 27 = 152

Pozostawia to 7 DNP: =aimnrt

Każdy program Haskell musi zdefiniować main ( main=), więc jest to 5 DNP. Aby drukować na standardowe, putChar, putStrlub interactmogą być stosowane, otrzymując ta rjako dalsze DNPS. (Jest też print, ale print 'a'drukuje, 'a'a nie a- i zawiera ti rtak.) Haskell ma również chrfunkcję, która zwraca odpowiedni znak podany w liczbie, jednak aby go użyć, import Data.Charjest potrzebny.

Łączny wynik 1437 + 152 = 1589 :, 7 DNP

BBC Basic, 422 413 bajtów

Pobierz tłumacza bezpłatnie ze strony http://www.bbcbasic.co.uk/bbcwin/bbcwin.html

9 bajtów zapisanych dzięki Dziurawej Zakonnicy.

Ogólna forma

V.<character code>

32..99 z wyłączeniem 12 specjalnych przypadków: 56x4 = 224 bajty

100..126 : 27x5 = 135 bajtów

12 przypadków specjalnych: 54 bajty

Większość liczb jest zgodna z ogólną formą, ale umieściłem je tutaj, aby pokazać, gdzie jest problem.

Pierwszy znak to znak, który ma zostać wydrukowany.

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

Dla większości znaków "<char-1>"1+O.byłby to prawidłowy program, być może jeden z najkrótszych. Jednak ze względu na fakt, że znaki są przechowywane jako punkty kodowe na stosie, oznacza to, że wiele z nich można wytworzyć przez pomnożenie i dodanie, w pięciu lub mniej bajtach. Należy również pamiętać, że l, $1, $2, $3, $4, $5, $6, $lsą 10, 11, 12, 13, 14, 15, 16, 100odpowiednio.

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.

Specjalne wzmianki:

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

(Spróbuj.) Minkolang ma możliwość modyfikowania znaków w polu kodu, więc program ten zastępuje go -na końcu ., co jest konieczne do zatrzymania programu. "N"1+d90pN.dla Odziała w ten sam sposób.

4: lZIO.

(Spróbuj.) lZ Wypycha na stos wielkie i małe litery oraz Iwypycha długość stosu, która wynosi 52, dokładnie punkt kodowy „4”. Najlepsze jest to, że początkowo zastanawiałem się nad rozwiązaniem 4$3*O., które zwielokrotnia 4 i 13, aby uzyskać 52, ale nie mogłem, ponieważ zawierało 4, więc ostatecznie znalazłem rozwiązanie dla golfistów!

y: $1d*O.

(Spróbuj.) d Powiela górę stosu, więc ten fragment kodu robi to, że wypycha 11, powiela go, a następnie mnoży. Alternatywnym sposobem na napisanie tego byłoby użycie $12;O.tej samej liczby bajtów.

}: 53;O.

(Spróbuj.) ; To potęgowanie, więc robi to 5 ^ 3, aby uzyskać 125.

Groovy, 1019 bajtów

Miałem już napisane inne rozwiązanie Groovy (patrz poniżej), ale po jego przesłaniu zacząłem nieco bardziej zagłębiać się w ucieczki postaci, mając nadzieję, że znajdę sposób na skrócenie programu i odkryłem, że Groovy ma ósemkową ucieczkę postaci, którą ja nie wiedziałem. To znacznie upraszcza kod, do tego stopnia, że ​​niestety eliminuje potrzebę prawie wszystkich dziwacznych obejść, które wymyśliłem.

Wygląda również prawie identycznie jak rozwiązanie Copper's Python 2 , do tego stopnia, że ​​wygląda na to, że plagiatowałem ich pracę. Ugh.

Każdy program ma formę print'\<octal value>', z wyjątkiem:

• p, r, i, n, t→ 'print''\<octal value>'(ale z literą dopasowującej „print” również zastąpić wartości ósemkowej)
• 0- 9→print~-<next int>

Oto pełna lista programów według postaci.

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

Mój poprzedni program, zanim odkryłem, że istnieją ósemkowe ucieczki. O wiele bardziej interesujące, IMO.

Każdy program ma formę print(--'<next char>'), z wyjątkiem:

• -, [, ~→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>

Oto pełna lista programów dla każdej postaci:

    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(++'}')

Właściwie , 383 382 381 bajtów

1 bajt dzięki Mego.

Dla ułatwienia pierwsza kolumna to kod znaku, druga kolumna to znak, a trzecia kolumna to kod.

Kod 0to pojedyncza spacja.

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

Wypróbuj online!

Sugestie dotyczące gry w golfa są mile widziane.

Fouriera, 306 bajtów, 1 DNP

Prawie wszystkie programy są zgodne ze wzorem, w naktórym n jest kodem znaków dla każdego ze znaków. Na przykład:

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

Wypróbuj online!

Wymienię więc wyjątki:

0 (zero)

Ponieważ akumulator jest ustawiony na zero, możemy to wyświetlić za pomocą jednego znaku:

o

Wypróbuj online!

1

Podobnie do zera, zwiększa to akumulator, aby uzyskać 1.

^o

Wypróbuj online!

5

Kod ASCII dla 5 to 53, więc musiałem obejść to:

6vo

Wypróbuj online!

za

Ponieważ ajest to funkcja wyjściowa znaków, nie ma innego sposobu na utworzenie znaku a, więc to mój jedyny NIE ZOSTAŁ PROGRAM .

Zobacz wszystkie programy tutaj

Matlab, 1238 1224 bajtów, 2 DNP

Główny wzór to:

disp([<char code> ''])

W przypadku cyfr jest nieco krótszy:

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

Dla postaci []'to:

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

Znaki dsz dispsą wyświetlane przy użyciu fprintf( dzięki @Stewie Griffin ); ipjednak należą również tam, więc zmieniam ciąg i używam eval:

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

Oba znaki ()są jednak niezbędne dla displub eval, więc są DNP.

Dla porównania cała lista:

    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

Galaretka (niekonkurencyjna), 406 bajtów

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Ọ

Spowoduje to wydrukowanie wszystkich znaków od 32 do 126. Liczba bajtów jest obliczana za pomocą https://mothereff.in/byte-counter .

Wypróbuj online!

Befunge-93, 530 bajtów

Najprostszym sposobem na wyprowadzenie znaku, bez jego użycia, jest obliczenie wartości ASCII i użycie polecenia ,(wyjście postaci) do jej renderowania. Na przykład,49*,@ wyświetla znak dolara (ASCII 36, 4 * 9). Jest to jednak rzadko najbardziej optymalne, ponieważ większość wartości wymaga więcej niż 3 bajtów do obliczenia.

Innym sposobem wygenerowania liczby w 3 bajtach jest skorzystanie z faktu, że polecenie g(get) w pierwszej komórce pola gry wygeneruje wartość ASCII g (przyjmuje się, że pusty stos jest wypełniony zerami, więc jest to odczyt wartości pola gry przy 0,0). W ten sposób g1+,@dostajesz h i g1-,@dostajesz f . To oczywiście działa dla wielu przesunięć i operacji innych niż +i -są również możliwe. Na przykład g3/,@dostajesz podwójną wycenę.

Odmianą tego jest poprzedzenie ginnego polecenia, które pozostawia wszystkie zera na stosie. Więc nadal odczytujesz wartość z pola gry na 0,0, ale czytana postać jest teraz inna. To kosztuje jeszcze jeden bajt, ale zapewnia dostęp do wielu innych wartości. Na przykład, 0g1-,@dostaje ukośnik i :g1+,@średnik. Inne realne prefiksy obejmują *, +, -, >, \i _. I jeszcze raz zauważ, że możliwe są inne operacje: >g2*,@zdobędziesz pionowy pasek.

Kolejną odmianą jest poprzedzenie literą ga 1, więc już nie czytasz już od 0,0, ale z pustej komórki przy 0,1. W Befunge puste komórki są domyślnie inicjowane spacjami, więc 1g,@dostajesz spację i1g1+,@ wykrzyknik.

W przypadku postaci cyfrowych możemy zastosować bardziej wątpliwą sztuczkę. Zamiast wyprowadzać je jako znaki, wyprowadzamy je jako liczby (łatwiej jest wygenerować małą liczbę niż jej odpowiednik ASCII). Na przykład 11+.@daje 2 , aw szczególności zwróć uwagę na przypadki szczególne: .@dla 0 i !.@dla 1 . Wątpliwą częścią tego jest to, że wynik liczbowy w Befunge zawiera spację po liczbie, więc nie jest to wynik czystych znaków.

Inną wątpliwą sztuczką, której możemy użyć, jest odmiana gpowyższej techniki. Zamiast ograniczać się do poleceń Befunge dla prefiksu, możemy technicznie użyć dowolnej postaci, która nie jest poleceniem Befunge. W większości interpreterów nierozpoznane polecenie zostanie zignorowane, więc gzakończy się odczytaniem wartości ASCII poprzedniego znaku. To pozwala nam generować większość innych wartości ASCII, których inaczej nie można obliczyć w 3 bajtach. Jako jeden przykład: Qg1+,@dostajesz R. .

Wreszcie są trzy przypadki szczególne. G nie mogą być generowane w mniej niż 5 bajtów, więc musimy uciekać się do "f"1+,@. Przecinek jest najbardziej skomplikowane, wymagające dynamiczna modyfikacja planszy: 0g4-:80p @. Możemy użyć podobnej techniki, aby uniknąć znaku at, ale bardziej efektywnym hackiem jest użycie polecenia %(modulo) jako terminatora, tj 88*,%. Kiedy %zostanie osiągnięty, na stosie nie ma nic, więc obliczenie modulo generuje podział przez zero, a na interpretera referencyjnym spowoduje to zakończenie programu.

Poniżej znajduje się pełna lista programów, po jednym w wierszu.

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*,@