C++ Programa que lê um número inteiro e um dígito em estrutura de repetição

[Fernanderson_]

Me deparei com o seguinte problema de c++ da faculdade e gostaria de ajuda

eis o enunciado:

Faça um programa que lê um número inteiro e um dígito. O programa deve informar se o dígito aparece no número.

De entradas devem ter:

Uma entrada do número (int) e uma entrada do dígito (int).

Se o número conter o dígito o programa mostra '1'

caso contrário mostrará '0'

[Um mero usuário]

vou apenas para a parte principal, depois cuide dos detalhes

 

int vitima = 6789; //um valor aleatorio
int digitoVitima = 5; //leitura 1 (tem que dar 0)
int digitoVitima2 = 7; //leitura 2 (tem que dar 1)
int cache = 0; //usada para calculos apenas

cache = vitima % 10; //isso vai retornar a sobra da divisão por 10, guardando, no exemplo dado, o digito 9
if ((cache == digitoVitima) || (cache == digitoVitima2)) cout<<"1"; //usei cout, mas pode trocar por printf ou outra coisa
else
 {cache = vitima % 100; //extrai os ultimos 2 digitos (89)
  cache = cache - (vitima % 10); //subtrai o ultimo digito (80)
  cache = cache / 10; //divide por 10 (8)
  if ((cache == digitoVitima) || (cache == digitoVitima2)) cout<<"1";
  else
   {cache = vitima % 1000; //(789)
    cache = cache - (vitima % 100); //(700)
    cache = cache / 100; //(7)
    if ((cache == digitoVitima) || (cache == digitoVitima2)) cout<<"1";
    //e assim vai o ciclo, até dar todos os digitos... no fim, coloque:
    else cout<<"0";

esse é um projeto de teste, coloque dentro do "int main", declare as bibliotecas, feche os "{}", arrume direitinho aí

 

daqui para baixo é edit:

 

pode fazer o seguinte: coloque uma variavel para ser o segundo parametro da divisão por '%'

 

int vitima = 6789; //um valor aleatorio
int digito = 5; //leitura 1 (tem que dar 0)
int digito2 = 7; //leitura 2 (tem que dar 1)
int cache = 0; //usada para calculos apenas
int divisor = 10; //parte 2 da divisão
int contador = 0; //para o projeto não ficar rodando infinitamente, caso digito = "0"

cache = vitima % divisor;
volta:
if ((cache == digito) || (cache == digito2) cout<<"1";
    else
    {
     divisor = divisor*10;
     cache = vitima % divisor;
     cache = cache - vitima % (divisor/10);
     cache = cache / (divisor/10);
     if (contador <= 5) goto volta;
     else cout<<"0";
     return 0;
    }

//fica bem mais legivel assim o codigo né :)

[Midori]

@Fernanderson_ Para pegar o último algarismo de um numero inteiro é só calcular módulo do número por 10, p.ex,

 

int x = 12345;
int y = x % 10;

 

Assim y será 5 e no seu programa você teria que comparar essa variável com o dígito. Para pega os próximos é da mesma forma, mas você vai ter ir dividindo por 10 no loop para ficar 1234, 123, etc. Seu loop termina quando x <= 0.

[Um mero usuário]

16 minutos atrás, Midori disse:

@Fernanderson_ Para pegar o último algarismo de um numero inteiro é só calcular módulo do número por 10, p.ex,

 

int x = 12345;
int y = x % 10;

 

Assim y será 5 e no seu programa você teria que comparar essa variável com o dígito. Para pega os próximos é da mesma forma, mas você vai ter ir dividindo por 10 no loop para ficar 1234, 123, etc. Seu loop termina quando x <= 0.

raiva, agora que lembrei... adicione a linha "contador++;" no loop

[Midori]

@Um mero usuário Da forma que comentei não precisa de contador já que a variável x será dividida por 10 a cada ciclo e o loop é enquanto x > 0.

[Um mero usuário]

1 hora atrás, Midori disse:

@Um mero usuário Da forma que comentei não precisa de contador já que a variável x será dividida por 10 a cada ciclo e o loop é enquanto x > 0.

é, realmente... mas ainda sim eu gostei de meu codigo hahah... pelo menos para mim, dá uma sensação de organização

 

2 horas atrás, Midori disse:

Assim y será 5 e no seu programa você teria que comparar essa variável com o dígito. Para pega os próximos é da mesma forma, mas você vai ter ir dividindo por 10 no loop para ficar 1234, 123, etc. Seu loop termina quando x <= 0.

no caso teria que fazer "x = x - y" antes de dividir, né?

Edit: na verdade não, variavel int arredonda pra baixo