A의 프로그래밍 언어 선택의의 다른 하나의 출력 각각 95 개 프로그램, 쓰기 (95 개) 인쇄 가능한 ASCII 문자를 프로그램 어디에서나 발생하는 해당 문자없이를 .

예를 들어, 언어가 Python 인 경우 문자를 출력하는 프로그램 P은 다음과 같습니다.

print(chr(80))

때문에 PASCII 코드 80을 가지고 있기 때문에이 프로그램은 유효 P결코 소스 코드에 표시되지 않습니다. 그러나, 소문자를 출력하는 프로그램 p처럼 뭔가를

print(chr(112))

이 인쇄를 수행하는 동안, 때문에 잘못된 것 p, p코드에 존재한다. 유효한 프로그램은

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

인쇄 p하지만 포함하지 않습니다 p.

목표는 95 개의 프로그램을 가능한 한 짧게 만드는 것입니다. 당신의 점수 는 모든 프로그램의 문자 길이의 합입니다.

어떤 이유로 든 일부 문자에 대해 유효한 프로그램을 작성할 수없는 경우 해당 문자를 "프로그램이 아님"또는 DNP 로 표시하고 해당 프로그램을 완전히 생략 할 수 있습니다. 이런 식으로 구문 적으로 엄격한 언어가 경쟁 할 수 있습니다.

당첨 답변은 DNP가 가장 적은 답변 중에서 가장 낮은 점수 를 얻은 답변입니다.

규칙

• 모든 프로그램의 소스 코드에는 인쇄 가능한 ASCII 플러스 탭과 줄 바꿈 만 포함될 수 있으며 모두 한 문자로 계산됩니다. (다른 인코딩으로 인해 존재하지 않는 문자를 생략하기 쉽습니다!)

  • 참고 : 이 규칙은 필요한 것 같지만 인코딩이 다른 많은 언어가 있으며 그에 대한 답변을 보는 것이 좋을 것입니다. 따라서이 규칙을 어길 수 있으며 원하는 문자를 사용할 수 있지만 대답은 비경쟁 적이되어 승리 할 수 ​​없습니다.

• 프로그램은 실제 전체 있어야합니다 프로그램 언어의 표준 규칙에 따라. 기능 및 REPL 스 니펫은 허용되지 않습니다.

• 각 프로그램의 출력은 stdout 또는 해당 언어의 허용되는 대안으로 이동해야합니다.

• 프로그램은 입력을 요구하거나 요구해서는 안됩니다. (입력하라는 메시지가 해당 언어에 고유 한 경우 괜찮습니다.)

• 프로그램은 결정적이며 런타임에 제한적이며 독립적이어야합니다. 예를 들어 다른 프로그램과 별도의 폴더에서 실행되는지는 중요하지 않습니다.

• 프로그램의 출력은 해당하는 정확한 인쇄 가능한 ASCII 문자 여야하며, 선택적으로 그 뒤에 하나의 후행 줄 바꿈이 있어야합니다.

점수 및 DNP뿐만 아니라 모든 95 (이상적으로) 프로그램에 대한 정보를 답에 포함 시키십시오. 당신은 나열하지 않아도 모두 "와 같은 간단한 패턴에 따라 프로그램을 print(chr(80)), print(chr(81)), print(chr(82))..."하지만 당신은 그들 모두가 확신하고 있는지 확인 할 일을하고 점수가 올바르게 추가됩니다.

참고로, 프로그램에서 출력해야하는 95 개의 인쇄 가능한 ASCII 는 다음과 같습니다.

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

Python 2, 1075 1065 1043 1040 1039 바이트

각 프로그램의 형식은 다음 print'\<octal char code>'과 같습니다.

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

참조 및 테스트 용이성을 위해 다음은 줄 바꿈으로 구분 된 전체 프로그램 목록입니다.

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

테스트하려면 :

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

@ Sp3000 덕분에 -1 바이트!

CJam, 269 바이트

각 프로그램은 다음을 '<char - 1>)제외한 형식으로 되어 있습니다.

• 스페이스 => S, 1 바이트
• '=> 39c, 3 바이트
• )=> '*(, 3 바이트
• 0=> T, 1 바이트
• 1=> X, 1 바이트
• 2=> Y, 1 바이트
• 3=> Z, 1 바이트
• 4- 9=> <num-1>), 2 바이트

점수는 : 3 * 82 + 1 + 3 + 3 + 4 * 1 + 6 * 2 = 269

