Fala galera da programação, tudo beleza?

Vamos a um novo exercício de algoritmos:

Exercício: Encontrando o Maior Número com Leitura de Entrada em uma Única Variável 

Objetivo:
Neste exercício, você vai criar um programa em que lê 5 números fornecidos pelo usuário e determina qual é o maior número entre eles. A primeira leitura do número será usada para inicializar a variável que armazenará o maior número.

Descrição:

1. Inicialização:
   • Leia o primeiro número do usuário e armazene-o na variável que será usada para armazenar o maior número.
2. Leitura e Comparação:
   • Utilize um loop para ler os outros 4 números fornecidos pelo usuário. Em cada iteração do loop, compare o número lido com o valor armazenado na variável de maior número. Se o número lido for maior, atualize a variável de maior número.
3. Saída:
   • Após a leitura dos 5 números, exiba o maior número encontrado.

Requisitos:

• A primeira leitura do número deve inicializar a variável de maior número.
• Utilize apenas uma variável para armazenar o número lido e a variável de maior número.

Passos para Implementação:

1. Leia o primeiro número do usuário e inicialize a variável maior.
2. Crie um loop para ler os outros 4 números do usuário.
3. Compare cada número lido com o valor atual de maior e atualize se necessário.
4. Exiba o maior número encontrado.

Vamos aos códigos:

Exemplo em C++

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

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

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

int main() {
    int maior; // Variável para armazenar o maior número
    int numero; // Variável para armazenar o número lido

    // Lê o primeiro número e inicializa 'maior'
    std::cout << "Digite um número: ";
    std::cin >> maior;

    // Loop para ler os outros 4 números
    for (int i = 1; i < 5; ++i) {
        std::cout << "Digite um número: ";
        std::cin >> numero;

        // Verifica se o número atual é maior que o valor armazenado em 'maior'
        if (numero > maior) {
            maior = numero;
        }
    }

    std::cout << "O maior número é: " << maior << std::endl;

    return 0;
}

O programa em C++ começa lendo o primeiro número do usuário e o utiliza para inicializar a variável maior, que armazenará o maior número encontrado. Em seguida, um loop for é usado para ler os outros 4 números fornecidos pelo usuário. Durante cada iteração do loop, o número lido é comparado com o valor atual de maior; se for maior, maior é atualizado com esse novo valor. Após a leitura de todos os números, o programa exibe o maior número encontrado. Este código é eficiente e simples, utilizando apenas uma variável para armazenar a entrada do usuário e determinar o maior valor entre os números fornecidos.

Exemplo em C Puro

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

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

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

int main() {
    int maior; // Variável para armazenar o maior número
    int numero; // Variável para armazenar o número lido

    // Lê o primeiro número e inicializa 'maior'
    printf("Digite um número: ");
    scanf("%d", &maior);

    // Loop para ler os outros 4 números
    for (int i = 1; i < 5; ++i) {
        printf("Digite um número: ");
        scanf("%d", &numero);

        // Verifica se o número atual é maior que o valor armazenado em 'maior'
        if (numero > maior) {
            maior = numero; // Atualiza 'maior' se o número lido for maior
        }
    }

    printf("O maior número é: %d\n", maior);

    return 0;
}

Este código em C funciona da mesma forma que a versão em C++, determinando o maior número a partir de 5 entradas do usuário.

Exemplo em Pascal / Delphi / Lazarus

(*

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

*)
program MaiorNumero;

var
  maior, numero: integer;
  i: integer;

begin
  { Lê o primeiro número e inicializa 'maior' }
  write('Digite um número: ');
  readln(maior);

  { Loop para ler os outros 4 números }
  for i := 1 to 4 do
  begin
    write('Digite um número: ');
    readln(numero);

    { Verifica se o número atual é maior que o valor armazenado em 'maior' }
    if numero > maior then
      maior := numero;
  end;

  writeln('O maior número é: ', maior);
end.

Este código em Pascal segue a mesma lógica das versões em C e C++, determinando o maior número a partir de 5 entradas do usuário.

Exemplo em Python

'''

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

'''
# Solicita e lê o primeiro número, inicializando 'maior'
maior = int(input("Digite um número: "))

# Loop para ler os outros 4 números
for _ in range(4):
    numero = int(input("Digite um número: "))
    
    # Verifica se o número atual é maior que o valor armazenado em 'maior'
    if numero > maior:
        maior = numero

# Exibe o maior número encontrado
print("O maior número é:", maior)

Explicação do Código:

O código em Python começa lendo o primeiro número fornecido pelo usuário e o utiliza para inicializar a variável maior, que armazenará o maior número encontrado. Em seguida, um loop for é usado para ler os outros 4 números. Durante cada iteração, o número lido é comparado com o valor atual de maior; se o número lido for maior, maior é atualizado. Finalmente, após o loop, o código imprime o maior número encontrado. Esse código é eficiente e direto, utilizando uma abordagem simples e clara para determinar o maior número entre as entradas fornecidas.

Exemplo em C# / C Sharp

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

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

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

class Program
{
    static void Main()
    {
        int maior; // Variável para armazenar o maior número
        int numero; // Variável para armazenar o número lido

        // Lê o primeiro número e inicializa 'maior'
        Console.Write("Digite um número: ");
        maior = int.Parse(Console.ReadLine());

        // Loop para ler os outros 4 números
        for (int i = 1; i < 5; ++i)
        {
            Console.Write("Digite um número: ");
            numero = int.Parse(Console.ReadLine());

            // Verifica se o número atual é maior que o valor armazenado em 'maior'
            if (numero > maior)
            {
                maior = numero; // Atualiza 'maior' se o número lido for maior
            }
        }

        Console.WriteLine("O maior número é: " + maior);
    }
}

Explicação do Código:

O programa em C# começa lendo o primeiro número do usuário e o utiliza para inicializar a variável maior. Em seguida, um loop for é utilizado para ler os outros 4 números do usuário. Durante cada iteração do loop, o número lido é comparado com o valor atual de maior; se for maior, maior é atualizado. Após o loop, o programa exibe o maior número encontrado. O uso de Console.ReadLine() para ler entradas e int.Parse() para converter as entradas para o tipo int permite manipular os números de forma simples e eficiente.

Exemplo em Java

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

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

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

public class MaiorNumero {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // Lê o primeiro número e inicializa 'maior'
        System.out.print("Digite um número: ");
        int maior = scanner.nextInt();

        // Loop para ler os outros 4 números
        for (int i = 1; i < 5; ++i) {
            System.out.print("Digite um número: ");
            int numero = scanner.nextInt();

            // Verifica se o número atual é maior que o valor armazenado em 'maior'
            if (numero > maior) {
                maior = numero; // Atualiza 'maior' se o número lido for maior
            }
        }

        System.out.println("O maior número é: " + maior);

        scanner.close();
    }
}

Explicação do Código:

O programa em Java inicia lendo o primeiro número do usuário e o usa para inicializar a variável maior, que será usada para armazenar o maior número encontrado. Em seguida, um loop for é usado para ler os outros 4 números fornecidos pelo usuário. Dentro do loop, o número lido é comparado com o valor atual de maior; se o número lido for maior, maior é atualizado. Após a conclusão do loop, o programa exibe o maior número encontrado. O uso da classe Scanner para a entrada e o método nextInt() para ler inteiros permite que o programa funcione de forma clara e eficiente. O método scanner.close() é chamado no final para fechar o Scanner e liberar os recursos.

Exemplo em Rust

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

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

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

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

    // Lê o primeiro número e inicializa 'maior'
    println!("Digite um número: ");
    io::stdin().read_line(&mut input).expect("Falha ao ler a linha");
    let mut maior: i32 = input.trim().parse().expect("Por favor, digite um número inteiro");
    input.clear(); // Limpa o buffer de entrada

    // Loop para ler os outros 4 números
    for _ in 1..5 {
        println!("Digite um número: ");
        io::stdin().read_line(&mut input).expect("Falha ao ler a linha");
        let numero: i32 = input.trim().parse().expect("Por favor, digite um número inteiro");
        input.clear(); // Limpa o buffer de entrada

        // Verifica se o número atual é maior que o valor armazenado em 'maior'
        if numero > maior {
            maior = numero; // Atualiza 'maior' se o número lido for maior
        }
    }

    println!("O maior número é: {}", maior);
}

Explicação do Código:

O programa em Rust começa lendo o primeiro número fornecido pelo usuário e o utiliza para inicializar a variável maior. Para isso, ele usa io::stdin().read_line() para ler a entrada do usuário, e trim().parse() para converter a entrada para um número inteiro. Em seguida, um loop for é utilizado para ler os outros 4 números. Durante cada iteração, o número lido é comparado com o valor atual de maior; se for maior, maior é atualizado. Após o loop, o programa imprime o maior número encontrado. O uso de input.clear() é necessário para limpar o buffer de entrada após cada leitura, garantindo que o próximo valor lido não seja afetado pela entrada anterior. O tratamento de erros é feito com expect() para garantir que a entrada seja válida e o programa continue funcionando conforme esperado.

Exemplo em Go

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

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

*******************************************************************************/
package main

import (
    "fmt"
)

func main() {
    var maior, numero int

    // Lê o primeiro número e inicializa 'maior'
    fmt.Print("Digite um número: ")
    fmt.Scan(&maior)

    // Loop para ler os outros 4 números
    for i := 1; i < 5; i++ {
        fmt.Print("Digite um número: ")
        fmt.Scan(&numero)

        // Verifica se o número atual é maior que o valor armazenado em 'maior'
        if numero > maior {
            maior = numero // Atualiza 'maior' se o número lido for maior
        }
    }

    fmt.Printf("O maior número é: %d\n", maior)
}

Explicação do Código

O programa em Go inicia lendo o primeiro número fornecido pelo usuário e o utiliza para inicializar a variável maior. Isso é feito com fmt.Scan(&maior), que lê a entrada do usuário e armazena o valor na variável maior. Em seguida, um loop for é usado para ler os outros 4 números. Durante cada iteração do loop, o número lido é comparado com o valor atual de maior; se for maior, maior é atualizado. Após a conclusão do loop, o programa imprime o maior número encontrado usando fmt.Printf. Este código é direto e utiliza funções básicas de entrada e saída para realizar a tarefa de forma eficiente.

Exemplo em PHP

<?php
/*

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

*/


// Função para ler um número do usuário
function lerNumero($prompt) {
    echo $prompt;
    return trim(fgets(STDIN));
}

// Lê o primeiro número e inicializa 'maior'
$maior = (int) lerNumero("Digite um número: ");

// Loop para ler os outros 4 números
for ($i = 1; $i < 5; $i++) {
    $numero = (int) lerNumero("Digite um número: ");

    // Verifica se o número atual é maior que o valor armazenado em 'maior'
    if ($numero > $maior) {
        $maior = $numero; // Atualiza 'maior' se o número lido for maior
    }
}

// Exibe o maior número encontrado
echo "O maior número é: $maior\n";

?>

Explicação do Código:

O programa em PHP começa definindo uma função lerNumero para ler um número do usuário. Essa função usa fgets(STDIN) para capturar a entrada e trim() para remover espaços em branco ao redor. O primeiro número é lido e armazenado na variável $maior. Em seguida, um loop for é utilizado para ler os outros 4 números. Durante cada iteração, o número lido é comparado com o valor atual de $maior; se for maior, $maior é atualizado. Após o loop, o programa imprime o maior número encontrado usando echo. O código utiliza práticas simples e claras para manipulação de entrada e saída em PHP.

Exemplo em COBOL

*> ***************************************

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

*> ***************************************
IDENTIFICATION DIVISION.
PROGRAM-ID. MaiorNumero.

DATA DIVISION.
WORKING-STORAGE SECTION.
01  MAIOR           PIC 9(5) VALUE 0.
01  NUMERO          PIC 9(5) VALUE 0.
01  I               PIC 9(1) VALUE 0.

PROCEDURE DIVISION.
    
    DISPLAY 'Digite um número: ' 
    ACCEPT MAIOR

    PERFORM VARYING I FROM 1 BY 1 UNTIL I > 4
        DISPLAY 'Digite um número: '
        ACCEPT NUMERO

        IF NUMERO > MAIOR
            MOVE NUMERO TO MAIOR
        END-IF
    END-PERFORM

    DISPLAY 'O maior número é: ' MAIOR

    STOP RUN.

Explicação das Correções:

1. Formatação de Indentação:
   • Certifique-se de que as divisões e os parágrafos estejam alinhados corretamente e que o código esteja alinhado com a coluna 7 (a coluna de indicadores).
2. Uso de Indicadores:
   • A formatação COBOL tradicional requer que as palavras-chave estejam na coluna 7 (ou coluna de indicadores). Em ambientes modernos, muitas vezes essa formatação é mais flexível, mas alguns compiladores COBOL ainda podem exigir a formatação tradicional.
3. Estrutura de Blocos:
   • Garantir que o código esteja estruturado corretamente, com PERFORM, IF, e END-IF corretamente alinhados e formatados.

O que podemos aprender neste exercício?

Neste exercício, podemos aprender várias coisas importantes sobre a programação e o desenvolvimento de software, independentemente da linguagem utilizada:

1. Controle de Fluxo e Loops: O exercício demonstra o uso de loops (for ou while) para iterar um número específico de vezes, o que é essencial para tarefas repetitivas e processamento de dados.
2. Manipulação de Variáveis: Aprendemos a inicializar e atualizar variáveis para manter o controle do estado do programa. Neste caso, a variável maior é atualizada com base em comparações sucessivas.
3. Entrada e Saída de Dados: O exercício envolve a leitura de entrada do usuário e a exibição de resultados. Em diferentes linguagens, isso é feito com funções específicas (scanf, input(), Console.ReadLine(), etc.).
4. Comparação e Condicionamento: Utilizamos instruções condicionais (if) para comparar valores e decidir qual valor deve ser mantido como o maior.
5. Conversão de Tipos: Em várias linguagens, é necessário converter a entrada do usuário para o tipo apropriado (por exemplo, de String para int) para realizar operações matemáticas.
6. Erros e Validações: A manipulação de entradas pode revelar a necessidade de validar e tratar possíveis erros, como entradas inválidas, para garantir que o programa funcione corretamente.
7. Simplicidade e Eficiência: O exercício mostra como resolver um problema de forma simples e direta, o que é uma boa prática em programação. A solução deve ser clara e eficiente para ser fácil de entender e manter.
8. Diferenças de Sintaxe: Observando a mesma lógica implementada em diferentes linguagens, podemos comparar e aprender as diferenças de sintaxe e as peculiaridades de cada linguagem.

Esse exercício é um bom exemplo de como conceitos básicos de programação são aplicados de maneira consistente através de diferentes linguagens, ajudando a consolidar o entendimento dos fundamentos da programação.

Beleza pessoal? Espero que tenham gostado.

Dúvidas ou sugestões de outras linguagens? Poste nos comentários!

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

#Algoritmos

#Exercícios

#ADS

#GiovaniDaCruz

Fala galera da programação, tudo beleza?

Hoje vamos desenvolver um programa simples em diversas linguagens de programação para encontrar o maior e o menor número dentre cinco fornecidos pelo usuário!

Dicas para o exercício

Utilizar variáveis adicionais para armazenar o maior e para armazenar o menor.

Comparar cada número lido com cada uma dessas variáveis adicionais.

Lembre-se de atribuir um valor inicial para as variáveis adicionais, que pode ser, por exemplo, o primeiro número lido.

O que podemos aprender neste exercício?

Este exercício em C++ nos ensina alguns conceitos importantes:

Uso de variáveis: Aprendemos como declarar e usar variáveis em C++, incluindo a atribuição de valores e a atualização dessas variáveis durante a execução do programa.

Estruturas de controle de fluxo: O uso do loop for nos permite iterar sobre um conjunto de números predefinido, enquanto as estruturas condicionais if e else if nos permitem comparar e atualizar variáveis com base em condições específicas.

Algoritmo de encontrar o maior e o menor número: Este exercício nos mostra uma maneira simples de encontrar o maior e o menor número em um conjunto de números fornecidos pelo usuário, usando variáveis adicionais para acompanhar esses valores durante a execução do programa.

Entrada e saída básicas: Aprendemos a usar cin para obter entrada do usuário e cout para exibir saída na tela.

Boas práticas de programação: O exercício também destaca a importância de usar variáveis descritivas e comentários claros para tornar o código mais compreensível e fácil de dar manutenção.

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 numero, maior, menor;

    // Lê o primeiro número e o considera tanto o maior quanto o menor
    cout << "Digite o 1º número: ";
    cin >> numero;
    maior = numero;
    menor = numero;

    // Loop para ler os próximos 4 números e atualizar o maior e o menor
    for (int i = 2; i <= 5; ++i) {
        cout << "Digite o " << i << "º número: ";
        cin >> numero;

        if (numero > maior) {
            maior = numero;
        } else if (numero < menor) {
            menor = numero;
        }
    }

    // Mostra o maior e o menor número
    cout << "O maior número é: " << maior << endl;
    cout << "O menor número é: " << menor << endl;

    return 0;
}

Este programa solicita ao usuário que insira 5 números e, à medida que os números são inseridos, verifica se são maiores ou menores do que os valores atuais armazenados nas variáveis maior e menor, atualizando-as conforme necessário. No final, imprime o maior e o menor número inserido.

A estratégia utilizada no programa foi a seguinte:

1. Inicialização das variáveis: Começamos declarando três variáveis inteiras: numero, maior e menor. A variável numero será usada para ler os números fornecidos pelo usuário, enquanto maior e menor serão usadas para armazenar o maior e o menor número, respectivamente.
2. Leitura do primeiro número: O programa solicita ao usuário que insira o primeiro número e armazena esse valor nas variáveis maior e menor, pois, no início, esse número é o único e, portanto, o maior e o menor.
3. Loop para os próximos números: Utilizando um loop for, o programa lê os próximos quatro números fornecidos pelo usuário. Começando do segundo número, até o quinto, ele compara cada número com os valores armazenados em maior e menor.
4. Atualização de maior e menor: Se o número lido for maior do que o valor atual de maior, maior é atualizado com esse número. Se o número lido for menor do que o valor atual de menor, menor é atualizado com esse número.
5. Exibição do resultado: Após a leitura de todos os números, o programa exibe o maior e o menor número lido.

Essa abordagem garante que, a cada iteração do loop, os valores de maior e menor são atualizados conforme necessário, resultando nos valores corretos no final da execução do programa.

Exemplo em C

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

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

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

