Multiplicative persistence calculator
Multiply a number's digits again and again until one digit is left: 39 becomes 27, then 14, then 4, so its multiplicative persistence is 3. Every intermediate product is listed, for numbers up to 1000 digits long. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- N
- 39
- Multiplicative persistence
- 3
- Single digit
- 4
Multiplicative persistence of a non-negative integer is the number of times you must replace the number with the product of its decimal digits until only one digit remains. Unlike the digital root path, which sums digits and stabilizes under modular arithmetic, the digit-product map shrinks values aggressively whenever a zero appears and yields a different single-digit terminal value that is not a simple residue of the original number. The measure appears in recreational number theory, contest problems about extreme persistence records, classroom contrasts with additive persistence, and automated checks that grade iterative digit procedures. This calculator takes one non-negative integer, multiplies digits step by step, returns the persistence count and the final single digit, and lists every intermediate product so you can verify the chain by hand without a computer-algebra system.
What multiplicative persistence means
Start with any non-negative integer written in base ten. Multiply its digits together to obtain a new non-negative integer. If the original number had two or more digits, the product is usually much smaller; if any digit is zero, the product is zero immediately.
Repeat the product-of-digits step until the value is a single digit from zero through nine. The number of full product steps required is the multiplicative persistence, and the final digit is the single-digit terminal value of that chain. For example, thirty-nine becomes twenty-seven, then fourteen, then four: the persistence is three and the terminal digit is four.
Ten becomes zero in one step because of the zero digit. Single-digit inputs already need no steps, so their persistence is zero and the single digit is the number itself. Multiplicative persistence is not the same as additive persistence: summing digits of nine thousand eight hundred seventy-five needs three additive steps, while multiplying its digits collapses faster or differently depending on zero and large digits.
Famous hard numbers in the literature pack many nines and sevens to delay zeros and force long product chains; this tool reports the exact step count and every intermediate product for any non-negative integer within the published digit limit, so recreational records and textbook exercises can be checked against a single deterministic definition rather than ad hoc scripts that disagree on edge cases like leading zeros or empty input.
Practical use, limits, pricing, and delivery
Use the browser tool when you want an immediate multiplicative persistence while studying recreational number theory, checking a contest problem, or contrasting digit products with digit sums beside a digital-root lesson. Accepted inputs are non-negative integers, including long digit strings up to one thousand digits so extreme persistence examples and classroom demos are not forced into floating-point approximations. Results are fully deterministic: the same n always yields the same multiplicative persistence, the same single digit, and the same ordered list of intermediate digit products.
There is no language model, no external arithmetic service, and no randomness, so the capability is safe to pin in automated tests and reproducible notebooks. For additive digit sums and digital roots, use the sibling digital-root capability instead of stretching this product-based measure beyond its definition.
What you can do with it
Homework and contest verification
Students and graders can confirm multiplicative persistence and inspect every intermediate digit product for non-negative integers without installing a local computer-algebra system.
Recreational number-theory demos
Lesson materials that compare additive and multiplicative persistence can show product chains beside sum chains so learners see how zeros and large digits change step counts.
FAQ
What happens if n is negative?
Multiplicative persistence is defined here for non-negative integers only; negatives are rejected and not charged.
How is this different from digital root?
Digital root repeatedly sums digits (additive persistence). This calculator repeatedly multiplies digits.
Is the multiplicative persistence calculator free?
The browser tool runs free on your device.
What is the persistence of a single-digit number?
Zero. A single digit needs no product steps.
What is the multiplicative persistence of 39?
It is 3. Multiplying the digits of 39 gives 27, the digits of 27 give 14, and the digits of 14 give 4. Three steps reach a single digit, and that final digit is 4.
Related tools
For developers — API access
Everything on this page is available programmatically. This section is for teams who want to wire it into their own systems; everyone else can just use the tool above.
API endpoint
Prefer to automate it? One authenticated POST creates the task; the result comes back by webhook or a signed link. The same capability also runs here on the web, by email and from Telegram — and soon from our app too.
Call it from your stack
curl -X POST https://api.kit.forhosting.com/numth/multiplicative-persistence \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"n":39}'const res = await fetch("https://api.kit.forhosting.com/numth/multiplicative-persistence", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"n": 39
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/numth/multiplicative-persistence",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"n": 39
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/numth/multiplicative-persistence", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"n":39}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"n":39}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/numth/multiplicative-persistence", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"n": 39
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "numth.multiplicative_persistence",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}The API is asynchronous: the call returns a task_id immediately and the result arrives by webhook. Polling is capped at 1 req/s per task.
Pricing
Published price — no tokens, no invented credits. A failed task is never charged.
Errors
| HTTP | Code | Meaning |
|---|---|---|
401 | unauthorized | Missing or invalid API key. |
402 | insufficient_balance | Your balance doesn't cover the task price. |
404 | unknown_type | That task type doesn't exist. |
429 | rate_limited | Too many requests. Use the webhook instead of polling. |
Technical notes
How this calculator evaluates repeated digit products
The implementation first validates that n is present, finite, integral, and not negative. It then normalizes the value to a canonical digit string without deceptive leading zeros. While the current string has more than one character, the engine multiplies its digit codes, short-circuiting to zero if any digit is zero, records a step with the previous value and the new digit product, and continues from that product written in decimal. Call the capability with a field n holding a non-negative integer, either as a JSON number within the safe integer range or as a decimal digit string for longer values up to one thousand digits. When a single digit remains, that digit is returned as single_digit and the step count is the multiplicative_persistence. Negative inputs, non-integers, missing n, and strings that exceed the maximum digit length fail with invalid_input and are not charged. Output field names stay DOM-safe and stable so widgets, SDK clients, and automated tests can pin the contract without special-case parsing. Intermediate steps keep the previous multi-digit value as a string so large inputs remain auditable even when the original n exceeds the safe integer range of JSON numbers.
Practical use, limits, pricing, and delivery
Each successful request is one billable item at $0.002; failed validation does not consume balance. Wire the endpoint into number-theory demos, contest-prep tools, recreational math pages, or pipelines that already trust exact digit arithmetic more than approximate heuristics or opaque black-box calculators.
Integration use cases
Automated number-theory pipelines
Scripts that search for high-persistence integers or classify values by terminal digit can call a single deterministic item-priced endpoint instead of embedding ad hoc product loops.
Technical questions
How do I compute multiplicative persistence with this API?
Send a JSON body with non-negative integer field n to the numth.multiplicative_persistence capability. The response returns multiplicative_persistence, single_digit, and the ordered list of digit-product steps.