Factor Calculator: Factors, Pairs, GCF & LCM | StatsUnlock

A factor calculator finds every whole number that divides a given number exactly, with no remainder. The factors of 48 are 1, 2, 3, 4, 6, 8, 12, 16, 24 and 48.

To find them, test each whole number from 1 up to the square root of the number. Every divisor that works gives you two factors at once: itself and the number divided by it. The count of factors comes straight from the prime factorization, so you never have to list them to know how many there are.

Rule of thumb: a number with exactly 2 factors is prime, a number with an odd count of factors is a perfect square, and if the greatest common factor of a list is 1 the numbers cannot be simplified together.

A factor of a whole number is any whole number that divides it exactly. If you can share 12 objects equally among 3 people with nothing left over, then 3 is a factor of 12. A factor calculator does this test for every possible divisor and hands back the complete list, so you do not miss one and you do not have to do the division by hand.

What this calculator reports for every number you enter:

• All factors, in order from 1 up to the number itself.
• Factor pairs, the two numbers that multiply to give your number, such as 6 × 8 = 48.
• Prime factorization, the number written as a product of primes, such as 48 = 2⁴ × 3.
• Number of factors and the sum of factors.
• Type: prime, composite or the unit 1, plus deficient, perfect or abundant, and whether it is a perfect square.

What it reports for every group of numbers: the greatest common factor (GCF), the least common multiple (LCM), the full list of common factors, how many of the numbers are prime, and the mean and median number of factors.

A worked one-liner: 48 ÷ 6 = 8 with no remainder, so 6 and 8 are both factors of 48. Repeat that test for 1, 2, 3, 4, 5 and 6 and you have found every factor: 1, 2, 3, 4, 6, 8, 12, 16, 24, 48. Only 5 fails.

How do you find the factors of a number?

Divide the number by each whole number from 1 up to its square root. Every division that leaves no remainder gives two factors: the divisor and the answer. For 48 you test 1 to 6 and get the pairs 1 and 48, 2 and 24, 3 and 16, 4 and 12, and 6 and 8.

Four methods you can use by hand:

1. Division method. Test 1, 2, 3 and so on up to the square root, and keep the divisors that leave no remainder.
2. Factor pairs, or the rainbow method. Write each divisor with its partner, starting from 1 and the number itself and working inward until the two meet.
3. Factor tree. Split the number into any two factors, then split those again until only primes are left.
4. Prime factorization. Use the primes from the tree and combine them in every possible way to build the full factor list.

How many factors does a number have?

Write the number as a product of primes, add 1 to each exponent, and multiply the results. For 48 = 2⁴ × 3 that is (4 + 1) × (1 + 1) = 10 factors. A prime number always has exactly 2 factors, and a perfect square always has an odd number.

What is the difference between factors and multiples?

Factors divide a number exactly, so they are never larger than the number. Multiples are the number times 1, 2, 3 and so on, so they are never smaller. 6 is a factor of 12, and 24 is a multiple of 12. A number has a fixed list of factors and endless multiples.

Who uses a factor calculator: students checking homework on factors, multiples and fractions. Teachers building worksheets. Researchers who need to know how a sample can be split into equal groups: a sample of 48 can be divided into equal blocks of 2, 3, 4, 6, 8, 12, 16 or 24, but a sample of 47 cannot be divided evenly at all. Engineers matching gear teeth or tile sizes. Programmers testing code that handles primes and divisors.

Factors and divisors mean the same thing on this page. Factoring a number is different from factoring an algebraic expression such as x² + 5x + 6, which this tool does not do.

4.1 What a factor list actually tells you

A factor list answers one question completely: in how many ways can this number be split into equal whole parts? Each factor is one answer. The factors of 48 are 1, 2, 3, 4, 6, 8, 12, 16, 24 and 48, so 48 items can be shared equally among 1, 2, 3, 4, 6, 8, 12, 16, 24 or 48 groups and in no other way. Try 5 groups and you have 3 items left over. Try 7 and you have 6 left over.

That makes the list a statement about flexibility. A number with a long factor list is easy to divide, which is why there are 12 items in a dozen, 60 minutes in an hour and 360 degrees in a circle. A number with a short list is rigid. This is the practical reading of the first chart: tall bars are flexible numbers, short bars are stubborn ones.

4.2 Reading the number of factors

The count of factors is the single most useful summary of a number. Read it against these fixed points. A count of 1 happens only for the number 1. A count of 2 means the number is prime. A count of 3 means the number is the square of a prime, such as 4, 9, 25 or 49. A count of 4 means it is either the product of two different primes, such as 55 = 5 × 11, or the cube of a prime, such as 8.

Anything above 4 is an ordinary composite number, and the count climbs as the number picks up more small primes. Size alone does not make the count large. 61 is bigger than 48, yet 61 has 2 factors and 48 has 10. What matters is how many small primes divide the number and how many times each one does.

4.3 Factor pairs and the square root rule

Factors always come in pairs that multiply to give the number. For 48 the pairs are 1 × 48, 2 × 24, 3 × 16, 4 × 12 and 6 × 8. In every pair one factor sits at or below the square root and the other sits at or above it. The square root of 48 is about 6.93, and the small factors are 1, 2, 3, 4 and 6, all below it.

