En el lenguaje de programación que elija, escriba 95 programas, cada uno de los cuales generará uno diferente de los 95 caracteres ASCII imprimibles sin que ese carácter aparezca en ninguna parte del programa .

Por ejemplo, si su lenguaje era Python , su programa que genera el carácter Ppodría ser

print(chr(80))

porque Ptiene el código ASCII 80. Este programa es válido porque Pnunca aparece en el código fuente. Sin embargo, para el programa que genera minúsculas p, algo como

print(chr(112))

sería inválido porque, aunque se imprime p, pestá presente en el código. Un programa válido podría ser

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

que imprime ppero no contiene p.

Su objetivo es hacer que cada uno de sus 95 programas sea lo más breve posible. Su puntaje es la suma de las longitudes de caracteres de todos sus programas.

Si por alguna razón no puede escribir programas válidos para algunos caracteres, puede marcar esos caracteres como "No se programó" o DNP , y omitir programas para ellos por completo. De esta forma, los lenguajes sintácticamente estrictos podrán competir.

La respuesta ganadora es la respuesta que tiene la puntuación más baja del conjunto de respuestas que tienen la menor cantidad de DNP.

Reglas

• El código fuente de todos sus programas solo puede contener pestañas ASCII plus imprimibles y líneas nuevas, todos los cuales se cuentan como un carácter. (¡Porque en una codificación diferente sería fácil omitir caracteres que no existen!)

  • Nota: Esta regla parece necesaria, pero hay muchos idiomas con diferentes codificaciones y estoy seguro de que sería genial ver las respuestas para ellos. Por lo tanto , puede romper esta regla , puede usar cualquier personaje que desee, pero luego su respuesta se vuelve no competitiva , no puede ganar.

• Los programas deben ser reales, llenos programas , de acuerdo con las convenciones estándar de su lenguaje. Las funciones y los fragmentos REPL no están permitidos.

• La salida de cada programa debe ir a stdout o la alternativa aceptada de su idioma.

• Los programas no deben solicitar ni requerir aportes. (Si solicitar entradas es inherente a su idioma, está bien).

• Los programas deben ser deterministas, finitos en tiempo de ejecución e independientes. por ejemplo, no debería importar si uno se ejecuta en una carpeta separada de los otros programas.

• La salida de un programa debe ser el carácter ASCII imprimible preciso al que corresponde, opcionalmente seguido de una nueva línea final, nada más y nada menos.

Asegúrese de incluir información sobre los 95 (idealmente) programas en su respuesta, así como su puntaje y cualquier DNP. Usted no tiene que enumerar todos los programas que siguen un patrón simple como " , ...", pero asegúrese de que está seguro de que todos serían trabajar y que se añade su puntuación correctamente.print(chr(80))print(chr(81))print(chr(82))

Como referencia, aquí están los 95 ASCII imprimibles que sus programas deben generar:

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

Python 2, 1075 1065 1043 1040 1039 bytes

Cada programa tiene la forma print'\<octal char code>', excepto:

• ' → print"\47"
• 0a través 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 referencia y facilidad de prueba, aquí está la lista completa de programas, separados por nueva línea.

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'

Probar:

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

-1 bytes gracias a @ Sp3000!

CJam, 269 bytes

Cada uno de los programas tiene la forma, '<char - 1>)excepto:

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

La puntuación es: 3 * 82 + 1 + 3 + 3 + 4 * 1 + 6 * 2 = 269

Código de máquina x86 con restricciones ASCII para DOS, 3104 3101 2913 bytes

Bueno ... supongo que es más corto que Java ...

32 30 bytes para casi todos los caracteres, para excepciones ver más abajo.

La mayoría de las veces solo sigue el patrón:

1. Haga algunos xorpara obtener un puntero hasta el final.
2. subde las últimas 2 palabras porque el código de operación para intno está en ASCII.
3. Consigue 2 AHy el personaje en DL. Ambos se xoreditan porque el carácter en sí no puede aparecer en el programa y 2 no es un carácter ASCII imprimible.
4. Imprime el personaje con int 21h
5. Salir con int 20h

