algoritmos em portugol

Programação de Computadores I Prof. Erlon Pinheiro

1/77


2/77

UNIDADE I – Introdução à Lógica de Programação O que vamos ver: � Noções de Lógica � Algoritmizando a Lógica � Conceitos e Exemplos de Algoritmos � Noções de Fluxos de Controle � Algoritmos � Exercícios de Fixação 1. Noções de Lógica O uso corriqueiro da palavra lógica está normalmente relacionado à coerência e racionalidade. Freqüentemente associa-se lógica apenas à matemática, deixando-se de perceber sua aplicabilidade e relação com as demais ciências. Lógica é a “arte de bem pensar”, que é a “ciência das formas do pensamento”. Visto que a forma mais complexa do pensamento é o raciocínio, a lógica estuda a “correção do pensamento”. Podemos também dizer que a lógica tem em vista a “ordem da razão”. Isto dá entender que a nossa razão pode funcionar desordenadamente. Por isso a lógica estuda e ensina a colocar “ordem no pensamento”. Exemplos: Todo mamífero é um animal. Todo cavalo é um mamífero. Portanto, todo cavalo é um animal. Espírito Santo é um estado do Brasil. Capixabas são as pessoas nascidas no Espírito Santo Logo, todos os capixabas são Brasileiros.


3/77

2. EXISTE LÓGICA NO DIA-A-DIA ? Sempre que pensamos, a lógica ou a ilógica necessariamente nos acompanha. Quando falamos ou escrevemos estamos expressando nosso pensamento, logo, precisamos usar de lógica nessas atividades. Exemplos: A gaveta está fechada. A caneta está dentro da gaveta. Precisamos primeiro abrir a gaveta para depois pegar a caneta. Anacleto é mais velho que Felisberto. Felisberto é mais velho que Marivaldo. Portanto, Anacleto é mais velho que Marivaldo. 3. MAS E A LÓGICA DE PROGRAMAÇÃO? Significa o uso correto das leis de pensamento, da “ordem da razão” e de processos de raciocínio e simbolização formais na programação de computadores, objetivando racionalidade e o desenvolvimento de técnicas que cooperam para a produção de soluções logicamente válidas e coerentes, que resolvam com qualidade os problemas que se deseja programar. O raciocínio é algo abstrato, intangível. Os seres humanos têm a capacidade de expressá-los através da palavra falada ou escrita (idioma). Um mesmo raciocínio pode ser expresso em qualquer um dos inúmeros idiomas existentes, mas continuará representando o mesmo raciocínio, usando apenas uma outra convenção. Algo similar ocorre com a Lógica de Programação, que pode ser concebida pela mente treinada e pode ser representada em qualquer uma das inúmeras linguagens de programação existentes. Para escapar dessa torre de Babel (detalhes das diversas linguagens de programação), e ao mesmo tempo, representar mais fielmente o raciocínio da Lógica de Programação, utilizamos os Algoritmos.


4/77

4. O QUE É UM ALGORITMO? Um algoritmo pode ser definido como uma seqüência de passos que visam atingir um objetivo bem definido. Na medida em que precisamos especificar uma seqüência de passos, precisamos utilizar ordem, ou seja, “pensar com ordem”, portanto precisamos utilizar lógica. Exemplo de Algoritmo: receita de bolo. 5. ALGORITMIZANDO A LÓGICA Por que é Importante Construir um Algoritmo? Um algoritmo tem por objetivo representar mais fielmente o raciocínio envolvido na Lógica de Programação e, dessa forma, permite-nos abstrair de uma série de detalhes computacionais, que podem ser acrescentados mais tarde. Outra importância da construção dos algoritmos é que, uma vez concebida uma solução algorítmica para um problema, esta pode ser traduzida para qualquer linguagem de programação. Costumamos denominar esse processo de codificação. Vamos a um Exemplo? A troca de uma lâmpada. Algoritmo 1.1 • pegar uma escada; • posicionar a escada embaixo da lâmpada; • buscar uma lâmpada nova; • subir na escada; • retirar a lâmpada velha; • colocar a lâmpada nova. Involuntariamente, já seguimos uma determinada seqüência de ações que representadas nesse algoritmo, fazem com que ela seja seguida naturalmente por qualquer pessoa, estabelecendo um padrão de comportamento, pois qualquer pessoa agiria da mesma maneira. A seqüenciação é uma convenção com o objetivo de reger o fluxo de execução do algoritmo, determinando qual a primeira ação a ser executada e qual ação vem a seguir. Nesse caso, a seqüência é linear, de cima para baixo.


5/77

O algoritmo tem um objetivo bem definido: trocar uma lâmpada. Porém, e se a lâmpada não estivesse queimada? A execução das ações conduziria a uma troca, independentemente de a lâmpada estar ou não queimada, porque não foi prevista essa possibilidade em sua construção. A solução seria acrescentar um teste, a fim de verificar se a lâmpada está ou não queimada. Algoritmo 1.2

• pegar uma escada; • posicionar a escada embaixo da lâmpada; • buscar uma lâmpada nova; • acionar o interruptor; • se a lâmpada não acender, então

• subir na escada; • retirar a lâmpada velha; • colocar a lâmpada nova.

Agora estamos ligando algumas ações à condição lâmpada não acender, ou seja, se esta condição for verdadeira (lâmpada queimada) efetuaremos a troca da lâmpada, seguindo as próximas ações:

• subir na escada; • retirar a lâmpada velha; • colocar a lâmpada nova.

Se a condição lâmpada não acender for falsa (a lâmpada está funcionando), as ações relativas à troca da lâmpada não serão executadas, e a lâmpada (que está em bom estado) não será trocada. O algoritmo está correto, visto que atinge seu objetivo, porém, pode ser melhorado, uma vez que buscamos uma escada e uma lâmpada sem saber se serão necessárias. Algoritmo 1.3 • acionar o interruptor; • se a lâmpada não acender, então

• pegar uma escada; • posicionar a escada embaixo da lâmpada; • buscar uma lâmpada nova; • subir na escada; • retirar a lâmpada velha; • colocar a lâmpada nova.


6/77

A solução apresentada está aparentemente adequada, porém, não prevê a possibilidade de a lâmpada nova não funcionar e, portanto, não atingir o objetivo nesta situação específica. Podemos fazer um refinamento, uma melhoria no algoritmo, de tal modo que se troque a lâmpada diversas vezes, se necessário, até que funcione. Algoritmo 1.4

• acionar o interruptor; • se a lâmpada não acender, então

• pegar uma escada; • posicionar a escada embaixo da lâmpada; • buscar uma lâmpada nova; • subir na escada; • retirar a lâmpada velha; • colocar a lâmpada nova. • se a lâmpada não acender, então

• retirar a lâmpada queimada; • colocar outra lâmpada nova; • se a lâmpada não acender, então

• retirar a lâmpada queimada; • colocar outra lâmpada nova;

.

.

. • Até quando ???

Notamos que o Algoritmo 1.4 não está terminado, faltou especificar até quando será feito o teste da lâmpada. As ações cessarão quando conseguirmos colocar uma lâmpada que acenda; caso contrário, ficaremos testando indefinidamente.


7/77

Podemos, então, expressar uma repetição de ação sem repetir o texto que representa a ação, assim como determinar um limite para tal repetição, com o objetivo de garantir uma condição de parada, ou seja, que seja cessada a atividade de testar a lâmpada nova quando esta já estiver acesa. Uma solução seria: Algoritmo 1.5

• acionar o interruptor; • se a lâmpada não acender, então

• pegar uma escada; • posicionar a escada embaixo da lâmpada; • buscar uma lâmpada nova; • subir na escada; • retirar a lâmpada velha; • colocar a lâmpada nova. • enquanto a lâmpada não acender, faça


A condição lâmpada não acender permaneceu, e estabelecemos um fluxo repetitivo que será finalizado assim que a condição de parada for falsa, ou seja, assim que a lâmpada acender. Percebemos que o número de repetições é indefinido, porém, é finito até alcançar o objetivo: trocar a lâmpada queimada por uma que funcione.


8/77

Até agora estamos efetuando a troca de uma única lâmpada, na verdade, estamos testando um soquete (acionado por um interruptor), trocando tantas lâmpadas quantas forem necessárias para assegurar que o conjunto funcione. O que faríamos se tivéssemos mais soquetes a testar, por exemplo, 10 soquetes ? Algoritmo 1.6 • acionar o interruptor do primeiro soquete; • se a lâmpada não acender, então



• acionar o interruptor do segundo soquete; • se a lâmpada não acender, então

• pegar uma escada; • posicionar a escada embaixo da lâmpada; . .

• acionar o interruptor do terceiro soquete; • se a lâmpada não acender, então

. .

• acionar o interruptor do décimo soquete; . .


9/77

Observamos que o Algoritmo 1.6 é apenas um conjunto de 10 repetições do Algoritmo 1.5, uma vez para cada soquete, havendo a repetição de um mesmo conjunto de ações por um número definido de vezes: 10. Como o conjunto de ações tem uma forma repetida, poderíamos alterar o fluxo seqüencial de execução de modo a fazer com que este voltasse a executar o conjunto de ações relativas a um único soquete (Algoritmo 1.5) tantas vezes quantas fossem desejadas. Uma solução para 10 soquetes seria: Algoritmo 1.7

• ir até o interruptor do primeiro soquete. • enquanto a quantidade de soquetes testados for menor ou igual que dez,

faça • acionar o interruptor do soquete; • se a lâmpada não acender, então



• ir até o interruptor do próximo soquete; Quando a condição ( quantidade de soquetes testados for menor ou igual a dez ) for verdadeira, as ações responsáveis pela troca ou não de um único soquete serão executadas. caso a condição de parada seja falsa, ou seja, todos os dez soquetes já tiverem sido trocados, nada mais será executado.


10/77

6. DE QUE MANEIRA REPRESENTAMOS O ALGORITMO? Convém enfatizar mais uma vez que um algoritmo é uma linha de raciocínio, que pode ser descrito de diversas maneiras, de forma gráfica ou textual. Os algoritmos representados até o momento estavam em forma textual, usando português coloquial. As formas gráficas são mais puras por serem mais fiéis ao raciocínio original, substituindo um grande número de palavras por convenções de desenhos. Para fins de ilustração mostraremos como ficaria o Algoritmo 1.7 representado graficamente em um fluxograma tradicional (algoritmo 1.8) e em um Chapin (Algoritmo 1.9). Algoritmo 1.8


11/77

Algoritmo 1.9


12/77

7. EXERCÍCIOS DE FIXAÇÃO 1 - Um homem precisa atravessar um rio com um barco que possui capacidade de transportar apenas ele mesmo e mais uma de suas três cargas, que são: um lobo, um bode e um maço de alfafas. O que o homem deve fazer para conseguir atravessar o rio sem perder suas cargas? informações: um barco um homem um lobo um bode um maço de alfafa ação: atravessar o rio sem perder as cargas resultado: todas as cargas na outra margem do rio. 2 - Elabore um algoritmo que mova três discos de uma Torre de Hanói, que consiste em três hastes (a-b-c), uma das quais serve de suporte para três discos de tamanhos diferentes (1-2-3), os menores sobre os maiores. Pode-se mover um disco de cada vez para qualquer haste, contanto que nunca seja colocado um disco maior sobre um

menor. O objetivo é transferir os três discos para outra haste. informações: 3 discos 3 hastes ações: movimentar um disco de cada vez de forma que fiquem ordenado resultado: discos transferidos e ordenados para outra haste


13/77

3. Três jesuítas e três canibais precisam atravessar um rio; para tal, dispõem de um barco com capacidade para duas pessoas. Por medidas de segurança não se permite que em alguma margem a quantidade de jesuítas seja inferior à de canibais. Qual a seqüência de passos que permitiria a travessia com segurança? informações: 3 jesuítas 3 canibais 1 barco com capacidade para 2 pessoas ações: atravessar o rio com segurança resultado: 3 jesuítas e 3 canibais na outra margem do rio (B)


14/77

UNIDADE II - Tópicos Preliminares O que vamos ver: � Tipos de Dados Básicos � Constantes e Variáveis 1. TIPOS DE DADOS BÁSICOS Informação é a matéria-prima que faz com que seja necessária a existência dos computadores, pois eles são capazes de manipular e armazenar um grande volume de dados com alto desempenho, liberando o homem para outras tarefas onde o seu conhecimento é indispensável. Aproximando-se da maneira pela qual o computador manipula as informações, vamos dividi-las em três tipos primitivos, que serão os tipos básicos que usaremos na construção de algoritmos.

