Dans un langage de programmation de votre choix, écrivez 95 programmes, dont chacun génère un des 95 caractères ASCII imprimables différent, sans que ce caractère ne se trouve ailleurs dans le programme .

Par exemple, si votre langage était Python , votre programme qui sort le caractère Ppeut être

print(chr(80))

car Pa le code ASCII 80. Ce programme est valide car Pn'apparaît jamais dans le code source. Cependant, pour le programme qui génère des minuscules p, quelque chose comme

print(chr(112))

serait invalide car, même s’il est imprimé p, il pest présent dans le code. Un programme valide pourrait être

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

qui imprime pmais ne contient pas p.

Votre objectif est de faire en sorte que chacun de vos 95 programmes soit le plus court possible. Votre score est la somme des longueurs de caractères de tous vos programmes.

Si, pour une raison quelconque, vous ne parvenez pas à écrire des programmes valides pour certains caractères, vous pouvez les marquer comme "n’a pas programmé" ou DNP et omettre totalement les programmes correspondants. De cette façon, les langages syntaxiquement stricts pourront se faire concurrence.

La réponse gagnante est la réponse qui a le score le plus bas de l'ensemble des réponses ayant le moins de DNP.

Règles

• Le code source de tous vos programmes ne peut contenir que des onglets ASCII plus imprimables et des nouvelles lignes, qui sont tous comptés comme un seul caractère. (Parce que dans un encodage différent, il serait facile d'omettre des caractères qui n'existent pas!)

  • Remarque: cette règle semble nécessaire, mais il existe de nombreuses langues avec différents encodages et je suis sûr que ce serait bien de voir les réponses à leurs questions. Par conséquent, vous pouvez enfreindre cette règle , utiliser les caractères de votre choix, mais si votre réponse devient non compétitive , elle ne peut gagner.

• Les programmes doivent être réels, pleins programmes , selon les conventions standard de votre langue. Les extraits de fonction et les extraits REPL ne sont pas autorisés.

• La sortie de chaque programme doit aller sur stdout ou l'alternative acceptée par votre langue.

• Les programmes ne doivent pas demander ni avoir besoin d'une contribution. (Si l'invitation à entrer est inhérente à votre langue, c'est bon.)

• Les programmes doivent être déterministes, limités dans le temps d'exécution et indépendants. Par exemple, il ne devrait pas avoir d'importance si l'un est exécuté dans un dossier séparé des autres programmes.

• La sortie d'un programme doit être le caractère ASCII imprimable précis auquel il correspond, suivi facultativement par un retour à la ligne simple, rien de plus, rien de moins.

Veillez à inclure des informations sur les 95 programmes (idéalement) dans votre réponse, ainsi que votre score et tout DNP. Vous ne devez pas énumérer tous les programmes qui suivent un modèle simple comme « , ... » mais assurez - vous que vous êtes sûr tous ne fonctionne et que votre score est ajouté correctement.print(chr(80))print(chr(81))print(chr(82))

Pour référence, voici les 95 fichiers ASCII imprimables que vos programmes doivent générer:

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

Python 2, 1075 1065 1043 1040 1039 octets

Chaque programme a la forme print'\<octal char code>', sauf:

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

Pour référence et facilité de test, voici la liste complète des programmes, séparés par une nouvelle ligne.

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'

Tester:

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

-1 octet grâce à @ Sp3000!

CJam, 269 octets

Chacun des programmes est sous la forme '<char - 1>)sauf:

• Espace => S, 1 octet
• '=> 39c, 3 octets
• )=> '*(, 3 octets
• 0=> T, 1 octet
• 1=> X, 1 octet
• 2=> Y, 1 octet
• 3=> Z, 1 octet
• 4- 9=> <num-1>), 2 octets

Le score est: 3 * 82 + 1 + 3 + 3 + 4 * 1 + 6 * 2 = 269

Code machine x86 sous contrainte ASCII pour DOS, 3104 3101 2913 octets

Eh bien ... c'est plus court que Java, je suppose ...

32 30 octets pour presque tous les caractères, voir les exceptions ci-dessous.

La plupart du temps, il ne fait que suivre le modèle:

1. Faites-en xorpour obtenir un pointeur vers la fin.
2. subà partir des 2 derniers mots car l'opcode for intn'est pas en ASCII.
3. Obtenez 2 dans AHet le personnage dans DL. Les deux sont xorédités parce que le caractère lui-même ne peut pas apparaître dans le programme et 2 n'est pas un caractère ASCII imprimable.
4. Imprimer le personnage avec int 21h
5. Sortir avec int 20h