La mayoría de las veces, si un personaje no está permitido, se puede reemplazar girando un poco los datos o cambiando a un registro diferente.

Se vuelve un poco más interesante cuando de repente te encuentras incapaz de restar o incapaz de empujar o reventar el único registro utilizable para los 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 guardados por Dennis
17 bytes guardados por Sp3000

DNP: 46 ( .)

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

Todos excepto 43, 45, 60, 62, 91 y 93 son robados descaradamente de Esolangs.org

MATL, 305, 302, 300 297 bytes

Cada programa se ve así:

33c
34c
35c
....

Excepto por

• Dígitos. Aquí están los programas para 0-9:

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

• 'C'. Este programa es

  'C'k
  

• espacio. Esto es

  0c
  

  Desde hoy aprendí que MATL trata el carácter 0 como espacio. Gracias @LuisMendo!

Puede usar matl.tio para verificar cualquiera de ellos.

Como referencia, aquí están todos ellos:

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

Esto es básicamente un puerto de mi respuesta de Python 2 , pero con todo lo que viene con la escritura de un programa completo en Java.

Ahora sin ningún DNP en absoluto! Gracias Kevin Cruijssen!

La mayoría de los programas tienen la forma interface A{static void main(String[]a){System.out.print("\<octal char code>");}}, excepto:

• espacio → interface\tA{static\tvoid\tmain(String[]a){System.out.print("\40");}}(pero con la \ts reemplazada por pestañas sin procesar)
• " → 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

Uf

El compilador de Java procesa escapes Unicode como \u007Bantes de realizar cualquier otro procesamiento, lo que hace posible escribir código que usa escapes Unicode en identificadores e incluso palabras clave. Entonces, para escribir un programa que no use un carácter presente en el repetitivo, simplemente lo sustituimos con escape unicode.

Para referencia y facilidad de prueba, aquí está la lista completa de programas, separados por nueva línea y con las pestañas sin procesar reemplazadas por cuatro espacios:

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

Tenga en cuenta que el programa uutiliza System.console(), que devolverá nulo (y, por lo tanto, provocará que el código arroje a NullPointerException) si lo llama desde cualquier otra cosa que no sea el terminal nativo de su sistema operativo ( cmden Windows y, supongo, bashen Linux / OSX) .

Para probar, cree un nuevo directorio y coloque el código anterior en un archivo nombrado printablesen ese directorio. Luego, ejecute el siguiente script de 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*

El script anterior colocará cada línea printablesen su propio directorio, los nombrará a todos A.java(excepto el archivo que se imprime A, al que se le cambia el nombre B.java), compilará cada archivo, los ejecutará y luego eliminará la evidencia. Los caracteres ASCII imprimibles deberían tardar unos diez segundos en comenzar a aparecer en su shell.

Si estás en Windows, ejecuta el siguiente archivo Batch:

@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

Este archivo por lotes adopta un enfoque ligeramente diferente; en lugar de dividir previamente las líneas, procesa el archivo línea por línea y compila y ejecuta cada programa a su vez. Nuevamente, elimina la evidencia una vez que finaliza.

¡Salvamos innumerables bytes + el 1 DNP gracias a Kevin Cruijssen!

> <> , 443 437 bytes

Enlace de intérprete de TIO . Hay muchos patrones aquí:

• [num][num]*o;: Multiplicación de dos números, luego genera el resultado como un carácter con oy para con ;. > <> dígitos van hasta 15, es decir 0123456789abcdef.
  • Del mismo modo [num][num]-n;, que toma la diferencia de dos números y las salidas como un número con n.

