Em uma linguagem de programação de sua escolha, escreva 95 programas, cada um com um dos 95 caracteres ASCII imprimíveis, sem que esse caractere ocorra em qualquer lugar do programa .

Por exemplo, se sua linguagem era Python , seu programa que gera o caractere Ppode ser

print(chr(80))

porque Ppossui o código ASCII 80. Este programa é válido porque Pnunca aparece no código-fonte. No entanto, para o programa que exibe letras minúsculas p, algo como

print(chr(112))

seria inválido porque, enquanto é impresso p, pestá presente no código. Um programa válido pode ser

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

que imprime, pmas não contém p.

Seu objetivo é tornar cada um de seus 95 programas o mais curto possível. Sua pontuação é a soma dos comprimentos de caracteres de todos os seus programas.

Se, por algum motivo, você não conseguir escrever programas válidos para alguns caracteres, poderá marcá-los como "Não programou" ou DNP e omitir os programas por completo. Dessa forma, idiomas sintaticamente estritos poderão competir.

A resposta vencedora é a resposta que tem a pontuação mais baixa do conjunto de respostas que têm o menor número de DNP.

Regras

• O código fonte de todos os seus programas pode conter apenas guias e novas linhas ASCII imprimíveis e novas, todas contadas como um caractere. (Como em uma codificação diferente, seria fácil omitir caracteres que não existem!)

  • Nota: Essa regra parece necessária, mas há muitos idiomas com codificações diferentes e tenho certeza de que seria legal ver as respostas para elas. Portanto, você pode violar essa regra , pode usar os caracteres que quiser, mas sua resposta se tornará não competitiva e não poderá vencer.

• Os programas devem ser reais, completos programas , de acordo com as convenções padrão do seu idioma. Funções e snippets REPL não são permitidos.

• A saída de cada programa deve ir para stdout ou a alternativa aceita pelo seu idioma.

• Os programas não devem solicitar ou exigir entrada. (Se a solicitação de entrada é inerente ao seu idioma, tudo bem.)

• Os programas devem ser determinísticos, finitos em tempo de execução e independentes. por exemplo, não importa se um é executado em uma pasta separada dos outros programas.

• A saída de um programa deve ser o caractere ASCII imprimível preciso a que corresponde, opcionalmente seguido por uma única nova linha à direita, nada mais, nada menos.

Certifique-se de incluir informações sobre todos os 95 programas (idealmente) em sua resposta, assim como sua pontuação e qualquer DNP. Você não tem que listar todos os programas que seguem um padrão simples como " , ...", mas verifique se você está certo de que todos eles iria funcionar e que a sua pontuação é adicionado corretamente.print(chr(80))print(chr(81))print(chr(82))

Para referência, aqui estão as 95 ASCII imprimíveis que seus programas devem gerar:

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

Python 2, 1075 1065 1043 1040 1039 bytes

Cada programa tem o formato print'\<octal char code>', exceto:

• ' → print"\47"
• 0através de 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"'

Para referência e facilidade de teste, eis a lista completa de programas, separados por nova linha.

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'

Testar:

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

-1 bytes graças a @ Sp3000!

CJam, 269 bytes

Cada um dos programas está no formato, '<char - 1>)exceto:

• Espaço => S, 1 byte
• '=> 39c, 3 bytes
• )=> '*(, 3 bytes
• 0=> T, 1 byte
• 1=> X, 1 byte
• 2=> Y, 1 byte
• 3=> Z, 1 byte
• 4- 9=> <num-1>), 2 bytes

A pontuação é: 3 * 82 + 1 + 3 + 3 + 4 * 1 + 6 * 2 = 269

Código de máquina x86 com restrição ASCII para DOS, 3104 3101 2913 bytes

Bem ... É mais curto que Java, eu acho ...

32. 30 bytes para quase todos os caracteres, para exceções, veja abaixo.

Na maioria das vezes, apenas segue o padrão:

