ForHosting KIT · Mathematik

Teilersummen-Rechner

Die Teiler von 12 ergeben zusammen 28: 1 + 2 + 3 + 4 + 6 + 12. Geben Sie eine positive ganze Zahl bis eine Billion ein und erhalten Sie diese exakte Summe samt den verwendeten Primfaktoren. Kostenlos in Ihrem Browser.

Kostenlos
Läuft in Ihrem Browser
Ohne Anmeldung
Ihre Daten bleiben auf Ihrem Gerät

Im Browser ausführen – kostenlos API ansehen

Nutzen Sie es über WebAPIE-MailTelegramApp bald

Rechenbeispiel

Wenn Sie eingeben

N: 12

Erhalten Sie

Sigma (σ): 28

Die Teilerfunktion sigma(n) addiert jeden positiven Teiler einer positiven ganzen Zahl n, einschließlich 1 und n selbst. Perfekte Zahlen, abundante Zahlen, Aliquotfolgen und viele zahlentheoretische Prüfungen hängen von dieser Summe ab. Diese Fähigkeit faktorisiert n per Probedivision, wendet die multiplikative Formel der Teilersummenfunktion an und liefert sowohl sigma(n) als auch die genutzte Primfaktorzerlegung—deterministisch, offline und kostenlos im Browser auszuprobieren.

Was sigma(n) bedeutet und warum die Zerlegung genügt

Für eine positive ganze Zahl n ist sigma(n) die Summe aller positiven ganzen Zahlen, die n genau teilen. Die positiven Teiler von 12 sind beispielsweise 1, 2, 3, 4, 6 und 12, daher ist sigma(12) gleich 28. Jeden Teiler durch Scannen bis n aufzulisten funktioniert bei winzigen Werten, wird aber mit wachsendem n verschwenderisch.

Die Zahlentheorie liefert eine geschlossene multiplikative Form: ist die Primfaktorzerlegung von n p1^a1 mal p2^a2 mal … mal pk^ak, dann ist sigma(n) das Produkt über i von (1 + pi + pi^2 + … + pi^ai), was auch (pi^(ai+1) − 1) / (pi − 1) ist. Diese Identität ist für jedes n größer oder gleich 1 exakt; insbesondere ist sigma(1) gleich 1 mit leerem Produkt.

Dieser Rechner zieht nie zufällige Kandidaten und approximiert nicht: er faktorisiert n einmal, multipliziert die geometrische Reihe jeder Primzahlpotenz und liefert die ganzzahlige Summe zusammen mit den gefundenen Faktoren, damit Sie die Schritte prüfen können.

Perfekte, defiziente und abundante Zahlen in der Praxis

Der Vergleich von sigma(n) mit 2n klassifiziert n: ist sigma(n) gleich 2n, ist die Zahl perfekt (ihre echten Teiler summieren zu ihr selbst); ist sigma(n) kleiner als 2n, defizient; ist sie größer, abundant. Sechs ist die kleinste perfekte Zahl, weil sigma(6) 12 ist. Achtundzwanzig ist das nächste klassische perfekte Beispiel.

Abundante Zahlen wie 12 (sigma 28) und 18 (sigma 39) tauchen in der Aliquotfolgen-Forschung und der Freizeit-Zahlentheorie auf. Weil dieser Endpunkt Summe und Zerlegung liefert, können Sie auch die Teileranzahl als Produkt von (Exponent + 1) je Primzahlpotenz ableiten oder die volle Teilerliste offline aus den Faktoren aufbauen, wenn Sie sie zum Lehren oder Debuggen brauchen. Halten Sie n im veröffentlichten Limit, damit Probedivision interaktiv bleibt; für kryptografisch große Ganzzahlen brauchen Sie einen eigenen Multipräzisions-Faktorisierungsstapel, nicht diese leichte Parse-Fähigkeit.

Anwendungsfälle

Perfekte, defiziente und abundante Zahlen klassifizieren

Berechnen Sie sigma(n) und vergleichen Sie es mit 2n, um jede ganze Zahl in einer Hausaufgabenmenge oder Forschungstabelle zu etikettieren, ohne Teiler von Hand aufzulisten.

Faktorisierungsbasierte Hausaufgaben und Wettbewerbe prüfen

Studierende und Wettbewerber können prüfen, dass ihre Primfaktorzerlegung die korrekte Teilersumme liefert, bevor sie Beweise oder Programmierlösungen einreichen.

Häufige Fragen

Was ist die Summe der Teiler von n?

Es ist sigma(n): die Summe jedes positiven Teilers von n, einschließlich 1 und n. Für 12 sind die Teiler 1, 2, 3, 4, 6 und 12, also ist die Summe 28.

