Embed Size (px)
Citation preview
ALGORITMOS EM PROGRAMAÇÃO ESTRUTURADA
PEDRO KANTEK com adaptação Patricia Rücker de Bassi
2000
ÍNDICE
INTRODUÇÃO.........................................................................................................................................................................3
ALGORITMOS.........................................................................................................................................................................4
LÓGICA.....................................................................................................................................................................................5
O PORTUGOL........................................................................................................................................................................10
IDENTIFICADOR................................................................................................................................................................10VARIÁVEIS.........................................................................................................................................................................11ATRIBUIÇÃO......................................................................................................................................................................12OPERADORES.....................................................................................................................................................................13QUALIDADES DE UM BOM ALGORITMO....................................................................................................................19BLOCOS...............................................................................................................................................................................20SEQUÊNCIA SIMPLES.......................................................................................................................................................20COMANDOS DE ENTRADA E SAÍDA.............................................................................................................................21ALTERNATIVA SIMPLES.................................................................................................................................................25ALTERNATIVA COMPOSTA............................................................................................................................................26ANINHAMENTO.................................................................................................................................................................27MULTIPLA ESCOLHA.......................................................................................................................................................30COMANDOS DE REPETIÇÃO...........................................................................................................................................37
ENQUANTO......................................................................................................................................................................37REPITA.............................................................................................................................................................................39PARA.................................................................................................................................................................................45
NOVOS TIPOS DE DADOS..................................................................................................................................................54
VETORES.............................................................................................................................................................................54CLASSIFICAÇÃO DE VETORES......................................................................................................................................59PESQUISA EM VETORES..................................................................................................................................................61MATRIZ...............................................................................................................................................................................63
MODULARIZAÇÃO..............................................................................................................................................................70
PROCEDIMENTO...............................................................................................................................................................73FUNÇÃO..............................................................................................................................................................................74
RECURSIVIDADE.................................................................................................................................................................78
ARQUIVOS.............................................................................................................................................................................81
2
INTRODUÇÃO
A arte e ciência de programar computadores é algo fascinante. Uma das melhores definições desta atividade pode ser considerada - “programar é emprestar um pouco de nossa inteligência ao computador”. Quando o mesmo trabalha, é como se a inteligência emprestada do programador estivesse trabalhando.
A tecnologia de fabricação de computadores tem evoluído de maneira muito rápida nos últimos tempos. A programação de computadores nem tanto, embora também tenha tido alguns progressos importantes.
Existem razões para esta diferença. A construção de hardware (equipamento) é engenharia. Tudo pode ser matematicamente provado, produzido em série, rejeitado por amostragem, e, a partir de um original, sua cópia pode ser vendida aos milhões. Com o software é quase tudo ao contrário. É mais arte do que engenharia, até hoje não se pode comprovar matematicamente a correção de código, cada necessidade demanda a construção de modelos específicos, que só se aplicam naquele momento (no espaço e no tempo). Para nós, seres humanos, é uma vantagem. Pois, enquanto a produção de hardware é (ou pode ser) em grande parte robotizada, a produção de software ainda exige um bom cérebro por trás.
As restrições que ainda existem sobre o hardware impedem a programação dos computadores em linguagem natural, embora existam estudos nesta área. Hoje ainda não é possível dialogar com um computador como se fala com uma pessoa medianamente inteligente. Os computadores ainda não conseguem tal proeza.
Para programar computadores, portanto, precisamos aprender uma linguagem de programação. Estas linguagens são chamadas artificiais justamente por terem sido inventadas para esta finalidade, ao contrário das naturais que surgiram para comunicação de seres humanos. Como se destinam a serem entendidas por máquinas, tais linguagens são bastante pobres em termos de expressões, quantidade de termos e facilidades de construção de frases.
Entretanto, quando os primeiros computadores foram construídos a única linguagem entendida por eles era a binária. Sequências intermináveis de uns e zeros, algo assim como00000000001010101111110011111000101010100001111010100011. Chamou-se a isto, mais tarde, linguagem de primeira geração.
A seguir, o primeiro melhoramento: o assembler ou montador, que era um programa capaz de entender instruções escritas em uma linguagem um pouco mais humana, e traduzir cada uma destas instruções em sua expressão binária correspondente. Junto com este programa criou-se a primeira linguagem: o assembler, até hoje utilizado, ainda que muito raramente e que simboliza a segunda geração de linguagens. Programar em assembler exige muito conhecimento e paciência, a máquina precisa ser conhecida em inúmeros detalhes de construção, os programas são longos e difíceis, principalmente sua manutenção. Mas esta é a linguagem mais eficiente do ponto de vista dos consumos dos recursos de máquina, isto é, ela gera programas velozes e pequenos.
Depois, vieram as linguagens de terceira geração: a primeira foi o FORTRAN, depois COBOL, PL/I, ALGOL, PASCAL, C e outras menos votadas: BASIC, ADA, APL. Há um distanciamento do programador em relação à máquina, e uma aproximação do mesmo em relação ao problema a resolver.
3
Estas linguagens são mais fáceis de aprender e embora gerem programas maiores e mais lentos, aumentam em muito a produtividade humana de escrever código de programação.
As linguagens de quarta geração tem as seguintes características: facilidade para criar e gerir banco de dados; são implementadas de forma interpretada, são consideradas amigáveis (user friendly), geram relatórios e entrada de dados de forma automática e tem facilidade de pesquisas. Um exemplo é a ferramenta ACCESS. Existem, também, as linguagens voltadas para objetos como VISUAL BASIC, VISUAL C entre outras. E a evolução continua...
Antes de iniciar o estudo de programação, é necessário considerar que um computador nada mais é do que uma ferramenta utilizada para solucionar problemas que envolvam a manipulação de informações, sendo que estas informações classificam-se a grosso modo em dois tipos básicos: dados e instruções (ou comandos).
Os dados são representados pelas informações a serem tratadas ou processadas por um computador As instruções ou comandos são representadas pelo conjunto de palavras-chave (ou vocabulário) de uma determinada linguagem de programação, que tem por finalidade comandar em um computador o seu funcionamento e a forma como os dados armazenados deverão ser tratados.
Para se criar um programa que seja executável dentro de um computador, deve-se ter em mente três pontos de trabalho: a entrada de dados, o seu processamento e a saída dos mesmos. Sendo assim, todo programa estará trabalhando com estes três conceitos. Se os dados forem entrados de forma errada, serão processados de forma errada e consequentemente, resultarão em respostas erradas. Desta forma, dizer a alguém que foi erro do computador é ser um tanto “medíocre”, se houve algum erro, é porque foi causado por falha humana. Realmente é impossível um computador errar por vontade própria, pois vontade é uma coisa que os computadores não tem.
ALGORITMOS
Segundo mestre Aurélio, algoritmo é “processo de cálculo, ou de resolução de um grupo de problemas semelhantes, em que se estipula, com generalidade e sem restrições, regras formais para a obtenção do resultado ou da solução do problema”.
Do ponto de vista da informática, algoritmos é a regra de solução de um problema, isto é, surgida uma necessidade buscar-se-á uma solução, ou construir-se-á um algoritmo capaz de solucionar o problema.
Já um programa de computador, segundo Wirth, “é um formulação concreta de algoritmos abstratos, baseados em representações e estruturas específicas de dados”. Isto é:
PROGRAMA = ALGORITMOS + ESTRUTURAS DE DADOS
Outra definição de algoritmos, esta dos autores Angelo Guimarães e Newton Lages: “algoritmo é a descrição de um padrão de comportamento, expressado em termos de um repertório bem definido e finito de ações primitivas, das quais damos por certo que elas podem ser executadas.”
O conceito de algoritmo deve ser entendido, para sua correta compreensão, em seus dois aspectos, a quem chamaremos estático e temporal. Na visão estática, um algoritmo é um conjunto de ordens, condições, testes e verificações. No seu aspecto temporal, o algoritmo passa a ser vivo, pois atual sobre um conjunto de dados de entrada, para gerar os correspondentes dados de saída.
4
Tais características não podem ser separadas, elas estão intrinsecamente ligadas. A dificuldade em fazer bons algoritmos é ter em mente, enquanto se escreve o algoritmo (aspecto estático) o que ele vai fazer com seus dados (aspecto temporal).
LÓGICA
Lógica é definida basicamente como sendo o estudo das leis do raciocínio e do modo de aplicá-las corretamente na demonstração da verdade. Chamamos de algoritmo lógico aquele algoritmo cujas instruções estão dispostas ordenadamente e de maneira compreensível por qualquer pessoa que possua conhecimento básico sobre o assunto. Isto é, um algoritmo deve ser facilmente entendido, sem que seja necessária uma grande perda de tempo para a tradução da idéia contida no mesmo. Um algoritmo lógico deve ser, também, formado apenas pelo número mínimo de instruções necessárias para a resolução do problema referido.
Cada pessoa analisa um problema de uma forma diferente, há uma certa tendência em complicar a sua solução. Sendo assim, deve-se pensar muito na solução desejada, analisando todas as possibilidades, ao invés de utilizar a primeira solução que vier à cabeça, sob pena de complicar o algoritmo de tal modo, que quando for necessária uma modificação, gastar-se-á mais tempo tentando entendê-lo do que criando-o novamente com as alterações desejadas. Porém, o problema da complexidade não está presente apenas na elaboração do algoritmo, mas também na sua codificação em uma determinada linguagem de programação.
PROGRAMAÇÃO ESTRUTURADA
O termo programação estruturada nasceu nos fins da década de 60, quando Edsger Dijkstra escreveu um artigo publicado pela Communications of the ACM, cujo título é “O comando GOTO é prejudicial”. Dijkstra observou que a qualidade dos programadores decai em função do número de GOTO’s usados em seus programas. Segundo ele, “comandos GOTO’s tendem a criar caminhos de lógica confusos e programas pouco claros”. A sua recomendação foi de que o comando em questão fosse excluído das linguagens de programação de alto nível.
Nessa época também, (1966) dois professores italianos G. Jacopini e C. Bohm, provaram matematicamente que qualquer lógica de programação poderia ser derivada de três tipos básicos de procedimentos, como se vê na figura a seguir.
5
AS 3 FERRAMENTAS DA PROGRAMAÇÃO ESTRUTURADA
SEQUÊNCIA SIMPLES IF-THEN-ELSE DO-WHILE
A importância desta descoberta para o software teve tanto impacto quanto a de que qualquer forma lógica de hardware pode ser construída pelas combinações das portas AND, OR e NOT.
A programação estruturada pode ser definida basicamente como sendo uma técnica de programação, na qual a construção de um programa é feita com base nas estruturas simples de controle definidas acima. A rigidez imposta por estas estruturas é um fator importante para a compreensão do programa, pois uma vez que não existem comandos de desvios (GOTO), o programador é obrigado a utilizar uma lógica coerente que se adapte às estruturas. Desse modo o programa torna-se inteligente, já que não é possível criar códigos que abram margem para uma falta de ordenação na lógica, códigos absurdos, programas poluídos e de difícil compreensão.
Com a utilização da programação estruturada um programa tem, obrigatoriamente, início, meio e fim, pois não existem desvios, as estruturas devem ser dispostas numa ordem tal que, chegando ao final do código, um processamento completo tenha sido executado. Como se fosse uma caixa preta, com somente uma entrada e uma saída.
6
PORQUE O PORTUGOL ?
Portugol é uma técnica narrativa denominada pseudo-código, também conhecida como português estruturado. Esta técnica de algoritmização é baseada em uma PDL – Program Design Language (Linguagem de Projeto de Programação). A forma original de escrita é conhecida como inglês estruturado, muito parecida com a notação da linguagem Pascal. A PDL é usada como referência genérica para uma linguagem de projeto de programação, tendo como finalidade mostrar uma notação para elaborações de algoritmos, os quais serão utilizados na definição, criação e desenvolvimento de uma linguagem computacional (Pascal, C, Delphi, Visual-Objects, Clipper) e sua documentação. A diferença entre uma linguagem de programação de alto nível utilizada em computação e uma PDL, é que esta não pode ser compilada em um computador.
Existem inúmeras versões de Portugol, cada professor tem a sua, assim como cada empresa pode definir um pseudo-código. É importante salientar que a sintaxe e a semântica da construção de Portugol são arbitrados por alguém, segundo seus critérios, mas UMA VEZ ESTABELECIDO UM PADRÃO, ELE PRECISA SER RELIGIOSAMENTE SEGUIDO.
Esta restrição tem duas vertentes: - há que haver um mínimo de concordância para que outras pessoas possam ler e entender o que escrevermos.
- uma das principais características de um bom programador é a disciplina intelectual.
O português, como qualquer outra linguagem natural, tem inúmeras desvantagens. Não é entendido pela máquina, sua tradução é bastante complexa, é ambíguo podendo gerar interpretações errôneas, e é muito extenso. Logo, não é um linguajar adequado para expressarmos algoritmos. Devemos lembrar sempre que a margem de interpretação do computador é sempre ZERO.
Já um linguagem de programação, mesmo que de alto nível, como o Pascal ou o C, exigem um conhecimento da máquina que ainda não temos. Também é importante salientar que idealmente falando, não é uma boa política enfrentar dois problemas interligados ao mesmo tempo. Isto é, não convém misturar dificuldades lógicas com dificuldades da linguagem de programação. Já dizia Dijkstra “(devemos) reconhecer que temos uma cabeça pequena, e que é melhor tratar de conviver com ela e respeitar suas limitações” e que “a regra áurea da programação estruturada é DIVIDIR PARA REINAR.”
Nossos programas em Portugol vão deixar de lado inúmeras tarefas que são imprescindíveis para o programa rodar em um computador, tais como: instruções de ambientação na compilação de programas, descrições de operações de entrada/saída complexas, pouca ou nenhuma preparação de contadores e chaves, etc.
Para tanto, existe uma disciplina anexa a esta, onde vai se aprender a linguagem de programação. Neste momento, então, a preocupação passa a ser a máquina e não mais a lógica do algoritmo que já deve estar consolidado. OUTRAS FERRAMENTAS DE REPRESENTAÇÃO DE ALGORITMOS
Além do Portugol existem outras formas de representar algoritmos, podendo-se citar duas outras linguagens: fluxogramas e diagramas de Chapin.
Os fluxogramas tem importância histórica em processamento de dados, pois foi a primeira representação de programas. Ela foi desenvolvida pelos profissionais de análise de sistemas e por
7
alguns profissionais de Organização, Sistemas e Métodos. Tem como finalidade descrever fluxos, manual ou mecânico, especificando os suportes usados para os dados e as informações. Usa símbolos convencionais, permitindo poucas variações. Esta ferramenta perdeu sua condição de única ferramenta em uso, entre outras razões, pelas seguintes:- permite a construção de algoritmos não estruturados, logo não servem para o contexto da programação estruturada;- exigem capricho, demandando muito trabalho para serem feitos e mantidos;- como só se escreve dentro dos quadrinhos, é necessário muito papel para definir um algoritmo completo, além de dificultar o manuseio;- mesmo com o advento de programas para trabalhar fluxograma, como Flowchart, Autoflow e outros, eles não são muito práticos para este trabalho.
Outra possibilidade de representação é através dos diagramas de Chapin ou estructogramas que foram desenvolvidos por Nassi e Schneiderman e ampliado por Ned Chapin, os quais resolveram substituir o fluxograma tradicional por um diagrama de quadros que permite apresentar uma visão hierárquica e estruturada da lógica do programa. A grande vantagem de usar este tipo de diagrama é a representação das estruturas que tem um ponto de entrada e um ponto de saída e portanto, são compostos pelas estruturas básicas de controle da programação estruturada. Enquanto é difícil mostrar o embutimento e a recursividade com o fluxograma tradicional, torna-se mais simples mostrá-los com o diagrama de Chapin, bem como, codificá-los em qualquer linguagem de programação estruturada. Porém, alguns autores consideram esta ferramenta um pseudo-código como o Portugol, apenas escrito de maneira diferente, assim, não será tratada esta representação aqui.
Para representar as estruturas de comando de forma completa, elas serão apresentadas no formato Portugol e Fluxograma.
8
Exemplo: Definir um algoritmo que leia dois valores A e B e imprimia o produto entre eles se A for par e imprima o somatório deles se A for impar.
FLUXOGRAMA DIAGRAMA DE CHAPIN PORTUGOL
inicio A,B,C : inteiro; leia (A); leia (B); se A mod 2 = 0 então C A * B; senão C A + B; fimse; imprima ( C );fim.
leia A
leia B
A é par ?
C = A * B C = A + B
imprima C
9
inicio
leia A
leia B
A é par
C = A* B C= A + B
imprima C
fim
V F
V F
O PORTUGOL
A seguir as principais regras de sintaxe e de construção da linguagem Portugol:
IDENTIFICADOR
O elemento básico da linguagem é o identificador. Sua construção é dada pelo diagrama a seguir:
Considerando-se:Letra - 26 letras do alfabeto maiúsculasDígitos - 0 a 9
Deve-se atentar que o branco não faz parte do rol de caracteres válidos, o que faz com que o identificador não possa ser constituído de mais de uma palavra. Pode-se utilizar, neste caso, o separador “_ “ , chamado sublinha ou underscore.
Exemplos válidos : NOME SOMA_TERMOS RAIZ1 X234 SALDO01
Exemplos não válidos : SALDO DEVEDOR 123SALDO
Regras de bom senso para batizar o identificador:1. cada identificador deve ter seu nome o mais próximo possível de sua função;2. o identificador não deve ser tão pequeno que fique impossível identificá-lo pelo nome, nem tão longo que seja cansativo de escrevê-lo3. padronizar os identificadores, em algoritmos, sempre em letras maiúsculas para facilitar a análise do mesmo. Ainda que as linguagens de programação façam diferenciação entre letras maiúsculas e minúsculas.
10
identificador letra
letra
dígito
VARIÁVEIS Variável é algo que pode ser alterado, isto é, não é constante. Variáveis de memória são endereços da memória RAM (Randomic Access Memory) do computador, onde são armazenados temporariamente os dados utilizados por um programa durante seu processamento, e que, como diz o próprio nome, podem ter seus conteúdos alterados durante o processamento do programa.
Para se utilizar o conceito de variável, imagine que a memória de um computador é um grande arquivo com várias gavetas, onde cada gaveta pode apenas armazenar um único valor por vez , seja ele inteiro, real, caracter ou lógico. Se é um grande arquivo com várias gavetas há que se concordar que é necessário identificar com um nome a gaveta que se pretende utilizar. O nome de uma variável é utilizado para sua identificação e posterior uso dentro de um programa, desse modo não é necessário saber a posição de cada byte (informação) dentro da memória do computador
Quando é feita a definição de variáveis no algoritmo, necessita-se indicar o nome que será dado a variável (identificador) e qual o tipo de informação que ela irá conter. Dependendo do tipo de informação será designado um espaço maior ou menor de memória onde ocorrerá o armazenamento.
TIPOS DE VARIÁVEISExistem quatro tipos básicos de variáveis em Portugol: INTEIRO, REAL, CARACTER E LÓGICO. Estes tipos também são conhecidos como tipos primitivos de dados.
O tipo de dado INTEIRO é uma variável numérica que pode conter números inteiros, positivos ou negativos.
O tipo de dado REAL é outra variável numérica que pode conter qualquer número real, isto é, inteiro, fracionário, positivo ou negativo.
Tipo de dado CARACTER é uma variável que pode armazenar em seu conteúdo todas as letras do alfabeto, todos os algarismos e todos os caracteres especiais (& # @ ? *, etc). Uma variável do tipo caracter não pode ser utilizada em expressões aritméticas, mesmo que contenha apenas algarismos.
São caracterizados como tipos LÓGICOS os dados com valores VERDADEIRO e FALSO sendo que este tipo de dado poderá representar apenas um dos dois valores por vez. Ele é chamado por alguns de tipo booleano, devido à contribuição do filósofo e matemático George Boole na área da lógica matemática.
O tipo caracter traz consigo uma pequena dificuldade, que é a necessidade de estabelecer qual o seu tamanho máximo, em número de caracteres. Esta atitude é necessária para informar a quem lê o algoritmo quanto de espaço reservar para conter esta variável. Os outros tipos de variáveis tem tamanho pré-determinados e fixos.
11
Uma variável quando é definida ganha um tipo de dado, e posterior referências de valor a esta variável deverão respeitar seu tipo de dado original.
A forma de definir variáveis dentro de um algoritmo é:
ATRIBUIÇÃO
O comando de atribuição é aquele que permite colocar valores nas variáveis ou alterar seu conteúdo, obedecendo o tipo de dado definido para ela. Para tanto usaremos o símbolo . Sua sintaxe é:
O novo valor atribuído à variável é feito durante o processamento do programa utilizado e pode ser uma constante, o resultado de uma expressão ou o valor de outra variável.
Exemplo: A 1
B 1 + 2
É importante notar que:- a expressão que se encontra do lado direito da atribuição deve ser compatível com o tipo de dado definido para a variável;- na atribuição de variável inteira, a expressão deverá ser uma expressão inteira, isto é, sem parte fracionária;
12
identificador expressão ;
,
: ;identificador inteiro
real
caracter
lógico
- na atribuição de variáveis do tipo real, a expressão deverá ser numérica, sem nenhuma outra restrição;- na atribuição de variáveis caracter o valor deverá estar envolvido por aspas “. Ele nunca poderá ter um tamanho maior do que aquele estabelecido para a variável. Se isto acontecer, o valor será truncado.- na atribuição de variáveis lógicas deveremos usar as palavras VERDADEIRO e FALSO, ou quando não houver risco de confusão, podemos usar as abreviaturas V e F.
Exemplo:A “1 “ ; inteiro ou caracterB “V” ; caracter ou lógico
OPERADORES
Operadores são símbolos utilizados em expressões que contêm variáveis, constantes e funções. De acordo com os tipos de dados das variáveis e o resultado da operação, os operadores dividem-se em três tipos:
- aritméticos- relacionais- lógicos
ARITMÉTICOS São aqueles que atuam apenas sobre constantes, variáveis e funções numéricas, gerando um resultado numérico em uma expressão. São eles:
+ adição
- subtração binária
* multiplicação
/ divisão
** exponenciação
- menos unário
Pode-se também utilizar as funções matemáticas usuais e as conhecidas da linguagem de programação, como:sen(x), cos(x), abs(x), int(x), frac(x), log(x), sqrt(x)
RELACIONAIS São aqueles que realizam uma comparação entre duas expressões e geram resultados lógicos, isto é Verdadeiro ou Falso, são eles:
= igual<> ou diferente
> maior que< menor que
>= ou maior ou igual<= ou menor ou igual
13
LÓGICOS São aqueles que geram resultados lógicos através da comparação entre duas expressões lógicas, são três:
conjunção E é aquele que exige que todos os termos da expressão sejam verdadeiros para que a expressão inteira seja verdadeira.
disjunção OU é aquele que exige que apenas um dos termos da expressão seja verdadeiro para que a expressão inteira seja veradeira.
negação NÃO é aquele que inverte ou nega o valor lógico de um elemento.
Os operadores lógicos tem seu resultado baseado na Tabela Verdade, eles operam sobre variáveis lógicas (V ou F) e tem como resultado valores lógicos (V ou F).
OU V F E V F NÃO V FV V V V V F F VF V F F F F
DIV E MOD São duas importantes funções matemáticas que atuam sobre números inteiros e dão como resultado também números inteiros. Div - resultado inteiro de uma divisão inteira Mod - resto inteiro de uma divisão inteira
PRIORIDADES Na execução de um comando complexo, podemos encontrar duas ou mais operações numéricas uma ao lado da outra, e neste caso devemos seguir regras de prioridades de operadores para sabermos qual será executado primeiro. No Portugol as prioridades são:
PRIORIDADE COMANDO1ª parênteses2ª funções3ª menos unário4ª **5ª * e /6ª + e -7ª relacionais8ª lógicos NÃO9ª E10ª OU
Se houverem duas operações de mesma prioridade, as mesmas, serão realizadas da esquerda para a direita, como na matemática.
14
SUGESTÕES PARA MAIOR CLAREZA DAS EXPRESSÕES1. Definir linhas pequenas gerando maior clareza e auto-documentação;2. Quebrar um comando complexo em diversos mais simples;3. Usar e abusar de parênteses, mesmo que redundantes, assim não precisamos decorar as regras de prioridade.
15
RESUMO
Identificador (nome de variável) - Sempre maiúsculo - Começa com letra - Continua com letra / dígitos - Tamanho ilimitadoEx.: MEDIA, SALD34, SAL_CONT
Tipos de variáveis
Inteiro: números inteiros, positivos / negativosReal: números inteiros / fracionários, positivos/ negativos de qualquer magnitudeCaracter: sequência de caracteresLógico: VERDADEIRO ou FALSO
Definição:Ident[ , ident]: inteiro; : real; : caracter [tam]; : lógico;
Comando de atribuição
ident expressão;
Expressão pode ser somente valor.Deve ser compatível com o tipo da variável.Se tipo for caracter deve ser entre aspas e com tamanho compatível.Se for tipo lógico somente V ou F.
Operadores aritméticos
+ adição- subtração* multiplicação/ divisão fracionária- unário: opostosen (x): seno de x radianoscos (x): cosseno de x radianosabs (x): valor absoluto xint (x): parte inteira de xfrac (x): parte fracionária de xlog (x): logaritmo de x
n div m: quociente da divisão inteira de n por m
n mod m: resto inteiro da divisão inteira de n por m
Operadores Lógicos
E : V somente quando ambos os operandos são V
V E V é VV E F é FF E V é FF E F é F
OU : F somente quando ambos os operandos forem F V OU V e’ VF OU V e’ VV OU F e’ VF OU F e’ F
NÃO : é a negação NÃO V é F NÃO F é V
Prioridade das Operações1. Parênteses2. Funções3. Menos unário (oposto)4. Potenciação5. Multiplicação e divisão6. Adição e subtração7. Comparações > Maior < Menor = Igual Maior ou igual Menor ou igual <> Diferente8. Operadores lógicos E OU NÃO9. Operações de mesma prioridade são resolvidas da direita para a esquerda.
16
EXERCÍCIOS
1. Informe o valor esperado para a variável VAR1
VAR1 (1 + (2 * (3 + 1) / 2 )) - 2VAR1 3 ** 3VAR1 2 * int(1,999)VAR1 abs( - (3 - 4))VAR1 int (1,5) - frac(1,.5)VAR1 2 / (2 * 3)
2. Quanto é 400 MOD 51
a. 30 MOD 7b. (5 MOD 4) + (22 DIV 10) + (3 MOD 2)c. 4376 MOD 10d. 4376 MOD 100e. 4376 MOD 1000f. 4376 MOD 10000
3. Informe qual o valor da variável VAR2
VAR2 VERDADEIROVAR2 NAO FALSOVAR2 NAO NAO VERDADEIROVAR2 FALSO OU FALSOVAR2 VERDADEIRO E (NAO VERDADEIRO)VAR2 (NAO FALSO) OU (NAO VERDADEIRO)VAR2 (FALSO OU VERDADEIRO) E (NAO VERDADEIRO)VAR2 FALSO E FALSOVAR2 VERDADEIRO E VERDADEIRO
4. Informe qual o valor final para VAR3
VAR3 (3 2) OU (1 = 3)VAR3 (1 + 1) = (3 - 1)VAR3 (int (1,5 * 4) > 6) E (1 <> 2)
5. Informe qual o valor para VAR4
VAR4 ( frac(0,999) - 1) > 0VAR4 1 = 2VAR4 1 + 2 = 2VAR4 0.5 2.5 - int(2,900)VAR4 3 > 1 + 1VAR4 1 + 3 * 4VAR4 2 ** 3 * 2 + 1VAR4 1 * 2 * 3 * 4 * 0 + 1VAR4 33 > (32 + int(2,45) - frac(0,5))VAR4 (4 ** (2 / 2 ** 2) 3,5) E ( 1 = 3 ** 0)
6. Assinalar com um X os identificadores válidos:
( ) VALOR ( ) "NOTA"
( ) NOMEMP ( ) SALA215
( ) MARIA( ) B248
17
( ) X2 ( ) SAL_LIQ( ) 3 X 4
( ) AH! ( ) M{A}( ) A1B2C3 ( ) "NOME"
( ) KM/H( ) XYZ( ) NOTA*DO*ALUNO
7. Considerando P = 3; Q = 4; R = 12 e S = 45; NOME = "MIRIAM"; PROFISSAO = "MEDICO", qual o valor de RESP em cada uma das expressões abaixo:
a. RESP 100 * (Q div P ) + R b. RESP (P + 1 >= SQRT(Q)) e NOME <> "ANA" e PROFISSAO = "MEDICO" c. RESP P * ( R mod 5) - Q / 2 d. RESP (S mod (P + 1)) - Q * R e. RESP PROFISSAO = "MEDICO" ou (Q mod P) = 0
8. Sendo: SOMA, NUM, X variáveis numéricas NOME, COR, DIA variáveis caracter e TESTE, COD, TUDO variáveis lógicas,assinalar os comandos considerados inválidos:
( ) NOME 5; ( ) SOMA NUM + 2 * X; ( ) TESTE COD ou X ** 2 <> SOMA; ( ) TUDO SOMA; ( ) COR "PRETO" - SQRT(X)
( ) X NOME >= COD; ( ) SOMA + 2 X ** 2 - SQRT( NUM); ( ) DIA "SEGUNDA"; ( ) NUM "*ABC*"; ( ) X X + 1
9. Considerando: A = 3; B = 16, NOME = "ANA", PROFISSAO = "ADVOGADO", TESTE= F avaliar as expressões abaixo e dar sua resposta:
a. SOL A + 1 >= SQRT(B) ou NOME <> "ANA"; b. SOL não TESTE = V e (A + 5 = B) ou não PROFISSAO = "MEDICO"; c. SOL PROFISSAO = "MEDICO" ou TESTE = F; d. SOL A mod 2 + 25 div B; e. SOL A + B * 2 > 10 10. Informar o valor da variável R, em cada item, após a execução da seguinte sequência de operações:a) R 3,0 * 6;b) X 2,0;
Y 3,0;R X ** Y – X;
c) R 4;X 2;R R * X;
RESPOSTA a) b) c)
11. Informar o valor da variável R, em cada item, após a execução da seguinte sequência de operações:a) R 1 * 1,78 / 3;b) B 2;
A 40 – B ** 2; R int (3,1416) + A * 5;c) R 9 – 18;
R abs ( -6 + int(3,4)) – R;
18
QUALIDADES DE UM BOM ALGORITMO
1. Clareza – o algoritmo é uma ferramenta de entendimento e solução de um problema, deve portanto, ser o mais claro possível. O autor deve preocupar-se constantemente se o que está pensando está visível no que está escrevendo;
2. Impessoalidade - não usar macetes, regras pessoais e nomes que só tem sentido para o autor, muitas vezes quem vai examinar, depurar, corrigir, alterar o algoritmo não é seu próprio autor. Neste ponto os CPD’s bem organizados definem um conjunto de normas de codificação e de elaboração de algoritmos;
3. Simplicidade – o algoritmo deve ter por princípio a simplicidade, logo transformar algo complicado em soluções simples, parece ser a diferença entre programadores comuns e grandes programadores;
4. Não reinvenção da roda – fazer uso do conceito de biblioteca de algoritmos. O programador não deve esquecer de que um algoritmo novo custa caro para ser feito, e muito mais caro ainda para ser depurado, então, caso exista um pronto este deve ser utilizado;
5. Capricho – a principal função de um algoritmo é transmitir a solução de um problema para outra pessoa. Desta forma a letra clara, uso de endentação, nomes bem atribuídos, papel limpo e sem borrões deve ser de uso constante;
6. Documentação – nem sempre o Portugol é bastante claro, além do que ele informa o que é feito e não porque é feito. Assim deve-se lançar mão de comentários sempre que necessário. O símbolo de comentário em algoritmo é { }, isto é, tudo que estiver entre as chaves é um comentário.
19
BLOCOS
Um bloco é um conjunto completo de comandos para resolver um determinado problema. Graficamente falando um bloco sempre começa pela palavra INICIO e termina pela palavra FIM. Entre estes dois limites existem duas partes:
definição de variáveis – que serve para definir as variáveis que serão utilizadas no bloco; comandos – que define quais os comandos que fazem parte deste bloco.
FLUXOGRAMA PORTUGOL
INICIO<declaração das variáveis>;<comandos>;
FIM.
Exemplo: calcular a área de um retângulo
inicio A, B, AREA : real; AREA A * B; fim.
SEQUÊNCIA SIMPLES
Trata-se de um conjunto de comandos simples, que seguem um ao outro e que são executados na ordem em que aparecem. Exemplo:
A 10; B A + 5; X 1 + 2;
variáveis
comandos
fim
inicio
20
Cada comando simples é escrito em uma linha e sempre termina por um ponto e vírgula ( ; ), o que é considerado uma instrução sequencial. Dentro de uma sequência simples de comandos a entrada é sempre pelo primeiro comando e a saída sempre pelo último comando.
FLUXOGRAMA PORTUGOL
.....
< comando 1 >;
< comando 2 >;
........
< comando n >;
....
Exemplo: calcular a área de um triângulo:
inicio B, H, AREA : real; leia (B); {base} leia (H); {altura} AREA ( B * H ) /2; {calcula a área} imprima (AREA); fim.
COMANDOS DE ENTRADA E SAÍDA
A maioria dos algoritmos que escrevemos necessita receber dados externos, e em algum momento necessitará comunicar respostas, para tanto usamos os comandos de entrada e saída. Para resolver estes dois problemas existem os chamados comandos de entrada/saída (E/S).
Desprezando as complexidades inerentes a um processo de transferência de dados em um computador real, uma vez que cada linguagem trata os dispositivos de E/S de forma
comando 1
comando2
comando n
21
diferenciada e o algoritmo deve ser capaz de ser traduzido para qualquer linguagem de programação, os comandos que serão usados são dois: leia e imprima.
O comando LEIA significa uma entrada de dados, realizada através de um dispositivo externos de entrada de dados, para o algoritmo, isto é, o valor não é gerado por um comando ou expressão do algoritmo utilizado. O dispositivo de entrada utilizado, isto é, se os dados entrarão via teclado, mouse, leitura de disco ou linha telefônica, não irá interferir no algoritmo.
Da mesma forma, para a saída dos dados usaremos o comando IMPRIMA, e também não importa, à nível de algoritmo, para qual dispositivo externo de saída de dados os mesmos serão enviados: terminal de vídeo, impressora, plotter, gravado em disco ou linha telefônica. A saída de dados consiste na exibição do conteúdo de uma variável ou constante, do resultado de uma expressão ou de uma mensagem.
A sintaxe destes comandos é:Entrada de dados: leia (<identificador 1>, <identificador 2>, ..., <identificador n>) ;
Saída de dados: imprima (<identificador 1>, <identificador 2>, ..., <identificador n>);
{conteúdo do identificador} imprima (<expressão numérica>); {resultado da expressão numérica} imprima( “cadeia de caracteres”); {caracteres existentes entre os aspas}
Obs: - em geral, dados que serão lidos não precisam ser inicializados; - os valores a serem impressos devem ser inicializados e/ou calculados antes da impressão.
Exemplo: inicio VALOR1, VALOR2 : inteiro; leia (VALOR1); VALOR2 VALOR1 * 2; imprima (“o valor primeiro é “, VALOR1); imprima (“o valor segundo é”, VALOR2); imprima (“a soma dos dois é “, VALOR1 + VALOR2);fim.
22
FLUXOGRAMA PORTUGOL
LEIA (var 1, ..., var n);
IMPRIMA (var 1, ... , var n);
ou
IMPRIMA (“mensagem”, var );
EXERCÍCIOS
1. Fazer um algoritmo que calcule o volume de uma esfera em função do raio R. V = 4 /3 R**3
2. Criar algoritmos em Portugol para fazer as seguintes conversões: a) Ler uma temperatura dada na escala Celsius e imprimir a equivalente em Fahrenheit (F = 9/5 * C + 32) b) Ler uma quantidade de chuva em polegadas e imprimir a equivalente em milímetros (25,4 mm = 1 polegada) c) Ler um valor referente ao resultado de salto em altura, relatado em metros, e converter para pés e polegadas (1 pé = 12 polegadas e 1 metro = 39,37 polegadas) d) Ler um tempo para uma corrida de 100 metros e calcular seu tempo para 100 jardas, supor que o atleta corra a uma velocidade constante ( jarda = 0,9144 metros)
3. O custo ao consumidor de um carro novo é a soma do custo de fábrica com a percentagem do distribuidor e dos impostos (aplicados ao custo da fábrica). Supondo que a percentagem do distribuidor seja de 12% e os impostos de 45%, preparar um algoritmo portugol para ler o custo de fábrica do carro e imprimir o custo ao consumidor.
4. O cardápio de uma casa de hamburger é dado abaixo. Preparar um algoritmo portugol para ler a quantidade de cada item comprado e calcular a conta ao final.
Mona’s Burgers
Hamburger (R$ 2,50) Cheeseburger (R$ 3,30) Batata Frita (R$ 1,50) Refrigerante (R$ 0,60) Milkshake (R$ 1,70)
O algoritmo deve ter uma variável para cada item para ler a quantidade e multiplicar pelo preço do respectivo item, somando tudo ao final, incluindo, também, os 10% dos serviços.
5. Preparar um algoritmo portugol para ler o comprimento dos 3 lados de um triângulo (S1, S2 e S3) e calcular a área do triângulo de acordo com a fórmula.
leia var1, ..., var n
imprima var 1, ... var n
23
3
Area = T ( T - S1) ( T - S2) ( T - S3)
onde T = ( S1 + S2 + S3) / 2
6. Preparar um algoritmo que leia os valores referentes aos 2 catetos de um triângulo retângulo e calcular o valor de sua hipotenusa.
7. Preparar um algoritmo que leia o tempo e distância percorridos por um veículo e calcule sua velocidade média.
8. Preparar um algoritmo que leia as 4 notas bimestrais de um aluno e calcule sua média anual.
9. Preparar um algoritmo que leia o mês e ano de nascimento de um indivíduo e calcule sua idade em meses com base na data atual.
10. Preparar um algoritmo que leia a hora e minuto de início de uma aula e imprima a hora e minuto de término desta aula, sabendo que a aula é de 50 minutos.
11. Preparar um algoritmo que leia 5 valores e imprima a média aritmética entre eles.
12. Dado um número inteiro de 3 algarismos, inverter a ordem de seus algarismos. Os três algarismos do número dado são diferentes de zero.
13. Dado um número de 3 algarismos construir outro número de 4 algarismos de acordo com a seguinte regra:a) os 3 primeiros algarismo, contados da esquerda para a direita são iguais aos do número dado;b) o quarto algarismo é um dígito de controle calculado da seguinte forma: primeiro algarismo + segundo
algarismo * 3 + terceiro algarismo * 5; o dígito de controle é igual ao resto da divisão dessa soma por 7.
14. Dadas duas frações ordinárias a/b e c/d, determinar a sua soma e o seu produto.
15. Dado um número inteiro que representa um número binário de cinco dígitos, determinar o seu equivalente decimal.
16. Dados o primeiro termo e a razão de uma progressão aritmética, determinar a soma de seus primeiros cinco termos.
17. Dado um número inteiro de segundos determinar o seu valor equivalente em graus, minutos e segundos. Se a quantidade de segundos for insuficiente para dar o valor em graus, o valor em graus deve ser zero. A mesma observação continua válida em relação a minutos e segundos. Por exemplo: 3600 segundos = 1 grau, 0 minutos, 0 segundos; 3500 segundos = 0 graus, 58 minutos, 20 segundos.
18. Fazer um algoritmo que leia a hora e o minuto de início de uma aula e imprima a hora e o minuta de término desta aula, sabendo que a aula é de 50 minutos.
24
ALTERNATIVA SIMPLES
Existem oportunidades em que determinados comandos dentro de um algoritmo devem ser executados caso certas condições o permitirem, em outras condições nada se executa. Por exemplo: na solução de uma equação do segundo grau, no momento de extrair a raiz quadrada de Delta, só pode-se fazer caso Delta seja positivo. Se Delta for menor do que zero, a raiz não pode ser extraída, e convém executar outros comandos.
O comando Portugol que identifica uma ação condicional é o Se, que tem a seguinte sintaxe:
Se <condição> então <ação>;fimse;
A condição é uma expressão cujo resultado final é do tipo lógico (V ou F). A ação pode ser um comando simples ou uma sequência de comandos.
Semântica - se o resultado da condição que acompanha o SE for V, os comandos internos ao ENTÃO devem ser executados; caso contrário, se o resultado da condição que acompanha o SE for F, todos os comandos internos ao ENTÃO devem ser desprezados até encontrar o FIMSE correspondente.
Exemplo: se DELTA < 0 então imprima (“não é possível extrair a raíz”);fimse;
Para facilitar a compreensão e a visualização do início e do final de cada estrutura, utiliza-se o artifício de deslocá-las à direita, de forma que uma estrutura fique dentro da outra, também conhecida como endentação. Costuma-se endentar os comandos subordinados a uma condição SE, isto é, comandos internos ao ENTÃO. E a margem deve ser trazida ao que era antes do comando SE, apenas quando for escrita a palavra FIMSE correspondente.
25
FLUXOGRAMA PORTUGOL
SE <condição >
ENTÃO < comando 1>; < comando 2>; ..... <comando n>;
FIMSE;
Cada SE deve ter um FIMSE correspondente. Ao percorrer o fluxo de controle do algoritmo, encontrando-se um FIMSE este sempre refere-se ao último SE aberto.
ALTERNATIVA COMPOSTA
É uma extensão da alternativa simples, neste caso temos determinar o que fazer se a condição for verdadeira, e o que fazer se a condição for falsa. O formato deste comando é:
Sintaxe: Se <condição> então <ação 1>; senão <ação 2>; fimse;
Semântica: se a condição contida no comando SE for verdadeira são executados os comandos internos ao ENTÃO, e os comandos internos ao SENÃO são desprezados até encontrar o FIMSE correspondente;
caso contrário, se a condição contida no comando SE for falsa, os comandos internos ao ENTÃO são desprezados e os comandos internos ao SENÃO são executados até encontrar o FIMSE correspondente.
Neste caso a endentação também é importante, os comandos SE e FIMSE começam na margem corrente, os comandos internos ao ENTÃO e ao SENÃO ficam endentados.
comando 1
comando n
condição
V
F
26
Exemplo: DELTA 4 * A * C - B ** 2;se DELTA < 0 então imprima (“raízes imaginárias”); senão X DELTA ** 0.5;fimse;
FLUXOGRAMA PORTUGOL
SE <condição >
ENTÃO < comando 1>; < comando 2>; ..... <comando n>; SENÃO < comando 11>; < comando 22>; ..... < comando nn>;
FIMSE;
ANINHAMENTO
Os algoritmos podem ser formados por diversas estruturas, cada uma com uma função específica. Existem casos em que uma estrutura poderá estar dentro de outra, e a isto dá-se o nome de aninhamento. Nada impede que exista uma condição dentro de outra, e isto também poderá ocorrer com as próximas estruturas de comando.
Não existe um limite para o número de estruturas que podem ser colocadas dentro de uma outra estrutura qualquer, mas se o número for muito grande, a compreensão e a visualização serão prejudicadas. Para facilitar a compreensão e a visualização do início e do final de cada estrutura, utiliza-se o artifício da endentação.
Nos casos em que são necessárias muitas estruturas internas, a solução é a utilização do processo de modularização do algoritmo, assunto que será tratado mais para frente.
comando 1
comando n
condição
comando 11
comando nn
VF
27
Exemplo: SEM IDENTAÇÃO COM IDENTAÇÃO
Se A <> 0então B 0;se C <> 0então D 0;F 3;fimse;G 77;fimse;
Se A <> 0 então B 0; se C <> 0 então D 0; F 3; fimse; G 77;fimse;
Uma regra importante que deve ser sempre seguida, é a de que o início e o final da estrutura mais interna devem ser sempre dentro da estrutura imediata que a contém.
VÁLIDO INVÁLIDO
NEGAÇÃO DOS OPERADORES
Relembrando as operações lógicas, elas tem como operadores os valores Verdadeiro e Falso e as operações E, OU e NÃO. Usando tais operações em conjunto com os comandos SE simples ou composto, além dos operadores relacionais, pode-se criar trechos de algoritmos muito ricos.
Exemplos:a) Definir se um valor esta compreendido entre 10 e 35:se VALOR > 9 e VALOR < 3 então imprima (“Valor OK”); senão imprima (“Valor errado”);fimse;
1
2
4
3
12
4
3
28
b) Definir se um valor numérico representativo de um mês está corretose MÊS > 0 e MÊS < 13 então imprima (“mês correto”); senão imprima (“mês incorreto”);fimse;
c) Um certo código pode assumir os seguintes valores: 10, 15, 17, 18 e 30. Testar se ele está ou não corretose COD = 10 ou COD = 15 ou COD = 17 ou COD = 18 ou COD = 30 então imprima (“código correto”); senão imprima (“código incorreto’);fimse;
Muitas vezes é mais fácil organizar a saída correta da condição através do SENÃO e não através do ENTÃO, o que inverte o comando.
d) Um indicador estará errado se assumir os valores: 1, 4, 5, 6, 7 ou 9. Organizar o comando:
CONDIÇÃO PELO ENTÃO CONDIÇÃO PELO SENÃO - INVERTIDA
se IND = 1 ou IND = 4 ou IND =5 ou IND =6 ou IND =7 ou IND = 9 então imprima (“indicador ERRADO”); senão imprima (“indicador CORRETO”);fimse;
se IND <> 1 e IND <> 4 e IND <> 5 e IND <> 6 e IND <> 7 e IND <> 9 então imprima (“identificador CORRETO”): senão imprima (“identificador ERRADO”);fimse;
outra maneira de representar a mesma condição:
CONDIÇÃO PELO ENTÃO CONDIÇÃO PELO SENÃO - INVERTIDA
se IND = 1 ou ( IND > 3 e IND < 8 ) ou IND = 9 então imprima (“indicador ERRADO”); senão imprima (“indicador CORRETO”);fimse;
se IND <> 1 e ( IND <= 3 ou IND >= 8 ) e IND <> 9 então imprima (“identificador CORRETO”): senão imprima (“identificador ERRADO”);fimse;
29
Quando não se deseja inverter as saídas necessitamos negar as condições, abaixo segue um resumo da negação dos comandos:
RESUMO RELAÇÀO NEGAÇÃO= <> ou
<> ou => <= ou < >= ou
>= ou <<= ou >
E OUOU E
MULTIPLA ESCOLHA
Nos casos em que há múltiplas saídas para um determinado teste, pode-se fazer uso das estruturas de alternativa simples e composta devidamente encadeadas. Tal uso, conforme os professores italianos em 1966, sempre é suficiente para a solução de qualquer problema. Entretanto para simplificar a solução inúmeras linguagens tem o comando teste múltiplo. Seu formato em Portugol é:
Sintaxe: caso <expressão> valor1 : <comando1>; valor 2 :< comando2>; ... valor n : <comando n>; senão: <comando n+1>; fimcaso;
onde o comando do lado direito do dois pontos ( : ) pode ser um comando simples ou um conjunto de comandos.
Semântica: a expressão do CASO é avaliada, e deve gerar um resultado determinado; este resultado é comparado com os valores indicados colocados do lado esquerdo do dois pontos ( : ); quando um valor igual for encontrado, o comando colocado ao lado direito do dois pontos ( : ) será executado, retornando ao FIMCASO correspondente, sem executar mais nenhuma comparação, onde prossegue o fluxo normal do algoritmo; caso nenhum valor seja igual ao resultado obtido na expressão do CASO o comando existente do lado direito do dois pontos ( : ) do SENÃO será executado, retornando ao FIMCASO onde prossegue o fluxo normal do algoritmo.
Exemplo:
30
Resolver o seguinte problema usando o comando CASO. Numa organização, o número de dependentes limita a quantidade de dias que um funcionário pode faltar anualmente. Assim, empregados com menos de 3 dependentes podem faltar 5 dias quem tem 4, 5 ou 6 dependentes pode faltar 8 dias, quem tem mais de 6 dependentes pode faltar 11 dias Escrever um alg que leia o número de dependentes e imprima a quantidade de dias que podem ser fruídos anualmente para cada caso.
RESUMOBLOCO-Conjunto de descrição de variáveis e comandos para realizar uma determinada tarefa
INÍCIO definição de variáveis comandos FIM
SEQÜÊNCIA SIMPLES-Comandos simples seguidos -Começa no primeiro e termina no último-Separados por “;”
comando 1; comando 2; comando n;
ENTRADA Transfere dados externos para o algoritmo
LEIA (var1, … var n);
SAÍDA Transfere dados do algoritmo para o meio externo
IMPRIMA (var1, … var n);
ALTERNATIVA SIMPLES-Comandos executados somente se a condição for verdadeira.
SE < condição > ENTÃO comando 1; … comando n; FIMSE;
ALTERNATIVA COMPOSTA
- Existem dois caminhos; a condição determina qual deve ser seguido.
SE < condição > ENTÃO comando 1; … comando n; SENÃO comando 11, … comando nn, FIMSE;
31
EXERCÍCIOS
1. Considerando A, B e C variáveis numéricas, contendo os valores, 1, 4.5 e 8 respectivamente; NOME e COR variáveis literais contendo “Tania” e “Branco” e TESTE variável lógica contendo o valor V, determinar os resultados obtidos da avaliação das seguintes expressões lógicas: a. A = 1 e TESTE b. NOME = “PEDRO” ou COR <> “Branco” c. não TESTE ou B mod 2 = 0.5 d. C < 10 ou TESTE e COR = “preto” e. A**2 + sqrt(C) = 3 e (A + trunc(B + C) > 13 ou NOME = “Ana” f. TESTE e não TESTE
2. Determinar os resultados que estarão em cada uma das variáveis definidas nos algoritmos abaixo:
a. inicio NUM, D1, D2, D3, D4 : inteiro; NUM 1352; D4 NUM mod 10; D3 (NUM div 10) mod 10; D2 (NUM div 100) mod 10; D1 (NUM div 1000) mod 10; fim.
b. inicio QUALE: caracter [15]; NUM: inteiro; NUM 10: se NUM > 0 então QUALE “numero positivo”; senão se NUM < 0 então QUALE “numero negativo”; senão QUALE “zero”; fimse; fimse; fim. c. executar o algoritmo B trocando 10 por 0 e depois por -4
d. inicio A, B, C: logico; X, Y: real; V, L: inteiro; A F; B V; C F; X 1.5; Y 3.2; X X + 1; se C ou (( X + Y > 5) ou ( não A e B)) então L 0; senão L 1; fimse; fim.
32
3. O que está errado no algoritmo abaixo: inicio N, PAR, X : inteiro; leia (N); X N mod 2; se X=0 então PAR V; senão PAR F; fimse; fim.
4. Um código está correto se for maior que 100, ou igual a 50. Escrever um algoritmo portugol que teste este valor e some 1 no código se ele estiver errado.
5. Uma data vem acompanhada de um campo chamado DIASEM, cujo valor é 1-domingo,2-segunda,....Escrever um algoritmo portugol que verifique se o DIASEM é um dia útil - semana inglesa.
6. Escrever um algoritmo que teste 3 valores numéricos e devolva a informação “OK” se: (A deve ser maior do que 10 e menor do que 100) ou (B deve ser diferente de C e C deve ser maior do que 50)
7. Criar algoritmos para solucionar os itens abaixo:a) fazer um algoritmo portugol que leia um número e determine se o valor é par ou impar.
b) fazer um algoritmo portugol que leia um valor referente ao ano e verifique se ele é bissexto ou não.
8. Uma agência de casamento possuí um cadastro contendo os seguintes dados de pessoas inscritas:nome, sexo, cor de olhos, altura, cor de cabelo e ano de nascimento. a. um americano contatou a agência e pediu uma moça de até 25 anos com 1.60 de altura, loura ou ruiva de olhos azuis;b. uma alemã pretende jantar esta noite com um senhor de mais de 50 anos, com altura entre 1.75 e 1.80, moreno de olhos pretosCriar um algoritmo portugol que leia os dados das pessoas inscritas e imprima o nome das pessoas que atendem ao item a e b.
9. Dados 3 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. Propriedades - o comprimento de cada lado de um triângulo é menor do que a soma dos outros 2 lados Equilátero - 3 lados iguais Isósceles - 2 lados iguais Escaleno - 3 lados diferentes
10. Criar um algoritmo portugol que calcule a média final das notas de um aluno. O algoritmo deve ler: o nome do aluno, nota do 1o bimestre, nota do 2o bimestre, nota do 3o bimestre e nota do 4o bimestre.Calcular a média aritmética das notas e imprimir o nome do aluno e a mensagem: ‘aprovado’ - média de 100 até 70; ‘exame final’ - média abaixo de 70 até 40; ‘reprovado’ - média abaixo de 40.
11. Criar um algoritmo portugol que verifique se uma data está correta ou não - utilizar valores lógicos:
33
Mês - entre 1 e 12 Dia - 1 a 28 - mês 2 e ano não bissexto 1 a 29 - mês 2 e ano bissexto 1 a 30 - meses 4, 6, 9, 11 1 a 31 - meses restantes
12. O Depto de Meio Ambiente mantém 3 listas de indústrias conhecidas por serem altamente poluentes da atmosfera. Os resultados de várias medidas são combinados para formar o que é chamado de índice de poluição. Isto é controlado regularmente. Normalmente os valores caem entre 0.05 e 0.25. Se o valor atingir 0.30 as indústrias da lista A serão chamadas a suspender as operações até os valores retornarem ao intervalo normal. Se o índice atingir 0.40 as indústrias da lista B serão notificadas também. Se o índice exceder 0.50 indústrias de todas as 3 listas serão avisadas. Preparar um algoritmo portugol para ler o índice de poluição e indicar as notações apropriadas.
13. Criar um algoritmo portugol que leia o nome, sexo e idade de candidatos a seleção brasileira de voleibol. Caso o participante seja do sexo feminino com idade entre 7 e 10 anos imprimir o nome e a frase "seleção feminina juvenil", caso seja do sexo masculino com idade entre 8 e 12 anos imprimir o nome e a frase "seleção masculina juvenil".
14. Criar um algoritmo em portugol que leia o nome, idade e altura de moças pretendentes a manequim profissional e imprimir o nome da pretendente e a frase “aprovada”, caso ela tenha idade entre 15 e 20 anos inclusive, e tenha altura de 1.70 a 1.80 inclusive. Em qualquer outro caso, imprimir o nome e a frase "reprovada".
15. Criar um algoritmo portugol que leia o CÓDIGO DO PRODUTO, DESCRIÇÃO DO PRODUTO, QUANTIDADE EM ESTOQUE e QUANTIDADE MÍNIMA, caso a quantidade em estoque seja menor ou igual a quantidade mínima imprimir a descrição do produto e a mensagem “estoque baixo”; caso a quantidade em estoque seja maior do que a quantidade mínima imprimir o código do produto e a diferença entre o estoque e a quantidade mínima em estoque.
16. Criar um algoritmo em portugol que leia o NOME DO PRODUTO, QUANTIDADE EM ESTOQUE, PREÇO UNITÁRIO, caso o preço unitário seja menor ou igual a R$ 1,99 imprimir o nome do produto e o valor a ser acrescido ao preço unitário para chegar em R$ 1,99; caso o preço seja maior do que R$ 1,99 imprimir o nome do produto e a mensagem “preço maior”.
17. Escreva um algoritmo Portugol que leia a idade de um nadador e classifique-o:IDADE CLASSIFICAÇÃO 6 pré-mirim7 a 10 mirim11 a 14 infantil15 a 18 juvenil 19 adulto
imprimindo ao final a idade e sua classificação
18. Criar um algoritmo Portugol que leia a altura e o sexo de uma pessoa, calcule e imprima seu peso ideal. Utilizando as seguintes fórmulas:- para homens : 72,7 * h – 58- para mulheres : 62,1 * h – 44,7
19. Escreva um algoritmo em Portugol que leia 4 números e imprima o maior deles.
34
20. Exercícios de teste de mesa:
inicioa, b, x, y : real;leia (a, b);se a=b
então x 1,5; y 2,5;senão x -1,5; y - 2,5;
fimse;imprima (x, y);
fim.
inicioa, b, i, m : real;leia (m);se m <> 0
então i trunc (m/12); a m / 12; b round (m/12); se m mod 12 >= 6
então i i + 1; fimse; imprima (a, b, i);
fimse;fim.Quais valores serão impressos se forem lidos 30; 19; 27; 60 e 0?
inicioaux, l, m, n : real;leia (l, m, n);se l > m ou l > n
então se m < nentão aux l;
l m; m aux;
senão aux l; l n; n aux;
fimse;fimse;se m > n
então aux m; m n; n aux;
fimse;imprima (l, m, n);
fim.
inicio X, Y, Z : inteiro; X 2; Y 5; Z 3; se X < Y então X X + 2 + Y * 4; imprima ( X ); senão Y Y + 5; Z Z + Y; imprima ( Y, Z); fimse; imprima (Y, Z); fim.
inicio A, B, C : inteiro; A 4; B -5; C 3; se C < B então A A + 6 + B * 5; imprima ( A ); senão B B + 10; C C + B; imprima ( B, C); fimse; imprima (B, C); fim.
35
21. Em uma classe são feitos 5 exames (A, B, C, D e E). Fazer um algoritmo que leia as notas destes exames e imprima a classificação do aluno, sabendo que a média é 70. Classificação: A – passou em todos os exames;
B – passou em A, B e D, mas não em C ou E;C – passou em A e B, C ou D, mas não em E.
22. Uma Cia de pulverização utiliza avião para pulverizar lavouras. Os custos de pulverização dependem do tipo de praga e da área a ser contratada conforme a tabela:Tipo 1 – ervas daninhas R$ 50,00 por acre;Tipo 2 – gafanhotos R$ 100,00 por acre;Tipo 3 – broca R$ 150,00 por acre;Tipo 4 – todos acima R$ 250,00 por acre.Se a área a ser pulverizada for superior a 1000 acres, o fazendeiro tem um desconto de 5%. Em adição, qualquer fazendeiro cujo custo for maior do que R$ 750,00 tem um desconto de 10% sobre o valor que ultrapassar os R$ 750,00. Caso ambos os descontos se aplicam o da área é calculado antes. Fazer um algoritmo que leia: nome do fazendeiro, tipo de pulverização (1 a 4) e área a ser pulverizada; e imprima o nome do fazendeiro e o valor a ser pago.
23. Muitos times de esportes profissionais utilizam o computador para auxiliar na análise de seus jogadores. Suponha que um time de Hockey tenha um sistema deste tipo. Para cada jogador existem os seguintes dados: nome do jogador, idade, altura, peso, gols no último campeonato, presenças no último campeonato, penalidades em minutos no último campeonato, fator da confederação.Fazer um algoritmo que leia os dados do jogador e imprima sua avaliação utilizando a fórmula: (gols + presença + (penalidades /4) + (altura + peso)/5 – idade) * fator.
24. A Cia Pascoalina Ltda decidiu dar a seus funcionários uma gratificação de Páscoa. A gratificação é baseada em dois critérios: o número de horas extras trabalhadas e o número de horas que o empregado faltou ao trabalho. Para todos os funcionários coletou-se os dados: nome do funcionário, nº de horas extra e nº de horas de faltas. A empresa decidiu utilizar a seguinte fórmula para calcular o prêmio: subtrair dois terços das horas que ele faltou de suas horas extras, e distribuir o prêmio de acordo com a tabela:
RESULTADO DA FÓRMULA VALOR DO PRÊMIO> 40 horas R$ 500,00
> 30 mas <= 40 horas R$ 400,00> 20 mas <= 30 horas R$ 300,00> 10 mas <= 20 horas R$ 200,00
<= 10 horas R$ 100,00Fazer um algoritmo que leia os dados do funcionário e imprima seu nome e seu prêmio.
36
COMANDOS DE REPETIÇÃO
Parece lógico que um algoritmo deva ser criado para a execução de um único conjunto de valores fornecidos como entrada. Por exemplo, ao escrever o algoritmo de aprovação de alunos da disciplina de Lógica, precisa-se somente preocupar-se com um único aluno, pois a regra de um vale para todos. Não teria sentido descrever os mesmos procedimentos para todos os alunos da turma, pois isto seria interminável, além de deixar o algoritmo específico para um determinado número de alunos.Da mesma forma, ao escrever um programa de computador que calcule o salário de um empregado, deve-se imaginar apenas um funcionário e não os milhares que o computador ira processar.
A solução para este problema está no reapreoveitamento de instruções do algoritmo. Em outras palavras, uma vez escrito o caminho principal do algoritmo, todos os outros dados (alunos ou funcionários) irão passar pelo mesmo caminho. Os comandos existentes para este fim são os chamados comandos de repetição, entre eles podemos citar: ENQUANTO, REPITA e PARA.
ENQUANTO
Semântica - a condição contida no ENQUANTO é avaliada, se ela for falsa todos os comandos internos ao ENQUANTO serão desprezados até encontrar o FIMENQUANTO correspondente, caso contrário, se a condição contida no ENQUANTO for verdadeira, os comandos internos ao ENQUANTO serão executados até encontrar o FIMENQUANTO correspondente, neste momento existe um desvio para o próprio comando ENQUANTO. A condição contida no ENQUANTO é novamente avaliada e o processo reinicia.
Sintaxe: enquanto <condição> faça <comando 1>; <comando 2>; ..... <comando n>;
fimenquanto;
Exemplo:Calcular a soma dos número inteiros até 100.
inicio SOMA,NUM: inteiro; SOMA 0; NUM 0;
37
enquanto NUM <= 100 faça SOMA SOMA + NUM; NUM NUM + 1; fimenquanto; imprima (SOMA); fim.
Se a condição contida no ENQUANTO for uma “verdade eterna”, isto é, como 1 = 1, tem-se um laço infinito (looping), pois os comandos nunca deixarão de serem executados. Por outro lado, se a condição for sempre falsa (tautologia) então os comandos internos ao ENQUANTO nunca serão executados.
FLUXOGRAMA PORTUGOL
ENQUANTO <condição > FAÇA
< comando 1>; < comando 2>; ..... <comando n>;
FIMENQUANTO;comando 1
comando n
condição
F
V
38
REPITA
O comando REPITA, assim como o ENQUANTO, é uma outra forma de repetir partes de um algoritmo. A rigor, com uma única estrutura pode-se resolver todos os problemas, como demonstrado pelos professores italianos em 1966. Entretanto, criar um programa nem sempre é um exercício acadêmico. Nos meios acadêmicos o rigor cientifico é o mais importante, e para tanto não existe pressa. Na vida prática o rigor é importante na medida em que garante a qualidade do processo, porém não é um fim em si mesmo. Portanto, visando facilitar, acelerar e simplificar surgiram dois novos comandos de repetição: o REPITA e o PARA.
Sintaxe: repita <comando 1>; < comando 2>; ... < comando N>; até <condiçao>;
Semântica : os comandos internos ao REPITA são executados até encontrar a condição contida no ATÉ correspondente; a condição contida no ATÉ correspondente é testada e sendo falsa existe um desvio para o comando REPITA correspondente, e os comandos internos a ele são novamente executados reiniciando o processo; caso contrário, quando a condição contida no ATË for verdadeira o processo de repetição pára e prossegue o fluxo normal do algoritmo
Exemplo: Somar os 100 primeiros números inteiros positivos.
inicio NUM, SOMA: inteiro; NUM 1; SOMA 0; repita SOMA SOMA + NUM; NUM NUM + 1; ate NUM > 100; imprima (SOMA); fim.
39
FLUXOGRAMA PORTUGOL
REPITA
< comando 1>; < comando 2>; ..... <comando n>;
ATÉ <condição >;
UMA COMPARAÇÃO ENTRE OS COMANDOS ENQUANTO E REPITA
ENQUANTO REPITA1. os comandos internos ao enquanto podem nunca serem executados;
1. os comandos internos ao repita são executados pelo menos uma vez;
2. o laço do enquanto é executado quando a condição for verdadeira;
2. o laço do repita é realizado quando a condição for falsa;
3. a estrutura enquanto testa e faz. 3. a estrutura repita faz e testa.
Em geral tudo o que se fizer com um dos comandos, pode-se fazer com outro. A vantagem é que para determinadas situações um ou outro pode ser mais indicado, isto é, pode solucionar o problema com menos lógica adicional (overhead), tais como contadores, chaves, testes, inicializações, etc.
EXERCÍCIOS
1. Fazer um algoritmo que leia uma lista de números terminada pelo número 0 e mostre cada número lido (não imprimir o 0).
2. Faça um algoritmo que leia um número N, e a seguir solicite N números e mostre a soma dos N números.
comando 1
comando n
condição
F
V
40
3. Escreva um algoritmo que leia um número inteiro positivo N. Calcule e mostre o maior quadrado menor ou igual a N. Por exemplo, se N for igual a 38, o menor quadrado é 36 (quadrado de 6).
4. Escreva um algoritmo que leia um número N, calcule e mostre os N primeiros termos da sequência (1, 3, 6, 10, 15, ...)
5. Escreva um algoritmo que leia um número N em base 10 e imprima o número base 2 correspondente.
6. Faça um algoritmo que leia um número e, a seguir, leia uma lista de número até encontrar um igual ao primeiro número lido. Mostre todos os números lidos.
7. Escreva um algoritmo que leia um número N, some todos os números inteiros entre 1 e N e mostre o resultado obtido.
8. Faça um algoritmo que leia uma lista de números terminada pelo número 0 e mostre cada número lido. Ao final, o algoritmo deve mostrar a média aritmética de todos os números da lista.
9. Escreva um algoritmo que leia um número N, calcule seu fatorial e mostre o resultado obtido.
10. Escreva um algoritmo que leia um número N, calcule todos os números primos no intervalo entre 0 e N e mostre o resultado obtido.
11. Escreva um algoritmo que leia um número, calcule uma relação de seus divisores e mostre o resultado obtido.
12. Escreva um algoritmo que leia uma lista de números terminada pelo número 0 e que, para cada número lido, mostre o próprio número e uma relação de seus divisores.
13. Faça um algoritmo que leia dois valores (limite inferior e limite superior) e mostre todos os números pares entre os dois limites lidos.
14. Faça um algoritmo que leia três valores (N, limite inferior, limite superior) e mostre todos os números inteiros múltiplos de N entre os dois limites lidos.
15. Trocar os comandos enquanto por repita:
A 0; enqto ( A <> 3) faca A A +1; imprima (A); fimeqto;
Z 10; enqto Z > 0 faca Z Z -3; imprima (Z); fimenqto;
K 5; enqto K < 10 faca K K + 1.5; imprima (K): fimenqto;
16. Transforme repita em enquanto:
A 10; repita A A + 1; ate A >10;
GH 5; repita imprima (ABC); ate GH <> 5;
T 0; repita T T + 0.5; imprima ( T * 2); ate T > 10;
17. Quais valores serão impressos executando o algoritmo abaixo:
inicio A, Q, TERMO: real;
41
A 1; Q 3; TERMO A; repita imprima (TERMO); TERMO TERMOS * Q; até TERMO >= 2000; FIM.
18. Dado o algoritmo abaixo, que valores seriam impressos se fossem lidos os valores 30; 19; 27; 60 e 0.
Inicio A, B, I , M : inteiro; leia (M); se M <> 0 então I trunc (M/12); A M /12; B arred (M/12); se M mod 12 >= 6 então I I +1; fimse; imprima (A, B, I); fimse;FIM.
19. Dado o algoritmo abaixo, informar o valor impresso caso sejam lidos os valores 3; 6; 8; 1.
Inicio FAT, N, MULT : real; leia (N); FAT 1; MULT N; repita FAT FAT * MULT; MULT MULT - 1; até MULT < 1; imprima (FAT);FIM.
20. Fazer um algoritmo que leia dois valores (X e Y) e imprima XY, sem utilizar o operador de potência (**).
21. Calcular a soma dos 100 primeiros números pares.
22. Totalize um conjunto de valores lidos, sendo todos positivos. O fim dos dados será indicado por um número negativo que não deve ser somado.
23. Ler um conjunto de números inteiros, caso ele seja par deve ser somado, caso seja impar deve ser multiplicado. O conjunto termina quando for lido 0.
24. Criar um algoritmo portugol que leia: matrícula, nome, nota 1o bimestre, nota 2o bimestre, nota 3o bimestre e nota 4o bimestre. O algoritmo deve calcular a média aritmética final do aluno e imprimir o nome do aluno e a mensagem: “aprovado”- média entre 100 até 70 “exame final “- média abaixo de 70 até 40 “reprovado”- média abaixo de 40
42
25. Fazer um algoritmo para calcular e imprimir a soma dos cubos dos números pares compreendidos entre B e A . Suponha que os valores de B e A (B > A) sejam lidos no início do algoritmo.
26. Fazer um algoritmo que leia 100 números inteiros positivos, calcule e imprima os que são números perfeitos. Número perfeito é aquele cuja soma de seus divisores, exceto ele próprio, é igual ao número. Exemplo: 6 é perfeito porque 1 + 2 + 3 = 6.
27. Tem-se uma estrada ligando várias cidades. Cada cidade tem seu marco quilométrico. Fazer um algoritmo que:
a) leia vários pares de dados, contendo cada par os valores dos marcos quilométricos em ordem crescente, de duas cidades. O último par contém estes dois valores iguais;
b) calcule o tempo decorrido para percorrer a distância entre estas duas cidades, com as seguintes velocidades: 40, 60 e 80 km/h, sabendo-se que:T = D / V, onde T = tempo; D = distância e V = velocidade.
28. Executando o algoritmo abaixo, que valores serão impressos?
Inicio N, QUAD : inteiro; N 5; enquanto N > 1 faça QUAD N ** 2; se QUAD mod 2 = 0 então imprima (QUAD); senão imprima (N); fimse; N N - 1; fimenquanto;fim.
Os valores lidos são: CAPITAL = 50,00; TAXA = 0,10; X = 1inicio CAPITAL, MONTANTE, N, TAXA, RENDIMENTO, TRIMESTRE, X: real; leia (CAPITAL, TAXA, X); MONTANTE CAPITAL; TRIMESTRE 1; N 4 * X; enquanto TRIMESTRE <> N faça RENDIMENTO TAXA * MONTANTE; MONTANTE CAPITAL * (( 1 + TAXA) ** TRIMESTRE); Imprima ( RENDIMENTO, MONTANTE); TRIMESTRE TRIMESTRE + 1; fimenquanto;fim.
29. O depto pessoal de uma empresa solicitou o desenvolvimento de um programa de computador capaz de calcular o desconto devido para o INSS. Assim, escreva um algoritmo capaz de calcular este desconto: . inicialmente deve ser lido o valor do salário de referencia; . depois deve-se ler uma série de dados compostos de: Rg e salário bruto; . a série termina quando for lido Rg 0; . tabela de desconto: salário bruto % desconto até 10 SR 8 de 10,01 a 20 SR 9 acima de 20 SR 10 . imprimir para cada funcionário o RG, salário bruto e desconto.
30. Definir um algoritmo portugol que receba uma série de pares de números, e para cada par calcule a média aritmética, imprimindo o resultado. A série termina quando for lido o par 0,0.
31. Melancias custam R$ 4,50 cada, se compradas até 5 unidades inclusive. R$ 4,20 se compradas até 20 unidades inclusive e R$ 4,00 se compradas até 100 unidades. Além deste valor, deve ser dado um desconto de 10% no valor total da compra.Escrever um algoritmo portugol que receba o número de melancias compradas e devolva a quantidade de reais a pagar. O programa deve rodar até receber o número zero melancias, que indica fim.
32. Uma empresa decidiu fazer um levantamento em relação aos candidatos que se apresentaram para preenchimento de vagas no seu quadro de funcionários. Fazer um algoritmo portugol que:
43
leia um conjunto de dados contendo: . número de inscrição do candidato; . idade; . sexo (F/M); . experiência no serviço (S/N); . o último cartão contém o número de inscrição = 0.
calcule: . o número de candidatos femininos; . o número de candidatos masculinos; . idade média dos homens que já tem experiência no serviço; . porcentagem dos homens com mais de 45 anos entre total de homens; . número de mulheres que tem idade inferior a 35 anos e com experiência no serviço. imprima . o que foi calculado.
33. Defina um algoritmo capaz de somar os primeiros 50 números múltiplos de 4, começando no 4 ( 4, 8, 12, ..., 400). O algoritmo deve imprimir o resultado ao final.
34. Dada uma série indeterminada de números, escrever um algoritmo portugol que calcule e imprima: a. quantos números foram fornecidos; b. quantos eram maiores que 100; c. quantos eram pares; d. quantos eram positivos; e. qual o maior valor.A série termina quando for digitado o valor 0, utilizar o comando de repetição repita.
35. Numa fábrica trabalham homens e mulheres divididos em 3 classes: A - os que fazem até 30 peças por mês; B - os que fazem de 31 a 35 peças por mês; C - os que fazem mais de 35 peças por mês.
A classe A recebe salário mínimo. A classe B recebe salário mínimo e mais 3% do salário mínimo por peça acima das 30 iniciais. A classe C recebe salário mínimo e mais 5% do salário mínimo por peça acima das 30 iniciais.Fazer um algoritmo que: a. leia um conjunto de dados contendo cada um: número do operário, número de peças fabricadas no mês e sexo; b. calcule e imprima: . salário de cada operário; . total da folha mensal de pagamento; . número total de peças fabricadas no mês; . média das peças fabricadas pelos homens em cada classe; . média de pecas fabricadas pelas mulheres em cada classe; . número do operário ou operária de maior salário ( não existe empate).O último dado a ser lido terá número de operário = 0.
36. Foi feita uma pesquisa de audiência de canal de TV em várias casas de uma certa cidade, num determinado dia. Para cada casa visitada foi criado um conjunto de dados contendo: número do canal (4, 5, 7,12) e o número de pessoas que estavam assistindo naquela casa. Se a televisão estivesse desligada nada seria digitado. Fazer um algoritmo que: . leia um número indeterminado de dados, sendo que o final seria canal =0; . calcule e imprima a percentagem de audiência para cada emissora e o respectivo canal.
44
37. O governo das Ilhas Oba Oba instituiu um controle de preços e salários logo após sua eleição. O Primeiro Ministro recebeu de seus conselheiros econômicos uma previsão, baseada nas tendências atuais, de que os salários continuarão a aumentar anualmente de 5%, o custo de vida e de serviços de 10%, e os impostos de 15%. Seus conselheiros políticos informam que, se os impostos mais o custo de vida e de serviços consumirem mais do que 75% do salário anual para um número significativo de cidadãos, ele terá problemas nas próximas eleições e que, se isto atingir 80%, ele se verá realmente em apuros. O Primeiro Ministro tem coletados os seguintes dados: salário anual, os impostos e o custo de vida e serviços para uma amostra tomada de seus eleitores. Preparar um algoritmo para determinar o número e a percentagem dos cidadãos estudados que caem nas categorias de 75% e 80% já descritas. O número de pessoas da amostra é desconhecido. O número de entrevistados termina quando for lido o salário anual 0.
PARA
O próximo comando disponível para controlar “loops” atende pelo nome de PARA, também conhecido como estrutura de repetição finita. O comando PARA permite que várias instruções sejam executadas repetidamente um número predeterminado de vezes, mediante o uso de uma variável de controle que irá controlar o início e o final da repetição, servindo como acumulador.
Sintaxe: para <identificador> de <valor inicio> até <valor fnal> passo <incremento> faça <comando 1>; < comando 2>; ... < comando n>: fimpara;
onde o identificador é a variável de controle do laço.
Semântica:1. antes de começar o trecho incluído no PARA, o identificador de controle é inicializado pelo valor de inicio;2. se o valor do identificador de controle for menor ou igual ao valor final o trecho interno ao PARA é executado, caso contrário, se o valor do identificador de controle for maior do que o valor final o processo de repetição termina e o algoritmo prossegue seu curso no comando imediatamente após o FIMPARA correspondente;3. ao chegar ao FIMPARA correspondente o identificador de controle é incrementado do valor do incremento;4. há um desvio para a linha do comando PARA, e o processo reinicia a partir do passo 2 acima, com idênticas saídas. Observações sobre o comando:
- dentro dos comandos internos ao PARA o identificador de controle do laço não pode ser alterado;
45
- os valores de inicio, final e incremento podem ser números, variáveis ou expressões, as quais também não podem ser alteradas pelos comandos internos ao PARA; - quando o valor do incremento for 1, este pode ser omitido; - o valor do incremento pode ser negativo, neste caso o valor inicio do identificador de controle deve ser maior do que seu valor final.
FLUXOGRAMA PORTUGOL
PARA <variável> DE <inicio> ATÉ <final> PASSO <incremento> FAÇA
<comando 1>; < comando 2>; ... < comando n>;
FIMPARA;
Exemplo:
USANDO O COMANDO PARA USANDO O COMANDO ENQUANTO
para I de 1 até 10 passo 2 faça imprima (I);
fimpara;
I 1;enquanto I <= 10 faça imprima (I): I I + 2;fimenquanto;
para <var > de <inicio> até <fim> passo <valor>
comando 1
comando n
46
para I de 1 até 20 passo 1 faça SOMA SOMA + I;fimpara;
OUpara I de 1 até 20 faça SOMA SOMA + I:fimpara;
EXERCÍCIOS
1. Substituir Para por Enquanto:
para J de 1 até 20 faça X J /3; imprima (X):fimpara;
para SEMENTE de 0 até 100 passo 2 faça SEM1 SEMENTE * 2; SEM2 SEMENTE + 1.5 * ABC; MEDIA (SEM1 + SEM2) /2; imprima (MEDIA);fimpara;
2. Escreva um algoritmo portugol que imprima uma tabela de angulos, seus senos e cossenos, para todos os angulos de 0 a 90 graus.Exemplo: Angulo Seno Cosseno 0 0 1 1 ... ...
3.Definir um algoritmo que informe o valor de H, sendo N lido no início do algoritmo:
1 1 1 1 1H = ------- + -------- + --------- + --------- + .... + -------- 1 2 3 4 N
4. Fazer um algoritmo portugol que calcule e imprima a seguinte soma:
1 3 5 7 99 S = ----- + ----- + ----- + ----- + ... + ------ 1 2 3 4 50
5. Defina um algoritmo portugol que calcule e imprima o somatório expresso pela seguinte série:
500 480 460 20 S = ----- + ----- + ----- + ... + ------ 2 3 4 26
6. Fazer um algoritmo que escreva a soma dos 50 primeiros termos da seguinte série:
1000 997 994 991 -------- - ------- + ------- - ------- + ..... 1 2 3 4
47
7. Fazer um algoritmo para calcular e escrever a seguinte soma:
37 * 38 36 * 37 35 * 36 1 * 2 S = ---------- + --------- + ---------- + ..... + ------ 1 2 3 37
8. Fazer um algoritmo que calcule e imprima a seguinte soma:
21 22 23 250
S = ----- + ---- + ----- + ..... + ------ 50 49 48 1
9. Definir um algoritmo para calcular o valor da seguinte soma, sendo N lido no início do algoritmo: 1 1 1 1 1S = ------- + -------- + --------- + --------- + .... + -------- 1! 2! 3! 4! N!
10. Fazer um algoritmo que calcule o valor do co-seno de X através de 20 termos da série abaixo;
X2 X4 X 6 X8
cosen(x) = 1 - ------ + ------ - ------ + ------ - .... 2! 4! 6! 8!
11. O valor aproximado de pode ser calculado usando-se a série
1 1 1 1 1 S = ----- - ---- + ---- - ---- + ---- - .... 13 33 53 73 93
3
sendo = ( S * 32) . Fazer um algoritmo para calcular e imprimir o valor de com 51 termos.
48
RESUMO
REPETIÇÃO
A- ENQUANTO Enquanto a condição for VERDADEIRA, o conjunto de comandos é executado.
Se a condição é FALSA o conjunto NÃO é executado (“testa e faz”)
ENQUANTO < condição > FAÇA comando 1; comando n;
FIMENQUANTO;
B- REPITA -Os comandos internos a ele são executados ao menos uma vez, independente da condição(“faz e testa”)- O laço REPITA é realizado se a condição for FALSA
REPITA comando 1
… comando n
ATÉ <condição>;
C- PARAPressupõe a existência de uma variável que controla o início e o fim
Sempre pode ser convertido num ENQUANTO
PARA variável DE valor1ATÉ valor2 PASSO valor3 FAÇA comando 1 … comando nFIMPARA;
49
EXERCÍCIOS
1. Escreva um algoritmo Portugol que leia uma série de números inteiros e positivos e ao final do processamento imprima qual o maior deles. O processamento se encerra quando for lido qualquer número negativo que não deve ser considerado para efeito de comparação.
2. Existe um conjunto de muitos números inteiros e positivos, agrupados 3 a 3. Deve-se escrever um algoritmo portugol capaz de: a. ler os 3 números; b. identificar o maior deles, e rejeitá-lo; c. calcular a média entre os 2 números restantes; d. imprimir os 2 números e a média.A pesquisa termina quando o primeiro número dos 3 lidos for negativo.
3. Escrever um algoritmo portugol que receba conjuntos de 2 números inteiros e positivos, e para cada par calcule o MDC ( máximo divisor comum) de acordo com o Algoritmo Euclidiano para o MDC, cuja descrição é: 1. entram 2 valores N1 e N2; 2. N1 recebe o valor absoluto de N1 e N2 recebe o valor absoluto de N2; 3. calcula-se X que é N1 menos ( N2 vezes ( inteiro de N1/N2)); 4. se X for zero, o MDC é N2; 5. se não for, N1 recebe N2 e N2 recebe X, voltando-se ao passo 2.O programa termina quando for lido o par 0,0, que não deve ser processado.
4. A comissão organizadora de um rallye automobilístico decidiu apurar os resultados da competição através de um processo informatizado. Um dos algoritmos necessários para a classificação das equipes concorrentes é o que emite uma listagem geral do desempenho das equipes, atribuindo pontos segundo determinadas normas.O algoritmo deverá: . ler : a. um campo contendo os tempos padrão (em minutos decimais) para as 3 fases de competição; b. um conjunto de dados contendo cada um o número de inscrição da equipe e os tempos (em minutos decimais) que as mesmas despenderam ao cumprir as 3 diferentes etapas. O último dado do conjunto contém o número 9999 como número de inscrição. . calcular: a. os pontos de cada equipe em cada uma das etapas, seguindo o seguinte critério: seja o valor absoluto da diferença entre o tempo padrão e o tempo despendido pela equipe numa etapa: < 3 minutos - atribuir 100 pontos a etapa 3 <= <= 5 minutos - atribuir 80 pontos a etapa > 5 minutos - atribuir 80 – ( - 5) pontos a etapa b. o total de pontos de cada equipe nas 3 etapas; c. a equipe vencedora. . imprimir: para cada equipe, o número de inscrição, os pontos obtidos em cada etapa e o total de pontos obtidos na prova toda.
5. Deseja-se fazer uma pesquisa a respeito do consumo mensal de energia elétrica em uma determinada cidade. Para isso, deve ser lido os seguintes dados: - preço do Kwh consumido; - número do consumidor; - quantidade de Kwh consumidos durante o mês; - código do tipo de consumidor ( residencial, comercial, industrial).O processo termina quando o número do consumidor for 0.
50
Fazer um algoritmo que: 1. leia os dados acima; 2. calcule: a) para cada consumidor, o total a pagar; b) o maior consumo verificado; c) o menor consumo verificado; d) o total do consumo para cada um dos 3 tipos de consumidores; e) a média geral de consumo. 3. imprima: a) para cada consumidor: seu número e total a pagar; b) o que foi calculado nos itens b, c, e d acima.
6. Uma companhia de teatro planeja dar uma série de espetáculos. A direção calcula que, a R$ 5,00 o ingresso, serão vendidos 120 ingressos, e as despesas montarão em R$ 200,00 . A diminuição de R$ 0,50 no preço dos ingressos espera-se que haja um aumento de 26 ingressos vendidos.Fazer um algoritmo que imprima uma tabela de valores do lucro esperado em função do preço do ingresso, fazendo-se variar este preço de R$ 5,00 a R$ 1,00 de R$ 0,50 em R$ 0,50. Imprima, ainda, o lcuro máximo esperado, o preço e o número de ingressos correspondentes.
7. Tem-se uma estrada ligando várias cidades. Cada cidade tem seu marco quilométrico. Fazer um algoritmo que: - leia vários pares de dados, contendo cada par os valores dos marcos quilométricos em ordem crescente, de duas cidades. O último par contém estes dois valores iguais; - calcule os tempos decorridos para percorrer a distância entre estas duas cidades, com as seguintes velocidades: 20, 30, 40, 50, 60, 70 e 80 Km/hora, sabendo-se que: T = E / V, onde T = tempo; E = espaço; V = velocidade;
- imprima os marcos quilométricos, a velocidade e o tempo decorrido entre as duas cidades, apenas quando este tempo for superior a 2 horas.
8. Um comerciante deseja fazer o levantamento do lucro das mercadorias que ele comercializa. Para isto, deve ser lido os seguintes dados, para cada mercadoria: o nome, preço de compra e preço de venda.Fazer um algoritmo que: - determine e imprima quantas mercadorias proporcionam: lucro < 10% 10% <= lucro <= 20% lucro > 20% - determine e imprima o valor total de compra e venda de todas as mercadorias, assim como lucro total. - O processo termina quando for final de arquivo
9. Sejam dois pontos P(x1,y1) e Q(x2,y2) no plano. Fazer um algoritmo, utilizando a fórmula abaixo, que calcule e mostre a distância entre os dois pontos, repetidas vezes até que o usuário digite zeros para as coordenadas x1, x2, y1, y2.
D = sqrt( (x2 – x1)2 + (y2 – y1)2 )
10. Fazer um algoritmo, usando estrutura de repetição, que calcule e imprima a soma dos 50 primeiros termos da série:
480 475 470 465 S = ------ + ------ + ------ + ------ + .... 10 11 12 13
11. Fazer um algoritmo, usando estrutura de repetição, que calcule e imprima o somatório dos 20 primeiros termos:
51
61 59 57 S = - 63 + ------ - ------ + ------ - .... 1! 2! 3!
12. Fazer um algoritmo que calcule e imprima os primeiros 40 termos da série:
1! 2! 3! 4! 5! S = ---- - ---- + ---- - ---- + ---- - ... 1 3 7 15 31
13. Fazer um algoritmo que calcule e imprima o valor de S no seguinte somatório:
1 2 4 8 16384 S = ---- - ---- + ---- - ---- + ... + ---- 225 196 169 144 1
14. Fazer um algoritmo para tabular a função y = f(x) + g(x), para x = 1,2,3,4,..., 10, onde:
h(x) = x2 - 16f(x) = h(x), se h(x) >= 0 1, se h(x) <0
g(x) = x2 + 16, se f(x) = 0 0, se f(x) > 0
15. Fazer um algoritmo que tabule a seguinte função:
x2 + 3x + y2
f(x,y) = --------------------- xy - 5y - 3x + 15
para x = 1, 4, 9, 16, ..., 100;e y = 0, 1, 2,..., 5 para cada valor de x.
16. Exercícios de teste de mesa:
inicioa, n, seno, t : real;imprima ( “A seno A N”);a 0;repita
seno 0;t a;n 0;repita
seno seno + t;n n + 1;t - t * (a**2 / ( 2*n*(2*n+1)));
até abs(t) < 0,0001;imprima (a, seno, n);a a + 0,1;
até a > 1,6;fim.
iniciod, k, num, soma : real;leia (num);soma num + 1;k num div 2;d 2;repita
se num mod d = 0então soma soma + d;
fimse;d d + 1;
até d > k;imprima (soma);
fim. Qual valor será impresso quando for lido 30?
inicioa, q, termo : real;a 1;q 3;termo a;repita
imprima (termo);
52
termo termo * q;até termo >= 2000;
fim.
53
NOVOS TIPOS DE DADOS
Criar um algoritmo portugol que leia a nota de 10 alunos, calcule a média destas notas e imprima o número de alunos com nota abaixo da média, na média e acima da média. Para solucionar o exercício acima necessita-se criar 10 variáveis de nota, sendo uma para cada aluno, uma variável soma e uma variável média. Não é nada exagerado, porém caso necessite-se realizar a mesma tarefa acima para uma turma de 120 alunos, o processo fica complicado à nível de definição de variáveis.
No caso acima fica claro que os tipos de dados primitivos (inteiro, real, caracter e lógico) não é suficiente para representar toda e qualquer informação que possa surgir. Portanto, em muitas situações necessita-se “construir novos tipos de dados” a partir da composição de tipos primitivos.
Estes novos tipos tem um formato denominado Estrutura de Dados, que define como os tipos primitivos de dados estão organizados. Voltando à comparação da memória com um armário de gavetas, em um primeiro momento uma gaveta poderia comportar apenas uma informação e, segundo esse novo conceito, uma gaveta pode comportar um conjunto de informações primitivas, desde que devidamente organizadas. Estes novos tipos são estranhos ao algoritmo logo devem ser declarados em cada detalhe de sua estrutura.
Desta forma, assim como na Teoria dos Conjuntos, uma variável pode ser interpretada como um elemento e uma Estrutura de Dados como um conjunto. Quando uma determinada Estrutura de Dados for composta de variáveis com o mesmo tipo primitivo, temos um conjunto homogêneo de dados, porém, caso os elementos do conjunto não sejam do mesmo tipo primitivo de dados, então diz-se um conjunto heterogêneo de dados.
Os novos tipos de dados podem ser classificados da seguinte forma:tipos de dados homogêneos unidimensionais – vetores multi-dimensionais – matrizestipos de dados heterogêneos – registros.
A utilização deste tipo de estrutura de dados recebe diversos nomes como: variáveis indexadas, variáveis compostas, variáveis subscritas, arranjos, vetores, matrizes, tabelas em memória ou array. Neste contexto utilizaremos os nomes: vetores, matrizes e registros.
VETORES
Vetores são estruturas de dados homogêneas unidimensionais e sua utilização mais comum está vinculada à criação de tabelas. Este novo tipo de dado permite a criação de muitas variáveis de mesmo tipo de dado, que atenderão pelo mesmo nome, e que serão acessadas pelo deslocamento dentro do vetor (índices).
54
Para entender variáveis compostas unidimensionais, imagina-se um edifício com um número finito de andares, representando uma estrutura de dados, e seus andares, partições desta estrutura. Visto que os andares são uma segmentação direta do prédio, estes compõem então o que é chamado de estrutura unidimensional, isto é, uma só dimensão.
Criação de Vetores A declaração de vetores em algoritmos dá-se em duas etapas: 1º. devemos definir um novo tipo de dado que virá a se juntar aos já existentes (inteiro, real ,caracter e lógico), e que vigorará dentro deste bloco de programa. TIPO <nome do tipo> = VETOR [ lim inf : lim sup] <tipo de dado já existente>;Onde: lim inf – limite inferior do vetor; lim sup – limite superior do vetor.
2º. devemos informar ao algoritmo quais variáveis poderão conter este novo tipo de dado.
<identificador 1>, <identificador 2> , ... , <identificador n> : <nome do novo tipo>;
O número de elementos de um vetor será dado por Lim Sup – Lim Inf + 1. Isto significa que as posições do vetor são identificadas a partir de Lim Inf, com incrementos unitários até Lim Sup.
Exemplo:
1. Definir um vetor para conter as taxas inflacionárias dos 12 últimos meses:
TIPO VETINF = VETOR [ 1: 12] real; INFLACAO : VETINF;
2. Definir um vetor para conter os nomes de 60 alunos:
TIPO VET1 = VETOR [ 1: 60] caracter[50]; NOME : VET1;
Acesso aos Dados Ao imaginar um elevador de um prédio sabe-se que este é capaz de acessar qualquer um de seus andares. Entretanto, não basta saber que andar desejamos atingir se não soubermos o nome do edifício. Logo, necessita-se ter conhecimento do nome do edifício para então procurar o andar desejado.
O mesmo acontece com os vetores, visto que são compostos por diversas variáveis. Torna-se, então, necessário definir o nome do vetor que contém os dados desejados e depois especificar em qual posição a informação se encontra.
Após isolar um único elemento do vetor, pode-se manipula-lo através de qualquer operação de entrada, saída ou atribuição. O acesso aos dados pode ser feito das seguintes maneiras:
55
Genericamente - considera-se um único valor para todas as ocorrências do vetor: VETVEN 0;
Conjuntamente - utiliza-se um conjunto de mesmo número de elementos na referencia ao vetor:
Tipo V = VETOR [ 1 : 5] inteiro; VETVEN : V; VETVEN ( 1 2 3 4 5);
Individualmente - pressupõem a existência de um comando para cada elemento do vetor Tipo VET = VETOR [ 1: 5] inteiro; V1: VET; V1[1] 2; V1[2] 5; V1[3] 6; V1[4] 9; V1[5] 23;
Pode-se observar neste exemplo que o nome (V1) é um só, o que muda é a informação indicada dentro dos colchetes (1 até 5). Este valor é o índice que indica o endereço onde o elemento está armazenado. É necessário salientar a diferença entre o conteúdo do vetor ( 2, 5, 6, 9, e 23) e seu endereço, que é representado pelo índice.
Estas 3 maneiras de acesso ao vetor aplicam-se á inicialização do vetor, isto é, podem ser utilizados pelos comandos de atribuição ( ) e entrada de dados ( leia ). Também podemos utilizar esta sintaxe no caso de saída de dados, isto é, o comando imprima.
Exemplo: Definir um algoritmo que leia um vetor de 120 elementos inteiros e imprima o somatório de seus elementos e os elementos.
inicio Tipo VET = VETOR [1:120] inteiro; V : VET; I, SOMA: inteiro; leia (VET); SOMA 0; Para I de 1 ate 120 faca SOMA SOMA + V[I]; fimpara; imprima (SOMA); imprima (V): fim.
56
EXERCÍCIOS
1. Criar um vetor para conter a nota dos 120 alunos da turma.
2. Criar um vetor para conter o PNB do Brasil dos últimos 8 anos (87 a 94).
3. Criar um algoritmo que defina um vetor de 500 posições e calcule a soma dos conteúdos impares.
4. Criar um algoritmo que defina um vetor para conter 1050 nomes de candidatos e imprima os nomes das posições impares.
5. Criar um algoritmo que defina um vetor de 600 posições e imprima o produto dos valores das posições pares.
6. Escrever um algoritmo que defina um vetor com 12 elementos lógicos e inicialize os primeiros 6 com Verdadeiro e os outros 6 com Falso.
7. Escrever um algoritmo que leia de uma só vez um vetor de 100 elementos numéricos inteiros e imprima aqueles que forem maiores do que o valor 150.
8. Escreva um algoritmo que leia 200 valores (um a um), crie um vetor com tais valores e informe, a seguir, qual a média dos valores positivos e qual a média dos valores negativos.
9. Fazer um algoritmo, usando vetores, que leia 100 valores numéricos, e verifique se existem elementos compondo o vetor maiores que 4,0 e menores que 7,0 e quantos são.
10. Escrever um algoritmo que seja capaz de ler um conjunto de 10 valores ( de uma só vez), calcular a média, e imprimir: todos os valores do conjunto, a média e a diferença entre cada valor individual e a média calculada.
11. Construir um algoritmo Portugol para fazer a soma, posição a posição, de dois vetores de 10 elementos cada e armazenar o somatório de cada posição em um terceiro vetor, também de 10 elementos.
12. Ler 15 elementos de um vetor A e construir um vetor B de mesmo tipo, onde: “todo elemento de B deverá ser o quadrado do elemento de A correspondente”.
13. Ler dois vetores A com 20 elementos e B com 15 elementos. Construir um vetor C, sendo este a junção dos dois vetores anteriores. Desta forma C deverá ter capacidade para armazenar 35 elementos.
14. Ler dois vetores A e B com 20 elementos cada, construir um vetor C, onde cada elemento de C é a subtração do elemento correspondente de A com B.
15. Ler um vetor A com 15 elementos, construir um vetor B de mesmo tipo, sendo que cada elemento de B seja o fatorial do elemento correspondente em A.
57
16. Imagine um algoritmo capaz de ler uma entrada formada por até 60 caracteres, que correspondem a uma frase. Esta frase termina quando for encontrado um ponto. O algoritmo deve ser capaz de responder: a. qual o tamanho da frase; b. quantas palavras existem na frase; c. quantas vezes a dupla “ma” apareceu na frase.
17. Desejamos analisar o mapa de uso de um disquete. Como sabemos um disquete dupla-dupla de 5 1/4 tem 2 faces, 40 trilhas e 9 setores por trilha, o que dá um total de 720 setores. Definir um algoritmo que leia 20 vetores ( de uma só vez), que correspondem cada vetor a um disco diferente, e determine qual o percentual de setores livres em cada um dos discos, imprimindo tal resultado. O vetor é de inteiros, e se existe um valor zero, isto significa que o setor está livre. Qualquer valor diferente de zero, implica em que o setor não está livre.
18. Existe um livro de 370 páginas que foi recentemente impresso. A editora deseja fazer um estudo sobre possíveis erros de impressão. Desta forma, um especialista foi convidado a levantar quantos erros existem em cada página. Cada valor foi digitado na forma de um vetor, formando um conjunto de 370 valores. Definir um algoritmo portugol que leia este conjunto de dados, e responda:
a. qual a página que tem mais erros? (suponha que só existe uma e ela é única)b. quantas páginas tem zero erros?c. quantas páginas tem mais de 10 erros?
19. Uma grande empresa tem seus preços armazenados na forma de três vetores de 650 ocorrências cada. No primeiro, a quem chamaremos COD estão os códigos dos produtos - inteiros. No outro vetor, chamado PRE, estão os preços de cada produto, na mesma ordem de aparecimento de COD. No último, chamado QTD, estão a quantidade em estoque do produto, também na mesma ordem de COD. Escrever um algoritmo que leia os vetores contendo código, preço e quantidade e imprima o código e o valor em estoque de cada produto armazenado e o valor total do estoque da empresa. VALOR = PRE[I] * QTD [I]
20. Escreva um algoritmo Portugol que leia uma linha de até 80 caracteres e informe nesta linha, quantos caracteres diferentes foram usados. Exemplo, se a linha digitada foraaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, a resposta será 1; se a linha forabcdefghijklmnopqrstuvwxyz, a resposta será 26.
21. Em uma cidade do interior, sabe-se que, de janeiro a abril de 1993 (121 dias), não ocorreu temperatura inferior a 15C nem superior a 40C. As temperaturas verificadas em cada dia estão dispostas em uma unidade de entrada de dados. Fazer um algoritmo Portugol que calcule e imprima: . a menor temperatura ocorrida; . a maior temperatura ocorrida; . a temperatura média;
58
. o número de dias nos quais a temperatura foi inferior a temperatura média.
22. Criar um algoritmo Portugol que imprima todas as combinações de apostas possíveis para o jogo da Sena, onde: podemos escolher para cada aposta 6 números entre 01 e 50.
CLASSIFICAÇÃO DE VETORES
É a técnica utilizada para ordenar o conteúdo de um vetor em ordem crescente ou decrescente, numérica ou alfabética. Existem diversos algoritmos prontos e comprovados para realizar tal tarefa, serão apresentados três: método bolha, seleção simples e inserção.
Os métodos de ordenação apresentados podem ser utilizados para ordenar vetores numéricos ou alfabéticos. Uma vez que cada letra possuí um valor diferente da outra. A letra “A” tem valor menor do que a letra “B”, e assim por diante. Se a letra “A” for comparada com a letra “a” também terão valores diferentes. Cada caracter (numérico, alfabético ou caracter especial) é guardado dentro da memória de um computador segundo o valor de um código. Este código recebe o nome de ASCII ( American Standard Code for Information Interchange – Código Americano Padrão para Troca de Informações). E é com base nesta tabela que o processo de ordenação trabalha, pois cada caracter tem um peso, um valor previamente determinado, segundo este padrão.
MÉTODO BOLHA
Semântica: uma vez comparados 2 valores adjacentes no vetor, se eles estiverem em ordem são matidos em seus lugares, e se não estiverem são invertidos. A execução sucessiva deste processo faz com que os menores valores comecem a subir aos poucos ( ordem ascendente) e consequentemente os maiores começam a descer, daí a analogia com uma bolha de sabão.
Sintaxe: inicio {método bolha} tipo VET = VETOR [ 1:5 ] inteiro; V: VET; I, AUX, LIM : inteiro; LIM 5; {tamanho do vetor} leia (V); enquanto LIM 2 faça I 2; {posiciona no segundo elemento do vetor} enquanto I LIM faça se V[I] < V[I-1] {compara o elemento anterior com o elemento posterior do vetor} então AUX V[I-1]; {troca os elementos} V[I-1] V [I]; V[I] AUX;
59
fimse; I I +1; fimenquanto; LIM LIM -1; fimenquanto; imprima (V); fim.
Demonstrar ordem crescente e decrescente através de teste de mesa.
Exercício: escrever o algoritmo acima utilizando o comando Para.
MÉTODO SELEÇÃO SIMPLES
Semântica: pesquisa-se no vetor qual o maior (menor) valor, selecionando-o. Deve-se colocá-lo no fim (inicio) e refazer o processo desconsiderando o elemento que foi alterado por último.
Sintaxe: inicio {seleção simples} tipo VET = Vetor [1:5] inteiro; V:VET; LIM, INDCUR, I, J: inteiro; CORR: inteiro; LIM 5; {tamanho do vetor} I 1; {posiciona no primeiro elemento do vetor} enquanto I < LIM faça CORR V[I]; INDCUR I; J I + 1; enquanto J LIM faça {pesquisa o menor valor} se V[J] < CORR então CORR V[J]; INDCUR J; fimse; J J + 1; fimenquanto; AUX V[I]; {troca o menor valor pela primeira posição do vetor} V[I] V[INDCUR]; V[INDCUR] AUX; I I + 1; {posiciona para comparar a próxima posição do vetor} fimenquanto; fim. Demonstrar ordem crescente e decrescente através do teste de mesa.
Exercício: escrever o algoritmo acima utilizando o comando Para.
60
MÉTODO DE INSERÇÃO
Semântica: o ciclo inicia no segundo elemento, o elemento é retirado do conjunto de dados, fazendo uso de uma posição auxiliar do vetor, e inserido em seu lugar definitivo, através da pesquisa de sua localização correta e do deslocamento dos outros elementos do conjunto.
Sintaxe: inicio {método de inserção} tipo VET = Vetor [0:5] inteiro; {posição 0 do vetor é a posição auxiliar} V:VET; LIM, I, J: inteiro; LIM 5; {tamanho do vetor} para I de 2 até LIM faça V[0] V[I]; {retira o elemento do conjunto de dados} J I - 1; enquanto V[J] < V[0] faça {pesquisa a localização correta deslocando os outros elementos} V[J+1] < V[J]; J J - 1; fimenquanto; V[J + 1] V[0]; {insere o elemento retirado na posição correta} fimpara; fim. Demonstrar ordem crescente e decrescente através do teste de mesa.
PESQUISA EM VETORES
Quando se trabalha com vetores, estes poderão gerar grandes tabelas, onde ficaria difícil a localização de um determinado elemento de forma rápida, mesmo que o vetor esteja classificado. Para solucionar este tipo de problema pode-se fazer uso de pesquisas em matrizes através de programas específicos. Serão apresentados dois métodos para efetuar pesquisa em vetores: método sequêncial e método binário.
MÉTODO DE PESQUISA SEQUÊNCIAL
Semântica: este método consiste em efetuar a busca da informação desejada a partir do primeiro elemento sequencialmente até o último. Localizando a informação no caminho, a mesma é apresentada. Este método de pesquisa é lento, porém eficiente nos casos em que um vetor encontra-se com seus elementos desordenados.
Sintaxe:inicio tipo VET = vetor [1:100] inteiro; V : VET;
61
CHAVE, I, OK : inteiro; leia (V); leia (CHAVE); {valor a ser pesquisado} OK 0; {flag determinando que o valor não foi encontrado} I 1; enquanto I 100 e OK = 0 faça
se V[I] = CHAVE então OK 1; {flag determinado que o valor foi encontrado}fimse;I I + 1;
fimenquanto; se OK = 1
então imprima (“chave encontrada”);senão imprima (“chave não encontrada”);
fimse;fim.
MÉTODO DE PESQUISA BINÁRIA
Semântica: o método é, em média, mais rápido do que o anterior porém, exige que o vetor esteja previamente classificado. Este método divide a tabela em duas partes e procura saber se a informação desejada está acima ou abaixo da linha de divisão. Se estiver acima, por exemplo, toda a metade abaixo é desprezada. Em seguida, se a informação não foi encontrada, é novamente dividida em duas partes, e pergunta se aquela informação está acima ou abaixo e assim irá sendo executada até encontrar ou não a informação pesquisada.
Pelo fato de ir dividindo sempre em duas partes o volume de dados é que o método recebe a denominação de pesquisa binária.
Sintaxe:inicio tipo VET = vetor [1:100] inteiro; V : VET; CHAVE, INIC, METADE, FINAL : inteiro; leia (V); leia (CHAVE); {valor a ser pesquisado} INIC 1; { indica inicio do vetor} FINAL 100; {indica final do vetor} repita
METADE int (INIC + FINAL) / 2; {indica posição da divisão do vetor}
se CHAVE < V[METADE] então FINAL METADE - 1; {pega a primeira parte do vetor} senão INIC METADE + 1; {pega a segunda parte do vetor}fimse;
até V[METADE] = CHAVE ou INIC > FINAL;
62
se V[METADE] = CHAVEentão imprima (“chave encontrada”);senão imprima (“chave não encontrada”);
fimse;fim.
EXERCÍCIOS
1. Ler 8 elementos em um vetor A . Construir um vetor B de mesma dimensão com os elementos do vetor A multiplicados por 5. Apresentar o vetor B na ordem crescente.
2. Ler um vetor A com 15 elementos. Construir um vetor B de mesmo tipo, sendo que cada elemento de B seja o fatorial do elemento correspondente do vetor A . Apresentar o vetor B ordenado de forma decrescente. Montar uma rotina de pesquisa binária em B para encontrar os valores de A.
3. Ler dois vetores sendo A com 20 elementos e B com 30 elementos. Construir um vetor C, sendo este a junção dos outros dois vetores. Desta forma, C deverá ter capacidade de armazenar 50 elementos. Apresentar os elementos de C em ordem decrescente. Mostrar uma rotina de pesquisa sequêcial em C para encontrar os elementos de A.
4. Criar um algoritmo portugol que calcule o salário mensal dos vendedores de uma concessionária de carros importados. O salário fixo de cada vendedor é de R$ 500,00, a comissão é de 7,5% sobre o valor vendido no mês. Para tanto existe um vetor contendo os nomes dos vendedores e um vetor contendo o valor vendido pelo vendedor no mês, a relação é feita pelo índice dos vetores. O algoritmo deve criar um terceiro vetor contendo o valor do salário mensal de cada vendedor e imprimir ao final o nome do vendedor que teve o maior salário e a média salarial do mês.
5. Utilizando o exercício acima, classifique os três vetores com base no vetor de salário mensal e imprima qual o nome do vendedor de maior venda e o de menor venda.
MATRIZ
Pelas mesmas razões que foi criado o conceito de vetor, necessita-se tratar de outro tipo de organização de dados: as matrizes. As estruturas de dados vetores são variáveis indexadas com apenas uma dimensão, isto é, uma coluna e várias linhas, a partir de agora serão apresentadas tabelas com mais colunas, sendo assim, haverão variáveis no sentido horizontal e vertical. As mais comum são as matrizes de duas dimensões por se relacionar diretamente com a utilização de tabelas. Matrizes com mais de duas dimensões são utilizadas com menos frequência, mas poderão ocorrer momentos em que se necessite trabalhar com um número maior de dimensões. As linguagens computacionais são privilegiadas neste aspecto, o APL permite até 256 dimensões em algumas aplicações e até 64 em outras.
No caso de matriz bidimensional necessita-se de 2 índices para referenciar um determinado elemento: linha e coluna. Para uma matriz tridimensional usa-se 3 índices: plano, linha e
63
coluna. Da mesma forma que a manipulação de um vetor necessita de uma instrução de looping (enquanto, repita ou para), no caso de matrizes deverá ser utilizado o número de loopings relativos ao número de dimensões da matriz. Sendo assim, uma matriz de duas dimensões deverá ser controlada por dois loopings, uma de três dimensões fará uso de 3 loopings e assim por diante.
Para definir uma matriz passa-se por duas etapas, como nos vetores:
1. definição do tipo de dado: Tipo <nome do tipo> = Matriz [li1:ls1,li2:ls2,...,lsN:liN] <tipo de dados já existente>;Onde: li1, li2, liN – limite inferior da primeira, da segunda e da eNésima dimensão respectivamente; ls1, ls2, lsN – limite superior da primeira, da segunda e da eNésima dimensão respectivamente.
2. definição das variáveis que poderão conter este novo tipo de dado:
<identificador 1>, <identificador 2>,... <identificador n> : <nome do novo tipo>;
Exemplo:
1. Criar uma matriz 8 x 12 devidamente zerada.
inicio tipo M = matriz [1:8, 1:12] inteiro; MAT:M; I,J: inteiro; para I de 1 ate 8 faca para J de 1 ate 12 faca MAT[I,J] 0; fimpara; fimpara; imprima (MAT); fim.
2. Criar uma matriz de 3 dimensões 8 x 12 x 5 e ler valores para ela.
inicio tipo M1 = matriz [1:8,1:12, 1:5] real; MAT1:M1; I, J, K: inteiro para I de 1 ate 8 faça para J de 1 ate 12 faça
para K de 1 até 5 faça leia (MAT1[I, J,K]); fimpara;
64
fimpara; fimpara; fim.
EXERCÍCIOS
1. Definir um algoritmo portugol que leia os elementos de uma matriz 14 x 30 um a um, preenchendo a matriz a seguir.
2. Dada uma matriz 7 x 13 devidamente preenchida, o algoritmo deve encontrar sua matriz transposta.
3. Definir um algoritmo que some duas matrizes A e B, de 7 linhas e 8 colunas cada uma, gerando uma matriz C, também 7 x 8, onde cada elemento de C é a soma dos 2 elementos correspondentes em A e B.
4. Definir algoritmo portugol onde dada uma matriz M1 de 6 x 9, devemos totalizá-la na vertical gerando um vetor de 9 elementos. Imprimir este vetor e a seguir, encontrar e imprimir a média destes 9 valores.
5. Ler dois vetores A e B, cada um com 7 elementos e construir uma matriz C de mesma dimensão onde a primeira coluna deverá ser formada pelos elementos de A e a segunda coluna pelos elementos de B.
6. Ler um vetor A de 10 elementos e construir uma matriz C de duas dimensões com 3 colunas, onde a primeira coluna é formada pelos elementos de A somados com o valor 5, a segunda coluna é formada pelo valor de cálculo de fatorial de cada elemento correspondente no vetor A, e a terceira coluna deverá ser formada pelos quadrados dos elementos correspondentes de A .
7. Definir algoritmo portugol capaz de ler uma matriz quadrada de ordem 23 e totalizar os elementos colocados abaixo da diagonal principal (exclusive esta), imprimindo o total ao final.
8. Defina um algoritmo portugol capaz de ler 2 matrizes de dimensões 4 x 9 e 9 x 7. Após lidas, as matrizes devem ser multiplicadas matricialmente gerando uma saída de dimensões 4 x 7. A matriz resultado deve ser impressa ao final. Lembre-se de que existe uma lei matemática que rege a multiplicação de matrizes. Esta lei estabelece que uma multiplicação entre matrizes poderá ocorrer quando o número de colunas da primeira matriz é igual ao número de linhas da segunda matriz, e que o valor resultante da terceira matriz é o somatório da multiplicação de cada elemento da coluna da primeira matriz com cada elemento da linha da segunda matriz.
9. Definir algoritmo portugol que leia duas matrizes (A e B) de dimensões 7 x 13 e gere uma terceira matriz, onde cada elemento é o maior entre os elementos correspondentes em A e B.
65
10. Escrever um algoritmo que leia uma matriz de 23 linhas por 10 colunas. Esta matriz representa a população dos 10 maiores municípios de cada estado brasileiro. Em cada linha, as colunas estão em ordem decrescente , com exceção da primeira coluna, que sempre representa a capital. O algoritmo deve imprimir: qual o número do estado de capital mais populosa; qual a média das populações das capitais do Brasil; quais os números dos estados e dos municípios que tem população maior que a capital.
11. Definir um algoritmo que trabalhe com uma matriz de 129 linhas por 5 colunas, onde cada linha contém os dados de um aluno da escola e cada coluna: coluna 1 - número do aluno, coluna 2 - nota do aluno no 1o. bimestre, coluna 3 - nota do aluno no 2o. bimestre, coluna 4 - nota do aluno no 3o. bimestre, coluna 5 - nota do aluno no 4o. bimestre. Após ler o conjunto de dados o algoritmo deve imprimir:
qual a média anual de cada aluno; qual a média da turma em cada bimestre; número do aluno e em qual bimestre ocorreu sua maior nota; qual o bimestre em que ocorreu mais 0.
12. Fazer um algoritmo para corrigir provas de múltipla escolha. Cada prova tem 10 questões, cada questão valendo um ponto. O primeiro conjunto de dados a ser lido será o gabarito para a correção da prova. Os outros dados serão os números dos alunos e suas respectivas respostas e o último número, do aluno fictício, será 9999.O algoritmo deve calcular e imprimir:a) para cada aluno, o seu número e sua nota;b) a porcentagem de aprovação, sabendo-se que a nota mínima de aprovação é 6;c) a nota que teve maior frequência absoluta, ou seja, a nota que apareceu maior número de vezes (supondo a inexistência de empates).
13. Dado um tabuleiro de xadrez TAB onde, para facilitar a indicação das pedras, vamos convencionar:
1 - peão 2 - cavalos 3 - torres 4 - bispos 5 - reis 6 - rainhas 0 - ausência de pedra
Ler os dados e contar a quantidade de cada tipo de peça no tabuleiro em um certo momento do jogo. Tamanho do tabuleiro 8 x 8. 14. Um biblioteca possuí 8 departamentos. Cada departamento contém 40 estantes capazes de conter, cada uma, 150 livros. Supondo que cada livro-padrão tenha 200 páginas de 35 linhas por 60 caracteres, declarar uma variável composta capaz de conter todos os caracteres presentes nos livros da biblioteca.
15. O Museu de Carros Antigos de Curitiba está conduzindo um levantamento dos carros antigos do Estado. Para cada carro, deve ser lida os seguintes dados: código do fabricante ( 0 a 30); ano do carro ( de 1900 a 1950); condições do carro ( 1 a 4). Para permitir a execução de várias análises nos dados, estes são armazenados em um conjunto
66
tridimensional. O valor armazenado é o número de carros encontrados com aquelas características.O algoritmo deve: criar esta estrutura e fazer a leitura dos dados para formar o conjunto de informações; calcular e imprimir:
o número de carros feitos em 1910 cujas condições são classificadas como boas ou excelentes - código 4;
o fabricante mais popular; identificar o fabricante cujos carros parecem estar em melhores condições - código
4.
16. Um grupo de 100 pessoas respondeu a um questionário composto de 10 perguntas. Cada pergunta contém somente uma entre três respostas: Sim, Não e vazio.Criar um algoritmo Portugol que leia um conjunto de dados contendo as respostas de cada pessoa para as 10 perguntas e armazene em uma matriz 100 x 10. O algoritmo deve imprimir ao final:
quantas respostas foram vazio; qual a pergunta com mais respostas Não - utilizar um vetor ; quantos Sim ocorreram na pergunta 7.
REGISTROS
Para a definição de estruturas complexas de dados, o Portugol oferece a ferramenta chamada registro, que são considerados tipos de dados heterogêneos por permitirem armazenar vários dados de tipos diferentes em uma mesma estrutura. Trata-se de um aglomerado de dados que pode ser acessado no todo, ou a cada um de seus elementos individualmente. Como cada elemento individual pode ser tratado separadamente e possuí tipo de dado especifico, leva o nome de campo. Logo, um registro pode ser considerado um conjunto de dados logicamente relacionados, mas de tipos de dados diferentes. .
Os tipos registros devem ser declarados antes das variáveis, pois poderá ocorrer a necessidade de se declarar uma variável com o tipo registro anteriormente atribuído. Para se declarar um tipo registro em Portugol o procedimento é semelhante ao de vetores e matrizes:
1. definição do tipo de dado: Tipo <nome do tipo> = REGISTRO
<campo 1>, <campo 11>, ... ,<campo 1n> : <tipo de dado já existente>; <campo 2> : <tipo de dado já existente>;
.....<campo n> : <tipo de dado já existente>;fimregistro;
Onde: campo são identificadores de variáveis.
67
2. definição das variáveis que poderão conter este novo tipo de dado:
<identificador 1>, <identificador 2>,... <identificador n> : <nome do novo tipo>;
Quando necessário, é possível definir um campo de um registro como tendo um conteúdo vetor ou matriz. Outro conceito interessante é a definição de um vetor com conteúdo um registro, esta estrutura é bastante útil para a definição de organização de dados.
ACESSO AOS DADOS
Para fazer acesso a um campo contido em um registro precisa-se indicar todo o caminho
necessário para encontrar a informação, separando-os por um ponto ( . ):
<nome do registro> . < nome do campo>
Desta forma pode-se atribuir um valor a um campo do registro, imprimir tal valor e utilizar o valor em expressões.
Exemplo: declarar um registro para armazenar um cadastro de pessoal
Tipo REG1 = registro NOME : caracter [40]; END : ENDEREÇO;
DTNASC : DATA; CPF, RG : inteiro; SAL : V; fimREG1; Tipo ENDEREÇO = registro RUA: caracter[20];
NUM : inteiro;CIDADE : caracter [15];ESTADO : caracter [2];CEP : inteiro;
fimENDEREÇO; Tipo DATA = registro D, M, A : inteiro;
fimDATA; Tipo V = vetor [0:11] real;
CAD : REG1;
leia (CAD); {acesso ao registro com todos os seus campos} se CAD.DTNASC.D = 29 e CAD.DTNASC.M = 10
então imprima (CAD.END); {todos os campos do registro ENDEREÇO} fimse;
68
para I de 0 até 11 façaimprima ( CAD.SAL[I]); {salário dos 12 últimos meses}
fimpara;
EXERCÍCIO
1. Declarar um registro com os dados: nome, data de nascimento (dia, mês e ano), tem dependentes (S/N), sexo ,cpf, endereço (rua, número, cep, cidade, estado).
2. Declarar um registro com os dados: nome, cpf, identidade, horas trabalhadas no ano (mês a mês), salário, fgts.
3. Declarar um registro com os dados: código do material, nome do material, número de peças em estoque, preço unitário.
4. Uma escola cadastrou as notas bimestrais de seus alunos em registros no formato:matrícula : inteiro;nome : caracter[40];nota do trabalho 1, nota do trabalho 2 , nota da prova : real;
Fazer um algoritmo que leia os registros acima até que seja lida matrícula = 0 e calcule a média de cada aluno, pela fórmula:
media = (( trabalho 1 * 2) + trabalho 2 + (prova * 7)) / 10Ao final deve ser impresso: o nome do aluno, sua média e a mensagem:
“Parabéns” se media for maior ou igual a 70 e “Precisamos estuda mais” se média for abaixo de 70.
5. Um universidade realizará seu concurso vestibular em duas 3 unidades, a instituição deseja saber qual unidade está mais próxima da residência do candidato. Para tanto cada candidato preencheu um registro no formato:
matrícula: inteiro;distância para unidade 1, distância para unidade 2, distância para unidade 3 : real;
O algoritmo deve gerar, para cada candidato, outro registro no formato:matrícula: inteiro;número da unidade mais próxima : inteiro;distância desta unidade : real;
Os dados terminam quando for lida matrícula = 0.
6. Uma organização tem um conjunto de registros de vendas de um ano. Tais registros tem o formato: REG dia, mês : inteiro; valor : real;Criar um algoritmo portugol capaz de ler os dados e imprimir os totais mensais de venda. O processamento termina quando for lido um dia igual a 0. Utilizar um vetor de 12 posições indexado pelo campo mês do registro.
69
19. Uma companhia aérea possui 6 tipos de aviões: 747, 737-200, 737-300, 727, A300 e Bandeirantes. Cada viagem realizada por cada avião gera um registro no formato:
tipo do avião : caracter [11];número de passageiros : inteiro;distância percorrida : real;
Fazer um algoritmo que leia tais registros até que seja lido tipo do avião igual a branco. O algoritmo deve totalizar por tipo de avião o número de passageiros e total da distância percorrida no período. Ao final deve ser impresso um relatório informando a produtividade de cada tipo de avião, isto é, número total de passageiros divido pela distância total.
20. Uma seguradora possui um cadastro de seus segurados contendo registros com os campos:
matrícula : inteiro;nome : caracter[40];data de nascimento : dia, mês e ano;sexo : caracter[1];
Fazer um algoritmo que leia tais registros até que seja lido uma matrícula = 0, este algoritmo deve conter uma função para calcular a idade de segurado, com base na data atual, em dias. Ao final devem ser gerados os seguintes registros:HOMENS nome : caracter[40]
idade : inteiroMULHERES nome: caracter [40];
idade : inteiro;
MODULARIZAÇÃO
A Programação Estruturada é hoje o resultado de uma série de estudos e propostas de disciplinas e metodologias para o desenvolvimento de software. Conceitos associados como técnica de refinamentos sucessivos e modularização de programas integram o ferramental para elaboração de programas visando, principalmente, os aspectos de confiabilidade, legibilidade, manutenibilidade e flexibilidade.A metodologia de refinamentos sucessivos parte do princípio de que resolver um problema complexo é mais fácil se não precisarmos considerar todos os aspectos do problema simultaneamente, isto é, a decomposição de um problema grande numa série de subproblemas mais simples.
Quando no processo de desenvolvimento do algoritmo faz-se a opção por divisão do algoritmo, este procedimento conduz a modularização da solução do problema.
Um módulo é então um grupo de comandos, constituindo um trecho de algoritmo, com uma função bem definida. Esta divisão da atividade de programação permite que, a cada instante, toda a atenção do programador esteja concentrada na solução de cada problema
70
específico e bem definido. Da mesma forma, pode-se verificar a correção do algoritmo por etapas analisando-se a correção de cada módulo.
A decisão pela divisão do algoritmo em módulos traz benefícios como:
a. maior flexibilidade e facilidade de manutenção, já que o módulo pode esconder dos outros módulos detalhes que só interessam a ele; b. permite a divisão de tarefa em uma equipe, onde cada módulo pode ser desenvolvido por um programador diferente; c. facilita o teste, porque cada módulo pode ser testado individualmente, e depois ser incorporado ao conjunto; d. facilita o projeto, na medida em que permite a abstração.
A experiência recomenda que os módulos constituintes de um programa devem ter no máximo o tamanho de uma página de listagem. Módulos maiores são difíceis de ser compreendidos e em geral são multifuncionais.
Um outro aspecto importante que envolve a modularização, em particular a modularização de dados, é a possibilidade de cada módulo poder definir as suas estruturas de dados próprias, suficientes e necessárias apenas para atingir o objetivo final do módulo. Estre aspecto disciplina e impõem restrições a utilização das estruturas de dados do algoritmo. Toda a comunicação entre módulos deverá ser bem definida através de vínculos entre os mesmos.
Um bom algoritmo deve procurar reduzir a interação entre módulos (acoplamento) e aumentar o relacionamento dos elementos de um mesmo módulo (coesão).
As ferramentas de modularização apresentadas são: funções e procedimentos.
Vantagens: 1. partes comuns a vários programas ou que se repetem dentro de um mesmo programa, quando modularizadas em um procedimento, são programadas (e testadas) uma só vez, mesmo que tenham que ser executadas com variáveis diferentes;
2. podem-se constituir bibliotecas de programas, isto é, uma coleção de módulos que podem ser utilizados em diferentes programas sem alteração e mesmo por outros programadores.
3. a modularização dos programas permite preservar na sua implementação os refinamentos obtidos durante o desenvolvimento dos algoritmos.
4. economia no armazenamento, uma vez que o módulo é armazenado uma única vez mesmo que utilizado em diferentes partes do programa. Permite, também, que, em um determinado instante da execução do programa, estejam na memória principal apenas o módulo ou os módulos necessários a execução deste trecho de programa - paginação.
Desvantagens:
71
1. existe um acréscimo de tempo na execução de programa constituídos de módulos, devido ao trabalho adicional de ativação do módulo.
BLOCO
O nosso conhecimento de bloco até agora, está limitado a colocar as palavras INICIO e FIM, respectivamente, para definir o algoritmo. Entretanto, o conceito de BLOCO tem uma amplitude maior, pois podemos ter diversos BLOCOS (uns dentro de outros) dentro de um algoritmo.
Um bloco era formado por: inicio <declaração de variáveis>; <comandos>; fim.
Agora, de acordo com o que vimos, podemos ter blocos dentro de blocos:
inicio <declaração de variáveis>; inicio {segundo bloco} <declaração de variáveis>; {segundo} <comandos>; {segundo} fim; {segundo} <comandos>; fim.
Uma das vantagens é a possibilidade de definir variáveis fora do seu lugar original, principalmente, quando se conhece a variável no meio do algoritmo.
Exemplo: inverter a ordem de um vetor.
inicio N: inteiro; leia (N); inicio {procedimento inverte} tipo V=VETOR [1:N] inteiro; VET : V; leia (VET); {inverta VET} imprima (VET); fim; {procedimento inverte} fim.
72
Uma variável começa quando o bloco, onde ela está contida, inicia e termina quando este bloco termina (FIM.) - variáveis locais ao bloco.
Quando existe um bloco dentro de outro, as variáveis do bloco externo são locais para ele e globais para o bloco internos. Já as variáveis do bloco interno são locais a ele e são desconhecidas pelo bloco externo.
Quando existe conflito de nomes (duas variáveis com mesmo nome, sendo uma local e outra global), vale a definição local, e a global deixa de poder ser acessada (embora continua existindo normalmente).
Exemplo:
inicio I,J:inteiro; NOME: caracter[40]; inicio {procedimento 1} K,L,M:real; NOME: caracter[60]; SOMA:inteiro; leia (NOME); K <= I + J; SOMA <= K + (I*J); fim; {procedimento 1} imprima (NOME); fim.
PROCEDIMENTO
Ë um bloco com nome, com isto, poderemos chamá-lo em qualquer ponto do algoritmo.
Sintaxe:
procedimento <nome> < lista de parâmetros>; <especificação dos parâmetros>; inicio <declaração de variáveis locais>; <comandos>; fim;
A chamada de um procedimento é apenas a colocação de seu nome em um comando, como se fosse um novo comando.
Sintaxe:
73
<nome do procedimento> ( <parâmetros necessários>);
Exemplo: seja um procedimento para achar e imprimir o maior número entre 3 valores fornecidos.
inicio N1,N2,N3:inteiro; procedimento ACHA (A, B, C) {encontra maior valor} A,B, C:inteiro; inicio se A>=B e A>=C entao imprima (A); fimse; se B>A e B>=C entao imprima (B); fimse; se C>A e C>B entao imprima (C); fimse; fim; {ACHA} leia (N1,N2.N3); ACHA (N1,N2,N3); leia (N1,N2,N3); ACHA(n1,N2,N3): leia (N1,N2,N3); ACHA (N1,N2,N3); fim.
No cabeçalho do procedimento, temos uma série de variáveis, que podem ser de entrada e de saída. Chamamos estas variáveis de Parâmetros FORMAIS. Já as variáveis usadas quando o procedimento é efetivamente chamado são denominadas Parâmetros EFETIVOS.
Os parâmetros Efetivos de entrada podem ser variáveis, constantes ou expressões. Já os parâmetros Efetivos de saída tem que ser variáveis.
Um procedimento pode chamar outros dentro dele - procedimentos aninhados.
FUNÇÃO
Uma função é um bloco que tem um nome e que devolve um resultado. Em outras palavras, quando não houver retorno de um resultado temos um procedimento, e quando houver temos uma função.
Sintaxe:
74
Função <nome> <lista de parâmetros>: <tipo de dado do resultado>; <declaração dos parâmetros>; inicio <declaração de variáveis locais>; <comandos>; <nome da função> < resultado>; fim;
Toda função usada dentro de um programa deve ter sido definida antes de ser chamada.Sintaxe:
<variável global> <nome da função ( <parâmetros>)>;
Exemplo: seja uma função que calcule o teorema de pitágoras.
inicio W1,W2,RESP:real; Funcao PITAG (A,B) : real; A,B:real; inicio X:real; X (A ** 2 ) + (B ** 2); PITAG X ** 0.5; fim; {PITAG} leia (W!,W2): RESP PITAG (W1,W2); imprima (RESP); fim.
EXERCÍCIOS
1. Fazer a função sen(x) que recebe o valor de x e calcula o seno através da seguinte série: x x3 x5 x7 sen(x) = ---- - ---- + ---- - ---- + .... 1 3! 5! 7! A função retorna o valor do seno de x. Obs.: Utilize a soma dos 30 primeiros termos da série acima
2. Fazer um algoritmo que calcule a área e o perímetro de um quadrado a partir do tamanho do lado. Lado é dado de entrada e os valores de área e perímetro são retornados por funções.
3. Fazer um algoritmo para achar o maior valor dentre 3. A função maiorde3 recebe como argumento os 3 valores e retorna o maior.
75
4. Escrever um algoritmo para gerar os N primeiros termos da série de Fibonacci: 1, 1, 2, 3, 5, 8, 13, 21,.... A função FIB tem N como parâmetro, calcula e imprime os termos da série.
5. Escrever um algoritmo que calcule e imprima o valor de S. Faça uma função que receba o valor de N e devolva o valor de S. N é dado de entrada e deve ser lido na função principal. 1 2 3 N-1 NS = ---- + ---- + ---- + ... + ---- + ---- N N-1 N-2 2 1
6. Fazer um algoritmo para ler um inteiro N >= 0 e calcular seu fatorial. A função FAT recebe o valor de N e devolve seu fatorial.
7. Fazer um algoritmo para ler um inteiro N > 0 e calcular o seguinte somatório: R = 1 + 22 + 32 + .... + N2. A função deve receber o valor de N e devolver o valor de R.
8. Fazer um algoritmo para ler um inteiro N > 0 e calcular o seguinte somatório: S = N + N-1 + N-2 + N-3 + ... + 0. A função deve receber o valor de N e devolver o
valor de S.
9. As notas de uma turma de N alunos são lidas e armazenadas em um vetor. N também é lido. Fazer um algoritmo contendo funções para: a) receber o valor de N, ler as N notas, armazenando-as em um vetor (este deve ser
variável global). b) receber o valor de N, calcular a média da turma, devolvendo seu valor à função
principal. c) receber o valor de N, achar a maior nota, devolvendo seu valor à função principal.
10. Um numero primo é qualquer numero inteiro positivo que é divisível apenas por si próprio e por 1. Escreva uma função que recebe um numero inteiro positivo e, se este número for primo, retorna 1, caso contrario, retorna 0.
11. Fazer um algoritmo, contendo uma função que receba uma temperatura dada em graus Fahrenheit e devolva a temperatura convertida para graus Celsius. (C = 5/9*(F-32)).
12. Fazer um algoritmo que calcule o volume e a área de uma esfera. O raio é dado de entrada, e os valores de volume e a área são retornados por funções que recebem o raio como argumento.V = 4/3*pi*R3 e A = 4*pi*R2, onde R = raio da esfera.
13. Um cofrinho contém os seguintes itens: n1 moedas de 1 real , n2 moedas de 50 centavos , n3 moedas de 25 centavos, n4 moedas de 10 centavos , n5 moedas de 5 centavos, n6 moedas de 1 centavo. Fazer uma função que receba os valores acima e devolva o total em Reais
76
14. Seja um vetor contendo N inteiros e de tamanho máximo TAM (n <= TAM). N deve ser lido do teclado pela função principal. Considere o vetor como variável global. Fazer um algoritmo contendo as seguintes funções: a)leitura: recebe o valor de N e lê os N elementos do vetor.b) menor: recebe o valor de N e devolve o menor elemento do vetor.c) imaior: recebe o valor de N e devolve o índice do maior elemento do vetor. d) par: recebe o valor de N e devolve o número de elementos pares do vetore) media: recebe o valor de N e devolve a média aritmética dos elementos do vetor.f) acimamed: recebe o valor de N e o valor da média calculada pela função anterior e devolve a porcentagem de elementos acima da média. Todos os valores devolvidos devem ser impressos através da função principal.
15. Faça uma função que receba um caracter e retorne 0 se o mesmo for letra e 1 caso contrário.
16. Seja um vetor de tamanho TAM, declarado como variável global. Fazer um algoritmo contendo as seguintes funções: a)leitura: lê os elementos do vetor.b) maiorsoma: devolve a maior soma entre dois elementos consecutivos do vetor.c ) maiordif: devolve a maior diferença entre dois elementos consecutivos do vetor.
17. Seja uma string (variável global) contendo um nome de pessoa e um caracter qualquer. Fazer um algoritmo contendo as seguintes funções: a)leitura: le a string e o caracter devolvendo (retornando) o valor deste último. b) tamanho: retorna o tamanho (número de caracteres) stringc) n_ocor_car: recebe o caracter e o tamanho da string como argumento, devolvendo o número de ocorrências do mesmo na stringd) p_oco_car: recebe o caracter e o tamanho da string como argumento, devolvendo o índice da primeira ocorrência do mesmo na string . Caso não haja ocorrência, devolve valor -1. E) npalavras: recebe o tamanho da string como argumento e devolve número de palavras da string (considere que cada palavra está separada por um espaço). F) imprime_inv: Imprime a string invertida. Todos os valores retornados devem ser impressos. A função principal é responsável por isso.
18. Faça uma função que recebe a idade de uma pessoa em anos, meses e dias e retorna essa idade expressa em dias.
19. Faça uma função que recebe um valor inteiro e positivo e retorna o número de divisores desse valor.
20. Escreva uma função que recebe dois valores X e Y e retorna X elevado a Y, sem utilizar funções ou operadores de potência prontos.
77
21. Fazer uma função que recebe um caracter e devolve o número de ocorrências desse caracter em uma frase. Considere que a frase e o caracter são lidos na função principal. Escrever o algoritmo completo.
22. Fazer um algoritmo contendo funções para: a) ler um vetor onde cada elemento (vagas[i]) representa o número de vagas do curso i. b) ler um outro vetor onde cada elemento (candidatos[i]) representa o número de candidatos inscritos para o curso i.c) criar um terceiro vetor contendo o número de candidatos por vagad) receber o índice de um curso e retornar o número de candidatos por vaga desse cursoe) retornar o índice do curso de maior concorrênciaobs.: Imprima todos os resultados e considere os vetores como variáveis globais
23. Seja um vetor de inteiros (global) de tamanho TAM. Faça um algoritmo com as seguintes funções:leitura: lê os elementos do vetor.imaior: retorna o índice do maior elemento do vetor. media: retorna a média aritmética dos elementos do vetor.troca: recebe dois valores x e y e substitui x por y no vetor. Ex.: supor x = 3 e y = 9. Se o vetor inicialmente lido fosse {2, 5, 3, 7, -5, 3, 2, 9}, depois da troca ele ficaria: {2, 5, 9, 7, -5, 9, 2, 9}imprime: imprime o vetor.
RECURSIVIDADE
Recursividade é um conceito matemático onde a solução de um problema é expressa como uma combinação de soluções de problemas idênticos, porém menores. A solução do menor problema possível consiste na solução de um caso extremo, o mais simples, que são as premissas sobre as quais a solução recursiva é criada.
A existência de solução para o caso mais simples é necessária para que as equações de definição recursiva possam ser resolvidas.
Por exemplo, a função fatorial de um número N inteiro positivo possui as seguintes equações recursivas:1. Fatorial (0) = 12. Fatorial (N) = N * Fatorial (N-1)
Observe na Segunda equação que o fatorial de um número N é expresso em função do fatorial do seu predecessor. A primeira equação trata do caso mais simples.
Quando um algoritmo é chamado iterativo, isto é, ele requer a repetição explícita de um processo até que determinada condição seja satisfeita, então este algoritmo poderá fazer uso de recursão. Em termos de algoritmoção de computadores, recursividade é utilizada quando existem rotinas que chamam a si próprias no decorrer do seu código.
78
Exemplos:1. Calculo do fatorial de um número N
Função FATORIAL (n) : inteiron : inteiro;Inicio
Se n>0Então fatorial FATORIAL (n –1);Senão fatorial 1;
Fimse;Fim.
2. Calculo do MDC entre M (dividendo) e N (divisor)Função MDC (m,n) : inteiro;
m, n : inteiro;Inicio
Se n > mEntão mdc MDC (n,m);Senão se n = 0
Então mdc m;Senão mdc MDC (n, (m mod n));
Fimse;Fimse;
Fim.
3. SÉRIE DE FIBONACCI
função FIB (N): inteiro; N: inteiro; inicio I, ANT, PEN, ULT: inteiro; ANT 0; PEN 1; FIB 0; para I de 1 até N faça ULT ANT + PEN; FIB FIB + ULT; ANT PEN; PEN ULT; fimpara; fim;
SÉRIE DE FIBONACCI - RECURSIVIDADE
função FIB (N) : inteiro; N: inteiro;
79
inicio se N<= 1 então FIB 1; senão FIB FIB(N-1) + FIB(N-2); fimse; fim;
função FIB (N) : inteiro; N: inteiro; inicio se N= 1 ou N=2 então FIB 1; senão FIB FIB(N-1) + FIB(N-2); fimse; fim;
A execução de um procedimento recursivo é geralmente efetuada pelo uso de sub-rotinas. Como uma rotina recursiva chama a si própria, é necessária uma área de memória para salvar o seu contexto antes dessa chamada recursiva (registro de ativação) a fim de que este possa ser restaurado ao final dessa chamada. Esses registros de ativação são organizados em forma de pilha.
Na maioria dos casos não é preciso utilizar recursividade, pois de um modo geral todo algoritmo recursivo pode ser escrito em forma não-recursivo; no entanto, em algumas situações ela é realmente oportuna.
A principal vantagem de sua utilização é a redução do código-fonte da rotina. Entretanto, o uso de recursividade apresenta algumas desvantagens, tais como:- baixo desempenho na execução devido ao tempo gasto no gerenciamento da pilha de
registros de ativação e o espaço por ela ocupado;- dificuldade de depuração dos algoritmos, particularmente se a recursão for muito
profunda.
Os principais critérios a serem utilizados para decidir se a recursividade deve ou não ser utilizada é a clareza do algoritmo e o desempenho esperado pelo algoritmo.
ProfundidadeChamamos de profundidade ao número de vezes que uma rotina recursiva chama a si própria, até obter o resultado.
O cálculo do fatorial de 3 possui profundidade 3, ou seja, três níveis de recursão:3! = 3 * 2!
2! = 2 * 1! Nível 11! = 1 * 0! Nível 2
0! = 1 Nível 3
80
EXERCÍCIOS
1. Escreva um algoritmo recursivo para avaliar a * b usando a adição, onde a e b são inteiros não-negativos.
2. Escreva uma definição recursiva de a + b, onde a e b são inteiros não-negativos, em termos da função sucessora succ definida como:Função SUCC (x) : inteiro;
x:inteiro;Inicio
SUCC x + 1;Fim.
3. Determine o que a seguinte função recursiva calcula e escreva uma função iterativa para atingir o mesmo objetivo:Função FUNC (n)
N: inteiro;Inicio
Se n = 0Então FUNC 0;Senão FUNC n + FUNC (n-1);
Fimse;Fim.
ARQUIVOS
Um arquivo é um conjunto de registros, ou seja, é uma estrutura de dados, na qual cada registro não ocupa uma posição fixa dentro da estrutura, não possuindo portanto tamanho preestabelecido. Os registros são formados por unidades de informação chamadas campos. Os campos devem possuir uma relação lógica entre seus conteúdos, ou serem relacionados a um determinado “objeto”, para então formarem um arquivo.
Em nosso cotidiano é normal a utilização de arquivos para armazenar grandes quantidades de informação com maleabilidade e por um grande período de tempo. Estas informações guardadas em um arquivo podem ser utilizadas por diferentes algoritmos – diferentes usuários e de formas diferenciadas.
A estrutura chamada arquivo permite algumas operações básicas que podem ser visualizadas através de uma analogia com uma gaveta de um arquivo de aço, que contém algumas pastas suspensas que seriam nossos registros.
As operações possíveis de serem realizadas em um arquivo tanto real quanto virtual são:- inclusão de registros (ou pastas suspensas);- alteração de registros (ou pastas suspensas);- consulta a um registro (ou a uma pasta suspensa);
81
- exclusão de um registro (ou de uma pasta suspensa).
MANIPULAÇÃO
Podemos admitir que todo arquivo possui maneiras semelhantes de serem manipulados., independente de como foi concebido. Concluímos que podemos consultar e/ou acrescer informação ao arquivo.
Retornando a analogia com um arquivo de aço, só podemos manipular registros (pastas suspensas) se o arquivo (gaveta) estiver aberto. Portanto, a primeira operação sobre um arquivo é “abrir”. Da mesma forma, após o término da manipulação dos registros (pastas suspensas) devemos sempre fechar o arquivo (gaveta). Portanto, a última operação sobre um arquivo é “fechar”.
Para guardarmos um registro no arquivo, faz-se necessário que este possua estruturação de campos igual à dos registros armazenados, e ao mesmo tempo esteja completamente preenchido. Uma vez que, quem guarda, guarda alguma coisa em algum lugar; neste comando guarda-se alguma informação de dado registro para a posição atual do arquivo.
CONCEPÇÃO DE ARQUIVOS
Quando criamos um arquivo, utilizamos determinado padrão de comportamento que estabelece o modo pelo qual os registros são armazenados no arquivo, isto é, o algoritmo estabelece a estruturação do arquivo.
SEQUENCIAL – caso a gravação dos registros no arquivo seja feita de forma contínua, um após o outro, teremos estabelecido uma circunstância de sequência no armazenamento dos registros, obtendo um arquivo cuja concepção é dita sequencial. Nestas circunstâncias dizemos que a localização de qualquer um dos registros que foi armazenado é indeterminada, ou seja, para acessar um registro específico precisamos obedecer a sua ordem de gravação, o que implica percorrer todos os registros que o antecedem, um após o outro. No caso de acrescermos um registro ao arquivo, este será inserido por último.
Na forma de armazenamento sequencial será necessária a definição de duas formas de abertura de arquivo, uma para leitura ( posicionando no inicio do arquivo, isto é, no primeiro registro) e outra para gravação ( posicionando no fim do arquivo, isto é, após o último registro).
A consulta de um determinado registro deve ser feita por comparação. Verifica-se se o conteúdo de um determinado campo é igual ao valor procurado, e assim sendo, encontramos o registro. Em caso contrário, deve-se ler os registros subsequentes sucessivamente até encontrar o registro desejado ou atingir o final do arquivo. Para identificar o final de arquivo, utiliza-se um registro finalizador, que é um valor atribuído ao campo chave, para identificarmos o último registro do arquivo.
82
DIRETA – a principal característica deste tipo de organização de arquivo é que os registros podem ser acessados diretamente. Isto é possível porque cada registro é associado a um número que representa sua posição no arquivo. Este número não faz parte o registro.
Ao criar um arquivo pode-se utilizar um algoritmo que expresse um padrão rígido, com o objetivo de estruturar o arquivo para facilitar sua manipulação. Através de um dos campos do registro podemos determinar o lugar onde está guardada a informação desejada, podendo acessá-lo de modo instantâneo. Este campo é denominado CHAVE, pois é uma informação capaz de acessar o registro, ela deve ser única, pois não podemos armazenar dois registros diferentes em uma mesma localização. Desta forma os registros possuem um lugar reservado onde serão gravados, lugar este identificado pela chave.
INDEXADA – o método de acesso direto é ineficiente para algumas aplicações, pois é difícil relacionar o número do registro com o seu conteúdo, uma vez que este número não faz parte do registro. Por exemplo, qual é o número do registro que contém as notas do aluno José da Silva? Este problema é resolvido usando métodos de classificação e pesquisa de dados.
Na organização indexada tem-se que construir um arquivo auxiliar, também chamado de arquivo de índices, que será constituído de registros, contendo apenas dois campos, o campo que irá armazenar a chave de acesso e o campo que irá armazenar o número do registro no arquivo de organização direta. Desta forma, a localização do registro pode ser feita através de pesquisa binária pelo campo chave desejado, e em seguida lê-se o registro indicado pelo número do registro no arquivo de organização direta.
Este caso assemelha-se a uma enciclopédia não alfabética que possui um volume de índices, no qual estão relacionados em ordem alfabética os assuntos e logo ao lado o volume e página onde encontrá-lo, acessando-o de forma direta.
COMANDOS DE MANIPULAÇÃO DE ARQUIVOS
Como um arquivo é composto por registros, para definirmos um arquivos devemos, primeiramente, definir o registro que irá compô-lo. Precisamos ter conhecimento de que um arquivo armazena diversos registro porém todos com um mesmo lay-out, logo o lay-out dos registros de um arquivo é único. A sintaxe para definição de arquivos em um algoritmo segue a regra abaixo:
< nome do arquivo> = ARQUIVO < tipo de organização> DE < nome do registro> ;
Onde, tipo de organização pode ser sequencial, direta ou indexada e irá definir a forma de acesso aos registros do arquivo.
ABRIR UM ARQUIVO – como dito anteriormente, não se pode obter informação contida em um arquivo sem antes abri-lo, em algoritmos isto será feito pelo comando:
83
ABRIR ( <nome do arquivo> );
Caso o arquivo tenha formato de organização sequencial deve-se indicar se ele será aberto para leitura ou gravação. Indicando assim o posicionamento do mesmo, respectivamente, no início ou final do arquivo:
ABRIR ( <nome do arquivo> , <leitura / gravação> );
FECHAR UM ARQUIVO – não devemos manter o arquivo aberto depois de usá-lo, pois isso deixaria seu conteúdo exposto a agentes externos que poderiam danificar sua integridade. Por isso, convém sempre fechar os arquivos após sua utilização, utilizando o comando:
FECHAR ( < nome do arquivo> );
Neste caso não importa a forma de organização do arquivo, tão pouco a razão de sua abertura.
COPIAR UM REGISTRO – um arquivo não deve ter seus registros consumidos e sim consultados e, para tal, precisa-se copiar o conteúdo que interessa em algum lugar para então fazer sua utilização. O local mais apropriado para esta cópia é o próprio registro que compõem o arquivo, pois terá o mesmo formato de campos. Neste caso copiam-se as informações da posição corrente do arquivo para o registro especificado, onde todos os campos do registro do arquivo são copiados para os respectivos campos do registro estabelecido no comando.
COPIAR ( <nome do arquivo > , < nome do registro >);
GRAVANDO UM REGISTRO – sempre que alguma nova informação deva ser gravada no arquivo esta deve ser feita em forma do registro que compõem o referido arquivo. Assim, deve-se preencher todos os campos do registro para então, gravá-lo no arquivo. Esta gravação ocorrerá na posição atual do arquivo. O comando será:
GRAVAR ( <nome do registro> , <nome do arquivo> );
Para percorrer todos os registros de um arquivo, a partir do primeiro, até encontrar seu fim. Este comando posiciona o arquivo na posição consecutiva, ou seja, no próximo registro, e é definido como:
AVANÇAR (< nome do arquivo>);
Outra instrução bastante importante é a que identifica o final do arquivo. Esta função retorna verdadeiro quando a posição corrente é o fim do arquivo, e falso em caso contrário. Sua sintaxe é:
EOF (<nome do arquivo>) ou FDA (< nome do arquivo>);
84
onde EOF simboliza, End Of File e FDA simboliza, Final De Arquivo.
Quando tem-se um arquivo com organização direta pode-se atingir o registro desejado fazendo uso do campo chave, para tanto utiliza-se o comando Posicionar, onde a posição corrente do arquivo passa a ser a indicada pela chave, da seguinte forma:
POSICIONAR ( <nome do arquivo> , <chave> );
A forma de acesso ao arquivo independe de sua organização, pode-se igualmente acessar um arquivo de organização direta de forma sequencial. Assim como um arquivo sequencial poderá ser acessado de forma direta desde que seja gerado um arquivo indexado associando um campo do registro deste arquivo, denominado como chave, ao seu número de registro no arquivo sequencial.
EXERCÍCIOS SOBRE ARQUIVOS
1. Supondo um arquivo com os registros com os campos: matrícula, nome, endereço, situação, título de eleitor, cpf, rg, conta bancária, estado civil, cargo, salário.Imprimir os funcionários com: situação = afastado, cargo = instrutor e salário acima de R$ 400,00.
2. Dado o arquivo Cadastro com registros com campos: nome, sexo, cor-de-olhos, altura, peso e data de nascimento. Criar um arquivo Homens cujo sexo =1 e um arquivo Mulheres cujo sexo = 2. Estes dois novos arquivos tem registros com campos nome, peso e data de nascimento.
3. Uma distribuidora de bebidas abastece o mercado de Coca-cola. A empresa, no momento, está preparando o iminente lançamento da Coca Light Plus. Assim, resolveu fazer uma pesquisa de opinião na cidade para determinar qual a melhor estratégia a seguir. Os dados da pesquisa estão em um arquivo com o lay-out:
identificação do quarteirão da cidade, quantidade de crianças no quarteirão, quantidade de adolescentes no quarteirão, quantidade de obesos no quarteirão, quantidade de diabéticos no quarteirão, total de pessoas no quarteirão.
Deve-se criar um algoritmo que leia e processe os dados, informando:a) quantos quarteirões tem mais de 100 obesos;b) qual a percentagem média (= média das percentagens) de crianças por quarteirão sobre o total de pessoas no quarteirão;c) quantos quarteirões tem mais adolescentes do que crianças;d) quantos quarteirões tem mais de 5% de diabéticos.
85
4. Uma revenda de automóveis quer fazer uma pesquisa para determinar se há correlação entre renda familiar e cor do automóvel adquirido. Para tanto, cada venda realizada no mês passado, gerou um registro magnético contendo: renda familiar, cor do carro adquirido. As cores possíveis são: amarelo, azul, branco, cinza, marrom, preto e vermelho. Já as classes de renda são 3: de 0 a 50 sal mínimos, de 50,01 a 150 sal mínimos, acima de 150 sal min.Ler o valor do sal mínimo no inicio do algoritmo e imprimir a quantidade de carros vendidos por cor em cada classe de renda.
5.Existe um arquivo de funcionários com registros com o lay-out:nome, carteira profissional, endereço, bairro, telefone, CEP, CPF, título de eleitor, número de dependentes, cargo, salário base, data de admissão (dia, mês, ano), data de demissão (dia, mês, ano).A partir deste arquivo, deseja-se:a) aumentar o salário em 10% dos funcionários casados e admitidos até 30/09/97;b) relação dos funcionários não solteiros;c) relação dos funcionários por faixa salarial:
1 a 2 salários mínimos2 a 4 salários mínimos4 a 7 salários mínimosacima de 7 salários mínimos,o valor do salário mínimo deve ser lido no início do procedimento;
d) relação dos funcionários com telefone que estão demitidos. Utilizar função ou procedimento para cada um dos itens acima.
6. Criar um algoritmo portugol que faça o calculo do valor do salário líquido de um funcionário. O arquivo de func. contém registros com os campos: matrícula, nome, endereço, CPF, RG, titulo eleitor, estado civil, sexo, data nascimento, conta corrente, salário mensal (220 horas), num horas extras, num de dias faltados, vale transporte (S/N), vale refeição (S/N), num dependentes - para cada dependente: grau de parentesco (filho, esposa), data nascimentoDescontos:Tabela de desconto de INSS sobre todos os proventos:
de 0 a 10 SM - 9% de 10 a 25 SM - 15% acima de 25 SM - 25%
Desconto do FGTS equivale a 8% do valor bruto de proventos.Para cada dia faltado diminuir 8 horas de trabalho.Vale refeição - 20% do SM.Vale transporte - 6% do salário bruto.Tabela de desconto de auxilio saúde - todos os funcionários possuem titular - 1,5% do salário bruto. dependentes - esposa - 3% do salário bruto filhos até 14 anos - 2% do salário bruto filhos acima de 14 anos - 3% do salário bruto.
86
Proventos:Valor do salário família: R$ 120,00 por filho com menos de 14 anos.Para cada hora extra o valor da hora é 50% mais que a hora normal.Salário Líquido : proventos = salário bruto + salário família + hora extra desconto = (proventos * % do INSS) + vale refeição + vale transporte + auxilio saúde + valor faltas liquido = proventos - descontosLer no inicio o valor do SM.Utilizar procedimentos e funções.Imprimir ao final:matricula, nome, conta corrente, salário a ser pago,total do INSS, total do FGTS e total líquido da folha de pagamento.
87
EXERCÍCIOS DIVERSOS
1. Dado um conjunto de datas do ano de 1996, no formato dia e mês, determinar qual o número relativo deste dia no ano, considerando o dia 1º de janeiro como dia número 1, e o dia 31 de dezembro como dia número 365. O algoritmo deve prosseguir lendo e calculando até que um dia igual a zero seja lido.
2. Dada uma matriz de dimensões 8 X 15, obter uma outra também 8 X 15, onde cada linha foi dividida pelo menor elemento da linha correspondente na matriz original.
3. Dada uma matriz de dimensões 9 X 12, obter uma outra também de 9 X 12, onde cada linha foi dividida pela somatória dos elementos da linha correspondente da matriz original.
4. Definir um algoritmo Portugol capaz de receber uma série de datas, sempre referentes ao ano de 1996, e no formato dia e mês. Para cada uma delas, o algoritmo deve calcular uma nova data, no mesmo formato, e que corresponda ao período de 180 dias posterior a data original. A série de datas se encerra quando for lido um dia igual a zero.
5. Dada uma matriz 7 X 12, definir um algoritmo que leia a matriz, e a seguir, classifique as linhas da matriz em ordem crescente. A matriz resultado deve ser impressa ao final.
6. Criar um algoritmo que leia um vetor de 500 elementos inteiros. A seguir o algoritmo deve determinar qual o valor que mais aparece neste vetor e quantas vezes ele aparece. Estas duas informações devem ser impressas ao final.
7. Dados dois horários no formato hora e minuto: hora variando de 0 até 11; minutos variando de 0 até 59; definir um algoritmo que leia um par de horários, sempre referentes a um mesmo dia, e
informe qual a diferença entre os dois. O algoritmo termina quando a primeira hora for igual a 99. Por definição, o segundo horário nunca é menor que o primeiro, e a diferença entre os dois deve ser informada no mesmo formato: hora e minuto.
8. Uma partida de rolamentos é composta de quantidades variáveis de rolamentos tipos 1, 2 e especial. Ela é aceita no TODO quando: pelo menos 97% de rolamentos tipo 1 não tem defeito E pelo menos 95% de rolamentos tipo 2 não tem defeito E menos de 1000 rolamentos tipo especial tem defeito.Os dados referentes a cada partida estão no formato:Número da partida; Tipo do rolamento; Quantidade de rolamentos; Quantidade de
rolamentos c/defeito.Deve-se definir uma algoritmo que leia todos os dados do arquivo e, para cada partida, deve-se imprimir seu número e a identificação: ACEITA ou REJEITADA.
9. Os números romanos são ainda utilizados em muitas indicações. Conhecendo seus símbolos, que são:
88
I = 1; V=5; X=10; L=50; C=100, D=500 e M=1000, escreva um algoritmo que leia o número inteiro e gere, para cada número lido, o equivalente em números romanos, imprimindo ao final.
10. Um fabricante de margarina deseja homenagear sua mãe no lançamento de um novo produto no próximo ano. A nova margarina deverá ter um nome formado por alguma combinação das letras M E R T A, que é o nome da mãe do fabricante. O algoritmo deve imprimir as 120 combinações possíveis, assim o fabricante escolherá o nome que quiser.
11. Uma fazenda resolveu automatizar o processo de tomada de decisão para escolha de sementes de trigo. Assim, a área de plantio foi dividida em 8600 lotes distintos, que devidamente semeados, tiveram a cultura de 95/96 observada. A partir dos dados levantados no campo, foi criado um arquivo contendo o seguinte lay-out:Identificação do lote; Tipo de semente; Área do lote plantado; Quantidade de trigo colhido no lote em kg; Qualidade do produto. Existem 22 tipos de sementes , numeradas de 1 até 22. A qualidade do produto é um número que significa: 1= excelente; 2=razoável; 3=inferior. Supõem-se que o custo de todos os tipos de semente é o mesmo.Deve-se definir um algoritmo que leia o arquivo, determine e imprima qual o tipo de semente mais produtiva, seguindo o critério:Se o trigo produzido for excelente, a produtividade do lote deve ser aumentada de 20%.Se o trigo for inferior, a produtividade deve ser diminuída em 15%.Para cada tipo de semente, devem ser totalizadas as informações de área e peso do produto produzido. A semente mais produtiva é aquela que tiver maior coeficiente peso/área.
89
