Imprima todos los caracteres ASCII imprimibles sin usarlo

56

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{|}~
Pasatiempos de Calvin
fuente
Si en mi codificación de códigos 0x30 para, digamos, 日 en lugar de 0, ¿puedo suponer que los ASCII imprimibles son los 95 normales, menos 0, agregue 日?
Leaky Nun
44
¿Qué? Necesita usar ASCII imprimible. Eso es solo una regla.
Aficiones de Calvin
Creo que hay codificaciones que no tienen la representación exacta de 0x30 como0
Leaky Nun
@LeakyNun EBCDIC
TuxCrafting
2
@Tim No. No sigue la regla de independencia.
Aficiones de Calvin

Respuestas:

25

Python 2, 1075 1065 1043 1040 1039 bytes

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

  • 'print"\47"
  • 0a través 8print~-<N+1>
  • 9print-~8
  • \print'%c'%92
  • iexec'pr\151nt"\151"'
  • nexec'pri\156t"\156"'
  • pexec'\160rint"\160"'
  • rexec'p\162int"\162"'
  • texec'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!

Cobre
fuente
print~-<N+1>no funciona para 1. Usted ha dicho que trabaja para 0a 8.
haykam
77
@ Maní lo hace. El código en <angle brackets>no es código literal. Sustituir <N+1>con el valor literal de N+1; en este caso, el programa para 1sería print~-2. Vea la lista completa de programas.
Cobre
21

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

Loovjo
fuente
39cpara '? Además, se está olvidando de que un solo dígito puede ser ese número
Sp3000 el
1
@ Sp3000 no pueden porque eso incluiría el carbón que está produciendo en la entrada
Azul
Pero luego use 1)para 2etc. para guardar un byte allí
Luis Mendo
Lo siento, 1)era a lo que me refería, sí
Sp3000
Además, hayTXYZ
Sp3000
12

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
Michael Ehrenreich
fuente
11

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

Betseg
fuente
3
@ βετѧΛєҫαγ Probablemente porque se copió principalmente.
Aficiones de Calvin
8
@HelkaHomba Quiero decir, las constantes BF son básicamente las más cortas de lo que sé. Intentar hacerlo usted mismo en constantes ya establecidas no tiene sentido.
Loco
3
--[>-<---]>[<->--]<[->-<]>.Funciona para la salida +.
Dennis
3
@ Dennis Un poco de críticas más tarde:-----[[----<]>>-]<.
Sp3000
2
También+[+[+>]<<++++]>.
Sp3000 el
9

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
DJMcMayhem
fuente
@LuisMendo Sigo contando 297
DJMcMayhem
@LuisMendo también cuento 297.
Leaky Nun
Lo siento, mi error
Luis Mendo
9

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");}}
  • 0interface A{static void main(String[]a){System.out.print(1-1);}}
  • 1interface A{static void main(String[]a){System.out.print(3-2);}}
  • 2interface A{static void main(String[]a){System.out.print(3-1);}}
  • 3interface A{static void main(String[]a){System.out.print(4-1);}}
  • 4interface A{static void main(String[]a){System.out.print(5-1);}}
  • 5interface A{static void main(String[]a){System.out.print(6-1);}}
  • 6interface A{static void main(String[]a){System.out.print(7-1);}}
  • 7interface A{static void main(String[]a){System.out.print(8-1);}}
  • 8interface A{static void main(String[]a){System.out.print(9-1);}}
  • 9interface A{static void main(String[]a){System.out.print(8+1);}}
  • ;interface A{static void main(String[]a){System.out.print("\73")\u003B}}
  • Ainterface B{static void main(String[]a){System.out.print("\101");}}
  • Sinterface 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");}}
  • ainterf\u0061ce A{st\u0061tic void m\u0061in(String[]b){System.out.print("\141");}}
  • cinterfa\u0063e A{stati\u0063 void main(String[]a){System.out.print("\143");}}
  • dinterface A{static voi\u0064 main(String[]a){System.out.print("\144");}}
  • eclass A{public static void main(String[]a){Syst\u0065m.out.print("\145");}}
  • fclass A{public static void main(String[]a){System.out.print("\146");}}
  • ginterface 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");}}
  • minterface A{static void \u006Dain(String[]a){Syste\u006D.out.print("\155");}}
  • nclass A{public static void mai\u006E(Stri\u006Eg[]a){System.out.pri\u006Et("\156");}}
  • ointerface A{static v\u006Fid main(String[]a){System.\u006Fut.print("\157");}}
  • pinterface A{static void main(String[]a){System.out.\u0070rint("\160");}}
  • rclass A{public static void main(St\u0072ing[]a){System.out.p\u0072int("\162");}}
  • sinterface A{\u0073tatic void main(String[]a){Sy\u0073tem.out.print("\163");}}
  • tclass A{public s\u0074a\u0074ic void main(S\u0074ring[]a){Sys\u0074em.ou\u0074.prin\u0074("\164");}}
  • uinterface A{static void main(String[]a){System.console().printf("%c",117);}}
  • vinterface A{static \u0076oid main(String[]a){System.out.print("\166");}}
  • yinterface 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!

