Introdução
Neste laboratório, aprenderá a calcular combinações (nCr) usando um programa em C. O laboratório cobre dois passos principais: ler os valores de entrada para n e r, e depois implementar a fórmula para calcular a combinação nCr = n! / (r! * (n-r)!). No final deste laboratório, terá um programa em C funcional que pode calcular combinações para quaisquer valores de n e r.
O laboratório começa demonstrando como ler os valores de entrada para n e r usando a função scanf(). Em seguida, apresenta a implementação das funções de cálculo fatorial e de combinação, que são usadas para calcular o resultado final. O laboratório fornece o código completo e instruções passo a passo, facilitando a sua compreensão e aplicação dos conceitos em seus próprios projetos.
Ler n e r
Neste passo, aprenderá a ler valores de entrada para n e r para calcular combinações num programa em C.
Primeiro, crie um novo ficheiro C para o seu programa de cálculo de combinações:
cd ~/project
nano combinations.c
Agora, adicione o seguinte código para ler os valores de entrada:
#include <stdio.h>
int main() {
int n, r;
// Solicita ao utilizador que introduza os valores para n e r
printf("Introduza o valor de n: ");
scanf("%d", &n);
printf("Introduza o valor de r: ");
scanf("%d", &r);
// Imprime os valores introduzidos para verificar a entrada
printf("Introduziu n = %d e r = %d\n", n, r);
return 0;
}
Compile e execute o programa para testar a entrada:
gcc combinations.c -o combinations
./combinations
Exemplo de saída:
Introduza o valor de n: 5
Introduza o valor de r: 3
Introduziu n = 5 e r = 3
Este código demonstra como:
- Usar
scanf()para ler entradas inteiras do utilizador - Solicitar ao utilizador que introduza os valores para n e r
- Imprimir os valores introduzidos para confirmar a entrada correta
O código estabelece a base para o cálculo de combinações, capturando primeiro os valores de entrada necessários n e r.
Calcular nCr = n!/(r!(n-r)!)
Neste passo, implementará uma função para calcular o fatorial e calcular combinações usando a fórmula nCr = n! / (r! * (n-r)!).
Abra o ficheiro combinations.c anterior e atualize-o com as funções de cálculo fatorial e de combinação:
cd ~/project
nano combinations.c
Adicione o seguinte código para implementar os cálculos fatorial e de combinação:
#include <stdio.h>
// Função para calcular o fatorial
unsigned long long factorial(int num) {
if (num == 0 || num == 1) {
return 1;
}
unsigned long long result = 1;
for (int i = 2; i <= num; i++) {
result *= i;
}
return result;
}
// Função para calcular combinações (nCr)
unsigned long long combinations(int n, int r) {
// Validar a entrada
if (r > n) {
return 0;
}
// Usar a fórmula de combinação: nCr = n! / (r! * (n-r)!)
unsigned long long numerator = factorial(n);
unsigned long long denominator = factorial(r) * factorial(n - r);
return numerator / denominator;
}
int main() {
int n, r;
// Solicitar ao utilizador que introduza os valores para n e r
printf("Introduza o valor de n: ");
scanf("%d", &n);
printf("Introduza o valor de r: ");
scanf("%d", &r);
// Calcular e imprimir a combinação
unsigned long long result = combinations(n, r);
printf("Combinação C(%d, %d) = %llu\n", n, r, result);
return 0;
}
Compile e execute o programa:
gcc combinations.c -o combinations
./combinations
Exemplo de saída:
Introduza o valor de n: 5
Introduza o valor de r: 3
Combinação C(5, 3) = 10
Pontos chave desta implementação:
- A função
factorial()calcula o fatorial de um número dado. - A função
combinations()implementa a fórmula de combinação. - Usa
unsigned long longpara lidar com cálculos de fatorial maiores. - Valida a entrada para evitar combinações inválidas.
Imprimir o Resultado
Neste passo, melhorará o programa de cálculo de combinações adicionando uma saída mais informativa e tratamento de erros.
Abra o ficheiro combinations.c e modifique o código:
cd ~/project
nano combinations.c
Atualize o código com a impressão de resultados melhorada e validação de entrada:
#include <stdio.h>
// As funções anteriores de fatorial e combinações permanecem as mesmas
int main() {
int n, r;
// Solicitar ao utilizador que introduza os valores para n e r
printf("Calculadora de Combinação (nCr)\n");
printf("-----------------------------\n");
// Validação de entrada
do {
printf("Introduza o número total de itens (n): ");
scanf("%d", &n);
if (n < 0) {
printf("Erro: n deve ser um inteiro não negativo.\n");
}
} while (n < 0);
do {
printf("Introduza o número de itens a escolher (r): ");
scanf("%d", &r);
if (r < 0 || r > n) {
printf("Erro: r deve estar entre 0 e n.\n");
}
} while (r < 0 || r > n);
// Calcular a combinação
unsigned long long result = combinations(n, r);
// Saída detalhada do resultado
printf("\nDetalhes do Resultado:\n");
printf("----------------\n");
printf("Itens totais (n): %d\n", n);
printf("Itens a escolher (r): %d\n", r);
printf("Combinações possíveis (nCr): %llu\n", result);
// Explicação do resultado
printf("\nInterpretação:\n");
printf("---------------\n");
printf("Existem %llu maneiras de escolher %d itens de um conjunto de %d itens.\n",
result, r, n);
return 0;
}
Compile e execute o programa:
gcc combinations.c -o combinations
./combinations
Exemplo de saída:
Calculadora de Combinação (nCr)
-----------------------------
Introduza o número total de itens (n): 5
Introduza o número de itens a escolher (r): 3
Detalhes do Resultado:
----------------
Itens totais (n): 5
Itens a escolher (r): 3
Combinações possíveis (nCr): 10
Interpretação:
---------------
Existem 10 maneiras de escolher 3 itens de um conjunto de 5 itens.
Melhorias chave:
- Adicionada validação de entrada para evitar entradas inválidas.
- Saída melhorada com detalhes do resultado.
- Fornecida interpretação do resultado da combinação.
Resumo
Neste laboratório, aprendeu a ler valores de entrada para n e r, e depois a calcular as combinações (nCr) usando a fórmula nCr = n! / (r! * (n-r)!). Implementou funções para calcular o fatorial e as combinações, e depois utilizou essas funções para calcular o resultado final. Os passos principais foram: 1) ler os valores de entrada para n e r, e 2) calcular as combinações usando a fórmula e a função fatorial.
