ในภาษาการเขียนโปรแกรมที่คุณเลือกให้เขียน 95 โปรแกรมโดยแต่ละโปรแกรมจะแสดงอักขระ ASCII ที่พิมพ์ได้ 95 ตัว ที่แตกต่างกันโดยไม่มีอักขระนั้นเกิดขึ้นที่ใดก็ได้ในโปรแกรมโดยไม่ต้องตัวละครที่เกิดขึ้นได้ทุกที่ในโปรแกรม

ตัวอย่างเช่นหากภาษาของคุณคือPythonโปรแกรมของคุณPอาจแสดงอักขระออกมา

print(chr(80))

เพราะPมีรหัส ASCII 80 โปรแกรมนี้ใช้ได้เพราะPไม่เคยปรากฏในซอร์สโค้ด อย่างไรก็ตามสำหรับโปรแกรมที่แสดงผลตัวพิมพ์เล็กpบางอย่างเช่น

print(chr(112))

จะไม่ถูกต้องเพราะในขณะที่มันไม่พิมพ์p, pเป็นปัจจุบันในรหัส โปรแกรมที่ถูกต้องอาจเป็น

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

ซึ่งพิมพ์แต่ไม่ได้มีpp

เป้าหมายของคุณคือทำให้แต่ละโปรแกรม 95 โปรแกรมของคุณสั้นที่สุด คะแนนของคุณคือผลรวมของความยาวอักขระของโปรแกรมทั้งหมดของคุณ

หากด้วยเหตุผลใดก็ตามที่คุณไม่สามารถเขียนโปรแกรมที่ถูกต้องสำหรับตัวละครบางตัวคุณอาจทำเครื่องหมายตัวอักษรเหล่านั้นเป็น "Did Not Program" หรือDNPและละเว้นโปรแกรมทั้งหมด วิธีนี้ภาษาที่เข้มงวดทางภาษาจะสามารถแข่งขันได้

คำตอบที่ชนะคือคำตอบที่มีคะแนนต่ำสุดของชุดคำตอบที่มี DNP น้อยที่สุด

กฎระเบียบ

• ซอร์สโค้ดของโปรแกรมทั้งหมดของคุณอาจมีเฉพาะแท็บASCII ที่พิมพ์ได้และการขึ้นบรรทัดใหม่ซึ่งทั้งหมดจะถูกนับเป็นอักขระเดียว (เพราะในการเข้ารหัสที่แตกต่างกันมันจะง่ายต่อการละเว้นอักขระที่ไม่มีอยู่!)

  • หมายเหตุ:กฎนี้ดูเหมือนจำเป็น แต่มีหลายภาษาที่มีการเข้ารหัสที่แตกต่างกันและฉันแน่ใจว่ามันจะเจ๋งที่เห็นคำตอบสำหรับพวกเขา ดังนั้นคุณสามารถทำลายกฎนี้คุณสามารถใช้อักขระใดก็ได้ที่คุณต้องการแต่จากนั้นคำตอบของคุณจะไม่สามารถแข่งขันได้และไม่สามารถชนะได้

• โปรแกรมที่จะต้องเกิดขึ้นจริงเต็มรูปแบบโปรแกรมตามอนุสัญญามาตรฐานภาษาของคุณ ไม่อนุญาตให้ใช้ฟังก์ชันและตัวอย่างข้อมูลREPL

• ผลลัพธ์ของแต่ละโปรแกรมควรไปที่ stdout หรือทางเลือกที่ได้รับการยอมรับในภาษาของคุณ

• โปรแกรมไม่ควรพร้อมท์หรือต้องการอินพุต (หากการขอให้ป้อนข้อมูลมีอยู่ในภาษาของคุณแสดงว่าไม่เป็นไร)

• ควรกำหนดโปรแกรมกำหนดเวลา จำกัด และเป็นอิสระ เช่นมันไม่สำคัญว่าจะมีการเรียกใช้ในโฟลเดอร์แยกจากโปรแกรมอื่น ๆ

• เอาต์พุตของโปรแกรมควรเป็นอักขระ ASCII ที่พิมพ์ได้อย่างแม่นยำซึ่งสอดคล้องกับตัวเลือกตามด้วยบรรทัดใหม่ต่อท้ายบรรทัดเดียวไม่มีอะไรมากไม่มีอะไรน้อย

ตรวจสอบให้แน่ใจว่าได้รวมข้อมูลเกี่ยวกับโปรแกรม 95 (นึกคิด) ไว้ในคำตอบของคุณรวมถึงคะแนนและ DNP ของคุณ คุณไม่จำเป็นต้องไปที่รายการทุกโปรแกรมที่เป็นไปตามรูปแบบที่เรียบง่ายเช่น " , ..." แต่ให้แน่ใจว่าคุณแน่ใจว่าพวกเขาทั้งหมดจะทำงานและคะแนนของคุณจะถูกเพิ่มอย่างถูกต้องprint(chr(80))print(chr(81))print(chr(82))

สำหรับการอ้างอิงต่อไปนี้เป็นASCII ที่พิมพ์ได้ 95 โปรแกรมที่คุณต้องส่งออก:

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

Python 2, 1075 1065 1043 1040 1039 ไบต์

แต่ละโปรแกรมมีรูปแบบprint'\<octal char code>'ยกเว้น:

• ' → print"\47"
• 0ผ่าน8→print~-<N+1>
• 9 → print-~8
• \ → print'%c'%92
• i → exec'pr\151nt"\151"'
• n → exec'pri\156t"\156"'
• p → exec'\160rint"\160"'
• r → exec'p\162int"\162"'
• t → exec'prin\164"\164"'

สำหรับการอ้างอิงและความง่ายในการทดสอบนี่คือรายการทั้งหมดของโปรแกรมแยกบรรทัดใหม่

print'\40'
print'\41'
print'\42'
print'\43'
print'\44'
print'\45'
print'\46'
print"\47"
print'\50'
print'\51'
print'\52'
print'\53'
print'\54'
print'\55'
print'\56'
print'\57'
print~-1
print~-2
print~-3
print~-4
print~-5
print~-6
print~-7
print~-8
print~-9
print-~8
print'\72'
print'\73'
print'\74'
print'\75'
print'\76'
print'\77'
print'\100'
print'\101'
print'\102'
print'\103'
print'\104'
print'\105'
print'\106'
print'\107'
print'\110'
print'\111'
print'\112'
print'\113'
print'\114'
print'\115'
print'\116'
print'\117'
print'\120'
print'\121'
print'\122'
print'\123'
print'\124'
print'\125'
print'\126'
print'\127'
print'\130'
print'\131'
print'\132'
print'\133'
print'%c'%92
print'\135'
print'\136'
print'\137'
print'\140'
print'\141'
print'\142'
print'\143'
print'\144'
print'\145'
print'\146'
print'\147'
print'\150'
exec'pr\151nt"\151"'
print'\152'
print'\153'
print'\154'
print'\155'
exec'pri\156t"\156"'
print'\157'
exec'\160rint"\160"'
print'\161'
exec'p\162int"\162"'
print'\163'
exec'prin\164"\164"'
print'\165'
print'\166'
print'\167'
print'\170'
print'\171'
print'\172'
print'\173'
print'\174'
print'\175'
print'\176'

ทดสอบ:

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

-1 ไบต์ขอบคุณ @ Sp3000!

CJam, 269 ไบต์

แต่ละโปรแกรมอยู่ในรูปแบบ'<char - 1>)ยกเว้น:

• Space => S, 1 ไบต์
• '=> 39c, 3 ไบต์
• )=> '*(, 3 ไบต์
• 0=> T, 1 ไบต์
• 1=> X, 1 ไบต์
• 2=> Y, 1 ไบต์
• 3=> Z, 1 ไบต์
• 4- 9=> <num-1>), 2 ไบต์

คะแนนคือ: 3 * 82 + 1 + 3 + 3 + 4 * 1 + 6 * 2 = 269

ASCII จำกัด x86 รหัสเครื่องสำหรับ DOS, 3104 3101 2913 ไบต์

ดี ... มันสั้นกว่า Java ฉันเดา ...

32 30 ไบต์สำหรับตัวละครเกือบทั้งหมดยกเว้นดูด้านล่าง

เวลาส่วนใหญ่จะเป็นไปตามรูปแบบ:

1. ทำบางอย่างxorเพื่อให้ได้ตัวชี้ไปยังจุดสิ้นสุด
2. subจาก 2 คำสุดท้ายเพราะ opcode สำหรับintไม่ได้อยู่ใน ASCII
3. ได้รับ 2 เข้าและตัวอักษรลงในAH DLทั้งสองเป็นxored เพราะตัวอักขระไม่สามารถปรากฏในโปรแกรมและ 2 ไม่ใช่อักขระ ASCII ที่พิมพ์ได้
4. พิมพ์ตัวละครด้วย int 21h
5. ออกด้วย int 20h

เวลาส่วนใหญ่หากตัวละครไม่ได้รับอนุญาตก็สามารถแทนที่ได้ด้วยการทวิตกับข้อมูลบิตหรือสลับไปที่การลงทะเบียนที่แตกต่างกัน

มันน่าสนใจขึ้นอีกเล็กน้อยเมื่อคุณพบว่าตัวเองไม่สามารถลบหรือไม่สามารถผลักหรือป๊อปอัพการลงทะเบียนที่ใช้งานได้สำหรับการคำนวณ ...

char  code
      hX'X5B&P[hT!^)7CC)7VX5t#PZ!C!B
!     hX'X5B&P[hS ^)7CC)7VX5r"PZ B A
"     hX'X5B&P[hS!^)7CC)7VX5q#PZ C B
#     hX'X5B&P[hS ^)7CC)7VX5p"PZ B A
$     hX'X5B&P[hS ^)7CC)7VX5w"PZ B A
%     hX'X5B&P[hS ^)7CC)7VX5v"PZ B A
&     hX#X5B"P[hS ^)7CC)7VX5u"PZ B A
'     hX#X5B"P[hS ^)7CC)7VX5t"PZ B A
(     hX'X5B&P[hS ^)7CC)7VX5{"PZ B A
)     hi'X5B&P[h!!X%BBHP^$!P_17C!?C17C!?hiBX5@@PZ2@2A
*     hX'X5B&P[hS ^)7CC)7VX5y"PZ B A
+     hX'X5B&P[hS ^)7CC)7VX5x"PZ B A
,     hX'X5B&P[hT ^)7CC)7VX5x"PZ!B!A
-     hX'X5B&P[hS ^)7CC)7VX5~"PZ B A
.     hX'X5B&P[hS ^)7CC)7VX5}"PZ B A
/     hX'X5B&P[hS ^)7CC)7VX5|"PZ B A
0     hX'X5B&P[hS ^)7CC)7VX5c"PZ B A
1     hX'X5B&P[hS ^)7CC)7VX5b"PZ B A
2     hX'X5B&P[hS ^)7CC)7VX5a"PZ B A
3     hX'X5B&P[hS ^)7CC)7VX5`"PZ B A
4     hX'X5B&P[hS ^)7CC)7VX5g"PZ B A
5     h;'X%[AP[h=S^)7CC)7VX%7"PZ _ ^
6     hX'X5B&P[hS ^)7CC)7VX5e"PZ B A
7     hX'X5B&P[hS _)?CC)?WX5d"PZ B A
8     hX'X5B&P[hS ^)7CC)7VX5k"PZ B A
9     hX'X5B&P[hS ^)7CC)7VX5j"PZ B A
:     hX'X5B&P[hS ^)7CC)7VX5i"PZ B A
;     hX'X5B&P[hS ^)7CC)7VX5h"PZ B A
<     hX'X5B&P[hS ^)7CC)7VX5o"PZ B A
=     hX'X5B&P[hS ^)7CC)7VX5n"PZ B A
>     hX'X5B&P[hS ^)7CC)7VX5m"PZ B A
?     hX'X5B&P[hS ^)7CC)7VX5l"PZ B A

