LuanCeli

Bom dia, Clube do Hardware.

Galera, estou aprendendo a utilizar a recursividade, porém existem nós na minha cabeça na construção dos meus algoritmos em torno dessa ferramenta. A saber, estou tentando resolver o seguinte problema:

DESCRIÇÃO:

Considere o seguinte algoritmo para gerar uma sequência de números. Comece com um inteiro n. Se n for par, divida por 2. Se n for ímpar, multiplique por 3 e some 1. Repita esse processo com o novo valor de n, terminando quando n = 1. Por exemplo, a seguinte sequência de números será gerada quando n é 22:

22 11 34 17 52 26 13 40 20 10 5 16 8 4 2 1

Embora ainda não exista uma prova, os matemáticos acreditam que esse algoritmo sempre termina com n=1, para qualquer inteiro n. Bem, para este problema aqui no Huxley, essa propriedade se mantém para qualquer inteiro menor que 1.000.000.

Para uma entrada n, o "tamanho do ciclo" de n é a quantidade de números gerados até o 1 (incluindo o próprio 1). No exemplo acima, o "tamanho do ciclo" de 22 é 16. 

Dado dois números i e j, determine o máximo "tamanho do ciclo" dentre todos os números entre i e j, incluindo tanto i quanto j.

ENTRADA:

A entrada consiste de uma série de pares de inteiros i e j, um par de inteiros por linha. Todos os inteiros serão menores que 1.000.000 e maiores que 0.

Perceba que a entrada só termina quando não houveram mais números. Descubra como fazer o seu programa funcionar nesse caso. Cada linguagem tem uma forma diferente de ler enquanto ainda houver entrada a ser lida.

SAÍDA:

Para cada par de inteiros i e j, imprima i e j na mesma ordem na qual eles aparecem na entrada e então imprima o máximo "tamanho de ciclo" encontrado. Esses 3 números devem ser separados por um espaço, com todos os 3 números em uma linha e sendo uma linha de saída para cada linha da entrada.

Veja o arquivo de exemplo para entender melhor o formato da entrada e da saída.

Bem, a lógica eu entendi. Já resolvi o problema no papel e agora eu busco a construção do código.

Eu fragmentei a resolução do meu problema baseado nas seguintes dúvidas que tenho:

1. Como definir a leitura dos números entre i e j?

2. Como definir a contagem desses números entre i e j para que meu código possa calcular número por número de maneira recursiva?

3. Como definir no meu código qual número entre i e j me deu o maior número de resultados?

4. Como imprimir a quantidade de resultados máximos no tamanho do ciclo?

Bom, acho que essas são as minhas principais dúvidas. Não sei se de fato essa fragmentação do problema que relatei é lógica na construção desse algoritmo, mas são as dúvidas que me passam na cabeça quando estou tentando resolver.

Gostaria de pedir a ajuda em especial do @isrnick e @Simon Viegas que foram bem atenciosos e prestativos na resolução do meu último problema.

Obrigado.

Bom dia!

Então, desculpem a demora na repostagem, eu conclui o exercício já faz algum tempo. Estou passando para agradecer.

Bom, @Simon Viegas pesquisei sobre o teste de mesa, muito obrigado por me apresentar a ferramenta ela com certeza vai me ajudar a implementar minha lógica. O esboço do seu código me permitiu entender minhas falhas.

Estudei um pouco mais e percebi que incrementar o conceito de resto dentro do meu código foi essencial no entendimento da coisa, assim como proposto pelo @isrnick. 

Meu código está completamente funcional.

#include <stdio.h>



int main() 
{   
    
    int N, A, B, multiploN;

    scanf("%d%d%d",&N, &A, &B);
    multiploN = 0;
    
    while (B >= A)
    {
        
        if (A % N == 0)
        {
            multiploN = 1;
            printf("%d\n", A);
        }
        A += 1;
        
    }
    
    if(!multiploN)
        printf("INEXISTENTE\n");
    
    return 0;
}

Vocês não sabem a felicidade que foi concluir essa atividade, mesmo sendo fácil aos olhos de muitos pra mim foi como derrotar um dragão na faca de serra, mas é isso ai a realização de conseguir foi ímpar.

Espero contar com a ajuda de vocês nas próximas, obrigado.

Boa tarde!  

Antes de mais nada eu agradeço a ambos que dispuseram do seu tempo para tentar iluminar as minhas ideias, elas definitivamente foram úteis a sua maneira. Infelizmente não consegui ainda o resultado esperado, passei mais um tempo pesquisando e tentando formular o algoritmo que agora acredito que o problema seja mais na construção. 

Em 11/01/2019 às 09:43, isrnick disse:

Um número n1 é múltiplo de outro número n2 se o resto da divisão inteira n1 / n2 é igual a zero.

 

Em C utiliza-sem o operador % para calcular o resto da divisão inteira, logo basta verificar se n1 % n2 é igual a zero para verificar se o n1 é múltiplo de n2.

Eu tentei buscar uma forma de utilizar o operador %, porém sem sucesso. Então tentei abstrair as ideias da maneira que @Simon Viegas propôs e diga-se de passagem que foi uma das melhores explicações para uma construção lógica que me permiti fazer, utilizei de um papel, fiz a resolução do problema da maneira humana e a partir de então percebi a facilidade na tradução para máquina. Essa foi a minha resolução:  
https://ibb.co/SwJPMgv

A partir de então passei a pesquisar sobre a construção do algoritmo, e ele ficou assim: 
 

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

int main() 

{
    int count, count2, num, num2, multiplo, multiplo2, maior, menor;
    scanf("%d%d", &num, &num2);
    if (num2 < num)
    {
        maior = num;
        menor = num2;
    }
    else
    {
        maior = num2;
        menor = num;
    }
    multiplo = menor; 
    multiplo2 = maior;
    
    
    
    while(multiplo != multiplo2)
    {
        multiplo = menor*count;
    }
   	while (multiplo > multiplo2)
    {
        multiplo2 = maior*count2;
        count2++;
    }
    
    printf("%d", multiplo);
	return 0;
}

Eu primeiramente pensei em ordenar os números que o usuário utilizará, logo depois tentei utilizar do while pra gerar um tipo de laço para que fosse balanceado o cálculo afim de encontrar o múltiplo e determinar a parada do algoritmo, porém não consegui a saída esperada.  
Vocês poderiam me ajudar nessa parte, pois já tentei exaustivamente e não consegui.  

Boa noite, comunidade. Galera, eu to aprendendo a programar, optei por C por sua clássica estrutura de construção de algoritmos e assim no futuro facilitar meu aprendizado nas demais linguagens. Estou com dificuldades lógica no entendimento desse exercício: 

[Descrição]

Escrever programa para exibir os múltiplos de N contidos entre os valores A e B, sendo N, A e B definidos pelo utilizador.

[Entrada]

Três valores inteiros.  Cada um em uma linha distinta.  O primeiro valor, N,  corresponde ao número do qual se deseja verificar se há múltiplos.  Os outros dois valores, A e B inclusivos, correspondem aos limites do intervalo de valores a serem validados como múltiplos ou não de N. 

[Saída]

Valores contidos entre A e B, que sejam múltiplos de N.

Caso não haja múltiplos de N, entre A e B, exibir: INEXISTENTE.

Não precisa deixar tudo mastigadinho, só gostaria do máximo de ajuda possível para construir a lógica desse algoritmo. 

Abraços.