La plupart du temps, si un caractère n'est pas autorisé, il peut être remplacé en twiddling un peu avec les données ou en passant à un autre registre.

Cela devient un peu plus intéressant quand vous vous trouvez soudainement incapable de soustraire ou incapable de pousser ou d'ouvrir le seul registre utilisable pour les calculs ...

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

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

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

Brainfuck, 1770 1710 1703 1686 octets

60 octets enregistrés par Dennis
17 octets enregistrés par Sp3000

DNP: 46 ( .)

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

Tous sauf 43, 45, 60, 62, 91 et 93 sont volés sans vergogne à Esolangs.org

MATL, 305, 302, 300 297 octets

Chaque programme ressemble à ceci:

33c
34c
35c
....

À l'exception de

• Chiffres. Voici les programmes pour 0-9:

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

• 'c' Ce programme est

  'C'k
  

• espace. C'est

  0c
  

  Depuis aujourd'hui, j'ai appris que MATL traitait le caractère 0 comme un espace. Merci @LuisMendo!

Vous pouvez utiliser matl.tio pour vérifier l'un d'entre eux.

Pour référence, voici chacun d'eux:

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

Java 8, 6798 6582 6577 octets

soupir

C’est fondamentalement un port de ma réponse Python 2 , mais avec tout ce qui se passe avec l’écriture d’un programme complet en Java.

Maintenant sans aucun DNP du tout! Merci, Kevin Cruijssen!

La plupart des programmes ont la forme interface A{static void main(String[]a){System.out.print("\<octal char code>");}}, sauf:

• espace → interface\tA{static\tvoid\tmain(String[]a){System.out.print("\40");}}(mais avec le \ts remplacé par des onglets bruts)
• " → interface A{static void main(String[]a){System.out.print('\42');}}
• ( → interface A{static void main\u0028String[]a){System.out.print\u0028"\50");}}
• ) → interface A{static void main(String[]a\u0029{System.out.print("\51"\u0029;}}
• . → interface A{static void main(String[]a){System\u002Eout\u002Eprint("\56");}}
• 0 → interface A{static void main(String[]a){System.out.print(1-1);}}
• 1 → interface A{static void main(String[]a){System.out.print(3-2);}}
• 2 → interface A{static void main(String[]a){System.out.print(3-1);}}
• 3 → interface A{static void main(String[]a){System.out.print(4-1);}}
• 4 → interface A{static void main(String[]a){System.out.print(5-1);}}
• 5 → interface A{static void main(String[]a){System.out.print(6-1);}}
• 6 → interface A{static void main(String[]a){System.out.print(7-1);}}
• 7 → interface A{static void main(String[]a){System.out.print(8-1);}}
• 8 → interface A{static void main(String[]a){System.out.print(9-1);}}
• 9 → interface A{static void main(String[]a){System.out.print(8+1);}}
• ; → interface A{static void main(String[]a){System.out.print("\73")\u003B}}
• A → interface B{static void main(String[]a){System.out.print("\101");}}
• S → interface A{static void main(\u0053tring[]a){\u0053ystem.out.print("\123");}}
• [ → interface A{static void main(String...a){System.out.print("\133");}}
• \ → interface A{static void main(String[]a){System.out.print((char)92);}}
• ] → interface A{static void main(String...a){System.out.print("\135");}}
• a → interf\u0061ce A{st\u0061tic void m\u0061in(String[]b){System.out.print("\141");}}
• c → interfa\u0063e A{stati\u0063 void main(String[]a){System.out.print("\143");}}
• d → interface A{static voi\u0064 main(String[]a){System.out.print("\144");}}
• e → class A{public static void main(String[]a){Syst\u0065m.out.print("\145");}}
• f → class A{public static void main(String[]a){System.out.print("\146");}}
• g → interface A{static void main(Strin\u0067[]a){System.out.print("\147");}}// \u0067
• i → \u0069nterface A{stat\u0069c vo\u0069d ma\u0069n(Str\u0069ng[]a){System.out.pr\u0069nt("\151");}}
• m → interface A{static void \u006Dain(String[]a){Syste\u006D.out.print("\155");}}
• n → class A{public static void mai\u006E(Stri\u006Eg[]a){System.out.pri\u006Et("\156");}}
• o → interface A{static v\u006Fid main(String[]a){System.\u006Fut.print("\157");}}
• p → interface A{static void main(String[]a){System.out.\u0070rint("\160");}}
• r → class A{public static void main(St\u0072ing[]a){System.out.p\u0072int("\162");}}
• s → interface A{\u0073tatic void main(String[]a){Sy\u0073tem.out.print("\163");}}
• t → class A{public s\u0074a\u0074ic void main(S\u0074ring[]a){Sys\u0074em.ou\u0074.prin\u0074("\164");}}
• u → interface A{static void main(String[]a){System.console().printf("%c",117);}}
• v → interface A{static \u0076oid main(String[]a){System.out.print("\166");}}
• y → interface A{static void main(String[]a){S\u0079stem.out.print("\171");}}
• { → interface A\u007Bstatic void main(String[]a)\u007BSystem.out.print("\173");}}
• } → interface A{static void main(String[]a){System.out.print("\175");\u007D\u007D

phew

Le compilateur Java traite les échappements Unicode comme \u007Bavant tout autre traitement, ce qui permet d'écrire du code utilisant des échappements Unicode dans des identifiants et même des mots-clés. Donc, pour écrire un programme qui n’utilise pas un caractère présent dans le passe-partout, nous le substituons simplement avec lui un échappement Unicode.

Pour la référence et la facilité de test, voici la liste complète des programmes, séparés par une nouvelle ligne et avec les onglets bruts remplacés par quatre espaces:

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

Notez que le programme uutilise System.console(), qui retournera null (et causera donc le code de jeter un NullPointerException) si vous l'appelez depuis autre chose que le terminal natif de votre système d'exploitation ( cmdsous Windows, et, je suppose, bashsous Linux / OSX) .

Pour tester, créez un nouveau répertoire et placez le code ci-dessus dans un fichier nommé printablesdans ce répertoire. Ensuite, exécutez le script Bash suivant:

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

Le script ci-dessus mettra chaque ligne de printablesdans son propre répertoire, les nommera tous A.java(à l'exception du fichier qui sera imprimé A, renommé B.java), compilera chaque fichier, exécutez-les, puis supprimez la preuve. Il faut environ dix secondes pour que les caractères ASCII imprimables apparaissent dans votre shell.

Si vous utilisez Windows, exécutez à la place le fichier batch suivant:

@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

Ce fichier de commandes adopte une approche légèrement différente. au lieu de pré-scinder les lignes, il traite le fichier ligne par ligne, compile et exécute chaque programme à tour de rôle. Encore une fois, il supprime la preuve après son achèvement.

Sauvegardé d'innombrables octets + le 1 DNP grâce à Kevin Cruijssen!

> <> , 443 437 octets

Lien interprète TIO . Il y a beaucoup de modèles ici:

• [num][num]*o;: Multiplication de deux nombres, puis sortie du résultat sous forme de caractère avec oet arrêt avec ;. > <> chiffres vont jusqu'à 15, c'est à dire 0123456789abcdef.
  • De même [num][num]-n;, qui prend la différence de deux nombres et génère un nombre avec à la nplace.

• '-o[invalid char]: > <> est toroïdal. Ainsi, lorsque le pointeur d'instruction atteint la fin d'une ligne, il revient au début. Dans ce cas, le code sera exécuté deux fois, c'est-à-dire '-o[char]'-o[char]. La première '-o[char]'partie pousse trois caractères dans la pile, -calcule 'o' - [char]puis oaffiche le résultat sous forme de caractère. > <> puis des erreurs se produisent lorsqu'il atteint [char], soit en raison d'une commande non reconnue, soit en raison du vidage d'une pile vide.

  • De même '-n[invalid char], qui sort sous forme de nombre.
  • De même '[num][op]o[invalid char], qui s'applique [op]à [num]on [char], en erreur sur char. Par exemple, les '2+oJsorties L, qui sont deux de plus que J.
  • 'Le code de, est "-oHen utilisant ".
  • -Le code de, est '%oBen utilisant %.

• ln;: Poussez la longueur de la pile, affichez num puis arrêtez, donnant 0. De même lln;pour 1et 'ln;pour 3.

• 4|n+: Appuyez sur 4, rebondissez sur le |et appuyez sur un autre 4, ajoutez, puis sortez 8comme num. Rebondissez à |nouveau et erreur en essayant d'exécuter à nnouveau sur une pile vide.
  • De même 3|n*pour 9.
  • De même [num]|o*pour @Qdy.
• '1-:00p: Le plus intéressant, pour le ocas. Pour éviter d'utiliser odans notre code, nous devons utiliser ppour placer un odans la boîte à code, puis l'exécuter. L'initiale '1-:00p'place la pile en phaut et la 1-décrémente en o. :duplique ceci oet en 00pplace un oà (0, 0) en transformant la boîte de code en o1-:00p. Le pointeur d'instruction retourne à nouveau et affiche l'autre o. Le caractère (0, 0) est ensuite remplacé plusieurs fois avant que le programme ne finisse par obtenir une erreur.

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

Dyalog APL , 527 522 octets

(non compétitif car APL ne peut pas vraiment être écrit en ASCII uniquement)

La plupart sont dans le format nn⊃⎕AVou nnn⊃⎕AV, les exceptions étant:

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

Voici la liste complète:

⊃''
205⊃⎕AV
216⊃⎕AV
⎕THIS
62⊃⎕AV
13⊃⎕AV
219⊃⎕AV
14⊃⎕AV
186⊃⎕AV
249⊃⎕AV
181⊃⎕AV
170⊃⎕AV
195⊃⎕AV
169⊃⎕AV
⊃1↓⍕÷2
157⊃⎕AV
⊃⍬
≢#
⍴⍬ ⍬
⎕WX
×⍨2
6-1
!3
6+1
2*3
3*2
241⊃⎕AV
194⊃⎕AV
161⊃⎕AV
163⊃⎕AV
165⊃⎕AV
173⊃⎕AV
232⊃⎕AV
⊃⎕a
2⊃⎕A
3⊃⎕A
4⊃⎕A
5⊃⎕A
6⊃⎕A
7⊃⎕A
8⊃⎕A
9⊃⎕A
10⊃⎕A
11⊃⎕A
12⊃⎕A
13⊃⎕A
14⊃⎕A
15⊃⎕A
16⊃⎕A
17⊃⎕A
18⊃⎕A
19⊃⎕A
20⊃⎕A
21⊃⎕A
22⊃⎕A
23⊃⎕A
24⊃⎕A
25⊃⎕A
26⊃⎕A
156⊃⎕AV
159⊃⎕AV
250⊃⎕AV
236⊃⎕AV
17⊃⎕AV
238⊃⎕AV
18⊃⎕AV
19⊃⎕AV
20⊃⎕AV
21⊃⎕AV
22⊃⎕AV
23⊃⎕AV
24⊃⎕AV
25⊃⎕AV
26⊃⎕AV
27⊃⎕AV
28⊃⎕AV
29⊃⎕AV
30⊃⎕AV
31⊃⎕AV
32⊃⎕AV
33⊃⎕AV
34⊃⎕AV
35⊃⎕AV
36⊃⎕AV
37⊃⎕AV
38⊃⎕AV
39⊃⎕AV
40⊃⎕AV
41⊃⎕AV
42⊃⎕AV
43⊃⎕AV
124⊃⎕AV
193⊃⎕AV
126⊃⎕AV
176⊃⎕AV

Ruby, 869 octets

Pour les 63 caractères @par ~, nous avons une solution à 10 octets:

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

Pour la plupart (21) des personnages de spacetravers ?, nous avons une solution de 9 octets:

puts"\xx"     (2 digit octal code)

Il reste onze cas spéciaux:

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

Au total, le score est de 10 × 63 + 9 × 21 + 10 + 3 + 8 × 4 + 5 = 869.

WolframAlpha , 368 octets

Format général:

u+<character code in hexadecimal>

Exceptions:

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

Voici la liste complète:

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

PHP ( 891 680 674 octets, 2 0 DNP)

Edit: sauvé 203 octets grâce à jimmy23013 et implémenté les 2 DNP grâce à Mego

Cette réponse abuse fortement de la nature généreuse de PHP. La plupart des cas prennent l'une des formes suivantes (7 octets chacun):

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

PHP convertit les lettres de chaque côté de l'opérateur à cordes, puis effectue l'opération de conversion binaire approprié par chaque chaîne à sa valeur de caractères ASCII, et convertit enfin le résultat de retour à un personnage.

Dans le premier exemple ci-dessus, Y^xdevient 89^78. Le résultat est ce 33qui est ensuite envoyé à STDOUT en tant que caractère !.

Un script a été écrit pour forcer toutes les combinaisons possibles: les résultats sont disponibles ici .

Exceptions:

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

<et ?devrait normalement être DNP en raison de la balise de début requise, mais en utilisant l' -rindicateur, le code peut être exécuté sans eux:

<is echo Z^f;(9 octets)
?est echo Z^e;(9 octets)
=est echo Z^g;(9 octets)

But:

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

Brachylog , 546 477 octets

Crédits à Fataliser pour le code pour @.

Dans la liste ci-dessous, le premier caractère est le caractère à imprimer (pour faciliter la référence).

  @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
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
| @P: 92m
} @Prbh
~ @Pt

Ce sont tous des prédicats, il Zfaut donc être l'argument pour recevoir le résultat: essayez-le en ligne!

Explication

@P est cette chaîne:

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

qui contient tous les ASCII imprimables.

> <> , 531 octets

Les programmes prennent deux formes principales:

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

Le premier concerne les caractères avec des codes de caractère avec deux facteurs inférieurs à 16, l’autre pour les autres cas. La plupart des nombres pour lesquels j'utilise le second formulaire ont de nombreuses solutions de longueur égale, mais j'ai choisi celui-ci pour des raisons de lisibilité.

Exceptions:

" 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

Liste complète:

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

Hexagony , 376 373 octets, 1 DNP

Merci à FryAmTheEggman pour la sauvegarde de 3 octets.

Presque tous les programmes ont la même forme:

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

Il y a cependant quelques exceptions:

• Il est impossible d'imprimer ;sans utiliser ;, d'où 1 DNP.
• Pour imprimer @, nous ne pouvons pas utiliser @pour terminer le programme. Au lieu de cela, nous utilisons soit S2;:ou S3;%. Cela se termine par une erreur de division par zéro, mais cette erreur n'est pas visible sur STDOUT. Donc, cela reste quatre octets.
• Il y a un affrontement Uqui nécessiterait U3;@. Il existe plusieurs façons de résoudre ce problème, notamment le passage en minuscule, c.-à-d n9;@. Ou l'utilisation d'incrément ou de décrément, c. T);@-à- d ou V(;@. Dans tous les cas, il reste quatre octets.
• Les bords de la mémoire sont initialisés sur 0et !impriment une valeur entière afin que nous puissions obtenir 0et 1avec !@et )!@, respectivement, économiser 3 octets.

Quant au fonctionnement des <letter><digit>;@programmes: la disposition hexagonale d’un programme de la forme 1234est toujours

 1 2
3 4 .
 . .

Etant donné qu'aucun programme ne contient de commande redirigeant le flux de contrôle, il s'agit simplement de programmes linéaires exécutés dans l'ordre.

Dans tous les cas, la lettre au début du code définit le bord de la mémoire en cours sur son code de caractère. Par exemple, dans le programme P1;@, le Pdéfinit la valeur 80. Ensuite, le chiffre multiplie cette valeur par 10 et s’ajoute (c’est-à-dire que le chiffre est ajouté à la valeur actuelle). Cela donne 801dans l'exemple ci-dessus. Enfin, ;affiche cette valeur en le prenant modulo 256 et en l’utilisant comme valeur d’octet. Dans ce cas 801 % 256 = 33et a !est imprimé.

Espace blanc , 1643 octets, 1 DNP

17 octets pour les caractères [33-63] et 18 octets pour les caractères [64-126]

Dans les espaces blancs, c'est simple, car les caractères imprimables (à l'exception de l'espace) n'ont de toute façon aucune signification:

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

Le programme ci-dessus affiche un "!" (100001b). Changez [TAB][SPACE][SPACE][SPACE][SPACE][TAB]dans la première ligne pour le personnage que vous aimez. Il n'est pas possible d'imprimer un espace sans utiliser d'espace, car l'impression commence toujours par[TAB][LF][SPACE]

Rétine , 712 octets, 2 DNP

C'était un effort de collaboration avec FryAmTheEggman.

Il existe plusieurs classes de solutions. Pour la plupart des caractères de l'espace à ^, nous utilisons un programme de la forme suivante:

_
T`w`p

Le caractère de la deuxième ligne parcourt les plages _0-9A-Za-ztandis que le reste reste inchangé. Cela transforme l'entrée vide en ce caractère, puis le remplace par le caractère imprimable ASCII (représenté par p) à la position correspondante. Chacun de ces programmes est long de 8 octets.

Dans cette plage, il n’ya que quelques exceptions. Plus important encore, les chiffres peuvent être raccourcis:

• 0: x(compte le nombre de xs dans l'entrée vide)
• 1:  (weehoo, programme vide; compte le nombre de correspondances vides dans l'entrée vide)

• 2: maintenant nous transformons l'entrée en un seul caractère avant de compter les chaînes vides:

  
  1
  
  

• 3: même chose mais nous transformons l’entrée en deux caractères:

  
  11
  
  

• 4: vous avez l'idée ...

  
  111
  
  

• 5 - 9: torsion de l'intrigue ... nous utilisons la répétition de caractères pour éviter que la deuxième ligne ne devienne plus longue:

  
  4$*
  
  

  ...

  
  8$*
  
  

L'autre exception est qu'il Ts'agit d'un DNP: nous ne pensons pas qu'il soit possible de générer un caractère non numérique sans qu'il n'apparaisse dans le code source si les étapes de translittération ne peuvent pas être utilisées.

Sur les personnages restants. Pour imprimer, _nous utilisons un programme similaire à la solution générale ci-dessus:

0
T`0`w

Utiliser le fait qui wcommence par _.

Vient ensuite `le deuxième DNP, car les étapes de translittération le nécessitent également.

Ensuite, la plupart des lettres minuscules sont imprimées avec quelque chose comme ceci (qui imprime a):

_
T`w`l

Encore une fois, le caractère de la deuxième ligne est incrémenté _0-9A-O. Ici, nous devons simplement surveiller let w, que nous pouvons imprimer avec les programmes suivants, respectivement:

P
T`p`w

6
T`p`l

Enfin, il ne {|}~reste que ceux qui nécessitent 9 octets chacun. Ici, nous utilisons l'étape de translittération pour incrémenter le caractère qui les précède. Par exemple, ~peut être imprimé avec:

}
T`_p`p

Pyke, 364 362 355 octets

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

Tous sous la forme w<chr(charcode+32)>.C(4 octets) à l'exception de:

• -> d1 octet
• 0-> Z1 octet
• 1-> ~W2 octets
• a-> Gh2 octets
• z-> Ge2 octets
• 10 premières lettres de l'alphabet minuscule (sauf a) sous forme G<number>@(3 octets)
• k-> GT@3 octets
• >-> ~Bh3 octets
• ]-> ~Be3 octets
• Z-> ~le3 octets
• 9-> ~ue3 octets
• w-> G22@4 octets
• .-> ~B4@4 octets
• C-> ~K38@5 octets

Interprète Pyke en ligne

JavaScript (ES6), 1083 1068 octets

Forme générale:

alert`\xhex`

Exceptions:

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`

Edit: Sauvegardé 15 octets grâce à @ GOTO0.

05AB1E , 417 octets

!   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

Explication

La plupart sont 5 octets de la forme: convert nr to base nr+1.
>nécessite un octet supplémentaire car nous ne pouvons pas utiliser incrément pour cela.

a,b,x,y,z,Y,Zsont extraites de Aqui contient l'alphabet en minuscule.

A,B,C,D,E,F sont des nombres convertis en hexadécimal.

0-9 sont des incréments / décréments simples ainsi que des variables prédéfinies.

Marbelous, 220 octets

Pour un caractère qui n'est pas un chiffre, il ne s'agit que des deux chiffres hexadécimaux majuscules du code de caractère. Par exemple, les sorties de programme suivantes A:

41

Pour un chiffre qui ne l'est pas 3, remplacez 2Fle code suivant par les chiffres hexadécimaux majuscules du code de caractère - 1:

2F
++

Pour 3:

66
>>

Note totale: 2 * 85 + 5 * 10 = 220.

Interprète.

Mon premier essai était Bubblegum et cela ne fonctionnait pas pour les personnages auparavant ?...

Perl 6: 921 octets

Traduction de la solution Python.

Chaque programme a la forme say "\x<hex escape code>", sauf:

• s → put "\x73"
• a → put "\x61"

• y → put "\x79"

• → "\x20".say

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

Pour référence et facilité de test, voici la liste complète des programmes, séparés par une nouvelle ligne.

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

Voici le code que j'ai utilisé pour tester la liste ci-dessus et compter le score:

#!/usr/bin/env perl6

my $file = 'print_ascii_characters.p6';

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

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

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

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

say "SCORE: ", @code.map(*.chars).sum;

Haskell, 1874 1864 1856 1855 1795 1791 1589 octets, 7 DNP

La plupart des programmes sont main=putChar '\xx'ou main=putChar '\xxx'où xx/ xxxest le code ASCII du caractère à imprimer. Cela fonctionne pour tous les caractères sauf 14:

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

Cependant, pour les chiffres, 1 7 4 octets peuvent être sauvegardés (grâce à Christian Sievers!):

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

Les 52 programmes jusqu’à c(code 99) prennent 18 octets, les 19 restants prennent 19 octets chacun.

Partition partielle: 10*14 + 52*18 + 19*19 = 1437

Pour 7 des caractères restants, les programmes suivants fonctionnent:

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

Partition partielle: 18 + 22 + 18 + 21 + 19 + 27 + 27 = 152

Cela laisse 7 DNP: =aimnrt

Chaque programme Haskell doit définir un main ( main=), donc 5 DNP. Pour imprimer à StdOut, putChar, putStrou interactpeut être utilisé, ce qui donne tet rque d' autres PND. (Il y a aussi print, cependant, des print 'a'impressions 'a'et non a- et contient également tet de rtoute façon.) Haskell a également une chrfonction qui renvoie le caractère correspondant à un numéro, mais son utilisation import Data.Charest nécessaire.

Score total: 1437 + 152 = 1589 7 DNP

BBC Basic, 422 413 octets

Téléchargez l'interprète gratuitement à l' adresse http://www.bbcbasic.co.uk/bbcwin/bbcwin.html

9 octets sauvés grâce à Leaky Nun.

Forme générale

V.<character code>

32..99 hors 12 cas spéciaux: 56x4 = 224 octets

100..126 : 27x5 = 135 octets

12 cas spéciaux: 54 octets

La plupart des nombres suivent la forme générale, mais je les ai tous inclus ici pour montrer où se situe le problème.

Le premier caractère est le caractère à imprimer.

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

Minkolang 0,15 , 604 octets

Pour la plupart des personnages, ce "<char-1>"1+O.serait un programme valide, peut-être l’un des plus courts. Cependant, étant donné que les caractères sont stockés en tant que points de code sur la pile, beaucoup d’entre eux peuvent être produits par multiplication et addition, sur cinq octets ou moins. Notez également que l, $1, $2, $3, $4, $5, $6, $lsont 10, 11, 12, 13, 14, 15, 16, 100respectivement.

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

Mentions spéciales:

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

(Essayez-le.) Minkolang a la capacité de modifier les caractères dans la boîte de code, donc ce programme fait qu'il remplace -à la fin .ce qui est nécessaire pour arrêter le programme. "N"1+d90pN.pour Ofonctionne de la même manière.

4: lZIO.

(Essayez-le.) lZ Pousse les alphabets majuscules et minuscules vers la pile et Ipousse la longueur de la pile, qui est 52, précisément le point de code de "4". La meilleure partie est que je pensais initialement à la solution de 4$3*O., qui multiplie 4 et 13 pour obtenir 52, mais ne pouvait pas parce qu’elle comportait un 4, j’ai donc fini par trouver une solution plus complète!

y: $1d*O.

(Essayez-le.) d Duplique le haut de la pile, donc ce morceau de code fait qu'il pousse 11, duplique, puis se multiplie. Une autre façon d'écrire cela aurait été $12;O., qui a le même nombre d'octets.

}: 53;O.

(Essayez-le.) ; Est une exponentiation, donc cela fait 5 ^ 3 pour obtenir 125.

Groovy, 1019 octets

J'avais une solution Groovy différente écrite (voir ci-dessous), mais après l'avoir soumise, j'ai creusé un peu plus dans les échappements de caractères, dans l'espoir de trouver un moyen de raccourcir davantage le programme, et j'ai découvert que Groovy avait un caractère octal d'échappement que je ne savait pas de. Cela simplifie considérablement le code, au point qu'il supprime malheureusement la quasi-totalité des solutions de contournement originales que j'avais proposées.

Il semble également presque identique à la solution Python 2 de Copper , au point où il semble en fait que je plagie leur travail. Pouah.

Chaque programme a la forme print'\<octal value>', sauf:

• p, r, i, n, t→ 'print''\<octal value>'(mais avec la lettre correspondante de « print » a également remplacé par la valeur octal)
• 0- 9→print~-<next int>

Voici la liste complète des programmes par personnage.

    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 octets

Mon programme précédent, avant que je découvre que des échappées octales existent. Beaucoup plus intéressant, IMO.

Chaque programme a la forme print(--'<next char>'), sauf:

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

Voici la liste complète des programmes pour chaque personnage:

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

En réalité , 383 382 381 octets

1 octet grâce à Mego.

Pour faciliter la recherche, la première colonne est le code du caractère, la deuxième colonne est le caractère et la troisième colonne est le code.

Le code pour 0est un espace unique.

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

Essayez-le en ligne!

Les suggestions de golf sont les bienvenues.

Fourier, 306 octets, 1 DNP

Pratiquement tous les programmes suivent le modèle naoù n est le code de caractère de chacun des caractères. Par exemple:

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

Essayez-le en ligne!

Je vais donc juste énumérer les exceptions:

0 (zéro)

Puisque l'accumulateur est préréglé à zéro, nous pouvons l'afficher en utilisant un seul caractère:

o

Essayez-le en ligne!

1

Semblable à zéro, cela incrémente l’accumulateur pour obtenir 1.

^o

Essayez-le en ligne!

5

Le code ASCII pour 5 est 53, donc j'ai dû contourner ce problème:

6vo

Essayez-le en ligne!

une

Comme ail s'agit de la fonction de sortie de caractères, il n'y a pas d'autre moyen de produire le caractère a, c'est donc mon seul DID NOT PROGRAM. .

Voir tous les programmes ici

Matlab, 1238 1224 octets, 2 DNP

Le motif principal est:

disp([<char code> ''])

Pour les chiffres, c'est un peu plus court:

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

Pour les personnages []'c'est:

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

Les caractères dsde dispsont affichés en utilisant fprintf( merci @Stewie Griffin ); ipCependant, je dois aussi déplacer la chaîne et utiliser eval:

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

Les deux caractères ()sont cependant nécessaires pour dispou eval, ils sont donc DNP.

Pour référence la liste complète:

    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

Gelée (non compétitive), 406 octets

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Ọ

Ceci imprime tous les caractères de 32 à 126. Le nombre d'octets est calculé avec https://mothereff.in/byte-counter .

Essayez-le en ligne!

Befunge-93, 530 octets

Le moyen le plus simple de générer un caractère, sans utiliser ce dernier, consiste à calculer la valeur ASCII et à utiliser la commande ,(sortie de caractère) pour le restituer. Par exemple,49*,@ affiche le caractère dollar (ASCII 36, 4 * 9). Ceci est rarement le plus optimal, car la plupart des valeurs nécessitent plus de 3 octets à calculer.

Une autre façon de générer un nombre sur 3 octets consiste à tirer parti du fait que la gcommande (get) située dans la première cellule du champ de lecture générera la valeur ASCII de g (une pile vide est supposée être remplie de zéros; lecture de la valeur de playfield à 0,0). Ainsi, g1+,@vous obtenez h , et g1-,@vous f . Cela fonctionne évidemment pour une gamme de compensations et d'opérations autres que +et -sont également possibles. Ainsi, par exemple, g3/,@vous obtenez un devis double.

Une variante de ceci consiste à faire précéder le gavec une autre commande qui laisse tous les zéros sur la pile. Donc, vous lisez toujours une valeur du champ de jeu à 0,0, mais le personnage en cours de lecture est maintenant différent. Cela coûte un octet de plus, mais vous donne accès à beaucoup plus de valeurs. Par exemple, 0g1-,@vous obtenez une barre oblique et :g1+,@un point-virgule. D' autres préfixes viables comprennent *, +, -, >, \et _. Et notez encore que d’autres opérations sont possibles: >g2*,@vous procurer une barre verticale.

Une autre variante consiste à faire précéder le gavec un 1, de sorte que vous ne lisez plus maintenant à partir de 0,0, mais à partir de la cellule vide à 0,1. Dans Befunge, les cellules vides sont initialisées avec des espaces par défaut, 1g,@vous obtenez donc un espace, et1g1+,@ un point d'exclamation.

Pour les caractères numériques, il y a une astuce plus douteuse que nous pouvons utiliser. Au lieu d'essayer de les sortir sous forme de caractères, nous les produisons sous forme de nombres (un petit nombre est plus facile à générer que son équivalent ASCII). Ainsi, par exemple, 11+.@vous en donne 2 et notez en particulier les cas particuliers: .@pour 0 et !.@pour 1 . La partie douteuse de ceci est qu'une sortie numérique dans Befunge inclut un espace après le nombre, donc ce n'est pas une sortie de caractère pur.

Une autre astuce douteuse que nous pouvons utiliser est une variante de la gtechnique ci-dessus. Au lieu de nous limiter aux commandes Befunge pour le préfixe, nous pouvons également utiliser techniquement tout caractère qui n'est pas une commande Befunge. Sur la plupart des interprètes, une commande non reconnue sera ignorée. Le glecteur lira alors la valeur ASCII du caractère précédent. Cela nous permet de générer la plupart des autres valeurs ASCII qui, autrement, ne pourraient pas être calculées sur 3 octets. A titre d'exemple: Qg1+,@vous obtenez R .

Enfin, il y a trois cas spéciaux. Un g ne peut pas être généré dans moins de 5 octets, nous devons donc recourir à "f"1+,@. Une virgule est le plus compliqué, ce qui nécessite une modification de la dynamique de la zone de jeu: 0g4-:80p @. Nous pourrions utiliser une technique similaire pour éviter le caractère différent, mais un hack plus efficace consiste à utiliser la %commande (modulo) comme terminateur, c'est-à-dire 88*,%. Quand le% atteinte est atteinte, il n'y a plus rien sur la pile. Le calcul modulo génère une division par zéro, ce qui met fin au programme sur l'interpréteur de référence.

Vous trouverez ci-dessous la liste complète des programmes, un par ligne.

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