1. Faça um pouco xorpara obter um ponteiro para o fim.
2. subdas 2 últimas palavras, porque o opcode para intnão está em ASCII.
3. Coloque 2 AHe o personagem DL. Ambos são xoreditados porque o caractere em si não pode aparecer no programa e 2 não é um caractere ASCII imprimível.
4. Imprima o caractere com int 21h
5. Sair com int 20h

Na maioria das vezes, se um caractere for desaprovado, ele poderá ser substituído, mexendo um pouco com os dados ou alternando para um registro diferente.

Torna-se um pouco mais interessante quando você de repente se vê incapaz de subtrair ou incapaz de pressionar ou abrir o único registro utilizável para cálculos ...

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 bytes

60 bytes salvos pelo Dennis
17 bytes salvos pelo Sp3000

DNP: 46 ( .)

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

Todos, exceto 43, 45, 60, 62, 91 e 93, são descaradamente roubados da Esolangs.org

MATL, 305, 302, 300 297 bytes

Cada programa é assim:

33c
34c
35c
....

Exceto por

• Dígitos. Aqui estão os programas para 0-9:

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

• 'c'. Este programa é

  'C'k
  

• espaço. Isto é

  0c
  

  Desde hoje, aprendi que o MATL trata o caractere 0 como espaço. Obrigado @LuisMendo!

Você pode usar o matl.tio para verificar qualquer um deles.

Para referência, aqui estão todos eles:

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 bytes

suspiro

Esta é basicamente uma porta da minha resposta do Python 2 , mas com todo o boilerplate que vem com a escrita de um programa completo em Java.

Agora sem DNPs! Obrigado, Kevin Cruijssen!

A maioria dos programas tem o formato interface A{static void main(String[]a){System.out.print("\<octal char code>");}}, exceto:

• espaço → interface\tA{static\tvoid\tmain(String[]a){System.out.print("\40");}}(mas com os \ts substituídos por guias não processadas)
• " → 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

Ufa

O compilador Java processa escapes Unicode como \u007Bantes de qualquer outro processamento, o que possibilita escrever código que usa escapes unicode nos identificadores e até nas palavras-chave. Portanto, para escrever um programa que não utiliza um caractere presente no clichê, simplesmente o substituímos pelo escape unicode.

Para referência e facilidade de teste, eis a lista completa de programas, separados por nova linha e com as guias brutas substituídas por quatro espaços:

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

Observe que o programa ufaz uso de System.console(), que retornará nulo (e, portanto, fará com que o código gere a NullPointerException) se você o chamar de qualquer coisa que não seja o terminal nativo do seu sistema operacional ( cmdno Windows e, suponho, bashno Linux / OSX) .

Para testar, crie um novo diretório e coloque o código acima em um arquivo nomeado printablesnesse diretório. Em seguida, execute o seguinte script 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*

O script acima colocará cada linha printablesem seu próprio diretório, nomeie todos eles A.java(exceto o arquivo que imprime A, que é renomeado B.java), compile cada arquivo, execute-os e exclua as evidências. Demora cerca de dez segundos para os caracteres ASCII imprimíveis começarem a aparecer no seu shell.

Se você estiver no Windows, execute o seguinte arquivo em lote:

@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

Esse arquivo em lotes tem uma abordagem um pouco diferente; em vez de pré-dividir as linhas, ele processa o arquivo linha por linha, compila e executa cada programa sucessivamente. Mais uma vez, ele exclui as evidências após o término.

Economizou inúmeros bytes + 1 DNP graças a Kevin Cruijssen!

> <> , 443 437 bytes

Link do intérprete TIO . Há muitos padrões aqui:

• [num][num]*o;: Multiplicação de dois números e, em seguida, imprima o resultado como um caractere com oe pare com ;. > <> dígitos chegam a 15, ou seja 0123456789abcdef.
  • Da mesma forma [num][num]-n;, que leva a diferença de dois números e sai como um número com n.