int main() {
    int numero, maior, menor, i;

    // Lê o primeiro número e o considera tanto o maior quanto o menor
    printf("Digite o 1º número: ");
    scanf("%d", &numero);
    maior = numero;
    menor = numero;

    // Loop para ler os próximos 4 números e atualizar o maior e o menor
    for (i = 2; i <= 5; ++i) {
        printf("Digite o %dº número: ", i);
        scanf("%d", &numero);

        if (numero > maior) {
            maior = numero;
        } else if (numero < menor) {
            menor = numero;
        }
    }

    // Mostra o maior e o menor número
    printf("O maior número é: %d\n", maior);
    printf("O menor número é: %d\n", menor);

    return 0;
}

Este programa realiza exatamente as mesmas operações que o programa em C++ que escrevi anteriormente, mas utiliza a sintaxe da linguagem C. As diferenças principais incluem a troca de cout e cin por printf e scanf, respectivamente, e a remoção do namespace std. O restante da lógica permanece a mesma.

Exemplo em Pascal / Delphi / Lazarus

{

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

}
program EncontrarMaiorMenor;

var
  numero, maior, menor, i: integer;

begin
  // Lê o primeiro número e o considera tanto o maior quanto o menor
  writeln('Digite o 1º número: ');
  readln(numero);
  maior := numero;
  menor := numero;

  // Loop para ler os próximos 4 números e atualizar o maior e o menor
  for i := 2 to 5 do
  begin
    writeln('Digite o ', i, 'º número: ');
    readln(numero);

    if numero > maior then
      maior := numero
    else if numero < menor then
      menor := numero;
  end;

  // Mostra o maior e o menor número
  writeln('O maior número é: ', maior);
  writeln('O menor número é: ', menor);

end.

Este programa em Pascal faz a mesma tarefa que os programas anteriores: lê 5 números do usuário, encontra o maior e o menor entre eles e os exibe na tela. A sintaxe em Pascal é um pouco diferente das outras linguagens, mas a lógica geral é a mesma.

Exemplo em Python

'''

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

'''
# Lê o primeiro número e o considera tanto o maior quanto o menor
numero = int(input("Digite o 1º número: "))
maior = numero
menor = numero

# Loop para ler os próximos 4 números e atualizar o maior e o menor
for i in range(2, 6):
    numero = int(input("Digite o {}º número: ".format(i)))
    
    if numero > maior:
        maior = numero
    elif numero < menor:
        menor = numero

# Mostra o maior e o menor número
print("O maior número é:", maior)
print("O menor número é:", menor)

Este programa em Python realiza a mesma tarefa que os programas anteriores: lê 5 números do usuário, encontra o maior e o menor entre eles e os exibe na tela. A sintaxe em Python é mais simples e legível, o que torna o código mais fácil de entender.

Exemplo em C# / C Sharp

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

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

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

class Program
{
    static void Main(string[] args)
    {
        int numero, maior, menor;

        // Lê o primeiro número e o considera tanto o maior quanto o menor
        Console.Write("Digite o 1º número: ");
        numero = Convert.ToInt32(Console.ReadLine());
        maior = numero;
        menor = numero;

        // Loop para ler os próximos 4 números e atualizar o maior e o menor
        for (int i = 2; i <= 5; i++)
        {
            Console.Write("Digite o {0}º número: ", i);
            numero = Convert.ToInt32(Console.ReadLine());

            if (numero > maior)
            {
                maior = numero;
            }
            else if (numero < menor)
            {
                menor = numero;
            }
        }

        // Mostra o maior e o menor número
        Console.WriteLine("O maior número é: {0}", maior);
        Console.WriteLine("O menor número é: {0}", menor);
    }
}

Este programa em C# realiza a mesma tarefa que os programas anteriores: lê 5 números do usuário, encontra o maior e o menor entre eles e os exibe na tela. A sintaxe em C# é semelhante à de outras linguagens como Java e C++, mas com algumas diferenças na maneira como a entrada e saída são tratadas.

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 numero, maior, menor;

        // Lê o primeiro número e o considera tanto o maior quanto o menor
        System.out.print("Digite o 1º número: ");
        numero = scanner.nextInt();
        maior = numero;
        menor = numero;

        // Loop para ler os próximos 4 números e atualizar o maior e o menor
        for (int i = 2; i <= 5; i++) {
            System.out.print("Digite o " + i + "º número: ");
            numero = scanner.nextInt();

            if (numero > maior) {
                maior = numero;
            } else if (numero < menor) {
                menor = numero;
            }
        }

        // Mostra o maior e o menor número
        System.out.println("O maior número é: " + maior);
        System.out.println("O menor número é: " + menor);

        scanner.close();
    }
}

Este programa em Java realiza a mesma tarefa que os programas anteriores: lê 5 números do usuário, encontra o maior e o menor entre eles e os exibe na tela. Java possui uma sintaxe semelhante à de C#, mas com algumas diferenças na manipulação de entrada e saída e na estrutura do loop.

Exemplo em Rust

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

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

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

fn main() {
    let mut maior;
    let mut menor;

    // Lê o primeiro número e o considera tanto o maior quanto o menor
    println!("Digite o 1º número:");
    let mut numero = String::new();
    io::stdin().read_line(&mut numero).expect("Falha ao ler a entrada");
    let numero: i32 = numero.trim().parse().expect("Entrada inválida");
    maior = numero;
    menor = numero;

    // Loop para ler os próximos 4 números e atualizar o maior e o menor
    for i in 2..=5 {
        println!("Digite o {}º número:", i);
        let mut input = String::new();
        io::stdin().read_line(&mut input).expect("Falha ao ler a entrada");
        let numero: i32 = input.trim().parse().expect("Entrada inválida");

        if numero > maior {
            maior = numero;
        } else if numero < menor {
            menor = numero;
        }
    }

    // Mostra o maior e o menor número
    println!("O maior número é: {}", maior);
    println!("O menor número é: {}", menor);
}

Este programa em Rust realiza a mesma tarefa que os programas anteriores: lê 5 números do usuário, encontra o maior e o menor entre eles e os exibe na tela. Rust possui uma sintaxe única e segura, com um sistema de tipos poderoso que garante a segurança do programa em tempo de compilação.

Exemplo em Go

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

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

*******************************************************************************/
package main

import (
    "fmt"
)

func main() {
    var numero, maior, menor int

    // Lê o primeiro número e o considera tanto o maior quanto o menor
    fmt.Print("Digite o 1º número: ")
    fmt.Scanln(&numero)
    maior = numero
    menor = numero

    // Loop para ler os próximos 4 números e atualizar o maior e o menor
    for i := 2; i <= 5; i++ {
        fmt.Printf("Digite o %dº número: ", i)
        fmt.Scanln(&numero)

        if numero > maior {
            maior = numero
        } else if numero < menor {
            menor = numero
        }
    }

    // Mostra o maior e o menor número
    fmt.Println("O maior número é:", maior)
    fmt.Println("O menor número é:", menor)
}

Este programa em Go realiza a mesma tarefa que os programas anteriores: lê 5 números do usuário, encontra o maior e o menor entre eles e os exibe na tela. A sintaxe em Go é diferente de outras linguagens, mas é bastante simples e intuitiva.

Conclusão

O exercício de desenvolver um programa para encontrar o maior e o menor número entre cinco fornecidos pelo usuário foi uma ótima oportunidade para explorar e comparar diferentes linguagens de programação. Ao escrever o mesmo algoritmo em linguagens como C++, C, Pascal, Python, C#, Java, Rust e Go, pude perceber as nuances e diferenças entre essas linguagens, além de fortalecer meu entendimento sobre os conceitos fundamentais de programação.

Este exercício demonstra a versatilidade e a diversidade de opções disponíveis para os desenvolvedores ao escolherem uma linguagem para resolver um determinado problema. Cada linguagem tem sua própria sintaxe, estilo e conjunto de recursos, mas todas compartilham a capacidade de expressar soluções para problemas complexos de maneira clara e eficiente.

Além disso, essa experiência reforçou a importância do pensamento algorítmico e da lógica de programação, habilidades essenciais que transcendem a linguagem específica utilizada. Independentemente da linguagem escolhida, a capacidade de quebrar um problema em etapas menores, identificar padrões e desenvolver soluções eficazes é fundamental para o sucesso na programação.

Em resumo, este exercício foi uma oportunidade valiosa para aprimorar minhas habilidades de programação, expandir meu conhecimento sobre diferentes linguagens e reforçar princípios fundamentais de desenvolvimento de software.

Beleza pessoal? Espero que tenham gostado.

Dúvidas ou sugestões? Deixe o seu comentário!

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

#Programação

#Desenvolvimento

#Aprendizado

#Coding

#Tech

#LinguagensDeProgramação

#GiovaniDaCruz

Fala galera da programação, tudo beleza? Vamos a um novo exercício de algoritmos com desvio condicional. Desafie suas habilidades de programação com este exercício simples de cálculo de estacionamento em diversas linguagens! Aprenda e pratique condicionais, entrada/saída e sintaxe em várias linguagens.

Dicas para o exercício

Lembrar que pode ser informado 0 no tempo e nesse caso nada é cobrado.

Exemplos:

1 hora = R$ 8;
2 horas = R$ 13;
3 horas = R$ 18;

Sugestão: Leia um numero inteiro correspondente as horas de estacionamento e escreva o valor que deve ser pago. Utilizar um comando condicional para calcular o valor a primeira hora e uma fórmula para calcular as demais.

O que podemos aprender neste exercício?

Lógica condicional: O problema envolve a utilização de lógica condicional para tomar decisões com base nas entradas do usuário.

Cálculos simples: O programa realiza cálculos simples para determinar o valor a ser pago com base no tempo de estacionamento fornecido pelo usuário.

Raciocínio lógico: Este exercício ajuda a praticar o raciocínio lógico ao lidar com diferentes cenários (tempo de estacionamento igual a 0, igual a 1 ou maior que 1).

Interação com o usuário: O programa solicita informações ao usuário e fornece resultados claros e compreensíveis.

Abstração de problemas reais para código: Este problema é um exemplo de como podemos traduzir um problema do mundo real (cobrança de estacionamento) em código de computador.

Prática de sintaxe de programação: Ajuda a praticar a sintaxe de programação, incluindo entrada e saída de dados, declaração de variáveis, uso de condicionais, etc.

Vamos aos códigos!

Exemplo em Portugol – Portugol Studio

/*

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

*/
programa {
  funcao inicio() {

    inteiro horas
    real valor

    escreva("Digite o tempo de estacionamento em horas: ")
    leia(horas)

    se (horas == 0) {
        valor = 0
    } senao se (horas == 1) {
        valor = 8
    } senao {
        // Calcula o valor para as horas adicionais
        valor = 8 + (horas - 1) * 5
    }

    escreva( "Valor a ser pago: R$ ", valor)
  
  }
}

Este programa solicita ao usuário o tempo de estacionamento em horas. Em seguida, ele calcula o valor a ser pago de acordo com as regras fornecidas. Se o tempo for 0, nenhum valor é cobrado. Se for 1 hora, é cobrado o valor base de R$ 8. Para mais de 1 hora, é cobrado o valor base mais R$ 5 para cada hora adicional após a primeira.

Exemplo em C++

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

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

*******************************************************************************/
#include <iostream>
using namespace std;

int main() {
    int horas;
    float valor;

    cout << "Digite o tempo de estacionamento em horas: ";
    cin >> horas;

    if (horas == 0) {
        valor = 0;
    } else if (horas == 1) {
        valor = 8;
    } else {
        // Calcula o valor para as horas adicionais
        valor = 8 + (horas - 1) * 5;
    }

    cout << "Valor a ser pago: R$ " << valor << endl;

    return 0;
}

A estratégia utilizada foi a seguinte:

1. O programa solicita ao usuário o tempo de estacionamento em horas.
2. Em seguida, ele verifica se o tempo informado é igual a 0. Se for, define o valor a ser pago como 0, pois não há cobrança.
3. Se o tempo for 1 hora, o programa define o valor a ser pago como R$ 8, que é o valor base.
4. Se o tempo for maior que 1 hora, o programa calcula o valor a ser pago somando o valor base de R$ 8 com R$ 5 multiplicado pelo número de horas adicionais (horas – 1). Isso porque a primeira hora já foi cobrada pelo valor base.
5. Por fim, o programa exibe o valor a ser pago ao usuário.

Exemplo em C

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

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

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

int main() {
    int horas;
    float valor;

    printf("Digite o tempo de estacionamento em horas: ");
    scanf("%d", &horas);

    if (horas == 0) {
        valor = 0;
    } else if (horas == 1) {
        valor = 8;
    } else {
        // Calcula o valor para as horas adicionais
        valor = 8 + (horas - 1) * 5;
    }

    printf("Valor a ser pago: R$ %.2f\n", valor);

    return 0;
}

Neste código, as funções de entrada e saída padrão da linguagem C (printf e scanf) são usadas para interagir com o usuário. A lógica do programa permanece a mesma que a versão em C++, apenas a sintaxe e as funções de entrada/saída são diferentes.

Exemplo em Pascal / Delphi / Lazarus

{

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

}
program CalculoEstacionamento;

var
  horas: integer;
  valor: real;

begin
  writeln('Digite o tempo de estacionamento em horas: ');
  readln(horas);

  if horas = 0 then
    valor := 0
  else if horas = 1 then
    valor := 8
  else
    // Calcula o valor para as horas adicionais
    valor := 8 + (horas - 1) * 5;

  writeln('Valor a ser pago: R$ ', valor:0:2);
end.

Este programa tem a mesma lógica dos exemplo em C++ e C, solicita ao usuário o tempo de estacionamento em horas, lê esse valor e calcula o valor a ser pago com base nas regras fornecidas. Em seguida, ele exibe o valor a ser pago ao usuário.

Exemplo em Python

'''

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

'''
horas = int(input("Digite o tempo de estacionamento em horas: "))

if horas == 0:
    valor = 0
elif horas == 1:
    valor = 8
else:
    valor = 8 + (horas - 1) * 5

print("Valor a ser pago: R$", valor)

Este programa solicita ao usuário o tempo de estacionamento em horas, lê esse valor e calcula o valor a ser pago com base nas regras fornecidas. Em seguida, ele exibe o valor a ser pago ao usuário. Python oferece estruturas de controle mais compactas, como a ausência de chaves e a identação significativa para delimitar blocos de código, tornando o código mais legível e conciso.

Exemplo em C#

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

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

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

class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine("Digite o tempo de estacionamento em horas: ");
        int horas = Convert.ToInt32(Console.ReadLine());
        float valor;

        if (horas == 0)
        {
            valor = 0;
        }
        else if (horas == 1)
        {
            valor = 8;
        }
        else
        {
            // Calcula o valor para as horas adicionais
            valor = 8 + (horas - 1) * 5;
        }

        Console.WriteLine("Valor a ser pago: R$ " + valor);
    }
}

Este programa em C# funciona de maneira semelhante aos programas em C e C++, mas utiliza as funcionalidades da linguagem C#. Ele solicita ao usuário o tempo de estacionamento em horas, lê esse valor e calcula o valor a ser pago com base nas regras fornecidas. Em seguida, ele exibe o valor a ser pago ao usuário.

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);
        System.out.println("Digite o tempo de estacionamento em horas: ");
        int horas = scanner.nextInt();
        float valor;

        if (horas == 0) {
            valor = 0;
        } else if (horas == 1) {
            valor = 8;
        } else {
            // Calcula o valor para as horas adicionais
            valor = 8 + (horas - 1) * 5;
        }

        System.out.println("Valor a ser pago: R$ " + valor);
    }
}

Este programa em Java realiza as mesmas operações que os exemplos anteriores. Ele solicita ao usuário o tempo de estacionamento em horas, lê esse valor e calcula o valor a ser pago com base nas regras fornecidas. Em seguida, ele exibe o valor a ser pago ao usuário.

Exemplo em Rust

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

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

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

fn main() {
    println!("Digite o tempo de estacionamento em horas: ");
    let mut input = String::new();
    io::stdin().read_line(&mut input).expect("Falha ao ler a entrada.");
    let horas: u32 = input.trim().parse().expect("Por favor, insira um número válido.");

    let mut valor: f32;

    if horas == 0 {
        valor = 0.0;
    } else if horas == 1 {
        valor = 8.0;
    } else {
        // Calcula o valor para as horas adicionais
        valor = 8.0 + (horas - 1) as f32 * 5.0;
    }

    println!("Valor a ser pago: R$ {:.2}", valor);
}

O código em Rust solicita ao usuário o tempo de estacionamento em horas, lê a entrada do console e converte-a em um número inteiro. Em seguida, calcula o valor a ser pago com base nas regras fornecidas, considerando uma tarifa fixa para a primeira hora e um valor adicional para as horas subsequentes. O resultado é exibido na tela com duas casas decimais. O programa também trata possíveis erros de conversão da entrada do usuário para garantir que a operação ocorra sem problemas, utilizando o método expect().

Exemplo em Go

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

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

*******************************************************************************/
package main

import (
    "fmt"
)

func main() {
    var horas int
    var valor float64

    fmt.Println("Digite o tempo de estacionamento em horas: ")
    fmt.Scan(&horas)

    if horas == 0 {
        valor = 0
    } else if horas == 1 {
        valor = 8
    } else {
        // Calcula o valor para as horas adicionais
        valor = 8 + float64(horas-1)*5
    }

    fmt.Printf("Valor a ser pago: R$ %.2f\n", valor)
}

No exemplo em Go, o programa solicita ao usuário o tempo de estacionamento em horas e lê a entrada do console usando fmt.Scan(). Em seguida, com base no tempo fornecido, calcula o valor a ser pago conforme as regras estipuladas, considerando uma tarifa fixa para a primeira hora e um valor adicional para as horas subsequentes. O resultado é exibido na tela com duas casas decimais usando fmt.Printf().

Conclusão

Este exercício demonstrou como implementar um programa simples para calcular o valor do estacionamento com base no tempo, seguindo regras específicas. Ao traduzir o problema do mundo real para código em diversas linguagens de programação, pudemos observar diferentes abordagens e sintaxes, destacando as características individuais de cada linguagem. Além disso, praticamos conceitos fundamentais de lógica de programação, como estruturas condicionais e cálculos simples, reforçando a compreensão desses conceitos e a habilidade de resolver problemas computacionais.

Beleza pessoal? Espero que tenham gostado.

Dúvidas ou sugestões? Deixe o seu comentário!

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

#Desenvolvimento

#Programação

#Aprendizado

