Dalam bahasa pemrograman pilihan Anda, tulislah 95 program, yang masing-masing menampilkan yang berbeda dari 95 karakter ASCII yang dapat dicetak tanpa karakter tersebut muncul di mana pun dalam program .

Misalnya, jika bahasa Anda adalah Python , program Anda yang menghasilkan karakter Pmungkin

print(chr(80))

karena Pmemiliki kode ASCII 80. Program ini valid karena Ptidak pernah muncul dalam kode sumber. Namun, untuk program yang menghasilkan huruf kecil p, sesuatu seperti

print(chr(112))

akan menjadi tidak valid karena, ketika sedang mencetak p, pada dalam kode. Program yang valid bisa saja

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

yang mencetak ptetapi tidak mengandung p.

Tujuan Anda adalah membuat masing-masing dari 95 program Anda sesingkat mungkin. Skor Anda adalah jumlah panjang karakter semua program Anda.

Jika karena alasan apa pun Anda tidak dapat menulis program yang valid untuk beberapa karakter, Anda dapat menandai karakter tersebut sebagai "Tidak Memprogram" atau DNP , dan mengabaikan program untuk mereka sepenuhnya. Dengan cara ini, bahasa yang ketat secara sintaksis akan dapat bersaing.

Jawaban yang menang adalah jawaban yang memiliki skor terendah dari serangkaian jawaban yang memiliki DNP paling sedikit.

Aturan

• Kode sumber semua program Anda hanya dapat berisi tab ASCII plus yang dapat dicetak dan baris baru, yang semuanya dihitung sebagai satu karakter. (Karena dalam penyandian yang berbeda akan mudah untuk menghilangkan karakter yang tidak ada!)

  • Catatan: Aturan ini tampaknya perlu tetapi ada banyak bahasa dengan penyandian berbeda dan saya yakin itu akan keren untuk melihat jawabannya. Karena itu Anda dapat melanggar aturan ini , Anda dapat menggunakan karakter apa pun yang Anda inginkan, tetapi kemudian jawaban Anda menjadi tidak kompetitif , itu tidak dapat menang.

• Program-program tersebut harus merupakan program penuh dan aktual , sesuai dengan konvensi standar bahasa Anda. Fungsi dan cuplikan REPL tidak diizinkan.

• Setiap output program harus menuju stdout atau alternatif bahasa Anda yang diterima.

• Program tidak boleh meminta atau membutuhkan input. (Jika meminta input sudah melekat pada bahasa Anda, tidak apa-apa.)

• Program harus bersifat deterministik, terbatas dalam jangka waktu, dan independen. mis. seharusnya tidak masalah jika seseorang dijalankan dalam folder yang terpisah dari program lain.

• Keluaran suatu program harus berupa karakter ASCII yang dapat dicetak yang sesuai dengannya, secara opsional diikuti oleh satu baris baru, tidak lebih, tidak kurang.

Pastikan untuk memasukkan informasi tentang semua 95 program (idealnya) dalam jawaban Anda, serta skor Anda dan DNP apa pun. Anda tidak harus daftar semua program yang mengikuti pola sederhana seperti " , ..." tapi pastikan Anda yakin semuanya akan bekerja dan bahwa skor Anda ditambahkan dengan benar.print(chr(80))print(chr(81))print(chr(82))

Untuk referensi, berikut adalah 95 ASCII yang dapat dicetak yang harus dihasilkan oleh program Anda:

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

Python 2, 1075 1065 1043 1040 1039 byte

Setiap program memiliki formulir print'\<octal char code>', kecuali:

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

Untuk referensi dan kemudahan pengujian, berikut adalah daftar lengkap program yang dipisahkan oleh baris baru.

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'

Untuk menguji:

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

-1 byte, terima kasih kepada @ Sp3000!

CJam, 269 byte

Masing-masing program dalam bentuk '<char - 1>)kecuali untuk:

• Spasi => 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

Skor adalah: 3 * 82 + 1 + 3 + 3 + 4 * 1 + 6 * 2 = 269

ASCII membatasi Kode Mesin x86 untuk DOS, 3104 3101 2913 byte

Yah ... Ini lebih pendek dari Jawa, kurasa ...

32 30 byte untuk hampir semua karakter, untuk pengecualian lihat di bawah.

Sebagian besar waktu hanya mengikuti pola:

1. Lakukan beberapa xoruntuk mendapatkan pointer ke ujung.
2. subdari 2 kata terakhir karena opcode untuk inttidak dalam ASCII.
3. Dapatkan 2 ke AHdan karakter ke DL. Keduanya xored karena karakter itu sendiri tidak dapat muncul dalam program dan 2 bukan karakter ASCII yang dapat dicetak.
4. Cetak karakter dengan int 21h
5. Keluar dengan int 20h

Sebagian besar waktu, jika karakter tidak diizinkan, karakter dapat digantikan dengan memutar-mutar data sedikit atau beralih ke register yang berbeda.

Menjadi sedikit lebih menarik ketika Anda tiba-tiba mendapati diri Anda tidak dapat mengurangi atau tidak dapat mendorong atau memunculkan satu-satunya daftar yang dapat digunakan untuk perhitungan ...

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 disimpan oleh Dennis
17 byte disimpan oleh Sp3000

DNP: 46 ( .)

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

Semua kecuali 43, 45, 60, 62, 91 dan 93 dicuri dari Esolangs.org tanpa malu-malu

MATL, 305, 302, 300 297 byte

Setiap program terlihat seperti ini:

33c
34c
35c
....

Kecuali untuk

• Digit. Berikut adalah program untuk 0-9:

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

• 'c'. Program ini adalah

  'C'k
  

• ruang. Ini adalah

  0c
  

  Sejak hari ini saya belajar, bahwa MATL memperlakukan karakter 0 sebagai spasi. Terima kasih @LuisMendo!

Anda dapat menggunakan matl.tio untuk memverifikasi salah satunya.

Untuk referensi, ini semuanya:

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

mendesah

Ini pada dasarnya adalah port jawaban Python 2 saya , tetapi dengan semua boilerplate yang datang dengan menulis program lengkap di Jawa.

Sekarang tanpa DNP sama sekali! Terima kasih, Kevin Cruijssen!

Sebagian besar program memiliki formulir interface A{static void main(String[]a){System.out.print("\<octal char code>");}}, kecuali:

• space → interface\tA{static\tvoid\tmain(String[]a){System.out.print("\40");}}(tetapi dengan \thuruf s diganti dengan tab mentah)
• " → 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

Fiuh

Compiler Java memproses Unicode lolos seperti \u007Bsebelum melakukan pemrosesan lain, yang memungkinkan untuk menulis kode yang menggunakan unicode lolos dalam pengidentifikasi dan bahkan kata kunci. Jadi, untuk menulis program yang tidak menggunakan karakter yang ada di boilerplate, kita cukup menggantinya dengan itu unicode escape.

Untuk referensi dan kemudahan pengujian, berikut adalah daftar lengkap program, dipisahkan oleh baris baru dan dengan tab mentah diganti dengan empat spasi:

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

Perhatikan bahwa program untuk umenggunakan System.console(), yang akan mengembalikan nol (dan dengan demikian menyebabkan kode untuk membuang a NullPointerException) jika Anda memanggilnya dari apa pun selain terminal asli OS Anda ( cmdpada Windows, dan, saya berasumsi, bashdi Linux / OSX) .

Untuk mengujinya, buat direktori baru dan letakkan kode di atas dalam file yang bernama printablesdi direktori itu. Kemudian, jalankan skrip Bash berikut:

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

Script di atas akan menempatkan setiap baris printableske dalam direktori sendiri, beri nama semuanya A.java(kecuali untuk file yang dicetak A, yang diubah namanya menjadi B.java), kompilasi setiap file, jalankan, kemudian hapus buktinya. Diperlukan waktu sekitar sepuluh detik untuk karakter ASCII yang dapat dicetak untuk mulai muncul di shell Anda.

Jika Anda menggunakan Windows, alih-alih jalankan file Batch berikut:

@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

File batch ini mengambil pendekatan yang sedikit berbeda; alih-alih memisahkan baris, ia memproses file baris demi baris dan mengkompilasi dan menjalankan setiap program secara bergantian. Sekali lagi, itu menghapus bukti setelah selesai.

Disimpan byte yang tak terhitung jumlahnya + 1 DNP berkat Kevin Cruijssen!

> <> , 443 437 byte

TIO interpreter link . Ada banyak pola di sini:

• [num][num]*o;: Mengalikan dua angka, lalu menampilkan hasilnya sebagai char with odan stop with ;. > <> digit naik hingga 15, yaitu 0123456789abcdef.
  • Demikian pula [num][num]-n;, yang mengambil perbedaan dari dua angka dan keluaran sebagai angka n.

