У мові програмування за вашим вибором, написати 95 програм, кожен з яких виходів інші один з 95 друкованих символів ASCII без цього символу , що відбувається в будь-якому місці програми .

Наприклад, якщо вашою мовою був Python , Pможе бути вашою програмою, яка виводить символ

print(chr(80))

тому що Pмає код ASCII 80. Ця програма діє, оскільки Pніколи не відображається у вихідному коді. Однак для програми, яка виводить малі регістри p, щось подібне

print(chr(112))

було б недійсним, оскільки, хоч воно друкує p, pприсутнє в коді. Дійсною може бути програма

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

який друкує, pале не містить p.

Ваша мета - зробити кожну з ваших 95 програм якомога коротшою. Ваш бал - це сума символів усіх ваших програм.

Якщо з будь-якої причини ви не в змозі написати дійсні програми для деяких символів, ви можете позначити ці символи як "Не програмував" або " DNP" і опустити програми для них повністю. Таким чином синтаксично суворі мови зможуть конкурувати.

Відповідна перемога - це відповідь, яка має найнижчий бал із набору відповідей, які мають найменшу кількість ДНП.

Правила

• Вихідний код усіх ваших програм може містити тільки друкований ASCII плюс вкладки та нові рядки, всі вони рахуються як один символ. (Тому що в іншому кодуванні було б легко опустити символи, яких не існує!)

  • Примітка: Це правило видається необхідним, але є багато мов з різними кодуваннями, і я впевнений, що було б здорово переглянути відповіді на них. Тому ви можете порушити це правило , ви можете використовувати будь-які символи, які ви хочете, але тоді ваша відповідь стає неконкурентоспроможною , вона не може перемогти.

• Програми повинні бути дійсними, повноцінними програмами відповідно до стандартних положень вашої мови. Функції та фрагменти REPL не дозволяються.

• Вихід кожної програми повинен переходити до stdout або альтернативи вашої мови.

• Програми не повинні вимагати введення або вимагати введення. (Якщо запит на введення притаманний вашій мові, це нормально.)

• Програми повинні бути детермінованими, обмеженими під час виконання та незалежними. наприклад, це не має значення, якщо один запускається в папці, окремо від інших програм.

• Вихід програми повинен бути точним символом ASCII для друку, якому він відповідає, за бажанням повинен слідувати один зворотний новий рядок, нічого більше, нічого менше.

Не забудьте включити у відповідь інформацію про всі 95 (в ідеалі) програм, а також ваш бал та будь-які результати ДНП. Вам не потрібно перераховувати всі програми , які слідують простому шаблоном , як « , ...» , але переконайтеся , що ви будете впевнені , що всі вони будуть працювати , і що ваш рахунок правильно доданий.print(chr(80))print(chr(81))print(chr(82))

Для довідки, ось 95 друкованих ASCII, які повинні видавати ваші програми:

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

Python 2, 1075 1065 1043 1040 1039 байт

Кожна програма має форму print'\<octal char code>', крім:

• ' → print"\47"
• 0через 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"'

Для довідки та зручності тестування, ось повний перелік програм, розділених новими рядками.

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'

Перевіряти:

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

-1 байт завдяки @ Sp3000!

CJam, 269 байт

Кожна з програм складається у формі, '<char - 1>)за винятком:

• Пробіл => S, 1 байт
• '=> 39c, 3 байти
• )=> '*(, 3 байти
• 0=> T, 1 байт
• 1=> X, 1 байт
• 2=> Y, 1 байт
• 3=> Z, 1 байт
• 4- 9=> <num-1>), 2 байти

Оцінка: 3 * 82 + 1 + 3 + 3 + 4 * 1 + 6 * 2 = 269

ASCII обмежений x86 машинний код для DOS, 3104 3101 2913 байт

Ну ... Це коротше, ніж Ява ...

32 30 байт майже для всіх символів, винятки див. Нижче.

Більшу частину часу він просто відповідає шаблону:

1. Зробіть кілька, xorщоб отримати вказівник до кінця.
2. subз останніх двох слів, оскільки опкод для intвідсутній в ASCII.
3. Введіть 2 AHі персонаж в DL. Обидва є xorредактором, оскільки сам символ не може відображатися в програмі, а 2 не є символом для друку ASCII.
4. Роздрукуйте символ за допомогою int 21h
5. Вихід із int 20h

У більшості випадків, якщо символ заборонений, його можна замінити або подвійним змістом з даними, або перемиканням на інший реєстр.

Це стає дещо цікавішим, коли раптом ви виявляєте, що не можете відняти або не можете натиснути або спливати єдиний реєстр, придатний для розрахунків ...

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 байт

60 байтів, збережених Деннісом,
17 байтів, збережених Sp3000

DNP: 46 ( .)

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

Усі, крім 43, 45, 60, 62, 91 і 93, безсоромно викрадені з Esolangs.org

MATL, 305, 302, 300 297 байт

Кожна програма виглядає так:

33c
34c
35c
....

Окрім

• Цифри. Ось програми на 0-9:

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

• 'c'. Ця програма є

  'C'k
  

• простір. Це

  0c
  

  З сьогоднішнього дня я дізнався, що MATL розглядає символ 0 як простір. Дякую @LuisMendo!

Ви можете використовувати matl.tio для підтвердження будь-якого з них.

Для довідки, ось їх усі:

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 байт

зітхати

Це в основному порт моєї відповіді Python 2 , але з усією табличкою, що постачається з написанням повної програми на Java.

Тепер без ДНП взагалі! Дякую, Кевін Круїссен!

Більшість програм мають форму interface A{static void main(String[]a){System.out.print("\<octal char code>");}}, крім:

• пробіл → interface\tA{static\tvoid\tmain(String[]a){System.out.print("\40");}}(але з \ts замінено на необроблені вкладки)
• " → 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

Phew

Компілятор Java обробляє Unicode, як і \u007Bперед будь-якою іншою обробкою, що дозволяє писати код, який використовує уникнення Unicode в ідентифікаторах і навіть ключових словах. Отже, щоб написати програму, яка не використовує символу, присутнього на панелі котла, ми просто підміняємо його унікодним утечею.

Для довідки та зручності тестування, ось повний перелік програм, розділених новою лінією та з необробленими вкладками, заміненими чотирма пробілами:

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

Зауважте, що програма для uвикористання використовує System.console(), яка поверне нуль (і, таким чином, призведе до викидання коду a NullPointerException), якщо ви будете викликати його з будь-якого іншого, крім рідного терміналу вашої ОС ( cmdв Windows, і, я припускаю, bashв Linux / OSX) .

Для тестування створіть нову директорію та вставте вищевказаний код у файл, названий printablesу цьому каталозі. Потім запустіть такий сценарій 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*

Наведений вище сценарій помістить кожен рядок printablesу свою власну директорію, назве їх усіх A.java(крім файлу, який друкує A, який перейменовано на B.java), складе кожен файл, запустить їх, а потім видалить докази. Потрібно пройти приблизно десять секунд, щоб символи ASCII для друку почали з’являтися у вашій оболонці.

Якщо ви працюєте в Windows, замість цього запустіть такий пакетний файл:

@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

Цей пакетний файл має дещо інший підхід; замість попереднього розбиття рядків, він обробляє файл по черзі та компілює та запускає кожну програму по черзі. Знову він видаляє докази після закінчення.

Збережено незліченну кількість байтів + ​​1 DNP завдяки Кевіну Крейсейну!

> <> , 443 437 байт

TIO перекладач посилання . Тут багато моделей:

• [num][num]*o;: Множення двох чисел, а потім вивести результат у вигляді знака oта зупинити ;. > <> цифри йдуть до 15, тобто 0123456789abcdef.
  • Аналогічно [num][num]-n;, що приймає різницю двох чисел і виводить nзамість них число.

