ForHosting KIT · Outils pour développeurs

Calculatrice de fractions égyptiennes

La calculatrice de fractions égyptiennes prend un numérateur et un dénominateur et réécrit la fraction comme le faisaient les scribes de l'Égypte antique : une somme de fractions unitaires distinctes, comme 1/2 + 1/4.

● BetaGratuit · dans votre navigateur

Lancer gratuitement Voir l’API

Utilisez-le depuis WebAPIE-mailTelegramApp bientôt

Elle utilise l'algorithme glouton de Fibonacci–Sylvester, qui se termine toujours et garantit des dénominateurs différents. Envoyez deux entiers positifs et recevez le développement, le nombre de termes et la partie entière lorsque la fraction est impropre. Le même code s'exécute gratuitement dans votre navigateur sur cette page et coûte $0.002 par requête lorsque vous appelez l'API.

Qu'est-ce qu'une fraction égyptienne et pourquoi est-elle encore utile

Les mathématiques de l'Égypte antique évitaient presque entièrement les fractions générales. Au lieu d'écrire 3/4, un scribe notait 1/2 + 1/4 : une somme de fractions unitaires, toutes de numérateur un et de dénominateurs distincts. Le papyrus Rhind s'ouvre sur une longue table qui fait exactement cela pour les fractions de la forme 2/n, car les tables de développements en fractions unitaires étaient l'outil de calcul quotidien de l'époque. Aujourd'hui, l'idée est bien plus qu'une curiosité : les développements en fractions unitaires apparaissent en théorie des nombres, dans les problèmes de partage équitable, dans l'enseignement de l'équivalence des fractions et dans les mathématiques récréatives. La calculatrice de fractions égyptiennes reproduit cette décomposition instantanément pour tout rationnel positif que vous lui donnez. Vous fournissez un numérateur et un dénominateur, tous deux entiers positifs, et le service renvoie la liste des dénominateurs distincts, le développement écrit sous forme de somme, le nombre de termes et une partie entière séparée lorsque la fraction est supérieure à un. La fraction est d'abord réduite à ses plus petits termes pour que le développement soit canonique : 2/4 et 3/6 se développent en 1/2, ce qui garde les résultats stables et comparables quelle que soit la façon dont l'entrée a été écrite.

Comment l'algorithme glouton construit le développement

Le moteur utilise la méthode gloutonne souvent attribuée à Fibonacci et étudiée par Sylvester. À chaque étape, il prend la plus grande fraction unitaire ne dépassant pas ce qui reste : si le reste est n/d, le terme suivant est 1/ceil(d/n). En soustrayant ce terme, il reste n*ceil(d/n) − d sur d*ceil(d/n), et le nouveau numérateur est strictement plus petit que l'ancien, donc le processus se termine toujours en au plus n étapes. Un effet agréable est que chaque dénominateur choisi est plus grand que le précédent, de sorte que la distinction est garantie par construction plutôt que vérifiée après coup. L'implémentation travaille sur des entiers de précision arbitraire, donc les valeurs jusqu'à un billion sont traitées exactement, sans aucun arrondi en virgule flottante dans le calcul. Il existe un plafond déclaré sur le nombre de termes, et les entrées qui le dépasseraient sont rejetées avec une erreur claire au lieu de s'exécuter sans limite. Comme le développement est déterministe, la même entrée renvoie toujours une sortie identique octet par octet, ce qui rend le service sûr à mettre en cache et à intégrer dans des pipelines qui comparent des résultats.

Lire la sortie et traiter les cas limites

La réponse vous donne le développement réduit ainsi que les entrées d'origine, afin qu'un client puisse consigner exactement ce qui a été décomposé. Le champ unit_fractions contient les dénominateurs dans l'ordre croissant, expansion les présente sous forme de somme lisible, par exemple 1/2 + 1/11 + 1/111 + 1/1221, et count est simplement le nombre de termes. Lorsque la fraction est impropre, la partie entière est renvoyée séparément dans whole et les fractions unitaires développent uniquement le reste fractionnaire, car la notation égyptienne classique gardait les nombres entiers hors de la somme. La validation est volontairement stricte : le dénominateur zéro est rejeté, les valeurs non entières comme 2.5 ou 1/2 écrit en texte sont rejetées, et les entrées négatives sont rejetées, chacune avec un message nommant le champ fautif. Appeler l'API coûte $0.002 par requête, et le même algorithme s'exécute gratuitement dans le widget du navigateur sur cette page, vous pouvez donc explorer interactivement et ne payer que lorsque vous automatisez. Tout est calculé à la demande et rien de ce que vous envoyez n'est conservé après la production de la réponse.

Cas d’usage

Enseigner l'équivalence des fractions

Montrez aux élèves qu'un nombre rationnel a plusieurs visages en développant 5/6 en 1/2 + 1/3 et en comparant avec d'autres représentations.

Reproduire les mathématiques historiques

Vérifiez des décompositions de 2/n dans le style du papyrus Rhind par rapport à une base gloutonne déterministe sans construire les tables à la main.

Générer du matériel d'exercices et d'énigmes

Produisez des sommes de fractions unitaires par programme pour des concours, des fiches d'exercices ou du contenu de jeux, avec une sortie stable que vous pouvez comparer.

Questions fréquentes

Combien cela coûte-t-il ?

$0.002 par requête via l'API. Le même algorithme s'exécute aussi gratuitement dans votre navigateur sur cette page.

Quelles entrées sont acceptées ?

Deux entiers positifs : un numérateur et un dénominateur. Les dénominateurs nuls, les négatifs, les décimaux et les valeurs non numériques sont rejetés avec une erreur claire.

Le développement se termine-t-il toujours ?

Oui. L'algorithme glouton réduit strictement le numérateur restant à chaque étape, donc il se termine toujours, et chaque dénominateur émis est distinct.

Que se passe-t-il avec les fractions supérieures à un ?

La partie entière est renvoyée séparément dans le champ whole et les fractions unitaires développent uniquement le reste fractionnaire, selon la notation égyptienne classique.

La fraction est-elle simplifiée d'abord ?

Oui. L'entrée est réduite à ses plus petits termes avant le développement, de sorte que les fractions équivalentes produisent toujours le même développement.

Quelque chose est-il stocké ?

Non. Le calcul est fait en mémoire et seul le développement est renvoyé ; vos entrées sont supprimées.

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

POSThttps://api.kit.forhosting.com/math/egyptian-fraction

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/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)

Exemple de requête

{
  "numerator": 5,
  "denominator": 6
}

Exemple de réponse

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "math.egyptian_fraction",
  "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

par requête$0.002

Le prix est publié, sans tokens ni crédits. Une tâche qui échoue n’est pas facturée.

Limites

`max_value`	1000000000000
`max_terms`	1000

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.

Consulter la documentation complète du KIT →