• '-o[invalid char]: > <> adalah toroidal, jadi ketika penunjuk instruksi mencapai ujung garis, ia bergerak kembali ke awal. Dalam hal ini, ini menyebabkan kode dieksekusi dua kali, yaitu '-o[char]'-o[char]. Bagian pertama '-o[char]'mendorong tiga karakter ke stack, -menghitung 'o' - [char]lalu omengeluarkan hasilnya sebagai karakter. > <> kemudian kesalahan keluar ketika mencapai [char], baik karena perintah yang tidak dikenal atau dari muncul tumpukan kosong.

  • Demikian pula '-n[invalid char], yang ditampilkan sebagai angka.
  • Begitu pula '[num][op]o[invalid char]yang berlaku [op]dengan [num]on [char], erroring on char. Misalnya, '2+oJoutput L, yang dua lebih dari J.
  • 'Kodenya adalah "-oH, gunakan "saja.
  • -Kodenya adalah '%oB, gunakan %saja.

• ln;: Dorong panjang tumpukan, output sebagai num lalu berhenti, memberi 0. Demikian pula lln;untuk 1dan 'ln;untuk 3.

• 4|n+: Tekan 4, pantulkan |dan tekan 4 lainnya, tambahkan, lalu 8hasilkan sebagai num. Bangkit |lagi, dan galat saat mencoba menjalankan nlagi di tumpukan kosong.
  • Demikian pula 3|n*untuk 9.
  • Demikian pula [num]|o*untuk @Qdy.
• '1-:00p: Yang paling menarik, untuk okasus ini. Untuk menghindari penggunaan odalam kode kita, kita perlu menggunakan puntuk menempatkan sebuah kotak okode, lalu jalankan. Inisial '1-:00p'mengatur stack untuk memiliki pdi atas, dan 1-menguranginya menjadi o. :menduplikasi ini o, dan 00pmenempatkan satu odi (0, 0), mengubah kotak kode menjadi o1-:00p. Penunjuk instruksi membungkus lagi, mengeluarkan yang lain o. Karakter (0, 0) kemudian diganti beberapa kali sebelum akhirnya program keluar.

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

(tidak bersaing karena APL tidak dapat benar-benar ditulis menggunakan ASCII saja)

Sebagian besar dalam format nn⊃⎕AVatau nnn⊃⎕AV, pengecualiannya adalah:

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

Berikut daftar lengkapnya:

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

Untuk 63 karakter @melalui ~, kami memiliki solusi 10-byte:

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

Untuk sebagian besar (21) karakter dari spacethrough ?, kami memiliki solusi 9-byte:

puts"\xx"     (2 digit octal code)

Ada sebelas kasus khusus yang tersisa:

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

Secara total, skornya 10 × 63 + 9 × 21 + 10 + 3 + 8 × 4 + 5 = 869.

WolframAlpha , 368 byte

Format umum:

u+<character code in hexadecimal>

Pengecualian:

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

Berikut daftar lengkapnya:

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

Sunting: menyimpan 203 byte berkat jimmy23013 dan menerapkan 2 DNP berkat Mego

Jawaban ini sangat menyalahgunakan sifat murah hati PHP. Sebagian besar kasus menggunakan salah satu dari formulir ini (masing-masing 7 byte):

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

PHP mengubah huruf-huruf di kedua sisi operator menjadi string, kemudian melakukan operasi bitwise yang sesuai dengan mengubah setiap string ke nilai karakter ASCII-nya, dan akhirnya mengubah hasilnya kembali ke karakter.

Pada contoh pertama di atas, Y^xmenjadi 89^78. Hasil dari ini adalah 33, yang kemudian dikirim ke STDOUT sebagai karakter !.

Sebuah skrip ditulis untuk memaksa semua kombinasi yang mungkin: hasilnya dapat ditemukan di sini .

Pengecualian:

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

<dan ?biasanya DNP karena tag awal yang diperlukan, tetapi dengan menggunakan -rflag, kode dapat dieksekusi tanpa mereka:

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

Skor:

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

Brachylog , 546 477 byte

Kredit untuk Melegalkan kode untuk @.

Dalam daftar di bawah ini, karakter pertama adalah karakter yang akan dicetak (untuk referensi mudah).

  @ S