DOS 용 ASCII 제한 x86 기계 코드, 3104 3101 2913 바이트

글쎄 ... 자바보다 짧다.

32 거의 모든 문자에 대해 30 바이트 (예외는 아래 참조)

대부분의 경우 패턴을 따릅니다.

1. xor끝에 대한 포인터를 얻기 위해 일부 를 수행하십시오.
2. sub에 대한 opcode int가 ASCII가 아니기 때문에 마지막 두 단어 에서
3. 에 2를 넣고 AH문자를에 넣습니다 DL. xor문자 자체는 프로그램에 나타나지 않으며 2는 인쇄 가능한 ASCII 문자가 아니기 때문에 둘 다 ed입니다.
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

fuck, 1770 1710 1703 1686 바이트

Dennis가 60 바이트 절약
Sp3000으로 17 바이트 절약

DNP : 46 ( .)

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

43, 45, 60, 62, 91 및 93을 제외한 모든 것은 Esolangs.org 에서 부끄럽게 도난 당했습니다.

MATL, 305, 302, 300 297 바이트

모든 단일 프로그램은 다음과 같습니다.

33c
34c
35c
....

제외하다

• 숫자. 0-9의 프로그램은 다음과 같습니다.

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

• '씨'. 이 프로그램은

  'C'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 answer 의 포트 이지만 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 컴파일러는 다음과 같은 유니 코드 이스케이프를 처리합니다. \u007B 다른 처리를 수행하기 전에 식별자 및 키워드에 유니 코드 이스케이프를 사용하는 코드를 작성할 수 있습니다. 따라서 상용구에있는 문자를 사용하지 않는 프로그램을 작성하려면 단순히 유니 코드 이스케이프로 대체하십시오.

