Trong ngôn ngữ lập trình bạn chọn, hãy viết 95 chương trình, mỗi chương trình sẽ tạo ra một trong số 95 ký tự ASCII có thể in khác nhau mà không có ký tự đó xuất hiện ở bất kỳ đâu trong chương trình .

Ví dụ: nếu ngôn ngữ của bạn là Python , chương trình của bạn xuất ký tự Pcó thể là

print(chr(80))

bởi vì Pcó mã ASCII 80. Chương trình này hợp lệ vì Pkhông bao giờ xuất hiện trong mã nguồn. Tuy nhiên, đối với chương trình xuất chữ thường p, đại loại như

print(chr(112))

sẽ không hợp lệ bởi vì, trong khi nó in p, pcó trong mã. Một chương trình hợp lệ có thể là

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

mà in pnhưng không chứa p.

Mục tiêu của bạn là làm cho mỗi chương trình trong 95 chương trình của bạn càng ngắn càng tốt. Điểm của bạn là tổng độ dài ký tự của tất cả các chương trình của bạn.

Nếu vì bất kỳ lý do nào bạn không thể viết chương trình hợp lệ cho một số ký tự, bạn có thể đánh dấu các ký tự đó là "Không lập trình" hoặc DNP và bỏ hoàn toàn các chương trình cho chúng. Bằng cách này, các ngôn ngữ nghiêm ngặt về mặt cú pháp sẽ có thể cạnh tranh.

Câu trả lời chiến thắng là câu trả lời có số điểm thấp nhất của tập các câu trả lời rằng có ít nhất DNP của.

Quy tắc

• Mã nguồn của tất cả các chương trình của bạn chỉ có thể chứa các tab và dòng mới ASCII có thể in được , tất cả đều được tính là một ký tự. (Bởi vì trong một mã hóa khác, sẽ dễ dàng bỏ qua các ký tự không tồn tại!)

  • Lưu ý: Quy tắc này có vẻ cần thiết nhưng có nhiều ngôn ngữ với các bảng mã khác nhau và tôi chắc chắn sẽ rất tuyệt khi xem câu trả lời cho chúng. Do đó, bạn có thể phá vỡ quy tắc này , bạn có thể sử dụng bất kỳ ký tự nào bạn muốn, nhưng sau đó câu trả lời của bạn trở nên không cạnh tranh , nó không thể thắng.

• Các chương trình phải thực tế, đầy đủ các chương trình , theo quy ước chuẩn của ngôn ngữ của bạn. Chức năng và đoạn REPL không được phép.

• Mỗi đầu ra của chương trình sẽ đi đến thiết bị xuất chuẩn hoặc ngôn ngữ thay thế được chấp nhận của bạn.

• Các chương trình không nên nhắc hoặc yêu cầu đầu vào. (Nếu lời nhắc nhập liệu là ngôn ngữ của bạn, thì không sao.)

• Các chương trình nên mang tính quyết định, hữu hạn trong thời gian chạy và độc lập. ví dụ: không có vấn đề gì nếu một chương trình được chạy trong một thư mục tách biệt với các chương trình khác.

• Đầu ra của một chương trình phải là ký tự ASCII có thể in chính xác mà nó tương ứng, theo sau là một dòng mới duy nhất, không hơn, không kém.

Hãy chắc chắn bao gồm thông tin về tất cả 95 chương trình (lý tưởng) trong câu trả lời của bạn, cũng như điểm số của bạn và bất kỳ DNP nào. Bạn không cần phải liệt kê tất cả các chương trình mà làm theo một mô hình đơn giản như " , ..." nhưng chắc chắn rằng bạn chắc chắn họ đều sẽ làm việc và điểm số của bạn được thêm vào một cách chính xác.print(chr(80))print(chr(81))print(chr(82))

Để tham khảo, đây là 95 ASCII có thể in được mà các chương trình của bạn phải xuất ra:

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

Python 2, 1075 1065 1043 1040 1039 byte

Mỗi chương trình có hình thức print'\<octal char code>', ngoại trừ:

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

Để tham khảo và dễ kiểm tra, đây là danh sách đầy đủ các chương trình, phân tách dòng mới.

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'

Để kiểm tra:

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

-1 byte nhờ @ Sp3000!

CJam, 269 byte

Mỗi chương trình đều ở dạng '<char - 1>)ngoại trừ:

• Dung lượng => S, 1 byte
• '=> 39c, 3 byte
• )=> '*(, 3 byte
• 0=> T, 1 byte
• 1=> X, 1 byte
• 2=> Y, 1 byte
• 3=> Z, 1 byte
• 4- 9=> <num-1>), 2 byte

