ForHosting KIT · Mathématiques

Calculatrice somme des diviseurs

Les diviseurs de 12 totalisent 28 : 1 + 2 + 3 + 4 + 6 + 12. Saisissez tout entier positif jusqu'à mille milliards et obtenez cette somme exacte avec les facteurs premiers utilisés pour la calculer. Gratuit dans votre navigateur.

Gratuit
Fonctionne dans votre navigateur
Sans inscription
Vos données restent sur votre appareil

Lancer gratuitement Voir l’API

Utilisez-le depuis WebAPIE-mailTelegramApp bientôt

Exemple résolu

Si vous saisissez

N: 12

Vous obtenez

Sigma (σ): 28

La fonction divisoria sigma(n) additionne tous les diviseurs positifs d'un entier positif n, y compris 1 et n. Les nombres parfaits, abondants, les suites aliquotes et de nombreux contrôles de théorie des nombres dépendent de ce total. Cette capacité factorise n par division d'essai, applique la formule multiplicative de la somme des diviseurs et renvoie à la fois sigma(n) et la factorisation première utilisée pour le calculer—déterministe, hors ligne et gratuite à essayer dans votre navigateur.

Ce que signifie sigma(n) et pourquoi la factorisation suffit

Pour un entier positif n, sigma(n) est la somme de tous les entiers positifs qui divisent n exactement. Par exemple, les diviseurs positifs de 12 sont 1, 2, 3, 4, 6 et 12, donc sigma(12) vaut 28. Énumérer chaque diviseur en parcourant jusqu'à n fonctionne pour de très petites valeurs mais devient coûteux à mesure que n croît.

La théorie des nombres fournit une forme multiplicative fermée : si la factorisation première de n est p1^a1 fois p2^a2 fois … fois pk^ak, alors sigma(n) est le produit sur i de (1 + pi + pi^2 + … + pi^ai), qui est aussi (pi^(ai+1) − 1) / (pi − 1). Cette identité est exacte pour tout n supérieur ou égal à 1 ; en particulier sigma(1) vaut 1 avec un produit vide.

Cette calculatrice ne tire jamais de candidats au hasard ni n'approxime : elle factorise n une fois, multiplie la série géométrique de chaque puissance de premier et renvoie le total entier avec les facteurs trouvés pour que vous auditiez les étapes.

Nombres parfaits, déficients et abondants en pratique

Comparer sigma(n) à 2n classe n : si sigma(n) égale 2n le nombre est parfait (ses diviseurs propres somment à lui-même) ; si sigma(n) est inférieur à 2n il est déficient ; s'il est supérieur, abondant. Six est le plus petit nombre parfait car sigma(6) vaut 12. Vingt-huit est le prochain exemple parfait classique.

Des nombres abondants tels que 12 (sigma 28) et 18 (sigma 39) apparaissent dans la recherche sur les suites aliquotes et la théorie des nombres récréative. Comme ce point d'accès renvoie la somme et la factorisation, vous pouvez aussi dériver le nombre de diviseurs comme le produit de (exposant + 1) pour chaque puissance de premier, ou reconstruire la liste complète des diviseurs hors ligne à partir des facteurs pour l'enseignement ou le débogage.

Gardez n dans la limite publiée pour que la division d'essai reste interactive ; pour des entiers de taille cryptographique il faut une pile de factorisation multiprécision dédiée, pas cette capacité légère de parse.

Cas d’usage

Classer parfaits, déficients et abondants

Calculez sigma(n) et comparez-le à 2n pour étiqueter chaque entier d'un devoir ou d'un tableau de recherche sans énumérer les diviseurs à la main.

Vérifier devoirs et concours basés sur la factorisation

Étudiants et concurrents peuvent vérifier que leur factorisation première donne la bonne somme des diviseurs avant de rendre preuves ou solutions de programmation.

Questions fréquentes

Qu'est-ce que la somme des diviseurs de n ?

C'est sigma(n) : la somme de tous les diviseurs positifs de n, y compris 1 et n. Pour 12 les diviseurs sont 1, 2, 3, 4, 6 et 12, donc la somme vaut 28.

Comment cette calculatrice calcule-t-elle sigma(n) ?

