Many programs, few characters Your task is to create many programs. The first outputs 1, the second outputs 2, etc. The higher you can go, the better!

However, all of these programs must be made the same list of characters. You can choose which characters to put in the list. Each program can only use a character as many times as it appears in the list.

For example, using the Python shell:

List of characters:  +122
-------
Program 1:      1
Program 2:      2
Program 3:      1+2
Program 4:      2+2   (2 appears twice in the list)


It is impossible to make a program which prints 5 without reusing the + character, so there are a total of 4 programs possible with this list. (Only consecutive numbers starting from 1 count. We therefore ignore other numbers we can make, like 12.)

Scoring


Let N be the number of programs.
Let S be the size of the shortest program, or 15, whichever is less.
Let L be the length of the list.


Your score is N / &Gamma;((L-S)/5), where &Gamma; is the gamma function.

In the example above, N is 4; S is 1; L is 4; the score is 4 / &Gamma;((4-1)/5) = 2.686.

Highest score wins!

Below is a Stack Snippet to help calculate your score:



var g=7,C=[0.99999999999980993,676.5203681218851,-1259.1392167224028,771.32342877765313,-176.61502916214059,12.507343278686905,-0.13857109526572012,9.9843695780195716e-6,1.5056327351493116e-7];function gamma(z) {if(z&lt;0.5){return Math.PI/(Math.sin(Math.PI*z)*gamma(1-z));}else{z--;var x=C[0];for(var i=1;i&lt;g+2;i++)x+=C[i]/(z+i);var t=z+g+0.5;return Math.sqrt(2*Math.PI)*Math.pow(t,(z+0.5))*Math.exp(-t)*x;}}function go(){var N=parseInt(jQuery('#programs').val()),S=parseInt(jQuery('#shortest').val()),L=parseInt(jQuery('#length').val());if(S&gt;15){S=15;}jQuery('#score').val(N/gamma((L-S)/5));}
&lt;script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"&gt;&lt;/script&gt;&lt;form&gt;&lt;table&gt;&lt;tr&gt;&lt;td&gt;&lt;label&gt;Number of programs:&lt;/label&gt;&lt;/td&gt;&lt;td&gt;&lt;input id='programs' oninput="go()" value='0'/&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;&lt;label&gt;Size of shortest program:&lt;/label&gt;&lt;/td&gt;&lt;td&gt;&lt;input id='shortest' oninput="go()" value='0'/&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;&lt;label&gt;Size of list:&lt;/label&gt;&lt;/td&gt;&lt;td&gt;&lt;input id='length' oninput="go()" value='0'/&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;&lt;label&gt;Score:&lt;/label&gt;&lt;/td&gt;&lt;td&gt;&lt;output id='score'&gt;0&lt;/output&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/form&gt;&lt;p&gt;Code from &lt;a href="http://stackoverflow.com/a/15454784/3148067"&gt;http://stackoverflow.com/a/15454784/3148067&lt;/a&gt;&lt;/p&gt;




Rules


You can use programs or functions.
You may use different languages for different numbers.
Each program must work by itself. For example, you can not assume that the first program will run before the second program.
Pyth, Score of 1.664 * 10^26

Since you only have L different chars to choose from, you can maximal generate O(L!) different programs. 

So lets build something really close: By indexing permutations of the alphabet:

I use a following list of characters is:

abcdefghijklmnoppqrstuvwxxyzG."


With these characters I can generate 26!-1 different programs like this:

Program 1: x.pG"abcdefghijklmnopqrstuvwxzy
Program 2: x.pG"abcdefghijklmnopqrstuvwyxz
Program 3: x.pG"abcdefghijklmnopqrstuvwyzx
  ...
Program 403291461126605635583999999: x.pG"zyxwvutsrqponmlkjihgfedcba


Notice I didn't use "abcdefghijklmnopqrstuvwxyz" (sorted alphabet), since I give an index of 0. 

So we got N = 403291461126605635583999999, S = 15, L = 31, which gives a score of 1.663767345141228e+26. 

Explanation:

x.pG"...     
   G       G is pre-initialized with "abc...xyz"
 .p        gives all possible permutations
x   "...   the index of "..." in the permutation list


Notice, that none of the programs will actually run. Because of memory and time. 

edit:

You can even get way higher. For instance by using also the uppercase letters. Gives me a score of about 10^76. 

edit 2: a runnable version

Since none of the programs above is actually runnable, here's one that works. 

x.pSK""Kabcde


The programs are:

Program 1: x.pSK"abced"K
Program 2: x.pSK"abdce"K
Program 3: x.pSK"abdec"K
  ...
Program 117: x.pSK"edbca"K
Program 118: x.pSK"edcab"K
Program 119: x.pSK"edcba"K


Here's an online Demonstration. 

Explanation:

x.pSK"abced"K
    K"abced"   K = "abced"
   S           sort it
 .p            generate all permutations of sorted(K)
x           K  index of K in the permutations. 


N = 119, S = 13, L = 13 gives a score of 0. But If we simply use a dummy char to the list we get N = 119, S = 13, L = 14 and a score of 25.92

Of course we can use more chars than abcde for the permutation. If we use n different chars, we get N = n!-1, S = 15, L = n+8, which gives a score of ~n!/(n-7)!. So we can get pretty much an unlimited score.