[Question]
  [
Choose any five characters your language supports. There are 5! = 5√ó4√ó3√ó2√ó1 = 120 ways these can be arranged into a 5-character string that contains each character once; 120 [permutations](https://en.wikipedia.org/wiki/Permutation).
Choose your characters such that, when each of the 120 strings is run in your language, the 120 outputs produced will be as many unique integers from 1 to 120 (inclusive) as possible.
That is, for each of the 120 permutations of your 5 characters that produce runnable code that outputs a single number, you want the set of all those numbers to match as close as possible to the set of integers from 1 through 120.
So, ideally, your first permutation would output `1`, the next `2`, the next `3`, all the way up to `120`. But that ideal is likely impossible for most languages and characters.
The 5-character strings may be run as:
* a program with no input
* a function with no arguments
* a [REPL](https://en.wikipedia.org/wiki/Read%E2%80%93eval%E2%80%93print_loop) command
Different strings can be run in different ways if desired
For the output to count, it must be a single integer output in a [normal](https://codegolf.meta.stackexchange.com/questions/2447/default-for-code-golf-input-output-methods) way, such as:
* being printed to stdout
* returned by the function
* the result of the REPL expression
The code should terminate normally (which [may involve](https://codegolf.meta.stackexchange.com/a/4781/26997) erroring out as long as the number has been output first). Code that does not run at all is fine, just the (nonexistent) output doesn't count. The numbers output should be in decimal unless a different base is the norm for your language.
**The submission that generates the most distinct numbers from 1 through 120 wins. The earlier submission wins in case of a tie.**
## Notes
* Your 5 characters do not all need to be different, but of course having duplicate characters reduces the effective number of permutations.
* Float outputs such as `32.0` count as well as plain `32`. (But `32.01` would not.)
* Leading zeroes such as `032` count as well as plain `32`.
* Valid outputs should be deterministic and time invariant.
* We are dealing with *characters*, not bytes.
# Example
The characters `123+*` are a reasonable first choice for Python's (or many language's) REPL. The resulting 120 permutations and outputs are:
```
123+* n/a
123*+ n/a
12+3* n/a
12+*3 n/a
12*3+ n/a
12*+3 36
132+* n/a
132*+ n/a
13+2* n/a
13+*2 n/a
13*2+ n/a
13*+2 26
1+23* n/a
1+2*3 7
1+32* n/a
1+3*2 7
1+*23 n/a
1+*32 n/a
1*23+ n/a
1*2+3 5
1*32+ n/a
1*3+2 5
1*+23 23
1*+32 32
213+* n/a
213*+ n/a
21+3* n/a
21+*3 n/a
21*3+ n/a
21*+3 63
231+* n/a
231*+ n/a
23+1* n/a
23+*1 n/a
23*1+ n/a
23*+1 23
2+13* n/a
2+1*3 5
2+31* n/a
2+3*1 5
2+*13 n/a
2+*31 n/a
2*13+ n/a
2*1+3 5
2*31+ n/a
2*3+1 7
2*+13 26
2*+31 62
312+* n/a
312*+ n/a
31+2* n/a
31+*2 n/a
31*2+ n/a
31*+2 62
321+* n/a
321*+ n/a
32+1* n/a
32+*1 n/a
32*1+ n/a
32*+1 32
3+12* n/a
3+1*2 5
3+21* n/a
3+2*1 5
3+*12 n/a
3+*21 n/a
3*12+ n/a
3*1+2 5
3*21+ n/a
3*2+1 7
3*+12 36
3*+21 63
+123* n/a
+12*3 36
+132* n/a
+13*2 26
+1*23 23
+1*32 32
+213* n/a
+21*3 63
+231* n/a
+23*1 23
+2*13 26
+2*31 62
+312* n/a
+31*2 62
+321* n/a
+32*1 32
+3*12 36
+3*21 63
+*123 n/a
+*132 n/a
+*213 n/a
+*231 n/a
+*312 n/a
+*321 n/a
*123+ n/a
*12+3 n/a
*132+ n/a
*13+2 n/a
*1+23 n/a
*1+32 n/a
*213+ n/a
*21+3 n/a
*231+ n/a
*23+1 n/a
*2+13 n/a
*2+31 n/a
*312+ n/a
*31+2 n/a
*321+ n/a
*32+1 n/a
*3+12 n/a
*3+21 n/a
*+123 n/a
*+132 n/a
*+213 n/a
*+231 n/a
*+312 n/a
*+321 n/a
```
There are 36 numbers generated, all luckily within 1 to 120:
```
36, 26, 7, 7, 5, 5, 23, 32, 63, 23, 5, 5, 5, 7, 26, 62, 62, 32, 5, 5, 5, 7, 36, 63, 36, 26, 23, 32, 63, 23, 26, 62, 62, 32, 36, 63
```
However, only 8 of them are unique:
```
36, 26, 7, 5, 23, 32, 63, 62
```
So such a submission would only score 8 out of a maximal 120.
  
[Answer]
# Python3, ~~21~~ 27 values
Characters: `3479%`
Unique numbers: `[1,2,3,4,5,6,7,8,9,11,12,19,20,21,24,29,34,35,36,37,39,43,46,47,49,73,74]`
As it was requested, here are the permutations that fell in the range **[1, 120]**. [Try it online!](https://tio.run/##VYzRCsIwDEXf9xWhUGhBxKkgDvcxQzusbE1IMnFfPzumDs/T4d7k0qh3TIdpahl7iBpYETuB2BOyAgXuB200YpKiaJGBIKa/2JnD8XS2xlcFZJTHRWYEajBm@8CYHPlfzEGGTnMXnk3nZC1iC66ES/29yFbud34dnCGOSZ2xkt3eDFhwsvl8@GUrvK6BtKJGZJre)
```
347%9   5
349%7   6
34%79   34
34%97   34
374%9   5
379%4   3
37%49   37
37%94   37
394%7   2
397%4   1
39%47   39
39%74   39
3%479   3
3%497   3
3%749   3
3%794   3
3%947   3
3%974   3
437%9   5
439%7   5
43%79   43
43%97   43
473%9   5
479%3   2
47%39   8
47%93   47
493%7   3
497%3   2
49%37   12
49%73   49
4%379   4
4%397   4
4%739   4
4%793   4
4%937   4
4%973   4
734%9   5
739%4   3
73%49   24
73%94   73
743%9   5
749%3   2
74%39   35
74%93   74
793%4   1
794%3   2
79%34   11
79%43   36
7%349   7
7%394   7
7%439   7
7%493   7
7%934   7
7%943   7
934%7   3
937%4   1
93%47   46
93%74   19
943%7   5
947%3   2
94%37   20
94%73   21
973%4   1
974%3   2
97%34   29
97%43   11
9%347   9
9%374   9
9%437   9
9%473   9
9%734   9
9%743   9
```
[Answer]
# Python, 18 numbers
```
237#-
```
Produces as valid results:
```
1, 2, 3, 4, 5, 7, 16, 23, 24, 25, 27, 32, 35, 37, 69, 71, 72, 73
```
---
**EDIT:** I can attest that [TuukkaX's solution](https://codegolf.stackexchange.com/a/102664/62393) is optimal for Python.
I ran the following code bruteforcing all possible combinations of 5 printable ASCII characters:
```
from itertools import permutations,combinations_with_replacement
def perms(chars):
  result=set()
  for permut in permutations(chars):
    try:
      current=eval(''.join(permut))
      assert str(int(current))==str(current)
      result.add(int(current))
    except:
      pass
  return sum([1 for x in result if 1<=x<=120])
best=1
for c in combinations_with_replacement(' !"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~',5):
    string=''.join(c)
    r=perms(string)
    if r>=best:
        best=r
        print(r,string,end='\n')
```
The results (after running for almost 7 hours) showed that the optimal solution is in fact 27 different numbers, produced by three different solutions all using four numbers and mod (`%`): `%3479`, `%5679` and `%5789`.
[Answer]
# [05AB1E](http://github.com/Adriandmen/05AB1E), ~~27~~ ~~38~~ 41 numbers
```
4¬∑>√ån
```
Generates the unique numbers:
`[4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 16, 17, 18, 19, 25, 27, 32, 33, 34, 35, 36, 37, 38, 49, 50, 52, 54, 64, 65, 66, 67, 72, 73, 74, 81, 83, 98, 100, 101, 102]`
Uses the constant `4` with the operations `+1`, `+2`, `*2` and `^2`.
[Answer]
# Java 8, ~~2~~ 4 numbers
```
n->12  // returns 12
n->21  // returns 21
n1->2  // returns 2
n2->1  // returns 1
```
Weren't expecting a Java answer, were you?
This is a lambda that can only be arranged one of two ways (and with any two different digits!) for a total of two unique numbers. Everything else isn't a valid lambda.
Actually improved the answer, thanks to some help from comments! Didn't see that 0 wasn't valid, and forgot that variables could, y'know, be more than one character. We've got 4!
## An even worse solution
`()->1`
But, on the bright side, two unique answers in Java!
[Answer]
# Jelly, ~~26~~ ~~30~~ 32 numbers
```
‚Äò‚Äô3¬≤·∏§
```
This (and its anagrams) are full programs, that take no input, and produce output on standard output.
The outputs from the 120 programs are, in the order Jelly generates them if you ask it to generate permutations of the program:
```
018 036 06 03 09 03 18 116 116 117 125 135 06 03 14 15 13 22 19 13 24
28 33 42 018 036 06 03 09 03 -132 -164 -120 -119 -149 -137 26 43 18 17 
33 24 -19 13 -216 -210 53 44 18 36 30 31 49 63 18 36 10 9 25 17 18 19
18 17 18 18 36 48 36 26 36 36 06 03 14 15 13 22 06 03 -18 -17 -13 -24
06 07 06 05 06 06 03 12 03 -14 03 03 09 03 14 18 03 12 09 03 -116 -110 
23 14 09 015 09 05 09 09 03 12 03 -14 03 03
```
If you just take the unique outputs in numerical order, you get:
```
-216 -210 -164 -149 -137 -132 -120 -119 -116 -110 -24 -19 -18 -17 -14 -13
03 05 06 07 09 10 12 13 14 15 17 018 19 22 23 24 25 26 28 30 31 33 036 42
43 44 48 49 53 63 116 117 125 135
```
Many of these are too small, and 135 is too large, but there are still 32 that are in range.
The basic idea is to use mostly monadic instructions (in a program with only monads and nilads, these each just transform the previous output), and ones that allow the value to diverge quickly. The exception is with `3`, which is a nilad (the constant value 3). If it appears at the start of the program, all the operations will be done from 3. If it appears in the middle, it splits the program into two halves, each of which outputs an integer (and as they each print to standard output, the results end up getting concatenated, thus giving us "concatenate" as an additional operation to generate numbers).
The operations we have here, in the context the program generates them in, are: increment; decrement; constant 3; square; and double. Increment and decrement are unfortunately opposites, and decrement has an unfortunate tendency to produce a -1 or -2 in the first section (thus leading to a negative number overall), but this still gave a greater spread of outputs than the other things I tried. In particular, we get a pretty good spread of both the first and second halves of the number (note that the first half can be the null string, if `3` is the first character in the program).
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 26 numbers
```
3+*^-
```
This outputs the following numbers: `[2,3,4,5,6,7,8,9,10,16,17,18,19,20,25,26,30,31,32,35,36,37,48,49,63,64]`
### Explanation
* `3` is the integer 3, obviously.
* `+` is increment
* `*` is double
* `^` is square
* `-` is decrement
There are a lot of situations where the program simply errors: for example `*+^3-` errors because it asks *‚ÄúTake 0, double it, increment, square, the result of that square is 3, decrement‚Äù* which is obviously wrong.
Any program that ends with `3` will either output `3` or not work.
Any program that starts with `*3` will loop infinitely because of a bug (Brachylog is attempting to find a list of sublists which product result in 3 which is not possible).
[Answer]
## JavaScript, 27 numbers
Very similar to [TuukkaX's answer](https://codegolf.stackexchange.com/a/102664/58563), with another set of digits.
```
5789%
```
The 27 distinct values are:
```
589 %   7 -> 1
987 %   5 -> 2
978 %   5 -> 3
879 %   5 -> 4
985 %   7 -> 5
958 %   7 -> 6
975 %   8 -> 7
 95 %  87 -> 8
  9 % 875 -> 9
 97 %  85 -> 12
 89 %  75 -> 14
 95 %  78 -> 17
 78 %  59 -> 19
 79 %  58 -> 21
 98 %  75 -> 23
 87 %  59 -> 28
 89 %  57 -> 32
 97 %  58 -> 39
 98 %  57 -> 41
 57 %  98 -> 57
 58 %  97 -> 58
 59 %  87 -> 59
 75 %  98 -> 75
 78 %  95 -> 78
 79 %  85 -> 79
 85 %  97 -> 85
 87 %  95 -> 87
```
[Answer]
## Vim, 16 numbers
```
i1234
```
print
```
1, 2, 3, 4, 12, 13, 14, 21, 23, 24, 31, 32, 34, 41, 42, 43
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 33 numbers
```
·∏§23+c
```
`·∏§` double(left);  
`2` literal 2;  
`3` literal 3;  
`+` add(left, right); and  
`c` choose(left, right), i.e. number of ways to choose right objects from a collection of left objects.
Numbers yielded with an example program:
```
 1 +32·∏§c   18 3·∏§c2+    45 2+3·∏§c
 2 c3·∏§+2   20 2+·∏§c3    47 23c+·∏§
 3 c2·∏§+3   21 2·∏§+3c    48 c+23·∏§
 4 +2·∏§c3   22 3·∏§c+2    53 2c+·∏§3
 5 2+3c·∏§   23 23c·∏§+    56 3·∏§+2c
 6 3c+2·∏§   24 c·∏§+23    63 c+2·∏§3
 8 2c+3·∏§   30 3+c2·∏§    65 32c+·∏§
 9 3c2+·∏§   32 32c·∏§+    66 c+32·∏§
12 +3c·∏§2   33 c·∏§+32    72 3c+·∏§2
13 +2c·∏§3   36 3+·∏§c2    82 c+3·∏§2
15 +3·∏§c2   42 c·∏§3+2   120 3+2·∏§c
```
I tried to choose easy to parse ones, but some are rare and slightly strange to parse, for example `23` is:
```
23c·∏§+: (23 c (2 * 23)) + 23 = (23 c 46) + 23 = 0 + 23 = 23
```
...and `72` and `13` use implicit printing:
```
3c+·∏§2: z = (3 c 0) + (3 * 2); print(z); z = 2; print(z)
       z =    1    +    6   ; print(z); z = 2; print(z)
+2c·∏§3: z = (0 + 2) c (2 * 0); print(z); z = 3; print(z)
       z =    2    c    0   ; print(z); z = 3; print(z)
       z =         1        ; print(z); z = 3; print(z)
```
---
Note that `·∏§34+c` also produces `33` unique values in `[1,120]`.
[Answer]
# IA-32 machine code, 8 numbers
Hexadecimal byte values:
```
2c 40 48 b0 c3
```
The code is run as a function returning the value in `al`.
Valid permutations:
```
b0 2c c3 xx xx => 2c (mov al, 2c)
b0 40 c3 xx xx => 40 (mov al, 40)
b0 48 c3 xx xx => 48 (mov al, 48)
b0 2c 40 c3 48 => 2d (mov al, 2c; inc eax)
b0 2c 48 c3 40 => 2b (mov al, 2c; dec eax)
b0 40 48 c3 2c => 3f (mov al, 40; dec eax)
b0 48 40 c3 2c => 49 (mov al, 48; inc eax)
b0 48 2c 40 c3 => 8 (mov al, 48; sub al, 40)
```
I did a brute-force search, with the following constraints:
* The first byte is `b0` - to initialize the `al` register
* The last byte is `c3` - return; following bytes are discarded
* Possible opcode bytes are:
	+ 0x04 - `add`
	+ 0x0c - `or`
	+ 0x24 - `and`
	+ 0x2c - `sub`
	+ 0x34 - `xor`
	+ 0xd4 - `aad`
	+ 0x40 - `inc`
	+ 0x48 - `dec`
This leaves only 3 changeable bytes with a maximum of 15 possible results. Of these, a maximum of 9 can be distinct (in fact, this happens for only one set of bytes!). One of the values is out of range, so this leaves 8 values. There is another set of bytes
```
34 40 48 b0 c3
```
which also gives 8 distinct values - the programs are the same, except for `sub` replaced by `xor`, which makes two of the possible outputs identical.
All other sets of bytes give 7 or fewer possible results.
[Answer]
# [Brain-Flak](http://github.com/DJMcMayhem/Brain-Flak) 1
```
(())#
```
Brain-Flak requires balanced braces, so a 5 character program is only valid if one of the characters starts a comment. That leaves us with 4 characters to work with. Of those, 2 have to be `(` and `)` otherwise nothing would get pushed onto the stack. Those have to go first and 4th with the comment last (`(..)#`). Now we can put `()`, `{}`, `<>`, or `[]` inside. `{}`, `<>`, and `[]` each evaluate to 0, but `()` is 1. That means that `(())#` is the only 5 character string that produces a valid Brain-Flak program.
[Try it Online!](http://brain-flak.tryitonline.net/#code=KCgpKSM&input=)
If the question were instead "what are the *6* most powerful characters", the answer would be `(){}[]` as Brain-Flak is turing complete using only this subset.
[Answer]
## [Hexagony](https://github.com/m-ender/hexagony), 13 numbers
```
)24!@
```
These are the 13 printable numbers with one possible program for each of them:
```
)!@24 1
2!@)4 2
2)!@4 3
4!@)2 4
4)!@2 5
)2!@4 12
)4!@2 14
24!@) 24
24)!@ 25
2)4!@ 34
42!@) 42
42)!@ 43
4)2!@ 52
```
The programs should be fairly self-explanatory. `@` terminates the program, `!` prints the current value, `)` increments it, `2` and `4` append themselves to the current value (where the initial value is `0`). The actual hexagonal layout of the source code is irrelevant here, the programs can simply be read from left to right.
This *should* be optimal, although instead of `2` and `4` you can pick any pair digits `x` and `y` such that `2 ‚â§ x ‚â§ y-2`. 
The above solution was found by (almost exhaustive) brute force, requiring one `!` (otherwise it wouldn't print anything), one `@` (otherwise the program won't terminate), and filling the remaining three characters with any (repeated) combination from the following set of characters:
```
#[]\/_|<>)!0123456789$
```
I can't see how any of the other commands could possibly generate more variety.
[Answer]
# Octave, 18
This was found using a bruteforce search on the symbols `*+-/0123456789:;<\^|~%`. But it took way too long to compute...
```
-139%
```
Possible outputs:
```
1, 2, 3, 4, 6, 8, 9,13,16,19,22,31,38,39,88,91,92,93
```
[Answer]
# Perl, 27 numbers
`3479%`
Perl doesn't have a built-in REPL, so you can use `re.pl` from [Devel::REPL](https://metacpan.org/pod/Devel::REPL).
Results:
```
%9743 -> N/A
9%743 -> 9
97%43 -> 11
974%3 -> 2
9743% -> N/A
%7943 -> N/A
7%943 -> 7
79%43 -> 36
794%3 -> 2
7943% -> N/A
%7493 -> N/A
7%493 -> 7
74%93 -> 74
749%3 -> 2
7493% -> N/A
%7439 -> N/A
7%439 -> 7
74%39 -> 35
743%9 -> 5
7439% -> N/A
%9473 -> N/A
9%473 -> 9
94%73 -> 21
947%3 -> 2
9473% -> N/A
%4973 -> N/A
4%973 -> 4
49%73 -> 49
497%3 -> 2
4973% -> N/A
%4793 -> N/A
4%793 -> 4
47%93 -> 47
479%3 -> 2
4793% -> N/A
%4739 -> N/A
4%739 -> 4
47%39 -> 8
473%9 -> 5
4739% -> N/A
%9437 -> N/A
9%437 -> 9
94%37 -> 20
943%7 -> 5
9437% -> N/A
%4937 -> N/A
4%937 -> 4
49%37 -> 12
493%7 -> 3
4937% -> N/A
%4397 -> N/A
4%397 -> 4
43%97 -> 43
439%7 -> 5
4397% -> N/A
%4379 -> N/A
4%379 -> 4
43%79 -> 43
437%9 -> 5
4379% -> N/A
%9734 -> N/A
9%734 -> 9
97%34 -> 29
973%4 -> 1
9734% -> N/A
%7934 -> N/A
7%934 -> 7
79%34 -> 11
793%4 -> 1
7934% -> N/A
%7394 -> N/A
7%394 -> 7
73%94 -> 73
739%4 -> 3
7394% -> N/A
%7349 -> N/A
7%349 -> 7
73%49 -> 24
734%9 -> 5
7349% -> N/A
%9374 -> N/A
9%374 -> 9
93%74 -> 19
937%4 -> 1
9374% -> N/A
%3974 -> N/A
3%974 -> 3
39%74 -> 39
397%4 -> 1
3974% -> N/A
%3794 -> N/A
3%794 -> 3
37%94 -> 37
379%4 -> 3
3794% -> N/A
%3749 -> N/A
3%749 -> 3
37%49 -> 37
374%9 -> 5
3749% -> N/A
%9347 -> N/A
9%347 -> 9
93%47 -> 46
934%7 -> 3
9347% -> N/A
%3947 -> N/A
3%947 -> 3
39%47 -> 39
394%7 -> 2
3947% -> N/A
%3497 -> N/A
3%497 -> 3
34%97 -> 34
349%7 -> 6
3497% -> N/A
%3479 -> N/A
3%479 -> 3
34%79 -> 34
347%9 -> 5
3479% -> N/A
```
Brute-forced using the following program:
```
use strict;
use warnings 'all';
use 5.010;
use Algorithm::Combinatorics qw(combinations);
use Algorithm::Permute;
use Scalar::Util::Numeric qw(isint);
my @chars = ( 0..9, qw(+ - * / . ; ' " \ @ $ # ! % ^ & ( ) { } =) );
my $iter  = combinations(\@chars, 5);
my $max   = 0;
my @best;
while (my $combo = $iter->next) {
    my $count = count_valid([@$combo]);
    if ($count > $max) {
        $max  = $count;
        @best = @$combo;
    }
}
say "$max -> @best";
sub count_valid {
    my ($chars) = @_;
    my $iter = Algorithm::Permute->new($chars);
    my %results;
    while (my @perm = $iter->next) {
        no warnings;
        my $val = eval join '', @perm;
        use warnings 'all';
        $results{$val} = 1 if isint($val) && $val > 0 && $val <= 120;
    }
    return scalar keys %results;
}
```
[Answer]
# R, ~~15~~ 18 numbers
Not a huge number but it may be the best that can be done with R. I searched all combinations of digits `0..9`, operators `+ - * / ^` and the comment char `#`, and the following eight all output 18 unique integers between 1 and 120.
```
-#146
-#157
-#237
-#238
-#256
-#267
-#278
-#378
-#467
-#568
```
As an example, let's take `-#146`. Here are the 18 integers we can get:
```
1#-46      = 1
6-4#1      = 2
4-1#6      = 3
4#-16      = 4
6-1#4      = 5
6#-14      = 6
14-6#      = 8
16-4#      = 12
14#-6      = 14
16#-4      = 16
41-6#      = 35
41#-6      = 41
46-1#      = 45
46#-1      = 46
61-4#      = 57
61#-4      = 61
64-1#      = 63
64#-1      = 64
```
If you're curious about the (ugly) code used to test all the possible combinations, here it is. It outputs the number of unique integers between 1 and 120 for each character combination of length 5 to a file called "datafile" in the current working directory.
```
allchars = c("1","2","3","4","5","6","7","8","9","0","+","-","*","/","^")
apply(gtools::combinations(n=15, r=5, v=allchars, repeats.allowed=TRUE),
      1,
      function(chars) {
        x = apply(apply(e1071::permutations(length(chars)), 
                        1,
                        function(i) chars[i]
                        ),
                  2,
                  paste, collapse=""
            )
        u = unique(x)
        o = as.numeric(unlist(sapply(u, function(i) eval(try(parse(t=i),TRUE)))))
        f = factor(unique(o[o<=120 & o>=1 & o%%1==0]))
        write(paste(nlevels(f), paste(chars, collapse="")), "datafile", append=TRUE)
      }
)
```
[Answer]
# Octave, 15 numbers
Not much to brag about, but this is the best I can get in Octave:
```
124+%
```
It gives the numbers:
```
1    2    3    4    5    6   12   14   16   21   24   25   41   42   43
```
---
I got 16 too, but it seems it's identical to Sefa's answer...
```
1234%
1    2    3    4   12   13   14   21   23   24   31   32   34   41   42   43
```
[Answer]
# PHP, 15 numbers
```
1230\r
```
Uses the fact that php prints anything outside its tags verbatim (without using this you can do exactly 1 number with something like `<?=1;`). Also uses an actual carriage return character rather than `\r`.
Creates (sorted, removed leading 0s):
```
 1 1 2 2 3 3 10 10 12 12 12 12 13 13 13 13 20 20 21 21 21 21 23 23 23 23 30 30 31 31 31 31 32 32 32 32 102 102 103 103 120 120 123 123 123  123  130  130  132  132  132  132  201  201  203  203  210  210  213  213  213  213  230  230  231  231  231  231  301  301  302  302  310  310  312  312  312  312  320  320  321  321  321  321  1023  1023  1032  1032  1203  1203  1230  1230  1302  1302  1320  1320  2013  2013  2031  2031  2103  2103  2130  2130  2301  2301  2310  2310  3012  3012  3021  3021  3102  3102  3120  3120  3201  3201  3210  3210
```
of which the valid unique numbers are:
```
1 2 3 10 12 13 20 21 23 30 31 32 102 103 120
```
[Answer]
# [Cubix](https://github.com/ETHproductions/cubix), 7 numbers
```
"2)@O
```
Outputs these numbers:
```
")O2@ ->  1
")2O@ ->  2
"2)O@ ->  3
2"O@) -> 41
)"O@2 -> 50
2"O)@ -> 64
2")O@ -> 65
```
---
Any valid Cubix program for this challenge has to have an `O` to output an integer, and an `@` to terminate the program (Cubix has never even heard of "errors"). This gives us 3 chars to play around with to generate the most outputs. Furthermore, because of the way Cubix arranges code on a cube, the first char will be useless unless one of the others is a directional char.
The most efficient way I have found to generate multiple numbers is to use `"` to push a string of char-codes to the stack. With careful rearrangement, we can fit several chars in the last spot and simply output their char-codes. By using `)` to increment the top item, we can create extra outputs from several of these arrangements.
There are two basic program types in use here. The first is this:
```
"2)O@
```
which expands to
```
  "
2 ) O @
  .
```
The resulting program pushes `2` to the stack, increments it with `)`, outputs with `O`, and terminates with `@`.
The second is this:
```
2")O@
```
which expands to
```
  2
" ) O @
  .
```
The resulting program pushes the char-codes of `)`, `O`, and `@`, increments the last one with `)`, outputs with `O`, and terminates with `@`.
[Answer]
# Groovy, 10 Numbers
Man JVM solutions are BAD for this... Who knew?
```
1200+
```
Results in:
```
[3, 10, 12, 17, 21, 30, 66, 80, 102, 120]
```
Wait, what? How the hell does it make 17 you ask?
```
20+10 is 30.
0120+ is invalid.
2+001 is 3.
201+0 is 201.
2+100 is 102.
0+012 is 10.
21+00 is 21.
02+01 is 3.
0210+ is invalid.
10+20 is 30.
200+1 is 201.
0+210 is 210.
1200+ is invalid.
0201+ is invalid.
+0021 is 17.
1+002 is 3.
210+0 is 210.
100+2 is 102.
010+2 is 10.
00+12 is 12.
20+01 is 21.
01+20 is 21.
0+120 is 120.
+0120 is 80.
0+021 is 17.
+1020 is 1020.
0012+ is invalid.
02+10 is 12.
102+0 is 102.
012+0 is 10.
+2100 is 2100.
12+00 is 12.
00+21 is 21.
+2001 is 2001.
+0210 is 136.
+1200 is 1200.
1020+ is invalid.
0102+ is invalid.
2001+ is invalid.
001+2 is 3.
+0012 is 10.
2+010 is 10.
0021+ is invalid.
10+02 is 12.
2100+ is invalid.
+0201 is 129.
2010+ is invalid.
020+1 is 17.
1002+ is invalid.
+2010 is 2010.
1+020 is 17.
1+200 is 201.
01+02 is 3.
+1002 is 1002.
120+0 is 120.
0+102 is 102.
+0102 is 66.
002+1 is 3.
0+201 is 201.
021+0 is 17.
```
Trade secret, in Groovy/Java integers preceded with a 0 are octals.
Code I used for testing Groovy answers incase someone wants to beat me:
```
("1200+" as List).permutations().collect{
    it.join()
}.collect {
    print "$it is "
    x=-1;
    try {
        x=Eval.me(it);
        println "$x."
    } catch(Exception e) {
        println "invalid."
    }
    x<=120?x:-1;
}.unique().sort();‚Äã
```
[Answer]
# TI-BASIC, 12 numbers
```
23+4!
```
There is most likely a better combination, but I wasn't able to find it.
All \$24\$ valid permutations are as follows:
```
23+4!   -> 47
24+3!   -> 30
2+4!3   -> 74
2+3!4   -> 26
2!4+3   -> 11
2!+43   -> 45
2!+34   -> 36
2!3+4   -> 10
32+4!   -> 56
34+2!   -> 36
3+4!2   -> 51
3+2!4   -> 11
3!4+2   -> 26
3!+42   -> 48
3!+24   -> 30
3!2+4   -> 16
43+2!   -> 45
42+3!   -> 48
4+2!3   -> 10
4+3!2   -> 16
4!2+3   -> 51
4!+23   -> 47
4!+32   -> 56
4!3+2   -> 74
```
Of which there are \$12\$ unique values:
\$10,11,16,26,30,36,45,47,48,51,56,74\$
[Answer]
# Befunge, 11 numbers
Befunge is a bit limited because it only supports single digit literals. So the best I could come up with was 11 numbers, assuming the calculation must leave us with one and only one number on the stack.
**Best characters:** `358*%`
**Generated numbers:** (just one example of each)
```
58*3% => 1
358*% => 3
38*5% => 4
538*% => 5
35*8% => 7
835*% => 8
385%* => 9
583%* => 10
358%* => 15
53%8* => 16
35%8* => 24
```
[Answer]
# [><>](http://esolangs.org/wiki/Fish), 6 numbers
Gained 2 numbers thanks to *Teal Pelican*
```
1ln";
```
Produces the unique numbers `[1, 4, 5, 49, 59, 108]`
We need `n` to print a number.  
We need `;` to terminate.
That leaves us only 3 chars to work with.
A few different combinations of `value` & `operator` together with `"` confirmed to produce 6 unique values, but I haven't found anything better than that.
[Answer]
# MATL, 15 numbers
```
0123%
```
`%` is the comment operator, so it will "cut" in all possible places once, helping to create all possible combinations of the given digits and subsets of them:
```
1
2
3
10
12
13
20
21
23
30
31
32
102
103
120
```
[Answer]
# J , 16 Numbers
```
1234]
```
Nothing fancy, just tested `1234` with all the 1-character verbs that were reasonable. `]` selects its right argument.
The unique numbers produced are
```
0 4 3 34 43 2 24 42 23 32 234 243 324 342 423 432 1 14 41 13 31 134 143 314 341 413 431 12 21 124 142 214 241 412 421 123 132 213 231 312 321 1234 1243 1324 1342 1423 1432 2134 2143 2314 2341 2413 2431 3124 3142 3214 3241 3412 3421 4123 4132 4213 4231 4312 4321
```
of which 16:
```
4 3 34 43 2 24 42 23 32 1 14 41 13 31 12 21
```
Are in the range [1,120].
Tested with
```
# (#~e.&(>:i.120)) ~. (". :: 0:)"1 (A.~ i.@!@#) '1234]'
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 41 numbers
Pretty much just trial and error so there may be a better solution. Uses integers `3` & `4` and the Japt shortcuts for squaring, adding `1` & multiplying by `2`. All 120 programmes output an integer `>0` but only 78 are `<=120` and only 41 of those are unique.
```
34¬≤√Ñ√ë
```
Generates the numbers:
```
1,3,4,5,6,7,8,9,13,14,17,20,21,26,27,29,30,31,32,33,34,35,36,37,38,39,42,43,44,45,47,56,59,68,69,72,73,86,87,92,93
```
View [the list of numbers](https://petershaggynoble.github.io/Japt-Interpreter/?v=2.0a0&header=Ig&code=MzSyxNE&footer=Ingg4SCjT3ZYw%2bIgZiN49Slu) or [the collection of valid programmes](https://petershaggynoble.github.io/Japt-Interpreter/?v=2.0a0&flags=LVI&header=Ig&code=MzSyxNE&footer=Ingg4SCjW1hPdlhdw2ZAI3j1IPhYzMPxzG1xIiA9ICI)
---
## Explanation
A few things to note about Japt that are relevant here are:
1. If a programme doesn't start with (in this case) one of the digits then the first input variable `U`, which defaults to `0`, is automatically inserted at the beginning,
2. If either or both of the digits immediately follow one of the shortcuts for a mathematical operation then they are appended to it (e.g. `3√Ñ4 = 3+14 = 17` and, similarly, `4√ë¬≤ = 4*2**2 = 16`), and,
3. If one of the digits immediately follows the `¬≤` then the `¬≤` and everything before it are, essentially, ignored.
Explanations for a few of the programmes (producing `1`, `3`, `37` and `93`, respectively):
```
¬≤√ë34√Ñ  :Square 0, multiply by 234 and add 1
4√Ñ√ë¬≤3  :Add 1 multiplied by 2 squared to 4, ignore that and return the 3
3¬≤√Ñ4√ë  :Square 3 and add 14 multiplied by 2
4√ë3√Ñ¬≤  :Multiply 4 by 23 and add 1 squared
```
[Answer]
# Python, 16 numbers
```
1234#
```
Uses # to comment out all unnecessary numbers.
[Answer]
# dc, 19 numbers
```
*3zO+
```
Output is on top of stack, and errors (including stack underflow) are ignored. The valid permutations are:
```
+O3*z:   1
+O*3z:   2
+Oz3*:   3
O*z3+:   4
O*3z+:   5
+O3z*:   6
+z3*O:  10
3*zO+:  11
3*Oz+:  12
Oz3*+:  13
O3z*+:  16
+3Oz*:  20
3Oz*+:  23
+zO3*:  30
O3*z+:  31
Oz+3*:  33
3Oz+*:  36
Oz3+*:  40
O3z+*:  50
TOTAL COUNT = 19 numbers
```
Here's the Python program I used to show those results:
```
#!/usr/bin/python
import sys
import itertools
import subprocess
if len(sys.argv[1]) != 5:
    print("Invalid input")
    sys.exit(1)
devnull = open("/dev/null", 'w');
r = dict()
for s in itertools.permutations(sys.argv[1]):
    p = "".join(s)
    try:
        e = (subprocess.check_output(['dc', '-e', p, '-e', 'p'], stderr=devnull))
        e = int(e)
        if 0 < e <= 120:
            r[e] = p
    except e:
        pass
for i in sorted(r):
    print("%5s: %3d" % (r[i], i))
print("TOTAL COUNT = %d numbers" % len(r))
```
---
Two other strings which give the same score of 19 are `32d+*` and `*4zO+`.
[Answer]
## Smalltalk, 26 numbers
```
1235r
```
Explanation: 12r35 is a notation for using radix 12, and is thus 3\*12+5.  
This can be verified in Squeak:
```
((Array streamContents: [:s |
    '1235r'  permutationsDo: [:each | 
        | eval |
        eval := [Compiler evaluate: each] ifError: [nil].
        (eval isInteger and: [eval >=1 and: [eval <= 120]]) ifTrue: [s nextPut: each copy -> eval]]])
  collect: #value as: Set) sorted
```
gives:
```
#(1 2 3 5 28 31 33 37 38 41 42 47 55 58 63 66 67 68 71 76 82 86 105 107 108 116)
```
If we replace last line with:
```
    sorted: #value ascending)
```
we then get the expressions:
```
'235r1' -> 1
'253r1' -> 1
'325r1' -> 1
'352r1' -> 1
'523r1' -> 1
'532r1' -> 1
'135r2' -> 2
'153r2' -> 2
'315r2' -> 2
'351r2' -> 2
'531r2' -> 2
'513r2' -> 2
'125r3' -> 3
'152r3' -> 3
'215r3' -> 3
'251r3' -> 3
'521r3' -> 3
'512r3' -> 3
'123r5' -> 5
'132r5' -> 5
'213r5' -> 5
'231r5' -> 5
'321r5' -> 5
'312r5' -> 5
'23r15' -> 28
'25r13' -> 28
'13r25' -> 31
'15r23' -> 33
'32r15' -> 37
'35r12' -> 37
'5r123' -> 38
'12r35' -> 41
'5r132' -> 42
'15r32' -> 47
'52r13' -> 55
'53r12' -> 55
'5r213' -> 58
'12r53' -> 63
'5r231' -> 66
'13r52' -> 67
'31r25' -> 67
'21r35' -> 68
'35r21' -> 71
'25r31' -> 76
'5r312' -> 82
'5r321' -> 86
'51r23' -> 105
'53r21' -> 107
'21r53' -> 108
'23r51' -> 116
```
I wanted to cheat and define a method r in Integer as
```
Integer>>r
    ^self \\ 120 + 1
```
Unfortunately, the compiler chops on 1235r because it recognizes an unfinished number with radix rather than a message r sent to 1235...  
I could easily change the compiler too, but it's a bit too much of a cheat to my taste.
[Answer]
# Runic Enchantments, 19 numbers
```
234p@
```
Essentially 3 literals, the pow operator, and a "print the entire stack and terminate" command. `234p@` prints 812 (3^4 conxatenated with a 2).
[Full permutation list](https://tio.run/##NZNLaiVRDEPnWY6kcchWQo@ahsYEsv6XWD41KqEr2/Knvr7///3zer3Lmc9/H28Lfr@zYAKzL1mw3wHMMjHimPCmcYFhVmKAVzwmcyWbZ4K4NVfcNAFkmUYHUBu1w1MMM494NtzCs4VniwYtWrZo0KLlm4EAWnGEOCI8I5h9WXG/AaSMyDwicyv0KYTXlwANb5oBDEwEkzV2dlxwoztfBuw0IpYSsaYYz7euzWMavE2W0SOm5dukCghvcQG0RUfYaIVlKhlAM7cCT2MYDYzW84jbuHxZwG3cCL2A27jpLmPmPGbOd2IqEAxLuW5WHDzfKjZPaPDuccWhwTvMZRptQG3UDk8WTB5xNvwaDSAwvedLMwd6z1fhGPc2boQnthBbhLu3cb/FiTMUTed85wMjMseP2IRPEM/jeYTnEZ7H2NjBvl4/), note that `@` has been replaced by `ak@` in order to generate a newline between each result and a `>` has been added to insure that each line executes independently. Note also that the outputs are not in the same order as the programs that generated them (as some programs may terminate more quickly).
Many permutations print nothing (eg. `@234p` or `p234@`), but 19 do result in output within the allowable range.
Numbers possible (and one possible program that results in it; `.` indicates that those positions may be any of the remaining characters as it isn't executed):
```
2@...        2
3@...        3
4@...        4
23p@.        8
32p@.        9
42p@.       16
32@..       23
42@..       24
23@..       32
43@..       34
24@..       42
34@..       43
23p4@       48
32p4@       49
43p@.       64
34p@.       81
423p@       84
432p@       94
```
[Answer]
# APL, 27 numbers
The best set after brute-forcing all permutations of characters that made sense.
```
5789‚ä§
```
All permutations
```
[ 7958‚ä§ ] N/A
[ 98‚ä§75 ] 75
[ 985‚ä§7 ] 7
[ 98‚ä§57 ] 57
[ 8‚ä§957 ] 5
[ 8‚ä§795 ] 3
[ 8‚ä§975 ] 7
[ ‚ä§9587 ] N/A
[ 897‚ä§5 ] 5
[ 75‚ä§89 ] 14
[ 785‚ä§9 ] 9
[ 78‚ä§59 ] 59
[ 8579‚ä§ ] N/A
[ 8597‚ä§ ] N/A
[ 79‚ä§85 ] 6
[ ‚ä§5789 ] N/A
[ ‚ä§5879 ] N/A
[ 7‚ä§895 ] 6
[ 7‚ä§985 ] 5
[ 578‚ä§9 ] 9
[ 59‚ä§87 ] 28
[ 9758‚ä§ ] N/A
[ 7589‚ä§ ] N/A
[ 7598‚ä§ ] N/A
[ ‚ä§8759 ] N/A
[ 789‚ä§5 ] 5
[ ‚ä§8597 ] N/A
[ 9‚ä§578 ] 2
[ 8975‚ä§ ] N/A
[ 9‚ä§587 ] 2
[ 7859‚ä§ ] N/A
[ 57‚ä§98 ] 41
[ 895‚ä§7 ] 7
[ 89‚ä§57 ] 57
[ 978‚ä§5 ] 5
[ 58‚ä§97 ] 39
[ 8759‚ä§ ] N/A
[ 875‚ä§9 ] 9
[ 87‚ä§59 ] 59
[ 975‚ä§8 ] 8
[ 97‚ä§58 ] 58
[ ‚ä§7958 ] N/A
[ 7‚ä§859 ] 5
[ 85‚ä§79 ] 79
[ 5‚ä§798 ] 3
[ 5‚ä§978 ] 3
[ 95‚ä§87 ] 87
[ 859‚ä§7 ] 7
[ 8‚ä§579 ] 3
[ 759‚ä§8 ] 8
[ ‚ä§9758 ] N/A
[ 7‚ä§958 ] 6
[ 587‚ä§9 ] 9
[ 59‚ä§78 ] 19
[ 879‚ä§5 ] 5
[ 9875‚ä§ ] N/A
[ ‚ä§7589 ] N/A
[ ‚ä§5798 ] N/A
[ ‚ä§5978 ] N/A
[ 95‚ä§78 ] 78
[ 7985‚ä§ ] N/A
[ 987‚ä§5 ] 5
[ 8‚ä§597 ] 5
[ ‚ä§9857 ] N/A
[ 89‚ä§75 ] 75
[ 758‚ä§9 ] 9
[ ‚ä§7895 ] N/A
[ ‚ä§7985 ] N/A
[ 9578‚ä§ ] N/A
[ 9587‚ä§ ] N/A
[ 5798‚ä§ ] N/A
[ 5789‚ä§ ] N/A
[ 798‚ä§5 ] 5
[ ‚ä§9785 ] N/A
[ ‚ä§9875 ] N/A
[ 5‚ä§789 ] 4
[ 5‚ä§879 ] 4
[ 57‚ä§89 ] 32
[ 598‚ä§7 ] 7
[ 9785‚ä§ ] N/A
[ ‚ä§8579 ] N/A
[ 78‚ä§95 ] 17
[ ‚ä§8957 ] N/A
[ 9‚ä§758 ] 2
[ 8957‚ä§ ] N/A
[ 9‚ä§857 ] 2
[ 5978‚ä§ ] N/A
[ 5987‚ä§ ] N/A
[ 9‚ä§785 ] 2
[ 9‚ä§875 ] 2
[ 7895‚ä§ ] N/A
[ 579‚ä§8 ] 8
[ 97‚ä§85 ] 85
[ 589‚ä§7 ] 7
[ 8795‚ä§ ] N/A
[ ‚ä§7598 ] N/A
[ ‚ä§8795 ] N/A
[ ‚ä§8975 ] N/A
[ 7‚ä§589 ] 1
[ 857‚ä§9 ] 9
[ ‚ä§5897 ] N/A
[ ‚ä§5987 ] N/A
[ 85‚ä§97 ] 12
[ 8‚ä§759 ] 7
[ 958‚ä§7 ] 7
[ 5‚ä§897 ] 2
[ 5‚ä§987 ] 2
[ 5879‚ä§ ] N/A
[ 5897‚ä§ ] N/A
[ 75‚ä§98 ] 23
[ 795‚ä§8 ] 8
[ 79‚ä§58 ] 58
[ ‚ä§9578 ] N/A
[ 7‚ä§598 ] 3
[ 58‚ä§79 ] 21
[ 597‚ä§8 ] 8
[ 87‚ä§95 ] 8
[ 9857‚ä§ ] N/A
[ ‚ä§7859 ] N/A
[ 957‚ä§8 ] 8
```
]