@     hX'X5B&P[h` ^)7CC)7VX5 "PZ-B-A
A     hX'X5B&P[h`!^)7CC)7VX5!#PZ-C-B
B     h['X5A&P[h`"^)7CC)7VX5" PZ-D-C
C     hX'X5B&P_h` ^)5GG)5VX5#"PZ-B-A
D     hX'X5B&P[h` ^)7CC)7VX5$"PZ-B-A
E     hX'X5B&P[h` ^)7CC)7VX5%"PZ-B-A
F     hX'X5B&P[h` ^)7CC)7VX5&"PZ-B-A
G     hX'X5B&P[h` ^)7CC)7VX5'"PZ-B-A
H     hX'X5B&P[h` ^)7CC)7VX5("PZ-B-A
I     hX'X5B&P[h` ^)7CC)7VX5)"PZ-B-A
J     hX'X5B&P[h` ^)7CC)7VX5*"PZ-B-A
K     hX'X5B&P[h` ^)7CC)7VX5+"PZ-B-A
L     hX'X5B&P[h` ^)7CC)7VX5,"PZ-B-A
M     hX'X5B&P[h` ^)7CC)7VX5-"PZ-B-A
N     hX'X5B&P[h` ^)7CC)7VX5."PZ-B-A
O     hX'X5B&P[h` ^)7CC)7VX5/"PZ-B-A
P     hj'X5B&`[[[[[[[[h` ^)7CC)7VX50"`ZZZZZZZZ-B-A
Q     hX'X5B&P[h` ^)7CC)7VX51"PZ-B-A
R     hX'X5B&P[h` ^)7CC)7VX52"PZ-B-A
S     hX'X5B&P[h` ^)7CC)7VX53"PZ-B-A
T     hX'X5B&P[h` ^)7CC)7VX54"PZ-B-A
U     hX'X5B&P[h` ^)7CC)7VX55"PZ-B-A
V     hX'X5B&P[h` _)?CC)?WX56"PZ B A
W     hX'X5B&P[h` ^)7CC)7VX57"PZ-B-A
X     _TYhe'WWWQWWWa5B&P[hSS^)7CC)7CC5_C5 @PZ u t
Y     hX'X5B&P[h` ^)7CC)7VX59"PZ-B-A
Z     _WTYhzBX5 @Phe'WPWQWWWa5B&P[hSS^)7CC)7X u t
[     hX'X5B&P_h` ^)5GG)5VX5;"PZ-B-A
\     hX'X5B&P[h` ^)7CC)7VX5<"PZ-B-A
]     hX'X5B&P[h` ^)7CC)7VX5="PZ-B-A
^     hX'X5B&P[h` _)?CC)?WX5>"PZ-B-A
_     hX'X5B&P[h` ^)7CC)7VX5?"PZ-B-A

`     hX'X5B&P[hS ^)7CC)7VX53"PZ B A
a     hX'X5B&P[hS ^)7CC)7VX52"PZ B A
b     hX'X5B&P[hS ^)7CC)7VX51"PZ B A
c     hX'X5B&P[hS ^)7CC)7VX50"PZ B A
d     hX'X5B&P[hS ^)7CC)7VX57"PZ B A
e     hX'X5B&P[hS ^)7CC)7VX56"PZ B A
f     hX'X5B&P[hS ^)7CC)7VX55"PZ B A
g     hX'X5B&P[hS ^)7CC)7VX54"PZ B A
h     _WWX5b'5B&P[WX5S P^)7CC)7VX5;"PZ B A
i     hX'X5B&P[hS ^)7CC)7VX5:"PZ B A
j     hX'X5B&P[hS ^)7CC)7VX59"PZ B A
k     hX'X5B&P[hS ^)7CC)7VX58"PZ B A
l     hX'X5B&P[hS ^)7CC)7VX5?"PZ B A
m     hX'X5B&P[hS ^)7CC)7VX5>"PZ B A
n     hX'X5B&P[hS ^)7CC)7VX5="PZ B A
o     hX'X5B&P[hS ^)7CC)7VX5<"PZ B A
p     hX'X5B&P[hS ^)7CC)7VX5#"PZ B A
q     hX'X5B&P[hS ^)7CC)7VX5""PZ B A
r     hX'X5B&P[hS ^)7CC)7VX5!"PZ B A
s     hX'X5B&P[hS ^)7CC)7VX5 "PZ B A
t     hX'X5B&P[hS ^)7CC)7VX5'"PZ B A
u     hX'X5B&P[hS ^)7CC)7VX5&"PZ B A
v     hX'X5B&P[hS ^)7CC)7VX5%"PZ B A
w     hX'X5B&P[hS ^)7CC)7VX5$"PZ B A
x     hX'X5B&P[hS ^)7CC)7VX5+"PZ B A
y     hX'X5B&P[hS ^)7CC)7VX5*"PZ B A
z     hX'X5B&P[hS ^)7CC)7VX5)"PZ B A
{     hX'X5B&P[hS ^)7CC)7VX5("PZ B A
|     hX'X5B&P[hS ^)7CC)7VX5/"PZ B A
}     hX'X5B&P[hS ^)7CC)7VX5."PZ B A
~     hX'X5B&P[hS ^)7CC)7VX5-"PZ B A

brainfuck, 1770 1710 1703 ไบต์ 1686

บันทึก 60 ไบต์โดย Dennis
17 ไบต์บันทึกโดย Sp3000

DNP: 46 ( .)

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

ทั้งหมดยกเว้น 43, 45, 60, 62, 91 และ 93 จะถูกขโมยอย่างไร้ยางอายจากEsolangs.org

MATL, 305, 302, 300 297 ไบต์

ทุก ๆ โปรแกรมมีลักษณะดังนี้:

33c
34c
35c
....

ยกเว้น

• ตัวเลข นี่คือโปรแกรมสำหรับ 0-9:

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

• 'C' โปรแกรมนี้คือ

  'C'k
  

• ช่องว่าง นี่คือ

  0c
  

  ตั้งแต่วันนี้ฉันได้เรียนรู้ว่า MATL ปฏิบัติต่ออักขระ 0 เป็นช่องว่าง ขอบคุณ @LuisMendo!

คุณสามารถใช้matl.tioเพื่อตรวจสอบใด ๆ ของพวกเขา

สำหรับการอ้างอิงนี่คือทั้งหมดของพวกเขา:

0c
33c
34c
35c
36c
37c
38c
39c
40c
41c
42c
43c
44c
45c
46c
47c
O
l
H
I
K
4Q
5Q
6Q
7Q
8Q
58c
59c
60c
61c
62c
63c
64c
65c
66c
67c
68c
69c
70c
71c
72c
73c
74c
75c
76c
77c
78c
79c
80c
81c
82c
83c
84c
85c
86c
87c
88c
89c
90c
91c
92c
93c
94c
95c
96c
97c
98c
'C'k
100c
101c
102c
103c
104c
105c
106c
107c
108c
109c
110c
111c
112c
113c
114c
115c
116c
117c
118c
119c
120c
121c
122c
123c
124c
125c
126c

ชวา 8, 6798 6582 6577 ไบต์

ถอนหายใจ

นี่เป็นพอร์ตของ คำตอบ Python 2ฉันแต่ด้วยต้นแบบสำเร็จรูปทั้งหมดที่มาพร้อมกับการเขียนโปรแกรมแบบเต็มใน Java

ตอนนี้ไม่มี DNP เลย! ขอบคุณ Kevin Cruijssen!

โปรแกรมส่วนใหญ่มีรูปแบบ interface A{static void main(String[]a){System.out.print("\<octal char code>");}}ยกเว้น:

• ช่องว่าง→ interface\tA{static\tvoid\tmain(String[]a){System.out.print("\40");}} (แต่ด้วย\ts แทนที่ด้วยแท็บดิบ)
• " → interface A{static void main(String[]a){System.out.print('\42');}}
• ( → interface A{static void main\u0028String[]a){System.out.print\u0028"\50");}}
• ) → interface A{static void main(String[]a\u0029{System.out.print("\51"\u0029;}}
• . → interface A{static void main(String[]a){System\u002Eout\u002Eprint("\56");}}
• 0 → interface A{static void main(String[]a){System.out.print(1-1);}}
• 1 → interface A{static void main(String[]a){System.out.print(3-2);}}
• 2 → interface A{static void main(String[]a){System.out.print(3-1);}}
• 3 → interface A{static void main(String[]a){System.out.print(4-1);}}
• 4 → interface A{static void main(String[]a){System.out.print(5-1);}}
• 5 → interface A{static void main(String[]a){System.out.print(6-1);}}
• 6 → interface A{static void main(String[]a){System.out.print(7-1);}}
• 7 → interface A{static void main(String[]a){System.out.print(8-1);}}
• 8 → interface A{static void main(String[]a){System.out.print(9-1);}}
• 9 → interface A{static void main(String[]a){System.out.print(8+1);}}
• ; → interface A{static void main(String[]a){System.out.print("\73")\u003B}}
• A → interface B{static void main(String[]a){System.out.print("\101");}}
• S → interface A{static void main(\u0053tring[]a){\u0053ystem.out.print("\123");}}
• [ → interface A{static void main(String...a){System.out.print("\133");}}
• \ → interface A{static void main(String[]a){System.out.print((char)92);}}
• ] → interface A{static void main(String...a){System.out.print("\135");}}
• a → interf\u0061ce A{st\u0061tic void m\u0061in(String[]b){System.out.print("\141");}}
• c → interfa\u0063e A{stati\u0063 void main(String[]a){System.out.print("\143");}}
• d → interface A{static voi\u0064 main(String[]a){System.out.print("\144");}}
• e → class A{public static void main(String[]a){Syst\u0065m.out.print("\145");}}
• f → class A{public static void main(String[]a){System.out.print("\146");}}
• g → interface A{static void main(Strin\u0067[]a){System.out.print("\147");}}// \u0067
• i → \u0069nterface A{stat\u0069c vo\u0069d ma\u0069n(Str\u0069ng[]a){System.out.pr\u0069nt("\151");}}
• m → interface A{static void \u006Dain(String[]a){Syste\u006D.out.print("\155");}}
• n → class A{public static void mai\u006E(Stri\u006Eg[]a){System.out.pri\u006Et("\156");}}
• o → interface A{static v\u006Fid main(String[]a){System.\u006Fut.print("\157");}}
• p → interface A{static void main(String[]a){System.out.\u0070rint("\160");}}
• r → class A{public static void main(St\u0072ing[]a){System.out.p\u0072int("\162");}}
• s → interface A{\u0073tatic void main(String[]a){Sy\u0073tem.out.print("\163");}}
• t → class A{public s\u0074a\u0074ic void main(S\u0074ring[]a){Sys\u0074em.ou\u0074.prin\u0074("\164");}}
• u → interface A{static void main(String[]a){System.console().printf("%c",117);}}
• v → interface A{static \u0076oid main(String[]a){System.out.print("\166");}}
• y → interface A{static void main(String[]a){S\u0079stem.out.print("\171");}}
• { → interface A\u007Bstatic void main(String[]a)\u007BSystem.out.print("\173");}}
• } → interface A{static void main(String[]a){System.out.print("\175");\u007D\u007D

วุ้ย

คอมไพเลอร์ Java ประมวลผล Unicode หนีเช่น \u007Bก่อนที่จะทำการประมวลผลอื่น ๆ ซึ่งทำให้มันเป็นไปได้ที่จะเขียนรหัสที่ใช้ unicode หนีในตัวระบุและคำหลัก ดังนั้นในการเขียนโปรแกรมที่ไม่ได้ใช้ตัวละครในแผ่นสร้างไอเท็มเราเพียงแทนที่มันด้วยการหลบหนีแบบยูนิโค้ด

สำหรับการอ้างอิงและความง่ายในการทดสอบนี่คือรายการทั้งหมดของโปรแกรมการแยกบรรทัดใหม่และด้วยแท็บ raw ที่ถูกแทนที่ด้วยช่องว่างสี่ช่อง:

interface    A{static    void    main(String[]a){System.out.print("\40");}}
interface A{static void main(String[]a){System.out.print("\41");}}
interface A{static void main(String[]a){System.out.print('\42');}}
interface A{static void main(String[]a){System.out.print("\43");}}
interface A{static void main(String[]a){System.out.print("\44");}}
interface A{static void main(String[]a){System.out.print("\45");}}
interface A{static void main(String[]a){System.out.print("\46");}}
interface A{static void main(String[]a){System.out.print("\47");}}
interface A{static void main\u0028String[]a){System.out.print\u0028"\50");}}
interface A{static void main(String[]a\u0029{System.out.print("\51"\u0029;}}
interface A{static void main(String[]a){System.out.print("\52");}}
interface A{static void main(String[]a){System.out.print("\53");}}
interface A{static void main(String[]a){System.out.print("\54");}}
interface A{static void main(String[]a){System.out.print("\55");}}
interface A{static void main(String[]a){System\u002Eout\u002Eprint("\56");}}
interface A{static void main(String[]a){System.out.print("\57");}}
interface A{static void main(String[]a){System.out.print(1-1);}}
interface A{static void main(String[]a){System.out.print(3-2);}}
interface A{static void main(String[]a){System.out.print(3-1);}}
interface A{static void main(String[]a){System.out.print(4-1);}}
interface A{static void main(String[]a){System.out.print(5-1);}}
interface A{static void main(String[]a){System.out.print(6-1);}}
interface A{static void main(String[]a){System.out.print(7-1);}}
interface A{static void main(String[]a){System.out.print(8-1);}}
interface A{static void main(String[]a){System.out.print(9-1);}}
interface A{static void main(String[]a){System.out.print(8+1);}}
interface A{static void main(String[]a){System.out.print("\72");}}
interface A{static void main(String[]a){System.out.print("\73")\u003B}}
interface A{static void main(String[]a){System.out.print("\74");}}
interface A{static void main(String[]a){System.out.print("\75");}}
interface A{static void main(String[]a){System.out.print("\76");}}
interface A{static void main(String[]a){System.out.print("\77");}}
interface A{static void main(String[]a){System.out.print("\100");}}
interface B{static void main(String[]a){System.out.print("\101");}}
interface A{static void main(String[]a){System.out.print("\102");}}
interface A{static void main(String[]a){System.out.print("\103");}}
interface A{static void main(String[]a){System.out.print("\104");}}
interface A{static void main(String[]a){System.out.print("\105");}}
interface A{static void main(String[]a){System.out.print("\106");}}
interface A{static void main(String[]a){System.out.print("\107");}}
interface A{static void main(String[]a){System.out.print("\110");}}
interface A{static void main(String[]a){System.out.print("\111");}}
interface A{static void main(String[]a){System.out.print("\112");}}
interface A{static void main(String[]a){System.out.print("\113");}}
interface A{static void main(String[]a){System.out.print("\114");}}
interface A{static void main(String[]a){System.out.print("\115");}}
interface A{static void main(String[]a){System.out.print("\116");}}
interface A{static void main(String[]a){System.out.print("\117");}}
interface A{static void main(String[]a){System.out.print("\120");}}
interface A{static void main(String[]a){System.out.print("\121");}}
interface A{static void main(String[]a){System.out.print("\122");}}
interface A{static void main(\u0053tring[]a){\u0053ystem.out.print("\123");}}
interface A{static void main(String[]a){System.out.print("\124");}}
interface A{static void main(String[]a){System.out.print("\125");}}
interface A{static void main(String[]a){System.out.print("\126");}}
interface A{static void main(String[]a){System.out.print("\127");}}
interface A{static void main(String[]a){System.out.print("\130");}}
interface A{static void main(String[]a){System.out.print("\131");}}
interface A{static void main(String[]a){System.out.print("\132");}}
interface A{static void main(String...a){System.out.print("\133");}}
interface A{static void main(String[]a){System.out.print((char)92);}}
interface A{static void main(String...a){System.out.print("\135");}}
interface A{static void main(String[]a){System.out.print("\136");}}
interface A{static void main(String[]a){System.out.print("\137");}}
interface A{static void main(String[]a){System.out.print("\140");}}
interf\u0061ce A{st\u0061tic void m\u0061in(String[]b){System.out.print("\141");}}
interface A{static void main(String[]a){System.out.print("\142");}}
interfa\u0063e A{stati\u0063 void main(String[]a){System.out.print("\143");}}
interface A{static voi\u0064 main(String[]a){System.out.print("\144");}}
class A{public static void main(String[]a){Syst\u0065m.out.print("\145");}}
class A{public static void main(String[]a){System.out.print("\146");}}
interface A{static void main(Strin\u0067[]a){System.out.print("\147");}}
interface A{static void main(String[]a){System.out.print("\150");}}
\u0069nterface A{stat\u0069c vo\u0069d ma\u0069n(Str\u0069ng[]a){System.out.pr\u0069nt("\151");}}
interface A{static void main(String[]a){System.out.print("\152");}}
interface A{static void main(String[]a){System.out.print("\153");}}
interface A{static void main(String[]a){System.out.print("\154");}}
interface A{static void \u006Dain(String[]a){Syste\u006D.out.print("\155");}}
class A{public static void mai\u006E(Stri\u006Eg[]a){System.out.print("\156");}}
interface A{static v\u006Fid main(String[]a){System.\u006Fut.print("\157");}}
interface A{static void main(String[]a){System.out.\u0070rint("\160");}}
interface A{static void main(String[]a){System.out.print("\161");}}
class A{public static void main(St\u0072ing[]a){System.out.p\u0072int("\162");}}
interface A{\u0073tatic void main(String[]a){Sy\u0073tem.out.print("\163");}}
class A{public s\u0074a\u0074ic void main(S\u0074ring[]a){Sys\u0074em.ou\u0074.prin\u0074("\164");}}
interface A{static void main(String[]a){System.console().printf("%c",117);}}
interface A{static \u0076oid main(String[]a){System.out.print("\166");}}
interface A{static void main(String[]a){System.out.print("\167");}}
interface A{static void main(String[]a){System.out.print("\170");}}
interface A{static void main(String[]a){S\u0079stem.out.print("\171");}}
interface A{static void main(String[]a){System.out.print("\172");}}
interface A\u007Bstatic void main(String[]a)\u007BSystem.out.print("\173");}}
interface A{static void main(String[]a){System.out.print("\174");}}
interface A{static void main(String[]a){System.out.print("\175");\u007D\u007D
interface A{static void main(String[]a){System.out.print("\176");}}

โปรดทราบว่าโปรแกรมสำหรับการuใช้งานSystem.console()ซึ่งจะส่งคืน null (และทำให้รหัสโยนNullPointerException) ถ้าคุณเรียกมันจากสิ่งอื่นที่ไม่ใช่เทอร์มินัลดั้งเดิมของระบบปฏิบัติการของคุณ ( cmdบน Windows และฉันถือว่าbashบน Linux / OSX) .

ในการทดสอบให้สร้างไดเรกทอรีใหม่และวางโค้ดด้านบนลงในไฟล์ที่มีชื่อprintablesในไดเรกทอรีนั้น จากนั้นรันสคริปต์ Bash ต่อไปนี้:

#!/bin/bash
split -l 1 printables
for i in x*; do
  mkdir z$i
  mv $i z$i/A.java
done
mv zxbh/A.java zxbh/B.java
for i in zx*; do
  javac $i/[AB].java
  if ! java -cp $i A 2> /dev/null; then
    java -cp $i B
  fi
done
rm -r zx*

สคริปต์ด้านบนจะใส่แต่ละบรรทัดprintablesลงในไดเรกทอรีของตัวเองตั้งชื่อพวกเขาทั้งหมดA.java(ยกเว้นไฟล์ที่พิมพ์Aซึ่งเปลี่ยนชื่อเป็นB.java) รวบรวมไฟล์แต่ละไฟล์เรียกใช้แล้วลบหลักฐาน ควรใช้เวลาประมาณสิบวินาทีเพื่อให้อักขระ ASCII ที่พิมพ์ได้เริ่มปรากฏในเชลล์ของคุณ

หากคุณใช้ Windows ให้เรียกใช้ไฟล์ชุดต่อไปนี้แทน:

@echo off
setlocal enabledelayedexpansion
set i=0
for /F "tokens=*" %%L in (printables) do (
  set file=A.java
  if "%i%" == "33" (set file=B.java)
  echo %%L>"%file%"
  javac "%file%"
  java -cp . A
  if not errorlevel 0 (java -cp . B)
  set /A i=%i% + 1
)
del *.java
del *.class

ไฟล์แบตช์นี้ใช้แนวทางที่ต่างออกไปเล็กน้อย แทนการแบ่งบรรทัดก่อนมันประมวลผลไฟล์บรรทัดต่อบรรทัดและรวบรวมและเรียกใช้แต่ละโปรแกรมในทางกลับกัน อีกครั้งมันจะลบหลักฐานหลังจากเสร็จสิ้น

ไบต์ที่บันทึกไว้นับไม่ถ้วน + 1 DNP ขอบคุณ Kevin Cruijssen!

> <> , 443 437 ไบต์

การเชื่อมโยงล่าม TIO มีรูปแบบมากมายที่นี่:

• [num][num]*o;:คูณของตัวเลขสองแล้วออกผลเป็นถ่านด้วยและหยุดด้วยo ;> <> ตัวเลขขึ้นไปถึง 15 0123456789abcdefคือ
  • ในทำนองเดียวกัน[num][num]-n;ซึ่งจะใช้ความแตกต่างของตัวเลขสองตัวและเอาท์พุทเป็นตัวเลขด้วยnแทน

• '-o[invalid char]: > <> นั้นเป็น toroidal ดังนั้นเมื่อตัวชี้คำสั่งถึงจุดสิ้นสุดของเส้นมันจะเลื่อนกลับไปที่จุดเริ่มต้น '-o[char]'-o[char]ในกรณีนี้นี้ทำให้รหัสที่จะดำเนินการเป็นครั้งที่สองคือ '-o[char]'ส่วนแรกผลักดันตัวอักษรสามตัวไปที่สแต็คจากนั้น-คำนวณผลลัพธ์เป็นอักขระ > <> จากนั้นเกิดข้อผิดพลาดเมื่อถึงอาจเกิดจากคำสั่งที่ไม่รู้จักหรือจากการเปิดสแต็กเปล่า'o' - [char]o[char]

  • ในทำนองเดียวกัน'-n[invalid char]ซึ่งส่งออกเป็นตัวเลข
  • ในทำนองเดียวกัน'[num][op]o[invalid char]ซึ่งนำไปใช้[op]กับ[num]เมื่อข้อผิดพลาด[char]ออกไปในถ่าน ตัวอย่างเช่น'2+oJเอาต์พุตLซึ่งมากกว่าสองJรายการ
  • 'รหัสคือ"-oHใช้"แทน
  • -รหัสคือ'%oBใช้%แทน

• ln;: ความยาวของสแต็คดันเอาท์พุทเป็น NUM 0แล้วหยุดให้ ในทำนองเดียวกันlln;สำหรับ1และสำหรับ'ln;3

• 4|n+:กด 4, กระเด็น|และกดอีก 4 ครั้ง, เพิ่ม, แล้วส่งออก8เป็นตัวเลข กระเด็น|อีกครั้งและเกิดข้อผิดพลาดในการพยายามดำเนินการnอีกครั้งในสแต็กเปล่า
  • ในทำนองเดียวกันสำหรับ3|n*9
  • ในทำนองเดียวกันสำหรับ[num]|o*@Qdy
• '1-:00p:สิ่งที่น่าสนใจที่สุดสำหรับoคดีนี้ เพื่อหลีกเลี่ยงการใช้oในรหัสของเราเราจำเป็นต้องใช้pเพื่อวางoในกล่องรหัสแล้วเรียกใช้ เริ่มต้น'1-:00p'ชุดสแต็คขึ้นที่จะมีpด้านบนและ1-decrements oมันกลายเป็น :ซ้ำกันนี้oและ00pสถานที่หนึ่งoที่ (0, 0), เปลี่ยน codebox o1-:00pลง การเรียนการสอนชี้ wraps oอีกครั้งการแสดงผลอื่น ๆ char (0, 0) จะถูกแทนที่อีกสองสามครั้งก่อนที่โปรแกรมจะเกิดข้อผิดพลาดในที่สุด

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

Dyalog APL , 527 522 ไบต์

(ไม่แข่งขันเนื่องจาก APL ไม่สามารถเขียนได้โดยใช้ ASCII เท่านั้น)

ส่วนใหญ่อยู่ในรูปแบบnn⊃⎕AVหรือnnn⊃⎕AVข้อยกเว้น:

⊃''     ⍝ space: extract one char from an empty string
⎕THIS   ⍝ hash: this namespace
⊃1↓⍕÷2  ⍝ period: the first char after stripping one char from 1÷2, i.e. 0.5
⊃⍬      ⍝ zero: extract one number from an empty numeric list
≢#      ⍝ one: tally the root namespace
⍴⍬⍬     ⍝ two: count two empty lists
⎕WX     ⍝ three: default "Window Expose" setting
×⍨2     ⍝ four: 2×2
6-1     ⍝ five: 6-1
!3      ⍝ six: 3!
6+1     ⍝ seven: 6+1
2*3     ⍝ eight: 2³
3*2     ⍝ nine: 3²
⊃⎕a     ⍝ A: first character (Dyalog system names are case insensitive)
2⊃⎕A    ⍝
⋮        ⍝  B-Y: n'th character
25⊃⎕A   ⍝
⊃⌽⎕A    ⍝ Z: last character

นี่คือรายการทั้งหมด:

⊃''
205⊃⎕AV
216⊃⎕AV
⎕THIS
62⊃⎕AV
13⊃⎕AV
219⊃⎕AV
14⊃⎕AV
186⊃⎕AV
249⊃⎕AV
181⊃⎕AV
170⊃⎕AV
195⊃⎕AV
169⊃⎕AV
⊃1↓⍕÷2
157⊃⎕AV
⊃⍬
≢#
⍴⍬ ⍬
⎕WX
×⍨2
6-1
!3
6+1
2*3
3*2
241⊃⎕AV
194⊃⎕AV
161⊃⎕AV
163⊃⎕AV
165⊃⎕AV
173⊃⎕AV
232⊃⎕AV
⊃⎕a
2⊃⎕A
3⊃⎕A
4⊃⎕A
5⊃⎕A
6⊃⎕A
7⊃⎕A
8⊃⎕A
9⊃⎕A
10⊃⎕A
11⊃⎕A
12⊃⎕A
13⊃⎕A
14⊃⎕A
15⊃⎕A
16⊃⎕A
17⊃⎕A
18⊃⎕A
19⊃⎕A
20⊃⎕A
21⊃⎕A
22⊃⎕A
23⊃⎕A
24⊃⎕A
25⊃⎕A
26⊃⎕A
156⊃⎕AV
159⊃⎕AV
250⊃⎕AV
236⊃⎕AV
17⊃⎕AV
238⊃⎕AV
18⊃⎕AV
19⊃⎕AV
20⊃⎕AV
21⊃⎕AV
22⊃⎕AV
23⊃⎕AV
24⊃⎕AV
25⊃⎕AV
26⊃⎕AV
27⊃⎕AV
28⊃⎕AV
29⊃⎕AV
30⊃⎕AV
31⊃⎕AV
32⊃⎕AV
33⊃⎕AV
34⊃⎕AV
35⊃⎕AV
36⊃⎕AV
37⊃⎕AV
38⊃⎕AV
39⊃⎕AV
40⊃⎕AV
41⊃⎕AV
42⊃⎕AV
43⊃⎕AV
124⊃⎕AV
193⊃⎕AV
126⊃⎕AV
176⊃⎕AV

Ruby, 869 ไบต์

สำหรับอักขระ 63 ตัว@ผ่าน~เรามีวิธีแก้ปัญหา 10 ไบต์:

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

สำหรับส่วนมาก (21) ตัวละครจากspaceผ่าน?เรามีทางออกที่ 9 ไบต์:

puts"\xx"     (2 digit octal code)

เหลืออีกสิบเอ็ดกรณีพิเศษ:

$><<34.chr    (10 bytes for ")
p$.           (3 bytes for 0)
p~-2          \
p~-3           \ (4 bytes for 1-8)
...            /
p~-9          /
p 1+8         (5 bytes for 9)

คะแนนรวมคือ 10 × 63 + 9 × 21 + 10 + 3 + 8 × 4 + 5 = 869

WolframAlpha , 368 ไบต์

รูปแบบทั่วไป:

u+<character code in hexadecimal>

ข้อยกเว้น

Character   Code
+           plus
0           1-1
1           0!
2           1+1
3           1+2
4           2+2
5           2+3
6           3!
7           3+4
8           4+4
9           4+5
u           U+75

นี่คือรายการทั้งหมด:

u+20
u+21
u+22
u+23
u+24
u+25
u+26
u+27
u+28
u+29
u+2A
plus
u+2C
u+2D
u+2E
u+2F
1-1
0!
1+1
1+2
2+2
2+3
3!
3+4
4+4
4+5
u+3A
u+3B
u+3C
u+3D
u+3E
u+3F
u+40
u+41
u+42
u+43
u+44
u+45
u+46
u+47
u+48
u+49
u+4A
u+4B
u+4C
u+4D
u+4E
u+4F
u+50
u+51
u+52
u+53
u+54
u+55
u+56
u+57
u+58
u+59
u+5A
u+5B
u+5C
u+5D
u+5E
u+5F
u+60
u+61
u+62
u+63
u+64
u+65
u+66
u+67
u+68
u+69
u+6A
u+6B
u+6C
u+6D
u+6E
u+6F
u+70
u+71
u+72
u+73
u+74
U+75
u+76
u+77
u+78
u+79
u+7A
u+7B
u+7C
u+7D
u+7E

PHP ( 891 680 674 ไบต์, 2 0 DNP)

แก้ไข:บันทึกแล้ว 203 ไบต์ขอบคุณ jimmy23013 และติดตั้ง 2 DNP ขอบคุณ Mego

คำตอบนี้ใช้ในทางที่ผิดอย่างยิ่งลักษณะของ PHP กรณีส่วนใหญ่ใช้หนึ่งในรูปแบบเหล่านี้ (แต่ละ 7 ไบต์):

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

PHP จะแปลงตัวอักษรที่ด้านข้างของโอเปอเรเตอร์เป็นสตริงจากนั้นดำเนินการบิตบิทที่เหมาะสมโดยแปลงแต่ละสตริงเป็นค่าอักขระ ASCII และในที่สุดก็แปลงผลลัพธ์กลับไปเป็นอักขระ

ในตัวอย่างแรกข้างต้นจะกลายเป็นY^x 89^78ผลจากการนี้ก็คือ33ที่จะส่งไปยัง STDOUT !เป็นตัวอักษร

สคริปต์ถูกเขียนขึ้นเพื่อ bruteforce ผสมเป็นไปได้ทั้งหมด: ผลลัพธ์ที่สามารถพบได้ที่นี่

ข้อยกเว้น

;คือ<?=Z^a?>(8 ไบต์)
|คือ<?='9'^E;(9 ไบต์)

<และ?โดยปกติจะเป็น DNP เนื่องจากแท็กเริ่มต้นที่ต้องการ แต่โดยใช้-rแฟล็กรหัสสามารถเรียกใช้งานได้โดยไม่ต้องใช้:

<คือecho Z^f;(9 ไบต์)
?คือecho Z^e;(9 ไบต์)
=คือecho Z^g;(9 ไบต์)

คะแนน:

(7 * 90) + 8 + 9 + 9 + 9 + 9 = 674 ไบต์

Brachylog , 546 477 ไบต์

เครดิตสำหรับ Fatalize สำหรับรหัสสำหรับ @สำหรับรหัสสำหรับ

ในรายการด้านล่างตัวอักษรตัวแรกคือตัวอักษรที่จะพิมพ์ (เพื่อการอ้างอิงที่ง่าย)

  @S
! @Ht
"@P: 2m
# @P: 3m
$ @P: 4m
% @P: 5 ม
& @P: 6 ม
'@P: 7m
(@P: 8 ม
) @P: 9m
* @P: 10 ม
+ @P: 11m
, @H: 5 ม
- @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: 30 ม
? @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: 40 ม
ฉัน @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: 60 ม
] @P: 61m
^ @P: 62m
_ @P: 63m
`@P: 64m
@Vh
b @Ch
c @Dbh
d @ A: 3m
e @Vbh
f @A: 5m
g @A: 6m
h @A: 7m
ฉัน @A: 8m
j @A: 9m
k @C: 7m
l @C: 8m
m @ D @ 2ht
n @ A: 13m
o @H: 4m
p @A: 15m
q @Z: 9m
r @Z: 8m
s @Z: 7m
t @ Z: 6m
คุณ @Vt
v @Z: 4m
w @Qt
x @Z: 2 ม
y @Wt
z @At
{@P: 91m
| @P: 92m
} @Prbh
~ @Pt

เป็นเพรดิเคตทั้งหมดดังนั้นจึงZต้องเป็นอาร์กิวเมนต์เพื่อรับเอาต์พุต: ลองออนไลน์!

คำอธิบาย

@P คือสายนี้:

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

ซึ่งมีทุก ASCII ที่พิมพ์ได้

> <> , 531 ไบต์

โปรแกรมใช้สองรูปแบบหลัก:

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

ตัวแรกคือตัวอักษรที่มีรหัสตัวอักษรที่มีสองปัจจัยทั้งน้อยกว่า 16 ตัวส่วนอีกตัวเป็นตัวพิมพ์ใหญ่ ตัวเลขส่วนใหญ่ที่ฉันใช้ในรูปแบบที่สองมีวิธีแก้ปัญหาความยาวเท่ากัน แต่ฉันเลือกรูปแบบนั้นเพื่อให้สามารถอ่านได้

ข้อยกเว้น

" b3*1+o; Would be "!"1+o; normally
0 11-n; n outputs as a number
1 22/n;
2-9 #1+n;
; ":"1+o* Ends in an error

รายการเต็ม:

! b3*o;
" b3*1+o;
# 57*o;
$ 66*o;
% "$"1+o;
& "%"1+o;
' d3*o;
( a4*o;
) "("1+o;
* ")"1+o;
+ ","1-o;
, b4*o;
- 95*o;
. "-"1+o;
/ "."1+o;
0 11-n;
1 22/n;
2 11+n;
3 21+n;
4 31+n;
5 41+n;
6 51+n;
7 61+n;
8 71+n;
9 81+n;
: "9"1+o;
; ":"1+o*
< a6*o;
= "<"1+o;
> "="1+o;
? 97*o;
@ 88*o;
A d5*o;
B b6*o;
C "B"1+o;
D "C"1+o;
E "D"1+o;
F a7*o;
G "F"1+o;
H 98*o;
I "H"1+o;
J "D"1+o;
K e5*o;
L "K"1+o;
M b7*o;
N d6*o;
O "D"1+o;
P a8*o;
Q 99*o;
R "Q"1+o;
S "R"1+o;
T c7*o;
U "T"1+o;
V "U"1+o;
W "V"1+o;
X b8*o;
Y "X"1+o;
Z a9*o;
[ c7*o;
\ "["1+o;
] "\"1+o;
^ "]"1+o;
_ "^"1+o;
` c8*o;
a "`"1+o;
b e7*o;
c b9*o;
d aa*o;
e "d"1+o;
f "e"1+o;
g "g"1+o;
h d8*o;
i e7*o;
j "i"1+o;
k "j"1+o;
l c9*o;
m "l"1+o;
n ba*o;
o DNP
p e8*o;
q "p"1+o;
r "q"1+o;
s "r"1+o;
t "s"1+o;
u c9*o;
v "u"1+o;
w "v"1+o;
x ca*o;
y bb*o;
z "y"1+o;
~ e9*o;

Hexagony , 376 373 ไบต์, 1 DNP

ขอบคุณ FryAmTheEggman สำหรับการบันทึก 3 ไบต์

เกือบทุกโปรแกรมมีรูปแบบเดียวกัน:

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

มีข้อยกเว้นเล็กน้อยว่า:

• มันเป็นไปไม่ได้ที่จะพิมพ์;โดยไม่ใช้;ดังนั้น 1 DNP
• ในการพิมพ์@เราไม่สามารถใช้@เพื่อยุติโปรแกรม แต่เราใช้อย่างใดอย่างหนึ่งS2;:หรือS3;%หรือสิ่งนี้จบลงด้วยข้อผิดพลาดการหารด้วยศูนย์ แต่ข้อผิดพลาดนั้นไม่สามารถมองเห็นได้บน STDOUT ดังนั้นนี่คือสี่ไบต์
• มีอยู่คนหนึ่งคือการปะทะกันซึ่งจะต้องมีU U3;@มีหลายวิธีในการแก้ไขปัญหานี้รวมถึงการเปลี่ยนเป็นตัวพิมพ์เล็กเช่นn9;@หรือใช้การเพิ่มขึ้นหรือลดลงเช่นT);@หรือV(;@หรือไม่ว่าในกรณีใดก็ยังคงมีสี่ไบต์
• หน่วยความจำเริ่มต้นที่ขอบ0และ!พิมพ์ค่าจำนวนเต็มดังนั้นเราสามารถรับ0และ1ด้วย!@และ)!@ตามลำดับการบันทึก 3 ไบต์

