Ir ao conteúdo
  • Cadastre-se
Usuário 3301

C Dividir resultado até ser igual a zero

Posts recomendados

Bem amigos, venho aqui novamente pedir ajuda com um assunto que não vi até o momento alguém comentando sobre.

Estou fazendo um algoritmo de uma calculadora, onde ela faz operações de adição, subtração, divisão...

Enfim, não irei dar muitos detalhes sobre e irei direto ao ponto!

Quero que minha calculadora faça o seguinte:

Receba um valor N, divida por 2 e logo depois pegue esse resultado e divida por 2 e assim sucessivamente, até que o resultado da operação seja igual a  zero. No final, ele tem que dar o resto de cada divisão.

Não irei colocar o meu algoritmo completo, até porque ele está muito grande, mas tentei utilizar o while e tive alguns problemas problemas.

 

printf("Informe o valor binário que deseja realizar da base 10 para base 2: ");
scanf("%d", &Num1);
resvid = Num1/2;
while(resvid = 0);
resvid = resvid/2;
printf("%d", resto);

resvid é o resultado da divisão.

Se alguém tiver algum algoritmo mais claro, compartilhe! Desde já agradeço.

 

Obs.: Sim, arquitetura de computadores... Estou tentando fazer um algoritmo que calcule o valor binário da base 10 para a base 2.

Compartilhar este post


Link para o post
Compartilhar em outros sites
38 minutos atrás, Usuário 3301 disse:

Receba um valor N, divida por 2 e logo depois pegue esse resultado e divida por 2 e assim sucessivamente, até que o resultado da operação seja igual a  zero. No final, ele tem que dar o resto de cada divisão.

a sua explicação foi um pouco complicada porque entendir voce explicar uma coisa e depois explicar outra mas vamos supor esse trecho que voce citou olhe este exemplo.

#include <stdio.h>

float num;
int main(){
	printf ("digite um numero\n");
	scanf ("%f", &num);
	inicio:
	if (num>1){
	num = num/2;
	goto inicio;
	}
	else {
		printf ("%f", num);
	}
}

para transformar numeros de uma base para outra é necessario uma tbela se voce for precisar posso de disponibilizar

  • Curtir 1

Compartilhar este post


Link para o post
Compartilhar em outros sites
8 minutos atrás, herbertbahia disse:

a sua explicação foi um pouco complicada porque entendir voce explicar uma coisa e depois explicar outra mas vamos supor esse trecho que voce citou olhe este exemplo.

#include <stdio.h>

float num;
int main(){
	printf ("digite um numero\n");
	scanf ("%f", &num);
	inicio:
	if (num>1){
	num = num/2;
	goto inicio;
	}
	else {
		printf ("%f", num);
	}
}

para transformar numeros de uma base para outra é necessario uma tbela se voce for precisar posso de disponibilizar

Vou tentar explicar com um exemplo, creio que será mais fácil o entendimento.

 

Recebo o Número 29.

29/2 = 14

resto 1.

 

14/2 = 7

resto 0.

 

7/2 = 3

resto 1.

 

3/2 = 1

resto 1.

 

1/2 = 0

resto 1.

 

O resultado da primeira divisão é dividida novamente por 2 e assim por diante, até chegar a zero. E no final, deve ser mostrado o resto de cada divisão.

  • Curtir 1

Compartilhar este post


Link para o post
Compartilhar em outros sites
#include <stdio.h>


int num,contador, resto;
int main(){
	printf ("digite um numero\n");
	scanf ("%d", &num);
	resto = num % 2;
	inicio:
	if (num>1){
	num = num/2;
	contador = contador +1;
	goto inicio;
	}
	else {
		printf ("o numero foi dividido %d vezes\n", contador);
		printf ("O resto da divisao e %d",resto);
	}
}

 

  • Curtir 1

Compartilhar este post


Link para o post
Compartilhar em outros sites

@Usuário 3301

#include <iostream>
#include <stdlib.h>
#include "locale.h"