This is why the calculator only tests divisors up to the square root, and why you should do the same by hand. Testing past the square root finds nothing new. It also explains an odd fact: a perfect square has an odd number of factors, because its square root pairs with itself. 36 has the pairs 1 × 36, 2 × 18, 3 × 12, 4 × 9 and 6 × 6, which is nine factors, not ten.

4.4 Prime factorization: the fingerprint of a number

Every whole number above 1 can be written as a product of primes in exactly one way, apart from the order. This is the fundamental theorem of arithmetic. For 48 the product is 2 × 2 × 2 × 2 × 3, written 2⁴ × 3. No other set of primes multiplies to 48.

Everything else in the results follows from that fingerprint. Every factor of 48 is 2 to some power from 0 to 4, times 3 to the power 0 or 1. That gives 5 choices times 2 choices, which is 10 factors. The second chart shows the fingerprint as a stacked bar: one colour per prime, and the height of each colour is the exponent. Two numbers with bars of the same colours share those primes, and that shared part is exactly their greatest common factor.

4.5 Prime, composite and the special case of 1

A prime number has exactly two factors, 1 and itself. A composite number has more than two. The number 1 is neither. It has only one factor, and mathematicians exclude it from the primes on purpose, because otherwise prime factorization would stop being unique: you could write 6 as 2 × 3, or 1 × 2 × 3, or 1 × 1 × 2 × 3.

In the results table a prime is flagged with an amber badge. That is not an error. It is a caution that this number will not simplify with anything except its own multiples. If your list contains a prime, look at the GCF straight away, because a single prime often forces it down to 1.

4.6 What the greatest common factor tells you

The greatest common factor is the largest whole number that divides every number in the group. It tells you how far the whole list can be reduced at once. For 84, 126 and 210 the GCF is 42, so the three numbers are really 2, 3 and 5 scaled up by 42. For 12, 18 and 30 the GCF is 6.

A GCF of 1 is a real result, not a failure. It means the numbers have no shared building block, so a fraction built from them is already in lowest terms and no equal block size larger than 1 fits all of them. Numbers like this are called coprime, or relatively prime. Note that a list can be coprime as a whole even when some pairs inside it share a factor: 6, 10 and 15 have a GCF of 1, although 6 and 10 share 2, 6 and 15 share 3, and 10 and 15 share 5.

The common factors column lists every factor of the GCF. Those are all the numbers that divide the whole group, and there are never any others.

4.7 What the least common multiple tells you

The least common multiple is the smallest whole number that every value in the group divides into exactly. It is the point where repeating cycles line up. If one event repeats every 12 days and another every 18 days, they coincide every 36 days, because 36 is the LCM of 12 and 18. It is also the lowest common denominator when you add fractions.

For two numbers there is a neat link: the GCF times the LCM equals the product of the two numbers. For 12 and 18, 6 × 36 = 216 = 12 × 18. That rule does not extend to three or more numbers, and assuming it does is a common mistake. The LCM also grows very fast when the numbers share few primes. The five worked numbers on this page are all under 62, yet their LCM is 98,395,440.

4.8 Deficient, perfect and abundant numbers

Add up every factor of a number except the number itself. These are the proper factors. If the total is less than the number it is deficient, if it is equal the number is perfect, and if it is more the number is abundant. For 48 the proper factors add to 76, so 48 is abundant. For 52 they add to 46, so 52 is deficient. For 28 they add to exactly 28, so 28 is perfect.

The fourth chart shows the same idea as one ratio, the sum of all factors divided by the number. A value of exactly 2 is perfect, below 2 is deficient and above 2 is abundant. Every prime sits just above 1, because its only factors are 1 and itself. Perfect numbers are very rare: the first four are 6, 28, 496 and 8128. Abundant numbers are common among multiples of 6 and 12, and the smallest odd abundant number is 945.

4.9 Reading the four charts together

Chart 1 ranks your numbers by how divisible they are. Chart 2 explains why, by showing which primes each one is built from. Chart 3 plots every factor of every number on a log scale, so you can see a shared factor as dots sitting at the same height in different columns. Chart 4 shows whether the factors of each number add up to less or more than twice the number.

Used together they answer most questions without reading the table. Tall bar in chart 1 and many colours in chart 2: a flexible number built from several small primes. Short bar and one colour: a prime or a prime power. Dots at the same height across every column in chart 3: a common factor. No shared height above 1: a GCF of 1.

4.10 What a factor list cannot tell you

Factors are exact arithmetic, not statistics. There is no sampling error, no p-value and no confidence interval here. The mean and median factor counts that the calculator reports are descriptive summaries of the numbers you typed, and they say nothing about any wider population of numbers.

A factor list also says nothing about decimals or fractions. 7.5 has no factor list in the sense used here. And the result depends completely on the number being right. If a count was mis-typed as 48 when it was 49, every factor on the page changes, because 48 has ten factors and 49 has three.

4.11 Decision guide

4.12 Common mistakes this calculator prevents

