Seçtiğiniz bir programlama dilinde , her biri programın herhangi bir yerinde bu karakter olmadan yazdırılabilir 95 ASCII karakterinden farklı bir çıktı veren 95 program yazın .

Dil Söz gelimi, Python , programınızı karakter çıktı versin Polabilir

print(chr(80))

çünkü PASCII kod 80'e sahiptir. Bu program geçerlidir çünkü Phiçbir zaman kaynak kodda görünmez. Ancak, küçük harf verir program için polduğu gibi, bir şey

print(chr(112))

o baskı yapar iken, çünkü geçersiz olacağını p, pkod mevcuttur. Geçerli bir program olabilir

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

Hangi yazdırır pama içermez p.

Amacınız, 95 programınızın her birini mümkün olduğunca kısa yapmaktır. Sizin puanı tüm programların karakter uzunlukları toplamıdır.

Herhangi bir sebepten dolayı bazı karakterler için geçerli programlar yazamıyorsanız, bu karakterleri "Program Yok" veya DNP olarak işaretleyebilir ve tamamen kendileri için programları çıkarabilirsiniz . Bu şekilde sözdizimsel olarak katı diller rekabet edebilecek.

Kazanan cevabı en düşük puanı vardır cevaptır arasında en az DNP en sahip cevaplar seti.

kurallar

• Tüm programlarınızın kaynak kodu yalnızca yazdırılabilir ASCII plus sekmeleri ve yeni satırları içerebilir , bunların tümü bir karakter olarak sayılır. (Çünkü farklı bir kodlamada var olmayan karakterleri atlamak kolay olurdu!)

  • Not: Bu kural gerekli görünüyor, ancak farklı kodlamaları olan birçok dil var ve cevaplarını görmenin iyi olacağını düşünüyorum. Bu nedenle , bu kuralı kırabilirsin , istediğin karakterleri kullanabilirsin, ama sonra cevabın rekabetçi olmaz, kazanamaz.

• Programlar , dilinizin standart kurallarına göre gerçek, tam programlar olmalıdır . İşlevlere ve REPL snippet'lerine izin verilmez.

• Her programın çıktısı stdout'a veya dilinizin kabul edilen alternatifine gitmelidir.

• Programlar, bilgi istememeli veya giriş yapılmamalıdır. (Giriş istemek dilinize özgü ise, sorun değil.)

• Programlar belirleyici, çalışma süresinde sonlu ve bağımsız olmalıdır. Örneğin, birinin diğer programlardan ayrı bir klasörde çalışması önemli değildir.

• Bir programın çıktısı, isteğe bağlı olarak takip eden tek satırlık bir yeni satırla karşılık gelen, yazdırılabilir ASCII karakteri olmalıdır;

Cevabınıza 95 (ideal) programın tamamı, puanınız ve DNP'ler hakkında bilgiler eklediğinizden emin olun. Sen listelemek gerekmez tüm "gibi basit bir kalıpta programları print(chr(80)), print(chr(81)), print(chr(82))..." ama sen hepsinin emin emin olur çalışacak ve puanınız doğru eklenir söyledi.

Başvuru için, programlarınızın çıkması gereken 95 yazdırılabilir ASCII :

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

Python 2, 1075 1065 1043 1040 1039 bayt

Her program aşağıdakiler print'\<octal char code>'dışında bir forma sahiptir :

• ' → print"\47"
• 0aracılığıyla 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"'

Referans ve test kolaylığı için, işte yeni satırlı programların tam listesi.

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'

Test etmek için:

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

@ Sp3000 sayesinde -1 bayt!

CJam, 269 bayt

Programların her biri aşağıdakiler '<char - 1>)haricinde formdadır :

• Boşluk => S, 1 bayt
• '=> 39c, 3 bayt
• )=> '*(, 3 bayt
• 0=> T, 1 bayt
• 1=> X, 1 bayt
• 2=> Y, 1 bayt
• 3=> Z, 1 bayt
• 4- 9=> <num-1>), 2 bayt

Puan: 3 * 82 + 1 + 3 + 3 + 4 * 1 + 6 * 2 = 269

ASCII kısıtlı x86 DOS için makine kodu 3104 3101 2913 bayt