int main() {

    int N, divisao, resto;
    
    setlocale(LC_ALL, "");
    
    printf("Entre com um número:");
    scanf("%i", &N);
    do{
        divisao = N / 2;
        resto = N % 2;
    
        printf("\nA divisão de %i por 2 é igual a: %i", N, divisao);
        printf("\nO resto é igual a: %i", resto);
        
        N = divisao;
        
        printf("\nAgora N vale: %i", N);
    }while(divisao > 0);

    return 0;
}

 

  • Obrigado 1

Compartilhar este post


Link para o post
Compartilhar em outros sites

@Usuário 3301 Para passar de decimal para binário, é preciso pegar os restos, do último ao primeiro, e organizá-los (pelo menos é assim que eu aprendi a converter).

Entendeu o algorítimo, certo?

Ele continua dividindo por 2 até que o resultado da divisão seja 0, é simplesmente isso.

adicionado 1 minuto depois

Bom, isso se não tiver que mexer com números quebrados, pois aí teria que fazer outro processo...

Compartilhar este post


Link para o post
Compartilhar em outros sites

@Lucca Rodrigues Realizei a criação do algoritmo que faz a conversão do valor binário da base 2 para a base 10, só não consegui fazer o contrário creio por já ter pensado muito.

adicionado 24 minutos depois
//declaração das diretivas
//declaração das diretivas

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <locale.h>

//declaração das variáveis

int Num1, Num2, Num3, Num4, Num5, Num6, Num7, Num8, Num9, Num10, Num11, Num12, opcao, nov, base;
float res;
int res1, res2, res3, res4, res5, res6, res7, res8, res9, res10, res11, res12, bin2, bin1;
int resto, resvid;

//inicio do algoritmo

main(){
	do{
	setlocale(LC_ALL, "Portuguese");
	system("cls");
	printf("Qual operação você deseja realizar?\n");
	printf("1 - Adição		2 - Subtração		3 - Multiplicação		4 - Divisão\n");
	printf("		5 - Raiz Quadrada		6 - Número Binário\n\n");
	scanf("%d", &opcao);
	switch(opcao){
		case 1:{
			printf("Você está realizando uma adição.\n");
			printf("Digite o primeiro número: ");
			scanf("%d", &Num1);
			printf("Digite o segundo número: ");
			scanf("%d", &Num2);
			res = Num1 + Num2;
			printf("A soma de %d e %d é: %.0f", Num1, Num2, res);
			break;
		}
		case 2:{
			printf("Você está realizando uma subtração.\n");
			printf("Digite o primeiro número: ");
			scanf("%d", &Num1);
			printf("Digite o segundo número: ");
			scanf("%d", &Num2);
			res = Num1 - Num2;
			printf("A subtração de %d e %d é: %.0f", Num1, Num2, res);
			break;
		}
		case 3:{
			printf("Você está realizando uma multiplicação.\n");
			printf("Digite o primeiro número: ");
			scanf("%d", &Num1);
			printf("Digite o segundo número: ");
			scanf("%d", &Num2);
			res = Num1 * Num2;
			printf("A multiplicação de %d e %d é: %.0f", Num1, Num2, res);
			break;
		}
		case 4:{
			printf("Você está realizando uma divisão.\n");
			printf("Digite o primeiro número: ");
			scanf("%d", &Num1);
			printf("Digite o segundo número: ");
			scanf("%d", &Num2);
			res = Num1 / Num2;
			printf("A divisão de %d e %d é: %.0f", Num1, Num2, res);
			break;
		}
		case 5:{
			printf("Você está realizando uma raiz quadrada!\n");
			printf("Digite o número que deseja saber a raiz: ");
			scanf("%d", &Num1);
			res = sqrt(Num1);
			printf("A raiz quadrada do número %d é: %.0f", Num1, res);
			break;
		}
		case 6:{
			printf("Em qual base você deseja calcular? // Base 2 ou Base 10\n");
			scanf("%d", &base);
			if (base == 2){
				printf("Informe o primeiro número: ");
				scanf("%d", &Num1);
				res1 = Num1*pow(2, 0);
				printf("Informe o segundo número: ");
				scanf("%d", &Num2);
				res2 = Num2*pow(2, 1);
				printf("Informe o terceiro número: ");
				scanf("%d", &Num3);
				res3 = Num3*pow(2, 2);
				printf("Informe o quarto número: ");
				scanf("%d", &Num4);
				res4 = Num4*pow(2, 3);
				printf("Informe o quinto número: ");
				scanf("%d", &Num5);
				res5 = Num5*pow(2, 4);
				printf("Informe o sexto número: ");
				scanf("%d", &Num6);
				res6 = Num6*pow(2, 5);
				printf("Informe o sétimo número: ");
				scanf("%d", &Num7);
				res7 = Num7*pow(2, 6);
				printf("Informe o oitavo número: ");
				scanf("%d", &Num8);
				res8 = Num8*pow(2, 7);
				printf("Informe o nono número: ");
				scanf("%d", &Num9);
				res9 = Num9*pow(2, 8);
				printf("Informe o décimo número: ");
				scanf("%d", &Num10);
				res10 = Num10*pow(2, 9);
				printf("Informe o décimo-primeiro número: ");
				scanf("%d", &Num11);
				res11 = Num11*pow(2, 10);
				printf("Informe o décimo-segundo número: ");
				scanf("%d", &Num12);
				res12 = Num12*pow(2, 11);
				bin2 = res1+res2+res3+res4+res5+res6+res7+res8+res9+res10+res11+res12;
				printf("o código binário %d%d%d%d%d%d%d%d%d%d%d%d na base 2 para base 10 é: %d", Num12, Num11, Num10, Num9, Num8, Num7, Num6, Num5, Num4, Num3, Num2, Num1, bin2);
			}
			else if(base == 10){
				printf("Informe o número que você deseja realizar a operação: ");
				scanf("%d", &Num1);
				do{
					resvid = Num1/2;
					resto = Num1%2;
					printf("\n A divisão de %d por 2 é igual a %d\n", Num1, resvid);
					printf("\nO resto é: %d\n", resto);
					
					Num1 = resvid;
					printf("\nAgora a divisão é por %d", Num1);
				}while(resvid > 0);
			}
			break;
		}
	}
	printf("\n\nVocê deseja realizar outra operação? 1 - Sim // 2 - Não\n");
	scanf("%d", &nov);
	if (nov == 2){
		printf("\n\nFinalizando aplicação...\n");
		system("pause");
		return 0;
	}
	}while(nov == 1);
	return 0;
}

