Lógica de Programação - Educacionalpessoal.educacional.com.br/up/3670002/686835/apostila_logica.pdf · Lógica de Programação 6 1.4.1 Língua Idioma de um povo, formado por seus

Lógica de Programação 1

Lógica de ProgramaçãoI

Ana Carolina S. S. [email protected]

Setembro/2006

Profª Ana Carolina [email protected]


Índice1 Algoritmos...................................................................................................................5

1.1 O que são Algoritmos?......................................................................................................................................................51.2 Representações..................................................................................................................................................................51.3 Qual é a dificuldade no aprendizado de algoritmos?.....................................................................................................51.4 Língua x Linguagem...........................................................................................................................................................5

1.4.1 Língua ............................................................................................................................................................................................61.4.2 Linguagem......................................................................................................................................................................................6

1.4.2.1 Linguagem Natural..............................................................................................................................................................61.4.2.2 Linguagem Artificial.............................................................................................................................................................6

1.4.2.2.1 Linguagem algorítmica...............................................................................................................................................61.4.2.2.2 Linguagem de programação.......................................................................................................................................6

1.4.3 Diferença entre Linguagem natural e Linguagem artificial..............................................................................................................61.4.3.1 Ambigüidade: ......................................................................................................................................................................61.4.3.2 Estrutura e complexidade: ..................................................................................................................................................61.4.3.3 Objetivo Geral x Objetivo Específico: .................................................................................................................................61.4.3.4 Estrutura e significado:........................................................................................................................................................6

1.5 Características dos algoritmos.........................................................................................................................................72 Conceitos Básicos......................................................................................................8

2.1 Constante.............................................................................................................................................................................82.2 Variável ...............................................................................................................................................................................82.3 Operações............................................................................................................................................................................82.4 Dados...................................................................................................................................................................................8

2.4.1 Tipos de Dados...............................................................................................................................................................................82.4.1.1 Escalares (primitivos).........................................................................................................................................................82.4.1.2 Estruturados........................................................................................................................................................................9

2.5 Operações............................................................................................................................................................................92.5.1 Operações aritméticas....................................................................................................................................................................92.5.2 Operações relacionais e lógicas....................................................................................................................................................9

2.5.2.1 Operações Relacionais.......................................................................................................................................................92.5.2.2 Operações Lógicas............................................................................................................................................................10

2.5.3 Operações Monádicas e Diádicas................................................................................................................................................10

2.6 Atribuição..........................................................................................................................................................................102.7 Expressões........................................................................................................................................................................10

2.7.1 Expressões Aritméticas................................................................................................................................................................112.7.2 Expressões lógicas.......................................................................................................................................................................11

3 Instruções e Operações...........................................................................................123.1 Critérios de Algoritmos Eficientes..................................................................................................................................12

3.1.1 Correção.......................................................................................................................................................................................123.1.2 Tempo de execução.....................................................................................................................................................................123.1.3 Adaptabilidades............................................................................................................................................................................123.1.4 Simplicidade.................................................................................................................................................................................123.1.5 Elegância......................................................................................................................................................................................123.1.6 Legibilidade...................................................................................................................................................................................12

3.2 Como construir.................................................................................................................................................................12



3.3 Componentes de um algoritmo.......................................................................................................................................123.3.1 Entradas.......................................................................................................................................................................................123.3.2 Saídas..........................................................................................................................................................................................133.3.3 Atribuição......................................................................................................................................................................................133.3.4 Tipos de Dados/Variáveis/Constantes..........................................................................................................................................13

4 Operadores................................................................................................................144.1 Operadores Aritméticos...................................................................................................................................................144.2 Operador de resto e quociente de divisão inteira.........................................................................................................14

4.2.1 Prioridades de resolução...................................................................................144.3 Operadores Relacionais...................................................................................................................................................144.4 Operadores Lógicos.........................................................................................................................................................15

4.4.1 Tabelas-Verdade..........................................................................................................................................................................154.4.1.1 Operação de negação.......................................................................................................................................................154.4.1.2 Operação de conjunção.....................................................................................................................................................164.4.1.3 Operação de disjunção......................................................................................................................................................164.4.1.4 Prioridades.........................................................................................................................................................................16

5 Algoritmos seqüenciais...........................................................................................175.1 Atividades com soluções.................................................................................................................................................18

6 Comandos de Seleção..............................................................................................216.1 Comando de Seleção Simples........................................................................................................................................22

6.1.1 Atividades.....................................................................................................................................................................................22

6.2 Seleção Múltipla................................................................................................................................................................306.2.1 Atividades.....................................................................................................................................................................................32

7 Comandos de Repetição..........................................................................................337.1 Acumulador.......................................................................................................................................................................337.2 Contador............................................................................................................................................................................33

7.2.1 O operador ++......................................................................................................................................................................33

7.3 Comandos de Repetição..................................................................................................................................................337.3.1 Para..............................................................................................................................................................................................347.3.2 Enquanto......................................................................................................................................................................................347.3.3 Faça...enquanto............................................................................................................................................................................34

7.4 Atividades..........................................................................................................................................................................358 Matrizes......................................................................................................................39

8.1 Matrizes Unidimensionais - Vetores...............................................................................................................................398.2 Matrizes Bidimensionais..................................................................................................................................................40

8.2.1 Ordenação de matrizes – método da bolha..................................................................................................................................428.2.2 Ordenação de Matrizes - método de troca do maior:....................................................................................................................44

8.3 Atividades..........................................................................................................................................................................459 Estruturas ou Registros...........................................................................................48

9.1 Criando...............................................................................................................................................................................489.2 Acrescentando mais detalhes.........................................................................................................................................499.3 Usando...............................................................................................................................................................................509.4 Exemplos...........................................................................................................................................................................50



10 Subalgoritmos.........................................................................................................5410.1 Funções...........................................................................................................................................................................54

10.1.1 Implementação...........................................................................................................................................................................5410.1.1.1 Nome da Função.............................................................................................................................................................5410.1.1.2 Chamada.........................................................................................................................................................................5510.1.1.3 Variáveis públicas e locais...............................................................................................................................................55

10.2 Procedimentos................................................................................................................................................................5610.2.1 Implementação...........................................................................................................................................................................5610.2.2 Chamada....................................................................................................................................................................................56

11 Exercícios................................................................................................................5711.1 Seqüenciais.....................................................................................................................................................................5711.2 Seleção.............................................................................................................................................................................5711.3 Repetição.........................................................................................................................................................................5811.4 Vetores e matrizes..........................................................................................................................................................58

Bibliografia...................................................................................................................60



1 Algoritmos

● Uma forma de indicar o caminho para a solução dos mais variados problemas.● São quase tão antigos quanto a matemática● Deriva do nome de um matemático Persa, século IX, ABU JA’FAR MAOMÉ IBN MÛSÂ

ALKHOWÂRIZM

1.1 O que são Algoritmos?Algoritmo é o caminho para a solução de um problema, e os caminhos são muitos.Algoritmo não é a solução do problema, senão cada problema teria um único algoritmo ou uma única solução.

A solução de um problema é obtida por meio da execução do algoritmo, realizado:● Mentalmente● Manualmente (lápis e papel)● Computador

1.2 Representações➢ Linguagens semelhantes a Linguagens de programação.

software ILA, que interpreta algoritmos escritos de forma bem similar à linguagem natural➢ Representações Gráficas.

Fluxogramas e diagramas de Chapin➢ Linguagens Estruturadas ou Português Estruturado.

1.3 Qual é a dificuldade no aprendizado de algoritmos?Expressar idéias da linguagem natural em forma de símbolos e códigos (linguagem formal)

LINGUAGEM NATURAL

(expressão completamente livre)

LINGUAGEM ALGORÍTMICA

(expressão organizada, com sintaxe, mas com atenção à lógica, e não tanto na sintaxe)

LINGUAGEM FORMAL

(com sintaxe - não familiar)

A dificuldade está em organizar o raciocínio lógico, de forma estruturada, com um conjunto de etapas bem definidas, paraatingirmos um objetivo esperado (solução do problema).

1.4 Língua x Linguagem



1.4.1 LínguaIdioma de um povo, formado por seus costumes, hábitos e trejeitos.Ex.: Língua portuguesa (dicionário, hábitos culturais escritos ou falados)

1.4.2 LinguagemAlguma coisa criada para uma situação específica a fim de comunicação. Fornece um conjunto de termos (vocabulário), regras

(sintaxe) e significados (semântica) que permitem um entendimento.

1.4.2.1 Linguagem NaturalUtilizada para comunicação entre pessoas.

1.4.2.2 Linguagem ArtificialComunicação criada para fins específicos.Ex.: Linguagem de programação – comunicação entre seres inteligentes (pessoas) e não inteligentes (máquinas)

1.4.2.2.1 Lin g u a g e m a l go r í tm i ca

Utiliza alguns termos, regras, mas a principal ênfase é na l ó g i ca p a r a a s o l u ç ã o d o p ro b l e m a .

1.4.2.2.2 L i ngua g em de p r ogra m a ç ão Termos, regras e significados que são compreendidos pelo programador e que permitem a formulação de

instruções que serão processadas e executadas pelo computador.Temos maior preocupação com detalhes de codificação/implementação.

1.4.3 Diferença entre Linguagem natural e Linguagem artificial1.4.3.1 Ambigüidade:

certas frases e expressões apresentam mais de um sentido.

• O homem viu o menino com o telescópio. (quem está com o telescópio ?)

• Ele esteve em minha c o m p a n h i a . (pode significar “ele esteve comigo” ou “ele esteve em minha empre s a ”).

1.4.3.2 Estrutura e complexidade: longas frases sem pontuação, como por exemplos os textos jurídicos.

Quando ela saiu la da minha casa e da minha casa ela saiu de novo e dai entrou de novo e dai saiu de novoa gente foi procurar o caderno e dai o caderno caiu e dai quando o caderno caiu o caderno molhou e o cadernoficou molhado porque o caderno caiu.

1.4.3.3 Objetivo Geral x Objetivo Específico: entender de forma completa, e não isolada, e somente o que está realmente expresso - não subentender coisas (“adivinhar”).

• O v i n h o se d á na p ac i ên c i a d o s c a c h o s . (cacho tem paciência??) (entender de forma completa, e nãoisolada)

1.4.3.4 Estrutura e significado:• A = ;• Eu pegamos a casa.• Eu d e z o mel a n c ia aqui. (os termos estão corretos se estiverem isolados, mas juntos não formam um

bom contexto – um contexto “intendível”)



1.5 Características dos algoritmosUm algoritmo deve ser definido como uma seqüência ordenada e sem ambigüidade de passos que levam a solução de um

determinado problema.

Um algoritmo tem cinco características importantes:

Finitude: Um algoritmo deve sempre terminar após um número finito de passos.

Definição: Cada passo de um algoritmo deve ser precisamente definido (sem ambigüidades)

Entradas: Um algoritmo pode ter uma ou mais entradas, isto é, dados que são lhe são fornecidos antes do algoritmo iniciar. Emraros casos o algoritmo terá zero entradas.

Saídas: Um algoritmo deve ter pelo menos uma saída, isto é, informar resultados que têm uma relação específica com as entradas(resultados dos processamentos das entradas)

Efetividade: Um algoritmo deve ser efetivo. Todas as operações devem ser tão simples e tão suficientes para solucionar oproblema, de forma que uma pessoa pode executá-las facilmente usando lápis e papel, e que mesmo assim o problema seja solucionado.



2 Conceitos Básicos

2.1 ConstanteSão valores invariantes em todas as expressões em que possa ser utilizado. Exemplo:

• pi = 3,14159265358979323846...• aceleração da gravidade na Terra (g) = 9.8 m/s²

2.2 Variável São objetos que representam valores em uma fórmula para que ela possa ser generalizada. Representa, então, uma

classe de um problema e não um problema específico.

• Ex: soma de dois números: 2 + 4 = 6 ou x + y = z, onde x e y são números variantes (variáveis) e z também é variável, poisdepende do x e do y para assumir um determinado valor.

2.3 OperaçõesSão ações executadas sobre operandos (valores constantes ou valores variáveis) que foram previamente definidos.

Representam a entrada, processamento e saída: ler, manipular, escrever.

● Certas operações só ocorrem em determinados objetos.

• Fogo no carvão, salgar a carne. (porque não podemos colocar fogo na carne salgar o carvão)• √ a , onde a deve ser um número real e positivo. (porque não se pode fazer uma raiz de um número

negativo ou número irreal)

● Operações seguem uma seqüência pré-determinada

• 2+5*3 , por definição, sempre a multiplicação é feita antes de uma soma ou subtração

2.4 Dados• Dados representam valores quaisquer, em qualquer intervalo ou domínio.

• 100; verdadeiro; ‘casa’; ‘200’; 12.50; ‘João’, e qualquer outro valor que possa ser representado.

• Representam somente o valor, não informando o contexto ou domínio em que se encontra.

• O número 100 é um dado que pode representar:

o saldo da conta bancária de um indivíduo a idade da bisavó dele um instante de tempo em segundos, minutos ou horas, e assim por diante.

• O nome “João” pode representar:

um aluno da Universidade um paciente de um hospital, etc. Um funcionário de uma empresa

2.4.1 Tipos de DadosDados podem ser classificados em dois tipos:

2.4.1.1 Escalares (primitivos)