สำหรับวิธีการ<letter><digit>;@ทำงานของโปรแกรม: เลย์เอาต์หกเหลี่ยมของโปรแกรมในแบบฟอร์ม1234อยู่เสมอ

 1 2
3 4 .
 . .

เนื่องจากไม่มีโปรแกรมใดที่มีคำสั่งใด ๆ ที่เปลี่ยนเส้นทางโฟลว์ควบคุมนี่เป็นเพียงโปรแกรมเชิงเส้นที่ดำเนินการตามลำดับ

ในทุกกรณีตัวอักษรที่จุดเริ่มต้นของรหัสจะตั้งค่าขอบหน่วยความจำปัจจุบันเป็นรหัสอักขระ เช่นในโปรแกรมP1;@ที่ชุดค่าP 80จากนั้นตัวเลขจะคูณค่านี้ด้วย 10 และเพิ่มตัวเอง (เช่นตัวเลขจะถูกผนวกเข้ากับค่าปัจจุบัน) ที่ให้801ในตัวอย่างข้างต้น ในที่สุด;พิมพ์ค่านี้โดยใช้มัน modulo 256 และใช้เป็นค่าไบต์ ในกรณีนี้801 % 256 = 33และ!พิมพ์

ช่องว่าง , 1643 ไบต์, 1 DNP