• '-o[invalid char]: > <> es toroidal, por lo que cuando el puntero de instrucción llega al final de una línea, retrocede al principio. En este caso, esto hace que el código se ejecute dos veces, es decir '-o[char]'-o[char]. La primera '-o[char]'parte empuja tres caracteres a la pila, -calcula y 'o' - [char]luego omuestra el resultado como un personaje. > <> luego genera errores cuando llega [char], ya sea debido a un comando no reconocido o por reventar una pila vacía.

  • Del mismo modo '-n[invalid char], que sale como un número.
  • Del mismo modo '[num][op]o[invalid char], lo que se aplica [op]con [num]on [char], error en char. Por ejemplo, '2+oJsalidas L, que son dos más que J.
  • 'El código de es "-oH, utilizando en su "lugar.
  • -El código de es '%oB, utilizando en su %lugar.

• ln;: Empuje la longitud de la pila, salida como num y luego pare, dando 0. Del mismo modo lln;para 1y 'ln;para 3.

• 4|n+: Presione 4, rebote |y presione otros 4, agregue, luego envíe 8como num. Rebota de |nuevo, y error al intentar ejecutar nnuevamente en una pila vacía.
  • Del mismo modo 3|n*para 9.
  • Del mismo modo [num]|o*para @Qdy.
• '1-:00p: El más interesante, para el ocaso. Para evitar el uso oen nuestro código, debemos usarlo ppara colocar un oen el cuadro de código y luego ejecutarlo. La inicial '1-:00p'configura la pila para que tenga un valor psuperior, y la 1-reduce a un valor o. :duplica esto oy 00pcoloca uno oen (0, 0), convirtiendo el cuadro de código en o1-:00p. El puntero de instrucción se ajusta nuevamente, generando el otro o. El carácter (0, 0) se reemplaza algunas veces más antes de que el programa finalmente falle.

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

(no compite porque APL realmente no se puede escribir usando ASCII solamente)

La mayoría están en el formato nn⊃⎕AVo nnn⊃⎕AV, las excepciones son:

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

Aquí está la 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

Rubí, 869 bytes

A los 63 caracteres @a través ~, tenemos una solución de 10 bytes:

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

Para la mayoría (21) de caracteres spacea través ?, tenemos una solución 9 bytes:

puts"\xx"     (2 digit octal code)

Quedan once casos especiales:

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

En total, la puntuación es 10 × 63 + 9 × 21 + 10 + 3 + 8 × 4 + 5 = 869.

WolframAlpha , 368 bytes

Formato general:

u+<character code in hexadecimal>

Excepciones:

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

Aquí está la 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)

Editar: ahorré 203 bytes gracias a jimmy23013 e implementé el 2 DNP gracias a Mego

Esta respuesta abusa fuertemente de la generosa naturaleza de PHP. La mayoría de los casos toman una de estas formas (7 bytes cada uno):

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

PHP convierte las letras a cada lado del operador en cadenas, luego realiza la operación apropiada a nivel de bits al convertir cada cadena a su valor de carácter ASCII y finalmente convierte el resultado nuevamente en un carácter.

En el primer ejemplo anterior, se Y^xconvierte 89^78. El resultado de esto es 33, que luego se envía a STDOUT como el personaje !.

Se escribió un guión para imponer todas las combinaciones posibles: los resultados se pueden encontrar aquí .

Excepciones:

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

<y ?normalmente sería DNP debido a la etiqueta de inicio requerida, pero al usar el -rindicador, el código se puede ejecutar sin ellos:

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

Puntuación:

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

Brachylog , 546 477 bytes

Créditos para Fatalizar por el código para @.

En la lista a continuación, el primer carácter es el carácter que se imprimirá (para facilitar la referencia).

  @S
! @Ht
"@P: 2m
# @P: 3m
$ @P: 4 millones
% @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
Yo @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
un @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
El | @P: 92m
} @Prbh
~ @Pt

Todos son predicados, por lo que Zdebe ser el argumento para recibir el resultado: ¡ Pruébelo en línea!

Explicación

@P es esta cadena:

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

que contiene todos los ASCII imprimibles.

> <> , 531 bytes

Los programas toman dos formas principales:

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

El primero es para caracteres con códigos de caracteres con dos factores, ambos menores que 16, el otro es para los otros casos. La mayoría de los números para los que uso la segunda forma tienen muchas soluciones de igual longitud, pero elegí esa por legibilidad.