São dados de tipos padrão como inteiros, reais, caracter e booleanos, que são bem definidos e geralmente bemconhecidos.

Inteiros: representam somente números pertencentes aos conjuntos I ou Z. Ex.: 100; -1; 100000;0; +345.



Reais: representam números pertencentes ao conjunto R, que possuem uma parte inteira e uma parte fracionada.Ex.: 100.34; -1.25; 1047.34

Caracter: dado composto de um único símbolo, representado por letra do alfabeto, símbolo especial ou por algarismo.Ex.: ‘a’, ‘b’, ‘c’, ..., ‘x’, ’y’, ’z’, ‘0’, ‘1’, ‘*’, ‘.’, etc…

Cadeia (string, literal): dado composto por um conjunto de caracteres. Deve ser definido (entre colchetes o tamanhomáximo)

Ex.: “Maxwell”, “João”, “melancia”

Booleanos ou lógicos: representam elementos do conjunto {verdadeiro, falso} ou {0, 1}. Ex.: 0,1 : onde 0 é falso e 1 é verdadeiro

V, F: onde V é verdadeiro e F é falso

2.4.1.2 EstruturadosSão combinações de tipos de dados escalares e incluem matrizes, vetores, registros, arquivos e conjuntos.

Ex.: Matriz de inteiros, vetores de caracteres, registros, conjunto de números reais...

2.5 OperaçõesOperações são ações que podem ser executadas sobre dados de um tipo específico.

Existe uma relação bastante importante entre os tipos de dados e as operações, uma vez que algumas operações sópodem ser executadas sobre determinados tipos de objetos, por isso que é imprescindível definirmos o tipo de dado de uma variável/valor.

2.5.1 Operações aritméticasPodem ser realizadas sobre números inteiros e/ou reais e produzem um número de um tipo definido.

Operador Nome da Operação Representação Resultado- subtração 4-1 3+ adição 3+2 5* multiplicação 3*4 12/ divisão 8/4 2

mod Resto da divisão mod(4,2) 0div Quociente (resultado

inteiro da divisão)div(4,2) 2

sqrt Radiciação sqrt(16,2)sqrt(16)

sqrt(27,3)

443

pow Potenciação pow(2,3) 8

2.5.2 Operações relacionais e lógicasProduzem um valor lógico como resultado, isto é, verdadeiro ou falso.

2.5.2.1 Operações Relacionais

== (igual)> (maior que)< (menor que)!= (diferente de)



>= (maior ou igual)<= (menor ou igual)

Exemplos:

x > y“João” == “José”( x + z ) == ( a - c )p >= q2<= 4

2.5.2.2 Operações Lógicas

São operadores lógicos: e, ou e não.

Ope r a d o r e : resultado é verdadeiro se e somente se todos os valores envolvidos na expressão forem verdadeiros;

Ope r a d o r ou : resultado falso se e somente se todos os valores envolvidos na expressão forem falsos;

Ope r a d o r n ã o : inverte o valor lógico da expressão (se era verdadeiro fica falso; se era falso fica verdadeiro)

2.5.3 Operações Monádicas e DiádicasIndependente de serem lógicas ou aritméticas, operações podem ser classificadas de acordo com o número de operadores ou

dados que são manipulados:

O pe ra ç ões m o n ád i c as : um operador atua sobre um único operando. Ex.:

• - (1)• ! (x>2)

O pe ra ç ões di á d i c as : um operador atua sobre dois operandos. Ex.:

• 1 + 2• a * b• x > y• (G1 >= 7 ) e (faltas < 15)• (curso == “engenharia”) ou (curso ==”administracao”).

2.6 AtribuiçãoA atribuição de um valor a uma variável é definida como o ato de a r m a z e n a r o u g r a v a r um d a d o em uma v a r iá v e l . Através de uma atribuição a variável passa a representar um novo dado, sendo perdido seu conteúdo anterior.A atribuição é representada pelo operador =

Exemplo de um algoritmo:

x = 5 (x passa a representar o valor 5)x = 3+3 (agora x passa a valer 3+3, ou seja, 6 e não vale mais 5)

2.7 ExpressõesSão representações simbólicas de seqüências de operações a serem realizadas sobre determinados operandos, visando à

obtenção de um resultado.



Os operandos de uma expressão podem ser variáveis ou constantes.O tipo da expressão é determinado pelo conjunto de operandos e operações que compõem a expressão e pelo tipo de resultado a

ser obtido.

2.7.1 Expressões AritméticasSão uma combinação de variáveis e/ou constantes relacionadas por meio de operações e/ou funções aritméticas.

Produzem números como resultado.Exemplo: ( x + 200 ) / ( 350 - z ) , tem um número como resultado.

A prioridade dos operadores aritméticos em uma expressão é determinada da seguinte maneira:

1. Potenciações e (-) monádico2. Multiplicação e divisão3. Soma e subtração4. Parênteses, colchetes ou chaves podem alterar esta ordem5. Segue-se da esquerda para a direita em caso de indeterminação (isto é, mais de uma operação com a mesma

prioridade).

2.7.2 Expressões lógicasCombinam operadores relacionais ou lógicos com variáveis e/ou constantes e produzem resultados com valor lógico, isto é,

verdadeiro ou falso. (“fazem perguntas”)Exemplos:

(X == “maria”) e (a >0)(a > 200) ou (y != 0)(z != “x”) ou (z < x)(2 >5)(2>5) ou (4<2)



3 Instruções e Operaçõesx=2y=x+3escrever(y)

O p r o c e d ime n t o acima possui um conjunto finito de passos. Quantos?E execução em te m p o i n f i n i t o (ele começa e termina)

escrever é uma instrução, que informa para o usuário o conteúdo de y.= é o operador de atribuição. Na primeira linha atribui para x o valor 2. Na segunda linha atribui para y o resultado da operação soma,representada pelo operador +.

3.1 Critérios de Algoritmos Eficientes3.1.1 Correção

Se o algoritmo resolve o problema e se o faz corretamente

3.1.2 Tempo de execuçãoSe fazemos em 4 minutos o que pode ser feito em 30 segundos

3.1.3 AdaptabilidadesAdaptabilidades do algoritmo para solução de problemas similares. Algoritmo que podemos usar muitas vezes

3.1.4 SimplicidadeEscrever de forma que podemos fazer com lápis e papel

Algoritmo com instruções bem objetivas

3.1.5 ElegânciaInstruções bem escritas e organizadas

3.1.6 LegibilidadeAlgoritmo elegante e bem apresentado (organizado)

Quanto maior o número de operações para se executar uma tarefa, mais algoritmos teremos para executá-la, ou seja, mais formasde escrever essas instruções.

3.2 Como construir1. ler atentamente o enunciado

2. identificar as possíveis entradas (dados variáveis e constantes)

3. identificar as saídas (resultados)

4. determinar o que fazer para transformar as entradas nas saídas desejadas

5. escrever o algoritmo (os procedimentos)

6. executá-lo para verificar se está certo

3.3 Componentes de um algoritmo3.3.1 Entradas



o que o usuário vai informar

ler (<lista de variáveis>)

Ex.:ler (a) //obtem um valor do usuário e o atribui para aler (a, b) //obtem dois valores do usuário e o atribui para a e bler (numero, nome, salario)

3.3.2 Saídaso que vamos informar ao usuário (escrever na tela)

escrever (<lista de variáveis, textos ou expressões>)

Ex.:

escrever (“5”) //caracter 5escrever (x) //conteúdo da variável xescrever (x, y, z) //conteúdo de x, de y e de zescrever (x+3) //resultado da soma de x com 3escrever (“Matrícula = (m) Nota= (n)”)

Tudo que estiver entre aspas será escrito fielmente, tudo que estiver entre parênteses será substituído peloseu valor, pois são nomes de variáveis e constantes.

3.3.3 Atribuiçãodigo qual valor a variável vai simbolizar

variavel = expressão

Ex.:x =15y = 4+2 -((d * 5 )/3)

3.3.4 Tipos de Dados/Variáveis/ConstantesValores armazenados em um endereço de memória.Possuem um tipo de dado e um nome sem acento, sem espaço e sem caracteres estranhos, em letras minúsculas.Antes do início do algoritmo temos um bloco de declaração de variáveis e constantes. Cada variável recebe dados de um tipo determinado. Isso é importante porque determinadas operações só podem ser aplicadas

sobre determinados tipos de dados.

<tipo> <nome das variáveis>

Ex.:

caracter opcao // variável que armazenará um único simbolocadeia nome_paciente[58] // variável que armazenará ate 58 caracteresinteiro idade // variável que armazenará um inteiro de nome idadeinteiro x // variável que armazenará um inteiroreal salario = 350,0 // constante que armazenará valor tipo real



4 Operadores4.1 Operadores Aritméticos

Operador Função

+ Adição

- Subtração

* Multiplicação

/ Divisão

4.2 Operador de resto e quociente de divisão inteiraOperador Função Exemplo

mod Resto da divisão inteira mod ( 9,4) = 1

mod (27,5) = 2

div Quociente (resultado) da divisão inteira div (9,4) = 2

div (27,5) = 5

Exemplo:

mod (9,4) div (9,4)

4.2.1 Prioridades de resoluçãoAtenção! Em todos os casos vale a regra: primeiro resolva o que estiver dentro dos parênteses mais

internos e depois o que estiver nos mais externos!

Quando se tem uma expressão contendo mais de uma operação, determinadas operações devem ser resolvidas antes das outras.

Quando se tem operações iguais (como 2+3+5) ou de mesma prioridade (2+7-1), obedecemos a ordem em que elas estão escritas(por exemplo: em 2+3-1 primeiro fazemos 2+3 depois a subtração).

Geralmente, esta é a lista de ordem de prioridades (o que deve ser resolvido antes do quê):

1) potenciação ou radiciação (raiz quadrada, cúbica....)2) * / 3) div mod4) + -

4.3 Operadores RelacionaisFazem questionamentos comparativos sobre duas (ou mais) proposições.



Operador Função Exemplos

= = Igual a 3 = = 3> Maior que 3 > 2< Menor que 2 < 3

>= Maior ou igual a 3 >= 2<= Menor ou igual a 2 <= 3!= Diferente 3 != 2

O resultado obtido de uma relação lógica é sempre um valor lógico. Isto é, o resultado será Verdadeiro ou Falso.

Exemplos:

3 >= 2 Verdadeiro4 <=6 Falso3 == 3 Verdadeiro4 != (2+2) Falso3 >(2+1) Falso(4*7) < (100/2) Verdadeiro

4.4 Operadores LógicosOperador Símbolo Função

não ! negação e && conjunção

ou || disjunção

4.4.1 Tabelas-Verdade

Tabela-verdade é o conjunto de todas as possibilidades de combinação entre os valores de diversas variáveis lógicas (se elasforem V ou se forem F) e um conjunto de operadores lógicos (negação, conjunção ou disjunção, por exemplo).

Por exemplo:Primeira proposição

(A)Segunda proposição

(B)Operação(A ou B)

Resultado da Operação

2 > 5 0 < 9 (2 > 5) ou (0 < 9) VERDADEIRO

4.4.1.1 Operação de negação

A Não A

F VV F


F V F ou V = V


4.4.1.2 Operação de conjunção

A B A e B

F F FF V FV F FV V V

4.4.1.3 Operação de disjunção

A B A ou B

F F FF V VV F VV V V

4.4.1.4 Prioridades

As prioridades na resolução das operações lógicas é:

1. Negação2. Conjunção3. Disjunção



5 Algoritmos seqüenciaisQuando em um algoritmo executamos todos os passos (instruções) na seqüência em que eles aparecem, e sem omitir nem repetir

nenhum, temos um algoritmo seqüencial. Naturalmente, depois que um passo acaba o próximo passo começa a ser executado – umaúnica vez!

Um algoritmo é os procedimentos que devemos fazer para resolução de um problema. Tecnicamente falamos que o algoritmo sãoas instruções que executamos para processar as entradas em saídas. Essas instruções, posteriormente podem ser codificadas(implementadas) em qualquer (teoricamente) linguagem de programação, criando-se, assim, um software.

Alguns exemplos de instruções usadas para fazermos algoritmos:

• INICIAR – inicio o algoritmo ou um bloco de operações• PARAR – termino um bloco de operações ou um comando

INICIO...FIM

• ESCREVER – imprimo na tela mensagens ou resultados

escrever (“Sejas bem vindo”)escrever(“O resultado da soma é (soma)”)

• LER - o que o usuário irá digitar, passa a ser colocado em uma variável

ler (nome)

• ATRIBUIR – faço um espaço de memória (uma variável) receber alguma coisa. Por exemplo: o resultado de uma expressão(cálculo matemático ou cálculo lógico: V ou F), uma palavra, um número, etc..

resultado = 3 + 5nome = “Maria”soma = 4 + numero

• CALCULAR – uso operadores lógicos ou matemáticos para processar os dados

soma = 4+5

(4 > 5)

(4 > 5) ou (variavel1 = variavel2)

Para a definição de um algoritmo, devemos identificar o que deve ser feito, como deve ser feito e usando o quê. Ou seja:

1- identificar os operandos (os dados que o usuário vai informar de acordo com a necessidade dele)


Imprimirá neste lugar o conteúdo da variável soma.

Eu sei isso porque a palavra

está entre parênteses.

O que o usuário digitar irá para a variável que está entre parênteses.