17 ไบต์สำหรับอักขระ [33-63] และ 18 ไบต์สำหรับอักขระ [64-126]

ในช่องว่างนี่จะส่งตรงไปข้างหน้าเนื่องจากอักขระที่พิมพ์ได้ (ยกเว้นช่องว่าง) ไม่มีความหมายใด ๆ อยู่แล้ว:

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

โปรแกรมด้านบนจะพิมพ์ '!' (100001b) เปลี่ยน[TAB][SPACE][SPACE][SPACE][SPACE][TAB]ในบรรทัดแรกเป็นตัวละครที่คุณชอบ ไม่สามารถพิมพ์ช่องว่างโดยไม่ใช้ช่องว่างเพราะการพิมพ์ทุกอย่างเริ่มต้นด้วยเสมอ[TAB][LF][SPACE]

Retina , 712 ไบต์, 2 DNPs

นี่เป็นความร่วมมือกับ FryAmTheEggman

มีการแก้ปัญหาหลายระดับ สำหรับตัวละครส่วนใหญ่จากอวกาศถึง^เราใช้โปรแกรมในแบบฟอร์มต่อไปนี้:

_
T`w`p

อักขระในบรรทัดที่สองจะวนซ้ำตามช่วง_0-9A-Za-zในขณะที่ส่วนที่เหลือยังคงไม่เปลี่ยนแปลง สิ่งนี้จะเปลี่ยนอินพุตว่างให้เป็นอักขระนั้นจากนั้นแทนที่ด้วยอักขระ ASCII ที่พิมพ์ได้ (แทนด้วยp) ที่ตำแหน่งที่สอดคล้องกัน แต่ละโปรแกรมเหล่านี้มีความยาว 8 ไบต์

