Faça um algoritmo e um programa que leia um valor inteiro (representando uma quantidade monetária em reais) e escreva a quantidade mínima de cédulas de 200, 100, 50, 20, 10, 5, 2 e moeda de 1 para representar esse valor.

Fala galera da programação, tudo beleza?

Já se perguntaram como um caixa eletrônico sabe quais notas de dinheiro entregar? Este exercício lembra de certa forma isso, tentando fornecer o menor número de notas possíveis para atender um valor informado,

Exemplo: Caso o valor seja 1446 reais deve escrever:

7 nota(s) de duzentos reais;
0 nota(s) de cem reais;
0 nota(s) de cinquenta reais;
2 nota(s) de vinte reais;
0 nota(s) de dez reais;
1 nota(s) de cinco reais;
0 nota(s) de dois reais;
1 moeda(s) de um real.

Legal? Então vamos ao código!

Exemplo em C / C++

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

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

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

int main() {
    int valor, quantidade;

    // Solicita ao usuário inserir um valor inteiro
    std::cout << "Digite um valor em reais: ";
    std::cin >> valor;

    // Calcula a quantidade de notas de 200
    quantidade = valor / 200;
    std::cout << quantidade << " nota(s) de duzentos reais;" << std::endl;
    valor %= 200;

    // Calcula a quantidade de notas de 100
    quantidade = valor / 100;
    std::cout << quantidade << " nota(s) de cem reais;" << std::endl;
    valor %= 100;

    // Continua o mesmo processo para as demais cédulas e moedas
    quantidade = valor / 50;
    std::cout << quantidade << " nota(s) de cinquenta reais;" << std::endl;
    valor %= 50;

    quantidade = valor / 20;
    std::cout << quantidade << " nota(s) de vinte reais;" << std::endl;
    valor %= 20;

    quantidade = valor / 10;
    std::cout << quantidade << " nota(s) de dez reais;" << std::endl;
    valor %= 10;

    quantidade = valor / 5;
    std::cout << quantidade << " nota(s) de cinco reais;" << std::endl;
    valor %= 5;

    quantidade = valor / 2;
    std::cout << quantidade << " nota(s) de dois reais;" << std::endl;
    valor %= 2;

    // A quantidade restante é a quantidade de moedas de 1 real
    std::cout << valor << " moeda(s) de um real." << std::endl;

    return 0;
}

Este programa solicita ao usuário inserir um valor em reais, e então calcula a quantidade mínima de cédulas de 200, 100, 50, 20, 10, 5, 2 e moedas de 1 necessárias para representar esse valor.

Funcionamento Geral:

• O programa recebe um valor em reais do usuário.
• Calcula a quantidade de cédulas ou moedas de cada denominação, começando pela maior (duzentos reais) e indo até a menor (um real).
• Imprime a quantidade de cada cédula ou moeda.

Observações:

• O operador % é usado para calcular o restante da divisão, o que permite atualizar o valor para o próximo cálculo.
• Cada bloco de código corresponde a uma denominação de cédula ou moeda.
• Ao final, o programa imprime a quantidade de moedas de um real com a variável valor restante.

Exemplo em Pascal

{

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

}
program ContagemCedulasEMoedas;

var
  valor, quantidade: integer;

begin
  // Solicita ao usuário inserir um valor inteiro
  write('Digite um valor em reais: ');
  readln(valor);

  // Calcula e imprime a quantidade de notas de 200
  quantidade := valor div 200;
  writeln(quantidade, ' nota(s) de duzentos reais;');
  valor := valor mod 200;

  // Calcula e imprime a quantidade de notas de 100
  quantidade := valor div 100;
  writeln(quantidade, ' nota(s) de cem reais;');
  valor := valor mod 100;

  // Continua o mesmo processo para as demais cédulas e moedas
  quantidade := valor div 50;
  writeln(quantidade, ' nota(s) de cinquenta reais;');
  valor := valor mod 50;

  quantidade := valor div 20;
  writeln(quantidade, ' nota(s) de vinte reais;');
  valor := valor mod 20;

  quantidade := valor div 10;
  writeln(quantidade, ' nota(s) de dez reais;');
  valor := valor mod 10;

  quantidade := valor div 5;
  writeln(quantidade, ' nota(s) de cinco reais;');
  valor := valor mod 5;

  quantidade := valor div 2;
  writeln(quantidade, ' nota(s) de dois reais;');
  valor := valor mod 2;

  // A quantidade restante é a quantidade de moedas de 1 real
  writeln(valor, ' moeda(s) de um real.');
end.

Este programa em Pascal realiza a mesma lógica que o programa em C++ explicado anteriormente.

Observações:

• Em Pascal, o operador div é usado para a divisão inteira, enquanto o operador mod retorna o resto da divisão inteira.
• Cada bloco de código corresponde a uma denominação de cédula ou moeda.
• Ao final, o programa imprime a quantidade de moedas de um real com a variável valor restante.

Exemplo em Python

'''

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

'''

# Solicita ao usuário inserir um valor inteiro
valor = int(input("Digite um valor em reais: "))