Quero agradecer a todos pela ajuda. Meu algoritmo completo ficou assim!

Basicamente é uma calculadora que tem a função de calcular as operações de matemática comum e um acréscimo de número binário... Caso queiram testar, no meu está funcionando perfeitamente!

  • Curtir 1

Compartilhar este post


Link para o post
Compartilhar em outros sites

@Usuário 3301

#include <iostream>
#include <stdlib.h>
#include "locale.h"

int main() {

    int N, divisao, resto[10], i;
    
    setlocale(LC_ALL, "");
    
    printf("Entre com um número: ");
    scanf("%i", &N);
    i = 0;
    do{
        
        divisao = N / 2;
        resto[i] = N % 2;
        i += 1;
        N = divisao;
        
    }while(divisao > 0);
    
    printf("\nO valor da conversão é: ");    
    
    for(i=i-1 ;i>=0 ;i--) // Conta de trás pra frente
    {    
        printf("%i", resto[i]);    
    }
    
    return 0;
}

De decimal para binário é assim, sem complicações. Com um array, armazenam-se os valores do resto que podem ser referenciados individualmente. Contando de trás pra frente, obtemos o valor em binário.

Lembre-se: "Todo usuário é i.diota", como já dizia meu professor. Tentarão fazer divisões por 0, preparou seu algoritmo para isso? E para operações com números quebrados? Todos que declarou são inteiros, isso é um problema.

Tente não declarar um zilhão números, use arrays.

Também há outro problema: conversão de binário para decimal e vice-versa com números quebrados. É outro processo.

Faça também outras conversões! Octal, hexadecimal, etc.

E para raiz de números negativos? Já entramos no domínio dos números complexos. Você teria que preparar seu algoritmo para isso também.

  • Amei 1

