Crie um algoritmo e um programa que solicite ao usuário digitar seis números inteiros. O programa deverá somar os valores pares informados e mostrar o resultado desta soma na tela.

Fala galera da programação, tudo beleza? Hoje vamos a um novo exercício que vai nos ajudar na lógica de programação.

Exemplo de saída: se o usuário informar os números 21, 15, 43, 34, -7 e 120 deverá ser mostrado na tela a mensagem “A soma dos números pares digitados é 154.”

Vamos tentar guardar os números lidos em um vetor para treinarmos esta parte também.

O que vamos aprender neste exercício:

Este exercício oferece várias oportunidades de aprendizado, tanto para iniciantes quanto para programadores mais experientes. Aqui estão algumas lições que podemos extrair deste exercício:

1. Lógica de Programação: Este exercício envolve a aplicação de conceitos de lógica de programação, como iteração sobre estruturas de dados, condicionais e aritmética básica.
2. Entrada e Saída de Dados: Aprender a solicitar entrada do usuário e exibir saída é fundamental para a maioria dos programas. Este exercício demonstra várias maneiras de fazer isso em diferentes linguagens de programação.
3. Manipulação de Arrays/Vetores: Em muitas linguagens de programação, arrays ou vetores são uma estrutura de dados fundamental. Este exercício mostra como criar, preencher e iterar sobre arrays/vetores.
4. Condicionais: A utilização de condicionais é essencial em muitos programas para realizar diferentes ações com base em certas condições. Neste exercício, os condicionais são usados para verificar se um número é par.
5. Sintaxe da Linguagem: Cada linguagem de programação tem sua própria sintaxe e conjunto de recursos. Este exercício oferece a oportunidade de praticar a sintaxe específica de várias linguagens, como C++, C, Python, Java, Rust, etc.
6. Boas Práticas de Programação: Ao escrever e revisar o código, é possível aprender e aplicar boas práticas de programação, como uso de comentários, nomeação de variáveis significativas, tratamento de erros e organização do código.
7. Comparação entre Linguagens: Este exercício também permite comparar e contrastar diferentes linguagens de programação, observando as diferenças e semelhanças em suas abordagens para resolver o mesmo problema.

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 numeros[6];
    int somaPares = 0;

    // Solicita ao usuário digitar os seis números inteiros
    cout << "Digite seis numeros inteiros: ";
    for (int i = 0; i < 6; ++i) {
        cin >> numeros[i];
    }

    // Soma os valores pares informados
    for (int i = 0; i < 6; ++i) {
        if (numeros[i] % 2 == 0) {
            somaPares += numeros[i];
        }
    }

    // Mostra o resultado da soma na tela
    cout << "A soma dos numeros pares digitados e " << somaPares << "." << endl;

    return 0;
}

Explicação:

1. Declaração de Variáveis: O programa começa declarando duas variáveis. A primeira é um array de inteiros chamado numeros com tamanho 6, que será usado para armazenar os números fornecidos pelo usuário. A segunda é uma variável inteira chamada somaPares, que será usada para armazenar a soma dos números pares.
2. Entrada de Dados: O programa solicita ao usuário que digite seis números inteiros usando um loop for. Ele armazena cada número fornecido pelo usuário no array numeros.
3. Soma dos Números Pares: O programa utiliza outro loop for para percorrer o array numeros e verificar se cada número é par. Se um número for par (ou seja, quando o resto da divisão por 2 for igual a 0), ele adiciona esse número à variável somaPares.
4. Exibição do Resultado: Após somar todos os números pares, o programa exibe a soma na tela usando a instrução cout.

Essa estratégia é simples e direta. O programa solicita os números, verifica se cada um é par e os soma. Por fim, ele exibe a soma dos números pares.

Exemplo em C

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

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

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

int main() {
    int numeros[6];
    int somaPares = 0;
    int i;

    // Solicita ao usuário digitar os seis números inteiros
    printf("Digite seis numeros inteiros: ");
    for (i = 0; i < 6; ++i) {
        scanf("%d", &numeros[i]);
    }

    // Soma os valores pares informados
    for (i = 0; i < 6; ++i) {
        if (numeros[i] % 2 == 0) {
            somaPares += numeros[i];
        }
    }

    // Mostra o resultado da soma na tela
    printf("A soma dos numeros pares digitados e %d.\n", somaPares);

    return 0;
}

Neste programa em C, o processo é essencialmente o mesmo que o programa em C++: solicitamos os números ao usuário, somamos os números pares e exibimos o resultado. As principais diferenças estão na forma como lidamos com a entrada de dados (usando scanf em vez de cin) e na formatação de saída (usando printf em vez de cout).

Exemplo em Pascal / Delphi / Lazarus

{

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

}
program Soma;
var
  numeros: array[1..6] of integer;
  somaPares, i: integer;
