How many lists of 100 numbers (1 to 10 only) add to 700? Each number is from one to ten inclusive only.  There are $100$ numbers in the ordered list. The total must be $700$.
How many such lists?
Note: if, as it happens, this is one of those math problems where only an approximation is known, that would be great.  (My guess is it's not "that" big, around $10^{20}$ maybe?)
Thank you!!

So, to be clear say you have a dice with sides labelled $1$-$10$. You roll it $100$ times, once every $10$ seconds in order. The result is, if you will, a specific array of $100$ numbers (each being $1$-$10$), each position labelled $1$ to $100$. The array must then add to $700$; how many such arrays??

Just to be absolutely clear, I believe the total of "all" such lists (so, there is no requirement to add to $700$; it can add to anything), is indeed, simply $1$ googol, ie, $10^{100}$.
 A: In the language of compositions, what you want are the number of $A$-restricted compositions of $n=700$ into $k=100$ parts where $A=\{1,2,\ldots,a\}$ with $a=10$. While I don't know a closed-form for this number, one can express such counting succinctly using formal power series. To represent our set $A$ of allowed terms, we use the formal polynomial $f_{a}(x)=\sum\limits_{j=1}^{a} x^j = \dfrac{x-x^{a+1}}{1-x}$. If we square this, then the coefficient of a term $x^n$ will represent the number of ways in which two integers in $A$ can add to a total of $n$. This gives us the following result:

The number of $A$-restricted compositions, with $A=\{1,2,\ldots a\}$, of $n$ into $k$ parts is the $n$th coefficient of $f_{10}(x)^k$, which we can express as $[x^n]\left(\dfrac{x-x^{a+1}}{1-x}\right)^k.$

Thus in the case at hand what we want to find (or at least estimate) is $\boxed{\displaystyle\left[x^{700}\right]\left(\dfrac{x-x^{11}}{1-x}\right)^{100}}$. Amazingly, this can be pulled off rather easily by WolframAlpha, yielding the rather impressive result of $$
\boxed{
\begin{align}
12113063910758377468145174162592296408571398929 &\\
1260198434849317132762403014516376282321342995 &\approx 1.2 \times 10^{92}
\end{align}
}
$$
For approximations, I suggest perusing Sedgwick and Flajolet's Analytic Combinatorics which is available for download on the book site. I may dig into there myself to see if anything is known or can be estimated about such numbers.
A: A066099 features a nice visual generation pattern for compositions of $n$ (listing them in reverse lexical order):
From Omar E. Pol, Sep 03 2013:       

-----------------------------------  ----------
n  j       Diagram   Composition j   Row length
-----------------------------------  ----------
.               _
1  1           |_|   1;              1
.             _ _
2  1         |  _|   2,              1
2  2         |_|_|   1, 1;           2
.           _ _ _
3  1       |    _|   3,              1
3  2       |  _|_|   2, 1,           2
3  3       | |  _|   1, 2,           2 
3  4       |_|_|_|   1, 1, 1;        3
.         _ _ _ _
4  1     |      _|   4,              1
4  2     |    _|_|   3, 1,           2
4  3     |   |  _|   2, 2,           2
4  4     |  _|_|_|   2, 1, 1,        3
4  5     | |    _|   1, 3,           2
4  6     | |  _|_|   1, 2, 1,        3
4  7     | | |  _|   1, 1, 2,        3
4  8     |_|_|_|_|   1, 1, 1, 1;     4
.

So we would need that diagramm for $n = 700$ and only those
rows with $100$ summands and all summands from $\{1, \ldots, 10 \}$.
Pragmatic problem: There are $N = 2.63 \times 10^{210}$ compositions of $700$, according to WolframAlpha link.
Looking at the diagram one notices that $N(n)$ is resulting from the doubling (see step 3 of the algorithm below) and is thus simply 
$N(n) = 2^{N-1}$ (A000225) and in this case: $N(700) = 2^{699}$.
About the recursion involved:


*

*The list of compositions for $n+1$ can be obtained, by using a copy of the list for $n$ first.

*Then we put a column of $1$ elements to the left of that list.

*Finally we put another copy of the list for $n$ on top, shifted one position left, aligning with the column of $1$ elements, and adding $1$ to each entry in the first column of the copy.


Side note: It is already interesting to see how the row lengths develop:

1
    1 2
    1 2 2 3
    1 2 2 3 2 3 3 4
    1 2 2 3 2 3 3 4 2 3 3 4 3 4 4 5

If we have $2^n$ terms, we find the next $2^n$ terms by copying the first $2^n$ terms plus $1$ each.
This leads to A063787 and is related to 
A000120 (binary weight of $n$).
They are described as fractal sequences - deleting every other term gives the original series. 
A: Note that the numbers being added together have mean $\mu_0=11/2$ and standard deviation $\sigma_0=\sqrt{33}/2$; by the central limit theorem, the distribution of the sum of $100$ such numbers is approximately a Gaussian with mean $\mu=100\mu_0 = 550$ and standard deviation $\sigma=10\sigma_0=5\sqrt{33}$.  The continuous Gaussian distribution is
$$
f(x,\mu,\sigma)=\frac{1}{\sigma\sqrt{2\pi}}\exp\left(-\frac{(x-\mu)^2}{2\sigma^2}\right);
$$
and to a first approximation you can ignore the correction from discreteness.  So the number you want is roughly
$$
N\approx 10^{100} \cdot f(700,550,5\sqrt{33})=\frac{10^{100}}{5\sqrt{33}\sqrt{2\pi}}\exp\left(-\frac{150^2}{1650}\right)\\
= \frac{10^{100}}{5\sqrt{66\pi}}e^{-150/11}\approx 1.66\times 10^{92}.
$$
It is helpful to compare this to the computational result.  A simple Python implementation is the following:
def N(x, n, cache={(0,0):1}):
   if x<0 or (n==0 and x>0): return 0
   if not cache.has_key((x,n)):
      cache[(x,n)] = sum([N(x-i, n-1) for i in xrange(1,11)])
   return cache[(x,n)]

Then N(700, 100) * 1.0 yields 1.2113063910758377e+92.
A: As this seems to be a programmer's problem, I will give you a sketch of the solution. For sake of completeness, I should advise you that this kind of problems should be posted in the correct stack exchange forum.
You certainly have been familiar with DP. So this problem should be solved in that manner.
You should look to a certain function, namely $f(n, m)$ that gives you the number of ordered sequences of $n$ integers in $A = \{1, \cdots, 10\} $ that sum $m$. You want $f(100, 700)$.
You should know a recursive way of computing this, as any sequence $a_1, \cdots , a_n$ that sums $m$ leads bijectively to a smaller sequence $a_1, \cdots , a_{n-1}$ that sum $m-a_n$
So $$f(n, m) = \sum_{k \in A}^{ m - k \geq 0} f(n-1, m-k)$$
You should initialize your function in $f(n, n) = 1$ and $f(1, m) = 1$ for $m\in A$, $f(1, m)=0 $ for $ m> 10 $. And now is just a question of programming.