Compartilhar este post


Link para o post
Compartilhar em outros sites

Olá!

 

Vou deixar um exemplo divertido para converter um int para binário numa função.

 

Uns detalhes

 

Um int na minha máquina tem 32 bits então vou limitar o maior valor em 31 '1' certo? O primeiro bit é o de sinal. Não faz diferença na verdade, mas tem que ter um limite. Podiam ser 32 ou 64, o caso do unsigned long. Mas vou usar um int.

 

Qual o limite? Em C essas constantes ficam todas em limits.h e em geral nem precisa do #include porque ele já é inclúido em outros tipo stdio ou memory eu acho. Teste. Se der erro numa linha como essa aqui use o tal include.

	int teste = INT_MAX;

Então vamos ter o valor de retorno do int N  convertido para binário em

	char	display[32];

 Inicialmente o display está com

	const char* zero = "                              0";

como convém a uma calculadora. E vamos criar a rotina, declarada assim

int		to_bin(char* display, int N)

Onde N é o número a converter e display é o endereço do zero lá no vetor display

 

Veja uma rotina dessas, bem curtinha:

int	to_bin(char* display, int N)
{
	if (N != 0)
	{	*display = (N&1) + '0';
		to_bin(--display, N>>1);
	}; // if()
}; // bits()


Só um if()

 

Eis a saída de um programa de teste da rotina,
com um gabarito na primeira linha e uns números legais para testar

começando com o tal máximo logo. 0 a 30 bits são 31 bits, o que cabe no int
 

0         1         2         3
0123456789012345678901234567890
1111111111111111111111111111111 = 2147483647
 101010101010101010101010101010 = 715827882
                     1111111111 = 1023
                            100 = 4
                              0 = 0
1111111111111111111111111111111 = 2147483647
 111111111111111111111111111111 = 1073741823
  11111111111111111111111111111 = 536870911
   1111111111111111111111111111 = 268435455
    111111111111111111111111111 = 134217727
     11111111111111111111111111 = 67108863
      1111111111111111111111111 = 33554431
       111111111111111111111111 = 16777215
        11111111111111111111111 = 8388607
         1111111111111111111111 = 4194303
          111111111111111111111 = 2097151
           11111111111111111111 = 1048575
            1111111111111111111 = 524287
             111111111111111111 = 262143
              11111111111111111 = 131071
               1111111111111111 = 65535
                111111111111111 = 32767
                 11111111111111 = 16383
                  1111111111111 = 8191
                   111111111111 = 4095
                    11111111111 = 2047
                     1111111111 = 1023
                      111111111 = 511
                       11111111 = 255
                        1111111 = 127
                         111111 = 63
                          11111 = 31
                           1111 = 15
                            111 = 7
                             11 = 3
                              1 = 1
                             10 = 2
                            100 = 4
                           1000 = 8
                          10000 = 16
                         100000 = 32
                        1000000 = 64
                       10000000 = 128
                      100000000 = 256
                     1000000000 = 512
                    10000000000 = 1024
                   100000000000 = 2048
                  1000000000000 = 4096
                 10000000000000 = 8192
                100000000000000 = 16384
               1000000000000000 = 32768
              10000000000000000 = 65536
             100000000000000000 = 131072
            1000000000000000000 = 262144
           10000000000000000000 = 524288
          100000000000000000000 = 1048576
         1000000000000000000000 = 2097152
        10000000000000000000000 = 4194304
       100000000000000000000000 = 8388608
      1000000000000000000000000 = 16777216
     10000000000000000000000000 = 33554432
    100000000000000000000000000 = 67108864
   1000000000000000000000000000 = 134217728
  10000000000000000000000000000 = 268435456
 100000000000000000000000000000 = 536870912

Eis o programa de teste

 

#define _CRT_SECURE_NO_WARNINGS
#include "limits.h"
#include "stdio.h"
#include "string.h"

int		to_bin(char* display, int N)
{
	if (N != 0)
	{	*display = (N&1) + '0';
		to_bin(--display, N>>1);
	}; // if()
};	// bits()