• Missing a factor. Hand lists usually lose one of the middle factors, such as 16 in the list for 48. The calculator builds factors in pairs so none can be skipped.
• Forgetting 1 and the number itself. Both are always factors, and both are counted.
• Calling 1 a prime. It is labelled as the unit, with one factor.
• Mixing up factors and multiples. Factors are never larger than the number. Multiples are never smaller.
• Using GCF × LCM = product for three or more numbers. The calculator computes the LCM directly, so this shortcut is never needed.
• Silently rounding a decimal. The factors of 8 are not the factors of 7.5. Decimals are skipped and reported, never rounded.
• Losing precision on a large LCM. The LCM is computed with exact integer arithmetic, so every digit shown is correct.

When reporting factor calculator results in a paper, thesis, lab report or lesson plan, say what numbers you factored, how you factored them, and what you used the result for. Factors are exact, so there is no test statistic to report. The five examples below fill in with your own numbers as soon as you run the calculator.

▶ Run the analysis above to auto-fill all five examples with your results.

5.1 Methods wording

One or two sentences are enough. Say that each number was decomposed into primes by trial division up to its square root, that all positive factors were generated from the prime exponents, and that the GCF was found with the Euclidean algorithm. If you used factors to choose a design, say so: "Block sizes were restricted to common factors of the site sample sizes so that every site could be divided into equal blocks."

5.2 The results sentence

Lead with the value the reader needs, then give the evidence. Good: "The site sample sizes (24, 36, 60, 72 and 96) had a greatest common factor of 12, so blocks of 2, 3, 4, 6 or 12 participants divided every site exactly." Weak: "Factors were calculated." Always name the numbers, give the GCF or the factor count, and state the consequence.

5.3 Table and figure conventions

In a table use one row per number with these columns in this order: number, prime factorization, factors, number of factors. Add the GCF and LCM as a footnote or a final row. In a figure, a bar chart of factor counts needs a zero baseline and a whole-number axis, because a count of 2.5 factors has no meaning. Label primes clearly, since readers look for them first.

5.4 The discussion sentence

Say what the factors allowed or prevented. "Because 47 is prime, the pilot sample could not be divided into equal groups, and one participant was assigned by lottery." Or: "A grid of 48 plots was chosen over 50 because 48 has ten factors and allows 4 × 12, 6 × 8 and 3 × 16 layouts." Do not describe a factor result as significant. It is exact, and the word significant will be read as a statistical claim.

5.5 Reporting checklist

• The numbers that were factored are listed in full.
• The word "positive" appears if negative factors were not counted.
• 1 is not described as prime.
• The GCF and LCM are both labelled, never just "common factor".
• The method or software is named.
• Any entry that was removed, such as zero or a decimal, is mentioned.
• Large values use a thousands separator and are written in full, not in scientific notation.

These are the seven rules behind every number this factor calculator reports, in the order they are applied.

This flowchart shows how a factor calculator works, step by step, from a raw list of whole numbers to a checked set of factors, a GCF and an LCM. Every box uses the same worked example as the Excel, R and Python sections: the class worksheet numbers 52, 48, 55, 61 and 47, with 48 worked in full.

Check any box yourself: the Excel sheet in Section 9, the R script in Section 10 and the Python script in Section 11 all return 10 factors for 48, a GCF of 1 and an LCM of 98,395,440 for this dataset.

1. Enter your whole numbers. The default tab takes comma-separated whole numbers, exactly as the placeholder shows: 52, 48, 55, 61, 47, .... Spaces, new lines, tabs and semicolons also work, so a column pasted from Excel is fine.
2. Name each group. The group name above every box is editable. Type something meaningful such as Room A sides (cm) and it flows into the tables, the charts and the downloads.
3. Add or remove clusters. Press Add cluster to compare several lists side by side. Every cluster has its own Clear and Remove button, and Remove is disabled on the last one.
4. Or upload a file. On the Upload tab choose a CSV or Excel file, then click the column names you want. Every column you click becomes its own cluster, and the preview highlights your choice.
5. Try a sample dataset. Ten built-in datasets cover tile planning, fractions, study group sizes, gear teeth, primes, perfect numbers, highly composite numbers and a messy list that shows what gets skipped.
6. Choose how negatives and duplicates are handled. Leave the settings on their defaults for standard positive factors, or switch on negative factors and remove repeated numbers.
7. Press Calculate Factors. Nothing is computed until you do. Changing any input or setting clears the results, so you never read stale numbers.
8. Pick a number to see in detail. The dropdown at the top of the results selects one number. Its factors, factor pairs, formulas and step-by-step working update at once.
9. Read the input quality table. It lists every entry that was skipped and why. Check it before you trust the GCF and LCM.
10. Check the four charts and export. Chart 2 shows which primes your numbers share. Section 5 fills in five reporting styles, and the two buttons download a text report or a print-ready PDF.

Worked example: load sample 1, press Calculate Factors, and you should see 48 with 10 factors, a GCF of 1 and an LCM of 98,395,440.

Excel has built-in functions for the greatest common factor and the least common multiple, but it has no function that lists the factors of a number. You build that list yourself with MOD, which returns a remainder, and SEQUENCE, which generates the divisors to test. This section shows the sheet at each stage, using the same five numbers as the rest of the page: 52, 48, 55, 61 and 47.

9.1 The functions you need

