Imprima todos os caracteres ASCII imprimíveis sem usá-lo

56

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

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

print(chr(80))

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

print(chr(112))

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

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

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

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

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

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

Regras

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

    • Nota: Essa regra parece necessária, mas há muitos idiomas com codificações diferentes e tenho certeza de que seria legal ver as respostas para elas. Portanto, você pode violar essa regra , pode usar os caracteres que quiser, mas sua resposta se tornará não competitiva e não poderá vencer.
  • Os programas devem ser reais, completos programas , de acordo com as convenções padrão do seu idioma. Funções e snippets REPL não são permitidos.

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

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

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

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

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

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

 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~
Passatempos de Calvin
fonte
Se na minha codificação 0x30 códigos para, digamos, 日 em vez de 0, posso assumir que o ASCII imprimível seja o 95 normal, menos 0, adicione 日?
Leaky Nun
4
O que? Você precisa usar ASCII imprimível. Isso é apenas uma regra.
Hobbies de Calvin
Eu acredito que há codificações que não têm a representação exata do 0x30 como0
Leaky Nun
@LeakyNun EBCDIC
TuxCrafting
2
@ Tim Não. Não segue a regra da independência.
Hobbies de Calvin

Respostas:

25

Python 2, 1075 1065 1043 1040 1039 bytes

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

  • 'print"\47"
  • 0através de 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 referência e facilidade de teste, eis a lista completa de programas, separados por nova linha.

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

Testar:

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

-1 bytes graças a @ Sp3000!

Cobre
fonte
print~-<N+1>não funciona para 1. Você disse que ele trabalha para 0a 8.
haykam
7
@Peanut Sim. O código <angle brackets>não é literal. Substitua <N+1>pelo valor literal de N+1; neste caso, o programa para 1seria print~-2. Veja a lista completa de programas.
Copper
21

CJam, 269 bytes

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

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

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

Loovjo
fonte
39cpara '? Além disso, você está esquecendo que um dígito pode ser apenas esse número
SP3000
11
@ SP3000 eles não podem porque isso iria incluir o caractere que você está produzindo na entrada
azul
Mas, em seguida, usar 1)para 2etc para salvar um byte não
Luis Mendo
Desculpe, 1)era o que eu queria dizer sim
SP3000
Além disso, háTXYZ
SP3000
12

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

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

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

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

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

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

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

char  code
      hX'X5B&P[hT!^)7CC)7VX5t#PZ!C!B
!     hX'X5B&P[hS ^)7CC)7VX5r"PZ B A
"     hX'X5B&P[hS!^)7CC)7VX5q#PZ C B
#     hX'X5B&P[hS ^)7CC)7VX5p"PZ B A
$     hX'X5B&P[hS ^)7CC)7VX5w"PZ B A
%     hX'X5B&P[hS ^)7CC)7VX5v"PZ B A
&     hX#X5B"P[hS ^)7CC)7VX5u"PZ B A
'     hX#X5B"P[hS ^)7CC)7VX5t"PZ B A
(     hX'X5B&P[hS ^)7CC)7VX5{"PZ B A
)     hi'X5B&P[h!!X%BBHP^$!P_17C!?C17C!?hiBX5@@PZ2@2A
*     hX'X5B&P[hS ^)7CC)7VX5y"PZ B A
+     hX'X5B&P[hS ^)7CC)7VX5x"PZ B A
,     hX'X5B&P[hT ^)7CC)7VX5x"PZ!B!A
-     hX'X5B&P[hS ^)7CC)7VX5~"PZ B A
.     hX'X5B&P[hS ^)7CC)7VX5}"PZ B A
/     hX'X5B&P[hS ^)7CC)7VX5|"PZ B A
0     hX'X5B&P[hS ^)7CC)7VX5c"PZ B A
1     hX'X5B&P[hS ^)7CC)7VX5b"PZ B A
2     hX'X5B&P[hS ^)7CC)7VX5a"PZ B A
3     hX'X5B&P[hS ^)7CC)7VX5`"PZ B A
4     hX'X5B&P[hS ^)7CC)7VX5g"PZ B A
5     h;'X%[AP[h=S^)7CC)7VX%7"PZ _ ^
6     hX'X5B&P[hS ^)7CC)7VX5e"PZ B A
7     hX'X5B&P[hS _)?CC)?WX5d"PZ B A
8     hX'X5B&P[hS ^)7CC)7VX5k"PZ B A
9     hX'X5B&P[hS ^)7CC)7VX5j"PZ B A
:     hX'X5B&P[hS ^)7CC)7VX5i"PZ B A
;     hX'X5B&P[hS ^)7CC)7VX5h"PZ B A
<     hX'X5B&P[hS ^)7CC)7VX5o"PZ B A
=     hX'X5B&P[hS ^)7CC)7VX5n"PZ B A
>     hX'X5B&P[hS ^)7CC)7VX5m"PZ B A
?     hX'X5B&P[hS ^)7CC)7VX5l"PZ B A

