Algoritmos Jabour

Algoritmos Computacionais com aplica co es em C Bacharelado em Sistemas de Informa ca o Engenharia Mecatr onica IF Sudeste MG Filippe Jabour
17 de dezembro de 2012 http://www.jabour.com.br

Este material pode ser usado livremente, copiado ou distribu do, desde que citada a autoria.
A Feito no L TEX em ambiente Linux.
Sum ario
Lista de Algoritmos/Programas
viii
Lista de guras
xii
Lista de tabelas
xiii
1 Conceitos Iniciais 1.1 1.2 1.3 1.4 1.5 Refer encias e bibliograa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Algoritmos e a linguagem C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Vari avel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Tipos de vari aveis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Conceitos iniciais: aplica c oes em C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.5.1 1.5.2 1.5.3 1.6 O conceito de fun c ao . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . A fun c ao main . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Primeiros exemplos de programas em C . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1 1 1 2 3 3 3 4 4 6 7 7 7 7 7
Exerc cios Propostos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.6.1 1.6.2 1.6.3 1.6.4 1.6.5 M edia aritm etica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . M edia ponderada . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Aumento de sal ario . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Sal ario base com gratica c ao e impostos . . . . . . . . . . . . . . . . . . . . . . . . . . . . Opera c oes com um n umero . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
ii
1.6.6 1.6.7 1.6.8 1.6.9
Pre co do carro, impostos e lucro . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . C alculo de sal ario . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7 8 8 8 8
Saldo da conta ap os emiss ao de cheques . . . . . . . . . . . . . . . . . . . . . . . . . . . . Consumo de ra c ao de gatos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.6.10 Medida da escada enconstada . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2 O comando if-else (se-sen ao) 2.1 2.2 Descri c ao e exemplos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9 9
if-else: aplica c oes em C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12 2.2.1 2.2.2 A fun c ao scanf . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12 Uso do se-sen ao (if-else) em C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.3
Exerc cios Propostos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15 2.3.1 2.3.2 2.3.3 2.3.4 2.3.5 2.3.6 2.3.7 Adivinhar um n umero . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15 Vericar se um n umero e par ou mpar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15 Achar o maior de 3 n umeros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16 . . . . . . . . . . . . . . . . . . . . . 16
Vericar se um n umero e positivo, negativo ou nulo
Equa c ao do segundo grau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16 Soma n umeros e escolhe uma opera c ao com base no resultado da soma . . . . . . . . . . . 16 Verica se empr estimo pode ser concedido . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
3 Switch-case (escolha-caso) 3.1 3.2 3.3
17
Descri c ao e exemplos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17 switch-case: aplica c oes em C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
Exerc cios Propostos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21 3.3.1 3.3.2 3.3.3 Peso nos planetas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21 Quest ao de m ultipla escolha . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21 Calculadora simples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
iii
4 For (para) 4.1 4.2 4.3
23
Descri c ao e exemplos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23 for: aplica c oes em C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26 Exerc cios Propostos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28 4.3.1 4.3.2 4.3.3 4.3.4 4.3.5 4.3.6 4.3.7 4.3.8 Adivinhar um n umero com n tentativas . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28 Menu de op c oes e um for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28 Progress ao aritm etica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28 Sequ encia de Fibonacci . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29 Par de n umeros com soma denida . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29 Soma de alguns n umeros digitados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29 Achar os divisores de um n umero . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29 Imprimir somente acima da diagonal principal . . . . . . . . . . . . . . . . . . . . . . . . 29
5 while e do-while (enquanto e fa ca-enquanto) 5.1 5.2 5.3
31
Descri c ao e exemplos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31 while e do-while: aplica c oes em C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33 Exerc cios Propostos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35 5.3.1 5.3.2 5.3.3 5.3.4 5.3.5 5.3.6 5.3.7 Adivinhar no at e o usu ario acertar ou desistir . . . . . . . . . . . . . . . . . . . . . . . . . 35 Pre co de passagem a erea . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35 L e no s e exibe o maior, o menor e a quantidade . . . . . . . . . . . . . . . . . . . . . . . . 36 Menu para somar ou multiplicar no s . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36 Achar o n umero de m ultiplos em um intervalo . . . . . . . . . . . . . . . . . . . . . . . . 36
Imprimir todos menos os m ultiplos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36 Movimenta c ao banc aria . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
6 String, vetor e matriz 6.1
38
Vetor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
iv
6.2
String . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40 6.2.1 Fun c oes de manipula c ao de strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41 strlen() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41 strcpy() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42 strcat() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43 strcmp() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
6.3
Matriz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44 6.3.1 Matrizes de strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
6.4
Exerc cios Propostos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47 6.4.1 6.4.2 6.4.3 6.4.4 6.4.5 6.4.6 6.4.7 6.4.8 6.4.9 Calcular a m edia dos elementos de um vetor . . . . . . . . . . . . . . . . . . . . . . . . . . 47 Gerar vetor soma e produto a partir de 2 vetores originais . . . . . . . . . . . . . . . . . . 47 Imprimir vetor de tr as pra frente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48 Concatenar 2 vetores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48 Achar maior e menor elementos do vetor e somar seus elementos . . . . . . . . . . . . . . 48 Confere senha digitada . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48 Imprimir uma string de tr as para frente . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48 L e e imprime strings e n umeros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48 Soma de matrizes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
6.4.10 Soma dos elementos da diagonal principal . . . . . . . . . . . . . . . . . . . . . . . . . . . 49 6.4.11 Menu e matriz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
7 Fun c oes 7.1 7.2 7.3
50
Fun co es em C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50 Regras de escopo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53 Exerc cios Propostos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54 7.3.1 Calculadora usando fun c oes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
7.3.2 7.3.3 7.3.4 7.3.5 7.3.6 7.3.7
Equa c ao do segundo grau usando fun c oes . . . . . . . . . . . . . . . . . . . . . . . . . . . 54 Cria c ao de um vetor aleat orio usando fun c ao . . . . . . . . . . . . . . . . . . . . . . . . . 54 Concatena c ao de 2 vetores ordenados em um 3o tamb em ordenado . . . . . . . . . . . . . 54 Achar o maior, menor, m edia, soma e produto dos elementos do vetor, usando fun c oes . . 55 Produto de matrizes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55 Ordena c ao de vetor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
8 struct (Estrutura) 8.1 8.2 8.3 8.4
56
struct : conceitos iniciais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56 Acessando os elementos (campos) da estrutura . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58 Vetores de estruturas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58 Exerc cios Propostos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58 8.4.1 Cadastro de produtos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
9 Solu c ao dos Exerc cios 9.1 9.2 9.3 9.4 9.5 9.6 9.7
59
Respostas dos exerc cios do Cap tulo 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59 Respostas dos exerc cios do Cap tulo 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59 Respostas dos exerc cios do Cap tulo 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64 Respostas dos exerc cios do Cap tulo 4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67 Respostas dos exerc cios do Cap tulo 5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73 Respostas dos exerc cios do Cap tulo 6 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74 Respostas dos exerc cios do Cap tulo 7 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
10 Perguntas e respostas
80
10.1 Perguntas e respostas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80 10.1.1 % no printf . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
11 Resumo de Consulta para Provas
81
vi
11.1 Dicas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81 11.2 Programas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
Refer encias Bibliogr acas
85
vii
Lista de Algoritmos/Programas
1.1 1.2 1.3 1.4 1.5 1.6 1.7 2.1 2.2 2.3 2.4 2.5 2.6 2.7 2.8 2.9 Algoritmo para somar 2 n umeros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Algoritmo c/ declara c ao de tipos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Programa vazio com include e main . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1 3 4 4 5 6 6 9
Programa que cria e imprime uma vari avel inteira
Programa que soma dois n umeros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Programa que multiplica dois n umeros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . C alculo da area do tri angulo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . O comando se . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Uso do comando se . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10 O comando se-sen ao . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10 Uso do comando se-sen ao . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11 Uso do comando se-sen ao . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11 se-sen ao aninhados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12 Um exemplo simples com scanf . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13 Um if simples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13 if-else simples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.10 if-else com aninhamento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14 2.11 if-else com aninhamento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14 3.1 O comando escolha-caso . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
viii
3.2 3.3 3.4 4.1 4.2 4.3 4.4 4.5 4.6 4.7 5.1 5.2 5.3 6.1 6.2 6.3 6.4 6.5 6.6 6.7 6.8 6.9 7.1 7.2 9.1 9.2
Exemplo simples com escolha-caso . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18 C alculo do peso em outros planetas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19 O comando switch-case . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20 Um exemplo simples com o la co para . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23 Imprimir os n umeros pares de 0 a 1000 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24 para com decremento da vari avel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24 Algoritmo 4.3 implementado em C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25 Imprimir os mpares de 30 a 100 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26 3 vari aveis mudando a cada itera c ao . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26 Um for dentro do outro . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27 Um exemplo simples com o la co enquanto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31 Um exemplo simples com o la co fa ca-enquanto . . . . . . . . . . . . . . . . . . . . . . . . . . . 32 Uso do while combinado com um menu de op c oes . . . . . . . . . . . . . . . . . . . . . . . . . . 33 O primeiro exemplo com vetores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39 Vari avel como ndice do vetor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40 Um exemplo simples de string e gets() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41 A fun c ao strlen() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42 A fun c ao strcpy() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42 A fun c ao strcat() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43 A fun c ao strcmp() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44 Um exemplo simples com matriz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45 L e e exibe um texto com v arias linhas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46 Programa com a fun c ao calculaMedia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50 Passando uma matriz como argumento da fun c ao . . . . . . . . . . . . . . . . . . . . . . . . . . . 52 Resposta do exerc cio 1.6.10 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59 Resposta do exerc cio 2.3.1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
ix
9.3 9.4 9.5 9.6 9.7 9.8 9.9
Resposta do exerc cio 2.3.2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60 Resposta do exerc cio 2.3.3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60 Resposta do exerc cio 2.3.4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61 Resposta do exerc cio 2.3.5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62 Resposta do exerc cio 2.3.6 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63 Resposta do exerc cio 2.3.7 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63 Resposta do exerc cio 3.3.1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
9.10 Resposta do exerc cio 3.3.2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65 9.11 Resposta do exerc cio 3.3.3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66 9.12 Resposta do exerc cio 4.3.1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67 9.13 Resposta do exerc cio 4.3.2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68 9.14 Resposta do exerc cio 4.3.3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69 9.15 Resposta do exerc cio 4.3.4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70 9.16 Resposta do exerc cio 4.3.5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70 9.17 Resposta do exerc cio 4.3.6 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71 9.18 Resposta do exerc cio 4.3.7 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71 9.19 Resposta do exerc cio 4.3.8 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72 9.20 Resposta do exerc cio 5.3.1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73 9.21 Resposta do exerc cio 6.4.1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74 9.22 Resposta do exerc cio 7.3.4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75 9.23 Resposta do exerc cio 7.3.6 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76 9.24 Resposta do exerc cio 7.3.7 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78 11.1 if-else . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81 11.2 switch-case com char . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81 11.3 switch-case com int . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82 11.4 for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
11.5 for dentro de for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
xi
Lista de Figuras
1.1 O ciclo de desenvolvimento, compila c ao e execu c ao de um programa em C . . . . . . . . . . . . . 2
xii
Lista de Tabelas
2.1 2.2 Operadores relacionais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10 Operadores l ogicos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
3.1
Gravidades relativas em outros planetas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
4.1
Sa da do programa 4.4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
5.1
Pre co de passagens a ereas por regi ao . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
xiii
Cap tulo 1
Conceitos Iniciais
1.1 Refer encias e bibliograa
Esta apostila usou como refer encia e bibliograa as seguintes obras, s tios e materiais: C - Completo e Total [3], Introdu c ao ` a programa c ao - 500 algoritmos resolvidos [1], Turbo C: guia do usu ario [2].
1.2
Algoritmos e a linguagem C
Algoritmo e uma sequ encia nita de passos com o objetivo de solucionar um problema. Dado um problema ou tarefa qualquer, voc e pode propor uma lista de a c oes sequencias que, se executadas, resolver ao o problema ou executar ao a tarefa. Se estivermos tratando de computa c ao, estes passos dever ao ser apropriados para a execu c ao em um computador. Para ser executado em um computador, seu algoritmo precisa ser traduzido (ou reescrito) em uma linguagem de programa ca o. Nesta apostila utilizaremos a linguagem C. Uma vez escrito o programa em C, o mesmo precisa se traduzido para a linguagem do computador para ser executado. Esta tradu c ao se chama compila c ao (Figura 1.1). A cada modica c ao do programa inicial, chamado de programa fonte ou c odigo fonte, a compila c ao deve ser refeita para gerar um novo programa execut avel que reita as modica c oes feitas. Vejamos um exemplo no algoritmo 1.1 Algoritmo/Programa 1.1: Algoritmo para somar 2 n umeros
1.3 Vari avel
Editor de textos OU Ambiente de desenvolvimento Integrado (IDE) Programa em C: MeuPrograma.c Compilador: gcc MeuPrograma.c , por exemplo Programa execut avel: MeuPrograma.o ou MeuPrograma.exe , por exemplo O programa e chamado (executado) Figura 1.1: O ciclo de desenvolvimento, compila c ao e execu c ao de um programa em C
i n cio A = 10; B = 23; C = A + B; Mostrar o v a l o r de C ; fim
1 2 3 4 5 6
A e B s ao chamadas vari aveis, como na matem atica, e recebem valores num ericos (10 e 23, respectivamente). A e B s ao somadas e o resultado e gravado (armazenado) em outra vari avel chamada C . Por m, o resultado da soma e mostrado ou exibido para uma pessoa (ou usu ario) qualquer. Em geral, um programa de computador tem uma entrada, ou dados de entrada, executa uma computa c ao (faz alguma coisa com estes dados) e exibe uma sa da. No exemplo do algoritmo 1.1, podemos adaptar os comandos A = 10; e B = 23; como a entrada de dados. C = A + B; e a computa c ao em si (executar uma soma, no caso). Por m, o enunciado Mostrar o valor de C; e a sa da do programa (mostrar ao usu ario o valor da soma, no caso, 33).
1.3
Vari avel
Computadores executam opera c oes matem aticas e compara c oes de valores no processador (CPU). Os valores usados nas opera c oes matem aticas e nas compara c oes cam armazenados (gravados) na mem oria principal. Para saber o que est a aonde, a mem oria e dividida em c elulas e estas c elulas possuem endere cos (como o n umero da sua casa). Uma vari avel e o nome dado a um endere co de mem oria ou, em outras palavras, uma vari avel e um endere co de mem oria. Como vimos no algoritmo 1.1, vari aveis podem receber valores (A = 10, B = 23). Este comando e chamado
1.4 Tipos de vari aveis atribui c ao de valores.
1.4
Tipos de vari aveis
As vari aveis podem ser de diversos tipos. Um deles e o tipo num erico. Vari aveis num ericas podem ser, por exemplo, do tipo inteiro (int) (3 , 0 , 4 , 8) ou do tipo real (oat) (3.14 , 5.67 , 9 , 4 , 0). Vejamos o algoritmo 1.1 com a declara ca o expl cita do tipo das vari aveis (algoritmo 1.2) Algoritmo/Programa 1.2: Algoritmo c/ declara c ao de tipos
1 2 3 4 5 6 7 8 9
i n cio int x ; int y ; i n t soma ; x = 8; y = 25; soma = x + y ; i m p r i m i r ( soma ) ; fim
1.5
Conceitos iniciais: aplica co es em C
Uma vez feito o algoritmo, voc e pode optar por test a-lo em um computador. Para isto, ele deve ser reescrito em uma linguagem de programa c ao. Dizemos que o algoritmo ser a implementado nesta linguagem. Como dito na Se c ao 1.2, usaremos a linguagem C.
1.5.1
O conceito de fun c ao
Uma fun c ao e um trecho de c odigo (um programa) j a pronto que pode ser utilizado dentro do seu programa. Para usar uma fun c ao pronta, basta escrever o nome dela no seu c odigo. Dizemos que estamos chamando a fun c ao. Para usar estas fun c oes j a prontas, precisamos avisar ao C (mais especicamente avisar ao compilador C) que esta fun c ao ser a usada. Isto e feito incluindo bibliotecas ao programa. Bibliotecas s ao conjuntos de fun c oes prontas. O comando em C para fazer isto e: #include <nome da biblioteca> Nos nossos primeiros programas, usaremos apenas a biblioteca b asica de entrada e sa da chamada stdio.h.
1.5 Conceitos iniciais: aplica c oes em C Deste modo, todos os programas come car ao com a inclus ao desta biblioteca: #include <stdio.h>
1.5.2
A fun c ao main
Todo programa precisa ter um ponto de partida. Um ponto a partir do qual ele ser a iniciado. Em outras palavras, a primeira instru c ao a ser executada. No caso do C, o programa come ca pela fun c ao principal, chamada fun c ao main. A forma de cham a-la e a seguinte: int main() Em seguida, abre-se uma chave ( { ) para indicar o in cio do bloco e no m da fun c ao main esta chave e fechada ( } ) para indicar o m do bloco (ou o m da fun c ao). Algoritmo/Programa 1.3: Programa vazio com include e main
1 2 3 4 5 6
#include < s t d i o . h>
i n t main ( ) { . . . . . . }
1.5.3
Primeiros exemplos de programas em C
Vamos ent ao ao primeiro programa em C, o programa 1.4: Algoritmo/Programa 1.4: Programa que cria e imprime uma vari avel inteira
1 2 3 4 5 6 7 8
i n t main ( ) { int a ; a = 10; p r i n t f ( " O valor de a e: %d " , a ) ; system ( " pause " ) ; }
O Programa 1.4 come ca com a declara c ao (linha 4) e inicializa c ao (atribui c ao de um valor) ` a vari avel a (linha 5). Em seguida, e chamada a fun c ao printf que corresponde ao imprimir do algoritmo. A fun c ao printf imprime um texto xo (entre aspas duplas ( )). No caso, o texto e O valor de a e:. O printf pode imprimir ainda valores de vari aveis (depois da v rgula), no caso o valor de a. O %d informa que
1.5 Conceitos iniciais: aplica c oes em C
a e uma vari avel do tipo inteiro. Al em disso, o valor da vari avel a ser a colocado no mesmo local da frase onde se encontra o %d. Por m, a fun c ao system chamada com o argumento pause (linha 7), usada no Windows, faz com que o programa pare a execu c ao e pe ca que qualquer tecla seja digitada. Serve para que a janela de execu c ao do programa n ao se feche e o usu ario possa ver o resultado nal (ou a sa da) do programa. Este comando n ao ser a mais inclu do nos exemplos e respostas dos exerc cios. Fica a crit erio de cada um o seu uso, quando necess ario. poss E vel inserir coment arios ao longo de um programa. S ao textos que voc e escreve para explicar o funcionamento e documentar o desenvolvimento do programa. Eles n ao tem nenhuma inu encia sobre a execu c ao do programa. Para um coment ario de uma linha, basta iniciar com //. Pode-se usar // no m da linha para que, a partir da , exista um coment ario. Coment arios maiores, come cam com /* e terminam com */, podendo ter v arias linhas. // Comenta linha
/* Comenta todo um trecho */ recomend E avel que nomes de vari aveis representem o signicado das mesmas. Use raizUm em lugar de r; notaDoAluno em lugar de n; etc. Insira tantos coment arios quantos julgar necess arios. O Programa 1.5 traz algumas novidades com rela c ao ao 1.4. As 3 vari aveis s ao declaradas todas na mesma linha (9), e feita uma soma e 3 valores s ao impressos pela fun c ao printf (13). Algoritmo/Programa 1.5: Programa que soma dois n umeros
1 2 3 4 5 6 7 8 9 10 11 12 13 14
/ Programa d e s e n v o l v i d o p e l o Prof . Jabour em mar c o de 2 0 1 1 . O programa soma d o i s n u meros , e x i b e a soma e o r e s u l t a d o /
i n t main ( ) { int a , b , c ; a = 10; b = 32; c = a + b; // e x e c u c a o do c alculo // i m p r e s s a o do r e s u l t a d o // d e c l a r a c a o de v a r i aveis
p r i n t f ( "\n%d + %d = %d\n" , a , b , c ) ; }
Os operadores aritm eticos s ao relacionados a seguir:
1.6 Exerc cios Propostos + Adi c ao Subtra c ao Multiplica c ao / Divis ao
O Programa 1.6 declara 3 n umeros reais (oat). Dois deles recebem valores (s ao inicializados) e o terceiro recebe o produto dos 2 primeiros (*). A m ascara %f informa que o n umero a ser impresso e real e o .1 faz com que o n umero seja impresso com uma casa decimal. como um enter. Chamamos de quebra de linha. O comando \n faz pular uma linha. E Algoritmo/Programa 1.6: Programa que multiplica dois n umeros
1 2 3 4 5 6 7 8 9
i n t main ( ) { float a , b , c ; a = 8.4; b = 4.5; c = a b; p r i n t f ( " \ n %.1 f x %.1 f = %.1 f \ n " , a , b , c ) ; }
Mais um exemplo (Programa 1.7). Fazer um programa que calcule a area do tri angulo (dadas a base e a altura). Algoritmo/Programa 1.7: C alculo da area do tri angulo
1 2 3 4 5 6 7 8 9
i n t main ( ) { float b , h , area ; b = 10; h = 3.5; area = b h / 2; p r i n t f ( " \ nbase = % f ; altura = % f ; area = %.3 f \ n " , b , h , a r e a ) ; }
1.6
Exerc cios Propostos
Como ainda n ao estudamos como inserir dados via teclado (digitar dados de entrada), considere nestes exerc cios que a entrada de dados ser a feita declarando vari aveis e atribuindo valores no pr oprio c odigo fonte.
1.6 Exerc cios Propostos
Deste modo, quando os enunciados falarem em receber valores, notas, sal ario, n umeros, etc, crie as vari aveis e atribua os valores a elas.
1.6.1
M edia aritm etica
Fa ca um programa que receba tr es notas, calcule e mostre a m edia aritm etica entre elas.
1.6.2
M edia ponderada
Fa ca um programa que receba tr es notas e seus respectivos pesos, calcule e mostre a m edia ponderada dessas notas.
1.6.3
Aumento de sal ario
Fa ca um programa que receba o sal ario de um funcion ario e o percentual de aumento, calcule e mostre o valor do aumento e o novo sal ario.
1.6.4
Sal ario base com gratica c ao e impostos
Fa ca um programa que receba o sal ario-base de um funcion ario, calcule e mostre o sal ario a receber, sabendose que esse funcion ario tem gratica c ao de 5% sobre o sal ario-base e paga imposto de 7% sobre sal ario-base.
1.6.5
Opera c oes com um n umero
Fa ca um programa que receba um n umero positivo e maior que zero, calcule e mostre: 1. O n umero digitado ao quadrado; 2. O n umero digitado ao cubo; 3. A metade do n umero digitado; 4. O sucessor do n umero digitado.
1.6.6
Pre co do carro, impostos e lucro
O custo ao consumidor de um carro novo e a soma do pre co de f abrica com o percentual de lucro do distribuidor e dos impostos aplicados ao pre co de f abrica. Fa ca um programa que receba o pre co de f abrica de um ve culo, o percentual de lucro do distribuidor e o percentual de impostos. Calcule e mostre:
1.6 Exerc cios Propostos O valor correspondente ao lucro do distribuidor; O valor correspondente aos impostos; O pre co nal do ve culo.
1.6.7
C alculo de sal ario
Fa ca um programa que receba o n umero de horas trabalhadas e o valor do sal ario m nimo. Calcule e mostre o sal ario a receber seguindo as regras abaixo:
A hora trabalhada vale a metade do sal ario m nimo; O sal ario bruto equivale ao n umero de horas trabalhadas multiplicado pelo valor da hora trabalhada; o imposto equivale a 3% do sal ario bruto; O sal ario a receber equivale ao sal ario bruto menos o imposto.
1.6.8
Saldo da conta ap os emiss ao de cheques
Um trabalhador recebeu seu sal ario e o depositou em sua conta corrente banc aria. Esse trabalhador emitiu dois cheques e agora deseja saber seu saldo atual. Sabe-se que cada opera c ao banc aria de retirada paga CPMF de 0, 38% e o saldo inicial da conta est a zerado. Fa ca um programa que receba o valor do sal ario e dos dois cheques emitidos e calcule o saldo atual.
1.6.9
Consumo de ra c ao de gatos
Pedro comprou um saco de ra c ao com peso em quilos. Pedro possui dois gatos para os quais fornece a quantidade de ra c ao em gramas. Fa ca um programa que receba o peso do saco de ra c ao e a quantidade de ra c ao fornecida para cada gato. Calcule e mostre quanto restar a de ra c ao no saco ap os cinco dias.
1.6.10
Medida da escada enconstada
Fa ca um programa que receba a medida do angulo formado por uma escada apoiada no ch ao e encostada na parede ( angulo entre a escada e o ch ao) e a altura da parede onde est a a ponta da escada. Calcule e mostre a medida desta escada. Resposta: programa 9.1.
Cap tulo 2
O comando if-else (se-sen ao)

