Imprimez tous les caractères ASCII imprimables sans les utiliser


56

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{|}~

Si, dans mon codage, 0x30 code pour, disons, plutôt que 0, puis-je supposer que les ASCII imprimables sont les 95 normaux, moins 0, ajouter?
Leaky Nun

4
Quelle? Vous devez utiliser ASCII imprimable. C'est juste une règle.
Hobbies de Calvin

Je crois qu'il y a des encodages qui n'ont pas la représentation exacte de 0x30 sous la forme0
Leaky Nun

@LeakyNun EBCDIC
TuxCrafting

2
@ Tim Non ne suit pas la règle d'indépendance.
Hobbies de Calvin

Réponses:


25

Python 2, 1075 1065 1043 1040 1039 octets

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

  • 'print"\47"
  • 0à travers 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"'

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!


print~-<N+1>ne fonctionne pas pour 1. Vous avez dit qu'il travaille pour 0à 8.
haykam

7
@ Peanut C'est le cas. Le code dans <angle brackets>n'est pas un code littéral. Remplacez <N+1>par la valeur littérale de N+1; dans ce cas, le programme 1serait print~-2. Voir la liste complète des programmes.
Cuivre

21

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


39cpour '? En outre, vous oubliez qu'un seul chiffre peut être juste ce nombre
Sp3000

1
@ Sp3000 ils ne peuvent pas parce que cela inclurait le caractère que vous produisez dans l'entrée
Bleu

Mais ensuite, utilisez 1)for 2pour sauvegarder un octet
Luis Mendo

Désolé, 1)c'était ce que je voulais dire oui
Sp3000

En outre, il y aTXYZ
Sp3000

12

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

11

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


3
@ βετѧΛєҫαγ Probablement puisqu'il a été en grande partie copié.
Les passe-temps de Calvin

8
@ HelkaHomba Je veux dire, les constantes BF sont fondamentalement les plus courtes de ce que je sais. Essayer de le faire vous-même sur des constantes déjà établies est inutile.
Insane

3
--[>-<---]>[<->--]<[->-<]>.travaille pour la sortie +.
Dennis

3
@Dennis Un peu plus tard:-----[[----<]>>-]<.
Sp3000 Le

2
Aussi+[+[+>]<<++++]>.
Sp3000

9

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

@LuisMendo Je compte toujours 297
DJMcMayhem

@ LuisMendo, je compte 297 aussi.
Leaky Nun

Désolé, mon erreur
Luis Mendo

9

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

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!


2
J'adore le hasard class Bpour l'impressionA
Tas

Tu m'as battu à ça. Hier, à la fin de la journée, j’écrivais une réponse pour Java en utilisant également des échappements Unicode. Ah bon, +1, une réponse bien écrite et un seul DNP n’est pas aussi mauvais que je le pensais auparavant pour Java. ;)
Kevin Cruijssen

2
Au fait, il y a une possibilité de supprimer le DNP pour u si vous utilisez Java 8+ ( interfaceau lieu de classe afin de pouvoir le supprimer public) et si votre système d'exploitation possède une console intégrée, vous n'avez donc pas à utiliser System.out.print: interface A{static void main(String[]a){System.console().printf("%1",(char)117);}}Eclipse, IntelliJ et les compilateurs en ligne ne disposent pas de cette console, ce qui entraîne un NullPointerException.
Kevin Cruijssen

@KevinCruijssen Merci! Je travaille sur le remaniement maintenant.
Cuivre

n: oublié de s'échapperprint
WeaponsGrade

7

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

7

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

1
Ce format est moins utile que le format des autres réponses, à mon avis
Leaky Nun

@ LeakyNun Voulez-vous dire de les regrouper par méthode? Il y a pas mal d'exceptions.
Adám

2
Ce ne sont pas tous des fichiers ASCII imprimables, donc techniquement invalides. Mais je vais ajouter une note indiquant que le format ASCII non imprimable est autorisé pour les soumissions non compétitives.
Les passe-temps de Calvin

@ HelkaHomba Oups, je n'ai pas remarqué cette exigence.
Adám

est mon nouveau smiley préféré
Lucas Trzesniewski

6

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.


Pour les échappements octaux, vous pouvez utiliser ?\xxxau lieu de "\xxx"1 octet chacun.
Jordanie

Pourquoi p 1+8et pas p-~8?
Cyoce

@Cyoce Ruby interprète cela comme binaire -, ou quelque chose comme ça. :(
Lynn

@Jordan A noté, mais je suis paresseux… n'hésitez pas à faire le montage / récapitulation n_n
Lynn

2
Vous pouvez faire la plupart de ces courtes avec putc 65=>A
histocrat

5

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

5

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


@ jimmy23013 Oups, j'ai mal lu la documentation.
Mego

Vous pouvez utiliser & | ^entre deux lettres pour générer tous les caractères ascii imprimables, à l'exception de <?=|;.
jimmy23013

@ jimmy23013 C'est dingue. Juste au moment où je pensais avoir appris toutes les bizarreries de PHP!
Clamburger

1
de nombreuses solutions de formulaire standard pourraient être optimisées pour enregistrer un octet avec NOT binaire ~au lieu de XOR, AND ou OR. PHP peut utiliser plus de caractères imprimables comme constantes que de simples lettres.
Fabian Schmengler

1
@fschmengler Malheureusement, autant que je sache, cela nécessiterait l'utilisation de caractères ASCII étendus (ou de caractères unicodes de plus en plus exotiques), ce qui, à mon avis, n'est pas valable pour ce défi.
Clamburger

4

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.



@Fatalize Merci, mis à jour.
Leaky Nun

4

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

Vos ;utilisations ;. En outre, je suis à peu près sûr que la plupart d’entre elles peuvent être gâchées par une erreur, et qu’elles osont tout à fait possibles.
Sp3000

@ Sp3000 Sauf s'il existe un interprète qui accepte les deux oet Oje ne vois pas comment oc'est possible. Et comment se terminer par une erreur serait-il plus court?
DanTheMan

opeut être fait en utilisant p. Je pourrais poster séparément pour erreur, car il y aura probablement beaucoup de modèles différents impliqués.
Sp3000

@ Sp3000 J'ai cependant corrigé le ;programme. Merci d'avoir fait remarquer cela!
DanTheMan

4

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


4

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]