GCD and LCM are built in from Excel 2007 onward. In Excel 2003 they are part of the Analysis ToolPak, which must be enabled first under Tools, Add-Ins.

9.2 Step by step

9.3 The awkward cases

Large numbers. The one-line formula tests every divisor up to the number itself, so it stops working above 1,048,576, the number of rows in a sheet. Test only up to the square root and it reaches about one trillion. This version needs Excel 365:

It finds the small factor of each pair, divides the number by it to get the large one, and sorts the two sets together. UNIQUE removes the repeat when the number is a perfect square.

Factor pairs side by side. With the small factors spilled in C2, type this next to them to get each partner:

The # after C2 means "the whole spilled range". The classic mistake is to type =A3/C2 and fill down by hand, which breaks as soon as the number of factors changes.

Common factors of a list. Find the GCF first, then list the factors of the GCF. Every common factor of the list is a factor of the GCF and nothing else is.

9.4 Why your Excel answer might differ from R or Python

9.5 Charting the result in Excel

Select the factor counts in B2:B6 and insert a Clustered Column chart. Then right-click the chart, choose Select Data, and set A2:A6 as the horizontal axis labels. If you select columns A and B together, Excel plots the numbers themselves as a second series, which is wrong.

Two changes make it ready to publish. Set the vertical axis major unit to 1, because a factor count is always a whole number. Then recolour the bars for the primes, so the reader finds them at a glance.

9.6 Excel errors you will probably hit

Base R has no factors() function for whole numbers. The word factor in R means a categorical variable, which is a different thing entirely. The script below is complete and runs top to bottom: it lists the factors and prime factors of each number, finds the GCF and LCM, prints a plain-English verdict, and saves one publication-ready figure at 300 dpi. It uses base R only, so there is nothing to install.

10.1 The complete script

R, base only, saves factor_plot.png

# ============================================================
# Factors, factor pairs, prime factorization, GCF and LCM
# with a single publication-ready plot
# StatsUnlock - https://statsunlock.com/factor-calculator/
# ============================================================

# ---- 1. Your data: change only this line --------------------
x <- c(52, 48, 55, 61, 47)
# x <- read.csv("numbers.csv")$number

# ---- 2. Clean: keep positive whole numbers only -------------
x <- x[!is.na(x)]
x <- x[x == floor(x) & x > 0]

get_factors <- function(n) {
  d <- seq_len(floor(sqrt(n)))
  small <- d[n %% d == 0]
  sort(unique(c(small, n / small)))
}

prime_factors <- function(n) {
  out <- c()
  p <- 2
  while (p * p <= n) {
    while (n %% p == 0) {
      out <- c(out, p)
      n <- n / p
    }
    p <- p + 1
  }
  if (n > 1) out <- c(out, n)
  out
}

gcd2 <- function(a, b) if (b == 0) a else gcd2(b, a %% b)
lcm2 <- function(a, b) a / gcd2(a, b) * b

# ---- 3. Compute ----------------------------------------------
facs  <- lapply(x, get_factors)
count <- sapply(facs, length)
total <- sapply(facs, sum)
kind  <- ifelse(x == 1, "unit", ifelse(count == 2, "prime", "composite"))
gcf   <- Reduce(gcd2, x)
lcm   <- Reduce(lcm2, x)

# ---- 4. Print the summary -------------------------------------
cat("Numbers analysed:", length(x), "\n")
for (i in seq_along(x)) {
  pf <- paste(prime_factors(x[i]), collapse = " x ")
  cat(sprintf("%s = %s | %d factors: %s | sum %s | %s\n",
              x[i], pf, count[i], paste(facs[[i]], collapse = ", "),
              total[i], kind[i]))
}
cat("Greatest common factor (GCF):", gcf, "\n")
cat("Least common multiple (LCM): ",
    format(lcm, big.mark = ",", scientific = FALSE), "\n")
cat(sprintf("Mean factors per number: %.2f\n", mean(count)))
best <- x[which.max(count)]
if (gcf == 1) {
  cat(sprintf("Verdict: the numbers share no factor above 1, so they cannot be simplified together. %s has the most factors (%d).\n",
              best, max(count)))
} else {
  cat(sprintf("Verdict: every number divides exactly by %s. %s has the most factors (%d).\n",
              gcf, best, max(count)))
}

# ---- 5. One 300 dpi figure ------------------------------------
# Nothing here is random, so the figure is identical on every run.
png("factor_plot.png", width = 2100, height = 1900, res = 300)
layout(matrix(c(1, 2)), heights = c(1, 1))
par(mar = c(4, 4.5, 2.5, 1))
cols <- ifelse(kind == "prime", "#f59e0b", "#16a34a")
bp <- barplot(count, names.arg = x, col = cols, border = NA,
              ylim = c(0, max(count) * 1.25),
              xlab = "Number", ylab = "Number of factors",
              main = "How many factors each number has")
text(bp, count, labels = count, pos = 3, cex = 0.9)
legend("topright", legend = c("Composite", "Prime"),
       fill = c("#16a34a", "#f59e0b"), border = NA, bty = "n")

plot(NA, xlim = c(0.5, length(x) + 0.5), ylim = c(1, max(x)), log = "y",
     xaxt = "n", xlab = "Number", ylab = "Factor (log scale)",
     main = "Every factor of every number")