#DesvioCondicional

#Algoritmos

#GiovaniDaCruz

Fala galera da programação, tudo beleza? Novo exercício na área para aprimorar a nossa lógica de programação.

Dica do exercício:

Para simplificar o problema, converta cada par de valores em um único valor em minutos.

O que podemos aprender neste exercício?

Neste exercício, podemos aprender várias coisas:

1. Manipulação de Entrada/Saída: Aprendemos como ler dados de entrada do usuário e exibir resultados na saída usando diferentes linguagens de programação.
2. Conversão de Tipos: Vimos como converter strings em valores numéricos adequados para cálculos, uma habilidade crucial ao lidar com entrada do usuário.
3. Cálculos Básicos: Praticamos realizar cálculos simples para resolver um problema específico, como converter horas e minutos em minutos totais e calcular a diferença entre dois horários.
4. Controle de Fluxo: Utilizamos estruturas de controle de fluxo, como condicionais, para lidar com diferentes cenários, como quando o evento se estende para o dia seguinte.
5. Sintaxe e Semântica: Comparamos a sintaxe e a semântica de diferentes linguagens de programação, observando suas similaridades e diferenças na implementação do 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 Hi, Mi, Hf, Mf;
    int inicio_minutos, fim_minutos, duracao_minutos;

    // Leitura dos valores de entrada
    cout << "Digite a hora inicial (Hi Mi): ";
    cin >> Hi >> Mi;
    cout << "Digite a hora final (Hf Mf): ";
    cin >> Hf >> Mf;

    // Convertendo hora inicial e final para minutos
    inicio_minutos = Hi * 60 + Mi;
    fim_minutos = Hf * 60 + Mf;

    // Calculando a duração do evento em minutos
    if (fim_minutos > inicio_minutos) {
        duracao_minutos = fim_minutos - inicio_minutos;
    } else {
        duracao_minutos = (24 * 60 - inicio_minutos) + fim_minutos;
    }

    // Convertendo a duração de minutos para horas e minutos
    int duracao_horas = duracao_minutos / 60;
    int duracao_minutos_resto = duracao_minutos % 60;

    // Exibindo o resultado
    cout << "A duração do evento é de " << duracao_horas << " horas e " << duracao_minutos_resto << " minutos." << endl;

    return 0;
}

Esse programa lê os valores de entrada representando a hora e minuto inicial (Hi, Mi) e a hora e minuto final (Hf, Mf) do evento. Em seguida, converte esses valores para minutos, calcula a duração do evento em minutos e, por fim, converte a duração de volta para horas e minutos, exibindo o resultado.

A estratégia utilizada neste programa foi:

1. Ler os valores de entrada representando a hora e minuto inicial (Hi, Mi) e a hora e minuto final (Hf, Mf) do evento.
2. Converter esses valores de hora e minuto para minutos, para simplificar os cálculos.
3. Calcular a duração do evento em minutos, levando em consideração a possibilidade do evento começar em um dia e terminar no dia seguinte.
   • Se a hora final for maior que a hora inicial, a duração é simplesmente a diferença entre as duas.
   • Se a hora final for menor ou igual à hora inicial, a duração é a diferença entre 24 horas (1440 minutos) e a hora inicial, somada à hora final.
4. Converter a duração de minutos para horas e minutos.
5. Exibir o resultado.

Exemplo em C

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

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

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

int main() {
    int Hi, Mi, Hf, Mf;
    int inicio_minutos, fim_minutos, duracao_minutos;

    // Leitura dos valores de entrada
    printf("Digite a hora inicial (Hi Mi): ");
    scanf("%d %d", &Hi, &Mi);
    printf("Digite a hora final (Hf Mf): ");
    scanf("%d %d", &Hf, &Mf);

    // Convertendo hora inicial e final para minutos
    inicio_minutos = Hi * 60 + Mi;
    fim_minutos = Hf * 60 + Mf;

    // Calculando a duração do evento em minutos
    if (fim_minutos > inicio_minutos) {
        duracao_minutos = fim_minutos - inicio_minutos;
    } else {
        duracao_minutos = (24 * 60 - inicio_minutos) + fim_minutos;
    }

    // Convertendo a duração de minutos para horas e minutos
    int duracao_horas = duracao_minutos / 60;
    int duracao_minutos_resto = duracao_minutos % 60;

    // Exibindo o resultado
    printf("A duração do evento é de %d horas e %d minutos.\n", duracao_horas, duracao_minutos_resto);

    return 0;
}

Este programa em C faz exatamente a mesma coisa que o programa em C++. Ele lê os valores de entrada, realiza os cálculos e exibe o resultado. Enquanto C++ usa cout e cin, C usa printf e scanf para entrada/saída.

Exemplo em Pascal / Delphi / Lazarus

{

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

}
program CalculaDuracaoEvento;
var
  Hi, Mi, Hf, Mf: Integer;
  inicio_minutos, fim_minutos, duracao_minutos: Integer;
  duracao_horas, duracao_minutos_resto: Integer;
begin
  // Leitura dos valores de entrada
  Write('Digite a hora inicial (Hi Mi): ');
  Readln(Hi, Mi);
  Write('Digite a hora final (Hf Mf): ');
  Readln(Hf, Mf);

  // Convertendo hora inicial e final para minutos
  inicio_minutos := Hi * 60 + Mi;
  fim_minutos := Hf * 60 + Mf;

  // Calculando a duração do evento em minutos
  if fim_minutos > inicio_minutos then
    duracao_minutos := fim_minutos - inicio_minutos
  else
    duracao_minutos := (24 * 60 - inicio_minutos) + fim_minutos;

  // Convertendo a duração de minutos para horas e minutos
  duracao_horas := duracao_minutos div 60;
  duracao_minutos_resto := duracao_minutos mod 60;

  // Exibindo o resultado
  WriteLn('A duração do evento é de ', duracao_horas, ' horas e ', duracao_minutos_resto, ' minutos.');
end.

Este programa em Pascal realiza as mesmas operações que os programas anteriores, lendo os valores de entrada, calculando a duração do evento e exibindo o resultado. Em Pascal, a entrada é feita usando Readln e a saída usando Write ou WriteLn. A declaração de variáveis vem antes do bloco principal do programa.

Exemplo em Python

'''

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

'''
# Leitura dos valores de entrada
Hi, Mi = map(int, input("Digite a hora inicial (Hi Mi): ").split())
Hf, Mf = map(int, input("Digite a hora final (Hf Mf): ").split())

# Convertendo hora inicial e final para minutos
inicio_minutos = Hi * 60 + Mi
fim_minutos = Hf * 60 + Mf

# Calculando a duração do evento em minutos
if fim_minutos > inicio_minutos:
    duracao_minutos = fim_minutos - inicio_minutos
else:
    duracao_minutos = (24 * 60 - inicio_minutos) + fim_minutos

# Convertendo a duração de minutos para horas e minutos
duracao_horas = duracao_minutos // 60
duracao_minutos_resto = duracao_minutos % 60

# Exibindo o resultado
print("A duração do evento é de", duracao_horas, "horas e", duracao_minutos_resto, "minutos.")

Este programa em Python realiza as mesmas operações que os programas anteriores, lendo os valores de entrada, calculando a duração do evento e exibindo o resultado. Python é uma linguagem de alto nível, por isso não há necessidade de declaração de tipo de variável e a sintaxe é mais simplificada em comparação com C e Pascal.

Exemplo em C# / C Sharp

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

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

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

class Program
{
    static void Main()
    {
        // Leitura dos valores de entrada
        Console.Write("Digite a hora inicial (Hi Mi): ");
        string[] inicio = Console.ReadLine().Split();
        int Hi = int.Parse(inicio[0]);
        int Mi = int.Parse(inicio[1]);

        Console.Write("Digite a hora final (Hf Mf): ");
        string[] fim = Console.ReadLine().Split();
        int Hf = int.Parse(fim[0]);
        int Mf = int.Parse(fim[1]);

        // Convertendo hora inicial e final para minutos
        int inicio_minutos = Hi * 60 + Mi;
        int fim_minutos = Hf * 60 + Mf;

        // Calculando a duração do evento em minutos
        int duracao_minutos;
        if (fim_minutos > inicio_minutos)
            duracao_minutos = fim_minutos - inicio_minutos;
        else
            duracao_minutos = (24 * 60 - inicio_minutos) + fim_minutos;

        // Convertendo a duração de minutos para horas e minutos
        int duracao_horas = duracao_minutos / 60;
        int duracao_minutos_resto = duracao_minutos % 60;

        // Exibindo o resultado
        Console.WriteLine($"A duração do evento é de {duracao_horas} horas e {duracao_minutos_resto} minutos.");
    }
}

Este programa em C# realiza as mesmas operações que os programas anteriores, lendo os valores de entrada, calculando a duração do evento e exibindo o resultado. C# é uma linguagem fortemente tipada, então é necessário fazer a conversão explícita dos valores lidos para os tipos desejados.

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);

        // Leitura dos valores de entrada
        System.out.print("Digite a hora inicial (Hi Mi): ");
        int Hi = scanner.nextInt();
        int Mi = scanner.nextInt();

        System.out.print("Digite a hora final (Hf Mf): ");
        int Hf = scanner.nextInt();
        int Mf = scanner.nextInt();

        // Convertendo hora inicial e final para minutos
        int inicio_minutos = Hi * 60 + Mi;
        int fim_minutos = Hf * 60 + Mf;

        // Calculando a duração do evento em minutos
        int duracao_minutos;
        if (fim_minutos > inicio_minutos)
            duracao_minutos = fim_minutos - inicio_minutos;
        else
            duracao_minutos = (24 * 60 - inicio_minutos) + fim_minutos;

        // Convertendo a duração de minutos para horas e minutos
        int duracao_horas = duracao_minutos / 60;
        int duracao_minutos_resto = duracao_minutos % 60;

        // Exibindo o resultado
        System.out.println("A duração do evento é de " + duracao_horas + " horas e " + duracao_minutos_resto + " minutos.");
        
        scanner.close();
    }
}

Este programa em Java realiza as mesmas operações que os programas anteriores, lendo os valores de entrada, calculando a duração do evento e exibindo o resultado. Java é uma linguagem fortemente tipada e orientada a objetos, então é necessário utilizar classes como Scanner para entrada de dados.

Exemplo em Rust

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

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

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

fn main() {
    // Leitura dos valores de entrada
    println!("Digite a hora inicial (Hi Mi): ");
    let mut inicio = String::new();
    io::stdin().read_line(&mut inicio).expect("Falha ao ler entrada.");
    let inicio: Vec<i32> = inicio.trim().split_whitespace()
                                .map(|x| x.parse().expect("Valor inválido."))
                                .collect();
    let Hi = inicio[0];
    let Mi = inicio[1];

    println!("Digite a hora final (Hf Mf): ");
    let mut fim = String::new();
    io::stdin().read_line(&mut fim).expect("Falha ao ler entrada.");
    let fim: Vec<i32> = fim.trim().split_whitespace()
                            .map(|x| x.parse().expect("Valor inválido."))
                            .collect();
    let Hf = fim[0];
    let Mf = fim[1];

    // Convertendo hora inicial e final para minutos
    let inicio_minutos = Hi * 60 + Mi;
    let fim_minutos = Hf * 60 + Mf;

    // Calculando a duração do evento em minutos
    let duracao_minutos = if fim_minutos > inicio_minutos {
        fim_minutos - inicio_minutos
    } else {
        (24 * 60 - inicio_minutos) + fim_minutos
    };

    // Convertendo a duração de minutos para horas e minutos
    let duracao_horas = duracao_minutos / 60;
    let duracao_minutos_resto = duracao_minutos % 60;

    // Exibindo o resultado
    println!("A duração do evento é de {} horas e {} minutos.", duracao_horas, duracao_minutos_resto);
}

Em Rust, a entrada é tratada usando a biblioteca padrão std::io, enquanto a conversão de tipos é mais explícita usando parse() e expect() para tratamento de erros. A linguagem enfatiza a segurança de memória e a prevenção de erros de tempo de execução.

Exemplo em Go

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

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

*******************************************************************************/
package main

import (
    "fmt"
)

func main() {
    // Leitura dos valores de entrada
    var Hi, Mi, Hf, Mf int

    fmt.Print("Digite a hora inicial (Hi Mi): ")
    fmt.Scan(&Hi, &Mi)

    fmt.Print("Digite a hora final (Hf Mf): ")
    fmt.Scan(&Hf, &Mf)

    // Convertendo hora inicial e final para minutos
    inicioMinutos := Hi*60 + Mi
    fimMinutos := Hf*60 + Mf

    // Calculando a duração do evento em minutos
    var duracaoMinutos int
    if fimMinutos > inicioMinutos {
        duracaoMinutos = fimMinutos - inicioMinutos
    } else {
        duracaoMinutos = (24*60 - inicioMinutos) + fimMinutos
    }

    // Convertendo a duração de minutos para horas e minutos
    duracaoHoras := duracaoMinutos / 60
    duracaoMinutosResto := duracaoMinutos % 60

    // Exibindo o resultado
    fmt.Printf("A duração do evento é de %d horas e %d minutos.\n", duracaoHoras, duracaoMinutosResto)
}

Este programa em Go realiza as mesmas operações que os programas anteriores, lendo os valores de entrada, calculando a duração do evento e exibindo o resultado. Go é uma linguagem compilada, concorrente e de tipagem estática, e sua sintaxe é mais simples e concisa em comparação com algumas outras linguagens.

Conclusão

Neste exercício, exploramos como resolver um problema simples de cálculo de duração de evento em diferentes linguagens de programação, como C++, C, Pascal, Python, C#, Java, Rust e Go. Ao escrever e comparar as soluções em várias linguagens, pudemos observar as diferentes sintaxes, abordagens e características de cada uma. A prática nos permitiu entender melhor como lidar com entrada/saída, fazer cálculos básicos, controlar o fluxo do programa e manipular tipos de dados em cada linguagem.

Beleza pessoal? Espero que tenham gostado!

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

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

#Programação

#DesenvolvimentoDeSoftware

#LinguagensDeProgramação

#GiovaniDaCruz

Menu do sistema

1. Adicionar item à pilha.
2. Remover item da pilha.
3. Sair do programa.

O programa deve permitir ao usuário escolher uma opção do menu. Ao selecionar a opção 1, o programa deve solicitar ao usuário que insira um caractere para ser adicionado à pilha. Ao selecionar a opção 2, o programa deve remover o último caractere adicionado à pilha e exibi-lo na tela. Caso a pilha esteja vazia, o programa deve informar ao usuário que a pilha está vazia. A opção 3 deve encerrar o programa.

Ao final de cada operação (adição ou remoção), o programa deve exibir o conteúdo atual da pilha.

Dica: Para c++, utilize a estrutura de dados stack da biblioteca padrão do C++ para implementar a pilha.

O que podemos aprender neste exercício?

Neste exercício, podemos aprender sobre o uso de pilhas e como implementar um programa simples que utiliza essa estrutura de dados. Além disso, podemos aprender sobre:

Interatividade do usuário: O exercício envolve a interação do usuário com o programa por meio de um menu de opções. Isso nos permite entender como criar interfaces simples para interagir com o usuário.

Manipulação de pilhas: A implementação do programa envolve a manipulação de uma pilha de caracteres, incluindo adição e remoção de elementos. Isso nos permite entender como trabalhar com pilhas na prática e entender seus métodos básicos, como push e pop.

Tratamento de erros: O programa lida com casos em que a pilha está vazia ao tentar remover um elemento. Isso nos ensina sobre como lidar com situações de erro e fornecer feedback adequado ao usuário.

Estrutura de repetição: O uso do loop do-while permite que o programa continue executando até que o usuário escolha a opção de saída. Isso nos ajuda a entender como criar estruturas de repetição controladas por usuário.

Organização do código: O código está estruturado de forma organizada, com funções separadas para diferentes funcionalidades, como impressão da pilha e manipulação do menu. Isso nos ensina sobre boas práticas de organização e modularização do código.

Vamos aos códigos!

Exemplo em C++

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

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

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

using namespace std;

void imprimePilha(stack<char> pilha) {
  cout << "-------" << endl;
  while (!pilha.empty()) {
    cout << "|  " << pilha.top() << "  |" << endl;
    cout << "-------" << endl;
    pilha.pop();
  }
}

int main() {
  stack<char> pilha;
  int opcao;

  do {
    cout << "\nSelecione uma opção:\n";
    cout << "1. Adicionar item\n";
    cout << "2. Remover item\n";
    cout << "3. Sair\n";
    cout << "Opção: ";
    cin >> opcao;

    switch (opcao) {
      case 1:
        char item;
        cout << "Digite o item a ser adicionado: ";
        cin >> item;
        pilha.push(item);
        cout << "Item adicionado!" << endl;
        break;

      case 2:
        if (pilha.empty()) {
          cout << "Pilha vazia!" << endl;
        } else {
          char elementoRemovido = pilha.top();
          pilha.pop();
          cout << "Item removido: " << elementoRemovido << endl;
        }
        break;

      case 3:
        cout << "Saindo..." << endl;
        break;

      default:
        cout << "Opção inválida!" << endl;
    }

    imprimePilha(pilha);
  } while (opcao != 3);

  return 0;
}

O programa implementa um menu para manipulação de uma pilha de caracteres em C++. As opções permitem adicionar e remover elementos da pilha, com validação para pilha vazia. O código utiliza um loop do-while para interação contínua com o usuário e uma função para imprimir visualmente a pilha.

Exemplo em Rust

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

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

*******************************************************************************/
use std::collections::LinkedList;
use std::io::{self, Write};

fn imprime_pilha(pilha: &LinkedList<char>) {
    println!("-------");
    for item in pilha.iter().rev() {
        println!("|  {}  |", item);
        println!("-------");
    }
}

fn main() {
    let mut pilha: LinkedList<char> = LinkedList::new();
    let mut opcao: i32;

    loop {
        println!("\nSelecione uma opção:");
        println!("1. Adicionar item");
        println!("2. Remover item");
        println!("3. Sair");
        print!("Opção: ");
        io::stdout().flush().unwrap();
        
        let mut input = String::new();
        io::stdin().read_line(&mut input).expect("Falha ao ler a entrada");
        opcao = input.trim().parse().expect("Entrada inválida");

        match opcao {
            1 => {
                print!("Digite o item a ser adicionado: ");
                io::stdout().flush().unwrap();
                let mut input = String::new();
                io::stdin().read_line(&mut input).expect("Falha ao ler a entrada");
                let item = input.trim().chars().next().expect("Entrada inválida");
                pilha.push_front(item);
                println!("Item adicionado!");
            },
            2 => {
                match pilha.pop_front() {
                    Some(item) => println!("Item removido: {}", item),
                    None => println!("Pilha vazia!"),
                }
            },
            3 => {
                println!("Saindo...");
                break;
            },
            _ => println!("Opção inválida!"),
        }

        imprime_pilha(&pilha);
    }
}