• Numérico Os dados numéricos dividem-se em dois grupos: inteiros e reais. Os números inteiros podem ser positivos ou negativos e NÃO possuem parte decimal. Exemplos: Vejamos algumas proposições declarativas comuns, em que é usado o tipo inteiro: a) Ele tem 15 irmãos. b) A escada possui 8 degraus. c) Meu vizinho comprou 2 carros novos Enfatizando o conceito de dado, vale observar, por exemplo, o item: 8 é um dado do tipo inteiro e a informação é associar que 8 é o número de degraus da escada.

• Real Os números reais podem ser positivos ou negativos e possuem parte decimal. Exemplos: a) Ela tem 1.73 metro de altura. b) Meu saldo bancário é de 215.20. c) No momento estou pesando 82.5 kg. Observação: Nas linguagens de programação a separação entre a parte inteira e a parte decimal de um número é feita pelo ponto (.), e a simples presença do ponto já significa que é um número real.


15/77

• Literal ou Caractere São dados formados por caracteres (um ou mais). Esses caracteres podem ser as letras maiúsculas, as letras minúsculas, os números e os caracteres especiais (&, #, @, ?, +). Exemplos: a) Escolha o sexo: ‘M’ ou ‘F’. b) Constava na prova: “Use somente a caneta!”; c) Parque municipal estava repleto de placas: “Não pise na grama”. d) Nome do vencedor é “Felisberto Laranjeira”. Observação: Os dados do tipo literal na linguagem C são sempre representados entre aspas simples quando temos um único caractere ou aspas duplas quando temos mais de um caractere. 2. CONSTANTES Entendemos que um dado é constante quando não sofre variação no decorrer do tempo, ou seja, seu valor é constante desde o início até o fim da execução do algoritmo, assim como é constante para execuções diferentes no tempo. O uso de constantes é igual na matemática, por exemplo: o uso da constante pi no cálculo da área de um círculo (área = π * r2 , onde π = 3.14159). 3. VARIÁVEL Um dado é classificado como variável quando tem a possibilidade de ser alterado em algum instante no decorrer do tempo, ou seja, durante a execução do programa em que é utilizado, o valor do dado sofre alteração ou o dado é dependente da execução em certo momento ou circunstância. Exemplos: A cotação do dólar, o peso de uma pessoa, o índice da inflação. Quando fazemos um programa, este normalmente recebe dados, os quais precisam ser armazenados no computador para que possam ser utilizados no processamento; esse armazenamento é feito na memória. Um exemplo para ilustrar a diferença entre valores constantes e variáveis seria a construção de um programa para calcular o valor da área de uma circunferência. Area = πr2 Area � 3.14159 * (raio*raio)


16/77

4. DECLARAÇÃO DE VARIÁVEIS No ambiente computacional, as informações variáveis são guardadas em dispositivos eletrônicos chamados de “memória”. Podemos imaginar essa “memória” como sendo um armário repleto de gavetas, no qual as gavetas seriam os locais físicos responsáveis por armazenar objetos; os objetos (que podem ser substituídos) seriam os dados e as gavetas, as variáveis. Visto que na memória (armário) existem inúmeras variáveis (gavetas), precisamos diferenciá-las, o que é feito por meio de identificadores (etiquetas ou rótulos). Cada variável (gaveta), no entanto, pode guardar apenas um dado (objeto) de cada vez, sendo sempre de mesmo tipo primitivo (material). Portanto, precisamos definir nomes para determinadas gavetas especificando qual o material dos objetos que lá podem ser armazenados; em outras palavras, declarar as variáveis que serão usadas para identificar os dados. 5. FORMAÇÃO DE IDENTIFICADORES Os identificadores são os nomes das variáveis utilizadas nos algoritmos. As regras básicas para a formação dos identificadores são: • Podem possuir qualquer tamanho. Entretanto, apenas os 32 primeiros caracteres

são utilizados pelo compilador C. • Os caracteres que você pode utilizar na formação dos identificadores são: os

números, as letras maiúsculas, as letras minúsculas e o caractere sublinhado (_); • Compilador C faz diferença entre letras maiúsculas e minúsculas; portanto, o

identificador NUM é exatamente diferente dos identificadores num, Num (aliás, em C todos esses identificadores seriam diferentes);

• O primeiro caractere deve ser sempre uma letra; • Não são permitidos espaços em branco e caracteres especiais (@, $, +, -, %, !); • Não podemos usar as palavras reservadas nos identificadores. Obs.: Palavras reservadas da linguagem C não podem ser identificadores de variáveis: auto, break, case, char, const, continue, default, do, double, else, enum, extern, float, for, goto, if, int, long, register, return, short, signed, sizeof, static, struct, switch, typedef, union, unsigned, void, volatile, while. Exemplos de identificadores válidos: A a nota NOTA X5 A32


17/77

NOTA1 MATRICULA nota_1 dia IDADE Exemplos de identificadores inválidos: 5b e@12 x-y prova 2n nota(2) else int 6. DECLARAÇÃO DE VARIÁVEIS As declarações de variáveis são obrigatórias para validar os identificadores. Todas as variáveis devem ser incluídas em uma única declaração da forma: tipo lista de variáveis;

tipo lista de variáveis; Onde tipo representa o conjunto de valores que podemos atribuir a essas variáveis e as listas de variáveis são os identificadores das variáveis do mesmo tipo separados por vírgulas. 7. TIPOS DE VARIÁVEIS Exemplos das declarações de variáveis:

real salario, nota_1; inteiro matricula, contador; caractere nome; 8. COMENTÁRIOS Os comentários não são interpretados pelo compilador, servem apenas para esclarecer o programador, são excelentes instrumentos de documentação e devem sempre estar entre /* ......... */. Ou ainda pode-se usar // para comentar o resto da linha. Exemplos de comentários: inteiro num; // variável inteira para guardar o nº de alunos real nota_1, nota_2; /* Variáveis reais que serão utilizadas para armazenar as duas notas do aluno. */


18/77

9. Operações aritméticas: Os operadores aritméticos a serem utilizados:

+ Adição - Subtração * Multiplicação / Divisão inteira e divisão real % Resto da divisão

Exemplo: Considere X e Y variáveis do tipo inteiro e com valores 7 e 3 respectivamente.

X + Y => 10 X / Y => 2 X - Y => 4 Y / X => 0 Y - X => - 4 Y % X => 3 X * Y => 21 X % Y => 1 X / 2.0 = 3.5 Y / 3.0 => 1.0

Exemplo:

X + Y – Z => (X + Y) – Z X * Y % Z => (X * Y) % Z

� A ordem da precedência dentro de uma expressão aritmética pode ser alterada fazendo-se uso de parênteses. Caso tenha dúvidas quanto à ordem de precedência de uma expressão, utilize sempre parênteses para especificar claramente a ordem da avaliação desejada. Exemplo:

A + B * C => A + (B * C) Para forçar a precedência usamos os parênteses => (A + B) * C

10. Potenciação e Radiciação Usaremos inicialmente duas funções matemáticas predefinidas para calcular a potenciação e a radiciação. Operador Função Significado Exemplo pot(x,y) Potenciação x elevado a y pot(2,3)==23== 8.0

rad(x) Radiciação Raiz quadrada de x rad(9)==3.0 Prioridades Na resolução das expressões aritméticas, as operações guardam uma hierarquia entre si.


19/77

Prioridade Operadores 1ª parênteses mais internos 2ª pot rad 3ª * / % (mod em portugol) 4ª + - Em caso de empate (operadores de mesma prioridade), devemos resolver da esquerda para a direita, conforme a seqüência existente na expressão aritmética. Para alterar a prioridade da tabela, utilizamos parênteses mais internos.

Exercício: Supondo que A, B e C são variáveis de tipo inteiro, com valores

iguais a 5, 10 e – 8, respectivamente, uma variável real D, com valor de 1.5,

resolva passo a passo (obedecendo a ordem de prioridade) as expressões

aritméticas abaixo e determine quais são os resultados.

a) 2 * A % 3 – C

b) rad( - 2 * C) / 4

c) ((20 / 3) / 3) + pot(2, 8) / 2

d) (30 % 4 * pot(3,3) ) * -1

e) pot( - C, 2 ) + ( D * 10 )/A

f) rad ( pot ( A, B/A) ) + C * D

Respostas: (a) 9 (b) 1.0 (c) 130.0 (d) – 54.0 (e) 67.0 (f) - 7.0 11. Sinal de atribuição O conteúdo de uma variável pode ser alterado a qualquer momento. Portanto para

atribuir valores a variáveis devemos usar o sinal de � (“=” em C) .

Exemplos:

Portugol

A �� 2;

B �� 3;

C �� A + B;

C

A = 2;

B = 3;

C = A + B;

Exercício: Encontre os erros dos seguintes comandos de atribuição:


20/77

inteiro A,D; real B, C; A �� 0; A �� A + 1; D �� B; C + 1 �� B + C; C �� 3.5; D �� 2*C +6*6*2 - 3 * 4;

12. Operações relacionais (Seguem a ordem de precedência posicional):

== Igual > Maior < Menor >= Maior ou igual <= Menor ou igual != Diferente

Exemplo: Considere I1 e I2 variáveis do tipo inteiro, R do tipo real com valores 10, 20, 4.5 respectivamente;

I1 > I2 é FALSO I1 > R é VERDADEIRO I1 == 10 é VERDADEIRO I1 < I2 é VERDADEIRO I2 != 20 é FALSO I2 == 20 é VERDADEIRO

13. Operadores Lógicos: não (!) Negação lógica e (&&) Interseção lógica ou (||) União lógica

Exemplo: Considere as variáveis: inteiro a = 3; real: x = 1.5:

Expressão Valor Lógico ((a/2 = = x) && (a>2)) Falso ((a != x) || (a/x < 2)) Verdadeiro

! (a/3 <= x) Falso ((a < 2*x) || ( x < a/2)) Falso

� Note que o valo r lógico de uma expressão lógica e (&&) é verdadeira somente se ambas as partes forem verdadeiras. Caso contrário, o valor lógico será falso. Por outro lado, o valor lógico de uma expressão lógica ou (||) é falso somente se ambas as partes forem falsas. Caso contrário, o valor lógico será verdadeiro.


21/77

Exercício: Determine os resultados obtidos na avaliação das expressões

lógicas seguintes, sabendo que A, B, C contêm, respectivamente, 2, 7 e 3.5:

a) (B == (A * C) ) && (C == 2) b) (B > A) || (B == 4) c) ((B % A) >= C) || ( ! ( A <= C)) d) ( ! (2 == A)) || ( 3 >= C) e) ((B / A ) == C ) || ((B / A ) != C)

Construção de tabela-verdade

Os operadores lógicos são usados para dar suporte às operações lógicas básicas de E (&&), OU (||) e NÃO (!), de acordo com a tabela-verdade. A tabela usa V para verdadeiro e F para falso. E1 e E2 são expressões lógicas quaisquer.

E1 E2 !E1 E1 && E2 E1 || E2 V V F V V V F F F V F V V F V F F V F F

O número de linhas de uma tabela verdade é sempre 2n onde n é o número de

expressões lógicas presente na sentença. A forma de preenchimento sempre se dará

por colunas e começa preenchendo a primeira coluna com metade V e a outra

metade F, a segunda coluna será preenchida com a metade da metade e assim por

diante. (como no exemplo anterior)

Exercício Proposto: Para cada uma das sentenças lógicas construa a respectiva

tabela-verdade:

a) E1 && !(E2 || E2)

b) !( !E1 || !(E2 && ! E3))

c) (E1 && E2) || !E3

d) !(!(!(E1 || !E2))) && !(E3||!E1)

e) !(!(!E1 || !E2)) && !(E3||!E1)

f) !(!(E1 && E2)) && !(!E3 && !E1)

g) (E1 || !E3) && (!E2 && !(E1 || E3))


22/77

14. Comandos de entrada e saída

leia � Comando de entrada que permite a leitura de variáveis de entrada.

EXEMPLO: leia(MATRICULA);

leia( NOME, NOTA_1, NOTA_2);

escreva �� Comando de saída que exibe uma informação na tela do monitor.

EXEMPLO: escreva( “BOM DIA “, NOME);

escreva( “VOCÊ PESA “, PESO, “ KG”);

