Deficient number checker
15 is deficient: its proper divisors 1, 3 and 5 add up to 9, which is less than 15. Enter any positive integer to get the exact divisor sum and a plain yes or no. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- N
- 15
- Proper divisor sum
- 9
A deficient number has a proper divisor sum smaller than the number itself. This checker accepts a positive integer, finds the sum of every positive divisor below that integer, and returns both the sum and a direct true-or-false result. It handles the special case of one, whose proper divisor set is empty, without approximation.
What makes a number deficient
A proper divisor of n is a positive integer that divides n evenly but is smaller than n. The number is deficient exactly when the sum of those divisors is below n. For example, the proper divisors of fifteen are one, three, and five.
Their sum is nine, so fifteen is deficient because nine is less than fifteen. A prime number is also deficient: its only proper divisor is one, which is smaller than every prime. The value one needs a careful convention.
It has no positive proper divisors, so the sum of its empty divisor set is zero; zero is below one, and this checker therefore reports one as deficient. The comparison is strict. A number whose proper divisor sum equals itself is perfect, not deficient, while a number whose sum exceeds itself is abundant.
How the calculation is performed
The algorithm checks possible divisors only through the square root of n. Whenever it finds a divisor, it adds that divisor and its paired quotient. For example, finding three as a divisor of thirty also discovers ten, because three times ten is thirty.
A perfect-square pair is added only once, preventing the square root from being double counted. For every n greater than one, one is included at the start because one divides every positive integer; n itself is never included because the calculation concerns proper divisors. This paired scan produces the exact integer sum and uses no random sampling, floating-point approximation, clock, external service, or stored state.
Numeric strings containing only decimal digits are accepted, but fractions, signs, scientific notation, missing values, and non-numeric text are rejected. The published upper bound keeps the square-root scan suitable for the lightweight parse engine.
What you can do with it
Check number theory homework
Compare a learner's proper divisor sum and deficient-number decision with a deterministic reference result.
Explore integer sequences
Test candidate values while studying how deficient, perfect, and abundant numbers are distributed.
FAQ
What is a deficient number?
It is a positive integer whose positive proper divisors add to less than the integer itself.
Is one a deficient number?
Yes. One has no proper divisors, so its proper divisor sum is zero, which is less than one.
Are all prime numbers deficient?
Yes. A prime's only positive proper divisor is one, and one is less than every prime.
Is 15 a deficient number?
Yes. The divisors of 15 smaller than itself are 1, 3 and 5, and they add up to 9. Because 9 is less than 15, the number is deficient.
How do deficient, perfect and abundant numbers differ?
Compare the sum of the proper divisors with the number itself. Below it means deficient, exactly equal means perfect, and above it means abundant. This checker answers only the first case, and shows the sum so you can tell the other two apart.
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/deficient-number-check \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"n":15}'const res = await fetch("https://api.kit.forhosting.com/numth/deficient-number-check", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"n": 15
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/numth/deficient-number-check",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"n": 15
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/numth/deficient-number-check", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"n":15}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"n":15}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/numth/deficient-number-check", 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": 15
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "numth.deficient_number_check",
"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.
Limits
max_n | 1000000000000 |
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
What makes a number deficient
The response keeps that decision easy to audit by returning the accepted n, the computed proper_divisor_sum, and the Boolean is_deficient rather than returning a label without its supporting arithmetic. This makes the endpoint useful both as a calculator and as a transparent reference result.
How the calculation is performed
Input may be supplied through n or its documented aliases number and value.
Using the result in lessons and software
A true result means the sum is strictly below n; false means the number is either perfect or abundant. If your workflow must distinguish those two non-deficient cases, compare the returned sum with n: equality identifies a perfect number and a greater sum identifies an abundant number. For batch work, call it once for each item and preserve each response with the originating value, which makes later review straightforward and avoids losing the relationship between an input and its divisor sum. Send one positive integer and read is_deficient for the decision. Keep proper_divisor_sum when you need evidence, debugging context, or a value to show learners. Successful API requests cost $0.002; validation failures return an invalid_input error instead of inventing a result. It is also convenient for checking claims in articles or puzzle solutions because the supporting sum appears beside the Boolean answer. Treat the endpoint as an exact checker within its declared input limit, not as a factorization service for cryptographic-size integers.
Integration use cases
Validate classification code
Use known inputs and returned sums as fixtures when testing an implementation that labels integer properties.
Technical questions
What happens when n is below one?
The request fails with an invalid_input error because this capability accepts only positive integers.
How much does the API request cost?
Each successful API request costs $0.002. The browser runner is available for quick interactive checks.