! @Ht
"@P: 2m
# @P: 3m
$ @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" ybh
A @ Zt @ u
B @ Ch @ u
C @ P: 35m
D @ P: 36m
E @P: 37m
F @ P: 38m
G @ P: 39m
H @ P: 40m
I @ P: 41m
J @ P: 42m
K @ P: 43m
L @ ​​P: 44m
M @ P: 45m
N @ P: 46m
O @ P: 47m
P @ A: 15m @ u
Q @ P: 49m
R @ P: 50m
S @P: 51m
T @ P: 52m
U @ Vt @ u
V @ P: 54m
W @ Qt @ u
X @ P: 56m
Y @ Wt @ u
Z @ At @ u
[@P: 59m
\ @ P: 60m
] @P: 61m
^ @ P: 62m
_ @ P: 63 m
`@ P: 64m
a @ Vh
b @ Ch
c @Dbh
d @ A: 3m
e @Vbh
f @ A: 5m
g @ A: 6m
h @ A: 7m
i @ A: 8m
j @ A: 9m
k @C: 7m
l @C: 8m
m @ D @ 2ht
n @ A: 13 m
o @ H: 4m
p @ A: 15m
q @Z: 9m
r @Z: 8m
s @Z: 7m
t @Z: 6m
kamu @Vt
v @ Z: 4m
w @ Qt
x @ Z: 2m
y @Wt
z @At
{@P: 91m
| @ P: 92m
} @Prbh
~ @ PT

Mereka semua adalah predikat, jadi Zperlu argumen untuk menerima output: Coba online!

Penjelasan

@P adalah string ini:

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

yang berisi setiap ASCII yang dapat dicetak.

> <> , 531 byte

Program-program tersebut mengambil dua bentuk utama:

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

Yang pertama adalah untuk karakter dengan kode karakter dengan dua faktor keduanya kurang dari 16, yang lainnya adalah untuk kasus lainnya. Sebagian besar angka yang saya gunakan bentuk kedua untuk memiliki banyak solusi panjang yang sama, tetapi saya memilih yang untuk dibaca.

Pengecualian:

" 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

Daftar lengkap:

! 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

Terima kasih kepada FryAmTheEggman karena telah menghemat 3 byte.

Hampir semua program memiliki bentuk yang sama:

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

Ada beberapa pengecualian:

• Tidak mungkin mencetak ;tanpa menggunakan ;, karenanya 1 DNP.
• Untuk mencetak @, kita tidak dapat menggunakan @untuk menghentikan program. Sebaliknya, kami menggunakan salah satu S2;:atau S3;%. Ini diakhiri dengan kesalahan pembagian-oleh-nol, tetapi kesalahan itu tidak terlihat pada STDOUT. Jadi ini masih empat byte.
• Ada satu bentrokan Uyang membutuhkan U3;@. Ada beberapa cara untuk memperbaikinya, termasuk beralih ke huruf kecil, yaitu n9;@, atau menggunakan kenaikan atau penurunan, yaitu T);@atau V(;@. Bagaimanapun itu masih empat byte.
• Tepi memory yang dijalankan untuk 0, dan !mencetak nilai integer, sehingga kita bisa mendapatkan 0dan 1bersama !@dan )!@masing-masing tabungan 3 byte.

Adapun cara <letter><digit>;@kerja program: tata letak heksagonal dari program bentuk 1234selalu

 1 2
3 4 .
 . .

Karena tidak ada program yang berisi perintah yang mengarahkan aliran kontrol, ini hanyalah program linier yang dijalankan secara berurutan.

Dalam setiap kasus, huruf di awal kode menetapkan batas memori saat ini ke kode karakternya. Misalnya dalam program P1;@, Pset nilainya 80. Kemudian digit mengalikan nilai ini dengan 10 dan menambahkan sendiri (yaitu digit ditambahkan ke nilai saat ini). Itu memberi 801dalam contoh di atas. Akhirnya, ;cetak nilai ini dengan mengambilnya modulo 256 dan menggunakannya sebagai nilai byte. Dalam hal ini 801 % 256 = 33dan !dicetak.

Spasi , 1643 byte, 1 DNP

17 byte untuk karakter [33-63] dan 18 byte untuk karakter [64-126]

Di Whitespace ini sangat mudah, karena karakter yang dapat dicetak (kecuali spasi) tidak memiliki arti:

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

Program di atas mencetak '!' (100001b). Ubah [TAB][SPACE][SPACE][SPACE][SPACE][TAB]baris pertama ke karakter mana saja yang Anda suka. Tidak mungkin untuk mencetak spasi tanpa menggunakan spasi, karena mencetak apa pun selalu dimulai dengan[TAB][LF][SPACE]

Retina , 712 byte, 2 DNP

Ini adalah upaya kolaborasi dengan FryAmTheEggman.

Ada beberapa kelas solusi. Untuk sebagian besar karakter dari luar angkasa hingga ^, kami menggunakan program dengan bentuk berikut:

_
T`w`p

Karakter pada baris kedua beralih melalui rentang _0-9A-Za-zsementara sisanya tetap tidak berubah. Ini mengubah input kosong menjadi karakter itu dan kemudian menggantinya dengan karakter ASCII yang dapat dicetak (diwakili oleh p) pada posisi yang sesuai. Masing-masing program ini berukuran 8 byte.

Dalam kisaran ini, hanya ada beberapa pengecualian. Yang paling penting digit dapat dipersingkat:

• 0: x(menghitung jumlah xs pada input kosong)
• 1:  (weehoo, program kosong; menghitung jumlah kecocokan kosong dalam input kosong)

• 2: sekarang kita mengubah input menjadi satu karakter, sebelum menghitung string kosong:

  
  1
  
  

• 3: hal yang sama tetapi kami mengubah input menjadi dua karakter:

  
  11
  
  

• 4: Anda mendapatkan ide ...

  
  111
  
  

• 5 - 9: plot twist ... kami menggunakan pengulangan karakter untuk menghindari baris kedua menjadi lebih lama:

  
  4$*
  
  

  ...

  
  8$*
  
  

Pengecualian lainnya adalah TDNP: kami pikir tidak mungkin untuk menghasilkan karakter non-digit tanpa muncul dalam kode sumber jika tahap transliterasi tidak dapat digunakan.

Aktif ke karakter yang tersisa. Untuk mencetak _kami menggunakan program serupa dengan solusi umum di atas:

0
T`0`w

Memanfaatkan fakta yang wdimulai dengan _.

Berikutnya, `adalah DNP kedua, karena tahap transliterasi juga membutuhkannya.

