Conversão de decimais em binários e vice-versa

Publicado por Angelito Monteiro Goulart em 20/05/2009

[ Hits: 28.942 ]

Blog: http://angelitomg.com

 


Conversão de decimais em binários e vice-versa



Introdução

Para quem trabalha com informática, saber converter números decimais em binários e binários em decimais é algo muito importante.

Nesta dica pretendo ensinar de forma fácil, rápida e prática, uma simples técnica de conversão.

Os números binários, como o próprio nome diz, bi -> 2, utilizam apenas dois números, 0 e 1.

Vamos então às conversões.

Convertendo decimais em binários

Vamos converter o número 342 em binário.

Primeiro faça uma tabela com o dobro dos números, começando do 1.

Exemplo: dobro de 1 -> 2, dobro de 2 -> 4, dobro de 4 -> 8 e assim sucessivamente.

Após isso, marque com 1 os números cuja soma seja o valor a ser convertido e marque com 0, os números que são serão utilizados na soma.

256   128   64   32   16   8   4   2   1
==============================
   1      0      1    0      1    0   1   1   0

Resultado: 101010110

Números marcados com 1 -> 256, 64, 16, 4, 2.

256 + 64 + 16 + 4 + 2 = 342

Convertendo binários em decimais

Para converter um número binário em decimal, basta fazer o inverso.

Convertendo 100110 em decimal:

Faça a tabela e preencha-a com o número binário.

32   16   8    4   2    1
===================
1      0   0      1    1    0

Números marcados com 1: 32, 4, 2

32 + 4 + 2 = 38

Conclusão

Há outras formas de realizar a conversão, porém escolhi esta devido ao fato dela ser bastante simples.

Espero que tenham entendido.

Grande abraço.

Outras dicas deste autor

Escolhendo sua distribuição Linux

Trabalhando com transações com PHP e MySQL

Trabalhando com parâmetros em Shell Script

Utilizando o comando cat

Executando comandos do sistema com PHP

Leitura recomendada

Borracha e pincel quadrados e preenchidos no Gimp

ONLYOFFICE Desktop Editors com interface totalmente reorganizada

Replicação no LDAP com slurp

Resolvendo o problema do VMware Player no Ubuntu 15.04 Vivid Vervet

Coaching Gratuito em Linux

  

Comentários
[1] Comentário enviado por matux em 20/05/2009 - 21:39h

Parabéns, mto útil!
Alias, sempre útil essas dicas de conversão!

[2] Comentário enviado por rndrama em 21/05/2009 - 09:54h

INTERESSANTE!!! PARABÉNS!!!! Fiz uma aplicação básica que demonstra a construção da matriz de Hamming, depois inserir uma rajada de erro e posteriormente corrir este. Usei as conversões citadas acima. Segue código......

#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#define N 51

void corrigeErro(char *str, int matriz[50][11], int lin_rajada, int tam_rajada);
int paridade(int num);
int verificaParidade(int matriz[50][11], int vet[4][5], int i, int cont, int insere_ou_verifica, int j);
int potenciaDois(int aux_col);
void converteMatrizString(int matriz[50][11], int insere_erro_ou_imrime_string);
int insereBitsParidade(int matriz[50][11], int insere_ou_verifica, int lin, int col);
int retornaLinhaVet(int j);

int main()
{
//size - pegamos tamanho da string
//ind_str - indice do vetor str
//vet - vetor que vai contabilizar a quantidade de vezes que as potências de dois aparecem
// nas somas dos seguintes números: 3,5,6,7,9,10,11(números de 1 a 11, exceto potências de
// dois);
// posição 0 informa a quantidade de vezes que o expoente zero aparece nas somas;
// posição 1 informa a quantidade de vezes que o expoente um aparece nas somas;
// posição 2 informa a quantidade de vezes que o expoente dois aparece nas somas;
// posição 3 informa a quantidade de vezes que o expoente tres aparece nas somas;


int size, num_dec, lin = 0, col = 11,
resto, ind_str = 0, matriz[50][11],
teste, aux_col, flag = 1,
vet[4] = {0, 0, 0, 0}, i,;

int insere_ou_verifica = 1, ret_paridade, insere_erro_ou_imrime_string = 1;

char str[N] = "Trabalho de Redes I analisando a Matriz de Hamming";


size = strlen(str);

while(size >= 0)
{

num_dec=(int)str[ind_str];

while(col > 0)
{
if(flag)
{
resto = num_dec%2;

num_dec = num_dec/2;

}

if(potenciaDois(col))
{
flag = 1;

matriz[lin][col]=resto;
}
else
{
flag = 0;

//só com o cinco que dar certo; nao sei pq
matriz[lin][col]=5;
}

col--;

}

size--;

ind_str++;

lin++;

col = 11;

flag = 1;

}

//insere_ou_verifica define o que a função insereBitsParidade vai fazer, inserir ou verificar e
//lin vai definir a linha da matriz
lin = 0;
col = 1;

ret_paridade = insereBitsParidade(matriz,insere_ou_verifica,lin,col);

printf("Questao (A): Matriz de Hamming para a String passada!!!!\n\n");

printf(" ");

for(col=1; col<=11; col++)
printf("%d ", col);

printf("\n");

for(lin=0; lin<50; lin++)
{
printf("%c ", str[lin]);

for(col=1; col<=11; col++)
printf("%d ", matriz[lin][col]);

printf("\n");
}

printf("\n\nQuestao (B): Inserir erro, Imprimir String com erro e corrigida!!!!\n");

//Insere Erro e converte a matriz em String
converteMatrizString(matriz,insere_erro_ou_imrime_string);

printf("\n\nOBS Questao (C): Favor descomentar linha 299(//tam_rajada = 50;) para rodarmos com a rajada 50!!!!\n\n\n\n");

system("PAUSE");
return 0;
}

