In un linguaggio di programmazione a tua scelta, scrivi 95 programmi, ognuno dei quali genera uno diverso dei 95 caratteri ASCII stampabili senza che quel carattere si presenti in nessun punto del programma .

Ad esempio, se la tua lingua era Python , il tuo programma che emette il personaggio Ppotrebbe essere

print(chr(80))

perché Pha il codice ASCII 80. Questo programma è valido perché Pnon appare mai nel codice sorgente. Tuttavia, per il programma che genera lettere minuscole p, qualcosa del genere

print(chr(112))

sarebbe non valido perché, mentre stampa p, pè presente nel codice. Un programma valido potrebbe essere

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

che stampa pma non contiene p.

Il tuo obiettivo è rendere ciascuno dei tuoi 95 programmi il più breve possibile. Il tuo punteggio è la somma delle lunghezze dei caratteri di tutti i tuoi programmi.

Se per qualsiasi motivo non si è in grado di scrivere programmi validi per alcuni caratteri, è possibile contrassegnarli come "Non programmati" o DNP e ometterli completamente. In questo modo le lingue sintatticamente rigorose saranno in grado di competere.

La risposta vincente è la risposta che ha il punteggio più basso del set di risposte che hanno il minor numero di DNP.

Regole

• Il codice sorgente di tutti i tuoi programmi può contenere solo schede ASCII plus stampabili e nuove righe, tutte contate come un carattere. (Perché con una codifica diversa sarebbe facile omettere caratteri che non esistono!)

  • Nota: questa regola sembra necessaria ma ci sono molte lingue con codifiche diverse e sono sicuro che sarebbe bello vedere le risposte per loro. Quindi puoi infrangere questa regola , puoi usare qualunque personaggio tu voglia, ma poi la tua risposta diventa non competitiva , non può vincere.

• I programmi devono essere effettivi, programmi completi , secondo le convenzioni standard della tua lingua. Le funzioni e gli snippet REPL non sono consentiti.

• L'output di ogni programma dovrebbe andare su stdout o l'alternativa accettata nella tua lingua.

• I programmi non devono richiedere o richiedere input. (Se la richiesta di input è inerente alla tua lingua, va bene.)

• I programmi dovrebbero essere deterministici, limitati in fase di esecuzione e indipendenti. ad esempio, non dovrebbe importare se uno viene eseguito in una cartella separata dagli altri programmi.

• L'output di un programma dovrebbe essere il preciso carattere ASCII stampabile a cui corrisponde, facoltativamente seguito da una nuova riga finale, niente di più, niente di meno.

Assicurati di includere informazioni su tutti i 95 programmi (idealmente) nella tua risposta, così come il tuo punteggio e tutti i DNP. Non è necessario elencare tutti i programmi che seguono uno schema semplice come " , ...", ma assicuratevi sei sicuro che tutti avrebbero lavorare e che il punteggio viene aggiunta correttamente.print(chr(80))print(chr(81))print(chr(82))

Per riferimento, ecco le 95 ASCII stampabili che i tuoi programmi devono produrre:

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

Python 2, 1075 1065 1043 1040 1039 byte

Ogni programma ha il modulo print'\<octal char code>', tranne:

• ' → print"\47"
• 0attraverso 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"'

Per riferimento e facilità di test, ecco l'elenco completo dei programmi, separati da una nuova riga.

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'

Testare:

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

-1 byte grazie a @ Sp3000!

CJam, 269 byte

Ciascuno dei programmi è nella forma ad '<char - 1>)eccezione di:

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

Il punteggio è: 3 * 82 + 1 + 3 + 3 + 4 * 1 + 6 * 2 = 269

Codice macchina x86 vincolato ASCII per DOS, 3104 3101 2913 byte

Beh ... è più corto di Java, immagino ...

32 30 byte per quasi tutti i caratteri, per le eccezioni vedi sotto.

Il più delle volte segue solo lo schema:

1. Fai alcuni xorper ottenere un puntatore alla fine.
2. subdalle ultime 2 parole perché il codice operativo per intnon è in ASCII.
3. Ottieni 2 in AHe il personaggio in DL. Entrambi sono modificati xorperché il personaggio stesso non può apparire nel programma e 2 non è un carattere ASCII stampabile.
4. Stampa il personaggio con int 21h
5. Esci con int 20h

