C Exercicio Iniciante em C

LuanCeli · 11 de janeiro de 2019

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.

isrnick · 11 de janeiro de 2019

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.

Simon Viegas · 11 de janeiro de 2019

@LuanCeli, vou tentar explicar (de uma forma mais prolixa) da forma que entendi...

Antes tudo: inicialmente esqueça que é algo voltado para programação. Entenda o problema em si... como algo do mundo real (e não que você precisa "criar um programa"), ou seja, que vai fazer na mão, como utilizando papel, lápis e calculadora etc. Antes de qualquer coisa, entenda o problema. Essa é a chave!

O quê que o enunciado está propondo?

Pelo que eu entendi: ele quer os múltiplos de N que estão contidos entre A e B (inclusos). Perceba que uma das etapas está na "interpretação de texto". É simplesmente entender o que se quer.

Está relativamente objetivo, veja:

12 horas atrás, LuanCeli disse:

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

Exemplo:

N = 7
A = 10
B = 50

12 horas atrás, LuanCeli disse:

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

Teria como resultado:

14, 21, 28, 35, 42 e 49

Já conseguiu ENTENDER O PROBLEMA? Se sim, beleza. Se não, tire as suas dúvidas postando aqui. (obs.: eu posso ter entendido errado, mas vamos pressupor que estou certo...)

Imagine que foi uma questão do Enem. Como você faria para encontrar a resposta? Foi dado como entrada N=6, A=27 e B=48. Qual a saída? Você está lá com a questão na sua frente... "precisa" responder... e aí? Bota mão na massa!

Então, no meu caso, fui meio que no automático (possivelmente por já ter tido contato com problemas semelhantes). Imaginei mais ou menos o que precisava (estou evitando spoiler) e fui achando os valores.

A minha sugestão é você também imaginar se deparando com essa questão... tente achar os resultados do exemplo que dei acima.

Após, vem a questão do tal algoritmo, ou seja, criar o passo a passo genérico para quaisquer números inteiros (válidos para o contexto, é claro).

"Como (mais ou menos) fez para chegar a esse algoritmo?" (vamos supor que achou e achou corretamente).

Veja, existem diversas formas que achar uma resposta!!! no caso, para esse contexto, só existe uma reposta correta (será sempre um conjunto de números específicos), concorda? entretanto, tecnicamente falando, existem infinitas formas para achar esse resultado, ou seja, o seu futuro algoritmo em C será uma das dessas possibilidades possíveis para achar os valores da saída.

@isrnick pode está sugerindo achar de uma forma (que envolve cálculos e verificações de múltiplos), eu imaginei de outra (que sei que segue outro caminho, pois não fiz utilizando dessa forma), assim como você pode achar uma terceiro outro caminho completamente diferente. E todos podem trazer a saída correta! (não entrando na questão da eficiência [seu custo], mas sim no sentido de sua eficácia [resultado]., ou seja, são infinitas formas de cegar a o único resultado correto, nesse contexto).

Não se preocupe com perfeição ou descrever os mínimos detalhes... é para ser apenas um esboço de algoritmo.

Minha sugestão:

- Resolva o exemplo dado: tendo como entrada N=6, A=27 e B=52, qual o valor da saída? o que importa aqui é resultado!

- Após, tente entender e descrever os passos que seguiu para achar a resposta. A dica é a seguinte: descreva de uma forma que uma terceira pessoa, que seguindo os passos que você descreveu, conseguiria chegar ao resultado correto. Mas em fim, de uma forma bem superficial mesmo... é só para ter uma base de como faria.

- Posta aqui para analisarmos.

- Chegando um algoritmo viável, ajudamos a converter para linguagem do C. Veja, de certo modo, aqui as possíveis dúvidas estariam mais relacionadas com a sintaxe, ou seja, a lógica em si já estaria pronta... será basicamente uma "tradução". Esse mesmo algoritmo que você descreveria, servia para uma outra linguagem qualquer*.

OU

Se já tem uma base do que quer fazer, além de descrever o que o algoritmo irá fazer, já implementa em C. Posta a descrição e o código para analisarmos.

OBSERVAÇÃO:

Podemos abstrair que são duas partes: [1] o que você quer implementar, ou seja, já ter uma ideia do que precisa fazer; e [2] implementar isso que eu já definiu, ou seja, conseguir traduzir para C.

Pelo que você postou, entendi que está com dificuldade no [1].

Só reforçando:

Você precisaria entender como você poderia resolver esse problema... por exemplo, se em determinada parte do seu algoritmo, você precisasse saber se um número é divisível por outro, poderia surgir um sub-problema: "como sei se um número é divisível por outro ou não?". Isso por enquanto é secundário... seria "destrinchar" a etapa... subentenda que sabe verificar... no momento oportuno, se fosse o caso, buscaria uma tentativa de solução para isso... e, nesse caso, por exemplo, poderia tentar usar como base a explicação:

4 horas atrás, 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.

