Another approach is to code a recursion in two variables. If we have n places and r digits, and each has to be used at least once, then call the number of possibilities f(n,r). The rules are as follows.

If there is but one digit, we only have one possibile value for a given n (every digit is the one that's allowable).

If we have fewer places than digits there are no possibilities that fulfill the requirements.

If number digits = number of places, call it r, then there are r! possibilities; each is a permutation of the available digits. (I didn't check whether this rule is really needed; maybe not.)

for other n, r the recurrence is that we have f(n,r-1) ways to fill out the first n-1 positions using all r digits, times r possibilities for the last, PLUS we have f(n-1,r-1) ways of filling out the first n-1 places using only r-1 digits, and the last pace is then forced on us, but multiply by the r choices for which digit gets omitted until the end.

In code this is as follows.

f[n_,1] = 1
f[n_,r_] /; n<r := 0
f[r_,r_] := r!
f[n_, r_] := f[n,r] = r*f[n-1,r] + r*f[n-1,r-1]

This gives:

f[64,21]                                                               
(* Out[16]= 1510109515792918244116781339315785081841294607960614956302330123544242628820336640000 *)

I was not able to convince RSolve or RecurrenceTable to do this but perhaps those might be used in a similar manner.

Is there an online Mathematics journal that is peer reviewed where we could publish this number and how it was derived?

After that, we could drop the reference in Wikipedia in a few places so this question does not come up again or get answered using bad math.

I obviously have some reading to do, because I like to be able to derive the math I am using from scratch.

Thank you Jim and Dan. Doug

P.S. 4 nucleotides, 20 amino acids == faces of smallest and largest Platonic solids.

Consider this to be the genetic code, and for once and all we are going to state how many possible codes there are! 64 bins for the codons. 21 items, for the 20 amino acids plus one stop codon.

Am I suppose to take an absolute value if these equations produce negative numbers?

Doug

s1 = Sum[(-1)^jBinomial[21, j]j^64, {j, 21}]

N[s1/21^64]

-151010951579291824411678133931578508184129460796061495630233012354424\ 2628820336640000

-0.360557

Douglas,

Consider this to be the genetic code, and for once and all we are going to state how many possible codes there are! 64 bins for the codons. 21 items, for the 20 amino acids plus one stop codon.

Does Nature know left from right? Should you divide your count by 2?

This isn't a Mathematica question, but...consider recasting your bins as digit places and your colored marbles as numbers from 0 through 9. So bin#1 is the ones place, bin#2 the tens place, etc. And red=0, yellow=1,...,violet=9.

Your (first) question is thus equivalent to this: how many base 10 numbers are there of 50 digits?

the requirement that all colors get used at least once is equivalent to asking how many 50 digit numbers there are that use every digit between 0 and 9. For that, you might start with the answer to the first question and subtract off however many numbers there are that DO NOT use all 10 digits. So then ask: how many use all but the first digit? All but the second? And so on. Now you have to account for double-subtracting since the ones that use all but the first overlap those that use all but the second (they are the ones that use neither first nor second). From here one develops an inclusion-exclusion method.

If I wrote the computation correctly, it is this:

s1 = Sum[(-1)^j*Binomial[10, j]*j^50, {j, 10}]

(* Out[90]= 94910235292763223632455966616702223835130977516800 *)

N[s1/10^50]

(* Out[93]= 0.949102352928 *)

So around 95% of the 50 digit numbers use all ten digits.