Somme des diviseurs unitaires
Les diviseurs unitaires de 12 sont 1, 3, 4 et 12, dont la somme vaut 20, alors que tous ses diviseurs totalisent 28. Saisissez un entier positif pour obtenir cette somme et les puissances de nombres premiers qui l'expliquent. Gratuit dans votre navigateur.
- Gratuit
- Fonctionne dans votre navigateur
- Sans inscription
- Vos données restent sur votre appareil
Lancer gratuitement
Exemple résolu
- N
- 12
- Somme des diviseurs unitaires
- 20
La somme des diviseurs unitaires, notée sigma étoile de n, additionne les diviseurs positifs d pour lesquels d et n divisé par d ne partagent aucun facteur premier. Elle est liée à la fonction usuelle de somme des diviseurs, mais répond à une question différente de théorie des nombres et donne généralement un autre résultat. Saisissez un entier positif pour obtenir sa somme de diviseurs unitaires et la factorisation en puissances premières qui justifie le calcul. L’algorithme est déterministe, fonctionne sans réseau et traite un comme le cas de base du produit vide.
Ce qui rend un diviseur unitaire
Un diviseur positif d de n est unitaire lorsque d est premier avec son diviseur complémentaire n divisé par d. Concrètement, chaque puissance première complète de n doit être attribuée entièrement à l’un des deux côtés de cette paire. Prenez 12, dont la factorisation en puissances premières est 2 au carré multiplié par 3.
Ses diviseurs unitaires sont 1, 3, 4 et 12 : chacun choisit soit tout le facteur 4, soit aucun, et indépendamment tout le facteur 3 ou aucun. Les diviseurs 2 et 6 sont ordinaires, mais non unitaires, car chacun partage un facteur 2 avec son complément. La somme ordinaire des diviseurs de 12 vaut donc 28, tandis que sa somme de diviseurs unitaires vaut 20.
Ce calculateur fournit cette dernière quantité, couramment notée sigma étoile de n. Cette distinction intervient en théorie multiplicative des nombres, dans l’étude des nombres parfaits unitaires et dans toute formule exigeant des facteurs complémentaires premiers entre eux plutôt qu’une simple division exacte.
Méthode de calcul de sigma étoile
Écrivez la factorisation première de n comme un produit de puissances premières complètes p élevé à a. Pour chaque puissance première, il existe exactement deux choix unitaires : inclure la valeur entière p élevé à a, ou inclure 1. Le développement de tous ces choix indépendants produit chaque diviseur unitaire une seule fois ; leur somme est donc le produit des facteurs 1 plus p élevé à a.
L’implémentation valide d’abord n, effectue ensuite une division d’essai déterministe, enregistre chaque nombre premier, exposant et puissance complète, puis multiplie ces facteurs courts. Pour 72, la factorisation est 2 au cube multiplié par 3 au carré : sigma étoile vaut (1 + 8)(1 + 9), soit 90. Pour un nombre premier q, les seuls diviseurs unitaires sont 1 et q, ce qui donne q + 1.
Lorsque n vaut 1, la liste des facteurs est vide et le produit vaut 1.
Utiliser le résultat en toute sécurité
Envoyez n sous forme de nombre entier positif inférieur ou égal à mille milliards. Les nombres JavaScript restent exacts pour les résultats pris en charge dans l’intervalle déclaré, mais la limite protège aussi le temps d’exécution, car la division d’essai peut examiner des candidats jusqu’à la racine carrée de n. Pour des entiers bien plus grands ou cryptographiques, utilisez un système spécialisé de factorisation en précision arbitraire.
Cette capacité privilégie volontairement un calcul transparent et borné, et non un service de factorisation illimité.
Cas d’usage
Étudier les nombres parfaits unitaires
Calculez sigma étoile pour des entiers candidats avant de comparer le résultat au double du nombre initial.
Vérifier des exercices de théorie des nombres
Contrôlez un produit de puissances premières obtenu à la main et distinguez clairement les diviseurs unitaires des diviseurs ordinaires.
Créer des données de suites déterministes
Générez des termes sigma étoile reproductibles pour des tables bornées, des tests automatisés ou des carnets exploratoires.
Questions fréquentes
Qu’est-ce qu’un diviseur unitaire ?
Un diviseur d de n est unitaire lorsque d et n divisé par d sont premiers entre eux ; aucun facteur premier n’est alors partagé par les diviseurs complémentaires.
Quelle différence avec la somme ordinaire des diviseurs ?
La somme ordinaire inclut tous les diviseurs positifs. Sigma étoile ne retient que les diviseurs unitaires, qui contiennent une puissance première complète de n ou aucune partie de celle-ci.
Quelle formule le calculateur utilise-t-il ?
Si n est le produit de puissances premières p^a, la somme des diviseurs unitaires est le produit des (1 + p^a) associés à ces puissances premières distinctes.
Que renvoie le calculateur pour un ?
Il renvoie 1. La factorisation est vide et le produit vide employé pour sigma étoile de 1 vaut 1.
Quelle est la somme des diviseurs unitaires de 72 ?
Elle vaut 90. Comme 72 s'écrit 2³ × 3², ses puissances premières entières sont 8 et 9, et la somme est le produit (1 + 8) × (1 + 9), soit 90.
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
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/unitary-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/unitary-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/unitary-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/unitary-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/unitary-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.unitary_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
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
Méthode de calcul de sigma étoile
Aucun dénombrement des diviseurs, aucune recherche aléatoire, approximation flottante, requête réseau ou opération dépendant de l’horloge n’intervient ; deux appels avec la même entrée acceptée renvoient le même résultat JSON.
Utiliser le résultat en toute sécurité
La réponse renvoie n, unitary_divisor_sum et factors par ordre croissant des nombres premiers ; chaque facteur contient les champs prime, exponent et power. Ces précisions permettent de vérifier que chaque multiplicateur du produit prend la forme 1 plus power, ce qui convient aux supports pédagogiques, aux jeux de tests, aux notes de recherche et aux expériences reproductibles. Une entrée inférieure à un, une valeur absente, une fraction, un texte non numérique ou une valeur dépassant la limite publiée produit une erreur invalid_input au lieu d’une réponse trompeuse. Une requête API réussie coûte $0.002, tandis que la version pour navigateur emploie localement la même arithmétique pure.
Questions techniques
Quelles entrées provoquent une erreur ?
Une valeur absente, inférieure à 1, fractionnaire, un texte non numérique ou un entier supérieur à 1,000,000,000,000 renvoie invalid_input.
Combien coûte une requête API ?
Une requête API réussie coûte $0.002. Le calculateur du navigateur exécute localement le même noyau déterministe.