15. Bloco do programa principal O bloco do programa principal geralmente começa com a declaração das constantes e variáveis que o algoritmo utilizará. Em seguida, especifica as ações a serem executadas sobre os objetos definidos (variáveis e/ou constantes). Ele é iniciado pela palavra início seguida pela seqüência de comandos e finalizada pela palavra fim seguida de um ponto. início <Bloco de comandos> fim. Exercício: Utilizando o seguinte trecho de algoritmo, explique o que está acontecendo em cada linha e qual é o resultado de cada ação executada. início inteiro X, Y ; real Z; Z �� 1; escreva(“Digite um valor inteiro: “); leia(X); escreva(X, “ ELEVADO AO CUBO = “, X*X*X); escreva(“Digite outro valor inteiro: “); leia(Y); escreva(“A soma e: “, X+Y); Z �� Z + 1; X �� (Y + X) % 2; escreva(“O valor final da expressao e: “, X); .... fim.

Exercícios de Fixação II 1 - Determine qual é o tipo básico de dados da informação destacado nas sentenças a seguir: a) A placa “Pare !” tinha 2 furos de bala.


23/77

b) Josefina subiu 5 degraus para pegar uma maçã “boa”. c) Alberta levou 3.5 horas para chegar ao hospital onde concebeu uma "garota” . d) Astrogilda pintou em sua camisa: “Preserve o meio ambiente”, e ficou devendo

100.59 ao vendedor de tintas. e) Felisberto recebeu sua 18a. medalha por ter alcançado a marca de 57.3 segundos nos

100 metros rasos. 2 – Assinale os identificadores válidos: a) if b) U2 c) AH! d) ‘ALUNO’ e) #55 f) KM/L g) UYT h) ASBRUBAL i) AB*C j) O&O k) P{O} l) B52 m) Rua n) CEP o) dia_mês 3 – Supondo que as variáveis Nota_A, Nome_A, NMat sejam utilizadas para armazenar a nota do aluno, o nome do aluno e o número da matrícula, declare-as corretamente, associando o tipo básico adequado ao dado que será armazenado. 4 – Encontre os erros da seguinte declaração de variáveis: inteiro endereco n_filhos; caractere idade, X, C; real XPTO, C, peso, R$; 5 - Identifique o tipo dos dados:

(a) inteiro; (b) real; (c) caractere; ( ) “MARIA” ( ) 45.0 ( ) 1234 ( ) 0.0 ( ) ‘a’ ( ) ‘*’ ( ) -234 ( ) ‘1’ ( ) -0.342 ( ) 35.23 ( ) ‘3’ ( ) -18.589 ( ) ” “ ( ) -354.0 ( ) -15.2 ( ) ”José” ( ) 0 ( ) 897 ( ) -23

6 - Identifique o tipo dos dados: (d) inteiro; (e) real; (f) caractere. ( ) “lote” ( ) 45.0 ( ) 1234 ( ) 0.0 ( ) ’a’ ( ) ‘*’ ( ) -234 ( ) ’1’ ( ) -0.342 ( ) 35.23 ( ) ’3’ ( ) -18.589 ( ) ’ ‘ ( ) -354.0 ( ) -15.2 ( ) ”Maria” ( ) 0 ( ) 897 ( ) -23

7 - Faça a declaração de 2 variáveis do tipo inteiro, 3 variáveis do tipo real e 2 variáveis do tipo caractere.


24/77

8 - Indique qual o resultado das expressões aritméticas abaixo: Sendo: x = 6.0 y = 2 z = 4.0 a = 8 b = 7.5

c = 7.7 d = 12 p = 4 q = 3 r = 10 s = 7.7 a) x + y – z * a b) d / y c) d % y d) y / d e) ((z / a) + b * a) – d f) 100 * (q / p) + r

9 - De acordo com as informações abaixo, informe qual o valor das relações ( V -

Verdadeira ou F - falsa): a) a � 2.0, b � 9.0, nome � “ana” , profissao � “advogado”

a + 1 >= b*a ( ) nome != “ana” ( ) profissao == “médico” ( )

b) a � 6.0 , b � 121.0 , nome � “pedro”, profissao � “médico” a + 1 >= b – 5 ( ) nome != “ana” ( ) profissao == “médico” ( )

c) x � 3 , y � 4 , z � 16 , nome � “maria” : (( x +y > z ) && (nome == “maria”)) ( ) (( x *y > z ) || ( y > = x )) ( ) (!( x - y > z ) && ( z / y + 1 == x )) ( ) ((nome == “josé”) && ( x + y + z < ( y*y ))) ( )

10 - Dadas as declarações:

inteiro NUM; real SOMA, X; caractere SIMBOLO;

Assinale os comandos de atribuição inválidos: ( ) SIMBOLO ← 5; ( ) SOMA ← NUM+2*X; ( ) X*X ← SOMA; ( ) TUDO ← SOMA; ( ) X ← X+1; ( ) NUM � 5*SOMA+2; ( ) NUM ←”*ABC*”;

11 - Marque os identificadores como válidos ou inválidos (explicando a resposta quando o identificador for inválido): (a) identificador válido; (b) identificador inválido; ( ) ano ( ) media_salario ( ) ai! ( ) A15B34


25/77

( ) “aula” ( ) 3/1

12 – Faça o rastreamento (tela e memória) do seguinte bloco de comandos: Início real nota1, nota2, media; escreva(“Digite as duas notas: “); leia(nota1,nota2); media �� (nota1 + nota2 ) / 2; escreva(“Media = “, media); fim.

13 – Encontre os erros no bloco de comandos abaixo: início inteiro X, Y ; real Z; Z �� 1.5; escreva(“Digite um valor inteiro: “); leia(X; escreva(X, “ ELEVADO AO CUBO = “, X*X*X); escreva(“Digite outro valor inteiro: “) leia(Y); escreva(“A soma e: , X+Y); Z + 3 �� Z + 1; X �� (Y + X) / 5.0; escreva(“O valor final da expressao e: “ X); fim


26/77

Unidade III - ESTRUTURA DE ALGORITMOS EM PORTUGOL

1. Introdução Usaremos um exemplo simples para compreendermos como a formalização em uma linguagem artificial é importante.

Exemplo Inicial

Suponha que o algoritmo leia dois números que o usuário do computador digitará no teclado, some-os e mostre o resultado na tela do computador. 1a solução: (Narrativa informal)

1. Leia do teclado dois valores 2. Some os dois valores 3. Mostre o resultado da soma na tela

2a solução: (Narrativa um pouco mais formal seria) 1. Leia o valor do teclado e armazene na memória A; 2. Leia o valor do teclado e armazene na memória B; 3. Some os valores da memória A e B e coloque o resultado na memória SOMA; 4. Mostre na tela o valor da memória SOMA.

Nesta solução vemos o uso de 3 memórias: A, B e SOMA. Aqui o conceito de memória é semelhante ao das memórias existentes nas calculadoras. Elas servem para acumular o resultado de cálculos intermediários. Uma solução ainda mais formal seria: 3a solução: (Portugol que será utilizado na disciplina)

algoritmo mostra_soma; início

inteiro a, b, soma; escreva(“Digite o primeiro número: “); leia (a); escreva(“Digite o segundo número: “); leia (b); soma ← a + b; escreva(“A soma é “, soma); fim. { Observe a identação } Aqui as palavras início e fim foram usadas para delimitar o bloco de comandos.

2. Estrutura de um algoritmo em Portugol


27/77

algoritmo <identificador>; ínicio

const <tipo> <identificador> � <dado>; <tipo> <identificador>;

<comando1>; ... <comandon>; fim. Segue um Algoritmo que lê as 4 notas bimestrais de um aluno. Em seguida o Algoritmo calcula e escreve a média obtida. Resolução: algoritmo media_final; início real nota1, nota2, nota3, nota4, media;

escreva (“DIGITE SUAS QUATRO NOTAS: “); leia (nota1, nota2, nota3, nota4); media � (nota1 + nota2 + nota3 + nota4) / 4; escreva (“ SUA MÉDIA É: “, media);

fim.

algoritmo media_final_v2; início real nota1, nota2, nota3, nota4, soma, media;

escreva (“DIGITE SUAS QUATRO NOTAS: “); leia (nota1, nota2, nota3, nota4); soma � nota1 + nota2 + nota3 + nota4; media � soma / 4; escreva (“ SUA MÉDIA É: “, media);

fim.

Exercícios Resolvidos: 1) Faça um algoritmo em Portugol que leia os valores inteiros para largura, comprimento e altura de um paralelepípedo retângulo e calcule o seu volume. RESOLUÇÃO: algoritmo volume_paralelepipedo; início inteiro largura, comprimento, altura; escreva(“Digite os valores para largura, comprimento e altura: “);


28/77

leia(largura, comprimento, altura); escreva(“Volume = “, largura*comprimento*altura,” cm3”): fim. Se largura == 10; comprimento = = 3; altura = = 2; o resultado do programa acima ficaria assim no vídeo: Digite os valores para largura, comprimento e altura: 10 3 2 <enter>. Volume = 60 cm3 Versão 2 do algoritmo anterior: algoritmo volume_paralelepipedo; início inteiro largura, comprimento, altura, volume_p; escreva(“Digite os valores para largura, comprimento e altura: “); leia(largura, comprimento, altura); volume_p � largura*comprimento*altura; escreva(“Volume = “, volume_p,” cm3”); fim. 2) Faça um Algoritmo que lê o raio de uma circunferência e calcula sua área. Resolução: algoritmo area_circunferencia;

início

const real pi = 3.1416;

real raio, area;

//Entrada de dados

escreva(“Digite o valor do raio: “);

leia (raio);

//Processamento de dados

area � pi * (raio*raio); // ou area � pi * (pot(raio,2));

// Saída de dados

escreva (“Area = “, area) ;

fim.

3) Faça um algoritmo em Portugol que leia dois valores inteiros para as variáveis A

e B e efetuar as operações de adição, subtração, multiplicação e divisão de A por B,

apresentando ao final os resultados obtidos.

Resolução:


29/77

algoritmo operações;

inicio

inteiro a, b, soma, sub, mult, divi;

//Entrada de dados

escreva(“Digite dois valores inteiros: “);

leia(a, b);


soma � a+b;

sub � a - b;

mult � a * b;

divi � a/b;

//Saída de dados

escreva(a, “ + “, b, “ = “, soma);

escreva(a, “ - “, b, “ = “, sub);

escreva(a, “ * “, b, “ = “, mult);

escreva(a, “ / “, b, “ = “, divi);

fim.

4) Efetuar a leitura de um número inteiro e apresentar o resultado do quadrado deste

número.

Resolução:

algoritmo calcula_quadrado.;

inicio

inteiro num;

//Entrada de dados

escreva(“Digite um valor inteiro: “);

leia(num);

//Processamento e saída de dados

escreva( num, “ ao quadrado e “, num*num);


30/77

fim.

algoritmo calcula_quadrado_v2;

inicio

inteiro num, quad;

//Entrada de dados


leia(num);


quad � num*num;

//Saída de dados

escreva( num, “ ao quadrado e “, quad);

fim.

algoritmo calcula_quadrado_v3;

inicio

inteiro num;

real quad;

//Entrada de dados


leia(num);


quad � pot(num, 2);

//Saída de dados

escreva( num, “ ao quadrado e “, quad);

fim.


31/77

5) Ler uma temperatura em graus Fahrenheit e apresentá-la convertida em graus

Célsius. A fórmula de conversão é: C � (F – 32) * (5 / 9.0), onde F é a temperatura em

Fahrenheit e C é a temperatura em Célsius.

Resolução:

algoritmo converte_temperatura;

inicio

real celsius, f;

//Entrada de dados

escreva(“Digite a temperatura em Fahrenheit: “);

leia(f);


celsius � (f – 32)*(5/9.0);

//Saída de dados

escreva(“A temperatura em Celsius e “, celsius);

fim.

6) Calcular e apresentar o volume de uma lata de óleo, utilizando a fórmula: VOLUME

� 3.14159 * R * R * ALTURA.

Resolução:

algoritmo volume_lata_oleo;

inicio

const real PI � 3.14159;

real volume, raio, altura;

//Entrada de dados

escreva(“Digite o valor do raio e da altura em cm: “);

leia(raio, altura);


volume � PI * pot(raio,2) * altura;

//saída de dados

escreva(“O volume da lata de óleo é “, volume, “ cm3”);