Excepciones:

" 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 llena:

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

Hexagony , 376 373 bytes, 1 DNP

Gracias a FryAmTheEggman por guardar 3 bytes.

Casi todos los programas tienen la misma forma:

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

Sin embargo, hay algunas excepciones:

• Es imposible imprimir ;sin usar ;, por lo tanto, 1 DNP.
• Para imprimir @, no podemos usar @para finalizar el programa. En su lugar, usamos S2;:o S3;%. Esto termina con un error de división por cero, pero ese error no es visible en STDOUT. Entonces esto sigue siendo cuatro bytes.
• Hay un choque Uque requeriría U3;@. Hay varias formas de solucionar esto, incluido el cambio a minúsculas, es decir n9;@, o el uso de incremento o disminución, es decir, T);@o V(;@. En cualquier caso, todavía son cuatro bytes.
• Los bordes de la memoria se inicializan 0e !imprimen un valor entero, para que podamos obtener 0y 1con !@y )!@, respectivamente, guardar 3 bytes.

En cuanto a cómo funcionan los <letter><digit>;@programas: el diseño hexagonal de un programa de la forma 1234es siempre

 1 2
3 4 .
 . .

Como ninguno de los programas contiene ningún comando que redirija el flujo de control, estos son simplemente programas lineales que se ejecutan en orden.

En todos los casos, la letra al comienzo del código establece el borde de la memoria actual en su código de caracteres. Por ejemplo, en el programa P1;@, Pestablece el valor 80. Luego, el dígito multiplica este valor por 10 y se suma a sí mismo (es decir, el dígito se agrega al valor actual). Eso da 801en el ejemplo anterior. Finalmente, ;imprime este valor tomándolo como módulo 256 y usándolo como un valor de byte. En este caso 801 % 256 = 33y !se imprime a.

Espacio en blanco , 1643 bytes, 1 DNP

17 bytes para los caracteres [33-63] y 18 bytes para los caracteres [64-126]

En Whitespace esto es sencillo, porque los caracteres imprimibles (excepto el espacio) no tienen ningún significado de todos modos:

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

El programa anterior imprime un '!' (100001b). Cambie [TAB][SPACE][SPACE][SPACE][SPACE][TAB]en la primera línea al personaje que desee. No es posible imprimir un espacio sin usar un espacio, porque imprimir cualquier cosa siempre comienza con[TAB][LF][SPACE]

Retina , 712 bytes, 2 DNP

Este fue un esfuerzo de colaboración con FryAmTheEggman.

Hay varias clases de soluciones. Para la mayoría de los caracteres desde el espacio hasta ^, utilizamos un programa de la siguiente forma:

_
T`w`p

El personaje en la segunda línea itera a través de los rangos _0-9A-Za-zmientras que el resto permanece sin cambios. Esto convierte la entrada vacía en ese carácter y luego la reemplaza con el carácter ASCII imprimible (representado por p) en la posición correspondiente. Cada uno de estos programas tiene 8 bytes de longitud.

Dentro de este rango, solo hay algunas excepciones. Lo más importante es que los dígitos se pueden acortar:

• 0: x(cuenta el número de xs en la entrada vacía)
• 1:  (weehoo, programa vacío; cuenta el número de coincidencias vacías en la entrada vacía)

• 2: ahora convertimos la entrada en un solo carácter, antes de contar cadenas vacías:

  
  1
  
  

• 3: lo mismo pero convertimos la entrada en dos caracteres:

  
  11
  
  

• 4: tienes la idea ...

  
  111
  
  

• 5-9: giro de la trama ... usamos la repetición de caracteres para evitar que la segunda línea se alargue:

  
  4$*
  
  

  ...

  
  8$*
  
  

La otra excepción es que Tes un DNP: no creemos que sea posible generar un carácter que no sea un dígito sin que aparezca en el código fuente si no se pueden utilizar las etapas de transliteración.

A los personajes restantes. Para imprimir _utilizamos un programa similar a la solución general anterior:

0
T`0`w

Haciendo uso del hecho que wcomienza con _.