A palavra numero é uma variável que eu declarei anteriormente, juntamente com seu tipo.Se não for um valor digitado pelo usuário eu não

necessito fazer declaração dela na início do algoritmo, com exceção de constantes que para me facilitar eu nomeio para usar depois referenciando-me pelo seu nome e não pelo seu conteúdo.

O operador + é o operador de soma

Operador relacional. Compara valores (maior que, menor que....)

Operador Lógico. Faz uma pergunta, e o resultado dessa operação lógica é sempre Verdadeiro ou Falso


2- identificar as possíveis isntruções (o que devemos fazer com esses dados)3- operar os operandos usando os operadores, na ordem correta4- exibir o resultado

Se quisermos um programa (um software) que some dois números com o número 3 e com o número pi , devemos pensarque:

• o usuário deve informar dois números• devemos conhecer o valor do número pi (3.14 15 92 6535 898)• devemos utilizar um operador para somar esses valores• devemos atribuir esse resultado em algum lugar• devemos mostrar para o usuário esse resultado (que está guardado em certo lugar da memória)

Para resolvermos esse problema, podemos fazer esse algoritmo aqui:algoritmo somavariaveis e constantesreal soma, numero1, numero2real pi = 3,1415926535898

inicioescrever (“digite um número: “)ler (numero1)escrever (“digite o segundo número: “)ler (numero2)soma= numero1 + numero2 + pi + 3escrever (“o resultado é (soma) “)

fim

Vamos explicar melhor ele:

algoritmo somavariaveisreal soma, numero1, numero2real pi = 3,1415926535898

inicio

escrever (“digite um número: “)ler (numero1)

escrever (“digite o segundo número: “)ler (numero2)

soma= numero1 + numero2 + pi + 3escrever (“o resultado é (soma)“)

fim

5.1 Atividades com soluções1. Receba dois números e faça sua média:

algoritmo mediavariaveis

real numero1, numero2, mediainicio


Tipo das variáveis

Nomes das variáveis. É por neio deles que nos referenciaremos a seus conteúdos

Valores complicados de serem escritos ou de serem lembrados, devem ser declarados como constantes. Também receberão um nome, e sempre que citarmos àquele nome estaremos nos referenciando ao valor declarado nesta parte do algoritmo.

Tipo Nome

Valor permanente dela

O que o usuário digitar irá para esse espaço de memória

Aparecerá na tela

Os nomes das variáveis e da constante é somado, junto ao valor 3 e atribuído para a variavel soma

O 3 não precisa ser declarado como constante porque ele não será muito usado e não é difícil lembrarmos dele, portanto não precisaremos alocar um espaço de memória para armazená-lo (seria um desperdício)

Aparecerá esta frase na tela, porém como soma está entre parêntese quer dizer que estamos nos referenciando ao seu conteúdo (que é o resultado da operação feita na linha anterior)

Final dos procedimentos


escrever (“digite um numero: ”)ler (numero1)escrever (“digite outro numero: ”)ler (numero2)media = (numero1+numero2)/2escrever (“ a media de (numero1) com (numero2) é igual a (media)” )

fim

2. Calcule a área de um triângulo, onde leia a medida da base e a medida da altura. Escreva "o triangulo com base ... e altura ....tem área igual a ...."

algoritmo area_triangulovariaveis

real area, base, alturainicio

escrever (“digite a medida da base do triangulo”)ler (base)escrever (“digite a medida da altura do triangulo”)ler (altura)area = (base*altura)/2escrever (“ a area do triangulo é (area)” )

fim

3. Sabendo que o valor do pi é 3,141592653, calcular á área de um círculo cujo raio será informado pelo usuário, e escrever "Umcírculo de raio ........ tem área igual a ......"

algoritmo circulovariaveis

real area, raio, piinicio

escrever (“digite o raio do círculo para saber sua area”)ler (raio)pi = 3,141592653area= pi * pow(raio,2) /* também pode-se multiplicar 2 vezes o raio → raio*raio*/escrever (“um circulo de raio (raio) tem area igual a (area)”)

fim

ou (usando pi como constante)

algoritmo circulovariaveis

real area, raio, pi = 3,141592653inicio

escrever (“digite o raio do círculo p saber sua area”)ler (raio)area= pi * pow(raio,2) escrever (“circulo de raio (raio)tem area = (area)”)

fim

4. Calcular a área de um trapézio, onde o usuário informará as duas bases e a altura. Escrever a área do trapézio.

algoritmo trapeziovariaveis

real area, base1, base2, alturainicio

escrever (“digite a base1, a base 2 e a altura”)ler (base1, base2, altura) area= ((base1*base2)/2 )*alturaescrever (“a area é (area) ”)

fim



5. Leia o valor da peça tipo1, o valor da peça tipo2, o número de peças tipo1 compradas, o número de peças tipo2 compradas e ovalor do frete. Calcule e escreva o valor total a ser pago.

/*devemos multiplicar o preço de cada produto pela quantidade comprada de cada um deles. Depois de feito isso deve-se acrescentar opreço do frete*/

algoritmo comprasvariaveis

real qtd_pecas1, qtd_pecas2, preco_1, preco_2, frete, totalinicio

escrever ("informe a quantidade de peças do tipo 1")ler (qtd_pecas1)escrever ("informe o preço das peças do tipo 1")ler (preco_1)escrever ("informe a quantidade de peças do tipo 2")ler (qtd_pecas2)escrever ("informe o preço das peças do tipo 2")ler (preco_2)escrever ("informe o valor do frete")ler (frete)total = (qtd_pecas1*preco_1) + (qtd_pecas2*preco_2) + freteescrever ("o valor a ser pago é (total) ")

fim



6 Comandos de SeleçãoÀs vezes é necessário tomarmos “decisões” dentro de um programa (ou algoritmo). Ou seja, desejamos que se faça “uma coisa” ou

“outra coisa”. Vou dar um exemplo da “vida real”:

mãe: Filho, se amanhã estiver chovendo tu ficas em casafilho: E se não estiver chovendo?mãe: Daí tu vais ao colégio e depois vens para casa

Isso é um algoritmo “não computacional”, mas que poderia ser escrito assim:

se (chove) ficar em casa

senãoir ao colégiovoltar para casa

fim_se

Também poderíamos elaborar mais esse algoritmo, assim:

mãe: Filho, se amanhã estiver chovendo tu ficas em casafilho: E se não estiver chovendo?Mãe: Se tiver nublado vais ao colégio e depois vens para casa, senao tiver nublado e não tiver chovendo tu vais no colégio e depois vaipara casa da tia

Ficaria assim: (note que: ou está chovendo ou está nublado ou está ensolarado)

se (chove) ficar em casa

senãose (nublado)

ir ao colégiovoltar para casa

senãoir no colégioir para casa da tia

fim_sefim_se

Os algoritmos podem ser baseados em estruturas concatenadas (uma em baixo da outra) ou estruturas aninhadas - uma dentro daoutra (de acordo com a formulação de condições e repetições)

Em um algoritmo com seleção, a execução de uma ou mais instruções é dependente da veracidade (verdadeiro ou falso) de umacondição - algumas instruções do algoritmo serão ou não executadas.

Por exemplo:

algoritmo numerovariaveisinteiro numero

inicioescrever (“digite um numero”)ler (numero)se (numero !=2)

escrever (“você não digitou o número certo! “)senão

escrever (“você acertou! “)fim_se

fim



No exemplo acima, OU vai ser escrito Você não digitou o número certo!, ou Você acertou!, dependendoda veracidade da condição (número ser diferente de 2), portanto, nem todas as instruções desse algoritmo vão ser executadas(uma delas não vai!)

6.1 Comando de Seleção SimplesO comando de seleção mais simples, é o comando SE. (if, na maioria das linguagens de programação)

se <condição> <instrução/instruções a ser executada se a condição for verdadeira>

fim_se

ou (com uso do senão)

se <condição> <instrução/instruções a ser executadas se a condição for verdadeira>

senão<instrução/instruções a ser executada se a condição for falsa>

fim_se

Onde INSTRUÇÃO é qualquer uma instrução logarítmica (iniciar, ler, escrever, operar ou calcular, parar) ou ainda uma seqüênciade instruções.

CONDIÇÃO é uma expressão lógica, isto é, o resultado das operações que estão representadas por ela será VERDADEIRO ouFALSO.

Assim, condição é:

• ou uma comparação de expressões aritméticas (relações) - por meio de operadores relacionais (=,<,>,>=,<=,!=)

• ou uma combinação de comparações - por meio de operadores lógicos (NÃO, E, OU: !, &&, ||).

6.1.1 Atividades

Escrever um algoritmo que lê o numero de um funcionário, o número de horas por ele trabalhadas, o valor que recebe por hora, onúmero de filhos com menos de 14 anos, a idade do funcionário, o tempo de serviço do funcionário e o valor do salário família por filho.Calcular o salário bruto o desconto do INSS (8,5% do salário bruto), e o salário família.

Calcular o desconto do Imposto de Renda como segue:• Se salário_bruto > 1500 então Imposto de Renda = 15% do salário bruto• Se salário_bruto > 500 e salário_bruto < 1500 então Imposto de Renda = 10% do salário bruto• Se salário_bruto < 500 não tem desconto

O funcionário pode ganhar um adicional (bônus):• Se idade > 40 ans então adicional = 2% do salário bruto• Se o tempo de serviço > 15 anos adicional=3,5% do salário bruto• Se o tempo de serviço < 15 anos, porém maior que 5 anos e a idade do funcionário > 30 anos, adicional=1,5% do salário bruto

Calcular o salário líquido e escrever o número do funcionário e seu salário líquido.

algoritmo funcionariovariaveisinteiro numfunc, numhoras, numfilhos, idadefunc,temposervico real valorhora, salfamilia, salbruto, salliquido, ir, adicional

inicioescrever (“informe o num do funcionario, valor hora e num de filhos”)



ler(numfunc, numhoras, valorhora, numfilhos)escrever (“informe a idade, tempo de servico e valor do sal. familia”)ler(idadefunc, temposerviço, salfamilia)

/*cálculo do salário bruto com o desconto do in=*/salbruto =(numhoras*valorhora) + (salfamilia*numfilhos)salbruto = salbruto - ((salbruto * 8,5)/100)

/*cálculo do imposto de renda conforme salário bruto*/se (salbruto > 1500 )

ir = (salbruto * 15)/100fim_sese ((salbruto > 500) e (salbruto <= 1500))

ir = (salbruto * 10)/100fim_se

/*cálculo do adicional conforme tempo de serviço e idade*/se (idadefunc > 40)

adicional = (salbruto * 2)/100fim_sese (temposerviço > 15)

