Conversor de código Gray
O binário 1011 vira o código Gray 1110, e o caminho inverso é igualmente exato, mantendo os zeros à esquerda para que a largura não mude. Útil para tabelas de encoders, mapas de Karnaugh e exercícios de lógica digital. Grátis no seu navegador.
- Grátis
- Funciona no seu navegador
- Sem cadastro
- Seus dados não saem do seu aparelho
Executar grátis
Exemplo resolvido
- Valor de entrada
- 1011
- Direção da conversão: binary_to_gray
- Binary to gray
- Bits de entrada
- 1011
- Bits de saída
- 1110
- Inteiro de entrada
- 11
- Inteiro de saída
- 14
O código Gray refletido binário rotula inteiros consecutivos de modo que códigos sucessivos diferem em exatamente um bit. Essa propriedade importa em encoders rotativos, mapas de Karnaugh, máquinas de estados tolerantes a falhas, demos de comunicações digitais e exercícios de sala em que alunos precisam mapear uma palavra binária para a forma Gray ou recuperar o binário a partir do Gray. Este conversor de código Gray aceita uma string de bits binária ou um número inteiro não negativo, uma direção de conversão, e devolve uma string de bits determinística mais campos estruturados que você pode fixar em testes automatizados.
O que é o código Gray refletido e quais entradas são válidas
O binário padrão é a representação ordinária em base dois de um inteiro não negativo, com valores posicionais que são potências de dois. O código Gray refletido binário é um rotulamento diferente dos mesmos inteiros: ainda usa bits de zero e um, mas valores consecutivos alteram só um bit.
A codificação clássica de binário B para Gray G é a regra bit a bit G igual a B XOR B deslocado à direita em um bit; a decodificação acumula XOR do bit mais significativo ao menos significativo de modo que cada bit binário é a paridade do prefixo Gray. Envie o campo obrigatório value como string pura de zeros e uns, opcionalmente com prefixo 0b, ou como inteiro não negativo ou string de dígitos inteiros quando preferir a magnitude decimal.
Zeros à esquerda em uma string de bits pura são preservados para que dever de casa e exemplos de hardware mantenham largura fixa.
Casos de uso
Notas de encoders e ferramentas embarcadas
Desenvolvedores que documentam encoders rotativos, máquinas de estados ou códigos de posição de sensores geram strings de bits Gray estáveis a partir de valores binários fonte sem calcular tabelas XOR à mão.
Perguntas frequentes
O que acontece se eu digitar um valor não binário?
Strings de bits devem usar só dígitos 0 e 1 (prefixo 0b opcional); floats, texto misto e lixo são rejeitados e não cobrados.
O conversor de código Gray é grátis?
A ferramenta do navegador roda grátis no seu dispositivo.
Qual variante de código Gray esta ferramenta implementa?
Somente código Gray refletido binário: codifica com XOR do valor e seu deslocamento à direita em um bit; decodifica por XOR cumulativo a partir do bit mais significativo. Outras famílias Gray ficam fora do escopo.
Como converter binário em código Gray à mão?
Desloque o número binário uma posição para a direita e combine-o com o original, bit a bit, usando o OU exclusivo. Com o binário 1011 você obtém o Gray 1110, o mesmo resultado que o conversor mostra.
Como transformar um código Gray de volta em binário?
Comece pelo bit da esquerda: cada bit binário é o OU exclusivo de todos os bits Gray até aquela posição. Escolha a direção de Gray para binário e a ferramenta faz isso por você, com o mesmo número de bits.
Ferramentas relacionadas
Para desenvolvedores — acesso via API
Tudo nesta página está disponível via API. Esta seção é para equipes que querem integrar a ferramenta aos próprios sistemas; quem não precisa disso pode simplesmente usar a ferramenta acima.
Endpoint
Autenticação por token Bearer. Um único POST coloca a tarefa na fila; o resultado chega por webhook ou link assinado.
Chame do seu código
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)Exemplo de requisição
{
"value": "1011",
"direction": "binary_to_gray"
}Exemplo de resposta
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "fmt.gray_code",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}A API é assíncrona: cada chamada devolve um task_id na hora. Se preferir polling, consulte o status a até 1 requisição por segundo.
Preço
Preço publicado, sem tokens nem créditos escondidos. Tarefa que falha não é cobrada.
Erros
| HTTP | Código | O que significa |
|---|---|---|
401 | unauthorized | Token ausente ou inválido. Confira o header Authorization. |
402 | insufficient_balance | Saldo insuficiente para esta tarefa. Faça uma recarga e tente de novo. |
404 | unknown_type | Esse tipo de tarefa não existe. Confira o campo type no catálogo. |
429 | rate_limited | Muitas requisições em pouco tempo. Espere um instante e tente de novo. |
Notas técnicas
Entrada não binária falha com um erro invalid_input claro em vez de truncar dígitos lixo em silêncio.
O que é o código Gray refletido e quais entradas são válidas
Os aliases bits, binary e n são aceitos quando o seu formulário ou SDK já rotula o campo assim. A direção deve ser binary_to_gray ou to_gray para codificar, e gray_to_binary ou from_gray para decodificar; os aliases dir e mode funcionam igual. Valores de ponto flutuante, números negativos, strings vazias e texto misto que não seja dígitos binários falham com invalid_input porque este produto promete conversão exata de números inteiros, não aproximação. Entradas idênticas sempre produzem JSON idêntico: não há chamada de rede, semente aleatória nem relógio de parede no caminho.
Como ler os campos da resposta e conferir resultados comuns à mão
Checagens rápidas geram confiança: o binário um zero um um codifica para Gray um um um zero; o Gray zero um um um decodifica de volta para binário zero um zero um; o binário zero mapeia para Gray zero; um binário de três bits um zero zero vira Gray um um zero. Como cada passo é XOR em bits discretos, os resultados nunca driftam como truques de ponto flutuante fariam com entradas grandes. Em caso de sucesso, a resposta ecoa value como a string de bits original ou o inteiro seguro que você enviou, direction como o rótulo canônico binary_to_gray ou gray_to_binary, bits_in como a string de entrada normalizada bit mais significativo primeiro, e bits_out como a string convertida que você normalmente quer para tela, corretores e documentação de encoders. integer_in e integer_out interpretam essas strings de bits como inteiros não negativos quando a magnitude cabe em um número JSON seguro, ou como strings de dígitos decimais quando maior, para pipelines afirmarem qualquer forma. bit_width reporta o comprimento de bits_in, e method é sempre reflected_gray para o código a jusante ramificar sem farejar formas. Falta de value, falta de direction, strings não binárias, rótulos de direção não suportados e larguras de bits excessivas falham com invalid_input e não são cobradas após a validação rejeitar a requisição. Use só bits_out quando uma pessoa ou relatório precisa de uma linha; use o objeto completo quando verificadores automáticos devem afirmar direção, largura e método além da string de dígitos.
Uso da API, preços, fluxos de sala de aula e limites práticos
Chame o conversor de código Gray grátis no navegador para checar dever de casa, demos de aula, labs de encoders rotativos e verificação rápida sem escrever um script descartável. Prefira larguras de escala de sala para oráculos avaliados e mantenha o comprimento de bits dentro do teto publicado por segurança do isolado. Envie um corpo JSON com os campos obrigatórios value e direction, ou use os aliases documentados quando o seu cliente já os nomeia de outra forma. Use a API pré-paga quando uma plataforma de tutoria, sandbox de avaliação de código, toolchain de firmware ou gerador de documentação precisar de um contrato estável sob saldo KIT a US$ 0,002 por item bem-sucedido; falhas de validação nunca consomem saldo. Combine este endpoint com formatadores binários ou hexadecimais quando uma lição percorre várias codificações, ou com ferramentas de tabelas-verdade e mapas de Karnaugh quando alunos conectam a adjacência Gray a transições de um bit. Autores que publicam SDKs podem mapear bits_out diretamente em rótulos de UI, flags de CLI ou comentários gerados que mostram a forma Gray ao lado da constante binária original.
Casos de integração
Verificação de dever de casa e provas
Alunos convertem palavras binárias para código Gray refletido e de volta, comparam strings de bits e recebem um erro invalid_input claro quando um valor não binário é enviado por engano.
Plataformas de tutoria e corretores automáticos
Construtores de lições e sandboxes de código chamam um contrato JSON pré-pago para checar respostas binário↔Gray em escala sem reimplementar a lógica de Gray refletido em cada stack.
Perguntas técnicas
Como converto binário para código Gray com esta ferramenta?
Envie JSON com value igual a uma string de bits ou um inteiro não negativo (por exemplo value: "1011") e direction: "binary_to_gray". O campo bits_out é a string do código Gray refletido.
Como converto código Gray de volta para binário?
Use direction "gray_to_binary" (ou from_gray) com a string de bits Gray em value. O bits_out da resposta é a string binária padrão recuperada.