2.1 Descri c ao e exemplos
comum termos que tomar decis E oes ao longo do algoritmo. Imagine que, se um valor for positivo, uma a c ao ser a tomada. Se ele for zero ou negativo, outra a c ao e necess aria. Este tipo de decis ao e representado pelo comando se. Vamos ver como e a sintaxe do se (Algoritmo 2.1): Algoritmo/Programa 2.1: O comando se
1 2 3 4 5 6
se ( condi c ao ) { comando 1 ; comando 2 ; . . . comando n ; }
A condi c ao entre par enteses (depois do se) e avaliada. Se o resultado por verdadeiro, o programa executa o bloco de instru c oes entre chaves, que vem em seguida (comando 1, comando 2, etc., comando n). Se for falso, o programa simplesmente pula este bloco e continua a execu c ao ap os o fechamento da chave correspondente. Assim, se a condi c ao for (a < 30), por exemplo, caso o valor de a seja 23, o resultado ser a verdadeiro e os comandos dentro do se ser ao executados. Dizemos que o programa entrou no se. Se a valer 234, por exemplo, a condi c ao ser a falsa e o programa pular a o bloco entre chaves depois do se. Dizemos que o programa n ao entrou no se. Resumindo, condi c ao assume um valor l ogico (verdadeiro ou falso). Se for verdadeiro, executa-se o interior das chaves do se, se for falso, n ao executa.
2.1 Descri c ao e exemplos A Tabela 2.1 mostra os operadores relacionais e a Tabela 2.2 os operadores l ogicos. Operador > < >= <= == != Signicado maior menor maior ou igual menor ou igual igual diferente (n ao igual)
10
Tabela 2.1: Operadores relacionais
Operador && || !
Signicado e ou nega c ao (n ao)
Tabela 2.2: Operadores l ogicos
Exemplo: Fazer um algoritmo que l e um valor inteiro e imprime o valor caso ele seja maior que 10. Solu c ao (Algoritmo 2.2) Algoritmo/Programa 2.2: Uso do comando se
1 2 3 4 5 6 7
i n cio int v a l o r ; ler ( valor ) ; s e ( v a l o r > 10 ) { imprima ( v a l o r ) } fim
A forma geral do comando se, incorpora tamb em um sen ao. Deste modo, a condi c ao e avaliada. Se for verdadeira, procede-se como descrito acima. Se for falsa, o bloco ap os o sen ao e executado. Veja a estrutura no Algoritmo 2.3: Algoritmo/Programa 2.3: O comando se-sen ao
1 2 3 4 5 6 7
se ( condi c ao ) { comando 1 ; comando 2 ; . . . comando n ; } sena o {
11
8 9 10 11 12
comando n+1; comando n+2; . . . comando n+ m; }
Exemplo (Algoritmo 2.4): Fazer um algoritmo que receba a idade de uma pessoa e informe se ela e maior ou menor de idade. Algoritmo/Programa 2.4: Uso do comando se-sen ao
1 2 3 4 5 6 7 8 9 10
i n cio int idade ; l e r ( idade ) ; s e ( i d a d e >= 1 8 ) { imprima ( " E maior de idade " ) ; } sena o { imprima ( " E menor de idade " ) ; } fim
Outro exemplo (Algoritmo 2.5): Fa ca um algoritmo que leia o sal ario base do empregado e o seu total de vendas. Em seguida e calculado o sal ario nal do empregado. O empregado que vendeu mais de R$ 1000 recebe um b onus de 20% em seu sal ario nal, calculado sobre o sal ario base. O total de vendas n ao se incorpora ao sal ario nal, sendo usado apenas como crit erio de distribui c ao do b onus. Algoritmo/Programa 2.5: Uso do comando se-sen ao
1 2 3 4 5 6 7 8 9 10 11 12
i n cio f l o a t s a l a r i o B a s e , s a l a r i o F i n a l , vendas ; ler ( salarioBase ) ; l e r ( vendas ) ; s e ( vendas > 1 0 0 0 ) { salarioFinal = salarioBase 1.2; } sena o { salarioFinal = salarioBase ; } imprima ( s a l a r i o F i n a l ) ; fim
poss o E vel que, dentro de um bloco do se e/ou do bloco sen ao, tenhamos outro ou outros se-sen ao. E que chamamos de aninhamento de se. Vejamos atrav es de um exemplo, no Algoritmo 2.6. Considere o crit erio de aprova c ao no IF Sudeste MG. Quando o aluno possui menos de 75% de frequ encia, ele est a reprovado, independente da nota. Possuindo frequ encia suciente, s ao 3 as possibilidades. Nota igual
2.2 if-else: aplica c oes em C
12
ou superior a 60 aprova o aluno. Nota entre 40 (inclusive) e 59 o coloca em prova nal e nota menor que 40 o reprova. A dupla reprova c ao (frequ encia menor que 75% e nota menor que 40) e registrada como reprova c ao por infrequ encia). Fa ca o algoritmo que leia nota e frequ encia e informe o resultado nal do aluno. Algoritmo/Programa 2.6: se-sen ao aninhados
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
// a l g 0 0 8 . t x t
i n cio f l o a t nota , f r e q u e n c i a ; l e r ( nota ) ; ler ( frequencia ) ; s e ( f r e q u e n c i a < 75 ) { imprima ( " reprovado por infrequ^ e ncia " ) ; } sena o { s e ( nota >= 60 ) { imprima ( " aprovado " ) ; } sena o { s e ( nota >= 40 ) { imprima ( " prova final " ) ; } sena o { imprima ( " reprovado por nota " ) ; } } } fim
Material desenvolvido por Filippe Jabour - http://www.jabour.com.br.
2.2
2.2.1
if-else: aplica co es em C
A fun c ao scanf
Para ler caracteres a partir do teclado usamos a fun c ao scanf. Ela necessita da m ascara aos mesmos moldes da printf. Outro argumento passado ` a fun c ao e o endere co da vari avel que receber a o que foi digitado. Exemplos: scanf(%d,&var) recebe uma vari avel inteira (%d) digitada via teclado e grava o valor digitado no endere co (&) da vari avel var. Assim, se voc e digitar 34 e teclar enter, a vari avel var passar a a ter o valor 34.
13
2.2.2
Uso do se-sen ao (if-else) em C
Primeiro vamor a um exemplo muito simples, apenas com o uso do scanf (Programa 2.7). Algoritmo/Programa 2.7: Um exemplo simples com scanf
1 2 3 4 5 6 7 8
# include < s t d i o . h>
i n t main ( ) { int a ; p r i n t f ( " \ nDigite um valor para a : " ) ; s c a n f ( " % d " ,&a ) ; // n e s t a l i n h a , o v a l o r d i g i t a d o e g r a v a d o no e n d e r e c o de a
p r i n t f ( " \ nVoc^ e digitou : % d \ n " , a ) ; }
Agora, no Programa 2.8, o scanf com um if simples. Algoritmo/Programa 2.8: Um if simples

1 2 3 4 5 6 7 8 9 10
i n t main ( ) { int a ; p r i n t f ( " \ nDigite um n u mero : " ) ; s c a n f ( " % d " ,&a ) ; i f ( a > 10) { p r i n t f ( "\n%d e maior que 10.\ n " , a ) ; } }
Programa 2.9, com if-else. Algoritmo/Programa 2.9: if-else simples

1 2 3 4 5 6 7 8 9 10 11 12 13
i n t main ( ) { int a ; p r i n t f ( " \ nDigite um n u mero : " ) ; s c a n f ( " % d " ,&a ) ; i f ( a > 10) { p r i n t f ( "\n%d e maior que 10.\ n " , a ) ; } else { p r i n t f ( "\n%d e menor ou igual a 10.\ n " , a ) ; } }
14
Exemplo (Programa 2.10): Leia a idade da pessoa e direcione para uma la de idoso quando a idade for maior ou igual a 60 anos; informe que n ao pode entrar quando for menor de 18 anos e direcione para a la comum quando for maior de idade e menor que 60 anos. Algoritmo/Programa 2.10: if-else com aninhamento
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
// prog008 . c
i n t main ( ) { int idade ; p r i n t f ( " \ nDigite a idade : " ) ; s c a n f ( " % d " ,& i d a d e ) ; i f ( i d a d e >= 60 ) { // o b s e r v e o uso de maior ou i g u a l
p r i n t f ( " \ nDirija - se ` a fila preferencial .\ n " ) ; } else { i f ( i d a d e >= 1 8 ) { / Como estamos no e l s e de i d a d e >= 6 0 , a idade ja e < 6 0 . Entrando n e s t e i f , e l a tamb em e maior de i d a d e . Logo : / p r i n t f ( " \ nDirija - se ` a fila comum .\ n " ) ; } else { p r i n t f ( " \ nEntrada proibida .\ n " ) ; } } }
Veja no Programa 2.11 a implementa c ao em C do Algoritmo 2.6. Algoritmo/Programa 2.11: if-else com aninhamento
1 2 3 4 5 6 7 8 9 10 11 12 13 14
// prog009 . c
i n t main ( ) { f l o a t nota , f r e q u e n c i a ; p r i n t f ( " \ nNota : " ) ; s c a n f ( " % f " ,& nota ) ; p r i n t f ( " \ nFrequ^ e ncia : " ) ; s c a n f ( " % f " ,& f r e q u e n c i a ) ; i f ( f r e q u e n c i a < 75 ) { p r i n t f ( " \ nReprovado por infrequ^ e ncia .\ n " ) ; } else {
15
15 16 17 18 19 20 21 22 23 24 25 26 27
i f ( nota >= 60 ) { p r i n t f ( " \ nAprovado \ n " ) ; } else { i f ( nota >= 40 ) { p r i n t f ( " \ nProva final .\ n " ) ; } else { p r i n t f ( " \ nReprovado por nota .\ n " ) ; } } } }
2.3
2.3.1

Adivinhar um n umero
Fa ca um programa que gere um n umero aleat orio de 0 a 9, receba um palpite via teclado e informe se o palpite e certo ou errado. Dicas:
A linha srand ( time(NULL) ); faz com que o n umero gerado varie a cada execu c ao do programa. A linha numeroGerado = rand(); gera um n umero aleat orio (fun c ao rand()) e atribui este valor ` a vari avel numeroGerado. O operador % e chamado operador m odulo ou resto da divis ao. Assim, x = y % 10; atribui ` a vari avel x o resto da divis ao de y por 10. Ou seja, se y = 23, x receber a o valor 3. O n umero gerado com a fun c ao rand() e grande. Se aplicarmos o aperador m odulo deste n umero grande por 10, por exemplo, teremos sempre o resto da divis ao por 10, o que ser a um n umero de zero a 9. Teste de igualdade em C e feito com == e n ao apenas com um =.
Resposta: programa 9.2. N ao olhe a resposta antes de tentar v arias vezes, antes de discutir com os colegas, procurar o professor, o monitor, etc.
2.3.2
Vericar se um n umero e par ou mpar
Fa ca um programa que receba um n umero via teclado e verique se este n umero e par ou mpar.
2.3 Exerc cios Propostos Resposta: programa 9.3.
16
2.3.3
Achar o maior de 3 n umeros
Fa ca um programa que receba 3 n umeros via teclado e imprima o maior deles. Resposta: programa 9.4.
2.3.4
Vericar se um n umero e positivo, negativo ou nulo
Ler um n umero e informar se ele e positivo, negativo ou nulo. Resposta: programa 9.5.
2.3.5
Equa c ao do segundo grau
Fa ca um programa que receba os 3 coecientes e encontre a(s) ra z(es) reais da equa c ao do segundo grau. N ao aceite o coeciente de x2 igual a zero. Resposta: programa 9.6.
2.3.6
Soma n umeros e escolhe uma opera c ao com base no resultado da soma
Fa ca um programa que recebe dois n umeros e efetua a adi c ao. Caso o valor somado seja maior que 20, este dever a ser apresentado somando-se a ele 8; caso o valor somado seja menor ou igual a 20, este dever a ser apresentado subtraindo-se 5. Resposta: programa 9.7.
2.3.7
Verica se empr estimo pode ser concedido
Uma empresa abriu uma linha de cr edito para os funcion arios. O valor da presta c ao n ao pode ultrapassar 30% do sal ario. Fa ca um programa que receba o sal ario, o valor do empr estimo e o n umero de presta c oes e informe se o empr estimo pode ser concedido. Nenhum dos valores informados pode ser zero ou negativo. Resposta: programa 9.8.
Cap tulo 3
Switch-case (escolha-caso)
O comando if-else permite uma decis ao que direcione o uxo de execu c ao do algoritmo em dois caminhos diferentes. O programa segue para o if ou para o else. Existe um comando que tem m ultiplos caminhos poss veis. Trata-se do comando escolha-caso. Existem algumas op c oes poss veis e o programa executa uma delas, de acordo com uma compara c ao de igualdade feita. A estrutura do escolha-caso e dada no algoritmo 3.1. Algoritmo/Programa 3.1: O comando escolha-caso
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
// a l g 0 0 9 . t x t
escolha ( varia vel ) { caso valor 1 : comando 1 ; comando 2 ; . . . comando n ; pare ; caso valor 2 : comando n +1; comando n +2; . . . comando n+k ; pare ; caso valor 3 : comando n+k +1; comando n+k +2; . . .
18
20 21 22 23 24 25 26 27 28 29
comando n+k+ m; pare ; . . . . . . default : comando n+k+ m +y +1; comando n+k+ m +y +2; . . . m +y+x ; comando n+k+ }
O valor da vari avel entre par enteses, ` a frente da palavra escolha, e comparado a cada valor i ` a frente de cada caso. Ao ser encontrado um valor igual (apenas a igualdade e testada), a sequ encia de comandos a seguir e executada at e o comando pare. Vamos ao primeiro exemplo (algoritmo 3.2): Algoritmo/Programa 3.2: Exemplo simples com escolha-caso
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
i n cio int x ;
e s c r e v a ( " Digite um n u mero " ) ; ler (x) ;
escolha (x) { caso 1: imprima ( " Voc^ e digitou 1 " ) ; pare ; caso 2: imprima ( " Voc^ e digitou 2 " ) ; pare ; caso 3: imprima ( " Voc^ e digitou 3 " ) ; pare ; default : imprima ( " Voc^ e n~ a o digitou 1 , nem 2 , nem 3 " ) ; } fim
O funcionamento e o seguinte: o valor da vari avel x e comparado a cada uma das constantes de cada caso (valores ` a frente da palavra caso) (1, 2 ou 3, neste exemplo). Se for igual, o bloco de comando ap os os dois pontos (:) e executado at e o comando pare. Se n ao for igual a nenhuma das op c oes, o bloco correspondente ` a op c ao default e executado. A escolha poder a ser feita apenas com n umeros inteiros ou caracteres (uma letra, por exemplo) e o teste de cada caso (case) s o testa a igualdade (n ao testa >, <, >=, etc, como pode ocorrer no se (if )).
19
Vamos a um exerc cio: escrever um algoritmo que leia um peso na Terra e o n umero de um planeta e imprima o valor deste peso no planeta escolhido. A rela c ao de planetas e dada na Tabela 3.1, juntamente com os valores das gravidades relativas ` a da Terra. N umero 1 2 3 4 5 6 7 Gravidade relativa 0.376 0.903 0.380 2.340 1.160 1.150 1.190 Planeta Merc urio V enus Marte J upiter Saturno Urano Netuno
Tabela 3.1: Gravidades relativas em outros planetas
A seguir a solu c ao, no algoritmo 3.3. Algoritmo/Programa 3.3: C alculo do peso em outros planetas
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27
// a l g 0 1 1 . t x t
i n cio int p l a n e t a E s c o l h i d o ; f l o a t pesoNaTerra , g r a v i d a d e R e l a t i v a , pes oN oPl an et a ;
e s c r e v a ( " Planetas " ) ; e s c r e v a ( " 1 - Merc u rio " ) ; e s c r e v a ( " 2 - V^ e nus " ) ; e s c r e v a ( " 3 - Marte " ) ; e s c r e v a ( " 4 - J u piter " ) ; e s c r e v a ( " 5 - Saturno " ) ; e s c r e v a ( " 6 - Urano " ) ; e s c r e v a ( " 7 - Netuno " ) ; e s c r e v a ( " Digite o n u mero do planeta escolhido : " ) ; l e r ( planetaEscolhido ) ;
e s c r e v a ( " Informe seu peso na Terra : " ) ; l e r ( pesoNaTerra ) ;
escolha ( planetaEscolhido ) { caso 1: gravidadeRelativa = 0.376; pare ; caso 2: gravidadeRelativa = 0.903; pare ;
3.2 switch-case: aplica c oes em C
20
28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55
caso 3: gravidadeRelativa = 0.380; pare ; caso 4: gravidadeRelativa = 2.340; pare ; caso 5: gravidadeRelativa = 1.160; pare ; caso 6: gravidadeRelativa = 1.150; pare ; caso 7: gravidadeRelativa = 1.190; pare ; default : gravidadeRelativa = 0; }
s e ( g r a v i d a d e R e l a t i v a != 0 ) { pe so NoP la ne ta = pesoNaTerra g r a v i d a d e R e l a t i v a ; e s c r e v a ( " Seu peso no planeta escolhido e " , pes oN oPl an et a ) ; } sena o { e s c r e v a ( " Erro na escolha do planeta . " ) ; }
fim
Em C, o comando escolha-caso corresponde ao switch-case e o pare corresponde ao break.
3.2
switch-case: aplica co es em C
A sintaxe da estrutura switch-case em C est a no trecho de programa 3.4. Algoritmo/Programa 3.4: O comando switch-case
1 2 3 4 5 6 7 8 9
// prog018 . c
switch ( v a r i avel ) { case v a l o r 1 : comando 1 ; comando 2 ; . . . comando n ; break ;
21
10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29
case v a l o r 2 : comando n +1; comando n +2; . . . comando n+k ; break ; case v a l o r 3 : comando n+k +1; comando n+k +2; . . . m; comando n+k+ break ; . . . . . . default : comando n+k+ m +y +1; comando n+k+ m +y +2; . . . m +y+x ; comando n+k+ }
3.3
3.3.1