• '-o[invalid char]: > <> є тороїдальним, тому коли вказівник інструкції доходить до кінця рядка, він повертається до початку. У цьому випадку це призводить до того, що код виконується двічі, тобто '-o[char]'-o[char]. Перша '-o[char]'частина штовхає три символи до стеку, -обчислює, 'o' - [char]а потім oвиводить результат як символ. > <> тоді помилки виходять, коли вона досягається [char], або через нерозпізнану команду, або через вивільнення порожнього стека.

  • Аналогічно '-n[invalid char], який виводиться як число.
  • Точно так само '[num][op]o[invalid char], що застосовується [op]і [num]до [char], помилка на графіку. Наприклад, '2+oJвиходи L, що на два більше, ніж J.
  • 'код є "-oH, використовуючи "замість цього.
  • -код є '%oB, використовуючи %замість цього.

• ln;: Push довжина стека, вивести як число, а потім зупинити, даючи 0. Аналогічно lln;для 1і 'ln;для 3.

• 4|n+: Натисніть 4, відмовтеся від |та натисніть ще 4, додайте, а потім виведіть 8як число. Відскакують від |знову, і помилки, намагаючись виконати nзнову на порожньому стеку.
  • Аналогічно 3|n*для 9.
  • Аналогічно [num]|o*для @Qdy.
• '1-:00p: Найцікавіший, для oвипадку. Щоб уникнути використання oв нашому коді, нам потрібно використовувати pрозміщення коду в коді o, а потім запустити його. Початковий '1-:00p'встановлює стек pвгорі і 1-декрементує його на o. :дублює це oі 00pрозміщує його oна (0, 0), перетворюючи кодове поле o1-:00p. Покажчик інструкцій загортається знову, виводячи інший o. Потім символ (0, 0) замінюється ще кілька разів, перш ніж програма остаточно помилиться.

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

Діялог APL , 527 522 байт

(не конкурує, оскільки APL не може бути записаний лише за допомогою ASCII)

Більшість у форматі nn⊃⎕AVабо nnn⊃⎕AV, за винятком:

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

Ось весь список:

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

Рубі, 869 байт

Для 63 символів @через ~, ми маємо розчин 10-байтовий:

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

Для більшості (21) символів spaceнаскрізь у ?нас є 9-байтове рішення:

puts"\xx"     (2 digit octal code)

Залишилося одинадцять особливих випадків:

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

Загалом оцінка складає 10 × 63 + 9 × 21 + 10 + 3 + 8 × 4 + 5 = 869.

Вольфрам Альфа , 368 байт

Загальний формат:

u+<character code in hexadecimal>

Винятки:

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

Ось повний список:

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 байт, 2 0 DNP)

Змінити: збережено 203 байти завдяки jimmy23013 та реалізовано 2 DNP завдяки Mego

Ця відповідь сильно зловживає щедрою природою PHP. Більшість випадків мають одну з цих форм (7 байт у кожному):

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

PHP перетворює букви з обох сторін оператора в рядки, потім виконує відповідну побітову операцію, перетворюючи кожну рядок у її значення символу ASCII і, нарешті, перетворює результат назад в символ.

У першому прикладі вище, Y^xстає 89^78. Результатом цього є те 33, що потім надсилається в STDOUT як символ !.

Сценарій був написаний, щоб забезпечити всі можливі комбінації: результати можна знайти тут .

Винятки:

;є <?=Z^a?>(8 байт)
|- це <?='9'^E;(9 байт)

<і ?зазвичай буде DNP через необхідний тег старту, але, використовуючи -rпрапор, код може бути виконаний без них:

<є echo Z^f;(9 байт)
?є echo Z^e;(9 байт)
=є echo Z^g;(9 байт)

Оцінка:

(7 * 90) + 8 + 9 + 9 + 9 + 9 = 674 байт

Брахілог , 546 477 байт

Кредити для Fatalize для коду для @.

У нижченаведеному списку перший символ - це символ, який слід надрукувати (для зручного ознайомлення).

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

Всі вони є предикатами, тому Zмає бути аргументом для отримання результату: Спробуйте це в Інтернеті!

Пояснення

@P це рядок:

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

який містить кожен друкований ASCII.

> <> , 531 байт

Програми приймають дві основні форми:

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