int main(int argc, char** argv)
{
	const char* zero = "                              0";
	char	display[32];
	strcpy( display,zero);
	display[31] = 0; // montado display, max 31 digitos
	int teste = INT_MAX;
	printf("0         1         2         3\n");
	printf("0123456789012345678901234567890\n");

	to_bin(display + 30, teste); // INT_MAX para comecar
	printf("%s = %d\n", display, teste);
	strcpy(display, zero);

	teste = 0x2AAAAAAA; // :) tudo alternado 010101...
	to_bin(display + 30, teste); // INT_MAX para comecar
	printf("%s = %d\n", display, teste);
	strcpy(display, zero);

	teste = 1023;
	to_bin(display + 30, teste);
	printf("%s = %d\n", display, teste);
	strcpy(display, zero);

	teste = 4;
	to_bin(display + 30, teste);
	printf("%s = %d\n", display, teste);
	strcpy(display, zero);

	teste = 0;
	to_bin(display + 30, teste);
	printf("%s = %d\n", display, teste);
	strcpy(display, zero);

	for (teste = INT_MAX; teste > 0; teste /= 2)
	{	// testa bit a bit
		to_bin(display + 30, teste);
		printf("%s = %d\n", display, teste);
		strcpy(display, zero);
	};	// for

	for (teste = 2; teste < INT_MAX/2; teste *= 2)
	{	// agora os pares
		to_bin(display + 30, teste);
		printf("%s = %d\n", display, teste);
		strcpy(display, zero);
	};	// for
	return 0;
}

 

É só um brinquedo. Não tem nada de especial. Podia ser feito usando uma pilha: muitas vezes pedem isso nos cursos de estruturas de dados, aquele lance de push(0 e pop(). Ou usando um while. Não teria muita graça. Em tempos de isolamento se você tiver interesse escreva e posso postar outros dois exemplos com esses casos amanhã.

 

De volta a rotina

 

É uma ideia bobinha, porque essencialmente a notação em base N funciona assim mesmo e a recursão cuida de inverter os dígitos. E como são poucos bits o consumo de memória é insignificante.

 

O if e a pegadinha

 

A rotina é chamada com o valor de N, que tem a chance de ser par ou impar. E o display já está apontando para o dígito certo. Então é só colocar zero se for par ou 1 se for ímpar, e depois andar para a esquerda. Vamos colocar '0' e não o zero decimal mesmo, porque estamos gravando uma string para mostrar na tela. Lógico que podia ser um vetor de int mas não seria útil. Usando char já pode imprimir o resultado.

 

        *display = (N&1) + '0';

'& 'é o operador lógico AND e N é o valor que temos, Então isso dá zero ou um conforme N seja par ou ímpar. E somado ao valor de '0' vai dar '0' ou '1' que é o que queremos. '0' é 48 e a gente podia usar mas seria frescura eu acho. Assim é mais fácil de ler,


E aí chamamos a rotina de novo e a vida continua.
 

        to_bin(--display, N>>1);

Só que antes de chamar o display anda para a esquerda ;) para não comer o dígito anterior. E o N divide por dois claro. Escrevi N>>1 porque tem a ver com o que estamos fazendo. '>>' é o operador de shift bit a direita em C e muitas outras linguagens. Deslocar um bit para a direita tem tudo a ver com a conversão para binário. Claro que é a mesma coisa que dividir por 2 e no fundo é o que o seu compilador faz quando vê uma divisão por dois se a otimização estiver habilitada. E em geral está.

 

E é isso: quando chegar a zero o if() passa e a função retorna.

 

adicionado 11 minutos depois

Em tempo: aquele seu código no início do tópico ficaria assim

    printf("Informe o valor binário que deseja converter da base 10 para base 2: ");
    scanf("%d", &Num1);
    strcpy(tela, zero); // zera o display: botao C
    to_bin(display, Num1);
    printf("%s = %d\n", tela, Num1);

Eis um programa assim

#define _CRT_SECURE_NO_WARNINGS
#include "limits.h"
#include "stdio.h"
#include "string.h"

int		to_bin(char*,int);

