Convertisseur code de Gray
Le binaire 1011 devient le code de Gray 1110, et le chemin inverse est tout aussi exact, avec les zéros de tête conservés pour garder la même largeur. Utile pour les tables de codeurs, les tableaux de Karnaugh et les exercices de logique. Gratuit dans votre navigateur.
- Gratuit
- Fonctionne dans votre navigateur
- Sans inscription
- Vos données restent sur votre appareil
Lancer gratuitement
Exemple résolu
- Valeur d'entrée
- 1011
- Sens de conversion : binary_to_gray
- Binary to gray
- Bits entrants
- 1011
- Bits sortants
- 1110
- Entier d'entrée
- 11
- Entier de sortie
- 14
Le code de Gray réfléchi binaire étiquette les entiers consécutifs de sorte que les codes successifs diffèrent d'exactement un bit. Cette propriété compte pour les encodeurs rotatifs, les cartes de Karnaugh, les machines d'états tolérantes aux erreurs, les démonstrations de communications numériques et les exercices de classe où les étudiants doivent associer un mot binaire à sa forme Gray ou récupérer le binaire à partir du Gray. Ce convertisseur de code de Gray accepte une chaîne de bits binaire ou un entier non négatif, une direction de conversion, et renvoie une chaîne de bits déterministe plus des champs structurés que vous pouvez figer dans des tests automatisés.
Ce qu'est le code de Gray réfléchi et quelles entrées sont valides
Le binaire standard est la représentation ordinaire en base deux d'un entier non négatif, avec des valeurs de place qui sont des puissances de deux. Le code de Gray réfléchi binaire est un étiquetage différent des mêmes entiers : on utilise encore des bits de zéro et un, mais les valeurs consécutives ne basculent qu'un seul bit.
L'encodage classique du binaire B vers Gray G est la règle bit à bit G égale B XOR B décalé à droite d'un bit ; le décodage accumule le XOR du bit le plus significatif vers le moins significatif de sorte que chaque bit binaire est la parité du préfixe Gray. Envoyez le champ obligatoire value comme chaîne pure de zéros et uns, éventuellement avec un préfixe 0b, ou comme entier non négatif ou chaîne de chiffres entiers si vous préférez la magnitude décimale.
Les zéros de tête dans une chaîne de bits pure sont conservés pour que devoirs et exemples matériels gardent une largeur fixe.
Cas d’usage
Notes d'encodeurs et d'outils embarqués
Les développeurs qui documentent des encodeurs rotatifs, des machines d'états ou des codes de position de capteurs génèrent des chaînes de bits Gray stables à partir de valeurs binaires sources sans calculer des tables XOR à la main.
Questions fréquentes
Que se passe-t-il si j'entre une valeur non binaire ?
Les chaînes de bits ne doivent utiliser que les chiffres 0 et 1 (préfixe 0b optionnel) ; flottants, texte mixte et déchets sont rejetés et non facturés.
Quelle variante de code de Gray cet outil met-il en œuvre ?
Uniquement le code de Gray réfléchi binaire : encode avec XOR de la valeur et de son décalage à droite d'un bit ; décode par XOR cumulatif depuis le bit le plus significatif. Les autres familles Gray sont hors périmètre.
Comment convertir du binaire en code de Gray à la main ?
Décalez le nombre binaire d'un rang vers la droite et combinez-le avec l'original bit à bit par un OU exclusif. Le binaire 1011 donne ainsi le Gray 1110, exactement ce que renvoie le convertisseur.
Comment repasser d'un code de Gray au binaire ?
Partez du bit de gauche : chaque bit binaire est le OU exclusif de tous les bits Gray jusqu'à cette position. Choisissez le sens Gray vers binaire et l'outil s'en charge, en gardant le même nombre de bits.
Les zéros de tête sont-ils conservés ?
Oui. Si vous saisissez une suite de bits commençant par des zéros, ils sont gardés dans le résultat, afin que votre exercice ou votre schéma matériel conserve une largeur fixe d'un bout à l'autre.
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/fmt/gray-code \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"value":"1011","direction":"binary_to_gray"}'const res = await fetch("https://api.kit.forhosting.com/fmt/gray-code", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"value": "1011",
"direction": "binary_to_gray"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/fmt/gray-code",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"value": "1011",
"direction": "binary_to_gray"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/fmt/gray-code", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"value":"1011","direction":"binary_to_gray"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"value":"1011","direction":"binary_to_gray"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/fmt/gray-code", 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
{
"value": "1011",
"direction": "binary_to_gray"
}Exemple de réponse
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "fmt.gray_code",
"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
Une entrée non binaire échoue avec une erreur invalid_input claire au lieu de tronquer silencieusement des chiffres parasites.
Ce qu'est le code de Gray réfléchi et quelles entrées sont valides
Les alias bits, binary et n sont acceptés lorsque votre formulaire ou SDK étiquette déjà le champ ainsi. La direction doit être binary_to_gray ou to_gray pour encoder, et gray_to_binary ou from_gray pour décoder ; les alias dir et mode fonctionnent de même. Les valeurs en virgule flottante, les nombres négatifs, les chaînes vides et le texte mixte qui n'est pas des chiffres binaires échouent avec invalid_input car ce produit promet une conversion exacte d'entiers, pas une approximation. Des entrées identiques produisent toujours un JSON identique : pas d'appel réseau, de graine aléatoire ni d'horloge murale sur le chemin.
Lire les champs de réponse et vérifier des résultats courants à la main
Comme chaque étape est un XOR sur des bits discrets, les résultats ne dérivent jamais comme le feraient des astuces en virgule flottante pour de grandes entrées. En cas de succès, la réponse renvoie value comme la chaîne de bits d'origine ou l'entier sûr que vous avez envoyé, direction comme l'étiquette canonique binary_to_gray ou gray_to_binary, bits_in comme la chaîne d'entrée normalisée bit le plus significatif en premier, et bits_out comme la chaîne convertie que vous voulez en général pour l'affichage, les correcteurs et la documentation d'encodeurs. integer_in et integer_out interprètent ces chaînes de bits comme des entiers non négatifs lorsque la magnitude tient dans un nombre JSON sûr, ou comme chaînes de chiffres décimaux lorsqu'elle est plus grande, afin que les pipelines puissent affirmer l'une ou l'autre forme. bit_width indique la longueur de bits_in, et method est toujours reflected_gray pour que le code aval puisse brancher sans renifler les formes. Des contrôles rapides instaurent la confiance : le binaire un zéro un un s'encode en Gray un un un zéro ; le Gray zéro un un un se décode en binaire zéro un zéro un ; le binaire zéro se mappe en Gray zéro ; un binaire de trois bits un zéro zéro devient Gray un un zéro. value manquant, direction manquante, chaînes non binaires, étiquettes de direction non prises en charge et largeurs de bits excessives échouent tous avec invalid_input et ne sont pas facturés après le rejet de validation. Utilisez bits_out seul lorsqu'une personne ou un rapport a besoin d'une seule ligne ; utilisez l'objet complet lorsque des vérificateurs automatisés doivent affirmer direction, largeur et méthode en plus de la chaîne de chiffres.
Usage de l'API, tarification, flux de classe et limites pratiques
Appelez le convertisseur de code de Gray gratuit dans le navigateur pour les contrôles de devoirs, les démonstrations de cours, les laboratoires d'encodeurs rotatifs et la vérification rapide sans écrire un script jetable. Préférez des largeurs d'échelle de classe pour les oracles notés, et gardez la longueur de bits dans le plafond publié pour la sécurité de l'isolat. Envoyez un corps JSON avec les champs obligatoires value et direction, ou utilisez les alias documentés lorsque votre client les nomme déjà autrement. Utilisez l'API prépayée lorsqu'une plateforme de tutorat, un bac à sable d'évaluation de code, une chaîne d'outils firmware ou un générateur de documentation a besoin d'un contrat stable sous solde KIT à $0.002 par élément réussi ; les échecs de validation ne consomment jamais le solde. Associez ce endpoint à des formateurs binaires ou hexadécimaux lorsqu'une leçon parcourt plusieurs encodages, ou à des outils de tables de vérité et de cartes de Karnaugh lorsque les étudiants relient l'adjacence Gray aux transitions d'un seul bit. Les auteurs qui livrent des SDK peuvent mapper bits_out directement dans des libellés d'UI, des drapeaux de CLI ou des commentaires générés qui montrent la forme Gray à côté de la constante binaire d'origine.
Cas d'intégration
Vérification de devoirs et d'examens
Les étudiants convertissent des mots binaires en code de Gray réfléchi et inversement, comparent les chaînes de bits et reçoivent une erreur invalid_input claire lorsqu'une valeur non binaire est soumise par erreur.
Plateformes de tutorat et correcteurs automatiques
Les créateurs de leçons et bacs à sable de code appellent un contrat JSON prépayé pour vérifier les réponses binaire↔Gray à l'échelle sans réimplémenter la logique Gray réfléchi dans chaque pile.
Questions techniques
Comment convertir du binaire en code de Gray avec cet outil ?
Envoyez un JSON avec value égal à une chaîne de bits ou un entier non négatif (par exemple value: "1011") et direction: "binary_to_gray". Le champ bits_out est la chaîne du code de Gray réfléchi.
Comment reconvertir le code de Gray en binaire ?
Utilisez direction "gray_to_binary" (ou from_gray) avec la chaîne de bits Gray dans value. Le bits_out de la réponse est la chaîne binaire standard récupérée.
Le convertisseur de code de Gray est-il gratuit ?
L'outil navigateur s'exécute gratuitement sur votre appareil. Les appels API utilisent le solde KIT prépayé à $0.002 par élément réussi ; les échecs de validation ne sont pas facturés.