[Question]
  [
In a [programming language](http://meta.codegolf.stackexchange.com/a/2073/26997) of your choice, write 95 programs, each of which outputs a different one of the [95 printable ASCII characters](https://en.wikipedia.org/wiki/ASCII#Printable_characters) ***without that character occurring anywhere in the program***.
For example, if your language was [Python](https://en.wikipedia.org/wiki/Python_(programming_language)), your program that outputs the character `P` might be
```
print(chr(80))
```
because `P` has ASCII code 80. This program is valid because `P` never appears in the source code. However, for the program that outputs lowercase `p`, something like
```
print(chr(112))
```
would be invalid because, while it does print `p`, `p` is present in the code. A valid program could be
```
exec(chr(112)+'rint(chr(112))')
```
which prints `p` but does not contain `p`.
**Your goal is to make each of your 95 programs as short as possible.** Your ***score*** is the sum of the character lengths of all your programs.
If for any reason you are unable to write valid programs for some characters, you may mark those characters as "Did Not Program" or ***DNP***, and omit programs for them entirely. This way syntactically strict languages will be able to compete.
**The winning answer is the answer that has the lowest score *of* the set of answers that have the fewest DNP's.**
# Rules
* The source code of all of your programs may only contain [printable ASCII](https://en.wikipedia.org/wiki/ASCII#Printable_characters) plus tabs and newlines, all of which are counted as one character. (Because in a different encoding it would be easy to omit characters that don't exist!)
	+ **Note:** This rule seems necessary but there are many languages with different encodings and I'm sure it'd be cool to see the answers for them. Therefore **you can break this rule**, you can use whatever characters you want, **but then your answer becomes non-competitive**, it cannot win.
* The programs must be actual, full *programs*, according to your language's standard conventions. Functions and [REPL](https://en.wikipedia.org/wiki/Read%E2%80%93eval%E2%80%93print_loop) snippets are not allowed.
* Each program's output should go to stdout or your language's accepted alternative.
* Programs should not prompt for or require input. (If prompting for input is inherent to your language, that's ok.)
* Programs should be deterministic, finite in run time, and independent. e.g. it shouldn't matter if one is run in a folder separate from the other programs.
* A program's output should be the precise printable ASCII character it corresponds to, optionally followed by a single trailing newline, nothing more, nothing less.
Be sure to include information on all 95 (ideally) programs in your answer, as well as your score and any DNP's. You don't have to list *all* programs that follow a simple pattern like "`print(chr(80))`, `print(chr(81))`, `print(chr(82))`..." but make sure you're sure they all *would* work and that your score is added correctly.
For reference, here are the 95 [printable ASCII](https://en.wikipedia.org/wiki/ASCII#Printable_characters) your programs must output:
```
 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~
```
  
[Answer]
# Python 2, ~~1075~~ ~~1065~~ ~~1043~~ ~~1040~~ 1039 bytes
Each program has the form `print'\<octal char code>'`, except:
* `'` → `print"\47"`
* `0` through `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"'`
For reference and ease of testing, here's the full list of programs, newline-separated.
```
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'
```
To test:
```
$ python printables.py | sed ':a;N;$!ba;s/\n//g'
 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~
```
*-1 bytes thanks to @Sp3000!*
[Answer]
# CJam, 269 bytes
Each of the programs are in the form `'<char - 1>)` except for:
* Space => `S`, 1 byte
* `'` => `39c`, 3 bytes
* `)` => `'*(`, 3 bytes
* `0` => `T`, 1 byte
* `1` => `X`, 1 byte
* `2` => `Y`, 1 byte
* `3` => `Z`, 1 byte
* `4`-`9` => `<num-1>)`, 2 bytes
Score is: `3 * 82 + 1 + 3 + 3 + 4 * 1 + 6 * 2 = 269`
[Answer]
## Brainfuck, ~~1770~~ ~~1710~~ ~~1703~~ 1686 bytes
*60 bytes saved by Dennis*  
*17 bytes saved by Sp3000*
DNP: 46 (`.`)
```
>-[-[-<]>>+<]>-.
>-[-[-<]>>+<]>.
>-[-[-<]>>+<]>+.
>-[++>+[<]>+]>.
+[->-[---<]>-]>.
>-[+<[-<]>>++]<.
>+[-->+[<]>-]>-.
>+[-->+[<]>-]>.
>+[-->+[<]>-]>+.
--[>+<++++++]>--.
--[>+<++++++]>-.
-----[[----<]>>-]<.
--[>+<++++++]>+.
+[+[+>]<<++++]>.
+[-[--<]>>--]<.
-[>+<-----]>---.
-[>+<-----]>--.
-[>+<-----]>-.
-[>+<-----]>.
-[>+<-----]>+.
-[>+<-----]>++.
-[>+<-----]>+++.
>-[++>+[+<]>]>-.
>-[++>+[+<]>]>.
>-[++>+[+<]>]>+.
>-[++[+<]>>+<]>.
>+[+[<]>->++]<.
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.
+[-[>+<<]>-]>--.
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.
+[-[>+<<]>-]>.
-[+[>+<<]>+]>.
>+[+[<]>>+<+]>.
--[++>+[<]>+]>.
+[->-[--<]>-]>.
+[->-[--<]>-]>+.
+[->-[--<]>-]>++.
-[+[>---<<]>+]>.
-[>+<-------]>--.
-[>+<-------]>-.
-[>+<-------]>.
-[>+<-------]>+.
-[>+<-------]>++.
>+[+<[-<]>>++]<.
>+++[[-<]>>--]<.
+[+[>>+<+<-]>]>.
-[+>++[++<]>]>-.
-[+>++[++<]>]>.
-[>+<---]>----.
-[>+<---]>---.
-[>+<---]>--.
-[>+<---]>-.
-[>+<---]>.
-[>+<---]>+.
-[>+<---]>++.
-[+[+<]>>+]<.
-[+[+<]>>+]<+.
-[+[+<]>>+]<++.
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.
+[->---[-<]>-]>.
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.
>-->+[+[+<]>>+]<.
>+[+[>+<+<]>]>-.
>+[+[>+<+<]>]>.
+[-[---<]>>-]<-.
+[-[---<]>>-]<.
>-[--[<]>+>-]<.
-[>++<-----]>--.
-[>++<-----]>-.
-[>++<-----]>.
-[>++<-----]>+.
+[->-[<]>--]>-.
+[->-[<]>--]>.
+[->-[<]>--]>+.
>+[++[++>]<<+]>.
>+[++[++>]<<+]>+.
+[->-[<]>+>--]>.
-[>--<-------]>.
>+[+>+[<]>->]<.
>+[+>+[<]>->]<+.
-[+>+++++[<]>+]>.
>+[-->++[<]>-]>.
+[->->-[<]>--]>.
+[->->-[-<]>-]>.
+[->>-[-<+<]>]>.
----[>+++++<--]>.
------[>+++<--]>.
>+[>+[<]>->+]<-.
>+[>+[<]>->+]<.
----[>+++<--]>.
--[>+<--]>----.
--[>+<--]>---.
--[>+<--]>--.
--[>+<--]>-.
```
All except 43, 45, 60, 62, 91 and 93 are shamelessly stolen from [Esolangs.org](https://esolangs.org/wiki/Brainfuck_constants)
[Answer]
## ASCII constrained x86 Machine Code for DOS, ~~3104~~ ~~3101~~ 2913 bytes
*Well... It's shorter than Java, I guess...*
~~32~~ 30 bytes for almost all characters, for exceptions see below.
Most of the time it just follows the pattern:
1. Do some `xor` to get a pointer to the end.
2. `sub` from the last 2 words because the opcode for `int` is not in ASCII.
3. Get 2 into `AH` and the character into `DL`. Both are `xor`ed because the character itself can't appear in the program and 2 is not a printable ASCII character.
4. Print the character with `int 21h`
5. Exit with `int 20h`
Most of the time, if a character is disallowed, it can be replaced by either twiddling with the data a bit or switching to a different register.
It gets a bit more interesting when you suddenly find yourself unable to subtract or unable to push or pop the only register usable for calculations...
```
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
```
[Answer]
# Java 8, ~~6798~~ ~~6582~~ 6577 bytes
*sigh*
This is basically a port of [my Python 2 answer](https://codegolf.stackexchange.com/a/90530/56755), but with all the boilerplate that comes with writing a full program in Java.
Now without any DNPs at all! Thanks, Kevin Cruijssen!
Most of the programs have the form `interface A{static void main(String[]a){System.out.print("\<octal char code>");}}`, except:
* space → `interface\tA{static\tvoid\tmain(String[]a){System.out.print("\40");}}` (but with the `\t`s replaced by raw tabs)
* `"` → `interface A{static void main(String[]a){System.out.print('\42');}}`
* `(` → `interface A{static void main\u0028String[]a){System.out.print\u0028"\50");}}`
* `)` → `interface A{static void main(String[]a\u0029{System.out.print("\51"\u0029;}}`
* `.` → `interface A{static void main(String[]a){System\u002Eout\u002Eprint("\56");}}`
* `0` → `interface A{static void main(String[]a){System.out.print(1-1);}}`
* `1` → `interface A{static void main(String[]a){System.out.print(3-2);}}`
* `2` → `interface A{static void main(String[]a){System.out.print(3-1);}}`
* `3` → `interface A{static void main(String[]a){System.out.print(4-1);}}`
* `4` → `interface A{static void main(String[]a){System.out.print(5-1);}}`
* `5` → `interface A{static void main(String[]a){System.out.print(6-1);}}`
* `6` → `interface A{static void main(String[]a){System.out.print(7-1);}}`
* `7` → `interface A{static void main(String[]a){System.out.print(8-1);}}`
* `8` → `interface A{static void main(String[]a){System.out.print(9-1);}}`
* `9` → `interface A{static void main(String[]a){System.out.print(8+1);}}`
* `;` → `interface A{static void main(String[]a){System.out.print("\73")\u003B}}`
* `A` → `interface B{static void main(String[]a){System.out.print("\101");}}`
* `S` → `interface A{static void main(\u0053tring[]a){\u0053ystem.out.print("\123");}}`
* `[` → `interface A{static void main(String...a){System.out.print("\133");}}`
* `\` → `interface A{static void main(String[]a){System.out.print((char)92);}}`
* `]` → `interface A{static void main(String...a){System.out.print("\135");}}`
* `a` → `interf\u0061ce A{st\u0061tic void m\u0061in(String[]b){System.out.print("\141");}}`
* `c` → `interfa\u0063e A{stati\u0063 void main(String[]a){System.out.print("\143");}}`
* `d` → `interface A{static voi\u0064 main(String[]a){System.out.print("\144");}}`
* `e` → `class A{public static void main(String[]a){Syst\u0065m.out.print("\145");}}`
* `f` → `class A{public static void main(String[]a){System.out.print("\146");}}`
* `g` → `interface A{static void main(Strin\u0067[]a){System.out.print("\147");}}// \u0067`
* `i` → `\u0069nterface A{stat\u0069c vo\u0069d ma\u0069n(Str\u0069ng[]a){System.out.pr\u0069nt("\151");}}`
* `m` → `interface A{static void \u006Dain(String[]a){Syste\u006D.out.print("\155");}}`
* `n` → `class A{public static void mai\u006E(Stri\u006Eg[]a){System.out.pri\u006Et("\156");}}`
* `o` → `interface A{static v\u006Fid main(String[]a){System.\u006Fut.print("\157");}}`
* `p` → `interface A{static void main(String[]a){System.out.\u0070rint("\160");}}`
* `r` → `class A{public static void main(St\u0072ing[]a){System.out.p\u0072int("\162");}}`
* `s` → `interface A{\u0073tatic void main(String[]a){Sy\u0073tem.out.print("\163");}}`
* `t` → `class A{public s\u0074a\u0074ic void main(S\u0074ring[]a){Sys\u0074em.ou\u0074.prin\u0074("\164");}}`
* `u` → `interface A{static void main(String[]a){System.console().printf("%c",117);}}`
* `v` → `interface A{static \u0076oid main(String[]a){System.out.print("\166");}}`
* `y` → `interface A{static void main(String[]a){S\u0079stem.out.print("\171");}}`
* `{` → `interface A\u007Bstatic void main(String[]a)\u007BSystem.out.print("\173");}}`
* `}` → `interface A{static void main(String[]a){System.out.print("\175");\u007D\u007D`
*Phew*
The Java compiler processes Unicode escapes like `\u007B` before doing any other processing, which makes it possible to write code which uses unicode escapes in identifiers and even keywords. So, to write a program that doesn't use a character present in the boilerplate, we simply substitute it with it unicode escape.
For reference and ease of testing, here's the full list of programs, newline-separated and with the raw tabs replaced by four spaces:
```
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");}}
```
Note that the program for `u` makes use of `System.console()`, which will return null (and thus cause the code to throw a `NullPointerException`) if you call it from anything other than your OS' native terminal (`cmd` on Windows, and, I assume, `bash` on Linux/OSX). 
To test, make a new directory and put the above code in a file named `printables` in that directory. Then, run the following Bash script:
```
#!/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*
```
The above script will put each line of `printables` into its own directory, name them all `A.java` (except for the file which prints `A`, which is renamed to `B.java`), compile each file, run them, then delete the evidence. It should take about ten seconds for the printable ASCII characters to start appearing in your shell.
If you're on Windows, instead run the following Batch file:
```
@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
```
This batch file takes a slightly different approach; instead of pre-splitting the lines, it processes the file line-by-line and compiles and runs each program in turn. Again, it deletes the evidence after it finishes.
*Saved countless bytes + the 1 DNP thanks to Kevin Cruijssen!*
[Answer]
# MATL, ~~305, 302, 300~~ 297 bytes
Every single program looks like this:
```
33c
34c
35c
....
```
Except for
* Digits. Here are the programs for 0-9:
```
O
l
H
I
K
4Q
5Q
6Q
7Q
8Q
```
* 'c'. This program is
```
'C'k
```
* space. This is
```
0c
```
Since today I learned, that MATL treats character 0 as space. *Thanks @LuisMendo!*
You can use [matl.tio](http://matl.tryitonline.net/) to verify any of them. 
For reference, here is all of them:
```
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
```
[Answer]
## [><>](http://esolangs.org/wiki/Fish), ~~443~~ 437 bytes
[TIO interpreter link](http://fish.tryitonline.net). There's a lot of patterns here:
* **`[num][num]*o;`:** Multiplication of two numbers, then output the result as a char with `o` and halt with `;`. ><> digits go up to 15, i.e. `0123456789abcdef`.
	+ Similarly `[num][num]-n;`, which takes the difference of two numbers and outputs as a number with `n` instead.
* **`'-o[invalid char]`:** ><> is toroidal, so when the instruction pointer reaches the end of a line it moves back to the beginning. In this case, this causes the code to be executed twice, i.e. `'-o[char]'-o[char]`. The first `'-o[char]'` part pushes three chars to the stack, `-` calculates `'o' - [char]` then `o` outputs the result as a character. ><> then errors out when it reaches `[char]`, either due to an unrecognised command or from popping an empty stack.
	+ Similarly `'-n[invalid char]`, which outputs as a number.
	+ Similarly `'[num][op]o[invalid char]`, which applies `[op]` with `[num]` on `[char]`, erroring out on char. For example, `'2+oJ` outputs `L`, which is two more than `J`.
	+ `'`'s code is `"-oH`, using `"` instead.
	+ `-`'s code is `'%oB`, using `%` instead.
* **`ln;`**: Push length of stack, output as num then halt, giving `0`. Similarly `lln;` for `1` and `'ln;` for `3`.
* **`4|n+`:** Push 4, bounce off the `|` and push another 4, add, then output `8` as num. Bounce off the `|` again, and error out trying to execute `n` again on an empty stack.
	+ Similarly `3|n*` for `9`.
	+ Similarly `[num]|o*` for `@Qdy`.
* **`'1-:00p`:** The most interesting one, for the `o` case. To avoid using `o` in our code, we need to use `p` to place an `o` in the codebox, then run it. The initial `'1-:00p'` sets the stack up to have a `p` on top, and `1-` decrements it into an `o`. `:` duplicates this `o`, and `00p` places one `o` at (0, 0), turning the codebox into `o1-:00p`. The instruction pointer wraps again, outputting the other `o`. The (0, 0) char is then replaced a few more times before the program finally errors out.
```
      '-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;
```
[Answer]
# [Dyalog APL](http://goo.gl/9KrKoM), ~~527~~ 522 [bytes](http://meta.codegolf.stackexchange.com/a/9429/43319)
(non-competing because APL cannot really be written using ASCII only)
Most are in the format `nn⊃⎕AV` or `nnn⊃⎕AV`, the exceptions being:
```
⊃''     ⍝ 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
```
Here is the entire list:
```
⊃''
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
```
[Answer]
# Ruby, 869 bytes
For the 63 characters `@` through `~`, we have a 10-byte solution:
```
$><<"\xxx"     (3 digit octal code)
$><<92.chr     (special case for \)
```
For most (21) characters from `space` through `?`, we have a 9-byte solution:
```
puts"\xx"     (2 digit octal code)
```
There are eleven special cases left:
```
$><<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 total, the score is 10×63 + 9×21 + 10 + 3 + 8×4 + 5 = 869.
[Answer]
# [WolframAlpha](https://www.wolframalpha.com/), 368 bytes
**General format:**
```
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
```
**Here is the full list:**
```
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
```
[Answer]
# PHP (~~891~~ ~~680~~ 674 bytes, ~~2~~ 0 DNP)
**Edit:** saved 203 bytes thanks to jimmy23013 and implemented the 2 DNP thanks to Mego
---
This answer heavily abuses PHP's generous nature. Most of the cases take one of these forms (7 bytes each):
```
<?=Y^x;
<?=Z&e;
<?=V|Z;
```
PHP converts the letters on either side of the operator to strings, then performs the appropriate bitwise operation by converting each string to its ASCII character value, and finally converts the result *back* to a character.
In the first example above, `Y^x` becomes `89^78`. The result of this is `33`, which is then sent to STDOUT as the character `!`.
A script was written to bruteforce all possible combinations: the results can be found [here](https://3v4l.org/PqLjr).
---
**Exceptions:**
`;` is `<?=Z^a?>` (8 bytes)  
`|` is `<?='9'^E;` (9 bytes)
`<` and `?` would normally be DNP due to the required start tag, but by using the `-r` flag, code can be executed without them:
`<` is `echo Z^f;` (9 bytes)  
`?` is `echo Z^e;` (9 bytes)  
`=` is `echo Z^g;` (9 bytes) 
---
**Score:**
(7 \* 90) + 8 + 9 + 9 + 9 + 9 = 674 bytes
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), ~~546~~ 477 bytes
**Credits to Fatalize for the code for `@`.**
In the list below, the first character is the character to be printed (for easy reference).
```
  @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
```
They are all predicates, so `Z` needs to be the argument to receive the output: [Try it online!](http://brachylog.tryitonline.net/#code=&input=&args=Wg)
---
## Explanation
`@P` is this string:
```
 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~
```
which contains every printable ASCII.
[Answer]
# [><>](http://esolangs.org/wiki/Fish), 531 bytes
The programs take two main forms:
```
##*o;
"chr-1"1+o;
```
The first is for characters with character codes with two factors both less than 16, the other is for the other cases. Most numbers that I use the second form for have many equal length solutions, but I chose that one for readability.
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
```
Full list:
```
! 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;
```
[Answer]
## [Hexagony](https://github.com/m-ender/hexagony), ~~376~~ 373 bytes, 1 DNP
*Thanks to FryAmTheEggman for saving 3 bytes.*
Almost all programs have the same form:
```
  P0;@
! P1;@
" P2;@
...
| Y2;@
} Y3;@
~ Y4;@
```
There are a few exceptions though:
* It's impossible to print `;` without using `;`, hence 1 DNP.
* To print `@`, we cannot use `@` to terminate the program. Instead we use either `S2;:` or `S3;%`. This terminates with a division-by-zero error, but that error is not visible on STDOUT. So this is still four bytes.
* There is one clash for `U` which would require `U3;@`. There are several ways to fix this, including switching to lower-case, i.e. `n9;@`, or using increment or decrement, i.e. `T);@` or `V(;@`. In any case it's still four bytes.
* Memory edges are initialised to `0`, and `!` prints an integer value, so we can get `0` and `1` with `!@` and `)!@`, respectively, saving 3 bytes.
As for how the `<letter><digit>;@` programs work: the hexagonal layout of a program of the form `1234` is always
```
 1 2
3 4 .
 . .
```
Since none of the programs contain any commands that redirect control flow, these are simply linear programs that are executed in order.
In every case, the letter at the beginning of the code sets the current memory edge to its character code. E.g. in the program `P1;@`, the `P` sets the value `80`. Then the digit multiplies this value by 10 and adds itself (i.e. the digit is appended to the current value). That gives `801` in the example above. Finally, `;` prints this value by taking it modulo 256 and using it as a byte value. In this case `801 % 256 = 33` and a `!` is printed.
[Answer]
# Marbelous, 220 bytes
For a character that is not a digit, it is just the two uppercase hex digits of the character code. For example, the following program outputs `A`:
```
41
```
For a digit that is not `3`, replace `2F` in the following code by the uppercase hex digits of the character code - 1:
```
2F
++
```
For `3`:
```
66
>>
```
Total score: 2\*85 + 5\*10 = 220.
[Interpreter.](https://codegolf.stackexchange.com/a/40808/25180)
My first try was Bubblegum and it didn't work for characters before `?`...
[Answer]
# [Whitespace](http://esolangs.org/wiki/Whitespace), 1643 bytes, 1 DNP
17 bytes for the characters [33-63] and 18 bytes for characters [64-126]
In Whitespace this is straight forward, because printable characters (except space) don't have any meaning anyway:
```
[SPACE][SPACE][SPACE][TAB][SPACE][SPACE][SPACE][SPACE][TAB][LF]
[TAB][LF]
[SPACE][SPACE][LF]
[LF]
[LF]
```
The program above prints a '!' (100001b).
Change `[TAB][SPACE][SPACE][SPACE][SPACE][TAB]` in the first line to whichever character you like.
It's not possible to print a space without using a space, because printing anything always starts with `[TAB][LF][SPACE]`
[Answer]
## [Retina](https://github.com/m-ender/retina/), 712 bytes, 2 DNPs
This was a collaborative effort with FryAmTheEggman.
There are several classes of solutions. For most characters from space to `^`, we use a program of the following form:
```
_
T`w`p
```
The character on the second line iterates through the ranges `_0-9A-Za-z` while the rest remains unchanged. This turns the empty input into that character and then replaces it with the printable ASCII character (represented by `p`) at the corresponding position. Each of these programs is 8 bytes long.
Within this range, there are only a few exceptions. Most importantly the digits can be shortened:
* 0: `x` (counts the number of `x`s in the empty input)
* 1:  (weehoo, empty program; counts the number of empty matches in the empty input)
* 2: now we turn the input into a single character, before counting empty strings:
```
1
```
* 3: same thing but we turn the input into two characters:
```
11
```
* 4: you get the idea...
```
111
```
* 5 - 9: plot twist... we use character repetition to avoid the second line getting any longer:
```
4$*
```
...
```
8$*
```
The other exception is that `T` is a DNP: we don't think it's possible to generate a non-digit character without it appearing in the source code if transliteration stages can't be used.
On to the remaining characters. To print `_` we use a similar program as the general solution above:
```
0
T`0`w
```
Making use of the fact that `w` starts with `_`.
Next, ``` is the second DNP, because transliteration stages require those as well.
Then most of the lower-case letters are printed with something like this (which prints `a`):
```
_
T`w`l
```
Again, the character on the second line increments through `_0-9A-O`. Here, we just need to watch out for `l` and `w`, which we can print with the following programs, respectively:
```
P
T`p`w
```
```
6
T`p`l
```
Finally, only `{|}~` are left, which require 9 bytes each. Here, we use the transliteration stage to increment the character that precedes them. E.g. `~` can be printed with:
```
}
T`_p`p
```
[Answer]
## Pyke, ~~364~~ ~~362~~ 355 bytes
```
2*1 + 3*2 + 14*3 + 2*4 + 5 + 73*4
```
All in the form `w<chr(charcode+32)>.C` (4 bytes) except for:
* -> `d` 1 byte
* `0` -> `Z` 1 byte
* `1` -> `~W` 2 bytes
* `a` -> `Gh` 2 bytes
* `z` -> `Ge` 2 bytes
* First 10 lowercase alphabet letters (except `a`) in form `G<number>@` (3 bytes)
* `k` -> `GT@` 3 bytes
* `>` -> `~Bh` 3 bytes
* `]` -> `~Be` 3 bytes
* `Z` -> `~le` 3 bytes
* `9` -> `~ue` 3 bytes
* `w` -> `G22@` 4 bytes
* `.` -> `~B4@` 4 bytes
* `C` -> `~K38@` 5 bytes
[Online Pyke interpreter](http://pyke.catbus.co.uk/)
[Answer]
## JavaScript (ES6), ~~1083~~ 1068 bytes
General form:
```
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: Saved 15 bytes thanks to @GOTO0.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/), 417 bytes
```
!   62D>B
"   63D>B
#   64D>B
$   65D>B
%   66D>B
&   67D>B
'   68D>B
(   69D>B
)   70D>B
*   71D>B
+   72D>B
,   73D>B
-   74D>B
.   75D>B
/   76D>B
0   1<
1   X
2   Y
3   Z
4   3>
5   4>
6   5>
7   6>
8   7>
9   8>
:   77D>B
;   78D>B
<   79D>B
=   80D>B
>   81D1+B
?   82D>B
@   83D>B
A   Th
B   T>h
C   T>>h
D   T3+h
E   T4+h
F   T5+h
G   16D>B
H   17D>B
I   18D>B
J   19D>B
K   20D>B
L   21D>B
M   22D>B
N   23D>B
O   24D>B
P   25D>B
Q   26D>B
R   27D>B
S   28D>B
T   29D>B
U   30D>B
V   31D>B
W   33D>B
X   33D>B
Y   A`\u
Z   A`u
[   84D>B
\   85D>B
]   86D>B
^   87D>B
_   88D>B
`   89D>B
a   A`r
b   A`r\
c   38D>B
d   39D>B
e   40D>B
f   41D>B
g   42D>B
h   43D>B
i   44D>B
j   45D>B
k   46D>B
l   47D>B
m   48D>B
n   49D>B
o   50D>B
p   51D>B
q   52D>B
r   53D>B
s   54D>B
t   55D>B
u   56D>B
v   57D>B
w   58D>B
x   A`\\
y   A`\
z   A`
{   90D>B
|   91D>B
}   92D>B
~   93D>B
```
**Explanation**
Most are 5 bytes long of the form: `convert nr to base nr+1`.  
`>` needs an extra byte since we can't use increment for that.
`a,b,x,y,z,Y,Z` are extracted from `A` which contains the alphabet in lower case.
`A,B,C,D,E,F` are numbers converted to hex.
`0-9` are simple increment/decrements as well as predefined variables.
[Answer]
# Perl 6: 921 bytes
Translation of the Python solution.
Each program has the form `say "\x<hex escape code>"`, except:
* `s` → `put "\x73"`
* `a` → `put "\x61"`
* `y` → `put "\x79"`
* → `"\x20".say`
* `"` → `say chr 34`
* `\` → `say chr 92`
* `x` → `say chr 120`
* `0` → `say 1-1`
* `1` → `say 3-2`
* `2` to `9` → `say <n minus one>+1`
For reference and ease of testing, here's the full list of programs, newline-separated.
```
"\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"
```
Here's the code I used to test the above listing, and count the 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;
```
[Answer]
# Haskell, ~~1874 1864 1856 1855 1795 1791~~ 1589 bytes, 7 DNPs
Most programs are `main=putChar '\xx'` or `main=putChar '\xxx'` where `xx`/`xxx` is the ascii code of the char to be printed.
This works for all but 14 chars:
```
 !"#$%& ()*+,-./0123456789:;< >?@AB DEFGHIJKLMNOPQRSTUVWXYZ[ ]^_` bcdefg  jkl  o q s  vwxyz{|}~
       '                     =     C                        \    a      hi   mn p r tu        
```
However, for the digits ~~1 7~~ 4 bytes can be saved (thanks to Christian Sievers!):
```
0   main=print$1-1
1   main=print$3-2
2   main=print$1+1
3   main=print$1+2
...
```
The 52 programs up to `c` (code 99) take 18 bytes, the remaining 19 take 19 bytes each.
*Partial score:* `10*14 + 52*18 + 19*19 = 1437`
For 7 of the remaining chars, the following programs work:
```
    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'])
```
*Partial score:* `18 + 22 + 18 + 21 + 19 + 27 + 27 = 152`
This leaves 7 DNPs: `=aimnrt`
Each Haskell program needs to define a main (`main=`), so that's 5 DNPs. To print to stdOut, `putChar`, `putStr` or `interact` can be used, yielding `t` and `r` as further DNPs. (There is also `print`, however `print 'a'` prints `'a'` and not `a` - and also contains `t` and `r` anyway.)
Haskell also has a `chr` function which returns the corresponding char given a number, however in order to use it `import Data.Char` is needed.
**Total score:** `1437 + 152 = 1589`, 7 DNPs
[Answer]
# Malbolge, 618 bytes.
This answer is pretty much obvious, and it's trivial to outgolf, but it may be worth to give a shot.
Jokes aside, I highly doubt you can golf it, just the `(` and '<' ones.
```
 :7 - (&<`M^\
!:7 - (C<;_"K
":7 - (&&$_L]
#:8 - (&<;_L\J
$:7 - D'<A:^K
%:8 - (=&;_L]J
&:7 - D'%`M#o
':6 - (&%`M^
(:16 - DCBA@?>~<;{98xUB
):8 - (&<%:^KJ
*:7 - (&<`M]>
+:7 - (&&;_L]
,:7 - (=&;_L>
-:6 - D'%%_L
.:7 - ('%`M9o
/:6 - (=B;_L
0:6 - ('%$_L
1:7 - (&a%M"o
2:8 - (=&;:^"J
3:7 - ('<;_L"
4:7 - ('%;_L]
5:6 - D'%`#L
6:6 - (=<`:L
7:7 - (&<;:^K
8:8 - ('&;$9]J
9:7 - ('<;:^K
::6 - (&%`M?
;:8 - (C<A:^"J
<:10 - ('&%#^"J~Z
=:7 - DC&$_#K
>:6 - (&%`#L
?:6 - (=<`@L
@:7 - (&B%:^K
A:7 - (&<`M^8
B:5 - (&a%M
C:6 - D'%`M#
D:6 - (&%`M"
E:7 - ('&$_L\
F:7 - (&%$:^K
G:6 - (&%;_L
H:7 - ('&;:^K
I:6 - (C<;_L
J:6 - D'<;_L
K:7 - (&a%M^!
L:7 - (=<;_#K
M:7 - ('%$#^K
N:7 - (&&;_#K
O:7 - DC&$:^K
P:5 - (&a;M
Q:8 - ('%A$9]J
R:6 - (&<`M?
S:7 - (&a%M]\
T:5 - (=a;M
U:6 - D'<%_L
V:5 - (&aAM
W:5 - (=aNM
X:6 - (=aN_#
Y:7 - (&&$:^K
Z:7 - DC&$_"K
[:7 - (&%$_"K
\:1 - Q
]:5 - ('<`M
^:6 - ('B;_L
_:6 - (&<`M#
`:7 - DC&;_L"
a:6 - ('%`M#
b:7 - ('%;_9K
c:5 - (&aN_
d:6 - (&<`:L
e:7 - (&%;_"K
f:6 - (=<;_L
g:7 - ('%;_#K
h:7 - (&a%M^"
i:7 - ('%`M^"
j:8 - (=B;:^"J
k:5 - ('%`M
l:5 - (&&`M
m:6 - (&%`:L
n:7 - D'%;_Lo
o:6 - (=aN_9
p:6 - (CB;_L
q:7 - D'%A:^K
r:4 - (=aN
s:5 - (C<`M
t:7 - (&%;_L]
u:5 - (&aN:
v:6 - D'%`:L
w:7 - (&B;:^K
x:5 - (=a$M
y:5 - D'<`M
z:7 - (&%%:^K
{:5 - (=aN_
|:5 - (&a$M
}:5 - (&aN#
~:7 - (&%$_L"
```
[Answer]
# BBC Basic, ~~422~~ 413 bytes
Download interpreter free at <http://www.bbcbasic.co.uk/bbcwin/bbcwin.html>
9 bytes saved thanks to Leaky Nun.
**General form**
```
V.<character code>
```
**32..99** excluding 12 special cases: 56x4= **224 bytes**
**100..126** : 27x5= **135 bytes**
**12 special cases : 54 bytes**
Most numbers follow the general form, but I included them all here to show where the problem is.
First character is the character to be printed.
```
. 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
```
[Answer]
# [Minkolang 0.15](https://github.com/elendiastarman/Minkolang), 604 bytes
For most characters, `"<char-1>"1+O.` would be a valid program, perhaps one of the shortest. However, due to the fact that characters are stored as code points on the stack means that many of them can be produced by multiplication and addition, in five bytes or fewer. Also, note that `l, $1, $2, $3, $4, $5, $6, $l` are `10, 11, 12, 13, 14, 15, 16, 100` respectively.
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.
```
### Special mentions:
```
.: "-"1+d$10pO-
```
[(Try it.)](http://play.starmaninnovations.com/minkolang/?code=%22-%221%2Bd%2410pO-) Minkolang has the ability to modify the characters in the code box, so what this program does is that it replaces that `-` at the end with `.`, which is necessary for stopping the program. [`"N"1+d90pN.`](http://play.starmaninnovations.com/minkolang/?code=%22N%221%2Bd90pN%2E) for `O` works the same way.
```
4: lZIO.
```
[(Try it.)](http://play.starmaninnovations.com/minkolang/?code=lZIO%2E) `lZ` pushes the uppercase and lowercase alphabets to the stack, and `I` pushes the length of the stack, which is 52, precisely the code point of "4". The best part is that I was initially considering the solution of `4$3*O.`, which multiplies 4 and 13 to get 52, but couldn't because it had a 4 in it, so I ended up finding a golfier solution anyway!
```
y: $1d*O.
```
[(Try it.)](http://play.starmaninnovations.com/minkolang/?code=%241d*O%2E) `d` duplicates the top of stack, so what this piece of code does is that it pushes `11`, duplicates it, and then multiplies. An alternate way to write this would have been `$12;O.`, which has the same byte count.
```
}: 53;O.
```
[(Try it.)](http://play.starmaninnovations.com/minkolang/?code=53%3BO%2E) `;` is exponentiation, so this does 5^3 to get 125.
[Answer]
# Groovy, 1019 bytes
I had a different Groovy solution written up (see below), but after I submitted it I did a bit more digging into character escapes, hoping to find a way of shortening the program more, and discovered that Groovy has an octal character escape that I did not know of. This significantly simplifies the code, to the point that it unfortunately removes the need for almost all of the quirky workarounds I had come up with.
It also looks almost identical to [Copper's Python 2 solution](https://codegolf.stackexchange.com/a/90530/58776), to the point where it basically looks like I plagiarized their work. Ugh.
Each program has the form `print'\<octal value>'`, except:
* `p`, `r`, `i`, `n`, `t` → `'print''\<octal value>'` (but with the matching letter of "print" also replaced with the octal value)
* `0` - `9` → `print~-<next int>`
Here is the full list of programs by character.
```
    print'\40'
!   print'\41'
"   print'\42'
#   print'\43'
$   print'\44'
%   print'\45'
&   print'\46'
'   print'\47'
(   print'\50'
)   print'\51'
*   print'\52'
+   print'\53'
,   print'\54'
-   print'\55'
.   print'\56'
/   print'\57'
0   print~-1
1   print~-2
2   print~-3
3   print~-4
4   print~-5
5   print~-6
6   print~-7
7   print~-8
8   print~-9
9   print~-10
:   print'\72'
;   print'\73'
<   print'\74'
=   print'\75'
>   print'\76'
?   print'\77'
@   print'\100'
A   print'\101'
B   print'\102'
C   print'\103'
D   print'\104'
E   print'\105'
F   print'\106'
G   print'\107'
H   print'\110'
I   print'\111'
J   print'\112'
K   print'\113'
L   print'\114'
M   print'\115'
N   print'\116'
O   print'\117'
P   print'\120'
Q   print'\121'
R   print'\122'
S   print'\123'
T   print'\124'
U   print'\125'
V   print'\126'
W   print'\127'
X   print'\130'
Y   print'\131'
Z   print'\132'
[   print'\133'
\   print'\134'
]   print'\135'
^   print'\136'
_   print'\137'
`   print'\140'
a   print'\141'
b   print'\142'
c   print'\143'
d   print'\144'
e   print'\145'
f   print'\146'
g   print'\147'
h   print'\150'
i   'pr\151nt''\151'
j   print'\152'
k   print'\153'
l   print'\154'
m   print'\155'
n   'pri\156t''\156'
o   print'\157'
p   '\160rint''\160'
q   print'\161'
r   'p\162int''\162'
s   print'\163'
t   'prin\164''\164'
u   print'\165'
v   print'\166'
w   print'\167'
x   print'\170'
y   print'\171'
z   print'\172'
{   print'\173'
|   print'\174'
}   print'\175'
~   print'\176'
```
# Groovy, 1130 bytes
My previous program, before I discovered that octal escapes exist. Much more interesting, IMO.
Each program has the form `print(--'<next char>')`, except:
* `-`, `[`, `~` → `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>`
Here is the full list of programs for each character:
```
    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(++'}')
```
[Answer]
# Fourier, 306 bytes, 1 DNP
Pretty much all of the programs follow the pattern `na` where n is the character code of each of the characters. For example:
```
!       33a
"       34a
#       35a
$       36a
%       37a
&       38a
'       39a
```
[**Try it online!**](http://fourier.tryitonline.net/#code=MzNhIDM0YSAzNWEgMzZhIDM3YSAzOGEgMzlh&input=)
So I'll just list the exceptions:
## 0 (Zero)
Since the accumulator is preset to zero, we can display this using a single character:
```
o
```
[**Try it online!**](http://fourier.tryitonline.net/#code=bw&input=)
## 1
Similar to zero, this increments the accumulator to get 1.
```
^o
```
[**Try it online!**](http://fourier.tryitonline.net/#code=Xm8&input=)
## 5
The ASCII code for 5 is 53, so I had to work around this:
```
6vo
```
[**Try it online!**](http://fourier.tryitonline.net/#code=NnZv&input=)
## a
Due to `a` being the character output function, there is no other way to produce the character a, so this my only **DID NOT PROGRAM**.
## See all of the programs [here](http://pastebin.com/raw/Cgg0KyTj)
[Answer]
## Matlab, ~~1238~~ 1224 bytes, 2 DNP
The main pattern is:
```
disp([<char code> ''])
```
For digits it's a little shorter:
```
disp(<sum or difference of two other digits>)
```
For characters `[]'` it's:
```
" " -- disp([0,''])
"[" -- disp(char(91))
"]" -- disp(char(93))
"'" -- disp(char(39))
```
Characters `ds` from `disp` are displayed using `fprintf` (*thanks [@Stewie Griffin](https://codegolf.stackexchange.com/users/31516/stewie-griffin)*); `ip` however belong also there, so I'm shifting the string and using `eval`:
```
d -- fprintf([100 ''])
i -- eval(['ejtq)(j(*'-1 ''])
s -- fprintf([115 ''])
p -- eval(['ejtq)(q(*'-1 ''])
```
Both characters `()` are however necessary for `disp` or `eval`, so they are DNP.
---
For reference the whole list:
```
    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
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly "Jelly, by Dennis Mitchell") (non-competitive), 406 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
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Ọ
```
This prints all characters from 32 - 126. The byte count is calculated with <https://mothereff.in/byte-counter>.
[Try it online!](http://jelly.tryitonline.net/#code=MzLhu4w&input=&args= "Jelly ASCII print")
[Answer]
# Befunge-93, 530 bytes
The easiest way to output a character, without actually using that character, is to calculate the ASCII value and use the `,` (character output) command to render it. For example, [`49*,@`](http://befunge.tryitonline.net/#code=NDkqLEA) outputs the dollar character (ASCII 36, 4 \* 9). This is rarely the most optimal, though, since most values take more than 3 bytes to calculate.
Another way to generate a number in 3 bytes is to take advantage of the fact that the `g` (get) command in the first cell of the playfield will generate the ASCII value of *g* (an empty stack is assumed to be populated with zeros, so it's reading the playfield value at 0,0). Thus [`g1+,@`](http://befunge.tryitonline.net/#code=ZzErLEA) gets you *h*, and [`g1-,@`](http://befunge.tryitonline.net/#code=ZzEtLEA) gets you *f*. This obviously works for a range of offsets, and operations other than `+` and `-` are also possible. So for example [`g3/,@`](http://befunge.tryitonline.net/#code=ZzMvLEA) gets you a double quote.
A variation of this, is to precede the `g` with another command that leaves all zeros on the stack. So you're still reading a value from the playfield at 0,0, but the character being read is now different. This costs one more byte, but gets you access to many more values. For example, [`0g1-,@`](http://befunge.tryitonline.net/#code=MGcxLSxA) gets you a forward slash and [`:g1+,@`](http://befunge.tryitonline.net/#code=OmcxKyxA) gets you a semicolon. Other viable prefixes include `*`, `+`, `-`, `>`, `\` and `_`. And again note that other operations are possible: [`>g2*,@`](http://befunge.tryitonline.net/#code=PmcyKixA) get you a vertical bar.
A further variation is to precede the `g` with a `1`, so you're now no longer reading from 0,0, but from the blank cell at 0,1. In Befunge, empty cells are initialized with spaces by default, so [`1g,@`](http://befunge.tryitonline.net/#code=MWcsQA) gets you a space, and [`1g1+,@`](http://befunge.tryitonline.net/#code=MWcxKyxA) gets you an exclamation mark.
For the digit characters, there's more dubious trick we can use. Instead of trying to output them as characters, we output them as numbers (a small number is easier to generate than its ASCII equivalent). So for example, [`11+.@`](http://befunge.tryitonline.net/#code=MTErLkA) gives you *2*, and in particular note the special cases: [`.@`](http://befunge.tryitonline.net/#code=LkA) for *0*, and [`!.@`](http://befunge.tryitonline.net/#code=IS5A) for *1*. The dubious part of this is that a numeric output in Befunge includes a space after the number, so it's not a pure character output.
Another dubious trick we can use is a variation of the `g` technique above. Instead of limiting ourselves to Befunge commands for the prefix, we can also technically use any character that isn't a Befunge command. On most interpreters an unrecognised command will be ignored, so the `g` will end up reading the ASCII value of the preceding character. This enables us to generate most other ASCII values that couldn't otherwise be calculated in 3 bytes. As one example: [`Qg1+,@`](http://befunge.tryitonline.net/#code=UWcxKyxA) gets you *R*.
Finally, there are three special cases. A *g* can't be generated in fewer than 5 bytes, so we have to resort to [`"f"1+,@`](http://befunge.tryitonline.net/#code=ImYiMSssQA). A comma is the most complicated, requiring dynamic modification of the playfield: [`0g4-:80p @`](http://befunge.tryitonline.net/#code=MGc0LTo4MHAgQA). We could use a similar technique to avoid the at character, but a more efficient hack is to use the `%` (modulo) command as the terminator, i.e. [`88*,%`](http://befunge.tryitonline.net/#code=ODgqLCU). When the `%` is reached there is nothing on the stack, so the modulo calculation generates a division by zero, and on the reference interpreter this will terminate the program.
Below is the full list of programs, one per line.
```
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*,@
```
]