Şey ... Java'dan daha kısa sanırım ...

32 Hemen hemen tüm karakterler için 30 bayt, istisnalar için aşağıya bakın.

Çoğu zaman sadece deseni izler:

1. xorSonuna kadar bir işaretçi almak için biraz yapın.
2. subSon 2 kelimeden: opcode için intASCII değil.
3. 2 içine AHve karakter içine alın DL. Her ikisi de bir xorkarakterdir çünkü karakter programda görünemez ve 2 yazdırılabilir bir ASCII karakteri değildir.
4. İle karakteri yazdır int 21h
5. İle çık int 20h

Bir karaktere izin verilmezse, çoğu zaman verileri biraz değiştirerek veya farklı bir kayıt cihazına geçerek değiştirilebilir.

Kendinizi aniden çıkaramayacağınız veya hesaplamalar için kullanılabilen tek kaydı açamayacağınızı fark ettiğinizde biraz daha ilginçleşir ...

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 bayt

Sp3000 tarafından kaydedilen 17 bayt Dennis tarafından kaydedilen 60 bayt

DNP: 46 ( .)

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

43, 45, 60, 62, 91 ve 93 dışındaki herkes Esolangs.org'dan utanmadan çalınır

MATL, 305, 302, 300 297 bayt

Her bir program şöyle görünür:

33c
34c
35c
....

Dışında

• Rakamlar. İşte 0-9 için programlar:

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

• 'C'. Bu program

  'C'k
  

• alan, boş yer, mekan. Bu

  0c
  

  Bugünden beri, MATL'in 0 karakterini boşluk olarak değerlendirdiğini öğrendim. @ LouisMendo teşekkürler!

Bunlardan herhangi birini doğrulamak için matl.tio kullanabilirsiniz .

Başvuru için, hepsi burada:

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 bayt

iç çekmek

Bu temelde Python 2 cevabımın bir limanı , fakat Java'da tam bir program yazmanın getirdiği tüm kazanlarla birlikte.

Şimdi hiç DNP olmadan! Teşekkürler, Kevin Cruijssen!

Programların çoğu aşağıdakiler interface A{static void main(String[]a){System.out.print("\<octal char code>");}}dışında bir forma sahiptir :

• boşluk → interface\tA{static\tvoid\tmain(String[]a){System.out.print("\40");}}(ancak \tham sekmelerle değiştirilen s ile )
• " → 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

vay be

Java derleyicisi \u007B, başka bir işlem yapmadan önceki Unicode çıkışlarını tanımlar; bu, tanımlayıcılarda ve hatta anahtar kelimelerde unicode çıkışları kullanan kod yazmayı mümkün kılar. Bu yüzden, kazan plakasında mevcut olan bir karakteri kullanmayan bir program yazmak için onu basitçe unicode kaçışla değiştiririz.

Referans ve test kolaylığı için, yeni satırla ayrılmış ve dört sekmeyle değiştirilen sekmelerle birlikte programların tam listesi:

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

Programı unutmayın ukullanır System.console()(a atmak için kodu ve böylece neden boş dönecektir, NullPointerExceptionsen yerli terminali 'OS dışında herhangi onu ararsanız () cmdWindows üzerinde ve ben, varsayalım bashLinux / OSX'te) .

Test etmek için yeni bir dizin oluşturun ve yukarıdaki kodu printableso dizinde adı verilen bir dosyaya yerleştirin . Ardından, aşağıdaki Bash komut dosyasını çalıştırın:

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

Yukarıdaki komut her satırı koyacağız printableshepsini isim, kendi dizine A.java(yazdırır dosyası hariç Ayeniden adlandırılır, B.javaardından delilleri silmek onları çalıştırmak, her dosyayı derlemek,). Yazdırılabilir ASCII karakterlerinin kabuğunuzda görünmeye başlaması yaklaşık on saniye sürecektir.

Windows kullanıyorsanız, bunun yerine aşağıdaki Toplu dosyayı çalıştırın:

@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

Bu toplu iş dosyası biraz farklı bir yaklaşım getiriyor; satırları önceden bölmek yerine, dosyayı satır satır işler ve sırayla her programı derler ve çalıştırır. Yine, bittikten sonra kanıtı siler.