Wie berechnet dieser Rechner sigma(n)?

Er faktorisiert n per Probedivision und multipliziert die geometrische Reihe (1 + p + … + p^a) für jede Primzahlpotenz p^a der Zerlegung—die standardmäßige multiplikative Formel.

Enthält die Antwort die Primfaktoren?

Ja. Neben sigma erhalten Sie factors als Primzahl/Exponent-Paare, um die Produktformel zu prüfen oder mit verwandten Teileranzahlen fortzufahren.

Wie groß ist die Teilersumme von 12?

Sie ist 28. Die Teiler von 12 sind 1, 2, 3, 4, 6 und 12, und zusammen ergeben sie 28, also mehr als das Doppelte von 12.

Wie erkenne ich an der Teilersumme eine vollkommene Zahl?

Vergleichen Sie die Summe mit dem Doppelten der Zahl. Sind beide gleich, ist die Zahl vollkommen, wie 6 mit der Teilersumme 12. Ist die Summe kleiner, ist sie defizient, ist sie größer, wie bei 12 mit 28, abundant.

Für Entwickler — API-Zugang

Alles auf dieser Seite ist auch per API verfügbar. Dieser Abschnitt richtet sich an Teams, die es in ihre eigenen Systeme einbinden möchten; alle anderen nutzen einfach das Tool oben.

Endpunkt

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

Authentifizierung per Bearer-Token. Ein einziger POST stellt die Aufgabe in die Warteschlange; das Ergebnis erhalten Sie per Webhook oder über einen signierten Link.

Aufruf aus Ihrem 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)

Beispiel-Anfrage

{
  "n": 12
}

Beispiel-Antwort

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

Die API arbeitet asynchron: Sie erhalten sofort eine task_id. Polling ist mit 1 Anfrage pro Sekunde erlaubt.

Preis

pro Anfrage$0.002

Der Preis steht auf der Seite – keine Tokens, keine Credits. Fehlgeschlagene Aufgaben werden nicht berechnet.

Limits

max_n 1000000000000

Fehler

HTTP	Code	Bedeutung
`401`	`unauthorized`	Der API-Schlüssel fehlt oder ist ungültig – prüfen Sie den Authorization-Header (Bearer).
`402`	`insufficient_balance`	Ihr Guthaben reicht für diese Aufgabe nicht aus – Aufladungen verfallen nicht.
`404`	`unknown_type`	Unbekannter Aufgabentyp – prüfen Sie das Feld „type“ gegen den Katalog.
`429`	`rate_limited`	Zu viele Anfragen – warten Sie kurz; Polling ist mit 1 Anfrage pro Sekunde erlaubt.

Technische Hinweise

So rufen Sie die API auf und was zurückkommt

Bei Erfolg enthält die Antwort n wie akzeptiert, sigma als volle Teilersumme und factors als geordnete Liste von Objekten mit prime und exponent. Nutzen Sie es aus Skripten, Hausaufgaben-Pipelines, CTF-Write-ups oder jedem Workflow, der ein reproduzierbares sigma(n) braucht, ohne ein Computeralgebrasystem zu installieren. Senden Sie einen JSON-Körper mit einem einzigen Pflichtfeld n—eine positive ganze Zahl mindestens 1 und höchstens eine Billion (10^12). Aliasse number und value werden für dasselbe Feld akzeptiert. Fehlgeschlagene Validierung—fehlendes n, Nicht-Ganzzahl, Wert unter 1 oder über dem Limit—liefert invalid_input und wird nie berechnet. Der Preis ist pauschal $0.002 pro erfolgreicher Anfrage (Einheitsposition mit marginalem Einheitspreis null).

Integrationsbeispiele

Aliquot- oder befreundete-Zahlen-Pipelines bauen

Skripte, die Aliquotfolgen ablaufen, brauchen einen zuverlässigen Sigma-Schritt; rufen Sie diese API (oder den kostenlosen Browser-Kern) als deterministischen Baustein auf.

Technische Fragen

Welche Eingaben werden abgelehnt?

Fehlendes n, Nicht-Ganzzahlen, Werte unter 1 und Werte über 10^12 liefern invalid_input. Diese Fehlschläge werden nicht berechnet.

Ist der Teilersummen-Rechner kostenlos?

Das Browser-Werkzeug ist kostenlos und läuft lokal. API-Aufrufe nutzen vorausbezahltes KIT-Guthaben zu $0.002 pro erfolgreicher Anfrage; fehlgeschlagene Aufgaben werden nie berechnet.

Vollständige KIT-Dokumentation lesen →