Entende? na criação de uma algoritmo do problema geral (achar os tais múltiplos lá da faixa), poderia surgir a necessidade de utilizar uma lógica de um algoritmo para uma parte (saber se um número é divisível ou não) desse algoritmo maior. Tente fazer essa abstração!!! Tipo... num futuro problema qualquer ainda mais complexo, poderia existir a possibilidade de justamente precisar de encontrar [3] "os múltiplos dentro de uma faixa". Lá, essa etapa não seria destrinchada.. você simplesmente entenderia que precisaria dessa "saída" e que iria conseguir... iria utilizar ela e tal... ao implementar o código, necessitando destrinchar o [3], poderia surgir outro sub-sub-problema lá da "se é múltiplo ou não", saca?. E vai indo. Por isso que no início, é bom ir tendo contatos com problemas mais simples mesmo... daí verás que um problema mais complexo, tente mais facilmente a ser visto como um conjunto desses problemas mais simples.

No possível algoritmo que venha a tentar descrever, você não necessariamente já precisaria descrever como iria verificar se um número é múltiplo de outro ou não, apenas poderia dizer, por exemplo: "bla bla bla verifico se bla bla bla é múltiplo de bla bla bla e depois bla bla bla..". Não precisa descrever como se verificar um múltiplo nesse momento.

No aguardo.

LuanCeli · 14 de janeiro de 2019

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.

isrnick · 14 de janeiro de 2019

Eu consigo pensar em 2 maneiras:

A primeira seria pegar cada número entre A e B e testar se é um múltiplo de N. Pra isso bastaria fazer uma variável começar igual a A, e usar um ciclo para ir testando se o número atual é múltiplo de N (se é múltiplo imprime o número), e depois soma +1 a variável para obter o próximo número, continua no ciclo até a variável chegar no valor B. Nesse caso iria usar o método que eu mencionei para fazer o teste.

A segunda maneira seria ir obtendo os múltiplos de N e checar se o múltiplo atual está entre A e B. Pra isso poderia fazer uma variável começar com valor N, e dentro de um ciclo ir testando se o valor da variável está entre A e B (se estiver imprime o múltiplo), e depois ir somando +N na variável para obter o próximo múltiplo de N, e continua no ciclo enquanto o múltiplo atual for menor ou igual a B.

Simon Viegas · 15 de janeiro de 2019

Vamos lá:

Sobre:

9 horas atrás, LuanCeli disse:


    int count, count2, num, num2, multiplo, multiplo2, maior, menor;

Se o enunciado fala em "N", "A" e "B", porque usar num, maior, menor etc?

Prefira nomenclaturas mais sugestivas. Mais a baixo dou exemplo...

Sobre:

9 horas atrás, LuanCeli disse:


    if (num2 < num)
    {
        maior = num;
        menor = num2;
    }
    else
    {
        maior = num2;
        menor = num;
    }

Não precisa efetuar validações por enquanto... De qualquer forma, acho que não seria válido. Os valores são lidos em sequência... N, A e B. Essa "otimização", por exemplo, seria implementada se fosse explicitada no enunciado... Talvez o que você poderia implementar seria dizer algo como "O valor de B deve ser maior ou igual ao valor de A" etc. Mas em fim... ignore isso... suponha dados perfeitos. O enunciado não fala de "validações". Se quiser, deixe isso após ter um código funcional.

Sobre:

9 horas atrás, LuanCeli disse:


    while(multiplo != multiplo2)
    {
        multiplo = menor*count;
    }

Aqui temos uma falha na implementação da lógica, ou seja, supondo que o quê você implementou no papel esteja correto, a tradução ficou errada... veja... menor e cout não estão sendo alteradas dentro do while, logo, o resultado desta conta sempre será a mesmo!!! vai entrar em loop infinito. Outro pronto é a condição: você definiu com "!=", ou seja, como é uma multiplicação, é bem provável que nunca seja igual... logo, também podendo entrar em loop infinito..

Poderia utilizar algo assim:

    count=1;
    while(multiplo < multiplo2)
    {
        multiplo = menor*count;
        count++;
    }

De qualquer forma, as variáveis usadas estão incompletas... falta o N ai no bolo. Resumidamente poderia ficar com algo assim:

#include <string.h>
#include <stdlib.h>
int main() 
{
    int N, A, B;
    int multiplo;
    int cont;

    scanf("%d", &N);
    scanf("%d", &A);
    scanf("%d", &B);   
    
    multiplo = N;
    cont = 0;
    while(multiplo < A)
    {
        multiplo = N*cont;
        cont++;
    }
    
    while (multiplo < B)
    {
        printf("%d ", multiplo);
        multiplo = N*cont; 
        cont++;
    }
    
    return 0;
}

Pronto! um código pronto!!! Eba!!

Será???

O que ser poderia fazer agora é testes de mesas... eu não sei explicar muito bem (dá um Google e/ou aguardar explicar melhor ), mas seria basicamente tentar definir as categorias de possibilidades e testar... por exemplo:

Se colocar N maior que A e menor que B;

Se colocar N maior que A e B;

Se colocar N igual a A e diferente de B;

Se colocar N igual a B e diferente de A;