• '-o[invalid char]: > <> é toroidal; portanto, quando o ponteiro de instrução chega ao final de uma linha, ele volta ao início. Nesse caso, isso faz com que o código seja executado duas vezes, ou seja '-o[char]'-o[char]. A primeira '-o[char]'parte envia três caracteres para a pilha, -calcula 'o' - [char]e ogera o resultado como um caractere. > <> então ocorre um erro quando é atingido [char], devido a um comando não reconhecido ou ao aparecer uma pilha vazia.

  • Da mesma forma '-n[invalid char], que sai como um número.
  • Da mesma forma '[num][op]o[invalid char], o que se aplica [op]com [num]on [char], com erro no char. Por exemplo, '2+oJsaídas L, que são duas a mais que J.
  • 'código é "-oH, usando em "vez disso.
  • -código é '%oB, usando em %vez disso.

• ln;: Empurre o comprimento da pilha, produza como num e depois para, dando 0. Da mesma forma lln;para 1e 'ln;para 3.

• 4|n+: Pressione 4, salte para fora |e pressione outro 4, adicione e depois a saída 8como num. Salte |novamente e erro ao tentar executar nnovamente em uma pilha vazia.
  • Da mesma forma 3|n*para 9.
  • Da mesma forma [num]|o*para @Qdy.
• '1-:00p: O mais interessante para o ocaso. Para evitar usar oem nosso código, precisamos pcolocar um ona caixa de código e executá-lo. A inicial '1-:00p'configura a pilha para ter um pno topo e a 1-diminui para um o. :duplica isso oe 00pcoloca um oem (0, 0), transformando o codebox em o1-:00p. O ponteiro de instruções é quebrado novamente, produzindo o outro o. O caractere (0, 0) é então substituído mais algumas vezes antes que o programa finalmente desapareça.

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

(não concorrente porque o APL realmente não pode ser gravado usando apenas ASCII)

A maioria está no formato nn⊃⎕AVou nnn⊃⎕AV, com as exceções:

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

Aqui está a lista completa:

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

Para os 63 caracteres @completos ~, temos uma solução de 10 bytes:

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

Para a maioria (21) a partir de caracteres spaceatravés ?, temos uma solução de 9-byte:

puts"\xx"     (2 digit octal code)

Restam onze casos especiais:

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

No total, a pontuação é 10 × 63 + 9 × 21 + 10 + 3 + 8 × 4 + 5 = 869.

WolframAlpha , 368 bytes

Formato geral:

u+<character code in hexadecimal>

Exceções:

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

Aqui está a lista completa:

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

PHP ( 891 680 674 bytes, 2 0 DNP)

Edit: economizou 203 bytes graças ao jimmy23013 e implementou o 2 DNP graças ao Mego

Essa resposta abusa muito da natureza generosa do PHP. A maioria dos casos assume um destes formulários (7 bytes cada):

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

O PHP converte as letras dos dois lados do operador em seqüências de caracteres, depois executa a operação bit a bit apropriada, convertendo cada sequência em seu valor de caractere ASCII e, finalmente, converte o resultado novamente em um caractere.

No primeiro exemplo acima, Y^xtorna-se 89^78. O resultado disso é 33, que é então enviado para STDOUT como o caractere !.

Um script foi escrito para bruteforce todas as combinações possíveis: os resultados podem ser encontrados aqui .

Exceções:

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

<e ?normalmente seria DNP devido à tag inicial necessária, mas usando o -rsinalizador, o código pode ser executado sem eles:

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

Ponto:

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

Braquilog , 546 477 bytes

Créditos para Fatalizar para o código @.

Na lista abaixo, o primeiro caractere é o caractere a ser impresso (para fácil referência).

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

Todos eles são predicados, portanto, Zprecisa ser o argumento para receber a saída: Experimente online!

Explicação

@P é esta sequência:

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

que contém todos os ASCII imprimíveis.

> <> , 531 bytes

Os programas assumem duas formas principais:

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

O primeiro é para caracteres com códigos de caracteres com dois fatores menores que 16, o outro é para os outros casos. A maioria dos números para os quais eu uso o segundo formulário tem muitas soluções de igual comprimento, mas eu escolhi esse para facilitar a leitura.

Exceções:

" 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

Lista completa:

! 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;

Hexagonia , 376 373 bytes, 1 DNP

