Facteurs premiers avec multiplicité
Compte chaque facteur premier de n, répétitions comprises : 12 vaut 2 × 2 × 3, donc Ω(12) vaut 3, tandis que ses premiers distincts ω(12) ne sont que 2. Les puissances de premiers s'affichent aussi, pour vérifier que les exposants s'additionnent bien. 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
- Grand oméga
- 3
- Grand oméga
- 3
- Petit oméga
- 2
Le grand oméga Ω(n) compte chaque facteur premier d'un entier positif n avec multiplicité : si douze se factorise en deux au carré fois trois, alors Ω(12) vaut trois car les premiers sont deux, deux et trois. Ce calculateur renvoie ce total après une factorisation déterministe par division d'essai, ainsi que les puissances premières ordonnées et le petit oméga ω(n) pour comparaison. Étudiants, programmeurs de concours et auteurs de pipelines utilisent Ω(n) lorsqu'ils ont besoin de la longueur du multiensemble de facteurs premiers, et non de la liste des diviseurs ni d'une page uniquement de factorisation.
Grand oméga versus petit oméga et factorisation
La théorie des nombres distingue deux décomptes étroitement liés. Le petit oméga ω(n) est le nombre de facteurs premiers distincts : la taille du support de la factorisation en premiers. Le grand oméga Ω(n) est le total des facteurs premiers comptés avec multiplicité : la somme des exposants dans cette même factorisation.
Pour un produit sans carré de k premiers distincts, les deux fonctions coïncident et valent k. Pour une puissance de premier p élevée à e, le petit oméga vaut un tandis que le grand oméga vaut e. Pour un, les deux valent zéro par les conventions de produit vide et de somme vide.
Ceux qui cherchent la taille du multiensemble saisissent souvent des expressions comme nombre de facteurs premiers avec multiplicité ou grand oméga de n ; cette intention diffère d'une table de factorisation complète ou du seul décompte de premiers distincts. Cette capacité est conçue pour cette question de longueur de multiensemble. Elle renvoie tout de même la factorisation pour que vous puissiez vérifier que la somme des exposants égale le Ω(n) annoncé, et le petit oméga pour des comparaisons côte à côte sans second outil.
L'algorithme est le classique des cours élémentaires de théorie des nombres : factoriser par division d'essai, puis additionner les exposants.
Où les décomptes avec multiplicité apparaissent dans le travail réel
Les problèmes de concours demandent souvent le total des facteurs premiers au sens multiensemble lorsqu'on analyse la fonction oméga des premiers, des recherches de nombres hautement composés ou les propriétés additives de Ω sous la multiplication d'arguments premiers entre eux. Les enseignants assignent des exercices qui contrastent Ω et ω sur la même liste d'entiers et ont besoin d'un oracle déterministe qui montre les puissances premières intermédiaires.
Les devoirs de cryptographie et de théorie des codes utilisent parfois la somme totale des exposants comme mesure de complexité pour des factorisations dans des modules jouets. Comme le moteur est du code parse pur, sans dérive de modèle, sans dépendance réseau et sans état stocké, le même n produit toujours la même réponse. Utilisez l'outil gratuit du navigateur pour des contrôles rapides, puis appelez le contrat identique depuis des scripts pour une vérification en masse.
Si vous avez ensuite besoin de la liste complète des diviseurs, du nombre de diviseurs τ(n) ou d'une page uniquement de factorisation avec un autre cadrage SEO, traitez-les comme des intentions de recherche distinctes plutôt que de surcharger cette page centrée sur la multiplicité.
Cas d’usage
Contrôles de devoirs et olympiades
Vérifiez Ω(n) pour des feuilles qui demandent le nombre de facteurs premiers comptés avec multiplicité, avec les puissances premières affichées pour inspecter la somme des exposants.
Contraste avec le petit oméga
Renvoie grand oméga et petit oméga sur la même factorisation afin que étudiants et pipelines comparent longueur du multiensemble et premiers distincts sans second appel.
Questions fréquentes
Qu'est-ce que le grand oméga Ω(n) ?
Ω(n) est le nombre de facteurs premiers de n comptés avec multiplicité. Si n = p1^e1 × … × pk^ek, alors Ω(n) = e1 + … + ek. Par exemple Ω(12) = Ω(2²×3) = 3.
En quoi Ω(n) diffère-t-il du petit oméga ω(n) ?
Le petit oméga ω(n) compte les premiers distincts (k dans la factorisation ci-dessus). Le grand oméga somme les exposants. Pour n sans carré ils coïncident ; pour les puissances de premier ils divergent.
Pourquoi Ω(1) est-il égal à 0 ?
Par convention la factorisation en premiers vide a une somme vide d'exposants, donc Ω(1) et ω(1) valent zéro.
Quel est le coût ?
L'outil navigateur est gratuit et s'exécute en local.
Que vaut Ω(n) pour une puissance d'un premier ?
Pour un premier p élevé à la puissance e, Ω vaut e, car le même premier est compté e fois, alors que ω vaut 1. Un premier seul donne donc 1 pour les deux comptes.
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/prime-factor-multiplicity \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"n":12}'const res = await fetch("https://api.kit.forhosting.com/numth/prime-factor-multiplicity", {
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/prime-factor-multiplicity",
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/prime-factor-multiplicity", 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/prime-factor-multiplicity", 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.prime_factor_multiplicity",
"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.
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
Vous envoyez un entier positif ; les valeurs invalides inférieures à un échouent aussitôt avec invalid_input et ne sont pas facturées.
Ce que vous envoyez et ce que la réponse contient
Fournissez un entier positif n. Les alias number et value sont acceptés pour les widgets de formulaire et les SDK qui préfèrent un nom de champ plus convivial. Les valeurs inférieures à un, non entières, champs vides et nombres supérieurs au maximum d'entiers sûrs de JavaScript sont rejetés avec invalid_input et ne consomment pas le solde prépayé. En cas de succès le JSON inclut n normalisé, big_omega (et l'alias omega_big de même valeur), little_omega comme décompte de premiers distincts, factorization comme tableau croissant d'objets premier et exposant, et une courte chaîne formula documentant l'identité utilisée. Vérifications résolues : douze donne big_omega trois et little_omega deux car deux au carré fois trois apporte trois facteurs premiers avec multiplicité et deux premiers distincts ; un premier p donne un et un ; une puissance p à la k donne k et un ; n égal à un donne zéro et zéro avec factorisation vide. Le tarif des items API réussis est la base publiée de $0.002.
Où les décomptes avec multiplicité apparaissent dans le travail réel
Les pipelines de données et de CI préfèrent un contrat JSON stable à une colonne de tableur recalculée à la main.
Cas d'intégration
Fixtures déterministes de pipeline
Appelez le même contrat pur depuis scripts et CI pour que les valeurs golden de Ω(n) ne dépendent jamais d'un formulaire web occasionnel ni d'un tableur flottant.
Questions techniques
Quelles valeurs de n sont acceptées ?
Entiers de 1 à 9007199254740991 (Number.MAX_SAFE_INTEGER). Zéro, négatifs, décimaux et chaînes non numériques échouent avec invalid_input et ne sont pas facturés.