adicional = (salbruto * 3,5)/100fim_sese ((temposerviço < 15) e (temposerviço > 5 e (idade > 30))

adicional = (salbruto * 1,5)/100fim_sesalliquido = (salbruto – ir) + adicional

/*exibe número do funcionário e o valor o salário líquido armazenado na variável salliquido: */escrever(“o funcionario é (numfunc), e o salario liquido (salliquido) ”)

fim

Leia o número de identificação de um aluno e as 3 notas obtivas por ele no semestre, assim como uma nota de exercícios. Calculara média final usando esta fórmula (linearize ela – coloque em uma mesma linha!!!)

Média = Nota 1 + (Nota 2 * 2) + (Nota 3 * 3) + Média dos exercícios

7algoritmo mediasvariaveis

inteiro numaluno real nota1, nota2, nota3, mediaexercic, ma /* ma é média de aproveitamento*/caractere conceito /*é uma letra só*/

inicioler(numaluno, nota1, nota2, nota3, mediaexercic)ma = nota1 + (nota2 * 2) + (nota3 * 3) + mediaexercic

/*armazena na variável conceito a, b, c, d ou e conforme o valor de ma*/se ( ma >= 9,0 )

conceito = "a"fim_sese ((ma >= 7,5) e (ma < 9,0) )

conceito = "b"fim_sese ((ma >= 6,0) e (ma < 7,5))

conceito = "c"fim_sese ((ma >= 4,0) e (ma < 6,0))

conceito = "d"fim_sese (ma < 4,0)

conceito = "e"fim_se

/*exibe o número do aluno, notas, a média dos exercícios, ma e o conceito*/escrever( numaluno, nota1, nota2, nota3, mediaexercic, ma )



/*testa se o aluno foi aprovado ou não, e exibe a mensagem aprovado ou reprovado*/se ((conceito == "a")ou(conceito == "b")ou(conceito == "c") )

escrever("aluno aprovado")senão

escrever("aluno reprovado")fim_se

fim

Determinada empresa decidiu dar aumento de salário aos funcionários conforme tabela abaixoSalário Atual Áumento

0 - 400 15%401 - 700 12%701 - 1000 10%

1001 - 1800 7%1801 - 2500 4%

Acima de 2500 sem aumento

algoritmo aumento_usando_concatenacao_de_condicionaisvariaveisinteiro numfunc real salatual, percentual, salcorrigido

inicioler(numfunc, salatual)

se (salatual <= 400) percentual = (salatual * 15)/100

fim_sese ((salatual > 400) e (salatual <= 700))

percentual = (salatual * 12)/100fim_sese ((salatual > 700) e (salatual <= 1000))



percentual = (salatual * 4)/100fim_sese ((salatual > 2500))

percentual = 0fim_sesalcorrigido = salatual + percentualescrever( numfunc, salatual, percentual, salcorrigido )

fim

Mesmo algoritmo, mas a solução usa os SE de forma ANINHADA (otimização do algoritmo)

algoritmo aumento_usando_concatenacao_de_condicionaisvariaveis

inteiro numfuncreal salatual, percentual, salcorrigido

inicioescrever (“digite o número do funcionário e seu salário”)ler(numfunc, salatual)se (salatual <= 400)

percentual = (salatual * 15)/100senão



se ((salatual > 400) e (salatual <= 700))percentual = (salatual * 12)/100

senãose ((salatual > 700) e (salatual <= 1000))

percentual = (salatual * 10)/100senão

se( (salatual > 1000) e (salatual <= 1800))percentual = (salatual * 7)/100

senãose ((salatual > 1800) e (salatual <= 2500))

percentual = (salatual * 4)/100fim_se

fim_sefim_se

fim_sefim_sesalcorrigido = salatual + percentualescrever( numfunc, salatual, percentual, salcorrigido )

fim

Escrever um algoritmo que lê um valor m. SE m não é inteiro escrever a mensagem "O VALOR DE M NÃO É INTEIRO”.SE m é negativo escrevê-lo com a mensagem "É NEGATIVO”. Caso contrário verificar SE m é par ou ímpar e

escrevê-lo com a mensagem correspondente.

algoritmo inteirovariaveisinteiro m

inicioler(m) se (m < 0)

escrever(“ (m) é negativo")senão

se (mod (m,2)==0 )escrever(“ (m) é positivo e par")

senãoescrever(“ (m) é positivo e ímpar")

fim_sefim_se

fim

Faça um algoritmo que leia os valores A, B, C e diga SE a soma de A + B é menor que C.

algoritmo somavariaveisreal a, b, c, soma

inicioescrever (“informe o valor a”)ler (a)escrever (“informe o valor b”)ler (b)escrever (“informe o valor c”)ler (c)soma=a+bse (soma < c)

escrever (“a soma é menor que (c)”)fim_se

fim

Faça o algoritmo de um programa que calcule as médias de um aluno e veja SE ele está aprovado ou reprovado. As regras paraisso são as mesmas aplicadas na Maxwell, ou seja:


Observem que aqui eu estou mostrando na tela o conteúdo da variável c


Temos a nota 1 que é somada com a nota 2, e depois esse somatório dividido por 2. Se o aluno alcançou a média 6,0 (ou superior),ele está aprovado (e deve-se informar isso a ele). Caso não alcançou essa média, informe a ele que não está aprovado ainda, e peça anota da prova de recuperação. Essa nota de recuperação será somada à média inicial (da prova 1 com a prova 2) e dividida por 2. Se essanova média for maior ou igual a 6,0, informe ao aluno que ele está aprovado, senão, que ele está reprovado.

algoritmo mediasvariaveis

real nota1, nota2, media_notas, recuperacao, media_final inicio

escrever (“digite a nota 1”)ler (nota1)escrever (“digite a nota2”)ler (nota2)media_notas = (nota1 + nota2)/2se (media_notas >= 6)

escrever (“aprovado”)senão

escrever (“ainda não aprovado. digite nota de recuperação”)ler (recuperacao)media_notas = (media_notas + recuperacao)/2se(media_notas >= 6)

escrever (“aprovado!!!!”)senão

escrever (“reprovado”)fim_se

fim_sefim

O usuário informará um valor horizontal ( a coordenada x) e o valor vertical (a coordenada y). Escreva em qual quadrante domonitor está esse ponto, ou se ele está exatamente na ordenada (eixo y) ou na abscissa (eixo x)

algoritmo quadrantesvariaveisreal x, y

inicioescrever (“informe a coordenada x”)ler (x)escrever (“informe a coordenada y”)ler (y)se (y==0)

escrever (“abscissa”)senão

se (x=0) escrever (“ordenada”)

senãose (x>0)

se (y>0) escrever (“quadrante 1”)

senãoescrever (“quadrante 4”)

fim_sesenão


X

Y


se (y<0) escrever (“quadrante 3”)

senãoescrever (“quadrante 2”)

fim_sefim_se

fim_sefim_se

fim

Faça um algoritmo que leia dois valores inteiros A e B se os valores forem iguais deverá se somar os dois, caso contráriomultiplique A por B, e atribua o produto para uma variável chamada C.

algoritmo somavariaveisreal a, b, soma, produto, c

inicioescrever (“informe o valor a”)ler (a)escrever (“informe o valor b”)ler (b)se (a == b)

soma=a+bsenão

produto=a*bc = produto

fim_sefim

Faça um algoritmo que leia o nome e três notas de uma disciplina de uma aluno e ao final escreva o nome do aluno, sua média ese ele foi aprovado ou reprovado. A média para aprovação é 8.

algoritmo mediasvariaveis

real nota1, nota2, nota3, mediacadeia nome_aluno[80], conceito[20]

inicioescrever (“digite o nome do aluno: “)ler(nome_aluno)escrever (“digite a nota 1”)ler (nota1)escrever (“digite a nota 2”)ler (nota2)escrever (“digite a nota 3”)ler (nota3)media= (nota1 + nota2 + nota3)/3se (media >= 8)

conceito = “aprovado”senão

conceito = “reprovado”fim_seescrever (“aluno: (nome_aluno) media: (media) conceito: (conceito)”)

fim

Faça um algoritmo que leia 3 números inteiros e imprima o maior deles. (usando somente operadores lógicos)

ALGORITMO maiorVARIAVEISreal a, b, c

INICIOescrever (“Informe o valor a”)ler (a)


“a igua a b”?

Lembre-se! Quando querermos mostrar o conteúdo de uma variável na tela devemos colocar ela entre parênteses no comando escrever


escrever (“Informe o valor b”)ler (b)escrever (“Informe o valor c”)ler (c)se (a > b)

se (a > c) escrever (“ O maior é (a)”)

senãoescrever (“ O maior é (c)”)

fim_sesenão

se (b > c) escrever (“ O maior é (b)”)

senãoescrever (“ O maior é (c)”)

fim_sefim_se

FIM

Dados três valores X, Y, Z, verificar se eles podem ser os comprimentos dos lados de um triângulo e, se forem, verificar se étriângulo equilátero, isósceles ou escaleno. Se não formarem triângulo, escrever uma mensagem .

Lembre que:• o comprimento de cada lado de um triângulo é menor que a soma dos comprimentos dos outros dois lados.• Equilátero tem 3 lados iguais. Isósceles: 2 lados iguais e 1 é diferentes. Escaleno: todos os lados são diferentes

ALGORITMO trianguloVARIAVEISreal a, b, c

INICIOescrever (“Informe o lado a”)ler (a)escrever (“Informe o lado b”)ler (b)escrever (“Informe o lado c”)ler (c)se ((a < (b+c)) e (b < (a+c)) e (c < (a+b)))

se ((a==b) e (a==c)) escrever(“Triangulo Equilatero.”)

senão se ((a==b) ou (a==c) ou (b==c))

escrever(“Triangulo Isoceles.”)senão

escrever(“Triangulo Escaleno.”)fim_se

fim_sesenão

escrever(“As medidas nao formam um triangulo.”)fim_se

FIM

Leia três valores numéricos e escreva-os em ordem crescente.

ALGORITMO 3_em_ordemVARIAVEISreal num1, num2, num3

INICIOescrever (“Informe o primeiro numero”)ler (num1)escrever (“Informe o segundo numero”)ler (num2)escrever (“Informe o terceiro numero”)ler (num3)


Dica: Pode-se fazer assim (direto), ao invés de atribuirmos a soma de a com ca uma variável para depois compararmos.


se (num1 <= num2) se(num1 <= num3)

se(num2 <= num3) escrever(num1,num2, num3)

senãoescrever(num1,num3, num2)

fim_sesenão

escrever(num3,num1, num2)fim_se

senãose(num2 <= num3)

se(num1 <= num3) escrever(num2,num1, num3)

senãoescrever(num2,num3, num1)

fim_sesenão

escrever(num3,num2, num1)fim_se

fim_seFIM

Leia dois valores numéricos e escreva o menor valor.

ALGORITMO menor_de_doisVARIAVEISreal num1, num2

INICIOescrever (“Informe o primeiro numero”)ler (num1)escrever (“Informe o segundo numero”)ler (num2)se (num1 < num2)

escrever ("Menor numero = (num1)")senão

se (num1 > num2) escrever ("Menor numero = (num2)")

senãoescrever("Os numeros são iguais!!")

fim_sefim_se

FIM

Leia dois números e calcule a soma e o produto entre eles, e a subtração e a divisão do primeiro valor com o segundo. Escreva oresultado na tela.

ALGORITMO calculosVARIAVEIS real num1, num2, soma, subtracao, produto, divisao INICIOescrever("Primeiro numero: ")ler(num1)escrever("Segundo numero: ")ler(num2)soma = num1 + num2subtracao = num1 - num2produto = num1 * num2divisao = num1 / num2escrever("soma = (soma)")escrever("subtracao = (subtracao)”)escrever("produto = (produto)”)


Mostro os conteúdos!!!


se(num2 != 0) divisao = num1 / num2escrever("A divisao é (divisao)”)

senãoescrever("Impossível dividir! O segundo número é zero.")

fim_seFIM

Leia sua data de nascimento, data de hoje, calcule sua idade e escreva na tela.

ALGORITMO dados_pessoaisVARIAVEIScadeia nome[80], ender[90], fone[10]

inteiro dia_nascimento, mes_nascimento, ano_nascimento, dia_atual, mes_atual, ano_atual, idade

INICIO

escrever("Dia do seu nascimento")ler(dia_nascimento)escrever("Mes do seu nascimento")ler(mes_nascimento)escrever("Ano do seu nascimento")ler(ano_nascimento)escrever("Informe o dia atual (hoje):")ler(dia_atual)escrever(“Informe o mes”)ler(mes_atual)escrever(“Informe o ano”)ler(ano_atual)idade = ano_atual - ano_nascimentose (mes_atual < mes_nascimento)

idade = idade – 1fim_sese (mes_atual == mes_nascimento)

se (dia_atual < dia_nascimento) idade = idade – 1

fim_sefim_seescrever("Voce tem (idade) anos ")

FIM

6.2 Seleção Múltiplacaso <expressão> { <valor 1> : <instrução ou instruções>

<valor 2> : <instrução ou instruções>...<valor n> : <instrução ou instruções>

}senão

<instrução ou instruções>fim_caso

Onde <valor 1>,<valor 2>,..,<valor n> são valores que podem ser assumidos pela <expressão>. Para cada valor pode-seespecificar uma ação ou um conjunto de ações a serem executadas (as instruções).

Por exemplo:


!= quer dizer “diferente”


algoritmo media_alunovariáveis

real a, b, respostainteiro escolha

inicioa=20b=5resposta=0escrever (“o que vc quer ver:

1– soma 2- multiplicação 3- divisão ”)

ler (escolha)caso (escolha) { 1: resposta= a+b

2: resposta= a*b3: resposta= a/b

}senão

escrever (“voce não digitou uma opcao valida!”)fim_casoescrever (“resposta é (resposta) “)

fim

algoritmo cache_bancariovariaveisinteiro opcao_menu

inicioescrever(“menu: “)escrever(“1 – saldo da conta”)escrever(“2 – saque”)escrever(“3 – transferência”)escrever(“digite uma opcao: ”)

ler(opcao_menu)caso (opcao_menu) { 1: escrever(“voce quis ver o saldo”)

2: escrever(“voce quis fazer um saque”)3: escrever(“voce quis fazer uma transferência”)

}senão

escrever(“opcao invalida!”)fim-caso

fim

algoritmo soma_de_dois_numerosvariaveisinteiro x, y

inicioescrever(“digite um numero “)ler (x)escrever(“digite outro numero”)ler(y)caso ( x+y ) { 0: escrever(“a soma deu zero”)

1: escrever(“a soma deu 1”)}senão

escrever(“a soma deu um numero positivo maior que 1”)fim-caso

fim


Veja que aqui eu coloquei uma expressão aritmética de soma para executar a comparação


Depois que executar a instrução selecionada (ou a 1, ou a 2, ou a 3), automaticamente termina o “bloco caso” (marcação fim_caso)e passa a ser executada a instrução que aparece logo abaixo do fim_caso, que é: escrever (“Resposta é (resposta)“).

Essa mesma regra vale para o se (usado para seleção única)

6.2.1 Atividades1. Numa festa, foi feito um sorteio para distribuir um bolo de dinheiro. Dez pessoas foram sorteadas e deveriam pegar uma bola numerada

de 0 a 9 e conforme o algarismo sorteado o prêmio seria:

Número da Bola Prêmio (% do valor do caixa)0 051 252 103 074 085 056 157 128 039 10

A pessoa deve informar a quantidade de dinheiro a ser dividida e o número da bola que tirou. Calcule o valor do prêmio dela combase na tabela e escreva na tela.

2. Sendo dados 3 números positivos, verificar a natureza do triângulo formado, quanto aos seus ângulos, com estes números comomedida dos lados (isósceles, equilátero, escaleno ou se não forma triângulo).

3. Ler quantos lados tem um polígono. Classifique os polígonos de 3 a 10 lados. Se for informado um número menor do que 3 diga queesse polígono não existe. Considere que o usuário nunca digite um número maior do que 10.

4. Dada a hora (apenas a hora, sem minutos ou segundos), informar qual a direção do sol. (leste, centro,ou oeste)


Em algum ponto do algoritmo ela é acrescida de qualquer valor, mas não é

zerada

Inicializa em 0 a variável que vai ser

o acumulador


7 Comandos de RepetiçãoEm um algoritmo de repetição, certas instruções são executadas mais de uma vez.

7.1 AcumuladorUma variável acumulador (ou somador) é qualquer variável que recebe um valor INICIO constante (geralmente 0) e é incrementada por

qualquer valor (pode não ser fixo) em algum ponto do algoritmo.

Observe este pedaço de um algoritmo qualquer:

INICIOacumulador = 0

.

.

.acumulador = acumulador + 1...

acumulador = acumulador + media_do_aluno...

FIM

7.2 ContadorUma variável contador é uma variável como outra qualquer, mas que recebe um valor INICIO (geralmente é 0) e depois é

incrementada por um valor constante qualquer (geralmente 1 ou 2). Ou seja, recebe sempre o mesmo valor.Observe esse pedaço de um algoritmo qualquer:

INICIOcontador = 0

.

.

.contador = contador + 1...

FIM

A linha contador = 0 armazena na variável chamada “contador” o valor 0.Na linha contador = contador + 1 incrementamos em 1 o conteúdo atual da variável contador .

7.2.1 O operador ++O operador ++ é usado sempre que se quiser acrescentar 1 (um) no valor atual de uma variável.Esse operador reconhece o valor que tem na variável, soma 1 naquele valor e atribui para ela - ele acrescenta 1A facilidade de usá-lo se dá na abreviação. Ou seja, ao invés de escrever: var=var+1 basta escrever: var++

7.3 Comandos de Repetição


Inicializa em 0 a variável que vai ser o contador.

Em algum ponto do algoritmo incrementa em 1


7.3.1 ParaRepete certas instruções um número fixo (e já conhecido) de vezes.

PARA (<var contador> = <INICIO> até <núm. repetições>; <incremento>)

Observe esse algoritmo, ele vai imprimir a frase Eu sei repetir 20 vezes na tela.

algoritmo uso_do_paravariaveisinteiro contador

iniciopara (contador = 1 até 20; contador = contador+1)

escrever (“eu sei repetir”)fim_para

fim

Nem sempre saberemos quantas vezes queremos que sejam repetidas as instruções, mas sim, sabemos que uma coisa deve serfeita até que tal coisa aconteça (uma condição passe a ser verdadeira) ou enquanto tal coisa está acontecendo (que uma condição aindaseja verdadeira). Quando isso acontece, usamos os comandos: enquanto ou faça...até que...

7.3.2 EnquantoExecuta certos comandos enquanto uma condição for verdadeira.

enquanto (<condição>)<comandos a serem repetidos>

fim_enquanto

No algoritmo abaixo, escreve uma mensagem e lê novamente um numero, enquanto o número não for 2.algoritmo uso_do_enquantovariaveisinteiro numero

inicioenquanto (numero != 2)

escrever (“digite um numero: “)ler (numero)

fim_enquantofim

7.3.3 Faça...enquanto...Repete certas instruções até que a condição seja verdadeira.

faça <instruções>

enquanto ( <condição> )

O algoritmo é executado linha-a-linha e de cima para baixo, por isso como a condição está depois das instruções, as instruçõesserão repetidas pelo menos 1 vez (mesmo que a condição seja falsa desde o INICIO).

No algoritmo abaixo, escreve-se uma frase na tela e incrementa um contador (que conta quantas vezes a frase foi repetida, já queacrescenta mais 1 cada vez que ela é escrita). Quanto o contador estiver em 5 o processo pára de ser repetido e o algoritmo acaba.

algoritmo uso_do_enquantovariaveisinteiro contador

iniciofaça



escrever (“eu nao canso de repetir”)contador = contador + 1

enquanto (contador <= 5)fim

7.4 Atividades

Dado uma série de 20 valores reais, faça uma algoritmo que calcule e escreva a média aritmética destes valores,entretanto se a média obtida for maior que 8 deverá ser atribuída 10 para a média.

algoritmo serievariaveisinteiro contador real n,soma, media

iniciocontador=1enquanto (contador <= 20)

ler (n)soma=soma+ncontador = contador + 1

fim_enquantomedia = soma / 20se (media > 8) entao

media = 10fim_seescrever (media)

fim

Dado um conjunto de registros cada registro contendo um valor real, faça um algoritmo que calcule a média dos valores maioresdo que 4.

algoritmo mediavariaveisinteiro n, conta, maior4 real soma, media, numero

inicioconta = 1maior4 = 0soma = 0ler (n)enquanto (conta < n)

ler (numero)se (numero > 4) entao

soma = soma + numeromaior4 = maior4 + 1

fim_seconta = conta + 1

fim_enquantomedia = soma / maior4escrever (media)

fim

Faça um algoritmo para ler base e altura de 50 triângulos e imprimir a sua área.

algoritmo triangulovariaveis inteiro contador real base, altura, areainicio contador = 1 enquanto (contador < 51)


Quando a variável contador for maior que 5 ele pára de repetir.

Podemos usar números para dar nomes às variáveis!!


ler (base) ler (altura)

area = (base * altura)/2 escrever (area) contador = contador + 1 fim_enquantofim

Dado um conjunto de 20 valores reais, faça um algoritmo que:a) Imprima os valores que não são negativos.b) Calcule e imprima a média dos valores < 0.

algoritmo conjunto20variaveis real n, soma_menor, media_menor inteiro contador, contador inicio contador = 0 soma_menor = 0 enquanto (contador < 20) ler (n) se (n >= 0) escrever (n) senao soma_menor = soma_menor + n contador = contador + 1 fim_se contador= contador + 1 fim enquanto media_menor = soma_menor / contadorfim

Você digita um número e ele escreve todos os números de 0 até ele.

algoritmo escreve_numerosvariaveis inteiro numero, contador inicio // primeiro o programa solicita

//um número ao usuário escrever("informe um número: ") ler (numero) // inicializa o contador contador = 0 //enquanto o contador for menor ou igual ao valor informado, faça enquanto (contador <= numero) // escreva o valor do contador escrever(“o contador é (contador))

// escreva o contador contador = contador + 1 // finaliza o laço fim_enquanto fim

Ler números ( um por vez) e escrever seu triplo. Até que seja digitado o número 999.

algoritmo conjunto20variaveis real n inicio faça


Comentários

Ao invés de atribuir isso para uma variável e depois escrevê-la, posso colocar direto. Primeiro será feito o

cálculo e depois será exibido automaticamente o resultado


escrever (“digite um número”)ler (n)escrever ( n * 3)

enquanto (n!=999)fim

A série Fibonacci tem como dados os 2 primeiros termos da série que são respectivamente 0 e 1. A partir deles, os demais termossão construídos pela seguinte regra:

atual = ultimo + penultimo

Escrever um algoritmo que gera os 10 primeiros termos desta série e calcula e escreve a sua soma.

algoritmo fibonacci_usando_laco_paravariáveisinteiro atual, ultimo, penúltimo, contador, soma

iniciosoma = 0penultimo = 0ultimo = 1escrever(penultimo) /*mostro os dois primeiros elementos da série*/escrever(ultimo)para (cont = 1 até 8; contador++)/*aqui, mostro os 8 elementos restantes*/

atual = ultimo + penúltimoescrever(atual) /*a medida que encontro o elemento atual, vou exibindo*/soma = soma + atual /*somo todos os elementos gerados*/penultimo = ultimo /*troco o que era o ultimo elemento, transforma-se em*/ultimo = atual /*último. e o que era atual, transforma-se em ultimo*/

fim_paraescrever(soma)

fim

algoritmo fibonacci, mas usando instrução faça...até que

algoritmo fibonacci_usando_facavariáveisinteiro atual, ultimo, penúltimo,contador, soma

iniciosoma = 0penultimo = 0ultimo = 1escrever(penultimo) escrever(ultimo)contador = 0faça

atual = ultimo + penúltimoescrever(atual) soma = soma + atual penultimo = ultimo ultimo = atual contador = contador + 1

enquanto (contador < 8)escrever(soma)

fim

Algoritmo Fibonacci com a instrução ENQUANTO

algoritmo fibonacci_usando_enquantovariáveisinteiro atual, ultimo, penultimo, contador, soma

inicio


Porque eu só quero os 10 primeiros termos da série. Os 2 primeiros são fixos

(0 e 1) e os 8 eu faço usando o algoritmo com o laço de repetição


soma = 0penultimo = 0ultimo = 1escrever(penultimo)escrever(ultimo)contador = 0enquanto (contador < 8)

atual = ultimo + penultimoescrever(atual) soma = soma + atual penultimo = ultimo ultimo = atualcontador++

fim_enquantoescrever(soma)

fim

Foi realizada uma pesquisa de algumas características físicas da população de uma certa região, a qual coletou os seguintesdados referentes a cada habitante para serem analisados:

- sexo (masculino e feminino) - cor dos olhos (azuis, verdes ou castanhos) - cor dos cabelos ( louros, castanhos, pretos) - idade

Faça um algoritmo que determine e escreva: - a maior idade dos habitantes - a quantidade de indivíduos do sexo feminino cuja idade está entre 18 e 35 anos inclusive e que tenham olhos verdes e cabeloslouros.

O final do conjunto de habitantes é reconhecido quando a idade informada for negativa (idade menor que 0).algoritmo pessoasvariáveiscaracter sexocadeia corolhos[20], corcabelo[20]inteiro idade, contapess, maioridade

iniciocontapess = 0maioridade = 0ler(idade)enquanto (idade >= 0)

ler(sexo, corolhos, corcabelo)se (idade > maioridade)

maioridade = idadefim_sese (sexo == ´f´) e (idade >= 18) e (idade <= 24) e (corolhos == ´verdes´)

e(corcabelo == ´louros´)contapess = contapess + 1

fim_seler(idade)

fim_enquantoescrever(maioridade)escrever(“total de pessoas com as características: (contapess) “)

fim



8 Matrizes“Matriz é um conjunto de variáveis, cada uma podendo representar um valor, como se fossem variáveis simples, mas todas

compartilham o mesmo nome”

Para individualizarmos cada um dos elementos do conjunto, associamos um índice (um número) a cada um deles.Exemplo: um conjunto de nome mat possui 4 elementos:

Como todos os elementos possuem o mesmo nome, a identificação de cada um deles passa a ser feita pelo nome (que é o mesmonome do conjunto) seguido por um índice (número).

Muitos algoritmos, necessitam que muitas variáveis sejam declaradas (e manipuladas) dentro dele.A escrita, leitura e manipulação (operação) de cada uma delas exigiria que nomeássemos uma-a-uma.As matrizes solucionam esse problema, pois declaramos uma matriz e depois dizemos quantos elementos ela pode conter. Assim,

se precisaríamos nomear 15 variáveis do tipo real no nosso algoritmo, basta declararmos uma variável com 15 posições – uma matriz! ecada vez que quisermos trabalhar com o primeiro, ou o segundo, ou o terceiro valor de dentro dela, acessamos ele com o nome da variávelmatriz seguido pelo seu índice.

Assim como na matemática, as matrizes podem ter mais de uma dimensão. Para cada dimensão usaremos um índice que vai de 1até a quantidade de posições em cada dimensão.

Os tipos que mais usaremos é a matriz unidimensional (só uma linha) e bidimensional (mais de uma linha). Algumas linguagens deprogramação nem permitem a declaração de mais dimensões.

8.1 Matrizes Unidimensionais - VetoresObserve este exemplo:

1. algoritmo matrizes2. variáveis3. inteiro minha_matriz[5]4. inicio5. minha_matriz[1]=26. minha_matriz[2]=667. minha_matriz[3]=32


A matriz se chamará minha_matriz

Ela vai ter 5 posições em 1 dimensão (1 linha)

Tipo dos valores que cada posição poderá conter.

Todos os elementos têm que ser do mesmo tipo (inteiro, neste caso)


8. minha_matriz[4]=119. minha_matriz[5]=47210. fim

Nesse algoritmo, declarei uma variável matriz/vetor chamada minha_matriz, de uma dimensão (1 linha) que comporta até 5elementos.

Nas linhas 5, 6, 7, 8 e 9, eu prencho o vetor com 5 elementos (um para cada posição).Ficará assim:

2 66 32 11 4721 2 3 4 5

Para ler (pedir ao usuário) o conteúdo de uma posição (por exemplo a posição 5), o procedimento pode ser:ler (minha_matriz[5])

Para imprimir na tela o conteúdo de uma posição (por exemplo a posição 3), o procedimento pode ser:

escrever (“O conteúdo da posição 5 é (minha_matriz[3]) “)

Percebe-se, que com 5 posições a escrita e a leitura já pode ser um processo trabalhoso se citarmos uma posição de cada vez nahora de atribuirmos um valor para cada.....(veja isso no exemplo do algoritmo anteriormente citado)

Um recurso que a gente usa para facilitar essas operações, é repetir o comando quantas vezes for o tamanho da matriz e usar ocontador para ir passando índice por índice.

Observe este exemplo - preencher o vetor com valores informados pelo usuário:

algoritmo matrizesvariáveisinteiro minha_matriz[5], contador

iniciopara (contador=1 até 5; contador++)

ler (minha_matriz[contador])fim_para

fim

Por que isso funciona? Porque estou dizendo que vou repetir o comando de leitura 5 vezes (que é o tamanho do vetor), e cadavez que eu ler eu vou colocar o valor lido dentro da variável minha_matriz (o vetor) na posição 1, 2, 3, 4 ou 5. Depende do número que avariável contador irá representar cada vez.

Sabemos que no laço de repetição PARA, serão repetidos determinados comandos um certo número de vezes, e possui umavariável de controle do número de vezes que está sendo repetido o comando. Essa variável contador é alterada (somada 1) cada vez,portanto, na primeira vez ela vai ser 1, depois ela vai ser 2, depois 3, depois 4, depois 5.

Como 1, 2, 3, 4 e 5 são os números que a gente precisa (para serem os índices das posições do vetor), a gente aproveita o valordo contador para indicar para qual posição do vetor eu estou lendo o valor do usuário.

Então vai ser:minha_matriz[1]minha_matriz[2]minha_matriz[3]minha_matriz[4]minha_matriz[5]

um de cada vez. E os números de índice serão dados pelo conteúdo da variável contador (iniciando em 1 e terminando em 5).

8.2 Matrizes BidimensionaisQuando se tem um vetor, o procedimento é o citado acima.

Quando se tem uma matriz com mais de uma dimensão devemos ter dois contadores (uma para contar as linhas, e outro paracontar as colunas).

Observe uma matriz bidimensional.


posições

percorre as linhaspercorre as

colunas dentro da

linha


1,1 1,2 1,3 1,4 1,5 1,62,1 2,2 2,3 2,4 2,5 2,6

Para preenchermos (ou escrevermos) um vetor, precisamos de somente 1 contador, pois no vetor só tempo o contador de posiçõesdentro de somente uma linha de dados.

Em uma matriz, precisamos de um contador para cada dimensão, pois temos um índice para cada dimensão da matriz (porexemplo, um contador para as linhas, e outro para as colunas)

Assim, para nos referenciarmos à posição “linha 1 coluna 3”, vamos precisar do índice de linha e do índice de coluna.

Primeiro vem o índice de linha, depois o de coluna!

Fazendo isso sem usarmos os laços de repetição, seria assim:

Exemplo 1:

algoritmo matrizesvariáveisinteiro minha_matriz[2] [6]

iniciominha_matriz[1][1]=6minha_matriz[1][3]=56minha_matriz[2][3]=99minha_matriz[2][5]=132

fim

6 5699 132

Para fazermos isso usando laços de repetição, basta colocar um PARA para cada índice.... um dentro do outro.Isso se faz para que ele corra todas as colunas de uma linha, depois todas as colunas da outra linha.

Exemplo 2:

algoritmo matrizesvariáveisinteiro linhas, colunas, minha_matriz[2][6]

iniciopara (linhas = 1 até 2; linhas++)

para (colunas= 1 até 6; colunas++)escrever ( minha_matriz[linhas][colunas] )

fim_parafim_para

fim

Agora um exemplo que multiplica todos os dados de uma matriz por 2 e escreve eles:Exemplo 3:

algoritmo matrizesvariáveisinteiro linhas, colunas, minha_matriz[2][6]

iniciopara (linhas = 1 até 2; linhas++)

para (colunas= 1 até 6; colunas++)


índice de linhas

índice de colunas

A matriz se chamará minha_matriz

Ela vai ter 2 linhas e 6 colunas

Tipo dos valores que cada posição poderá conter.


minha_matriz[linhas][colunas]=minha_matriz[linhas][colunas]*2escrever (“conteúdo da linha (linhas) coluna (colunas)é=

(minha_matriz[linhas][colunas]) “ )fim_para

fim_parafim

Exemplo 4:

Ler um vetor chamado meu_vetor, com 80 elementos, cada elemento é anota de um aluno de certa turma. Calcular a média geralda turma e verificar quantos alunos ficaram acima da média ou iguais à ela e quantos abaixo da média. Escrever a média, o número denotas acima da média ou iguais à média e o número de notas abaixo da média.

algoritmo estatistica_de_alunosinteiro meu_vetor[80], i, j, acima_media, abaixo_mediareal soma, media_geral

iniciosoma =0 acima_media =0para (i=1 até 80; i++)

ler (meu_vetor[i])soma = soma + meu_vetor[i]

fim_paramedia_geral = soma / 80para (j = 1 até 80; j++)

se (meu_vetor[j]< media_geral) acima_media ++

fim_sefim_para

abaixo_media = acima_media – 80escrever (“a média geral é (media_geral) “)escrever (“alunos na média ou acima (acima_media) “)escrever (“alunos abaixo da média (abaixo_media) “)

fim.

Observe que poderíamos ter usado a mesma variável ( i ou j) como índice dos vetores, pois o i para de ser usado e poderia serreaproveitado, mas no algoritmo usa-se a variável i para correr o vetor e preenchê-lo, e depois a variável j para correr o vetor e compararseus elementos com a média.

Exemplo 5:Ler um vetor chamado meu_vetor, de 6 elementos, e escrevê-lo. Ordenar, em seguida, os elementos de V em ordem crescente e

escreer o vetor V assim ordendado.Teremos aqui 2 exemplos, bastantes simples, portanto eficientes para manipulação de conjuntos pequenos (poucos elementos) e

mais lentos (não muito bons) para a manipulação de grande quantidade de dados.

8.2.1 Ordenação de matrizes – método da bolhaVamos comparar cada elemento do vetor com o elemento imediatamente seguinte ( meu_vetor[i] com meu_vetor[i+1] ).Se o elemento comparado for menor ou igual ao elemento seguinte, compara-se o segundo valor com o próximo, até terminar o

vetor.Se o elemento comparado for maior do que o imediatamnte segunte, troca-se entre si os dois elementos comparados e continua-se

comparando o segundo valor com o imediatamente seguinte enquanto houver elementos no vetor.

para (i = 1 até 5; i++)se (meu_vetor[i] > meu_vetor[i+1])

x= meu_vetor[i]meu_vetor[i] = meu_vetor[i+1]


Preencho o vetor com as notas dos alunos

Acumulo todas as notas

Usados para controlar a posição do vetor que estou manipulando

Porque 80 é a quantidade de notas lidas

Avalio quantos valores do vetor são maiores que a

médiaDiminuo de 80 os alunos que estão na média (ou acima) para

descobrir quantos estão abaixo da média geral


meu_vetor[i+1] =xfim_se

fim_para

Supondo a leitura de um vetor meu_vetor[6] com os seguintes valores:

15 7 1 4 17 10

Executando o trecho acima sobre este vetor, resultaria o seguinte:

7 1 4 15 10 17

Como pode ser observado, o novo vetor ficou mais próximo de uma ordenação em ordem crescente, mas não está ordenadoconforme se deseja. Isso indica que o processo deve ser repetido várias vezes até se conseguir o objetivo final.

Uma segunda execução nos levaria a:

1 4 7 10 15 17

Como se vê, este vetor, com apenas 2 execuções do trecho do algoritmo acima já ficou ordenado. Outros vetores, entretanto,podem exigir uma quantidade bem maior de repetições das execuções do trecho acima até conseguirem deixar o vetor completamentordenado.

O número máximo de execuções necessárias para a completa ordenação de um vetor é N – 1 vezes, onde N é o tamanho do vetor.Sabendo isso, podemos completar o trecho do algoritmo:

para (n = 1 até 5; n ++)para (i=1 até 5; i++)

se (meu_vetor[i] > meu_vetor[i+1]) x= meu_vetor[i]meu_vetor[i] = meu_vetor[i+1]meu_vetor[i+1] =x

fim_sefim_para

fim_para

Esse trecho certamente garante a ordenação do vetor conforme desejado, contudo, na prática o número de vezes que se tem quepassar pelo vetor é bem menor do que N -1, conforme pôde ser visto no exemplo do vetor acima. Em lugar de 5 passagens oramnecessárias apenas 2. Desta forma, uma solução melhor é a seguinte:

k=oenquanto (k==0)k=1para (i=1 até 5; i++)

se (meu_vetor[i] > meu_vetor[i+1]) x= meu_vetor[i]meu_vetor[i] = meu_vetor[i+1]meu_vetor[i+1] =xk=0

fim_sefim_para

fim_enquanto

Com isto, a versão 1 da ordenação de um vetor de 6 elementos é a seguinte:

Algoritmo ordena_crescente_bolhaVariáveisinteiro meu_vetor[6], i, k, x

INICIOpara (i= 1 até 6; i++)

ler (meu_vetor[i])escrever (meu_vetor[i])

fim_para



k=oenquanto (k==0)

k=1para (i=1 até 5; i++)

se (meu_vetor[i] > meu_vetor[i+1]) x= meu_vetor[i]meu_vetor[i] = meu_vetor[i+1]meu_vetor[i+1] =xk=0

fim_sefim_para

fim_enquantopara (i= 1 até 6; i++)

escrever (meu_vetor[i])fim_para

FIM

Assim, o algoritmo acima lê um vetor de 6 elementos e o escreve talq ual foi lido. Em seguida, ordena o vetor em ordem crescenteusando um dos muitos méodos de ordenação existentes (Bubble Sort). Uma vez ordenado, o algoritmo escreve o vetor ordenado emordem crescente.

Outro processo de ordenação de um conjunto, consiste em achar o maior elemento do conjunto e trocá-lo com a última posição.Em seguida, acha-s o maio do conjunto restante e troca-se com a penúltima posição. Procede-se da mesma maneira até qiue o conjuntorestante contenha apenas um elemento quando se dá por concluído o processo.

Supondo que se tenha o mesmo vetor usado anteriormente:

15 7 1 4 17* 10*15* 7 1 4 10* 1710* 7 1 4* 15 174 7* 1* 10 15 174* 1* 7 10 15 171 4 7 10 15 17

Os asteriscos indicam que foram trocados de uma linha para a seguinte.A solução dos problemas de ordenação por este processo leva ai seguinte algoritmo.

8.2.2 Ordenação de Matrizes - método de troca do maior:Algoritmo ordena_troca_do_maiorVariáveisinteiro meu_vetor[6], i, n, m, p, aux, k


ler (meu_vetor[i])escrever (meu_vetor[i])

fim_paran=6enquanto (n>1)

m= meu_vetor[1]p=1para (i=2 até 6; i++)

se (m < meu_vetor[i]) m= meu_vetor[i]p=i

fim_sefim_paraaux = meu_vetor[n]meu_vetor[n]=meu_vetor[p]



meu_vetor[p]=auxn=n-1

fim_enquantopara (k= 1 até 6; k++)

escrever (meu_vetor[k])fim_para

FIM

Quando se trata de matrizes de duas dimensões, tem-se dois índices que devem ser controlados. Considere o seguinte problema:

Ler uma tabela chamada minha_tabela[10][20].Em seguida ler 15 valores, um decada vez, e para cada valor lido, verificar se este valor está ou não na

tabela minha_tabela, escrevendo-o com a mensagem adequada.

Desta forma temos o algoritmo abaixo:

Algoritmo pesquisa_em _tabelaVariáveisinteiro minha_tabela[10][20], n, i, j, a


para (j= 1 até 20; j++)ler (minha_tabela[i][j])

fim_parafim_parapara (n=1 até 15; n++)

ler (a)para (i=1 até 10; i++)

para (j= 1 até 20; j++)se (a == minha_tabela[i][j])

i= 12j= 10

fim_sefim_para

fim_parase (i==11)

escrever ( “(a) não está na tabela”)senão

escrever ( “(a) está na tabela”)fim_se

fim_paraFIM

8.3 Atividades1) Conceitue MatrizMatriz é um conjunto de variáveis, cada uma podendo representar o valor de uma constante, como se fossem variáveis simples,

mas todas elas compartilham o mesmo nome e todas são do mesmo tipo.

2) Como é indicada a leitura de um vetor V(10)?

algoritmo leitura_vetorvariáveis

“tipo_qualquer” v[10] inteiro coluna

iniciopara (coluna=1 até 10; coluna++)

ler( v[coluna] )fim_para

fim

3) Como é indicada a escrita de uma matriz M(5,8)?