참조 및 테스트 용이성을 위해 개행으로 구분되고 원시 탭이 4 개의 공백으로 대체 된 전체 프로그램 목록이 있습니다.

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()(A 던져 코드를 따라서 원인이 null을 반환합니다, NullPointerException당신은 기본 터미널 '당신의 OS 이외에서 ()를 호출하면 cmdWindows에서, 그리고, 나는, 가정 bash리눅스 / 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 문자가 쉘에 나타나기 시작하는 데 약 10 초가 걸립니다.

Windows를 사용하는 경우 다음 배치 파일을 대신 실행하십시오.

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

이 배치 파일은 약간 다른 접근 방식을 취합니다. 라인을 사전 분할하는 대신 파일을 라인별로 처리하고 각 프로그램을 차례로 컴파일하고 실행합니다. 다시 한 번 완료되면 증거를 삭제합니다.

Kevin Cruijssen 덕분에 셀 수없이 많은 바이트와 1 DNP가 절약되었습니다!

> <> , 443 437 바이트

TIO 통역사 링크 . 여기에 많은 패턴이 있습니다 :

• [num][num]*o;: 두 숫자를 곱한 다음 결과를 문자로 출력하고을 사용 o하여 정지합니다 ;. > <> 숫자는 15까지입니다 (예 :) 0123456789abcdef.
  • 마찬가지로 [num][num]-n;두 숫자와 출력의 차이를 n대신 숫자로 사용합니다.

• '-o[invalid char]: > <>는 환상적이므로 명령 포인터가 줄 끝에 도달하면 처음으로 돌아갑니다. 이 경우 코드가 두 번 실행됩니다 '-o[char]'-o[char]. 첫 번째 '-o[char]'부분은 3 개의 문자를 스택으로 푸시 하고 결과를 문자로 -계산 'o' - [char]하여 o출력합니다. [char]인식되지 않은 명령으로 인해 또는 빈 스택이 튀어 나와서>에 도달하면 오류가 발생합니다 .

  • 마찬가지로 '-n[invalid char]숫자로 출력됩니다.
  • 마찬가지로 on에 '[num][op]o[invalid char]적용 [op]되어 char에서 오류가 발생합니다. 예를 들어 outputs 는 2보다 큽니다 .[num][char]'2+oJLJ
  • '의 코드는 대신 "-oH사용 "합니다.
  • -의 코드는 대신 '%oB사용 %합니다.

• ln;: 스택 길이를 푸시하고 num으로 출력 한 다음 정지하여을 제공 0합니다. 마찬가지로 lln;에 대한 1및 'ln;대한 3.

• 4|n+: 4를 누르고 바운스를 끈 다음 |다른 4를 누르고 추가 한 다음 8num으로 출력 합니다. |다시 반송 n하고 빈 스택에서 다시 실행하려고하면 오류가 발생합니다 .
  • 마찬가지로 3|n*위한 9.
  • 마찬가지로 [num]|o*위한 @Qdy.
• '1-:00p: 가장 흥미로운 것 o입니다. o코드에서 사용하지 않으려면 코드 상자에 코드 p를 배치 한 o다음 실행해야합니다. 초기 값 '1-:00p'은 스택 p을 맨 위에 놓도록 설정하고 스택을 1-로 줄 o입니다. :이 중복 o하고 00p한 장소 o에서 (0, 0)으로 codebox 선회 o1-:00p. 명령 포인터가 다시 랩핑되어 다른 명령이 출력 o됩니다. (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

루비, 869 바이트

63자를 @통해 ~10 바이트 솔루션이 있습니다.

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

에서 space까지의 대부분의 (21) 문자에 ?대해 9 바이트 솔루션이 있습니다.

puts"\xx"     (2 digit octal code)

남은 11 가지 특별한 경우가 있습니다 :

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

총점은 10 × 63 + 9 × 21 + 10 + 3 + 8 × 4 + 5 = 869입니다.

WolframAlpha , 368 바이트

일반적인 형식 :

u+<character code in hexadecimal>

예외 :

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

전체 목록은 다음과 같습니다.

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

PHP ( 891 680 674 바이트 2 0 DNP)

편집 : jimmy23013 덕분에 203 바이트를 절약하고 Mego 덕분에 2 DNP를 구현했습니다.

이 답변은 PHP의 관대 한 특성을 크게 남용합니다. 대부분의 경우 다음 형식 중 하나를 사용합니다 (각각 7 바이트).

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

PHP는 연산자의 양쪽에있는 문자를 문자열로 변환 한 다음 각 문자열을 ASCII 문자 값으로 변환하여 적절한 비트 단위 연산을 수행 한 다음 결과 를 문자로 다시 변환합니다 .

위의 첫 번째 예에서는가 Y^x됩니다 89^78. 이것의 결과 33는 문자로 STDOUT에 전송됩니다 !.

스크립트는 가능한 모든 조합을 무차별 적으로 작성하기 위해 작성되었습니다. 결과는 여기 에서 찾을 수 있습니다 .

예외 :

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

<그리고 ?일반적으로 인해 필요한 시작 태그에 DNP가 될 것입니다,하지만 사용하여 -r플래그를, 코드가 그들없이 실행할 수 있습니다 :

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

점수:

(7 * 90) + 8 + 9 + 9 + 9 + 9 = 674 바이트

Brachylog , 546 477 바이트

의 코드에 대한 치명적인 크레딧 @.

아래 목록에서 첫 번째 문자는 인쇄 할 문자입니다 (쉽게 참조 할 수 있도록).

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

헥사 고니 , 376 373 바이트, 1 DNP

3 바이트를 절약 한 FryAmTheEggman에게 감사합니다.

거의 모든 프로그램의 형식은 동일합니다 :

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

그러나 몇 가지 예외가 있습니다.

• ;를 사용하지 않고 인쇄 할 수 없으므로 ;1 DNP입니다.
• 인쇄 @하기 @위해 프로그램을 종료 할 수 없습니다 . 대신 우리는 하나를 사용 S2;:하거나 S3;%. 이것은 0으로 나누기 오류와 함께 종료되지만 해당 오류는 STDOUT에 표시되지 않습니다. 따라서 이것은 여전히 ​​4 바이트입니다.
• U필요한 충돌이 하나 있습니다 U3;@. 즉, 낮은 경우에 전환을 포함하여이 문제를 해결하는 방법은 여러 가지가 있습니다 n9;@, 또는 증가 또는 감소, 즉 사용 T);@하거나 V(;@. 어쨌든 여전히 4 바이트입니다.
• 메모리 가장자리에 초기화되어 0, 및 !정수 값을 출력, 그래서 우리가 얻을 수 0와 1와 !@와 )!@3 바이트를 저장, 각각.

방법의 경우와 <letter><digit>;@프로그램이 작동 : 형식의 프로그램의 육각형 레이아웃은 1234항상

 1 2
3 4 .
 . .

제어 흐름을 재지 정하는 명령을 포함하는 프로그램이 없기 때문에 순서대로 실행되는 선형 프로그램입니다.

