Exercício 3 de Programação em Linguagem de Alto Nível
Seção 4.8: Exercícios de Programação (Questões 2-4, 6-8)
Questão 2: Manipulação de Nomes com Formatação
Este programa solicita ao usuário um nome e demonstra várias opções de formatação para exibi-lo, incluindo alinhamento e preenchimento com espaços.
#include <stdio.h>
#include <string.h>
int main(void){
char nomeUsuario[30];
printf("Digite o seu nome: ");
scanf("%s", nomeUsuario);
printf("\"%s\"\n", nomeUsuario); // Exibe o nome entre aspas
printf("\"%20s\"\n", nomeUsuario); // Exibe o nome em um campo de 20 caracteres, alinhado à direita
printf("\"%-20s\"\n", nomeUsuario); // Exibe o nome em um campo de 20 caracteres, alinhado à esquerda
int larguraNecessaria = strlen(nomeUsuario) + 3;
printf("\"%*s\"\n", larguraNecessaria, nomeUsuario); // Exibe o nome em um campo 3 caracteres maior que o nome
return 0;
}
Questão 3: Formatação de Números de Ponto Flutuante
O programa lê um número de ponto flutuante e o exibe em notação decimal e científica, com diferentes precisões.
#include <stdio.h>
int main(void){
float numero;
printf("Digite um número de ponto flutuante: ");
scanf("%f", &numero);
printf("O número digitado é %.1f ou %.1e.\n", numero, numero);
printf("O número digitado é %+.3f ou %.3E.\n", numero, numero);
return 0;
}
Questão 4: Conversão de Altura e Exibição Formatada
Solicita a altura em polegadas e o nome do usuário, exibindo a altura em pés com formatação específica.
#include <stdio.h>
int main(void){
float alturaPolegadas;
char nome[30];
printf("Digite a altura em polegadas e o nome: ");
scanf("%f %s", &alturaPolegadas, nome);
printf("%s, você tem %.3f pés de altura.\n", nome, alturaPolegadas / 12.0);
return 0;
}
Questão 6: Exibição de Tamanhos de Strings Alinhados
Pede ao usuário para digitar o primeiro e o último nome, exibindo-os e, em seguida, o comprimento de cada nome, alinhado com o final e o início dos nomes correspondentes.
#include <stdio.h>
#include <string.h>
int main(void){
char primeiroNome[30];
char ultimoNome[30];
printf("Digite o primeiro nome: ");
scanf(" %s", primeiroNome);
printf("Digite o último nome: ");
scanf(" %s", ultimoNome);
printf("%s %s\n", primeiroNome, ultimoNome);
// Exibe o comprimento dos nomes alinhado à direita
printf("%*d %*d\n", (int)strlen(primeiroNome), (int)strlen(primeiroNome), (int)strlen(ultimoNome), (int)strlen(ultimoNome));
// Exibe os nomes novamente para alinhar o próximo conjunto de comprimentos
printf("%s %s\n", primeiroNome, ultimoNome);
// Exibe o comprimento dos nomes alinhado à esquerda
printf("%-*d %-*d\n", (int)strlen(primeiroNome), (int)strlen(primeiroNome), (int)strlen(ultimoNome), (int)strlen(ultimoNome));
return 0;
}
Questão 7: Precisão de Ponto Flutuante (float vs. double)
Compara a precisão de double e float ao representar a fração 1.0/3.0. Exibe os valores com diferentes precisões e também os valores de FLT\_DIG e DBL\_DIG.
#include <stdio.h>
#include <float.h>
int main(void){
double valorDouble = 1.0 / 3.0;
float valorFloat = 1.0 / 3.0;
printf("Precisão double: %.6f | %.12f | %.16f\n", valorDouble, valorDouble, valorDouble);
printf("Precisão float: %.6f | %.12f | %.16f\n", valorFloat, valorFloat, valorFloat);
printf("FLT_DIG: %d\n", FLT_DIG);
printf("DBL_DIG: %d\n", DBL_DIG);
// Observação: A comparação dos valores impressos com FLT_DIG e DBL_DIG indicará a diferença de precisão.
return 0;
}
Questão 8: Cálculo de Consumo de Combustível e Conversão de Unidades
Calcula a quilometragem por galão (MPG) e converte para litros por 100 km (L/100km). Utiliza constantes simbólicas para os fatores de conversão.
#include <stdio.h>
#define LITROS_POR_GALAO 3.785
#define QUILOMETROS_POR_MILHA 1.609
int main(void){
double milhas, galoes;
printf("Digite a distância percorrida (milhas) e o consumo de combustível (galões): ");
scanf("%lf %lf", &milhas, &galoes);
// Cálculo em Milhas por Galão (MPG)
if (galoes > 0) {
double mpg = milhas / galoes;
printf("Consumo: %.1f milhas por galão\n", mpg);
// Conversão para Litros por 100 km (L/100km)
// 1 milha = 1.609 km
// 1 galão = 3.785 L
// MPG = milhas / galoes
// km = milhas * 1.609
// L = galoes * 3.785
// L/100km = (L / km) * 100
// L/100km = ( (galoes * 3.785) / (milhas * 1.609) ) * 100
// L/100km = (galoes / milhas) * (3.785 / 1.609) * 100
// L/100km = (1 / MPG) * (3.785 / 1.609) * 100
double litrosPor100km = (galoes / milhas) * (LITROS_POR_GALAO / QUILOMETROS_POR_MILHA) * 100.0;
printf("Consumo: %.1f L/100km\n", litrosPor100km);
} else {
printf("O consumo de combustível não pode ser zero ou negativo.\n");
}
return 0;
}
Seção 5.11: Exercícios de Programação (Questões 1-9)
Questão 1: Conversão de Tempo (Minutos para Horas e Minutos)
Converte um tempo em minutos para horas e minutos. Utiliza uma constante para 60 e um loop while para permitir múltiplas conversões até que um valor não positivo seja inserido.
#include <stdio.h>
int main(void){
const int MINUTOS_POR_HORA = 60;
int minutosEntrada;
while (1) {
printf("Digite o tempo em minutos (ou 0 ou menos para sair): ");
scanf("%d", &minutosEntrada);
if (minutosEntrada <= 0) {
break; // Sai do loop se a entrada for menor ou igual a 0
}
int horas = minutosEntrada / MINUTOS_POR_HORA;
int minutosRestantes = minutosEntrada % MINUTOS_POR_HORA;
printf("%d minutos = %d horas e %d minutos\n", minutosEntrada, horas, minutosRestantes);
}
return 0;
}
Questão 2: Exibição de Sequência de Inteiros
Solicita um número inteiro e exibe uma sequência de 11 números, começando pelo número fornecido e terminando 10 números à frente.
#include <stdio.h>
int main(void){
int numeroBase;
printf("Digite um número inteiro: ");
scanf("%d", &numeroBase);
printf("Sequência de %d a %d:\n", numeroBase, numeroBase + 10);
for (int i = 0; i <= 10; i++) {
printf("%d ", numeroBase + i);
}
printf("\n");
return 0;
}
Questão 3: Conversão de Dias para Semanas e Dias
Converte um número de dias em semanas e dias. Um loop while continua solicitando entrada até que um número não positivo seja inserido.
#include <stdio.h>
int main(void){
const int DIAS_POR_SEMANA = 7;
int totalDias;
printf("Digite o número de dias (ou 0 ou menos para sair): ");
scanf("%d", &totalDias);
while (totalDias > 0) {
int semanas = totalDias / DIAS_POR_SEMANA;
int diasRestantes = totalDias % DIAS_POR_SEMANA;
printf("%d dias = %d semanas e %d dias\n", totalDias, semanas, diasRestantes);
printf("Digite o número de dias (ou 0 ou menos para sair): ");
scanf("%d", &totalDias);
}
return 0;
}
Questão 4: Conversão de Altura (cm para Pés e Polegadas)
Converte altura em centímetros para pés e polegadas. O programa permite múltiplas entradas até que um valor não positivo seja inserido.
#include <stdio.h>
#define CM_POR_PE 30.48
#define POLEGADAS_POR_PE 12.0
#define CM_POR_POLEGADA 2.54
int main(void){
float alturaCm;
int pes;
printf("Digite a altura em centímetros (ou 0 ou menos para sair): ");
scanf("%f", &alturaCm);
while (alturaCm > 0) {
pes = (int)(alturaCm / CM_POR_PE); // Calcula o número inteiro de pés
float cmRestantes = alturaCm - (pes * CM_POR_PE);
float polegadas = cmRestantes / CM_POR_POLEGADA;
printf("%.1f cm = %d pés, %.1f polegadas\n", alturaCm, pes, polegadas);
printf("Digite a altura em centímetros (ou 0 ou menos para sair): ");
scanf("%f", &alturaCm);
}
printf("Até logo!\n");
return 0;
}
Questão 5: Programa Interativo de Soma Progressiva
Modifica um programa existente para calcular a soma de 1 a N, onde N é fornecido pelo usuário.
#include <stdio.h>
int main(void){
int contador = 0;
int somaTotal = 0;
int diasUsuario;
printf("Quantos dias você trabalhou? ");
scanf("%d", &diasUsuario);
// O loop while incrementa o contador *antes* de usá-lo na soma
// Isso corresponde a somar 1, 2, 3, ..., diasUsuario
while (contador < diasUsuario) {
contador++;
somaTotal += contador;
}
printf("Em %d dias, você ganhou $%d\n", diasUsuario, somaTotal);
return 0;
}
Questão 6: Soma dos Quadrados
Modifica o programa anterior para calcular a soma dos quadrados dos primeiros N dias (1^2 + 2^2 + ... + N^2).
#include <stdio.h>
int main(void){
int contador = 0;
int somaDosQuadrados = 0;
int diasUsuario;
printf("Quantos dias você trabalhou? ");
scanf("%d", &diasUsuario);
while (contador < diasUsuario) {
contador++;
somaDosQuadrados += contador * contador; // Adiciona o quadrado do dia atual
}
printf("Em %d dias, a soma dos quadrados é $%d\n", diasUsuario, somaDosQuadrados);
return 0;
}
Questão 7: Função para Calcular Cubo
Pede ao usuário um número double e utiliza uma função definida pelo usuário (cubo) para calcular e exibir o valor do número ao cubo.
#include <stdio.h>
// Função para calcular o cubo de um número double
double calcularCubo(double num) {
return num * num * num;
}
int main(void){
double numeroUsuario;
printf("Digite um número double: ");
scanf("%lf", &numeroUsuario);
double resultadoCubo = calcularCubo(numeroUsuario);
printf("O cubo de %.2f é: %.2f\n", numeroUsuario, resultadoCubo);
return 0;
}
Questão 8: Operação de Módulo Interativa
Demonstra a operação de módulo. O programa solicita um número para ser o segundo operando (divisor) e o mantém fixo. Em seguida, solicita repetidamente o primeiro operando e exibe o resultado do módulo até que o usuário insira um valor não positivo.
#include <stdio.h>
int main(void){
int divisor;
int dividendo;
printf("Este programa calcula o módulo.\n");
printf("Digite um inteiro para ser o segundo operando (divisor): ");
scanf("%d", &divisor);
// Validação simples para evitar divisão por zero
if (divisor == 0) {
printf("Erro: O divisor não pode ser zero.\n");
return 1; // Indica erro
}
printf("Agora digite o primeiro operando (dividendo): ");
scanf("%d", ÷ndo);
while (dividendo > 0) {
printf("%d %% %d é %d\n", dividendo, divisor, dividendo % divisor);
printf("Digite o próximo dividendo (<= 0 para sair): ");
scanf("%d", ÷ndo);
}
printf("Fim do programa.\n");
return 0;
}
Questão 9: Conversão de Temperatura (Fahrenheit, Celsius, Kelvin)
Pede ao usuário uma temperatura em Fahrenheit e a converte para Celsius e Kelvin usando uma função Temperaturas. O programa continua solicitando entradas até que o usuário insira 'q' ou qualquer caractere não numérico.
#include <stdio.h>
// Função para converter e exibir temperaturas
void exibirTemperaturas(double fahrenheit) {
const double FATOR_CONVERSAO_C = 5.0 / 9.0;
const double SUBTRACAO_C = 32.0;
const double ADICAO_K = 273.16;
double celsius = FATOR_CONVERSAO_C * (fahrenheit - SUBTRACAO_C);
double kelvin = celsius + ADICAO_K;
printf("%.2f ℉ = %.2f ℃ = %.2f K\n", fahrenheit, celsius, kelvin);
}
int main(void){
double tempFahrenheit;
printf("Digite uma temperatura em Fahrenheit (℉): ");
// scanf retorna o número de itens lidos com sucesso.
// Comparamos com 1 para garantir que um double foi lido.
while (scanf("%lf", &tempFahrenheit) == 1) {
exibirTemperaturas(tempFahrenheit);
printf("Digite a próxima temperatura em Fahrenheit (℉) (ou 'q' para sair): ");
}
printf("Fim do programa.\n");
return 0;
}
Design de Programa: Prioridade de Operadores
Programa 1: Demonstração da Prioridade de Operadores
Este programa tenta inferir e exibir a prioridade relativa de alguns operadores aritméticos e de encremento/decremento com base em seus resultados.
#include <stdio.h>
int main(void){
int a = 5, b = 6, c = 1;
// Variáveis para armazenar níveis de prioridade (menor valor = maior prioridade)
int priIncrementoDecremento = 1; // Ex: ++, --
int priMultiplicacaoDivisao = 1; // Ex: *, /
int priAdicaoSubtracao = 1; // Ex: +, -
// Teste para ++ e -
// Se (++a - b) == 0, significa que ++a foi avaliado antes de -b
// No exemplo: ++a = 6, 6 - 6 = 0. A condição é verdadeira.
// priIncrementoDecremento permanece 1 (maior prioridade), priAdicaoSubtracao permanece 1.
if ((++a - b) == 0) {
// A estrutura original do código parece ter uma lógica de incremento que
// pode ser confusa. Vamos reinterpretar para clareza:
// Se a condição for verdadeira, a prioridade de ++ é maior que -, o que é o padrão.
// Não precisamos alterar priIncrementoDecremento neste caso se assumirmos a prioridade padrão.
} else {
priAdicaoSubtracao++; // Se não for 0, a prioridade de '+' ou '-' pode ser maior.
}
// Resetando 'a' para o teste original, caso tenha sido modificado.
// A partir daqui, 'a' é 6 (do ++a anterior).
// Teste para * e --
// Se (a * --c) == 0, significa que --c foi avaliado antes de *a
// No exemplo: --c = 0. a * 0 = 0. A condição é verdadeira.
if ((a * --c) == 0) {
// priIncrementoDecremento permanece 1.
} else {
priMultiplicacaoDivisao++; // Se não for 0, a prioridade de '*' ou '/' pode ser maior.
}
// Teste para * e -
// Se (a*b - b) != 0, significa que * tem prioridade sobre -
// No exemplo: a=6, b=6. a*b = 36. 36 - 6 = 30. 30 != 0. A condição é verdadeira.
if ((a * b - b) != 0) {
// priMultiplicacaoDivisao permanece 1.
} else {
priAdicaoSubtracao++; // Se for 0, a prioridade de '+' ou '-' pode ser maior.
}
printf("Prioridade '++' '--': %d\n", priIncrementoDecremento);
printf("Prioridade '*' '/': %d\n", priMultiplicacaoDivisao);
printf("Prioridade '+' '-': %d\n", priAdicaoSubtracao);
// Nota: A lógica original do código tenta "aumentar" a prioridade de um operador
// quando a condição esperada para sua prioridade mais alta *não* é satisfeita.
// Isso pode levar a interpretações confusas. O código acima tenta clarificar a intenção.
// A saída esperada, seguindo as regras padrão de C, é que ++/-- e */% tenham prioridade maior que +/-,
// o que seria representado por um valor menor nas variáveis `pri` se elas funcionassem
// como um "nível" onde 1 é o mais alto.
return 0;
}
Programa 2: Exibição de Níveis de Prioridade de Operadores
Exibe os níveis de prioridade de operadores comuns em C, ordenados do mais alto para o mais baixo.
#include <stdio.h>
int main(void){
int nivelPrioridade = 1;
printf("Operadores por prioridade (do mais alto para o mais baixo):\n");
printf("Prioridade %d: '()' '[]'\n", nivelPrioridade++);
printf("Prioridade %d: '++' '--'\n", nivelPrioridade++);
printf("Prioridade %d: '*' '/' '%%'\n", nivelPrioridade++);
printf("Prioridade %d: '+' '-'\n", nivelPrioridade++);
// Adicionar mais níveis conforme necessário (ex: relacionais, lógicos, etc.)
return 0;
}
Resumo e Reflexões
- Aprendizado sobre a estrutura de controle
whilepara repetição de blocos de código. - Compreensão do uso de
constpara definir variáveis constantes e#definepara criar constantes simbólicas. - Introdução e consolidação do conhecimento sobre a ordem de avaliação (prioridade) de diferentes operadores em C.
- Prática na criação e utilização de funções definidas pelo usuário para modularizar o código.