algoritmo escreve_matrizvariáveistipo_qualquer m[5][8]inteiro coluna, linha

iniciopara (linha = 1 até 5; linha++)

para (coluna=1 até 8; coluna++)escrever( m[linha][ coluna] )

fim_parafim_para

fim

4) Escrever um algoritmo que lê um vetor X(100) e o escreve. Substitua, a seguir, todos os valores negativos de X por 1 e escrevao vetor modificado

algoritmo modifica_vetorvariáveisinteiro x[100], coluna


ler (x[coluna])escrever(x[coluna])se (x[coluna] < 0 )

x[coluna] = 1fim_se

fim_parapara (coluna=1 até 100; coluna++)

escrever(x[coluna])fim_para

fim5) Escrever um algoritmo que lê um vetor K(20) e o escreve. Troque, a seguir, os elementos de ordem ímpar com os de ordem par

imediatamente seguintes e escreva o vetor assim modificado.algoritmo troca_elementosvariáveisinteiro k[20], aux, coluna


ler (k[coluna])escrever(k[coluna])

fim_paracoluna =1faça

aux = k[coluna]k[coluna]= k[coluna + 1]k[coluna + 1] = auxcoluna = coluna + 2

até que ( coluna >= 20)para (coluna=1 até 20; coluna++)