La maggior parte delle volte, se un carattere non è consentito, può essere sostituito sia ruotando un po 'con i dati o passando a un altro registro.

Diventa un po 'più interessante quando improvvisamente ti trovi incapace di sottrarre o incapace di spingere o far apparire l'unico registro utilizzabile per i calcoli ...

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 byte

60 byte salvati da Dennis
17 byte salvati da Sp3000

DNP: 46 ( .)

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

Tutti tranne 43, 45, 60, 62, 91 e 93 vengono sottratti senza vergogna a Esolangs.org

MATL, 305, 302, 300 297 byte

Ogni singolo programma è simile al seguente:

33c
34c
35c
....

Eccetto per

• Cifre. Ecco i programmi per 0-9:

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

• 'C'. Questo programma è

  'C'k
  

• spazio. Questo è

  0c
  

  Da oggi ho imparato che MATL considera il carattere 0 come spazio. Grazie @LuisMendo!

Puoi usare matl.tio per verificarne uno.

Per riferimento, eccone tutti:

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 byte

sospiro

Questa è fondamentalmente una porta della mia risposta Python 2 , ma con tutta la piastra di caldaia che viene fornita con la scrittura di un programma completo in Java.

Ora senza alcun DNP a tutti! Grazie, Kevin Cruijssen!

La maggior parte dei programmi ha la forma interface A{static void main(String[]a){System.out.print("\<octal char code>");}}, tranne:

• spazio → interface\tA{static\tvoid\tmain(String[]a){System.out.print("\40");}}(ma con le \ts sostituite da schede non elaborate)
• " → 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

Uff

Il compilatore Java elabora gli escape Unicode come \u007Bprima di qualsiasi altra elaborazione, il che rende possibile scrivere codice che utilizza gli escape unicode negli identificatori e persino nelle parole chiave. Quindi, per scrivere un programma che non usa un personaggio presente nella piastra della caldaia, lo sostituiamo semplicemente con la sua fuga unicode.

Per riferimento e facilità di test, ecco l'elenco completo dei programmi, separati da nuova riga e con le schede non elaborate sostituite da quattro spazi:

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

Si noti che il programma per ufare uso di System.console(), che restituirà null (e quindi causerà il lancio del codice a NullPointerException) se lo si chiama da qualsiasi altro terminale diverso dal proprio sistema operativo ( cmdsu Windows e, presumo, bashsu Linux / OSX) .

Per testare, crea una nuova directory e inserisci il codice sopra in un file chiamato printablesin quella directory. Quindi, esegui il seguente script Bash:

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

Lo script sopra inserirà ciascuna riga printablesnella propria directory, nominandoli tutti A.java(ad eccezione del file che stampa A, a cui viene rinominato B.java), compilerà ogni file, eseguirli, quindi eliminerà le prove. Dovrebbero essere necessari circa dieci secondi affinché i caratteri ASCII stampabili inizino a comparire nella shell.

Se sei su Windows, esegui invece il seguente file batch:

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

Questo file batch ha un approccio leggermente diverso; invece di suddividere le linee, elabora il file riga per riga e compila ed esegue ogni programma a turno. Ancora una volta, elimina le prove al termine.

Ha salvato innumerevoli byte + 1 DNP grazie a Kevin Cruijssen!

> <> , 443 437 byte

Link dell'interprete TIO . Ci sono molti schemi qui:

• [num][num]*o;: Moltiplicazione di due numeri, quindi stampa il risultato come carattere con oe termina con ;. > <> cifre fino a 15, ad es 0123456789abcdef.
  • Allo stesso modo [num][num]-n;, che prende invece la differenza di due numeri e genera un numero con n.

• '-o[invalid char]: > <> è toroidale, quindi quando il puntatore dell'istruzione raggiunge la fine di una riga, torna all'inizio. In questo caso, ciò causa l'esecuzione del codice due volte, ad es '-o[char]'-o[char]. La prima '-o[char]'parte spinge tre caratteri nello stack, -calcola 'o' - [char]quindi oemette il risultato come carattere. > <> quindi si interrompe quando raggiunge [char], a causa di un comando non riconosciuto o dallo scoppio di uno stack vuoto.

  • Allo stesso modo '-n[invalid char], che genera un numero.
  • Allo stesso modo '[num][op]o[invalid char], che si applica [op]con [num]on [char], errore su char. Ad esempio, '2+oJoutput L, che è due in più di J.
  • 'il codice è "-oH, usando "invece.
  • -il codice è '%oB, usando %invece.