int main(int argc, char** argv)
{
	const char* zero = "                              0";
	char        tela[32];
	char*       display = tela + 30;
	int Num1;
	printf("Informe o valor binário que deseja converter da base 10 para base 2: ");
	scanf("%d", &Num1);
	strcpy(tela, zero); // zera o display: botao C
	to_bin(display, Num1);
	printf("%s = %d\n", tela, Num1);
	return 0;
}

int		to_bin(char* display, int N)
{
	if (N != 0)
	{
		*display = (N & 1) + '0';
		to_bin(--display, N >> 1);
	}; // if()
};	// bits()

:) 

Compartilhar este post


Link para o post
Compartilhar em outros sites

:)

 

adicionado 9 minutos depois

Uma implementação usando pilhas poderia ser

int		to_bin_pilha(char* display, unsigned N)
{
	unsigned guia = 1;
	int pilha = 0;
	do
	{	// push() empilha o valor, mas sao so bits
		pilha <<= 1;
		pilha = (pilha | (N & 1));
		guia <<= 1;
		N >>= 1;
	} while (N > 0);
	// terminou. agora pop() desempilha e mostra o valor
	char* p = display;
	while (guia > 1)
	{
		*p = (pilha & 1) + '0'; p++; // ja monta a string
		pilha >>= 1;
		guia >>= 1;
	};
	*p = 0;
	return 0;
};	// to_bin_pilha()

É muito mais rápida e barata que a versão recursiva. Não há necessidade de implementar as rotinas de push() e pop() mesmo porque na verdade a pilha é de bits e só de 31 então pode empilhar em um int. E já devolve a string pronta, alinhada a esquerda, pronta para o uso.

 

Uma versão usando loop

int		to_bin_loop(char* display, unsigned N)
{
	unsigned guia = INT_MIN;
	int pilha = 0, estado = 0;
	char* p = display;
	guia = INT_MIN;
	while (guia > 0)
	{
		if( estado  == 0)
		{
			if (N & guia)
			{	estado = 1;
				*p = '1';
				++p;
			}
		}
		else
		{	*p = '0' + ((N & guia) != 0);
			++p;
		};	// if
		guia >>= 1;
	};  // while
	*p = 0;
	return 0;
};

Essa é uma implementação ortodoxa usando um único lop. a mais rápida e mais barata das 3. Monta a string certinha e devolve em display.

 

Como testar?

void teste_as_3(unsigned teste)
{
	const char* zero = "                              0";
	char	display[32];
	strcpy(display, zero);
	display[31] = 0; // montado display, max 31 digitos
	char* inicio = display + 30;

	to_bin(inicio, teste); 
	printf("\n[R] %32s = %d\n", display, teste);
	strcpy(display, zero);
	to_bin_loop(display, teste);
	printf("[L] %32s = %d\n", display, teste);
	to_bin_pilha(display, teste);
	printf("[P] %32s = %d\n", display, teste);

};	// teste_as_3()

Essa função serve. Chama com

        teste_as_3(25);

mostra


[R]                            11001 = 25
[L]                            11001 = 25
[P]                            11001 = 25

Onde R L  P mostram os resultados da função recursiva, loop e pilha ...

Compartilhar este post


Link para o post
Compartilhar em outros sites

Crie uma conta ou entre para comentar

Você precisar ser um membro para fazer um comentário

Criar uma conta

Crie uma nova conta em nossa comunidade. É fácil!

Crie uma nova conta

Entrar

Já tem uma conta? Faça o login.

Entrar agora





Sobre o Clube do Hardware

No ar desde 1996, o Clube do Hardware é uma das maiores, mais antigas e mais respeitadas publicações sobre tecnologia do Brasil. Leia mais

Direitos autorais

Não permitimos a cópia ou reprodução do conteúdo do nosso site, fórum, newsletters e redes sociais, mesmo citando-se a fonte. Leia mais

×
×
  • Criar novo...

Aprenda_a_Ler_Resistores_e_Capacitores-capa-3d-newsletter.jpg

EBOOK GRÁTIS!

CLIQUE AQUI E BAIXE AGORA MESMO!