Peso nos planetas
Implementar em C o algoritmo 3.3. Resposta: programa 9.9.
3.3.2
Quest ao de m ultipla escolha
Fazer um programa que mostre uma quest ao de m ultipla escolha com 5 op c oes (letras a, b, c, d, e e). Sabendo a resposta certa, receber a op c ao do usu ario e informar a letra que o usu ario marcou e se a resposta est a certa ou errada. Usar o tipo char para armazenar a vari avel de teste do switch. Ela pode ser lida do teclado com scanf e a m ascara %c ou com a fun c ao getchar() (opcao = getchar()). Na compara c ao do case, deve-se colocar o valor a ser comparado entre aspas simples: case a:, por exemplo. Resposta: programa 9.10.
22
3.3.3
Calculadora simples
Fazer um programa que l e dois n umeros, l e a opera c ao desejada ( + - * / ), faz a opera c ao pedida e mostra o resultado. A opera c ao escolhida deve ser armazenada em uma vari avel do tipo char. Resposta: programa 9.11.
Cap tulo 4
For (para)
comum termos um trecho de c E odigo (conjunto de instru c oes) que precise ser repetido v arias vezes (executado v arias vezes), at e que uma condi c ao seja satisfeita (ou at e que uma condi c ao deixe de ser satisfeita). Uma das formas disto ser feito e atrav es da estrutura para (for em C). Material desenvolvido por Filippe Jabour - http://www.jabour.com.br. A forma geral do comando para (chamado de la co) e a seguinte: para ( inicializa c ao ; condi c ao ; incremento ) { comando 1; comando 2; . . . comando n; }
A inicializa c ao e geralmente uma atribui c ao, ou seja, uma vari avel recebe um valor inicial. Esta vari avel e chamada vari avel de controle do la co. A condi c ao e um teste l ogico que verica se o la co ser a executado. sempre testada no in E cio e, somente se for verdadeira, o interior do la co e executado. O incremento dene como a vari avel de controle do la co varia cada vez que o la co e repetido. Vejamos um exemplo no algoritmo 4.1. Algoritmo/Programa 4.1: Um exemplo simples com o la co para
1 2 3 4
// a l g 0 1 2 . t x t
i n cio int i ;
24
5 6 7 8 9 10
para ( i = 0 ; i < 100 ; i = i + 1 ) { imprima ( i ) ; }
fim
A vari avel i recebe inicialmente o valor 0. O teste l ogico (condi c ao de perman encia) i < 100 e feito e retorna verdadeiro. Deste modo, o la co e executado e o valor 0 e impresso. Ao nal do la co, a vari avel i e incrementada em uma unidade e passa a valer 1 (i = i + 1). A condi c ao continua verdadeira pois 1 < 100. Assim, o la co e executado novamente e o valor 1 e impresso. Isto se repete at e que i assuma o valor 100. Com i = 100, a condi c ao se torna falsa e o la co e abandonado (o algoritmo passa para a pr oxima instru c ao ap os a chave de fechamento do bloco). Em resumo, o algoritmo imprime todos os n umeros inteiros de 0 a 99 (inclusive). Um exerc cio: Fa ca um algoritmo para imprimir os n umeros pares maiores que zero e menores que 1000. Solu c ao no algoritmo 4.2. Algoritmo/Programa 4.2: Imprimir os n umeros pares de 0 a 1000
1 2 3 4 5 6 7 8
i n cio i n t par ;
para ( par = 2 ; par < 1000 ; par = par + 2 ) { imprima ( par ) ; }
fim
Vamos agora analisar o algoritmo 4.3: Algoritmo/Programa 4.3: para com decremento da vari avel
1 2 3 4 5 6 7 8 9
i n cio int x ; float z ;
para ( x = 100 ; x != 65 ; x = x 5 ) { z = x x; e s c r e v a ( " O quadrado de % d e %f" , x , z ) ; } fim
Inicialmente, as vari aveis s ao declaradas, como sempre. x e a vari avel de controle do la co para e e inicializada com o valor 100. O primeiro teste e atendido (d a verdadeiro j a que x = 65). Deste modo, o algoritmo entra no para, calcula o quadrado de x (x x) e guarda o resultado na vari avel z . Em seguida, os valores de x e z s ao impressos e termina o la co. Neste momento, x e decrementado em 5 unidades e passa a valer 95. A condi c ao
25
de perman encia continua sendo atendida e o la co e executado novamente. Isto ocorre at e que x assuma o valor 65. Neste momento x = 65 se torna falso e o la co e abandonado. O algoritmo 4.3 implementado em C encontra-se no programa 4.4 e a sa da (resultado) do programa na Tabela 4.1. Algoritmo/Programa 4.4: Algoritmo 4.3 implementado em C
1 2 3 4 5 6 7 8 9 10 11 12 13
// prog021 . c
i n t main ( ) { int x ; float z ;
f o r ( x = 100 ; x != 65 ; x = x 5 ) { z = x x; p r i n t f ( " \ nO quadrado de % d e %.0 f " , x , z ) ; } }
O quadrado de 100 e 10000 O quadrado de 95 e 9025 O quadrado de 90 e 8100 O quadrado de 85 e 7225 O quadrado de 80 e 6400 O quadrado de 75 e 5625 O quadrado de 70 e 4900 Tabela 4.1: Sa da do programa 4.4
Considere o trecho de programa abaixo: x = 10; para ( y = 10 ; y != x ; y = y + 1) { printf(\n y = %d,y); }
Observe que o interior do la co nunca ser a executado. Como x = y , o teste x = y j a dar a falso da primeira vez.
4.2 for: aplica c oes em C
26
4.2
for: aplica co es em C
A sintaxe do for: for ( inicializa c ao ; condi c ao ; incremento ) { comando 1; comando 2; . . . comando n; }
Observa c ao: e comum o uso de y + + no lugar de y = y + 1. Da mesma forma, x e a mesma coisa que x = x 1. Vamos a um exemplo: imprimir os n umeros mpares existentes entre 30 e 100. A solu c ao est a no programa 4.5: Algoritmo/Programa 4.5: Imprimir os mpares de 30 a 100
1 2 3 4 5 6 7 8 9 10 11 12 13 14
// prog022 . c
i n t main ( ) { i n t impar ;
p r i n t f ( "\ n I mpares entre 30 e 100: " ) ;
f o r ( impar = 31 ; impar < 100 ; impar = impar + 2 ) { p r i n t f ( " %d , " , impar ) ; } p r i n t f ( "\n" ) ; }
Bastou identicar que o primeiro mpar era o 31, inicializar a vari avel de controle com este valor e rodar o for de 2 em 2, at e o limite de 100. Em C, x = x + 2 e a mesma coisa que x += 2; y = y 5 e a mesma coisa que y = 5; z = z 8 e a mesma coisa que z = 8; k = k/9 e a mesma coisa que k /= 9; e assim por diante. Na op c ao incremento, a terceira do comando for, podemos ter opera c oes com mais de uma vari avel. Observe no programa 4.6 que as tr es vari aveis i, x e y s ao modicadas a cada rodada do la co (cada rodada do for e tamb em chamada de itera c ao). Algoritmo/Programa 4.6: 3 vari aveis mudando a cada itera c ao
4.2 for: aplica c oes em C
27
1 2 3 4 5 6 7 8 9 10
// prog023 . c
i n t main ( ) {
int i , x = 2 , y = 2 0 ;
f o r ( i = 1 ; i < 10 ; i ++, x = 2 , y = 1 ) { p r i n t f ( "\n i = %d \t x = %d \t y = %d " , i , x , y ) ; ( tabula ca o ) // \ t c o r r e p o n d e a um TAB
11 12 13 14 15
p r i n t f ( "\n" ) ;
Podemos ter aninhamento de la cos for, ou seja, um for dentro do outro. Veja o programa 4.7: Algoritmo/Programa 4.7: Um for dentro do outro
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
// prog026 . c
i n t main ( ) {
int i , j ;
p r i n t f ( " \ n Impress~ a o de (i , j ) \ n " ) ;
f o r ( i = 0 ; i < 10 ; i++ ) { p r i n t f ( "\n" ) ; f o r ( j = 0 ; j < 10 ; j++ ) p r i n t f ( " \ t (% d , % d ) " , i , j ) ; }
p r i n t f ( "\n\n" ) ;
A sa da em v deo ser a a seguinte: (0, 0) (0, 1) (0, 2) (0, 3) (0, 4) (0, 5) (0, 6) (0, 7) (0, 8) (0, 9) (1, 0) (1, 1) (1, 2) (1, 3) (1, 4) (1, 5) (1, 6) (1, 7) (1, 8) (1, 9) (2, 0) (2, 1) (2, 2) (2, 3) (2, 4) (2, 5) (2, 6) (2, 7) (2, 8) (2, 9) (3, 0) (3, 1) (3, 2) (3, 3) (3, 4) (3, 5) (3, 6) (3, 7) (3, 8) (3, 9) (4, 0) (4, 1) (4, 2) (4, 3) (4, 4) (4, 5) (4, 6) (4, 7) (4, 8) (4, 9)
4.3 Exerc cios Propostos (5, 0) (5, 1) (5, 2) (5, 3) (5, 4) (5, 5) (5, 6) (5, 7) (5, 8) (5, 9) (6, 0) (6, 1) (6, 2) (6, 3) (6, 4) (6, 5) (6, 6) (6, 7) (6, 8) (6, 9) (7, 0) (7, 1) (7, 2) (7, 3) (7, 4) (7, 5) (7, 6) (7, 7) (7, 8) (7, 9) (8, 0) (8, 1) (8, 2) (8, 3) (8, 4) (8, 5) (8, 6) (8, 7) (8, 8) (8, 9) (9, 0) (9, 1) (9, 2) (9, 3) (9, 4) (9, 5) (9, 6) (9, 7) (9, 8) (9, 9)
28
4.3
4.3.1

Adivinhar um n umero com n tentativas
Modique o exerc cio 2.3.1 de modo que o usu ario informe quantas tentativas de adivinha c ao quer fazer. O programa permite ent ao que ele tente este n umero de vezes informado ou acaba caso ele acerte antes. Obs.: O comando break interrompe o la co for. Resposta: programa 9.12.
4.3.2
Menu de op co es e um for
Fazer um algoritmo que tenha um menu que permita ao usu ario escolher 5 op c oes de exibi c ao de pot encias. As op c oes permitem escolher as pot encias de 2, 3, 5, 10 ou 15. De acordo com a op c ao escolhida, o programa exibir a todas as pot encias do n umero escolhido que sejam menores que 10000. Resposta: programa 9.13.
4.3.3
Progress ao aritm etica
Considere uma progress ao aritm etica (PA). Fa ca um programa que receba o termo inicial a1 , a raz ao r e o ` medida que a n umero de termos a serem gerados. Em seguida, a PA e impressa, com 10 termos por linha. A PA vai sendo gerada, a soma dos termos e calculada (vai sendo acumulada). Ao nal, esta soma e impressa e e feita uma verica c ao de acerto atrav es da f ormula da soma dos termos da PA dada pela expres ao 4.1.
Sn = Resposta: programa 9.14.
n (a1 + an ) 2
(4.1)
29
4.3.4
Sequ encia de Fibonacci
Fa ca um programa que receba um n umero n e gere os n primeiros n umeros da sequ encia de Fibonacci denida na f ormula 4.2.
0, se n = 0; F (n) = 1, se n = 1; F (n 1) + F (n 2) outros casos. Resposta: programa 9.15.
(4.2)
4.3.5
Par de n umeros com soma denida
Fa ca um programa que leia um valor inteiro n ao negativo e imprima todos os pares de n umeros inteiros n ao negativos cuja soma seja igual a este n umero. Considere que o par x, y e diferente de y, x e deve ser impresso duas vezes. Dica que pode ser uma usada em uma solu c ao: a inicializa c ao do for (primeira op c ao entre par enteses), pode conter mais de uma vari avel. Por exemplo: for ( x = 0, y = 100; etc. . . ). Resposta: programa 9.16.
4.3.6
Soma de alguns n umeros digitados
Fa ca um programa que receba 10 n umeros via teclado e imprima a soma dos n umeros cujos quadrados sejam menores que 225. Utilize a estrutura for na solu c ao. Resposta: programa 9.17.
4.3.7
Achar os divisores de um n umero
Ler um n umero positivo e imprimir todos os seus divisores. Resposta: programa 9.18.
4.3.8
Imprimir somente acima da diagonal principal
Considere a sa da do programa 4.7 como uma matriz (aten c ao, reporte-se ao programa 4.7). Modique este programa para que apenas a diagonal principal e os dados acima dela sejam impressos.
4.3 Exerc cios Propostos Resposta: programa 9.19.
30
Cap tulo 5
while e do-while (enquanto e fa ca-enquanto)

Neste cap tulo vamos estudar dois outros comandos de repeti c ao. O primeiro deles e o enquanto e sua forma geral e a seguinte: enquanto ( condi c ao ) { comando 1; comando 2; . . . comando n; }
sempre testada no in A condi c ao e um teste l ogico que verica se o la co ser a executado. E cio e, somente se for verdadeira, o interior do la co e executado. Cada vez que o enquanto e executado, ao se atingir o m do la co (}), a execu c ao volta ao in cio (enquanto ( condi c ao ) {), a condi c ao e testada novamente. Se for verdadeira, o la co e executado novamente, se for falsa, a execu c ao segue para a pr oxima instru c ao ap os o la co. O algoritmo 5.1 apresenta um primeiro exemplo. Algoritmo/Programa 5.1: Um exemplo simples com o la co enquanto
1 2 3 4
i n cio
i n t par = 2 ;
32
5 6 7 8 9 10
enquanto ( par <= 1000 ) { e s c r e v a ( par ) ; par = par + 2 ; }
fim
A vari avel par recebe inicialmente o valor 2. O teste l ogico (condi c ao de perman encia) par 1000 e feito e retorna verdadeiro. Deste modo, o la co e executado e o valor 2 e impresso. Ao nal do la co, a vari avel par e incrementada em duas unidades e passa a valer 4 (par = par + 2). A condi c ao continua verdadeira pois 4 1000. Assim, o la co e executado novamente e o valor 4 e impresso. Isto se repete at e que par assuma o valor 1002. Com par = 1002, a condi c ao se torna falsa e o la co e abandonado (o algoritmo passa para a pr oxima instru c ao ap os a chave de fechamento do bloco). Em resumo, o algoritmo imprime todos os n umeros pares de 2 (inclusive) a 1000 (inclusive). O outro comando e o fa ca-enquanto. Ele e semelhante ao enquanto, mas o teste l ogico (condi c ao) e feito no m do bloco. Sua forma geral e a seguinte: fa ca { comando 1; comando 2; . . . comando n; } enquanto ( condi c ao );
Observe que a condi c ao ca depois das chaves de fechamento do bloco, que o bloco e executado pelo menos uma vez e que se usa o ponto e v rgula ao nal da condi c ao. Vejamos ent ao, no Algoritmo 5.2, como ca o Algoritmo 5.1 (pares de 2 a 1000) desenvolvido com o fa caenquanto: Algoritmo/Programa 5.2: Um exemplo simples com o la co fa ca-enquanto
1 2 3 4 5 6 7 8 9 10
inicio
i n t par = 2 ;
fa ca { e s c r e v a ( par ) ; par = par + 2 ; } enquanto ( par <= 1 0 0 0 ) ;
fim
5.2 while e do-while: aplica c oes em C
33
Observe que o 2 e impresso inicialmente sem que qualquer condi c ao seja testada (entra do la co sempre). Ap os a impress ao do 2, o valor da vari avel par e incrementado em duas unidades e o teste e feito (4 1000 ?). Este teste retorna verdadeiro at e par valer 1000. Neste momento, 1000 1000 ainda retorna verdadeiro, o la co e executado, o valor 1000 e impresso e par passa a valer 1002. Como 1002 1000 retorna falso, o la co e abandonado e o uxo de execu c ao segue para a pr oxima instru c ao ap os o fa ca-enquanto.
5.2
while e do-while: aplica co es em C
Em C, o enquanto e substitu do por while e o fa ca-enquanto po do-while. Veja a sintaxe: while ( condi c ao ) { comando 1; comando 2; . . . comando n; }
do { comando 1; comando 2; . . . comando n; } while ( condi c ao );
Como nos comandos anteriores, podemos ter aninhamento, com while dentro de while, do-while dentro de do-while, while dentro do switch, do-while dentro do for, etc, etc, etc. Podemos usar while ou do-while para repetir um menu at e que o usu ario escolha sair. Veja no exemplo 5.3. Algoritmo/Programa 5.3: Uso do while combinado com um menu de op c oes
1 2 3 4 5 6 7 8 9 10 11
// prog035 . c
i n t main ( ) {
i n t opcaoDoMenu = 0 ;
while ( opcaoDoMenu != 5 ) {
p r i n t f ( " \ n Op c~ o es " ) ;
5.2 while e do-while: aplica c oes em C
34
12 13 14 15 16 17 18 19 20 21 22 23 24
p r i n t f ( " \ n 1 - Faz isso " ) ; p r i n t f ( " \ n 2 - Faz aquilo " ) ; p r i n t f ( " \ n 3 - Calcula alguma coisa " ) ; p r i n t f ( " \ n 4 - Mostra aquele resultado " ) ; p r i n t f ( " \ n 5 - Sai do programa \ n -> " ) ; s c a n f ( " % d " , &opcaoDoMenu ) ;
switch ( opcaoDoMenu ) {
case 1 : p r i n t f ( " \ nVoc^ e escolheu a op c~ a o 1. " ) ; p r i n t f ( " \ nA op c~ a o se refere a \" Fazer isso \". " ) ; p r i n t f ( " \ nAqui entraria o c o digo que faria o que se deseja .\ n \ n" ) ;
25 26 27 28 29 30
break ;
case 2 : p r i n t f ( " \ nVoc^ e escolheu a op c~ a o 2. " ) ; p r i n t f ( " \ nA op c~ a o se refere a \" Fazer aquilo \". " ) ; p r i n t f ( " \ nAqui entraria o c o digo que faria o que se deseja .\ n \ n" ) ;
31 32 33 34 35 36
break ;
case 3 : p r i n t f ( " \ nVoc^ e escolheu a op c~ a o 3. " ) ; p r i n t f ( " \ nA op c~ a o se refere a \" Calcular alguma coisa \". " ) ; p r i n t f ( " \ nAqui entraria o c o digo que faria o que se deseja .\ n \ n" ) ;
37 38 39 40 41 42
break ;
case 4 : p r i n t f ( " \ nVoc^ e escolheu a op c~ a o 4. " ) ; p r i n t f ( " \ nA op c~ a o se refere a \" Mostrar aquele resultado \". " ) ; p r i n t f ( " \ nAqui entraria o c o digo que faria o que se deseja .\ n \ n" ) ;
43 44 45 46 47 48 49 50 51 52 53 54 55
break ;
case 5 : p r i n t f ( " \ nVoc^ e escolheu a op c~ a o 5. " ) ; p r i n t f ( " \ nA op c~ a o se refere a \" Sair do programa \".\ n \ n " ) ; break ;
default : p r i n t f ( " \ nVoc^ e escolheu uma op ca ~ o inv a lida .\ n \ n " ) ;
35
56
5.3
5.3.1

Adivinhar no at e o usu ario acertar ou desistir
Modique os exerc cios 2.3.1 e 4.3.1 de modo que o usu ario possa tentar adivinhar o n umero quantas vezes desejar, tendo a op c ao de abandonar o programa quando quiser. Aumente agora o intervalo de n umeros gerados para [0, 99]. Resposta: programa 9.20.
5.3.2
Pre co de passagem a erea
Fazer um programa com o seguinte menu:
1. Informa pre co da passagem 2. Informa quantos pre cos j a foram informados 3. Informa total em R$ j a informados 4. Sai do programa.
Para a op c ao 1, o programa recebe o destino e se e viagem s o de ida ou de ida e volta e informa o pre co, segundo a tabela abaixo: Destino Regi ao Norte Regi ao Nordeste Regi ao Centro-oeste Regi ao Sul Pre co ida R$ 500 R$ 350 R$ 350 R$ 300 Pre co ida e volta R$ 900 R$ 650 R$ 600 R$ 550
Tabela 5.1: Pre co de passagens a ereas por regi ao
36
5.3.3
L e no s e exibe o maior, o menor e a quantidade
Fazer um programa que leia n n umeros e imprima, no nal, o maior deles, o menor deles e quantos n umeros foram digitados. A op c ao para terminar de informar n umeros deve ser -999.
5.3.4
Menu para somar ou multiplicar no s
Fazer um programa com o seguinte menu:
a. Soma v arios n umeros b. Multiplica v arios n umeros c. Sai do programa
Cada op c ao do menu faz o que o nome sugere, ou seja, soma v arios n umeros at e o usu ario decidir encerrar ou multiplica v arios n umeros at e o usu ario decidir parar. Ap os a execu c ao das somas ou das multiplica c oes, o menu principal e novamente apresentado ao usu ario.
5.3.5
Achar o n umero de m ultiplos em um intervalo
Fazer um programa que leia X e N e informe quantos m ultiplos de X existem entre 1 e N . Use while ou do-while e n ao use divis ao. Exemplo: Se X = 8 e N = 30, a sa da do programa ser a 3. Pois existem 3 m ultiplos de 8 entre 1 e 30 (8, 16 e 24).
5.3.6
Imprimir todos menos os m ultiplos
Fa ca um programa que leia 3 valores: a (entre 0 e 10), b (entre 100 e 1000) e c (entre 2 e 15). Em seguida, o programa imprime todos os n umeros de a a b, exceto os que forem m ultiplos de c.
5.3.7
Movimenta c ao banc aria
Fa ca um programa com o seguinte menu:
a. Dep osito b. Retirada
5.3 Exerc cios Propostos c. Salto Atual d. Sai
37
Partindo de um saldo nulo. Atenda ` as op c oes acima em uma conta banc aria. Considere que a conta n ao pode car negativa.
Cap tulo 6
String, vetor e matriz

6.1 Vetor
Vari aveis armazenam um valor de um determinado tipo. Por exemplo, uma vari avel do tipo int pode armazenar um valor do tipo inteiro (int). Por exemplo: int a; declara a vari avel a. Esta vari avel pode assumir o valor 10 ou 5 ou 8, etc. como ter v Um vetor (ou array), pode armazenar v arios valores de um determinado tipo. E arios valores do mesmo tipo colocados um do lado da outro e todos acessados pela vari avel de mesmo nome. Para acessar cada um destes valores, usamos um ndice num erico que determina qual deles queremos manipular. A sintaxe e a seguinte: tipo nome[tamanho]; Por exemplo: int notas[5]; Neste exemplo queremos armazenar 5 valores do tipo int na vari avel notas. Em C, vetores come cam na posi c ao 0. Os elementos do vetor ocupam localiza c oes adjacentes na mem oria. Deste modo, para o exemplo acima, teremos as seguintes posi c oes v alidas para o vetor notas: notas[0], notas[1], notas[2], notas[3], notas[4].
6.1 Vetor Vejamos o primeiro exemplo no programa 6.1. Algoritmo/Programa 6.1: O primeiro exemplo com vetores
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34
39
// prog036 . c
i n t main ( ) {
int x ;
int vetorTeste [ 5 ] ;
vetorTeste [ 0 ] = 34; v e t o r T e s t e [ 1 ] = 3; vetorTeste [ 2 ] = 0; vetorTeste [ 3 ] = 6; v e t o r T e s t e [ 4 ] = 8;
p r i n t f ( " Elementos do vetor : " ) ; p r i n t f ( " \ nElemento da posi c~ a o 0 do vetor = % d " , v e t o r T e s t e [ 0 ] ) ; p r i n t f ( " \ nElemento da posi c~ a o 1 do vetor = % d " , v e t o r T e s t e [ 1 ] ) ; p r i n t f ( " \ nElemento da posi c~ a o 2 do vetor = % d " , v e t o r T e s t e [ 2 ] ) ; p r i n t f ( " \ nElemento da posi c~ a o 3 do vetor = % d " , v e t o r T e s t e [ 3 ] ) ; p r i n t f ( " \ nElemento da posi c~ a o 4 do vetor = % d \ n " , v e t o r T e s t e [ 4 ] ) ;
x = vetorTeste [ 3 ] vetorTeste [ 4 ] ; p r i n t f ( " \ nElemento 3 multiplicado pelo elemento 4 = % d \ n " , x ) ;
v e t o r T e s t e [ 0 ] = 2 ; p r i n t f ( " \ nElemento da posi c~ a o 0 multiplicado por 2 = % d \ n " , v e t o r T e s t e [ 0 ] ) ;
p r i n t f ( " \ nDigite um novo valor para o elemento 4: " ) ; s c a n f ( " % d " ,& v e t o r T e s t e [ 4 ] ) ; p r i n t f ( " \ nNovo valor do elemento da posi c~ a o 4 do vetor = % d \ n \ n " , v e t o r T e s t e [ 4 ] ) ;
Importante: C n ao verica se o programa est a acessando uma posi c ao v alida do vetor. Se voc e acessar uma posi c ao al em do m do vetor, erros em tempo de execu c ao podem ocorrer. Veja abaixo um trecho de c odigo que pode provocar erros imprevis veis: int vetorDois[10]; int x; vetorDois[11] = 32; x = vetorDois[13];
6.2 String
40
Podemos ter vari aveis usadas como ndice do vetor. Vejamos o programa 6.2: Algoritmo/Programa 6.2: Vari avel como ndice do vetor
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
// prog037 . c
i n t main ( ) {
int i ;
// tem que s e r do t i p o i n t e i r o
int vetor [ 1 0 ] ;
// d e c l a r a um v e t o r de i n t e i r o s
// I n s e r e o quadrado dos n u meros de 0 a 9 em cada p o s i c a o do v e t o r f o r ( i = 0 ; i < 10 ; i ++ ) { vetor [ i ] = i i ; }
// E x i b e o c o n t e u d o do v e t o r f o r ( i = 0 ; i < 10 ; i ++ ) { p r i n t f ( "\n%d" , vetor [ i ] ) ; }
p r i n t f ( "\n" ) ;
O ndice (n umero entre colchetes), tem que ser do tipo int.
6.2
String
Uma string e uma cadeia ou sequ encia de caracteres. As strings s ao usadas para armazenar nomes, palavras e frases. Em C, uma string consiste em um vetor de caracteres (char) terminada em zero. Mais especicamente, terminada com \0. Por essa raz ao, voc e deve declarar o vetor de caracteres com uma posi c ao a mais do que a maior string que voc e quer que ele possa armazenar. Por exemplo, se voc e quer que o vetor armazene uma string de at e 10 posi c oes, declare da seguinte maneira: char palavra[11]; A melhor maneira de ler uma string via teclado e com a fun c ao gets():
6.2 String gets(nome do vetor); Por exemplo: gets(palavra); Veja um exemplo simples no programa 6.3: Algoritmo/Programa 6.3: Um exemplo simples de string e gets()
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
41
// prog039 . c
i n t main ( ) {
char f r a s e [ 8 0 ] ;
p r i n t f ( " Digite uma frase : " ) ;
gets ( frase ) ;
p r i n t f ( " Voc^ e digitou % s \ n " , f r a s e ) ;
A fun c ao gets() ler a os caracteres digitados at e que voc e tecle ENTER. N ao e feita nenhuma verica c ao se o que voc e digitou cabe no vetor declarado. No programa 6.3, se voc e digitar uma string com mais de 79 caracteres, os u ltimos caracteres invadir ao espa cos de mem oria de outras vari aveis.
6.2.1
Fun c oes de manipula c ao de strings
Existem algumas fun c oes prontas para a manipula c ao de strings. Vamos descrev e-las e apresentar alguns exemplos. Estas fun c oes est ao da biblioteca string.h, sendo necess ario inserir #include <string.h> no cabe calho do programa.
strlen() Sintaxe: strlen(s) (onde s e uma string). Esta fun c ao retorna (devolve) um n umero inteiro que corresponde ao comprimento (tamanho ou n umero de caracteres) da string s. Como ela retorna um valor, e comum fazermos uma vari avel inteira receber o resultado da fun c ao. Veja o exemplo no programa 6.4.
6.2 String Algoritmo/Programa 6.4: A fun c ao strlen()

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
42
// prog041 . c
#include < s t d i o . h> #include < s t r i n g . h>
i n t main ( ) {
i n t tamanho ;
char f r a s e [ 3 1 ] ;
p r i n t f ( " \ nDigite o conte u do da string ( com 30 caracteres no m a ximo ) : " ) ;
gets ( frase ) ;
tamanho = s t r l e n ( f r a s e ) ;
p r i n t f ( " \ nA string \ t % s \ ttem % d caracteres .\ n " , f r a s e , tamanho ) ;
p r i n t f ( " \ n \ n Quinto elemento da frase = % c \ n \ n " , f r a s e [ 4 ] ) ;
Observe que, como a fun c ao strlen() retorna um valor inteiro, ao fazermos tamanho = strlen(s); , este valor e atribu do ` a vari avel tamanho.
strcpy() Sintaxe: strcpy(s1, s2) (onde s1 e s2 s ao strings). Esta fun c ao copia o conte udo da string s2 para a string s1. Certique-se que s2 s1. Veja o exemplo no programa 6.5. Algoritmo/Programa 6.5: A fun c ao strcpy()
1 2 3 4 5 6 7 8 9 10
// prog042 . c
i n t main ( ) {
char t e s t e [ 5 0 ] ;
s t r c p y ( t e s t e , " Texto a ser inserido na string teste " ) ;
6.2 String
43
11 12 13 14
p r i n t f ( "\n %s \n" , t e s t e ) ;
strcat() Sintaxe: strcat(s1, s2) (onde s1 e s2 s ao strings). Esta fun c ao anexa s2 ao nal de s1. s2 ca inalterada. Dizemos que foi feita a concatena c ao das strings s1 e s2 O programa 6.6 apresenta um exemplo. Algoritmo/Programa 6.6: A fun c ao strcat()
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27
// prog043 . c
i n t main ( ) {
char p r i m e i r a S t r i n g [ 5 0 ] , s e g u n d a S t r i n g [ 2 5 ] ;
p r i n t f ( " \ nDigite a primeira string ( com no m a ximo 25 caracteres ) .\ n " ) ; gets ( primeiraString ) ; p r i n t f ( " \ nDigite a segunda string ( com no m a ximo 25 caracteres ) .\ n " ) ; gets ( segundaString ) ;
p r i n t f ( " \ n \ nAntes da concatena ca ~o :" ) ;
p r i n t f ( " \ nPrimeira : % s " , p r i m e i r a S t r i n g ) ; p r i n t f ( " \ nSegunda : % s " , s e g u n d a S t r i n g ) ;
s t r c a t ( primeiraString , segundaString ) ;
p r i n t f ( " \ n \ nDepois da concatena c~ ao :" ) ;
p r i n t f ( " \ nPrimeira : % s " , p r i m e i r a S t r i n g ) ; p r i n t f ( " \ nSegunda : % s \ n \ n " , s e g u n d a S t r i n g ) ;
6.3 Matriz strcmp() Sintaxe: strcmp(s1, s2) (onde s1 e s2 s ao strings).
44
Esta fun ca o compara as strings s1 e s2. Ela retorna 0 se s1 = = s2; retorna um n umero positivo se s1 for lexicogracamente maior que s2 e retorna um n umero negativo se s1 < s2. Algoritmo/Programa 6.7: A fun c ao strcmp()
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
// prog040 . c
i n t main ( ) {
int r e s u l t a d o ;
char s 1 [ 1 0 ] , s 2 [ 1 0 ] ; s t r c p y ( s1 , " aaa " ) ; s t r c p y ( s2 , " aaa " ) ; r e s u l t a d o = strcmp ( s1 , s 2 ) ; p r i n t f ( " \ nResultado = % d " , r e s u l t a d o ) ;
s t r c p y ( s1 , " aaa " ) ; s t r c p y ( s2 , " bbb " ) ; r e s u l t a d o = strcmp ( s1 , s 2 ) ; p r i n t f ( " \ nResultado = % d " , r e s u l t a d o ) ;
s t r c p y ( s1 , " bbb " ) ; s t r c p y ( s2 , " aaa " ) ; r e s u l t a d o = strcmp ( s1 , s 2 ) ; p r i n t f ( " \ nResultado = % d " , r e s u l t a d o ) ;
s t r c p y ( s1 , " aaaa " ) ; s t r c p y ( s2 , " aaa " ) ; r e s u l t a d o = strcmp ( s1 , s 2 ) ; p r i n t f ( " \ nResultado = % d \ n " , r e s u l t a d o ) ;
6.3
Matriz
Matrizes s ao vetores com mais dimens oes. Em outras palavras, podemos ver um vetor como uma matriz com uma linha e n colunas. Uma matriz bidimensional possui i linhas e j colunas. C permite matrizes com
6.3 Matriz mais dimens oes: 3, 4, . . . (multidimensionais). No momento, vamos abordar apenas as matrizes bidimensionais. A sintaxe e a seguinte: ao 2]; tipo nome[dimens ao 1] [dimens Por exemplo: int matriz[10][20]; declara uma matriz de inteiros com 10 linhas e 20 colunas. Outros exemplos:
45
int matrizA[5][5]; : a vari avel chama-se matrizA, seus elementos s ao do tipo int e sua dimens ao e de 5 linhas e 5 colunas. matrizA[2][2] = 34; : a atribui c ao de valores e normal, como se faz com qualquer vari avel ou vetor. oat M[4][6] : a vari avel chama-se M, seus elementos s ao do tipo oat e sua dimens ao e de 4 linhas e 6 colunas. M[2][3] refere-se ao elemento da terceira linha e quarta coluna da matriz M. Como nos vetores, a contagem come ca de zero. M[i][j] = 3.456; : podemos usar vari aveis como ndices da matriz. De um modo geral, temos tipo nome da vari avel[no de linhas][no de colunas]. Vejamos um exemplo no programa 6.8. Algoritmo/Programa 6.8: Um exemplo simples com matriz
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
// prog044 . c
i n t main ( ) {
int i , j , matriz [ 3 ] [ 4 ] ;
p r i n t f ( " \ n Digite os elementos da matriz \ n " ) ;
f o r ( i = 0 ; i < 3 ; i++ ) { f o r ( j = 0 ; j < 4 ; j++ ) { s c a n f ( " % d " ,& m a t r i z [ i ] [ j ] ) ; } }
f o r ( i = 0 ; i < 3 ; i++ ) {
6.3 Matriz
46
18 19 20 21 22 23
f o r ( j = 0 ; j < 4 ; j++ ) { p r i n t f ( " matriz [% d ][% d ] = % d \ t " , i , j , m a t r i z [ i ] [ j ] ) ; } p r i n t f ( "\n" ) ; } }
6.3.1
Matrizes de strings
Para criar uma matriz de strings, usa-se uma matriz bidimensional de caracteres (char), na qual o ndice da esquerda (linhas) determina o n umero de strings e o ndice da direita (colunas) especica o comprimento m aximo de cada string. Por exemplo, char matriz str[30][81]; declara uma matriz de 30 strings, sendo que cada string pode ter, no m aximo, 81 caracteres (80 caracteres + o terminador \0). Para acessar uma determinada string, basta especicar o ndice da linha (primeiro ndice). A linha abaixo, por exemplo, l e a terceira string da matriz str: gets(matriz str[2]); Ela e equivalente a gets(matriz str[2][0]);. Vamos a um exemplo que l e v arias linhas de texto. Algoritmo/Programa 6.9: L e e exibe um texto com v arias linhas
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
// prog045 . c
i n t main ( ) {
int i ; char t e x t o [ 1 0 0 ] [ 8 0 ] ;
p r i n t f ( " ------------------------------------------------------------------------" ) ; p r i n t f ( " \ n Digite o texto e uma linha em branco para encerrar \ n " ) ; p r i n t f ( " - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\ n " ) ;
f o r ( i = 0 ; i < 100 ; i++ ) {
gets ( texto [ i ] ) ;
i f ( t e x t o [ i ] [ 0 ] == \0 ) break ;
47
20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35
p r i n t f ( " - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\ n " ) ;
f o r ( i = 0 ; i < 100 ; i++ ) {
i f ( t e x t o [ i ] [ 0 ] == \0 ) break ;
p r i n t f ( "%s\n" , texto [ i ] ) ;
p r i n t f ( " - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\ n " ) ;
O primeiro for recebe (l e) v arias linhas digitadas com a fun c ao gets(). Quando uma linha em branco e digitada, ela ter a apenas uma string vazia, a condi c ao do if ser a verdadeira e o for ser a interrompido com o comando break. Em seguida, todas as strings (linhas do texto) s ao impressas at e atingirmos a linha vazia (texto[i][0] == \0).
6.4
6.4.1

Calcular a m edia dos elementos de um vetor
Fa ca um programa que receba via teclado 8 notas de uma turma. Depois de lidas todas as notas, calcule e imprima a m edia da turma. As notas devem ser armazenadas em um vetor de reais (oat). Resposta: programa 9.21.
6.4.2
Gerar vetor soma e produto a partir de 2 vetores originais
Ler 2 vetores de inteiros com 11 elementos cada um. Em seguida, gerar um vetor soma onde cada elemento corresponda a ` soma dos dois elementos correspondentes dos vetores lidos. Gerar outro vetor produto cujos elementos correspondam ao produto dos elementos de mesma posi c ao dos vetores lidos. Exibir os 4 vetores na tela.
48
6.4.3
Imprimir vetor de tr as pra frente
Ler um vetor com 8 elementos do tipo oat e imprimir seus elementos de tr as pra frente (do u ltimo ao primeiro).
6.4.4
Concatenar 2 vetores
Ler 2 vetores com 7 elementos do tipo inteiro cada um e concaten a-los em um terceiro vetor.
6.4.5
Achar maior e menor elementos do vetor e somar seus elementos
Fazer um programa que receba 15 valores inteiros e os grave em um vetor. Depois desta etapa, percorra o vetor e identique o maior e o menor elemento do vetor. Informe os valores e a posi c ao que eles ocupam no vetor. Depois desta etapa, some os elementos do vetor e exiba o valor desta soma.
6.4.6
Confere senha digitada
Fazer um programa que leia a senha do usu ario e informe se a senha est a correta ou incorreta. Considere que a senha correta est a gravada no c odigo fonte do programa.
6.4.7
Imprimir uma string de tr as para frente
Fazer um programa que leia uma string e a imprima de tr as pra frente. Exemplo: Digitado: ifsudestemg Impresso: gmetsedus
6.4.8
L e e imprime strings e n umeros
Fa ca um programa que receba o nome do aluno, o nome da disciplina, o n umero de faltas (inteiro) e a nota na disciplina (real). Em seguida, o programa imprime os dados lidos.
49
6.4.9
Soma de matrizes
Fazer um programa que preencha automaticamente uma matriz 3X 3 com 0, 1, 2, 3, 4, . . .. Em seguida, o programa recebe, via teclado, os elementos de outra matriz 3X 3. Por m, o programa calcula e exibe a matriz soma das duas primeiras matrizes.
6.4.10
Soma dos elementos da diagonal principal
Fazer um programa que leia os elementos de uma matriz 4X 4. Em seguida, o programa calcula e exibe a soma dos elementos da diagonal principal.
6.4.11
Menu e matriz
Fazer um programa c/ seguinte menu:
1. Inserir notas 2. Exibir nota do aluno 3. Modica nota 4. M edia do aluno 5. M edia da turma na disciplina 6. M edia geral da turma 7. Exibir todas as notas 8. Sair
A turma tem 5 alunos e cada aluno tem 3 disciplinas. As notas devem ser inseridas em uma matriz 5X 3. Considere que as op c oes 2, 3, 4, 5, 6 e 7 s o podem ser executadas se a op c ao 1 j a tiver sido executada. Considere que a op c ao 1 s o pode ser executada uma vez. A op c ao 2 pede o n umero do aluno e exibe suas notas. A op c ao 3 pede o n umero do aluno e da disciplina, l e a nova nota e substitui a antiga pela nova. A op c ao 4 pede o n umero do aluno, calcula e exibe sua m edia. A op c ao 5 pede o n umero da discplina, calcula e exibe a m edia da turma na disciplina.
Cap tulo 7
Fun c oes
7.1 Fun c oes em C
Fun c oes s ao trechos de c odigo que podem ser referenciados por um nome. Quando o nome de uma fun c ao aparece no c odigo, dizemos que a fun c ao foi chamada. Quando uma fun c ao e chamada, ela faz alguma coisa e pode retornar (devolver) valores (resultado). Quando a fun c ao n ao est a pronta em uma biblioteca, ela precisa ser criada (implementada). Forma geral: tipo que retorna nome da fun c ao (lista de par ametros) {
c odigo da fun c ao }
Exemplo: oat calculaMedia (oat a, oat b) {
c odigo da fun c ao return(resultado); }
A fun c ao se chama calculaMedia. Ela retorna (devolve) um valor real (oat). Ela recebe dois argumentos do tipo oat (a e b). Ap os calcular a m edia, o comando return(resultado); e respons avel por retornar a m edia calculada para o programa que chamou a fun c ao. A seguir o primeiro exemplo.
7.1 Fun c oes em C Algoritmo/Programa 7.1: Programa com a fun c ao calculaMedia

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29
51
// prog046 . c
float calculaMedia ( float , float ) ;
i n t main ( ) {
f l o a t a , b , m;
p r i n t f ( " \ nDigite o primeiro n u mero : " ) ; s c a n f ( " % f " , &a ) ; p r i n t f ( " \ nDigite o segundo n u mero : " ) ; s c a n f ( " % f " , &b ) ;
m = calculaMedia (a , b) ;
p r i n t f ( " \ nA m e dia entre %.2 f e %.2 f e %.2 f \ n " , a , b ,m) ;
f l o a t c a l c u l a M e d i a ( f l o a t argA , f l o a t argB ) { float mediaCalculada ;
m e d i a C a l c u l a d a = ( argA + argB ) / 2 ;
return ( m e d i a C a l c u l a d a ) ;
Vamos analisar o c odigo. Observe que o programa cont em duas fun c oes, a fun c ao main e a fun c ao calculaMedia. A execu c ao come ca pela fun c ao main. Na linha 14, a vari avel m recebe o resultado da fun c ao calculaMedia. Neste instante, a execu c ao do programa salta para a fun c ao calculaMedia e ela come ca a ser executada. Veja que na chamada da fun c ao, dois argumentos foram passados, as vari aveis a e b. Estes argumentos s ao recebidos na fun c ao atrav es das vari aveis argA e argB . A m edia e ent ao calculada e devolvida (retornada) atrav es do comando return. O comando return encerra a execu c ao de qualquer fun c ao. Assim, neste instante, a execu c ao volta para a fun c ao main, o resultado retornado (a m edia entre os argumentos passados) e atribu da ` a vari avel m e o programa continua a sua execu c ao. Por m a explica c ao da linha 3. Durante a tradu c ao do programa para a linguagem do computador
7.1 Fun c oes em C
52
(compila c ao), o tradutor (compilador) ir a deparar com o nome da fun c ao calculaMedia. Se n ao houvesse a linha 3, fun c ao n ao seria reconhecida e ocorreria um erro de compila c ao. Deste modo, a linha 3 serve para apresentar ao compilador a fun c ao calculaMedia, ou seja, diz ao compilador que esta fun c ao existe, o tipo de valor que ela retorna e os argumentos que recebe. Chamamos esta linha de prot otipo da fun c ao. Outra op c ao e escrever a fun c ao implementada antes da fun c ao main. Uma fun ca o pode ser chamada (usada) v arias vezes. Como aplica c ao deste conceito, fa ca o seguinte: no programa 7.1, declare outras duas vari aveis c e d, leia c e d com a fun c ao scanf, calcule e exiba a m edia entre c e d usando novamente a fun c ao calculaMedia. Veja outra possibilidade do uso de fun c oes: x = ( calculaMedia(a,b) + calculaMedia(c,d) ) / 2; Observe que o resultado da fun c ao e inserido diretamente em uma express ao e o valor retornado e usado para um novo c alculo. Um vetor ou matriz podem ser passados como argumentos para fun c oes. Por ainda n ao termos estudado ponteiros em C, ser a apresentada apenas uma forma de faz e-lo. Ela consiste em passar apenas o nome do vetor (ou matriz) na chamada da fun c ao e em declarar, na constru c ao da fun c ao, um vetor ou matriz igual ao argumento que ser a passado na chamada. Vejamos o exemplo do programa 7.2. Algoritmo/Programa 7.2: Passando uma matriz como argumento da fun c ao
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
// prog047 . c
void imprimeMatriz ( f l o a t a r g M a t r i z [ 4 ] [ 4 ] ) ;
i n t main ( ) {
float matriz [ 4 ] [ 4 ] ;
int i , j ;
p r i n t f ( " \ nDigite os elementos da matriz \ n " ) ; f o r ( i = 0 ; i < 4 ; i++ ) { f o r ( j = 0 ; j < 4 ; j++ ) { s c a n f ( " % f " ,& m a t r i z [ i ] [ j ] ) ; } }
imprimeMatriz ( m a t r i z ) ;
7.2 Regras de escopo
53
23 24 25 26 27 28 29 30 31 32 33 34 35
void imprimeMatriz ( f l o a t a r g M a t r i z [ 4 ] [ 4 ] ) {
int i , j ;
p r i n t f ( " \ nImpress~ a o da matriz \ n " ) ; f o r ( i = 0 ; i < 4 ; i++ ) { f o r ( j = 0 ; j < 4 ; j++ ) { p r i n t f ( " %.1 f \ t " , a r g M a t r i z [ i ] [ j ] ) ; } p r i n t f ( "\n" ) ; } }
7.2
Regras de escopo
Vari aveis declaradas dentro de uma fun ca o s ao chamadas vari aveis locais, ou seja, elas s o podem ser usadas dentro da fun c ao. Em outras palavras, elas s o existem dentro da fun c ao. Isto serve tamb em para qualquer bloco de c odigo delimitado por chaves ({. . .}). Neste caso, dizemos que o escopo destas vari aveis est a limitado a fun ` c ao dentro da qual elas foram declaradas. Quando o programa e executado, uma vari avel local e criada quando a execu c ao do bloco e iniciada ({) e destru da quando a execu c ao do bloco e encerrada (}). No trecho a seguir, cada vari avel x s o existe dentro de cada uma das fun c oes. Uma n ao interfere na outra. Ambas podem ser chamar x ou poderiam ter nomes diferentes. ... int funcaoUm(int a){ int x; x = a * a; return(x); } ... int funcaoDois(int m){ int x; x = m * m * m; return(x); }
Ao contr ario das vari aveis locais, as vari aveis globais s ao conhecidas em todo o programa e podem ser
54
usadas por qualquer parte do c odigo. Sua visibilidade e total. Uma vari avel global e criada atrav es de uma declara c ao feita fora de qualquer fun c ao (inclusive, fora da pr opria fun c ao main).
7.3
7.3.1

Calculadora usando fun co es
Fazer um programa que execute at e que o usu ario decida encerrar. Na execu c ao, o programa recebe 2 n umeros, o usu ario escolhe a opera c ao desejada ( + - * / ) e o programa efetua a opera c ao desejada. Use chamadas de fun c oes para executar as opera c oes. N ao permita divis ao por zero.
7.3.2
Equa c ao do segundo grau usando fun co es
Refa ca o exerc cio 2.3.5 usando fun c oes. As seguintes fun c oes devem ser criadas e usadas: oat calculaDelta(oat, oat, oat) : recebe os coecientes da equa c ao e retorna o valor de delta. oat calculaRaizUm(oat, oat, oat) : recebe os coecientes a e b da equa c ao, recebe o valor de delta e retorna o valor de uma das ra zes da equa c ao. oat calculaRaizDois(oat, oat, oat) : recebe os coecientes a e b da equa c ao, recebe o valor de delta e retorna o valor da outra raiz da equa c ao.
7.3.3
Cria c ao de um vetor aleat orio usando fun c ao
Fazer um programa que gere e imprima um vetor com 20 n umeros inteiros. Estes n umeros devem ser aleat orios e gerados por uma fun c ao int geraInt(int limiteSuperior). Esta fun c ao gera aleatoriamente um n umero inteiro entre 0 e limiteSuperior.
7.3.4
Concatena c ao de 2 vetores ordenados em um 3o tamb em ordenado
Fazer um programa que gere aleatoriamente dois vetores com 20 n umeros inteiros em ordem crescente. Em seguida, e gerado um terceiro vetor com os 40 elementos dos dois primeiros, tamb em em ordem crescente. Exemplo: vetorUm = {1, 4, 8, 8, 10} vetorDois = {0, 1, 5, 9, 11}
7.3 Exerc cios Propostos vetorResultado = {0, 1, 1, 4, 5, 8, 8, 9, 10, 11}
55
Uma forma de gerar o vetor j a ordenado e usar a fun c ao geraInt do exerc cio 7.3.3 e sempre somar o n umero gerado ao valor anterior. Assim, o elemento i + 1 ser a igual ao elemento i + geraInt(...). O limite superior usado na fun ca o geraInt() n ao ser a respeitado nestes vetores gerados, mas n ao se preocupe com este fato. A sugest ao e que o programa v a percorrendo os dois vetores simultaneamente (mas n ao sincronizadamente) e v a transferindo valores para o vetorResultado de forma a manter a ordena c ao. Resposta: programa 9.22.
7.3.5
Achar o maior, menor, m edia, soma e produto dos elementos do vetor, usando fun c oes
Fa ca um programa com um menu contendo as seguintes op c oes: gera vetor; exibe vetor; acha maior; acha menor; calcula m edia dos elementos; calcula soma dos elementos; calcula produto dos elementos; sai do programa. Considere que o vetor em quest ao tem 15 elementos reais. Implemente cada op c ao do menu atrav es da chamada de uma fun c ao espec ca.
7.3.6
Produto de matrizes
Fa ca um programa que gere duas matrizes, uma 4X 6 e outra 6X 4, calcule e exiba o produto delas. Obs.: neste momento, sugiro n ao usar fun c oes (exceto a fun c ao geraInt()). Resposta: programa 9.23.
7.3.7
Ordena c ao de vetor
Fa ca um programa que gere um vetor de n umeros inteiros aleat orios e fa ca a ordena c ao dos valores em ordem crescente. Resposta: programa 9.24.
Cap tulo 8
struct (Estrutura)
8.1 struct : conceitos iniciais
Em C, uma estrutura e uma cole c ao de vari aveis agrupadas dentro de outra vari avel. Imagine que voc e precisa gravar v arios dados de um cliente (codigo, nome, endere co, telefone, CPF, e-mail, limite de cr edito). interessante que voc E e crie uma estrutura (struct) e, dentro dela, crie vari aveis para cada um dos campos (c odigo, nome, endere co, . . .). No exemplo dado acima, a estrutura seria a seguinte: struct TipoCliente { int codigo; char nome[50]; char endereco[100]; char telefone[12]; char CPF[11]; char eMail[40]; oat limiteDeCredito; };
Observe que dentro da estrutura temos v arias vari aveis de tipos primitivos (int, vetores de char e oat). Veja que o enunciado termina com ponto e v rgula ( ; ). Na verdade, no exemplo acima, ainda n ao foi criada a vari avel em si. O que foi feito foi a deni c ao (cria c ao) de um novo tipo chamado TipoCliente que cont em todos aqueles campos. Para se declarar uma vari avel efetivamente, e preciso um enunciado como o que mostramos a seguir:
8.1 struct : conceitos iniciais struct TipoCliente cliente; A sim, passamos a ter uma vari avel chamada cliente que e do tipo TipoCliente. Voc e pode inclusive declarar mais de uma vari avel deste tipo: struct TipoCliente cliente, clienteEspecial, clienteInativo; A declara c ao das vari aveis pode ser feita junto com a cria c ao do tipo. No caso acima ter amos: struct TipoCliente { int codigo; char nome[50]; char endereco[100]; char telefone[12]; char CPF[11]; char eMail[40]; oat limiteDeCredito; } cliente, clienteEspecial, clienteInativo;
57
Se voc e precisar de apenas uma vari avel do tipo criado, n ao precisa incluir o seu nome. Veja o exemplo adaptado a este caso: struct { int codigo; char nome[50]; char endereco[100]; char telefone[12]; char CPF[11]; char eMail[40]; oat limiteDeCredito; } cliente;
Temos, ent ao, como forma geral da deni c ao de uma estrutura, esta mostrada a seguir: struct NomeDoNovoTipo { tipo nomeDaVari avel; tipo nomeDaVari avel; ... tipo nomeDaVari avel; } variavelUm, variavelDois, . . . , variavelN;
8.2 Acessando os elementos (campos) da estrutura
58
8.2
Acessando os elementos (campos) da estrutura
O acesso a um campo da estrutura se d a atrav es do nome da vari avel, um ponto e o nome do campo. Nos exemplos acima, ter amos: cliente.codigo = 123; clienteEspecial.limiteDeCredito = 1200.50; gets(clienteInativo.nome); De um modo geral: nomeDaVari avelDoTipoEstrutura.nomeDoCampo
8.3
Vetores de estruturas
Depois de declarado o tipo da estrutura, basta declarar o vetor com a quantidade de elementos desejada. Ainda com rela c ao ao exemplo da se c ao 8.1, veja como seria a cria c ao de um vetor para armazenar at e 100 clientes: struct TipoCliente bancoDeClientes[100]; Para acessar um campo de um cliente em especial, combine os conceitos j a estudados de vetores com os conceitos aqui apresentados: Por exemplo, o c odigo do trig esimo cliente e acessado atrav es do enunciado a seguir: bancoDeClientes[29].codigo
8.4
8.4.1

Cadastro de produtos
Fa ca um programa que permita cadastrar, consultar e modicar uma base de 15 produtos. Cada produto cont em os seguintes atributos: c odigo, nome, pre co, quantidade em estoque.
Cap tulo 9
Solu c ao dos Exerc cios

9.1 Respostas dos exerc cios do Cap tulo 1
Algoritmo/Programa 9.1: Resposta do exerc cio 1.6.10
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
// prog033 . c
#include < s t d i o . h> #include < s t d l i b . h> #include <math . h> i n t main ( ) { f l o a t x , y , r , e ; // xa n g u l o ; ymedida da p a r e d e ; rr a d i a n o s e medida da e s c a d a p r i n t f ( " O angulo eh : " ) ; s c a n f ( " % f " , &x ) ; p r i n t f ( " A medida da parede eh : " ) ; s c a n f ( " % f " ,&y ) ; r=x ( 3 . 1 4 / 1 8 0 ) ; e=y/ s i n ( r ) ; p r i n t f ( " A medida da escada eh : %.1 f \ n " , e ) ; }
9.2
Respostas dos exerc cios do Cap tulo 2

1 2 3 4 5
// prog010 . c
i n t main ( ) {
60
6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29
i n t numeroGerado , p a l p i t e ;
s r a n d ( time (NULL) ) ;
// f a z n u mero g e r a d o v a r i a r a cada e x e c u c a o do programa
numeroGerado = rand ( ) ;
// g e r a um n u mero a l e a t o rio
// T i r e o c o m e n t a r i o da l i n h a a b a i x o para v e r o n u mero a n t e s de t e n t a r // p r i n t f ( \ nN umero g e r a d o : %d , numeroGerado ) ;
numeroGerado = numeroGerado % 1 0 ; // T i r e o c o m e n t a r i o da l i n h a a b a i x o para v e r o n u mero r e d u z i d o a n t e s de t e n t a r // p r i n t f ( \ nResto da d i v i s a o do n u mero g e r a d o por 1 0 : %d , numeroGerado ) ;
p r i n t f ( " \ nSeu palpite : " ) ; s c a n f ( " % d " ,& p a l p i t e ) ;
i f ( p a l p i t e == numeroGerado ) { p r i n t f ( " \ nAcertou !!!\ n " ) ; } else { p r i n t f ( " \ nErrou ...\ n " ) ; }

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
// prog011 . c
i n t main ( ) { i n t numeroDigitado ;
p r i n t f ( " \ nDigite um n u mero : " ) ; s c a n f ( " % d " ,& numeroDigitado ) ;
p r i n t f ( "\n%d e " , numeroDigitado ) ; i f ( numeroDigitado % 2 == 0 ) { p r i n t f ( " par .\ n " ) ; } else { printf (" mpar .\ n " ) ; }
61
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41
// prog012 . c
i n t main ( ) { i n t numeroUm , numeroDois , numeroTres ; i n t maior ;
p r i n t f ( " \ nDigite 3 n u meros separados por espa c o e tecle ENTER : " ) ; s c a n f ( " % d % d % d " ,&numeroUm , &numeroDois , &numeroTres ) ;
i f ( numeroUm > numeroDois ) { i f ( numeroUm > numeroTres ) maior = numeroUm ; else maior = numeroTres ; } else { i f ( numeroDois > numeroTres ) maior = numeroDois ; else maior = numeroTres ; } // s o uma l i n h a d e n t r o do i f d i s p e n s a as c h a v e s
p r i n t f ( " \ nO maior entre %d , % d e % d e % d \ n " , numeroUm , numeroDois , numeroTres , maior ) ;
// Outra s o l u c ao i f ( numeroUm >= numeroDois && numeroUm >= numeroTres ) { maior = numeroUm ; }
i f ( numeroDois >= numeroUm && numeroDois >= numeroTres ) { maior = numeroDois ; }
i f ( numeroTres >= numeroDois && numeroTres >= numeroUm ) { maior = numeroTres ; }
p r i n t f ( " \ n ( Por outra l o gica ) \ nO maior entre %d , % d e % d e % d \ n " , numeroUm , numeroDois , numeroTres , maior ) ;
42 43 44
62
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
// prog013 . c
i n t main ( ) { i n t numero ;
p r i n t f ( " \ nDigite um n u mero : " ) ; s c a n f ( " % d " ,&numero ) ;
p r i n t f ( "\n%d e " , numero ) ; i f ( numero > 0 ) { p r i n t f ( " positivo \ n " ) ; } else { i f ( numero < 0 ) p r i n t f ( " negativo \ n " ) ; else p r i n t f ( " nulo \ n " ) ; } }

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
// prog014 . c
#include < s t d i o . h> #include <math . h>
//No Linux , c o m p i l e com g c c lm para c a r r e g a r a b i b l i o t e c a matem a tica com a f u n c a o s q r t //No Ubuntu 10 u s e i g++ ( sem lm ) em l u g a r de g c c lm ( que n ao f u n c i o n o u ) //O programa r e q u e r a j u s t e s quando a > 0 e b = c = 0 .
i n t main ( ) { float a , b , c ; f l o a t d e l t a , raizUm , r a i z D o i s ;
p r i n t f ( " \ nSeja a equa c~ a o do segundo grau na forma : a x2 + b x + c = 0 \ n " ) ; p r i n t f ( " Digite os coeficientes a , b e c : " ) ; p r i n t f ( " \ na = " ) ; s c a n f ( " % f " ,&a ) ; i f ( a == 0 ) { p r i n t f ( " \ nO coeficiente \" a \" n~ a o pode ser nulo .\ nO programa ser a encerrado .\ n ") ;
20 21 22 23
return ( 0 ) ; } p r i n t f ( " \ nb = " ) ; s c a n f ( " % f " ,&b ) ;
// r e t u r n e n c e r r a uma f u n c a o . No c a s o da main , e n c e r r a o programa .
63
24 25 26 27 28 29 30
p r i n t f ( " \ nc = " ) ; s c a n f ( " % f " ,& c ) ;
d e l t a = pow ( b , 2 ) 4 a c ;
if ( delta < 0 ) p r i n t f ( " \ nDelta negativo , a equa ca ~ o \"%.1 f x2 + (%.1 f ) x + (%.1 f ) \" n~ a o tem ra zes reais .\ n " , a , b , c ) ;
31 32 33 34
else { i f ( d e l t a == 0 ) { raizUm = r a i z D o i s = ( 1 b ) / ( 2 a ) ; p r i n t f ( " \ nDelta = 0 , a equa c~ a o \"%.1 f x2 + (%.1 f ) x + (%.1 f ) \" tem uma raiz que vale % f .\ n " , a , b , c , raizUm ) ;
35 36 37 38 39
} else { raizUm = (( 1 b ) + s q r t ( d e l t a ) ) / ( 2 a ) ; r a i z D o i s = (( 1 b ) s q r t ( d e l t a ) ) / ( 2 a ) ; p r i n t f ( " \ nA equa ca ~ o \"%.1 f x2 + (%.1 f ) x + (%.1 f ) \" tem duas ra zes reais : % f e % f \ n " , a , b , c , raizUm , r a i z D o i s ) ;
40 41 42
} } }

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
// prog015 . c
i n t main ( ) { i n t numeroUm , numeroDois , soma , r e s u l t a d o F i n a l ;
p r i n t f ( " \ nDigite dois n u meros separados por espa co : " ) ; s c a n f ( " % d % d " ,&numeroUm,& numeroDois ) ;
soma = numeroUm + numeroDois ;
i f ( soma > 20 ) r e s u l t a d o F i n a l = soma + 8 ; else r e s u l t a d o F i n a l = soma 5 ;
p r i n t f ( " \ nResultado final : % d \ n " , r e s u l t a d o F i n a l ) ; }

1 2
// prog016 . c
64
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
i n t main ( ) { f l o a t s a l a r i o , valorDoEmprestimo , v a l o r D a P r e s t a c a o ; i n t numeroDePrestacoes ;
p r i n t f ( " \ nSal a rio : " ) ; s c a n f ( " % f " ,& s a l a r i o ) ;
p r i n t f ( " Valor do empr e stimo : " ) ; s c a n f ( " % f " ,& valorDoEmprestimo ) ;
p r i n t f ( " N u mero de prestacoes : " ) ; s c a n f ( " % d " ,& numeroDePrestacoes ) ;
i f ( s a l a r i o <= 0 | valorDoEmprestimo <=0 | numeroDePrestacoes <=0 ) { p r i n t f ( " \ nNenhum dos valores pode ser nulo ou negativo .\ nPrograma ser a encerrado .\ n " ) ;
20 21 22 23 24 25
return ( 0 ) ; }
v a l o r D a P r e s t a c a o = valorDoEmprestimo / ( f l o a t ) numeroDePrestacoes ;
// O uso de 0 . 3 f a b a i x o e s p e c i f i c a um f l o a t . Se u s a r apenas 0 . 3 , e t r a t a d o como d o u b l e e f a l h a na compara ca o do >
26 27 28 29 30
i f ( valorDaPrestacao > s a l a r i o 0.3 f ) p r i n t f ( " \ n Empr e stimo n~ a o autorizado .\ n " ) ; else p r i n t f ( " \ n Empr e stimo autorizado .\ n " ) ; }
9.3

1 2 3 4 5 6 7 8 9 10 11
// prog019 . c
i n t main ( ) { int p l a n e t a E s c o l h i d o ; f l o a t pesoNaTerra , g r a v i d a d e R e l a t i v a , pes oN oPl an et a ;
p r i n t f ( " \ nPlanetas " ) ; p r i n t f ( " \ n1 - Merc u rio " ) ; p r i n t f ( " \ n2 - V^ e nus " ) ;
65
12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57
p r i n t f ( " \ n3 - Marte " ) ; p r i n t f ( " \ n4 - J u piter " ) ; p r i n t f ( " \ n5 - Saturno " ) ; p r i n t f ( " \ n6 - Urano " ) ; p r i n t f ( " \ n7 - Netuno \ n " ) ; p r i n t f ( " \ nDigite o n u mero do planeta escolhido : " ) ; s c a n f ( " % d " ,& p l a n e t a E s c o l h i d o ) ;
p r i n t f ( " \ n \ nInforme seu peso na Terra : " ) ; s c a n f ( " % f " ,& pesoNaTerra ) ;
switch ( p l a n e t a E s c o l h i d o ) { case 1 : gravidadeRelativa = 0.376; break ; case 2 : gravidadeRelativa = 0.903; break ; case 3 : gravidadeRelativa = 0.380; break ; case 4 : gravidadeRelativa = 2.340; break ; case 5 : gravidadeRelativa = 1.160; break ; case 6 : gravidadeRelativa = 1.150; break ; case 7 : gravidadeRelativa = 1.190; break ; default : gravidadeRelativa = 0; }
i f ( g r a v i d a d e R e l a t i v a != 0 ) { pe so NoP la ne ta = pesoNaTerra g r a v i d a d e R e l a t i v a ; p r i n t f ( " \ n \ nSeu peso no planeta escolhido e %.3 f \ n \ n " , pes oN oPl an eta ) ; } else { p r i n t f ( " \ n \ nErro na escolha do planeta . " ) ; }
9.3 Respostas dos exerc cios do Cap tulo 3 Algoritmo/Programa 9.10: Resposta do exerc cio 3.3.2
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35
66
// prog020 . c
i n t main ( ) { char opcao ;
p r i n t f ( " \ nQual a raiz quadrada de 49?\ n " ) ; p r i n t f ( " \ n \ ta ) 4\ n \ tb ) 7\ n \ tc ) 9\ n \ td ) 6\ n \ te ) Nenhuma das respostas anteriores \ n " ) ;
p r i n t f ( " \ n \ tSua op c~ ao : " ) ;
// opcao = g e t c h a r ( ) ; s c a n f ( " % c " ,& opcao ) ;
e s t a l i n h a tem o mesmo funcionamento da
linha abaixo
switch ( opcao ) { case a : p r i n t f ( " \ n \ tVoc^ e marcou letra \" a \" e errou .\ n \ n " ) ; break ; case b : p r i n t f ( " \ n \ tVoc^ e marcou letra \" b \" e acertou .\ n \ n " ) ; break ; case c : p r i n t f ( " \ n \ tVoc^ e marcou letra \" c \" e errou .\ n \ n " ) ; break ; case d : p r i n t f ( " \ n \ tVoc^ e marcou letra \" d \" e errou .\ n \ n " ) ; break ; case e : p r i n t f ( " \ n \ tVoc^ e marcou letra \" e \" e errou .\ n \ n " ) ; break ; default : p r i n t f ( " \ n \ tOp ca ~ o inv a lida .\ n \ n " ) ; } }

1 2 3 4 5 6 7 8 9
// prog017 . c
i n t main ( ) { f l o a t operandoUm , o p e r a n d o D o i s ; char o p e r a d o r ;
p r i n t f ( " \ nDigite o primeiro n u mero : " ) ;
67
10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41
s c a n f ( " % f " ,&operandoUm ) ;
p r i n t f ( " \ nDigite o segundo n u mero : " ) ; s c a n f ( " % f " ,& o p e r a n d o D o i s ) ;
p r i n t f ( " \ nDigite a opera ca ~ o (+ - * /) : " ) ;
getchar () ; operador = getchar ( ) ;
switch ( o p e r a d o r ) { case + : p r i n t f ( " \ nResultado = %.2 f \ n " , operandoUm+o p e r a n d o D o i s ) ; break ; case - : p r i n t f ( " \ nResultado = %.2 f \ n " , operandoUmo p e r a n d o D o i s ) ; break ; case * : p r i n t f ( " \ nResultado = %.2 f \ n " , operandoUm o p e r a n d o D o i s ) ; break ; case / : i f ( o p e r a n d o D o i s != 0 ) { p r i n t f ( " \ nResultado = %.2 f \ n " , operandoUm/ o p e r a n d o D o i s ) ; } else { p r i n t f ( " \ nDivis~ a o por zero n~ a o efetuada .\ n " ) ; } break ; default : p r i n t f ( " \ nOpera ca ~ o desconhecida .\ n " ) ; } }
9.4

1 2 3 4 5 6 7 8 9
// prog024 . c
i n t main ( ) { i n t numeroGerado , p a l p i t e , numeroDeTentativas , i ;
68
10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
numeroGerado = numeroGerado % 1 0 ;
p r i n t f ( " Quantas tentativas quer fazer ? " ) ; s c a n f ( " % d " , &numeroDeTentativas ) ;
f o r ( i = 1 ; i <= numeroDeTentativas ; i++ ) {
p r i n t f ( " \ nTentativa n u mero % d .\ n \ tSeu palpite : " , i ) ; s c a n f ( " % d " ,& p a l p i t e ) ;
i f ( p a l p i t e == numeroGerado ) { p r i n t f ( " \ nAcertou !!!\ n " ) ; break ; } else { p r i n t f ( " \ nErrou ...\ n " ) ; } } } // I n t e r r o m p e a e x e c u c a o do f o r

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
// prog025 . c
i n t main ( ) {
i n t opcao , base , p o t e n c i a ;
p r i n t f ( "\n\n p r i n t f ( "\n p r i n t f ( "\n p r i n t f ( "\n p r i n t f ( "\n p r i n t f ( "\n p r i n t f ( "\n
*** Menu *** " ) ; 2 - Pot^ e ncias de 3 - Pot^ e ncias de 5 - Pot^ e ncias de 2. " ) ; 3. " ) ; 5. " ) ;
10 - Pot^ e ncias de 10. " ) ; 15 - Pot^ e ncias de 15. " ) ; Sua op c~ ao : " ) ;
s c a n f ( " % d " , &opcao ) ;
switch ( opcao ) { case 2 : base = 2 ; break ; case 3 : base = 3 ; break ;
69
25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48
case 5 : base = 5 ; break ; case 1 0 : base = 10; break ; case 1 5 : base = 15; break ; default : base = 10000; }
i f ( b a s e != 10000 ) { p r i n t f ( " \ n Pot^ e ncias de % d menores que 10000: " , b a s e ) ; f o r ( p o t e n c i a = b a s e ; p o t e n c i a < 10000 ; p o t e n c i a = b a s e ) p r i n t f ( "%d " , potencia ) ; p r i n t f ( "\n\n" ) ; } else { p r i n t f ( " \ n Op ca ~ o inv a lida .\ n " ) ; } //um s o comando d i s p e n s a as c h a v e s do f o r

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
// prog027 . c
i n t main ( ) {
i n t i , a1 , r , n , a i , somaDosTermos = 0 , somaDosTermosPelaFormula ;
p r i n t f ( " \ n a1 = " ) ; s c a n f ( " % d " ,& a1 ) ;
p r i n t f ( "\n r = " ) ; s c a n f ( " % d " ,& r ) ;
p r i n t f ( " \ n N u mero de termos . n = " ) ; s c a n f ( " % d " ,&n ) ;
a i = a1 ;
f o r ( i = 1 ; i <= n ; i++ ) { i f ( ( i 1) % 10 == 0 )
70
22 23 24 25 26 27 28 29 30 31 32 33 34 35 36
p r i n t f ( "\n" ) ; p r i n t f ( "\t%d" , a i ) ; somaDosTermos += a i ; a i += r ; }
a i = r ;
// s a i do f o r j a com o pr o ximo termo da PA
p r i n t f ( " \ n Soma dos termos acumulada = % d " , somaDosTermos ) ;
somaDosTermosPelaFormula = n ( a1 + a i ) / 2 ;
p r i n t f ( " \ n Soma dos termos calculada = % d \ n \ n " , somaDosTermosPelaFormula ) ;

1 2 3 4 5 6 7 8 9 10 11 12 13
// prog028 . c
i n t main ( ) {
i n t i , n , t e r m o i m e n o s 2 = 0 , t e r m o i m e n o s 1 = 1 , termo ;
p r i n t f ( "\n n = " ) ; s c a n f ( " % d " , &n ) ;
if ( n > 1 ) { p r i n t f ( " \ n Sequ^ e ncia dos % d primeiros n u meros da sequ^ e ncia de Fibonacci .\ n " , n ) ;
14 15 16 17 18 19 20 21 22 23 24 25 26
printf ("
%d
%d" , termo i menos 2 , termo i menos 1 ) ;
f o r ( i = 3 ; i <= n ; i++ ) { termo = t e r m o i m e n o s 1 + t e r m o i m e n o s 2 ; printf (" % d " , termo ) ;
termo i menos 2 = termo i menos 1 ; t e r m o i m e n o s 1 = termo ; i f ( i %15 == 0 ) p r i n t f ( "\n" ) ; } p r i n t f ( "\n\n" ) ; }
71
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
// prog029 . c
i n t main ( ) { i n t i , j , numero ; p r i n t f ( " \ n n u mero ( >= 0 ) = " ) ; s c a n f ( " % d " , &numero ) ; i f ( numero >= 0 ) { p r i n t f ( " \ n Pares de n u meros cuja soma e igual a % d .\ n " , numero ) ; f o r ( i = 0 , j = numero ; i <= numero ; i ++, j ) { p r i n t f ( " \ t % d + % d = % d \ n " , i , j , numero ) ; } p r i n t f ( "\n\n" ) ; } }

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
// prog030 . c
i n t main ( ) {
i n t numero , soma = 0 , i ;
f o r ( i = 1 ; i <= 10 ; i++ ) {
p r i n t f ( " ( rodada %d , faltam % d ) . s c a n f ( " % d " , &numero ) ;
Digite um n u mero : " , i , 10 i ) ;
i f ( numero numero < 225 ) { soma += numero ; } }
p r i n t f ( " \ nSoma dos n u meros cujos quadrados s~ a o menores que 225: % d \ n \ n " , soma ) ;

1 2 3 4 5
// prog031 . c
i n t main ( ) {
72
6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
i n t numero , i ;
p r i n t f ( " \ n Digite um n u mero positivo : " ) ; s c a n f ( " % d " , &numero ) ;
i f ( numero <= 0 ) { p r i n t f ( " \ nErro no n u mero digitado .\ n " ) ; return ( 0 ) ; }
p r i n t f ( " \ n Divisores de % d : " , numero ) ;
f o r ( i = 1 ; i <= numero / 2 ; i++ ) {
i f ( numero % i == 0 ) { p r i n t f ( "%d } } ", i);
p r i n t f ( "%d
" , numero ) ;
p r i n t f ( "\n\n" ) ;

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
// prog032 . c
i n t main ( ) {
int i , j , k ;
p r i n t f ( " Usando a solu c~ a o 1:\ n \ n " ) ; f o r ( i = 0 ; i < 10 ; i++ ) { p r i n t f ( "\n" ) ; f o r ( j = 0 ; j < 10 ; j++ ) { i f ( j >= i ) { p r i n t f ( " \ t (% d , % d ) " , i , j ) ; } else { / imprime e s p a c o s em branco , quando o n u mero n ao e , impresso ,
73
21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40
para manter a t e l a formatada / p r i n t f ( "\t } } } ") ;
p r i n t f ( " \ n \ nUsando a solu c~ a o 2:\ n \ n " ) ; f o r ( i = 0 ; i < 10 ; i++ ) { p r i n t f ( "\n" ) ; //O f o r a b a i x o e para manter a t e l a formatada f o r ( k = 0 ; k < i ; k++ ) p r i n t f ( "\t" ) ; f o r ( j = i ; j < 10 ; j++ ) { p r i n t f ( " \ t (% d , % d ) " , i , j ) ; } }
p r i n t f ( "\n\n" ) ;
9.5

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
// prog034 . c
i n t main ( ) {
i n t numeroGerado , p a l p i t e = 0 ;
numeroGerado = numeroGerado % 1 0 0 ;
while ( p a l p i t e != 1 ) {
p r i n t f ( " \ n Digite seu palpite ( de 0 a 99) ( -1 sai ) : " ) ; s c a n f ( " % d " ,& p a l p i t e ) ;
i f ( p a l p i t e == numeroGerado ) { p r i n t f ( " \ nAcertou !!!\ n " ) ;
74
22 23 24 25 26 27 28 29
break ; } else {
// I n t e r r o m p e a e x e c u c a o do w h i l e
i f ( p a l p i t e != 1 ) p r i n t f ( " \ nErrou ...\ n " ) ; } } }
9.6

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28
// prog038 . c
i n t main ( ) {
int i ;
f l o a t somaDasNotas = 0 , mediaDaTurma ;
float notas [ 8 ] ;
//L e notas p r i n t f ( " \ nDigite as notas da turma :\ n " ) ; f o r ( i = 0 ; i < 8 ; i ++ ) { s c a n f ( " % f " ,& n o t a s [ i ] ) ; }
//Soma n o t a s f o r ( i = 0 ; i < 8 ; i ++ ) { somaDasNotas += n o t a s [ i ] ; }
// C a l c u l a e e x i b e a m e dia mediaDaTurma = somaDasNotas / 8 ; p r i n t f ( " \ nM e dia da turma = %.2 f \ n " , mediaDaTurma ) ;
9.7
9.7 Respostas dos exerc cios do Cap tulo 7 Algoritmo/Programa 9.22: Resposta do exerc cio 7.3.4
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47
75
// prog050 . c
int g e r a I n t ( int l i m i t e S u p e r i o r ) { i n t numeroGerado = rand ( ) ; numeroGerado %= l i m i t e S u p e r i o r ; return ( numeroGerado ) ; }
i n t main ( ) {
int vet1 [ 2 0 ] , vet2 [ 2 0 ] , vet3 [ 4 0 ] , i , j , k ;
vet1 [ 0 ] = geraInt (100) ; f o r ( i = 1 ; i < 20 ; i++ ) { v e t 1 [ i ] = v e t 1 [ i 1] + g e r a I n t ( 1 0 0 ) ; }
vet2 [ 0 ] = geraInt (100) ; f o r ( i = 1 ; i < 20 ; i++ ) { v e t 2 [ i ] = v e t 2 [ i 1] + g e r a I n t ( 1 0 0 ) ; }
p r i n t f ( " \ n \ n Vetor 1
") ;
f o r ( i = 0 ; i < 20 ; i++ ) { p r i n t f ( "%d " , vet1 [ i ] ) ; }
") ;
f o r ( i = 0 ; i < 20 ; i++ ) { p r i n t f ( "%d " , vet2 [ i ] ) ; }
i =0; j =0; f o r ( k = 0 ; k < 40 ; k++ ) { i f ( i ==20) { vet3 [ k ] = vet2 [ j ] ; j ++; continue ; } i f ( j ==20) { vet3 [ k ] = vet1 [ i ] ; i ++; // V o l t a ao t o p o do f o r
76
48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67
continue ; }
i f ( vet1 [ i ] < vet2 [ j ] ) { vet3 [ k ] = vet1 [ i ] ; i ++; } else { vet3 [ k ] = vet2 [ j ] ; j ++; } }
") ;
f o r ( i = 0 ; i < 40 ; i++ ) { p r i n t f ( "%d " , vet3 [ i ] ) ; } p r i n t f ( "\n\n" ) ; }

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
// prog048 . c
int g e r a I n t ( int ) ; void imprimeMatriz ( int , int , i n t ) ; i n t m u l t i p l i c a M a t r i z e s ( int , i n t ) ;
i n t main ( ) {
i n t matrizUm [ 4 ] [ 6 ] , m a t r i z D o i s [ 6 ] [ 4 ] , m a t r i z P r o d u t o [ 4 ] [ 4 ] ;
int i , j , k ;
// Gera c a o da matrizUm f o r ( i = 0 ; i < 4 ; i++ ) { f o r ( j = 0 ; j < 6 ; j++ ) { matrizUm [ i ] [ j ] = g e r a I n t ( 1 0 ) ; } }
p r i n t f ( " \ n \ nMatriz Um \ n " ) ; f o r ( i = 0 ; i < 4 ; i++ ) {
77
26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73
f o r ( j = 0 ; j < 6 ; j++ ) { p r i n t f ( " % d \ t " , matrizUm [ i ] [ j ] ) ; } p r i n t f ( "\n" ) ; }
// Gera c a o da m a t r i z D o i s f o r ( i = 0 ; i < 6 ; i++ ) { f o r ( j = 0 ; j < 4 ; j++ ) { matrizDois [ i ] [ j ] = geraInt (10) ; } }
p r i n t f ( " \ n \ nMatriz Dois \ n " ) ; f o r ( i = 0 ; i < 6 ; i++ ) { f o r ( j = 0 ; j < 4 ; j++ ) { p r i n t f ( "%d\t" , matrizDois [ i ] [ j ] ) ; } p r i n t f ( "\n" ) ; }
// C a l c u l o da m a t r i z P r o d u t o f o r ( i = 0 ; i < 4 ; i++ ) { f o r ( j = 0 ; j < 4 ; j++ ) { matrizProduto [ i ] [ j ] = 0 ; f o r ( k = 0 ; k < 6 ; k++ ) { m a t r i z P r o d u t o [ i ] [ j ] += matrizUm [ i ] [ k ] m a t r i z D o i s [ k ] [ j ] ; } } }
p r i n t f ( " \ n \ nMatriz Produto \ n " ) ; f o r ( i = 0 ; i < 4 ; i++ ) { f o r ( j = 0 ; j < 4 ; j++ ) { p r i n t f ( "%d\t" , matrizProduto [ i ] [ j ] ) ; } p r i n t f ( "\n" ) ; }
int g e r a I n t ( int l i m i t e S u p e r i o r ) { int intGerado ; i n t G e r a d o = rand ( ) ; intGerado = intGerado % l i m i t e S u p e r i o r ; return ( i n t G e r a d o ) ; }
78

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45
// prog049 . c
int quantidade ( ) { int quantidadeDeValores ; p u t s ( " Entre com a quantidade de numeros que deseja ordenar : " ) ; s c a n f ( " % d " ,& q u a n t i d a d e D e V a l o r e s ) ; return ( q u a n t i d a d e D e V a l o r e s ) ; }
int g e r a I n t ( int l i m i t e S u p e r i o r ) { i n t numeroGerado = rand ( ) ; numeroGerado %= l i m i t e S u p e r i o r ; return ( numeroGerado ) ; }
void imprime ( i n t argNUmeros [ ] , i n t argQ ) { int i ; f o r ( i = 0 ; i < argQ ; i++ ) p r i n t f ( " % d " , argNUmeros [ i ] ) ; }
i n t main ( ) { i n t i , j , q , temp ; q = q u a n t i d a d e ( ) ; // q u a n t i d a d e de numeros do v e t o r
i f ( q <= 0 ) { p r i n t f ( " \ nERRO : quantidade negativa ou nula .\ n " ) ; return ( 0 ) ; }
i n t numeros [ q ] ;
// Gera v e t o r f o r ( i = 0 ; i < q ; i ++) numeros [ i ] = g e r a I n t ( 1 0 0 ) ;
p r i n t f ( " \ nVetor gerado :\ n " ) ; imprime ( numeros , q ) ; p r i n t f ( "\n" ) ;
// Ordena v e t o r em ordem c r e s c e n t e
79
46 47 48 49 50 51 52 53 54 55 56 57 58 59 60
f o r ( j = q1 ; j > 0 ; j ) { f o r ( i = 0 ; i < j ; i ++) { i f ( numeros [ i ] > numeros [ i +1]) { temp = numeros [ i ] ; numeros [ i ] = numeros [ i + 1 ] ; numeros [ i +1] = temp ; } } }
p r i n t f ( " \ nVetor ordenado :\ n " ) ; imprime ( numeros , q ) ; p r i n t f ( "\n" ) ;
Cap tulo 10
Perguntas e respostas
10.1 Perguntas e respostas
A seguir relacionaremos algumas perguntas e respostas r apidas.
10.1.1
% no printf
Como imprimir % no printf? A solu c ao e colocar %% Exemplo: printf(Imprimindo 10%%); A sa da ser a: Imprimindo 10%
Cap tulo 11
Resumo de Consulta para Provas

11.1 Dicas
= Um igual e atribui c ao, ou seja, x = 10; atribui o valor 10 ` a vari avel x = = Dois sinais de igual e compara c ao, ou seja, x = = 10 est a vericando se x e ou n ao igual a 10. Pode resultar em verdadeiro ou falso.
11.2
Programas
Algoritmo/Programa 11.1: if-else
1 2 3 4 5 6 7 8 9 10 11 12 13
i n t main ( ) { int a ; p r i n t f ( " \ nDigite um n u mero : " ) ; s c a n f ( " % d " ,&a ) ; i f ( a > 10) { p r i n t f ( "\n%d e maior que 10.\ n " , a ) ; } else { p r i n t f ( "\n%d e menor ou igual a 10.\ n " , a ) ; } }
Algoritmo/Programa 11.2: switch-case com char

1 2
// prog020 . c
11.2 Programas
82
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35
i n t main ( ) { char opcao ;
p r i n t f ( " \ nQual a raiz quadrada de 49?\ n " ) ; p r i n t f ( " \ n \ ta ) 4\ n \ tb ) 7\ n \ tc ) 9\ n \ td ) 6\ n \ te ) Nenhuma das respostas anteriores \ n " ) ;
p r i n t f ( " \ n \ tSua op c~ ao : " ) ;
// opcao = g e t c h a r ( ) ; s c a n f ( " % c " ,& opcao ) ;
e s t a l i n h a tem o mesmo funcionamento da
linha abaixo
switch ( opcao ) { case a : p r i n t f ( " \ n \ tVoc^ e marcou letra \" a \" e errou .\ n \ n " ) ; break ; case b : p r i n t f ( " \ n \ tVoc^ e marcou letra \" b \" e acertou .\ n \ n " ) ; break ; case c : p r i n t f ( " \ n \ tVoc^ e marcou letra \" c \" e errou .\ n \ n " ) ; break ; case d : p r i n t f ( " \ n \ tVoc^ e marcou letra \" d \" e errou .\ n \ n " ) ; break ; case e : p r i n t f ( " \ n \ tVoc^ e marcou letra \" e \" e errou .\ n \ n " ) ; break ; default : p r i n t f ( " \ n \ tOp ca ~ o inv a lida .\ n \ n " ) ; } }
Algoritmo/Programa 11.3: switch-case com int

1 2 3 4 5 6 7 8 9 10 11 12
// prog025 . c
i n t main ( ) {
i n t opcao , base , p o t e n c i a ;
p r i n t f ( "\n\n p r i n t f ( "\n p r i n t f ( "\n p r i n t f ( "\n
*** Menu *** " ) ; 2 - Pot^ e ncias de 3 - Pot^ e ncias de 5 - Pot^ e ncias de 2. " ) ; 3. " ) ; 5. " ) ;
11.2 Programas
83
13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48
p r i n t f ( "\n p r i n t f ( "\n p r i n t f ( "\n
10 - Pot^ e ncias de 10. " ) ; 15 - Pot^ e ncias de 15. " ) ; Sua op c~ ao : " ) ;
s c a n f ( " % d " , &opcao ) ;
switch ( opcao ) { case 2 : base = 2 ; break ; case 3 : base = 3 ; break ; case 5 : base = 5 ; break ; case 1 0 : base = 10; break ; case 1 5 : base = 15; break ; default : base = 10000; }
i f ( b a s e != 10000 ) { p r i n t f ( " \ n Pot^ e ncias de % d menores que 10000: " , b a s e ) ; f o r ( p o t e n c i a = b a s e ; p o t e n c i a < 10000 ; p o t e n c i a = b a s e ) p r i n t f ( "%d " , potencia ) ; p r i n t f ( "\n\n" ) ; } else { p r i n t f ( " \ n Op ca ~ o inv a lida .\ n " ) ; } //um s o comando d i s p e n s a as c h a v e s do f o r
Algoritmo/Programa 11.4: for

1 2 3 4 5 6 7 8 9
// prog021 . c
i n t main ( ) { int x ; float z ;
f o r ( x = 100 ; x != 65 ; x = x 5 ) {
11.2 Programas
84
10 11 12 13
z = x x; p r i n t f ( " \ nO quadrado de % d e %.0 f " , x , z ) ; } }
Algoritmo/Programa 11.5: for dentro de for

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
// prog026 . c
i n t main ( ) {
int i , j ;
f o r ( i = 0 ; i < 10 ; i++ ) { p r i n t f ( "\n" ) ; f o r ( j = 0 ; j < 10 ; j++ ) p r i n t f ( " \ t (% d , % d ) " , i , j ) ; }
p r i n t f ( "\n\n" ) ;
Refer encias Bibliogr acas

[1] Anita Lopes and Guto Garcia. Introdu c ao ` a programa c ao - 500 algoritmos resolvidos. Elsevier, Rio de Janeiro, 1. edition, 2002. [2] Herbert Schildt. Turbo C: guia do usu ario. McGraw-Hill, S ao Paulo, 2. edition, 1988. [3] Herbert Schildt. C, completo e total. Pearson Makron Books, S ao Paulo, 3. edition, 1997.

Algoritmos Jabour

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Algoritmos Jabour

Transféré par

Droits d'auteur :

Formats disponibles

Algoritmos Computacionais com aplica co es em C Bacharelado em Sistemas de Informa ca o Engenharia Mecatr onica IF Sudeste MG Filippe Jabour

17 de dezembro de 2012 http://www.jabour.com.br

1.6.6 1.6.7 1.6.8 1.6.9

Pre co do carro, impostos e lucro . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . C alculo de sal ario . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Saldo da conta ap os emiss ao de cheques . . . . . . . . . . . . . . . . . . . . . . . . . . . . Consumo de ra c ao de gatos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

1.6.10 Medida da escada enconstada . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

2 O comando if-else (se-sen ao) 2.1 2.2 Descri c ao e exemplos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Vericar se um n umero e positivo, negativo ou nulo

3 Switch-case (escolha-caso) 3.1 3.2 3.3

Descri c ao e exemplos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17 switch-case: aplica c oes em C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

4 For (para) 4.1 4.2 4.3

5 while e do-while (enquanto e fa ca-enquanto) 5.1 5.2 5.3

Imprimir todos menos os m ultiplos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36 Movimenta c ao banc aria . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36

6 String, vetor e matriz 6.1

Matriz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44 6.3.1 Matrizes de strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46

6.4.10 Soma dos elementos da diagonal principal . . . . . . . . . . . . . . . . . . . . . . . . . . . 49 6.4.11 Menu e matriz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49

7 Fun c oes 7.1 7.2 7.3

7.3.2 7.3.3 7.3.4 7.3.5 7.3.6 7.3.7

8 struct (Estrutura) 8.1 8.2 8.3 8.4

10.1 Perguntas e respostas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80 10.1.1 % no printf . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80

11 Resumo de Consulta para Provas

11.1 Dicas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81 11.2 Programas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81

Refer encias Bibliogr acas

Programa que cria e imprime uma vari avel inteira

9.3 9.4 9.5 9.6 9.7 9.8 9.9

11.5 for dentro de for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84

Gravidades relativas em outros planetas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

Pre co de passagens a ereas por regi ao . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35

1.3 Vari avel

1.4 Tipos de vari aveis atribui c ao de valores.

Tipos de vari aveis

i n cio int x ; int y ; i n t soma ; x = 8; y = 25; soma = x + y ; i m p r i m i r ( soma ) ; fim

Conceitos iniciais: aplica co es em C

#include < s t d i o . h>

Primeiros exemplos de programas em C

#include < s t d i o . h>

1.5 Conceitos iniciais: aplica c oes em C

/ Programa d e s e n v o l v i d o p e l o Prof . Jabour em mar c o de 2 0 1 1 . O programa soma d o i s n u meros , e x i b e a soma e o r e s u l t a d o /

#include < s t d i o . h>

i n t main ( ) { int a , b , c ; a = 10; b = 32; c = a + b; // e x e c u c a o do c alculo // i m p r e s s a o do r e s u l t a d o // d e c l a r a c a o de v a r i aveis

Os operadores aritm eticos s ao relacionados a seguir:

1.6 Exerc cios Propostos + Adi c ao Subtra c ao Multiplica c ao / Divis ao

#include < s t d i o . h>

i n t main ( ) { float a , b , c ; a = 8.4; b = 4.5; c = a b; p r i n t f ( " \ n %.1 f x %.1 f = %.1 f \ n " , a , b , c ) ; }

#include < s t d i o . h>

Exerc cios Propostos

1.6 Exerc cios Propostos

M edia aritm etica

Aumento de sal ario

Sal ario base com gratica c ao e impostos

Opera c oes com um n umero

Pre co do carro, impostos e lucro

C alculo de sal ario

Saldo da conta ap os emiss ao de cheques

Medida da escada enconstada

O comando if-else (se-sen ao)

se ( condi c ao ) { comando 1 ; comando 2 ; . . . comando n ; }

Tabela 2.1: Operadores relacionais

Signicado e ou nega c ao (n ao)

Tabela 2.2: Operadores l ogicos

i n cio int v a l o r ; ler ( valor ) ; s e ( v a l o r > 10 ) { imprima ( v a l o r ) } fim

se ( condi c ao ) { comando 1 ; comando 2 ; . . . comando n ; } sena o {

2.1 Descri c ao e exemplos