@     hX'X5B&P[h` ^)7CC)7VX5 "PZ-B-A
A     hX'X5B&P[h`!^)7CC)7VX5!#PZ-C-B
B     h['X5A&P[h`"^)7CC)7VX5" PZ-D-C
C     hX'X5B&P_h` ^)5GG)5VX5#"PZ-B-A
D     hX'X5B&P[h` ^)7CC)7VX5$"PZ-B-A
E     hX'X5B&P[h` ^)7CC)7VX5%"PZ-B-A
F     hX'X5B&P[h` ^)7CC)7VX5&"PZ-B-A
G     hX'X5B&P[h` ^)7CC)7VX5'"PZ-B-A
H     hX'X5B&P[h` ^)7CC)7VX5("PZ-B-A
I     hX'X5B&P[h` ^)7CC)7VX5)"PZ-B-A
J     hX'X5B&P[h` ^)7CC)7VX5*"PZ-B-A
K     hX'X5B&P[h` ^)7CC)7VX5+"PZ-B-A
L     hX'X5B&P[h` ^)7CC)7VX5,"PZ-B-A
M     hX'X5B&P[h` ^)7CC)7VX5-"PZ-B-A
N     hX'X5B&P[h` ^)7CC)7VX5."PZ-B-A
O     hX'X5B&P[h` ^)7CC)7VX5/"PZ-B-A
P     hj'X5B&`[[[[[[[[h` ^)7CC)7VX50"`ZZZZZZZZ-B-A
Q     hX'X5B&P[h` ^)7CC)7VX51"PZ-B-A
R     hX'X5B&P[h` ^)7CC)7VX52"PZ-B-A
S     hX'X5B&P[h` ^)7CC)7VX53"PZ-B-A
T     hX'X5B&P[h` ^)7CC)7VX54"PZ-B-A
U     hX'X5B&P[h` ^)7CC)7VX55"PZ-B-A
V     hX'X5B&P[h` _)?CC)?WX56"PZ B A
W     hX'X5B&P[h` ^)7CC)7VX57"PZ-B-A
X     _TYhe'WWWQWWWa5B&P[hSS^)7CC)7CC5_C5 @PZ u t
Y     hX'X5B&P[h` ^)7CC)7VX59"PZ-B-A
Z     _WTYhzBX5 @Phe'WPWQWWWa5B&P[hSS^)7CC)7X u t
[     hX'X5B&P_h` ^)5GG)5VX5;"PZ-B-A
\     hX'X5B&P[h` ^)7CC)7VX5<"PZ-B-A
]     hX'X5B&P[h` ^)7CC)7VX5="PZ-B-A
^     hX'X5B&P[h` _)?CC)?WX5>"PZ-B-A
_     hX'X5B&P[h` ^)7CC)7VX5?"PZ-B-A

`     hX'X5B&P[hS ^)7CC)7VX53"PZ B A
a     hX'X5B&P[hS ^)7CC)7VX52"PZ B A
b     hX'X5B&P[hS ^)7CC)7VX51"PZ B A
c     hX'X5B&P[hS ^)7CC)7VX50"PZ B A
d     hX'X5B&P[hS ^)7CC)7VX57"PZ B A
e     hX'X5B&P[hS ^)7CC)7VX56"PZ B A
f     hX'X5B&P[hS ^)7CC)7VX55"PZ B A
g     hX'X5B&P[hS ^)7CC)7VX54"PZ B A
h     _WWX5b'5B&P[WX5S P^)7CC)7VX5;"PZ B A
i     hX'X5B&P[hS ^)7CC)7VX5:"PZ B A
j     hX'X5B&P[hS ^)7CC)7VX59"PZ B A
k     hX'X5B&P[hS ^)7CC)7VX58"PZ B A
l     hX'X5B&P[hS ^)7CC)7VX5?"PZ B A
m     hX'X5B&P[hS ^)7CC)7VX5>"PZ B A
n     hX'X5B&P[hS ^)7CC)7VX5="PZ B A
o     hX'X5B&P[hS ^)7CC)7VX5<"PZ B A
p     hX'X5B&P[hS ^)7CC)7VX5#"PZ B A
q     hX'X5B&P[hS ^)7CC)7VX5""PZ B A
r     hX'X5B&P[hS ^)7CC)7VX5!"PZ B A
s     hX'X5B&P[hS ^)7CC)7VX5 "PZ B A
t     hX'X5B&P[hS ^)7CC)7VX5'"PZ B A
u     hX'X5B&P[hS ^)7CC)7VX5&"PZ B A
v     hX'X5B&P[hS ^)7CC)7VX5%"PZ B A
w     hX'X5B&P[hS ^)7CC)7VX5$"PZ B A
x     hX'X5B&P[hS ^)7CC)7VX5+"PZ B A
y     hX'X5B&P[hS ^)7CC)7VX5*"PZ B A
z     hX'X5B&P[hS ^)7CC)7VX5)"PZ B A
{     hX'X5B&P[hS ^)7CC)7VX5("PZ B A
|     hX'X5B&P[hS ^)7CC)7VX5/"PZ B A
}     hX'X5B&P[hS ^)7CC)7VX5."PZ B A
~     hX'X5B&P[hS ^)7CC)7VX5-"PZ B A
Michael Ehrenreich
fonte
11

Brainfuck, 1770 1710 1703 1686 bytes

60 bytes salvos pelo Dennis
17 bytes salvos pelo Sp3000

DNP: 46 ( .)

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

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

betseg
fonte
3
@ βετѧΛєҫαγ Provavelmente, uma vez que a maioria foi copiada.
Hobbies de Calvin
8
@HelkaHomba Quero dizer, as constantes BF são basicamente as mais curtas do que eu sei. Tentar fazer você mesmo em constantes já estabelecidas é inútil.
Insano
3
--[>-<---]>[<->--]<[->-<]>.trabalha para saída +.
Dennis
3
@Dennis Um pouco de -----[[----<]>>-]<.
contundência
2
Também+[+[+>]<<++++]>.
Sp3000 28/08/16
9

MATL, 305, 302, 300 297 bytes

Cada programa é assim:

33c
34c
35c
....

Exceto por

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

    O
    l
    H
    I
    K
    4Q
    5Q
    6Q
    7Q
    8Q
    
  • 'c'. Este programa é

    'C'k
    
  • espaço. Isto é

    0c
    

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

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

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

0c
33c
34c
35c
36c
37c
38c
39c
40c
41c
42c
43c
44c
45c
46c
47c
O
l
H
I
K
4Q
5Q
6Q
7Q
8Q
58c
59c
60c
61c
62c
63c
64c
65c
66c
67c
68c
69c
70c
71c
72c
73c
74c
75c
76c
77c
78c
79c
80c
81c
82c
83c
84c
85c
86c
87c
88c
89c
90c
91c
92c
93c
94c
95c
96c
97c
98c
'C'k
100c
101c
102c
103c
104c
105c
106c
107c
108c
109c
110c
111c
112c
113c
114c
115c
116c
117c
118c
119c
120c
121c
122c
123c
124c
125c
126c
DJMcMayhem
fonte
@LuisMendo ainda estou contando 297
DJMcMayhem
@LuisMendo Também conto 297.
Leaky Nun
Desculpe, meu erro
Luis Mendo
9

Java 8, 6798 6582 6577 bytes

suspiro

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

Agora sem DNPs! Obrigado, Kevin Cruijssen!

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

  • espaço → interface\tA{static\tvoid\tmain(String[]a){System.out.print("\40");}}(mas com os \ts substituídos por guias não processadas)
  • "interface A{static void main(String[]a){System.out.print('\42');}}
  • (interface A{static void main\u0028String[]a){System.out.print\u0028"\50");}}
  • )interface A{static void main(String[]a\u0029{System.out.print("\51"\u0029;}}
  • .interface A{static void main(String[]a){System\u002Eout\u002Eprint("\56");}}
  • 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

Ufa

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

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

interface    A{static    void    main(String[]a){System.out.print("\40");}}
interface A{static void main(String[]a){System.out.print("\41");}}
interface A{static void main(String[]a){System.out.print('\42');}}
interface A{static void main(String[]a){System.out.print("\43");}}
interface A{static void main(String[]a){System.out.print("\44");}}
interface A{static void main(String[]a){System.out.print("\45");}}
interface A{static void main(String[]a){System.out.print("\46");}}
interface A{static void main(String[]a){System.out.print("\47");}}
interface A{static void main\u0028String[]a){System.out.print\u0028"\50");}}
interface A{static void main(String[]a\u0029{System.out.print("\51"\u0029;}}
interface A{static void main(String[]a){System.out.print("\52");}}
interface A{static void main(String[]a){System.out.print("\53");}}
interface A{static void main(String[]a){System.out.print("\54");}}
interface A{static void main(String[]a){System.out.print("\55");}}
interface A{static void main(String[]a){System\u002Eout\u002Eprint("\56");}}
interface A{static void main(String[]a){System.out.print("\57");}}
interface A{static void main(String[]a){System.out.print(1-1);}}
interface A{static void main(String[]a){System.out.print(3-2);}}
interface A{static void main(String[]a){System.out.print(3-1);}}
interface A{static void main(String[]a){System.out.print(4-1);}}
interface A{static void main(String[]a){System.out.print(5-1);}}
interface A{static void main(String[]a){System.out.print(6-1);}}
interface A{static void main(String[]a){System.out.print(7-1);}}
interface A{static void main(String[]a){System.out.print(8-1);}}
interface A{static void main(String[]a){System.out.print(9-1);}}
interface A{static void main(String[]a){System.out.print(8+1);}}
interface A{static void main(String[]a){System.out.print("\72");}}
interface A{static void main(String[]a){System.out.print("\73")\u003B}}
interface A{static void main(String[]a){System.out.print("\74");}}
interface A{static void main(String[]a){System.out.print("\75");}}
interface A{static void main(String[]a){System.out.print("\76");}}
interface A{static void main(String[]a){System.out.print("\77");}}
interface A{static void main(String[]a){System.out.print("\100");}}
interface B{static void main(String[]a){System.out.print("\101");}}
interface A{static void main(String[]a){System.out.print("\102");}}
interface A{static void main(String[]a){System.out.print("\103");}}
interface A{static void main(String[]a){System.out.print("\104");}}
interface A{static void main(String[]a){System.out.print("\105");}}
interface A{static void main(String[]a){System.out.print("\106");}}
interface A{static void main(String[]a){System.out.print("\107");}}
interface A{static void main(String[]a){System.out.print("\110");}}
interface A{static void main(String[]a){System.out.print("\111");}}
interface A{static void main(String[]a){System.out.print("\112");}}
interface A{static void main(String[]a){System.out.print("\113");}}
interface A{static void main(String[]a){System.out.print("\114");}}
interface A{static void main(String[]a){System.out.print("\115");}}
interface A{static void main(String[]a){System.out.print("\116");}}
interface A{static void main(String[]a){System.out.print("\117");}}
interface A{static void main(String[]a){System.out.print("\120");}}
interface A{static void main(String[]a){System.out.print("\121");}}
interface A{static void main(String[]a){System.out.print("\122");}}
interface A{static void main(\u0053tring[]a){\u0053ystem.out.print("\123");}}
interface A{static void main(String[]a){System.out.print("\124");}}
interface A{static void main(String[]a){System.out.print("\125");}}
interface A{static void main(String[]a){System.out.print("\126");}}
interface A{static void main(String[]a){System.out.print("\127");}}
interface A{static void main(String[]a){System.out.print("\130");}}
interface A{static void main(String[]a){System.out.print("\131");}}
interface A{static void main(String[]a){System.out.print("\132");}}
interface A{static void main(String...a){System.out.print("\133");}}
interface A{static void main(String[]a){System.out.print((char)92);}}
interface A{static void main(String...a){System.out.print("\135");}}
interface A{static void main(String[]a){System.out.print("\136");}}
interface A{static void main(String[]a){System.out.print("\137");}}
interface A{static void main(String[]a){System.out.print("\140");}}
interf\u0061ce A{st\u0061tic void m\u0061in(String[]b){System.out.print("\141");}}
interface A{static void main(String[]a){System.out.print("\142");}}
interfa\u0063e A{stati\u0063 void main(String[]a){System.out.print("\143");}}
interface A{static voi\u0064 main(String[]a){System.out.print("\144");}}
class A{public static void main(String[]a){Syst\u0065m.out.print("\145");}}
class A{public static void main(String[]a){System.out.print("\146");}}
interface A{static void main(Strin\u0067[]a){System.out.print("\147");}}
interface A{static void main(String[]a){System.out.print("\150");}}
\u0069nterface A{stat\u0069c vo\u0069d ma\u0069n(Str\u0069ng[]a){System.out.pr\u0069nt("\151");}}
interface A{static void main(String[]a){System.out.print("\152");}}
interface A{static void main(String[]a){System.out.print("\153");}}
interface A{static void main(String[]a){System.out.print("\154");}}
interface A{static void \u006Dain(String[]a){Syste\u006D.out.print("\155");}}
class A{public static void mai\u006E(Stri\u006Eg[]a){System.out.print("\156");}}
interface A{static v\u006Fid main(String[]a){System.\u006Fut.print("\157");}}
interface A{static void main(String[]a){System.out.\u0070rint("\160");}}
interface A{static void main(String[]a){System.out.print("\161");}}
class A{public static void main(St\u0072ing[]a){System.out.p\u0072int("\162");}}
interface A{\u0073tatic void main(String[]a){Sy\u0073tem.out.print("\163");}}
class A{public s\u0074a\u0074ic void main(S\u0074ring[]a){Sys\u0074em.ou\u0074.prin\u0074("\164");}}
interface A{static void main(String[]a){System.console().printf("%c",117);}}
interface A{static \u0076oid main(String[]a){System.out.print("\166");}}
interface A{static void main(String[]a){System.out.print("\167");}}
interface A{static void main(String[]a){System.out.print("\170");}}
interface A{static void main(String[]a){S\u0079stem.out.print("\171");}}
interface A{static void main(String[]a){System.out.print("\172");}}
interface A\u007Bstatic void main(String[]a)\u007BSystem.out.print("\173");}}
interface A{static void main(String[]a){System.out.print("\174");}}
interface A{static void main(String[]a){System.out.print("\175");\u007D\u007D
interface A{static void main(String[]a){System.out.print("\176");}}

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

Para testar, crie um novo diretório e coloque o código acima em um arquivo nomeado printablesnesse diretório. Em seguida, execute o seguinte script Bash:

#!/bin/bash
split -l 1 printables
for i in x*; do
  mkdir z$i
  mv $i z$i/A.java
done
mv zxbh/A.java zxbh/B.java
for i in zx*; do
  javac $i/[AB].java
  if ! java -cp $i A 2> /dev/null; then
    java -cp $i B
  fi
done
rm -r zx*

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

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

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

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

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

Cobre
fonte
2
Eu amo o aleatório class Bpara impressãoA
Tas
Você chegou antes de mim. Ontem, no final do dia, eu estava escrevendo uma resposta para Java usando escapes unicode também. Ah, bem, +1, resposta bem escrita e apenas 1 DNP não é tão ruim quanto eu pensava anteriormente sobre Java. ;)
Kevin Cruijssen
2
Aliás, existe a possibilidade de remover o DNP para u se você usa Java 8+ (em interfacevez da classe para remover o public) e se o seu sistema operacional possui um console integrado, para que você não precise usar System.out.print: interface A{static void main(String[]a){System.console().printf("%1",(char)117);}}Eclipse, IntelliJ e compiladores on-line ainda não possuem esse console, resultando em um NullPointerException.
Kevin Cruijssen
@KevinCruijssen Thanks! Estou trabalhando em reformulá-lo agora.
Copper
n: Esqueceu-se de escaparprint
WeaponsGrade
7

> <> , 443 437 bytes

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

  • [num][num]*o;: Multiplicação de dois números e, em seguida, imprima o resultado como um caractere com oe pare com ;. > <> dígitos chegam a 15, ou seja 0123456789abcdef.
    • Da mesma forma [num][num]-n;, que leva a diferença de dois números e sai como um número com n.
  • '-o[invalid char]: > <> é toroidal; portanto, quando o ponteiro de instrução chega ao final de uma linha, ele volta ao início. Nesse caso, isso faz com que o código seja executado duas vezes, ou seja '-o[char]'-o[char]. A primeira '-o[char]'parte envia três caracteres para a pilha, -calcula 'o' - [char]e ogera o resultado como um caractere. > <> então ocorre um erro quando é atingido [char], devido a um comando não reconhecido ou ao aparecer uma pilha vazia.

    • Da mesma forma '-n[invalid char], que sai como um número.
    • Da mesma forma '[num][op]o[invalid char], o que se aplica [op]com [num]on [char], com erro no char. Por exemplo, '2+oJsaídas L, que são duas a mais que J.
    • 'código é "-oH, usando em "vez disso.
    • -código é '%oB, usando em %vez disso.
  • ln;: Empurre o comprimento da pilha, produza como num e depois para, dando 0. Da mesma forma lln;para 1e 'ln;para 3.

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

      '-oO
!     '-oN
"     '-oM
#     '-oL
$     '-oK
%     '-oJ
&     '-oI
'     "-oH
(     '-oG
)     '-oF
*     '-oE
+     '-oD
,     '-oC
-     '%oB
.     '-oA
/     '-o@
0     ln;
1     lln;
2     '-o=
3     'ln;
4     '-o;
5     61-n;
6     '-nh
7     '-ng
8     4|n+
9     3|n*
:     '1-o;
;     '6-oA
<     6a*o;
=     '2+o;
>     '3+o;
?     79*o;
@     8|o*
A     '-o.
B     '-o-
C     '-o,
D     '-o+
E     '-o*
F     '-o)
G     '-o(
H     89*o;
I     '1-oJ
J     '-o%
K     '-o$
L     '2+oJ
M     7b*o;
N     '-o!
O     '5+oJ
P     8a*o;
Q     9|o*
R     '8+oJ
S     '9+oJ
T     7c*o;
U     'b+oJ
V     'c+oJ
W     'd+oJ
X     8b*o;
Y     'f+oJ
Z     9a*o;
[     7d*o;
\     'c-oh
]     'b-oh
^     'a-oh
_     '9-oh
`     8c*o;
a     '7-oh
b     7e*o;
c     9b*o;
d     a|o*
e     '3-oh
f     '2-oh
g     '1-oh
h     '2-oj
i     8d*o;
j     '2+oh
k     '3+oh
l     9c*o;
m     '5+oh
n     ab*o;
o     '1-:00p
p     8e*o;
q     '3-ot
r     '2-ot
s     '1-ot
t     '1+os
u     9d*o;
v     '2+ot
w     '3+ot
x     ac*o;
y     b|o*
z     '6+ot
{     '7+ot
|     '8+ot
}     '9+ot
~     9e*o;
Sp3000
fonte
7

Dyalog APL , 527 522 bytes

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

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

''      space: extract one char from an empty string
THIS    hash: this namespace
1↓⍕÷2   period: the first char after stripping one char from 1÷2, i.e. 0.5
⊃⍬       zero: extract one number from an empty numeric list
≢#       one: tally the root namespace
⍴⍬⍬      two: count two empty lists
WX      three: default "Window Expose" setting
×⍨2      four: 2×2
6-1      five: 6-1
!3       six: 3!
6+1      seven: 6+1
2*3      eight: 2³
3*2      nine: 3²
⊃⎕a      A: first character (Dyalog system names are case insensitive)
2⊃⎕A    
          B-Y: n'th character
25⊃⎕A   ⍝
⊃⌽⎕A    ⍝ Z: last character

Aqui está a lista completa:

''
205⊃⎕AV
216⊃⎕AV
THIS
62⊃⎕AV
13⊃⎕AV
219⊃⎕AV
14⊃⎕AV
186⊃⎕AV
249⊃⎕AV
181⊃⎕AV
170⊃⎕AV
195⊃⎕AV
169⊃⎕AV
1↓⍕÷2
157⊃⎕AV
⊃⍬
≢#
⍴⍬ 
WX
×⍨2
6-1
!3
6+1
2*3
3*2
241⊃⎕AV
194⊃⎕AV
161⊃⎕AV
163⊃⎕AV
165⊃⎕AV
173⊃⎕AV
232⊃⎕AV
⊃⎕a
2⊃⎕A
3⊃⎕A
4⊃⎕A
5⊃⎕A
6⊃⎕A
7⊃⎕A
8⊃⎕A
9⊃⎕A
10⊃⎕A
11⊃⎕A
12⊃⎕A
13⊃⎕A
14⊃⎕A
15⊃⎕A
16⊃⎕A
17⊃⎕A
18⊃⎕A
19⊃⎕A
20⊃⎕A
21⊃⎕A
22⊃⎕A
23⊃⎕A
24⊃⎕A
25⊃⎕A
26⊃⎕A
156⊃⎕AV
159⊃⎕AV
250⊃⎕AV
236⊃⎕AV
17⊃⎕AV
238⊃⎕AV
18⊃⎕AV
19⊃⎕AV
20⊃⎕AV
21⊃⎕AV
22⊃⎕AV
23⊃⎕AV
24⊃⎕AV
25⊃⎕AV
26⊃⎕AV
27⊃⎕AV
28⊃⎕AV
29⊃⎕AV
30⊃⎕AV
31⊃⎕AV
32⊃⎕AV
33⊃⎕AV
34⊃⎕AV
35⊃⎕AV
36⊃⎕AV
37⊃⎕AV
38⊃⎕AV
39⊃⎕AV
40⊃⎕AV
41⊃⎕AV
42⊃⎕AV
43⊃⎕AV
124⊃⎕AV
193⊃⎕AV
126⊃⎕AV
176⊃⎕AV
Adão
fonte
11
Este formato é menos útil do que o formato das outras respostas, na minha opinião
Leaky Nun
@LeakyNun Você pretende agrupá-los por método? Existem algumas exceções.
Adám 21/08/16
2
Nem todos são ASCII imprimíveis, portanto tecnicamente inválidos. Mas vou acrescentar que o ASCII não imprimível é permitido para envios não competitivos.
Hobbies de Calvin
@HelkaHomba Ops, eu não percebi esse requisito.
Adám 21/08/16
é o meu novo emoticon favorito
Lucas Trzesniewski
6

Ruby, 869 bytes

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

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

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

puts"\xx"     (2 digit octal code)

Restam onze casos especiais:

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

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

Lynn
fonte
Para as fugas octais, você pode usar em ?\xxxvez de "\xxx"1 byte cada.
Jordânia
Por que p 1+8e não p-~8?
Cyoce 21/08/16
@Cyoce Ruby interpreta isso como binário -, ou algo assim. :(
Lynn
@Jordan Notável, mas eu sou preguiçoso ... sinta-se livre para fazer o n_n editar / recontagem
Lynn
2
Você pode fazer a maioria destes mais curtos com putc 65=>A
histocrat 28/08
5

WolframAlpha , 368 bytes

Formato geral:

u+<character code in hexadecimal>

Exceções:

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

Aqui está a lista completa:

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

PHP ( 891 680 674 bytes, 2 0 DNP)

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


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

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

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

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

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


Exceções:

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

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

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


Ponto:

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

Clamburger
fonte
@ jimmy23013 Opa, eu li errado a documentação.
Mego
Você pode usar & | ^entre duas letras para gerar todos os caracteres ascii imprimíveis, exceto <?=|;.
precisa saber é o seguinte
@ jimmy23013 Isso é loucura. Apenas quando eu pensei que tinha aprendido todas as peculiaridades do PHP!
Clamburger
11
muitas das soluções de formulário padrão podem ser otimizadas para salvar um byte com o binário NOT em ~vez de XOR, AND ou OR. O PHP pode usar mais caracteres imprimíveis como constantes do que apenas letras.
Fabian Schmengler
11
@fschmengler Infelizmente, até onde posso ver, isso exigiria o uso de ASCII estendido (ou caracteres unicode cada vez mais exóticos) que, acredito, não são válidos para esse desafio.
Clamburger
4

Braquilog , 546 477 bytes

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

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

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

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


Explicação

@P é esta sequência:

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

que contém todos os ASCII imprimíveis.

Freira Furada
fonte
@Fatalize Obrigado, atualizado.
Leaky Nun
4

> <> , 531 bytes

Os programas assumem duas formas principais:

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

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

Exceções:

" b3*1+o; Would be "!"1+o; normally
0 11-n; n outputs as a number
1 22/n;
2-9 #1+n;
; ":"1+o* Ends in an error

Lista completa:

! b3*o;
" b3*1+o;
# 57*o;
$ 66*o;
% "$"1+o;
& "%"1+o;
' d3*o;
( a4*o;
) "("1+o;
* ")"1+o;
+ ","1-o;
, b4*o;
- 95*o;
. "-"1+o;
/ "."1+o;
0 11-n;
1 22/n;
2 11+n;
3 21+n;
4 31+n;
5 41+n;
6 51+n;
7 61+n;
8 71+n;
9 81+n;
: "9"1+o;
; ":"1+o*
< a6*o;
= "<"1+o;
> "="1+o;
? 97*o;
@ 88*o;
A d5*o;
B b6*o;
C "B"1+o;
D "C"1+o;
E "D"1+o;
F a7*o;
G "F"1+o;
H 98*o;
I "H"1+o;
J "D"1+o;
K e5*o;
L "K"1+o;
M b7*o;
N d6*o;
O "D"1+o;
P a8*o;
Q 99*o;
R "Q"1+o;
S "R"1+o;
T c7*o;
U "T"1+o;
V "U"1+o;
W "V"1+o;
X b8*o;
Y "X"1+o;
Z a9*o;
[ c7*o;
\ "["1+o;
] "\"1+o;
^ "]"1+o;
_ "^"1+o;
` c8*o;
a "`"1+o;
b e7*o;
c b9*o;
d aa*o;
e "d"1+o;
f "e"1+o;
g "g"1+o;
h d8*o;
i e7*o;
j "i"1+o;
k "j"1+o;
l c9*o;
m "l"1+o;
n ba*o;
o DNP
p e8*o;
q "p"1+o;
r "q"1+o;
s "r"1+o;
t "s"1+o;
u c9*o;
v "u"1+o;
w "v"1+o;
x ca*o;
y bb*o;
z "y"1+o;
~ e9*o;
DanTheMan
fonte
Seus ;usos ;. Além disso, tenho certeza de que a maioria deles pode ser jogada em erro, e oé definitivamente possível.
SP3000
@ Sp3000 A menos que haja um intérprete que aceite ambos oe O, não vejo como oé possível. E como o final de um erro seria mais curto?
21716 DanTheMan
opode ser feito usando p. Posso postar separadamente por erro, porque provavelmente haverá muitos padrões diferentes envolvidos.
SP3000
@ Sp3000 Corrigi o ;programa embora. Obrigado por apontar isso!
21416 DanTheMan
4

Hexagonia , 376 373 bytes, 1 DNP

Obrigado a FryAmTheEggman por salvar 3 bytes.

Quase todos os programas têm a mesma forma:

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

Existem algumas exceções:

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

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

 1 2
3 4 .
 . .

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

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

Martin Ender
fonte
4

Espaço em branco , 1643 bytes, 1 DNP

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

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

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

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

Rolf
fonte
2
O espaço é um caractere ASCII imprimível ("ASCII imprimível" refere-se ao intervalo de 0x20 a 0x7E, inclusive), portanto você precisará incluí-lo como 1 DNP, a menos que seja possível encontrar uma maneira de imprimi-lo sem usar espaços. Além disso, inclua a pontuação do programa.
Martin Ender
4

Retina , 712 bytes, 2 DNPs

Este foi um esforço colaborativo com FryAmTheEggman.

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


_
T`w`p

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

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

  • 0: x(conta o número de xs na entrada vazia)
  • 1:  (weehoo, programa vazio; conta o número de correspondências vazias na entrada vazia)
  • 2: agora transformamos a entrada em um único caractere, antes de contar as strings vazias:

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

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

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

    
    4$*
    
    

    ...

    
    8$*
    
    

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

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


0
T`0`w

Fazendo uso do fato que wcomeça com _.

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

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


_
T`w`l

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


P
T`p`w

6
T`p`l

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


}
T`_p`p
Martin Ender
fonte
Com a nova versão do Retina, é possível imprimir todas as letras (mesmo T) com quatro bytes usando $ L e $ u ... Ainda não consegui encontrar uma maneira de imprimir o backtick sem usá-lo, você acha que é possível?
Leo
@ Leo Não, acho que não. Eu pretendo adicionar outro operador binário à sintaxe de substituição, que seria a expansão do intervalo, o que resolveria o problema. Eu preciso descobrir exatamente como eu quero implementá-lo. Outra opção seria algum recurso de sintaxe de substituição para trabalhar com pontos de código.
Martin Ender
3

Pyke, 364 362 355 bytes

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

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

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

Intérprete online de Pyke

Azul
fonte
3

JavaScript (ES6), 1083 1068 bytes

Forma geral:

alert`\xhex`

Exceções:

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

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

Neil
fonte
"x" também precisa de tratamento especial. Além disso, use alert(atob`XA`)"\" para salvar alguns bytes.
GOTO 0
@ GOTO0 Ugh, eu não acredito que esqueci x.
Neil
11
Javascript permite \uescapes no código fonte? Legal
Cyoce
@ Cyoce: Nos identificadores, sim, em geral, não.
Bergi
Os escapes Unicode do @Bergi são processados ​​primeiro, para que você possa escrever toda a sua fonte em termos de escapamentos unicode, se quiser, enquanto os escapes hexadecimais funcionam apenas dentro de cadeias.
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

Explicação

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

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

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

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

Emigna
fonte
3

Marbelous, 220 bytes

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

41

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

2F
++

Para 3:

66
>>

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

Intérprete.

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

jimmy23013
fonte
3

Perl 6: 921 bytes

Tradução da solução Python.

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

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

  • "\x20".say

  • "say chr 34
  • \say chr 92
  • xsay chr 120
  • 0say 1-1
  • 1say 3-2
  • 2para 9say <n minus one>+1

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

"\x20".say
say "\x21"
say chr 34
say "\x23"
say "\x24"
say "\x25"
say "\x26"
say "\x27"
say "\x28"
say "\x29"
say "\x2A"
say "\x2B"
say "\x2C"
say "\x2D"
say "\x2E"
say "\x2F"
say 1-1
say 3-2
say 1+1
say 2+1
say 3+1
say 4+1
say 5+1
say 6+1
say 7+1
say 8+1
say "\x3A"
say "\x3B"
say "\x3C"
say "\x3D"
say "\x3E"
say "\x3F"
say "\x40"
say "\x41"
say "\x42"
say "\x43"
say "\x44"
say "\x45"
say "\x46"
say "\x47"
say "\x48"
say "\x49"
say "\x4A"
say "\x4B"
say "\x4C"
say "\x4D"
say "\x4E"
say "\x4F"
say "\x50"
say "\x51"
say "\x52"
say "\x53"
say "\x54"
say "\x55"
say "\x56"
say "\x57"
say "\x58"
say "\x59"
say "\x5A"
say "\x5B"
say chr 92
say "\x5D"
say "\x5E"
say "\x5F"
say "\x60"
put "\x61"
say "\x62"
say "\x63"
say "\x64"
say "\x65"
say "\x66"
say "\x67"
say "\x68"
say "\x69"
say "\x6A"
say "\x6B"
say "\x6C"
say "\x6D"
say "\x6E"
say "\x6F"
say "\x70"
say "\x71"
say "\x72"
put "\x73"
say "\x74"
say "\x75"
say "\x76"
say "\x77"
say chr 120
put "\x79"
say "\x7A"
say "\x7B"
say "\x7C"
say "\x7D"
say "\x7E"

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

#!/usr/bin/env perl6

my $file = 'print_ascii_characters.p6';

my @expected = ' ' .. '~';
my @code     = $file.IO.lines;
my $code     = @code.join: ';';
my @got      = (run 'perl6', '-e', $code, :out).out.lines.map: |*.comb;

given +@expected, +@got, +@code -> ($e, $g, $c) {
    say "WRONG COUNT: Expected $e / output $g / source $c" and exit if not $e == $g == $c;
}

for @expected Z @got -> ($e, $g) {
    say "WRONG OUTPUT: Expected {$e.perl}, got {$g.perl}" and exit if $e ne $g;
}

for @expected Z @code -> ($char, $code) {
    say "COLLISION: {$char.perl} contained in {$code.perl}" if $code.match($char);
}

say "SCORE: ", @code.map(*.chars).sum;
smls
fonte
@sch No Perl 5, isso funcionaria, mas tentei fazê-lo no Perl 6, onde o espaço a seguir sayé necessário e as seqüências de escape octais são escritas como \o77. Sinta-se à vontade para postar uma solução Perl 5 separada ... :)
smls
Desculpe, perdi a parte do perl 6 na sua resposta.
sch
3