Перший - для символів з кодовими символами, які мають два коефіцієнти менше 16, другий - для інших випадків. Більшість цифр, для яких я використовую другу форму, мають багато рішень однакової довжини, але я вибрав цю для читабельності.

Винятки:

" 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

Повний список:

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

Шестикутник , 376 373 байт, 1 ДНП

Завдяки FryAmTheEggman за збереження 3 байтів.

Практично всі програми мають однакову форму:

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

Однак є кілька винятків:

• Не можна друкувати ;без використання ;, отже, 1 DNP.
• Для друку @ми не можемо використовувати @для припинення програми. Замість цього ми використовуємо S2;:або S3;%. Це закінчується помилкою поділу на нуль, але ця помилка не відображається на STDOUT. Так що це ще чотири байти.
• Є одна сутичка, для Uякої знадобиться U3;@. Існує кілька способів виправити це, включаючи перехід на малі регістри, тобто n9;@, або збільшення приросту чи зменшення, тобто T);@або V(;@. У будь-якому випадку це все-таки чотири байти.
• Краї пам'яті инициализируются до 0, і !друкує ціле значення, так що ми можемо отримати 0і 1з !@і )!@, відповідно, заощаджуючи 3 байта.

Що стосується того, як <letter><digit>;@працюють програми: шестигранна компонування програми форми 1234завжди є

 1 2
3 4 .
 . .

Оскільки жодна з програм не містить команд, які перенаправляють керуючий потік, це просто лінійні програми, які виконуються в порядку.

У кожному випадку буква на початку коду встановлює поточний край пам’яті своєму коду символів. Наприклад , в програмі P1;@, то Pвстановлює значення 80. Потім цифра помножує це значення на 10 і додає себе (тобто цифра додається до поточного значення). Це наведено 801у наведеному вище прикладі. Нарешті, ;друкує це значення, беручи його за модулем 256 та використовуючи його як байтове значення. У цьому випадку 801 % 256 = 33і !друкується а.

Пробіл , 1643 байт, 1 DNP

17 байт для символів [33-63] та 18 байт для символів [64-126]

У Whitespace це прямо вперед, тому що символи для друку (крім простору) взагалі не мають жодного значення:

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

Програма вище виводить "!" (100001b). Змініть [TAB][SPACE][SPACE][SPACE][SPACE][TAB]у першому рядку будь-який символ, який вам подобається. Не можна надрукувати пробіл, не використовуючи пробіл, оскільки друк будь-чого завжди починається[TAB][LF][SPACE]

Сітківка , 712 байт, 2 ДНП

Це було спільним зусиллям з FryAmTheEggman.

Існує кілька класів рішень. Для більшості символів від простору до ^ми використовуємо програму наступної форми:

_
T`w`p

Символ у другому рядку повторюється через діапазони, _0-9A-Za-zа решта залишається незмінною. Це перетворює порожній вхід у цей символ, а потім замінює його на друкований символ ASCII (представлений символом p) у відповідному положенні. Кожна з цих програм має 8 байт.

У цьому діапазоні є лише кілька винятків. Найголовніше цифри можна скоротити:

• 0: x(підраховує кількість xs на порожньому вході)
• 1:  (weehoo, порожня програма; підраховує кількість порожніх збігів у порожньому вході)

• 2: тепер ми перетворимо вхід в один символ, перш ніж рахувати порожні рядки:

  
  1
  
  

• 3: те саме, але ми перетворимо вхід на два символи:

  
  11
  
  

• 4: Ви отримуєте ідею ...

  
  111
  
  

• 5 - 9: вивертання сюжету ... ми використовуємо повторення символів, щоб уникнути отримання другого рядка:

  
  4$*
  
  

  ...

  
  8$*
  
  

Інший виняток - Tце DNP: ми не вважаємо, що неможливо генерувати нецифровий символ без того, щоб він з'явився у вихідному коді, якщо етапи транслітерації неможливо використовувати.

Про залишилися символи. Для друку _ми використовуємо аналогічну програму, як загальне рішення вище:

0
T`0`w

Використання факту, що wпочинається з _.

Далі `- другий DNP, оскільки необхідні і етапи транслітерації.

Тоді більшість малих літер друкується приблизно так (що друкує a):

_
T`w`l

Знову характер на другому рядку збільшується наскрізь _0-9A-O. Тут нам просто потрібно стежити lі w, що ми можемо надрукувати відповідно за допомогою наступних програм:

P
T`p`w

6
T`p`l

Нарешті, {|}~залишилися лише ті , для яких потрібно 9 байт. Тут ми використовуємо етап транслітерації для збільшення символу, який передує їм. Наприклад, ~можна надрукувати за допомогою:

}
T`_p`p

Пайк, 364 362 355 байт

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

Все у формі w<chr(charcode+32)>.C(4 байти), крім:

• -> d1 байт
• 0-> Z1 байт
• 1-> ~W2 байти
• a-> Gh2 байти
• z-> Ge2 байти
• Перші 10 малих букв алфавіту (крім a) у формі G<number>@(3 байти)
• k-> GT@3 байти
• >-> ~Bh3 байти
• ]-> ~Be3 байти
• Z-> ~le3 байти
• 9-> ~ue3 байти
• w-> G22@4 байти
• .-> ~B4@4 байти
• C-> ~K38@5 байт

Інтернет-перекладач Pyke

JavaScript (ES6), 1083 1068 байт

Загальна форма:

alert`\xhex`

Винятки:

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`

Редагувати: Збережено 15 байт завдяки @ GOTO0.

05AB1E , 417 байт

!   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

Пояснення

Більшість з них 5 байт довжиною форми: convert nr to base nr+1.
>потрібен додатковий байт, оскільки для цього ми не можемо використовувати приріст.

a,b,x,y,z,Y,Zвитягуються з Aяких містить алфавіт у малому регістрі.

A,B,C,D,E,F - це числа, перетворені в шістнадцятковий.

0-9 є простими приростами / зменшеннями, а також заздалегідь заданими змінними.

Marbelous, 220 байт

Для символу, який не є цифрою, це лише дві великі шістнадцяткові цифри коду символу. Наприклад, такі програми A:

41

Для такої цифри 3замініть 2Fу наступному коді великі шістнадцяткові цифри коду символу - 1:

2F
++

Для 3:

66
>>

Загальна оцінка: 2 * 85 + 5 * 10 = 220.

Перекладач.

Моя перша спроба була Bubblegum, і вона раніше не працювала для персонажів ?...

Perl 6: 921 байт

Переклад рішення Python.

Кожна програма має форму say "\x<hex escape code>", крім:

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

Для довідки та зручності тестування, ось повний перелік програм, розділених новими рядками.

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

Ось код, який я використав для перевірки вищевказаного списку та підрахунку балів:

#!/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 байт, 7 ДНП

Більшість програм є main=putChar '\xx'або main=putChar '\xxx'де xx/ xxxє кодом ascii діаграми, що підлягає друкуванню. Це працює для всіх, крім 14 символів:

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

Однак для цифр можна зберегти 1 7 4 байти (завдяки Крістіану Сіверсу!):

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

52 програми до c(код 99) займають 18 байт, решта 19 - по 19 байт.

Часткова оцінка: 10*14 + 52*18 + 19*19 = 1437

Для 7 з інших символів працюють наступні програми:

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

Часткова оцінка: 18 + 22 + 18 + 21 + 19 + 27 + 27 = 152

Це залишає 7 ДНП: =aimnrt

Кожна програма Haskell повинна визначати main ( main=), так що це 5 DNP. Для друку на STDOUT, putChar, putStrабо interactможе бути використаний, отримуючи tі в rякості додаткових DNPS. (Існує print, однак, print 'a'друкує, 'a'а не a- і також містить tі rвсе одно.) Haskell також має chrфункцію, яка повертає відповідне знака, яке задане номером, однак для того, щоб використовувати його import Data.Charпотрібно.

Загальна оцінка: 1437 + 152 = 1589 7 ДНП

BBC Basic, 422 413 байт

Завантажте перекладача безкоштовно на http://www.bbcbasic.co.uk/bbcwin/bbcwin.html

9 байт збережено завдяки Leaky Nun.

Загальна форма

V.<character code>

32..99 без урахування 12 особливих випадків: 56x4 = 224 байт

100..126 : 27х5 = 135 байт

12 особливих випадків: 54 байти

Більшість цифр відповідають загальній формі, але я включив їх сюди, щоб показати, де проблема.

Перший символ - це символ, який слід надрукувати.

. 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

Мінколанг 0,15 , 604 байт

Для більшості персонажів "<char-1>"1+O.було б дійсною програмою, можливо, однією з найкоротших. Однак через те, що символи зберігаються як кодові точки на стеці, це означає, що багато з них можна створити шляхом множення та додавання у п’ять байт чи менше. Крім того , зверніть увагу , що l, $1, $2, $3, $4, $5, $6, $lє 10, 11, 12, 13, 14, 15, 16, 100відповідно.

Формат: <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.

Спеціальні згадки:

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

(Спробуйте.) Minkolang має можливість змінювати символи в кодовому полі, тому те, що ця програма робить, це те, що вона замінює те, що -в кінці ., на що необхідно для зупинки програми. "N"1+d90pN.для Oробіт так само.

4: lZIO.

(Спробуйте.) lZ Висуває великі і малі алфавіти до стеку, і Iвисуває довжину стека, яка становить 52, саме кодову точку "4". Найкраща частина полягає в тому, що я спочатку розглядав рішення 4$3*O., яке помножує 4 і 13, щоб отримати 52, але не міг, оскільки в ньому було 4, тож я все-таки знайшов рішення про гольфіст!

y: $1d*O.

(Спробуйте.) d Дублює верхню частину стека, так що цей фрагмент коду - це те, що він штовхає 11, дублює його, а потім множує. Альтернативний спосіб записати це був би такий $12;O., який має однакове число байтів.

}: 53;O.