axis(1, at = seq_along(x), labels = x)
for (i in seq_along(x)) {
  points(rep(i, count[i]), facs[[i]], pch = 19, col = "#2563eb")
}
dev.off()
cat("\nSaved factor_plot.png\n")

Run it with Rscript factor_plot.R from a terminal, or paste it into the RStudio console. For the worked example it prints 10 factors for 48, a GCF of 1 and an LCM of 98,395,440. The figure appears as factor_plot.png in your working directory, which you can check with getwd().

10.2 What each part does

10.3 What the figure shows

The upper panel is a bar chart of how many factors each number has, with composite numbers in green and primes in amber. For the worked example the bar for 48 stands at 10, well above the rest, and the two amber bars for 61 and 47 stand at 2.

The lower panel plots every factor of every number as a dot, on a log scale. Each column always has a dot at 1 and a dot at the number itself. A factor shared by the whole list would show as dots at the same height in every column. Here the only height shared by all five columns is 1, which is the picture of a GCF of 1.

10.4 Common R problems and fixes

10.5 Useful one-liners

Python is the best of the three tools for this job, because its whole numbers have no size limit and the standard library already contains math.gcd and math.isqrt. The script below is complete and runnable: it lists every factor and the prime factorization of each number, finds the GCF and LCM, prints a verdict, and saves one 300 dpi figure.

Install with pip install matplotlib if you do not already have it. Add pandas only if you use the commented CSV line.

11.1 The complete script

Python 3, saves factor_plot.png

# ============================================================
# Factors, factor pairs, prime factorization, GCF and LCM
# with a single publication-ready plot
# StatsUnlock - https://statsunlock.com/factor-calculator/
# ============================================================
import math
from functools import reduce
import matplotlib
matplotlib.use("Agg")                 # write to file, no window needed
import matplotlib.pyplot as plt

# ---- 1. Your data: change only this line --------------------
x = [52, 48, 55, 61, 47]
# import pandas as pd
# x = pd.read_csv("numbers.csv")["number"].dropna().astype(int).tolist()

# ---- 2. Clean: keep positive whole numbers only -------------
x = [int(v) for v in x if v is not None and float(v) == int(v) and int(v) > 0]


