Maior numero palíndromo feito a partir do produto de dois números de 3 dígitos.

[Anatanael Barbosa]

Faça  um  programa  que  calcule  o  maior  número  palíndromo  feito  a  partir  do produto de dois números de 3 dígitos. Ex: O maior palíndromo feito a partir do produto de dois números de dois dígitos é 9009 = 91*99. 

 

Tentei multiplicar 100 x 100, 100 x 101, 100 x 102, ... ate 999 x 999 mas o numero de cálculos é grande demais. 

[isrnick]

Se quer encontrar o maior faça o contrário, comece pelos maiores números com 3 dígitos 999 x 999 e vá diminuindo ao invés de aumentando, 999 x 998, 999 x 997, etc até encontrar o primeiro palíndromo...

 

Fazer as multiplicações na ordem crescente realmente vai fazer muito cálculo até chegar no maior...

[Evandro]

Caro usuário,

 

Seja bem-vindo ao Fórum do Clube do Hardware.

 

No intuito de servir como fonte de pesquisa no caso de instituições de ensino, informamos que incorrer no resolvimento por completo de questões relacionadas a disciplinas escolares de cursos técnicos e faculdades podem ser revistas e removidas pela Equipe de Moderação do Clube do Hardware.

 

Para sanar dúvidas sobre esse tipo de problema, por gentileza, publique o passo a passo do desenvolvimento da questão, projeto, monografia ou conteúdo em dúvida para que possamos analisar se a resposta está correta ou não, ou para que possa ser auxiliado com a dúvida no desenvolvimento do exercício.

 

Infelizmente, não há como resolver os trabalhos pelos usuários. O objetivo do Fórum do Clube do Hardware é auxiliar seus usuários a encontrar soluções para que possam sanar suas dúvidas, e não de trazer soluções prontas para seus usuários.. Além disso, copiar e colar respostas que não são de autoria própria do qualquer usuário é considerado plágio, o que é ilegal.

 

Esperamos que compreenda.

 

Atenciosamente,

Equipe Clube do Hardware

[Anatanael Barbosa]

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

int main()
{
    // Todos os palindromos de 6 digitos
    int a, b, c;

    c = 99;
    for (a = 99; a >= 10; a--) {
        if (c < 0) {
            c = ((a % 10) * 10 + (a / 10));
        }
        for (b = 99; b >= 0; b -= 11) {
            printf("%d\n", a * 10000 + b * 100 + c);
        }
        c -= 10;
    }
    
    system("pause");
    return 0;
}

Aqui eu tenho todos os palíndromos de 6 dígitos, porém não acho uma forma de verificar se o número é formado por uma multiplicação de dois números de 3 dígitos cada.

[isrnick]

Eu postei uma solução pra esse mesmo problema nesse outro tópico:

 

[Anatanael Barbosa]

22 horas atrás, isrnick disse:

Eu postei uma solução pra esse mesmo problema nesse outro tópico:

 

 

Muito obrigado, com sua solução consegui resolver o exercicio.

 

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

int main()
{
    int num1, num2, prod, numInverso = 0, temp, quantDig = 0, cifra, maiorPalindromo = 0, fatorMaior1, fatorMaior2;

    /*
        num1 -> 1º Numero de tres digitos
        num2 -> 2º Numero de tres digitos
        prod -> Produto entre o 1º e 2º numeros
        temp -> Temporaria utilizada para contagem de digitos do produto e para inverter o produto
        quantDig -> Quantidade de digitos do produto
        cifra -> Um algarismo do produto (Utilizada para inverter o produto)
        maiorPalindromo -> O maior palindromo formado pelo produto
        fatorMaior1 e fatorMaior2 -> Sao os fatores que resultam no maior numero palindromo

    */

    for (num1 = 999; num1 >= 100; num1--) {
        for (num2 = num1; num2 >= 100; num2--) {
            prod = num1 * num2;

            if (prod > maiorPalindromo) {
                // Contagem de digitos do produto
                temp = prod;
                while (temp != 0) {
                    quantDig++;
                    temp /= 10;
                }

                // Inversao do produto
                temp = prod;
                numInverso = 0;
                while(temp != 0) {
                    cifra = temp % 10;
                    numInverso += cifra * pow(10, quantDig - 1);
                    temp /= 10;
                    quantDig--;
                }

                // Comparacao se eh um numero palindromo
                if (prod == numInverso) {
                    maiorPalindromo = numInverso;
                    fatorMaior1 = num1;
                    fatorMaior2 = num2;
                }
            }
        }
    }

    printf("O maior palindromo eh formado pela multiplicacao de %d x %d = %d\n\n", fatorMaior1, fatorMaior2, maiorPalindromo);

    system("pause");
    return 0;
}

 

[isrnick]

Essa seria minha versão para fazer apenas o mínimo de operações necessárias para encontrar o maior número palíndromo:

#include <stdio.h>

int main()
{
    int i = 999,  //contador
        j,        //contador
        n,        //numero calculado
        t,        //numero temporario
        ni,       //numero invertido
        im,       //i do MNC
        jm,       //j do MNC
        mnc = 0;  //maior numero capicua
    for (n = i * i; n > mnc; n = i * i){
        for (j = i; n > mnc; n = i * j){
            ni = 0;
            //inverte o número:
            for (t = n; t > 0; t /= 10){
                ni = ni * 10 + t % 10;
            }
            //Se for capicua guarda como sendo o novo MNC:
            if (n == ni) {
                    mnc = n;
                    im = i;
                    jm = j;
            }
            j--;
        }
        i--;
    }
    printf("Maior numero capicua: %d = %d x %d\n", mnc, im, jm);
    return 0;
}

 

Aqui a diferença em relação ao meu programa original é que a contagem dos multiplicadores é regressiva, e também para de procurar o maior palíndromo assim que determinar que as próximas multiplicações sempre vão resultar em números menores que o maior palíndromo encontrado até o momento.

[Anatanael Barbosa]

19 horas atrás, isrnick disse:

Essa seria minha versão para fazer apenas o mínimo de operações necessárias para encontrar o maior número palíndromo:

#include <stdio.h>

int main()
{
    int i = 999,  //contador
        j,        //contador
        n,        //numero calculado
        t,        //numero temporario
        ni,       //numero invertido
        im,       //i do MNC
        jm,       //j do MNC
        mnc = 0;  //maior numero capicua
    for (n = i * i; n > mnc; n = i * i){
        for (j = i; n > mnc; n = i * j){
            ni = 0;
            //inverte o número:
            for (t = n; t > 0; t /= 10){
                ni = ni * 10 + t % 10;
            }
            //Se for capicua guarda como sendo o novo MNC:
            if (n == ni) {
                    mnc = n;
                    im = i;
                    jm = j;
            }
            j--;
        }
        i--;
    }
    printf("Maior numero capicua: %d = %d x %d\n", mnc, im, jm);
    return 0;
}

 

Aqui a diferença em relação ao meu programa original é que a contagem dos multiplicadores é regressiva, e também para de procurar o maior palíndromo assim que determinar que as próximas multiplicações sempre vão resultar em números menores que o maior palíndromo encontrado até o momento.

 

Quando encontra um numero palíndromo testa com o produto de i * j, se o produto for menor então sair do loop. Entendi, excelente resolução.

 

Muito obrigado pela ajuda!