32/77

fim.

Exercícios de Fixação III 1 - Ler dois valores inteiros para as variáveis A e B e efetuar as operações de adição, subtração, multiplicação e divisão de A por B, apresentando ao final os resultados obtidos. 2 - Efetuar a leitura de um número inteiro e apresentar o resultado do quadrado deste número. 3 - Ler uma temperatura em graus Fahrenheit e apresentá-la convertida em graus Célsius. A fórmula de conversão é: C � (F – 32) * (5 / 9.0), onde F é a temperatura em Fahrenheit e C é a temperatura em Célsius. 4 - Calcular e apresentar o volume de uma lata de óleo, utilizando a fórmula: VOLUME � 3.14159 * R * R * ALTURA. 5 - Faça um algoritmo que receba dois números inteiros, calcule e imprima: soma dos dois números; subtração do primeiro pelo segundo; subtração do segundo pelo primeiro; multiplicação dos dois números; divisão real do primeiro pelo segundo; divisão real do segundo pelo primeiro; quociente inteiro da divisão do primeiro pelo segundo; quociente inteiro da divisão do segundo pelo primeiro; resto da divisão do primeiro pelo segundo; resto da divisão do segundo pelo primeiro. 6 - Ler dois valores para as variáveis A e B, efetuar a troca de valores de forma que a variável A passe a possuir o valor da variável B e que a variável B passe a possuir o valor da variável A. Apresentar os valores trocados. 7 – Faça um algoritmo que efetue o cálculo do valor de uma prestação em atraso, utilizando a fórmula: PRESTACAO � VALOR + (VALOR * (TAXA/100) * TEMPO), onde a TAXA é um valor constante de 2 e o TEMPO é dado em dias. Resolução:

algoritmo valor_prestacao; inicio const real taxa � 2.0; inteiro tempo; real prestação, valor; //Entrada de dados


33/77

escreva(“Digite o valor da prestação: “); leia(valor); escreva(“Digite o tempo de atraso em dias: “); leia(tempo); //Processamento de dados prestação � (valor * (taxa/100)*tempo)+valor; //saída de dados escreva(“O valor final da prestação é: “, prestação); fim.

8 - Uma loja de animais precisa de um programa para calcular os custos de criação de coelhos. O custo é calculado com a fórmula CUSTO � (NR_COELHOS * 0.70) / 18 + 10. O programa deve ler um valor para a variável NR_COELHOS e apresentar o valor da variável CUSTO. 9 - Faça um algoritmo que receba duas notas de um aluno e seus respectivos pesos, calcule e imprima a média ponderada dessas notas. Resolução: algoritmo media_ponderada; inicio real nota1, nota2, media_p; inteiro peso1, peso2; //Entrada de dados escreva(“Digite as duas notas: “); leia(nota1, nota2); escreva(“Digite os pesos: “); leia(peso1, peso2); //Processamento de dados media_p � (nota1*peso1 + nota2*peso2)/(peso1+peso2); //Saída de dados escreva(“A media ponderada e “, media_p); fim.

Rastreamento

Memória Tela nota1: 7.0 nota2: 8.0 media_p: 7.6666 peso1: 1 peso2: 2

Digite as duas notas: 7 8 <Enter> Digite os pesos: 1 2 <Enter> A media ponderada e 7.6666


34/77

10 - Faça um algoritmo que receba o valor de um depósito e o valor da taxa de juros. Calcule e imprima o valor do rendimento e o valor total depois do rendimento. Resolução: algoritmo aplicacao_financeira; inicio real deposito, taxa, rend, valor_final; //Entrada de dados escreva(“Digite o valor do deposito: “); leia(deposito); escreva(“Digite o valor da taxa de juros: “); leia(taxa); //Processamento de dados rend � deposito * (taxa/100); valor_final � deposito + rend; //Saída de dados escreva(“O valor do rendimento e: “, rend); escreva(“O valor final com o rendimento e : “, valor_final); fim.

Faça o rastreamento 11 - Faça um algoritmo que receba um número inteiro, calcule e imprima a tabuada desse número. Resolução: algoritmo tabuada; inicio inteiro num; //Entrada de dados escreva(“Digite um numero para a tabuada: “); leia(num); //Processamento e saída de dados escreva(“A tabuada de multiplicação do numero “, num); escreva(num , “ * 1 = “, num); escreva(num , “ * 2 = “, 2*num); escreva(num , “ * 3 = “, 3*num); escreva(num , “ * 4 = “, 4*num); escreva(num , “ * 5 = “, 5*num); escreva(num , “ * 6 = “, 6*num); escreva(num , “ * 7 = “, 7*num);


35/77

escreva(num , “ * 8 = “, 8*num); escreva(num , “ * 9 = “, 9*num); escreva(num , “ * 10 = “, 10*num); fim.

Rastreamento

Memória Tela num: 2

Digite um numero para a tabuada: 2 <Enter> 2 * 1 = 2 2 * 2 = 4 2 * 3 = 6 2 * 4 = 8 2 * 5 = 10 2 * 6 = 12 2 * 7 = 14 2 * 8 = 16 2 * 9 = 18 2 * 10 = 20

12 - Faça um algoritmo que receba um número real, calcule e imprima o valor referente ao volume do cubo que tenha este número real como lado. 13 - Faça um algoritmo que receba um número inteiro, calcule e imprima: a raiz quadrada desse número; esse número elevado ao quadrado. 14 - Faça um algoritmo que receba o valor do salário de um funcionário e o valor do salário mínimo. Calcule e imprima quantos salários mínimos ganha esse funcionário. 15 - Faça um algoritmo que calcule e imprima a área de um retângulo. 16 - Faça um algoritmo que receba o salário de um funcionário, calcule e imprima o valor do imposto de renda a ser pago, sabendo que o imposto equivale a 5% do salário. 17 - Faça um algoritmo que receba o salário de um funcionário, calcule e imprima o novo salário sabendo-se que este sofreu um aumento de 25%. Resolução: algoritmo reajuste_salarial; inicio


36/77

const real reaj = 25; real salario, novo_sal; //Entrada de dados escreva(“Digite o valor do salario: “); leia(salario); //Processamento de dados novo_sal � salario * (reaj/100) + salario; //Saída de dados escreva(“O valor do salario reajustado e: “, novo_sal); fim.

18 - Faça um algoritmo que receba o peso de uma pessoa, um valor inteiro, calcule e imprima: o peso dessa pessoa em gramas; se essa pessoa engordar 5%, qual será seu novo peso em gramas. 19 - Imprima o cálculo da seguinte equação sendo lidos os parâmetros a, b e c: X = ((a + (2* b + c) * c) / a *a) 20 - Faça um algoritmo que leia as medidas de um retângulo (base, altura), calcule e imprima sua área e seu perímetro.


37/77

UNIDADE IV – Comandos de Seleção O que vamos ver: • Seleção Simples • Seleção Composta • Seleção Encadeada • Seleção Múltipla Escolha Uma estrutura de seleção permite a escolha de um grupo de ações (bloco) a ser executado quando determinadas condições, representadas por expressões lógicas ou relacionais, são ou não satisfeitas. 1. Seleção Simples Quando precisamos testar certa condição antes de executar uma ação, usamos uma seleção simples, que segue o seguinte modelo: se (<condição>) então Comando; // comando único <condição> é uma expressão lógica que, quando inspecionada, pode gerar um resultado falso ou verdadeiro. Se <condição> for verdadeira, a ação primitiva sob a cláusula então (Comando) será executada; caso contrário (<condição>) for falsa), encerra-se a seleção (fim), neste caso sem executar nenhum comando. Através do exemplo anterior, observamos que, quando existir apenas uma ação após a cláusula, então basta escrevê-la; já quando precisamos colocar diversas ações é necessário usar um bloco, delimitado por início e fim conforme o seguinte modelo: se (<condição>) então início Comando-1; Comando-2; ... Comando-n; fim; Exemplo:


38/77

algoritmo exemplo1;

inicio

real n1, n2, n3, m;

escreva(“DIGITE TRÊS NOTAS: “);

leia(n1, n2, n3);

m ←←←← (n1 + n2 + n3) / 3;

se ( m >= 7 ) então

inicio

escreva(“APROVADO”);

escreva(“MÉDIA = “,m);

fim;

fim. 2. Seleção Composta Quando tivermos situações em que duas alternativas dependem de uma mesma condição, uma da condição ser verdadeira e outra da condição ser falsa, usamos a estrutura de seleção composta. Supondo que um conjunto de ações dependa da avaliação verdadeira uma única ação primitiva dependa da avaliação falsa, usaremos uma estrutura de seleção semelhante ao seguinte modelo: se (<condição>) então início Comando-1; Comando-2; .... Comando-n; fim; senão inicio Comando-z1; Comando-z2; fim;


39/77

algoritmo exemplo02;

inicio

inteiro num1, num2;

escreva(“Digite dois valores inteiros: “);

leia(num1, num2);

se (num1 == num2) então

escreva(“NÚMEROS IGUAIS”);

senão

escreva(“NÚMEROS DIFERENTES”);

fim. Outro exemplo de estrutura condicional composta:

algoritmo exemplo2_1;

inicio

real n1, n2, n3, m;


leia(n1, n2, n3);

m ← (n1 + n2 + n3) / 3;

se (m >= 7) então

inicio

escreva(“APROVADO”);

fim;

senão

inicio

escreva(“ REPROVADO”);

fim;

escreva(“MÉDIA = “,m);

fim.


40/77

3. Seleção Encadeada Quando precisarmos agrupar várias seleções, formaremos uma seleção encadeada. Normalmente, tal formação ocorre quando uma determinada ação (ou bloco de ações) deve ser executada de acordo com um conjunto de possibilidades. se (<condição 1>) então se (<condição 2>) então início Comando-1; Comando-2; .... Comando-n; fim; senão se (<condição 3>) então início

Comando-1; Comando-2; .... Comando-n;

fim; senão se (<condição 4>) então se (<condição 5>) então Comando –v; senão Comando-f;


41/77

Exemplo de estruturas condicionais encadeadas:

algoritmo exemploO3;

inicio

real N1, N2, N3, M, FALTA;


leia(N1, N2, N3);

M � (N1 + N2 + N3) / 3;

se ( M >= 7) então

inicio

escreva(“ALUNO APROVADO”);

fim;

senão

se ( M >= 3) então

inicio

escreva(“PROVA DE RECUPERAÇÃO.”);

FALTA �10 – M;

escreva(“NOTA PARA TIRAR NO EXAME = “, FALTA);

fim;

senão

inicio

escreva(“ ALUNO REPROVADO”);

fim;

escreva(“ SUA MÉDIA FOI: “, M);

fim.


42/77

Exercícios de Fixação IV 1. Faça um algoritmo para ler três valores numéricos inteiros distintos e determinar o menor deles. 2. Faça um algoritmo que leia o sexo (m ou M para masculino – f ou F para feminino) e a idade de uma pessoa e determine se a pessoa já atingiu a maioridade, sabendo-se que: as pessoas do sexo masculino atingem a maioridade aos 18 anos e as pessoas do sexo feminino atingem a maioridade aos 21 anos. O algoritmo deve escrever o resultado esperado. RESOLUÇÃO

Rastreamento

Memória Tela sexo: ‘F’ idade: 27

Digite seu sexo (M ou F ): F <Enter> Digite sua idade: 27 <Enter> Atingiu a maioridade!

sexo: ‘f’ idade: 15

Digite seu sexo (M ou F ): f <Enter> Digite sua idade: 15 <Enter> Nao atingiu a maioridade.

sexo: ‘M’ idade: 28

Digite seu sexo (M ou F ): M <Enter> Digite sua idade: 28 <Enter> Atingiu a maioridade!

sexo: ‘m’ idade: 14

Digite seu sexo (M ou F ): m <Enter> Digite sua idade: 14 <Enter> Nao atingiu a maioridade.

sexo: ‘$’ idade: 2

Digite seu sexo (M ou F ): $ <Enter> Digite sua idade: 2 <Enter> Sexo invalido.

3. Suponha que os termos b1, b2 e b3 abaixo sejam expressões Verdadeiras ou Falsas e que c1, c2, c3, c4 e c5 sejam comandos quaisquer.


43/77

algoritmo ex03; início

se (b1) então início

c1; fim senão início



c2; fim senão início c3;

c4; fim

fim; c5;