Cobre
fuente
2
Me encanta lo aleatorio class Bpara imprimirA
Tas
Me ganaste a eso. Ayer, al final del día, estaba escribiendo una respuesta para Java usando escapes Unicode también ... Ah, bueno, +1, respuesta bien escrita y solo 1 DNP no es tan malo como pensaba de antemano para Java. ;)
Kevin Cruijssen
2
Por cierto, existe la posibilidad de eliminar el DNP para usted si usa Java 8+ (en interfacelugar de la clase para que pueda eliminar el public) y si su sistema operativo tiene una consola incorporada, por lo que no tiene que usar System.out.print: interface A{static void main(String[]a){System.console().printf("%1",(char)117);}}Eclipse, IntelliJ y los compiladores en línea no tienen esta consola, lo que resulta en a NullPointerException.
Kevin Cruijssen
@KevinCruijssen ¡Gracias! Estoy trabajando en reelaborarlo ahora.
Cobre
n: Olvidé escaparprint
WeaponsGrade
7

> <> , 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;
Sp3000
fuente
7

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
Adán
fuente
1
Este formato es menos útil que el formato de las otras respuestas, en mi opinión
Leaky Nun
@LeakyNun ¿Quiere agruparlos por método? Hay bastantes excepciones.
Adám
2
No todos son ASCII imprimibles, por lo que técnicamente no son válidos. Pero voy a agregar una nota de que ASCII no imprimible está permitido para envíos no competitivos.
Aficiones de Calvin
@HelkaHomba Vaya, no noté ese requisito.
Adám
es mi nuevo smiley favorito
Lucas Trzesniewski
6

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.

Lynn
fuente
Para los escapes octales puede usar en ?\xxxlugar de "\xxx"1 byte cada uno.
Jordania
¿Por qué p 1+8y no p-~8?
Cyoce
@Cyoce Ruby interpreta eso como binario -, o algo así. :(
Lynn
@Jordan Noted, pero soy vago ... siéntase libre de hacer la edición / recuento n_n
Lynn
2
Puede hacer la mayoría de estos más cortos con putc 65=>A
histocrat
5

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
Anastasiya-Romanova 秀
fuente
5

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

Clamburger
fuente
@ jimmy23013 Vaya, leí mal la documentación.
Mego
Puede usar & | ^entre dos letras para generar todos los caracteres ascii imprimibles, excepto <?=|;.
jimmy23013
@ jimmy23013 Eso es una locura. ¡Justo cuando pensaba que había aprendido todas las peculiaridades de PHP!
Clamburger
1
Muchas de las soluciones de formulario estándar podrían optimizarse para guardar un byte con NOT binario en ~lugar de XOR, AND u OR. PHP puede usar más caracteres imprimibles como constantes, que solo letras.
Fabian Schmengler
1
@fschmengler Desafortunadamente, hasta donde puedo ver, eso requeriría el uso de ASCII extendido (o caracteres unicode cada vez más exóticos) que creo que no es válido para este desafío.
Clamburger
4

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.

Monja permeable
fuente
@Fatalize Gracias, actualizado.
Leaky Nun
4

> <> , 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;
DanTheMan
fuente
Sus ;usos ;. Además, estoy bastante seguro de que la mayoría de estos se pueden jugar al golf por error, y odefinitivamente es posible.
Sp3000
@ Sp3000 A menos que haya un intérprete que acepte ambos oy O, no veo cómo oes posible. ¿Y cómo terminar en un error sería más corto?
DanTheMan
ose puede hacer haciendo uso de p. Sin embargo, podría publicar por separado por error, porque probablemente habrá muchos patrones diferentes involucrados.
Sp3000
@ Sp3000 Sin embargo, arreglé el ;programa. ¡Gracias por señalar eso!
DanTheMan
4

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.

Martin Ender
fuente
4

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]

Rolf
fuente
2
El espacio es un carácter ASCII imprimible ("ASCII imprimible" se refiere al rango de 0x20 a 0x7E, inclusive), por lo que deberá incluirlo como 1 DNP a menos que pueda encontrar una manera de imprimirlo sin usar ningún espacio. Aparte de eso, incluya el puntaje del programa.
Martin Ender
4

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
Martin Ender
fuente
Con la nueva versión de Retina es posible imprimir todas las letras (incluso T) con cuatro bytes usando $ L y $ u ... Todavía no pude encontrar una manera de imprimir el backtick sin usarlo, ¿crees que es posible?
Leo
@Leo No, no lo creo. He tenido la intención de agregar otro operador binario a la sintaxis de sustitución que sería la expansión de rango, lo que resolvería el problema. Sin embargo, necesito descubrir exactamente cómo quiero implementarlo. Otra opción sería alguna característica de sintaxis de sustitución para trabajar con puntos de código.
Martin Ender
3

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