def get_factors(n):
    """Every positive factor of n, by trial division up to the square root."""
    small = [d for d in range(1, math.isqrt(n) + 1) if n % d == 0]
    return sorted(set(small + [n // d for d in small]))


def prime_factors(n):
    """Prime factorization as a dict, for example 48 -> {2: 4, 3: 1}."""
    out, p = {}, 2
    while p * p <= n:
        while n % p == 0:
            out[p] = out.get(p, 0) + 1
            n //= p
        p += 1
    if n > 1:
        out[n] = out.get(n, 0) + 1
    return out


def lcm2(a, b):
    return a // math.gcd(a, b) * b


# ---- 3. Compute ----------------------------------------------
facs = [get_factors(n) for n in x]
count = [len(f) for f in facs]
total = [sum(f) for f in facs]
kind = ["unit" if n == 1 else ("prime" if c == 2 else "composite")
        for n, c in zip(x, count)]
gcf = reduce(math.gcd, x)
lcm = reduce(lcm2, x)

# ---- 4. Print the summary -------------------------------------
print(f"Numbers analysed: {len(x)}")
for n, f, c, t, k in zip(x, facs, count, total, kind):
    pf = " x ".join(f"{p}^{e}" if e > 1 else f"{p}" for p, e in prime_factors(n).items())
    print(f"{n} = {pf or '1'} | {c} factors: {f} | sum {t} | {k}")
print(f"Greatest common factor (GCF): {gcf}")
print(f"Least common multiple (LCM):  {lcm:,}")
print(f"Mean factors per number: {sum(count) / len(count):.2f}")
best = x[count.index(max(count))]
if gcf == 1:
    print(f"Verdict: the numbers share no factor above 1, so they cannot be "
          f"simplified together. {best} has the most factors ({max(count)}).")
else:
    print(f"Verdict: every number divides exactly by {gcf}. "
          f"{best} has the most factors ({max(count)}).")

# ---- 5. One 300 dpi figure ------------------------------------
# Nothing here is random, so the figure is identical on every run.
fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(7, 6.4),
                               gridspec_kw={"hspace": 0.45})
pos = list(range(1, len(x) + 1))
cols = ["#f59e0b" if k == "prime" else "#16a34a" for k in kind]
bars = ax1.bar(pos, count, color=cols, zorder=2)
for b, c in zip(bars, count):
    ax1.text(b.get_x() + b.get_width() / 2, c + 0.15, str(c),
             ha="center", va="bottom", fontsize=10)
ax1.set_xticks(pos)
ax1.set_xticklabels([str(n) for n in x])
ax1.set_ylim(0, max(count) * 1.25)
ax1.set_ylabel("Number of factors")
ax1.set_title("How many factors each number has", fontweight="bold")
ax1.grid(axis="y", color="#e5e7eb", zorder=1)
ax1.legend(handles=[plt.Rectangle((0, 0), 1, 1, color="#16a34a"),
                    plt.Rectangle((0, 0), 1, 1, color="#f59e0b")],
           labels=["Composite", "Prime"], frameon=False, loc="upper right")

for i, f in zip(pos, facs):
    ax2.scatter([i] * len(f), f, color="#2563eb", s=30, zorder=2)
ax2.set_yscale("log")
ax2.set_xticks(pos)
ax2.set_xticklabels([str(n) for n in x])
ax2.set_xlim(0.5, len(x) + 0.5)
ax2.set_xlabel("Number")
ax2.set_ylabel("Factor (log scale)")
ax2.set_title("Every factor of every number", fontweight="bold")
ax2.grid(axis="y", color="#e5e7eb", zorder=1)

for ax in (ax1, ax2):
    ax.spines[["top", "right"]].set_visible(False)
fig.savefig("factor_plot.png", dpi=300, bbox_inches="tight")
print("\nSaved factor_plot.png")

This script was run while building this page. For the worked example it prints 10 factors for 48, a GCF of 1, an LCM of 98,395,440 and a mean of 4.80 factors per number, the same values as the calculator above.

11.2 What each part does

11.3 What the figure shows

The same figure as the R script, drawn by a different engine. The upper panel shows the number of factors of each number, with primes in amber. The lower panel shows every factor as a dot on a log scale, one column per number.

Read the lower panel across, not down. If a row of dots lines up at the same height in every column, that height is a common factor, and the highest such row is the GCF. For 52, 48, 55, 61 and 47 only the bottom row at 1 lines up.

11.4 Common Python problems and fixes

11.5 Useful one-liners

Run the script with python factor_plot.py from a terminal. In Jupyter, remove the matplotlib.use("Agg") line and add plt.show() at the end to see the figure inline.

Eight lookup tables for checking a factor list by eye. Every value was computed, not copied, and matches what the factor calculator above returns.

12.1 Factors of every number from 1 to 36

What to conclude: the count column never follows the size of the number. 36 has nine factors and 31 has two. Look your number up here to check a hand calculation.

12.2 Divisibility rules for 2 to 12

What to conclude: use these rules to find the small factors in your head before you reach for a calculator. If a number passes none of the rules for 2, 3, 5, 7 and 11, and it is below 169, it is prime.

12.3 Prime numbers below 200

What to conclude: there are 46 primes below 200. If your number is in this table it has exactly two factors, 1 and itself, and no factor calculator will find more.

12.4 How many factors: reading the count from the prime exponents

What to conclude: add 1 to each exponent and multiply. You can state the number of factors of any number from its prime factorization alone, without listing a single one.

12.5 Highly composite numbers up to 5,040

What to conclude: each number here has more factors than every smaller number. This is why 12, 24, 60 and 360 are used for time, angles and packaging. The idea was first studied in depth by Ramanujan (1915), listed in Section 23.

12.6 Deficient, perfect and abundant numbers

What to conclude: compare the sum of proper factors with the number. Equal means perfect, which is rare: 6, 28, 496 and 8,128 are the only perfect numbers below 10,000. The ratio in the fourth column is what chart 4 plots.

12.7 GCF and LCM of common pairs

What to conclude: the last two columns are always equal. For two numbers, GCF × LCM is the product of the numbers. This shortcut does not work for three or more numbers.

12.8 Factors of commonly searched numbers

What to conclude: these are the numbers people look up most often, from the factors of 60 and 72 to the factors of 100, 144 and 360. Any number not listed here can be typed into the calculator above.

Eight worked cases, from the plain textbook number to the inputs that break a factor list. Each one shows the figure, the numbers, what they mean and how to write them up.

Study design: a factor calculator assumes a list of exact, positive whole numbers. These are usually counts: participants, plots, items, teeth, tiles or days. A measured quantity such as 12.4 cm is not a count and has no factor list.

1. Decide what question the factors will answer. Equal group sizes need the factors of one number. Simplifying a ratio needs the GCF of two or more. Lining up cycles needs the LCM. Write the question down first.
2. Collect counts, not measurements, for the factor calculator. Count whole units. If a value has a decimal part, it belongs in a different analysis.
3. Record each number exactly as counted. Do not round 47 to 48 because 48 is easier to divide. The factors of 48 say nothing about 47.
4. Keep units out of the cells. Type 120, not 120 cm. Put the unit in the group name, where it is safe.
5. Write large numbers without separators. Type 98395440, not 98,395,440. A comma inside a number is read as a break between two numbers.
6. Record missing values as blanks. A blank is ignored. A zero typed in place of a missing value is reported as a skipped entry and cannot be factored.
7. Group numbers that belong together. The GCF and LCM are calculated per group, so put the numbers you want compared in the same column.
8. Prepare a GCF and LCM list with one column per group, exactly as the layout below shows, ready to paste or upload here.
9. Check the count of entries before you calculate factors. The results table should have the same number of rows as your list. If it has fewer, an entry was skipped.
10. Confirm one result by hand. Pick the smallest number, list its factor pairs yourself, and compare. One check catches most typing errors.

One column per group, one row per number, whole numbers only below the header row. Blank cells are ignored, so unequal group sizes are fine.

Minimum sample: one number is enough for a factor list. You need at least two numbers in a group for the GCF and LCM to say anything, and the calculator accepts up to 200 per group.

Pre-registration: if factors decide a design choice, such as block size, record the rule before you look at the numbers: "blocks will be the largest common factor of the site sample sizes that is not above 8". Then the choice cannot drift toward a convenient answer.

Common collection mistakes:

• Typing a thousands separator, which splits one number into two.
• Rounding a count to a friendlier number before factoring it.
• Recording missing values as zero.
• Mixing numbers from unrelated sources in one group, which forces the GCF to 1.
• Pasting measurements with decimals and expecting factors.

This free factor calculator is designed for exact questions about whole numbers. It is the right tool more often than people expect, and the wrong tool in a few clear cases.

Use it when:

• ✓ You need every factor or every factor pair of a whole number.
• ✓ You want to know if a number is prime or composite.
• ✓ You are simplifying a fraction or a ratio and need the GCF.
• ✓ You are adding fractions or syncing repeating events and need the LCM.
• ✓ You need to split a sample, a class or a field into equal groups.
• ✓ You want to compare several lists of numbers side by side.

Do not use it when:

• ✗ Your values are decimals or measurements. Factors apply to whole numbers only.
• ✗ You need to factor an algebraic expression such as x² + 5x + 6. That is polynomial factoring, a different task.
• ✗ You want factor analysis, the statistical method that finds hidden variables behind survey items. The name is similar and the method is unrelated.
• ✗ You need a Bayes factor, a variance inflation factor or a conversion factor. Those are statistics and units, not divisors.
• ✗ Your number is above 1,000,000,000,000. Use SymPy in Python, which uses faster methods.

Real-world examples:

1. Research design. A trial has 48 participants. The factors show it can be run with equal arms of 24, 16, 12, 8, 6, 4, 3 or 2 people.
2. Field ecology. A 120 m by 180 m plot is to be divided into equal square quadrats. The GCF is 60, so squares of 60, 30, 20, 15, 12, 10 m and smaller all fit exactly.
3. Teaching. A class of 30 can be put in equal groups of 2, 3, 5, 6, 10 or 15. A class of 29 cannot be grouped equally at all.
4. Scheduling. One sensor logs every 12 minutes and another every 18. They log together every 36 minutes, the LCM.

Study design guidance: if you can choose your sample size, choose one with many factors. 48 or 60 gives far more ways to form equal groups than 50 or 47.

Decision tree: one whole number and you want its divisors: use this calculator. Two or more whole numbers and you want what they share: use the GCF from this calculator. Decimals: stop, factors do not apply. An expression with letters in it: use a polynomial factoring tool. Survey items and hidden variables: use exploratory factor analysis.

Assumptions

1. Every value is a whole number. Check that no entry has a decimal part. If one slips through after rounding, the factors belong to a different number, and the error can go either way: rounding 47.6 to 48 turns a number with no factor list into one with ten factors.
2. Every value is positive. Check for minus signs. A negative number is factored as its positive value, so the list is right but the sign is lost. Counting negative factors doubles the count.
3. No value is zero. Check for zeros used as missing-value codes. Every whole number divides zero, so its factor list has no end. Left in, a zero would force the LCM to 0.
4. The number is recorded exactly. Check counts at the source. An error of one changes everything: 48 has ten factors and 49 has three. The factor count is biased in no fixed direction, which is what makes this error hard to spot.
5. Numbers in a group belong together. Check that each group answers one question. One unrelated number pulls the GCF down toward 1 and pushes the LCM up, often by a large multiple.
6. Each value is at or below 1,000,000,000,000. Check the size of your largest number. Larger values are skipped, so the group results would describe fewer numbers than you entered.

Limitations

• The method is trial division. It is exact and fast up to one trillion, but it is not suitable for the very large numbers used in cryptography. Use SymPy or the gmp package in R, which use Pollard rho and elliptic curve methods.
• It handles whole numbers only. For algebraic expressions use a polynomial factoring tool.
• It is not factor analysis. For latent variables behind survey data, use exploratory or confirmatory factor analysis in R or Python.
• The mean and median factor counts describe only the numbers you typed. They carry no uncertainty and support no inference about other numbers.
• A group is limited to 200 numbers and the page to eight groups. For longer lists use the R or Python script.
• Factor lists longer than 120 values are shortened on screen. The complete list is always in the Download Doc file.
• The charts show the first 40 numbers only. The tables and downloads include all of them.

A factor calculator answers a simple question exactly: which whole numbers divide this one with nothing left over? The arithmetic is easy. The value is in getting the complete list every time, and in seeing what the list means.

What was found on this page. Every factor comes with a partner, and the pair always straddles the square root. That is why you only test divisors up to the square root, and why a perfect square has an odd number of factors. The prime factorization is the fingerprint behind everything else: add 1 to each exponent and multiply, and you have the number of factors without listing one. For 48 that is 5 × 2 = 10.

What it means in practice. A long factor list means flexibility. A sample of 48 can be divided into equal groups in eight useful ways, while a sample of 47 cannot be divided at all. For a list of numbers, the greatest common factor tells you how far the whole list can be reduced, and the least common multiple tells you where repeating cycles meet. A GCF of 1 is a genuine answer, meaning the numbers share nothing.

Cautions. Factors belong to exact whole numbers. A decimal has no factor list, zero has an endless one, and a count that is wrong by one gives a completely different result. The number 1 is not prime. And the shortcut GCF × LCM = product is true for two numbers only. Factor results are exact, so do not describe them with statistical words such as significant.

Next steps. Paste your numbers into the calculator, read the input quality table first so you know nothing was skipped, and look at chart 2 to see which primes your numbers share. Copy a sentence from Section 5 for your report, and confirm the values with the Excel, R or Python steps in Sections 9 to 11. Come back to this factor calculator whenever you need to split, simplify or line up whole numbers.

The following peer-reviewed journal articles support the methods used in this factor calculator, covering trial division and faster factoring methods, primality testing, the greatest common factor, highly composite numbers, and how learners understand divisibility.

1. Rivest, R. L., Shamir, A., & Adleman, L. (1978). A method for obtaining digital signatures and public-key cryptosystems. Communications of the ACM, 21(2), 120–126. https://doi.org/10.1145/359340.359342
2. Pollard, J. M. (1974). Theorems on factorization and primality testing. Mathematical Proceedings of the Cambridge Philosophical Society, 76(3), 521–528. https://doi.org/10.1017/S0305004100049252
3. Pollard, J. M. (1975). A Monte Carlo method for factorization. BIT Numerical Mathematics, 15(3), 331–334. https://doi.org/10.1007/BF01933667
4. Brent, R. P. (1980). An improved Monte Carlo factorization algorithm. BIT Numerical Mathematics, 20(2), 176–184. https://doi.org/10.1007/BF01933190
5. Lenstra, H. W., Jr. (1987). Factoring integers with elliptic curves. Annals of Mathematics, 126(3), 649–673. https://doi.org/10.2307/1971363
6. Agrawal, M., Kayal, N., & Saxena, N. (2004). PRIMES is in P. Annals of Mathematics, 160(2), 781–793. https://doi.org/10.4007/annals.2004.160.781
7. Shor, P. W. (1997). Polynomial-time algorithms for prime factorization and discrete logarithms on a quantum computer. SIAM Journal on Computing, 26(5), 1484–1509. https://doi.org/10.1137/S0097539795293172
8. Miller, G. L. (1976). Riemann’s hypothesis and tests for primality. Journal of Computer and System Sciences, 13(3), 300–317. https://doi.org/10.1016/S0022-0000(76)80043-8
9. Rabin, M. O. (1980). Probabilistic algorithm for testing primality. Journal of Number Theory, 12(1), 128–138. https://doi.org/10.1016/0022-314X(80)90084-0
10. Solovay, R., & Strassen, V. (1977). A fast Monte-Carlo test for primality. SIAM Journal on Computing, 6(1), 84–85. https://doi.org/10.1137/0206006
11. Adleman, L. M., Pomerance, C., & Rumely, R. S. (1983). On distinguishing prime numbers from composite numbers. Annals of Mathematics, 117(1), 173–206. https://doi.org/10.2307/2006975
12. Dixon, J. D. (1981). Asymptotically fast factorization of integers. Mathematics of Computation, 36(153), 255–260. https://doi.org/10.1090/S0025-5718-1981-0595059-1
13. Morrison, M. A., & Brillhart, J. (1975). A method of factoring and the factorization of F₇. Mathematics of Computation, 29(129), 183–205. https://doi.org/10.1090/S0025-5718-1975-0371800-5
14. Montgomery, P. L. (1987). Speeding the Pollard and elliptic curve methods of factorization. Mathematics of Computation, 48(177), 243–264. https://doi.org/10.1090/S0025-5718-1987-0866113-7
15. Knuth, D. E., & Trabb Pardo, L. (1976). Analysis of a simple factorization algorithm. Theoretical Computer Science, 3(3), 321–348. https://doi.org/10.1016/0304-3975(76)90050-5
16. Ramanujan, S. (1915). Highly composite numbers. Proceedings of the London Mathematical Society, s2-14(1), 347–409. https://doi.org/10.1112/plms/s2_14.1.347
17. Stein, J. (1967). Computational problems associated with Racah algebra. Journal of Computational Physics, 1(3), 397–405. https://doi.org/10.1016/0021-9991(67)90047-2
18. Diffie, W., & Hellman, M. (1976). New directions in cryptography. IEEE Transactions on Information Theory, 22(6), 644–654. https://doi.org/10.1109/TIT.1976.1055638
19. Zazkis, R., & Campbell, S. (1996). Divisibility and multiplicative structure of natural numbers: Preservice teachers’ understanding. Journal for Research in Mathematics Education, 27(5), 540–563. https://doi.org/10.2307/749847
20. Meurer, A., Smith, C. P., Paprocki, M., Čertík, O., Kirpichev, S. B., Rocklin, M., Kumar, A., Ivanov, S., Moore, J. K., Singh, S., Rathnayake, T., Vig, S., Granger, B. E., Muller, R. P., Bonazzi, F., Gupta, H., Vats, S., Johansson, F., Pedregosa, F., … Scopatz, A. (2017). SymPy: Symbolic computing in Python. PeerJ Computer Science, 3, e103. https://doi.org/10.7717/peerj-cs.103