ภายในช่วงนี้มีข้อยกเว้นเพียงเล็กน้อยเท่านั้น สิ่งสำคัญที่สุดคือตัวเลขสามารถสั้นลง:

• 0: x (นับจำนวนxs ในอินพุตว่าง)
• 1:  (weehoo โปรแกรมที่ว่างเปล่านับจำนวนการจับคู่ที่ว่างเปล่าในอินพุตที่ว่างเปล่า)

• 2: ตอนนี้เราเปลี่ยนอินพุตให้เป็นอักขระเดียวก่อนนับสตริงว่าง:

  
  1
  
  

• 3: สิ่งเดียวกัน แต่เราเปลี่ยนอินพุตให้เป็นอักขระสองตัว:

  
  11
  
  

• 4: คุณได้รับความคิด ...

  
  111
  
  

• 5-7

  
  4$*
  
  

  ...

  
  8$*
  
  

ข้อยกเว้นอื่น ๆ คือ Tคือ DNP: เราไม่คิดว่าเป็นไปได้ที่จะสร้างตัวละครที่ไม่ใช่ตัวเลขโดยไม่ปรากฏในซอร์สโค้ดหากขั้นตอนการถอดเสียงไม่สามารถใช้งานได้

เมื่อถึงตัวละครที่เหลือ ในการพิมพ์_เราใช้โปรแกรมที่คล้ายกับโซลูชันทั่วไปด้านบน:

0
T`0`w

การใช้ประโยชน์จากความจริงที่ว่าเริ่มต้นด้วยw_

ถัดไป`คือ DNP ตัวที่สองเนื่องจากขั้นตอนการถอดเสียงต้องใช้เช่นกัน

จากนั้นตัวอักษรตัวพิมพ์เล็กส่วนใหญ่จะถูกพิมพ์ด้วยสิ่งนี้ (ที่พิมพ์a):

_
T`w`l

อักขระบนบรรทัดที่สองเพิ่มขึ้น_0-9A-Oอีกครั้ง ที่นี่เราเพียงแค่ต้องระวังlและwซึ่งเราสามารถพิมพ์ด้วยโปรแกรมต่อไปนี้ตามลำดับ:

P
T`p`w

6
T`p`l

ในที่สุดเหลือเพียง{|}~9 ไบต์เท่านั้นที่ต้องใช้ ที่นี่เราใช้ขั้นตอนการทับศัพท์เพื่อเพิ่มอักขระที่นำหน้าพวกเขา เช่น~สามารถพิมพ์ด้วย:

}
T`_p`p

Pyke, 364 362 355 ไบต์

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

ทั้งหมดอยู่ในรูปแบบw<chr(charcode+32)>.C(4 ไบต์) ยกเว้น:

• -> d 1 ไบต์
• 0 -> Z 1 ไบต์
• 1 -> ~W 2 ไบต์
• a -> Gh 2 ไบต์
• z -> Ge 2 ไบต์
• ตัวอักษรตัวพิมพ์เล็ก 10 ตัวแรก (ยกเว้นa) ในรูปแบบG<number>@ (3 ไบต์)
• k -> GT@ 3 ไบต์
• > -> ~Bh 3 ไบต์
• ] -> ~Be 3 ไบต์
• Z -> ~le 3 ไบต์
• 9 -> ~ue 3 ไบต์
• w -> G22@ 4 ไบต์
• . -> ~B4@ 4 ไบต์
• C -> ~K38@ 5 ไบต์

ล่าม Pyke ออนไลน์

JavaScript (ES6), 1083 1068 ไบต์

แบบฟอร์มทั่วไป:

alert`\xhex`

ข้อยกเว้น

0 alert(9-9)
...
8 alert(9-1)
9 alert(8+1)
\ alert(atob`XA`)
` alert('\x60')
a \u0061lert`\x61`
e al\u0065rt`\x65`
l a\u006cert`\x6c`
r ale\u0072t`\x72`
t aler\u0074`\x74`
x alert`\u0078`

แก้ไข: บันทึก 15 ไบต์ขอบคุณ @ GOTO0

05AB1E , 417 ไบต์