모든 경우에 코드 시작 부분의 문자는 현재 메모리 에지를 문자 코드로 설정합니다. 프로그램의 예 P1;@는 P설정 값 80. 그런 다음 숫자에이 값에 10을 곱하고 자체를 더합니다 (즉, 숫자가 현재 값에 추가됨). 즉, 범 801위의 예. 마지막 ;으로이 값을 모듈로 256을 사용하여 바이트 값으로 사용하여 인쇄합니다. 이 경우에는 801 % 256 = 33a !가 인쇄됩니다.

공백 , 1643 바이트, 1 DNP

문자 [33-63]의 경우 17 바이트, 문자 [64-126]의 경우 18 바이트

공백에서 인쇄 가능한 문자 (공백 제외)는 아무 의미가 없기 때문에 공백에서는이 방법이 간단합니다.

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

위의 프로그램은 '!' (100001b). [TAB][SPACE][SPACE][SPACE][SPACE][TAB]첫 번째 줄에서 원하는 문자로 변경하십시오 . 공백을 사용하지 않고 공백을 인쇄 할 수 없습니다. 인쇄는 항상[TAB][LF][SPACE]

레티 나 , 712 바이트, 2 개의 DNP

이것은 FryAmTheEggman과의 공동 노력이었습니다.

여러 종류의 솔루션이 있습니다. 공백에서까지의 대부분의 문자 ^에 대해 다음 형식의 프로그램을 사용합니다.

_
T`w`p

두 번째 줄의 문자는 범위 _0-9A-Za-z를 반복 하며 나머지는 변경되지 않습니다. 빈 입력을 해당 문자로 바꾼 다음 인쇄 가능한 ASCII 문자 (p 해당 위치에서 )로 . 이러한 각 프로그램의 길이는 8 바이트입니다.

이 범위 내에서 몇 가지 예외가 있습니다. 가장 중요한 것은 숫자를 줄일 수 있습니다.

• 0 : x(의 수를 센다x 빈 입력 s )
• 1:  (weehoo, 빈 프로그램; 빈 입력에서 빈 일치 횟수를 센다)

• 2 : 이제 빈 문자열을 세기 전에 입력을 단일 문자로 바꿉니다.

  
  1
  
  

• 3 : 같은 것이지만 입력을 두 문자로 바꿉니다.

  
  11
  
  

• 4 : 당신은 아이디어를 얻는다 ...

  
  111
  
  

• 5-9 : 플롯 트위스트 ... 두 번째 줄이 길어지지 않도록 문자 반복을 사용합니다.

  
  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

파이크, 364 (362) 355 바이트

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

다음을 제외한 모든 형식 w<chr(charcode+32)>.C(4 바이트)

• -> d1 바이트
• 0 -> Z1 바이트
• 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 바이트

온라인 파이크 통역사

자바 스크립트 (ES6), 1083 1068 바이트

일반적인 형태 :

alert`\xhex`

예외 :

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

편집 : @ GOTO0 덕분에 15 바이트가 절약되었습니다.

05AB1E , 417 바이트

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

설명

대부분 길이는 5 바이트 convert nr to base nr+1입니다.
>증분을 사용할 수 없으므로 추가 바이트가 필요합니다.

a,b,x,y,z,Y,Z 에서 추출 A 소문자의 알파벳을 포함한다.

A,B,C,D,E,F 16 진수로 변환 된 숫자입니다.

0-9 사전 정의 된 변수뿐만 아니라 단순한 증감입니다.

놀라운, 220 바이트

숫자가 아닌 문자의 경우 문자 코드의 두 개의 대문자 16 진수입니다. 예를 들어, 다음 프로그램이 출력됩니다 A.

41

이 아닌 숫자의 경우 다음 코드에서 문자 코드의 대문자 16 진수로 3대체하십시오 2F.-1

2F
++

의 경우 3:

66
>>

총점 : 2 * 85 + 5 * 10 = 220.

통역사.

내 첫 번째 시도는 Bubblegum이었고 이전에는 캐릭터에서 작동하지 않았습니다 ?...

펄 6 : 921 바이트

파이썬 솔루션의 번역.

각 프로그램의 형식은 다음 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;

하스켈, 1874 1864 1856 1855 1795 1791 1589 바이트, 7 DNP

대부분의 프로그램은 main=putChar '\xx'또는 main=putChar '\xxx'어디에 xx/ xxx숯불의 아스키 코드를 인쇄 할 수있다. 이것은 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 개의 DNP가 남습니다. =aimnrt

