Calcolatore di frazioni egizie
Il calcolatore di frazioni egizie prende un numeratore e un denominatore e riscrive la frazione come facevano gli scribi dell'antico Egitto: una somma di frazioni unitarie distinte, come 1/2 + 1/4.
Esegui gratis nel browser
Usa l'algoritmo goloso di Fibonacci–Sylvester, che termina sempre e garantisce denominatori diversi. Invii due interi positivi e ricevi lo sviluppo, il numero di termini e la parte intera quando la frazione è impropria. Lo stesso codice viene eseguito gratuitamente nel Suo browser su questa pagina e costa $0.002 per richiesta quando chiama l'API.
Che cos'è una frazione egizia e perché è ancora importante
La matematica dell'antico Egitto evitava quasi del tutto le frazioni generali. Invece di scrivere 3/4, uno scriba annotava 1/2 + 1/4: una somma di frazioni unitarie, tutte con numeratore uno e denominatori distinti. Il papiro Rhind si apre con una lunga tavola che fa esattamente questo per le frazioni della forma 2/n, perché le tavole di sviluppi in frazioni unitarie erano lo strumento di calcolo quotidiano dell'epoca. Oggi l'idea è molto più di una curiosità: gli sviluppi in frazioni unitarie compaiono nella teoria dei numeri, nei problemi di divisione equa, nell'insegnamento dell'equivalenza delle frazioni e nella matematica ricreativa. Il calcolatore di frazioni egizie riproduce questa scomposizione all'istante per qualsiasi razionale positivo che Lei fornisce. Lei indica un numeratore e un denominatore, entrambi interi positivi, e il servizio restituisce l'elenco dei denominatori distinti, lo sviluppo scritto come somma, il conteggio dei termini e una parte intera separata quando la frazione è maggiore di uno. La frazione viene prima ridotta ai minimi termini affinché lo sviluppo sia canonico: 2/4 e 3/6 si sviluppano come 1/2, il che mantiene i risultati stabili e confrontabili indipendentemente da come è stato scritto l'input.
Come l'algoritmo goloso costruisce lo sviluppo
Il motore usa il metodo goloso spesso attribuito a Fibonacci e studiato da Sylvester. A ogni passo prende la più grande frazione unitaria che non supera ciò che resta: se il resto è n/d, il termine successivo è 1/ceil(d/n). Sottraendo quel termine resta n*ceil(d/n) − d su d*ceil(d/n), e il nuovo numeratore è strettamente più piccolo del precedente, quindi il processo termina sempre in al massimo n passi. Un effetto piacevole è che ogni denominatore scelto è più grande del precedente, così la distinzione è garantita per costruzione invece di essere verificata dopo. L'implementazione lavora su interi a precisione arbitraria, quindi i valori fino a mille miliardi sono gestiti esattamente, senza alcun arrotondamento in virgola mobile nel calcolo. Esiste un limite dichiarato al numero di termini, e gli input che lo supererebbero vengono rifiutati con un errore chiaro invece di essere eseguiti senza limiti. Poiché lo sviluppo è deterministico, lo stesso input restituisce sempre un output identico byte per byte, il che rende il servizio sicuro da memorizzare nella cache e da integrare in pipeline che confrontano i risultati.
Leggere l'output e gestire i casi limite
La risposta Le fornisce lo sviluppo ridotto insieme agli input originali, così un client può registrare esattamente ciò che è stato scomposto. Il campo unit_fractions contiene i denominatori in ordine crescente, expansion li presenta come una somma leggibile, ad esempio 1/2 + 1/11 + 1/111 + 1/1221, e count è semplicemente il numero di termini. Quando la frazione è impropria, la parte intera viene restituita separatamente in whole e le frazioni unitarie sviluppano solo il resto frazionario, perché la notazione egizia classica teneva i numeri interi fuori dalla somma. La validazione è volutamente rigorosa: il denominatore zero viene rifiutato, i valori non interi come 2.5 o 1/2 scritto come testo vengono rifiutati, e gli input negativi vengono rifiutati, ciascuno con un messaggio che nomina il campo responsabile. Chiamare l'API costa $0.002 per richiesta, e lo stesso algoritmo viene eseguito gratuitamente nel widget del browser su questa pagina, quindi può esplorare in modo interattivo e pagare solo quando automatizza. Tutto viene calcolato su richiesta e nulla di ciò che invia viene conservato dopo la produzione della risposta.
Casi d'uso
Insegnare l'equivalenza delle frazioni
Mostri agli studenti che un numero razionale ha molte forme sviluppando 5/6 come 1/2 + 1/3 e confrontandolo con altre rappresentazioni.
Riprodurre la matematica storica
Verifichi scomposizioni di 2/n nello stile del papiro Rhind rispetto a una base golosa deterministica senza costruire le tavole a mano.
Generare materiale per esercizi e rompicapi
Produca somme di frazioni unitarie in modo programmatico per gare, schede di esercizi o contenuti di giochi, con un output stabile che può confrontare.
Domande frequenti
Quanto costa?
$0.002 per richiesta tramite l'API. Lo stesso algoritmo viene eseguito gratuitamente anche nel Suo browser su questa pagina.
Quali input sono accettati?
Due interi positivi: un numeratore e un denominatore. Denominatori zero, negativi, decimali e valori non numerici vengono rifiutati con un errore chiaro.
Lo sviluppo termina sempre?
Sì. L'algoritmo goloso riduce strettamente il numeratore rimanente a ogni passo, quindi termina sempre, e ogni denominatore emesso è distinto.
Cosa succede con le frazioni maggiori di uno?
La parte intera viene restituita separatamente nel campo whole e le frazioni unitarie sviluppano solo il resto frazionario, secondo la notazione egizia classica.
La frazione viene semplificata prima?
Sì. L'input viene ridotto ai minimi termini prima dello sviluppo, così le frazioni equivalenti producono sempre lo stesso sviluppo.
Viene memorizzato qualcosa?
No. Il calcolo avviene in memoria e viene restituito solo lo sviluppo; i Suoi input vengono eliminati.
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/math/egyptian-fraction \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"numerator":5,"denominator":6}'const res = await fetch("https://api.kit.forhosting.com/math/egyptian-fraction", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"numerator": 5,
"denominator": 6
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/math/egyptian-fraction",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"numerator": 5,
"denominator": 6
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/math/egyptian-fraction", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"numerator":5,"denominator":6}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"numerator":5,"denominator":6}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/math/egyptian-fraction", 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
{
"numerator": 5,
"denominator": 6
}Esempio di risposta
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "math.egyptian_fraction",
"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.
Limiti
max_value | 1000000000000 |
max_terms | 1000 |
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. |