//retorna 1 se o número passado não seja potência de dois, 0 caso seja
int potenciaDois(int aux_col)
{
int flag = 0;

while(aux_col != 1)
{
if(aux_col%2)
flag = 1;

aux_col = aux_col/2;
}

return flag;
}

//Insere conteúdo nos bits de paridade, levando-se em conta a paridade par(insere 1 se a soma dos
//conteúdos dos bits de dados, não potência de dois, for ímpar, insere 0 caso a soma seja par)
int insereBitsParidade(int matriz[50][11], int insere_ou_verifica, int lin, int col)
{

/*
+++++++++++++++++++++++++++++++++
EXPLICAÇÃO DE ALGUMAS VARIÁVEIS
+++++++++++++++++++++++++++++++++
1 - vet: Vai armazenar os bits, cuja soma aparecem as potências de dois(vai determinar o valor
dos bits de paridade, ou seja, os bits potência de dois)
EX:
Expoentes: 1 = 2º / 2 = 2¹ / 4 = 2² / 8 = 2³
Somas: bit 3 = 1 + 2
bit 5 = 1 + 4
bit 6 = 2 + 4
bit 7 = 1 + 2 + 4
bit 9 = 1 + 8
bit 10 = 2 + 8
bit 11 = 1 + 2 + 8

Logo, observa-se que a potência 2º(1) acontece 5 vezes nas somas, nos bits 3,5,7,9 e 11.
Esse raciocínio também é verificado para as outras potências
Nesse sentido, criamos o vetor vet para armazenar tais posições.
2 - ret_paridade: vai receber paridade do bit
*/

int vet[4][5] = {
{3,5,7,9,11},
{3,6,7,10,11},
{5,6,7},
{9,10,11}
};
int i, j, aux_lin_vet, ret_paridade;


for(i=lin; (i<50 && insere_ou_verifica) || (i<lin+1 && !insere_ou_verifica); i++)
{

for(j=col; (j<=11 && insere_ou_verifica) || (j<col+1 && !insere_ou_verifica); j++)
{

if(!potenciaDois(j))
{

aux_lin_vet = retornaLinhaVet(j);

if(insere_ou_verifica)
matriz[i][j] = verificaParidade(matriz, vet, i, aux_lin_vet,insere_ou_verifica,j);
else
ret_paridade = verificaParidade(matriz, vet, i, aux_lin_vet,insere_ou_verifica,j);

aux_lin_vet++;

}

}

//precisamos da paridade do bit a cada linha na verificação
if(!insere_ou_verifica)
return ret_paridade;

}

return ret_paridade;

}

int verificaParidade(int matriz[50][11], int vet[4][5], int i, int aux_lin_vet, int insere_ou_verifica, int j)
{
int cont = 0, lin, col, ja;

for(lin = aux_lin_vet; lin < aux_lin_vet + 1; lin++)
{

for(col=0; col<5; col++)
{

if(matriz[ i ][ vet[lin][col] ] == 1)
cont++;

}

}

return paridade(cont);
}

//Retorna 1 se número passado é impar, e 0 caso par
int paridade(int num)
{
if(num%2)
return 1;
else
return 0;
}



int retornaLinhaVet(int j)
{
int aux_lin_vet = 0;

if(j == 2)
aux_lin_vet=1;
else
if(j == 4)
aux_lin_vet=2;
else
if(j == 8)
aux_lin_vet=3;

return aux_lin_vet;
}

/*
========================================================================================
RESOLUÇÃO DA QUESTÃO B - RECEBE UMA MATRIZ E RETORNA(IMPRIME) UM VETOR DE CARACTERES
========================================================================================
*/

