O número 3025 tem a seguinte característica: 30+25=55 e 552=3025. Sendo um número de Kaprekar. Crie um algoritmo e um programa que solicite o usuário informar um número inteiro de quatro dígitos. O programa deve verificar e mostrar na tela uma mensagem indicando se este número possui esta característica, ou seja, ser um Número de Kaprekar.

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