用您选择的编程语言编写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个程序中的每一个都尽可能短。您的分数是所有程序的字符长度之和。

如果由于某种原因您无法为某些字符编写有效的程序，则可以将这些字符标记为“ Did Not Program”或DNP，并完全省略它们的程序。这样，语法严格的语言就可以竞争。

获奖的答案是，有得分最低的答案中的一组拥有最少的DNP的答案。

规则

• 您所有程序的源代码只能包含可打印的ASCII加上制表符和换行符，所有这些都被视为一个字符。（由于采用了不同的编码，因此很容易省略不存在的字符！）

  • 注意：此规则似乎是必需的，但是有许多语言使用不同的编码，我敢肯定看到它们的答案会很酷。因此，您可以打破这条规则，可以使用任何想要的字符，但是您的答案将变得不具有竞争力，因此无法取胜。

• 根据您语言的标准约定，程序必须是实际的完整程序。不允许使用功能和REPL代码段。

• 每个程序的输出应转到stdout或您的语言可接受的替代方案。

• 程序不应提示或要求输入。（如果提示输入是您的语言固有的，那么可以。）

• 程序应具有确定性，运行时有限且独立。例如，一个文件是否在与其他程序分开的文件夹中运行没关系。

• 程序的输出应该是与之对应的可精确打印的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个字节
• '=> 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

DOS的ASCII受限x86机器代码， 3104 3101 2913字节

好吧...它比Java短，我想...

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

笨蛋， 1770年 1710 1703 1686字节

Dennis保存了60个字节Sp3000 保存了
17个字节

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编写完整程序所附带的所有样板。

现在根本没有任何DNP！谢谢，凯文·克鲁伊森！

大多数程序具有以下形式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

ew

Java编译器像\u007B执行任何其他处理之前一样处理Unicode转义，这使得编写使用标识符甚至关键字中的Unicode转义的代码成为可能。因此，要编写一个不使用样板中存在的字符的程序，我们只需将其替换为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");}}

请注意，如果您从OS的本机终端（在Windows上，并且我假设在Linux / OSX上）以外的任何地方调用，则for的程序u会使用System.console()，它将返回null（并因此导致代码引发）。 。NullPointerExceptioncmdbash

要进行测试，请创建一个新目录，并将上面的代码放入该目录中命名的文件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（除了prints文件，该文件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

该批处理文件采用略有不同的方法。它不是逐行预分割，而是逐行处理文件并依次编译和运行每个程序。同样，它会在完成后删除证据。

凯文·克鲁伊森（Kevin Cruijssen）节省了无数字节+ 1个DNP！

> <> ，443个 437字节

TIO解释器链接。这里有很多模式：

• [num][num]*o;：将两个数字相乘，然后将结果输出为char 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]on [char]，对char出错。例如，'2+oJ输出L是的两倍J。
  • '的代码是"-oH，"改为使用。
  • -的代码是'%oB，%改为使用。

• ln;：推栈的长度，以num的形式输出，然后停止，给出0。同样lln;的1和'ln;为3。

• 4|n+：按4，弹开|，然后再按4，加，然后输出8为num。|再次弹起，并尝试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）char替换了几次。

      '-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 字节

（非竞争性，因为实际上不能仅使用ASCII来编写APL）

多数格式为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

Ruby，869字节

对于63个字符@通过~，我们有一个10字节的解决方案：

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

对于从大多数（21）个字符space通过?，我们有一个9字节的溶液：

puts"\xx"     (2 digit octal code)

尚有11种特殊情况：

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

编辑：感谢jimmy23013，节省了203个字节；感谢Mego，实现了2个DNP

这个答案严重滥用了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字节

Brachylog，546个 477字节

归功于Fatalize的代码@。

在下面的列表中，第一个字符是要打印的字符（为便于参考）。

  @S