Obrigado a FryAmTheEggman por salvar 3 bytes.

Quase todos os programas têm a mesma forma:

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

Existem algumas exceções:

• É impossível imprimir ;sem usar ;, portanto, 1 DNP.
• Para imprimir @, não podemos usar @para finalizar o programa. Em vez disso, usamos um S2;:ou S3;%. Isso termina com um erro de divisão por zero, mas esse erro não é visível no STDOUT. Portanto, ainda são quatro bytes.
• Há um conflito para o Uqual seria necessário U3;@. Existem várias maneiras de corrigir isso, incluindo alternar para minúsculas, ou seja n9;@, usando incremento ou decremento, T);@ou seja V(;@. De qualquer forma, ainda são quatro bytes.
• As bordas da memória são inicializadas 0e !imprimem um valor inteiro, para que possamos obter 0e 1com !@e )!@, respectivamente, economizando 3 bytes.

Quanto ao funcionamento dos <letter><digit>;@programas: o layout hexagonal de um programa da forma 1234é sempre

 1 2
3 4 .
 . .

Como nenhum dos programas contém comandos que redirecionam o fluxo de controle, esses são simplesmente programas lineares executados em ordem.

Em todos os casos, a letra no início do código define a borda da memória atual como seu código de caractere. Por exemplo, no programa P1;@, Pdefine o valor 80. Em seguida, o dígito multiplica esse valor por 10 e se adiciona (ou seja, o dígito é anexado ao valor atual). Isso dá 801no exemplo acima. Por fim, ;imprime esse valor usando o módulo 256 e usando-o como um valor de byte. Nesse caso, 801 % 256 = 33e a !é impresso.

Espaço em branco , 1643 bytes, 1 DNP

17 bytes para os caracteres [33-63] e 18 bytes para os caracteres [64-126]

No espaço em branco, isso é simples, porque os caracteres imprimíveis (exceto o espaço) não têm qualquer significado:

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

O programa acima imprime um '!' (100001b). Mude [TAB][SPACE][SPACE][SPACE][SPACE][TAB]na primeira linha para o caractere que desejar. Não é possível imprimir um espaço sem usá-lo, porque a impressão de qualquer coisa sempre começa com[TAB][LF][SPACE]

Retina , 712 bytes, 2 DNPs

Este foi um esforço colaborativo com FryAmTheEggman.

Existem várias classes de soluções. Para a maioria dos caracteres do espaço para ^, usamos um programa da seguinte forma:

_
T`w`p

O caractere na segunda linha percorre os intervalos _0-9A-Za-zenquanto o restante permanece inalterado. Isso transforma a entrada vazia nesse caractere e a substitui pelo caractere ASCII imprimível (representado por p) na posição correspondente. Cada um desses programas tem 8 bytes.

Dentro desse intervalo, existem apenas algumas exceções. Mais importante ainda, os dígitos podem ser reduzidos:

• 0: x(conta o número de xs na entrada vazia)
• 1:  (weehoo, programa vazio; conta o número de correspondências vazias na entrada vazia)

• 2: agora transformamos a entrada em um único caractere, antes de contar as strings vazias:

  
  1
  
  

• 3: mesma coisa, mas transformamos a entrada em dois caracteres:

  
  11
  
  

• 4: você entendeu a idéia ...

  
  111
  
  

• 5 - 9: reviravolta na trama ... usamos a repetição de caracteres para evitar que a segunda linha fique mais longa:

  
  4$*
  
  

  ...

  
  8$*
  
  

A outra exceção é que Té um DNP: não achamos possível gerar um caractere que não seja um dígito sem que ele apareça no código-fonte se os estágios de transliteração não puderem ser usados.

Para os caracteres restantes. Para imprimir _, usamos um programa semelhante à solução geral acima:

0
T`0`w

Fazendo uso do fato que wcomeça com _.