Haskell, 1874 1864 1856 1855 1795 1791 1589 bytes, 7 DNPs

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

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

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

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

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

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

Para 7 dos caracteres restantes, os seguintes programas funcionam:

    main=putChar$'\32'
'   main=putStr$pred<$>"("
C   main=putStr['\67']
\   main=putChar$pred ']'
h   main=putStr['\104']
p   main=interact(\_->['\112'])
u   main=interact(\_->['\117'])

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

Isso deixa 7 DNPs: =aimnrt

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

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

Laikoni
fonte
11
Com novas linhas opcionais permitidas, podemos obter dígitos como este: main=print$1-1etc.
Christian Sievers
Seu programa p usa p (mas pode ser facilmente corrigido com succ)
Christian Sievers
2

BBC Basic, 422 413 bytes

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

9 bytes salvos graças a Leaky Nun.

Forma geral

V.<character code>

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

100..126 : 27x5 = 135 bytes

12 casos especiais: 54 bytes

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

Primeiro caractere é o caractere a ser impresso.

. VDU46       :REM Full form of the command used in general form: send character 46 to VDU)
V P.CHR$86    :REM short for PRINT CHR$(86)
0 V.48       
1 V.49
2 V.50
3 V.51
4 V.52
5 P.1+4
6 V.54
7 V.55
8 V.56
9 V.57
Level River St
fonte
Por que não usar V.48para 0?
Leaky Nun
@LeakyNun 9 bytes salvos, obrigado!
Level River St
Woah, os comandos V.e P.sempre estiveram lá?
Beta Decay
@ βετѧΛєҫαγ Sim, mas o editor as expande para as palavras completas VDU e PRINT após digitar (mas elas são interpretadas sem expansão na linha de comando do BASIC). A maioria das letras maiúsculas seguida por .será expandida para uma palavra-chave. Esse desafio é estrito sobre o uso de ASCII não imprimível, mas, sem dúvida, com outros desafios, você poderia dizer que as palavras-chave tokenizadas (ascii 127-255) eram de um byte. Dito isto, nunca tentei esse argumento e geralmente dou as duas pontuações.
Level River St
@LevelRiverSt I see
Beta Decay
2