• ln;: Spingere la lunghezza dello stack, emettere come num quindi arrestare, dando 0. Allo stesso modo lln;per 1e 'ln;per 3.

• 4|n+: Premere 4, rimbalzare |e premere un altro 4, aggiungere, quindi emettere 8come num. Rimbalzare di |nuovo, ed errore durante il tentativo di eseguire nnuovamente su uno stack vuoto.
  • Allo stesso modo 3|n*per 9.
  • Allo stesso modo [num]|o*per @Qdy.
• '1-:00p: Il più interessante, per il ocaso. Per evitare di utilizzare onel nostro codice, è necessario utilizzare pper inserire un onella casella di codice, quindi eseguirlo. L'iniziale '1-:00p'imposta lo stack in modo che abbia un pin cima e lo 1-decrementa in un o. :lo duplica oe ne 00pposiziona uno oin (0, 0), trasformando la codebox in o1-:00p. Il puntatore dell'istruzione si avvolge di nuovo, emettendo l'altro o. Il carattere (0, 0) viene quindi sostituito alcune altre volte prima che il programma alla fine si rompa.

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

(non concorrenziale perché APL non può davvero essere scritto usando solo ASCII)

La maggior parte sono nel formato nn⊃⎕AVo nnn⊃⎕AV, le eccezioni sono:

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

Ecco l'intero elenco:

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

Rubino, 869 byte

Per i 63 caratteri @attraverso ~, abbiamo una soluzione di 10 byte:

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

Per la maggior parte (21) caratteri da spaceattraverso ?, abbiamo una soluzione a 9 byte:

puts"\xx"     (2 digit octal code)

Sono rimasti undici casi speciali:

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

In totale, il punteggio è 10 × 63 + 9 × 21 + 10 + 3 + 8 × 4 + 5 = 869.

WolframAlpha , 368 byte

Formato generale:

u+<character code in hexadecimal>

eccezioni:

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

Ecco l'elenco completo:

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 byte, 2 0 DNP)

Modifica: salvato 203 byte grazie a jimmy23013 e implementato i 2 DNP grazie a Mego

Questa risposta abusa pesantemente della generosa natura di PHP. La maggior parte dei casi assume una di queste forme (7 byte ciascuna):

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

PHP converte le lettere su entrambi i lati all'operatore di stringhe, quindi esegue l'operazione bit appropriato convertendo ogni stringa al suo valore carattere ASCII, ed infine converte il risultato indietro ad un carattere.

Nel primo esempio sopra, Y^xdiventa 89^78. Il risultato è questo 33, che viene quindi inviato a STDOUT come personaggio !.

Uno script è stato scritto per rinforzare tutte le possibili combinazioni: i risultati possono essere trovati qui .

eccezioni:

;è <?=Z^a?>(8 byte)
|è <?='9'^E;(9 byte)

<e ?normalmente sarebbe DNP a causa del tag iniziale richiesto, ma usando il -rflag, il codice può essere eseguito senza di loro:

<è echo Z^f;(9 byte)
?è echo Z^e;(9 byte)
=è echo Z^g;(9 byte)

Punto:

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

Brachylog , 546 477 byte

Crediti a Fatalize per il codice per @.

Nell'elenco seguente, il primo carattere è il carattere da stampare (per un facile riferimento).

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

Sono tutti predicati, quindi Zdeve essere l'argomento per ricevere l'output: provalo online!

Spiegazione

@P è questa stringa:

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

che contiene ogni ASCII stampabile.

> <> , 531 byte

I programmi assumono due forme principali:

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

Il primo è per i personaggi con codici carattere con due fattori entrambi inferiori a 16, l'altro è per gli altri casi. La maggior parte dei numeri per i quali utilizzo il secondo modulo ha molte soluzioni di uguale lunghezza, ma ho scelto quella per leggibilità.

eccezioni:

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

Lista completa:

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

Esagonia , 376 373 byte, 1 DNP

Grazie a FryAmTheEggman per aver salvato 3 byte.

