Exercício: formar grupos de alunos e calcular o resto

Fala galera da programação, tudo beleza?

E ai, gostam de fazer trabalhos em grupo na sala de aula? As vezes é uma confusão para conseguir montar. Utilizando esta temática vamos fazer este interessante exercício.

Vamos ler o total de alunos da sala e ler quantos alunos haverão por grupo, assim podemos ter uma ideia de quantos grupos serão formados.

Então, vamos ao código:

 

Exemplo em Portugol (Portugol Studio)

/*

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

*/

programa
{
    
    funcao inicio()
    {

          // delcarando variáveis
          inteiro totalAlunos, alunosPorGrupo, grupos, resto
        
        
          // Solicita a quantidade de alunos e alunos por grupo
          escreva("Digite a quantidade total de alunos na sala: ")
          leia(totalAlunos)
        
          escreva("Digite a quantidade de alunos por grupo: ")
          leia(alunosPorGrupo)
        
          // Calcula a quantidade de grupos e o resto de alunos
          grupos = totalAlunos / alunosPorGrupo
          resto = totalAlunos % alunosPorGrupo
        
          // Exibe os resultados
          escreva("Número de grupos formados: ", grupos, "\n")
          escreva("Resto de alunos que não formaram um grupo completo: ", resto)


    }
}

Este programa lê a quantidade total de alunos na sala e a quantidade de alunos por grupo. Em seguida, ele calcula o número de grupos formados e o resto de alunos que não foram suficientes para formar mais um grupo. Os resultados são exibidos na tela.

 

Exemplo em C / C++

/*

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

*/
#include <iostream>

int main() {
    int totalAlunos, alunosPorGrupo;

    // Solicita a quantidade de alunos e alunos por grupo
    std::cout << "Digite a quantidade total de alunos na sala: ";
    std::cin >> totalAlunos;

    std::cout << "Digite a quantidade de alunos por grupo: ";
    std::cin >> alunosPorGrupo;

    // Calcula a quantidade de grupos e o resto de alunos
    int grupos = totalAlunos / alunosPorGrupo;
    int resto = totalAlunos % alunosPorGrupo;

    // Exibe os resultados
    std::cout << "\nNúmero de grupos formados: " << grupos << std::endl;
    std::cout << "Resto de alunos que não formaram um grupo completo: " << resto << std::endl;

    return 0;
}

Assim como o exemplo em Portugol, este programa lê a quantidade total de alunos na sala e a quantidade de alunos por grupo. Em seguida, ele calcula o número de grupos formados e o resto de alunos que não foram suficientes para formar mais um grupo. Os resultados são exibidos na tela.

 

Exemplo em Pascal / Delphi / Lazarus

{

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

}
program CalcularGrupos;

var
  totalAlunos, alunosPorGrupo, grupos, resto: Integer;

begin
  // Solicita a quantidade de alunos e alunos por grupo
  Write('Digite a quantidade total de alunos na sala: ');
  Readln(totalAlunos);

  Write('Digite a quantidade de alunos por grupo: ');
  Readln(alunosPorGrupo);

  // Calcula a quantidade de grupos e o resto de alunos
  grupos := totalAlunos div alunosPorGrupo;
  resto := totalAlunos mod alunosPorGrupo;

  // Exibe os resultados
  Writeln;
  Writeln('Número de grupos formados: ', grupos);
  Writeln('Resto de alunos que não formaram um grupo completo: ', resto);

end.

O código em Pascal segue uma lógica semelhante ao código em C++. Ele utiliza a estrutura básica de um programa Pascal, com declaração de variáveis, entrada de dados, cálculos e exibição dos resultados. As funções Write e Writeln são utilizadas para exibir mensagens no console, e Readln é usada para ler valores do teclado.

 

Exemplo em Python

'''

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

'''

# Solicita a quantidade de alunos e alunos por grupo
total_alunos = int(input("Digite a quantidade total de alunos na sala: "))
alunos_por_grupo = int(input("Digite a quantidade de alunos por grupo: "))

# Calcula a quantidade de grupos e o resto de alunos
grupos = total_alunos // alunos_por_grupo
resto = total_alunos % alunos_por_grupo

# Exibe os resultados
print("\nNúmero de grupos formados:", grupos)
print("Resto de alunos que não formaram um grupo completo:", resto)

Em Python, a entrada de dados é realizada pela função input(), que retorna uma string, e a conversão para inteiro é feita usando int(). A divisão inteira é representada pelo operador //, e o operador % retorna o resto da divisão. A função print() é usada para exibir os resultados no console.

 

Exemplo em C#

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

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

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

class Program
{
    static void Main()
    {
        // Solicita a quantidade de alunos e alunos por grupo
        Console.Write("Digite a quantidade total de alunos na sala: ");
        int totalAlunos = Convert.ToInt32(Console.ReadLine());

        Console.Write("Digite a quantidade de alunos por grupo: ");
        int alunosPorGrupo = Convert.ToInt32(Console.ReadLine());

        // Calcula a quantidade de grupos e o resto de alunos
        int grupos = totalAlunos / alunosPorGrupo;
        int resto = totalAlunos % alunosPorGrupo;

        // Exibe os resultados
        Console.WriteLine("\nNúmero de grupos formados: " + grupos);
        Console.WriteLine("Resto de alunos que não formaram um grupo completo: " + resto);
    }
}

O código em C# segue uma lógica semelhante aos exemplos em C++ e Pascal. Utiliza a classe Console para entrada/saída de dados e a classe Convert para converter as strings de entrada em números inteiros. A divisão inteira é realizada com o operador /, e o operador % é usado para obter o resto da divisão. Os resultados são exibidos usando Console.WriteLine().

 

Exemplo em Java

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

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

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

public class CalcularGrupos {

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

        // Solicita a quantidade de alunos e alunos por grupo
        System.out.print("Digite a quantidade total de alunos na sala: ");
        int totalAlunos = scanner.nextInt();

        System.out.print("Digite a quantidade de alunos por grupo: ");
        int alunosPorGrupo = scanner.nextInt();

        // Calcula a quantidade de grupos e o resto de alunos
        int grupos = totalAlunos / alunosPorGrupo;
        int resto = totalAlunos % alunosPorGrupo;

        // Exibe os resultados
        System.out.println("\nNúmero de grupos formados: " + grupos);
        System.out.println("Resto de alunos que não formaram um grupo completo: " + resto);
    }
}

 

Beleza pessoal? Espero que tenham gostado.

 

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

 

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