Azul
fuente
3

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.

Neil
fuente
"x" también necesita un manejo especial. Además, use alert(atob`XA`)"\" para guardar algunos bytes.
GOTO 0
@ GOTO0 Ugh, no puedo creer que lo haya olvidado x.
Neil
1
Javascript permite \uescapes en el código fuente? Genial
Cyoce
@Cyoce: en identificadores, sí, en general, no.
Bergi
Los escapes @Bergi Unicode se procesan primero, por lo que puede escribir su fuente completa en términos de escapes Unicode si lo desea, mientras que los escapes hexadecimales solo funcionan dentro de cadenas.
Neil
3

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.

Emigna
fuente
3

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

jimmy23013
fuente
3

Perl 6: 921 bytes

Traducción de la solución Python.

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

  • sput "\x73"
  • aput "\x61"
  • yput "\x79"

  • "\x20".say

  • "say chr 34
  • \say chr 92
  • xsay chr 120
  • 0say 1-1
  • 1say 3-2
  • 2a 9say <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;
smls
fuente
@sch En Perl 5 eso funcionaría, pero intenté hacerlo en Perl 6, donde sayse requiere el espacio posterior y las secuencias de escape octal se escriben como \o77. Siéntase libre de publicar una solución Perl 5 por separado ... :)
smls
Lo siento, me perdí la parte de Perl 6 en tu respuesta.
sch
3

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

Laikoni
fuente
1
Con nuevas líneas opcionales permitidas, podemos obtener dígitos como este: main=print$1-1etc.
Christian Sievers
Su programa p usa p (pero se puede solucionar fácilmente con succ)
Christian Sievers
2

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
Level River St
fuente
¿Por qué no usar V.48para 0?
Leaky Nun
@LeakyNun 9 bytes guardados, ¡gracias!
Level River St el
Woah, ¿los comandos V.y P.siempre han estado allí?
Decaimiento Beta
@ βετѧΛєҫαγ Sí, pero el editor las expande a las palabras completas VDU e IMPRIMIR después de escribir (pero se interpretan sin expansión en la línea de comandos BASIC). La mayoría de las letras mayúsculas seguidas por .se expandirán en una palabra clave. Este desafío es estricto sobre el uso de ASCII no imprimible, pero podría decirse que con otros desafíos se podría decir que las palabras clave simbólicas (ascii 127-255) fueron un byte. Dicho esto, nunca he intentado ese argumento, y generalmente doy ambas puntuaciones.
Level River St el
@LevelRiverSt Ya veo
Beta Decay
2

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.

El'endia Starman
fuente
2

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- 9print~-<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, nSystem.out<<--'<next char>'
  • t'prin\u0074'(--'u')
  • (print'\u0028'
  • )print'\u0029'
  • 0- 9print~-<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(++'}')
M. Justin
fuente
2

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.

Monja permeable
fuente
:en 5:9P2*c
Mego
@Mego Gracias, agregó.
Leaky Nun
2

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í

Decaimiento Beta
fuente
2

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
pajonk
fuente
¿Funciona algo como [100 105 115 112](char-codes) disp?
Leaky Nun
¿Qué quieres decir exactamente? disp([100 105 115 112])tampoco producirá una cadena eval([100 105 115 112]).
pajonk
Se puede utilizar fprintfpara ans d s: fprintf([115,'']). Guarda 2x7 bytes =) No será una presentación ganadora, pero oye: 14 bytes son 14 bytes ,,,
Stewie Griffin
Además: disp([0 ''])contiene un espacio. disp([0,''])no lo hace
Stewie Griffin
@StewieGriffin Gracias, me perdí el espacio. Además, gracias por el truco con fprintf.
pajonk
2

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!

Soren
fuente
1
No creo que esta sea una respuesta válida. En primer lugar, no se le permite tomar una entrada, y en segundo lugar, este es un programa, no 95 programas. El desafío diceIn a programming language of your choice, write 95 programs, each of which outputs a different one of the 95 printable ASCII characters without that character occurring anywhere in the program.
DJMcMayhem
@DJMcMayhem Ok, cambiaré eso
Soren
DJ es correcto. Esto es descaradamente inválido.
Aficiones de Calvin
@HelkaHomba, ¿mi byte cuenta el total de todos los programas?
Soren
1
¡Gracias por arreglarlo y bienvenido al sitio! Espero que lo disfrutes aquí. Además, para que lo sepas, Jelly usa una página de códigos personalizada , por lo que en este caso es realmente 406 caracteres, aunque sería 503 en UTF-8.
DJMcMayhem
2

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*,@
James Holderness
fuente