Elle factorise n par division d'essai et multiplie la série géométrique (1 + p + … + p^a) pour chaque puissance de premier p^a de la factorisation—la formule multiplicative standard.

La réponse inclut-elle les facteurs premiers ?

Oui. À côté de sigma vous recevez factors comme paires premier/exposant pour vérifier la formule produit ou poursuivre avec des décomptes de diviseurs liés.

Quelle est la somme des diviseurs de 12 ?

Elle vaut 28. Les diviseurs de 12 sont 1, 2, 3, 4, 6 et 12, et leur somme donne 28, ce qui dépasse le double de 12.

Comment savoir avec cette somme si un nombre est parfait ?

Comparez la somme au double du nombre. Si elles sont égales, le nombre est parfait, comme 6 dont les diviseurs totalisent 12. Plus petite, il est déficient ; plus grande, comme 12 avec 28, il est abondant.

Outils associés

Pour les développeurs — accès API

Tout sur cette page est disponible par programmation. Cette section s'adresse aux équipes qui veulent l'intégrer à leurs systèmes ; les autres peuvent simplement utiliser l'outil ci-dessus.

Endpoint

POSThttps://api.kit.forhosting.com/numth/divisor-sum

Authentification par jeton Bearer : un seul POST met la tâche en file d’attente, et le résultat vous parvient par webhook ou lien signé.

Appeler depuis votre stack

curl -X POST https://api.kit.forhosting.com/numth/divisor-sum \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"n":12}'

const res = await fetch("https://api.kit.forhosting.com/numth/divisor-sum", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "n": 12
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/numth/divisor-sum",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "n": 12
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/numth/divisor-sum", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"n":12}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"n":12}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/numth/divisor-sum", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Exemple de requête

{
  "n": 12
}

Exemple de réponse

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "numth.divisor_sum",
  "status": "queued",
  "_links": {
    "result": "/tasks/tsk_…/result"
  }
}

L’API est asynchrone : chaque appel renvoie un task_id immédiatement, puis vous interrogez l’état à raison d’une requête par seconde.

Tarifs

par requête$0.002

Le prix est publié, sans tokens ni crédits. Une tâche qui échoue n’est pas facturée.

Limites

max_n 1000000000000

Erreurs

HTTP	Code	Signification
`401`	`unauthorized`	Clé API absente ou invalide : vérifiez l’en-tête Authorization.
`402`	`insufficient_balance`	Solde insuffisant : rechargez votre compte pour lancer cette tâche.
`404`	`unknown_type`	Type de tâche inconnu : vérifiez le champ type de votre requête.
`429`	`rate_limited`	Trop de requêtes : ralentissez la cadence, puis réessayez.

Notes techniques

Comment appeler l'API et ce qui revient

En cas de succès la réponse inclut n tel qu'accepté, sigma comme la somme complète des diviseurs, et factors comme liste ordonnée d'objets avec prime et exponent. Utilisez-la depuis des scripts, des pipelines de devoirs, des write-ups CTF ou tout flux qui a besoin d'un sigma(n) reproductible sans installer un système d'algèbre informatique. Envoyez un corps JSON avec un seul champ obligatoire n—un entier positif au moins 1 et au plus un billion (10^12). Les alias number et value sont acceptés pour le même champ. Une validation échouée—n manquant, non entier, valeur sous 1 ou au-dessus de la limite—renvoie invalid_input et n'est jamais facturée. Le tarif est un forfait de $0.002 par requête réussie (élément unitaire à prix marginal unitaire zéro).

Cas d'intégration

Construire des pipelines aliquotes ou de nombres amis

Les scripts qui parcourent des suites aliquotes ont besoin d'une étape sigma fiable ; appelez cette API (ou le noyau gratuit du navigateur) comme brique déterministe.

Questions techniques

Quelles entrées sont rejetées ?

n manquant, non entiers, valeurs sous 1 et valeurs au-dessus de 10^12 renvoient invalid_input. Ces échecs ne sont pas facturés.

La calculatrice de somme des diviseurs est-elle gratuite ?

L'outil navigateur est gratuit et s'exécute localement. Les appels API utilisent le solde prépayé KIT à $0.002 par requête réussie ; les tâches échouées ne sont jamais facturées.

Consulter la documentation complète du KIT →

Lancer gratuitement