Maka sebagian besar huruf kecil dicetak dengan sesuatu seperti ini (yang dicetak a):

_
T`w`l

Sekali lagi, karakter pada baris kedua bertambah _0-9A-O. Di sini, kita hanya perlu diwaspadai ldan w, yang masing-masing dapat kita cetak dengan program-program berikut:

P
T`p`w

6
T`p`l

Akhirnya, hanya {|}~tersisa, yang masing-masing memerlukan 9 byte. Di sini, kami menggunakan tahap transliterasi untuk meningkatkan karakter yang mendahuluinya. Misalnya ~dapat dicetak dengan:

}
T`_p`p

Pyke, 364 362 355 byte

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

Semua dalam bentuk w<chr(charcode+32)>.C(4 byte) kecuali untuk:

• -> d1 byte
• 0-> Z1 byte
• 1-> ~W2 byte
• a-> Gh2 byte
• z-> Ge2 byte
• 10 huruf alfabet kecil pertama (kecuali a) dalam bentuk 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

Penerjemah Pyke online

JavaScript (ES6), 1083 1068 byte

Bentuk umum:

alert`\xhex`

Pengecualian:

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`

Sunting: Disimpan 15 byte berkat @ 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

Penjelasan

Kebanyakan 5 byte panjang dalam bentuk: convert nr to base nr+1.
>membutuhkan byte tambahan karena kita tidak dapat menggunakan increment untuk itu.

a,b,x,y,z,Y,Zdiekstraksi dari Ayang berisi alfabet dalam huruf kecil.

A,B,C,D,E,F adalah angka yang dikonversi menjadi hex.

0-9 adalah kenaikan / penurunan sederhana serta variabel yang telah ditentukan sebelumnya.

Marbelous, 220 byte

Untuk karakter yang bukan digit, itu hanya dua digit heks huruf besar dari kode karakter. Sebagai contoh, output program berikut A:

41

Untuk digit yang tidak 3, ganti 2Fkode berikut dengan digit hex huruf besar dari kode karakter - 1:

2F
++

Untuk 3:

66
>>

Total skor: 2 * 85 + 5 * 10 = 220.

Penerjemah.

Percobaan pertama saya adalah Bubblegum dan tidak berhasil untuk karakter sebelum ?...

Perl 6: 921 byte

Terjemahan dari solusi Python.

Setiap program memiliki formulir say "\x<hex escape code>", kecuali:

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

Untuk referensi dan kemudahan pengujian, berikut adalah daftar lengkap program yang dipisahkan oleh baris baru.

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

Inilah kode yang saya gunakan untuk menguji daftar di atas, dan hitung skornya:

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

Sebagian besar program berada main=putChar '\xx'atau di main=putChar '\xxx'mana xx/ xxxadalah kode ascii dari char yang akan dicetak. Ini berfungsi untuk semua kecuali 14 karakter:

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

Namun, untuk digit 1 7 4 byte dapat disimpan (terima kasih kepada Christian Sievers!):

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

52 program hingga c(kode 99) mengambil 18 byte, sisanya 19 masing-masing mengambil 19 byte.

Skor sebagian: 10*14 + 52*18 + 19*19 = 1437

Untuk 7 dari karakter yang tersisa, program berikut berfungsi:

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

Skor sebagian: 18 + 22 + 18 + 21 + 19 + 27 + 27 = 152

Ini menyisakan 7 DNP: =aimnrt

Setiap program Haskell perlu mendefinisikan main ( main=), jadi itu 5 DNP. Untuk mencetak ke stdout, putChar, putStratau interactdapat digunakan, menghasilkan tdan rsebagai DNPs lebih lanjut. (Ada juga print, bagaimanapun print 'a'mencetak 'a'dan tidak a- dan juga mengandung tdan rtetap.) Haskell juga memiliki chrfungsi yang mengembalikan arang yang sesuai diberi nomor, namun untuk menggunakannya import Data.Chardiperlukan.

Total skor 1437 + 152 = 1589 :, 7 DNP

BBC Basic, 422 413 byte

Unduh juru bahasa gratis di http://www.bbcbasic.co.uk/bbcwin/bbcwin.html

9 byte disimpan berkat Leaky Nun.

Bentuk umum

V.<character code>

32..99 tidak termasuk 12 kasus khusus: 56x4 = 224 byte

100..126 : 27x5 = 135 byte

12 kasus khusus: 54 byte

Sebagian besar angka mengikuti bentuk umum, tetapi saya memasukkan semuanya di sini untuk menunjukkan di mana masalahnya.

Karakter pertama adalah karakter yang akan dicetak.

. VDU46       :REM Full form of the command used in general form: send character 46 to VDU)
V P.CHR$86    :REM short for PRINT CHR$(86)
0 V.48       
1 V.49
2 V.50
3 V.51
4 V.52
5 P.1+4
6 V.54
7 V.55
8 V.56
9 V.57

Minkolang 0,15 , 604 byte

Untuk sebagian besar karakter, "<char-1>"1+O.akan menjadi program yang valid, mungkin salah satu yang terpendek. Namun, karena fakta bahwa karakter disimpan sebagai titik kode pada tumpukan berarti banyak dari mereka dapat diproduksi dengan perkalian dan penambahan, dalam lima byte atau kurang. Juga, perhatikan bahwa l, $1, $2, $3, $4, $5, $6, $lyang10, 11, 12, 13, 14, 15, 16, 100 masing masing.

Format: <character>: <program>

 : 48*O.
!: $13*O.
": 66*2-O.
#: 57*O.
$: 66*O.
%: 66*1+O.
&: 4l*2-O.
': 3$3*O.
(: 4l*O.
): 4l*1+O.
*: ")"1+O.
+: "*"1+O.
,: $14*O.
-: 59*O.
.: "-"1+d$10pO-
/: "."1+O.
0: 68*O.
1: 77*O.
2: 5l*O.
3: 5l*1+O.
4: lZIO.
5: lZdIO.
6: 239**O.
7: 5$1*O.
8: 4$4*O.
9: 6l*3-O.
:: 6l*2-O.
;: 6l*1-O.
<: 6l*O.
=: 6l*1+O.
>: 6l*2+O.
?: 79*O.
@: 88*O.
A: 5$3*O.
B: 6$1*O.
C: 7l*3-O.
D: 7l*2-O.
E: 7l*1-O.
F: 7l*O.
G: 7l*1+O.
H: 89*O.
I: 89*1+O.
J: 89*2+O.
K: 355**O.
L: 89*4+O.
M: 7$1*O.
N: 6$3*O.
O: "N"1+d90pN.
P: 8l*O.
Q: 99*O.
R: 8l*2+O.
S: 8l*3+O.
T: 347**O.
U: 8l*5+O.
V: 8l*6+O.
W: 8l*7+O.
X: 8$1*O.
Y: 8l*9+O.
Z: 9l*O.
[: $l9-O.
\: $l8-O.
]: $l7-O.
^: $l6-O.
_: $l5-O.
`: 8$2*O.
a: $l3-O.
b: $l2-O.
c: 9$1*O.
d: $lO.
e: $l1+O.
f: $l2+O.
g: $l3+O.
h: $l4+O.
i: $l5+O.
j: $l6+O.
k: $l7+O.
l: $l8+O.
m: $l9+O.
n: l$1*O.
o: $l$1+O.
p: $l$2+O.
q: $l$3+O.
r: $l$4+O.
s: $l$5+O.
t: $l$6+O.
u: "t"1+O.
v: "u"1+O.
w: 7dl+*O.
x: 358**O.
y: $1d*O.
z: 53;3-O.
{: 53;2-O.
|: 53;1-O.
}: 53;O.
~: 53;1+O.

