C Dividir resultado até ser igual a zero

[Usuário 3301]

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.

[herbertbahia]

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

[Usuário 3301]

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.

[herbertbahia]

#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);
	}
}

 

[Lucca Rodrigues]

@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;
}

 

[Usuário 3301]

@Lucca Rodrigues Perfeito!

[Lucca Rodrigues]

@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...

[Usuário 3301]

@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!

[Lucca Rodrigues]

@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.

[arfneto]

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

 

[arfneto]

 

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 ...