# Calcula e imprime a quantidade de notas de 200
quantidade = valor // 200
print(f"{quantidade} nota(s) de duzentos reais;")
valor %= 200

# Calcula e imprime a quantidade de notas de 100
quantidade = valor // 100
print(f"{quantidade} nota(s) de cem reais;")
valor %= 100

# Continua o mesmo processo para as demais cédulas e moedas
quantidade = valor // 50
print(f"{quantidade} nota(s) de cinquenta reais;")
valor %= 50

quantidade = valor // 20
print(f"{quantidade} nota(s) de vinte reais;")
valor %= 20

quantidade = valor // 10
print(f"{quantidade} nota(s) de dez reais;")
valor %= 10

quantidade = valor // 5
print(f"{quantidade} nota(s) de cinco reais;")
valor %= 5

quantidade = valor // 2
print(f"{quantidade} nota(s) de dois reais;")
valor %= 2

# A quantidade restante é a quantidade de moedas de 1 real
print(f"{valor} moeda(s) de um real.")

Este código Python realiza a mesma lógica que os programas em C++ e Pascal, mas utiliza a sintaxe específica do Python.

Observações:

• Em Python, o operador // é usado para divisão inteira, e % retorna o resto da divisão inteira.
• A f-string é uma maneira conveniente de formatar strings no Python, permitindo a inclusão de variáveis diretamente na string.

Exemplo em C#

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

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

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

class ProgramaNotas
{
    static void Main()
    {
        // Solicita ao usuário inserir um valor inteiro
        Console.Write("Digite um valor em reais: ");
        int valor = int.Parse(Console.ReadLine());

        // Calcula e imprime a quantidade de notas de 200
        int quantidade = valor / 200;
        Console.WriteLine($"{quantidade} nota(s) de duzentos reais;");
        valor %= 200;

        // Calcula e imprime a quantidade de notas de 100
        quantidade = valor / 100;
        Console.WriteLine($"{quantidade} nota(s) de cem reais;");
        valor %= 100;

        // Continua o mesmo processo para as demais cédulas e moedas
        quantidade = valor / 50;
        Console.WriteLine($"{quantidade} nota(s) de cinquenta reais;");
        valor %= 50;

        quantidade = valor / 20;
        Console.WriteLine($"{quantidade} nota(s) de vinte reais;");
        valor %= 20;

        quantidade = valor / 10;
        Console.WriteLine($"{quantidade} nota(s) de dez reais;");
        valor %= 10;

        quantidade = valor / 5;
        Console.WriteLine($"{quantidade} nota(s) de cinco reais;");
        valor %= 5;

        quantidade = valor / 2;
        Console.WriteLine($"{quantidade} nota(s) de dois reais;");
        valor %= 2;

        // A quantidade restante é a quantidade de moedas de 1 real
        Console.WriteLine($"{valor} moeda(s) de um real.");
    }
}

Este código C# realiza a mesma lógica dos programas em C++, Pascal e Python, mas utiliza a sintaxe específica do C#.

Observações:

• O operador % é usado para calcular o resto da divisão inteira.
• A interpolação de strings ($"{quantidade} nota(s) de duzentos reais;") facilita a criação de strings formatadas com valores de variáveis.

Exemplo em Java

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

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

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

public class ContagemCedulasEMoedas {
    public static void main(String[] args) {
        // Cria um scanner para entrada de dados
        Scanner scanner = new Scanner(System.in);

        // Solicita ao usuário inserir um valor inteiro
        System.out.print("Digite um valor em reais: ");
        int valor = scanner.nextInt();

        // Calcula e imprime a quantidade de notas de 200
        int quantidade = valor / 200;
        System.out.println(quantidade + " nota(s) de duzentos reais;");
        valor %= 200;

        // Calcula e imprime a quantidade de notas de 100
        quantidade = valor / 100;
        System.out.println(quantidade + " nota(s) de cem reais;");
        valor %= 100;

        // Continua o mesmo processo para as demais cédulas e moedas
        quantidade = valor / 50;
        System.out.println(quantidade + " nota(s) de cinquenta reais;");
        valor %= 50;

        quantidade = valor / 20;
        System.out.println(quantidade + " nota(s) de vinte reais;");
        valor %= 20;

        quantidade = valor / 10;
        System.out.println(quantidade + " nota(s) de dez reais;");
        valor %= 10;

        quantidade = valor / 5;
        System.out.println(quantidade + " nota(s) de cinco reais;");
        valor %= 5;

        quantidade = valor / 2;
        System.out.println(quantidade + " nota(s) de dois reais;");
        valor %= 2;

        // A quantidade restante é a quantidade de moedas de 1 real
        System.out.println(valor + " moeda(s) de um real.");

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

Este código Java realiza a mesma lógica dos programas em C++, Pascal, Python e C#, mas utiliza a sintaxe específica do Java.

Observações:

• A classe Scanner é utilizada para obter entrada do usuário.
• O operador % é usado para calcular o resto da divisão inteira.

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!