void converteMatrizString(int matriz[50][11], int insere_erro_ou_imrime_string)
{

/*
+++++++++++++++++++++++++++++++++
EXPLICAÇÃO DE ALGUMAS VARIÁVEIS
+++++++++++++++++++++++++++++++++
1 - quant_bits: Vai ser o expoente das potências de dois, como vai achar n bits inicializamos de
de -1 para podermos pegar n-1(vai incrementar) potências de 2(expoentes de 0 a n-1)
*/

int lin, col, quant_bits = -1, num_dec_convert, aux_quant_bits,
lin_rajada, col_rajada, tam_rajada, troca_bit, bck_tam_rajada;
char str[N];
float temp, num_dec;

srand(time(NULL));


if(insere_erro_ou_imrime_string)
{
lin_rajada = 0 + rand() % 50;

col_rajada = 1 + rand() % 11;

tam_rajada = 1 + rand() % 50;

//==========================================================
//QUESTÃO C: para rodar a questão c só é descomentar a linha abaixo(tam_rajada = 50)
//==========================================================
//tam_rajada = 50;

bck_tam_rajada = tam_rajada;

printf("\n\nO tamanho da rajada foi %d, a linha foi %d e a coluna foi %d\n", tam_rajada,
lin_rajada, col_rajada);

for(lin=lin_rajada; (lin<50 || lin<lin_rajada) && tam_rajada>0; lin++)
{

troca_bit = matriz[lin][col_rajada];

troca_bit = paridade(!troca_bit);

matriz[lin][col_rajada] = troca_bit;

tam_rajada--;

if(lin == 49)
lin = 0;

}
}

//descobre quantidade de bits
for(col=1; col<=11; col++)
if(potenciaDois(col))
quant_bits++;

//conservar a quantidade de bits
aux_quant_bits = quant_bits;

//convertemos o valor binário em decimal(somas sucessivas de potências de dois) e inserimos no
//vetor de caracteres
for(lin=0; lin<50; lin++)
{

num_dec = 0;

for(col=1; col<=11; col++)
{

//bits que contém os dados; todos aqueles não potência de dois
if(potenciaDois(col))
{

//bit com valor 1, fazemos a soma sucessiva
if(matriz[lin][col])
{
temp = pow(2,quant_bits);

num_dec = num_dec + temp;
}

quant_bits--;

}

}
//atualiza valor da quantidade de bits
quant_bits = aux_quant_bits;

//converte o valor float achado, após a conversão de binário, para int
num_dec_convert = (int)num_dec;

//converte o valor int ao caractere correspondente levando em conta a Tabela ASCII e insere
//o caractere no vetor
str[lin] = (char)num_dec_convert;

}

printf("\n\n");

//Impressão do vetor de caracteres formado
for(lin=0; lin<50; lin++)
printf("%c", str[lin]);

printf("\n\n");

if(insere_erro_ou_imrime_string)
corrigeErro(str, matriz, lin_rajada, bck_tam_rajada);

}

void corrigeErro(char *str, int matriz[50][11], int lin_rajada, int tam_rajada)
{
int insere_ou_verifica = 0, insere_erro_ou_imrime_string = 0, acumula_soma = 0,
i, j, ret_paridade, troca_bit;

for(i=lin_rajada; (i<50 || i<lin_rajada) && tam_rajada>0; i++)
{

for(j=1; j<=11; j++)
{

if(!potenciaDois(j))
{

ret_paridade = insereBitsParidade(matriz,insere_ou_verifica,i,j);

if(ret_paridade != matriz[i][j])
acumula_soma = acumula_soma + j;

}

}

troca_bit = matriz[i][acumula_soma];

troca_bit = paridade(!troca_bit);

matriz[i][acumula_soma] = troca_bit;

acumula_soma = 0;

tam_rajada--;

if(i == 49)
i = 0;

}

converteMatrizString(matriz,insere_erro_ou_imrime_string);

}

[3] Comentário enviado por zecnikis em 26/05/2009 - 20:48h

Otimo artigo para quem esta começando.
O Básico do básico!
Mas com prática não tem erro!

Até mais!

[4] Comentário enviado por removido em 30/08/2009 - 01:53h

Show.

[5] Comentário enviado por julio.ferraz em 05/01/2012 - 16:45h

Ótima Explicação! Ainda mas pra quem tá relembrando..ou ainda...não sabe..obrigado!



Contribuir com comentário




Patrocínio

Site hospedado pelo provedor RedeHost.
Linux banner
Linux banner
Linux banner

Destaques

Artigos

Dicas

Tópicos

Top 10 do mês

Scripts