A seguir, `é o segundo DNP, porque os estágios de transliteração também os exigem.

Em seguida, a maioria das letras minúsculas é impressa com algo assim (que é impresso a):

_
T`w`l

Novamente, o caractere na segunda linha é incrementado _0-9A-O. Aqui, precisamos apenas tomar cuidado com le w, que podemos imprimir com os seguintes programas, respectivamente:

P
T`p`w

6
T`p`l

Finalmente, restam apenas {|}~, que exigem 9 bytes cada. Aqui, usamos o estágio de transliteração para incrementar o caractere que os precede. Por exemplo, ~pode ser impresso com:

}
T`_p`p

Pyke, 364 362 355 bytes

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

Tudo no formato w<chr(charcode+32)>.C(4 bytes), exceto:

• -> d1 byte
• 0-> Z1 byte
• 1-> ~W2 bytes
• a-> Gh2 bytes
• z-> Ge2 bytes
• Primeiras 10 letras minúsculas do alfabeto (exceto a) no formulário G<number>@(3 bytes)
• k-> GT@3 bytes
• >-> ~Bh3 bytes
• ]-> ~Be3 bytes
• Z-> ~le3 bytes
• 9-> ~ue3 bytes
• w-> G22@4 bytes
• .-> ~B4@4 bytes
• C-> ~K38@5 bytes

Intérprete online de Pyke

JavaScript (ES6), 1083 1068 bytes

Forma geral:

alert`\xhex`

Exceções:

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`

Editar: salvou 15 bytes graças a @ GOTO0.

05AB1E , 417 bytes

!   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

Explicação

A maioria é 5 bytes do formulário: convert nr to base nr+1.
>precisa de um byte extra, pois não podemos usar incremento para isso.

a,b,x,y,z,Y,Zsão extraídos dos Aquais contém o alfabeto em letras minúsculas.

A,B,C,D,E,F são números convertidos em hexadecimal.

0-9 são simples incrementos / decréscimos, bem como variáveis ​​predefinidas.

Marbelous, 220 bytes

Para um caractere que não é um dígito, são apenas os dois dígitos hexa maiúsculos do código de caractere. Por exemplo, o seguinte programa gera A:

41

Para um dígito que não seja 3, substitua 2Fno código a seguir pelos dígitos hexa maiúsculos do código de caractere - 1:

2F
++

Para 3:

66
>>

Pontuação total: 2 * 85 + 5 * 10 = 220.

Intérprete.

Minha primeira tentativa foi Bubblegum e não funcionou para personagens antes ?...

Perl 6: 921 bytes

Tradução da solução Python.

Cada programa tem o formato say "\x<hex escape code>", exceto:

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

Para referência e facilidade de teste, eis a lista completa de programas, separados por nova linha.

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

Aqui está o código que usei para testar a lista acima e conte a pontuação:

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

A maioria dos programas é main=putChar '\xx'ou main=putChar '\xxx'onde xx/ xxxé o código ascii do caractere a ser impresso. Isso funciona para todos, exceto 14 caracteres:

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

No entanto, para os dígitos 1 7 4 bytes podem ser salvos (graças a Christian Sievers!):

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

Os 52 programas até c(código 99) recebem 18 bytes, os 19 restantes, 19 bytes cada.

Pontuação parcial: 10*14 + 52*18 + 19*19 = 1437

Para 7 dos caracteres restantes, os seguintes programas funcionam:

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

Pontuação parcial: 18 + 22 + 18 + 21 + 19 + 27 + 27 = 152

Isso deixa 7 DNPs: =aimnrt

Cada programa Haskell precisa definir um main ( main=), então são 5 DNPs. Para imprimir a StdOut, putChar, putStrou interactpode ser utilizado, dando origem te rcomo mais DNPS. (Há também print, no entanto, print 'a'imprime 'a'e não a- e também contém te de rqualquer maneira.) Haskell também possui uma chrfunção que retorna o caractere correspondente dado um número, no entanto, para usá-loimport Data.Char é necessário.

Pontuação total 1437 + 152 = 1589 :, 7 DNPs

BBC Basic, 422 413 bytes

Faça o download do intérprete gratuitamente em http://www.bbcbasic.co.uk/bbcwin/bbcwin.html