fim; fim. Dado o algoritmo acima, responda: a) Se b1 for verdadeiro, b2 for verdadeiro e b3 for falso, quais os comandos que serão

executados ? b) Se b1 for falso, b2 for verdadeiro e b3 for falso, quais os comandos que serão

executados ? c) Quais os valores de b1, b2, b3 para que somente o comando C5 seja executado ? d) Se b1 for verdadeiro, b2 for verdadeiro e b3 for verdadeiro, quais os comandos que

serão executados ? e) Quais os valores de b1, b2 e b3 para que sejam executados os comandos c2 e c5? 4. Faça um algoritmo que leia dois números, some-os e imprima o resultado caso a soma seja maior que 10. 5. Faça um algoritmo que leia um número inteiro e imprima a mensagem ‘Número par!’ caso ele seja divisível por 2. 6. Faça um algoritmo que leia 2 números inteiros para as variáveis A e B. Caso A seja maior que B e B seja par, efetue a troca dos valores de forma que a variável A passe a conter o valor da variável B e, a variável B passe a conter o valor da variável A.


44/77

7. Faça um algoritmo que leia um número inteiro positivo e imprima uma mensagem dizendo se ele é par ou impar.

8. Faça um algoritmo que leia dois valores numéricos inteiros e distintos. Apresente a diferença do maior pelo menor na tela.

9. O que está errado no algoritmo abaixo? algoritmo erro inicio

inteiro num1, num2, par; printf(Digite um valor inteiro: ”) leia (num1); num2 ← num1 % 2.0; /* resto da divisão ou num2 ← num1 mod 2.0;*/ se ( num2 == 0 ) então inicio par ← ‘v’; fim; senão inicio par ← ‘f’; fim;

fim.

10. Dado o algoritmo abaixo responda qual o valor de Result após a sua execução? algoritmo valor_final; início

real num1; inteiro num2, result; num1 ← 1.5; num2 ← 3; num1 ← num1 + 1; se ( (num1+2<= num2) ou ((num1 + num2 > 5) ou (não (num1+pot(num2,2) / num1 + num2>=4 ))) então

inicio result� 0; fim; senão

inicio result � 1; fim; fim. 11. Faça um algoritmo que leia dois valores numéricos e imprima o maior. Caso os números sejam iguais imprima a mensagem ‘Números iguais!’. 12. Faça um algoritmo que leia três números distintos e imprima o maior.


45/77

13. Faça um algoritmo que calcule e imprima o desconto do salário de um funcionário, sabendo que:

a. se salário < R$ 1000, 00, desconto de 5% sobre o salário; b. se salário >= R$ 1000, 00 e <= R$2000,00, desconto de 10% sobre o

salário; c. se salário > R$ 2000, 00, desconto de 15% sobre o salário;

14. Faça um algoritmo que efetue a leitura de três valores numéricos reais distintos e apresente os valores lidos em ordem crescente. 15. Faça um algoritmo que leia 2 notas e o número de faltas semestrais de um determinado aluno e calcule a média aritmética entre elas. Imprima a média e uma mensagem informando a situação final do aluno. O aluno estará aprovado caso sua média seja maior ou igual a 7. O aluno terá direito a uma recuperação caso sua média seja maior ou igual a 3, caso contrário estará reprovado. Mesmo que possua média para aprovação ou recuperação, o aluno estará reprovado caso possua mais de 20 faltas. 16. Dado o algoritmo abaixo responda: a) Se b1 = VERDADEIRO e b2 = VERDADEIRO, o que será impresso? b) Se b1 = FALSO e b2 = VERDADEIRO, o que será impresso? c) Se b1 = FALSO e b2 = FALSO, o que será impresso? Onde c1, c2 e c3 são mensagens, isto e, cadeias de caracteres. algoritmo teste; início se ( b1 )então início escreva (c1); fim; senão início se ( b2) então início escreva (c2); fim; senão início escreva (c3); fim; fim; fim. 17. O que será impresso após a execução do algoritmo abaixo se: a) num = 10 b) num = 0 c) num = - 4 algoritmo resultado;


46/77

início /* declaração de variáveis */ inteiro num; leia ( num); se (num > 0) então escreva (“numero positivo”) senão

se (num < 0) então escreva (“numero negativo”) senão escreva (“zero”);

fim. 18. Uma empresa decide dar um aumento de 4% aos funcionários cujo salário é inferior a 500 reais. Escreva um algoritmo que receba o salário de um funcionário e imprima o valor do salário reajustado ou uma mensagem caso o funcionário não tenha direito ao aumento. 19. Faça um algoritmo que verifique a validade de uma senha fornecida pelo usuário. A senha correta é o número: 12345. O algoritmo deve imprimir mensagem de permissão ou negação de acesso. 20. Faça um algoritmo que receba a idade de uma pessoa e imprima mensagem de maioridade ou não. Assuma que a maioridade ocorre somente aos 21 anos. 21. Faça um algoritmo que receba a altura e o sexo de uma pessoa, calcule e imprima o seu peso ideal, utilizando as fórmulas abaixo. Assuma M ou F como sendo os valores válidos para o sexo de uma pessoa.

• para homens: (72.7 * ALTURA) – 58 • para mulheres: (62.1 * ALTURA) – 44.7


47/77

4. Seleção de Múltipla Escolha Quando um conjunto de valores discretos precisa ser testado e ações diferentes são associadas a esses valores, estamos diante de uma seleção encadeada homogênea do tipo se – senão – se. Como esta situação é bastante freqüente na construção de algoritmos que dependem de alternativas, utilizaremos uma estrutura específica para estes casos, a seleção de múltipla escolha. O modelo que expressa as possibilidades é o seguinte: escolha(X) inicio caso V1 : C1; pare; caso V2 : C2; pare; caso V3 : C3; pare; caso V4 : C4; fim; Caso o contéudo da variável seletora X seja igual ao valor Vn, então, o comando Cn será executado; caso contrário, serão inspecionados os outros casos até ser encontrada uma igualdade ou terminarem os caso. Para executramos um comando que possui mais de um valor em que se verifica sua necessidade, agrupamos todos esses valores em único caso. E, para executarmos um comando que se verifica com todos os outros valores, exceto os discriminados caso a caso, incluímos outra situação: caso contrário. escolha(X) inicio caso V1 : C1; pare; caso V2: caso V3 : C2; pare; caso V4 : C3; pare; caso V5 : C4; pare; caso contrário: C5; fim;


48/77

Exemplos 1 – Construa um programa que leia um valor numérico inteiro e uma opção de operação ( 1 – Raiz Quadrada, e 2 – Valor ao Quadrado) a qual o número deve ser submetido. algoritmo exemplo_01; inicio inteiro num, op; real resultado; escreva(“Digite o valor inteiro: “); leia(num); escreva(“Escolha uma opção: “); escreva(“1: Raiz ou 2: Quadrado: “); leia(op); escolha(op) inicio caso 1: resultado rad(num); pare; caso 2: resultado pot(num, 2); fim; escreva(“O resultado é ”, resultado); fim. Outra versão: algoritmo exemplo_01_v2; inicio inteiro num, op; escreva(“Digite o valor inteiro: “); leia(num); escreva(“Escolha uma opção: “); escreva(“1: Raiz ou 2: Quadrado: “); leia(op); escolha(op) inicio caso 1: escreva(“ O resultado é “,rad(num)); pare; caso 2: escreva(“O resultado é “,pot(num, 2)); pare; caso contrário: escreva(“Opção Inválida!!!!”); fim; fim. Importante! A restrição da estrutura escolha é que o seletor só pode ser variável do tipo inteiro ou um único caractere.


49/77

2 – Construa um algoritmo que leia um caractere, e determine se este é uma vogal maiúscula, ou um digito numérico (caractere numérico), ou um operador aritmetico, ou senão um outro caractere. algoritmo exemplo_02; inicio caractere car; escreva(“Digite um caractere: “); leia(car); escolha (car) inicio caso ‘A’: caso ’E’: caso ‘I’: caso ‘O’: caso‘U’: escreva(“Vogal maiúscula”); pare; caso ‘0’: caso ‘1’: caso ‘2’: caso ‘3’: caso ‘4’: caso ‘5’: caso ‘6’: caso ‘7’: caso ‘8’: caso ’9’: escreva(”Valor numérico”); pare; caso ‘+’: caso ‘-’: caso ‘*’: caso ‘/’: escreva(“Operador aritmético”); pare; caso contrário : escreva(“Você digitou outro caractere”); fim; fim. Exercícios de Fixação V

0000000

Comando de seleção múltipla 1. Leia uma vogal maiúscula e imprima a vogal subseqüente. Resolução: algoritmo exercício1; inicio caractere car; escreva(“Digite uma vogal maiúscula: “); leia(car); escolha (car) inicio caso ‘A’: escreva(“Vogal subsequente: E”); pare;

caso ’E’: escreva(“Vogal subsequente: I”); pare;

caso ‘I’: escreva(“Vogal subsequente: O”); pare;

caso ‘O’: escreva(“Vogal subsequente: U”); pare; caso‘U’: escreva(“Vogal subsequente: A”); pare; caso contrário : escreva(“Você digitou outro caractere”); fim;


50/77

fim. 2. Leia um caractere e imprima a mensagem ‘É uma vogal!’, caso o caractere lido seja

uma vogal. Caso contrário imprima ‘O caractere lido não é uma vogal!’. Resolução: algoritmo acha_vogal; inicio caractere car; //Entrada de dados escreva(“Digite um caractere: “); leia( car ); //Processamento e saida de dados escolha( car ) inicio caso ‘A’: caso ‘a’: caso ‘E’: caso ‘e’: caso ‘O’: caso ‘o’: caso ‘U’: caso ‘u’: caso ‘ I’: caso ‘i’: escreva(“ O caracter e uma vogal!”); pare; caso contrario: escreva(“O caractere lido não e uma vogal!”); fim; fim. 3. Leia o mês e o ano (em números) e exiba o número de dias do mês digitado.

Obs.: meses com 30 dias: 4, 6, 9, 11 meses com 31 dias: 1, 3, 5, 7, 8, 10, 12 fevereiro possui 28 dias em ano não bissexto e 29 dias em ano bissexto. Um ano é identificado como bissexto quando ANO mod 4 = 0 e se Ano for divisível por 100 ele também deve ser divisível por 400.

4. Leia o número de um mês e imprima o nome do mês por extenso.

5. Leia uma data (dia, mês e ano) em valores numéricos e a imprima por extenso como mostrado no exemplo abaixo:

Lido: 21 04 1970 Escrito: 21 de abril de 1970

6. No curso de Introdução a Computação, a nota final do estudante é calculada a partir de 3 notas atribuídas respectivamente a um trabalho de laboratório, a uma avaliação semestral e a um exame final. As notas variam de 0 a 10 e a nota final é a média ponderada das 3 notas mencionadas. A tabela abaixo fornece os pesos das notas:

trabalho de laboratório - peso 2


51/77

avaliação semestral - peso 3 exame final - peso 5 Faça um algoritmo que receba as 3 notas, calcule e imprima a média final e o conceito desse estudante. O conceito segue a tabela abaixo: Média Final Conceito 8.0 |___| 10.0 A 7.0 |___ 8.0 B 6.0 |___ 7.0 C 5.0 |___ 6.0 D < 5.0 E

7. Faça um algoritmo que receba um código de origem (número inteiro) e imprima a sua procedência. A procedência obedece à tabela abaixo. Caso um código inválido seja digitado imprima uma mensagem de erro.

Código de Origem Procedência 1 Sul 2 Norte 3 Leste 4 Oeste 5 ou 6 Nordeste 7,8 ou 9 Sudeste 10 até 20 Centro-Oeste 21 até 30 Nordeste

Resolução: algoritmo identifica_regiao; inicio inteiro codigo; //Entrada de dados escreva(“ Digite o codigo da região: “); leia(codigo); //Processamento e saída de dados escolha( codigo ) inicio

caso 1: escreva(“Procedencia: Regiao Sul”); pare; caso 2: escreva(“Procedencia: Regiao Norte”); pare; caso 3: escreva(“Procedencia: Regiao Leste”); pare; caso 4: escreva(“Procedencia: Regiao Oeste”); pare; caso 5: caso 6: escreva(“Procedencia: Regiao Nordeste”); pare; caso 7: caso 8: caso 9: escreva(“Procedencia: Regiao Sudeste”);


52/77