Điểm là: 3 * 82 + 1 + 3 + 3 + 4 * 1 + 6 * 2 = 269

ASCII ràng buộc mã máy x86 cho DOS, 3104 3101 2913 byte

Chà ... Nó ngắn hơn Java, tôi đoán ...

32 30 byte cho hầu hết tất cả các ký tự, cho các trường hợp ngoại lệ, xem bên dưới.

Hầu hết thời gian nó chỉ theo mô hình:

1. Làm một số xorđể có được một con trỏ đến cuối.
2. subtừ 2 từ cuối cùng vì opcode cho intkhông có trong ASCII.
3. Nhận 2 vào AHvà nhân vật vào DL. Cả hai đều là xored vì bản thân ký tự không thể xuất hiện trong chương trình và 2 không phải là ký tự ASCII có thể in được.
4. In ký tự với int 21h
5. Thoát với int 20h

Hầu hết thời gian, nếu một nhân vật không được phép, nó có thể được thay thế bằng cách xoay vòng với dữ liệu một chút hoặc chuyển sang một thanh ghi khác.

Sẽ thú vị hơn một chút khi bạn đột nhiên thấy mình không thể trừ hoặc không thể đẩy hoặc bật đăng ký duy nhất có thể sử dụng để tính toán ...

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 byte

60 byte được lưu bởi Dennis
17 byte được lưu bởi Sp3000

DNP: 46 ( .)

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

Tất cả ngoại trừ 43, 45, 60, 62, 91 và 93 đều bị đánh cắp một cách đáng xấu hổ từ Esolangs.org

MATL, 305, 302, 300 297 byte

Mỗi chương trình đều giống như thế này:

33c
34c
35c
....

Ngoại trừ

• Chữ số. Dưới đây là các chương trình cho 0-9:

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

• 'C'. Chương trình này là

  'C'k
  

• không gian. Đây là

  0c
  

  Kể từ hôm nay tôi đã học được rằng MATL coi nhân vật 0 là không gian. Cảm ơn @LuisMendo!

Bạn có thể sử dụng matl.tio để xác minh bất kỳ trong số họ.

Để tham khảo, đây là tất cả chúng:

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 byte

thở dài

Về cơ bản, đây là một cổng của câu trả lời Python 2 của tôi , nhưng với tất cả các mẫu soạn sẵn đi kèm với việc viết một chương trình đầy đủ bằng Java.

Bây giờ không có bất kỳ DNP nào cả! Cảm ơn, Kevin Cruijssen!

Hầu hết các chương trình có hình thức interface A{static void main(String[]a){System.out.print("\<octal char code>");}}, ngoại trừ:

• dấu cách → interface\tA{static\tvoid\tmain(String[]a){System.out.print("\40");}}(nhưng với \ts được thay thế bằng các tab thô)
• " → 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

Phù

Trình biên dịch Java xử lý thoát Unicode như \u007Btrước khi thực hiện bất kỳ xử lý nào khác, điều này cho phép viết mã sử dụng các mã thoát unicode trong mã định danh và thậm chí từ khóa. Vì vậy, để viết một chương trình không sử dụng một ký tự có trong bản tóm tắt, chúng ta chỉ cần thay thế nó bằng một lối thoát unicode.

Để tham khảo và dễ kiểm tra, đây là danh sách đầy đủ các chương trình, được phân tách bằng dòng mới và với các tab thô được thay thế bằng bốn khoảng trắng:

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

Lưu ý rằng chương trình usử dụng System.console(), sẽ trả về null (và do đó khiến mã bị ném NullPointerException) nếu bạn gọi nó từ bất kỳ thứ gì khác ngoài thiết bị đầu cuối gốc của hệ điều hành của bạn ( cmdtrên Windows, và, tôi giả sử, bashtrên Linux / OSX) .

Để kiểm tra, tạo một thư mục mới và đặt đoạn mã trên vào một tệp có tên printablestrong thư mục đó. Sau đó, chạy tập lệnh Bash sau:

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

Kịch bản trên sẽ đặt từng dòng printablesvào thư mục riêng của nó, đặt tên cho tất cả A.java(ngoại trừ tệp được in A, được đổi tên thành B.java), biên dịch từng tệp, chạy chúng, sau đó xóa bằng chứng. Sẽ mất khoảng mười giây để các ký tự ASCII có thể in bắt đầu xuất hiện trong vỏ của bạn.

Nếu bạn đang ở trên Windows, thay vào đó hãy chạy tệp Batch sau:

@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

Tập tin lô này có một cách tiếp cận hơi khác nhau; thay vì chia trước các dòng, nó xử lý từng dòng tệp và biên dịch và chạy lần lượt từng chương trình. Một lần nữa, nó xóa các bằng chứng sau khi nó kết thúc.