Se colocar os 3 valores iguais?

Se colocar N igual a 0;

etc

Tem que testar as possibilidades e ir corrigindo.

obs.: essas possibilidades se referem a lógica do problema em si. Aqui para cada tipo de entrada, terá que daá a saída correta... alguns dos testes vão dar o tal "INEXISTENTE"... tem que implementar isso.

A forma que pensei foi assim:

Sobre:

Em 11/01/2019 às 13:46, Simon Viegas disse:

Minha sugestão:

- Resolva o exemplo dado: tendo como entrada N=6, A=27 e B=52, qual o valor da saída? o que importa aqui é resultado!

Lá no rascunho eu faria:

N=6 A=27 B=52 //anoto o que preciso

[analisando] tá! o que eu preciso fazer agora? hum! vou encontrar o primeiro múltiplo da lista e ir escrevendo[/analisando]

0, 6, 12, 18, 24, 30 //<--- num cantinho do papel, encontro o primeiro múltiplo que esteja na faixa

30, 36, 42, 48, 54 //começo a escrever a sequência... esse último não escreveria, pois saberia após fazer a conta, que é maior que 52. Deixei só para ilustrar.

A resposta é: 30, 36, 42 e 48. //tenho um certo grau de certeza... esses valores estão batendo pra mim..

FIM

Veja! não tem nada de programação nessa abordagem... o que estava propondo seria apenas conseguir resolver o problema mesmo.

Sobre:

Em 11/01/2019 às 13:46, Simon Viegas disse:

- Após, tente entender e descrever os passos que seguiu para achar a resposta. A dica é a seguinte: descreva de uma forma que uma terceira pessoa, que seguindo os passos que você descreveu, conseguiria chegar ao resultado correto. Mas em fim, de uma forma bem superficial mesmo... é só para ter uma base de como faria.

Algo como:

Encontre o primeiro múltiplo de N que é igual ou maior que A... para isso, poderia pegar o valor de N e ir somando o com o próprio valor de N até satisfazer essa condição. Esse valor encontrado será o primeiro número da sequência. Para o restante, basta ir somando ~~ao mesmo~~ a ele o valor de N e anotando... isto enquanto o resultado for menor ou igual a B.

Então, não precisa ser nada rebuscado... é só uma tentativa de descrição mesmo...

Sobre:

Em 11/01/2019 às 13:46, Simon Viegas disse:

- Posta aqui para analisarmos.

- Chegando um algoritmo viável, ajudamos a converter para linguagem do C. Veja, de certo modo, aqui as possíveis dúvidas estariam mais relacionadas com a sintaxe, ou seja, a lógica em si já estaria pronta... será basicamente uma "tradução". Esse mesmo algoritmo que você descreveria, servia para uma outra linguagem qualquer*.

Após alinharmos o entendimento do que se quer fazer, ou seja, que estaríamos com uma lógica viável, traduziríamos para linguagem escolhida, ex.:

Em C :

Criando um esboço:

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int main() 
{
    //ler os valores de N, A e B

    //encontrar o primeiro número da lista
    
    //gerar lista
  
    //exibir o resultado
    
    return 0;
}

Implementando:

#include <stdio.h>
int main() 
{   
    //ler os valores de N, A e B
    int N, A, B;
    printf("Digite os valores de ENTRADA\n");
    printf("N = "); scanf("%d",&N);
    printf("A = "); scanf("%d",&A);
    printf("B = "); scanf("%d",&B);
    
    //encontrar o primeiro número da lista
    int multiploN = 0;
    while (multiploN < A)
    {
        multiploN+=N;
    }
    
    //gerar lista em si e exibir o resultado
    while (multiploN < B)
    {
        printf("%d ",multiploN);
        multiploN+=N;
    }

    return 0;
}

A lógica foi bem parecida... apenas que pensei em ir somando, em vez de multiplicar valores...

obs.: esse código também precisaria fazer os testes de mesa e efetuar as devidas correções.

RESUMINDO:
Tente fazes os testes de mesa e ajuste o código de acordo com o enunciado.

PS: a lógica utilizando divisores também é viável, mas aí podemos deixar para depois.

No aguardo.

luizmatheusz · 17 de janeiro de 2019

Bom dia. Primeiramente declarar as variáveis A, B, N e duas auxiliares (uma para um futuro for, e outra para ajudar a dar o printf no INEXISTENTE) que podem ser chamadas de b e c. Atribuir o valor 0 para c. Usar o scanf em cada uma das três primeiras variáveis. Depois, criar um laço de repetição for com b dentro, para que b seja igual a A e vá incrementando até B, e ir testando para cada valor, se o resto de b por N é 0: se sim, atribua o valor 1 a variável c, e dê um printf no b com uma quebra de linha;

Ao final do laço de repetição, faça uma condição: se o valor de c for 0 (significando que não houveram valores entre A e B sendo múltiplos de N, pois se houvessem o valor de c seria 1), printf INEXISTENTE, e quebra de linha.

Espero ter ajudado.

LuanCeli · 21 de janeiro de 2019

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.