escrever(k[coluna])fim_para

fim6) Armazene em uma Matriz de 3 linhas por 2 colunas nome de pessoas.Pesquise nessa matriz quantas pessoas chamadas "camila" estão cadastradas.

ALGORITMO NOMESVARIÁVEIS cadeia nomes[3][2] inteiro lin, col, camilasINICIO para (lin= 0 até 2; lin++) para (col=0 até 1; col++)



ler (nomes[lin][col]) se (nomes[lin][col] =="Camila") /*se o nome é camila*/ camilas++ /*adiciono 1 em camilas*/ fim_se fim_se fim_para escrever ("Na matriz tem (camilas) pessoas com o nome Camila")FIM

7) Leia uma frase de 120 caracteres, troque todos as letras "i" por "I" e todos os "A" por "b"

ALGORITMO troca_letrasVARIAVEIS cadeia frase[120] inteiro contINICIO ler (frase) para (cont = 1 até 120) se (frase[cont] =="i") frase[cont] = "I" senão se (frase[cont]=="A") frase[cont]="b" fim_se fim_Se fim_paraFIM

8)Leia um vetor de 30 posições. Seo número inteiro lido for 19, troque-o com o seu "vizinho" da direita(indice+1)

ALGORITMO troca_posicaoVARIAVEIS inteiro vetor[30] inteito cont, auxiliarINICIO para (cont=1 até 30; cont++) ler (vetor[cont]) fim_para para (cont= 1 até 30; cont++) se (vetor[cont] ==19) auxiliar= vetor[cont] vetor[cont]=vetor[cont+1] vetor[cont+1]=auxiliar fim_se fim_paraFIM



