Teorema di Lucas
Ottenga C(n, k) modulo un primo senza fattoriali enormi: C(1000, 200) modulo 7 vale 1, scrivendo entrambi i numeri in base 7 e moltiplicando piccoli binomiali delle cifre. Le cifre vengono mostrate perché possa controllare ogni passaggio. Gratis nel suo browser.
- Gratis
- Funziona nel suo browser
- Senza registrazione
- I suoi dati restano sul dispositivo
Esegui gratis nel browser
Esempio risolto
- N
- 1000
- K
- 200
- Potenza (W)
- 7
- Risultato
- 1
- Cifre di n
- 6, 2, 6, 2
- Cifre di k
- 4, 0, 4, 0
Il teorema di Lucas è il metodo classico per valutare un coefficiente binomiale modulo un numero primo quando n è abbastanza grande da rendere impraticabile il fattoriale di n. Il prodotto è esattamente C(n, k) mod p; se una cifra inferiore supera quella superiore corrispondente, l’intero valore è zero. La programmazione di gara, la teoria dei numeri combinatoria e i compiti di crittografia richiedono questa riduzione quando i fattoriali diretti traboccano o costano troppo.
Cosa afferma il teorema di Lucas e quando ne ha bisogno
Nella combinatoria elementare il coefficiente binomiale C(n, k) conta i sottoinsiemi di k elementi di un insieme di n elementi e vale il fattoriale di n diviso il fattoriale di k per il fattoriale di (n meno k). Quella forma chiusa diventa inutile non appena n supera alcune migliaia se serve solo la risposta modulo un piccolo primo: i fattoriali intermedi esplodono e le approssimazioni in virgola mobile perdono il residuo esatto. Il teorema di Lucas, intitolato a Édouard Lucas, risolve proprio questo problema modulare.
Ogni fattore usa argomenti minori di p, quindi si calcola con un breve ciclo moltiplicativo e inversi modulari che esistono perché p è primo e ogni denominatore è minore di p. Solo quel test risponde a molte domande del tipo «il binomiale è divisibile per questo primo?» senza calcolare un prodotto completo.
Il teorema richiede che p sia primo; per moduli composti lo stesso prodotto di cifre non è in generale valido, e questa capacità rifiuta deliberatamente un p non primo invece di restituire in silenzio un residuo errato. Studenti che incontrano il teorema nel materiale olimpico, sviluppatori che collegano librerie di programmazione competitiva e docenti che preparano laboratori di aritmetica modulare traggono vantaggio da un’unica funzione deterministica che impone l’ipotesi di primalità ed espone gli sviluppi di cifre usati nella dimostrazione.
Come questa calcolatrice applica il teorema di Lucas passo per passo
Invocchi la capacità con i campi interi n, k e p. Sia n sia k devono essere interi non negativi al massimo di un bilione; p deve essere un primo tra due e un milione e tre inclusi. L’implementazione valida prima tipi e limiti, poi esegue un test di primalità per divisione di prova deterministico su p.
Quando p è accettato, il risolutore percorre le cifre in base p di n e k dal meno significativo al più significativo. Ogni piccolo binomiale usa la formula moltiplicativa con inversi modulari tramite il piccolo teorema di Fermat (a elevato a p meno due modulo p), implementata con prodotti intermedi esatti in BigInt così da non perdere precisione entro i limiti pubblicati.
I casi limite sono stabili e documentati: quando k è zero o uguale a n il risultato è uno modulo p (o zero solo se p vale uno, che viene rifiutato); quando k supera n il risultato è zero; quando n e k sono entrambi zero gli array di cifre sono la sola cifra zero e il risultato è uno modulo p.
Casi d'uso
Programmazione di gara e pratica olimpica
I programmatori competitivi possono verificare C(n, k) mod p per n grandi rispetto a casi di esempio e vedere un errore esplicito quando un modulo risulta composto per sbaglio.
Laboratori di teoria dei numeri e combinatoria
Docenti e studenti possono ispezionare le cifre in base p accanto al prodotto modulare mentre apprendono il teorema di Lucas e il test di zero per divisibilità da un primo.
Domande frequenti
Cosa succede se p non è primo?
Il messaggio indica che p deve essere un primo (ad esempio quando p è composto o uguale a 1). La validazione fallita non viene addebitata.
Quale algoritmo calcola il binomiale modulare?
I piccoli binomiali di cifra usano la formula moltiplicativa con inversi modulari.
La calcolatrice del teorema di Lucas è gratuita?
Lo strumento del browser viene eseguito gratis sul Suo dispositivo.
Quali intervalli di n, k e p sono accettati?
n e k devono essere interi non negativi al massimo 1,000,000,000,000. p deve essere un primo da 2 a 1,000,003. I valori fuori da tali limiti, o un p composto, vengono rifiutati.
Come capisco se C(n, k) è divisibile per un primo?
Scriva n e k in base p e li confronti cifra per cifra. Se una cifra di k supera la cifra corrispondente di n, il risultato è 0: significa che p divide il coefficiente binomiale.
Strumenti correlati
Per sviluppatori — accesso via API
Tutto quello che vedi in questa pagina è disponibile anche via API. Questa sezione è per i team che vogliono integrarlo nei propri sistemi; chi non ne ha bisogno può semplicemente usare lo strumento qui sopra.
Endpoint
Autenticazione con Bearer token: un POST mette in coda l'attività e il risultato arriva via webhook o link firmato.
Chiamala dal tuo stack
curl -X POST https://api.kit.forhosting.com/numth/lucas-theorem-binomial \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"n":1000,"k":200,"p":7}'const res = await fetch("https://api.kit.forhosting.com/numth/lucas-theorem-binomial", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"n": 1000,
"k": 200,
"p": 7
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/numth/lucas-theorem-binomial",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"n": 1000,
"k": 200,
"p": 7
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/numth/lucas-theorem-binomial", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"n":1000,"k":200,"p":7}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"n":1000,"k":200,"p":7}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/numth/lucas-theorem-binomial", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Esempio di richiesta
{
"n": 1000,
"k": 200,
"p": 7
}Esempio di risposta
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "numth.lucas_theorem_binomial",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}L'API è asincrona: ricevi subito un task_id e puoi fare polling fino a 1 richiesta al secondo.
Prezzi
Prezzo pubblicato, senza token né crediti. Se l'attività fallisce, non paghi.
Errori
| HTTP | Codice | Significato |
|---|---|---|
401 | unauthorized | Chiave API mancante o non valida: controlla l'header Authorization. |
402 | insufficient_balance | Credito esaurito: ricarica per continuare a eseguire attività. |
404 | unknown_type | Tipo di attività sconosciuto: controlla il campo type della richiesta. |
429 | rate_limited | Troppe richieste in poco tempo: rallenta e riprova tra qualche secondo. |
Note tecniche
Dati interi non negativi n e k e un modulo primo p, il teorema sviluppa n e k in base p e moltiplica i binomiali di cifre C(n_i, k_i) modulo p. Questa calcolatrice accetta n, k e p, rifiuta moduli composti con un errore invalid_input chiaro, esegue un cammino di Lucas deterministico e restituisce il risultato modulare insieme alle cifre in base p così che Lei possa verificare ogni passo senza ricalcolare a mano lo sviluppo.
Cosa afferma il teorema di Lucas e quando ne ha bisogno
Scriva n e k in base p come sequenze di cifre n_i e k_i, ciascuna strettamente minore di p. Allora C(n, k) è congruente modulo p al prodotto su i di C(n_i, k_i). Un corollario cruciale è il test di zero: se in una posizione la cifra inferiore k_i è maggiore di n_i, quel binomiale di cifra è zero e quindi C(n, k) è divisibile per p.
Come questa calcolatrice applica il teorema di Lucas passo per passo
Valori composti, uno, zero e negativi falliscono con invalid_input e un messaggio che nomina p; tali fallimenti non vengono addebitati. Per ogni coppia (n_i, k_i) o interrompe a zero se k_i supera n_i, oppure moltiplica il prodotto corrente per C(n_i, k_i) mod p. La risposta restituisce n, k, p, result (il residuo da zero a p meno uno), is_zero, gli array n_digits e k_digits in ordine dalla cifra meno significativa, e method impostato alla stringa lucas.
Uso pratico, limiti, prezzo e consegna
Usi lo strumento del browser quando desidera un controllo rapido di Lucas leggendo una nota di teoria dei numeri, verificando un esempio di gara o debuggando una routine di combinatoria modulare. Gli input accettati sono interi non negativi n e k fino a un bilione e primi p da due a un milione e tre. Se Le serve il C(n, k) intero senza restrizioni, una riga binomiale per ogni k, o binomiali modulari per moduli composti tramite il teorema cinese del resto, usi una capacità dedicata; questo strumento si ferma deliberatamente a Lucas per un primo p verificato, così il contratto resta semplice e verificabile. Usi l’API quando un correttore, una piattaforma didattica o uno script necessita di molte valutazioni di C(n, k) mod p senza incorporare un filtro di primalità e una camminata sulle cifre. Ogni richiesta riuscita è un elemento fatturabile a $0.002; i fallimenti di validazione e i moduli non primi non consumano saldo. I risultati sono deterministici: lo stesso triplo produce sempre lo stesso residuo, gli stessi array di cifre e lo stesso flag is_zero. Colleghi l’endpoint ad aiuti olimpici, sandbox di programmazione competitiva, demo didattiche di crittografia che toccano coefficienti binomiali modulo piccoli primi, o qualsiasi pipeline di interi che preferisca aritmetica modulare esatta a librerie approssimate. Poiché l’unità è un singolo elemento e il motore è parse puro, la latenza resta bassa e il canale web gratuito rispecchia l’API a pagamento senza un secondo percorso di codice che possa divergere.
Casi di integrazione
Correttori di compiti e pipeline modulari
I correttori automatici e gli script possono confermare i residui, rilevare un p non primo tramite invalid_input e mantenere ogni prodotto intermedio entro i limiti documentati.
Domande tecniche
Come si calcola C(n,k) mod p con questa API?
Invii JSON con i campi interi n, k e p (p primo) a numth.lucas_theorem_binomial. In caso di successo la risposta restituisce result in 0..p−1, is_zero, array di cifre in base p e method "lucas".