Disebutkan secara khusus:

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

(Cobalah.) Minkolang memiliki kemampuan untuk memodifikasi karakter dalam kotak kode, jadi yang dilakukan oleh program ini adalah mengganti -di akhir dengan ., yang diperlukan untuk menghentikan program. "N"1+d90pN.untuk Obekerja dengan cara yang sama.

4: lZIO.

(Cobalah.) lZ Mendorong huruf besar dan kecil ke tumpukan, dan Imendorong panjang tumpukan, yaitu 52, tepatnya titik kode "4". Bagian yang terbaik adalah saya awalnya mempertimbangkan solusi 4$3*O., yang mengalikan 4 dan 13 untuk mendapatkan 52, tetapi tidak bisa karena ada 4 di dalamnya, jadi akhirnya saya menemukan solusi golf!

y: $1d*O.

(Cobalah.) d Menggandakan bagian atas tumpukan, jadi yang dilakukan oleh bagian kode ini adalah mendorong 11, menggandakannya, dan kemudian mengalikannya. Cara alternatif untuk menulis ini adalah $12;O., yang memiliki jumlah byte yang sama.

}: 53;O.

(Cobalah.) ; Adalah eksponensial, jadi ini artinya 5 ^ 3 untuk mendapatkan 125.

Groovy, 1019 byte