(Спробуйте.) ; - це експоненція, тож це 5 \ 3, щоб отримати 125.

Groovy, 1019 байт

У мене було написано інше рішення Groovy (див. Нижче), але після того як я подав його, я трохи більше розкопався у втечах персонажів, сподіваючись знайти спосіб скоротити програму більше, і виявив, що у Groovy є восьмикутний втеча персонажа, який я не знав. Це значно спрощує код до того, що він, на жаль, усуває потребу майже у всіх химерних способах вирішення, які я придумав.

Це також виглядає майже ідентично рішення Copper's Python 2 , до того моменту, як це, в основному, схоже на те, що я плагіат їх роботи. Тьфу.

Кожна програма має форму print'\<octal value>', крім:

• p, r, i, n, t→ 'print''\<octal value>'(але з согласующей буквою «друк» , також замінюється значенням вісімкового)
• 0- 9→print~-<next int>

Ось повний список програм за характером.

    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 байт

Моя попередня програма, перш ніж я виявив, що восьмигранні втечі існують. Набагато цікавіше, ІМО.

Кожна програма має форму print(--'<next char>'), крім:

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

Ось повний список програм для кожного персонажа:

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

Власне , 383 382 381 байт

1 байт завдяки Mego.

Для легкої довідки, перший стовпець - код символів, другий стовпець - символ, а третій - це код.