Đã lưu vô số byte + 1 DNP nhờ Kevin Cruijssen!

> <> , 443 437 byte

Liên kết phiên dịch TIO . Có rất nhiều mẫu ở đây:

• [num][num]*o;: Nhân hai số, sau đó xuất kết quả dưới dạng char với ovà tạm dừng với ;. > <> chữ số lên tới 15, tức là 0123456789abcdef.
  • Tương tự [num][num]-n;, thay vào đó, lấy sự khác biệt của hai số và đầu ra làm một số n.

• '-o[invalid char]: > <> là hình xuyến, vì vậy khi con trỏ lệnh đến cuối dòng, nó sẽ quay trở lại điểm bắt đầu. Trong trường hợp này, điều này làm cho mã được thực thi hai lần, tức là '-o[char]'-o[char]. Phần đầu tiên '-o[char]'đẩy ba ký tự vào ngăn xếp, -tính toán 'o' - [char]sau đó đưa ora kết quả dưới dạng một ký tự. > <> sau đó lỗi khi nó đạt được [char], do một lệnh không được nhận dạng hoặc do xuất hiện một ngăn xếp trống.

  • Tương tự '-n[invalid char], mà đầu ra là một số.
  • Tương tự '[num][op]o[invalid char], áp dụng [op]với [num]bật [char], lỗi trên char. Ví dụ, '2+oJđầu ra L, nhiều hơn hai J.
  • 'Mã là "-oH, sử dụng "thay thế.
  • -Mã là '%oB, sử dụng %thay thế.

• ln;: Đẩy chiều dài của ngăn xếp, đầu ra là num rồi dừng lại, cho 0. Tương tự lln;cho 1và 'ln;cho 3.

• 4|n+: Đẩy 4, bật ra |và đẩy 4 khác, thêm, sau đó xuất ra 8dưới dạng num. Thoát ra |một lần nữa và lỗi cố gắng thực hiện nlại trên một ngăn xếp trống.
  • Tương tự 3|n*cho 9.
  • Tương tự [num]|o*cho @Qdy.
• '1-:00p: Điều thú vị nhất, cho otrường hợp. Để tránh sử dụng otrong mã của chúng tôi, chúng tôi cần sử dụng pđể đặt một otrong cơ sở mã, sau đó chạy nó. Ban đầu '1-:00p'thiết lập ngăn xếp lên trên để có một pđỉnh và 1-giảm nó thành một o. :nhân đôi cái này ovà 00pđặt một cái oở (0, 0), biến codebox thành o1-:00p. Con trỏ lệnh kết thúc tốt đẹp, xuất ra cái khác o. Char (0, 0) sau đó được thay thế một vài lần nữa trước khi chương trình cuối cùng bị lỗi.

      '-oO