Este código em Rust utiliza a estrutura de dados LinkedList para representar a pilha. Ele apresenta um menu de opções ao usuário e permite adicionar e remover itens da pilha, além de sair do programa quando desejado.

Exemplo em Go

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

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

*******************************************************************************/
package main

import (
    "container/list"
    "fmt"
    "os"
    "os/exec"
)

func clearScreen() {
    cmd := exec.Command("cmd", "/c", "cls")
    cmd.Stdout = os.Stdout
    cmd.Run()
}

func imprimePilha(pilha *list.List) {
    clearScreen()
    fmt.Println("-------")
    for e := pilha.Front(); e != nil; e = e.Next() {
        fmt.Printf("|  %c  |\n", e.Value)
        fmt.Println("-------")
    }
}

func main() {
    pilha := list.New()

    for {
        fmt.Println("\nSelecione uma opção:")
        fmt.Println("1. Adicionar item")
        fmt.Println("2. Remover item")
        fmt.Println("3. Sair")
        fmt.Print("Opção: ")

        var opcao int
        fmt.Scanln(&opcao)

        switch opcao {
        case 1:
            var item rune
            fmt.Print("Digite o item a ser adicionado: ")
            fmt.Scanf("%c\n", &item)
            pilha.PushFront(item)
            fmt.Println("Item adicionado!")
        case 2:
            if pilha.Len() == 0 {
                fmt.Println("Pilha vazia!")
            } else {
                item := pilha.Remove(pilha.Front())
                fmt.Printf("Item removido: %c\n", item)
            }
        case 3:
            fmt.Println("Saindo...")
            return
        default:
            fmt.Println("Opção inválida!")
        }

        imprimePilha(pilha)
    }
}

Este código em Go realiza as mesmas operações que o programa em C++, utilizando a estrutura de dados list.List da biblioteca padrão. Ele apresenta um menu de opções ao usuário e permite adicionar e remover itens da pilha, além de sair do programa quando desejado. A função imprimePilha é responsável por exibir a pilha visualmente no console.

Conclusão

Este exercício proporcionou uma oportunidade valiosa de explorar a implementação de uma estrutura de dados fundamental, como uma pilha, em diferentes linguagens de programação. Além disso, pude destacar a importância de compreender os recursos e as bibliotecas disponíveis em cada linguagem para implementar soluções eficazes. Este exercício reforçou a compreensão dos conceitos fundamentais de programação e a habilidade de adaptar esses conceitos a diferentes ambientes de desenvolvimento.

Beleza pessoal? Espero que tenham gostado.

Dívidas ou sugestões? Deixe o seu comentário!

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

#Programação

#EstruturaDeDados

#DesafioDeProgramação

#GiovaniDaCruz

Fala galera da programação, tudo beleza?

Vamos resolver um desafio simples: encontrar o maior número entre cinco valores utilizando apenas uma variável. Que tal dar uma olhada nas diferentes abordagens em C, C++, Pascal, Python, C#, Java, Rust e Go.

Neste nosso exercício, a ideia é sem utilizar vetores, solicitar 5 números ao usuário, descobrir e mostrar o maior número lido.

O que podemos aprender neste exercício?

Este exercício em C++ oferece várias lições:

Uso eficiente de variáveis: Mostra como é possível realizar uma tarefa (encontrar o maior número entre cinco números) usando apenas uma variável (maior). Isso demonstra a importância de pensar de forma eficiente ao usar variáveis, evitando o uso desnecessário de memória.

Utilização de estruturas de controle: Demonstração do uso da estrutura de controle de repetição (loop for) para iterar sobre os cinco números e tomar decisões com base neles.

Lógica de programação: O exercício desenvolve a habilidade de pensar logicamente para resolver problemas. Neste caso, é necessário comparar cada número com o atual maior e, se for maior, atualizar o valor de maior.

Entrada e saída de dados: O programa envolve entrada de dados do usuário e exibição de resultados que são práticas comuns em programação.

Boas práticas de programação: Utilização de indentação, comentários explicativos e organização do código, que são boas práticas para tornar o código mais legível e compreensível.

Entendimento do conceito de variáveis: Ajuda a reforçar o conceito de variáveis e seu papel em armazenar dados durante a execução de um programa.

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 num;
    int maior;

    cout << "Digite o 1º número: ";
    cin >> maior; // Inicializa o maior com o primeiro número

    for(int i = 2; i <= 5; ++i) {
        cout << "Digite o " << i << "º número: ";
        cin >> num;
        if(num > maior) {
            maior = num; // Atualiza o maior se o número atual for maior
        }
    }

    cout << "O maior número é: " << maior << endl;

    return 0;
}

Neste programa, você inicializa a variável maior com o primeiro número lido e, em seguida, itera sobre os próximos quatro números. A cada iteração, você compara o número lido com o valor atual de maior e, se for maior, atualiza maior. No final, a variável maior conterá o maior número entre os cinco lidos.

Exemplo em C

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

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

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

int main() {
    int num;
    int maior;

    printf("Digite o 1º número: ");
    scanf("%d", &maior); // Inicializa o maior com o primeiro número

    for(int i = 2; i <= 5; ++i) {
        printf("Digite o %dº número: ", i);
        scanf("%d", &num);
        if(num > maior) {
            maior = num; // Atualiza o maior se o número atual for maior
        }
    }

    printf("O maior número é: %d\n", maior);

    return 0;
}

Este código em C faz exatamente a mesma coisa que o código em C++. Ele lê cinco números e encontra o maior entre eles, usando apenas a variável maior. As diferenças principais estão na forma como a entrada e a saída são tratadas, já que em C utilizamos printf e scanf em vez de cout e cin, respectivamente.

Exemplo em Pascal / Delphi / Lazarus

{

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

}
program MaiorNumero;

var
  num, maior, i: integer;

begin
  Write('Digite o 1º número: ');
  Readln(maior); // Inicializa o maior com o primeiro número

  for i := 2 to 5 do
  begin
    Write('Digite o ', i, 'º número: ');
    Readln(num);
    if num > maior then
      maior := num; // Atualiza o maior se o número atual for maior
  end;

  Writeln('O maior número é: ', maior);

end.

Este código em Pascal realiza a mesma tarefa que os códigos em C e C++. Ele lê cinco números e encontra o maior entre eles, utilizando apenas a variável maior. As principais diferenças estão na sintaxe da linguagem, como o uso de Write e Readln para entrada e saída, e a estrutura do loop for, que é diferente da de C e C++, utilizando a palavra-chave to para especificar o intervalo de valores.

Exemplo em Python

'''

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

'''
maior = int(input("Digite o 1º número: "))
for i in range(2, 6):
    num = int(input(f"Digite o {i}º número: "))
    if num > maior:
        maior = num

print("O maior número é:", maior)

Neste código em Python, utilizamos a função input() para obter os números inseridos pelo usuário. Utilizamos um loop for para iterar cinco vezes (de 2 a 5) e em cada iteração solicitamos um novo número. Em seguida, comparamos esse número com o atual maior e, se for maior, atualizamos o valor de maior. Por fim, exibimos o maior número encontrado. Python oferece uma sintaxe mais concisa e direta para realizar esta tarefa.

Exemplo em C# / C Sharp

using System;

class Program
{
    static void Main()
    {
        int maior;

        Console.Write("Digite o 1º número: ");
        maior = Convert.ToInt32(Console.ReadLine()); // Inicializa o maior com o primeiro número

        for (int i = 2; i <= 5; i++)
        {
            Console.Write("Digite o {0}º número: ", i);
            int num = Convert.ToInt32(Console.ReadLine());
            if (num > maior)
            {
                maior = num; // Atualiza o maior se o número atual for maior
            }
        }

        Console.WriteLine("O maior número é: " + maior);
    }
}

Este código em C# faz a mesma coisa que os exemplos anteriores. Ele lê cinco números e encontra o maior entre eles, utilizando apenas a variável maior. As diferenças principais estão na sintaxe da linguagem, como o uso de Console.WriteLine() e Console.ReadLine() para entrada e saída, e a declaração do loop for segue o padrão C#.

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 maior;

        System.out.print("Digite o 1º número: ");
        maior = scanner.nextInt(); // Inicializa o maior com o primeiro número

        for (int i = 2; i <= 5; i++) {
            System.out.print("Digite o " + i + "º número: ");
            int num = scanner.nextInt();
            if (num > maior) {
                maior = num; // Atualiza o maior se o número atual for maior
            }
        }

        System.out.println("O maior número é: " + maior);
        scanner.close();
    }
}

Neste código em Java, utilizamos a classe Scanner para obter os números inseridos pelo usuário. Assim como nos exemplos anteriores, usamos um loop for para iterar cinco vezes (de 2 a 5) e em cada iteração solicitamos um novo número. Em seguida, comparamos esse número com o atual maior e, se for maior, atualizamos o valor de maior. Por fim, exibimos o maior número encontrado.

Exemplo em Rust

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

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

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

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

    println!("Digite o 1º número: ");
    io::stdin().read_line(&mut maior).expect("Falha ao ler entrada.");
    let mut maior: i32 = maior.trim().parse().expect("Por favor, digite um número.");

    for i in 2..=5 {
        let mut input = String::new();
        println!("Digite o {}º número: ", i);
        io::stdin().read_line(&mut input).expect("Falha ao ler entrada.");
        let num: i32 = input.trim().parse().expect("Por favor, digite um número.");
        if num > maior {
            maior = num; // Atualiza o maior se o número atual for maior
        }
    }

    println!("O maior número é: {}", maior);
}

Neste código em Rust, utilizamos a biblioteca padrão std::io para obter os números inseridos pelo usuário. Assim como nos exemplos anteriores, usamos um loop for para iterar cinco vezes (de 2 a 5) e, em cada iteração, solicitamos um novo número. Em seguida, comparamos esse número com o atual maior e, se for maior, atualizamos o valor de maior. Por fim, exibimos o maior número encontrado. Rust é uma linguagem moderna que enfatiza a segurança e o desempenho, e este código demonstra a sua sintaxe robusta.

Exemplo em Go

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

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

*******************************************************************************/
package main

import (
    "fmt"
)

func main() {
    var maior int

    fmt.Print("Digite o 1º número: ")
    fmt.Scanln(&maior) // Inicializa o maior com o primeiro número

    for i := 2; i <= 5; i++ {
        var num int
        fmt.Printf("Digite o %dº número: ", i)
        fmt.Scanln(&num)
        if num > maior {
            maior = num // Atualiza o maior se o número atual for maior
        }
    }

    fmt.Println("O maior número é:", maior)
}

Neste código em Go, utilizamos o pacote fmt para entrada e saída de dados. Assim como nos exemplos anteriores, usamos um loop for para iterar cinco vezes (de 2 a 5) e em cada iteração solicitamos um novo número. Em seguida, comparamos esse número com o atual maior e, se for maior, atualizamos o valor de maior. Por fim, exibimos o maior número encontrado. Go é uma linguagem de programação eficiente e fácil de aprender, e este código demonstra sua sintaxe simples e concisa.

Beleza pessoal? Espero que tenham gostado.

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

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

#Programação

#LinguagensDeProgramação

#DesenvolvimentoDeSoftware

#Aprendizado

#GiovaniDaCruz

Fala galera da programação, tudo beleza? Novo algoritmo na área com o tema desvio condicional.

Hoje vamos explorar uma variedade de linguagens de programação! Comparando diferentes abordagens para resolver um problema simples: determinar se um número é zero, positivo ou negativo. Da sintaxe às estruturas condicionais, mergulhamos na essência de cada linguagem.

O que podemos aprender?

Lógica de Programação: Ao criar um programa simples para verificar se um número é zero, positivo ou negativo, praticamos conceitos básicos de lógica de programação, como estruturas condicionais e entrada/saída de dados.

Conversão de Tipos de Dados: Em algumas linguagens, como Python e Rust, é necessário converter a entrada do usuário de uma string para um tipo de dados numérico, como inteiro, usando funções como int() (Python) ou parse (Rust).

Diferenças entre Linguagens de Programação: Ao escrever o mesmo programa em várias linguagens, podemos observar as diferenças na sintaxe, nas convenções de nomenclatura e nas formas de entrada/saída de dados entre as linguagens.

Prática de Codificação: Este exercício oferece uma oportunidade de praticar a escrita de código em diferentes linguagens, o que é útil para desenvolver habilidades de codificação e familiaridade com diversas linguagens de programação.

Vamos aos códigos!

Exemplo em C++

#include <iostream>
using namespace std;

int main() {
    int numero;

    // Solicita ao usuário que insira um número
    cout << "Digite um numero: ";
    cin >> numero;

    // Verifica se o número é zero, positivo ou negativo e imprime a mensagem correspondente
    if (numero == 0) {
        cout << "Zero" << endl;
    } else if (numero > 0) {
        cout << "Positivo" << endl;
    } else {
        cout << "Negativo" << endl;
    }

    return 0;
}

Este programa solicitará ao usuário que insira um número, e então irá determinar se é zero, positivo ou negativo, e imprimirá a mensagem correspondente.

A estratégia utilizada para resolver esse exercício é bastante simples. Aqui está uma explicação passo a passo:

1. Solicitação de Entrada: O programa começa solicitando ao usuário que insira um número.
2. Leitura da Entrada: Em seguida, o programa lê o número inserido pelo usuário e armazena-o em uma variável.
3. Verificação: O programa verifica se o número é zero, positivo ou negativo.
4. Impressão da Mensagem Correspondente: Dependendo do resultado da verificação, o programa imprime a mensagem “Zero”, “Positivo” ou “Negativo”.
5. Fim do Programa: O programa termina.

Essencialmente, a estratégia é baseada em uma estrutura condicional (if-else) que compara o número inserido com zero e determina se é positivo ou negativo, e então imprime a mensagem correspondente.

Exemplo em C

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

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

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

int main() {
    int numero;

    // Solicita ao usuário que insira um número
    printf("Digite um numero: ");
    scanf("%d", &numero);

    // Verifica se o número é zero, positivo ou negativo e imprime a mensagem correspondente
    if (numero == 0) {
        printf("Zero\n");
    } else if (numero > 0) {
        printf("Positivo\n");
    } else {
        printf("Negativo\n");
    }

    return 0;
}

Neste programa em C, a lógica é a mesma que expliquei anteriormente para o programa em C++. Ele solicita ao usuário que insira um número, lê o número inserido, verifica se é zero, positivo ou negativo e imprime a mensagem correspondente.

No exemplo em C, a entrada de dados é realizada com a função scanf e a saída com printf, enquanto em C++, são utilizados cin e cout.

Exemplo em Pascal / Delphi / Lazarus

{

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

}
program VerificarNumero;
var
  numero: integer;

begin
  // Solicita ao usuário que insira um número
  writeln('Digite um numero: ');
  readln(numero);

  // Verifica se o número é zero, positivo ou negativo e imprime a mensagem correspondente
  if numero = 0 then
    writeln('Zero')
  else if numero > 0 then
    writeln('Positivo')
  else
    writeln('Negativo');
end.

Neste programa em Pascal, a lógica é a mesma que expliquei anteriormente para os programas em C e C++. Ele solicita ao usuário que insira um número, lê o número inserido, verifica se é zero, positivo ou negativo e imprime a mensagem correspondente.

Lembrando que em Pascal, as variáveis são declaradas com var, e a entrada/saída é feita com readln e writeln. As estruturas condicionais utilizam if, else, e os blocos são delimitados por begin e end.

Exemplo em Python

'''

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

'''
# Solicita ao usuário que insira um número
numero = int(input("Digite um número: "))

# Verifica se o número é zero, positivo ou negativo e imprime a mensagem correspondente
if numero == 0:
    print("Zero")
elif numero > 0:
    print("Positivo")
else:
    print("Negativo")

Em Python, a entrada é feita com a função input, que retorna uma string, então usamos int() para converter essa string em um número inteiro. A estrutura condicional é semelhante à do C/C++, mas em Python, não precisamos de parênteses e usamos : para indicar o início de um bloco de código. A função print é usada para exibir mensagens na tela.

Exemplo em C#

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

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

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

class Program
{
    static void Main(string[] args)
    {
        // Solicita ao usuário que insira um número
        Console.Write("Digite um número: ");
        int numero = Convert.ToInt32(Console.ReadLine());

        // Verifica se o número é zero, positivo ou negativo e imprime a mensagem correspondente
        if (numero == 0)
        {
            Console.WriteLine("Zero");
        }
        else if (numero > 0)
        {
            Console.WriteLine("Positivo");
        }
        else
        {
            Console.WriteLine("Negativo");
        }
    }
}

Em C#, a entrada é feita usando Console.ReadLine() para obter a entrada do usuário como uma string e Convert.ToInt32() para converter essa string em um número inteiro. A estrutura condicional é semelhante à do C/C++, e a função Console.WriteLine() é usada para exibir mensagens na tela.

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);

        // Solicita ao usuário que insira um número
        System.out.print("Digite um número: ");
        int numero = scanner.nextInt();

        // Verifica se o número é zero, positivo ou negativo e imprime a mensagem correspondente
        if (numero == 0) {
            System.out.println("Zero");
        } else if (numero > 0) {
            System.out.println("Positivo");
        } else {
            System.out.println("Negativo");
        }

        scanner.close();
    }
}

Em Java, usamos a classe Scanner para obter entrada do usuário. O método nextInt() é usado para ler um número inteiro. A estrutura condicional é semelhante à do C/C++, e System.out.println() é usada para exibir mensagens na tela.

Exemplo em Rust

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

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

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

fn main() {
    // Solicita ao usuário que insira um número
    println!("Digite um número:");
    let mut input = String::new();
    io::stdin().read_line(&mut input).expect("Falha ao ler entrada.");
    let numero: i32 = input.trim().parse().expect("Por favor, insira um número válido.");

    // Verifica se o número é zero, positivo ou negativo e imprime a mensagem correspondente
    if numero == 0 {
        println!("Zero");
    } else if numero > 0 {
        println!("Positivo");
    } else {
        println!("Negativo");
    }
}

