Crie um algoritmo e um programa que solicite ao usuário digitar dois números inteiros. O programa deverá verificar se estes números são múltiplos entre si. O programa deve mostrar na tela uma das seguintes mensagens “São múltiplos” ou “Não são múltiplos”.

Fala galera da programação, tudo beleza?

Hoje vamos fazer um exercício com números múltiplos.

O que são números múltiplos?

Números múltiplos são números que podem ser obtidos multiplicando-se um número inteiro por outro. Em outras palavras, um número é considerado um múltiplo de outro se puder ser dividido por esse outro número sem deixar resto.

Por exemplo:

• 6 é um múltiplo de 2, pois 6 dividido por 2 é igual a 3, sem resto.
• 15 é um múltiplo de 5, pois 15 dividido por 5 é igual a 3, sem resto.
• 9 é um múltiplo de 3, pois 9 dividido por 3 é igual a 3, sem resto.

Em resumo, se ao dividirmos um número (denominado “a”) por outro número (denominado “b”) e o resto da divisão for igual a zero, então “a” é um múltiplo de “b”.

Dicas do exercício

Para realizar esta verificação, devemos dividir os dois números entre si e verificar se o resto da divisão é igual a zero.

Exemplo de saída: se o usuário informar os números 3 e 21, a mensagem “ São múltiplos” deverá ser mostrada na tela. Se o usuário informar os números 5 e 7, a mensagem “ Não são múltiplos” deverá ser mostrada na tela.

Outro ponto importante é que para resolver este problema, duas divisões devem ser realizadas. No primeiro exemplo, devemos dividir 3/21 e 21/3. Se uma das duas divisões resultar em resto zero (21/3), então os dois números serão múltiplos.

Vamos aos códigos!

Exemplo em C++

/******************************************************************************

Criado pelo Professor Giovani Da Cruz
https://giovanidacruz.com.br

*******************************************************************************/
#include <iostream>

using namespace std;

int main() {
    int num1, num2;

    // Solicita ao usuário que digite dois números inteiros
    cout << "Digite o primeiro número inteiro: ";
    cin >> num1;
    cout << "Digite o segundo número inteiro: ";
    cin >> num2;

    // Verifica se os números são múltiplos entre si
    if (num1 % num2 == 0 || num2 % num1 == 0) {
        cout << "São múltiplos" << endl;
    } else {
        cout << "Não são múltiplos" << endl;
    }

    return 0;
}

A estratégia utilizada foi bastante direta e baseada na definição de múltiplos. Aqui está uma explicação passo a passo:

1. Entrada de dados: O programa solicita ao usuário que insira dois números inteiros, armazenando esses valores nas variáveis num1 e num2.
2. Verificação de múltiplos: O programa verifica se os números são múltiplos entre si. Isso é feito verificando se o resto da divisão de num1 por num2 é zero OU o resto da divisão de num2 por num1 é zero. Se uma dessas condições for verdadeira, então os números são múltiplos um do outro.
3. Saída de mensagem: Dependendo do resultado da verificação, o programa exibe a mensagem “São múltiplos” ou “Não são múltiplos” na tela.

Exemplo em C

/******************************************************************************

Criado pelo Professor Giovani Da Cruz
https://giovanidacruz.com.br

*******************************************************************************/
#include <stdio.h>

int main() {
    int num1, num2;

    // Solicita ao usuário que digite dois números inteiros
    printf("Digite o primeiro número inteiro: ");
    scanf("%d", &num1);
    printf("Digite o segundo número inteiro: ");
    scanf("%d", &num2);

    // Verifica se os números são múltiplos entre si
    if (num1 % num2 == 0 || num2 % num1 == 0) {
        printf("São múltiplos\n");
    } else {
        printf("Não são múltiplos\n");
    }

    return 0;
}

Neste código em C, os comandos printf e scanf são usados para entrada e saída, respectivamente. A lógica para verificar se os números são múltiplos é a mesma que foi explicada anteriormente para o código em C++.

Exemplo em Pascal / Delphi / Lazarus

(**************************************

Criado pelo Professor Giovani Da Cruz
https://giovanidacruz.com.br

***************************************)
program VerificarMultiplos;

var
  num1, num2: Integer;

begin
  // Solicita ao usuário que digite dois números inteiros
  Write('Digite o primeiro número inteiro: ');
  Readln(num1);
  Write('Digite o segundo número inteiro: ');
  Readln(num2);

  // Verifica se os números são múltiplos entre si
  if (num1 mod num2 = 0) or (num2 mod num1 = 0) then
    Writeln('São múltiplos')
  else
    Writeln('Não são múltiplos');
end.

Neste código em Pascal, utilizamos os comandos Write e Readln para entrada e saída de dados, respectivamente. A lógica para verificar se os números são múltiplos é a mesma usada nos exemplos anteriores.

Exemplo em Python

'''

Criado pelo Professor Giovani Da Cruz
https://giovanidacruz.com.br

'''
# Solicita ao usuário que digite dois números inteiros
num1 = int(input("Digite o primeiro número inteiro: "))
num2 = int(input("Digite o segundo número inteiro: "))

# Verifica se os números são múltiplos entre si
if num1 % num2 == 0 or num2 % num1 == 0:
    print("São múltiplos")
else:
    print("Não são múltiplos")

Neste código em Python, usamos a função input() para obter a entrada do usuário e int() para converter essa entrada em números inteiros. Em seguida, verificamos se os números são múltiplos entre si usando a mesma lógica explicada anteriormente. Por fim, exibimos a mensagem correspondente na tela usando print().