9 bytes salvos graças a Leaky Nun.

Forma geral

V.<character code>

32..99, excluindo 12 casos especiais: 56x4 = 224 bytes

100..126 : 27x5 = 135 bytes

12 casos especiais: 54 bytes

A maioria dos números segue a forma geral, mas incluí todos aqui para mostrar onde está o problema.

Primeiro caractere é o caractere a ser impresso.

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

Para a maioria dos personagens, "<char-1>"1+O.seria um programa válido, talvez um dos mais curtos. No entanto, devido ao fato de os caracteres serem armazenados como pontos de código na pilha, muitos deles podem ser produzidos por multiplicação e adição, em cinco bytes ou menos. Além disso, observe que l, $1, $2, $3, $4, $5, $6, $lsão 10, 11, 12, 13, 14, 15, 16, 100respectivamente.

Formato: <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.

Menções especiais:

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

(Experimente.) Minkolang tem a capacidade de modificar os caracteres na caixa de código; portanto, o que este programa faz é que ele substitua isso -no final por ., necessário para interromper o programa. "N"1+d90pN.para Ofunciona da mesma maneira.

4: lZIO.

(Experimente.) lZ Empurra os alfabetos em maiúsculas e minúsculas para a pilha e Iempurra o comprimento da pilha, que é 52, precisamente o ponto de código de "4". A melhor parte é que eu estava inicialmente pensando na solução de 4$3*O., que multiplica 4 e 13 para obter 52, mas não consegui porque tinha 4, então acabei encontrando uma solução para golfista de qualquer maneira!

y: $1d*O.

(Tente.) d Duplica a parte superior da pilha, então o que esse trecho de código faz é que ele empurra 11, duplica e multiplica. Uma maneira alternativa de escrever isso seria $12;O., com a mesma contagem de bytes.

}: 53;O.

(Experimente.) ; É exponenciação, então isso faz 5 ^ 3 para obter 125.

Groovy, 1019 bytes

Eu tinha uma solução Groovy diferente escrita (veja abaixo), mas depois que a enviei, me aprofundou um pouco mais nas fugas de caracteres, na esperança de encontrar uma maneira de reduzir mais o programa, e descobri que o Groovy tem uma fuga octal de caracteres que eu não sabia. Isso simplifica significativamente o código, a ponto de, infelizmente, remover a necessidade de quase todas as soluções alternativas peculiares que eu criei.

Também parece quase idêntico à solução Python 2 da Copper , a ponto de basicamente parecer que plagiei o trabalho deles. Ugh.

Cada programa tem o formato print'\<octal value>', exceto:

• p, r, i, n, t→ 'print''\<octal value>'(mas com a letra correspondente de "print" também substituído com o valor octal)
• 0- 9→print~-<next int>

Aqui está a lista completa de programas por personagem.

    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 bytes

Meu programa anterior, antes de descobrir que existem fugas octais. Muito mais interessante, IMO.

Cada programa tem o formato print(--'<next char>'), exceto:

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

Aqui está a lista completa de programas para cada personagem:

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

Na verdade , 383 382 381 bytes

1 byte graças ao Mego.

Para fácil referência, a primeira coluna é o código do caractere, a segunda coluna é o caractere e a terceira coluna é o código.

O código para 0é um espaço único.

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

Experimente online!

Sugestões de golfe são bem-vindas.

Fourier, 306 bytes, 1 DNP

Praticamente todos os programas seguem o padrão em naque n é o código de caractere de cada um dos caracteres. Por exemplo:

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

Experimente online!

Então, apenas listarei as exceções:

0 (zero)

Como o acumulador é predefinido para zero, podemos exibir isso usando um único caractere:

o

Experimente online!

1 1

Semelhante a zero, isso incrementa o acumulador para obter 1.

^o

Experimente online!

5

O código ASCII para 5 é 53, então tive que contornar isso:

6vo

Experimente online!

uma

Por aser a função de saída de caractere, não há outra maneira de produzir o caractere a, então esse é o meu único DID NOT PROGRAM .