Quasi tutti i programmi hanno la stessa forma:

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

Ci sono alcune eccezioni però:

• È impossibile stampare ;senza usare ;, quindi 1 DNP.
• Per stampare @, non possiamo usare @per terminare il programma. Invece usiamo uno S2;:o S3;%. Questo termina con un errore di divisione per zero, ma quell'errore non è visibile su STDOUT. Quindi questo è ancora quattro byte.
• C'è uno scontro per il Uquale richiederebbe U3;@. Esistono diversi modi per risolvere questo, tra il passaggio di lettere minuscole, cioè n9;@, o utilizzando incremento o decremento, cioè T);@o V(;@. In ogni caso sono ancora quattro byte.
• I bordi di memoria sono inizializzati 0e !stampano un valore intero, in modo che possiamo ottenere 0e 1con !@e )!@, rispettivamente, salvare 3 byte.

Per quanto riguarda il funzionamento dei <letter><digit>;@programmi: il layout esagonale di un programma del modulo 1234è sempre

 1 2
3 4 .
 . .

Poiché nessuno dei programmi contiene comandi che reindirizzano il flusso di controllo, si tratta semplicemente di programmi lineari che vengono eseguiti in ordine.

In ogni caso, la lettera all'inizio del codice imposta il bordo di memoria corrente sul suo codice carattere. Ad esempio nel programma P1;@, Pimposta il valore 80. Quindi la cifra moltiplica questo valore per 10 e si aggiunge (ovvero la cifra viene aggiunta al valore corrente). Questo dà 801nell'esempio sopra. Infine, ;stampa questo valore prendendolo modulo 256 e utilizzandolo come valore byte. In questo caso 801 % 256 = 33e !viene stampato a.

Spazio bianco , 1643 byte, 1 DNP

17 byte per i caratteri [33-63] e 18 byte per i caratteri [64-126]

In Whitespace questo è semplice, perché i caratteri stampabili (tranne lo spazio) non hanno comunque alcun significato:

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

Il programma sopra stampa un '!' (100001b). Cambia [TAB][SPACE][SPACE][SPACE][SPACE][TAB]nella prima riga il carattere che preferisci. Non è possibile stampare uno spazio senza usare uno spazio, perché la stampa di qualcosa inizia sempre con[TAB][LF][SPACE]

Retina , 712 byte, 2 DNP

Questo è stato uno sforzo collaborativo con FryAmTheEggman.

Esistono diverse classi di soluzioni. Per la maggior parte dei personaggi dallo spazio a ^, utilizziamo un programma nel seguente formato:

_
T`w`p

Il personaggio sulla seconda riga scorre le gamme _0-9A-Za-zmentre il resto rimane invariato. Questo trasforma l'input vuoto in quel carattere e poi lo sostituisce con il carattere ASCII stampabile (rappresentato da p) nella posizione corrispondente. Ciascuno di questi programmi è lungo 8 byte.

All'interno di questo intervallo, ci sono solo alcune eccezioni. Soprattutto le cifre possono essere abbreviate:

• 0: x(conta il numero di xs nell'input vuoto)
• 1:  (weehoo, programma vuoto; conta il numero di corrispondenze vuote nell'input vuoto)

• 2: ora trasformiamo l'input in un singolo carattere, prima di contare le stringhe vuote:

  
  1
  
  

• 3: stessa cosa ma trasformiamo l'input in due caratteri:

  
  11
  
  

• 4: hai avuto l'idea ...

  
  111
  
  

• 5 - 9: twist della trama ... usiamo la ripetizione del personaggio per evitare che la seconda riga si allunghi ancora:

  
  4$*
  
  

  ...

  
  8$*
  
  

L'altra eccezione è che si Ttratta di un DNP: non pensiamo che sia possibile generare un carattere non numerico senza che appaia nel codice sorgente se non è possibile utilizzare le fasi di traslitterazione.

Dai personaggi rimanenti. Per stampare _utilizziamo un programma simile come soluzione generale sopra:

0
T`0`w

Facendo uso del fatto che winizia con _.

Successivamente, `è il secondo DNP, perché anche le fasi di traslitterazione richiedono.

Quindi la maggior parte delle lettere minuscole sono stampate con qualcosa del genere (che stampa a):

_
T`w`l

Ancora una volta, il carattere sulla seconda riga aumenta _0-9A-O. Qui, dobbiamo solo fare attenzione le w, che possiamo stampare con i seguenti programmi, rispettivamente:

P
T`p`w

6
T`p`l

Infine, ne {|}~rimangono solo alcuni che richiedono 9 byte ciascuno. Qui, usiamo la fase di traslitterazione per incrementare il carattere che li precede. Ad esempio, ~può essere stampato con:

}
T`_p`p

Pyke, 364 362 355 byte

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

Tutto nel modulo w<chr(charcode+32)>.C(4 byte) ad eccezione di:

• -> d1 byte
• 0-> Z1 byte
• 1-> ~W2 byte
• a-> Gh2 byte
• z-> Ge2 byte
• Prime 10 lettere dell'alfabeto minuscole (tranne a) nella forma G<number>@(3 byte)
• k-> GT@3 byte
• >-> ~Bh3 byte
• ]-> ~Be3 byte
• Z-> ~le3 byte
• 9-> ~ue3 byte
• w-> G22@4 byte
• .-> ~B4@4 byte
• C-> ~K38@5 byte

Interprete Pyke online

JavaScript (ES6), 1083 1068 byte

Forma generale:

alert`\xhex`

eccezioni:

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`

Modifica: salvato 15 byte grazie a @ GOTO0.

05AB1E , 417 byte

!   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

Spiegazione

La maggior parte sono 5 byte lunga della forma: convert nr to base nr+1.
>ha bisogno di un byte extra poiché non possiamo usare l'incremento per quello.

a,b,x,y,z,Y,Zsono estratti da Acui contiene l'alfabeto in minuscolo.

A,B,C,D,E,F sono numeri convertiti in esadecimali.

0-9 sono semplici incrementi / decrementi e variabili predefinite.

Marbelous, 220 byte

Per un carattere che non è una cifra, sono solo le due cifre esadecimali maiuscole del codice del carattere. Ad esempio, vengono emessi i seguenti programmi A:

41

Per una cifra che non lo è 3, sostituire 2Fnel seguente codice le cifre esadecimali maiuscole del codice carattere - 1:

2F
++

Per 3:

66
>>

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

Interprete.

Il mio primo tentativo è stato Bubblegum e non ha funzionato per i personaggi prima ?...

Perl 6: 921 byte

Traduzione della soluzione Python.

Ogni programma ha il modulo say "\x<hex escape code>", tranne:

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

• y → put "\x79"

• → "\x20".say

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

Per riferimento e facilità di test, ecco l'elenco completo dei programmi, separati da una nuova riga.

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

Ecco il codice che ho usato per testare l'elenco sopra e contare il punteggio:

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

La maggior parte dei programmi è main=putChar '\xx'o main=putChar '\xxx'dove xx/ xxxè il codice ASCII del carattere da stampare. Questo funziona per tutti tranne 14 caratteri:

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

Tuttavia, per le cifre è possibile salvare 1 7 4 byte (grazie a Christian Sievers!):

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

I 52 programmi fino a c(codice 99) occupano 18 byte, i restanti 19 prendono 19 byte ciascuno.

Punteggio parziale: 10*14 + 52*18 + 19*19 = 1437

Per 7 dei caratteri rimanenti, funzionano i seguenti programmi:

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

Punteggio parziale: 18 + 22 + 18 + 21 + 19 + 27 + 27 = 152

Questo lascia 7 DNP: =aimnrt

Ogni programma Haskell deve definire un main ( main=), quindi sono 5 DNP. Per stampare sullo standard output, putChar, putStro interactpuò essere utilizzato, cedendo te rcome ulteriori DNPS. (C'è anche print, comunque print 'a'stampa 'a'e non a- e contiene anche te rcomunque.) Haskell ha anche una chrfunzione che restituisce il carattere corrispondente dato un numero, tuttavia per usarlo import Data.Charè necessario.

Punteggio totale: 1437 + 152 = 1589 7 DNP

BBC Basic, 422 413 byte

Scarica l'interprete gratuitamente da http://www.bbcbasic.co.uk/bbcwin/bbcwin.html

9 byte salvati grazie a Leaky Nun.

Forma generale

V.<character code>

32..99 esclusi 12 casi speciali: 56x4 = 224 byte

100..126 : 27x5 = 135 byte

12 casi speciali: 54 byte

La maggior parte dei numeri segue il modulo generale, ma li ho inclusi tutti qui per mostrare dove si trova il problema.

Il primo carattere è il personaggio da stampare.

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

Per la maggior parte dei personaggi "<char-1>"1+O.sarebbe un programma valido, forse uno dei più brevi. Tuttavia, a causa del fatto che i caratteri sono memorizzati come punti di codice nello stack, significa che molti di essi possono essere prodotti per moltiplicazione e addizione, in cinque byte o meno. Inoltre, si noti che l, $1, $2, $3, $4, $5, $6, $lsono 10, 11, 12, 13, 14, 15, 16, 100rispettivamente.

Formato: <character>: <program>

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

Menzioni speciali:

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

(Provalo.) Minkolang ha la possibilità di modificare i caratteri nella casella del codice, quindi quello che fa questo programma è che lo sostituisce -alla fine con ., che è necessario per fermare il programma. "N"1+d90pN.per Ofunziona allo stesso modo.

4: lZIO.

(Provalo). lZ Spinge gli alfabeti maiuscoli e minuscoli nello stack e Ispinge la lunghezza dello stack, che è 52, precisamente il punto di codice di "4". La parte migliore è che inizialmente stavo considerando la soluzione di 4$3*O., che moltiplica 4 e 13 per ottenere 52, ma non potevo perché aveva un 4, quindi alla fine ho trovato una soluzione più golfista!

y: $1d*O.

(Provalo.) d Duplica la parte superiore dello stack, quindi ciò che fa questo pezzo di codice è che lo spinge 11, lo duplica e quindi si moltiplica. Sarebbe stato un modo alternativo per scrivere questo $12;O., che ha lo stesso numero di byte.

}: 53;O.

(Provalo.) ; È esponenziale, quindi questo fa 5 ^ 3 per ottenere 125.

Groovy, 1019 byte

Avevo scritto una soluzione Groovy diversa (vedi sotto), ma dopo averlo inviato ho scavato un po 'di più nelle fughe di caratteri, sperando di trovare un modo per accorciare di più il programma e ho scoperto che Groovy ha una fuga di caratteri ottale che io non lo sapevo. Ciò semplifica notevolmente il codice, al punto che sfortunatamente rimuove la necessità di quasi tutte le strane soluzioni alternative che avevo escogitato.

Sembra anche quasi identico alla soluzione Python 2 di Copper , al punto in cui sembra praticamente aver plagiato il loro lavoro. Ugh.

Ogni programma ha il modulo print'\<octal value>', tranne:

• p, r, i, n, t→ 'print''\<octal value>'(ma con la lettera corrispondente di "stampa" anche sostituito con il valore ottale)
• 0- 9→print~-<next int>

Ecco l'elenco completo dei programmi per carattere.

    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 byte

Il mio programma precedente, prima di scoprire che esistono fughe ottali. Molto più interessante, IMO.

Ogni programma ha il modulo print(--'<next char>'), tranne:

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

Ecco l'elenco completo dei programmi per ciascun personaggio:

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

In realtà , 383 382 381 byte

1 byte grazie a Mego.

Per un facile riferimento, la prima colonna è il codice carattere, la seconda colonna è il carattere e la terza colonna è il codice.

Il codice per 0è un singolo spazio.

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

Provalo online!

I suggerimenti sul golf sono i benvenuti.

Fourier, 306 byte, 1 DNP

Praticamente tutti i programmi seguono il modello in nacui n è il codice carattere di ciascuno dei caratteri. Per esempio:

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

Provalo online!

Quindi elencherò solo le eccezioni:

0 (zero)

Poiché l'accumulatore è preimpostato su zero, possiamo visualizzarlo utilizzando un singolo carattere:

o

Provalo online!

1

Simile a zero, questo aumenta l'accumulatore per ottenere 1.

^o

Provalo online!

5

Il codice ASCII per 5 è 53, quindi ho dovuto aggirare questo:

6vo

Provalo online!

un'

Essendo ala funzione di output del personaggio, non c'è altro modo di produrre il personaggio a, quindi questo è il mio unico NON PROGRAMMA .

Vedi tutti i programmi qui

Matlab, 1238 1224 byte, 2 DNP

Il modello principale è:

disp([<char code> ''])

Per le cifre è un po 'più breve:

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

Per i personaggi []'è:

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

I personaggi dsdi dispvengono visualizzati usando fprintf( grazie @Stewie Griffin ); ipcomunque appartengono anche lì, quindi sto spostando la stringa e usando eval:

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

Entrambi i caratteri ()sono tuttavia necessari per dispo eval, quindi sono DNP.

Per riferimento l'intero elenco:

    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

Gelatina (non competitiva), 406 byte

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Ọ

Stampa tutti i caratteri da 32 a 126. Il conteggio dei byte viene calcolato con https://mothereff.in/byte-counter .

Provalo online!

Befunge-93, 530 byte

Il modo più semplice per generare un carattere, senza effettivamente usarlo, è calcolare il valore ASCII e usare il ,comando (output del carattere) per renderlo. Ad esempio, 49*,@genera il carattere in dollari (ASCII 36, 4 * 9). Questo è raramente il più ottimale, tuttavia, poiché la maggior parte dei valori richiede più di 3 byte per il calcolo.

Un altro modo per generare un numero in 3 byte è trarre vantaggio dal fatto che il gcomando (get) nella prima cella del campo di gioco genererà il valore ASCII di g (si presume che uno stack vuoto sia popolato con zeri, quindi è leggendo il valore del campo di gioco a 0,0). Così g1+,@ti prende h e g1-,@ti fa f . Questo ovviamente funziona per una serie di offset +e -sono possibili anche operazioni diverse da e . Quindi, per esempio, g3/,@ti fa ottenere una doppia citazione.

Una variante di questo, è di precedere il gcon un altro comando che lascia tutti gli zeri nello stack. Quindi stai ancora leggendo un valore dal campo di gioco a 0,0, ma il personaggio che stai leggendo ora è diverso. Questo costa un altro byte, ma ti dà accesso a molti più valori. Ad esempio, 0g1-,@ti offre una barra e :g1+,@un punto e virgola. Altri prefissi vitali includono *, +, -, >, \e _. E ancora una volta nota che sono possibili altre operazioni: >g2*,@procurarti una barra verticale.

Un'ulteriore variazione è quella di precedere la gcon a 1, quindi ora non stai più leggendo da 0,0, ma dalla cella vuota a 0,1. In Befunge, le celle vuote sono inizializzate con spazi per impostazione predefinita, quindi 1g,@ti procura uno spazio e 1g1+,@ti dà un punto esclamativo.

Per i personaggi delle cifre, c'è un trucco più discutibile che possiamo usare. Invece di provare ad emetterli come caratteri, li emettiamo come numeri (un piccolo numero è più facile da generare rispetto al suo equivalente ASCII). Quindi, ad esempio, 11+.@ti dà 2 , e in particolare nota i casi speciali: .@per 0 e !.@per 1 . La parte dubbia di ciò è che un output numerico in Befunge include uno spazio dopo il numero, quindi non è un output di carattere puro.

Un altro trucco discutibile che possiamo usare è una variante della gtecnica sopra. Invece di limitarci ai comandi di Befunge per il prefisso, possiamo anche tecnicamente usare qualsiasi personaggio che non sia un comando di Befunge. Sulla maggior parte degli interpreti un comando non riconosciuto verrà ignorato, quindi gfinirà per leggere il valore ASCII del carattere precedente. Questo ci consente di generare la maggior parte degli altri valori ASCII che altrimenti non potrebbero essere calcolati in 3 byte. Come un esempio: Qg1+,@si ottiene R .

Infine, ci sono tre casi speciali. Un g non può essere generato in meno di 5 byte, quindi dobbiamo ricorrere a "f"1+,@. Una virgola è la più complicata, richiede modifica dinamica del campo di gioco: 0g4-:80p @. Potremmo usare una tecnica simile per evitare il carattere at, ma un trucco più efficiente è usare il %comando (modulo) come terminatore, cioè 88*,%. Quando %viene raggiunto, non c'è nulla nello stack, quindi il calcolo del modulo genera una divisione per zero e sull'interprete di riferimento questo termina il programma.

Di seguito è riportato l'elenco completo dei programmi, uno per riga.

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