!     '-oN
"     '-oM
#     '-oL
$     '-oK
%     '-oJ
&     '-oI
'     "-oH
(     '-oG
)     '-oF
*     '-oE
+     '-oD
,     '-oC
-     '%oB
.     '-oA
/     '-o@
0     ln;
1     lln;
2     '-o=
3     'ln;
4     '-o;
5     61-n;
6     '-nh
7     '-ng
8     4|n+
9     3|n*
:     '1-o;
;     '6-oA
<     6a*o;
=     '2+o;
>     '3+o;
?     79*o;
@     8|o*
A     '-o.
B     '-o-
C     '-o,
D     '-o+
E     '-o*
F     '-o)
G     '-o(
H     89*o;
I     '1-oJ
J     '-o%
K     '-o$
L     '2+oJ
M     7b*o;
N     '-o!
O     '5+oJ
P     8a*o;
Q     9|o*
R     '8+oJ
S     '9+oJ
T     7c*o;
U     'b+oJ
V     'c+oJ
W     'd+oJ
X     8b*o;
Y     'f+oJ
Z     9a*o;
[     7d*o;
\     'c-oh
]     'b-oh
^     'a-oh
_     '9-oh
`     8c*o;
a     '7-oh
b     7e*o;
c     9b*o;
d     a|o*
e     '3-oh
f     '2-oh
g     '1-oh
h     '2-oj
i     8d*o;
j     '2+oh
k     '3+oh
l     9c*o;
m     '5+oh
n     ab*o;
o     '1-:00p
p     8e*o;
q     '3-ot
r     '2-ot
s     '1-ot
t     '1+os
u     9d*o;
v     '2+ot
w     '3+ot
x     ac*o;
y     b|o*
z     '6+ot
{     '7+ot
|     '8+ot
}     '9+ot
~     9e*o;

APL Dyalog , 527 522 byte

(không cạnh tranh vì APL thực sự không thể được viết chỉ bằng ASCII)

Hầu hết là ở định dạng nn⊃⎕AVhoặc nnn⊃⎕AV, ngoại lệ là:

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

Đây là toàn bộ danh sách:

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

Đối với 63 ký tự @thông qua ~, chúng tôi có giải pháp 10 byte:

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

Đối với hầu hết (21) ký tự từ spacexuyên qua ?, chúng tôi có giải pháp 9 byte:

puts"\xx"     (2 digit octal code)

Có mười một trường hợp đặc biệt còn lại:

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

Tổng cộng, điểm số là 10 × 63 + 9 × 21 + 10 + 3 + 8 × 4 + 5 = 869.

WolframAlpha , 368 byte

Định dạng chung:

u+<character code in hexadecimal>

Ngoại lệ:

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

Dưới đây là danh sách đầy đủ:

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 byte, 2 0 DNP)

Chỉnh sửa: đã lưu 203 byte nhờ jimmy23013 và triển khai 2 DNP nhờ Mego

Câu trả lời này lạm dụng rất nhiều bản chất hào phóng của PHP. Hầu hết các trường hợp có một trong các hình thức này (mỗi 7 byte):

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

PHP chuyển đổi các chữ cái ở hai bên của người vận hành chuỗi, sau đó thực hiện các hoạt động Bitwise thích hợp bằng cách chuyển đổi mỗi chuỗi giá trị ký tự ASCII của nó, và cuối cùng chuyển đổi kết quả lại để một nhân vật.

Trong ví dụ đầu tiên ở trên, Y^xtrở thành 89^78. Kết quả của việc này là 33, sau đó được gửi đến STDOUT dưới dạng ký tự !.

Một kịch bản đã được viết để bruteforce tất cả các kết hợp có thể: kết quả có thể được tìm thấy ở đây .

Ngoại lệ:

;là <?=Z^a?>(8 byte)
|là <?='9'^E;(9 byte)

<và ?thông thường sẽ là DNP do thẻ bắt đầu được yêu cầu, nhưng bằng cách sử dụng -rcờ, mã có thể được thực thi mà không có chúng:

<là echo Z^f;(9 byte)
?là echo Z^e;(9 byte)
=là echo Z^g;(9 byte)

Ghi bàn:

(7 * 90) + 8 + 9 + 9 + 9 + 9 = 674 byte

Brachylog , 546 477 byte

Tín dụng để Fatalize cho mã cho @.

Trong danh sách dưới đây, ký tự đầu tiên là ký tự được in (để tham khảo dễ dàng).

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

Chúng đều là các vị từ, vì vậy Zcần phải là đối số để nhận đầu ra: Hãy thử trực tuyến!

Giải trình

@P là chuỗi này:

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

có chứa mọi ASCII có thể in được.

> <> , 531 byte

Các chương trình có hai hình thức chính:

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

Đầu tiên là cho các ký tự có mã ký tự có hai yếu tố nhỏ hơn 16, hai là cho các trường hợp khác. Hầu hết các số mà tôi sử dụng mẫu thứ hai có nhiều giải pháp có độ dài bằng nhau, nhưng tôi đã chọn số đó cho dễ đọc.

Ngoại lệ:

" 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

Danh sách đầy đủ:

! 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 byte, 1 DNP

Cảm ơn FryAmTheEggman vì đã lưu 3 byte.

Hầu như tất cả các chương trình có cùng một hình thức:

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

Có một vài trường hợp ngoại lệ:

• Không thể in ;mà không sử dụng ;, do đó 1 DNP.
• Để in @, chúng tôi không thể sử dụng @để chấm dứt chương trình. Thay vào đó chúng tôi sử dụng S2;:hoặc S3;%. Điều này chấm dứt với lỗi chia cho 0, nhưng lỗi đó không hiển thị trên STDOUT. Vì vậy, đây vẫn là bốn byte.
• Có một cuộc đụng độ Umà sẽ yêu cầu U3;@. Có một số cách để khắc phục điều này, bao gồm chuyển sang chữ thường, nghĩa là n9;@, hoặc sử dụng tăng hoặc giảm, tức là T);@hoặc V(;@. Trong mọi trường hợp, nó vẫn là bốn byte.
• Cạnh bộ nhớ được khởi tạo 0, và !sau đó in ra giá trị số nguyên, vì vậy chúng tôi có thể nhận được 0và 1với !@và )!@, tương ứng, tiết kiệm 3 byte.

Về cách thức các <letter><digit>;@chương trình hoạt động: bố cục hình lục giác của một chương trình có dạng 1234luôn

 1 2
3 4 .
 . .

Vì không có chương trình nào chứa bất kỳ lệnh nào điều hướng luồng điều khiển, đây chỉ là các chương trình tuyến tính được thực hiện theo thứ tự.

Trong mọi trường hợp, chữ cái ở đầu mã đặt cạnh bộ nhớ hiện tại thành mã ký tự của nó. Ví dụ, trong chương trình P1;@, Pcác giá trị đặt 80. Sau đó, chữ số nhân giá trị này với 10 và tự thêm vào (tức là chữ số được gắn vào giá trị hiện tại). Điều đó đưa ra 801trong ví dụ trên. Cuối cùng, ;in giá trị này bằng cách lấy modulo 256 và sử dụng nó làm giá trị byte. Trong trường hợp này 801 % 256 = 33và một !được in.

Khoảng trắng , 1643 byte, 1 DNP

17 byte cho các ký tự [33-63] và 18 byte cho các ký tự [64-126]

Trong Whitespace, điều này là thẳng về phía trước, bởi vì các ký tự có thể in (trừ không gian) dù sao cũng không có ý nghĩa gì:

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

Chương trình trên in một '!' (100001b). Thay đổi [TAB][SPACE][SPACE][SPACE][SPACE][TAB]trong dòng đầu tiên cho bất kỳ nhân vật nào bạn thích. Không thể in một không gian mà không sử dụng một khoảng trắng, vì in mọi thứ luôn bắt đầu bằng[TAB][LF][SPACE]

Võng mạc , 712 byte, 2 DNP

Đây là một nỗ lực hợp tác với FryAmTheEggman.

Có một số lớp giải pháp. Đối với hầu hết các ký tự từ không gian đến ^, chúng tôi sử dụng một chương trình có dạng sau:

_
T`w`p

Ký tự trên dòng thứ hai lặp qua các phạm vi _0-9A-Za-ztrong khi phần còn lại không thay đổi. Điều này biến đầu vào trống thành ký tự đó và sau đó thay thế nó bằng ký tự ASCII có thể in (được đại diện bởi p) ở vị trí tương ứng. Mỗi chương trình này dài 8 byte.

Trong phạm vi này, chỉ có một vài ngoại lệ. Quan trọng nhất là các chữ số có thể được rút ngắn:

• 0: x(đếm số xs trong đầu vào trống)
• 1:  (tuần trăng mật, chương trình trống; đếm số lượng kết quả trống trong đầu vào trống)

• 2: bây giờ chúng ta biến đầu vào thành một ký tự, trước khi đếm các chuỗi trống:

  
  1
  
  

• 3: điều tương tự nhưng chúng tôi biến đầu vào thành hai ký tự:

  
  11
  
  

• 4: bạn có ý tưởng ...

  
  111
  
  

• 5 - 9: xoắn cốt truyện ... chúng tôi sử dụng sự lặp lại ký tự để tránh dòng thứ hai dài hơn:

  
  4$*
  
  

  ...

  
  8$*
  
  

Một ngoại lệ khác là TDNP: chúng tôi không nghĩ có thể tạo ra một ký tự không có chữ số mà không xuất hiện trong mã nguồn nếu các giai đoạn chuyển ngữ không thể được sử dụng.

Trên các nhân vật còn lại. Để in _chúng tôi sử dụng một chương trình tương tự như giải pháp chung ở trên:

0
T`0`w

Sử dụng thực tế wbắt đầu với _.

Tiếp theo, `là DNP thứ hai, bởi vì các giai đoạn chuyển ngữ cũng yêu cầu những giai đoạn đó.