Kevin Cruijssen sayesinde sayısız byte + 1 DNP kaydedildi!

> <> , 443 437 bayt

TIO tercüman bağlantısı . Burada birçok desen var:

• [num][num]*o;: İki sayının çarpımı, ardından sonucu bir char olarak basar ove durur ;. > <> rakamlar 15’e kadar çıkar, yani 0123456789abcdef.
  • Benzer şekilde [num][num]-n;, iki sayının farkını alır ve nbunun yerine sayılar olarak çıktılar .

• '-o[invalid char]: > <> toroidal, bu nedenle komut gösterici bir satırın sonuna ulaştığında başa döner. Bu durumda, kodun iki kez yürütülmesine neden olur, yani '-o[char]'-o[char]. Birinci '-o[char]'bölüm, yığının üç karakter iter -hesaplar 'o' - [char]sonra obir karakter olarak oluşturur. > <> sonra [char], tanınmayan bir komut nedeniyle veya boş bir yığın açması nedeniyle ulaştığında hata verir .

  • Benzer şekilde '-n[invalid char], sayı olarak çıktı verir.
  • Benzer şekilde '[num][op]o[invalid char], uygulandığı [op]ile [num]tarihinde adlı [char]char dışarı erroring. Örneğin , ikiden fazla olan '2+oJçıktılar .LJ
  • ''s kodu yerine "-oHkullanıyor ".
  • -'s kodu yerine '%oBkullanıyor %.

• ln;: İstif uzunluğunu itin, sayı olarak çıkın, sonra durdurun, verin 0. Benzer lln;için 1ve 'ln;için 3.

• 4|n+: 4 |düğmesine basın , zıplayın ve başka bir 4 düğmesine basın, ekleyin, ardından 8sayı olarak çıkın. |Tekrar atla ve tekrar nboş bir yığında çalıştırmaya çalışırken hata .
  • Benzer 3|n*için 9.
  • Benzer [num]|o*için @Qdy.
• '1-:00p: En ilginç olanı, odurum için. Kodumuzu okullanmaktan kaçınmak için , kod kutusuna pbir yerleştirmek için kullanmamız o, sonra çalıştırmamız gerekir. İlk '1-:00p', yığını üstte olacak şekilde ayarlar pve 1-onu bir azalır o. :Bu kopyalar ove 00pbir tane yerleştirir ode (0, 0), içine Codebox dönüm o1-:00p. Talimat göstericisi, diğerini çıkartarak tekrar kaydırılır o. (0, 0) karakteri daha sonra programın sonunda hata vermeden önce birkaç kez daha değiştirilir.

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

(rakip değil, çünkü APL yalnızca ASCII kullanılarak yazılamaz)

Çoğu, formatta nn⊃⎕AVya nnn⊃⎕AVda istisnalar:

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

İşte tüm liste:

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

63 karakterden için @aracılığıyla ~, biz 10 bayt çözümü vardır:

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

En (21) karakterler için spacearacılığıyla ?, bir 9 bayt çözümü vardır:

puts"\xx"     (2 digit octal code)

Geriye kalan on özel durum var:

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

Toplamda puan 10 × 63 + 9 × 21 + 10 + 3 + 8 × 4 + 5 = 869'dur.

WolframAlpha , 368 bayt

Genel format:

u+<character code in hexadecimal>

İstisnalar:

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

İşte tam listesi:

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

Düzenleme: jimmy23013 sayesinde 203 bayt kurtardı ve 2 DNP'yi Mego sayesinde uyguladı

Bu cevap, PHP'nin cömert doğasını ağır şekilde kötüye kullanıyor. Vakaların çoğu bu formlardan birini alır (her biri 7 bayt):

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

PHP daha sonra ASCII karakter değerine her dize dönüştürerek uygun bitsel işlemini gerçekleştirir ve son olarak sonuç dönüştürür, dizelerine operatörünün her iki tarafında harfleri dönüştürür geri bir karaktere.

Yukarıdaki ilk örnekte, Y^xolur 89^78. Bunun sonucu 33, karakter olarak STDOUT'a gönderilir !.

Tüm olası kombinasyonları kaldırmak için bir senaryo yazılmıştır: sonuçlar burada bulunabilir .

İstisnalar:

;olduğu <?=Z^a?>(8 bayt)
|olan <?='9'^E;(9 bayt)

<ve ?normalde gerekli başlangıç ​​etiketi nedeniyle DNP olur, ancak -rbayrak kullanarak kod onlar olmadan çalıştırılabilir:

<olduğu echo Z^f;(9 bayt)
?olan echo Z^e;(9 bayt)
=olan echo Z^g;(9 bayt)

Puan:

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

Brachylog , 546 477 bayt

Kodu için Fatalize Kredileri @.

Aşağıdaki listede, ilk karakter yazdırılacak karakterdir (kolay başvuru için).

  @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
CP: 35m
DP: 36m
EP: 37m
F @ P: 38m
G @ P: 39m
H @ P: 40m
I @ P: 41m
JP: 42m
K @ P: 43m
LP: 44m
M @ P: 45m
N @ P: 46m
OP: 47m
P @ A: 15m @ u
Q @ P: 49 m
RP: 50m
S @ P: 51m
TP: 52m
U @ Vt @ u
V @ P: 54m
W @ Qt @ u
XP: 56m
Y @ Wt @ u
Z @ At @ u
[@P: 59m
\ @ P: 60 m
] @P: 61m
^ @P: 62m
_ @ P: 63m
`@ P: 64m
@Vh
b @Ch
c @Dbh
d @ A: 3m
e @Vbh
f @ A: 5 m
g @ A: 6m
h @ A: 7m
i @A: 8m
j @ A: 9m
k @ C: 7m
lC: 8m
m @ D @ 2ht
n @ A: 13m
oH: 4m
p @ A: 15m
q @ Z: 9m
r @ Z: 8m
s @ Z: 7 m
t @ Z: 6 m
u @Vt
v @ Z: 4m
w @Qt
x @ Z: 2m
y @Wt
z @At
{@P: 91m
| @P: 92m
} @Prbh
~ @Pt

Hepsi tahmindir, bu yüzden Zçıktıyı almak için argüman olması gerekir: Çevrimiçi deneyin!

açıklama

@P bu dize:

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

her yazdırılabilir ASCII'yi içerir.

> <> , 531 bayt

Programlar iki ana formda:

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

İlki, her ikisi de 16'dan az iki faktöre sahip karakter kodları olan karakterler içindir, diğeri ise diğer durumlar içindir. İkinci formu kullandığım çoğu sayının eşit uzunluktaki birçok çözümü var, ancak bunu okunabilirlik için seçtim.

İstisnalar:

" 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

Tam liste:

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

FryAmTheEggman'a 3 bayt kaydettiği için teşekkür ederiz.

Hemen hemen tüm programlar aynı biçimdedir:

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

Ancak birkaç istisna vardır:

• Bu yazdırmak için imkansız ;kullanmadan ;, dolayısıyla 1 DNP.
• Yazdırmak için programı sonlandırmak için @kullanamıyoruz @. Bunun yerine ya S2;:da kullanıyoruz S3;%. Bu, sıfıra bölünme hatasıyla sona eriyor, ancak bu hata STDOUT'da görünmüyor. Yani bu hala dört bayttır.
• Bunun için Ugereken bir çatışma var U3;@. Bunu düzeltmek için, küçük harfe geçmek, yani n9;@artırma veya azaltma, yani T);@veya kullanma gibi birçok yol vardır V(;@. Her durumda hala dört bayt.
• Hafıza kenarları için ilklendirilmiş 0ve !bir tamsayı değeri yazdırır, bu nedenle alabilirsiniz 0ve 1ile !@ve )!@3 bayt tasarrufu sırasıyla.

<letter><digit>;@Programların nasıl çalıştığına gelince : formdaki bir programın altıgen düzeni 1234her zaman

 1 2
3 4 .
 . .

Programların hiçbiri kontrol akışını yönlendiren herhangi bir komut içermediğinden, bunlar sadece sırayla çalıştırılan doğrusal programlardır.

Her durumda, kodun başındaki harf, geçerli bellek kenarını karakter koduna ayarlar. Örneğin programda P1;@, Pdeğeri ayarlar 80. Ardından, rakam bu değeri 10'la çarpar ve kendisini ekler (yani basamak, geçerli değere eklenir). Bu 801yukarıdaki örnekte verir . Son olarak, ;bu değeri modulo 256'yı alarak ve bir bayt değeri olarak kullanarak yazdırır. Bu durumda 801 % 256 = 33ve a !basılır.

Boşluk , 1643 bayt, 1 DNP

[33-63] karakterleri için 17 bayt ve [64-126] karakterleri için 18 bayt

Whitespace'de bu basittir, çünkü yazdırılabilir karakterlerin (boşluk hariç) hiçbir anlamı yoktur:

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

Yukarıdaki program '!' Yazıyor (100001b). [TAB][SPACE][SPACE][SPACE][SPACE][TAB]İlk satırda istediğiniz karaktere göre değiştirin . Boşluk kullanmadan boşluk yazdırmak mümkün değildir, çünkü her zaman bir şey yazdırmakla başlar[TAB][LF][SPACE]

Retina , 712 bayt, 2 DNP

Bu FryAmTheEggman ile ortak bir çabaydı.

Birkaç çözüm sınıfı vardır. Uzaydan karakterlerin çoğunda ^, aşağıdaki biçimde bir program kullanıyoruz:

_
T`w`p

İkinci satırdaki karakter, aralık _0-9A-Za-zdeğişmeden kalırken aralık boyunca yinelenir . Bu boş girişi bu karaktere dönüştürür ve ardından pkarşılık gelen pozisyonda yazdırılabilir ASCII karakteri ile (temsil edilen ) değiştirir. Bu programların her biri 8 bayttır.

Bu aralıkta, sadece birkaç istisna vardır. En önemlisi, rakamlar kısaltılabilir:

• 0: x( xboş girişteki s sayısını sayar )
• 1:  (weehoo, boş program; boş girişteki boş eşleşme sayısını sayar)

• 2: şimdi boş dizeleri saymadan önce girişi tek bir karaktere dönüştürüyoruz:

  
  1
  
  

• 3: aynı şey ancak girişi iki karaktere dönüştürüyoruz:

  
  11
  
  

• 4: fikri anladınız ...

  
  111
  
  

• 5 - 9: plot twist… ikinci satırın daha fazla kalmasını önlemek için karakter tekrarını kullanıyoruz:

  
  4$*
  
  

  ...

  
  8$*
  
  

Diğer bir istisna ise TDNP'dir: Harf çevirisi aşamaları kullanılamıyorsa kaynak kodda görünmeden rakamsız bir karakter oluşturmanın mümkün olmadığını düşünüyoruz.

Kalan karakterlere açık. Yazdırmak için _yukarıdaki genel çözüme benzer bir program kullanıyoruz:

0
T`0`w

İle wbaşlayan gerçeği kullanarak _.

Sonraki, `ikinci DNP'dir, çünkü harf çevirisi aşamaları da bunları gerektirir.