Saya memiliki solusi Groovy berbeda yang ditulis (lihat di bawah), tetapi setelah saya kirimkan, saya melakukan sedikit lebih banyak penggalian karakter, berharap menemukan cara untuk memperpendek program lebih banyak, dan menemukan bahwa Groovy memiliki karakter oktan yang lolos. tidak tahu. Ini secara signifikan menyederhanakan kode, ke titik yang sayangnya menghilangkan kebutuhan untuk hampir semua solusi unik yang saya buat.

Itu juga terlihat hampir identik dengan solusi Copper's Python 2 , ke titik di mana pada dasarnya terlihat seperti saya menjiplak pekerjaan mereka. Ugh.

Setiap program memiliki formulir print'\<octal value>', kecuali:

• p, r, i, n, t→ 'print''\<octal value>'(tapi dengan huruf pencocokan "cetak" juga diganti dengan nilai oktal)
• 0- 9→print~-<next int>

Berikut adalah daftar lengkap program berdasarkan karakter.

    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

Program saya sebelumnya, sebelum saya menemukan bahwa pelarian oktal ada. Jauh lebih menarik, IMO.

Setiap program memiliki formulir print(--'<next char>'), kecuali:

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

Berikut adalah daftar lengkap program untuk setiap karakter:

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

Sebenarnya , 383 382 381 byte

1 byte berkat Mego.

Untuk referensi yang mudah, kolom pertama adalah kode karakter, kolom kedua adalah karakter, dan kolom ketiga adalah kode.

Kode untuk 0adalah ruang tunggal.

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

Cobalah online!

Saran bermain golf dipersilakan.

Fourier, 306 byte, 1 DNP

Hampir semua program mengikuti pola di namana n adalah kode karakter masing-masing karakter. Sebagai contoh:

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

Cobalah online!

Jadi saya hanya akan membuat daftar pengecualian:

0 (Nol)

Karena akumulator diatur ke nol, kita dapat menampilkan ini menggunakan satu karakter:

o

Cobalah online!

1

Mirip dengan nol, ini menambah akumulator untuk mendapatkan 1.

^o

Cobalah online!

5

Kode ASCII untuk 5 adalah 53, jadi saya harus mengatasi ini:

6vo

Cobalah online!

Sebuah

Karena amenjadi fungsi keluaran karakter, tidak ada cara lain untuk menghasilkan karakter a, jadi ini satu-satunya DID BUKAN PROGRAM .

Lihat semua program di sini

Matlab, 1238 1224 byte, 2 DNP

Pola utamanya adalah:

disp([<char code> ''])

Untuk digit itu sedikit lebih pendek:

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

Untuk karakter []':

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