!   62D>B
"   63D>B
#   64D>B
$   65D>B
%   66D>B
&   67D>B
'   68D>B
(   69D>B
)   70D>B
*   71D>B
+   72D>B
,   73D>B
-   74D>B
.   75D>B
/   76D>B
0   1<
1   X
2   Y
3   Z
4   3>
5   4>
6   5>
7   6>
8   7>
9   8>
:   77D>B
;   78D>B
<   79D>B
=   80D>B
>   81D1+B
?   82D>B
@   83D>B
A   Th
B   T>h
C   T>>h
D   T3+h
E   T4+h
F   T5+h
G   16D>B
H   17D>B
I   18D>B
J   19D>B
K   20D>B
L   21D>B
M   22D>B
N   23D>B
O   24D>B
P   25D>B
Q   26D>B
R   27D>B
S   28D>B
T   29D>B
U   30D>B
V   31D>B
W   33D>B
X   33D>B
Y   A`\u
Z   A`u
[   84D>B
\   85D>B
]   86D>B
^   87D>B
_   88D>B
`   89D>B
a   A`r
b   A`r\
c   38D>B
d   39D>B
e   40D>B
f   41D>B
g   42D>B
h   43D>B
i   44D>B
j   45D>B
k   46D>B
l   47D>B
m   48D>B
n   49D>B
o   50D>B
p   51D>B
q   52D>B
r   53D>B
s   54D>B
t   55D>B
u   56D>B
v   57D>B
w   58D>B
x   A`\\
y   A`\
z   A`
{   90D>B
|   91D>B
}   92D>B
~   93D>B

คำอธิบาย

ส่วนใหญ่จะเป็น 5 convert nr to base nr+1ไบต์ยาวของรูปแบบ:
>ต้องการไบต์พิเศษเนื่องจากเราไม่สามารถใช้ส่วนเพิ่มได้

a,b,x,y,z,Y,ZสกัดจากAที่มีตัวอักษรในกรณีที่ต่ำกว่า

A,B,C,D,E,F ตัวเลขที่ถูกแปลงเป็นเลขฐานสิบหก

0-9 เป็นการเพิ่ม / ลดลงอย่างง่ายเช่นเดียวกับตัวแปรที่กำหนดไว้ล่วงหน้า

Marbelous, 220 ไบต์

สำหรับตัวละครที่ไม่ใช่ตัวเลขมันเป็นเพียงตัวเลขฐานสิบหกสองตัวใหญ่ของรหัสอักขระ ตัวอย่างเช่นผลลัพธ์ของโปรแกรมต่อไปนี้A:

41

สำหรับตัวเลขที่ไม่ใช่3ให้แทนที่2Fด้วยรหัสต่อไปนี้ด้วยเลขฐานสิบหกตัวพิมพ์ใหญ่ของรหัสอักขระ - 1:

2F
++

สำหรับ3:

66
>>

คะแนนรวม: 2 * 85 + 5 * 10 = 220

ล่าม.

ความพยายามครั้งแรกของฉันคือ Bubblegum และมันไม่ได้ผลกับตัวละครมาก่อน?...

Perl 6: 921 ไบต์

การแปลของโซลูชัน Python

แต่ละโปรแกรมมีรูปแบบsay "\x<hex escape code>"ยกเว้น:

• s → put "\x73"
• a → put "\x61"

• y → put "\x79"

• → "\x20".say

• " → say chr 34
• \ → say chr 92
• x → say chr 120
• 0 → say 1-1
• 1 → say 3-2
• 2เป็น9→say <n minus one>+1

สำหรับการอ้างอิงและความง่ายในการทดสอบนี่คือรายการทั้งหมดของโปรแกรมแยกบรรทัดใหม่

"\x20".say
say "\x21"
say chr 34
say "\x23"
say "\x24"
say "\x25"
say "\x26"
say "\x27"
say "\x28"
say "\x29"
say "\x2A"
say "\x2B"
say "\x2C"
say "\x2D"
say "\x2E"
say "\x2F"
say 1-1
say 3-2
say 1+1
say 2+1
say 3+1
say 4+1
say 5+1
say 6+1
say 7+1
say 8+1
say "\x3A"
say "\x3B"
say "\x3C"
say "\x3D"
say "\x3E"
say "\x3F"
say "\x40"
say "\x41"
say "\x42"
say "\x43"
say "\x44"
say "\x45"
say "\x46"
say "\x47"
say "\x48"
say "\x49"
say "\x4A"
say "\x4B"
say "\x4C"
say "\x4D"
say "\x4E"
say "\x4F"
say "\x50"
say "\x51"
say "\x52"
say "\x53"
say "\x54"
say "\x55"
say "\x56"
say "\x57"
say "\x58"
say "\x59"
say "\x5A"
say "\x5B"
say chr 92
say "\x5D"
say "\x5E"
say "\x5F"
say "\x60"
put "\x61"
say "\x62"
say "\x63"
say "\x64"
say "\x65"
say "\x66"
say "\x67"
say "\x68"
say "\x69"
say "\x6A"
say "\x6B"
say "\x6C"
say "\x6D"
say "\x6E"
say "\x6F"
say "\x70"
say "\x71"
say "\x72"
put "\x73"
say "\x74"
say "\x75"
say "\x76"
say "\x77"
say chr 120
put "\x79"
say "\x7A"
say "\x7B"
say "\x7C"
say "\x7D"
say "\x7E"

นี่คือรหัสที่ฉันใช้ทดสอบรายการด้านบนและนับคะแนน:

#!/usr/bin/env perl6

my $file = 'print_ascii_characters.p6';

my @expected = ' ' .. '~';
my @code     = $file.IO.lines;
my $code     = @code.join: ';';
my @got      = (run 'perl6', '-e', $code, :out).out.lines.map: |*.comb;

given +@expected, +@got, +@code -> ($e, $g, $c) {
    say "WRONG COUNT: Expected $e / output $g / source $c" and exit if not $e == $g == $c;
}

for @expected Z @got -> ($e, $g) {
    say "WRONG OUTPUT: Expected {$e.perl}, got {$g.perl}" and exit if $e ne $g;
}

for @expected Z @code -> ($char, $code) {
    say "COLLISION: {$char.perl} contained in {$code.perl}" if $code.match($char);
}

say "SCORE: ", @code.map(*.chars).sum;

Haskell, 1874 1864 1856 1855 1795 1791 1589 ไบต์, 7 DNPs

โปรแกรมส่วนใหญ่เป็นmain=putChar '\xx'หรือmain=putChar '\xxx'ที่ไหนxx/ xxxเป็นรหัส ASCII ของถ่านที่จะพิมพ์ ใช้ได้กับตัวอักษรทั้งหมด 14 ตัวเท่านั้น:

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

อย่างไรก็ตามสำหรับตัวเลข1 7 4 ไบต์สามารถบันทึกได้ (ขอบคุณ Christian Sievers!):

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

โปรแกรม 52 รายการc(รหัส 99) ใช้เวลา 18 ไบต์ส่วนที่เหลืออีก 19 รายการใช้เวลา 19 ไบต์ต่อโปรแกรม

คะแนนบางส่วน: 10*14 + 52*18 + 19*19 = 1437

สำหรับ 7 ตัวอักษรที่เหลือโปรแกรมต่อไปนี้ทำงาน:

    main=putChar$'\32'
'   main=putStr$pred<$>"("
C   main=putStr['\67']
\   main=putChar$pred ']'
h   main=putStr['\104']
p   main=interact(\_->['\112'])
u   main=interact(\_->['\117'])

คะแนนบางส่วน: 18 + 22 + 18 + 21 + 19 + 27 + 27 = 152

ใบนี้ 7 DNPs: =aimnrt

แต่ละโปรแกรม Haskell จำเป็นต้องกำหนด main ( main=) ดังนั้นนั่นคือ 5 DNP พิมพ์ไป stdout, putChar, putStrหรือinteractสามารถใช้ผลผลิตtและrDNPs เป็นต่อ (นอกจากนี้ยังมีprintแต่print 'a'พิมพ์'a'และไม่ได้a- และยังมีtและrต่อไป.) Haskell นอกจากนี้ยังมีchrฟังก์ชั่นที่ส่งกลับถ่านที่สอดคล้องกันได้รับหมายเลขอย่างไรเพื่อที่จะใช้มันimport Data.Charเป็นสิ่งจำเป็น

คะแนนรวม: 1437 + 152 = 1589 7 DNPs

BBC Basic, 422 413 bytes

ดาวน์โหลดล่ามฟรีที่http://www.bbcbasic.co.uk/bbcwin/bbcwin.html

บันทึกไปแล้ว 9 ไบต์จาก Leaky Nun

แบบฟอร์มทั่วไป

V.<character code>

32 .. 99ไม่รวม 12 กรณีพิเศษ: 56x4 = 224 ไบต์

100..126 : 27x5 = 135 ไบต์

12 กรณีพิเศษ: 54 ไบต์

ตัวเลขส่วนใหญ่เป็นไปตามแบบฟอร์มทั่วไป แต่ฉันรวมพวกเขาทั้งหมดที่นี่เพื่อแสดงว่าปัญหาอยู่ที่ใด

อักขระตัวแรกคืออักขระที่จะพิมพ์

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

Minkolang 0.15 , 604 ไบต์

สำหรับตัวละครส่วนใหญ่"<char-1>"1+O.น่าจะเป็นโปรแกรมที่ถูกต้องซึ่งอาจเป็นหนึ่งในระยะสั้นที่สุด อย่างไรก็ตามเนื่องจากความจริงที่ว่าอักขระถูกเก็บเป็นจุดรหัสบนสแต็กหมายความว่าหลายตัวสามารถสร้างได้โดยการคูณและการเพิ่มในห้าไบต์หรือน้อยกว่า นอกจากนี้ทราบว่าl, $1, $2, $3, $4, $5, $6, $lมี10, 11, 12, 13, 14, 15, 16, 100ตามลำดับ

รูปแบบ: <character>: <program>

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

กล่าวถึงเป็นพิเศษ:

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

(ลองเลย) Minkolang มีความสามารถในการปรับเปลี่ยนอักขระในกล่องรหัสดังนั้นสิ่งที่โปรแกรมนี้ทำคือมันแทนที่โปรแกรมนั้น-ในตอนท้ายด้วย.ซึ่งจำเป็นสำหรับการหยุดโปรแกรม "N"1+d90pN.สำหรับการOทำงานในลักษณะเดียวกัน

4: lZIO.

(ลองใช้งาน) lZผลักตัวอักษรตัวพิมพ์ใหญ่และตัวพิมพ์เล็กไปยังสแต็กและIดันความยาวของสแต็กซึ่งเป็น 52 ซึ่งเป็นจุดรหัสที่แม่นยำของ "4" ส่วนที่ดีที่สุดคือตอนแรกฉันกำลังพิจารณาวิธีแก้ปัญหาของ4$3*O.ซึ่งคูณ 4 และ 13 เพื่อรับ 52 แต่ทำไม่ได้เพราะมันมี 4 อยู่ในนั้นฉันเลยลงเอยด้วยการหาวิธีแก้ปัญหานักกอล์ฟ!

y: $1d*O.

(ลองใช้งาน) dทำซ้ำด้านบนสุดของสแต็กดังนั้นสิ่งที่โค้ดนี้ทำคือกดผลัก11ทำซ้ำและทวีคูณ วิธีอื่นในการเขียนสิ่งนี้น่าจะมี$12;O.ซึ่งมีจำนวนไบต์เดียวกัน

}: 53;O.

(ลองเลย) ;เป็นการยกกำลังดังนั้นนี่จะเป็น 5 ^ 3 เพื่อรับ 125

Groovy ขนาด 1019 ไบต์