Daha sonra küçük harflerin çoğu, böyle bir şeyle basılır (bu da basılır a):

_
T`w`l

Yine, ikinci satırdaki karakter artmaktadır _0-9A-O. Burada, biz sadece dikkat gerekir lve wbiz sırasıyla aşağıdaki programları ile yazdırabilir, hangi:

P
T`p`w

6
T`p`l

Sonunda, sadece {|}~9 bayt gerektiren yalnızca kalanlar bulunur. Burada, harf çevirme aşamasını onlardan önce gelen karakteri arttırmak için kullanırız. Örn ~: ile basılabilir:

}
T`_p`p

Pyke, 364 362 355 bayt

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

Formdakilerin tümü w<chr(charcode+32)>.C(4 bayt) hariç:

• -> d1 bayt
• 0-> Z1 bayt
• 1-> ~W2 bayt
• a-> Gh2 bayt
• z-> Ge2 bayt
• aFormdaki ilk 10 küçük harfli alfabe harfleri (hariç ) G<number>@(3 bayt)
• k-> GT@3 bayt
• >-> ~Bh3 bayt
• ]-> ~Be3 bayt
• Z-> ~le3 bayt
• 9-> ~ue3 bayt
• w-> G22@4 bayt
• .-> ~B4@4 bayt
• C-> ~K38@5 bayt

Çevrimiçi Pyke tercüman

