Crie um algoritmo e um programa que solicite ao usuário digitar dois números reais. O programa deverá verificar entre estes dois valores qual é o menor valor e mostrar na tela os dois valores em ordem crescente.

Fala galera da programação, tudo beleza? Neste exercício vamos testar nossas habilidades para ler dois números e conseguir exibi-los em forma crescente.

Dica do exercício

Utilize o comando Se (if) para fazer os testes;

Lembre-se de utilizar variáveis do tipo Real (ou equivalente na linguagem);

Para leitura de números reais, pode ser necessário utilizar o ponto “.” como separador decimal.

Exemplo de saída: se o usuário informar os números 95.8 e 34.79, deverá ser mostrado na tela a mensagem “Valores em ordem crescente: 34.79 e 95.8”.

O que podemos aprender neste exercício?

Este exercício nos ensina alguns conceitos importantes:

1. Entrada e Saída (E/S): Aprendemos como solicitar dados de entrada do usuário e como exibir resultados para o usuário.
2. Variáveis e Tipos de Dados: Vimos como declarar variáveis para armazenar números reais e como converter entre diferentes tipos de dados quando necessário.
3. Estruturas Condicionais: Utilizamos estruturas condicionais, como if-else, para tomar decisões com base em condições específicas.
4. Lógica de Programação: Praticamos a lógica de programação ao determinar o menor valor entre dois números e ao exibi-los em ordem crescente.
5. Manipulação de Strings: Em linguagens como Rust e Python, aprendemos a manipular strings para remover espaços em branco e converter para tipos numéricos.
6. Sintaxe da Linguagem: Observamos a sintaxe específica de cada linguagem, incluindo como são escritas as estruturas de controle, as operações de entrada e saída, e a declaração de variáveis.

Vamos aos códigos!

Exemplo em C++

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

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

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

int main() {
    // Declaração das variáveis para armazenar os números reais
    double num1, num2;

    // Solicita ao usuário que digite os números reais
    std::cout << "Digite o primeiro número real: ";
    std::cin >> num1;

    std::cout << "Digite o segundo número real: ";
    std::cin >> num2;

    // Verifica qual é o menor valor entre os dois números
    double menor, maior;
    if (num1 < num2) {
        menor = num1;
        maior = num2;
    } else {
        menor = num2;
        maior = num1;
    }

    // Mostra na tela os valores em ordem crescente
    std::cout << "Valores em ordem crescente: " << menor << " e " << maior << std::endl;

    return 0;
}

Este programa solicita ao usuário que insira dois números reais, armazena esses números em variáveis e, em seguida, determina qual é o menor valor entre os dois. Depois, ele imprime na tela os números em ordem crescente.

A estratégia usada neste programa envolve os seguintes passos:

1. Solicitação dos números reais: O programa solicita ao usuário que insira dois números reais.
2. Armazenamento dos números reais: Os números digitados pelo usuário são armazenados em duas variáveis num1 e num2.
3. Determinação do menor valor: O programa verifica qual dos dois números é o menor, usando uma estrutura condicional if-else.
4. Impressão na tela: Os números são então impressos na tela em ordem crescente, primeiro o menor e depois o maior.

Essa estratégia é simples e direta, envolvendo apenas algumas operações básicas de entrada, saída e comparação de valores.

Exemplo em C

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

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

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

int main() {
    // Declaração das variáveis para armazenar os números reais
    double num1, num2;

    // Solicita ao usuário que digite os números reais
    printf("Digite o primeiro número real: ");
    scanf("%lf", &num1);

    printf("Digite o segundo número real: ");
    scanf("%lf", &num2);

    // Verifica qual é o menor valor entre os dois números
    double menor, maior;
    if (num1 < num2) {
        menor = num1;
        maior = num2;
    } else {
        menor = num2;
        maior = num1;
    }

    // Mostra na tela os valores em ordem crescente
    printf("Valores em ordem crescente: %.2lf e %.2lf\n", menor, maior);

    return 0;
}

Neste programa em C, a lógica é a mesma do programa em C++, mas a sintaxe é diferente, pois C e C++ têm algumas diferenças na forma como a entrada e a saída são tratadas.

Exemplo em Pascal / Delphi / Lazarus

{

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

}
program OrdenarNumeros;

var
  num1, num2, menor, maior: Real;