Код для 0- це єдиний пробіл.

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

Спробуйте в Інтернеті!

Пропозиції з гольфу вітаються.

Фур’є, 306 байт, 1 ДНП

Практично всі програми слідують шаблону, naде n - код символів кожного з символів. Наприклад:

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

Спробуйте в Інтернеті!

Тому я просто перерахую винятки:

0 (нуль)

Оскільки в акумуляторі встановлено нуль, ми можемо відобразити це за допомогою одного символу:

o

Спробуйте в Інтернеті!

1

Аналогічно нулю, це збільшує акумулятор, щоб отримати 1.

^o

Спробуйте в Інтернеті!

5

Код ASCII для 5 - 53, тому мені довелося обійти це питання:

6vo

Спробуйте в Інтернеті!

а

Через aте, що це функція виведення символів, немає іншого способу створити символ a, тому це моя єдина НЕ ПРОГРАМА .

Дивіться всі програми тут

Матлаб, 1238 1224 байт, 2 ДНП

Основний зразок:

disp([<char code> ''])

Для цифр це трохи коротше:

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

Для персонажів []'це:

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

Персонажі dsз dispвідображаються за допомогою fprintf( спасибі @Stewie Griffin ); ipоднак належу і там, тому я перекладаю рядок і використовую eval:

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