pare; caso contrário: se ( (codigo>=10)&&(codigo<=20)) então escreva(“Procedencia: Regiao Centro-Oeste”); senão se (( codigo>=21)&&(codigo<=30))

escreva(“Procedencia: Regiao Nordeste”); senão

escreva(“Codigo invalido”); fim //escolha fim.//do algoritmo

Código de Origem Procedência 1 Sul 2 Norte 3 Leste 4 Oeste 5 ou 6 Nordeste 7,8 ou 9 Sudeste 10 até 20 Centro-Oeste 21 até 30 Nordeste

8. Faça um algoritmo que receba o código correspondente ao cargo de um funcionário e imprima seu cargo e o percentual de a umento ao qual este funcionário tem direito seguindo a tabela abaixo:


53/77

Código Cargo Percentual

1 Escriturário 50%

2 Secretário 35%

3 Caixa 20%

4 Gerente 10%

5 Diretor não tem aumento

9. Faça um algoritmo que mostre um menu com as seguintes opções: 1. soma 2. multiplicação 3. finalizar O algoritmo deve receber a opção desejada, receber os dados necessários para a operação de cada opção, realizar a operação e imprimir o resultado. Na opção finalizar nada deve acontecer. 10. Uma companhia de seguros tem três categorias de seguros baseadas na idade e ocupação do segurado. Somente pessoas com pelo menos 18 anos e não mais de 70 anos podem adquirir apólices de seguros. As classes de ocupações foram definidas em três grupos de risco. A tabela a seguir fornece as categorias em função da faixa de idade e do grupo de risco:

Código do Grupo de Risco Idade Baixo Médio Alto

18 a 24 7 8 9

25 a 40 4 5 6

41 a 70 1 2 3