Karakter dsdari dispditampilkan menggunakan fprintf( terima kasih @Stewie Griffin ); ipNamun milik juga di sana, jadi saya menggeser string dan menggunakan eval:

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

Namun kedua karakter ()tersebut diperlukan untuk dispatau eval, jadi mereka adalah DNP.

Untuk referensi seluruh daftar:

    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 (tidak kompetitif), 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Ọ

Ini mencetak semua karakter dari 32 - 126. Hitungan byte dihitung dengan https://mothereff.in/byte-counter .

Cobalah online!

Befunge-93, 530 byte

Cara termudah untuk mengeluarkan karakter, tanpa benar-benar menggunakan karakter itu, adalah menghitung nilai ASCII dan menggunakan perintah ,(keluaran karakter) untuk membuatnya. Misalnya, 49*,@menampilkan karakter dolar (ASCII 36, 4 * 9). Ini jarang yang paling optimal, karena sebagian besar nilai membutuhkan lebih dari 3 byte untuk dihitung.

Cara lain untuk menghasilkan angka dalam 3 byte adalah dengan memanfaatkan fakta bahwa perintah g(get) di sel pertama playfield akan menghasilkan nilai ASCII dari g (tumpukan kosong diasumsikan diisi dengan nol, jadi itu adalah membaca nilai playfield pada 0,0). Dengan demikian g1+,@membuat Anda h , dan g1-,@membuat Anda f . Ini jelas bekerja untuk berbagai offset, dan operasi selain +dan -juga dimungkinkan. Jadi misalnya g3/,@memberi Anda penawaran ganda.

Variasi dari ini, adalah untuk mengawali gdengan perintah lain yang meninggalkan semua nol pada stack. Jadi Anda masih membaca nilai dari playfield pada 0,0, tetapi karakter yang sedang dibaca sekarang berbeda. Ini membutuhkan satu byte lagi, tetapi memberi Anda akses ke banyak nilai lainnya. Misalnya, 0g1-,@memberi Anda garis miring dan :g1+,@membuat titik koma. Awalan yang layak lainnya termasuk *, +, -, >, \dan _. Dan lagi perhatikan bahwa operasi lain dimungkinkan: >g2*,@buatkan Anda bilah vertikal.

Variasi lebih lanjut adalah dengan mendahului gdengan a 1, jadi Anda sekarang tidak lagi membaca dari 0,0, tetapi dari sel kosong di 0,1. Di Befunge, sel kosong diinisialisasi dengan spasi secara default, jadi 1g,@memberi Anda spasi, dan 1g1+,@memberi Anda tanda seru.

Untuk karakter digit, ada trik lebih meragukan yang bisa kita gunakan. Alih-alih mencoba menampilkannya sebagai karakter, kami mengeluarkannya sebagai angka (sejumlah kecil lebih mudah untuk menghasilkan daripada yang setara ASCII). Jadi misalnya, 11+.@memberi Anda 2 , dan khususnya catatan kasus khusus: .@untuk 0 , dan !.@untuk 1 . Bagian yang meragukan dari ini adalah bahwa output numerik di Befunge termasuk spasi setelah angka, jadi itu bukan output karakter murni.

Trik meragukan lain yang dapat kita gunakan adalah variasi dari gteknik di atas. Alih-alih membatasi diri pada perintah Befunge untuk awalan, kita juga bisa secara teknis menggunakan karakter apa pun yang bukan perintah Befunge. Pada kebanyakan penerjemah, perintah yang tidak dikenal akan diabaikan, sehingga gakhirnya akan membaca nilai ASCII dari karakter sebelumnya. Ini memungkinkan kami untuk menghasilkan sebagian besar nilai ASCII lain yang tidak bisa dihitung dalam 3 byte. Sebagai satu contoh: Qg1+,@memberi Anda R .

Akhirnya, ada tiga kasus khusus. Sebuah g tidak dapat dihasilkan dalam waktu kurang dari 5 byte, jadi kami harus resor untuk "f"1+,@. Sebuah koma adalah yang paling rumit, memerlukan modifikasi dinamis playfield: 0g4-:80p @. Kita dapat menggunakan teknik serupa untuk menghindari karakter at, tetapi peretasan yang lebih efisien adalah dengan menggunakan perintah %(modulo) sebagai terminator, yaitu 88*,%. Ketika %tercapai, tidak ada apa-apa di stack, sehingga perhitungan modulo menghasilkan pembagian dengan nol, dan pada interpreter referensi ini akan menghentikan program.

Di bawah ini adalah daftar lengkap program, satu per baris.

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