Em Rust, usamos println! para exibir mensagens na tela e std::io para entrada de usuário. O método read_line é usado para ler uma linha da entrada do usuário, e parse é usado para converter a entrada em um número inteiro. A estrutura condicional é semelhante à do C/C++.

Exemplo em Go

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

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

*******************************************************************************/
package main

import (
    "fmt"
)

func main() {
    var numero int

    // Solicita ao usuário que insira um número
    fmt.Println("Digite um número:")
    fmt.Scanln(&numero)

    // Verifica se o número é zero, positivo ou negativo e imprime a mensagem correspondente
    if numero == 0 {
        fmt.Println("Zero")
    } else if numero > 0 {
        fmt.Println("Positivo")
    } else {
        fmt.Println("Negativo")
    }
}

Em Go, usamos fmt.Println() para exibir mensagens na tela e fmt.Scanln() para entrada de usuário. A estrutura condicional é semelhante à do C/C++.

Conclusão

Este exercício nos proporcionou uma valiosa oportunidade de explorar e comparar diferentes linguagens de programação ao resolver o mesmo problema básico: determinar se um número é zero, positivo ou negativo. Ao escrever o código em várias linguagens, pudemos observar as diferenças na sintaxe, nas convenções de nomenclatura, nas bibliotecas padrão e nos estilos de programação de cada linguagem.

Além disso, ao comparar as implementações, pudemos refletir sobre conceitos mais amplos de programação, como estruturas condicionais, entrada/saída de dados, conversão de tipos e eficiência de código. Essa análise nos ajudou a entender melhor as características e os pontos fortes de cada linguagem, bem como a desenvolver uma compreensão mais profunda de princípios fundamentais de programação e engenharia de software.

Portanto, este exercício não apenas nos permitiu praticar a lógica de programação, mas também nos proporcionou uma valiosa oportunidade de aprendizado sobre a codificação em várias linguagens.

Beleza pessoal? Espero que tenham gostado.

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

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

#Programação

#LinguagensDeProgramação

#Comparação

#Aprendizado

#GiovaniDaCruz

Fala galera da programação, tudo beleza?

Hoje vamos descubra como este simples exercício de programação em várias linguagens pode fortalecer suas habilidades de codificação! Aprenda a calcular médias de notas e determinar a aprovação ou reprovação de alunos em C++, C, Pascal, Python, C#, Java, Rust e Go.

O que podemos aprender neste exercício?

Este exercício proporciona uma oportunidade para aprender e praticar os seguintes conceitos:

1. Entrada e Saída de Dados: Você aprendeu várias maneiras de interagir com o usuário para obter informações através de entrada de dados e exibir resultados por meio de saída de dados.
2. Cálculos Simples: Você implementou um cálculo básico para encontrar a média aritmética das notas fornecidas pelo usuário.
3. Estruturas de Controle: Utilizou estruturas de decisão (como if e else) para determinar se o aluno estava aprovado ou reprovado com base na média calculada.
4. Lidando com Erros e Exceções: Em algumas linguagens, como Python e Go, foi necessário lidar com a possibilidade de entrada de dados inválida ou inesperada, garantindo que o programa continuasse funcionando corretamente.
5. Prática de Sintaxe: Este exercício permitiu praticar a sintaxe básica das linguagens de programação usadas (C++, C, Pascal, Python, C#, Java, Rust e Go).

Além disso, ao comparar a implementação do mesmo problema em várias linguagens, você pode notar diferenças e semelhanças na sintaxe, paradigmas de programação e ferramentas disponíveis em cada uma delas. Isso pode ajudá-lo a entender melhor as características únicas de cada linguagem e a tomar decisões mais informadas sobre qual usar em diferentes situações.

Vamos aos códigos!

Exemplo em C++

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

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

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

using namespace std;

int main() {
    float nota1, nota2, nota3;
    float media;

    // Solicita as notas ao usuário
    cout << "Digite a primeira nota: ";
    cin >> nota1;

    cout << "Digite a segunda nota: ";
    cin >> nota2;

    cout << "Digite a terceira nota: ";
    cin >> nota3;

    // Calcula a média aritmética
    media = (nota1 + nota2 + nota3) / 3;

    // Verifica se o aluno está aprovado ou reprovado
    if (media >= 6.0) {
        cout << "APROVADO" << endl;
    } else {
        cout << "REPROVADO" << endl;
    }

    return 0;
}

Este programa solicita ao usuário que insira as três notas do aluno e, em seguida, calcula a média aritmética dessas notas. Com base na média calculada, ele imprime “APROVADO” se a média for maior ou igual a 6, caso contrário, imprime “REPROVADO”.

A estratégia utilizada neste programa é bastante direta:

1. Entrada de Dados: O programa solicita ao usuário que insira as três notas do aluno, armazenando cada uma delas em variáveis separadas (nota1, nota2 e nota3).
2. Cálculo da Média: Em seguida, o programa calcula a média aritmética das três notas, somando-as e dividindo o resultado por 3. O valor da média é armazenado na variável media.
3. Decisão de Aprovação ou Reprovação: O programa verifica se a média calculada é maior ou igual a 6. Se for, o programa imprime “APROVADO”. Caso contrário, imprime “REPROVADO”.
4. Saída de Dados: O resultado da aprovação ou reprovação é exibido na tela.

Essa estratégia segue de perto o enunciado do problema, que basicamente envolve a entrada de dados (notas), o cálculo da média e a decisão baseada nessa média.

Exemplo em C

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

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

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

int main() {
    float nota1, nota2, nota3;
    float media;

    // Solicita as notas ao usuário
    printf("Digite a primeira nota: ");
    scanf("%f", &nota1);

    printf("Digite a segunda nota: ");
    scanf("%f", &nota2);

    printf("Digite a terceira nota: ");
    scanf("%f", &nota3);

    // Calcula a média aritmética
    media = (nota1 + nota2 + nota3) / 3;

    // Verifica se o aluno está aprovado ou reprovado
    if (media >= 6.0) {
        printf("APROVADO\n");
    } else {
        printf("REPROVADO\n");
    }

    return 0;
}

Neste programa em C, as funções printf() e scanf() são usadas para entrada e saída de dados, respectivamente. A lógica geral do programa permanece a mesma que na versão em C++, mas a sintaxe e algumas das funções utilizadas são diferentes para se adequarem à linguagem C.

Exemplo em Pascal / Delphi / Lazarus

(*

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

*)
program VerificaAprovacao;

var
  nota1, nota2, nota3: real;
  media: real;

begin
  // Solicita as notas ao usuário
  writeln('Digite a primeira nota: ');
  readln(nota1);

  writeln('Digite a segunda nota: ');
  readln(nota2);

  writeln('Digite a terceira nota: ');
  readln(nota3);

  // Calcula a média aritmética
  media := (nota1 + nota2 + nota3) / 3;

  // Verifica se o aluno está aprovado ou reprovado
  if media >= 6.0 then
    writeln('APROVADO')
  else
    writeln('REPROVADO');
end.

Neste programa em Pascal, usamos as instruções writeln e readln para entrada e saída de dados, respectivamente. O cálculo da média e a lógica de decisão são semelhantes aos programas anteriores, mas adaptados à sintaxe do Pascal.

Exemplo em Python

'''

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

'''
# Solicita as notas ao usuário
nota1 = float(input("Digite a primeira nota: "))
nota2 = float(input("Digite a segunda nota: "))
nota3 = float(input("Digite a terceira nota: "))

# Calcula a média aritmética
media = (nota1 + nota2 + nota3) / 3

# Verifica se o aluno está aprovado ou reprovado
if media >= 6.0:
    print("APROVADO")
else:
    print("REPROVADO")

Em Python, a entrada de dados é feita com a função input(), que retorna uma string, então usamos a função float() para converter a entrada em números de ponto flutuante. O cálculo da média e a lógica de decisão são bastante diretos e semelhantes aos outros exemplos.

Exemplo em C# / C Sharp

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

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

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

class Program
{
    static void Main(string[] args)
    {
        float nota1, nota2, nota3;
        float media;

        // Solicita as notas ao usuário
        Console.Write("Digite a primeira nota: ");
        nota1 = float.Parse(Console.ReadLine());

        Console.Write("Digite a segunda nota: ");
        nota2 = float.Parse(Console.ReadLine());

        Console.Write("Digite a terceira nota: ");
        nota3 = float.Parse(Console.ReadLine());

        // Calcula a média aritmética
        media = (nota1 + nota2 + nota3) / 3;

        // Verifica se o aluno está aprovado ou reprovado
        if (media >= 6.0)
        {
            Console.WriteLine("APROVADO");
        }
        else
        {
            Console.WriteLine("REPROVADO");
        }
    }
}

Em C#, utilizamos a classe Console para entrada e saída de dados. A entrada é feita com Console.ReadLine(), e a conversão para float é realizada com float.Parse(). O restante do programa é semelhante à lógica dos exemplos anteriores.

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);
        float nota1, nota2, nota3;
        float media;

        // Solicita as notas ao usuário
        System.out.print("Digite a primeira nota: ");
        nota1 = scanner.nextFloat();

        System.out.print("Digite a segunda nota: ");
        nota2 = scanner.nextFloat();

        System.out.print("Digite a terceira nota: ");
        nota3 = scanner.nextFloat();

        // Calcula a média aritmética
        media = (nota1 + nota2 + nota3) / 3;

        // Verifica se o aluno está aprovado ou reprovado
        if (media >= 6.0) {
            System.out.println("APROVADO");
        } else {
            System.out.println("REPROVADO");
        }

        scanner.close();
    }
}

Em Java, utilizamos a classe Scanner para entrada de dados. As notas são lidas com o método nextFloat() e armazenadas em variáveis de tipo float. O restante do programa é semelhante à lógica dos exemplos anteriores. É importante fechar o objeto Scanner no final para liberar recursos.

Exemplo em Rust

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

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

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

fn main() {
    let mut input = String::new();
    let mut notas = Vec::new();

    // Solicita as notas ao usuário
    println!("Digite a primeira nota:");
    io::stdin().read_line(&mut input).expect("Falha ao ler a linha");
    let nota1: f32 = input.trim().parse().expect("Por favor, insira um número válido");
    notas.push(nota1);

    input.clear();

    println!("Digite a segunda nota:");
    io::stdin().read_line(&mut input).expect("Falha ao ler a linha");
    let nota2: f32 = input.trim().parse().expect("Por favor, insira um número válido");
    notas.push(nota2);

    input.clear();

    println!("Digite a terceira nota:");
    io::stdin().read_line(&mut input).expect("Falha ao ler a linha");
    let nota3: f32 = input.trim().parse().expect("Por favor, insira um número válido");
    notas.push(nota3);

    // Calcula a média aritmética
    let media: f32 = notas.iter().sum::<f32>() / 3.0;

    // Verifica se o aluno está aprovado ou reprovado
    if media >= 6.0 {
        println!("APROVADO");
    } else {
        println!("REPROVADO");
    }
}

Neste código em Rust, usamos a macro println! para imprimir mensagens no console e io::stdin().read_line() para ler as entradas do usuário. Os valores lidos são convertidos em f32 e armazenados em um vetor. Em seguida, calculamos a média aritmética usando o método iter().sum::<f32>() e verificamos se o aluno está aprovado ou reprovado.

Exemplo em Go

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

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

*******************************************************************************/
package main

import (
    "fmt"
    "strconv"
)

func main() {
    var nota1, nota2, nota3 float64

    // Solicita as notas ao usuário
    fmt.Println("Digite a primeira nota:")
    nota1 = lerNota()

    fmt.Println("Digite a segunda nota:")
    nota2 = lerNota()

    fmt.Println("Digite a terceira nota:")
    nota3 = lerNota()

    // Calcula a média aritmética
    media := (nota1 + nota2 + nota3) / 3.0

    // Verifica se o aluno está aprovado ou reprovado
    if media >= 6.0 {
        fmt.Println("APROVADO")
    } else {
        fmt.Println("REPROVADO")
    }
}

// Função para ler notas do usuário
func lerNota() float64 {
    var input string
    fmt.Scanln(&input)
    nota, err := strconv.ParseFloat(input, 64)
    if err != nil {
        fmt.Println("Erro ao ler a nota:", err)
        return lerNota()
    }
    return nota
}

Neste programa em Go, usamos a função fmt.Println() para exibir mensagens no console e fmt.Scanln() para ler as entradas do usuário. Para garantir que a entrada seja um número válido, usamos strconv.ParseFloat(). O cálculo da média aritmética e a verificação da aprovação ou reprovação são feitos da mesma forma que nos exemplos anteriores.

Conclusão

O exercício de implementar um programa para calcular a média de notas de um aluno e determinar se ele está aprovado ou reprovado foi uma excelente oportunidade para explorar conceitos fundamentais de programação em diferentes linguagens. Ao escrever o código em várias linguagens, pudemos comparar e contrastar suas sintaxes, estruturas de controle e abordagens para lidar com entrada e saída de dados.

Por meio deste exercício, consolidamos nosso conhecimento sobre como solicitar entrada de dados do usuário, realizar cálculos simples e tomar decisões com base nos resultados. Além disso, aprendemos a lidar com erros e exceções, garantindo a robustez e a confiabilidade de nossos programas.

Ao analisar as diferentes implementações em linguagens como C++, C, Pascal, Python, C#, Java, Rust e Go, pudemos apreciar a diversidade de abordagens que cada linguagem oferece para resolver o mesmo problema.

No geral, este exercício proporcionou uma valiosa oportunidade de prática e aprendizado, ajudando-nos a aprimorar nossas habilidades de programação e a compreender melhor as nuances das diferentes linguagens de programação. Essa experiência será útil ao enfrentarmos desafios futuros de programação em uma variedade de contextos.

Beleza pessoal? Espero que tenham gostado.

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

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

#Algoritmos

#Programação

#Aprendizado

#LinguagensDeProgramação

#DesenvolvimentoDeSoftware

#GiovaniDaCruz

Fala galera da programação, tudo beleza?

O exercício pede para verificar se o número lido possui determinada característica. Ela é conhecida como “Número Kaprekar”. Um número de Kaprekar é um inteiro positivo cuja representação em quadrados de seus dígitos pode ser dividida em duas partes que somam o número original quando somadas. O exemplo citado, 3025, é um número de Kaprekar, pois 30 + 25 = 55, e 552 = 3025.

Lembrando que o objetivo deste exercício é ler número de 4 dígitos e descobrir se ele é um número de Kaprekar.

Dica do Exercício

Para dividir um número de quatro dígitos em duas partes de dois dígitos, divida este número por 100 e pegue o quociente e o resto da divisão.

Valide que o número informado tenha 4 dígitos;

Se ele for um número escreva: O número xx possui a característica desejada.
Senão escreva: O número xx não possui a característica desejada

O que vamos aprender neste exercício?

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 numero, parte1, parte2;

    // Solicitar ao usuário para inserir o número inteiro de quatro dígitos
    cout << "Digite um número inteiro de quatro dígitos: ";
    cin >> numero;

    // Verificar se o número tem quatro dígitos
    if (numero < 1000 || numero > 9999) {
        cout << "O número digitado não possui quatro dígitos." << endl;
    } else {
        // Dividir o número em duas partes de dois dígitos
        parte1 = numero / 100;
        parte2 = numero % 100;

        // Verificar se a soma das partes elevada ao quadrado é igual ao número original
        if ((parte1 + parte2) * (parte1 + parte2) == numero) {
            cout << "O número " << numero << " possui a característica desejada." << endl;
        } else {
            cout << "O número " << numero << " não possui a característica desejada." << endl;
        }
    }

    return 0;
}

Explicação:

Este programa solicita ao usuário para inserir um número inteiro de quatro dígitos. Em seguida, ele verifica se o número inserido possui quatro dígitos. Se tiver, o programa divide o número em duas partes de dois dígitos e verifica se a soma dessas partes elevada ao quadrado é igual ao número original. Ele então imprime uma mensagem indicando se o número possui ou não a característica desejada.

A estratégia usada no código pode ser dividida em alguns passos:

1. Entrada de Dados: O programa solicita ao usuário que insira um número inteiro de quatro dígitos.
2. Verificação de Quatro Dígitos: O programa verifica se o número inserido pelo usuário possui quatro dígitos. Se não possuir, o programa informa ao usuário que o número não é válido e encerra a execução.
3. Divisão do Número em Duas Partes: Se o número tiver quatro dígitos, o programa divide o número em duas partes de dois dígitos. Isso é feito dividindo o número por 100 (parte1) e obtendo o resto dessa divisão (parte2).
4. Verificação da Característica de Kaprekar: O programa verifica se a soma das partes, elevada ao quadrado, é igual ao número original. Se essa condição for verdadeira, o número possui a característica de Kaprekar e o programa informa ao usuário. Caso contrário, o programa informa que o número não possui a característica.

A estratégia geral do código é bastante simples: dividir o número em partes, realizar algumas operações e verificar se uma condição específica é atendida.

Exemplo em C

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

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

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

int main() {
    int numero, parte1, parte2;

    // Solicitar ao usuário para inserir o número inteiro de quatro dígitos
    printf("Digite um número inteiro de quatro dígitos: ");
    scanf("%d", &numero);

    // Verificar se o número tem quatro dígitos
    if (numero < 1000 || numero > 9999) {
        printf("O número digitado não possui quatro dígitos.\n");
    } else {
        // Dividir o número em duas partes de dois dígitos
        parte1 = numero / 100;
        parte2 = numero % 100;

        // Verificar se a soma das partes elevada ao quadrado é igual ao número original
        if ((parte1 + parte2) * (parte1 + parte2) == numero) {
            printf("O número %d possui a característica desejada.\n", numero);
        } else {
            printf("O número %d não possui a característica desejada.\n", numero);
        }
    }

    return 0;
}

Este código em C realiza exatamente as mesmas operações que o código em C++ fornecido anteriormente, mas usando a sintaxe da linguagem C.

Exemplo em Pascal / Delphi / Lazarus

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

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

*******************************************************************************)
program VerificarKaprekar;

var
  numero, parte1, parte2: integer;

begin
  // Solicitar ao usuário para inserir o número inteiro de quatro dígitos
  writeln('Digite um número inteiro de quatro dígitos: ');
  readln(numero);

  // Verificar se o número tem quatro dígitos
  if (numero < 1000) or (numero > 9999) then
    writeln('O número digitado não possui quatro dígitos.')
  else
  begin
    // Dividir o número em duas partes de dois dígitos
    parte1 := numero div 100;
    parte2 := numero mod 100;

    // Verificar se a soma das partes elevada ao quadrado é igual ao número original
    if (parte1 + parte2) * (parte1 + parte2) = numero then
      writeln('O número ', numero, ' possui a característica desejada.')
    else
      writeln('O número ', numero, ' não possui a característica desejada.');
  end;