Faça um algoritmo que receba a idade (um número inteiro) e o grupo de risco (representados pelos caracteres: `b`: baixo`; `m`: médio ou `a`: alto) e determine e imprima o código do seguro.

UNIDADE V – Comandos de Repetição O que vamos ver:


54/77

• Comandos de Repetição com teste no início • Comandos de Repetição com teste no final • Comandos de Repetição com variável de controle

Definição: Comandos de Repetição São comandos caracterizados por permitir que uma seqüência de comandos seja executada um número repetido de vezes. (Lembrem-se do exemplo inicial do algoritmo da troca da lâmpada ) 1. Repetição com teste no início Consiste de uma estrutura de controle do fluxo de execução que permite repetir diversas vezes um mesmo trecho do algoritmo, porém, verificando ANTES de cada execução se é permitido executar o mesmo trecho. Forma geral do comando enquanto: enquanto (<Condição>) faça inicio

<comando1>; <comando2>; ... <comandon>;

fim;

Antes da seqüência de comandos ser executada, a condição é avaliada. Caso seja verdadeira, a seqüência será repetidamente executada enquanto a condição permanecer verdadeira. Note que se a condição for falsa já na primeira avaliação, a seqüência de comandos não será executada. A condição deverá se tornar falsa em algum momento, caso contrário a seqüência será executada indefinidamente (Loop infinito). Exemplo 1: Mostrar os números inteiros de 1 a 10. algoritmo numeros; inicio

const inteiro maior = 10; inteiro i; i � 1; escreva(“ Números inteiros de 1 até ”, maior, “ : “); enquanto ( i <= maior) faça início


55/77

escreva (i, “ “); i � i + 1;

fim; fim. A aplicação do comando enquanto se dá em problemas onde o número de repetições não é conhecido. O exemplo anterior tem apenas exemplo didático, pois existe outro comando mais apropriado para este caso. Exemplo 2: Ler uma seqüência de salários terminada por um salário menor que zero. Para cada salário, mostrar o novo salário reajustado e, ao final, a média dos salários reajustados. O valor do reajuste deve ser lido no início do algoritmo.

algoritmo mediasalarial; início real salario, reajuste, novo_sal, tot_reaj, media; inteiro num_sal;

tot_reaj � 0; num_sal � 0; escreva (“Entre com o reajuste : “); leia (reajuste); escreva (“Entre com o salário ou salário negativo para parar: “); leia (salario); enquanto ( salario > 0) faça início

novo_sal � salario + (salario * reajuste) / 100; tot_reaj � tot_reaj + novo_sal; num_sal � num_sal + 1; escreva (“Salário reajustado: “, novo_sal); escreva (“Entre com o salário ou salário negativo para parar: “); leia (salario); fim; se (num_sal > 0) então início

media � tot_reaj / num_sal; escreva (“Média dos salários = “, media);

fim; senão

escreva (“Não existem dados a serem processados”); fim.


56/77

Exemplo 3: Ler uma seqüência de vogais terminada por ponto e exibir os totais de vogais e não vogais encontradas. Resolução:

algoritmo conta_vogal; início const caractere fim = ´.´; caractere car; inteiro cont_a, cont_e, cont_i, cont_o, cont_u, outros;

cont_a � 0; cont_e � 0; cont_i � 0; cont_o � 0; cont_u � 0; outros � 0; escreva (“Entre com o primeiro caractere ou . para parar: “); leia (car); enquanto ( car != fim) faça início

escolha (car) inicio

caso ‘a’: caso ‘A’ : cont_a � cont_a + 1; pare; caso ‘e’: caso ‘E’ : cont_e � cont_e + 1; pare; caso ‘i’ : caso ‘I’ : cont_i � cont_i + 1; pare; caso ‘o’: caso ‘O’ : cont_o � cont_o + 1; pare; caso ‘u’: caso ‘U’ : cont_u � cont_u + 1; pare; caso contrário: outros � outros +1;

fim; escreva (“Entre com o próximo caractere ou . para parar: “); leia (car);

fim; escreva (“O total de a’s é: “, cont_a); escreva (“O total de e’s é: “, cont_e); escreva (“O total de i’s é: “, cont_i); escreva (“O total de o’s é: “, cont_o); escreva (“O total de u’s é: “, cont_u); escreva (“O total de outros é: “, outros);

fim.


57/77

2. Repetição com teste no final Para realizar uma repetição com teste no final, utilizamos a estrutura faça enquanto, que permite que o bloco ou ação primitiva seja repetido enquanto uma determinada condição seja verdadeira. O modelo genérico desse tipo de repetição é o seguinte:

faça início


fim; enquanto(<Condição>);

Este comando, assim como o comando ENQUANTO, é usado quando não é conhecido o número de vezes que uma seqüência de comandos deverá ser executada. Porém a seqüência será executada pelo menos uma vez, visto que a avaliação da condição é feita ao final de cada interação. A seqüência será executada repetidamente até que a condição seja falsa. Esta condição deve ser uma expressão que retorne um valor lógico. A condição deverá se tornar falsa em algum momento, caso contrário a seqüência será executada indefinidamente (Loop infinito). Exemplo 4: Mostrar os números inteiros de 1 a 10.

algoritmo numeros; início const inteiro maior = 10; inteiro i; i � 1; escreva(“ Os números inteiros de 1 a 10:”); faça inicio escreva (i ,” “); i � i + 1; fim; enquanto (i <= maior); fim.

A aplicação do comando faça enquanto se dá em problemas onde o número de repetições não é conhecido, mas se deseja que a seqüência de comandos seja executada pelo menos uma vez. O exemplo anterior tem apenas exemplo didático, pois existe um outro comando mais apropriado para este caso.


58/77

Exemplo 5: Mostrar os números inteiros de 1 a 10, sendo que para cada número mostrado o algoritmo deve aguardar que sejam pressionadas a tecla C e ENTER para continuar.

algoritmo numeros; início

const inteiro maior = 10; inteiro i ; caractere tecla ; i � 1; escreva(“ Os números inteiros de 1 a 10:”); faça inicio

escreva (i); i � i+ 1; faça inicio

escreva (“tecle [C] para continuar…”); leia (tecla);

fim; enquanto ((tecla != ‘c’ ) e (tecla != ‘C’));

fim; enquanto (i <= maior);

fim.

3. Repetição com variável de controle Nas estruturas de repetição vistas até agora, ocorrem casos em que se torna difícil determinar o número de vezes em que o bloco de comandos será executado. Sabemos que ele será executado enquanto uma condição for satisfeita. A estrutura para é diferente, já que sempre repete a execução do bloco de comandos um número determinado de vezes, pois ela não prevê uma condição e possui limites fixos. Modelo genérico:

para (< inicialização da var> ; <condição de repetição> ; <incremento da var>) início


fim; O comando para é utilizado quando se deseja executar uma seqüência de comando repetidamente, um número conhecido e fixo de vezes. O número de vezes é controlado pela variável de controle <var>. Na primeira parte < inicialização da var> inicializa a variável de controle quando o comando é executado pela primeira vez. A segunda parte <condição de repetição> testa se a repetição deve


59/77

continuar e a terceira parte incrementa a variável de controle <var> (que geralmente é de uma unidade). Nos exemplos abaixo a seqüência será executada 10 vezes. Exemplo 5: Mostrar os números inteiros de 1 a 10 e de 10 a 1.

algoritmo numeros; início const inteiro maior = 10; inteiro i; escreva(“ Os números inteiros de 1 a 10:”); para( i � 1 ; i<= maior ; i � i + 1) início

escreva (i, “ “); fim;

escreva(“ Os números inteiros de 10 a 1:”); para (i � 10 ; i>= 1 ; i � i -1) início escreva (i , “ “); //neste caso, o início/fim são dispensáveis (Apenas um comando) fim;

fim. O incremento/decremento da variável de controle é na maioria das vezes igual a 1 ou -1. Geralmente o tipo da variável de controle é inteiro.

O que aconteceria se maior = 0 ?

Exercícios de Complementares: Comando Enquanto 01. Escreva um algoritmo que receba a idade de um grupo de pessoas, calcule e imprima a quantidade de pessoas maiores de idade (idade >= 18 anos). Para encerrar a entrada de dados, deve ser digitado um valor < 0. Resolução: algoritmo conta_maior_idade; inicio inteiro idade, cont � 0; escreva(“Digite a primeira idade ou idade < 0 para parar: “); leia(idade); enquanto ( idade >= 0 ) faça inicio se ( idade >= 18 ) então cont � cont + 1;


60/77

escreva(“Digite a proxima idade ou idade < 0 para parar: “); leia(idade); fim; se ( cont > 0 ) então escreva ( “ Total que atingiu a maioridade: “, cont); senão escreva(“ Ninguém atingiu a maioridade!”); fim. 02. Escreva um algoritmo que receba a idade de um grupo de pessoas, calcule e imprima a porcentagem de cada faixa etária em relação ao total de pessoas. As faixas etárias são: 01 - 15 anos - A 16 - 30 anos - B 31 - 45 anos - C 46 - 60 anos - D >= 61 anos - E Para encerrar a entrada de dados, digite uma idade <= 0. 03. Escreva um algoritmo que receba um conjunto de valores inteiros e positivos,calcule e imprima o maior e o menor valor do conjunto.

• Para encerrar a entrada de dados, deve ser digitado o valor zero. • Para valores negativos, deve ser enviada uma mensagem. • Esses valores (zero e negativo) não entrarão nos cálculos.

04. Faça um algoritmo que apresente um menu de opções (apresentado abaixo) para o cálculo das operações entre dois números reais lidos previamente: Programa Calculadora [1] – adição

[2] – subtração [3] – multiplicacao [4] – divisão [5] – sair do programa


61/77

Escolha uma opcao: Possibilitar ao usuário escolher a operação desejada, mostrar o resultado e voltar ao menu de opções. O programa só deve permitir a saída se o usuário teclar 5. 05. Faça um algoritmo receba o valor e o código de várias mercadorias vendidas em um determinado dia. Os códigos obedecem a tabela abaixo: “L” ou “l” - limpeza “A” ou “a” - alimentação “H” ou “h” - higiene Calcule e imprima: • total vendido naquele dia, com todos os códigos juntos; • total vendido naquele dia em cada um dos códigos. Para encerrar a entrada de dados, digite o valor da mercadoria zero. Exercícios Complementares: Comando faça/enquanto:

01. Faça um algoritmo que receba como entrada, uma lista de números positivos ou negativos finalizada com o número zero e forneça, como saída, a soma dos números positivos, a soma dos números negativos e a soma das duas parciais.

Resolução: algoritmo soma_numeros; inicio inteiro num, soma_pos � 0, soma_neg � 0, soma_total; //Entrada e processamento de dados faça inicio escreva(“Digite um numero inteiro ou 0 para parar: “); leia(num); se ( num != 0 ) entao inicio se ( num > 0 ) entao soma_ pos � soma_pos + num; senao soma_neg � soma_neg + num; fim; // fim se/entao

fim; // fim do bloco faça/enquanto enquanto ( num != 0 ); soma_total � soma_pos + soma_neg; //Saída de dados escreva(“Soma dos positivos: “, soma_pos); escreva(“Soma dos negativos: “, soma_neg); escreva(“Soma Total: “, soma_total);

fim.


62/77

02. Faça um algoritmo que receba a idade e a altura de várias pessoas, calcule e imprima a média das alturas das pessoas com mais de 50 anos. Para encerrar a entrada de dados, digite idade <= zero. 03. Construa um algoritmo que leia um conjunto de valores inteiros e positivos, e determine qual o menor e o maior valor do conjunto. Para valor final de entrada considerar o valor -1 que não deve ser considerado. Exercícios Complementares: Comando para: 01. Escreva um algoritmo para calcular N! (fatorial de N), sendo que o valor inteiro de N é fornecido pelo usuário. Sabe-se que: N! = 1 * 2 * 3 * ... * (N-1) * N; 0! = 1 Resolução: algoritmo calcula_fatorial; inicio inteiro num, fat � 1, i; //Entrada de Dados com tratamento de erro faça inicio escreva(“Digite um numero inteiro >=0: “); leia(num); se ( num < 0 ) então escreva(“Numero Invalido!”); fim; enquanto( num < 0 ); //Processamento de dados para( i � 2; i < = num; i � i + 1 ) fat � fat * i ; //Saída de dados escreva ( num, “ ! = “, fat); fim.


63/77

02. A conversão de graus Farenheit para Centígrados é obtida por C = (5/9.0) * (F - 32). Faça um algoritmo que calcule e escreva uma tabela de graus Centígrados e os graus Farenheit, que variam de 50 a 65 de 1 em 1. 03. Faça um algoritmo que receba a idade e o estado civil : C - casado, S - solteiro, V - viúvo e D - desquitado, de 10 pessoas. Calcule e imprima:

� a quantidade de pessoas casadas; � a média das idades das pessoas viúvas.

Lembre-se do exercício 11 de algoritmos em Portugol: 11 - Faça um algoritmo que receba um número inteiro, calcule e imprima a tabuada desse número. Resolução: algoritmo tabuada; inicio inteiro i, num; //Entrada de dados escreva(“Digite um numero para a tabuada: “); leia(num); //Processamento e saída de dados escreva(“A tabuada de multiplicação do numero “, num, “ : “); para ( i � 1; i <= 10; i � i + 1 ) escreva(num , “ * ”, i, “ = “,i * num); fim.

Rastreamento

Memória Tela i: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 num: 2

Digite um numero para a tabuada: 2 <Enter> 2 * 1 = 2 2 * 2 = 4 2 * 3 = 6 2 * 4 = 8 2 * 5 = 10 2 * 6 = 12 2 * 7 = 14 2 * 8 = 16


64/77

2 * 9 = 18 2 * 10 = 20

Exercícios de Fixação VI

1. Faça um algoritmo que imprima todos os números inteiros no intervalo [0, 100]. 2. Faça um algoritmo que leia uma seqüência de N números positivos e calcule e

imprima a média aritmética entre eles. A leitura é encerrada quando um número negativo ou nulo for digitado.

3. Faça um algoritmo que leia o peso, em quilogramas, de N bois e calcule e imprima:

• o peso médio do rebanho; • o peso do boi mais gordo; e • o peso do boi mais magro.

Encerre a leitura quando um peso nulo for digitado. 4. Faça um algoritmo que leia 50 dados contendo as medidas de diferentes retângulos

(base, altura), e emita um relatório contendo o perímetro e a área de cada retângulo.

5. Escreva um algoritmo que encontre o maior e o segundo maior número de uma

série de números lidos do teclado. Obs: - Use uma marca (um flag) para a saída do comando de repetição, uma vez que o número de repetições não é conhecido. 6. Faça um algoritmo que leia uma seqüência de números inteiros positivos (um por

vez), e verifique se eles são pares ou impares. Obs: - Use uma marca (um flag) para a saída do comando de repetição, uma vez que o número de repetições não é conhecido. 7. Seja S = 2, 3, 5, 8, 13, 21, 34, 55, ... um exemplo de uma série de Fibonacci.

Perceba que o padrão de comportamento desta série é tal que cada número a partir do terceiro é a soma dos dois anteriores. Escreva um algoritmo que gere uma série de Fibonacci até o n-ésimo termo, onde n será um valor lido.

Dica: - leia os dois primeiros termos. Resolução: algoritmo serie_fibonacci; inicio


65/77

inteiro n, t1� 2, t2 � 3, t3, cont � 2; //Entrada de dados com trat. de erro faça inicio escreva(“Entre com o numero de termos ( >=3): “); leia( n ); se ( n < 3 ) então escreva(“Numero de termos invalido!”); fim; enquanto( n < 3 ); //Processamento e saída de dados escreva(“Serie de Fibonacci: “, t1, “ “, t2); enquanto( cont < n ) inicio t3 � t1 + t2; escreva( t3, “ “); t1 � t2; t2 � t3; cont � cont + 1; fim; fim. 8. Dada a série: 2 3 4 9 16 29 54 99... onde cada elemento a partir do quarto é a

soma dos três termos que lhe antecedem. Faça um algoritmo que leia apenas os três termos iniciais, que podem ser quaisquer, e, a partir daí, obtenha e imprima mais 20 termos da referida série.

9. Faça um algoritmo que calcule e imprima o valor da soma: S = 1 + 3 + 5 + 7 + ... + 99 1 2 3 4 50 10. Faça um algoritmo para calcular o valor da equação abaixo. Onde o valor de n será

lido.

∑=

=

n

kkS

1

2

6

11. Faça um algoritmo que leia um conjunto de 30 matrículas dos vendedores de uma

firma comercial, juntamente com os respectivos totais de vendas diárias e verifique quantos deles estão na faixa compreendida entre R$500.00 e R$1500.00. Imprima uma listagem contendo todas as matrículas das pessoas situadas no intervalo especificado, bem como o total delas.

12. Faça um algoritmo que leia uma seqüência de N (o valor de N é lido durante a

execução do algoritmo) conjuntos de dados, cada conjunto contendo a conta do correntista de uma caderneta de poupança e seu respectivo saldo médio. Imprima:


66/77

a) o total de clientes bons, clientes que possuem o saldo médio entre 500 e 1000 reais; b) o total de clientes razoáveis, clientes que possuem o saldo médio menor 500 reais; c) o número da conta com maior saldo médio.

13. Faça um algoritmo que leia 80 números reais, imprima o menor e o número de vezes

que ele aparece. Resolução: algoritmo acha_e_conta_menor; inicio real num, menor; inteiro vezes , i; escreva(“Digite o primeiro numero real: “); leia( num ); menor � num; vezes � 1; para ( i �2; i<= 80; i � i+1) inicio escreva(“Digite o “, i,”o numero real: “); leia( num ); se ( num < menor) inicio menor � num; vezes � 1; fim senão se ( num == menor ) vezes � vezes + 1; fim escreva(“O menor numero foi “, menor, “ e apareceu “, vezes, “ vezes“); fim

14. O sistema de avaliação de uma determinada disciplina obedece aos seguintes critérios :

• durante o ano letivo são dadas três notas. • a nota final é obtida pela média aritmética das notas dadas durante o curso. • é considerado aprovado o aluno que obtiver a nota final superior ou igual a 7.0

e que tiver comparecido a um mínimo de 40 aulas. Faça um algoritmo que: a) Leia um conjunto de dados contendo a matricula, as três notas e a freqüência de 100 alunos. b) Imprima:


67/77

• para cada aluno, o número de matricula, a freqüência, a nota final e uma mensagem informando se este esta aprovado ou reprovado;

• a maior e a menor nota da turma; • a nota média da turma; e • o total de alunos reprovados.

15. Faça um algoritmo que leia uma seqüência de dados contendo a matrícula e a

medida da altura dos funcionários de uma empresa e imprima: • altura média dos funcionários; • o total de funcionários baixos (altura inferior a 1.55 m); e • o total de funcionários de altura mediana (1.55m <= Altura <= 1.75m).

Obs: - utilize uma marca (um flag) para indicar o final da entrada de dados.

16. Um serviço de correspondência sentimental mantém um fichário de seus clientes.

Cada ficha contém as seguintes informações: Matrícula, Sexo (M, m, F ou f), Idade, Altura (em m), Peso (em quilogramas), Cor dos olhos (1-azul, 2-castanhos, 3- outros), Cor dos cabelos (1- ruivos, 2- loiros, 3- outros).

Prepare um algoritmo que leia este fichário e imprima as matrículas de: • Todos os homens loiros de olhos castanhos, altura maior que 1.75 m, pesando

entre 75Kg e 95 Kg. • Todas as mulheres ruivas de olhos azuis, altura entre 1.65 m e 1.75 m, pesando

menos de 60 Kg. Obs: - utilize uma marca (um flag) para indicar o final da entrada de dados. Resolução: //Usarei a digitação de uma matricula negativa ou nula como flag de parada Algoritmo correio_sentimental; inicio inteiro matricula, idade, cor_olhos, cor_cab; real altura, peso; caractere sexo; faca inicio escreva(“Digite a matricula ou matricula <= 0 para parar: “); leia(matricula); se ( matricula > 0 ) inicio escreva(“Sexo (m ou f): “); leia(sexo); escreva(“Idade: “); leia(idade); escreva(“Altura e peso: “); leia(altura,peso); escreva(“Cor dos olhos: “); escreva(“1. Azul ou 2. Castanho ou 3. Outros “);


68/77

leia(cor_olhos); escreva(“Cor dos cabelos: “); escreva(“1. Ruivos ou 2. Loiros ou 3. Outros “); leia(cor_cab); se ( (sexo == ‘F’) ||(sexo==’f’)) se ( cor_cab == 1 ) se (cor_olhos == 1 ) se ( (altura>=1.65) && ( altura<=1.75)) se ( peso < 60) escreva(“A matricula e “, matricula); se ( (sexo == ‘M’) ||(sexo==’m’)) se ( cor_cab == 2 ) se (cor_olhos == 2 ) se ( altura>1.75) se ( (peso >= 75) && ( peso <=95)) escreva(“A matricula e “, matricula); fim//se matricula fim enquanto(matricula>0); fim 17. Faça um algoritmo à ser fornecido ao Detran para provimento das informações

abaixo descritas, referentes a acidentes em estradas: • percentagem de motoristas não-habilitados; • percentagem de homens no volante; e • percentagem de motoristas inexperientes (menos de 20 anos).

Os dados de entrada contém o ano de nascimento, o sexo e o código de habilitação dos motoristas, sendo: Código de Habilitação = 1 - motorista habilitado e Código de Habilitação = 2 - motorista não-habilitado. Obs: - utilize uma marca (um flag) para indicar o final da entrada de dados. 18. Faça um algoritmo que teste a validade de uma senha digitada no teclado. A

digitação deve ser refeita até que a senha correta seja digitada ou o número de tentativas seja maior que 5. A senha correta é o número 12345.


69/77

19. Faça um algoritmo que tendo lido uma vogal minúscula imprima sua correspondente maiúscula. Repita a leitura quantas vezes for necessário até que uma vogal maiúscula seja digitada como entrada.

20. Faça um algoritmo que leia um número inteiro no intervalo [1, 12] e imprima o nome do mês correspondente. Garanta que somente números no intervalo [1, 12] serão aceitos.

21. Faça um algoritmo que imprima a soma de todos os inteiros no intervalo [5, 30]. 22. Faça um algoritmo que leia N notas, N é lido, calcule e imprima a média aritmética

entre elas. 23. Faça um algoritmo que leia 50 números e imprima o menor e o maior. 24. Dada a série 2 3 4 9 16 29 54 .... Faça um algoritmo que leia os três primeiros

termos e em seguida imprima os próximos 20 termos. 25. Faça um algoritmo que leia o preço e o código de 20 mercadorias presentes em uma

cesta básica. Os códigos obedecem à tabela abaixo: ‘l’ ou ‘L’ : limpeza ‘a’ ou ‘A’ : alimentação ‘h’ ou ‘H’ : higiene

Calcule e imprima: - o preço total da cesta básica; e - para cada código, o preço total das mercadorias presentes na cesta.

26. De posse de um conjunto de dados contendo a altura e o sexo (F, f, m ou M) de 15

pessoas. Faça um algoritmo que calcule e imprima: • a maior e a menor altura do grupo; • a altura média das mulheres; e • o número de homens.

27. A conversão de graus Farenheit para Celsius é obtida por C = 5/9*(F-32). Faça um

algoritmo que calcule e escreva uma tabela de equivalência entre graus Celsius e graus Farenheit, com os valores variando de 1 em 1 de 50 a 65 graus Farenheit.

28. Uma empresa decidiu fazer um levantamento dos seus 500 funcionários. Faça um

algoritmo que leia para cada funcionário a idade, o sexo (F, f, m ou M), experiência de mais de 3 anos no serviço (S, s, n ou N). Calcule e escreva:

• o número de funcionários do sexo feminino; • o número de funcionários do sexo masculino; • a idade média dos homens com mais de 3 anos de experiência no serviço; • a porcentagem dos homens com mais de 45 anos entre o total de homens; • o número de mulheres com idade inferior a 35 anos com mais de 3 anos de

experiência; e


70/77

• a menor idade entre as mulheres com experiência no serviço. 29. Faça um algoritmo que imprima as tabuadas de multiplicação dos números de 1 a

10. 30. Faça um algoritmo que receba 2 notas de 10 alunos. Calcule para cada aluno sua

média e imprima uma mensagem de acordo com a tabela abaixo: Média Mensagem Abaixo de 3 Aluno Reprovado Entre 3 e 7 Aluno de Recuperação Maior ou igual a 7 Aluno Aprovado


71/77

UNIDADE VI – Estrutura de Dados Composta Homogênea e Unidimensional O que vamos ver: • Vetores • Tipos Estruturados • Variáveis Compostas Homogêneas • Variáveis Compostas Unidimensionais – VETORES 1. Vetores Retornando ao conceito de informações e tipos de informação, podemos notar que foi feita uma divisão imaginária, a fim de tornar mais simples a classificação das informações. Talvez alguns já tenham notado que a quantidade de tipos de dados primitivos não é suficiente para representar toda e qualquer informação que possa surgir. Portanto, em muitas situações, esses recursos são escassos, o que poderia ser suprido se existissem mais tipos de dados ou, ainda melhor, se esses tipos pudessem ser “construídos”, criados, à medida que se fizessem necessários. 2. Tipos Estruturados São organizações de dados construídas a partir da composição dos tipos primitivos já existentes (caractere, inteiro, real). Esses novos tipos podem armazenar um conjunto de dados conhecidos como variáveis compostas. As variáveis que armazenam esses tipos de dados podem ser classificadas em: variáveis compostas homogêneas e variáveis compostas heterogêneas. 3. Variáveis Compostas Homogêneas São variáveis que armazenam vários elementos do mesmo tipo primitivo. Exemplo: alcatéia (vários lobos), conjunto de números inteiros, e outros. As variáveis compostas são estruturas de dados (armazenam um conjunto de dados). Esses dados podem ser armazenados em dois tipos de variáveis: as variáveis unidimensionais (conhecidas como vetores) e as variáveis multidimensionais (conhecidas como matriz). 4. Variáveis Compostas Unidimensionais - VETORES


72/77

São variáveis que necessitam de apenas um índice para individualizar um elemento do conjunto. Exemplo:

real media[40]; ou usando uma constante: const inteiro TAM=40; // const int TAM = 40; real media[TAM]; // float media[TAM];

Estrutura que se forma: media:

0 1 2 3 4 5 6 ... ... 39 8.0 7.0 5.5 9.5 6.4 9.9 1.0 4.8

Para acessar cada elemento da variável composta unidimensional (vetor) é necessário especificar o nome da variável seguido do número do elemento que se deseja acessar (deverá estar entre colchetes). Este número tem o nome de índice. O índice pode varia de 0 até n-1 (onde n é o número que representa a quantidade de variáveis simples do vetor). Exemplos de utilização de um vetor: leia (media[1]); // scanf(“%f”, &media[1]); media [2] � 8.5; // media[2] = 8.5; escreva(media[3]);// printf(“%.2f\n”, media[3]); ....... Exemplo 1: Dados 5 valores numéricos reais elaborar um algoritmo que calcule e exiba a média dos valores dados e quantos desses valores estão acima da média. a) Resolução sem utilizar vetor: algoritmo media_turma; início inteiro cont ; real n1, n2, n3, n4, n5, media; cont� 0; escreva(“ Digite o 1º número: “); leia (n1); escreva(“ Digite o 2º número: “); leia (n2); escreva(“ Digite o 3º número: “); leia (n3); escreva(“ Digite o 4º número: “); leia (n4);


73/77

escreva(“ Digite o 5º número: “); leia (n5); media � (n1+n2+n3+n4+n5)/5; escreva(“A média dos números é “, media); se (n1>media) então

cont ← cont + 1; se (n2>media) então




cont ← cont + 1; escreva(“Quantidade de números acima da média é “, cont); fim; b) Resolução utilizando variável composta: algoritmo media_de_numeros; início

const inteiro qn = 5; // Quantidade de números real media, numeros[qn], soma;

inteiro i, cont; cont ← 0; soma ←0; // Inicialização das variáveis contadora e

// acumuladora

para (i�0; i < qn ; i � i+1) início escreva(“Digite o “,i+1,”º número: “); leia(numeros[i]); fim; para (i�0; i < qn ; i � i+1) soma← soma + numeros[i]; media ← soma/qn; escreva(“ A média dos números é: “, media); para (i�0; i < qn ; i � i+1) inicio se (numeros[i]>media) então

cont ← cont +1; fim; escreva(“ Quantidade de números acima da média: “, cont);


74/77

fim. Exemplo 2 – Elabore um algoritmo que leia, some e imprima o resultado da soma entre dois vetores inteiros de 50 posições. Resolução: algoritmo soma_dois_vetores; início

const inteiro TAM = 50; // Tamanho do vetor inteiro vet_a[TAM], vet_b[TAM], vet_r[TAM]; // Declaração dos vetores;

inteiro i; // Declaração da var. inteira a ser utilizada para índice // Entrada de dados para os dois vetores: para (i �0; i<TAM; i� i+1) inicio

escreva(“Digite o “, i+1 ,”º número do vetor a: “); leia(vet_a[i]);

escreva(“Digite o “, i+1 ,”º número do vetor b: “); leia(vet_b[i]);

fim;

// Processamento de dados para (i �0; i<TAM; i� i+1)

vet_r[i] � vet_a[i] + vet_b[i];

// Saída de dados escreva (“ Vetor soma: “);

para (i �0; i<TAM; i� i+1) escreva(vet_r[i], “ “); fim. Exercícios Propostos: 1) Dado um vetor contendo 10 elementos numéricos elabore um algoritmo que verifique se outro valor dado pertence ou não ao vetor, se pertencer exibir quantas vezes ele aparece no vetor. Caso contrário, mostrar uma mensagem informando que o número não está no vetor.

2) Considere um vetor de tamanho máximo 100 de números reais. Solicite ao usuário qual o limite superior válido que ele deseja e em seguida desenvolva um algoritmo que leia o vetor até o limite superior escolhido e determine qual é o menor valor existente no vetor. O algoritmo deve ainda subtrair de todos os elementos este valor. Exibir o vetor resultado. 3) Faça um algoritmo que receba as notas da primeira prova de 10 alunos e armazene essas notas em um vetor. Receba as notas da Segunda prova de 10 alunos e armazene essas notas em outro vetor. Calcule e imprima a média entre essas duas notas de cada aluno.


75/77

4) Faça um algoritmo que receba as médias de 10 alunos e armazene essas média em um vetor. Calcule e imprima: - a média da classe; - a quantidade de alunos aprovados, isto é, com média >= 7; - a quantidade de alunos reprovados, isto é, com média < 7. 5) Faça um algoritmo que receba a temperatura média de cada mês do ano e armazene essas temperaturas em um vetor; calcule e imprima a maior e a menor temperatura do ano e em que mês estas temperaturas aconteceram.

Exercícios de Fixação VII 1. Faça um algoritmo que leia um vetor de 40 valores inteiros. Imprima os índices onde o número 23 aparece. 2. Faça um algoritmo que leia dois vetores A e B de 30 componentes. Gere o vetor C, do mesmo tipo de A e B, onde cada elemento de C é a subtração do elemento correspondente de A com B. 3. Faça um algoritmo que tendo lido 2 vetores, A e B, de 20 e 30 elementos, respectivamente, construa um vetor C composto pela junção dos vetores A e B. Por exemplo:

const inteiro tam1 = 20, tam2 = 30; inteiro vet_a[tam1], vet_b[tam2], vet_j[tam1+tam2];

Exemplo: Vet_a:

0 1 8 7

Vet_b:

0 1 2 17 13 55

Vet_j:

0 1 2 3 4 8 7 17 13 55


76/77

4. Faça um algoritmo que leia um vetor A de 100 componentes. Construa um vetor B, do mesmo tipo do vetor A, observando a seguinte lei de formação: se o índice do componente em B é par este deve receber o componente correspondente em A multiplicado por 2; se o índice em B é impar este recebe o componente correspondente em A. Exemplo: Vet_a:

0 1 2 3 4 5 6 ... ... 99 8 7 5 9 6 9 1 4

Vet_b:

0 1 2 3 4 5 6 ... ... 99 16 7 10 9 12 9 2 4

5. Faça um algoritmo que leia a nota dos 60 alunos da disciplina de programação e imprima:

• A nota média da turma • A menor e a maior nota da turma • O total de alunos cuja nota é inferior a nota média da turma

6. Faça um algoritmo que leia 50 notas e 50 matrículas dos alunos de Programação. Informe os números de matrícula dos alunos cuja nota é inferior à nota média da turma. 7. Um armazém trabalha com 100 mercadorias diferentes identificadas pelos números inteiros de 1 a 100. O dono do armazém utiliza uma tabela para guardar o preço de cada mercadoria. A tabela tem o formato mostrado abaixo:

1 2 3 4 5 ... 100 5 20 10 8 54 ... 4.5

onde, a posição 1 armazena o preço da mercadoria identificada pelo número 1, e assim por diante. Faça um algoritmo que tendo lido uma tabela com o formato acima imprima o número das mercadorias cujo preço é maior que 5 reais.

8. Faça um algoritmo que tendo lido um vetor VET de 10 números inteiros positivos, crie um novo vetor VETPAR com os elementos pares do vetor VET. Antes de preencher o vetor VETPAR com os números pares de VET faça com que todos os componentes de VETPAR recebam o valor zero. Exemplo:

0 1 2 3 4 5 6 7 8 9 Vetor VET = 2 9 7 5 10 4 3 1 6 21


77/77

0 1 2 3 4 5 6 7 8 9 Vetor VETPAR = 2 10 4 6 0 0 0 0 0 0 9. Faça um algoritmo que leia dois vetores de 10 elementos do tipo real. Intercale os elementos destes dois vetores criando um novo vetor de 20 elementos. Exemplo: Vetor1 1 2 3 4 5 6 7 8 9 10 2 9 7 5.5 10 4 3 -1 6 21 Vetor2 1 2 3 4 5 6 7 8 9 10

32 -4 12 6 90 -4 5 43 27 82 Vetor criado a partir dos anteriores 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 2 32 9 -4 7 12 5 6 10 90 4 -4 3 5 -1 43 6 27 21 82 10. Faça um algoritmo que leia a nota dos alunos da turma de Programação. Calcule a média da turma e imprima as notas maiores ou iguais a média. Considere que a turma possua no máximo 60 alunos e que existe a possibilidade de não estar completa. 11. Faça um algoritmo que leia 2 vetores, A e B, de 30 elementos e informe o número de vezes que os elementos de A aparecem em B. 12. Uma empresa comercializa uma peça especial para a fábrica da Ferrari. O preço da peça é determinado mensalmente de acordo com uma tabela anual (vetor). Faça um programa C que receba a quantidade de peças vendidas por MÊS e armazene essas quantidades em um vetor. Receba também o preço que a peça foi comercializada e armazene esses preços em outro vetor. Em seguida o programa deve: (a) Calcular e mostrar o total de peças vendidas e (b) calcular e mostrar o faturamento bruto total da empresa em um ano (quantidade * preço).

algoritmos em portugol

Documents