begin
  // Solicita ao usuário que digite os números reais
  Write('Digite o primeiro número real: ');
  ReadLn(num1);

  Write('Digite o segundo número real: ');
  ReadLn(num2);

  // Verifica qual é o menor valor entre os dois números
  if num1 < num2 then
  begin
    menor := num1;
    maior := num2;
  end
  else
  begin
    menor := num2;
    maior := num1;
  end;

  // Mostra na tela os valores em ordem crescente
  WriteLn('Valores em ordem crescente: ', menor:0:2, ' e ', maior:0:2);
end.

Este é o mesmo programa, mas escrito em Pascal. Ele solicita ao usuário que insira dois números reais, armazena esses números em variáveis, determina qual é o menor valor e, em seguida, imprime os números em ordem crescente.

Exemplo em Python

'''

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

'''
# Solicita ao usuário que digite os números reais
num1 = float(input("Digite o primeiro número real: "))
num2 = float(input("Digite o segundo número real: "))

# Verifica qual é o menor valor entre os dois números
if num1 < num2:
    menor = num1
    maior = num2
else:
    menor = num2
    maior = num1

# Mostra na tela os valores em ordem crescente
print("Valores em ordem crescente:", menor, "e", maior)

Neste programa, a estrutura if é utilizada para determinar qual dos números (num1 ou num2) é o menor e o maior, e então os valores são impressos em ordem crescente.

Os valores poderiam ser determinados usando as funções min() e max(), mas optamos por usar if para manter a mesma lógica dos demais exemplos.

Exemplo em C# / C Sharp

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

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

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

class Program
{
    static void Main()
    {
        // Solicita ao usuário que digite os números reais
        Console.Write("Digite o primeiro número real: ");
        double num1 = Convert.ToDouble(Console.ReadLine());

        Console.Write("Digite o segundo número real: ");
        double num2 = Convert.ToDouble(Console.ReadLine());

        // Verifica qual é o menor valor entre os dois números
        double menor, maior;
        if (num1 < num2)
        {
            menor = num1;
            maior = num2;
        }
        else
        {
            menor = num2;
            maior = num1;
        }

        // Mostra na tela os valores em ordem crescente
        Console.WriteLine($"Valores em ordem crescente: {menor} e {maior}");
    }
}

Neste programa em C#, o processo é semelhante aos outros exemplos. Ele solicita ao usuário que insira dois números reais, determina qual é o menor valor usando uma estrutura if-else, e então imprime os números em ordem crescente.

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 Scanner para receber entrada do usuário
        Scanner scanner = new Scanner(System.in);

        // Solicita ao usuário que digite os números reais
        System.out.print("Digite o primeiro número real: ");
        double num1 = scanner.nextDouble();

        System.out.print("Digite o segundo número real: ");
        double num2 = scanner.nextDouble();

        // Verifica qual é o menor valor entre os dois números
        double menor, maior;
        if (num1 < num2) {
            menor = num1;
            maior = num2;
        } else {
            menor = num2;
            maior = num1;
        }

        // Mostra na tela os valores em ordem crescente
        System.out.println("Valores em ordem crescente: " + menor + " e " + maior);

        // Fecha o scanner
        scanner.close();
    }
}

Neste programa em Java, é utilizado um Scanner para obter entrada do usuário. Os números são então armazenados em variáveis, e a estrutura condicional if-else é usada para determinar qual é o menor valor. Por fim, os números são impressos em ordem crescente.

Exemplo em Rust

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

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

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

fn main() {
    // Solicita ao usuário que digite os números reais
    println!("Digite o primeiro número real:");
    let mut num1 = String::new();
    io::stdin().read_line(&mut num1)
        .expect("Falha ao ler o número");

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

    // Converte os números para o tipo f64
    let num1: f64 = num1.trim().parse()
        .expect("Por favor, digite um número válido");
    let num2: f64 = num2.trim().parse()
        .expect("Por favor, digite um número válido");

    // Verifica qual é o menor valor entre os dois números
    let (menor, maior) = if num1 < num2 {
        (num1, num2)
    } else {
        (num2, num1)
    };

    // Mostra na tela os valores em ordem crescente
    println!("Valores em ordem crescente: {} e {}", menor, maior);
}

Neste programa em Rust, é utilizado o módulo std::io para obter entrada do usuário. Os números são armazenados como Strings, depois convertidos para o tipo f64. A estrutura if-else é utilizada para determinar qual é o menor valor, e os números são impressos em ordem crescente.

Conclusão

Neste exercício podemos aprender como resolver um problema simples de forma eficaz e como a lógica de resolução de problemas é comum em diferentes linguagens de programação, mesmo que a sintaxe e as ferramentas específicas possam variar. Isso ilustra a portabilidade dos conceitos de programação entre diferentes 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 #LógicaDeProgramação #Ordenação #GiovaniDaCruz