9 Estruturas ou RegistrosUma estrutura agrupa várias variáveis numa só. Funciona como uma ficha pessoal que tenha nome, telefone e endereço.

A ficha seria uma estrutura. A estrutura, então, serve para agrupar um conjunto de dados não similares (que não são do mesmo tipo),formando um novo tipo de dados.

9.1 CriandoSua forma geral é:

nome_do_tipo_da_estrutura { tipo1 variavel1 tipo2 variavel2...

}

Um primeiro exemplo:animais{cadeia nome[80]cadeia raca[80]inteiro idade

}

Neste caso, animais é uma estrutura com três campos: nome, raça e idade. Podemos usar ela mais de uma vez. É só declararmos mais de uma variável sendo do tipo “animais”Se quisermos fazer um programa que utilize esse tipo de dado (o tipo animais), seria assim:

ALGORITMO animaisDECLARAÇÃO DE TIPOSanimais{

cadeia nome[80]cadeia raca[80]inteiro idade

} DECLARAÇÃO DE VARIÁVEISinteiro nomeanimais cachorro[1], gato[1]

INICIOescrever(“Digite o seu nome”)ler (nome)escrever(“Digite o nome de seu cachorro”)ler (cachorro[1].nome)escrever(“Digite a raça de seu cachorro”)ler (cachorro[1].raca)escrever(“Digite a idade de seu cachorro”)ler (cachorro[1].idade)escrever(“Digite o nome de seu gato”)ler (gato[1].nome)escrever(“Digite a raça de seu gato”)ler (gato[1].raca)escrever(“Digite a idade de seu gato”)ler (gato[1].idade)escrever (“(nome), voce informou os dados do seu cao e de seu gato!”)



FIM

Note que declarei um registro (ou estrutura) chamado animais. Depois, declarei uma variável do tipo animais.Essa variável possui três campos: os três campos da estrutura animais.Quando quisermos manipular os dados das estruturas, utilizamos um ponto (.) para referenciarmos o campo.Utilizamos o número (índice) a estrutura entre parênteses, pois o cachorro[1].raca, cachorro[1].idade e cachorro[1].nome pertencem

todos ao mesmo cachorro.Se tivéssemos mais um cachorro a ser cadastrado seria o cachorro[2].raca, cachorro[2].idade e cachorro[2].nom, e assim

sucessivamente.Com o gato a mesma coisa.

Podemos declarar quantas estruturas quisermos:

ALGORITMO pet_shopDECLARAÇÃO DE TIPOSanimais{

cadeia nome[80]cadeia raca[80]inteiro idade

} cliente{

cadeia nome[80]inteiro telefone

} DECLARAÇÃO DE VARIÁVEISanimais cachorro[1]cliente dono_do_cachorro[1]

INICIOescrever(“Digite o nome do dono do cachorro”)ler (dono_do_cachorro[1].nome)escrever(“Digite o telefone do dono”)ler (dono_do_cachorro[1].telefone)escrever(“Digite o nome do cachorro”)ler (cachorro[1].nome)escrever(“Digite a idade do cachorro”)ler (cachorro[1].idade)escrever(“Digite a raça do cachorro”)ler (cachorro[1].raca)

FIM

9.2 Acrescentando mais detalhesPodemos declarar mais de uma estrutura. Um campo de uma estrutura pode ser do tipo “outra estrutura”Vamos criar uma estrutura de endereço:

Enderecos{cadeira Rua[50]inteiro Numerocadeia Bairro[20]cadeia Cidade[30]cadeia SiglaEstado[3]

}

Vamos agora criar uma estrutura chamada ficha_pessoal com os dados pessoais de uma pessoa: FichaPessoal{cadeia Nome[50]inteiro TelefoneEnderecos endereco



}Vemos, pelos exemplos acima, que uma estrutura pode fazer parte de outra ( a Enderecos é usada pela FichaPessoal).

9.3 UsandoVamos agora utilizar as estruturas declaradas na seção anterior para escrever um programa que preencha uma ficha.

ALGORITMO usando_uma_estrutura_que_usa_outraDECLARAÇÃO DE TIPOS (OU REGISTROS)Enderecos{cadeira Rua[50]inteiro Numerocadeia Bairro[20]cadeia Cidade[30]cadeia SiglaEstado[3]

}

FichaPessoal{cadeia Nome[50]inteiro TelefoneEnderecos endereco

}

VARIÁVEISFichaPessoal ficha /*se for só uma, não é necessário colocar o [1] */

INICIOficha.Nome = "Luiz dos Santos"ficha.Telefone=49212345ficha.endereco.Rua = "Rua 12"ficha.endereco.Numero = 10ficha.endereco.Bairro = "Porto Alegre"ficha.endereco.Cidade = "Rio Grande do Sul"ficha.endereco.SiglaEstado = "RS"

}O programa declara uma variável ficha do tipo FichaPessoal e preenche os seus dados. O exemplo mostra como podemos acessar um elemento de uma estrutura: basta usar o ponto (.). Assim, para acessar o campo

Telefone de ficha, escrevemos:

ficha.Telefone = 4921234

Como a estrutura FichaPessoal possui o campo endereco, que também é uma estrutura, podemos fazer acesso aos campos destaestrutura interna da seguinte maneira:

ficha.endereco.iNumero = 10

Desta forma, estamos acessando, primeiramente, o campo endereco da estrutura ficha e, dentro deste campo, estamos acessando ocampo Numero.

9.4 Exemplos1- Cadastre 4 pessoas e conte quantas têm mais de 18 anos.

ALGORITMO MAIORESDECLARACAO DE TIPOSpessoas{

cadeia nome[40]



inteiro idade}

VARIAVEISinteiro cont, quantidadepessoas pessoa[4]

INICIOpara (cont=0 até 3; cont++)

escrever("Digite o nome da pessoa numero (cont) ")ler (pessoa[cont].nome)escrever("Digite a idade da pessoa numero (cont) ")ler (pessoa[cont].idade)se (pessoa[cont].idade > 18)

quantidade ++fim_se

fim_paraFIM

2- Cadastre 7 livros. Se o genero do livro for ficção, troque o genero por drama.

ALGORITMO troca_genero_atribuindo_um_novo_genero_para_o_campoDECLARACAO DE TIPOSlivros{

cadeia titulo[40], autor[80], editora[80], genero[80]inteiro isbn

}VARIAVEISinteiro contlivros livro[7]


escrever("Digite o titulo do livro numero (cont) ")ler (livro[cont].titulo)escrever("Digite o autor do livro numero (cont) ")ler (livro[cont].autor)escrever("Digite a editora do livro numero (cont) ")ler (livro[cont].editora)escrever("Digite o isbn do livro numero (cont) ")ler (livro[cont].isbn)escrever("Digite o genero do livro numero (cont) ")ler (livro[cont].genero)se (livro[cont].genero =="ficcao")

livro[cont].genero = "drama"fim_se

fim_paraFIM

3- Pergunte ao usuario se ele quer cadastrar um cliente. Leiaos dados de clientes até que ele digite "NÃO" (não quer castrar novocliente)

Os dados do cliente deve ser:* nome* idade* sexoConte quantos clientes têm entre 30 e 50 anos.***************para fazermos esse algoritmo poderíamos usar o "enquanto" ou o "faça... até que"*******************ALGORITMO clientesDECLARACAO DE TIPOSpessoas{

cadeia nome[40]inteiro idadecaracter sexo



}VARIAVEISinteiro cont, quantidade cadeia resposta[80]pessoas cliente[80]

INICIOresposta ="sim"enquanto (resposta != "nao")

escrever("Digite o nome da pessoa numero (cont) ")ler (cliente[cont].nome)escrever("Digite o sexo da pessoa numero (cont) ")ler (cliente[cont].sexo)escrever("Digite a idade da pessoa numero (cont) ")ler (cliente[cont].idade)se ( (pessoa[cont].idade > 18) e (pessoa[cont].idade < 50) )

quantidade ++fim_seescrever("Deseja cadastrar novo cliente? ")ler (resposta) /*precisamos perguntar, para que quando o

'enquanto' terminar, ele verifique novamente e só volte a repetir o cadastramento se a pessoa respondeu 'sim'*/

cont ++ /*o "para" tem o incremento automático quando inicia, como o enquanto não faz o incremento, precisamos faze-lo

utilizando para isso uma variavel no final das instrucoes para que sejam lidos os dados da pessoa 1, depois da 2,

depois da 3.... e assim por diante*/

fim_enquantoFIM

4 - Leia um numero até que seja válido (2 ou 7). Depois, se ele for 2, leia um outro número e escreva a classificação. 0- classe A 1- classe B 2- classe C3- classe D

Se não for 2, imprima a frase " o numero é 7", 30 vezes.

ALGORITMO validacao_de_numeroVARIAVEISreal num1, num2inteiro cont

INICIOfaça

ler (num1)enquanto ((num1 !=2) ou (num1 !=7))se (num1 ==2)

ler (num2)caso (num2) { 0: escrever ("Classe A")

1: escrever ("Classe B") 2: escrever ("Classe c")3: escrever ("Classe D")

}senão

para (cont = 0 até 29; cont ++)escrever ("O número é 7")

fim_parafim_caso

fim_se



FIM 5 - Faça um cadastro para pet-shop (use estruturas). O máximo é 300 clientes. Cadastre nome do animal, classificação (canino - 1, felino - 2, roedor - 3, ave - 4), raça, idade, nome do dono e telefone. A classificação será dada pelo codigo. Depois de cadastrado conte quantos animais temos em cada classe e escreva, no final essa classificação.

ALGORITMO pet_shop_usando_estruturasDECLARACAO DE TIPOanimais{

cadeia nome[40], dono[50]inteiro classe, idade, raca [50], telefone

}

VARIAVEIS

animais cliente[300]inteiro quantidade_canino, quantidade_felino, quantidade_roedor,

quantidade_aveinteiro cont


ler (cliente[cont].nome, cliente[cont].raca, cliente[cont].dono)ler (cliente[cont].classe, cliente[cont].idade, cliente[cont].telefone)

caso (cliente[cont].raca) {

1: quantidade_canino++2: quantidade_felino++3: quantidade_roedor++4: quantidade_ave++

}fim_caso

fim_paraescrever("Caninos cadastrados (quantidade_canino) ")escrever("Felinos cadastrados (quantidade_felino) ")escrever("Roedores cadastrador (quantidade_roedor) ")escrevr ("Aves cadastradas (quantidade_ave) ")

FIM



10 SubalgoritmosMuitos problemas com soluções complexas podem ser divididos, sucessivamente em problemas menores e de lógica mais fácil. Ao

invés de você escrever um algoritmo grande, poderá escrever vários algoritmos menores, os quais, não isoladamente mas em conjunto,resolvem o problema proposto.

Subalgoritmos são trechos de algoritmo que efetuam um ou mais cálculos determinados.Os valores fornecidos aos subalgoritmos são denominados de Parâmetros ou Argumentos.Parâmetros são valores que você substitui nas funções. Assim, na matemática, se você tem y=x+2 ou f(x)=x+2, para encontrar um

valor para Y, você deve dar para a função um valor através de variável x, que é o parâmetro da função.O uso de variáveis como Parâmetros permite escrever uma solução geral para um determinado conjunto de problemas.Nós implementaremos os subalgoritmos através de Procedimentos e Funções.A forma geral de um algoritmo como visto na seção 2.5, passa a ser da seguinte forma:

ALGORITMO <nome do algoritmo>Constantes

<declaração das constantes)Variáveis

<declaração das varáveis>

IMPLEMENTAÇÃO de Funções e/ou Procedimentos

INICIO<comandos>CHAMADA de funções e/ou Procedimentos

FIM

