Bacharelado em
Sistemas de Informação
Programação
em Linguagem C
Parte 1 (básico)
Profa. Dra. Elisamara de Oliveira
2
Índice
Capítulo 1 ............................................................................................................................................... 4
O Conceito de Algoritmo ....................................................................................................................... 4
1.1. O que é um algoritmo? ................................................................................................................. 4
1.2. Conceitos Básicos da Programação de Computadores ................................................................... 6
1.3. O Conceito de Programação Estruturada ....................................................................................... 8
Capítulo 2 ............................................................................................................................................. 11
Expressão de Algoritmos ..................................................................................................................... 11
2.1. Expressão de Algoritmos através de Diagramas ........................................................................... 11
2.2. Expressão de Algoritmos através de Linguagem de Programação ................................................ 12
2.3. Expressão de Algoritmos através de Pseudo-linguagem .............................................................. 15
2.4. Nossa escolha: os algoritmos serão expressos em pseudo-linguagem ...................................... 16
Capítulo 3 ............................................................................................................................................. 17
Pseudo-linguagem de Programação: PortuCê .................................................................................... 17
3.1. Identificadores............................................................................................................................. 17
3.2. Tipos Básicos e Declaração de Variáveis ..................................................................................... 18
3.3. Comando de Atribuição............................................................................................................... 18
3.4. Operadores Aritméticos ............................................................................................................... 19
3.5. Operadores Lógicos..................................................................................................................... 20
3.6. Operadores Relacionais ............................................................................................................... 23
3.7. Comando Condicional ................................................................................................................. 24
3.8. Comando de Repetição ................................................................................................................ 26
3.9. Comandos de Entrada e Saída ..................................................................................................... 28
3.10. Separador de comandos ............................................................................................................. 30
3.11. Bloco de Programa .................................................................................................................... 31
Capítulo 4 ............................................................................................................................................. 35
Construção de Algoritmos em PortuCê: Praticando os comandos e fazendo cálculos...................... 35
4.1. Declaração de variáveis, comandos “leia” e “imprima” ............................................................... 35
4.2. Comando condicional “se” .......................................................................................................... 36
4.3. Bloco de Programa ...................................................................................................................... 37
4.4. Operações Básicas com Números ................................................................................................ 39
4.5. Operações com Operadores Lógicos e Relacionais ...................................................................... 42
Capítulo 5 ............................................................................................................................................. 46
Construção de Algoritmos em PortuCê: Usando Laços de Repetição .............................................. 46
5.1. Comando de repetição “enquanto” – Uso de flags – entrada indeterminada de dados ................. 46
5.2. Comando de repetição “enquanto” – entrada de dados determinada ............................................. 49
3
Capítulo 6 ............................................................................................................................................. 53
A linguagem de programação C .......................................................................................................... 53
6.1. Tipos Básicos e Declaração de Variáveis em C ........................................................................... 53
6.2. Operadores de Atribuição, Aritméticos, Relacionais e Lógicos (Binários) em C .......................... 54
6.3. Comando Condicional em C ........................................................................................................ 57
6.4. Comando de Seleção Múltipla em C ............................................................................................ 59
6.5. Comando de Repetição while em C ............................................................................................. 61
6.6. Comandos de Leitura e Escrita em C .......................................................................................... 62
6.7. Bloco de Programa em C ............................................................................................................ 64
6.8. Funções Úteis em C..................................................................................................................... 66
6.9. Tradução de PortuCê para a Linguagem C .................................................................................. 68
Capítulo 7 ............................................................................................................................................. 75
Construção de Programas em C: Metodologia para Desenvolvimento de Algoritmos ..................... 75
7.1. Os 10 passos da metodologia ....................................................................................................... 75
7.2. Exemplo dos Impulsos Telefônicos ............................................................................................ 77
7.3. Exemplo do Preço Final de Automóveis ..................................................................................... 80
7.4. Exemplo da Eleição .................................................................................................................... 83
7.5. Exemplos de Programas em C .................................................................................................... 86
Respostas de Alguns Exercícios ........................................................................................................... 97
1ª aula Prática em Laboratório ......................................................................................................... 111
Estudo Dirigido .................................................................................................................................. 111
4
Capítulo 1
O Conceito de Algoritmo
Em nosso dia-a-dia executamos mecanicamente uma série de ações que são seguidas
seqüencialmente e que provocam o acontecimento de algo. Por exemplo, temos um trajeto freqüente ao
sairmos diariamente de casa em direção ao nosso trabalho ou à nossa universidade que, sempre que
seguido, nos leva ao nosso destino. Isso é um algoritmo. Em outras palavras, um algoritmo descreve
eventos com duração finita, que envolvem um conjunto de objetos cujas características podem ser
alteradas, através de ações que ocorrem seqüencialmente.
1.1. O que é um algoritmo?
"Programar é construir algoritmos"
"Programa = Algoritmo + Estruturas de Dados"
"No processo de construção de programas a formulação do algoritmo e a definição das estruturas de
dados estão intimamente ligadas"
Num algoritmo podem-se observar os seguintes aspectos:
- Ação: evento que ocorre num período de tempo finito
- Estado: propriedades de um objeto numa dada situação
- Processo: seqüência temporal de ações
- Padrão de comportamento: toda vez que é seguido, um evento ocorre
Exemplo de um algoritmo: Algoritmo para fazer " batatas fritas para o jantar "
"Traga a cesta com batatas da despensa" ;
"Traga a panela do armário";
“Coloque óleo na panela”;
Se "a roupa é clara”
então
"coloque o avental";
Enquanto "nº de batatas é insuficiente para o número de pessoas"
"descasque as batatas";
“Pique as batatas”;
“Esquente o óleo da panela”;
"Frite as batatas na panela";
“Escorra o excesso de óleo das batatas fritas”;
"Coloque as batatas fritas numa vasilha com papel absorvente".
faça
5
Apesar de muito simples, algumas observações importantes podem ser notadas neste algoritmo:
tempo verbal está na forma imperativa (“faça”, “traga”, “frite”, etc);
Há um seqüenciamento das ações, que estão separadas por um ponto-e-vírgula “;”;
avental não é usado toda vez: existe um motivo para colocá-lo, ou seja, há uma condição para
que o avental seja colocado;
número de batatas descascadas varia; a ação de “descascar uma batata” repete-se até que a
condição de parada (ser suficiente para alimentar as pessoas que irão jantar) seja alcançada;
A ordem das ações é importante: primeiro descasca-se a batata, pica-se a batata, para depois
fritá-la...
Exemplos de algoritmos conhecidos:
- Qual é o algoritmo que você descreve para vir estudar?
- Qual é o algoritmo para se fazer uma feijoada?
Apesar de receitas culinárias e trajetos rotineiramente percorridos encaixarem-se perfeitamente no
conceito inicial de algoritmo, no nosso curso estamos interessados num tipo de algoritmo especial, que
seja capaz de ser executado por um computador. Para tanto, é necessário que identifiquemos problemas
do mundo real que possam ser traduzidos em ações primitivas finitas e dos quais se possa extrair um
padrão de comportamento.
Qual o padrão de comportamento utilizado para gerar as seqüências?
1, 5, 9, 13, 17, 21, 25 ...
1, 1, 2, 3, 5, 8, 13, 21, 34 ...
Os dois exemplos anteriores são problemas do mundo real que, por serem finitos (ou para os quais se
possa determinar uma condição de parada) e por possuírem um padrão de comportamento, podem ser
resolvidos através de um programa de computador. No entanto, antes de se chegar ao programa de
computador, o 1º passo é fazer um algoritmo que seja capaz de solucionar o problema em questão....
Definição de algoritmo:
Um algoritmo é a descrição de um padrão de comportamento, expresso em termos de um
repertório bem definido e finito de ações primitivas que podem ser executadas
Num algoritmo distinguem-se claramente dois aspectos:
- Aspecto estático: texto
- Aspecto dinâmico: sua execução
(a partir de valores iniciais)
O curso de Algoritmos é, na realidade, um curso de Programação de Computadores para alunos que
iniciam cursos superiores na área de Informática. Para começarmos a construir algoritmos e fazermos
nossos primeiros programas de computador, é necessário que o aluno domine uma série de conceitos
básicos, que são apresentados a seguir, a começar pelo próprio computador!
6
1.2. Conceitos Básicos da Programação de Computadores
Computador: é uma máquina capaz de seguir uma espécie de
algoritmo chamado programa que está escrito em linguagem de máquina.
Linguagem de máquina: internamente o computador executa
uma série de instruções que ficam armazenadas em sua memória
principal em código binário, ou seja, em linguagem de máquina (zeros
(0) e uns (1) que são os dígitos binários ou bits).
Linguagem de alto nível: para escrever os programas de computador, os programadores utilizam
linguagens que estão mais próximas da linguagem humana, que são chamadas de linguagens de alto nível
ou simplesmente linguagens de programação. Exemplos de linguagens de programação (alto nível) são
Pascal, C, C++, Basic, Fortran, dentre muitas outras.
Linguagem de montagem: há programas de computador que precisam interferir diretamente no
hardware da máquina para permitir a execução de funções específicas como as oferecidas por sistemas
operacionais, por exemplo. Neste caso, os programadores utilizam as linguagens de montagem ou
linguagens assembly, que estão muito próximas da linguagem de máquina e mais distantes das linguagens
de programação, sendo por isso chamadas de linguagem de baixo nível.
A figura 1 mostra a relação entre as linguagens discutidas anteriormente. Numa ponta está a linguagem
de máquina e no outro extremo estão as linguagens humanas. Quanto mais próxima da linguagem de
máquina, mais de “baixo nível” é a linguagem; em contrapartida, quanto mais próxima das linguagens
humanas, mais “alto nível”. As linguagens de programação fazem uma espécie de ponte entre a
linguagem binária ou linguagem que o computador entende e a linguagem que nós humanos utilizamos.
Figura 1
Relação entre linguagens de baixo e de alto nível
Compilador: permite que os programadores utilizem linguagens de alto nível para escrever os
programas de computador, pois se encarrega de traduzi-los para linguagem de máquina. O compilador é
um programa que traduz uma determinada linguagem de programação para linguagem de máquina. Desta
forma, existem diversos compiladores específicos para cada uma das linguagens de programação e
específicos para cada sistema operacional, conforme ilustra a figura 2. Um compilador C para o sistema
Windows 98 (compilador X) é diferente de um compilador C para o sistema Unix (compilador Y),
embora a linguagem de programação seja a mesma (linguagem de alto nível). O compilador de linguagem
de montagem ou linguagem assembly é chamado de assembler.
7
Programa escrito em linguagem de alto nível
Compilador X
Programa em
Linguagem de
Máquina para
o Computador
X
Compilador Y
Programa em
Linguagem de
Máquina para
o Computador
Y
Compilador Z
Programa em
Linguagem de
Máquina para
o Computador
Z
Figura 2
Os compiladores são específicos para cada linguagem e para cada sistema operacional
O ciclo completo da elaboração do algoritmo à execução de um programa de computador pode ser
visto na figura 3. Cada um dos componentes deste ciclo é explicado a seguir.
algoritmo
editor
código
fonte
compilador
arquivos de
biblioteca
código
objeto
linker
executável
Figura 3
Do algoritmo à execução de um programa de computador
Algoritmo: estrutura do programa; instruções que descrevem a lógica do programa
Editor de texto: permite que o código fonte do programa seja editado em um arquivo-fonte. Alguns
compiladores têm editores com ambiente de programação integrados, como é o caso do Turbo Pascal e do
Turbo C.
Código fonte: conjunto de comandos escritos na linguagem de programação escolhida (como Pascal, C,
Java, C++, etc). O código fonte fica armazenado no arquivo-fonte em formato ASCii, ou seja, em texto.
(O arquivo-fonte possui a extensão relativa à linguagem de programação usada, por exemplo, .pas
(Pascal), .c (C), .cpp (C++), .cs (C#), .java (Java)).
8
Compilador: lê o código fonte do programa e cria um outro arquivo em linguagem binária ou de
máquina.
Código objeto: arquivo resultante da compilação do código fonte. Contém informações sobre alocação
de memória, os símbolos do programa (como nomes de variáveis e de funções) e também informações
sobre debug. (O arquivo-objeto possui a extensão .obj para a maioria das linguagens de programação).
Arquivos de biblioteca: contém funções já compiladas que podem ser utilizadas no programa.
Linker: cria um programa executável a partir de arquivos-objeto e dos arquivos de biblioteca.
Código executável: programa que pode ser executado no computador (o arquivo-executável possui a
extensão .exe).
1.3. O Conceito de Programação Estruturada
Para conseguirmos construir programas de computador, é necessário cumprir as 5 etapas básicas da
programação, das quais a confecção do algoritmo é extremamente importante.
As 5 etapas da programação de computadores são:
1. Identificação de um problema do mundo real
2. Confecção do algoritmo
3. Teste do algoritmo
4. Confecção do programa de computador
5. Execução do programa no computador
Para realizarmos este ciclo de etapas com sucesso, quer dizer, para conseguirmos fazer programas de
computador com qualidade e confiáveis, é muito importante a utilização de técnicas programação como a
programação estruturada.
A programação estruturada é uma metodologia de projeto e desenvolvimento, que pretende:
- facilitar a escrita;
- facilitar o entendimento;
- permitir a verificação;
- facilitar a alteração e a manutenção dos programas de computador
O principal objetivo da metodologia de programação estruturada é reduzir a complexidade dos
problemas.
"A arte de programar consiste na arte de organizar e dominar a complexidade.”
A metodologia de programação estruturada, quando utilizada, induz o programador a produzir
programas:
- confiáveis
- de fácil manutenibilidade
- flexíveis
- documentados
- legíveis
9
Exemplo de Programa Estruturado
1
2
3
4
Programa 1
Programa 2
read idade
if (idade .gt. 17) goto 3
if (idade .gt. 12) goto 2
if (idade .gt. 8) goto 1
print “Você é uma criança”
goto 4
print “Você é pré-adolescente”
goto 4
print “Você é um adolescente”
goto 4
print “Você é um adulto”
continue
leia(IDADE);
se IDADE > 17 //pessoa tem mais de 17 anos
então imprima (“Você é um adulto”)
senão se IDADE > 12 //pessoa tem entre 13 e 17 anos
então imprima (“Você é um adolescente”)
senão se IDADE > 8 //pessoa entre 9 e 12 anos
então imprima (“Você é pré-adolescente”)
senão imprima (“Você é uma criança”);
- Os dois programas fazem a mesma coisa. Tente entender o que eles fazem. Qual dos dois programas o
ajudou mais a entender a sua lógica?
- Com certeza o programa 2 facilitou muito mais o seu entendimento... E o motivo principal é que o
programa 2 é um programa estruturado e o programa 1 não é estruturado. Veja as principais diferenças
entre eles:
Programa não estruturado
Programa estruturado
- uso excessivo de gotos
- não usa gotos
(goto é um comando de desvio incondicional, e seu uso é muito indesejável pois quebra o fluxo de
execução seqüencial das instruções do programa)
- difícil de entender
- fácil de entender
- ilegível
- legível
- difícil de testar
- de fácil teste
(faça alguns testes com idades diferentes e veja qual dos dois programas é mais fácil de ser testado...)
- fluxo de controle não seqüencial
- fluxo de controle seqüencial
- não usa comentários
- usa comentários
(os comentários não fazem parte do código, mas facilitam o seu entendimento e contribuem para a
documentação do código implementado)
10
Resposta dos Exercícios
Qual o padrão de comportamento utilizado para gerar as seqüências?
1, 5, 9, 13, 17, 21, 25 ...
A série de números começa com 1 (primeiro termo)
Para se gerar o segundo termo soma-se 4 ao primeiro número
Para se gerar qualquer um dos outros termos da série, basta somar 4 ao número imediatamente
anterior
Esta é uma série infinita. Seu fim deve ser determinado por uma condição do tipo “gerar os 10
primeiros termos da série” ou “gerar todos os termos da série menores que 100”
1, 1, 2, 3, 5, 8, 13, 21, 34 ...
A série de números começa com 1 (primeiro termo)
O segundo termo também é 1
Para se gerar qualquer um dos outros termos da série, basta somar os dois termos imediatamente
anteriores
Exemplos: 1 (primeiro termo) + 1 (segundo termo) =2 (terceiro termo)
1 (segundo termo) + 2 (terceiro termo) = 3 (quarto termo)
2 (terceiro termo) + 3 (quarto termo) = 5 (quinto termo)
Esta é uma série infinita, conhecida como série de Fibonacci. Seu fim deve ser determinado por
uma condição do tipo “gerar os 10 primeiros termos da série” ou “gerar todos os termos da série
menores que 100”.
11
Capítulo 2
Expressão de Algoritmos
Os algoritmos podem ser expressos através de diagramas, através de pseudo-linguagens ou através
da própria linguagem de programação. Vamos examinar cada uma destas três opções e, no final deste
capítulo, vamos optar por uma delas para que possamos começar a fazer nossos primeiros algoritmos!
2.1. Expressão de Algoritmos através de Diagramas
A utilização de diagramas para a expressão de algoritmos foi
bastante utilizada até a década de 1980. Diagramas de Chapin e fluxogramas
foram os principais métodos utilizados, então. Nos métodos baseados em
diagramas, uma grande variedade de formas geométricas como quadrados, retângulos, hexágonos,
pentágonos, etc., são utilizadas para representar as instruções de leitura e impressão de dados, assim como
os comandos condicionais, de repetição, etc. Além disso, uma série de regras para a disposição dessas
formas e/ou setas para representar o seqüenciamento das instruções fazem parte desses métodos.
Apesar de terem sido utilizados largamente pelas primeiras gerações de programadores, estes
métodos apresentam uma série de inconveniências como:
O programador tem que memorizar todas as formas geométricas e conhecer as regras de interrelacionamento entre elas;
O programador perde um tempo considerável para fazer e refazer desenhos, tendo que possuir
diversas réguas com os símbolos dos diagramas;
Para algoritmos muito grandes, os desenhos começam a ocupar muitas páginas, tornando
impraticável a visualização de toda a solução;
A memorização de regras de expressão desvia a atenção do programador que não tem apenas de se
concentrar na lógica do problema, como seria desejável, mas tem as preocupações adicionais de
elaborar desenhos e consultar regras e regras...
Além de todos os inconvenientes citados, que de longe esgotam os seus problemas, os métodos
baseados em diagramas se distanciam muito do alvo da programação que é a expressão da lógica
algorítmica na própria linguagem de programação! Além disso, esses métodos não são nem um pouco
intuitivos... veja a figura 1 e tente descobrir o que o programa faz... sem muito esforço, se for possível:
Figura 1
Algoritmo expresso através de um diagrama de Chapin
12
Exemplo de um Fluxograma
A figura 2 mostra um exemplo de um algoritmo expresso através de um fluxograma. Observe a
existência de diferentes formas geométricas para as diferentes instruções e o uso de setas para representar
o fluxo dos dados. Você seria capaz de dizer o que este algoritmo faz? Quais as variáveis que ele utiliza e
de que tipo básico elas são? (Dica: este algoritmo faz a mesma coisa que o expresso pelo diagrama de
Chapin mostrado na figura 1).
Figura 2
Algoritmo expresso através de um Fluxograma
2.2. Expressão de Algoritmos através de Linguagem de Programação
Expressar um algoritmo através de uma linguagem de programação é o objetivo,
a meta do programador, com certeza. Mas, isso é feito quando o programador já
adquiriu bastante experiência de programação, quer dizer, quando o programador já
consegue programar diretamente da linguagem de programação. Os programadores
iniciantes podem ter grandes dificuldades para aprenderem a programar se forem direto
às instruções da linguagem de programação...
Uma linguagem de programação permite, além da expressão do raciocínio algorítmico, a sua
execução no computador (por causa do compilador, com já aprendemos). Embora as linguagens de
programação sejam chamadas de linguagens de alto nível, devido à sua proximidade com a linguagem
13
humana, suas instruções vêm em inglês... O inglês é uma das diversas linguagens humanas, claro, mas
pode oferecer um certo desconforto aos estudantes, principalmente aos que falam português, como é o
nosso caso...
Existem diversas linguagens de programação. Cada uma pode ser mais adequada à resolução de
problemas específicos, e recebem alguns rótulos por isso, como linguagens para aplicações científicas,
linguagens para desenvolvimento de software básico, linguagens para utilização intensiva de recursos
gráficos, para manipulação de bancos de dados, etc, etc, e... linguagens para o ensino de programação!
Veja a figura 3. É um código escrito em Pascal.
PROGRAM MenorValor;
{ Este programa seleciona o menor número em uma seqüência de
números inteiros}
VAR
Valor, Menor: INTEGER;
BEGIN
WRITE(‘Forneça um número inteiro: ’);
READLN(Valor);
Menor := Valor;
WHILE Valor <> -1 DO
BEGIN
IF Valor < Menor
THEN Menor := Valor;
WRITE(‘Forneça um número inteiro (flag=-1): ’);
READLN(Valor);
END; {while}
WRITELN(‘O menor valor lido foi: ’, Menor);
END.
Figura 3
Algoritmo expresso na Linguagem de Programação Pascal
A figura 3 mostra um algoritmo expresso na linguagem de programação Pascal, ou seja, já é um
programa de computador. Observe a estrutura do programa: começa com PROGRAM, depois tem a seção
VAR na qual as variáveis são declaradas e depois vêm as instruções contidas entre o BEGIN (início) e o
END. (fim.). Você seria capaz de dizer o que este algoritmo faz? Quais as variáveis que ele utiliza e de que
tipo básico elas são? (Dica: este programa faz a mesma coisa que o expresso pelo diagrama de Chapin e
pelo fluxograma mostrados nas figuras 1 e 2).
Agora observe o exemplo de um programa escrito na linguagem de programação C.
14
/* Este programa seleciona o menor número em uma seqüência de
números inteiros */
#include <stdio.h>
int
valor, menor;
void main (void)
{ printf (“\n Forneça um número inteiro:
”);
scanf (“%i”, &valor);
menor = valor;
while (valor != -1)
{ if (valor < menor)
menor = valor;
printf(“\nForneça um número inteiro (–1 para terminar):
scanf (“%i”, &valor);
}
printf (“O menor valor lido foi: %i ”, menor);
}
”);
Figura 4
Algoritmo expresso na Linguagem de Programação C
A figura 4 mostra um algoritmo expresso na linguagem de programação C, ou seja, também é um
programa de computador. Observe a estrutura do programa: começa com um comentário, depois tem a
inclusão de uma biblioteca de funções, depois a declaração das variáveis e em seguida vem a seção main
na qual as instruções do programa estão contidas entre o { (início) e o } (fim). Você seria capaz de dizer
o que este algoritmo faz? Quais as variáveis que ele utiliza e de que tipo básico elas são? (Dica: este
programa faz a mesma coisa que o expresso pelo diagrama de Chapin, pelo fluxograma e pelo programa
Pascal mostrados nas figuras 1, 2 e 3).
O programa traz um comentário dizendo explicitamente o que ele faz. Portanto, garanto que você
conseguiu responder à primeira pergunta. Com relação às variáveis que o programa utiliza e seu tipo
básico, observe a declaração “int valor, menor;” no programa. Há duas variáveis ali declaradas:
valor e menor... o tipo básico é int ... um pouquinho de imaginação e int = inteiro!
Que tal você comparar o código C com o código Pascal? Semelhanças? Qual dos dois lhe pareceu
mais fácil de entender?
Bem, se sua resposta foi o código Pascal, digo-lhe que o Pascal tem o "rótulo" de linguagem mais
adequada ao ensino de programação... Se sua resposta foi o código C, saiba que é uma linguagem que foi
criada para ser utilizada por programadores experientes... Mas... se você teve dificuldade de entender
ambos os códigos, não se preocupe! O curso está apenas começando e há muito o que se aprender de
lógica de programação! Garanto que no final do curso este programa vai parecer muito, muito fácil para
você!
15
2.3. Expressão de Algoritmos através de Pseudo-linguagem
Uma pseudo-linguagem é uma notação para expressão de algoritmos para ser
utilizada nas 3 primeiras etapas da programação definidas na seção 1.3 da primeira
lição, quais sejam, identificação de um problema do mundo real, confecção e teste do algoritmo. É
apresentada na forma de português estruturado. Embora seja uma pseudo-linguagem, possui estrutura,
sintaxe e semântica semelhantes às de uma linguagem de programação.
A principal diferença entre a pseudo-linguagem e a linguagem de programação é que a primeira
não possui um compilador. Isso significa que é possível expressar o raciocínio algorítmico utilizando-se
uma pseudo-linguagem, mas o programa não pode ser executado no computador.
São muitas as vantagens de se utilizar uma pseudo-linguagem para escrever algoritmos:
É uma linguagem independente de máquina; o programador pensa somente no problema a
ser resolvido sem se preocupar com possíveis restrições do compilador ou do hardware
(computador);
O programador tem que conhecer a sintaxe, a semântica e a estrutura da pseudolinguagem, mas tem total liberdade para criar novos comandos ou usar instruções em alto
nível (ou em forma de frases): por um lado ele vai se acostumando com a rigidez da
sintaxe das linguagens de programação, mas por outro lado, tem a liberdade de expressar
seu raciocínio sem esbarrar em limitações de contexto;
Uma vez estando pronto o algoritmo na pseudo-linguagem, a sua implementação no
computador (etapas 4 e 5 da programação: confecção e execução do programa) fica muito
facilitada, pois toda a lógica já foi desenvolvida e testada e somente uma tradução para a
linguagem de programação-alvo se faz necessária.
Veja o exemplo de um algoritmo escrito na pseudo-linguagem PortuCê.
/* Este programa seleciona o menor número em uma seqüência de
números inteiros */
int
valor, menor;
principal( )
{ imprima (“Forneça um número inteiro:
”);
leia (“%i”, &valor);
menor = valor;
enquanto (valor != -1)
{ se (valor < menor)
menor = valor;
imprima (“Forneça um número inteiro(–1 para terminar):
leia (“%i”, &valor);
}
imprima(“O menor valor lido foi: %i ”, menor);
}
Figura 5
Algoritmo expresso na pseudo-linguagem de PortuCê
”);
16
A figura 5 mostra um algoritmo expresso na pseudo-linguagem PortuCê. Observe a estrutura do
algoritmo: começa com um comentário dizendo o que o algoritmo faz, tem a declaração das variáveis e
depois vem a seção principal ( ) em que são apresentadas as instruções contidas entre o { (início)
e } (fim) do algoritmo. Você seria capaz de dizer o que este algoritmo faz? Quais as variáveis que ele
utiliza e de que tipo básico elas são? (Dica: este algoritmo faz a mesma coisa que o expresso pelo
diagrama de Chapin, pelo fluxograma, pela linguagem Pascal e pela linguagem C mostrados nas figuras
1, 2, 3 e 4).
Este algoritmo em PortuCê corresponde ao programa em C mostrado no exemplo 2.3. Observe a
grande semelhança entre eles. Essa semelhança é proposital, com certeza. O PortuCê é quase que a
tradução de um programa C para o português. As vantagens de se utilizar o PortuCê são muitas. Pense
sobre elas, pois o PortuCê será nosso maior aliado no aprendizado de algoritmos!
Um exercício interessante para você fazer agora, seria visitar os exemplos deste algoritmo escritos
no diagrama de Chapin e no fluxograma e compará-los com o PortuCê... Diga-me qual deles é mais fácil
de entender? Qual dessas formas de expressão de algoritmos você escolheria?
2.4. Nossa escolha: os algoritmos serão expressos em pseudo-linguagem
Como eu disse no início desta lição, após conhecermos as 3 formas de expressão de algoritmos,
faríamos nossa escolha. E aqui está o veredito: usaremos pseudo-linguagem! Espero que você esteja de
acordo comigo. As justificativas dessa nossa escolha são muitas e foram já fundamentadas. A pseudolinguagem PortuCê utiliza o português, numa forma estruturada, e tem estrutura, sintaxe e semântica
muito semelhantes às da linguagem de programação C.
Apesar do Pascal ter se consagrado como uma linguagem adequada para o ensino da programação
aos estudantes que a iniciam, ou seja, como primeira linguagem de programação, a linguagem C, antes
restrita à comunidade científica, ganhou uma popularidade inquestionável na década de 1990, que se
estende aos dias atuais, pois é a base de novas linguagens e paradigmas. Em função disto, a linguagem C
passou a ser alvo do interesse dos estudantes. A resistência em utilizá-la como primeira linguagem de
programação pelos professores, se deveu, em parte, ao fato de seus criadores, Dennis Ritchie e Brian
Kernighan, terem afirmado que “C retém a filosofia básica de que os programadores sabem o que estão
fazendo”1. Bem, se considerarmos que programadores iniciantes não têm condições de saber com
segurança o que estão fazendo, exatamente pelo fato de serem inexperientes, a adoção da linguagem seria
realmente questionável.
No entanto, as linguagens de programação evoluíram bastante e as mais utilizadas hoje, como o
Java e o C#, têm como base a linguagem C. Além disso, a adoção de um método adequado e coerente
para o ensino da programação de computadores pode atuar como um facilitador do processo de
aprendizagem, permitindo que uma linguagem mais complexa, como o C, possa ser ensinado sem
oferecer obstáculos à aprendizagem.
Assim, a adoção do PortuCê, nossa pseudo-linguagem, e da metodologia de ensino proposta pela
professora, viabiliza a adoção da linguagem de programação C como primeira linguagem. Isso vai ao
encontro das expectativas dos estudantes e coloca o ensino da programação na direção da atual tendência
da programação de computadores que vem utilizando, cada vez mais, o C como base dos novos e
modernos paradigmas de programação.
O PortuCê, além de oferecer o conforto de utilizar nossa língua-pátria, o que o torna muito
familiar ao programador, não requer a memorização das abomináveis formas geométricas e setas e mais
setas dos diagramas... Fique tranqüilo, meu estudante, mais duas lições e você já estará fazendo seus
primeiros programas de computador!
1
Kernighan, B. , Ritchie, D. C- A Linguagem de Programação Padrão ANSI, São Paulo: Campus, 1989.
17
Capítulo 3
Pseudo-linguagem de Programação: PortuCê
3.1. Identificadores
Todo programa de computador manipula dados que são armazenados em variáveis. Uma variável
precisa ter um nome que a identifique de forma única no programa: é o identificador.
Um identificador em PortuCê é formado por caracteres alfanuméricos.
O primeiro caracter tem que ser uma letra; os outros caracteres podem ser:
letras: A-Z, a-z
dígitos: 0-9
sublinhado: _
Não pode haver dois identificadores iguais.
Letras minúsculas e letras maiúsculas são diferentes
Os identificadores não podem ser acentuados.
Não pode haver espaço em branco num identificador.
O caracter “ç” não pode ser usado num identificador.
Um identificador não pode ter o mesmo nome das palavras reservadas do PortuCê
(como principal, se, senão, inteiro, real...).
Exemplos de identificadores válidos:
NOME, raiz1, letra4, Total_dos_Salarios, Nome_de_Familia
Exemplos de identificadores inválidos:
4pontos
(começa com número)
CUSTO FINAL
(tem espaço em branco)
PreçoTotal
(caracter “ç” não pode ser usado)
Pessoa+Alta
(caracter “+” não pode ser usado)
Preco-caro
(caracter “-” não permitido)
Total_dos_salários
(palavra acentuada)
inteiro
(palavra reservada do PortuCê)
18
3.2. Tipos Básicos e Declaração de Variáveis
Os dados manipulados por um programa são armazenados em variáveis. As variáveis precisam ter
um nome (identificador), um tipo associado e precisam ser declaradas antes que possam ser utilizadas.
Há três tipos básicos que podem ser associados às variáveis:
inteiro
real
caracter
Para se declarar uma variável escreve-se o nome de seu tipo, salta-se um espaço em
branco, em seguida o nome do seu identificador e “;” para finalizar a declaração.
Se mais de uma variável for do mesmo tipo básico, elas podem ser declaradas juntas,
apenas separadas por vírgulas “,”.
Toda variável precisa ser declarada antes de ser utilizada.
Não pode haver duas variáveis com mesmo nome, mesmo que tenham tipos básicos
diferentes, a menos que algum caracter maiúsculo ou minúsculo as diferencie.
Exemplo de declaração de variáveis válido:
caracter NOME[20], letra;
inteiro soma;
real raiz1, Total_dos_Salarios;
caracter Nome_de_familia[30];
Exemplo de declaração de variáveis INVÁLIDO:
caracter NOME[20]; letra4;
(o separador de identificadores deve ser a vírgula)
inteiro: SOMA;
( não pode haver o sinal de dois-pontos após o nome do tipo)
raiz1, Total_dos_Salarios real;
(o tipo básico deve vir antes dos identificadores)
carater Nome_de_Familia[30];
(o nome do tipo básico está errado)
real SOMA;
(a variável SOMA já foi declarada: um identificador não pode ser duplicado)
3.3. Comando de Atribuição
O conteúdo das variáveis do programa pode ser determinado através dos comandos de atribuição e
de leitura. O comando de atribuição permite que um determinado valor seja armazenado numa variável.
O símbolo do comando de atribuição é =
Pode-se atribuir a uma variável um valor que NÃO seja compatível com o tipo
básico desta variável, ou seja, números inteiros podem ser atribuídos a variáveis do
tipo caracter ou real, números reais podem ser atribuídos a variáveis do tipo caracter
ou inteiro, etc. Mas, muito cuidado, pois neste tipo de atribuição ocorre a
CONVERSÃO AUTOMÁTICA DE TIPOS e o que chega na variável de
destino pode ser um desastre!
Toda variável deve ter um valor a ela atribuído antes de ser usada no programa
Em variáveis reais, SÓ EXISTE PONTO DECIMAL; não se pode usar vírgula
19
Exemplos de atribuições válidas:
letra4 = ‘L’;
Soma = 0;
Total_dos_Salarios = 1275.50;
NOME = “Luiza”;
Exemplos de atribuições INVÁLIDAS:
NOME = Maria;
NOME = ‘Maria’;
(a cadeia de caracteres tem que estar entre “ ” )
(o símbolo que delimita a cadeia de caracteres não pode ser apóstrofo)
Total_dos_Salarios = ‘1275.50’;
(o valor a ser atribuído a uma variável numérica não pode estar entre apóstrofos, senão
ocorrerá uma conversão automática)
NumeroInteiro = 10.0;
(numa variável do tipo INTEIRO não pode haver parte decimal; este caso está sujeito à
conversão automática)
(o símbolo do comando de atribuição é = e não :=)
SOMA := 0;
3.4. Operadores Aritméticos
Os operadores aritméticos permitem que expressões da Matemática sejam atribuídas às variáveis.
Os operadores aritméticos implementam as operações básicas (adição, subtração, divisão e multiplicação)
e algumas operações mais avançadas da Matemática (logaritmo, raiz quadrada, seno, cosseno...). A
variável que vai receber o resultado de uma operação aritmética tem que ser de um tipo numérico
compatível, capaz de armazenar o valor resultante, senão ocorrerá a conversão automática com resultados
muitas vezes indesejados ou mesmo imprevisíveis.
Os operadores aritméticos básicos são:
+ (adição)
- (subtração)
* (multiplicação)
/ (divisão real)
++ ( adiciona 1)
--
(subtrai 1)
Alguns operadores aritméticos mais avançados são:
% (resto da divisão inteira)
/ (quociente da divisão inteira)
sqrt( ) (raiz quadrada)
abs( ) (valor absoluto)
20
Exemplos de expressões aritméticas válidas:
Resto = 10 % 3;
Quociente = 10 / 3;
Salario = ((TotaldeHoras*32.50)+102.00) - DescontoINSS;
ValoremDolares = Salario / 2.55;
ImpostodeRenda = Salario * (0.20);
Nome = Nome + “da Silva”;
Contador = Contador +1;
++Contador;
--Contador;
Raiz = sqrt(numero);
Exemplos de expressões aritméticas INVÁLIDAS:
Resto = 10.0 % 3;
(o operador % só pode envolver números inteiros)
Salario = TotaldeHoras *+ 32.50;
(os operadores * e + são diádicos, envolvem sempre dois operadores, portanto não
podem ser utilizados juntos)
ValoremDolares = Salario / 2,55;
(não existe vírgula decimal, o separador é sempre o ponto “.”)
Nome = Nome * 3;
(em variáveis do tipo CARACTER só pode ser feita adição ou subtração de caracteres)
Contador = *1;
(o operador * é diádico, tem que envolver dois operandos)
3.5. Operadores Lógicos
Os operadores lógicos permitem que os três principais operadores da Álgebra de Boole possam ser
utilizados num programa: E, OU e NÃO. O estado dos operandos e o resultado de uma operação lógica é
sempre FALSO (avaliado como zero) ou VERDADEIRO (avaliado como diferente de zero).
Os operadores lógicos são:
e
(conjunção)
ou
(disjunção)
!
(negação)
O operador binário “e” envolve sempre dois operandos e o resultado é
VERDADEIRO somente quando ambos os operandos são VERDADEIROs, ou seja,
basta que um operando seja FALSO para que o resultado seja FALSO.
O operador binário “ou” envolve sempre dois operandos e o resultado é FALSO
somente quando ambos os operandos são FALSOs, ou seja, basta que um operando
seja VERDADEIRO para que o resultado seja VERDADEIRO.
O operador unário “!” muda o estado do operando de FALSO para
VERDADEIRO ou de VERDADEIRO para FALSO.
21
•
Uma variável lógica é aquela que pode assumir apenas os valores VERDADEIRO ou FALSO.
•
Na prática, as variáveis lógicas são utilizadas para descrever o funcionamento de um sistema,
como um circuito formado por uma bateria e uma lâmpada:
•
A representação dos níveis lógicos (1=verdadeiro e 0=falso) pode ser melhor entendida através de
chaves que representam um circuito:
•
Uma função “E” resulta em 1=VERDADEIRO se, e somente se, todas as variáveis lógicas de
entrada tiverem valor 1=VERDADEIRO. Em outras palavras: a lâmpada do circuito só acende se
ambas as chaves estiverem fechadas. (Na função E somente se ambas as entradas forem
verdadeiras, a expressão é avaliada como verdadeira).
•
•
22
Uma função “OU” resulta em 1=VERDADEIRO se pelo menos uma das variáveis lógicas de
entrada tiverem valor 1=VERDADEIRO. Em outras palavras: a lâmpada acende se uma das
chaves estiver fechada ou quando as duas estiverem fechadas (forem verdadeiras). (Na função OU
basta que uma entrada seja verdadeira para a expressão ser avaliada como verdadeira).
Uma função “!” (não) é uma operação de inversão. Ela converte o estado ou valor de uma variável
lógica em seu inverso lógico: de VERDADEIRO para FALSO e de FALSO para VERDADEIRO.
Exemplos de expressões lógicas válidas:
se (Altura > 1.80 e Idade < 21 e Escolaridade >= 2)
se (Idade >= 13
e Idade <=20)
se ((Media >= 7.0 e Faltas <= 18) ou FoiDispensado == 1)
se
!( numero % 2 == 0)
Exemplos de expressões lógicas INVÁLIDAS:
se (Altura > 1.80 e ou Idade < 21)
(os operadores <e> e <ou> são binários, envolvem sempre 2 operandos,
portanto não podem ser utilizados juntos)
se (Idade >=13 e <= 20)
(o operando Idade deveria ser repetido para se obter o resultado
lógico da comparação)
23
3.6. Operadores Relacionais
Os operadores relacionais permitem a comparação entre conteúdos de variáveis ou de valores, e
resultam sempre num resultado FALSO (avaliado como zero) ou VERDADEIRO (avaliado como
diferente de zero).
Os operadores relacionais são:
>
(maior que)
>=
(maior ou igual a)
<
(menor que)
<=
(menor ou igual a)
==
(igual a)
!=
(diferente de)
Exemplos de expressões relacionais válidas:
se (Resposta == ’S’)
se (Resposta == ‘S’ ou Resposta == ’s’)
se (Resposta != ‘S’ e Resposta != ‘s’)
se (Sexo == ‘F’ e Altura <= 1.50)
Exemplos de expressões relacionais INVÁLIDAS:
se (Resposta !
=
‘S’)
(o símbolo do operador “diferente” está errado: não pode haver espaço em branco entre o “!” e o “=”)
se (Altura <
= 1.50)
(o símbolo do operador “menor que” está errado: operador não pode haver espaço em branco entre o
“<” e o “=”)
24
3.7. Comando Condicional
O comando condicional permite que se tomem 2 caminhos diferentes e mutuamente exclusivos a
partir da avaliação de uma condição. Se a condição é avaliada como verdadeira um caminho é seguido, se
é avaliada como falsa outro caminho é escolhido, nunca ambos! A associação do comando condicional
com fatos rotineiros é imediata: “Se estiver chovendo eu vou de carro, senão eu vou de bicicleta”, neste
exemplo, a pessoa avalia a condição do tempo antes de decidir se sairá de carro ou de bicicleta e não há
possibilidade dela sair com ambos os meios de transporte.
A sintaxe do comando condicional é:
se (<condição>)
{
<bloco de comandos 1>
}
senão
{
<bloco de comandos 2>
}
A semântica (como funciona) do comando condicional é:
1. A <condição> é avaliada como VERDADEIRA (valor diferente de zero) ou
FALSA (valor igual a zero);
2. Se a <condição> for VERDADEIRA, o <bloco de comandos 1> é executado e
o comando condicional é finalizado;
3. Se a <condição> for FALSA, o <bloco de comandos 2> é executado e o
comando condicional é finalizado.
senão é cláusula do comando se, ou seja, não é comando, apenas faz parte do
comando se.
A cláusula senão pode não existir num comando se. Neste caso (não existe a cláusula
senão), quando a <condição> é avaliada como FALSA, nenhum comando é executado e o
comando se é finalizado.
Os delimitadores de { e } são obrigatórios quando existe mais de um comando no
<bloco de comandos 1> ou mais de um comando no <bloco de comandos 2>. Quando
existir apenas um comando, os delimitadores ficam opcionais.
Exemplos de comandos condicionais VÁLIDOS:
se
(Media >= 7.0)
Aprovado = 1;
se (Media >= 7.0)
{ Aprovado = 1;
}
se (Media >= 7.0)
{
Aprovado = 1;
++ContadorAprovados;
}
25
se (Media >= 7.0)
Aprovado = 1;
senão
Aprovado = 0;
se (Media >= 7.0)
{ Aprovado = 1;
++ContadorAprovados;
}
senão
Aprovado = 0;
se (Media >= 7.0 e Faltas <= 9)
{ Aprovado = 1;
++ContadorAprovados;
}
senão
{ Aprovado = 0;
++ContadorReprovados;
}
Exemplos de comandos condicionais INVÁLIDOS:
se
Media >= 7.0
Aprovado = 1;
(faltou colocar parênteses na condição)
se (Media >= 7.0)
{
Aprovado = 1;
++ContadorAprovados;
(faltou colocar o delimitador de fim { no final do comando )
se (Media >= 7.0)
Aprovado = 1
senão
Aprovado = 0;
(faltou ; depois do comando Aprovado = 1)
se (Media >= 7.0)
{ Aprovado = 1;
++ContadorAprovados;
}
senão
Aprovado = 0
(novamente faltou ; após o comando Aprovado = 0)
26
se (Media >= 7.0 e Faltas <= 9)
{ Aprovado = 1;
++ContadorAprovados;
}
senão
Aprovado = 0;
++ContadorReprovados;
}
(faltou o delimitador { após o senão)
se (Media >= 7.0)
Aprovado = 1;
++ContadorAprovados;
senão
Aprovado = 0
(faltaram os delimitadores { } após a condição do comando se antes do senão)
3.8. Comando de Repetição
O comando de repetição permite que um comando ou um bloco de comandos seja executado
diversas vezes. O número de vezes é determinado por uma condição que é constantemente avaliada.
Enquanto a condição for avaliada como verdadeira (ou diferente de zero), o comando ou bloco de
comandos é executado repetidamente; quando a condição fica falsa, o comando de repetição pára. A
associação do comando de repetição com fatos rotineiros é possível: “Enquanto o número da casa for
menor que o procurado, continue subindo a rua e verificando se é a casa procurada”, neste exemplo, a
pessoa avalia a condição que é a verificação do número desejado entre diversas casas de uma rua, por
exemplo; essa avaliação continua até que a casa procurada seja encontrada ou que se encontre uma casa
cujo número seja superior ao procurado, supondo que a numeração esteja em ordem crescente.
A sintaxe do comando de repetição é:
enquanto (condição)
{
<bloco de comandos>
}
A semântica (como funciona) do comando de repetição é:
1. A condição é avaliada como VERDADEIRA (diferente de zero) ou FALSA (igual
a zero);
2. Se a condição for VERDADEIRA, o <bloco de comandos> é executado e, ao se
chegar ao delimitador de fim } ou final do comando, automaticamente se retorna à
avaliação da condição;
3. Se a condição for FALSA, o comando de repetição é finalizado.
Dentre os comandos do <bloco de comandos> é ESSENCIAL que exista um comando
que altere a <condição> que é constantemente avaliada, pois, caso contrário, o comando
enquanto NUNCA TERMINARÁ!
Os delimitadores { e } são obrigatórios quando existe mais de um comando no <bloco
de comandos>. Quando existir apenas um comando, os delimitadores ficam opcionais e o
“;” funcionará como delimitador de fim, indicando o final do comando enquanto.
27
Exemplos de comandos de repetição válidos:
enquanto (Contador < 3)
++Contador;
enquanto (Numero <= 10)
{ se (Numero % 2 == 0)
++ContaPar;
senão
++ContaImpar;
Numero = Numero + 3;
}
Exemplos de comandos de repetição INVÁLIDOS:
enquanto Contador <= 10
++Contador;
(faltaram parênteses na condição)
enquanto (Numero <= 10)
{
se (Numero % 2 == 0)
++ContaPar;
senão
++ContaImpar;
Numero = Numero + 3;
(faltou colocar o delimitador fim } após o último comando...)
enquanto (Numero <= 10)
se (Numero % 2 == 0)
++ContaPar;
senão
++ContaImpar;
Numero = Numero + 3;
( como não existem os delimitadores de início e fim { }, somente o comando se faz parte do
comando enquanto e como o comando se não altera a variável Numero, o comando
enquanto nunca vai parar!)
enquanto (Numero <= 10);
{
se (Numero % 2 == 0)
++ContaPar;
senão
++ContaImpar;
Numero = Numero + 3;
}
( como foi colocado ; após a condição, o comando enquanto foi finalizado, a variável
Numero não será alterada e o comando enquanto nunca vai parar!)
28
3.9. Comandos de Entrada e Saída
O comando de entrada permite que o usuário possa fornecer valores ao programa, através do
teclado, que serão armazenados nas variáveis. O comando de saída permite que informações e valores de
variáveis possam ser enviados ao usuário pela tela do monitor. É dessa forma que se consegue estabelecer
um diálogo com o usuário. Se o programa deseja saber o nome do usuário, por exemplo, usa-se o
comando de saída para fazer a pergunta “Qual é o seu nome? ” e usa-se o comando de entrada para obter
a resposta e armazená-la numa variável.
A sintaxe do comando de entrada é:
leia(“%letra”, [&] variável);
em que:
“%letra” representa os especificadores de formato e depende do tipo associado à
variável:
“%d” ou “%i”
para variáveis do tipo inteiro
“%f”
para variáveis do tipo real
“%c”
para variáveis do tipo caracter (único)
“%s”
para variáveis do tipo caracter (cadeia ou string)
O símbolo & deve ser utilizado apenas para os tipos numéricos, ou seja, para variáveis
declaradas como inteiro ou real.
A semântica (como funciona) do comando de entrada é:
1. A variável tem que ter sido previamente declarada;
2. O usuário vai se utilizar do teclado para fornecer o dado e, depois que ele teclar
<ENTER>, tudo o que ele tiver digitado será armazenado na variável
automaticamente.
Recomenda-se utilizar o comando leia para ler uma só <variável> de cada vez.
A tabela abaixo mostra um exemplo de declaração de variáveis de tipos básicos e a forma correta
de leitura.
Declaração
Leitura
Exemplos de conteúdos
inteiro numero;
leia(“%i”, &numero);
real valor;
leia(“%f”, &valor);
caracter car;
leia(“%c”, car);
caracter nome[20];
leia(“%s”, nome);
numero = -5;
numero = 2002;
valor = -5.867;
valor = 2002.50;
car = ‘5’;
car = ‘s’;
car = ‘#’;
nome = “Maria”;
numero = “fim”;
Observe na tabela a diferença entre a declaração, leitura e atribuição de valores a um caracter
único (%c) e a uma cadeia de caracteres (%s). Um único caracter vem entre apóstrofos ‘ ’ e uma
cadeia entre aspas “” !
29
A sintaxe do comando de saída é:
imprima(“ frase e
%letra ” [, lista de variáveis] );
Entre “ ” podem ser escritas frases formadas por palavras intercaladas pelos especificadores
de formato %s, %c, %i, %d ou %f descritos no comando leia. Para cada especificador utilizado,
a variável do tipo correspondente deve constar da lista de variáveis.
A lista de variáveis é opcional; deve existir somente quando um especificador de formato é
colocado na frase entre aspas e, neste caso, deve haver uma vírgula separando a frase da lista de
variáveis e vírgulas separando as variáveis da lista.
A semântica (como funciona) do comando de saída é:
1. Pode ser impressa qualquer frase e qualquer variável dentro de um comando
imprima, desde que a frase esteja entre aspas e as variáveis estejam devidadmente
listadas após a vírgula que separa a frase da lista de variáveis;
2. A frase entre aspas é copiada integralmente para a tela e os especificadores de
formato são substituídos pelas variáveis da lista de variáveis;
1. Quando existe uma variável, o seu conteúdo é copiado para a tela;
2. A ordem em que as palavras da frase e as variáveis aparecem no comando imprima é
mantida quando é impressa na tela.
Exemplos de comandos de entrada e saída válidos:
imprima (“Qual é o seu nome? ”);
leia(“%s”,Nome);
imprima (“Qual é a sua idade? ”);
leia (“%i”,&idade);
imprima (“Qual é a sua altura? ”);
leia (“%f”,&altura);
imprima (“Qual é o seu sexo? (F/M) ”);
leia (“%c”,sexo);
imprima (“O seu nome é: %s e você tem %i anos ”,Nome, idade);
imprima (“Você foi aprovado no curso com média= %f”, Media);
30
Exemplos de comandos de entrada e saída INVÁLIDOS:
imprima (“Qual é o seu nome? );
(faltaram aspas após a interrogação para delimitar a frase a ser impressa)
imprima (“Qual é a sua idade? ”);
leia (“%i”,idade);
(faltou o & antes do identificador idade, pois o tipo é numérico: %i)
imprima (“A sua idade é %i ” idade);
(faltou uma vírgula entre a frase entre aspas e a variável idade)
imprima (“Você foi aprovado no curso com média= ”, Media);
(faltou o especificador de formato da variável Media (%f) após o = na frase entre aspas)
imprima (“Qual é o seu nome? ”);
leia (“%s”,&nome);
(não pode haver & na leituras de variáveis do tipo caracter (%c e %s) )
3.10. Separador de comandos
Todos os comandos do PortuCê são separados por ponto-e-vírgula.
O separador de comandos é:
;
Exemplos de erro na separação de comandos:
se (resposta != ‘s’);
{ <comandos>
}
(o ; depois da condição finaliza o comando “se”)
enquanto (contador < 5) ;
{ <comandos>
}
(o ; depois da condição do comando “enquanto” coloca o programa em loop infinito!)
31
3.11. Bloco de Programa
Bloco de programa é o nome que se dá à estrutura de um programa escrito numa determinada
linguagem. O bloco de programa em PortuCê pode ser visto abaixo.
O Bloco de Programa em PortuCê tem a forma:
/* comentários */
<declaração de variáveis>;
principal()
{
<bloco de comandos>;
}
Todo algoritmo escrito em PortuCê deve começar com um comentário dizendo o que o
programa faz.
Em seguida devem ser declaradas todas as variáveis que serão utilizadas no <bloco de
comandos>.
Após a declaração das variáveis deve-se escrever a palavra principal( ), que delimita a
seção em que os comandos podem ser utilizados.
O <bloco de comandos> pode conter todos os comandos válidos em PortuCê, separados
por ; e estes devem estar contidos entre os delimitadores { e }. Nenhum comando pode ser
usado fora desta seção.
É importante notar que letras maiúsculas e minúsculas alteram os identificadores e as
palavras reservadas do PortuCê.
Exemplos de programas escritos em PortuCê válidos:
/* sexo.c: le o nome e o sexo de uma pessoa e imprime uma frase
dizendo se é masculino, feminino ou invalido */
caracter nome[20], sexo;
principal ( )
{
imprima (“Qual eh o seu nome? ”);
leia(“%s”,nome);
imprima (“Qual eh o seu sexo? (f/m) ”);
leia (“%c”,sexo);
se (sexo == ‘f’ ou sexo == ‘F’)
imprima (“%s voce eh do sexo feminino. ”,nome);
senão se (sexo == ‘m’ ou sexo == ‘M’)
imprima (“%s voce eh do sexo masculino. ”,nome);
senão imprima (“Voce digitou um sexo invalido ”);
imprima(“Fim do programa.”);
}
32
/* idade.c: le o ano atual e o ano de nascimento de uma pessoa
e imprime uma frase dizendo qual eh a idade da pessoa */
inteiro anoatual, anonasc, idade;
principal()
{
imprima (“Qual eh o ano atual? ”);
leia(“%i”,&anoatual);
imprima (“Qual eh o seu ano de nascimento? ”);
leia (“%i”,&anonasc);
idade = anoatual – anonasc;
imprima (“Voce fez ou fara %i anos ”, idade);
imprima(“Fim do programa.”);
}
/* parimpar.c: le um numero e verifica se ele eh par ou impar */
inteiro n;
principal()
{
imprima (“Digite um numero inteiro: ”);
leia(“%i”,&n);
se (n % 2 == 0)
imprima (“O numero %i eh par ”, n);
senão
imprima (“O numero %i eh impar ”, n);
imprima(“ Fim do programa.”);
}
/* nota.c: le a nota de um aluno e verifica se ele foi aprovado ou
reprovado */
real nota;
principal()
{
imprima (“Digite sua nota final: ”);
leia(“%f”,&nota);
se (nota >= 6.0)
imprima (“Voce foi aprovado! ”);
senão
imprima (“Voce foi reprovado... ”);
imprima(“ Fim do programa.”);
}
33
Exemplos de programas INVÁLIDOS:
caracter
sexo, caracter[20];
principal ( )
{
imprima (“Qual eh o seu nome? ”);
leia(“%s”,caracter);
imprima (“Qual eh o seu sexo? (F/M) ”);
leia (“%c”,sexo);
se (sexo == ‘F’)
imprima (“%s voce eh do sexo feminino. ”,caracter);
senão
imprima (“%s você eh do sexo masculino. ”,caracter);
}
(A variável caracter tem o mesmo nome da palavra reservada caracter)
real nota;
{
imprima (“Digite sua nota final: ”);
leia(“%f”,&nota);
se (nota >= 6.0)
imprima (“Voce foi aprovado! ”);
senão
imprima (“Voce foi reprovado... ”);
imprima(“Fim do programa.”);
}
(Faltou a palavra principal( ) para dar início à seção de comandos)
real nota;
nota = 7.5;
principal()
{
imprima (“Digite sua nota final: ”);
leia(“%f”,&nota);
se (nota >= 6.0)
imprima (“Voce foi aprovado! ”);
senão
imprima (“Voce foi reprovado... ”);
imprima(“ Fim do programa.”);
}
(Há um comando de atribuição nota=7.5; na seção de declaração de variáveis: não pode!)
34
inteiro anoatual, anonasc, idade;
principal()
imprima (“Qual eh o ano atual? ”);
leia(“%i”,&anoatual);
imprima (“Qual eh o seu ano de nascimento? ”);
leia (“%i”,&anonasc);
idade = anoatual – anonasc;
imprima (“Voce fez ou fara %i anos ”, idade);
imprima(“Fim do programa.”);
}
(Faltou o delimitador { para iniciar a seção de comandos do programa)
inteiro N;
principal()
{
imprima (“Digite um numero inteiro: ”);
leia(“%i”,&n);
se (n % 2 == 0)
imprima (“O numero %i eh par ”, n);
senão
imprima (“O numero %i eh impar ”, n);
imprima(“ Fim do programa.”);
}
(Não foi declarada a variável n ou foi declarada errada ( n maiúsculo))
35
Capítulo 4
Construção de Algoritmos em PortuCê:
Praticando os comandos e fazendo cálculos
4.1. Declaração de variáveis, comandos “leia” e “imprima”
1) Escreva um comando que leia um número inteiro.
leia (“%i”,&numero);
2) Escreva comandos para pedir e ler um número inteiro.
imprima(“Forneca um numero inteiro: ”);
leia (“%i”,&numero);
3) Escreva comandos para pedir, ler e imprimir um número inteiro.
imprima(“Forneca um numero inteiro: ”);
leia (“%i”,&numero);
imprima(“O numero lido foi: %i”, numero);
4) Repita o exercício 3 para um número real.
imprima(“Digite a sua altura: ”);
leia (“%f”,&altura);
imprima(“A altura digitada foi: %.2f ”, altura);
5) Declare as variáveis utilizadas nos exercícios de 1 a 4.
inteiro
real
numero;
altura;
6) Escreva comandos para pedir, ler e imprimir o nome e a idade de uma pessoa.
imprima(“Qual eh o seu nome? ”);
leia(“%s”,nome);
imprima(“Qual eh a sua idade? “);
leia (“%i”,&idade);
imprima(“Nome lido: %s e idade lida: %i “,nome,idade);
36
4.2. Comando condicional “se”
7) Escreva um comando para verificar se a idade lida no exercício 6 corresponde a um adulto (maior que
17 anos). Se for verdadeiro, imprimir uma frase dizendo que é um adulto.
se (idade > 17)
imprima(“Voce eh um adulto(a) ”);
8) Escreva um comando para verificar se a idade lida no exercício 6 corresponde a uma criança (menor
que 13 anos). Se for, imprima uma frase dizendo que é uma criança.
se (idade < 13)
imprima(“Voce eh uma crianca “);
9) Escreva um comando para verificar se a idade lida no exercício 6 corresponde a um adolescente (entre
13 e 17 anos). Se for imprima uma frase...
se (idade >= 13 e idade <= 17)
imprima(“Voce eh um adolescente “);
10) Escreva um único comando capaz de classificar uma pessoa pela faixa etária e ainda verificar se a
idade é válida.
se (idade >= 0 e idade <= 12)
imprima(“Faixa etaria: criança “);
senão se (idade >=13 e idade <= 17)
imprima (“Faixa etaria: adolescente”);
senão se (idade >= 18 e idade <=120)
imprima (“Faixa etaria: adulto(a)”);
senão imprima (“Idade invalida “);
37
4.3. Bloco de Programa
11) Transforme o exercício 6 num algoritmo, ou seja, construa o Bloco de Programa em PortuCê.
/* nomeidade.c: programa que lê o nome e a idade de uma pessoa */
caracter nome[20];
inteiro
idade;
principal()
{ imprima(“Qual eh o seu nome? “);
leia(“%s”,nome);
imprima(“Qual eh a sua idade? “);
leia(“%i”,&idade);
imprima(“Nome lido: %s e idade lida: %i “,nome,idade);
imprima(“Fim do programa “);
}
12) Escreva um algoritmo que leia o nome e a idade de uma pessoa e imprima uma frase dizendo se a
pessoa é uma criança, um adolescente ou um adulto.
/* fxetaria.c: programa que define a faixa etaria de uma pessoa */
caracter
inteiro
nome[20];
idade;
principal()
{
imprima(“Qual eh o seu nome? “);
leia(“%s”,nome);
imprima(“Qual eh a sua idade? “);
leia (“%i”,&idade);
imprima(“Nome lido: %s e idade lida: %i “,nome,idade);
se (idade >= 0 e idade <= 12)
imprima(“Faixa etaria: criança “);
senão se (idade >=13 e idade <= 17)
imprima (“Faixa etaria: adolescente”);
senão se (idade >= 18 e idade <=120)
imprima (“Faixa etaria: adulto(a)”);
senão imprima (“Idade invalida “);
imprima(“Fim do programa “);
}
38
Lista de exercícios nº 4.1
Com os 12 exercícios anteriores, você deve ter já uma boa base... Agora é hora de você praticar um
pouco sozinho! A minha forte recomendação é que você faça os exercícios sozinho, consultando os
exemplos anteriores para ajudá-lo... Somente depois da sua tentativa é que você deve conferir as
respostas... Boa sorte!
4.1.1) Escreva um algoritmo que leia e imprima o nome e as duas notas de um aluno.
4.1.2) Escreva um comando que calcule a média das duas notas lidas no exercício 4.1.1.
4.1.3) Escreva um comando que verifique se a média calculada no exercício 4.1.2 é maior ou igual a 7; se
for, imprima uma frase dizendo que o aluno foi aprovado, caso contrário, imprima uma frase dizendo que
foi reprovado.
4.1.4) Escreva um algoritmo que leia o nome e as duas notas de um aluno, calcule a média das notas e
imprima uma frase dizendo se ele foi aprovado (média maior ou igual a 7.0) ou reprovado.
39
4.4. Operações Básicas com Números
13) Escreva um comando para somar dois números n1 e n2.
soma = n1 + n2;
Observe que soma é a variável na qual o resultado da adição de n1 com n2 será armazenado.
São usados apenas o comando de atribuição “=” e o operador “+”.
14) Escreva comandos para subtrair e multiplicar dois números n1 e n2.
subtracao = n1 - n2;
multiplicacao = n1 * n2;
O raciocínio para subtrair e multiplicar dois números é o mesmo usado na adição....
15) Escreva um comando para dividir dois números N1 por N2.
Antes de dividir um número n1(numerador) por um número n2 (denominador) é necessário que
verifiquemos primeiro se o denominador é diferente de zero, pois não existe divisão por zero! O
comando “divisao = n1 / n2;” é válido do ponto de vista sintático, mas em programação temos que
pensar nos erros que porventura possam ocorrer quando da execução dos comandos...
se (n2 != 0)
{ divisao = n1/n2;
imprima(“%i dividido por %i = %f”,n1,n2,divisao);
}
senão
imprima(“Divisao por zero nao existe! ”);
Para evitarmos a divisão eventual por zero, usamos o comando “se”. Somente se n2 for diferente
de zero é que a divisão será calculada; caso contrário uma mensagem é impressa para comunicar
ao usuário o motivo pelo qual o cálculo não foi efetuado. O resultado da divisão é um número real.
16) Escreva um comando para calcular o quadrado de um número inteiro n1 e também n1 elevado a 3.
quadrado = n1*n1;
cubo = n1*n1*n1;
Com certeza é muito mais fácil do que você pensava, não é? São pequenos truques da programação...
Mas se quisermos calcular n1 elevado a 1000 ou n1 elevado a um número qualquer, teremos que
escrever um pequeno trecho de algoritmo. Depois eu mostro como fazer...
40
17) Escreva um comando para calcular a raiz quadrada de um numero n1.
se (n1 > 0)
{ raiz = sqrt(n1);
imprima(“Raiz quadrada por %i = %f”,n1,raiz);
}
senão
imprima(“Nao existe raiz de numero negativo! ”);
Observe que sqrt( ) é um operador aritmético cuja sintaxe é diferente dos outros vistos nos
exercícios anteriores. Este tipo de operador na verdade é uma função que recebe n1 como parâmetro
e devolve a sua raiz quadrada calculada. Existem muitas outras funções e elas serão apresentadas na
medida em que se fizer necessária a sua utilização.
18) Escreva comandos para fornecer o quociente e o resto da divisão inteira de n1 por n2.
No caso da divisão inteira de n1 (numerador) por um número n2 (denominador) também é
necessário que o denominador seja diferente de zero.
se (n2 != 0)
{ quociente = n1 / n2;
resto = n1 % n2;
imprima(“divisao inteira de %i por %i tem quociente = %i e
resto = %i ”,n1,n2,quociente, resto);
}
senão
imprima(“Divisao por zero nao existe! ”);
Neste caso é importante você notar que ambos os números n1 e n2 têm que ser inteiros
para que os operadores “/” (quociente da divisão real) e “%” (resto da divisão inteira) possam
ser utilizados! Como você pode notar, não existe um operador específico para o quociente da
divisão inteira; usa-se o “/” (que é da divisão real), mas como n1 e n2 são inteiros e quociente é
inteiro, haverá uma conversão automática de tipos, com o truncamento da parte fracionária do
resultado, o que nos fornece o quociente da divisão inteira. Isso é um trunfo do PortuCê: nunca
se esqueça disso!
Se n1 for 7 e n2 for 3, por exemplo, quais seriam os valores de quociente e resto?
(7 dividido por 3 dá 2(quociente) e sobra 1 (resto), não é?)
19) Escreva um comando para calcular 10% de um número.
porc = n1 * 0.10;
Em primeiro lugar, vamos esclarecer que NÃO EXISTE O OPERADOR “porcentagem”: na
verdade, “%” é o resto da divisão inteira... Portanto, o cálculo da porcentagem tem que ser feito
pela operação equivalente: 10% = 10/100 = 0.10. A variável porc dev ser do tipo real. Não
recomendo o uso de 10/100, pois 10/100 pode ser zero, com a conversão automática de tipos....
41
20) Suponha que um produto custe um determinado preço, mas, se pago à vista, o cliente ganha 5% de
desconto. Escreva comandos para calcular o valor do desconto e o valor final do produto.
desconto = preco * 0.05;
precofinal = preco – desconto;
21) Escreva comandos para separar os dígitos de um número inteiro menor que 100 em dezena e unidade.
Vamos entender primeiro o que se quer: dado um número menor que 100, por exemplo, 29, se
deseja obter o dígito 2 (dezena) separado do dígito 9 (unidade); no caso de um número de um só
dígito, por exemplo, 3, o resultado seria 0(dezena) e 3(unidade). Bem, este é um problema muito
comum na programação e muito fácil de ser resolvido também! Basta usar os operadores “/” e
“%” com números inteiros.
dezena = n1 / 10;
unidade = n1 % 10;
Vamos fazer um pequeno teste: 29 dividido por 10 dá 2 e sobram 9, certo? 2 é a dezena de 29 e
coincide com o quociente da divisão inteira; 9 é a unidade de 29 e coincide com o resto da divisão
inteira por 10! No caso de n1 ser igual a 3, ficaria assim: 3 dividido por 10 dá 0 e sobram 3. Neste
caso, 0 é a dezena (“/”) e 3 é a unidade (“%”).
22) Suponha que numa certa universidade os alunos têm um número de 5 dígitos que os identificam.
Desses 5 dígitos, os 2 primeiros indicam o ano em que o aluno entrou na universidade. Escreva comandos
para separar os 2 primeiros dígitos de um número inteiro de 5 dígitos que representa a identificação do
aluno.
Vamos entender o que se quer: dado um número de 5 dígitos, por exemplo, 99211, se deseja
obter os 2 primeiros dígitos, no caso, 99 (que indicaria que o aluno entrou em 1999 na
universidade). Mas, e se o aluno em entrou em 2000 ou 2009? Temos que previnir o “bug do
milênio” em nossa solução...
anoentrada = n1 / 1000;
Vamos fazer, agora, os testes. Vejamos: n1 é 00211. 00211 dividido por 1000 dá ZERO (que é o
quociente) e sobram 211. Pode parecer estranho, mas quando se divide um número por 1000, o
menor resto é zero e o maior resto pode ser 999... Como queremos apenas o quociente da divisão
inteira, o resultado será anoentrada = 0 (que, no caso, representaria 2000). Funciona!
Outro teste: N1 igual a 10231. 10231 dividido por 1000 dá 10 e sobram 231, certo? 10 é o
quociente , o que resulta em anoentrada= 10 (que seria 2010)! Funciona mesmo!
42
4.5. Operações com Operadores Lógicos e Relacionais
23) Escreva um comando para verificar se um número é positivo ou negativo.
se (n1 >= 0)
imprima(“%i
senão
imprima(“%i
eh positivo. ”, n1);
eh negativo. ”, n1);
Observe que 0 pode ser considerado um número positivo e todo número menor que 0 é negativo.
24) Escreva um comando para verificar se um número é par ou ímpar.
Um número par é aquele que dividido por 2 o resto é zero: 0, 2, 4, 6, 8, 10.... e um número ímpar
é aquele que dividido por 2 o resto é diferente de zero: 1, 3, 5, 7, 9...
se (n1 % 2 == 0)
imprima(“%i eh par. ”, n1);
senão
imprima(“%i eh impar. ”, n1);
25) Escreva um comando para verificar se um número é maior que 100.
se (n1 > 100)
imprima(“%i eh maior que 100”,n1);
senão
imprima(“%i eh menor ou igual a 100 ”,n1);
26) Escreva um comando para verificar se um número está entre 10 e 100.
se (n1 >= 10 e n1 <= 100)
imprima(“%i esta entre 10 e 100”,n1);
senão
imprima(“%i nao esta entre 10 e 100”,n1);
Para se verificar se um número está entre dois limites são necessárias duas comparações, uma
para o limite inferior e outra para o limite superior e essas comparações têm que estar ligadas pelo
conectivo lógico “e”, quer dizer, somente quando as duas comparações forem verdadeiras, o
número está dentro dos limites. Não é como na Matemática que usamos uma expressão do tipo
“10 ≤ N1 ≤ 100”!
43
27) Suponha que um certo clube esportivo quer selecionar atletas para o time de basquete. As exigências
são: ter 1.85m de altura ou mais, ter menos de 21 anos e ter, pelo menos, o primeiro grau completo.
Escreva um comando para verificar se um candidato pode ser ou não aprovado para o time de basquete.
se (altura >= 1.85 e idade < 21 e instrucao >= 1)
imprima(“Candidato aprovado para o basquete.”);
senão
imprima(“Candidato reprovado para o basquete.”);
Observe que ao se fazer a comparação da altura não se faz referência à unidade de medida
“metros”, quer dizer, estaria errada uma comparação do tipo “altura >= 1.85m”. O mesmo
acontece com a idade, em que os “anos” foram (e devem) ser omitidos. Já o grau de instrução
deve ser definido pelo problema. Neste caso, “0= sem instrução”, “1=primeiro grau”,
“2=segundo grau”, “3=superior”.
28) Suponha que o clube esportivo deseje, agora, formar um time masculino e outro feminino e tenha
mudado um pouco seus critérios. As exigências passaram a ser: ter 1.85m de altura ou mais para os
homens e 1.75 ou mais para as mulheres e ter menos de 21 anos. Escreva um comando para verificar se
um candidato ou candidata pode ser ou não aprovado (a) para o time de basquete.
se (((sexo == ‘m’ e altura>=1.85) ou (sexo == ‘f’ e altura>=1.75))
e idade < 21)
imprima(“Candidato/a aprovado/a para o basquete.”);
senão
imprima(“Candidato/a reprovado/a para o basquete.”);
Observe que surgiu o conectivo “ou” ligando as comparações de altura para os sexos diferentes,
que continuaram a ser ligados pelo conectivo “e” na comparação de idade! Pense porquê é assim...
44
Lista de Exercícios nº 4.2
4.2.1) Considere o trecho de algoritmo em PortuCê:
se (B1)
C1;
senão se (B2)
se (B3)
C2;
senão
{
C3;
C4;
}
C5;
Em PortuCê não existe uma variável do tipo “lógico” a qual se possa atribuir um valor “verdadeiro”
ou “falso”. No entanto, o PortuCê considera o valor 0 (zero) como sendo falso e qualquer outro valor
diferente de zero como sendo verdadeiro. Nos exercícios que se seguem, considere que os valores de B1,
B2 e B3 representam valores “verdadeiros” (diferentes de zero) ou “falsos” (iguais a zero) e responda à
pergunta “Quais comandos serão executados”:
a) Se B1= Verdadeiro B2 =Verdadeiro e B3=Falso?
b) Se B1=Falso B2= Verdadeiro e B3= Falso?
c) Se B1=Falso B2=Verdadeiro e B3=Verdadeiro?
d) Quais os valores de B1, B2 e B3 para que somente o comando C5 seja executado?
4.2.2) Observe o algoritmo abaixo. Qual o valor de L após a execução desse algoritmo?
inteiro A, B, C;
real
X, Y;
inteiro L;
principal()
{
A = 0;
/* falso */
B = 1;
/* verdadeiro */
C = 0;
/* falso */
X = 1.5;
Y = 3.2;
se (C ou (X+Y>5) ou não(A e B))
L = 0;
senão
L = 1;
}
45
4.2.3) Escreva os trechos de algoritmo em PortuCê que ajudem o IBGE a fazer o senso populacional de
uma certa cidade. Sabendo-se que os seguintes dados foram pedidos aos cidadãos: SEXO (H= homem,
M= mulher) e RENDA (número de salários mínimos - s.m.), os trechos de algoritmo devem fornecer:
a) o total de homens
b) o total de mulheres
c) o total de pessoas da classe C (até 4 s.m.), da classe B (até 20 s.m.) e da classe A (acima de 20
s.m.)
4.2.4) Dado um conjunto de respostas “sim” ou “não” de várias pessoas e seu sexo (F=feminino,
M=masculino), escreva comandos em PortuCê para calcular:
a) o número de mulheres que responderam sim
b) o número de homens que responderam não
c) o número de mulheres e homens que responderam não
4.2.5) Fornecidos os dados das candidatas a modelo: ALTURA, PESO e IDADE, escreva um trecho de
algoritmo para verificar se os dados se enquadram nos seguintes limites:
ALTURA: de 1.70 a 1.85 m
PESO: de 48.0 a 60.0 Kg
IDADE: de 17 a 21 anos
Se os dados da candidata corresponderem aos limites acima, deve ser impressa uma frase dizendo que ela
foi aprovada, caso contrário, que não foi aprovada.
4.2.6) Modifique o exercício anterior para que uma frase seja impressa após a verificação de cada quesito
dizendo se a candidata foi aprovada ou não em cada um deles e uma frase final dizendo se foi aprovada
ou não como modelo.
4.2.7) Escreva comandos em PortuCê para um trecho de algoritmo que, dada a Renda Anual (RA),
verifique a alíquota e calcule o IR (Imposto de Renda) de um contribuinte de acordo com a tabela:
Renda Anual
até 5000.00
de 5000.01 até 50000.00
acima de 50000.01
Alíquota para cálculo do IR
isento
10 %
15 %
46
Capítulo 5
Construção de Algoritmos em PortuCê:
Usando Laços de Repetição
5.1. Comando de repetição “enquanto” – Uso de flags – entrada indeterminada de
dados
Aqui você vai aprender a usar o comando repetitivo e a resolver problemas que envolvam flags.
Flag vem do inglês e significa sinal ou bandeira. Um flag em programação representa um valor que é
usado para indicar o final da entrada de dados. Como já foi dito antes, um algoritmo é usado para resolver
problemas finitos. Se alguém pede que façamos um programa para ler uma “quantidade indeterminada de
números...” aparentemente não poderíamos escrever um algoritmo para resolvê-lo. Mas se um flag é
informado, a solução se torna possível: faça um programa para ler uma “quantidade indeterminada de
dados, sabendo-se que o último valor será –1...”. Veja bem: a quantidade de números continua
indeterminada, isso é, não sabemos se serão 5, 20, 2 ou 2000 números, mas sabemos que o último é –1!
Assim, -1 é o flag e os números serão lidos até que seja fornecido o –1, quando o programa irá parar de
ler os números... Vamos ver isso na prática!
1) Escreva comandos para ler e imprimir vários números inteiros. O último número é 0 (flag=0).
imprima(“Digite um numero inteiro: ”);
leia (“%i”,&n);
enquanto (n != 0)
{ imprima(“Numero lido: %i ”, n);
imprima(“Digite outro numero inteiro (0 para terminar): ”);
leia (“%i”,&n);
}
É importante que você observe a lógica de um trecho de algoritmo que trabalha com flag.
Antes de o número n ser “processado”, é necessário verificar se ele é o flag ou não. Por isso é
feita uma leitura ANTES do início do comando de repetição “enquanto”. No entanto, é
necessário que o número n seja lido novamente dentro do comando “enquanto” para que a
condição que determina a finalização do comando seja modificada (senão o comando “enquanto”
nunca para) e também para que a leitura indeterminada de dados prossiga; essa nova leitura é
feita no FINAL do comando “enquanto”!
Não pretendo aqui dar uma “receita de bolo” para você seguir, mas apenas chamar a sua
atenção para a lógica deste tipo de problema que poderá ser utilizada, com certeza, em muitos
outros problemas que envolvam o uso de flags...
47
2) Escreva comandos para ler e imprimir vários números inteiros e contar a quantidade de
números lidos. O último número é 0 (flag=0). Imprima, também, a quantidade de números.
imprima(“Tecle um numero inteiro: “);
leia (“%i”,&n);
cont = 0;
enquanto (n != 0)
{
imprima(“ Numero lido: %i “, n);
++cont;
imprima(“Tecle outro numero inteiro (0 para terminar): “);
leia (“%i”,&n);
}
imprima(“A quantidade de numeros lidos foi: %i “,cont);
É importante que você observe a lógica para se contar a quantidade de números
fornecidos. Quando o flag é utilizado, sabe-se que a entrada de dados é indeterminada. Quando
se deseja saber quantos valores válidos foram fornecidos é necessário usar um contador (neste
algoritmo é o Cont). O contador tem que ser inicializado com zero. Cada vez que uma repetição
é realizada (ou seja, cada vez que o comando “enquanto” é executado), soma-se mais 1 ao
contador. A impressão do conteúdo do contador só pode ser feita após o final do comando
“enquanto”, quando temos a certeza de que a entrada de dados foi finalizada (ou seja, o flag foi
fornecido).
3) Escreva comandos para ler e somar vários números inteiros. O último número é -1 (flag= -1).
soma = 0;
imprima(“Tecle um numero inteiro: “);
leia (“%i”,&n);
enquanto (n != -1)
{ soma = soma + n;
imprima(“Tecle outro numero inteiro (flag= -1): “);
leia (“%i”,&n);
}
imprima(“A soma dos números= %i “, soma);
48
4) Escreva comandos para ler e imprimir a idade e o nome de várias pessoas (última idade=0).
imprima(“Qual eh sua idade? “);
leia (“%i”,&idade);
enquanto (idade != 0)
{ imprima (“Qual eh seu nome? “);
leia(“%s”,nome);
imprima(“ %s sua idade=%i anos “,nome,idade);
imprima(“Qual eh sua idade? (0 para terminar): “);
leia (“%i”,&idade);
}
Temos, neste exemplo, um caso em que há mais de uma variável a ser lida e apenas uma
dessas variáveis vai funcionar como flag. Neste caso, a lógica tem que ser um pouco alterada: a
variável que será utilizada como flag deve ser lida ANTES do começo do comando “enquanto” e
sua leitura deve ser repetida DENTRO do comando imediatamente ANTES DO FINAL do
comando “enquanto” (observe os comandos em destaque); todas as outras variáveis devem
ser lidas apenas uma vez, DENTRO do comando “enquanto”, bem no seu início!
5) Escreva comandos para ler e imprimir a idade, o nome e a altura várias pessoas (última
idade=0). Crie uma forma alternativa.
enquanto (1)
{ imprima(“Qual eh sua idade? (0 para terminar): “);
leia (“%i”,&idade);
se (idade==0)
break;
imprima (“Qual eh seu nome? “);
leia(“%s”,nome);
imprima(“Qual eh sua altura? “);
leia (“%f”,&altura);
imprima(“%s sua idade=%i anos e sua altura=%.2f m“,nome,idade, altura);
}
Observe que, neste exemplo, o comando “enquanto” não pára nunca, pois a condição é sempre 1,
ou seja, sempre “verdadeira”. Para finalizar o comando enquanto, foi utilizado o comando
break. Ou seja, quando o usuário digitar 0 para a idade, o comando enquanto é finalizado pelo
break. Isso pode ser feito, sim, sem problemas!
49
5.2. Comando de repetição “enquanto” – entrada de dados determinada
Você vai continuar usando o comando repetitivo, mas para resolver problemas que envolvam
contadores. Ao contrário do que vimos na parte 5.1, em que entradas indeterminadas de dados foram
tratadas, aqui estudaremos os problemas cuja entrada de dados é DETERMINADA. Se alguém pede que
façamos um programa para ler um “conjunto de 10 números...” seria necessário que contássemos de 1 até
10 e, a cada contagem, lêssemos um dos números do conjunto para que, no final, todos os 10 valores
tivessem sido lidos. Este tipo de problema requer o uso de contadores para facilitar a contagem dos dados
de entrada. Vamos ver isso na prática!
6) Escreva comandos para ler e imprimir o nome de 5 pessoas.
cont = 0;
enquanto (cont < 5)
{ imprima(“Qual eh seu nome? “);
leia (“%s”,Nome);
imprima(“Seu nome é: %s “,Nome);
++cont;
}
Novamente é importante que você observe a lógica de um trecho de algoritmo que
trabalha com entrada determinada de dados. Antes de o NOME ser lido é necessário zerar o
contador CONT. Daí utiliza-se o comando “enquanto” cuja condição é exatamente o contador
ser menor do que o número de dados a serem lidos (cont < 5, neste caso). DENTRO do comando
enquanto é feita, uma única vez, a leitura do nome, o nome é impresso e somente no FINAL do
comando enquanto o contador é incrementado de 1.
7) Escreva comandos para ler e imprimir o nome, a idade e a altura de 10 pessoas.
cont = 0;
enquanto (cont < 10)
{ imprima(“Qual eh seu nome? “);
leia (“%s”,Nome);
imprima(“Qual eh a sua idade? “);
leia (“%i”,&idade);
imprima(“Qual eh a sua altura? “);
leia (“%f”,&altura);
imprima(“%s, você tem %i anos e %1.2f de altura.”,
nome,idade,altura);
++cont;
}
Observe que quando há mais de uma variável a ser lida, todas elas devem ser lidas apenas
uma vez DENTRO do comando “enquanto”. A contagem fica como antes... Fácil, não é?
50
8) Escreva comandos para pedir ao usuário o número de dados que ele deseja fornecer (N) e leia e
imprima o nome e a quantidade que ele forneceu.
cont = 0;
imprima(“Quantos dados você deseja fornecer? “);
leia(“%i”,&n);
enquanto (cont < n)
{
imprima(“Qual eh seu nome? “);
leia (“%s”,nome);
imprima(“Seu nome eh: %s “,nome);
++cont;
}
imprima(“Foram fornecidos %i dados”,n);
Note que a única mudança na solução deste tipo de problema é a leitura da quantidade de
dados ANTES do comando “enquanto” e a mudança na condição do comando “enquanto” para
(cont < n)...
9) Reescreva o trecho 8) usando enquanto (1).
cont = 0;
imprima(“Quantos dados você deseja fornecer? “);
leia(“%i”,&n);
enquanto (1)
{
imprima(“Qual eh seu nome? “);
leia (“%s”,nome);
imprima(“Seu nome eh: %s “,nome);
++cont;
se (cont==n)
break;
}
imprima(“Foram fornecidos %i dados”,n);
51
Lista de exercícios nº 5.1
Vamos praticar um pouco mais, agora. A minha forte recomendação, novamente, é que você faça os
exercícios sozinho, consultando os exemplos dados para ajudá-lo... Somente depois da sua tentativa é
que você deve conferir as respostas... Boa sorte!
5.1.1) Escreva um algoritmo que leia e imprima o nome e as duas notas de vários alunos. O último aluno
terá o nome=FIM.
5.1.2) Escreva um algoritmo que leia 10 números e calcule e imprima a sua soma.
5.1.3) Escreva um algoritmo que calcule e imprima N números pares, começando do zero. Pergunte ao
usuário quantos números ele deseja (ou seja, peça-lhe para fornecer o valor de N).
5.1.4) Quais os resultados produzidos pelo algoritmo?
inteiro
X, Y;
principal()
{
Y = 0;
X = -1;
enquanto (Y != 4)
{
X = X * -1;
++Y;
se (X > 0) /* X é positivo? */
imprima(“%i”,Y);
senão
imprima (“%i”,-Y);
}
}
Para que seja possível você acompanhar a execução do algoritmo, vamos criar uma “tabela” para
fazermos o chamado “teste de mesa” de um algoritmo. A tabela deve ter uma coluna para cada
variável e uma coluna especial para a impressão dos resultados. O algoritmo deve ser seguido
comando a comando e os valores das variáveis devem ir sendo alterados de acordo com os
comandos.
X
Y
Resultados
52
5.1.5) Faça o “teste de mesa” do algoritmo abaixo e construa a tabela com os valores das variáveis e os
resultados do programa.
/* este algoritmo .... */
inteiro numero, cont;
principal()
{
cont = 0;
numero = 2;
enquanto (cont != 5)
{
imprima (“%i”,numero);
imprima (“%i”,-numero);
numero = numero + 2;
++cont;
}
}
numero
cont
Resultado
53
Capítulo 6
A linguagem de programação C
Neste capítulo o aluno poderá começar a traduzir seus primeiros algoritmos para a linguagem de
programação C. Isso o capacitará a realizar as primeiras aulas práticas em laboratório. Recomenda-se que
o aluno prepare em seu computador um ambiente adequado à programação em C e comece a trabalhar
sozinho fazendo os programas da lista 6.1 como atividades extra-classe. O interessante em se utilizar o
PortuCê como pseudo-linguagem, é que ele segue quase totalmente as mesmas regras da linguagem C.
6.1. Tipos Básicos e Declaração de Variáveis em C
Um identificador em C é formado por caracteres alfanuméricos.
O primeiro caracter tem que ser uma letra; os outros caracteres podem ser:
letras: A-Z, a-z
dígitos: 0-9
sublinhado: _
Não pode haver dois identificadores iguais.
Letras minúsculas e letras maiúsculas são diferentes
Os identificadores não podem ser acentuados.
Não pode haver espaço em branco num identificador.
O caracter “ç” não pode ser usado num identificador.
Um identificador não pode ter o mesmo nome das palavras reservadas do C (como
main, if, else, int, char...).
Na linguagem C há 4 tipos básicos e cinco modificadores de tipos, o que amplia
muito os tipos de variáveis, mas neste curso usaremos apenas 3 tipos básicos:
int
float
char
Existe, também, o tipo de dados double (%g)
Para se declarar uma variável escreve-se o nome de seu tipo, salta-se um espaço em
branco, em seguida o nome do seu identificador e “;” para finalizar a declaração.
Se mais de uma variável for do mesmo tipo básico, elas podem ser declaradas
juntas, apenas separadas por vírgulas “,”.
Pode-se inicializar uma variável na sua declaração, atribuindo-se a ela um
valor inicial compatível com seu tipo.
Toda variável precisa ser declarada antes de ser utilizada.
Não pode haver duas variáveis com mesmo nome, mesmo que tenham tipos básicos
diferentes, a menos que algum caracter maiúsculo ou minúsculo as diferencie.
Exemplo de declaração de variáveis válido:
char nome[20], letra, zero=’0’;
float soma=0;
int n1, n2;
float raiz1, Total_dos_Salarios;
char nome_de_familia[30]=”Menezes”;
int idade, cont=0;
54
6.2. Operadores de Atribuição, Aritméticos, Relacionais e Lógicos (Binários) em C
O operador de atribuição é:
=
Há os operadores de atribuição compostos
+=
-=
*=
/=
Os operadores aritméticos básicos são:
+ (adição)
- (subtração)
* (multiplicação)
/ (divisão real)
++ ( adiciona 1)
-- (subtrai 1)
Alguns operadores aritméticos mais avançados são:
% (resto da divisão inteira)
/ (quociente da divisão inteira)
sqrt( ) (raiz quadrada)
abs( ) (valor absoluto)
Os operadores relacionais são:
> (maior que)
>= (maior ou igual a)
< (menor que)
<= (menor ou igual a)
== (igual a)
!= (diferente de)
Os operadores lógicos são:
&&
(operador e - conjunção)
||
(operador ou - disjunção)
!
(operador não - negação)
Funcionamento dos operadores lógicos em C
Operador Lógico
Ação
&&
(e)
avalia como 1 (verdadeiro) se ambas expressões forem verdadeiras,
caso contrário, avalia como 0 (falso)
||
(ou)
avalia como 1 (verdadeiro) se pelo menos uma expressão for
verdadeira, caso contrário, avalia como 0 (falso)
!
(não)
avalia como 1 (verdadeiro) se a expressão for falsa e 0 (falso) se a
expressão for verdadeira, ou seja, troca verdadeiro por falso e viceversa
•
55
Expressões conectadas por operadores lógicos são avaliadas da esquerda para a direita e a
avaliação para tão logo a veracidade ou falsidade do resultado for reconhecida
•
Em qualquer expressão que se espere um valor lógico, o resultado será:
- falso se o valor for 0
- verdadeiro para qualquer outro valor (1 ou qualquer número positivo ou negativo)
•
Exemplos:
(5 > 2) && (3 != 2) /* avalia como 1 (verdadeiro) */
(3 >= 2) || (4 == 2) /* avalia como 1 (verdadeiro) */
(3 <= 2) || (4==2)
/* avalia como 0 (falso) */
! (4==2)
! (4>3)
/* avalia como 1 (verdadeiro) */
/* avalia como 0 (falso) */
Exemplos de expressões lógicas e relacionais válidas:
if (altura > 1.80 && idade < 21 && escolaridade >= 2)
if (idade >= 13
&& idade <=20)
if ((media >= 7.0 && faltas <= 18) || foidispensado == 1)
if
!(numero % 2 == 0)
if (resposta == ’S’)
if (resposta == ‘S’ || resposta == ’s’)
if (resposta != ‘S’ && resposta != ‘s’)
if (sexo == ‘F’ && altura <= 1.50)
if (cont=0 && soma !=0)
(muito cuidado com este tipo de expressão: cont=0 é uma atribuição e não uma comparação,
mas em C pode-se fazer atribuição num comando if!!)
Exemplos de expressões lógicas e relacionais INVÁLIDAS:
if (altura > 1.80 && || idade < 21)
(os operadores “&&” e “||” são binários, envolvem sempre 2 operandos,
portanto não podem ser utilizados juntos)
if (idade >=13 && <= 20)
(o operando idade deveria ser repetido para se obter o resultado lógico da comparação)
if (Resposta !
=
‘S’)
(o símbolo do operador “diferente” está errado: não pode haver espaço em branco entre o “!” e o “=”)
if (Altura <
= 1.50)
(o símbolo do operador “menor que” está errado: não pode haver espaço em branco entre o “<” e o “=”)
if resposta == ’S’
(faltaram parênteses delimitando a expressão)
56
Exemplos de expressões aritméticas válidas:
resto = 10 % 3;
quociente =
10 / 3;
salario = ((totaldehoras*32.50)+102.00) - descontoinss;
valoremdolares = salario / 2.55;
impostoderenda = salario * 0.20;
ok = (achou=1) && (resposta=’s’);
strcat (nome,"da silva”);
// concatenação de strings
contador = contador +1;
++contador;
contador += 2;
// equivale a contador = contador + 2;
--valor;
valor -= 5;
// equivale a valor = valor – 5;
Soma += Valor;
// equivale a Soma = Soma + Valor;
x1 = -b + sqrt(teta) / (2*A);
// a função sqrt() está na biblioteca <math.h>
Exemplos de expressões aritméticas INVÁLIDAS:
resto = 10.0 % 3;
(o operador % só pode envolver números inteiros)
salario = totaldehoras *+ 32.50;
(os operadores * e + são diádicos, envolvem sempre dois operadores, portanto não podem ser utilizados juntos)
valoremdolares = salario / 2,55;
(não existe vírgula decimal, o separador é sempre o ponto “.”)
Nome = Nome * 3;
Nome = Nome + “da Silva”;
(em variáveis do tipo string a manipulação é feita através de funções. As funções estão na biblioteca <string.h>)
Contador =
*1;
(o operador * é diádico, tem que envolver dois operandos)
57
6.3. Comando Condicional em C
A sintaxe do comando condicional é:
if (condição)
{
<bloco de comandos 1>
}
else
{
<bloco de comandos 2>
}
A semântica (como funciona) do comando condicional if é:
1. A <condição> é avaliada como VERDADEIRA (valor diferente de zero) ou
FALSA (valor igual a zero);
2. Se a <condição> for VERDADEIRA, o <bloco de comandos 1> é executado e
o comando condicional é finalizado;
3. Se a <condição> for FALSA, o <bloco de comandos 2> é executado e o
comando condicional é finalizado.
else é cláusula do comando if, ou seja, não é comando, apenas faz parte do
comando if.
A cláusula else pode não existir num comando if. Neste caso (não existe a cláusula
else), quando a <condição> é avaliada como FALSA, nenhum comando é executado e o
comando if é finalizado.
Os delimitadores de { e } são obrigatórios quando existe mais de um comando no
<bloco de comandos 1> ou mais de um comando no <bloco de comandos 2>. Quando
existir apenas um comando, os delimitadores ficam opcionais.
Exemplos de comandos condicionais VÁLIDOS:
if
(Media >= 7.0)
Aprovado = 1;
if (Media >= 7.0)
{ Aprovado = 1;
}
if (Media >= 7.0)
{
Aprovado = 1;
++ContadorAprovados;
}
if (Media >= 7.0)
{ Aprovado = 1;
++ContadorAprovados;
}
else
Aprovado = 0;
58
if (Media >= 7.0)
Aprovado = 1;
else
Aprovado = 0;
if (Media >= 7.0 && Faltas <= 9)
{ Aprovado = 1;
++ContadorAprovados;
}
else
{ Aprovado = 0;
++ContadorReprovados;
}
Exemplos de comandos condicionais INVÁLIDOS:
if
Media >= 7.0
Aprovado = 1;
(faltou colocar parênteses na condição)
if (Media >= 7.0)
{
Aprovado = 1;
++ContadorAprovados;
(faltou colocar o delimitador de fim { no final do comando )
if (Media >= 7.0)
Aprovado = 1
else
Aprovado = 0;
(faltou ; depois do comando Aprovado = 1)
if Media >= 7.0
Aprovado = 1;
++ContadorAprovados;
else
{ Aprovado = 0;
++ContadorReprovados;
}
(faltou colocar parênteses na condição e delimitadores de iníco e fim { } antes do else )
59
6.4. Comando de Seleção Múltipla em C
Comando de seleção múltipla que testa sucessivamente o valor de uma expressão contra uma lista de
valores do tipo inteiro ou de caracteres. Quando o valor coincide, os comandos associados àquele valor
são executados. A sintaxe do comando de seleção múltipla switch é:
switch (expressão)
{ case valor1:
<comandos_1>;
break;
case valor2:
<comandos_2>;
break;
...
case valorn:
<comandos_n>;
break;
default:
comandos_default;
}
expressão deve resultar num valor inteiro do tipo long, int ou char. Compara-se este resultado
com o valor1 até valorn.
- Se for encontrada alguma equivalência, o programa passa a executar os comandos a partir
deste ponto, até encontrar uma instrução break.
- Se nenhuma equivalência for encontrada os comandos relativos a default são executados.
- Caso não haja a opção default, nenhum comando é executado.
- Caso a instrução break não seja encontrada, todos os comandos vão sendo executados até se
chegar ao final do comando switch.
Exemplos de comandos de seleção múltipla válidos:
switch (sexo)
{
case ‘f’:
case ‘F’:
printf(“\nVoce eh do sexo feminino”);
break;
case ‘m’:
case ‘M’:
printf(“\nVoce eh do sexo masculino”);
break;
default:
printf(“\nSexo invalido.”);
}
letra = toupper(letra);
switch (letra)
{ case ‘A’:
case ‘E’:
case ‘I’:
case ‘O’:
case ‘U’:
printf(“\n Voce digitou uma vogal”);
break;
default:
printf(“\n Voce digitou algo diferente de uma vogal”);
}
60
switch (voto)
{ case 1: printf(“\n
++cont1;
break;
case 2: printf(“\n
++cont2;
break;
case 3: printf(“\n
++cont3;
break;
default:
printf(“\n
}
Voce votou no candidato 1”);
Voce votou no candidato 2”);
Voce votou no candidato 3”);
Voto invalido”);
printf(“\nDigite o numero do dia da semana (1-7): “);
scanf(“%i”,&dia);
switch(dia)
{
case 1:
printf("\n1-Domingo - Sunday");
break;
case 2:
printf("\n2-Segunda-feira - Monday");
break;
case 3:
printf("\n3-Terca-feira - Tuesday");
break;
case 4:
printf("\n4-Quarta-feira - Wednesday");
break;
case 5:
printf("\n5-Quinta-feira - Thursday");
break;
case 6:
printf("\n6-Sexta-feira - Friday");
break;
case 7:
printf("\n7-Sabado - Saturday");
break;
default:
printf("\nDia da semana invalido.");
}// switch
Exemplos de comandos de seleção múltipla INVÁLIDOS:
switch (sexo)
{
case ‘f’:
case ‘F’:
printf(“\nVoce eh do sexo feminino”);
case ‘m’:
case ‘M’:
printf(“\nVoce eh do sexo masculino”);
default:
printf(“\nSexo invalido.”);
}
(falta o comando break dentros dos cases, então todos os printf serão executados)
printf(“\nQual eh a temperatura do seu corpo? “);
scanf(“%f”,&temp);
switch (temp)
{ case 36.0:
case 36.5: printf(“\nVoce não tem febre. Temperatura normal.”);
break;
case 37.0:
case 37.5: printf(“\nVoce esta levemente febril.”);
break;
default: if (temp > 37.5)
printf(“\nVoce esta febril. Procure um medico”);
else
printf(“\nEsta temperatura esta fora dos valores normais”);
}
(O comando switch não aceita valores do tipo real!!! Este comando é totalmente inválido.)
61
6.5. Comando de Repetição while em C
A sintaxe do comando de repetição while é:
while (condição)
{
<bloco de comandos>
}
A semântica (como funciona) do comando de repetição while é:
1. A condição é avaliada como VERDADEIRA (diferente de zero) ou FALSA (igual
a zero);
2. Se a condição for VERDADEIRA, o <bloco de comandos> é executado e, ao se
chegar ao delimitador de fim } ou final do comando, automaticamente se retorna à
avaliação da condição;
4. Se a condição for FALSA, o comando de repetição é finalizado.
Dentre os comandos do <bloco de comandos> é ESSENCIAL que exista um comando
que altere a <condição> que é constantemente avaliada, pois, caso contrário, o comando
enquanto NUNCA TERMINARÁ!
Caso haja um comando break; dentro do comando while, este finaliza
imediatamente o comado while quando for executado.
Os delimitadores { e } são obrigatórios quando existe mais de um comando no <bloco
de comandos>. Quando existir apenas um comando, os delimitadores ficam opcionais e o
“;” funcionará como delimitador de fim, indicando o final do comando while.
Exemplos de comandos de repetição válidos:
Contador=0;
while (Contador < 3)
++Contador;
Numero = 1;
while (Numero <= 100)
{ if (Numero % 2 == 0)
++ContaPar;
else
++ContaImpar;
Numero += 3;
}
Numero = 1;
while (1)
{ if (Numero % 2 == 0)
++ContaPar;
else
++ContaImpar;
Numero += 3;
if (Numero >= 100)
break;
}
62
Exemplos de comandos de repetição INVÁLIDOS ou errados:
while Contador <= 10
++Contador;
(faltaram parênteses na condição)
Numero =1;
while (Numero <= 100)
if (Numero % 2 == 0)
++ContaPar;
else
++ContaImpar;
Numero += 3;
( como não existem os delimitadores de início e fim { } do comando, somente o
comando if faz parte do comando while e como o comando if não altera a variável
Numero, o comando while nunca vai parar!)
Numero = 1;
while (Numero <= 10);
{
Numero += 3;
}
( como foi colocado ; após a condição, o comando while foi finalizado, a variável
Numero não será alterada e o comando while nunca vai parar!)
Numero = 1;
while (1)
Numero += 3;
if Numero >= 10
break;
( como não foram colocados { } delimitando os comandos dentro do while, o comando break
não será executado e o comando while nunca vai parar!)
6.6. Comandos de Leitura e Escrita em C
A sintaxe dos comandos de entrada é:
scanf(“%letra”, & variável);
em que “%letra” representa os especificadores de formato e depende do tipo associado à
variável: “%d” ou “%i” para variáveis do tipo int e “%f” para variáveis do tipo float
variável = getche();
gets(variável);
para variáveis do tipo char (único)
para variáveis do tipo char (string)
63
A tabela abaixo mostra um exemplo de declaração de variáveis de tipos básicos, a forma correta
de leitura e as bibliotecas do C a serem incluídas.
Declaração
Leitura
int numero;
scanf(“%d”, &numero); numero = -5;
numero = 2002;
scanf(“%f”, &valor);
valor = -5.867;
stdio.h
valor = 2002.50;
c=getche();
c = ‘5’;
conio.h
c = ‘s’;
c = ‘#’;
gets(nome);
Atribuição somente através string.h
de função:
strcpy(nome, “Ana”);
float valor;
char c;
char nome[20];
Exemplos de conteúdos
Biblioteca a
ser incluída
stdio.h
A sintaxe dos comandos de saída é:
printf(“[\n] frase
%letra ” [, <lista de variáveis>]);
puts(“[\n] frase”);
No comando printf, entre “ ” podem ser escritas somente frases ou frases formadas por
palavras intercaladas pelos especificadores de formato %s, %c, %i, %d ou %f descritos
nos comandos de leitura. Caso haja especificadores, para cada especificador utilizado, a
variável do tipo correspondente deve constar da <lista de variáveis>.
A lista de variáveis é opcional; deve existir somente quando um especificador de formato é
colocado na frase entre aspas e, neste caso, deve haver uma vírgula separando a frase da lista de
variáveis e vírgulas separando as variáveis da lista.
Os números do tipo float podem ser impressos, no comando printf, com formato para
evitar a forma científica, ou seja, para serem impressos em forma estendida. A parte fracionária
é truncada caso haja mais casas fracionárias do que a delimitada pelo formato, mas a parte
inteira nunca é truncada. Exemplos: %.2f (2 casas na parte fracionária), %3.0f (no mínimo
3 casas na parte inteira, mas não ocorre truncamento nunca, e nenhuma casa na parte
fracionária).
\n é um código de barra invertida que salta uma linha na tela. Pode ser usado em qualquer
posição dentro das aspas em ambos os comandos, puts e printf, e é opcional. O
comando puts salta uma linha após a impressão da frase, mesmo sem \n.
Exemplos de comandos de entrada e saída válidos:
puts (“\nQual é o seu nome? ”);
gets(nome);
printf (“\nQual é a sua idade? ”);
scanf (“%i”,&idade);
64
puts (“\nQual é a sua altura? ”);
scanf (“%f”,&altura);
puts (“\nQual é o seu sexo? (F/M) ”);
sexo=getche();
printf (“\nO seu nome é: %s, \nvocê tem %i anos e\n %.2m de
altura”,nome, idade, altura);
printf (“Você foi aprovado no curso com média= %2.1f”, media);
6.7. Bloco de Programa em C
O Bloco de Programa em C tem a forma:
/* comentários */
<inclusão de bibliotecas>
<declaração de variáveis>
void main()
{
<bloco de comandos>
}
Todo programa C deve começar com o nome do arquivo .c em um comentário dizendo o que o
programa faz.
Em seguida devem ser declaradas todas as variáveis que serão utilizadas no <bloco de
comandos>.
Após a declaração das variáveis deve-se escrever a palavra main( ), que delimita a seção em
que os comandos podem ser utilizados.
O <bloco de comandos> pode conter todos os comandos válidos em C, separados por ; e estes
devem estar contidos entre os delimitadores { e }. Nenhum comando pode ser usado fora desta
seção, a não ser o comando de atribuição para inicializar variáveis na sua declaração.
É importante notar que letras maiúsculas e minúsculas alteram os identificadores e as palavras
reservadas do C.
Alguns compiladores C não aceitam void main( ), mas int main() ou apenas main().
Nestes casos, é necessário colocar-se o comando return 0; antes de finalizar o programa.
65
Exemplo de programas escrito em C válidos:
/* nomesexo.c: le o nome e o sexo de uma pessoa e imprime uma frase
dizendo se é masculino ou feminino */
#include <stdio.h>
#include <conio.h>
char nome[20], sexo;
void main ()
{
clrscr();
// limpa a tela
puts (“Qual eh o seu nome? ”);
gets(nome);
printf (“\nQual eh o seu sexo? (F/M) ”);
sexo=getche();
if (sexo == ‘F’ || sexo == ‘f’)
printf (“\n%s, voce eh do sexo feminino. ”,nome);
else
printf (“\n%s, voce eh do sexo masculino. ”,nome);
puts(“\n Fim do programa”);
getch();
// para a tela
}
/* switch.c - avalia o conhecimento do usuário */
#include <stdio.h>
#include <conio.h>
int opcao;
void main()
{
printf(“\nTeste de avaliacao de conhecimento\n”);
printf(“\nPergunta: Em que ano o Brasil foi descoberto?”);
printf(“\n 1- Em 100 AC por Pitagoras”);
printf(“\n 2- Em 1492 por Cristovao Colombo”);
printf(“\n 3- Em 1500 por Pero Vaz de Caminha”);
printf(“\n 4- Em 1500 por Pedro Alvares Cabral”);
printf(“\n Qual a sua escolha? ”);
scanf(“%d”,&opcao);
switch(opcao)
{ case 1:
printf(“\n Voce precisa ler mais sobre a historia grega !”);
break;
case 2:
printf(“\n Chegou nos paises vizinhos...Mais sorte na proxima vez!”);
break;
case 3:
printf(“\n Naturalmente voce eh um fã da carta do descobrimento!”);
break;
case 4:
printf(“\n Resposta certissima !”);
break;
default: printf(“\nVoce nao escolheu nenhuma das alternativas validas.”);
}
printf(“\n Fim do programa ”);
getch();
}
66
6.8. Funções Úteis em C
A linguagem C fornece uma série de funções úteis que pertencem a diferentes bibliotecas. Segue uma
pequena lista das principais funções.
Funções da biblioteca string.h:
strcat (destino, fonte);
anexa o string <fonte> ao string <destino>
strcpy (destino, fonte);
copia o string <fonte> para o string <destino>
strcmp (string1,string2);
compara o <string1> com o <string 2> pela ordem alfabética (conforme tabela ASCii),
resultando em:
menor que 0: <string1> menor que <string2>
igual a 0: <string1> igual a <string2>
maior que 0: <string1> maior que <string2>
strchr(string, caracter);
verifica se o <caracter> se encontra na <string> e retorna a posição da primeira ocorrência do
<caracter> no <string>; se o <caracter> não for encontrado, retorna NULL
tamanho = strlen(string);
retorna o <tamanho> de uma <string> em número de caracteres.
strrev(string);
retorna a <string> invertida, ou seja, os caracteres em ordem contrária.
strupr(string);
retorna a <string> convertida para letras maiúsculas.
strlwr(string);
retorna a <string> convertida para letras minúsculas.
Funções da biblioteca ctype.h:
letra=toupper(letra);
converte uma <letra> para maiúsculo.
letra=tolower(letra);
converte uma <letra> para minúsculo.
Funções da biblioteca conio.h
clrscr();
limpa a tela
textcolor(cor);
muda a cor da letra
67
textbackground(cor);
muda a cor do fundo
gotoxy(coluna, linha);
posiciona o cursor nas coordenadas especificadas
Funções da biblioteca math.h
Trigonométricas
sin()
Retorna o valor do seno. Recebe como argumento o valor dos graus em double.
cos()
Retorna o valor do co-seno. Recebe como argumento o valor dos graus em double.
tan()
Retorna o valor da tangente. Recebe como argumento o valor dos graus em double.
Logarítmicas
log()
Retorna o valor do logaritmo na base 2. Exige um argumento do tipo double.
log10()
Retorna o valor do logaritmo na base 10. Exige um argumento do tipo double.
Potências
pow()
Retorna o valor da base elevada ao expoente. Recebe dois argumentos do tipo double, o
primeiro é a base e o segundo o expoente. Por exemplo: se quisermos saber o resultado da
operação 210, faríamos pow (2, 10).
sqrt()
Retorna o valor da raiz quadrada. Recebe como argumento um double do qual ele deve
extrair a raiz.
Arredondamento
ceil()
Retorna o primeiro float sem casas decimais acima. Recebe um float como argumento.
Exemplo: ceil (45.98561) resultaria em 46.
floor()
Retorna o primeiro float sem casas decimais abaixo. Recebe um float como argumento.
Exemplo: floor (45.98561) resultaria em 45.
Outras funções system
system(“cls”);
Limpa a tela
system(“pause”);
Faz uma pausa ou para a tela
system("color 0B");
Cor de fundo preta e letras azuis brilhantes
68
6.9. Tradução de PortuCê para a Linguagem C
Comandos/Tipos
Atribuição
PortuCê
=
C
=
Tipos básicos
inteiro
inteiro longo
real
caracter
int
long int
float
char
Formatos
inteiro
real
caracter único
string
inteiro longo
%i ou %d
%f
%c
%s
%ld
Condicional
se senão
if else
Seleção Múltipla
escolha
switch
Leitura de caracteres
Leitura de strings
Leitura de números
leia
leia
leia
getche()
gets
scanf
Escrita
Escrita
imprima
imprima
printf
puts
Operadores lógicos
e
ou
não
&&
||
!
69
O aluno deve implementar todos os programas em C usando o compilador de sua preferência.
/* sexo.c: le o nome e o sexo de uma pessoa e imprime uma frase
dizendo se é masculino, feminino ou invalido */
caracter nome[20], sexo;
principal ( )
{
imprima (“Qual eh o seu nome? ”);
leia(“%s”,nome);
imprima (“Qual eh o seu sexo? (f/m) ”);
leia (“%c”,sexo);
se (sexo == ‘f’ ou sexo == ‘F’)
imprima (“%s voce eh do sexo feminino. ”,nome);
senão se (sexo == ‘m’ ou sexo == ‘M’)
imprima (“%s voce eh do sexo masculino. ”,nome);
senão imprima (“Voce digitou um sexo invalido ”);
imprima(“Fim do programa.”);
}
/* sexo.c: le o nome e o sexo de uma pessoa e imprime uma frase
dizendo se é masculino, feminino ou invalido */
#include <stdio.h>
#include <conio.h>
char nome[20], sexo;
int main()
{
puts (“Qual eh o seu nome? ”);
gets(nome);
puts (“\nQual eh o seu sexo? (f/m) ”);
sexo = getche();
if (sexo == ‘f’ || sexo == ‘F’)
printf (“\n%s voce eh do sexo feminino. ”,nome);
else if (sexo == ‘m’ || sexo == ‘M’)
printf (“\n%s voce eh do sexo masculino. ”,nome);
else printf (“\nVoce digitou um sexo invalido ”);
puts(“\nFim do programa.”);
getch();
return 0;
}
70
/* idade.c: le o ano atual e o ano de nascimento de uma pessoa
e imprime uma frase dizendo qual eh a idade da pessoa */
inteiro anoatual, anonasc, idade;
principal()
{
imprima (“Qual eh o ano atual? ”);
leia(“%i”,&anoatual);
imprima (“Qual eh o seu ano de nascimento? ”);
leia (“%i”,&anonasc);
idade = anoatual – anonasc;
imprima (“Voce fez ou fara %i anos ”, idade);
imprima(“Fim do programa.”);
}
/* idade.c: le o ano atual e o ano de nascimento de uma pessoa
e imprime uma frase dizendo qual eh a idade da pessoa */
#include <stdio.h>
#include <conio.h>
int anoatual, anonasc, idade;
main()
{
printf (“\nQual eh o ano atual? ”);
scanf(“%i”,&anoatual);
printf (“\nQual eh o seu ano de nascimento? ”);
scanf (“%i”,&anonasc);
idade = anoatual – anonasc;
printf (“\nVoce fez ou fara
puts(“\nFim do programa.”);
getch();
return 0;
}
%i anos ”, idade);
71
/* parimpar.c: le um numero e verifica se ele eh par ou impar */
inteiro n;
principal()
{
imprima (“\nDigite um numero inteiro: ”);
leia (“%i”,&n);
se (n % 2 == 0)
imprima (“O numero %i eh par ”, n);
senão
imprima (“O numero %i eh impar ”, n);
imprima(“ Fim do programa.”);
}
/* parimpar.c: le um numero e verifica se ele eh par ou impar */
#include <stdio.h>
#include <conio.h>
int n;
void main()
{
printf (“\nDigite um numero inteiro: ”);
scanf(“%i”,&n);
if (n % 2 == 0)
printf (“\nO numero %i eh par ”, n);
else
printf (“\nO numero %i eh impar ”, n);
puts(“\nFim do programa.”);
getch();
}
72
/* nota.c: le a nota de um aluno e verifica se ele foi aprovado ou
reprovado */
real nota;
principal()
{
imprima (“Digite sua nota final: ”);
scanf(“%f”,&nota);
se (nota >= 6.0)
imprima (“Voce foi aprovado! ”);
senão
imprima (“Voce foi reprovado... ”);
imprima(“ Fim do programa.”);
}
/* nota.c: le a nota de um aluno e verifica se ele foi aprovado ou
reprovado */
#include <stdio.h>
#include <conio.h>
float nota;
void main()
{
printf (“\nDigite sua nota final: ”);
scanf(“%f”,&nota);
if (nota >= 6.0)
printf (“\nVoce foi aprovado! ”);
else
printf (“\nVoce foi reprovado... ”);
printf(“\n Fim do programa.”);
getch();
}
73
Lista de Exercícios 6.1
6.1.1.
6.1.2.
6.1.3.
6.1.4.
6.1.5.
6.1.6.
6.1.7.
6.1.8.
Faça um programa em C para calcular e imprimir a área e o perímetro de uma sala, sendo que os
comprimentos das paredes (comprimento e largura) são fornecidos pelo usuário.
Faça um programa em C para calcular e imprimir o volume de uma esfera. O raio da esfera será fornecido
pelo usuário. Obs: V = 3.14*R2
Faça um programa em C que calcule e imprima o valor em Reais correspondente aos dólares que um turista
possui no cofre do hotel. O programa deve solicitar os seguintes dados: quantidade de dólares guardados no
cofre e cotação do dólar naquele dia.
Faça um programa em C para calcular o valor do desconto, sendo que o preço do produto é fornecido pelo
usuário e o desconto é de 5%. Apresentar o preço do produto, o valor do desconto e o preço final com o
desconto.
Faça um programa em C para calcular e imprimir qual foi a porcentagem de desconto dada em um
determinado produto, sabendo-se o preço original do produto e o preço que foi cobrado por ele depois do
desconto serão fornecidos pelo usuário.
Faça um programa em C que calcule e imprima a quantidade de tijolos iguais necessários para construir
uma determinada parede. São dados de entrada do programa: dimensões do tijolo (comprimento e largura)
e dimensões da parede a ser construída (comprimento e largura).
Faça um programa em C que receba dois valores inteiros nas variáveis A e B. O programa deve trocar os
valores entre as variáveis (ou seja, ao término do programa a variável A deve ter o valor inicial de B e viceversa). Apresentar as duas variáveis o final.
Faça um programa em C para calcular e imprimir o valor a ser pago pelo período de estacionamento do
automóvel. O usuário entra com os seguintes dados: hora e minuto de entrada, hora e minuto de saída.
Sabe-se que este estacionamento cobra R$ 10,00 por hora ou fração.
6.1.9. Faça um programa em C que leia o valor de uma conta de luz e, caso o valor seja maior que R$
50,00 apresente a mensagem: “Você está gastando muito”. Caso contrário exiba a mensagem:
“Seu gasto foi normal, parabéns”.
6.1.10. Faça um programa em C que determine quanto será gasto para encher o tanque de um carro,
sabendo-se que o preço da gasolina é de R$ 2.30 e o preço do álcool é de R$ 1.50. O usuário
fornecerá os seguintes dados: Tipo de carro (as opções como tipo de carro são a letra “G” –
gasolina ou a letra “A” – álcool; rejeitar valores inválidos) e Capacidade do tanque em litros.
6.1.11. Faça um programa em C que leia o valor do salário atual e calcule e imprima o valor do novo
salário de um funcionário. Considere que o funcionário deverá receber um reajuste de 15% caso
seu salário seja menor que R$500.00. Se o salário for maior ou igual a 500, mas menor ou igual a
R$1000.00, o reajuste deve ser de 10%. Caso o salário seja maior que R$1000.00, o reajuste deve
ser de 5%.
6.1.12. Faça um programa em C que receba a leitura do termômetro. Caso a temperatura esteja abaixo de
100ºC, apresentar a mensagem de que a temperatura está muito baixa. Caso a temperatura esteja
entre 100ºC e 200ºC, apresentar a mensagem de que a temperatura está baixa. Caso a temperatura
esteja acima de 200ºC e inferior a 500ºC, apresentar a mensagem de que a temperatura está
normal. Caso contrário, apresentar a mensagem de que a temperatura está muito alta.
6.1.13. Faça um programa em C que, tendo como dados de entrada a altura e o sexo (F/M) de uma pessoa
calcule e apresente seu peso ideal utilizando as seguintes fórmulas: para homens: PESO = (72.7 *
altura) – 58 Para mulheres: PESO = (62.1 * altura) – 44.7
6.1.14. Faça um programa em C que tendo como dados de entrada o preço de um produto e seu código de
origem, apresente o preço e a sua procedência, de acordo com a tabela abaixo:
Código de Origem
1
Procedência
Sul
2
Sudeste
3
Centro-Oeste
4
Norte
5
Nordeste
74
6.1.15. Traduzir o algoritmo em PortuCê para C
/* Eleicoes.c: este programa computa os votos de uma eleição e divulga os
números obtidos e o candidato vencedor.*/
inteiro
Voto, Vencedor, Brancos, Nulos, Eleitores, Cont1, Cont2, Cont3;
principal()
{ imprima (“Digite o seu voto (1,2,3 ou 0(branco) -1 finaliza): ”);
leia (“%i”,&Voto);
Brancos=Nulos=Eleitores=Cont1=Cont2=Cont3=0;
enquanto (Voto != -1)
{
++Eleitores;
se (Voto == 1)
++Cont1;
senão se (Voto == 2)
++Cont2;
senão se (Voto == 3)
++Cont3;
senão se (Voto == 0)
++Brancos;
senão ++Nulos;
imprima (“Digite o seu voto (1,2,3 ou 0(branco) –1 finaliza): ”);
leia (“%i”,&Voto);
}
se ((Cont1 > Cont2) e (Cont1 > Cont3))
Vencedor = 1;
senão se ((Cont2 > Cont1) e (Cont2 > Cont3))
Vencedor = 2;
senão Vencedor = 3;
imprima
imprima
imprima
imprima
}
(“O candidato vencedor foi: %i ”, Vencedor);
(“Numero de votos em branco: %i ”, Brancos);
(“Numero de votos nulos: %i ”,Nulos);
(“Numero de eleitores: %i ”,Eleitores);
75
Capítulo 7
Construção de Programas em C: Metodologia
para Desenvolvimento de Algoritmos
Neste capítulo o aluno aprenderá uma metodologia que facilitará o processo de desenvolvimento
de soluções algorítmicas para problemas propostos. A metodologia é composta de uma sequência de 10
passos, cujo principal objetivo é ajudar o aluno a resolver problemas dividindo-os por partes, diminuindo,
assim, a sua complexidade. Como ficará bem claro logo adiante, resolvendo cada parte do problema por
vez, consegue-se chegar a soluções completas e complexas a partir de soluções simples que já foram,
muitas vezes, encontradas para diversos outros problemas semelhantes.
Você conhecerá os 10 passos da metodologia e vários exemplos práticos serão fornecidos de
maneira a familiarizá-lo com o método. É importante ressaltar que a metodologia é um processo
dinâmico. O aluno pode estar no passo 7 e identificar uma variável auxiliar e voltar aos passos anteriores
e alterá-los, por exemplo. Portanto, não se detenha aos detalhes, pelo contrário, sinta-se livre para criar
suas soluções. O método pretende ajudá-lo e não engessá-lo! Vamos em frente!
7.1. Os 10 passos da metodologia
Passo 1: Ler e entender o problema
entendeu = 0; /* falso */
vezes = 0;
enquanto (entendeu == 0) /* enquanto não entendeu */
{
entendeu = “leia a especificação até o final”;
++vezes;
se (entendeu==0 e vezes > 3)
entendeu = “pergunte a quem especificou até entender e vá para o passo 2”;
}
Este pequeno trecho de algoritmo nos mostra o quanto é importante ler e reler, pelo menos 3 vezes, o
problema até que ele seja completamente compreendido. Não adianta querer buscar a solução de um
problema que não esteja suficientemente esclarecido!
Passo 2: Listar todos os dados de entrada do problema
Um dado de entrada é aquele que será fornecido pelo usuário, ou seja, o dado que será lido pelo
programa.
76
Passo 3: Listar todos os dados de saída do problema
Um dado de saída é algo que será produzido ou calculado pelo programa; tudo aquilo que deve ser
apenas impresso não deve ser considerado um dado de saída.
Passo 4: Listar todas as variáveis auxiliares do programa
Uma variável auxiliar é identificada como aquela que é necessária para o cálculo de alguma
variável de saída e não é variável de entrada. Por exemplo, num problema em que vários números serão
lidos e sua média deva ser calculada, o número é uma variável de entrada e a média é uma variável de
saída, mas como para calcular a média é necessário somar os números e dividir a soma pela quantidade de
números lidos, a soma e a quantidade de números são variáveis auxiliares do programa.
Assim, para se identificar as variáveis auxiliares, basta analisar cada uma das saídas e
verificar se, dadas as estradas, há necessidade de mais alguma variável para facilitar o seu cálculo.
Passo 5: Declarar todas as variáveis do programa
Cada dado de entrada, cada dado de saída e cada variável auxiliar “gera” uma variável. O
número de variáveis do programa deverá ser a soma dos dados de entrada com os dados de saída e com as
variáveis auxiliares.
É extremamente importante que o programador escolha nomes de variáveis significativos,
que possam exprimir a função da variável. Por exemplo, uma variável que receberá a idade de uma
pessoa, não deveria se chamar “x”, nem mesmo “i” seria bom, o ideal seria “idade”.
Passo 6: Inicializar as variáveis do programa
Há um conjunto de pequenas regras que podem nos ajudar a encontrar os valores iniciais de
cada variável do programa, apesar de que nem todas as variáveis precisam ter valores iniciais:
Toda variável de entrada é inicializada com o comando “leia” (scanf, gets, getchar)
Todo contador e todo somador deve ser inicializado com zero
Todo produtório deve ser inicializado com um
Passo 7: Escrever o código para calcular cada uma das saídas do programa
Os principais problemas a serem solucionados, na maior parte das vezes, resumem-se no cálculo das
saídas do programa. Portanto, neste passo, cada uma das saídas deve ser analisada individualmente e sua
solução encontrada separadamente.
Passo 8: Imprimir os resultados do programa
Aqui só devem ser impressos os resultados pedidos na especificação do problema.
Passo 9: Montar o algoritmo unindo os resultados dos passos 5 a 8
Os passos 5 a 8 têm a solução do problema. A montagem do algoritmo/programa pode seguir um
esquema básico, mas vai depender muito da lógica de cada problema. Portanto, o esquema abaixo serve
apenas de uma orientação para o aluno. Cada problema deve, no entanto, ser analisado logicamente para
chegar ao seu algoritmo.
77
/* Nome do Programa e o que ele faz */
<inclusão das bibliotecas>
<passo 5 – declarar todas as variáveis do programa>
void main()
{
<passo 6 – inicializar as variáveis do programa >
<passo 7 – calcular cada uma das saídas do programa>
<passo 8 – imprimir os resultados do programa>
printf(“\n Fim do programa”);
}
Passo 10: Fazer o “teste de mesa” do programa a partir de diferentes valores
iniciais
O “teste de mesa” consiste na execução de todas as instruções do programa a partir de conjuntos de
valores iniciais. Os valores iniciais devem ser escolhidos de maneira que as “condições de contorno” do
problema sejam verificadas. Por exemplo, num programa que trabalhe com flags, deve ser testada a
condição em que o valor do flag seja fornecido como dado inicial; num programa que só leia números
positivos, devem ser fornecidos números negativos e zero; dentre outras situações possíveis.
7.2. Exemplo dos Impulsos Telefônicos
A empresa TELEFUN está interessada em saber qual foi o maior
número de impulsos no mês e quantos assinantes atingiram esse
valor. Faça um programa que leia os valores dos impulsos (o
último valor será –1) e imprima os resultados desejados pela
empresa.
Passo 1 (Ler e entender o problema)
Uma certa cia. telefônica quer saber qual foi o maior número de impulsos gastos num certo mês e
quantos assinantes “empataram” atingindo este valor máximo. Por exemplo, se o conjunto de impulsos é
fornecido:
200, 150, 300, 200, 300, -1
O resultado seria: “300 foi o maior número de impulsos e 2 assinantes atingiram o valor máximo”.
Passo 2 (Dados de entrada)
1) Valor dos impulsos
78
Passo 3 (Dados de saída)
1) Maior número de impulsos
2) Quantos assinantes atingiram o maior número de impulsos
Passo 4 (Variáveis auxiliares)
-
Não há variáveis auxiliares a serem geradas
(Para se chegar a esta conclusão, o raciocínio foi o seguinte: para o cálculo do maior número de
impulsos é necessário apenas comparar o valor do impulso (dado de entrada) com o maior impulso
(dado de saída), ou seja, não precisa de variável auxiliar; para saber a quantidade de assinantes,
somente o contador é necessário...)
Passo 5 (Declarar as variáveis)
int impulsos, maiorimpulsos, quantos;
(Uma variável para cada entrada, saída e cada auxiliar: total de 3 variáveis. Todas do tipo int.)
Passo 6 (Inicializar as variáveis)
printf(“\nDigite o numero de impulsos: ”);
scanf (“%i”,&impulsos);
(variável de entrada do tipo int: inicializada com “scanf”)
maiorimpulsos = 0;
(quando se deseja selecionar o maior valor, uma estratégia possível é considerar o
primeiro valor lido como sendo o maior ou então como sendo zero e depois fazer
a comparação dos outros valores com este...)
quantos = 0;
(contador: inicializado com zero. Poderia ser inicializado na declaração também.)
Passo 7
Há apenas 2 variáveis de saída, então dois trechos a serem construídos. Para se selecionar o maior
número de impulsos é necessário compará-lo com o valor dos impulsos que serão lidos. O comando a ser
utilizado é o “if”.
if (impulsos > maiorimpulsos)
{ maiorimpulsos = impulsos;
quantos = 1;
}
No caso dessa comparação ser verdadeira, o valor do maior impulso deve ser mudado:
maiorimpulsos = impulsos. Mas, ao se alterar o valor do maior impulso, o contador de assinantes que o
atingiram deve ser retornado para 1, pois este seria o primeiro assinante que o utilizou: quantos = 1. A
partir desse raciocínio, teríamos:
79
Resta, agora, contar a quantidade de assinantes que atingiram o valor máximo de impulsos. Isso
deve ser feito através de outra comparação. Cada vez que o valor do maior número de impulsos for
encontrado novamente, deve-se somar 1 ao contador:
if (impulsos == maiorimpulsos)
++quantos;
No entanto, estes 2 trechos devem ser unidos num único comando “if”, pois não se deve somar +1 ao
contador quantos quando ocorre a troca do valor de maiorimpulsos, senão o contador ficaria sempre
com um 1 a mais. Para manter os dois trechos separados, o contador quantos teria que ser inicializado
com zero. Faça alguns testes você mesmo para entender melhor esta explicação.
if (impulsos > maiorimpulsos)
{ maiorimpulsos = impulsos;
quantos = 1;
}
else if (impulsos == maiorimpulsos)
++quantos;
Passo 8 (Impressão dos resultados)
if (maiorimpulsos !=0)
{
printf(“\nO maior numero de impulsos foi: %i ”, maiorimpulsos);
printf(“\nAssinantes que atingiram o maior nro de impulsos: %i”,
quantos);
}
else printf (“\nNenhum valor valido foi fornecido”);
Passo 9 (Montagem do algoritmo/programa)
/* telefun.c: este programa lê um conjunto de valores de impulsos, seleciona o maior
deles e conta quantos assinantes atingiram este valor */
#include <stdio.h>
#include <conio.h>
int
impulsos, maiorimpulsos=0, quantos=0;
void main()
{ while (1)
{
printf(“\nDigite o numero de impulsos (-1 finaliza): ”);
scanf(“%i”,&impulsos);
if (impulsos = -1)
break;
if (impulsos > maiorimpulsos)
{ maiorimpulsos = impulsos;
quantos = 1;
}
else if (impulsos == maiorimpulsos)
++quantos;
}
if (maiorimpulsos !=0)
{ printf(“\nO maior numero de impulsos foi: %i ”, maiorimpulsos);
printf(“\nAssinantes que atingiram o maior nro de impulsos: %i”, quantos);
}
else printf (“\nNenhum valor valido foi fornecido”);
}
80
Passo 10 (Fazer o teste de mesa do algoritmo)
Suponha os seguintes valores de entrada: 100, 50, 100, 150, 150, 10, 150 , -1
impulsos
100
50
100
150
150
10
150
-1
maiorimpulsos
0
100
quantos
0
1
150
2
1
2
Resultados
3
O maior número de impulsos foi: 150
Número de assinantes que atingiram o maior número
de impulsos: 3
Suponha o seguinte valor de entrada: -1
impulsos
-1
maiorimpulsos
0
quantos
0
Resultados
Nenhum valor valido foi fornecido
7.3. Exemplo do Preço Final de Automóveis
O preço final de um automóvel novo é calculado da
seguinte forma: ao preço de fábrica são acrescidos 35% de
IPI e sobre o preço já com o IPI é acrescido 5%
correspondente ao ICMS. Faça um programa que leia o
nome de vários modelos de automóveis (flag=FIM) e o seu
preço de fábrica e calcule e imprima o seu preço final.
Passo 1 (Ler e entender o problema)
Suponhamos a seguinte entrada de dados:
BMW 70000.00
GOL 20000.00
FIM
O preço final do BMW seria assim calculado:
IPI 70000.00 x 0.35 = 24500.00
PRIPI 70000.00 + 24500.00=94500.00
FINAL PRIPI x 1.05 = 99225.00
O preço final do GOL seria assim calculado:
IPI 20000.00 x 1.35 =
PRIPI 20000.00 + 7000.00=27000.00
FINAL PRIPI x 1.05 = 28350.00
Passo 2 (Dados de entrada)
1) Nome do modelo do automóvel
2) Preço de fábrica do automóvel
81
Passo 3 (Dados de saída)
1) Preço final do automóvel
Passo 4 (Variáveis auxiliares)
1) Valor do IPI
2) Preço do automóvel com o IPI
(Para se chegar a esta conclusão, o raciocínio foi o seguinte: dado o preço de fábrica, primeiro
calcula-se o preço com o IPI numa variável auxiliar; depois é feito o cálculo do preço do carro com o
valor do IPI, gerando duas variáveis auxiliares)
Passo 5 (Declarar as variáveis)
char nome[20];
float
prFabrica, IPI,
prIPI, prFinal;
(Uma variável para cada entrada, uma para cada saída, uma para cada auxiliar: total de 5 variáveis)
Passo 6 (Inicializar as variáveis)
printf(“\nForneca o nome do modelo do automovel: ”);
gets (nome);
printf(“\nForneca o preco de fabrica do automovel: ”);
scanf (“%f”,&prFabrica);
(variáveis de entrada: inicializadas com “leia”)
(as outras variáveis não precisam de valores iniciais, pois o IPI, o preço com o IPI e o preço final
serão calculados diretamente)
Passo 7 (Escrever o código para calcular as saídas)
Há apenas uma variável de saída, então um trecho de algoritmo a ser construído. Para se chegar
ao preço final, no entanto, primeiro é necessário calcular o preço com o IPI.
IPI = prFabrica * 0.35;
prIPI = prFabrica + IPI;
prFinal = prIPI * 1.05;
Aqui são apresentadas 2 formas diferentes de se fazer o cálculo de porcentagem. No caso do IPI,
isso foi feito em 2 passos: primeiro calcula-se o IPI e depois soma-se este valor ao preço de fábrica para
se obter o preço com IPI. No caso do ICMS, foi feito um único cálculo multiplicando-se o preço com IPI
por 1.05. Neste caso, o valor 1 na parte inteira faz com que seja somado ao preço com IPI o valor do
ICMS!
82
Passo 8 (Impressão dos resultados)
printf(“\nIPI= R$%.2f ICMS= R$%.2f“,IPI,prIPI*0.05);
printf (“\nO preco final do automovel %s= R$ %.2f ”,
nome, prFinal);
Passo 9 (Montagem do algoritmo)
/* zerokm.C: este programa lê o nome e o preço de fábrica de vários automóveis e
calcula seu preço final. */
#include <stdio.h>
#include <conio.h>
char nome[20];
float prFabrica, IPI, prIPI, prFinal;
void main()
{ clrscr;
while (1)
{
printf(“\nForneca o nome do modelo do automóvel (FIM para terminar): ”);
gets (nome);
if (strcmp(nome,”FIM”)==0)
break;
printf(“\nForneca o preço de fabrica do automovel: ”);
scanf (“%f”,&prFabrica);
IPI = prFabrica * 0.35;
prIPI = PrFabrica + IPI;
prFinal = prIPI * 1.05;
printf(“\nIPI= R$%.2f ICMS= R$%.2f“,IPI,prIPI*0.05);
printf (“\nPreco final do automovel %s= R$ %.2f ”,nome, prFinal);
}
puts (“Fim do programa”);
}
Passo 10 (Fazer o teste de mesa do algoritmo)
Suponha os seguintes valores de entrada:
ECOSPORT 30000.00
nome
10000.00
KA
prFinal
IPI
prIPI
ECOSPORT
30000.00
10500.00
40500.00
MILLE
10000.00
3500.00
13500.00
KA
12000.00
4200.00
16200.00
CIVIC
50000.00
17500.00
67500.00
FIM
prFabrica
MILLE
12000.00 CIVIC 50000.00 FIM
Resultados
42525.00 IPI= R$ 10500.00 ICMS=2025.00
Preco final do automovel ECOSPORT= R$42525.00
14175.00 IPI= R$ 3500.00 ICMS=675.00
Preco final do automovel UNO= R$14175.00
17010.00 IPI= R$ 4200.00 ICMS=810.00
Preco final do automovel KA= R$17010.00
70875.00 IPI= R$ 17500.00 ICMS=3375.00
Preco final do automovel CIVIC= R$70875.00
Fim do programa
83
7.4. Exemplo da Eleição
Existem 3 candidatos a uma vaga no senado. Durante a eleição, os
votos são computados eletronicamente através do seguinte código:
1, 2, 3 votos para os candidatos 1, 2 e 3
0 voto em branco
≠ 0,1,2,3 voto nulo
-1 fim dos votos
Fazer um algoritmo que forneça o número do candidato vencedor, a quantidade de votos nulos e
brancos e a quantidade de eleitores que participaram da eleição. Suponha que não haverá empates.
Passo 1 (Ler e entender o problema)
Vamos simular a eleição e computar seus resultados. Esses foram os votos:
0,2,3,2,3,1,1,1,3,2,0,1,1,0,3,5,1,9,3,-1.
Votos do candidato 1: 6, votos do candidato 2: 3, votos do candidato 3: 5, votos em branco: 3,
votos nulos: 2, total de eleitores: 19.
Resultados:
Candidato vencedor: 1
Quantidade de votos brancos: 3
Quantidade de votos nulos: 2
Total de eleitores: 19
Passo 2 (Dados de entrada)
1) Votos
Passo 3 (Dados de saída)
1)
2)
3)
4)
Candidato vencedor
Votos brancos
Votos nulos
Total de eleitores
Passo 4 (Variáveis auxiliares)
1) Contador de votos para o candidato 1
2) Contador de votos para o candidato 2
3) Contador de votos para o candidato 3
Passo 5 (Declarar as variáveis)
int
int
int
voto;
vencedor, brancos, nulos, eleitores;
cont1, cont2, cont3;
Passo 6 (Inicializar as variáveis)
pritnf(“\nDigite o seu voto (1,2,3 ou 0(branco)): ”);
scanf (“%i”,&voto);
(variável de entrada: inicializada com “leia”)
84
brancos=nulos=eleitores=cont1=cont2=cont3=0;
(contadores: inicializados com zero. Em C é possível inicializar várias variáveis com
o mesmo valor num único comando! )
Passo 7 (Escrever o código para calcular as saídas)
Para se saber quem foi o candidato vencedor, é necessário, primeiro, computar os votos:
++eleitores;
if (voto == 1)
++cont1;
else if (voto == 2)
++cont2;
else if (voto == 3)
++cont3;
else if (voto == 0)
++brancos;
else ++nulos;
Existe uma outra maneira muito mais prática de se realizar esta comparação. Basta usar o comando
de seleção múltipla switch. Veja como fica a solução.
++eleitores;
switch (voto)
{ case 0:
++brancos;
break;
case 1:
++cont1;
break;
case 2:
++cont2;
break;
case 3:
++cont3;
break;
default: ++nulos;
}
Note que os dois trechos de código fazem exatamente a mesma coisa, mas de formas diferentes. Escolha
a que achar mais fácil.
Ao se computar os votos, as saídas 2, 3 e 4 foram obtidas, resta, agora obter o candidato vencedor.
if ((cont1 > cont2) && (cont1 > cont3))
vencedor = 1;
else if ((cont2 > cont1) && (cont2 > cont3))
vencedor = 2;
else vencedor = 3;
85
Passo 8 (Impressão dos resultados)
printf(“\nO candidato vencedor foi: %i ”, vencedor);
printf(“\nNumero de votos em branco: %i ”,brancos);
printf(“\nNumero de votos nulos: %i ”,nulos);
printf(“\nNumero de eleitores: %i ”,eleitores);
Passo 9 (Montagem do algoritmo)
/* Eleicoes.c: computa os votos de uma eleição e divulga os números obtidos e o
candidato vencedor.*/
#include <stdio.h>
#include <conio.h>
int
voto, vencedor, brancos, nulos, eleitores, cont1, cont2, cont3;
void main ()
{ clrscr();
brancos=nulos=eleitores=cont1=cont2=cont3= 0;
while (1)
{
printf (“\nDigite o seu voto (1,2,3 ou 0(branco) -1 finaliza): ”);
scanf (“%d”,&voto);
if (voto==-1)
break;
++eleitores;
switch (voto)
{ case 0: ++brancos;
break;
case 1: ++cont1;
break;
case 2: ++cont2;
break;
case 3: ++cont3;
break;
default: ++nulos;
}
}
if ((cont1 > cont2) && (cont1 > cont3))
vencedor = 1;
else if ((cont2 > cont1) && (cont2 > cont3))
vencedor = 2;
else vencedor = 3;
printf
printf
printf
printf
(“\nO candidato vencedor foi: %d ”, vencedor);
(“\nNumero de votos em branco: %d ”, brancos);
(“\nNumero de votos nulos: %d ”,nulos);
(“\nNumero de eleitores: %d ”,eleitores);
puts(“\nFim do programa”);
getch();
}
86
Passo 10 (Fazer o teste de mesa do algoritmo)
Suponha os seguintes valores de entrada: 1,2,2,0,2,1,3, -1
voto cont1 cont2
1
2
2
0
2
1
3
-1
0
1
0
cont3
0
brancos
0
nulos
0
1
2
1
3
2
1
eleitores vencedor
0
1
2
3
4
5
6
7
2
7.5. Exemplos de Programas em C
/*CoresnoDevC.c: mostra como usar cores de texto e de fundo no DevC++ */
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
int main()
{ system ("cls"); // limpa a tela
system ("color 0B"); // cor de fundo preta e letras azuis brilhantes
printf ("\n\n\t\t\tTESTE: AZUL");
getch();
system ("cls"); // limpa a tela
system ("color 4C"); // cor de fundo vermelha e letras vermelhas brilhantes
printf ("\n\n\t\t\tTESTE: VERMELHO");
getch();
system ("cls"); // limpa a tela
system ("color 5D"); // cor de fundo roxa e letras lilases brilhantes
printf ("\n\n\t\t\tTESTE: LILAS");
getch();
system ("cls"); // limpa a tela
system ("color 0E"); // cor de fundo preta e letras amarelas brilhantes
printf ("\n\n\t\t\tTESTE: AMARELO");
getch();
system ("cls"); // limpa a tela
system ("color 1B"); // cor de fundo azul e letras azuis claras
printf ("\n\n\n");
system ("color /? |more");
getch();
}
Resultados
O candidato vencedor foi: 2
Numero de votos em branco: 1
Numero de votos nulos: 0
Numero de eleitores: 7
Fim do programa
87
/*
SomaInt.c:
Este programa le e soma varios numeros inteiros */
#include <stdio.h>
int Soma, Valor;
int main( )
{
printf("\nPrograma que le varios numeros inteiros e calcula sua soma\n\n");
Soma = 0;
printf("Forneca um valor: ");
scanf("%d",&Valor);
while (Valor != -1)
{ Soma = Soma + Valor;
printf("Forneca um valor (flag= -1): ");
scanf("%d",&Valor);
}
printf("\nValor da soma: %d \n",Soma);
printf("\nFim do programa... ");
getch(); /* para a tela */
return 0;
}
/*Potencia2.c: mostra números potencia de 2 usando long int */
#include <stdio.h>
#include <conio.h>
long int numlong;
int main()
{
printf("\n Sequencia de numeros potencia de 2 menores que 1000000");
printf("\n ===========================================n\n");
numlong=2;
while (numlong<1000000)
{ printf("%ld\t",numlong);
numlong = numlong * 2;
}
printf ("\n\n\n\n Fim do programa");
getch();
return 0;
}
88
/*Impares.c: gera numeros impares menores que 100 */
#include <stdio.h>
#include <conio.h>
int num;
int main()
{
printf("\n Sequencia de numeros impares menores que 100");
printf("\n ===================================\n\n");
num=1;
while (num<100)
{
printf("%i\t",num);
num = num + 2;
if (num%10==1)
getch();
}
printf ("\n\n\n\n Fim do programa");
getch();
return 0;
}
/*Multiplos3.c: gera multiplos de 3 menores que 500 */
#include <stdio.h>
#include <conio.h>
int num, contnum;
int main()
{
printf("\n Sequencia de numeros multiplos de 3 menores que 500");
printf("\n ========================================\n\n");
contnum=0;
num=3;
while (num<500)
{
printf("%i\t",num);
num = num + 3;
if (contnum==20)
{
getch();
contnum=0;
}
++contnum;
}
printf ("\n\n\n\n Fim do programa");
getch();
return 0;
}
89
/*Pesquisa.c: realiza uma pesquisa de opinião, computando votos em numero e em percentual */
#include<conio.h>
#include<stdio.h>
#include<stdlib.h>
int opcao, sexo, afavor=0, contra=0, homens=0,mulheres=0, total;
float porcent;
int main()
{
while (1)
{
system("cls"); // limpa a tela
printf ("\nReferendo sobre a internacionalizacao da Amazonia. Qual eh sua opiniao?");
printf ("\n1 - A favor");
printf ("\n2 - Contra");
printf ("\n0 - Finaliza");
printf ("\nDigite a opcao desejada: ");
scanf ("%i",&opcao);
if (opcao == 0)
break;
while (1)
{
printf("\nInforme o seu sexo 1=masculino 2=feminino: ");
scanf("%i", &sexo);
if (sexo == 1)
{ ++homens;
break;
}
else if (sexo == 2)
{ ++mulheres;
break;
}
else
printf("\nSexo invalido. Por favor, digite 1 ou 2.\n");
}
switch (opcao)
{ case 1:
printf("\nObrigada, voto computado!");
++afavor;
break;
case 2: printf("\nObrigada, voto computado!");
++contra;
break;
default: printf("\nOpcao invalida.");
}
getch();
} // while 1
90
total = mulheres + homens;
printf("\nResultados da pesquisa\n");
printf("----------------------");
printf("\n\n%i votante(s) do sexo masculino.", homens);
if (total > 0)
{ porcent = (float) homens/total;
printf("\n%.1f %% dos votantes sao homens",porcent*100);
}
printf("\n\n%i votante(s) do sexo feminino.", mulheres);
if (total > 0)
{ porcent = (float) mulheres/total;
printf("\n%.1f %% dos votantes sao mulheres",porcent*100);
}
total = afavor + contra;
printf("\n\n%i votante(s) a favor.", afavor);
if (total > 0)
{ porcent = (float) afavor/total;
printf("\n%.1f %% dos votantes sao a favor",porcent*100);
}
printf("\n\n%i votante(s) contra.", contra);
if (total > 0)
{ porcent = (float) contra/total;
printf("\n%.1f %% dos votantes sao contra",porcent*100);
}
getch();
printf("\n\n\nFim do programa");
getch();
return 0;
}
91
/*Compara.c: mostra como se apresenta um menu e se comparam strings e numeros */
#include <stdlib.h>
#include <conio.h>
#include <stdio.h>
#include <string.h>
char str1[20], str2[20];
int num1, num2, opcao;
int main()
{
while ( 1 )
{
printf("\n 1- Compara strings ");
printf("\n 2- Compara numeros ");
printf("\n 0- Finaliza ");
printf("\n\n Escolha sua opcao: ");
scanf ("%i", &opcao);
if (opcao == 0)
{ printf ("\n Bye, bye! Pressione ENTER...");
getch();
break;
}
switch (opcao)
{ case 1:
printf ("\n Forneca o primeiro nome: ");
gets(str1);
printf ("\n Forneca o segundo nome: ");
gets(str2);
if (strcmp(str1,str2) > 0)
printf ("\n %s vem depois de %s ", str1, str2);
else if (strcmp(str1,str2) < 0)
printf ("\n %s vem antes de %s ", str1, str2);
else printf ("\n Os nomes são iguais.");
getch();
break;
case 2:
printf ("\n Forneca um numero inteiro: ");
scanf("%d", &num1);
printf ("\n Forneca outro numero inteiro: ");
scanf("%d", &num2);
if (num1>num2)
printf ("\n %d eh maior que %d ", num1, num2);
else if (num2>num1)
printf ("\n %d eh maior que %d ", num2, num1);
else printf ("\n Os numeros sao iguais! ");
getch();
break;
default:
printf ("\n Opçao de menu invalida. ");
getch();
} // fim do switch
} // fim do while (1)
return 0;
} // fim do main()
92
Lista de Exercícios 7.1
7.1.1) Fazer um programa que leia vários valores de ângulos (flag=-1) e verifique a qual quadrante
pertence este ângulo.
900
180
20
10
00
30
40
3600
0
2700
7.1.2) Fazer um programa que leia vários pares de números N1 e N2 (Flag=N1=0) e calcule e imprima:
a) N1 * N2
b) N1 / N2
c) N1 - N2
d) N1 + N2
e) 10% de N1
f) 25% de N2
g) raiz quadrada de N1
h) raiz quadrada de N2
i) a unidade de N1
j) a dezena de N2
k) o resto da divisão inteira de N1 por N2
l) N1 elevado a 3
m) N2 elevado a 2 n) N1 elevado a N2
7.1.3) Fazer um programa que leia 10 respostas S = sim ou N = não à pergunta “Você está
desempregado?” e calcule e imprima a porcentagem de respostas S e a porcentagem de respostas N.
7.1.4) Fazer um programa que pergunte a vários usuários “Qual é o seu sexo? (F=feminino,
M=masculino) e calcule e imprima quantos são homens e quantos são mulheres. Sexo = X para terminar.
7.1.5) Fazer um programa que leia vários números inteiros (flag=0) e conte e imprima quantos são pares e
positivos, pares e negativos, ímpares e positivos, ímpares e negativos.
7.1.6) Fazer um programa que leia o NOME, a ALTURA, o PESO e a IDADE de vários homens
(flag=NOME=fim) e verifique se eles podem ser aprovados ou não para o cargo de segurança:
1.80 <= ALTURA <= 2.10
90 <= PESO <= 120
30 <= IDADE <= 45
7.1.7) Fazer um programa que leia o número de termos desejados e gere as seqüências numéricas (uma de
cada vez, mas ambas no mesmo programa):
2, 4, 8, 16, 32, 64 ....
1, -1, 2, -2, 3, -3, 4, -4....
7.1.8) O preço final de um automóvel é calculado pelo preço de fábrica mais o valor do IPI = 40% sobre
o preço de fábrica, mais a porcentagem da concessionária= 10% sobre o preço já com o IPI. Faça um
programa que leia o NOME de vários modelos de automóveis (flag=NOME=jegue) e o preço de fábrica e
calcule e imprima o seu preço final.
7.1.9) Fazer um programa que leia vários números (flag=-1) e conte a quantidade de números ímpares, a
quantidade de números múltiplos de 3 e a quantidade de números negativos.
93
7.1.10) Faça um programa que leia a ALTURA e o SEXO de várias pessoas (flag=ALTURA=0) e
conte a quantidade e imprima uma frase dizendo se se trata:
- de uma mulher baixa (<1.55)
- de um homem baixo (<1.70)
- de uma mulher alta (>1.70)
- de um homem alto (>1.90)
- de um homem de estatura mediana
- de uma mulher de estatura mediana
7.1.11) Fazer um programa que peça ao usuário para escolher algumas características de aves e adivinhe
qual é a ave que se encaixa no conjunto de características fornecidos. Pergunte ao usuário se ele deseja
continuar (S/N) para repetir as perguntas.
Tropical
Polar
pingüim
avestruz
Não voadora
Ave
Nadadora
pato
De rapina
águia
7.1.12) Fazer um programa para calcular a média de um conjunto de números inteiros (flag = -1).
7.1.13) Fazer um programa para calcular as raízes de uma equação do 2º grau. Os valores dos
coeficientes A, B e C serão fornecidos pelo usuário.
7.1.14) Fazer um programa para ler o valor do raio de várias esferas (R) (flag = -1) e calcular e imprimir o
seu volume (V). (V = (4πR3) / 3)
7.1.15) Fazer um programa para ler uma sequência de números inteiros de 5 dígitos (flag = -1), calcular o
seu dígito verificador (DV) e imprimir o número lido e seu DV separado por um hífen. O DV é calculado
somando-se os 5 dígitos do número, dividindo esta soma por 11 e obtendo o resto desta divisão inteira.
Quando o DV for 10, deve-se imprimir X.
Exemplo:
Número lido: 12819
DV = 1 + 2 + 8 + 1 + 9 = 21 11
-11 1
10
Número impresso: 12819 - X
7.1.16) Números palíndromos são aqueles que têm o mesmo valor se lidos da esquerda para a direita ou
da direita para a esquerda, como: 44, 232, 1001, 838, etc. Fazer um programa que leia vários números
inteiros de 4 dígitos (flag= -1) e imprima o número lido e uma frase dizendo se ele é palíndromo ou não.
94
7.1.17) Fazer um programa para calcular o valor aproximado de π, utilizando-se os N primeiros termos
(N deverá ser lido) da série:
π =4- 4 + 4 - 4 +
3
5
7
4 - ....
9
7.1.18) Fazer um programa para ler um conjunto de 200 dados que contém a resposta “SIM” ou “NÃO”
de uma pessoa e seu sexo (“F”=feminino, “M”=masculino) e calcular e imprimir:
a) o número de pessoas que responderam “SIM”
b) o número de pessoas que responderam “NÃO”
c) a porcentagem de mulheres que responderam “SIM”
d) a porcentagem de homens que responderam “NÃO”
e) o número de mulheres que responderam “NÃO”
7.1.19) Fazer um programa para calcular e imprimir o valor de H, dado pela seguinte série:
H=
1 - 2 + 4 - 8
225 196 169 144
+ 16 - .... + 16.384
121
1
7.1.20) Fazer um programa para calcular o imposto de renda (IR) de um grupo de contribuintes, sabendo
que:
a) Deverão ser lidos o CPF e a renda anual de cada contribuinte (último contribuinte tem o
CPF = 0);
b) O IR deverá ser calculado de acordo com a tabela:
Renda Anual
até 5000,00
de 5000,01 até 50000,00
acima de 50000,01
Alíquota para cálculo do IR
isento
10 %
15 %
c) Deverá ser impressa uma frase com o CPF do contribuinte, sua renda anual e o valor do IR.
7.1.21) Fazer um programa que leia um conjunto de números inteiros (flag=0) e calcule e imprima:
a) a quantidade de números pares lidos
b) a quantidade de números ímpares lidos
c) a quantidade de quadrados perfeitos lidos
d) a porcentagem de números negativos
e) a quantidade de números maiores do que 1000
7.1.22) Fazer um programa que leia vários conjuntos de dados com: o NOME de um produto, seu preço
de CUSTO, seu preço de VENDA e a QUANTIDADE vendida do produto (último conjunto lido tem
NOME do produto=“fim”) e calcule o lucro obtido com o produto. No final o programa deve imprimir o
NOME do produto que deu mais lucro.
7.1.23) Fazer um programa que leia vários números que representam um determinado número de mês do
ano (flag=-1), escreva o nome do mês por extenso e o número de dias. Se o mês não existir, imprimir uma
frase de erro.
7.1.24) Um certo produto custa R$ 100,00 e é concedido um desconto de 10% se a compra for acima de
10 unidades, 15% se for acima de 40 unidades e 25% se for acima de 100 unidades. Faça um programa
que leia a quantidade desejada por vários clientes (flag=quantidade=0) e calcule e imprima o preço sem
desconto, o valor do desconto (se não houver desconto, imprima 0) e o valor a ser pago com o desconto.
95
7.1.25) Faça um programa que leia a distância em quilômetros percorrida por vários carros (flag=0), a
quantidade de combustível consumida e calcule e imprima o consumo médio de combustível.
(Consumo= distância/combustível)
7.1.26) Faça um programa que leia várias temperaturas em graus Fahreinheit (flag=1000) e calcule e
imprima a temperatura em graus Celsius.
(Celsius = (Fahreinheit-32) * (5/9))
7.1.27) Faça um programa que leia vários pares de valores N1 e N2 (flag=N1=0), imprima uma frase
dizendo se eles são iguais, qual é o maior e qual é o menor e após terminar a leitura de todos os números,
selecione e imprima o maior e o menor de todos.
7.1.28) Fazer um programa que leia vários pares de coordenadas X e Y (flag=X=1000) e verifique a qual
quadrante pertence este ponto (X,Y). A seta indica o sentido positivo dos eixos.
Y
20
10
X
30
40
7.1.29) Fazer um programa que leia vários números inteiros (flag=0) e verifique se o número é primo ou
não. Um número primo só é divisível por 1 e por ele mesmo. (Sugestão: tente dividir o número por 2, 3,
4, 5...até o valor do número; se alguma divisão resultar em zero, ele não é primo...).
7.1.30) Fazer um programa para ajudar o IBGE a fazer o senso populacional de São Paulo. Para isto, os
seguintes dados devem ser pedidos aos usuários (último usuário tem IDADE = -1): IDADE, SEXO (H=
homem, M=mulher) e RENDA (nº de salários mínimos - s.m.) e o programa deve calcular e imprimir:
a) o total de pessoas, o total de homens e o total de mulheres em quantidade e em percentual
b) a porcentagem de crianças (até 12 anos), adolescentes (de 13 a 20 anos) e adultos (acima de 20)
c) a porcentagem de pessoas da classe C (até 4 s.m.), da classe B (até 20 s.m.) e da classe A
(acima de 20 s.m.)
7.1.31) Fazer um programa para calcular o salário líquido dos funcionários de uma pequena empresa.
Devem ser lidos seguintes dados de cada funcionário: nome, número de horas trabalhadas, número de
horas-extra e número de dependentes. O último funcionário tem o nome = ÚLTIMO. O salário é
calculado da seguinte maneira:
SALÁRIO BRUTO = (número de horas trabalhadas * VHT) + (número de horas-extra * VHE) +
(número de dependentes * VCD)
SALÁRIO LÍQUIDO = SALÁRIO BRUTO - (desconto IR) - (desconto INSS)
VHT
R$ 14.00
VHE
R$ 21.00
VCD
R$ 100,00
desconto IR
12% do SALÁRIO BRUTO
desconto INSS
8% do SALÁRIO BRUTO
96
7.1.32) Faça um programa que apresente o menu de livros à venda numa livraria:
Código do Livro
1
Título
Informática para
Concursos
Preço
87,00
2
Java como Programar
219,00
3
Use a cabeça: C#
99,00
0
finaliza
Para cada opção válida de livro (rejeitar escolhas inválidas), oferecer as formas de pagamento.
Código da forma de pagamento
1
2
Condição de pagamento
À vista com 10% de desconto
Em 2 vezes, preço normal de etiqueta sem juros
Imprimir todos os valores de acordo com a escolha do usuário. Rejeitar formas de pagamento inválidas.
7.1.33) Faça um programa que leia o código de um livro (* finaliza) e apresente a categoria do livro,
conforme a tabela abaixo:
Código do Livro
Categoria
A
Ficção
B
Romance
C
Documentário
D
Audiolivro
E
Técnico
7.1.34) Faça um programa que leia o código de um determinado produto (0 finaliza) e mostre a sua
classificação, utilizando a seguinte tabela:
Código do Produto (CP)
Classificação
1
Alimento não perecível
2, 3 ou 4
Alimento perecível
5 ou 6
Vestuário
7
Higiene Pessoal
8 ou 9
Limpeza e Utensílios Domésticos
Qualquer outro código
Inválido
7.1.35) Faça um programa em C para calcular o valor a ser pago pelo período de estacionamento do
automóvel. O usuário entra com os seguintes dados: hora e minuto de entrada, hora e minuto de saída.
Sabe-se que este estacionamento cobra hora cheia, ou seja, se passar um minuto ele cobra a hora inteira.
O valor cobrado pelo estacionamento é:
o R$ 4,00 para 1 hora de estacionamento
o R$ 6,00 para 2 horas de estacionamento
o R$ 1,00 por hora adicional (acima de 2 horas)
97
Respostas de Alguns Exercícios
Respostas da lista de exercícios nº 4.1
4.1.1) Escreva um algoritmo que leia e imprima o nome e as duas notas de um aluno.
/* notas.c: programa que le e imprime 2 notas */
caracter
real
nome[20];
nota1, nota2;
principal()
{
imprima (“Qual eh o seu nome?
leia (“%s”,nome);
“);
imprima (“Digite a primeira nota do aluno: “);
leia (“%f”,&nota1);
imprima (“Digite a segunda nota do aluno:
leia(“%f”,&nota2);
“);
imprima (“%s, sua 1a nota foi: %1.2f e a sua 2a nota foi: %1.2f “,
nome,nota1,nota2);
imprima (“Fim do programa”);
}
4.1.2) Escreva um comando que calcule a média das duas notas lidas no exercício 4.1.1.
media = (nota1 + nota2) / 2;
4.1.3) Escreva um comando que verifique se a média calculada no exercício 4.1.2 é maior ou igual a 7; se
for, imprima uma frase dizendo que o aluno foi aprovado, caso contrário, imprima uma frase dizendo que
foi reprovado.
se (media >= 7.0)
imprima (“Voce foi aprovado! “);
senão
imprima (“Voce foi reprovado...”);
98
4.1.4) Escreva um algoritmo que leia o nome e as duas notas de um aluno, calcule a média das notas e
imprima uma frase dizendo se ele foi aprovado (média maior ou igual a 7.0) ou reprovado.
/* media.c: programa que calcula a media de 2 notas e verifica a aprovacao do
aluno */
caracter
real
nome[20];
nota1, nota2, media;
principal()
{
imprima (“Qual eh o seu nome?
leia (“%s”,nome);
“);
imprima (“Digite a primeira nota do aluno: “);
leia (“%f”,&nota1);
imprima (“Digite a segunda nota do aluno:
leia(“%f”,&nota2);
“);
media = (nota1 + nota2) / 2;
se (media >= 7.0)
imprima (“%s voce foi aprovado! “,nome);
senão
imprima (“%s voce foi reprovado...”, nome);
imprima(“Fim do programa “);
}
Respostas dos exercícios da Lista 4.2
4.2.1)
a) Se B1 é verdadeiro o comando C1 do primeiro “se” será executado e o ninho de comandos “se” será
finalizado (lembre-se que o “senão” não poderá ser executado, pois a condição “se B1” foi avaliada como
verdadeira!). Finalizado o ninho de comandos “se”, o próximo comando a ser executado é o C5.
Resposta: C1 e C5
b)
Se B1 é falso o “senão” do primeiro “se” será executado e a condição do segundo comando “se”
será avaliada. ComoB2 é verdadeiro, o segundo “se” será executado e a condição do terceiro comando
“se” será avaliada. Como B3 é falso, o “senão” do terceiro “se” será executado, ou seja, os comandos C3
e C4 serão executados e o ninho de comandos “se” será finalizado. Finalizado o ninho de comandos “se”,
o próximo comando a ser executado é o C5.
Resposta: C3, C4 e C5
c)
Se B1 é falso o “senão” do primeiro “se” será executado e a condição do segundo comando “se”
será avaliada. Como B2 é verdadeiro, o segundo “se” será executado e a condição do terceiro comando
“se” será avaliada. Como B3 é verdadeiro, o comando C2 do terceiro “se” será executado e o ninho de
comandos “se” será finalizado. Finalizado o ninho de comandos “se”, o próximo comando a ser
executado é o C5.
Resposta: C2 e C5
99
d) Se B1 é falso o “senão” do primeiro “se” será executado e a condição do segundo comando “se” será
avaliada. Como B2 é falso e não existe o “senão” do segundo “se”, o ninho de comandos “se” será
finalizado. Finalizado o ninho de comandos “se”, o único comando a ser executado é o C5!
Resposta: B1 = Falso, B2= Falso e B3 não precisa ser definido...
4.2.2) Após a inicialização das variáveis, a condição do comando “se” deve ser avaliada. Como esta não
é uma condição simples, vamos analisá-la por partes:
“(C)” = Falso
“(X+Y > 5)” = “(1.5 + 3.2 = 4.7 ... 4.7 > 5 ?)” = Falso
“não (A e B)”= “(não (Falso e Verdadeiro) = não(Falso))” = Verdadeiro
Falso ou Falso ou Verdadeiro = Verdadeiro!
Como a condição do comando “se” foi avaliada como verdadeira, o comando “L=0” será executado e o
algoritmo será finalizado!
Resposta: L=0
4.2.3)
a) o total de homens
se (sexo == ‘H’ ou sexo == ‘h’)
++contHomens;
b) o total de mulheres
se (sexo == ‘M’ ou sexo == ‘m’)
++contMulheres;
c) o total de pessoas da classe C (até 4 s.m.), da classe B (até 20 s.m.) e da cl. A (acima de 20 s.m.)
se (renda <= 4)
++contClasseC;
senão se (renda <= 20)
++contClasseB;
senão ++contClasseA;
O trecho da letra c) pode ser escrito em 3 comandos “se” separados. Ficaria assim:
“se (renda<= 4)
++contClasseC;”
“se (renda > 4 e renda <= 20)
++contClasseB;”
“se (Renda > 20)
++contClasseA;”!
Atenção! Todos os contadores utilizados nos trechos de algoritmo devem ser previamente
inicializados com 0 (zero).
4.2.4)
a) o número de mulheres que responderam SIM
se (sexo == ‘F’ e resposta == “sim”)
ContMulSim = ContMulSim + 1;
100
b) o número de homens que responderam NÃO
se (sexo == ‘M’ e resposta == “nao”)
ContMulSim = ContMulSim + 1;
c) o número de mulheres e homens que responderam NÃO
se (resposta == “nao”)
ContNao = ContNao + 1;
Atenção! Todos os contadores utilizados nos trechos de algoritmo devem ser previamente
inicializados com 0 (zero).
As comparações com ‘F’, ‘M’, “sim” e “nao”, só vão funcionar se o usuário, é claro, escrever as
respostas exatamente dessa forma. Se o programador quiser que o programa aceite outros tipos de
grafia envolvendo letras maiúsculas e minúsculas, isso deve ser incluído no código. Por exemplo,
para aceitar ‘F’ ou ‘f’, o trecho da letra a) ficaria assim:
se ( (sexo==’F’ ou sexo==’f’) e (resposta==”sim” ou resposta=”SIM”) )
4.2.5)
se ( (altura >= 1.70 e altura <= 1.85) e
(peso >= 48 e peso <= 60) e
(idade >=17 e idade <= 21) )
imprima(“Candidata aprovada”);
senão
imprima(“Candidata reprovada”);
4.2.6)
aprovada = 1;
se (altura >= 1.70 e altura <= 1.85)
imprima (“quesito altura aprovado!”);
senão
{ imprima (“reprovada no quesito altura”);
aprovada = 0;
}
se (peso >=48 e peso <=60)
imprima(“quesito peso aprovado!”)
senão
{ imprima(“reprovada no quesito peso.”);
aprovada = 0;
}
se (idade >=17 e idade <= 21)
imprima(“quesito idade aprovado!”)
senão
{ imprima(“reprovada no quesito idade”);
aprovada = 0;
}
se (aprovada)
imprima(“Candidata aprovada”);
senão
imprima(“Candidata reprovada”);
101
Observe a estratégia que eu utilizei para saber se a candidata foi reprovada em algum quesito: eu
usei uma variável inteira que funciona como uma variável lógica “aprovada”. Essa variável foi
inicializada com “verdadeiro” (1) e somente no caso de algum quesito ser reprovado, ou seja, no
caso de algum “senão” ser executado, essa variável passaria a ter o valor “falso” (0), indicando a
reprovação da candidata. Mas existem outras soluções, claro. Uma delas foi criada por um aluno
que usou um contador: cada vez que um quesito era aprovado, ele somava 1 ao contador; no final
se o contador fosse igual a 3 a candidata estaria aprovada, caso contrário, teria sido reprovada.
4.2.7)
se (RA <= 5000.00)
IR = 0
senão se (RA <= 50000.00)
IR = RA * 0.10;
senão IR = RA * 0.15;
imprima (“O contribuinte vai pagar de imposto de renda R$ %.2f”, IR);
Novamente o aluno poderia optar por utilizar 3 comandos “se” separados como mostrado
anteriormente.
Respostas da lista de exercícios 5.1
5.1.1) Escreva um algoritmo que leia e imprima o nome e as duas notas de vários alunos. O último aluno
terá o nome=FIM.
/* notas.c: programa que le e imprime 2 notas de vários alunos */
caracter nome[15];
real
nota1, nota2;
principal()
{
enquanto (1)
{ imprima (“Qual é o seu nome? FIM finaliza “);
leia (“%s”,nome);
se (nome=”FIM”)
break;
imprima (“Digite a primeira nota do aluno: “);
leia (“%f”,&nota1);
imprima (“Digite a segunda nota do aluno: “);
leia(“%f”,&nota2);
imprima (“%s, sua 1a. nota foi: %1.2f e a sua 2a. nota foi: %1.2f“,
nome,nota1,nota2);
}
}
102
5.1.2) Escreva um algoritmo que leia 10 números e calcule e imprima a sua soma.
/* soma10.c: Programa que le e soma 10 numeros */
inteiro numero, soma, contador;
principal()
{
contador = 0;
soma = 0;
enquanto (contador < 10)
{
imprima (“Digite um número:
leia(“%i”,&numero);
soma = soma + numero;
++contador;
}
“);
imprima(“A soma dos 10 números é: %i“,soma);
}
Neste exemplo fica bem claro uma das regras básicas da programação: TODO SOMADOR E TODO
CONTADOR DEVE SER INICIALIZADO COM ZERO! Além disso, é importante notar que a impressão da soma
dos números é feita FORA do comando “enquanto”. Isso porque é preciso terminar a leitura dos dados para que a
soma final tenha sido calculada e possa ser impressa.
5.1.3) Escreva um algoritmo que calcule e imprima N números pares, começando do zero. Pergunte ao
usuário quantos números ele deseja (ou seja, peça-lhe para fornecer o valor de N).
/* Pares.c: programa que gera e imprime N numeros pares */
inteiro n, numeropar, cont;
principal()
{
imprima(“Quantos números pares devem ser impressos? “);
leia(“%i”,&n);
numeropar = 0;
cont = 0;
enquanto (cont < n)
{
imprima(“%i”,numeropar);
numeropar = numeropar + 2;
++cont;
}
}
Note como os números pares são gerados: inicializa-se a variável NumeroPar com zero e depois vai adicionando-se
2 a ela. Dessa forma são gerados 0, 2, 4, 6 ... Fácil, não é?
103
5.1.4)
X
Y
Resultados
-1
0
1
1
1
-1
2
-2
1
3
3
-1
4
-4
Este exemplo, apesar de simples, mostra claramente como se fazer um “teste de mesa”. Na primeira
linha da coluna mostram-se apenas os valores iniciais das variáveis X e Y. Na segunda linha, a
condição do comando “enquanto” foi avaliada como verdadeira (“0 != 4”=Verdadeiro) e os
comandos delimitados por “{”e “}” do “enquanto” foram executados: em X foi colocado o
resultado de “*-1” (-1*-1=1), Y foi acrescido de 1 (0+1=1) e a condição do comando “se” foi
avaliada como verdadeira, implicando na impressão do valor de Y (1), o que foi mostrado na coluna
“Resultado”. As outras linhas correspondem à execução do laço do comando “enquanto”.
5.1.5)
numero
2
4
6
8
10
12
cont
0
1
2
3
4
5
Resultado
2 -2
4 -4
6 -6
8 -8
10 –10
Respostas da lista de exercícios 6.1
6.1.3)
/*exerc613.c: le valor em dolares e converte para reais*/
#include <stdio.h>
float dolares, reais, cotacao;
int main()
{
printf("\nPrograma para converter dolares em reais\n");
printf("\nQual eh a cotacao do dolar? ");
scanf("%f",&cotacao);
printf("\nQuantos dolares devem ser convertidos para reais? ");
scanf("%f",&dolares);
reais = dolares*cotacao;
104
printf("\n%.2f USD convertidos para reais = R$ %.2f ",dolares,reais);
printf("\n\nFim do programa");
getch();
return 0;
}
6.1.8)
/*exerc618.c: calcula o valor a ser pago num estacionamento*/
#include <stdio.h>
int horaent, minent, horasai, minsai, tempo;
float valoraserpago;
int main()
{
printf("\nPrograma para calcular o valor a ser pago num estacionamento\n");
printf("\nValor do estacionamento: 10.00 por hora ou fracao\n\n");
printf("\nQual eh a hora de entrada? ");
scanf("%i",&horaent);
printf("\nQual eh o minuto de entrada? ");
scanf("%i",&minent);
printf("\nQual eh a hora de saida? ");
scanf("%i",&horasai);
printf("\nQual eh o minuto de saida? ");
scanf("%i",&minsai);
if (horasai >= horaent)
{
tempo = (horasai - horaent);
if (minsai > minent)
++tempo; // fracao de minutos implicam na cobranca de mais 1 hora
valoraserpago = tempo * 10.00;
printf("\nTotal a ser pago por %i hora(s) de estacionamento = R$ %.2f ",tempo,valoraserpago);
}
else printf("\nErro nos valores de hora de entrada e saida.");
printf("\n\nFim do programa");
getch();
return 0;
}
105
6.1.11)
/*exerc6111.c: calcula o novo valor do salario de um funcionario*/
#include <stdio.h>
float salario, aumento, novosalario;
int main()
{
printf("\nPrograma para calcular o valor do novo salario reajustado de um funcionario\n");
printf("\nQual eh o valor de seu salario atual? ");
scanf("%f",&salario);
if (salario > 0)
{
if (salario < 500.00)
aumento = salario * 0.15;
else if (salario >=500.00 && salario <= 1000.00)
aumento = salario * 0.10;
else aumento = salario * 0.05;
novosalario = salario + aumento;
printf("\nVoce teve um reajuste de %.2f e seu novo salario = R$ %.2f ",aumento,novosalario);
}
else printf("\nErro no valor do salario. Nao existe salario igual a zero ou negativo.");
printf("\n\nFim do programa");
getch();
return 0;
}
106
6.1.14)
/*exerc6114.c: apresenta a regiao de procedencia de um produto*/
#include <stdio.h>
float preco;
int codigo;
int main()
{
printf("\nPrograma para apresentar a regiao de origem de um produto\n");
printf("\nQual eh o preco do produto? ");
scanf("%f",&preco);
printf("\nQual eh o codigo da regiao de origem do produto? (1 a 5): ");
scanf("%i",&codigo);
switch (codigo)
{ case 1: printf("\nPreco do produto = R$ %.2f - Regiao de origem = SUL", preco);
break;
case 2: printf("\nPreco do produto = R$ %.2f - Regiao de origem = SUDESTE", preco);
break;
case 3: printf("\nPreco do produto = R$ %.2f - Regiao de origem = CENTRO-OESTE", preco);
break;
case 4: printf("\nPreco do produto = R$ %.2f - Regiao de origem = NORTE", preco);
break;
case 5: printf("\nPreco do produto = R$ %.2f - Regiao de origem = NORDESTE", preco);
break;
default: printf("\nCodigo da regiao invalido\n");
}
printf("\n\nFim do programa");
getch();
return 0;
}
107
Respostas da lista de exercícios 7.1
7.1.1)
/*exerc711.c: le o angulo e informa o quadrante*/
#include <stdio.h>
int angulo;
int quadrante;
int main()
{
printf("\nPrograma para apresentar a qual quadrante um angulo pertence\n");
while (1)
{ printf("\nDigite o valor do angulo (0 a 360) -1 finaliza: ");
scanf("%i",&angulo);
if (angulo== -1)
break;
if (angulo >= 0 && angulo < 90)
printf("\nO angulo %i pertence ao quadrante 1\n", angulo);
else if (angulo >= 90 && angulo < 180)
printf("\nO angulo %i pertence ao quadrante 2\n", angulo);
else if (angulo >= 180 && angulo < 270)
printf("\nO angulo %i pertence ao quadrante 3\n", angulo);
else if (angulo >= 270 && angulo <= 360)
printf("\nO angulo %i pertence ao quadrante 4\n", angulo);
else printf("\nValor de angulo invalido.\n ");
}
printf("\n\nFim do programa");
getch();
return 0;
}
108
7.1.7)
/*exerc717.c: gera sequencias numericas*/
#include <stdio.h>
int n, cont, termo;
int main()
{
printf("\nPrograma para gerar sequencias numericas\n");
printf("\nDigite o numero de termos da sequencia de potencias de 2: ");
scanf("%i",&n);
cont = 1;
termo = 2;
while (cont<=n)
{
printf(" %i ",termo);
termo = termo*2;
++cont;
}
printf("\n\n");
printf("\nDigite o numero de termos da sequencia de positivos e negativos: ");
scanf("%i",&n);
cont = 1;
termo = 1;
while (cont<=n)
{
printf(" %i ",termo);
termo = termo*-1;
++cont;
if (cont % 2 == 1) // cont eh impar?
++ termo;
}
printf("\n\n");
printf("\n\nFim do programa");
getch();
return 0;
}
109
7.1.15)
/*exerc7115.c: le numeros e calcula o digito verificador*/
#include <stdio.h>
long int n;
int d1,d2,d3,d4,d5,dv;
int main()
{
printf("\nPrograma para ler numeros e calcular o digito verificador\n");
while (1)
{ printf("\nDigite um numero inteiro de 5 digitos (-1 finaliza): ");
scanf("%ld",&n);
if (n == -1)
break;
if (n >= 10000 && n<=99999)
{
d1 = n / 10000;
d2 = (n % 10000) / 1000;
d3 = (n % 1000) / 100;
d4 = (n % 100) / 10;
d5 = n % 10;
printf("\nd1= %i d2=%i d3=%i d4=%i d5=%i",d1,d2,d3,d4,d5);
dv = (d1 + d2 + d3 + d4 + d5) % 11;
if (dv == 10)
printf("\n\n%ld - x ", n);
else
printf("\n\n%ld - %i",n, dv);
printf("\n\n");
}
else printf("\nEste numero nao tem 5 digitos.\n");
}
printf("\n\nFim do programa");
getch();
return 0;
}
110
7.1.34)
/*exerc7134.c: le o codigo do produto e apresenta sua classificacao*/
#include <stdio.h>
int codigo;
int main()
{
printf("\nPrograma para apresentar a classificacao de produtos\n");
while (1)
{
printf("\nQual eh o codigo do produto? (1 a 9 ou 0 para finalizar): ");
scanf("%i",&codigo);
if (codigo == 0)
break;
switch (codigo)
{ case 1: printf("\nClassificacao do produto %i = ALIMENTO NAO PERECIVEL", codigo);
break;
case 2:
case 3:
case 4: printf("\nClassificacao do produto %i = ALIMENTO PERECIVEL", codigo);
break;
case 5:
case 6: printf("\nClassificacao do produto %i = VESTUARIO", codigo);
break;
case 7: printf("\nClassificacao do produto %i = HIGIENE PESSOAL", codigo);
break;
case 8:
case 9: printf("\nClassificacao do produto %i = LIMPEZA E UTENSILIOS DOMESTICOS", codigo);
break;
default: printf("\nCodigo do produto invalido\n");
}
printf("\n");
} // while 1
printf("\n\nFim do programa");
getch();
return 0;
}
111
1ª aula Prática em Laboratório
Estudo Dirigido
1) No caso desta universidade, verifique em qual diretório você pode criar e executar seus programas. Em
sua casa, crie um diretório somente para seus programas em C.
Crie uma pasta com seu nome no diretório.
Entre no Windows Explorer ou na pasta “Meu computador” do desktop:
clique em <Arquivo> <Novo> <Pasta>
substitua o nome “nova pasta” criado, pelo seu primeiro nome
2) No sistema Windows, localize o compilador Dev-C++
<Iniciar> <Todos os Programas> <Dev-C++>
3) No DevC++, crie um novo arquivo
<Arquivo> <Novo> <Arquivo Fonte>
4) Edite o seguinte programa no editor.
/* nota.c: le a nota de um aluno e verifica se ele foi aprovado ou
reprovado */
#include <stdio.h>
#include <conio.h>
float nota;
char nome[20];
int main()
{
printf (“\nQual eh seu nome? ”);
gets(nome);
printf (“\nDigite sua nota final: ”);
scanf(“%f”,&nota);
if (nota >= 7.0)
printf (“\n%s, voce foi aprovado! ”,nome);
else
printf (“\n%s, voce foi reprovado... ”,nome);
printf(“\n\nFim do programa.”);
getch();
return 0;
}
5) A qualquer momento que desejar, salve o seu arquivo. Clique em <Arquivo> <Salvar Como>. Vá
para o diretório que você criou \seunome e salve seu arquivo como nota.c e vá salvando seu programa
enquanto edita.
112
6) Compile e execute seu programa. Conserte os erros que o compilador apontar antes de executar.
Clique em <Executar> <Compilar&Executar>
Execute o programa várias vezes para diferentes valores.
7) Edite o programa C abaixo, salve-o, compile-o e execute-o seguindo os passos ensinados no programa
anterior. Para abrir um arquivo novo: <Arquivo> <Novo><Arquivo Fonte>. Salve seu arquivo como
menor.c.
/* menor.c: Este programa seleciona o menor numero em uma sequencia de
numeros inteiros */
#include <stdio.h>
#include <conio.h>
int
valor, menor;
int main ()
{ printf (“\nDigite um numero inteiro:
”);
scanf (“%i”, &valor);
menor = valor;
while (valor != -1)
{ if (valor < menor)
menor = valor;
printf(“\nDigite um numero inteiro (–1 para terminar):
scanf (“%i”, &valor);
}
printf (“\nO menor valor lido foi: %i ”, menor);
printf(“\n\nFim do programa”);
getch();
return 0;
}
”);
Dica: faça o download gratuito do compilador Dev-C++ para que
você possa praticar em casa.
Esta apostila foi produzida pela Profa. Elisamara de Oliveira.
Caso você tenha alguma sugestão ou crítica para fazer sobre o
seu conteúdo, por favor, envie e-mail para:
[email protected]
Abraços e obrigada.