Luego, `está el segundo DNP, porque las etapas de transliteración también lo requieren.

Luego, la mayoría de las letras minúsculas se imprimen con algo como esto (que se imprime a):

_
T`w`l

Nuevamente, el carácter en la segunda línea se incrementa a través _0-9A-O. Aquí, solo tenemos que tener cuidado con ly w, que podemos imprimir con los siguientes programas, respectivamente:

P
T`p`w

6
T`p`l

Finalmente, solo {|}~quedan, que requieren 9 bytes cada uno. Aquí, usamos la etapa de transliteración para incrementar el carácter que los precede. Por ejemplo, ~se puede imprimir con:

}
T`_p`p

Pyke, 364 362 355 bytes

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

Todo en la forma w<chr(charcode+32)>.C(4 bytes) excepto:

• -> d1 byte
• 0-> Z1 byte
• 1-> ~W2 bytes
• a-> Gh2 bytes
• z-> Ge2 bytes
• Primeras 10 letras minúsculas del alfabeto (excepto a) en forma 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 de Pyke en línea

JavaScript (ES6), 1083 1068 bytes

Forma general:

alert`\xhex`

Excepciones:

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: Guardado 15 bytes gracias 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

Explicación

La mayoría son 5 bytes de longitud del formulario: convert nr to base nr+1.
>necesita un byte extra ya que no podemos usar incremento para eso.

a,b,x,y,z,Y,Zse extraen de los Acuales contiene el alfabeto en minúsculas.

A,B,C,D,E,F son números convertidos a hexadecimal.

0-9 son simples incrementos / decrementos, así como variables predefinidas.

Maravilloso, 220 bytes

Para un carácter que no es un dígito, son solo los dos dígitos hexadecimales en mayúsculas del código de caracteres. Por ejemplo, los siguientes resultados del programa A:

41

Para un dígito que no lo es 3, reemplace 2Fen el siguiente código por los dígitos hexadecimales en mayúsculas del código de caracteres - 1:

2F
++

Para 3:

66
>>

Puntuación total: 2 * 85 + 5 * 10 = 220.

Interprete.

Mi primer intento fue Bubblegum y no funcionó para los personajes antes ?...

Perl 6: 921 bytes

Traducción de la solución Python.

Cada programa tiene la forma say "\x<hex escape code>", excepto:

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

Para referencia y facilidad de prueba, aquí está la lista completa de programas, separados por nueva línea.

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

Aquí está el código que usé para probar la lista anterior, y cuente la puntuación:

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

La mayoría de los programas son main=putChar '\xx'o main=putChar '\xxx'where xx/ xxxes el código ASCII del carácter a imprimir. Esto funciona para todos menos 14 caracteres:

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

Sin embargo, para los dígitos 1 7 4 bytes se pueden guardar (¡gracias a Christian Sievers!):

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

Los 52 programas hasta c(código 99) toman 18 bytes, los 19 restantes toman 19 bytes cada uno.

Puntuación parcial: 10*14 + 52*18 + 19*19 = 1437

Para 7 de los caracteres restantes, funcionan los siguientes programas:

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

Puntuación parcial: 18 + 22 + 18 + 21 + 19 + 27 + 27 = 152

Esto deja 7 DNP: =aimnrt

Cada programa Haskell necesita definir un main ( main=), por lo que son 5 DNP. Para imprimir en stdout putChar, putStro interactse puede utilizar, produciendo ty rcomo otros DNP. (También hay print, sin embargo, print 'a'impresiones 'a'y no a, y también contiene ty de rtodos modos). Haskell también tiene una chrfunción que devuelve el número de caracteres correspondiente dado, sin embargo, para usarlo import Data.Chares necesario.

Puntuación total: 1437 + 152 = 1589 7 DNP

BBC Basic, 422 413 bytes

Descargue el intérprete gratis en http://www.bbcbasic.co.uk/bbcwin/bbcwin.html

9 bytes guardados gracias a Leaky Nun.

Forma general

V.<character code>

32..99 excluyendo 12 casos especiales: 56x4 = 224 bytes

100..126 : 27x5 = 135 bytes

12 casos especiales: 54 bytes

La mayoría de los números siguen la forma general, pero los incluí todos aquí para mostrar dónde está el problema.

El primer carácter es el carácter que se imprimirá.

. 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 la mayoría de los personajes, "<char-1>"1+O.sería un programa válido, quizás uno de los más cortos. Sin embargo, debido al hecho de que los caracteres se almacenan como puntos de código en la pila significa que muchos de ellos se pueden producir por multiplicación y suma, en cinco bytes o menos. Además, tenga en cuenta que l, $1, $2, $3, $4, $5, $6, $lson 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.

Menciones especiales:

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

(Pruébelo). Minkolang tiene la capacidad de modificar los caracteres en el cuadro de código, por lo que este programa hace que lo reemplace -al final ., lo cual es necesario para detener el programa. "N"1+d90pN.para Otrabajos de la misma manera.

4: lZIO.

(Pruébelo) lZ empuja los alfabetos en mayúsculas y minúsculas a la pila, y Iempuja la longitud de la pila, que es 52, precisamente el punto de código de "4". La mejor parte es que inicialmente estaba considerando la solución 4$3*O., que multiplica 4 y 13 para obtener 52, pero no pude porque tenía un 4, ¡así que terminé encontrando una solución más golfista de todos modos!

y: $1d*O.

(Pruébelo) d duplica la parte superior de la pila, por lo que lo que hace este código es empujarlo 11, duplicarlo y luego multiplicarlo. Hubiera sido una forma alternativa de escribir esto $12;O., que tiene el mismo número de bytes.

}: 53;O.

(Pruébelo) ; es exponenciación, por lo que hace 5 ^ 3 para obtener 125.

Groovy, 1019 bytes

Tenía una solución de Groovy diferente escrita (ver más abajo), pero después de enviarla, profundicé un poco más en los escapes de personajes, con la esperanza de encontrar una forma de acortar más el programa, y ​​descubrí que Groovy tiene un escape de caracteres octal que yo no sabía de Esto simplifica significativamente el código, hasta el punto de que desafortunadamente elimina la necesidad de casi todas las soluciones extravagantes que se me ocurrieron.

También parece casi idéntico a la solución Python 2 de Copper , hasta el punto de que básicamente parece que plagiado su trabajo. Ugh

Cada programa tiene la forma print'\<octal value>', excepto:

• p, r, i, n, t→ 'print''\<octal value>'(pero con la letra correspondiente de "imprimir" también reemplazado por el valor octal)
• 0- 9→print~-<next int>

Aquí está la lista completa de programas por personaje.

    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

Mi programa anterior, antes de descubrir que existen escapes octales. Mucho más interesante, OMI.

Cada programa tiene la forma print(--'<next char>'), excepto:

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

Aquí está la lista completa de programas para cada personaje:

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

En realidad , 383 382 381 bytes

1 byte gracias a Mego.

Para una referencia fácil, la primera columna es el código de caracteres, la segunda columna es el carácter y la tercera columna es el código.

El código para 0es un espacio ú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

Pruébalo en línea!

Sugerencias de golf son bienvenidas.

Fourier, 306 bytes, 1 DNP

Casi todos los programas siguen el patrón nadonde n es el código de caracteres de cada uno de los caracteres. Por ejemplo:

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

Pruébalo en línea!

Así que solo enumeraré las excepciones:

0 (cero)

Como el acumulador está preconfigurado a cero, podemos mostrar esto usando un solo carácter:

o

Pruébalo en línea!

1

Similar a cero, esto incrementa el acumulador para obtener 1.

^o

Pruébalo en línea!

5 5

El código ASCII para 5 es 53, así que tuve que solucionar esto:

6vo

Pruébalo en línea!

una

Debido a que aes la función de salida de caracteres, no hay otra forma de producir el carácter a, por lo que este es mi único NO PROGRAMA .

Vea todos los programas aquí

Matlab, 1238 1224 bytes, 2 DNP

El patrón principal es:

disp([<char code> ''])

Para los dígitos es un poco más corto:

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

Para los personajes []'es:

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

Los caracteres dsde dispse muestran usando fprintf( gracias @Stewie Griffin ); ipSin embargo, también pertenezco allí, así que estoy cambiando la cadena y usando eval:

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

()Sin embargo, ambos caracteres son necesarios para dispo eval, por lo que son DNP.

Para referencia toda la lista:

    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

Jalea (no 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Ọ

Esto imprime todos los caracteres del 32 al 126. El recuento de bytes se calcula con https://mothereff.in/byte-counter .

Pruébalo en línea!

Befunge-93, 530 bytes

La forma más fácil de generar un carácter, sin usar ese carácter, es calcular el valor ASCII y usar el ,comando (salida de caracteres) para representarlo. Por ejemplo,49*,@ genera el carácter de dólar (ASCII 36, 4 * 9). Sin embargo, esto rara vez es el más óptimo, ya que la mayoría de los valores requieren más de 3 bytes para calcular.

Otra forma de generar un número en 3 bytes es aprovechar el hecho de que el gcomando (get) en la primera celda del campo de juego generará el valor ASCII de g (se supone que una pila vacía se rellena con ceros, por lo que es leyendo el valor del campo de juego en 0,0). Así g1+,@te da h , y g1-,@te da f . Obviamente, esto funciona para una gama de compensaciones, y también son posibles operaciones distintas +y -también. Entonces, por ejemplo, g3/,@obtienes una cita doble.

Una variación de esto es preceder al gcomando con otro que deja todos los ceros en la pila. Entonces todavía estás leyendo un valor del campo de juego en 0,0, pero el personaje que se está leyendo ahora es diferente. Esto cuesta un byte más, pero le da acceso a muchos más valores. Por ejemplo, le 0g1-,@da una barra diagonal y le :g1+,@da un punto y coma. Otros prefijos viables incluyen *, +, -, >, \y _. Y de nuevo tenga en cuenta que otras operaciones son posibles: >g2*,@obtener una barra vertical.

Otra variación es preceder a gcon a 1, por lo que ahora ya no está leyendo desde 0,0, sino desde la celda en blanco en 0,1. En Befunge, las celdas vacías se inicializan con espacios de forma predeterminada, por lo que 1g,@obtiene un espacio y 1g1+,@un signo de exclamación.

Para los caracteres de dígitos, hay un truco más dudoso que podemos usar. En lugar de tratar de generarlos como caracteres, los generamos como números (un número pequeño es más fácil de generar que su equivalente ASCII). Entonces, por ejemplo, 11+.@le da 2 y, en particular, tenga en cuenta los casos especiales: .@para 0 y !.@para 1 . La parte dudosa de esto es que una salida numérica en Befunge incluye un espacio después del número, por lo que no es una salida de caracteres pura.

Otro truco dudoso que podemos usar es una variación de la gtécnica anterior. En lugar de limitarnos a los comandos Befunge para el prefijo, también podemos utilizar técnicamente cualquier personaje que no sea un comando Befunge. En la mayoría de los intérpretes se ignorará un comando no reconocido, por lo gque terminará leyendo el valor ASCII del carácter anterior. Esto nos permite generar la mayoría de los otros valores ASCII que de otra manera no podrían calcularse en 3 bytes. Como un ejemplo: Qg1+,@te da R .

Finalmente, hay tres casos especiales. No se puede generar una g en menos de 5 bytes, por lo que debemos recurrir a ella "f"1+,@. Una coma es el más complicado modificación dinámica, que requiere del campo de juego: 0g4-:80p @. Podríamos usar una técnica similar para evitar el carácter at, pero un truco más eficiente es usar el %comando (módulo) como terminador, es decir 88*,%. Cuando %se alcanza el no hay nada en la pila, por lo que el cálculo del módulo genera una división por cero, y en el intérprete de referencia esto terminará el programa.

A continuación se muestra la lista completa de programas, uno por línea.

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