begin
  somaPares := 0;

  // Solicita ao usuário digitar os seis números inteiros
  writeln('Digite seis numeros inteiros:');
  for i := 1 to 6 do
    readln(numeros[i]);

  // Soma os valores pares informados
  for i := 1 to 6 do
  begin
    if (numeros[i] mod 2 = 0) then
      somaPares := somaPares + numeros[i];
  end;

  // Mostra o resultado da soma na tela
  writeln('A soma dos numeros pares digitados e ', somaPares, '.');
end.

Neste programa em Pascal, seguimos a mesma lógica do programa em C e C++. Solicitamos ao usuário que digite os seis números inteiros, somamos os números pares e exibimos o resultado. As estruturas de controle em Pascal são um pouco diferentes, utilizando writeln para exibir na tela e readln para ler os valores fornecidos pelo usuário.

Exemplo em Python

'''

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

'''
# Solicita ao usuário digitar seis números inteiros
numeros = []
for _ in range(6):
    numeros.append(int(input("Digite um número inteiro: ")))

# Soma os valores pares informados
soma_pares = sum(num for num in numeros if num % 2 == 0)

# Mostra o resultado da soma na tela
print(f"A soma dos números pares digitados é {soma_pares}.")

Este programa em Python é bastante semelhante aos programas anteriores, mas usa a sintaxe específica do Python. Ele solicita ao usuário que digite seis números inteiros, somando apenas os números pares fornecidos e, em seguida, exibe a soma na tela. A compreensão de lista é usada para filtrar apenas os números pares da lista numeros durante a soma.

Exemplo em C# / C Sharp

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

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

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

class Program
{
    static void Main()
    {
        int[] numeros = new int[6];
        int somaPares = 0;

        // Solicita ao usuário digitar os seis números inteiros
        Console.WriteLine("Digite seis números inteiros:");
        for (int i = 0; i < 6; i++)
        {
            numeros[i] = int.Parse(Console.ReadLine());
        }

        // Soma os valores pares informados
        foreach (int num in numeros)
        {
            if (num % 2 == 0)
            {
                somaPares += num;
            }
        }

        // Mostra o resultado da soma na tela
        Console.WriteLine($"A soma dos números pares digitados é {somaPares}.");
    }
}

Neste programa em C#, seguimos a mesma lógica dos programas anteriores. Solicitamos ao usuário que digite os seis números inteiros, somamos apenas os números pares fornecidos e, em seguida, exibimos a soma na tela. Utilizamos um loop for para a entrada de dados e um loop foreach para percorrer os números e somar os pares. Por fim, usamos a interpolação de string para exibir a mensagem com a soma.

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[] numeros = new int[6];
        int somaPares = 0;

        // Solicita ao usuário digitar os seis números inteiros
        System.out.println("Digite seis números inteiros:");
        for (int i = 0; i < 6; i++) {
            numeros[i] = scanner.nextInt();
        }

        // Soma os valores pares informados
        for (int num : numeros) {
            if (num % 2 == 0) {
                somaPares += num;
            }
        }

        // Mostra o resultado da soma na tela
        System.out.println("A soma dos números pares digitados é " + somaPares + ".");
        
        scanner.close();
    }
}

Neste programa em Java, a lógica é semelhante aos programas anteriores. Usamos a classe Scanner para capturar a entrada do usuário. Solicitamos ao usuário que digite os seis números inteiros, somamos apenas os números pares fornecidos e, em seguida, exibimos a soma na tela. Utilizamos um loop for para a entrada de dados e um loop enhanced for para percorrer os números e somar os pares. Por fim, usamos a concatenação de strings para exibir a mensagem com a soma.

Exemplo em Rust

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

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

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

fn main() {
    let mut numeros = Vec::new();
    let mut soma_pares = 0;

    // Solicita ao usuário digitar os seis números inteiros
    println!("Digite seis números inteiros:");
    for _ in 0..6 {
        let mut input = String::new();
        io::stdin().read_line(&mut input).expect("Falha ao ler a linha");
        let numero: i32 = input.trim().parse().expect("Digite um número válido");
        numeros.push(numero);
    }

    // Soma os valores pares informados
    for num in &numeros {
        if num % 2 == 0 {
            soma_pares += num;
        }
    }

    // Mostra o resultado da soma na tela
    println!("A soma dos números pares digitados é {}.", soma_pares);
}

Neste programa em Rust, utilizamos vetores para armazenar os números e a entrada e saída padrão do Rust (std::io). Solicitamos ao usuário que digite os seis números inteiros, somamos apenas os números pares fornecidos e, em seguida, exibimos a soma na tela. Laços de repetição como for e loop são usados para iterar sobre os números e calcular a soma dos pares. A função expect é usada para lidar com erros de entrada e saída.

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