На языке программирования по вашему выбору напишите 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 и полностью пропустить программы для них. Таким образом, синтаксически строгие языки смогут конкурировать.

Победившим ответом является ответ с наименьшим количеством баллов из набора ответов с наименьшим числом DNP.

правила

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

  • Примечание: это правило кажется необходимым, но есть много языков с разными кодировками, и я уверен, что было бы здорово увидеть ответы на них. Поэтому вы можете нарушить это правило , вы можете использовать любые символы, которые захотите, но тогда ваш ответ станет неконкурентным , он не сможет победить.

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

• Вывод каждой программы должен идти на стандартный вывод или принятую альтернативу вашего языка.

• Программы не должны запрашивать или требовать ввода. (Если запрос на ввод данных присущ вашему языку, это нормально.)

• Программы должны быть детерминированными, конечными во время выполнения и независимыми. например, это не должно иметь значения, если один запускается в папке отдельно от других программ.

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

Обязательно включите в свой ответ информацию обо всех 95 (в идеале) программах, а также свои оценки и любые оценки DNP. Вам не нужно перечислять все программы , которые следуют простому шаблону , как « , ...» , но убедитесь , что вы будете уверены , что все они будут работать , и что ваш счет правильно добавлен.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 байт
• '=> 39c3 байта
• )=> '*(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 байт

Ну ... Короче, чем Java, я думаю ...

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

Большую часть времени это просто следует шаблону:

1. Сделайте некоторые, xorчтобы получить указатель до конца.
2. subиз последних 2 слов, потому что код операции 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
....

За исключением

• Digits. Вот программы для 0-9:

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

• «С». Эта программа

  '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");}}(но с \tзаменой s на необработанные вкладки)
• " → 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

фу

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

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

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(), который вернет значение null (и, следовательно, заставит код бросить 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], erroring на символ. Например, '2+oJвыходов L, что на два больше, чем J.
  • 'код "-oH, использующий "вместо.
  • -код '%oB, использующий %вместо.

• ln;: Толкать длину стека, выводить как num, затем останавливать, давая 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;

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

WolframAlpha , 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 как символ !.

Был написан сценарий, чтобы перебить все возможные комбинации: результаты можно найти здесь .

Исключения:

;is <?=Z^a?>(8 байт)
|is <?='9'^E;(9 байт)

<и ?обычно это DNP из-за обязательного начального тега, но с помощью -rфлага код можно выполнить без них:

<is echo Z^f;(9 байт)
?is echo Z^e;(9 байт)
=is 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м
@H: 5 м
- @P: 13 м
, @P: 14m
/ @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: 27m
<@P: 28 м
= @P: 29 м
> @P: 30 м
? @P: 31m
@ "?": "А" ибх
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 млн @ у
Q @P: 49 м
R @P: 50 м
S @P: 51 м
Т @Р: 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 м
@Vh
б @ ч
c @Dbh
д @ А: 3 м
E @Vbh
F @A: 5 м
г @ А: 6 м
ч @ а: 7 м
я @А: 8м
J @A: 9 м
к @ С: 7м
л @ С: 8 м
м @ д @ 2ч
п @ А: 13 м
о @H: 4 м
р @ А: 15 м
q @Z: 9 м
r @Z: 8 м
с @ Z: 7 м
т @ з: 6 м
ты @Vt
V @Z: 4 м
w @Qt
x @ Z: 2 м
у @ Вт
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 DNP

Спасибо 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 DNP

Это было совместное усилие с FryAmTheEggman.

Есть несколько классов решений. Для большинства символов от пробела до ^мы используем программу следующего вида:

_
T`w`p

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

В этом диапазоне есть только несколько исключений. Самое главное, цифры могут быть сокращены:

• 0: x(считает количество xs в пустом входе)
• 1:  (крошечный, пустая программа; подсчитывает количество пустых совпадений в пустом входе)

• 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 DNP.

Большинство программ находятся 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 DNP: =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 : 27x5 = 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 байт благодаря Мего.

Для удобства: первый столбец - это код символа, второй столбец - это символ, а третий столбец - это код.

Код для 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 DNP

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

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

Попробуйте онлайн!

Поэтому я просто перечислю исключения:

0 (ноль)

Так как аккумулятор предустановлен на ноль, мы можем отобразить это, используя один символ:

o

Попробуйте онлайн!

1

Подобно нулю, это увеличивает аккумулятор, чтобы получить 1.

^o

Попробуйте онлайн!

5

Код ASCII для 5 - 53, поэтому мне пришлось обойти это:

6vo

Попробуйте онлайн!

a

Из-за aтого, что это функция вывода символов, нет другого способа создать символ a, так что это моя единственная НЕ ПРОГРАММА .

Посмотреть все программы здесь

Matlab, 1238 1224 байта, 2 DNP

Основной шаблон:

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*,@вы получите вертикальную черту.

Еще одним вариантом является предшествование gс 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 @. Мы могли бы использовать подобную технику , чтобы избежать на характер, но более эффективный хак использовать %команду ( по модулю) в качестве терминатора, то есть 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*,@