end.

As principais mudanças para o código em Pascal incluem a utilização de writeln e readln para entrada e saída de dados, e begin e end para delimitar blocos de código. Os operadores de divisão inteira (div) e resto (mod) são usados para dividir o número em duas partes de dois dígitos, assim como no código em C e C++. Fora essas diferenças sintáticas, a lógica do programa permanece a mesma.

Exemplo em Python

'''

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

'''
# Solicitar ao usuário para inserir o número inteiro de quatro dígitos
numero = int(input("Digite um número inteiro de quatro dígitos: "))

# Verificar se o número tem quatro dígitos
if numero < 1000 or numero > 9999:
    print("O número digitado não possui quatro dígitos.")
else:
    # Dividir o número em duas partes de dois dígitos
    parte1 = numero // 100
    parte2 = numero % 100

    # Verificar se a soma das partes elevada ao quadrado é igual ao número original
    if (parte1 + parte2) ** 2 == numero:
        print(f"O número {numero} possui a característica desejada.")
    else:
        print(f"O número {numero} não possui a característica desejada.")

As principais mudanças para o código em Python incluem a sintaxe para entrada de dados utilizando a função input(), que retorna uma string (portanto, precisamos converter para inteiro usando int()), e a utilização de print() para exibir mensagens na tela. Além disso, em Python, a divisão inteira é realizada com // e o operador de resto é %. Fora essas diferenças sintáticas, a lógica do programa permanece a mesma.

Exemplo em C# / C Sharp

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

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

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

class Program
{
    static void Main(string[] args)
    {
        // Solicitar ao usuário para inserir o número inteiro de quatro dígitos
        Console.WriteLine("Digite um número inteiro de quatro dígitos: ");
        int numero = int.Parse(Console.ReadLine());

        // Verificar se o número tem quatro dígitos
        if (numero < 1000 || numero > 9999)
        {
            Console.WriteLine("O número digitado não possui quatro dígitos.");
        }
        else
        {
            // Dividir o número em duas partes de dois dígitos
            int parte1 = numero / 100;
            int parte2 = numero % 100;

            // Verificar se a soma das partes elevada ao quadrado é igual ao número original
            if ((parte1 + parte2) * (parte1 + parte2) == numero)
            {
                Console.WriteLine($"O número {numero} possui a característica desejada.");
            }
            else
            {
                Console.WriteLine($"O número {numero} não possui a característica desejada.");
            }
        }
    }
}

As principais mudanças para o código em C# incluem o uso de Console.WriteLine() para exibir mensagens na tela e Console.ReadLine() para ler a entrada do usuário. O resto da lógica é bastante similar aos códigos anteriores, utilizando operadores aritméticos para dividir o número em partes e verificar a característica desejada.

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);

        // Solicitar ao usuário para inserir o número inteiro de quatro dígitos
        System.out.println("Digite um número inteiro de quatro dígitos: ");
        int numero = scanner.nextInt();

        // Verificar se o número tem quatro dígitos
        if (numero < 1000 || numero > 9999) {
            System.out.println("O número digitado não possui quatro dígitos.");
        } else {
            // Dividir o número em duas partes de dois dígitos
            int parte1 = numero / 100;
            int parte2 = numero % 100;

            // Verificar se a soma das partes elevada ao quadrado é igual ao número original
            if ((parte1 + parte2) * (parte1 + parte2) == numero) {
                System.out.println("O número " + numero + " possui a característica desejada.");
            } else {
                System.out.println("O número " + numero + " não possui a característica desejada.");
            }
        }
        
        scanner.close();
    }
}

As principais mudanças para o código em Java incluem o uso da classe Scanner para ler a entrada do usuário, e o uso de System.out.println() para exibir mensagens na tela. Além disso, a estrutura da classe e do método main é diferente em Java, mas a lógica do programa é a mesma que nos exemplos anteriores.

Exemplo em Rust

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

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

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

fn main() {
    // Solicitar ao usuário para inserir o número inteiro de quatro dígitos
    println!("Digite um número inteiro de quatro dígitos: ");

    let mut input = String::new();
    io::stdin().read_line(&mut input).expect("Falha ao ler entrada.");
    let numero: i32 = input.trim().parse().expect("Entrada inválida.");

    // Verificar se o número tem quatro dígitos
    if numero < 1000 || numero > 9999 {
        println!("O número digitado não possui quatro dígitos.");
    } else {
        // Dividir o número em duas partes de dois dígitos
        let parte1 = numero / 100;
        let parte2 = numero % 100;

        // Verificar se a soma das partes elevada ao quadrado é igual ao número original
        if (parte1 + parte2) * (parte1 + parte2) == numero {
            println!("O número {} possui a característica desejada.", numero);
        } else {
            println!("O número {} não possui a característica desejada.", numero);
        }
    }
}

As principais mudanças para o código em Rust incluem o uso de macros println! para exibir mensagens na tela e read_line para ler a entrada do usuário. Além disso, a manipulação de erros é feita usando expect ou tratamento de erro com Result, o que é uma prática comum em Rust para lidar com possíveis falhas durante a execução do programa. A sintaxe para declarar variáveis e a utilização de tipos é ligeiramente diferente, mas a lógica geral do programa é a mesma que nos exemplos anteriores.

Exemplo em GO

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

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

*******************************************************************************/
package main

import (
    "fmt"
)

func main() {
    var numero int

    // Solicitar ao usuário para inserir o número inteiro de quatro dígitos
    fmt.Println("Digite um número inteiro de quatro dígitos: ")
    fmt.Scanln(&numero)

    // Verificar se o número tem quatro dígitos
    if numero < 1000 || numero > 9999 {
        fmt.Println("O número digitado não possui quatro dígitos.")
    } else {
        // Dividir o número em duas partes de dois dígitos
        parte1 := numero / 100
        parte2 := numero % 100

        // Verificar se a soma das partes elevada ao quadrado é igual ao número original
        if (parte1+parte2)*(parte1+parte2) == numero {
            fmt.Printf("O número %d possui a característica desejada.\n", numero)
        } else {
            fmt.Printf("O número %d não possui a característica desejada.\n", numero)
        }
    }
}

As principais diferenças em relação aos outros exemplos são:

• Utilização do pacote fmt para impressão na tela e entrada de dados.
• Utilização da função Scanln para ler a entrada do usuário.
• Sintaxe específica de declaração de variáveis e divisão de números.
• Não há necessidade de importar um pacote específico para lidar com entrada e saída de dados, pois o pacote fmt já inclui essas funcionalidades.

Conclusão

Este exercício foi uma oportunidade valiosa para praticar e aplicar diversos conceitos fundamentais de programação. Ao escrever um programa para verificar se um número inteiro de quatro dígitos possui uma determinada característica matemática, pudemos praticar habilidades como manipulação de números, entrada e saída de dados, controle de fluxo e resolução de problemas.

Além disso, ao escrever o mesmo programa em várias linguagens de programação, como C++, Python, Java, C#, Rust, Go e Pascal, pudemos comparar e contrastar as diferenças entre essas linguagens, incluindo sintaxe, convenções de nomenclatura e recursos disponíveis. Isso nos permitiu ampliar nossa compreensão sobre as diferentes abordagens para resolver um problema semelhante em diferentes contextos de programação.

Em última análise, este exercício destacou a importância da prática contínua na construção e aprimoramento das habilidades de programação, bem como a versatilidade e adaptabilidade necessárias para trabalhar em várias linguagens de programação.

Beleza pessoal? Espero que tenham gostado.

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

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

#DesafioDeProgramação

#Programação

#DesenvolvimentoDeSoftware

#Aprendizado

#GiovaniDaCruz

Fala galera da programação, tudo beleza? Hoje um novo exercício de calculadora para aprimorar nossa lógica de programação.

Dicas do exercício

Em duas situações, o programa não deverá efetuar o cálculo:

Se o operador informado pelo usuário for inválido mostrar a mensagem “Operador inválido” e encerrar a execução do programa.

Se o segundo operando for igual a 0 (zero) e o operador escolhido for a divisão (/), mostrar na tela a mensagem “Divisão por Zero!” e encerrar a execução do programa.

[table id=3 /]

Exemplo em C++

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

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

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

using namespace std;

int main() {
    float num1, num2, resultado;
    char operador;

    // Solicitar entrada do usuário
    cout << "Digite o primeiro operando: ";
    cin >> num1;
    cout << "Digite o operador (+, -, *, /): ";
    cin >> operador;
    cout << "Digite o segundo operando: ";
    cin >> num2;

    // Verificar se o operador é válido e efetuar o cálculo
    switch(operador) {
        case '+':
            resultado = num1 + num2;
            break;
        case '-':
            resultado = num1 - num2;
            break;
        case '*':
            resultado = num1 * num2;
            break;
        case '/':
            // Verificar se o segundo operando é zero
            if (num2 == 0) {
                cout << "Divisao por Zero!" << endl;
                return 1; // Encerrar o programa
            }
            resultado = num1 / num2;
            break;
        default:
            cout << "Operador invalido" << endl;
            return 1; // Encerrar o programa
    }

    // Mostrar o resultado na tela
    cout << num1 << " " << operador << " " << num2 << " = " << resultado << endl;

    return 0;
}

Este programa solicita que o usuário insira o primeiro operando, o operador e o segundo operando. Em seguida, verifica se o operador é válido e se o segundo operando é zero (no caso da divisão). Dependendo das condições, exibirá uma mensagem de erro apropriada ou calculará e exibirá o resultado da operação.

A estratégia utilizada neste programa foi:

1. Solicitar ao usuário que forneça o primeiro operando, o operador e o segundo operando.
2. Utilizar um switch-case para verificar o operador inserido pelo usuário e executar a operação correspondente.
3. Se o operador for inválido (ou seja, diferente de ‘+’, ‘-‘, ‘*’, ‘/’), exibir a mensagem “Operador inválido” e encerrar a execução do programa.
4. Se o operador for ‘/’, verificar se o segundo operando é zero. Se for zero, exibir a mensagem “Divisão por Zero!” e encerrar a execução do programa.
5. Calcular o resultado da operação e exibi-lo na tela.

Essa abordagem permite que o programa valide as entradas do usuário e forneça mensagens de erro apropriadas quando necessário, garantindo que a calculadora funcione corretamente para as operações de adição, subtração, multiplicação e divisão.

Exemplo em C

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

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

*******************************************************************************/
#include 

int main() {
    float num1, num2, resultado;
    char operador;

    // Solicitar entrada do usuário
    printf("Digite o primeiro operando: ");
    scanf("%f", &num1);
    printf("Digite o operador (+, -, *, /): ");
    scanf(" %c", &operador); // Note o espaço antes do %c para ignorar espaços em branco
    printf("Digite o segundo operando: ");
    scanf("%f", &num2);

    // Verificar se o operador é válido e efetuar o cálculo
    switch(operador) {
        case '+':
            resultado = num1 + num2;
            break;
        case '-':
            resultado = num1 - num2;
            break;
        case '*':
            resultado = num1 * num2;
            break;
        case '/':
            // Verificar se o segundo operando é zero
            if (num2 == 0) {
                printf("Divisao por Zero!\n");
                return 1; // Encerrar o programa
            }
            resultado = num1 / num2;
            break;
        default:
            printf("Operador invalido\n");
            return 1; // Encerrar o programa
    }

    // Mostrar o resultado na tela
    printf("%.2f %c %.2f = %.2f\n", num1, operador, num2, resultado);

    return 0;
}

Este programa realiza exatamente as mesmas operações que o anterior, mas utilizando as funções de entrada e saída padrão em C (scanf e printf) e a sintaxe da linguagem C.

Exemplo em Pascal / Delphi / Lazarus

{

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

}
program Calculadora;

var
  num1, num2, resultado: real;
  operador: char;

begin
  // Solicitar entrada do usuário
  writeln('Digite o primeiro operando: ');
  readln(num1);
  writeln('Digite o operador (+, -, *, /): ');
  readln(operador);
  writeln('Digite o segundo operando: ');
  readln(num2);

  // Verificar se o operador é válido e efetuar o cálculo
  case operador of
    '+': resultado := num1 + num2;
    '-': resultado := num1 - num2;
    '*': resultado := num1 * num2;
    '/': begin
          // Verificar se o segundo operando é zero
          if num2 = 0 then
          begin
            writeln('Divisao por Zero!');
            exit; // Encerrar o programa
          end;
          resultado := num1 / num2;
        end;
  else
    begin
      writeln('Operador invalido');
      exit; // Encerrar o programa
    end;
  end;

  // Mostrar o resultado na tela
  writeln(num1, ' ', operador, ' ', num2, ' = ', resultado:0:2);
end.

Este código em Pascal funciona de forma muito semelhante ao código em C/C++. Ele solicita que o usuário insira os operandos e o operador, verifica se o operador é válido, realiza o cálculo correspondente e exibe o resultado. Além disso, ele lida com a divisão por zero e exibe mensagens de erro apropriadas conforme necessário.

Exemplo Python

'''

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

'''
# Solicitar entrada do usuário
num1 = float(input("Digite o primeiro operando: "))
operador = input("Digite o operador (+, -, *, /): ")
num2 = float(input("Digite o segundo operando: "))

# Verificar se o operador é válido e efetuar o cálculo
if operador == '+':
    resultado = num1 + num2
elif operador == '-':
    resultado = num1 - num2
elif operador == '*':
    resultado = num1 * num2
elif operador == '/':
    # Verificar se o segundo operando é zero
    if num2 == 0:
        print("Divisao por Zero!")
        exit()  # Encerrar o programa
    resultado = num1 / num2
else:
    print("Operador invalido")
    exit()  # Encerrar o programa

# Mostrar o resultado na tela
print(f"{num1} {operador} {num2} = {resultado}")

Este código em Python solicita que o usuário insira os operandos e o operador, verifica se o operador é válido, realiza o cálculo correspondente e exibe o resultado. Além disso, ele lida com a divisão por zero e exibe mensagens de erro apropriadas conforme necessário.

Exemplo C# / C Sharp

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

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

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

class Program
{
    static void Main(string[] args)
    {
        float num1, num2, resultado;
        char operador;

        // Solicitar entrada do usuário
        Console.Write("Digite o primeiro operando: ");
        num1 = float.Parse(Console.ReadLine());
        Console.Write("Digite o operador (+, -, *, /): ");
        operador = char.Parse(Console.ReadLine());
        Console.Write("Digite o segundo operando: ");
        num2 = float.Parse(Console.ReadLine());

        // Verificar se o operador é válido e efetuar o cálculo
        switch (operador)
        {
            case '+':
                resultado = num1 + num2;
                break;
            case '-':
                resultado = num1 - num2;
                break;
            case '*':
                resultado = num1 * num2;
                break;
            case '/':
                // Verificar se o segundo operando é zero
                if (num2 == 0)
                {
                    Console.WriteLine("Divisao por Zero!");
                    return; // Encerrar o programa
                }
                resultado = num1 / num2;
                break;
            default:
                Console.WriteLine("Operador invalido");
                return; // Encerrar o programa
        }

        // Mostrar o resultado na tela
        Console.WriteLine($"{num1} {operador} {num2} = {resultado}");
    }
}

Este programa em C# funciona de maneira semelhante aos programas em C e C++, mas utiliza as funcionalidades da linguagem C#. Ele solicita que o usuário insira os operandos e o operador, verifica se o operador é válido, realiza o cálculo correspondente e exibe o resultado. Além disso, ele lida com a divisão por zero e exibe mensagens de erro apropriadas conforme necessário.

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);
        float num1, num2, resultado;
        char operador;

        // Solicitar entrada do usuário
        System.out.print("Digite o primeiro operando: ");
        num1 = scanner.nextFloat();
        System.out.print("Digite o operador (+, -, *, /): ");
        operador = scanner.next().charAt(0);
        System.out.print("Digite o segundo operando: ");
        num2 = scanner.nextFloat();

        // Verificar se o operador é válido e efetuar o cálculo
        switch (operador) {
            case '+':
                resultado = num1 + num2;
                break;
            case '-':
                resultado = num1 - num2;
                break;
            case '*':
                resultado = num1 * num2;
                break;
            case '/':
                // Verificar se o segundo operando é zero
                if (num2 == 0) {
                    System.out.println("Divisao por Zero!");
                    return; // Encerrar o programa
                }
                resultado = num1 / num2;
                break;
            default:
                System.out.println("Operador invalido");
                return; // Encerrar o programa
        }

        // Mostrar o resultado na tela
        System.out.printf("%.2f %c %.2f = %.2f%n", num1, operador, num2, resultado);
    }
}

Este programa em Java funciona de maneira semelhante aos programas em C, C++ e C#, mas utiliza as funcionalidades da linguagem Java. Ele solicita que o usuário insira os operandos e o operador, verifica se o operador é válido, realiza o cálculo correspondente e exibe o resultado. Além disso, ele lida com a divisão por zero e exibe mensagens de erro apropriadas conforme necessário.

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();
    let mut operador = String::new();

    // Solicitar entrada do usuário
    println!("Digite o primeiro operando: ");
    io::stdin().read_line(&mut num1).expect("Falha ao ler a linha.");
    let num1: f32 = num1.trim().parse().expect("Por favor, digite um número válido.");

    println!("Digite o operador (+, -, *, /): ");
    io::stdin().read_line(&mut operador).expect("Falha ao ler a linha.");
    let operador: char = operador.trim().chars().next().expect("Por favor, digite um operador válido.");

    println!("Digite o segundo operando: ");
    io::stdin().read_line(&mut num2).expect("Falha ao ler a linha.");
    let num2: f32 = num2.trim().parse().expect("Por favor, digite um número válido.");

    // Verificar se o operador é válido e efetuar o cálculo
    let resultado = match operador {
        '+' => num1 + num2,
        '-' => num1 - num2,
        '*' => num1 * num2,
        '/' => {
            // Verificar se o segundo operando é zero
            if num2 == 0.0 {
                println!("Divisao por Zero!");
                return; // Encerrar o programa
            }
            num1 / num2
        }
        _ => {
            println!("Operador invalido");
            return; // Encerrar o programa
        }
    };

    // Mostrar o resultado na tela
    println!("{:.2} {} {:.2} = {:.2}", num1, operador, num2, resultado);
}