ฉันมีวิธีการแก้ปัญหา Groovy ที่แตกต่างกันเขียนขึ้น (ดูด้านล่าง) แต่หลังจากที่ฉันส่งฉันได้ขุดลงไปในการหลบหนีตัวละครอีกเล็กน้อยหวังที่จะหาวิธีที่จะทำให้โปรแกรมสั้นลงมากขึ้นและค้นพบว่า Groovy ไม่ทราบ สิ่งนี้ทำให้รหัสง่ายขึ้นอย่างมากจนถึงจุดที่น่าเสียดายที่ไม่จำเป็นต้องใช้วิธีแก้ปัญหาที่แปลกประหลาดเกือบทั้งหมดที่ฉันได้ทำ

มันก็ดูเหมือนกับโซลูชัน Python 2 ของ Copperเกือบจะถึงจุดที่มันดูเหมือนว่าฉันลอกเลียนผลงานของพวกเขา ฮึ.

แต่ละโปรแกรมมีรูปแบบprint'\<octal value>'ยกเว้น:

• p, r, i, n, t→ 'print''\<octal value>'( แต่ด้วยตัวอักษรการจับคู่ของ "พิมพ์" ก็ถูกแทนที่ด้วยค่าฐานแปด)
• 0- 9→print~-<next int>

นี่คือรายการทั้งหมดของโปรแกรมโดยตัวละคร

    print'\40'
!   print'\41'
"   print'\42'
#   print'\43'
$   print'\44'
%   print'\45'
&   print'\46'
'   print'\47'
(   print'\50'
)   print'\51'
*   print'\52'
+   print'\53'
,   print'\54'
-   print'\55'
.   print'\56'
/   print'\57'
0   print~-1
1   print~-2
2   print~-3
3   print~-4
4   print~-5
5   print~-6
6   print~-7
7   print~-8
8   print~-9
9   print~-10
:   print'\72'
;   print'\73'
<   print'\74'
=   print'\75'
>   print'\76'
?   print'\77'
@   print'\100'
A   print'\101'
B   print'\102'
C   print'\103'
D   print'\104'
E   print'\105'
F   print'\106'
G   print'\107'
H   print'\110'
I   print'\111'
J   print'\112'
K   print'\113'
L   print'\114'
M   print'\115'
N   print'\116'
O   print'\117'
P   print'\120'
Q   print'\121'
R   print'\122'
S   print'\123'
T   print'\124'
U   print'\125'
V   print'\126'
W   print'\127'
X   print'\130'
Y   print'\131'
Z   print'\132'
[   print'\133'
\   print'\134'
]   print'\135'
^   print'\136'
_   print'\137'
`   print'\140'
a   print'\141'
b   print'\142'
c   print'\143'
d   print'\144'
e   print'\145'
f   print'\146'
g   print'\147'
h   print'\150'
i   'pr\151nt''\151'
j   print'\152'
k   print'\153'
l   print'\154'
m   print'\155'
n   'pri\156t''\156'
o   print'\157'
p   '\160rint''\160'
q   print'\161'
r   'p\162int''\162'
s   print'\163'
t   'prin\164''\164'
u   print'\165'
v   print'\166'
w   print'\167'
x   print'\170'
y   print'\171'
z   print'\172'
{   print'\173'
|   print'\174'
}   print'\175'
~   print'\176'

Groovy ขนาด 1130 ไบต์

โปรแกรมก่อนหน้าของฉันก่อนที่ฉันจะค้นพบว่ามีฐานแปดอยู่ น่าสนใจยิ่งขึ้น IMO

แต่ละโปรแกรมมีรูปแบบprint(--'<next char>')ยกเว้น:

• -, [, ~→print(++'<previous char>')
• & → print(--"'")
• p, r, i, n→System.out<<--'<next char>'
• t → 'prin\u0074'(--'u')
• ( → print'\u0028'
• ) → print'\u0029'
• 0- 9→print~-<next int>

นี่คือรายการโปรแกรมทั้งหมดสำหรับตัวละครแต่ละตัว:

    print(--'!')
!   print(--'"')
"   print(--'#')
#   print(--'$')
$   print(--'%')
%   print(--'&')
&   print(--"'")
'   print(--'(')
(   print'\u0028'
)   print'\u0029'
*   print(--'+')
+   print(--',')
,   print(--'-')
-   print(++',')
.   print(--'/')
/   print(--'0')
0   print~-1
1   print~-2
2   print~-3
3   print~-4
4   print~-5
5   print~-6
6   print~-7
7   print~-8
8   print~-9
9   print~-10
:   print(--';')
;   print(--'<')
<   print(--'=')
=   print(--'>')
>   print(--'?')
?   print(--'@')
@   print(--'A')
A   print(--'B')
B   print(--'C')
C   print(--'D')
D   print(--'E')
E   print(--'F')
F   print(--'G')
G   print(--'H')
H   print(--'I')
I   print(--'J')
J   print(--'K')
K   print(--'L')
L   print(--'M')
M   print(--'N')
N   print(--'O')
O   print(--'P')
P   print(--'Q')
Q   print(--'R')
R   print(--'S')
S   print(--'T')
T   print(--'U')
U   print(--'V')
V   print(--'W')
W   print(--'X')
X   print(--'Y')
Y   print(--'Z')
Z   print(--'[')
[   print(++'Z')
\   print(--']')
]   print(--'^')
^   print(--'_')
_   print(--'`')
`   print(--'a')
a   print(--'b')
b   print(--'c')
c   print(--'d')
d   print(--'e')
e   print(--'f')
f   print(--'g')
g   print(--'h')
h   print(--'i')
i   System.out<<--'j'
j   print(--'k')
k   print(--'l')
l   print(--'m')
m   print(--'n')
n   System.out<<--'o'
o   print(--'p')
p   System.out<<--'q'
q   print(--'r')
r   System.out<<--'s'
s   print(--'t')
t   'prin\u0074'(--'u')
u   print(--'v')
v   print(--'w')
w   print(--'x')
x   print(--'y')
y   print(--'z')
z   print(--'{')
{   print(--'|')
|   print(--'}')
}   print(--'~')
~   print(++'}')

อันที่จริง , 383 382 381 ไบต์

1 ไบต์ต้องขอขอบคุณ Mego

เพื่อการอ้างอิงที่ง่ายคอลัมน์แรกคือรหัสอักขระคอลัมน์ที่สองคืออักขระและคอลัมน์ที่สามคือรหัส

รหัสสำหรับ0เป็นช่องว่างเดียว

032   :32c
033 ! HN
034 " 9Fc
035 # :35c
036 $ :36c
037 % :37c
038 & :38c
039 ' :39c
040 ( :40c
041 ) 9R$N
042 * :42c
043 + :43c
044 , :44c
045 - :45c
046 . :46c
047 / :47c
048 0  
049 1 0Y
050 2 0P
051 3 1P
052 4 3u
053 5 2P
054 6 3!
055 7 3P
056 8 6F
057 9 NF
058 : 9P;+c
059 ; :59c
060 < :60c
061 = :61c
062 > :62c
063 ? :63c
064 @ :64c
065 A :65c
066 B :66c
067 C :67c
068 D :68c
069 E :69c
070 F :70c
071 G :71c
072 H :72c
073 I :73c
074 J :74c
075 K :75c
076 L :76c
077 M :77c
078 N :78c
079 O :79c
080 P :80c
081 Q :81c
082 R :82c
083 S :83c
084 T :84c
085 U :85c
086 V :86c
087 W :87c
088 X :88c
089 Y :89c
090 Z :90c
091 [ k$F
092 \ :92c
093 ] k$N
094 ^ :94c
095 _ :95c
096 ` :96c
097 a :97c
098 b :98c
099 c :12#"%x"%
100 d :100c
101 e :101c
102 f :102c
103 g :103c
104 h :104c
105 i :105c
106 j :106c
107 k :107c
108 l :108c
109 m :109c
110 n :110c
111 o :111c
112 p :112c
113 q 9PPc
114 r 9R$F
115 s :115c
116 t :116c
117 u :117c
118 v :118c
119 w 5!Dc
120 x 5!c
121 y 5!uc
122 z :122c
123 { :123c
124 | :124c
125 } :125c
126 ~ :126c

ลองออนไลน์!

ยินดีให้คำแนะนำการเล่นกอล์ฟ

ฟูเรียร์ 306 ไบต์ 1 DNP

โปรแกรมส่วนใหญ่จะเป็นไปตามรูปแบบnaที่ n คือรหัสอักขระของอักขระแต่ละตัว ตัวอย่างเช่น:

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

ลองออนไลน์!

ดังนั้นฉันจะแสดงรายการข้อยกเว้น:

0 (ศูนย์)

เนื่องจากตัวสะสมมีการตั้งค่าไว้ที่ศูนย์เราสามารถแสดงสิ่งนี้โดยใช้อักขระเดียว:

o

ลองออนไลน์!

1

คล้ายกับศูนย์สิ่งนี้จะเพิ่มตัวสะสมเพื่อให้ได้ 1

^o

ลองออนไลน์!

5

รหัส ASCII สำหรับ 5 คือ 53 ดังนั้นฉันต้องแก้ไขสิ่งนี้:

6vo

ลองออนไลน์!

a

เนื่องจากaเป็นฟังก์ชั่นการส่งออกของตัวละครไม่มีทางอื่นที่จะผลิตตัวอักษรดังนั้นนี้เท่านั้นฉันไม่ PROGRAM

ดูโปรแกรมทั้งหมดได้ที่นี่

Matlab, 1238 1224 ไบต์, 2 DNP

รูปแบบหลักคือ:

disp([<char code> ''])

สำหรับตัวเลขมันสั้นกว่าเล็กน้อย:

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

สำหรับตัวละคร[]'มันคือ:

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

แสดงอักขระdsจากdispโดยใช้fprintf( ขอบคุณ@Stewie Griffin ); ipอย่างไรก็ตามเป็นของที่นั่นด้วยดังนั้นฉันจึงเปลี่ยนสตริงและใช้eval:

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

()อย่างไรก็ตามตัวละครทั้งสองมีความจำเป็นสำหรับdispหรือevalดังนั้นจึงเป็น DNP

