Which number has the highest divisibility (factors)? I'm trying to find out the most divisible numbers using the divisibility rules from 2-12, but i'm getting lost. Is there any online calculator that given a range of numbers(for me would be 2-12) will output the highest divisible numbers?
Edit: Okay, fair enough. I'll explain more about my idea here. The thing is that i'm want to find the 'right' number for a CSS grid system that I'm working on. The http://960.gs is the most famous one. But as you can tell the maximum width for the grid is 960pixel. Which was ok 5 years ago, but nowadays a lot of people have computers with big screen. I want to push forward. Another one is http://1080.gs this one is good too. It is divisible by 2, 3, 4, 5, 6, 8, 10, 12, 15, 20, 24, 30, 40, 60, 120. Those are the numbers that i'm looking for. 
For example, how do I which numbers can divide 1008 or 1024..and so on. 
I hope this make sense now.
 A: You might check out OEIS on highly composite numbers.  $840$ has $32$ factors, while $960$ has only $28$, but maybe the $7$ isn't so useful.  The next record holder is $1260$ with $36$ factors.  It isn't too much larger than $1080$, which has $32$ like $840$ did.
A: I'll interpret your question as "What numbers in the range $2,\dots,12$ have the most divisors?" A useful result here is that if you express a positive integer as a product of primes, 
$$
n=p_1^{a_1}p_2^{a_2}\cdots p_k^{a_k}
$$
then the number of positive integers that divide $n$ will be
$$
(a_1+1)(a_2+1)\cdots(a_k+1)
$$
For example, if $n=40=2^35^1$, then $n$ will have eight divisors, namely
$$
1, 2, 4, 5, 10, 20, 40
$$
It's not hard to see how this result is derived; a divisor of $p_1^{a_1}p_2^{a_2}\cdots p_k^{a_k}$ will have to be of the form $p_1^{b_1}p_2^{b_2}\cdots p_k^{b_k}$ where $b_i\le a_i$ for $i=1, \dots, k$, so there will be $a_1+1$ possibilities for $b_1$ (namely $0, 1, \dots,a_1$) and regardless of those choices there will be $a_2+1$ choices for how many of the $p_2$ appear, and similarly for the other choices for the $b$s.
For your problem, it's easy to produce the prime factorizations of the numbers between $2$ and $12$:
$$
\begin{array}{lccccccccccc}
\mathbf{n}        & 2 & 3 & 4 & 5 & 6 & 7 & 8 & 9 & 10 & 11 & 12\\
\mathbf{divisors} & 2 & 2 & 3 & 2 & 4 & 2 & 4 & 3 & 4  & 2  & 6
\end{array}
$$
so in this case, $12$ will have the most divisors: $1, 2, 3, 4, 6, 12$.
A: How can there be a discussion of this
without mentioning Ramanujan's pioneering 1915 paper
“Highly Composite Numbers”?
A good summary of this paper
and more recent related work can be found at
http://www.math.jussieu.fr/~miw/articles/pdf/LegacyRamanujan2012.pdf.
A related paper by Erdos is at
http://www.renyi.hu/~p_erdos/1944-04.pdf.
I was not able to find the original paper via Google.
A: It actually sounds like you want the least common multiple of the integers 2 through 12. That would certainly make sense if you're designing a grid system! It would guarantee you the ability to divide the grid into any number of cells up to $12$. 
Going through prime factors, we have
$$\mathrm{lcm}(2,\ldots,12)=2^3\times 3^2\times5\times7\times11=27720.$$
Ouch! That's pretty large. We're going to have to drop support for $11$:
$$\mathrm{lcm}(2,\ldots,10)=2^3\times 3^2\times5\times7=2520.$$
Still too large. We have to drop support for $9$ as well:
$$\mathrm{lcm}(2,\ldots,8)=2^3\times 3\times5\times7=840.$$
For more on these numbers, check out https://oeis.org/A003418
A: You were asking if there was a calculator. I made a piece of python code to find the numbers with the most integer factors (highest divisibility). I also have it in java and C++ if you are interested. You give it a max range, and it will spit out the numbers that show up with the most factors, and tell you how many factors they have.
If you just paste and run this code in an online python interpreter, you will have an online calculator. Hope it works out for you.
print("This program finds the number/s with the most factors between 1 and a value of your choice.")

initialNumber = int(input("Enter a number over one, and press enter:"))

limiter = initialNumber//2
factorLimiter = 0

resultingFactorsArray = []

devider = 2

def createArray(searchRange):
    arrayCounter = 0
    while arrayCounter <= searchRange:
        resultingFactorsArray.append(0)
        arrayCounter += 1

createArray(initialNumber)


while devider <= limiter:
    factor = 2
    while factor <= (initialNumber//devider):
        result = devider * factor
        resultingFactorsArray[result] += 1
        factor += 1

    devider += 1


numberOfFactors = 0

for result in resultingFactorsArray:
    if result > numberOfFactors:
        numberOfFactors = result

counter = 0
for number in resultingFactorsArray:
    if number == numberOfFactors and counter != 0:
        print(counter)
    counter += 1

print("With " + str(numberOfFactors+2) + " factors.")