10.1 FunçõesSão subalgoritmos que implementam uma função no sentido matemático do termo, isto é, retornam um único valor, de um ou mais

valores recebidos.

10.1.1 ImplementaçãoA Implementação deste tipo de subalgoritmo será feita como segue:

Tipo_da_Função Nome_Função (Parâmetros)Variáveis (locais)

IniciocomandosNome_Função = Expressão (Resultado)

Fim

Se você observar, mudaram poucas coisas em relação a forma geral de um algoritmo, por isso que chamamos de subalgoritmos,pois é uma subdivisão do algoritmo principal em trechos menores.

Todo algoritmo que referência um ou mais subalgoritmo é denominado algoritmo principal em relação aos subalgoritmos por elereferenciados.

10.1.1.1 Nome da FunçãoO nome da função (Nome_Função) é considerado uma variável, e toda variável deve ser de algum tipo (Tipo_da_Função), assim

como cada parâmetro terá seu tipo. Exemplo:

real area_triangulo(base,altura : numero) logico existe(x : tipo_vetor, k : numero)caracter endereco(x : tipo_vetor, nome: caracter)

Uma função nunca terá um tipo pré-definido, tipo_vetor por exemplo, lembre-se de que uma função retorna um único valor.Os Parâmetros devem corresponder em número, tipo e ordem.



10.1.1.2 Chamada

O que caracteriza uma função é que o nome da função é uma variável, pois esta retorna um valor.A chamada de uma função se dará da seguinte forma:

Atribuindo a função a uma variável:

var = nome_funcao(parametros)var = x + nome_funcao(parâmetros) - 20

Usando a função numa condição:

nome_funcao(parametros) >= 7

Mandando escrever a função:escreva(nome_funcao(parametros))

Enquanto os Parâmetros de definição devem ser variáveis, os parâmetros de chamada podem ser expressões aritméticas.

algoritmo expressoes

variaveis (publicas)

inteiro fatorial (f : número) variáveis (locais)iniciocomandos ...fatorial = resultado

fim

iniciocomandos ...escreva(fatorial(n+2))escreva(fatorial(6))escreva(fatorial(a*2))

fim

10.1.1.3 Variáveis públicas e locaisVocê pode observar no exemplo acima que as variáveis LOCAIS são aquelas definidas dentro da função, no entanto elas só

existem para aquela função específica. Uma função/procedimento poderá ou não ter variáveis locais.As variáveis PÚBLICAS (ou GLOBAIS), como o próprio nome diz, elas fazem parte de todo o programa, isto é, do programa

principal e de todas as funções e procedimentos existentes.Quando ocorre de uma função/procedimento chamar outra função/procedimento, as variáveis LOCAIS da primeira função tornam-

se PÚBLICAS para a segunda função. Pelo raciocínio lógico, se uma função chama uma segunda e esta chama uma terceira, e assimsucessivamente, as variáveis LOCAIS da primeira são PÚBLICAS/GLOBAIS para a segunda, terceira ..., as variáveis LOCAIS da segundasão PÚBLICAS para a terceira,... e assim por diante.

Exemplo:Dados dois valores, calcule a soma dos dois valores.

algoritmo exeres7.2variáveisreal a,b

real soma (x,y : número)iniciosoma= x+y



fim

inicio {inicio programa principal}leia(a,b)escreva(soma(a,b))

fim

10.2 ProcedimentosSão subalgoritmos que podem retornar um número qualquer de valores em função dos Parâmetros recebidos.A definição deste tipo de subalgoritmo é semelhante ao anterior com a diferença de que os valores calculados figuram na lista dos

Parâmetros juntamente com os valores recebidos.

10.2.1 ImplementaçãoA Implementação deste tipo de subalgoritmo será feita como segue:procedimento nome_procedimento (parametros)variaveis (locais)inicio

comandosfim

10.2.2 ChamadaA chamada de um procedimento se dará sempre da mesma forma, veja os exemplos:algoritmo exemplovariaveis(publicas)

procedimento ordena (x : tipo_vetor; t : número)variáveis (locais)iniciocomandos ...

fim

iniciocomandos ...ordena(v,n)ordena(w,n)

fim

A chamada de procedimento se difere da chamada de função, enquanto que a função deve ser atribuída, o procedimento não. Noprocedimento pode não retornar valor algum ou vários valores. Os parâmetros devem corresponder em número, tipo e ordem.



11 Exercícios11.1 Seqüenciais

1. Escreva um algoritmo para ler um uma temperatura em graus Fahrenheit, calcular e Escrever o valor correspondente em grausCelsius (baseado na fórmula abaixo): C/5=(F-32)/9

2. Escreva um algoritmo para ler o salário mensal atual de um funcionário e o percentual de reajuste. Calcular e escrever o valor donovo salário.

3. O custo de um carro novo ao consumidor é a soma do custo de fábrica com a porcentagem do distribuidor e dos impostos(aplicados ao custo de fábrica). Supondo que o percentual do distribuidor seja de 28% e os impostos de 45%, escrever umalgoritmo para ler o custo de fábrica de um carro e escrever o custo final ao consumidor.

4. Uma revendedora de carros usados paga a seus funcionários vendedores um salário fixo por mês, mais uma comissão tambémfixa para cada carro vendido e mais 5% do valor das vendas por ele efetuadas. Escrever um algoritmo que leia o número decarros por ele vendidos, o valor total de suas vendas, o salário fixo e o valor que recebe por carro vendido. Calcule e escreva osalário mensal do vendedor.

11.2 Seleção1. Ler um valor e escrever a mensagem É MAIOR QUE 10! se o valor lido for maior que 10, caso contrário escrever NÃO É MAIOR

QUE 10!

2. Ler um valor e escrever se é positivo ou negativo (considere o valor zero como positivo).

3. Ler as notas da 1a. e 2a. avaliações de um aluno. Calcular a média aritmética simples e escrever uma mensagem que diga se oaluno foi ou não aprovado (considerar que nota igual ou maior que 6 o aluno é aprovado). Escrever também a média calculada.

4. Ler o ano atual e o ano de nascimento de uma pessoa. Escrever uma mensagem que diga se ela poderá ou não votar este ano(não é necessário considerar o mês em que a pessoa nasceu).

5. Ler 3 valores (considere que não serão informados valores iguais) e escrevê-los em ordem crescente.

6. Ler 3 valores (A, B e C) representando as medidas dos lados de um triângulo e escrever se formam ou não um triângulo. OBS:para formar um triângulo, o valor de cada lado deve ser menor que a soma dos outros 2.

7. A jornada de trabalho semanal de um funcionário é de 40 horas. O funcionário que trabalhar mais de 40 horas receberá horaextra, cujo cálculo é o valor da hora regular com um acréscimo de 50%. Escreva um algoritmo que leia o número de horastrabalhadas em um mês, o salário por hora e escreva o salário total do funcionário, que deverá ser acrescido das horas extras,caso tenham sido trabalhadas (considere que o mês possua 4 semanas exatas).

8. As maçãs custam R$ 1,30 cada se forem compradas menos de uma dúzia, e R$ 1,00 se forem compradas pelo menos 12.Escreva um programa que leia o número de maçãs compradas, calcule e escreva o custo total da compra.

9. Ler o nome de 2 times e o número de gols marcados na partida. Escrever o nome do vencedor. Caso não haja vencedor deveráser impressa a palavra EMPATE.

10. Faça um algoritmo para ler as 3 notas obtidas por um aluno nas 3 verificações e a média dos exercícios que fazemparte da avaliação. Calcular a média de aproveitamento, usando a fórmula: media_de_aproveitamento=(N1+(N2*2)+(N3*3)+Média_exercícios)/7 A atribuição de conceitos obedece a tabela abaixo:

Média Conceito>= 9 A>= 7,5 B>= 6 C< 6 D



11. Escreva um algoritmo que leia as idades de 2 homens e 2 mulheres (considere que as idades dos homens serão semprediferentes, bem como as das mulheres). Calcule e escreva a soma das idades do homem mais velho com a mulher mais nova, eo produto das idades do homem mais novo com a mulher mais velha.

11.3 Repetição1. Escreva um algoritmo para ler 2 valores (se o segundo valor informado for ZERO, deve ser lido um novo valor, ou seja, para o

segundo valor não pode ser aceito o zero) e imprimir o resultado da divisão do primeiro pelo segundo. Use faça... enquanto...

2. Escreva um algoritmo para ler as notas da 1a. e 2a. avaliações de um aluno, calcule e imprima a média (simples) semestral. Sódevem ser aceitos valores válidos durante a leitura (0 a 10) para cada nota.

3. Escreva um algoritmo para imprimir os números de 1 (inclusive) a 10 (inclusive) em ordem decrescente.

4. Ler um valor N e imprimir todos os valores inteiros entre 1 (inclusive) e N (inclusive). Considere que o N será sempre maior queZERO.

5. Modifique o exercício anterior para aceitar somente valores maiores que 0 para N.

6. Escreva um algoritmo que calcule e imprima a tabuada do 8 (1 a 10).

7. Ler 10 valores e escrever quantos destes valores são NEGATIVOS.

8. Ler 10 valores e escrever quantos destes valores estão no intervalo [10,20] e quantos deles estão fora deste intervalo.

9. Ler 10 valores, calcular e escrever a média aritmética destes valores.

10. Ler o número de alunos existentes em uma turma, ler as notas destes alunos, e calcular e escrever a média aritmética destasnotas.

11. Escreva um algoritmo para ler 10 números e ao final escrever a soma dos 10 números lidos.

12. Escreva um algoritmo para ler 10 números. Todos os números lidos com valores inferiores a 40 devem ser somados. Escreva ovalor final da soma.

11.4 Vetores e matrizes1. Escreva um algoritmo que permita a leitura dos nomes de 10 pessoas. Guarde em um vetor. Os nomes tem largura máxima de

20 caracteres. Após isto, o algoritmo deve permitir a leitura de 01 nome qualquer de pessoa. Escrever a mensagem ACHEI, se onome estiver entre os 10 nomes lidos anteriormente, ou NÃO ACHEI caso contrário.

2. Escreva um algoritmo que permita a leitura das notas de uma turma de 20 alunos. Calcular a média da turma e contar quantosalunos obtiveram nota acima desta média calculada. Escrever a média da turma e o resultado da contagem.

3. Ler um vetor de 10 posições (aceitar somente números positivos). Escrever a seguir o valor do maior elemento do vetor e arespectiva posição que ele ocupa no vetor.

4. Ler um vetor A de 10 elementos inteiros e um valor X também inteiro. Armazenar em um vetor M o resultado de cada elementode A multiplicado pelo valor X. Logo após, imprimir o vetor M.

5. Leia um vetor de 20 números reais que são códigos de produtos. Para cada número lido escreva na tela o resultado do cálculopedido.

1 - dobro do terceiro valor2 - triplo do quarto valor3 - raiz quadrada do primeiro valoroutro - cubo do primeiro valor



6. Leia uma matriz de 7 linhas po 8 colunas de reais. Só aceite números positivos. Depois da matriz completamente preenchidaescreva o triplo do segundo alor da primeira linha. Atribua para a penúltima posição da terceira linha o cubo do valor que está nalinha 6 coluna 8.

7. Leia uma matriz de 3 colunas e 5 linhas de inteiros. Depois dela completamente preenchida verifique se o primeiro valor daterceira linha é menor que 0. Se for, escreva todos os valores da linha 4.



BibliografiaARAÚJO, Everton C. Algoritmos: Fundamento e Prática. 2ed. Florianópolis,Visual Books, 2005.EVARISTO, Jaime & CRESPO, Sérgio. Aprendendo a programar: programando numa linguagem algorítmica executável ILA. Rio de

Janeiro, Book Express, 2000. FERNANDES, Antônio L. B. & BOTINI, Joana. Construção de Algoritmos. SENAC Nacional, 1998. FORBELLONE, André L. V. & EBERSPACHER, Henry F. Lógica de programação: a construção de algoritmos e estruturas de

dados.3 ed. São Paulo Makron Books, 2000.GUIMARÃES, Ângelo de Moura & LAGES, Newton Alberto de Castilho. Algoritmos e estruturas de dados. Rio de Janeiro, LTC,

1994. HOLLOWAY, James Paul. Introdução à programação para engenharia. Rio de Janeiro, LTC, 2005.MANZANO, José A. N. G. & OLIVEIRA, Jayr F. Algoritmos: lógica para desenvolvimento de programação de computadores. São

Paulo, Érica, 2000. MANZANO, José Augusto N. G. & OLIVEIRA, Jayr Figueiredo de. Estudo dirigido de algoritmos. São Paulo: Érica, 1997. MEDINA, Marco & Cristina Fertig. Algoritmos e Programação - Teoria e Prática. São Paulo, Novatec, 2005.ORTH, Afonso Inácio. Algoritmos e Programação. Editora AIO. Porto Alegre, 2001. SALVETTI, Dirceu D. & BARBOSA, Lisbete M. Algoritmos. São Paulo, Makron Book, 1998. VENANCIO, Claudio Ferreira. Desenvolvimento de algoritmos: uma nova abordagem. São Paulo, Érica, 1997.


Documents

Lógica de Programação - Educacionalpessoal.educacional.com.br/up/3670002/686835/apostila_logica.pdf · Lógica de Programação 6 1.4.1 Língua Idioma de um povo, formado por seus