각 Haskell 프로그램은 메인 ( main=) 을 정의해야 하므로 5 개의 DNP입니다. 표준 출력을 인쇄하려면 putChar, putStr또는 interact산출 사용될 수 t와 r같이 상기 DNPS. (이 또한 print, 그러나 print 'a'인쇄 'a'하지 a- 포함도 및 t및 r하스켈도있다 어쨌든.) chr숫자를 주어진 해당하는 문자를 반환하는 기능을하지만 그것을 사용하기 위해 import Data.Char필요하다.

총점 : 1437 + 152 = 1589 , 7 DNP

BBC 기본, 422 413 바이트

http://www.bbcbasic.co.uk/bbcwin/bbcwin.html 에서 무료 통역사 다운로드

Leaky Nun 덕분에 9 바이트가 절약되었습니다.

일반적인 형태

V.<character code>

12 개의 특수한 경우를 제외하고 32..99 : 56x4 = 224 바이트

100..126 : 27x5 = 135 바이트

12 가지 특수한 경우 : 54 바이트

대부분의 숫자는 일반적인 형식을 따르지만 문제가 어디에 있는지 보여주기 위해 여기에 모두 포함 시켰습니다.

첫 문자는 인쇄 할 문자입니다.

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

미 콜랑 0.15 , 604 바이트

대부분의 캐릭터들 "<char-1>"1+O.에게는 아마도 가장 짧은 프로그램 일 것입니다. 그러나 문자가 스택에 코드 포인트로 저장되어 있기 때문에 5 바이트 이하로 곱셈과 덧셈을 통해 많은 문자를 생성 할 수 있습니다. 또한, 참고 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 스택에 알파벳 대문자와 소문자를 가압하고, I52이고, 스택의 길이, "4"의 정확한 코드 포인트를 민다. 가장 좋은 부분은 처음에 4$3*O.4와 13을 곱하여 52를 얻는 솔루션을 고려하고 있었지만 4를 가지고 있기 때문에 불가능했기 때문에 어쨌든 골퍼 솔루션을 찾았습니다!

y: $1d*O.

(시도해보십시오.) d 스택 상단을 11복제 하므로이 코드는 푸시 , 복제 및 곱셈입니다. 이것을 쓰는 다른 방법 $12;O.은 같은 바이트 수를 가진 것입니다.

}: 53;O.

(시도하십시오) ; 는 지수이므로 125를 얻기 위해 5 ^ 3을 수행합니다.

그루비, 1019 바이트

나는 다른 Groovy 솔루션을 작성했지만 (아래 참조) 제출 한 후 프로그램을 더 단축하는 방법을 찾기 위해 문자 이스케이프를 조금 더 파고 그루비에 8 가지 문자 이스케이프가 있음을 발견했습니다. 몰랐다. 이것은 불행히도 내가 생각해 낸 거의 모든 기발한 해결 방법의 필요성을 제거한다는 점까지 코드를 크게 단순화시킵니다.

또한 거의 동일하게 보입니다 Copper의 Python 2 솔루션 기본적으로 작업을 표절 한 것처럼 보입니다. 어.

각 프로그램의 형태는 print'\<octal value>'과 같습니다.

• p, r, i,n , t→'print''\<octal value>' (그러나 "인쇄"의 일치 문자로도 8 진수 값으로 대체)
• 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'

그루비, 1130 바이트

8 진수 탈출이 존재한다는 사실을 발견하기 전에 나의 이전 프로그램. 훨씬 더 흥미로운 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 바이트

Mego 덕분에 1 바이트.

쉽게 참조 할 수 있도록 첫 번째 열은 문자 코드이고 두 번째 열은 문자이며 세 번째 열은 코드입니다.

코드 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 (영)

누산기가 0으로 사전 설정되어 있으므로 단일 문자를 사용하여이를 표시 할 수 있습니다.

o

온라인으로 사용해보십시오!

1

0과 유사하게 누산기가 1이되도록 증가합니다.

^o

온라인으로 사용해보십시오!

5

5의 ASCII 코드는 53 이므로이 문제를 해결해야했습니다.

6vo

온라인으로 사용해보십시오!

에이

때문에에 a문자 출력 기능되고,이 문자 a를 생산하는 다른 방법이 없다, 그래서 이것은 단지 내 프로그램 않았다 .

여기에서 모든 프로그램을 보십시오

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는 ( @Stewie Griffin 덕분에 )를 disp사용하여 표시됩니다 . 그러나 거기에도 속하므로 문자열을 이동하고 다음을 사용합니다 .fprintfipeval

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