Exemplo em C# / C Sharp

/******************************************************************************

Criado pelo Professor Giovani Da Cruz
https://giovanidacruz.com.br

*******************************************************************************/
using System;

class Program
{
    static void Main()
    {
        int num1, num2;

        // Solicita ao usuário que digite dois números inteiros
        Console.Write("Digite o primeiro número inteiro: ");
        num1 = Convert.ToInt32(Console.ReadLine());
        Console.Write("Digite o segundo número inteiro: ");
        num2 = Convert.ToInt32(Console.ReadLine());

        // Verifica se os números são múltiplos entre si
        if (num1 % num2 == 0 || num2 % num1 == 0)
        {
            Console.WriteLine("São múltiplos");
        }
        else
        {
            Console.WriteLine("Não são múltiplos");
        }
    }
}

Neste código em C#, utilizamos Console.Write() e Console.ReadLine() para obter a entrada do usuário e Convert.ToInt32() para converter essa entrada em números inteiros. Em seguida, verificamos se os números são múltiplos entre si usando a mesma lógica explicada anteriormente. Por fim, exibimos a mensagem correspondente na tela usando Console.WriteLine().

Exemplo em Java

/******************************************************************************

Criado pelo Professor Giovani Da Cruz
https://giovanidacruz.com.br

*******************************************************************************/
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int num1, num2;

        // Solicita ao usuário que digite dois números inteiros
        System.out.print("Digite o primeiro número inteiro: ");
        num1 = scanner.nextInt();
        System.out.print("Digite o segundo número inteiro: ");
        num2 = scanner.nextInt();

        // Verifica se os números são múltiplos entre si
        if (num1 % num2 == 0 || num2 % num1 == 0) {
            System.out.println("São múltiplos");
        } else {
            System.out.println("Não são múltiplos");
        }

        scanner.close();
    }
}

Neste código Java, utilizamos a classe Scanner para obter a entrada do usuário. Em seguida, verificamos se os números são múltiplos entre si usando a mesma lógica explicada anteriormente. Por fim, exibimos a mensagem correspondente na tela usando System.out.println().

Exemplo em Rust

/******************************************************************************

Criado pelo Professor Giovani Da Cruz
https://giovanidacruz.com.br

*******************************************************************************/
use std::io;

fn main() {
    let mut num1 = String::new();
    let mut num2 = String::new();

    // Solicita ao usuário que digite dois números inteiros
    println!("Digite o primeiro número inteiro: ");
    io::stdin().read_line(&mut num1)
        .expect("Falha ao ler o número");

    println!("Digite o segundo número inteiro: ");
    io::stdin().read_line(&mut num2)
        .expect("Falha ao ler o número");

    let num1: i32 = num1.trim().parse().expect("Por favor, insira um número inteiro válido");
    let num2: i32 = num2.trim().parse().expect("Por favor, insira um número inteiro válido");

    // Verifica se os números são múltiplos entre si
    if num1 % num2 == 0 || num2 % num1 == 0 {
        println!("São múltiplos");
    } else {
        println!("Não são múltiplos");
    }
}

Neste código em Rust, usamos o pacote padrão std::io para lidar com entrada e saída de dados. A lógica para verificar se os números são múltiplos entre si é a mesma explicada anteriormente. Por fim, exibimos a mensagem correspondente na tela usando println!().

O que podemos aprender neste exercício?

Neste exercício, podemos aprender alguns conceitos e práticas importantes:

1. Entrada e saída de dados: Aprendemos como solicitar entrada de dados do usuário e exibir mensagens na tela, usando diferentes métodos dependendo da linguagem de programação utilizada. Em cada linguagem, há uma maneira específica de fazer isso, como por exemplo, scanf e printf em C, cin e cout em C++, input() e print() em Python, Console.ReadLine() e Console.WriteLine() em C#, Read e Write em Pascal, e Scanner, e System.out.println() em Java.
2. Operadores matemáticos: Entendemos como usar operadores matemáticos para realizar cálculos e verificar relações entre números. No caso deste exercício, utilizamos o operador de módulo (%) para calcular o resto da divisão entre dois números, permitindo-nos verificar se um número é múltiplo do outro.
3. Estruturas condicionais: Vimos como usar estruturas condicionais (como if-else em todas as linguagens) para tomar decisões com base em determinadas condições. Isso nos permitiu determinar se os números fornecidos pelo usuário são múltiplos um do outro e exibir mensagens correspondentes de acordo com o resultado.
4. Lógica de programação: Este exercício nos desafiou a pensar logicamente sobre como resolver o problema proposto. A lógica para verificar se dois números são múltiplos entre si é simples, mas requer uma compreensão clara dos conceitos matemáticos subjacentes e das estruturas de programação necessárias para implementá-la.
5. Flexibilidade de linguagens: Ao implementar o mesmo problema em várias linguagens de programação, podemos observar como diferentes linguagens abordam a solução de maneiras semelhantes ou diferentes. Isso nos ajuda a entender as nuances de cada linguagem e a apreciar sua aplicabilidade em diferentes contextos.

Conclusão

Espero que tenham gostado pessoal. Isso faz parte da jornada do aprendizado. No geral, este exercício nos forneceu uma oportunidade valiosa para praticar habilidades de programação e expandir o conhecimento sobre diferentes linguagens de programação.

Dúvidas ou sugestão de outras linguagens? Deixe o seu comentário!

Um abraço e até o próximo post. Valeu!

#Algortimos #GiovaniDaCruz