Aqui estão algumas diferenças notáveis entre Rust e as linguagens mencionadas anteriormente:

1. Segurança e gerenciamento de memória: Rust é conhecido por seu sistema de tipos seguro e por evitar erros de memória, como referências nulas e vazamentos de memória, por meio de seu sistema de propriedade e regras de empréstimo. Neste programa, não há necessidade de gerenciar explicitamente a alocação e liberação de memória para variáveis de string, como num1, num2 e operador. O compilador de Rust garante a segurança de memória em tempo de compilação.
2. Padrões de concorrência: Rust tem suporte para concorrência seguro em seu sistema de tipos, através de construções como std::thread e std::sync. Embora este programa seja simples e sequencial, Rust oferece ferramentas robustas para lidar com concorrência e paralelismo de maneira segura e eficiente.
3. Gerenciamento de erros: Em Rust, é comum usar o Result ou o Option para lidar com possíveis erros de operações de I/O ou conversões de tipo, ao contrário de lançar exceções ou retornar valores especiais de erro. No programa acima, usamos expect() para tratar erros de leitura de entrada, o que pode falhar se houver um erro de I/O, e parse() para converter strings em números, que pode falhar se a string não for um número válido.
4. Coincidência de padrões (pattern matching): Rust oferece uma poderosa construção de correspondência de padrões, que é usada no bloco match para verificar o operador inserido pelo usuário. Isso oferece uma maneira concisa e segura de lidar com várias opções de maneira elegante.

Exemplo em Go

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

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

*******************************************************************************/
package main

import (
    "fmt"
    "os"
)

func main() {
    var num1, num2 float64
    var operador string

    // Solicitar entrada do usuário
    fmt.Print("Digite o primeiro operando: ")
    fmt.Scanln(&num1)
    fmt.Print("Digite o operador (+, -, *, /): ")
    fmt.Scanln(&operador)
    fmt.Print("Digite o segundo operando: ")
    fmt.Scanln(&num2)

    // Verificar se o operador é válido e efetuar o cálculo
    switch operador {
    case "+":
        fmt.Printf("%.2f + %.2f = %.2f\n", num1, num2, num1+num2)
    case "-":
        fmt.Printf("%.2f - %.2f = %.2f\n", num1, num2, num1-num2)
    case "*":
        fmt.Printf("%.2f * %.2f = %.2f\n", num1, num2, num1*num2)
    case "/":
        if num2 == 0 {
            fmt.Println("Divisao por Zero!")
            os.Exit(1) // Encerrar o programa
        }
        fmt.Printf("%.2f / %.2f = %.2f\n", num1, num2, num1/num2)
    default:
        fmt.Println("Operador invalido")
        os.Exit(1) // Encerrar o programa
    }
}

O algoritmo solicita ao usuário que insira dois operandos e um operador. Em seguida, verifica se o operador é válido e executa a operação correspondente (adição, subtração, multiplicação ou divisão). Se o operador for divisão e o segundo operando for zero, o programa exibe uma mensagem de erro. Por fim, o resultado é exibido na tela. O programa lida com entrada e saída usando as funcionalidades específicas da linguagem utilizada e encerra a execução caso haja um operador inválido ou uma divisão por zero.

Aqui estão algumas diferenças notáveis na sintaxe e semântica entre Go e as linguagens mencionadas anteriormente:

1. Declaração de Pacote e Função Main:
   • Em Go, o código é organizado em pacotes, e um programa começa com a declaração do pacote principal package main e a função main().
   • Nas outras linguagens, a estrutura do programa pode variar, mas normalmente começa com uma função main() ou algo semelhante.
2. Importação de Pacotes:
   • Go usa a palavra-chave import para importar pacotes externos.
   • Em outras linguagens, como C/C++, Java, C#, a importação de bibliotecas é feita de maneira semelhante, mas a sintaxe pode variar ligeiramente.
3. Entrada e Saída:
   • Go usa os pacotes fmt e os para entrada e saída.
   • A função fmt.Scanln() é usada para ler entrada do usuário e fmt.Printf() para imprimir saída formatada.
   • Em outras linguagens, como C/C++, Java, C#, as entradas e saídas são tratadas com funções específicas da linguagem ou bibliotecas padrão.
4. Tratamento de Erros e Encerramento do Programa:
   • Em Go, os erros são tratados usando funções como os.Exit() para encerrar o programa com um código de saída específico.
   • Nas outras linguagens, o tratamento de erros pode ser feito de maneira semelhante, mas pode variar na sintaxe e nas convenções de uso.
5. Tipo de Dados e Formatação de Saída:
   • Go é uma linguagem fortemente tipada que requer declarações explícitas de tipos de variáveis.
   • A formatação de saída em Go é feita usando o pacote fmt, que fornece funções como Printf() para imprimir saída formatada.
   • Em outras linguagens, como Java e C#, a formatação de saída pode ser semelhante, mas a sintaxe específica e os recursos disponíveis podem variar.

Essas são algumas das diferenças mais notáveis na sintaxe e semântica entre Go e as outras linguagens mencionadas.

Conclusão

Este exercício proporcionou uma oportunidade valiosa para praticar conceitos fundamentais de programação, como manipulação de entradas e saídas, tratamento de erros, lógica de programação e interação com o usuário. Desenvolver uma calculadora simples em C++ não apenas reforçou esses conceitos, mas também ajudou a entender a importância de validar entradas e fornecer feedback claro ao usuário. Além disso, explorar diferentes linguagens de programação, como C++, Rust, Go e outras, permitiu compreender suas peculiaridades e aprender novas abordagens para resolver problemas. No geral, este exercício foi uma excelente oportunidade para aprimorar habilidades práticas e consolidar conhecimentos teóricos.

Beleza pessoal? Espero que tenham gostado.

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

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

#Programação

#C++

#DesenvolvimentoDeSoftware

#Aprendizado

#Rust

#GO

#GiovaniDaCruz

Fala galera da programação, tudo beleza? Lá vamos nós a mais um interessante exercício.

Dados do Exercício

Formulas
Para Homens: ( 72.7 * altura ) – 58
Para Mulheres: ( 62.1 * altura) – 44.7

Mais dicas

A altura da pessoa é um valor real.
O sexo da pessoa deverá ser identificado através de um caracter.
O programa deverá aceitar os caracteres “m” ou “M” para identificar pessoas do sexo masculino e os caracteres “f” ou “F” para identificar pessoas do sexo feminino.
A variável que identifica o sexo deve ser declarada com o tipo char.

Exemplo 1

Valores informados pelo usuário: Altura: 1.6 e Sexo: F

Mensagens mostradas na tela: Peso ideal: 54,7kg

Exemplo 2

Valores informados pelo usuário: Altura: 1.8 e Sexo: M

Mensagens mostradas na tela: Peso ideal: 72,9 kg

O que podemos aprender neste exercício?

Neste exercício, podemos aprender várias coisas:

1. Manipulação de Entrada do Usuário: Aprendemos como solicitar e receber entrada do usuário em diferentes linguagens de programação, como C++, C, Pascal, Python, Java, Rust e Go. Cada linguagem tem suas próprias maneiras de fazer isso, mas a essência é a mesma: pedir informações ao usuário e armazená-las para uso posterior.
2. Estruturas de Controle: Aprendemos como usar estruturas de controle de fluxo, como condicionais (if-else ou switch-case), para tomar decisões com base nas entradas do usuário. Isso nos permite lidar com diferentes cenários e responder de acordo com as condições especificadas.
3. Cálculos Simples: Praticamos realizar cálculos simples com base nas entradas do usuário. Isso envolveu operações matemáticas básicas, como multiplicação, subtração e adição, para calcular o peso ideal com base na altura e sexo fornecidos.
4. Formatação de Saída: Aprendemos como formatar a saída para que os resultados sejam exibidos de maneira legível e informativa para o usuário. Isso inclui especificar o número de casas decimais ou formatar uma string de maneira adequada para exibição.
5. Gerenciamento de Erros e Exceções: Em alguns exemplos, lidamos com casos em que o usuário fornece entradas inválidas, como um sexo não reconhecido. Aprendemos a como lidar com essas situações, exibindo mensagens de erro apropriadas e encerrando o programa de forma adequada.
6. Adaptação a Diferentes Linguagens: Ao escrever o mesmo programa em várias linguagens, podemos comparar e contrastar as diferenças de sintaxe, estilo e paradigmas de programação entre essas linguagens. Isso nos permite entender como conceitos similares são expressos de maneiras diferentes em diferentes ambientes de programação.

Em resumo, este exercício nos permite praticar habilidades fundamentais de programação, como entrada/saída, controle de fluxo, cálculos matemáticos simples e formatação de saída, enquanto nos familiarizamos com várias linguagens de programação. Isso nos ajuda a expandir nosso conhecimento e habilidades como programadores.

Vamos aos códigos!

Exemplo em C++

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

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

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

using namespace std;

int main() {
    // Declaração das variáveis
    double altura, peso_ideal;
    char sexo;

    // Solicita a entrada do usuário
    cout << "Altura (metros): ";
    cin >> altura;
    cout << "Sexo (M/F): ";
    cin >> sexo;

    // Verifica o sexo e calcula o peso ideal
    if (sexo == 'm' || sexo == 'M') {
        peso_ideal = (72.7 * altura) - 58;
    } else if (sexo == 'f' || sexo == 'F') {
        peso_ideal = (62.1 * altura) - 44.7;
    } else {
        cout << "Sexo inválido. Por favor, insira 'M' para masculino ou 'F' para feminino." << endl;
        return 1; // Encerra o programa com código de erro
    }

    // Exibe o peso ideal
    cout << "Peso ideal: " << peso_ideal << " kg" << endl;

    return 0;
}

Este programa solicita ao usuário a altura em metros e o sexo da pessoa. Em seguida, ele calcula e exibe o peso ideal conforme as fórmulas fornecidas, considerando o sexo informado. O programa verifica se o sexo inserido é válido e, caso contrário, exibe uma mensagem de erro e encerra com um código de erro.

Exemplo em C

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

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

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

int main() {
    // Declaração das variáveis
    double altura, peso_ideal;
    char sexo;

    // Solicita a entrada do usuário
    printf("Altura (metros): ");
    scanf("%lf", &altura);
    printf("Sexo (M/F): ");
    scanf(" %c", &sexo);

    // Verifica o sexo e calcula o peso ideal
    if (sexo == 'm' || sexo == 'M') {
        peso_ideal = (72.7 * altura) - 58;
    } else if (sexo == 'f' || sexo == 'F') {
        peso_ideal = (62.1 * altura) - 44.7;
    } else {
        printf("Sexo inválido. Por favor, insira 'M' para masculino ou 'F' para feminino.\n");
        return 1; // Encerra o programa com código de erro
    }

    // Exibe o peso ideal
    printf("Peso ideal: %.1lf kg\n", peso_ideal);

    return 0;
}

Neste código, as funções de entrada e saída padrão da linguagem C (printf e scanf) são usadas para interagir com o usuário. A lógica do programa permanece a mesma que a versão em C++, apenas a sintaxe e as funções de entrada/saída são diferentes.

Exemplo em Pascal / Delphi / Lazarus

{

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

}
program CalculoPesoIdeal;

var
  altura, peso_ideal: real;
  sexo: char;

begin
  // Solicita a entrada do usuário
  write('Altura (metros): ');
  readln(altura);
  write('Sexo (M/F): ');
  readln(sexo);

  // Verifica o sexo e calcula o peso ideal
  if (sexo = 'm') or (sexo = 'M') then
    peso_ideal := (72.7 * altura) - 58
  else if (sexo = 'f') or (sexo = 'F') then
    peso_ideal := (62.1 * altura) - 44.7
  else
  begin
    writeln('Sexo inválido. Por favor, insira ''M'' para masculino ou ''F'' para feminino.');
    halt(1); // Encerra o programa com código de erro
  end;

  // Exibe o peso ideal
  writeln('Peso ideal: ', peso_ideal:0:1, ' kg');
end.

Este código em Pascal realiza a mesma função que as versões anteriores. Ele solicita a altura e o sexo do usuário, calcula o peso ideal com base nas fórmulas fornecidas e exibe o resultado. A estrutura geral do programa é semelhante à dos exemplos anteriores, mas adaptada à sintaxe e às construções da linguagem Pascal.

A estratégia utilizada para escrever o programa em Pascal foi:

1. Declaração de variáveis: Inicialmente, as variáveis necessárias foram declaradas, incluindo altura, peso_ideal e sexo.
2. Entrada de dados: O programa solicita ao usuário que insira a altura e o sexo. Isso é feito usando a função write para exibir mensagens no console e readln para ler as entradas do usuário.
3. Cálculo do peso ideal: Com base no sexo fornecido pelo usuário, o programa calcula o peso ideal usando as fórmulas específicas para homens e mulheres.
4. Verificação do sexo: O programa utiliza uma estrutura condicional (if-else if-else) para verificar se o sexo fornecido é válido (‘M’ ou ‘F’). Se o sexo não for válido, uma mensagem de erro é exibida e o programa é encerrado.
5. Exibição do resultado: Por fim, o programa exibe o peso ideal calculado usando a função writeln.

Exemplo em Python

'''

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

'''
# Solicita a entrada do usuário
altura = float(input("Altura (metros): "))
sexo = input("Sexo (M/F): ").lower()  # Converte para minúsculo para facilitar a comparação

# Verifica o sexo e calcula o peso ideal
if sexo == 'm':
    peso_ideal = (72.7 * altura) - 58
elif sexo == 'f':
    peso_ideal = (62.1 * altura) - 44.7
else:
    print("Sexo inválido. Por favor, insira 'M' para masculino ou 'F' para feminino.")
    exit(1)  # Encerra o programa com código de erro

# Exibe o peso ideal
print(f"Peso ideal: {peso_ideal:.1f} kg")

Este código em Python realiza as mesmas operações que os exemplos anteriores. Ele solicita a altura e o sexo do usuário, calcula o peso ideal com base nas fórmulas fornecidas e exibe o resultado. A estrutura geral do programa é semelhante à dos exemplos anteriores, mas adaptada à sintaxe e às construções da linguagem Python.

Exemplo em C# / C Sharp

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

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

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

class Program
{
    static void Main(string[] args)
    {
        // Solicita a entrada do usuário
        Console.Write("Altura (metros): ");
        double altura = Convert.ToDouble(Console.ReadLine());
        Console.Write("Sexo (M/F): ");
        char sexo = Char.ToLower(Convert.ToChar(Console.ReadLine()));

        // Verifica o sexo e calcula o peso ideal
        double peso_ideal;
        if (sexo == 'm')
        {
            peso_ideal = (72.7 * altura) - 58;
        }
        else if (sexo == 'f')
        {
            peso_ideal = (62.1 * altura) - 44.7;
        }
        else
        {
            Console.WriteLine("Sexo inválido. Por favor, insira 'M' para masculino ou 'F' para feminino.");
            return; // Encerra o programa
        }

        // Exibe o peso ideal
        Console.WriteLine("Peso ideal: {0:f1} kg", peso_ideal);
    }
}

Este código em C# realiza as mesmas operações que os exemplos anteriores. Ele solicita a altura e o sexo do usuário, calcula o peso ideal com base nas fórmulas fornecidas e exibe o resultado. A estrutura geral do programa é semelhante à dos exemplos anteriores, mas adaptada à sintaxe e às construções da linguagem C#.

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) {
        // Cria um objeto Scanner para obter entrada do usuário
        Scanner scanner = new Scanner(System.in);

        // Solicita a entrada do usuário
        System.out.print("Altura (metros): ");
        double altura = scanner.nextDouble();
        System.out.print("Sexo (M/F): ");
        char sexo = scanner.next().charAt(0);
        sexo = Character.toLowerCase(sexo); // Converte para minúsculo para facilitar a comparação

        // Verifica o sexo e calcula o peso ideal
        double pesoIdeal;
        if (sexo == 'm') {
            pesoIdeal = (72.7 * altura) - 58;
        } else if (sexo == 'f') {
            pesoIdeal = (62.1 * altura) - 44.7;
        } else {
            System.out.println("Sexo inválido. Por favor, insira 'M' para masculino ou 'F' para feminino.");
            scanner.close();
            return; // Encerra o programa
        }

        // Exibe o peso ideal
        System.out.printf("Peso ideal: %.1f kg%n", pesoIdeal);

        // Fecha o Scanner para evitar vazamento de recursos
        scanner.close();
    }
}

Este programa em Java realiza as mesmas operações que os exemplos anteriores. Ele solicita a altura e o sexo do usuário, calcula o peso ideal com base nas fórmulas fornecidas e exibe o resultado. A estrutura geral do programa é semelhante à dos exemplos anteriores, mas adaptada à sintaxe e às construções da linguagem Java.

Exemplo em Rust

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

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

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

fn main() {
    // Solicita a entrada do usuário
    println!("Altura (metros): ");
    let mut altura = String::new();
    io::stdin().read_line(&mut altura).expect("Falha ao ler a entrada");
    let altura: f64 = altura.trim().parse().expect("Valor inválido");

    println!("Sexo (M/F): ");
    let mut sexo = String::new();
    io::stdin().read_line(&mut sexo).expect("Falha ao ler a entrada");
    let sexo: char = sexo.trim().chars().next().expect("Valor inválido");

    // Verifica o sexo e calcula o peso ideal
    let peso_ideal: f64;
    match sexo {
        'm' | 'M' => {
            peso_ideal = (72.7 * altura) - 58.0;
        }
        'f' | 'F' => {
            peso_ideal = (62.1 * altura) - 44.7;
        }
        _ => {
            println!("Sexo inválido. Por favor, insira 'M' para masculino ou 'F' para feminino.");
            return; // Encerra o programa
        }
    }

    // Exibe o peso ideal
    println!("Peso ideal: {:.1} kg", peso_ideal);
}

Este programa em Rust realiza as mesmas operações que os exemplos anteriores. Ele solicita a altura e o sexo do usuário, calcula o peso ideal com base nas fórmulas fornecidas e exibe o resultado. A estrutura geral do programa é semelhante à dos exemplos anteriores, mas adaptada à sintaxe e às construções da linguagem Rust.

Exemplo em Go

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

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

*******************************************************************************/
package main

import (
    "fmt"
)