Sau đó, hầu hết các chữ cái viết thường được in bằng một cái gì đó như thế này (in ra a):

_
T`w`l

Một lần nữa, nhân vật trên dòng thứ hai tăng dần qua _0-9A-O. Ở đây, chúng ta chỉ cần coi chừng lvà w, chúng ta có thể in với các chương trình sau:

P
T`p`w

6
T`p`l

Cuối cùng, chỉ {|}~còn lại, yêu cầu 9 byte mỗi. Ở đây, chúng tôi sử dụng giai đoạn chuyển ngữ để tăng ký tự đứng trước chúng. Ví dụ: ~có thể được in bằng:

}
T`_p`p

Pyke, 364 362 355 byte

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

Tất cả ở dạng w<chr(charcode+32)>.C(4 byte) ngoại trừ:

• -> d1 byte
• 0-> Z1 byte
• 1-> ~W2 byte
• a-> Gh2 byte
• z-> Ge2 byte
• 10 chữ cái chữ cái viết thường đầu tiên (ngoại trừ a) ở dạng G<number>@(3 byte)
• k-> GT@3 byte
• >-> ~Bh3 byte
• ]-> ~Be3 byte
• Z-> ~le3 byte
• 9-> ~ue3 byte
• w-> G22@4 byte
• .-> ~B4@4 byte
• C-> ~K38@5 byte