JavaScript (ES6), 1083 1068 bayt

Genel form:

alert`\xhex`

İstisnalar:

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`

Düzenleme: @ GOTO0 sayesinde 15 bayt kaydedildi.

05AB1E , 417 bayt

!   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

açıklama

Çoğu formun 5 bayt uzunluğunda şunlardır: convert nr to base nr+1.
>Bunun için bir artış kullanamadığımızdan fazladan bir bayta ihtiyaç duyuyor.

a,b,x,y,z,Y,ZAküçük harfle alfabeyi içeren ayıklanır .

A,B,C,D,E,F onaltılık dönüştürülmüş sayılardır.

0-9 önceden tanımlanmış değişkenlerin yanı sıra basit artış / azalışlardır.

Mermer, 220 bayt

Rakam olmayan bir karakter için, karakter kodunun yalnızca iki büyük harf altıgen hanesidir. Örneğin, aşağıdaki program çıktıları A:

41

Olmayan bir rakam için 3, yerine 2Fkarakter kodunun büyük heks basamağı aşağıdaki kodu: 1 -

2F
++

İçin 3:

66
>>

Toplam puan: 2 * 85 + 5 * 10 = 220.

Tercüman.

İlk denemem Bubblegum'du ve daha önce karakterler için işe yaramadı ?...

Perl 6: 921 bayt

Python çözümünün çevirisi.

Her program aşağıdakiler say "\x<hex escape code>"dışında bir forma sahiptir :

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

Referans ve test kolaylığı için, işte yeni satırlı programların tam listesi.

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

İşte yukarıdaki listeyi test etmek için kullandığım kod ve puanı:

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

Programların çoğu , basılacak karakterin ascii kodu main=putChar '\xx'veya main=putChar '\xxx'nerede xx/ xxxolduğu şeklindedir. Bu 14 karakter hariç herkes için işe yarar:

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

Ancak, haneler için 1 7 4 bayt kaydedilebilir (Christian Sievers sayesinde!):

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

cKod 99'a kadar olan 52 program 18 bayt, geri kalan 19 her 19 bayt alıyor.

Kısmi puan: 10*14 + 52*18 + 19*19 = 1437

Kalan karakterlerin 7'sinde aşağıdaki programlar çalışır:

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

Kısmi puan: 18 + 22 + 18 + 21 + 19 + 27 + 27 = 152

Bu 7 DNP bırakır: =aimnrt

Her Haskell programının bir main ( main=) tanımlaması gerekir , bu yüzden 5 DNP var. Stdout'a yazdırmak için putChar, putStrya da interactverimli kullanılabilir tve rgibi başka DNPs. (Ayrıca print, print 'a'basar 'a've yazmaz a- ve ayrıca içerir tve ryine de vardır.) Haskell, aynı zamanda chrbir numara verilen karşılık gelen karakteri döndüren bir işleve sahiptir, ancak kullanmak için import Data.Chargereklidir.

Toplam puan:, 1437 + 152 = 1589 7 DNP

BBC Basic, 422 413 bayt

Tercümanı ücretsiz olarak http://www.bbcbasic.co.uk/bbcwin/bbcwin.html adresinden indirin.

Leaky Nun sayesinde 9 byte kurtarıldı.

Genel form

V.<character code>

12 özel durum hariç 32.99 : 56x4 = 224 bayt

100,.126 : 27x5 = 135 bayt

12 özel durum: 54 bayt

Rakamların çoğu genel formu izler, ancak sorunun nerede olduğunu göstermek için hepsini buraya dahil ettim.

İlk karakter, yazdırılacak karakterdir.

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

Çoğu karakter "<char-1>"1+O.için geçerli bir program olabilir, belki de en kısa programlardan biri. Bununla birlikte, karakterlerin yığında kod noktaları olarak saklanmasından dolayı, bunların çoğunun beş bayt veya daha az bir sürede çarpma ve ekleme yoluyla üretilebileceği anlamına gelir. Ayrıca, not olduğunu l, $1, $2, $3, $4, $5, $6, $lvardır 10, 11, 12, 13, 14, 15, 16, 100sırasıyla.

Biçim: <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.

Özel sözler:

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

(. Deneyin) Minkolang kod kutusunda karakterleri değiştirme olanağı vardır, ne yani bu program yapar o yerini olmasıdır -ile sonunda .programı durdurmak için gereklidir. "N"1+d90pN.için Oaynı şekilde çalışır.

4: lZIO.

(Deneyin.) lZ Büyük ve küçük harfleri yığına Iiter ve yığının uzunluğunu, 52 olan tam olarak "4" kod noktasını iter. En iyi kısmı, başlangıçta 4$3*O.4 ve 13 ile 52'yi almak için çarpan çözümünü düşünüyordum , ancak 4 olması nedeniyle yapamadım, bu yüzden yine de bir golfçü çözümü buldum!

y: $1d*O.

(Deneyin.) d Yığının tepesini çoğaltır, bu nedenle bu kod parçasının yaptığı, ittiği 11, kopyaladığı ve sonra çoğaldığıdır. Bunu yazmanın alternatif bir yolu $12;O.da aynı bayt sayısına sahip olacaktı.

}: 53;O.

(Deneyin.) ; Üstel, bu 125'i almak için 5 ^ 3 yapıyor.

Groovy, 1019 bayt

Farklı bir Groovy çözümü yazdım (aşağıya bakınız), ancak gönderdikten sonra, biraz daha fazla karakter kaçmasına neden oldum, programı daha fazla kısaltmanın bir yolunu bulmayı umdum ve Groovy'nin benim için sekizli bir karakter kaçışının olduğunu keşfettim. bilmiyordum. Bu, kodun önemli ölçüde basitleştirilmesini sağlar, ne yazık ki, karşılaştığım tuhaf geçici çözümlerin tamamına olan ihtiyacını ortadan kaldırır.

Ayrıca Copper'in Python 2 çözümüyle neredeyse aynı görünüyor , aslında çalışmalarını inkar ettim gibi görünüyor. Ugh.

Her program aşağıdakiler print'\<octal value>'dışında bir forma sahiptir :

• p, r, i, n, t→ 'print''\<octal value>'(ama "baskı" nin eşleştirme harfiyle da sekizlik değeri ile değiştirilir)
• 0- 9→print~-<next int>

İşte programların karakter listesiyle listesi.

    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 bayt

Önceki programım, sekizli kaçışların olduğunu keşfetmeden önce. Çok daha ilginç, IMO.

Her program aşağıdakiler print(--'<next char>')dışında bir forma sahiptir :

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

Her karakter için programların tam listesi:

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

Aslında , 383 382 381 bayt

Mego sayesinde 1 bayt.

Kolay başvuru için, ilk sütun karakter kodudur, ikinci sütun karakterdir ve üçüncü sütun koddur.

İçin kod 0tek bir alandır.

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

Çevrimiçi deneyin!

Golf önerileri açıktır.

Fourier, 306 bayt, 1 DNP

Neredeyse tüm programlar nan'nin karakterlerin her birinin karakter kodu olduğu kalıbı izler . Örneğin:

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

Çevrimiçi deneyin!

Bu yüzden istisnaları listeleyeceğim:

0 (Sıfır)

Akü sıfıra ayarlı olduğundan, bunu tek bir karakter kullanarak gösterebiliriz:

o

Çevrimiçi deneyin!

1

Sıfıra benzer şekilde, bu akümülatörü 1 elde etmek için arttırır.

^o

Çevrimiçi deneyin!

5

5 ASCII kodu 53'tür, bu yüzden bunun üzerinde çalışmak zorunda kaldım:

6vo

Çevrimiçi deneyin!

bir

Nedeniyle akarakter çıkış fonksiyonu olan orada karakter a üretmek için başka bir yol, bu nedenle bu sadece Gözat PROGRAMI YAPMADIĞIMIZ .

Buradaki tüm programları görün.

Matlab, 1238 1224 bayt, 2 DNP

Ana model:

disp([<char code> ''])

Rakamlar için biraz daha kısa:

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

Karakterler []'için:

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

Karakterler dsgelen dispkullanılarak gösterildi fprintf( sayesinde @Stewie Griffin ); ipancak oraya da aittir, bu yüzden dizeyi değiştirip kullanıyorum eval:

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

()Ancak her iki karakter de dispveya için gereklidir eval, bu yüzden DNP'dir.

Tüm listeye referans için:

    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

Jöle (rekabetçi olmayan), 406 bayt

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Ọ

Bu, 32 - 126 arasındaki tüm karakterleri yazdırır. Bayt sayısı, https://mothereff.in/byte-counter ile hesaplanır .

Çevrimiçi deneyin!

Befunge-93, 530 bayt

Bir karakteri gerçekten o karakter kullanmadan çıkarmanın en kolay yolu ASCII değerini hesaplamak ve ,(karakter çıkışı) komutunu kullanmaktır. Örneğin 49*,@, dolar karakterini (ASCII 36, 4 * 9) çıkarır. Bu, nadiren en optimalidir, çünkü çoğu değerin hesaplanması 3 bayttan fazla sürmektedir.

3 baytlık bir sayı üretmenin bir başka yolu g, oyun alanının ilk hücresindeki (get) komutunun g ASCII değerini üreteceği gerçeğinden yararlanmaktır (boş bir yığının sıfırlarla doldurulduğu varsayılmaktadır, bu nedenle oyun alanı değerini 0,0 olarak okuma). Böylece g1+,@seni s , f'yig1-,@ alır . Bu açıkça bir dizi ofset için işe yarar ve ayrıca ve dışındaki işlemler de mümkündür. Yani+-g3/,@ , size çifte fiyat teklifi veriyor.

Bunun bir varyasyonu g, yığındaki tüm sıfırları bırakan başka bir komutla gelmektir. Demek hala oyun alanındaki değeri 0,0 olarak okuyorsun, ama okunan karakter şimdi farklı. Bu bir bayt daha maliyeti, ancak daha birçok değere erişmenizi sağlar. Örneğin, 0g1-,@size bir eğik çizgi ve :g1+,@bir noktalı virgül alır. Diğer canlı önek içerir *, +, -, >, \ve _. Ve yine başka işlemlerin mümkün olduğunu unutmayın: >g2*,@size dikey bir çubuk alın.

Bir başka varyasyon önce etmektir gbir ile 1, böylece artık artık 0,0 okuma, ama 0,1 de boş hücreden ediyoruz. Befunge'de boş hücreler varsayılan olarak boşluklarla başlatılır, bu nedenle 1g,@size bir boşluk verir ve 1g1+,@bir ünlem işareti alır.

Rakam karakterleri için kullanabileceğimiz daha şüpheli bir numara var. Onları karakter olarak çıkarmaya çalışmak yerine, onları sayı olarak çıkarırız (küçük bir sayı oluşturmak ASCII eşdeğerinden daha kolaydır). Yani, örneğin, 11+.@verir 2'ye ve özellikle özel durumları not: .@için 0 ve !.@için 1 . Bunun şüpheli kısmı, Befunge'deki sayısal bir çıkışın, sayıdan sonra bir boşluk içermesidir, bu yüzden saf bir karakter çıktısı değildir.

Kullanabileceğimiz bir başka şüpheli numara, gyukarıdaki tekniğin bir varyasyonudur . Önek için kendimizi Befunge komutlarıyla sınırlamak yerine, teknik olarak Befunge komutu olmayan herhangi bir karakteri de kullanabiliriz. Tercümanların çoğunda tanınmayan bir komut göz ardı edilir, bu yüzden gönceki karakterin ASCII değerini okur. Bu, 3 byte olarak hesaplanamayan diğer ASCII değerlerini üretmemizi sağlar. Bir örnek olarak: RQg1+,@ alır .

Son olarak, üç özel durum vardır. Bir g 5 bayttan daha az üretilemediğinden, başvurmamız gerekiyor "f"1+,@. Virgülle Playfield en karmaşık gerektiren dinamik bir değişiklik olup: 0g4-:80p @. Karakterden kaçınmak için benzer bir teknik kullanabiliriz, ancak daha verimli bir kesmek %(modulo) komutunu terminatör olarak kullanmaktır 88*,%. Ne zaman% isimli varabilmesi yığında bir şey değildir, yani modülo hesaplama sıfıra bölmeye oluşturur, ve referans yorumlayıcı bu program sona erer.

Aşağıda, her satırda bir tane olmak üzere programların tam listesi bulunmaktadır.

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