Minkolang 0.15 , 604 bytes

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

Formato: <character>: <program>

 : 48*O.
!: $13*O.
": 66*2-O.
#: 57*O.
$: 66*O.
%: 66*1+O.
&: 4l*2-O.
': 3$3*O.
(: 4l*O.
): 4l*1+O.
*: ")"1+O.
+: "*"1+O.
,: $14*O.
-: 59*O.
.: "-"1+d$10pO-
/: "."1+O.
0: 68*O.
1: 77*O.
2: 5l*O.
3: 5l*1+O.
4: lZIO.
5: lZdIO.
6: 239**O.
7: 5$1*O.
8: 4$4*O.
9: 6l*3-O.
:: 6l*2-O.
;: 6l*1-O.
<: 6l*O.
=: 6l*1+O.
>: 6l*2+O.
?: 79*O.
@: 88*O.
A: 5$3*O.
B: 6$1*O.
C: 7l*3-O.
D: 7l*2-O.
E: 7l*1-O.
F: 7l*O.
G: 7l*1+O.
H: 89*O.
I: 89*1+O.
J: 89*2+O.
K: 355**O.
L: 89*4+O.
M: 7$1*O.
N: 6$3*O.
O: "N"1+d90pN.
P: 8l*O.
Q: 99*O.
R: 8l*2+O.
S: 8l*3+O.
T: 347**O.
U: 8l*5+O.
V: 8l*6+O.
W: 8l*7+O.
X: 8$1*O.
Y: 8l*9+O.
Z: 9l*O.
[: $l9-O.
\: $l8-O.
]: $l7-O.
^: $l6-O.
_: $l5-O.
`: 8$2*O.
a: $l3-O.
b: $l2-O.
c: 9$1*O.
d: $lO.
e: $l1+O.
f: $l2+O.
g: $l3+O.
h: $l4+O.
i: $l5+O.
j: $l6+O.
k: $l7+O.
l: $l8+O.
m: $l9+O.
n: l$1*O.
o: $l$1+O.
p: $l$2+O.
q: $l$3+O.
r: $l$4+O.
s: $l$5+O.
t: $l$6+O.
u: "t"1+O.
v: "u"1+O.
w: 7dl+*O.
x: 358**O.
y: $1d*O.
z: 53;3-O.
{: 53;2-O.
|: 53;1-O.
}: 53;O.
~: 53;1+O.

Menções especiais:

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

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

4: lZIO.

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

y: $1d*O.

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

}: 53;O.

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

El'endia Starman
fonte
2

Groovy, 1019 bytes

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

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

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

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

Aqui está a lista completa de programas por personagem.

    print'\40'
!   print'\41'
"   print'\42'
#   print'\43'
$   print'\44'
%   print'\45'
&   print'\46'
'   print'\47'
(   print'\50'
)   print'\51'
*   print'\52'
+   print'\53'
,   print'\54'
-   print'\55'
.   print'\56'
/   print'\57'
0   print~-1
1   print~-2
2   print~-3
3   print~-4
4   print~-5
5   print~-6
6   print~-7
7   print~-8
8   print~-9
9   print~-10
:   print'\72'
;   print'\73'
<   print'\74'
=   print'\75'
>   print'\76'
?   print'\77'
@   print'\100'
A   print'\101'
B   print'\102'
C   print'\103'
D   print'\104'
E   print'\105'
F   print'\106'
G   print'\107'
H   print'\110'
I   print'\111'
J   print'\112'
K   print'\113'
L   print'\114'
M   print'\115'
N   print'\116'
O   print'\117'
P   print'\120'
Q   print'\121'
R   print'\122'
S   print'\123'
T   print'\124'
U   print'\125'
V   print'\126'
W   print'\127'
X   print'\130'
Y   print'\131'
Z   print'\132'
[   print'\133'
\   print'\134'
]   print'\135'
^   print'\136'
_   print'\137'
`   print'\140'
a   print'\141'
b   print'\142'
c   print'\143'
d   print'\144'
e   print'\145'
f   print'\146'
g   print'\147'
h   print'\150'
i   'pr\151nt''\151'
j   print'\152'
k   print'\153'
l   print'\154'
m   print'\155'
n   'pri\156t''\156'
o   print'\157'
p   '\160rint''\160'
q   print'\161'
r   'p\162int''\162'
s   print'\163'
t   'prin\164''\164'
u   print'\165'
v   print'\166'
w   print'\167'
x   print'\170'
y   print'\171'
z   print'\172'
{   print'\173'
|   print'\174'
}   print'\175'
~   print'\176'