func main() {
    // Solicita a entrada do usuário
    var altura float64
    var sexo string

    fmt.Print("Altura (metros): ")
    fmt.Scanln(&altura)
    fmt.Print("Sexo (M/F): ")
    fmt.Scanln(&sexo)

    // Verifica o sexo e calcula o peso ideal
    var pesoIdeal float64
    switch sexo {
    case "M", "m":
        pesoIdeal = (72.7 * altura) - 58.0
    case "F", "f":
        pesoIdeal = (62.1 * altura) - 44.7
    default:
        fmt.Println("Sexo inválido. Por favor, insira 'M' para masculino ou 'F' para feminino.")
        return // Encerra o programa
    }

    // Exibe o peso ideal
    fmt.Printf("Peso ideal: %.1f kg\n", pesoIdeal)
}

Este programa em Go realiza as mesmas operações que os exemplos anteriores. Ele solicita a altura e o sexo do usuário, calcula o peso ideal com base nas fórmulas fornecidas e exibe o resultado. A estrutura geral do programa é semelhante à dos exemplos anteriores, mas adaptada à sintaxe e às construções da linguagem Go.

Conclusão

Este exercício foi uma oportunidade valiosa para praticar e comparar a implementação de um programa simples em várias linguagens de programação, incluindo C++, C, Pascal, Python, Java, Rust e Go. Durante o exercício, pudemos observar as diferentes sintaxes, estruturas de controle e abordagens para manipulação de entrada/saída em cada linguagem.

Ao escrever o programa em diferentes linguagens, pudemos destacar as semelhanças e diferenças entre elas, bem como entender como conceitos fundamentais de programação são expressos em diferentes ambientes de desenvolvimento.

Além disso, este exercício nos permitiu praticar habilidades como manipulação de entrada/saída, uso de estruturas de controle, realização de cálculos simples e formatação de saída. Também lidamos com casos de entrada inválida, aprendendo a gerenciar erros e exceções de forma adequada em cada linguagem.

Em conclusão, este exercício foi uma excelente maneira de ampliar nosso conhecimento e habilidades em programação, enquanto nos familiarizamos com uma variedade de linguagens de programação. Isso nos prepara para enfrentar uma variedade de problemas e projetos futuros, independentemente da linguagem de programação utilizada.

Beleza pessoal? Espero que tenham gostado.

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

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

#DesenvolvimentoDeSoftware

#Programação

#LinguagensDeProgramação

#AprendizadoDeMáquina

#Algoritmos

#GiovaniDaCruz

Fala galera da programação, tudo beleza?

Você já pensou como é possível contar palavras únicas em um texto de forma eficiente? Neste nosso post, exploramos como resolver esse problema usando diferentes linguagens de programação, desde Python até Rust! Descubra como manipular strings, usar estruturas de dados como HashMaps e muito mais. Confira agora mesmo e aprimore suas habilidades de programação!

Dicas do Exercício

Não é necessário solicitar ao usuário para informar um texto. Vamos deixar ele fixo neste exercício;

Neste problema, um HashMap é útil para armazenar as palavras únicas como chaves e seus contadores como valores. Iteramos sobre cada palavra no texto, removemos pontuações e convertemos para minúsculas. Em seguida, verificamos se a palavra já está no HashMap. Se sim, incrementamos seu contador; caso contrário, adicionamos a palavra ao HashMap com um contador inicial de 1. Isso nos permite contar eficientemente as ocorrências de cada palavra única no texto.

Exemplo de Texto de Entrada

“O rato roeu a roupa do rei de Roma. E o rei ficou tão irritado que mandou o rato para o mar.”

Exemplo de saída:

{
    "o": 3,
    "rato": 2,
    "roeu": 1,
    "a": 1,
    "roupa": 1,
    "do": 1,
    "rei": 2,
    "de": 1,
    "roma": 1,
    "e": 1,
    "ficou": 1,
    "tão": 1,
    "irritado": 1,
    "que": 1,
    "mandou": 1,
    "para": 1,
    "mar": 1
}

O que podemos aprender neste exercício?

Neste exercício, podemos aprender várias coisas:

1. Uso de Estruturas de Dados: A solução do problema envolve o uso de estruturas de dados adequadas para manipular e armazenar informações. Em diferentes linguagens de programação, foram utilizadas estruturas como HashMaps, Dicionários e Unordered Maps para armazenar as contagens de palavras únicas.
2. Manipulação de Strings: O problema requer a manipulação de strings para dividir o texto em palavras, remover pontuações e converter para minúsculas. Isso demonstra a importância de saber como manipular strings eficientemente para processamento de texto.
3. Uso de Iteração: A solução envolve iteração sobre as palavras no texto e sobre os itens das estruturas de dados. Iterar sobre coleções de dados é uma habilidade fundamental na programação e é amplamente utilizada para processamento de informações.
4. Tratamento de Dados não Estruturados: O texto fornecido é um exemplo de dados não estruturados. Lidar com esse tipo de dados requer técnicas para extrair informações relevantes e tratá-las de maneira eficaz.
5. Algoritmos de Contagem: O problema demonstra um tipo de algoritmo de contagem, que é comum em muitos cenários de processamento de dados. Esse tipo de algoritmo é útil em uma variedade de aplicações, como análise de texto, contagem de ocorrências e geração de estatísticas.

De modo resumido, este exercício oferece uma oportunidade para praticar habilidades de manipulação de dados, estruturas de dados e algoritmos básicos, enquanto aborda um problema comum de processamento de texto.

Vamos aos códigos!

Exemplo em GO

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

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

*******************************************************************************/
package main

import (
    "fmt"
    "strings"
)

func countUniqueWords(text string) map[string]int {
    // Inicializa o mapa para armazenar as contagens de palavras únicas
    wordCount := make(map[string]int)

    // Divide o texto em palavras usando espaços em branco como delimitador
    words := strings.Fields(text)

    // Itera sobre cada palavra no texto
    for _, word := range words {
        // Remove pontuações e converte para minúsculas
        cleanedWord := strings.ToLower(strings.Trim(word, ".,!?"))

        // Incrementa o contador da palavra no mapa
        wordCount[cleanedWord]++
    }

    return wordCount
}

func main() {
    // Texto de exemplo
    text := "O rato roeu a roupa do rei de Roma. E o rei ficou tão irritado que mandou o rato para o mar."

    // Conta as palavras únicas no texto
    uniqueWordCount := countUniqueWords(text)

    // Imprime as contagens de palavras únicas
    fmt.Println("Contagem de palavras únicas:")
    for word, count := range uniqueWordCount {
        fmt.Printf("%s: %d\n", word, count)
    }
}

Neste código Go, usando um HashMap, a função countUniqueWords recebe o texto como entrada e retorna um mapa onde as chaves são as palavras únicas e os valores são o número de vezes que cada palavra aparece no texto. O texto é dividido em palavras usando espaços em branco como delimitador, e então cada palavra é limpa de pontuações e convertida para minúsculas antes de ser contada. A função main utiliza este método para contar as palavras únicas em um texto de exemplo e imprime o resultado.

Exemplo em Python

'''

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

'''
def count_unique_words(text):
    # Inicializa o dicionário para armazenar as contagens de palavras únicas
    word_count = {}

    # Divide o texto em palavras usando espaços em branco como delimitador
    words = text.split()

    # Itera sobre cada palavra no texto
    for word in words:
        # Remove pontuações e converte para minúsculas
        cleaned_word = word.strip(".,!?").lower()

        # Incrementa o contador da palavra no dicionário
        if cleaned_word in word_count:
            word_count[cleaned_word] += 1
        else:
            word_count[cleaned_word] = 1

    return word_count

def main():
    # Texto de exemplo
    text = "O rato roeu a roupa do rei de Roma. E o rei ficou tão irritado que mandou o rato para o mar."

    # Conta as palavras únicas no texto
    unique_word_count = count_unique_words(text)

    # Imprime as contagens de palavras únicas
    print("Contagem de palavras únicas:")
    for word, count in unique_word_count.items():
        print(f"{word}: {count}")

if __name__ == "__main__":
    main()

Neste código Python, a função count_unique_words recebe o texto como entrada e retorna um dicionário onde as chaves são as palavras únicas e os valores são o número de vezes que cada palavra aparece no texto. O texto é dividido em palavras usando espaços em branco como delimitador, e então cada palavra é limpa de pontuações e convertida para minúsculas antes de ser contada. A função main utiliza este método para contar as palavras únicas em um texto de exemplo e imprime o resultado.

Exemplo em C# / C Sharp

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

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

*******************************************************************************/
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.RegularExpressions;

class Program
{
    static Dictionary<string, int> CountUniqueWords(string text)
    {
        // Inicializa o dicionário para armazenar as contagens de palavras únicas
        Dictionary<string, int> wordCount = new Dictionary<string, int>();

        // Divide o texto em palavras usando expressões regulares
        string[] words = Regex.Split(text, @"\W+");

        // Itera sobre cada palavra no texto
        foreach (string word in words)
        {
            // Remove pontuações e converte para minúsculas
            string cleanedWord = word.Trim().ToLower();

            // Incrementa o contador da palavra no dicionário
            if (!string.IsNullOrEmpty(cleanedWord))
            {
                if (wordCount.ContainsKey(cleanedWord))
                {
                    wordCount[cleanedWord]++;
                }
                else
                {
                    wordCount[cleanedWord] = 1;
                }
            }
        }

        return wordCount;
    }

    static void Main(string[] args)
    {
        // Texto de exemplo
        string text = "O rato roeu a roupa do rei de Roma. E o rei ficou tão irritado que mandou o rato para o mar.";

        // Conta as palavras únicas no texto
        Dictionary<string, int> uniqueWordCount = CountUniqueWords(text);

        // Imprime as contagens de palavras únicas
        Console.WriteLine("Contagem de palavras únicas:");
        foreach (var kvp in uniqueWordCount)
        {
            Console.WriteLine($"{kvp.Key}: {kvp.Value}");
        }
    }
}

Neste código C#, a função CountUniqueWords recebe o texto como entrada e retorna um dicionário onde as chaves são as palavras únicas e os valores são o número de vezes que cada palavra aparece no texto. O texto é dividido em palavras usando expressões regulares para separar palavras de pontuações, e então cada palavra é limpa de espaços em branco, pontuações e convertida para minúsculas antes de ser contada. A função Main utiliza este método para contar as palavras únicas em um texto de exemplo e imprime o resultado.

Exemplo em Delphi

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

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

****************************************)
program CountUniqueWords;

{$APPTYPE CONSOLE}

uses
  SysUtils, StrUtils, Classes, Generics.Collections, RegularExpressions;

function CountUniqueWords(const Text: string): TDictionary<string, Integer>;
var
  Words: TStringList;
  WordCount: TDictionary<string, Integer>;
  Word: string;
  CleanedWord: string;
begin
  // Inicializa o TDictionary para armazenar as contagens de palavras únicas
  WordCount := TDictionary<string, Integer>.Create;
  Words := TStringList.Create;
  try
    // Divide o texto em palavras usando expressões regulares
    Words.DelimitedText := TRegEx.Replace(Text, '\W+', ' ');

    // Itera sobre cada palavra no texto
    for Word in Words do
    begin
      // Remove pontuações e converte para minúsculas
      CleanedWord := Trim(LowerCase(Word));

      // Incrementa o contador da palavra no TDictionary
      if not CleanedWord.IsEmpty then
      begin
        if WordCount.ContainsKey(CleanedWord) then
          WordCount[CleanedWord] := WordCount[CleanedWord] + 1
        else
          WordCount.Add(CleanedWord, 1);
      end;
    end;
  finally
    Words.Free;
  end;
  Result := WordCount;
end;

var
  Text: string;
  UniqueWordCount: TDictionary<string, Integer>;
  Word: string;
begin
  // Texto de exemplo
  Text := 'O rato roeu a roupa do rei de Roma. E o rei ficou tão irritado que mandou o rato para o mar.';

  // Conta as palavras únicas no texto
  UniqueWordCount := CountUniqueWords(Text);

  try
    // Imprime as contagens de palavras únicas
    WriteLn('Contagem de palavras únicas:');
    for Word in UniqueWordCount.Keys do
      WriteLn(Word + ': ' + IntToStr(UniqueWordCount[Word]));
  finally
    UniqueWordCount.Free;
  end;
end.

Neste código Delphi, a função CountUniqueWords recebe o texto como entrada e retorna um TDictionary onde as chaves são as palavras únicas e os valores são o número de vezes que cada palavra aparece no texto. O texto é dividido em palavras usando expressões regulares para separar palavras de pontuações, e então cada palavra é limpa de espaços em branco, pontuações e convertida para minúsculas antes de ser contada. O programa principal utiliza este método para contar as palavras únicas em um texto de exemplo e imprime o resultado.

Exemplo em Java

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

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

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

public class Main {
    public static Map<String, Integer> countUniqueWords(String text) {
        // Inicializa o mapa para armazenar as contagens de palavras únicas
        Map<String, Integer> wordCount = new HashMap<>();

        // Divide o texto em palavras usando expressões regulares
        String[] words = text.split("\\W+");

        // Itera sobre cada palavra no texto
        for (String word : words) {
            // Remove pontuações e converte para minúsculas
            String cleanedWord = word.trim().toLowerCase();

            // Incrementa o contador da palavra no mapa
            if (!cleanedWord.isEmpty()) {
                wordCount.put(cleanedWord, wordCount.getOrDefault(cleanedWord, 0) + 1);
            }
        }

        return wordCount;
    }

    public static void main(String[] args) {
        // Texto de exemplo
        String text = "O rato roeu a roupa do rei de Roma. E o rei ficou tão irritado que mandou o rato para o mar.";

        // Conta as palavras únicas no texto
        Map<String, Integer> uniqueWordCount = countUniqueWords(text);

        // Imprime as contagens de palavras únicas
        System.out.println("Contagem de palavras únicas:");
        for (Map.Entry<String, Integer> entry : uniqueWordCount.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }
    }
}

Neste código Java, a função countUniqueWords recebe o texto como entrada e retorna um HashMap onde as chaves são as palavras únicas e os valores são o número de vezes que cada palavra aparece no texto. O texto é dividido em palavras usando expressões regulares para separar palavras de pontuações, e então cada palavra é limpa de espaços em branco, pontuações e convertida para minúsculas antes de ser contada. O método main utiliza este método para contar as palavras únicas em um texto de exemplo e imprime o resultado.

Exemplo em C++

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

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

*******************************************************************************/
#include <iostream>
#include <string>
#include <unordered_map>
#include <sstream>
#include <algorithm>

std::unordered_map<std::string, int> countUniqueWords(const std::string& text) {
    // Inicializa o unordered_map para armazenar as contagens de palavras únicas
    std::unordered_map<std::string, int> wordCount;

    // Cria um stringstream a partir do texto para processar palavra por palavra
    std::stringstream ss(text);
    std::string word;

    // Itera sobre cada palavra no texto
    while (ss >> word) {
        // Remove pontuações e converte para minúsculas
        word.erase(std::remove_if(word.begin(), word.end(), ispunct), word.end());
        std::transform(word.begin(), word.end(), word.begin(), ::tolower);

        // Incrementa o contador da palavra no unordered_map
        wordCount[word]++;
    }

    return wordCount;
}

int main() {
    // Texto de exemplo
    std::string text = "O rato roeu a roupa do rei de Roma. E o rei ficou tão irritado que mandou o rato para o mar.";

    // Conta as palavras únicas no texto
    auto uniqueWordCount = countUniqueWords(text);

    // Imprime as contagens de palavras únicas
    std::cout << "Contagem de palavras únicas:" << std::endl;
    for (const auto& pair : uniqueWordCount) {
        std::cout << pair.first << ": " << pair.second << std::endl;
    }

    return 0;
}

Neste código C++, a função countUniqueWords recebe o texto como entrada e retorna um std::unordered_map onde as chaves são as palavras únicas e os valores são o número de vezes que cada palavra aparece no texto. O texto é dividido em palavras usando um std::stringstream, e então cada palavra é limpa de pontuações e convertida para minúsculas antes de ser contada. O método main utiliza este método para contar as palavras únicas em um texto de exemplo e imprime o resultado.

Exemplo em Rust

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

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

*******************************************************************************/
use std::collections::HashMap;

fn count_unique_words(text: &str) -> HashMap<String, usize> {
    // Inicializa o HashMap para armazenar as contagens de palavras únicas
    let mut word_count: HashMap<String, usize> = HashMap::new();

    // Divide o texto em palavras
    for word in text.split_whitespace() {
        // Remove pontuações e converte para minúsculas
        let cleaned_word = word.trim_matches(|c: char| !c.is_alphanumeric()).to_lowercase();

        // Incrementa o contador da palavra no HashMap
        *word_count.entry(cleaned_word).or_insert(0) += 1;
    }

    word_count
}

fn main() {
    // Texto de exemplo
    let text = "O rato roeu a roupa do rei de Roma. E o rei ficou tão irritado que mandou o rato para o mar.";

    // Conta as palavras únicas no texto
    let unique_word_count = count_unique_words(text);

    // Imprime as contagens de palavras únicas
    println!("Contagem de palavras únicas:");
    for (word, count) in &unique_word_count {
        println!("{}: {}", word, count);
    }
}

Neste código Rust, a função count_unique_words recebe o texto como entrada e retorna um HashMap onde as chaves são as palavras únicas e os valores são o número de vezes que cada palavra aparece no texto. O texto é dividido em palavras usando split_whitespace, e então cada palavra é limpa de pontuações e convertida para minúsculas antes de ser contada. O método main utiliza este método para contar as palavras únicas em um texto de exemplo e imprime o resultado.

Conclusão

Este exercício nos permitiu explorar como resolver um problema prático de contagem de palavras únicas em um texto usando diferentes linguagens de programação. Através deste exercício, aprendemos a utilizar estruturas de dados adequadas, como HashMaps, Dicionários e Unordered Maps, para armazenar as contagens de palavras únicas. Além disso, praticamos técnicas de manipulação de strings, como dividir o texto em palavras, remover pontuações e converter para minúsculas.

Foi uma oportunidade para entender como lidar com dados não estruturados e aplicar algoritmos simples, como algoritmos de contagem, para resolver problemas de processamento de texto. Também destacou a importância da iteração sobre coleções de dados e a necessidade de compreender as peculiaridades de cada linguagem de programação para implementar soluções eficientes e legíveis.

Em resumo, este exercício proporcionou uma valiosa prática para desenvolver habilidades essenciais de programação, além de ilustrar a aplicação de conceitos fundamentais em um contexto prático.

Beleza pessoal? Espero que tenham gostado.

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

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

#Programação

#ManipulaçãoDeTexto

#EstruturasDeDados

#DesenvolvimentoDeSoftware

#GiovaniDaCruz