Thông dịch viên Pyke trực tuyến

JavaScript (ES6), 1083 1068 byte

Hình thức chung:

alert`\xhex`

Ngoại lệ:

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`

Chỉnh sửa: Đã lưu 15 byte nhờ @ GOTO0.

05AB1E , 417 byte

!   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

Giải trình

Hầu hết là 5 byte dài của mẫu : convert nr to base nr+1.
>cần thêm một byte vì chúng ta không thể sử dụng gia số cho điều đó.

a,b,x,y,z,Y,Zđược trích xuất từ Ađó chứa bảng chữ cái trong trường hợp thấp hơn.

A,B,C,D,E,F là các số được chuyển đổi thành hex.

0-9 là các mức tăng / giảm đơn giản cũng như các biến được xác định trước.

Tuyệt vời, 220 byte

Đối với một ký tự không phải là một chữ số, nó chỉ là hai chữ số hex chữ hoa của mã ký tự. Ví dụ, các chương trình đầu ra sau đây A:

41

Đối với một chữ số không có 3, thay thế 2Ftrong mã sau bằng các chữ số hex chữ hoa của mã ký tự - 1:

2F
++

Dành cho 3:

66
>>

Tổng số điểm: 2 * 85 + 5 * 10 = 220.

Thông dịch viên.

Lần thử đầu tiên của tôi là Bubblegum và nó không hoạt động cho các nhân vật trước đây ?...

Perl 6: 921 byte

Dịch thuật giải pháp Python.

Mỗi chương trình có hình thức say "\x<hex escape code>", ngoại trừ:

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

Để tham khảo và dễ kiểm tra, đây là danh sách đầy đủ các chương trình, phân tách dòng mới.

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

Đây là mã tôi đã sử dụng để kiểm tra danh sách trên và tính điểm:

#!/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 byte, 7 DNP

Hầu hết các chương trình là main=putChar '\xx'hoặc main=putChar '\xxx'nơi xx/ xxxlà mã ascii của char sẽ được in. Điều này hoạt động cho tất cả trừ 14 ký tự:

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

Tuy nhiên, đối với các chữ số 1 7 4 byte có thể được lưu (nhờ Christian Sievers!):

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

52 chương trình lên đến c(mã 99) lấy 18 byte, 19 chương trình còn lại lấy 19 byte mỗi chương trình.

Điểm một phần: 10*14 + 52*18 + 19*19 = 1437

Đối với 7 ký tự còn lại, các chương trình sau hoạt động:

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

Điểm một phần: 18 + 22 + 18 + 21 + 19 + 27 + 27 = 152

Điều này để lại 7 DNP: =aimnrt

Mỗi chương trình Haskell cần xác định một ( main=) chính, vì vậy đó là 5 DNP. Để in để STDOUT, putChar, putStrhoặc interactcó thể được sử dụng, năng suất tvà rDNPs như thêm. (Ngoài ra print, còn có print 'a'in 'a'và không a- và cũng có chứa tvà rdù sao đi nữa.) Haskell cũng có một chrhàm trả về char tương ứng được cung cấp một số, tuy nhiên để sử dụng nó import Data.Charlà cần thiết.

Tổng số điểm : 1437 + 152 = 1589 , 7 DNP

BBC cơ bản, 422 413 byte

Tải xuống thông dịch viên miễn phí tại http://www.bbcbasic.co.uk/bbcwin/bbcwin.html

9 byte được lưu nhờ Leaky Nun.

Hình thức chung

V.<character code>

32..99 không bao gồm 12 trường hợp đặc biệt: 56x4 = 224 byte

100..126 : 27x5 = 135 byte

12 trường hợp đặc biệt: 54 byte

Hầu hết các con số theo mẫu chung, nhưng tôi đã bao gồm tất cả chúng ở đây để chỉ ra vấn đề ở đâu.

Nhân vật đầu tiên là nhân vật được in.

. 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

Chồn 0,15 , 604 byte

Đối với hầu hết các nhân vật, "<char-1>"1+O. sẽ là một chương trình hợp lệ, có lẽ là một trong những chương trình ngắn nhất. Tuy nhiên, do thực tế là các ký tự được lưu trữ dưới dạng các điểm mã trên ngăn xếp có nghĩa là nhiều trong số chúng có thể được tạo ra bằng cách nhân và cộng, trong năm byte hoặc ít hơn. Ngoài ra, lưu ý rằng l, $1, $2, $3, $4, $5, $6, $llà 10, 11, 12, 13, 14, 15, 16, 100tương ứng.

Định dạng: <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.

Đề cập đặc biệt:

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

(Hãy thử.) Minkolang có khả năng sửa đổi các ký tự trong hộp mã, do đó, chương trình này làm gì là nó thay thế -ở cuối ., điều cần thiết để dừng chương trình. "N"1+d90pN.cho Ocác công trình theo cùng một cách.

4: lZIO.

(Hãy thử.) lZ Đẩy các chữ cái in hoa và chữ thường vào ngăn xếp và Iđẩy chiều dài của ngăn xếp là 52, chính xác là điểm mã của "4". Phần tốt nhất là ban đầu tôi đã xem xét giải pháp 4$3*O., nhân 4 và 13 để có 52, nhưng không thể vì nó có 4 trong đó, vì vậy cuối cùng tôi đã tìm ra giải pháp chơi gôn!

y: $1d*O.

(Hãy thử nó.) d Sao chép đỉnh của ngăn xếp, vì vậy những gì đoạn mã này làm là nó đẩy 11, sao chép nó và sau đó nhân lên. Một cách khác để viết cái này sẽ là $12;O., có cùng số byte.

}: 53;O.

(Hãy thử nó.) ; Là lũy thừa, vì vậy, điều này làm 5 ^ 3 để nhận 125.

Groovy, 1019 byte

Tôi đã có một giải pháp Groovy khác được viết lên (xem bên dưới), nhưng sau khi tôi gửi nó, tôi đã đào sâu hơn một chút vào các nhân vật trốn thoát, hy vọng tìm ra cách rút ngắn chương trình nhiều hơn và phát hiện ra rằng Groovy có một ký tự bát phân mà tôi không biết Điều này đơn giản hóa đáng kể mã, đến mức nó không may loại bỏ sự cần thiết của hầu hết các cách giải quyết kỳ quặc mà tôi đã đưa ra.

Nó cũng trông gần giống với giải pháp Python 2 của Copper , đến mức về cơ bản trông giống như tôi đạo văn công việc của họ. Ừ

Mỗi chương trình có hình thức print'\<octal value>', ngoại trừ:

• p, r, i, n, t→'print''\<octal value>' (nhưng bằng chữ kết hợp của "in" cũng thay thế bằng giá trị bát phân)
• 0- 9→print~-<next int>

Dưới đây là danh sách đầy đủ các chương trình theo nhân vật.

    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 byte

Chương trình trước đây của tôi, trước khi tôi phát hiện ra rằng bát phân thoát tồn tại. Thú vị hơn nhiều, IMO.

Mỗi chương trình có hình thức print(--'<next char>'), ngoại trừ:

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

Dưới đây là danh sách đầy đủ các chương trình cho mỗi nhân vật:

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

Trên thực tế , 383 382 381 byte

1 byte nhờ Mego.

Để dễ dàng tham khảo, cột đầu tiên là mã ký tự, cột thứ hai là ký tự và cột thứ ba là mã.

Mã cho 0là một không gian duy nhất.

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

Hãy thử trực tuyến!

Đề nghị chơi golf được chào đón.

Fourier, 306 byte, 1 DNP

Khá nhiều tất cả các chương trình theo mô hình natrong đó n là mã ký tự của mỗi ký tự. Ví dụ:

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

Hãy thử trực tuyến!

Vì vậy, tôi sẽ chỉ liệt kê các ngoại lệ:

0 (Không)

Vì bộ tích lũy được đặt trước về 0, chúng ta có thể hiển thị giá trị này bằng một ký tự duy nhất:

o

Hãy thử trực tuyến!

1

Tương tự như không, điều này làm tăng bộ tích lũy để có 1.

^o

Hãy thử trực tuyến!

5

Mã ASCII cho 5 là 53, vì vậy tôi phải giải quyết vấn đề này:

6vo

Hãy thử trực tuyến!

một

Do alà chức năng đầu ra của nhân vật, không có cách nào khác để tạo ra ký tự a, vì vậy đây là CHƯƠNG TRÌNH DID KHÔNG duy nhất của tôi .

Xem tất cả các chương trình tại đây

Matlab, 1238 1224 byte, 2 DNP

Mẫu chính là:

disp([<char code> ''])

Đối với các chữ số, nó ngắn hơn một chút:

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

Đối với các nhân vật, []'đó là:

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

Các ký tự dstừ dispđược hiển thị bằng cách sử dụng fprintf( cảm ơn @Stewie Griffin ); iptuy nhiên cũng thuộc về đó, vì vậy tôi đang dịch chuyển chuỗi và sử dụng eval:

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

()Tuy nhiên, cả hai ký tự đều cần thiết cho disphoặc evalvì vậy chúng là DNP.

Để tham khảo toàn bộ danh sách:

    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

Jelly (không cạnh tranh), 406 byte

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Ọ

Điều này in tất cả các ký tự từ 32 - 126. Số byte được tính bằng https://otherseff.in/byte-corer .

Hãy thử trực tuyến!

Befunge-93, 530 byte

Cách dễ nhất để xuất ký tự, mà không thực sự sử dụng ký tự đó, là tính giá trị ASCII và sử dụng lệnh ,(đầu ra ký tự) để hiển thị ký tự đó. Ví dụ: 49*,@xuất ký tự đô la (ASCII 36, 4 * 9). Tuy nhiên, điều này hiếm khi là tối ưu nhất, vì hầu hết các giá trị cần nhiều hơn 3 byte để tính toán.

Một cách khác để tạo một số trong 3 byte là tận dụng thực tế là lệnh g(get) trong ô đầu tiên của sân chơi sẽ tạo ra giá trị ASCII của g (một ngăn xếp trống được giả sử là có các số 0, vì vậy, nó đọc giá trị sân chơi ở 0,0). Do đó g1+,@có được bạn h , và g1-,@có được bạn f . Điều này rõ ràng hoạt động cho một loạt các bù đắp, và các hoạt động khác +và -cũng có thể. Vì vậy, ví dụ g3/,@giúp bạn có được một trích dẫn kép.

Một biến thể của điều này, là đi trước gmột lệnh khác để lại tất cả các số không trên ngăn xếp. Vì vậy, bạn vẫn đang đọc một giá trị từ sân chơi ở mức 0,0, nhưng ký tự đang đọc giờ đã khác. Điều này tốn thêm một byte, nhưng giúp bạn truy cập vào nhiều giá trị hơn. Ví dụ, 0g1-,@giúp bạn có một dấu gạch chéo về phía trước và :g1+,@giúp bạn có dấu chấm phẩy. Tiền tố khả thi khác bao gồm *, +, -, >, \và _. Và một lần nữa lưu ý rằng các hoạt động khác là có thể: >g2*,@giúp bạn có một thanh dọc.

Một biến thể nữa là đi trước gvới a 1, vì vậy bây giờ bạn không còn đọc từ 0,0, mà từ ô trống ở 0,1. Trong Befunge, các ô trống được khởi tạo với khoảng trắng theo mặc định, do đó, cung cấp cho 1g,@bạn một khoảng trắng và 1g1+,@giúp bạn có dấu chấm than.

Đối với các ký tự chữ số, chúng ta có thể sử dụng nhiều mẹo đáng ngờ hơn. Thay vì cố gắng xuất chúng dưới dạng ký tự, chúng tôi xuất chúng dưới dạng số (một số nhỏ dễ tạo hơn so với tương đương ASCII của nó). Vì vậy, ví dụ, 11+.@cung cấp cho bạn 2 và đặc biệt lưu ý các trường hợp đặc biệt: .@cho 0 và !.@cho 1 . Phần đáng ngờ của điều này là một đầu ra số trong Befunge bao gồm một khoảng trắng sau số đó, vì vậy nó không phải là đầu ra ký tự thuần túy.

Một thủ thuật đáng ngờ khác mà chúng ta có thể sử dụng là một biến thể của gkỹ thuật trên. Thay vì tự giới hạn các lệnh Befunge cho tiền tố, chúng tôi cũng có thể sử dụng kỹ thuật bất kỳ ký tự nào không phải là lệnh Befunge. Trên hầu hết các trình thông dịch, một lệnh không được nhận dạng sẽ bị bỏ qua, vì vậy gcuối cùng sẽ đọc giá trị ASCII của ký tự trước. Điều này cho phép chúng tôi tạo ra hầu hết các giá trị ASCII khác mà không thể tính bằng 3 byte. Như một ví dụ: Qg1+,@bị bạn R .

Cuối cùng, có ba trường hợp đặc biệt. Một g không thể được tạo ra dưới 5 byte, vì vậy chúng tôi phải sử dụng đến "f"1+,@. Dấu phẩy là phức tạp nhất, đòi hỏi phải sửa đổi động của sân chơi : 0g4-:80p @. Chúng ta có thể sử dụng một kỹ thuật tương tự để tránh ký tự, nhưng một cách hack hiệu quả hơn là sử dụng lệnh %(modulo) làm đầu cuối, nghĩa là 88*,%. Khi %đạt được không có gì trên ngăn xếp, vì vậy phép tính modulo tạo ra một phép chia cho 0 và trên trình thông dịch tham chiếu, điều này sẽ chấm dứt chương trình.

Dưới đây là danh sách đầy đủ các chương trình, mỗi chương trình một dòng.

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