2
L'espace est un caractère ASCII imprimable ("ASCII imprimable" se rapportant à la plage 0x20 à 0x7E, inclus), vous devrez donc l'inclure en tant que 1 DNP sauf si vous pouvez trouver un moyen de l'imprimer sans utiliser d'espaces. En dehors de cela, s'il vous plaît inclure le score du programme.
Martin Ender

4

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

Avec la nouvelle version de Retina, il est possible d'imprimer toutes les lettres (même le T) avec quatre octets avec $ L et $ u ... Je ne pouvais toujours pas trouver un moyen d'imprimer le backtick sans l'utiliser, vous pensez que c'est possible?
Leo

@Leo Non, je ne le pense pas. Je voulais ajouter un autre opérateur binaire à la syntaxe de substitution, ce qui serait une extension de plage, ce qui résoudrait le problème. Je dois savoir comment je veux exactement le mettre en œuvre. Une autre option serait une fonctionnalité de syntaxe de substitution permettant de travailler avec des points de code.
Martin Ender

3

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


3

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.


"x" nécessite également un traitement spécial. En outre, utilisez alert(atob`XA`)pour "\" pour enregistrer quelques octets.
GOTO 0

@ GOTO0 Ugh, je ne peux pas croire que j'ai oublié x.
Neil

1
Javascript permet des \uéchappées en code source? Cool
Cyoce

@Cyoce: Dans les identifiants, oui, en général, non.
Bergi

Les échappements @Bergi Unicode sont traités en premier. Vous pouvez donc écrire votre source entière sous forme d'échappements Unicode, si vous le souhaitez, tandis que les échappements Hex fonctionnent uniquement à l'intérieur de chaînes.
Neil

3

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.


3

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


3

Perl 6: 921 octets

Traduction de la solution Python.

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

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

  • "\x20".say

  • "say chr 34
  • \say chr 92
  • xsay chr 120
  • 0say 1-1
  • 1say 3-2
  • 2à 9say <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;

@sch en Perl 5 cela fonctionnerait, mais j'ai essayé de le faire en Perl 6, où l'espace après sayest requis et les séquences d'échappement octales sont écrites comme \o77. N'hésitez pas à poster une solution Perl 5 séparée ... :)
smls

Désolé, j'ai raté la partie perl 6 de votre réponse.
sch

3

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

La plupart des programmes sont main=putChar '\xx'ou main=putChar '\xxx'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


1
Avec les nouvelles lignes facultatives autorisées, nous pouvons obtenir des chiffres comme celui-ci: main=print$1-1etc.
Christian Sievers,

Votre programme p utilise p (mais peut facilement être corrigé avec succ)
Christian Sievers

2

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

Pourquoi ne pas utiliser V.48pour 0?
Leaky Nun

@ LeakyNun 9 octets enregistrés, merci!
Level River St

Woah, les commandes V.et P.ont toujours été là?
Beta Decay

@ βετѧΛєҫαγ Oui, mais l'éditeur les étend aux mots entiers VDU et PRINT après la frappe (mais ils sont interprétés sans extension à la ligne de commande BASIC). La plupart des lettres majuscules suivies de .se développeront en mot clé. Ce défi est strict quant à l’utilisation d’ASCII non imprimable, mais avec d’autres défis, vous pourriez dire que les mots-clés marqués (ascii 127-255) correspondaient à un octet. Cela dit, je n'ai jamais essayé cet argument et donne généralement les deux scores.
Level River St

@LevelRiverSt I see
Beta Decay

2

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.


2

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

2

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.


:dans 5:9P2*c
Mego

@ Mego Merci, ajouté.
Leaky Nun

2

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


2

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

Est-ce que quelque chose comme [100 105 115 112](codes de caractères) fonctionne disp?
Leaky Nun

Que voulez-vous dire exactement? disp([100 105 115 112])ne produira pas de chaîne, eval([100 105 115 112])non plus.
pajonk

Vous pouvez utiliser fprintfpour d ans s: fprintf([115,'']). Enregistre 2x7 octets =) Je ne ferai pas une soumission gagnante, mais hé: 14 octets correspondent à 14 octets ,,,
Stewie Griffin

Aussi: disp([0 ''])contient un espace. disp([0,''])ne le fait pas
Stewie Griffin

@StewieGriffin Merci, j'ai raté la première. Merci aussi pour le tour avec fprintf.
pajonk

2

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!


1
Je ne pense pas que ce soit une réponse valable. Tout d'abord, vous n'êtes pas autorisé à prendre une entrée, et ensuite, il s'agit d' un programme et non de 95 programmes. Le défi ditIn 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, je vais changer cela
Soren

DJ est correct. Ceci est manifestement invalide.
Hobbies de Calvin le

@ HelkaHomba est mon nombre d'octets compte le total de tous les programmes?
Soren

1
Merci de l'avoir corrigé et bienvenue sur le site! J'espère que vous l'apprécierez ici. De plus, juste pour que vous sachiez que Jelly utilise une page de code personnalisée , il s'agit donc réellement de 406 caractères, même si ce serait 503 en UTF-8.
DJMcMayhem

2

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*,@
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.