Groovy, 1130 bytes

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

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

  • -, [, ~print(++'<previous char>')
  • &print(--"'")
  • p, r, i, nSystem.out<<--'<next char>'
  • t'prin\u0074'(--'u')
  • (print'\u0028'
  • )print'\u0029'
  • 0- 9print~-<next int>

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

    print(--'!')
!   print(--'"')
"   print(--'#')
#   print(--'$')
$   print(--'%')
%   print(--'&')
&   print(--"'")
'   print(--'(')
(   print'\u0028'
)   print'\u0029'
*   print(--'+')
+   print(--',')
,   print(--'-')
-   print(++',')
.   print(--'/')
/   print(--'0')
0   print~-1
1   print~-2
2   print~-3
3   print~-4
4   print~-5
5   print~-6
6   print~-7
7   print~-8
8   print~-9
9   print~-10
:   print(--';')
;   print(--'<')
<   print(--'=')
=   print(--'>')
>   print(--'?')
?   print(--'@')
@   print(--'A')
A   print(--'B')
B   print(--'C')
C   print(--'D')
D   print(--'E')
E   print(--'F')
F   print(--'G')
G   print(--'H')
H   print(--'I')
I   print(--'J')
J   print(--'K')
K   print(--'L')
L   print(--'M')
M   print(--'N')
N   print(--'O')
O   print(--'P')
P   print(--'Q')
Q   print(--'R')
R   print(--'S')
S   print(--'T')
T   print(--'U')
U   print(--'V')
V   print(--'W')
W   print(--'X')
X   print(--'Y')
Y   print(--'Z')
Z   print(--'[')
[   print(++'Z')
\   print(--']')
]   print(--'^')
^   print(--'_')
_   print(--'`')
`   print(--'a')
a   print(--'b')
b   print(--'c')
c   print(--'d')
d   print(--'e')
e   print(--'f')
f   print(--'g')
g   print(--'h')
h   print(--'i')
i   System.out<<--'j'
j   print(--'k')
k   print(--'l')
l   print(--'m')
m   print(--'n')
n   System.out<<--'o'
o   print(--'p')
p   System.out<<--'q'
q   print(--'r')
r   System.out<<--'s'
s   print(--'t')
t   'prin\u0074'(--'u')
u   print(--'v')
v   print(--'w')
w   print(--'x')
x   print(--'y')
y   print(--'z')
z   print(--'{')
{   print(--'|')
|   print(--'}')
}   print(--'~')
~   print(++'}')
M. Justin
fonte
2

Na verdade , 383 382 381 bytes

1 byte graças ao Mego.

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

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

032   :32c
033 ! HN
034 " 9Fc
035 # :35c
036 $ :36c
037 % :37c
038 & :38c
039 ' :39c
040 ( :40c
041 ) 9R$N
042 * :42c
043 + :43c
044 , :44c
045 - :45c
046 . :46c
047 / :47c
048 0  
049 1 0Y
050 2 0P
051 3 1P
052 4 3u
053 5 2P
054 6 3!
055 7 3P
056 8 6F
057 9 NF
058 : 9P;+c
059 ; :59c
060 < :60c
061 = :61c
062 > :62c
063 ? :63c
064 @ :64c
065 A :65c
066 B :66c
067 C :67c
068 D :68c
069 E :69c
070 F :70c
071 G :71c
072 H :72c
073 I :73c
074 J :74c
075 K :75c
076 L :76c
077 M :77c
078 N :78c
079 O :79c
080 P :80c
081 Q :81c
082 R :82c
083 S :83c
084 T :84c
085 U :85c
086 V :86c
087 W :87c
088 X :88c
089 Y :89c
090 Z :90c
091 [ k$F
092 \ :92c
093 ] k$N
094 ^ :94c
095 _ :95c
096 ` :96c
097 a :97c
098 b :98c
099 c :12#"%x"%
100 d :100c
101 e :101c
102 f :102c
103 g :103c
104 h :104c
105 i :105c
106 j :106c
107 k :107c
108 l :108c
109 m :109c
110 n :110c
111 o :111c
112 p :112c
113 q 9PPc
114 r 9R$F
115 s :115c
116 t :116c
117 u :117c
118 v :118c
119 w 5!Dc
120 x 5!c
121 y 5!uc
122 z :122c
123 { :123c
124 | :124c
125 } :125c
126 ~ :126c

Experimente online!

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

Freira Furada
fonte
:em 5:9P2*c
Mego
@Mego Obrigado, acrescentou.
Leaky Nun
2

Fourier, 306 bytes, 1 DNP

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

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

Experimente online!

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

0 (zero)

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

o

Experimente online!

1 1

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

^o

Experimente online!

5

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

6vo

Experimente online!

uma

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

Veja todos os programas aqui

Beta Decay
fonte
2

Matlab, 1238 1224 bytes, 2 DNP

O padrão principal é:

disp([<char code> ''])

Para dígitos, é um pouco menor:

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

Para caracteres []'é:

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

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

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

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


Para referência a lista inteira:

    char    char code   code                        length
            32          disp([0 ''])                12
    !       33          disp([33 ''])               13
    "       34          disp([34 ''])               13
    #       35          disp([35 ''])               13
    $       36          disp([36 ''])               13
    %       37          disp([37 ''])               13
    &       38          disp([38 ''])               13
    '       39          disp(char(39))              14
    (       40          DNP
    )       41          DNP 
    *       42          disp([42 ''])               13
    +       43          disp([43 ''])               13
    ,       44          disp([44 ''])               13
    -       45          disp([45 ''])               13
    .       46          disp([46 ''])               13
    /       47          disp([47 ''])               13
    0       48          disp(1-1)                   9
    1       49          disp(3-2)                   9
    2       50          disp(5-3)                   9
    3       51          disp(7-4)                   9
    4       52          disp(9-5)                   9
    5       53          disp(2+3)                   9
    6       54          disp(3+3)                   9
    7       55          disp(4+3)                   9
    8       56          disp(5+3)                   9
    9       57          disp(6+3)                   9
    :       58          disp([58 ''])               13
    ;       59          disp([59 ''])               13
    <       60          disp([60 ''])               13
    =       61          disp([61 ''])               13
    >       62          disp([62 ''])               13
    ?       63          disp([63 ''])               13
    @       64          disp([64 ''])               13
    A       65          disp([65 ''])               13
    B       66          disp([66 ''])               13
    C       67          disp([67 ''])               13
    D       68          disp([68 ''])               13
    E       69          disp([69 ''])               13
    F       70          disp([70 ''])               13
    G       71          disp([71 ''])               13
    H       72          disp([72 ''])               13
    I       73          disp([73 ''])               13
    J       74          disp([74 ''])               13
    K       75          disp([75 ''])               13
    L       76          disp([76 ''])               13
    M       77          disp([77 ''])               13
    N       78          disp([78 ''])               13
    O       79          disp([79 ''])               13
    P       80          disp([80 ''])               13
    Q       81          disp([81 ''])               13
    R       82          disp([82 ''])               13
    S       83          disp([83 ''])               13
    T       84          disp([84 ''])               13
    U       85          disp([85 ''])               13
    V       86          disp([86 ''])               13
    W       87          disp([87 ''])               13
    X       88          disp([88 ''])               13
    Y       89          disp([89 ''])               13
    Z       90          disp([90 ''])               13
    [       91          disp(char(91))              14
    \       92          disp([92 ''])               13
    ]       93          disp(char(93))              14
    ^       94          disp([94 ''])               13
    _       95          disp([95 ''])               13
    `       96          disp([96 ''])               13
    a       97          disp([97 ''])               13
    b       98          disp([98 ''])               13
    c       99          disp([99 ''])               13
    d       100         fprintf([100 ''])           17
    e       101         disp([101 ''])              14
    f       102         disp([102 ''])              14
    g       103         disp([103 ''])              14
    h       104         disp([104 ''])              14
    i       105         eval(['ejtq)(j(*'-1 ''])    24
    j       106         disp([106 ''])              14
    k       107         disp([107 ''])              14
    l       108         disp([108 ''])              14
    m       109         disp([109 ''])              14
    n       110         disp([110 ''])              14
    o       111         disp([111 ''])              14
    p       112         eval(['ejtq)(q(*'-1 ''])    24
    q       113         disp([113 ''])              14
    r       114         disp([114 ''])              14
    s       115         fprintf([115,''])           17
    t       116         disp([116 ''])              14
    u       117         disp([117 ''])              14
    v       118         disp([118 ''])              14
    w       119         disp([119 ''])              14
    x       120         disp([120 ''])              14
    y       121         disp([121 ''])              14
    z       122         disp([122 ''])              14
    {       123         disp([123 ''])              14
    |       124         disp([124 ''])              14
    }       125         disp([125 ''])              14
    ~       126         disp([126 ''])              14
pajonk
fonte
Algo como [100 105 115 112](char-codes) funciona disp?
Leaky Nun
O que você quer dizer exatamente? disp([100 105 115 112])também não produzirá uma string eval([100 105 115 112]).
Pajonk
Você pode usar fprintfpara d ans s: fprintf([115,'']). Salva 2x7 bytes =) não vai torná-lo um projeto vencedor, mas hey: 14 bytes é de 14 bytes ,,,
Stewie Griffin
Também: disp([0 ''])contém um espaço. disp([0,''])não.
Stewie Griffin
@ StewieGriffin Obrigado, eu perdi o espaço. Além disso, obrigado pelo truque com fprintf.
Pajonk
2

Gelatina (não competitiva), 406 bytes

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

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

Experimente online!

Soren
fonte
11
Não acho que seja uma resposta válida. Primeiro, você não tem permissão para receber uma entrada e, segundo, este é um programa, não 95 programas. O desafio dizIn 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, eu vou mudar isso #
Soren
DJ está correto. Isso é flagrantemente inválido.
Hobbies de Calvin
@HelkaHomba, minha contagem de bytes é o total de todos os programas?
Soren
11
Obrigado por corrigi-lo e bem-vindo ao site! Espero que você goste daqui. Além disso, só para você saber, o Jelly usa uma página de código personalizada , portanto, nesse caso, são realmente 406 caracteres, mesmo que fosse 503 em UTF-8.
DJMcMayhem
2

Befunge-93, 530 bytes

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

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

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

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

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

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

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

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

1g,@
1g1+,@
g3/,@
57*,@
49*,@
1g5+,@
1g6+,@
1g7+,@
58*,@
1g9+,@
0g6-,@
0g5-,@
0g4-:80p @
59*,@
0g2-,@
0g1-,@
.@
!.@
11+.@
21+.@
31+.@
41+.@
51+.@
61+.@
71+.@
81+.@
>g4-,@
:g1+,@
:g2+,@
:g3+,@
:g4+,@
79*,@
88*,%
>g3+,@
>g4+,@
>g5+,@
>g6+,@
>g7+,@
>g8+,@
>g9+,@
89*,@
Hg1+,@
Ig1+,@
Jg1+,@
Kg1+,@
Lg1+,@
Mg1+,@
Ng1+,@
Og1+,@
99*,@
Qg1+,@
\g9-,@
\g8-,@
\g7-,@
\g6-,@
\g5-,@
\g4-,@
\g3-,@
\g2-,@
\g1-,@
_g3-,@
\g1+,@
g9-,@
g8-,@
g7-,@
g6-,@
g5-,@
g4-,@
g3-,@
g2-,@
g1-,@
"f"1+,@
g1+,@
g2+,@
g3+,@
g4+,@
g5+,@
g6+,@
g7+,@
g8+,@
g9+,@
tg3-,@
tg2-,@
tg1-,@
:g2*,@
tg1+,@
tg2+,@
tg3+,@
tg4+,@
tg5+,@
tg6+,@
tg7+,@
>g2*,@
tg9+,@
*g3*,@
James Holderness
fonte