！@H T
“ @P：2m
＃@P：3m
$ @P：400万
％@P：5m
＆@P：600万
'@P：700万
（@P：8m
）@P：9m
* @P：10m
+ @P：11m
，@H：5m
-@P：1300万
。@P：14m
/ @P：1500万
0 1
1 0+
2 1+
3 2+
4 3+
5 4+
6 5+
7 6+
8 7+
9 8+
：@ P @ 4bhbbbh
; @P：27m
<@P：28m
= @P：29m
> @P：30m
？@P：31m
@“？”：“ A” ybh
@ Zt @ u
B @ Ch @ u
C @P：35m
D @P：36m
E @P：37m
F @P：38m
G @P：39m
高@P：40m
我@P：41m
J @P：42m
K @P：43m
L @P：44m
男@P：45m
N @P：46m
O @P：47m
P @A：15m @ u
Q @P：49m
R @P：50m
S @P：51m
电话@P：52m
U @ Vt @ u
V @P：54m
W @ Qt @ u
X @P：56m
是@ Wt @ u
Z @ At @ u
[@P：59m
\ @P：60m
] @P：61m
^ @P：62m
_ @P：63m
`@P：64m
@Vh
b @Ch
c @Dbh
d @A：3m
e @Vbh
f @A：5m
g @A：6m
h @A：7m
我@A：8m
j @A：9m
k @C：7m
l @C：8m
m @ D @ 2ht
n @A：13m
o @H：4m
p @A：15m
q @Z：9m
r @Z：8m
s @Z：7m
t @Z：6m
你@Vt
v @Z：4m
w @Qt
x @Z：2m
y @Wt
z @在
{@P：91m
| @P：92m
} @Prbh
〜@铂

它们都是谓词，因此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;

Hexagony，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，a !被打印。

空格，1643字节，1 DNP

字符[33-63]为17个字节，字符[64-126]为18个字节

在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，其余字符保持不变。这会将空的输入转换为该字符，然后p在相应位置将其替换为可打印的ASCII字符（由表示）。这些程序每个都是8个字节长。

在此范围内，只有少数例外。最重要的是，数字可以缩短：

• 0 ：（x计算x空输入中的s 数）
• 1：  （weehoo，空程序；计算空输入中的空匹配数）

• 2：现在我们将输入变成单个字符，然后再计算空字符串：

  
  1
  
  

• 3：一样，但是我们将输入变成两个字符：

  
  11
  
  

• 4：你有主意...

  
  111
  
  

• 5-9：情节扭曲...我们使用字符重复来避免第二行变得更长：

  
  4$*
  
  

  ...

  
  8$*
  
  

另一个例外是TDNP：如果无法使用音译阶段，我们认为如果不在源代码中不出现非数字字符，就不可能生成非数字字符。

其余字符。要进行打印，_我们使用与上述常规解决方案类似的程序：

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个字节

在线派克口译员

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`

编辑：由于@ GOTO0，节省了15个字节。

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字节可以保存（感谢Christian Sievers！）：

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

最多c（代码99）的52个程序占用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。要打印到标准输出，putChar，putStr或interact可使用，产生t和r作为进一步DNPS。（还有print，但是print 'a'打印'a'而不是a-并且也包含t和r。）Haskell还具有一个chr函数，该函数可以在给定数字的情况下返回相应的char，但是要使用它，import Data.Char是必须的。

总分： 1437 + 152 = 1589 7个DNP

BBC基础，422个 413字节

可在http://www.bbcbasic.co.uk/bbcwin/bbcwin.html免费下载口译员

感谢Leaky Nun，节省了9个字节。

一般形式

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字节

对于大多数字符，"<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的Python 2解决方案完全相同，以至于看起来我I窃了他们的工作。啊。

每个程序具有以下形式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字节

在发现八进制转义存在之前，我的上一个程序已经存在。IMO，更有趣。

每个程序具有以下形式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 DNP

几乎所有程序都遵循以下模式na，其中n是每个字符的字符代码。例如：

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

在线尝试！

因此，我只列出例外情况：

0（零）

由于累加器预设为零，因此我们可以使用单个字符显示它：

o

在线尝试！

1个

类似于零，这使累加器递增至1。

^o

在线尝试！

5

5的ASCII码是53，因此我必须解决此问题：

6vo

在线尝试！

一种

由于a是字符输出函数，因此没有其他方法可以产生字符a，因此这是我唯一的DID NOT PROGRAM。

在这里查看所有程序

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格里芬）; 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个字节的数字的另一种方法是利用以下事实：在gplayfield的第一个单元格中的（get）命令将生成g的ASCII值（假定一个空堆栈填充有零，所以它是读取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 @。我们可以使用类似的技术来避免使用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*,@