Обидва символи (), однак, необхідні для dispабо eval, тому вони є DNP.

Для ознайомлення з усім списком:

    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

Желе (неконкурентоспроможне), 406 байт

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Ọ

Це друкує всіх символів від 32 до 126. Кількість байтів обчислюється за допомогою https://mothereff.in/byte-counter .

Спробуйте в Інтернеті!

Befunge-93, 530 байт

Найпростіший спосіб виведення символу, фактично не використовуючи цей символ, - це обчислити значення ASCII і використовувати команду ,(виведення символів) для його надання. Наприклад,49*,@ виводить символ долара (ASCII 36, 4 * 9). Це рідко є найбільш оптимальним, оскільки для обчислення для більшості значень потрібно більше 3-х байт.

Інший спосіб генерувати число в 3 байти - скористатися тим, що команда g(get) у першій комірці ігрового поля генерує значення ASCII g (порожній стек передбачається заповненим нулями, тому це зчитування значення ігрового поля на 0,0). Таким чином g1+,@отримує вас h , і g1-,@отримує вас f . Це, очевидно, працює для цілого ряду компенсацій, а також можливі й інші операції, ніж +і -є. Так, наприклад, g3/,@ви отримуєте подвійну цитату.

Варіація цього - передувати gкоманді, яка залишає всі нулі на стеку. Таким чином, ви все ще читаєте значення з ігрового поля в 0,0, але характер, який читається, зараз інший. Це коштує ще один байт, але ви отримуєте доступ до багатьох інших значень. Наприклад, 0g1-,@отримує нахил вперед і :g1+,@отримує крапку з комою. Інші життєздатні префікси *, +, -, >, \і _. І знову зауважте, що можливі й інші операції: >g2*,@отримайте вертикальну смугу.

Подальшим варіантом є передувати знаку ga 1, тож тепер ви вже не читаєте з 0,0, а з порожньої комірки на 0,1. У Befunge порожні комірки ініціалізуються пробілами за замовчуванням, тому 1g,@ви отримуєте пробіл та 1g1+,@отримуєте знак оклику.

Для знакових цифр існує більш сумнівний трюк, який ми можемо використовувати. Замість того, щоб намагатися виводити їх як символи, ми виводимо їх як числа (невелике число легше генерувати, ніж його еквівалент ASCII). Так, наприклад, 11+.@дає 2 , і, зокрема, відзначте особливі випадки: .@для 0 , і !.@для 1 . Сумнівною частиною цього є те, що числовий вихід у Befunge включає пробіл після числа, тому це не є чистим вихідним символом.

Ще одна сумнівна хитрість, яку ми можемо використати, - це варіант gвищезазначеної техніки. Замість обмеження себе командами Befunge для префікса, ми можемо також технічно використовувати будь-який символ, який не є командою Befunge. У більшості інтерпретаторів нерозпізнана команда буде ігноруватися, тому в gкінцевому підсумку буде прочитано значення ASCII попереднього символу. Це дозволяє нам генерувати більшість інших значень ASCII, які інакше не могли бути обчислені в 3 байтах. Як один із прикладів: Qg1+,@отримує тебе R .

Нарешті, є три особливих випадки. Г не може бути згенерований в менш ніж 5 байт, тому ми повинні вдаватися до "f"1+,@. Кома є найбільш складною, що вимагає динамічної модифікації лопая: 0g4-:80p @. Ми могли б використовувати аналогічну техніку, щоб уникнути символу at, але більш ефективним злом є використання команди %(modulo) як термінатора, тобто 88*,%. Коли значення %досягається, на стеку нічого немає, тому обчислення модуля генерує поділ на нуль, а на еталонному інтерпретаторі це припинить програму.

Нижче наведено повний список програм, по одній на рядок.

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