สำหรับการอ้างอิงรายการทั้งหมด:

    char    char code   code                        length
            32          disp([0 ''])                12
    !       33          disp([33 ''])               13
    "       34          disp([34 ''])               13
    #       35          disp([35 ''])               13
    $       36          disp([36 ''])               13
    %       37          disp([37 ''])               13
    &       38          disp([38 ''])               13
    '       39          disp(char(39))              14
    (       40          DNP
    )       41          DNP 
    *       42          disp([42 ''])               13
    +       43          disp([43 ''])               13
    ,       44          disp([44 ''])               13
    -       45          disp([45 ''])               13
    .       46          disp([46 ''])               13
    /       47          disp([47 ''])               13
    0       48          disp(1-1)                   9
    1       49          disp(3-2)                   9
    2       50          disp(5-3)                   9
    3       51          disp(7-4)                   9
    4       52          disp(9-5)                   9
    5       53          disp(2+3)                   9
    6       54          disp(3+3)                   9
    7       55          disp(4+3)                   9
    8       56          disp(5+3)                   9
    9       57          disp(6+3)                   9
    :       58          disp([58 ''])               13
    ;       59          disp([59 ''])               13
    <       60          disp([60 ''])               13
    =       61          disp([61 ''])               13
    >       62          disp([62 ''])               13
    ?       63          disp([63 ''])               13
    @       64          disp([64 ''])               13
    A       65          disp([65 ''])               13
    B       66          disp([66 ''])               13
    C       67          disp([67 ''])               13
    D       68          disp([68 ''])               13
    E       69          disp([69 ''])               13
    F       70          disp([70 ''])               13
    G       71          disp([71 ''])               13
    H       72          disp([72 ''])               13
    I       73          disp([73 ''])               13
    J       74          disp([74 ''])               13
    K       75          disp([75 ''])               13
    L       76          disp([76 ''])               13
    M       77          disp([77 ''])               13
    N       78          disp([78 ''])               13
    O       79          disp([79 ''])               13
    P       80          disp([80 ''])               13
    Q       81          disp([81 ''])               13
    R       82          disp([82 ''])               13
    S       83          disp([83 ''])               13
    T       84          disp([84 ''])               13
    U       85          disp([85 ''])               13
    V       86          disp([86 ''])               13
    W       87          disp([87 ''])               13
    X       88          disp([88 ''])               13
    Y       89          disp([89 ''])               13
    Z       90          disp([90 ''])               13
    [       91          disp(char(91))              14
    \       92          disp([92 ''])               13
    ]       93          disp(char(93))              14
    ^       94          disp([94 ''])               13
    _       95          disp([95 ''])               13
    `       96          disp([96 ''])               13
    a       97          disp([97 ''])               13
    b       98          disp([98 ''])               13
    c       99          disp([99 ''])               13
    d       100         fprintf([100 ''])           17
    e       101         disp([101 ''])              14
    f       102         disp([102 ''])              14
    g       103         disp([103 ''])              14
    h       104         disp([104 ''])              14
    i       105         eval(['ejtq)(j(*'-1 ''])    24
    j       106         disp([106 ''])              14
    k       107         disp([107 ''])              14
    l       108         disp([108 ''])              14
    m       109         disp([109 ''])              14
    n       110         disp([110 ''])              14
    o       111         disp([111 ''])              14
    p       112         eval(['ejtq)(q(*'-1 ''])    24
    q       113         disp([113 ''])              14
    r       114         disp([114 ''])              14
    s       115         fprintf([115,''])           17
    t       116         disp([116 ''])              14
    u       117         disp([117 ''])              14
    v       118         disp([118 ''])              14
    w       119         disp([119 ''])              14
    x       120         disp([120 ''])              14
    y       121         disp([121 ''])              14
    z       122         disp([122 ''])              14
    {       123         disp([123 ''])              14
    |       124         disp([124 ''])              14
    }       125         disp([125 ''])              14
    ~       126         disp([126 ''])              14

เยลลี่ (ไม่ใช่แบบแข่งขัน) 406 ไบต์

32Ọ
33Ọ
34Ọ
35Ọ
36Ọ
37Ọ
38Ọ
39Ọ
40Ọ
41Ọ
42Ọ
43Ọ
44Ọ
45Ọ
46Ọ
47Ọ
48Ọ
49Ọ
50Ọ
51Ọ
52Ọ
49+4Ọ
54Ọ
55Ọ
56Ọ
57Ọ
58Ọ
59Ọ
60Ọ
61Ọ
62Ọ
63Ọ
64Ọ
65Ọ
66Ọ
67Ọ
68Ọ
69Ọ
70Ọ
71Ọ
72Ọ
73Ọ
74Ọ
75Ọ
76Ọ
77Ọ
78Ọ
79Ọ
80Ọ
81Ọ
82Ọ
83Ọ
84Ọ
85Ọ
86Ọ
87Ọ
88Ọ
89Ọ
90Ọ
91Ọ
92Ọ
93Ọ
94Ọ
95Ọ
96Ọ
97Ọ
98Ọ
99Ọ
³Ọ
101Ọ
102Ọ
103Ọ
104Ọ
105Ọ
106Ọ
107Ọ
108Ọ
109Ọ
110Ọ
111Ọ
112Ọ
113Ọ
114Ọ
115Ọ
116Ọ
117Ọ
118Ọ
119Ọ
120Ọ
121Ọ
122Ọ
123Ọ
124Ọ
125Ọ
126Ọ

นี้จะพิมพ์ตัวละครทั้งหมดจาก 32 - 126 นับไบต์จะคำนวณด้วยhttps://mothereff.in/byte-counter https://mothereff.in/byte-counter

ลองออนไลน์!

Befunge-93, 530 bytes

วิธีที่ง่ายที่สุดในการแสดงอักขระโดยไม่ใช้อักขระนั้นคือการคำนวณค่า ASCII และใช้,คำสั่ง (เอาต์พุตอักขระ) เพื่อแสดงผล ตัวอย่างเช่น,49*,@เอาท์พุทอักขระดอลล่าร์ (ASCII 36, 4 * 9) สิ่งนี้ไม่ค่อยดีที่สุดเนื่องจากค่าส่วนใหญ่ใช้เวลามากกว่า 3 ไบต์ในการคำนวณ

อีกวิธีในการสร้างตัวเลขใน 3 ไบต์คือการใช้ประโยชน์จากข้อเท็จจริงที่ว่าgคำสั่ง (รับ) ในเซลล์แรกของ playfield จะสร้างค่า ASCII ของg (สแต็กที่ว่างเปล่าจะถูกเติมด้วยค่าศูนย์ดังนั้นจึงเป็น อ่านค่า playfield ที่ 0,0) ดังนั้นg1+,@คุณจะได้รับhและg1-,@ทำให้คุณฉ . เห็นได้ชัดว่าทำงานได้ในช่วงออฟเซ็ตและการดำเนินการอื่นที่ไม่ใช่+และ-ยังเป็นไปได้ ตัวอย่างเช่นg3/,@คุณจะได้รับใบเสนอราคาคู่

รูปแบบของสิ่งนี้คือการนำหน้าgด้วยคำสั่งอื่นที่ปล่อยให้ศูนย์ทั้งหมดบนสแต็ก ดังนั้นคุณยังคงอ่านค่าจากสนามแข่งขันที่ 0,0 แต่ตอนนี้ตัวละครที่กำลังอ่านแตกต่างกัน ค่าใช้จ่ายนี้เพิ่มอีกหนึ่งไบต์ แต่จะช่วยให้คุณเข้าถึงค่าได้มากขึ้น ตัวอย่างเช่น0g1-,@ทำให้คุณได้รับเครื่องหมายสแลชและ:g1+,@รับเครื่องหมายอัฒภาค คำนำหน้าทำงานอื่น ๆ ได้แก่*, +, -, >, และ\ _และโปรดทราบว่าการดำเนินการอื่น ๆ นั้นเป็นไปได้: >g2*,@ให้คุณได้รับแถบแนวตั้ง

รูปแบบเพิ่มเติมคือนำหน้าgด้วย a 1ดังนั้นตอนนี้คุณจะไม่อ่านจาก 0,0 อีกต่อไป แต่จากเซลล์ว่างที่ 0,1 ใน Befunge เซลล์ว่างจะถูกกำหนดค่าเริ่มต้นด้วยช่องว่างตามค่าเริ่มต้นดังนั้น1g,@คุณจะได้ช่องว่างและ1g1+,@รับเครื่องหมายอัศเจรีย์

สำหรับตัวละครหลักมีเคล็ดลับที่น่าสงสัยมากกว่าที่เราสามารถใช้ได้ แทนที่จะพยายามเอาท์พุทมันเป็นตัวละครเราเอาท์พุทมันเป็นตัวเลข (จำนวนน้อยนั้นง่ายต่อการสร้างมากกว่า ASCII ที่เทียบเท่ากัน) ดังนั้นสำหรับตัวอย่างเช่น11+.@ช่วยให้คุณ2และโดยเฉพาะอย่างยิ่งทราบกรณีพิเศษ: .@สำหรับ0และ!.@สำหรับ1 ส่วนที่น่าสงสัยของเรื่องนี้คือเอาท์พุทตัวเลขใน Befunge รวมถึงช่องว่างหลังตัวเลขดังนั้นมันจึงไม่ใช่ตัวอักษรล้วน

เคล็ดลับที่น่าสงสัยอีกข้อที่เราสามารถใช้ได้คือการเปลี่ยนแปลงของgเทคนิคด้านบน แทนที่จะ จำกัด ตัวเองเป็นคำสั่ง Befunge สำหรับคำนำหน้าเรายังสามารถใช้อักขระใด ๆ ที่ไม่ใช่คำสั่ง Befunge สำหรับล่ามส่วนใหญ่คำสั่งที่ไม่รู้จักจะถูกละเว้นดังนั้นคำสั่งจะgจบลงด้วยการอ่านค่า ASCII ของอักขระก่อนหน้า สิ่งนี้ทำให้เราสามารถสร้างค่า ASCII อื่น ๆ ส่วนใหญ่ที่ไม่สามารถคำนวณได้เป็น 3 ไบต์ เป็นตัวอย่างหนึ่ง: Qg1+,@คุณได้รับR

ในที่สุดมีสามกรณีพิเศษ กรัมไม่สามารถสร้างขึ้นในน้อยกว่า 5 "f"1+,@ไบต์ดังนั้นเราจึงต้องหันไป เครื่องหมายจุลภาคมีความซับซ้อนมากที่สุดซึ่งต้องมีการแก้ไขแบบไดนามิกของสนามเด็กเล่น:0g4-:80p @เครื่องหมายจุลภาคเป็นที่ซับซ้อนมากที่สุดต้องปรับเปลี่ยนแบบไดนามิกของสนามแข่งขัน:เราสามารถใช้เทคนิคที่คล้ายกันเพื่อหลีกเลี่ยงการที่ตัวละคร แต่สับมีประสิทธิภาพมากขึ้นคือการใช้%คำสั่ง (โมดูโล) 88*,%ขณะที่เทอร์มิเช่น เมื่อ%ถึงจะไม่มีอะไรในสแต็คดังนั้นการคำนวณแบบโมดูโล่จะสร้างการหารด้วยศูนย์และในล่ามอ้างอิงสิ่งนี้จะยุติโปรแกรม

ด้านล่างคือรายการทั้งหมดของโปรแกรมหนึ่งรายการต่อบรรทัด

1g,@
1g1+,@
g3/,@
57*,@
49*,@
1g5+,@
1g6+,@
1g7+,@
58*,@
1g9+,@
0g6-,@
0g5-,@
0g4-:80p @
59*,@
0g2-,@
0g1-,@
.@
!.@
11+.@
21+.@
31+.@
41+.@
51+.@
61+.@
71+.@
81+.@
>g4-,@
:g1+,@
:g2+,@
:g3+,@
:g4+,@
79*,@
88*,%
>g3+,@
>g4+,@
>g5+,@
>g6+,@
>g7+,@
>g8+,@
>g9+,@
89*,@
Hg1+,@
Ig1+,@
Jg1+,@
Kg1+,@
Lg1+,@
Mg1+,@
Ng1+,@
Og1+,@
99*,@
Qg1+,@
\g9-,@
\g8-,@
\g7-,@
\g6-,@
\g5-,@
\g4-,@
\g3-,@
\g2-,@
\g1-,@
_g3-,@
\g1+,@
g9-,@
g8-,@
g7-,@
g6-,@
g5-,@
g4-,@
g3-,@
g2-,@
g1-,@
"f"1+,@
g1+,@
g2+,@
g3+,@
g4+,@
g5+,@
g6+,@
g7+,@
g8+,@
g9+,@
tg3-,@
tg2-,@
tg1-,@
:g2*,@
tg1+,@
tg2+,@
tg3+,@
tg4+,@
tg5+,@
tg6+,@
tg7+,@
>g2*,@
tg9+,@
*g3*,@