()그러나 두 문자 모두 disp또는에 필요 eval하므로 DNP입니다.

전체 목록을 참조하십시오.

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

젤리 (비경쟁), 406 바이트

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

이것은 32-126의 모든 문자를 인쇄합니다. 바이트 수는 https://mothereff.in/byte-counter를 사용하여 계산됩니다. .

온라인으로 사용해보십시오!

Befunge-93, 530 바이트

실제로 해당 문자를 사용하지 않고 문자를 출력하는 가장 쉬운 방법은 ASCII 값을 계산하고 ,(문자 출력) 명령을 사용하여 렌더링하는 것입니다. 예를 들어49*,@ 달러 문자 (ASCII 36, 4 * 9)를 출력합니다. 그러나 대부분의 값을 계산하는 데 3 바이트 이상이 걸리기 때문에 이것이 가장 최적 인 것은 아닙니다.

3 바이트로 숫자를 생성하는 또 다른 방법 g은 재생 필드의 첫 번째 셀에있는 (get) 명령이 ASCII 값 g를 생성 한다는 사실을 이용하는 것입니다 (빈 스택은 0으로 채워진 것으로 가정되므로 0,0에서 운동장 값을 읽는 것). 따라서 g1+,@당신이 도착 시간을 , 그리고 g1-,@당신은 얻는다 F . 이것은 분명히 오프셋, 및 이외의 작업의 범위 작동 +및 -도 가능합니다. 예를 들어 g3/,@큰 따옴표 를 얻을 수 있습니다.

이것의 변형은 g스택에 모든 0을 남기는 다른 명령 보다 앞에 오는 것 입니다. 따라서 여전히 0,0의 플레이 필드에서 값을 읽는 중이지만 읽은 캐릭터가 다릅니다. 이것은 1 바이트를 더 필요로하지만 더 많은 값에 액세스 할 수있게합니다. 예를 들어, 0g1-,@슬래시를 :g1+,@가져오고 세미콜론을 얻습니다. 다른 가능한 접두사 포함 *, +, -, >, \와 _. 그리고 다시 다른 작업이 가능하다는 점에 유의하십시오 >g2*,@. 세로 막대를 사용하십시오.

또 다른 변화는 선행 할 수 없다 g와 함께 1, 그래서 당신은 이제 더 이상 0,0에서 읽기,하지만 0,1에서 빈 셀에서하고 있습니다. 비 펀지에서 빈 셀 때문에, 기본적으로 공백으로 초기화 1g,@당신에게 공간을 가져오고 1g1+,@당신에게 느낌표를 가져옵니다.

숫자 문자의 경우 우리가 사용할 수있는 더 모호한 트릭이 있습니다. 문자로 출력하는 대신 숫자로 출력합니다 (ASCII에 비해 작은 숫자를 생성하는 것이 더 쉽습니다). 그래서 예를 들어, 11+.@당신에게주는 2를 , 특히 특별한 경우를주의 : .@위해 0 , 및 !.@대한 1 . 이것의 모호한 부분은 Befunge의 숫자 출력에 숫자 다음에 공백이 포함되므로 순수한 문자 출력이 아닙니다.

우리가 사용할 수있는 또 하나의 모호한 트릭은 g위 기술 의 변형입니다 . 접두사에 대한 Befunge 명령으로 제한하는 대신 Befunge 명령이 아닌 모든 문자를 기술적으로 사용할 수도 있습니다. 대부분의 인터프리터에서 인식 할 수없는 명령은 무시되므로 g결국 이전 문자의 ASCII 값을 읽습니다. 이를 통해 3 바이트로 계산할 수없는 대부분의 다른 ASCII 값을 생성 할 수 있습니다. 일례로 : R을Qg1+,@ 얻습니다 .

마지막으로 세 가지 특별한 경우가 있습니다. g는 보다 적은 5 바이트를 생성 할 수 없습니다, 그래서 우리는에 의지해야한다 "f"1+,@. 쉼표는 가장 복잡하므로 다음과 같이 운동장을 동적으로 수정해야 0g4-:80p @합니다. at 문자를 피하기 위해 비슷한 기술을 사용할 수 있지만보다 효율적인 해킹은 %(modulo) 명령을 종료 자로 사용하는 것 88*,%입니다. 때 %IS 도달이 스택에 아무것도 없으므로 모듈로 연산은 0으로 나누기를 생성하고, 상기 기준 인터프리터에이 프로그램을 종료한다.

아래는 한 줄에 하나씩 전체 프로그램 목록입니다.

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