Veja todos os programas aqui

Matlab, 1238 1224 bytes, 2 DNP

O padrão principal é:

disp([<char code> ''])

Para dígitos, é um pouco menor:

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

Para caracteres []'é:

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

Os caracteres dsde dispsão exibidos usando fprintf( obrigado @Stewie Griffin ); ipno entanto pertencem também lá, então estou mudando a string e usando eval:

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

()No entanto, ambos os caracteres são necessários para dispou eval, portanto, são DNP.

Para referência a lista inteira:

    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

Gelatina (não competitiva), 406 bytes

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Ọ

Isso imprime todos os caracteres de 32 a 126. A contagem de bytes é calculada com https://mothereff.in/byte-counter .

Experimente online!

Befunge-93, 530 bytes

A maneira mais fácil de gerar um caractere, sem usá-lo, é calcular o valor ASCII e usar o ,comando (saída de caractere) para renderizá-lo. Por exemplo, 49*,@gera o caractere do dólar (ASCII 36, 4 * 9). Porém, isso raramente é o melhor, já que a maioria dos valores leva mais de 3 bytes para calcular.

Outra maneira de gerar um número em 3 bytes é aproveitar o fato de o gcomando (get) na primeira célula do campo de jogo gerar o valor ASCII de g (presume-se que uma pilha vazia seja preenchida com zeros, portanto, é lendo o valor do campo de jogo em 0,0). Assim, g1+,@você recebe h , e g1-,@você recebe f . Obviamente, isso funciona para uma série de compensações e operações diferentes +e -também são possíveis. Assim, por exemplo, g3/,@você recebe uma citação dupla.

Uma variação disso é preceder o gcomando com outro comando que deixa todos os zeros na pilha. Então você ainda está lendo um valor do campo de jogo em 0,0, mas o personagem que está sendo lido agora é diferente. Isso custa mais um byte, mas você obtém acesso a muitos outros valores. Por exemplo, 0g1-,@você obtém uma barra e :g1+,@um ponto e vírgula. Outros prefixos viáveis incluem *, +, -, >, \e _. E, novamente, observe que outras operações são possíveis: >g2*,@obtenha uma barra vertical.

Uma variação adicional é preceder o gcom a 1, então você não está mais lendo de 0,0, mas da célula em branco em 0,1. No Befunge, as células vazias são inicializadas com espaços por padrão, então 1g,@você recebe um espaço e 1g1+,@um ponto de exclamação.

Para os dígitos, há mais truques duvidosos que podemos usar. Em vez de tentar produzi-los como caracteres, nós os produzimos como números (um número pequeno é mais fácil de gerar do que seu equivalente ASCII). Assim, por exemplo, 11+.@você fornece 2 e, em particular, observe os casos especiais: .@para 0 e !.@para 1 . A parte duvidosa disso é que uma saída numérica no Befunge inclui um espaço após o número, portanto não é uma saída pura de caracteres.

Outro truque duvidoso que podemos usar é uma variação da gtécnica acima. Em vez de nos limitarmos aos comandos Befunge para o prefixo, também podemos usar tecnicamente qualquer caractere que não seja um comando Befunge. Na maioria dos intérpretes, um comando não reconhecido será ignorado e, portanto g, acabará lendo o valor ASCII do caractere anterior. Isso nos permite gerar a maioria dos outros valores ASCII que não poderiam ser calculados em 3 bytes. Como um exemplo: Qg1+,@você recebe R .

Finalmente, existem três casos especiais. Um g não pode ser gerado em menos de 5 bytes, por isso temos que recorrer "f"1+,@. A vírgula é o mais complicado, exigindo a alteração dinâmica do campo de jogo: 0g4-:80p @. Poderíamos usar uma técnica semelhante para evitar o caractere at, mas um hack mais eficiente é usar o %comando (modulo) como terminador, ie 88*,%. Quando o% é atingido, não há nada na pilha; portanto, o cálculo do módulo gera uma divisão por zero, e no intérprete de referência isso encerrará o programa.

Abaixo está a lista completa de programas, um por linha.

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