algoritmos - técnicas de programação

7/26/2019 Algoritmos - Técnicas de Programação

http://slidepdf.com/reader/full/algoritmos-tecnicas-de-programacao 1/129

Algoritmos

Técnicas de Programação



1

José Augusto N. G. Manzano

Ecivaldo Matos

André Evandro Lourenço

Algoritmos

Técnicas de Programação

1ª Edição

www.editoraerica.com.br



2 Algoritmos - Técnicas de Programação

Dados Internacionais de Catalogação na Publicação (CIP)(Câmara Brasileira do Livro, SP, Brasil)

Manzano, José Augusto N. G.Algoritmos : técnicas de programação / José Augusto N. G. Manzano, Ecivaldo Matos,

André Evandro Lourenço. -- 1. ed. -- São Paulo : Érica, 2014.

Bibliografia

ISBN 978-85-365-0737-8

1. Algoritmos 2. Linguagens de programação (Computadores) 3. Programação (Computadores eletrônicos) I. Matos,Ecivaldo. II. Lourenço, André Evandro. III. Título.

14-01498 CDD-005.1

Índices para catálogo sistemático:

1. Algoritmos : Computadores : Programação : Processamento de dados 005.1

Copyright © 2014 da Editora Érica Ltda.

Todos os direitos reservados. Nenhuma parte desta publicação poderá ser reproduzida por qualquer meio ou forma sem prévia autorização

da Editora Érica. A violação dos direitos autorais é crime estabelecido na Lei nº 9.610/98 e punido pelo Artigo 184 do Código Penal.

Coordenação Editorial: Rosana Arruda da SilvaCapa: Maurício S. de FrançaPreparação e Edição de Texto: Beatriz M. Carneiro, Bruna Gomes Cordeiro, Carla de Oliveira Morais Tureta,

Juliana Ferreira Favoretto, Nathalia Ferrarezi, Silvia CamposProdução Editorial: Adriana Aguiar Santoro, Alline Bullara, Dalete Oliveira, Graziele Liborni, Laudemir Marinho dos

Santos, Rosana Aparecida Alves dos Santos, Rosemeire CavalheiroEditoração: ERJ Composição Editorial

Os Autores e a Editora acreditam que todas as informações aqui apresentadas estão corretas e podem ser utilizadas para qualquer m legal.Entretanto, não existe qualquer garantia, explícita ou implícita, de que o uso de tais informações conduzirá sempre ao resultado desejado.

Os nomes de sites e empresas, porventura mencionados, foram utilizados apenas para ilustrar os exemplos, não tendo vínculo nenhum como livro, não garantindo a sua existência nem divulgação. Eventuais erratas estarão disponíveis para download no site da Editora Érica.

Conteúdo adaptado ao Novo Acordo Ortográco da Língua Portuguesa, em execução desde 1º de janeiro de 2009.

A ilustração de capa e algumas imagens de miolo foram retiradas de <www.shutterstock.com>, empresa com a qual se mantém contratoativo na data de publicação do livro. Outras foram obtidas da Coleção MasterClips/MasterPhotos© da IMSI, 100 Rowland Way, 3rd oorNovato, CA 94945, USA, e do CorelDRAW X5 e X6, Corel Gallery e Corel Corporation Samples. Copyright© 2013 Editora Érica, CorelCorporation e seus licenciadores. Todos os direitos reservados.

Todos os esforços foram feitos para creditar devidamente os detentores dos direitos das imagens utilizadas neste livro. Eventuais omissõesde crédito e copyright não são intencionais e serão devidamente solucionadas nas próximas edições, bastando que seus proprietários conta-tem os editores.

Seu cadastro é muito importante para nós

Ao preencher e remeter a cha de cadastro constante no site da Editora Érica, você passará a receber informações sobre nossos lançamentosem sua área de preferência.

Conhecendo melhor os leitores e suas preferências, vamos produzir títulos que atendam suas necessidades.

Contato com o editorial: [email protected]

Editora Érica Ltda. | Uma Empresa do Grupo SaraivaRua São Gil, 159 - TatuapéCEP: 03401-030 - São Paulo - SPFone: (11) 2295-3066 - Fax: (11) 2097-4060www.editoraerica.com.br



3

Agradecimentos

Agradecemos a todos aqueles que acreditam na educação como um dos elementos undamen-tais para a mudança social.




Sobre os autores

José Augusto N. G. Manzano, brasileiro, nascido em São Paulo, em 26 de abril de 1965,é proessor e mestre com licenciatura em Matemática. Atua na área de ecnologia da Inorma-

ção (desenvolvimento de sofware, ensino e treinamento) desde 1986. Participou do desenvolvimento de aplicações computacionais para as áreas de telecomunicações e comércio. Na carreiradocente, iniciou sua atividade em cursos livres, trabalhando posteriormente em empresas de trei-namento e atuando nos ensinos técnico e superior. rabalhou em empresas da área, como: ABAK,SERVIMEC, CEBEL, SPCI, BEPE, ORIGIN, OpenClass, entre outras.

Atualmente, é proessor com dedicação exclusiva ao IFSP (Instituto Federal de Educação,Ciência e ecnologia de São Paulo, antiga Escola écnica Federal). Em sua carreira como docente,tem condições de ministrar componentes curriculares de Lógica de Programação (Algoritmos),Estrutura de Dados, Microinormática, Inormática, Linguagens de Programação Estruturada, Lin-guagens de Programação Orientada a Objetos, Engenharia de Sofware, ópicos Avançados em Pro-cessamento de Dados, Sistemas de Inormação, Engenharia da Inormação, Arquitetura de Compu-tadores e ecnologias Web. Possui conhecimento de uso e aplicação das linguagens de programaçãoCLASSICBASIC, COMAL, Assembly, LOGO, PASCAL, FORRAN, C, C++, JAVA, MODULA-2,SRUCUREDBASIC, C#, Lua, HML, XHML, JavaScript, VBA e ADA. Possui mais de oitentaobras publicadas, além de artigos publicados no Brasil e no exterior.

Ecivaldo Matos, doutor em Educação (Didática, eorias de Ensino e Práticas Escolares) pelaFaculdade de Educação da Universidade de São Paulo (USP), com apoio do Programa Internacionalde Bolsas de Pós-graduação da Fundação FORD (IFP - Ford Foundation International FellowshipsProgram), mestre em Inormática pela Universidade Federal de Campina Grande e bacharel em

Ciência da Computação com especialização em Sistemas Distribuídos pela Universidade Federal daBahia. Atuou como proessor eetivo do Colégio Pedro II (RJ), na área de Ciência da Computação ecomo pesquisador do Laboratório de Estudos da Aprendizagem Humana da Universidade do Estadodo Rio de Janeiro (LEAH/UERJ). Atualmente, é proessor e coordenador da área de Inormática doInstituto Federal de Educação, Ciência e ecnologia de São Paulo - IFSP (Campus São Paulo), pes-quisador do Grupo Alpha (USP), membro da Association or Computing Machinery (ACM) e daComissão de Educação da Sociedade Brasileira de Computação (SBC).

André Evandro Lourenço, mestre em Engenharia Elétrica (Processamento em Alto Desempe-nho e Sistemas Digitais) pela Universidade de São Paulo (USP) e bacharel em Ciência da Compu-

tação pela Universidade Federal de Mato Grosso do Sul (UFMS). Atualmente, é proessor e coor-denador do Instituto Federal de Educação, Ciência e ecnologia de São Paulo - IFSP (Campus SãoPaulo) e docente do Centro Universitário Fundação Instituto de Ensino para Osasco (UNIFIEO).em experiência técnica e docente nas áreas de programação em ambiente internet, data mining ,webmining , algoritmos e estruturas de dados, sistemas operacionais, arquitetura de computadores,computação gráfica, gestão empresarial, marketing e propaganda, além de trabalhos envolvendobanco de dados.



5

Sumário

Capítulo 1 - Introdução aos Algoritmos ....................................................................................... 9

1.1 Breve história da computação .........................................................................................................................................9

1.2 Lógica de programação e algoritmos ...........................................................................................................................131.3 Paradigmas de programação .........................................................................................................................................14

1.4 Diagrama de blocos ........................................................................................................................................................15

1.5 Linguagem de projeto de programação .......................................................................................................................16

1.6 Interpretadores, compiladores e tradutores ................................................................................................................17

1.6.1 Interpretadores ......................................................................................................................................................17

1.6.2 Compiladores .........................................................................................................................................................18

1.6.3 radutores ...............................................................................................................................................................18

1.7 Recomendações para resolução de problemas ............................................................................................................19

1.8 abela ASCII....................................................................................................................................................................20

Agora é com você! .................................................................................................................................................................24Capítulo 2 - Programação Sequencial ........................................................................................ 25

2.1 Etapas operacionais ........................................................................................................................................................25

2.2 ipos de dados ................................................................................................................................................................26

2.2.1 Dado numérico inteiro .........................................................................................................................................26

2.2.2 Dado numérico real ..............................................................................................................................................26

2.2.3 Dado caractere/cadeia...........................................................................................................................................27

2.2.4 Dado lógico ............................................................................................................................................................27

2.3 Variáveis ...........................................................................................................................................................................27

2.4 Constantes .......................................................................................................................................................................28

2.5 Operadores aritméticos ..................................................................................................................................................292.6 Expressões aritméticas ...................................................................................................................................................29

2.7 Instruções e comandos ...................................................................................................................................................31

Agora é com você! .................................................................................................................................................................36

Capítulo 3 - Programação com Desvios ..................................................................................... 37

3.1 omada de decisões ........................................................................................................................................................37

3.2 Operadores relacionais ...................................................................................................................................................38

3.3 Desvios condicionais ......................................................................................................................................................39

3.3.1 Desvio condicional simples .................................................................................................................................39

3.3.2 Desvio condicional composto ..............................................................................................................................41

3.3.3 Desvio condicional encadeado ............................................................................................................................42

3.3.4 Desvio com múltipla escolha ...............................................................................................................................44

3.4 Divisibilidade ..................................................................................................................................................................45

3.5 Operadores lógicos .........................................................................................................................................................47

3.5.1 Operador lógico .e. ................................................................................................................................................47

3.5.2 Operador lógico .ou. .............................................................................................................................................48

3.5.3 Operador lógico .não. ...........................................................................................................................................50

Agora é com você! .................................................................................................................................................................52




Capítulo 4 - Programação com Laços ........................................................................................ 53

4.1 Controle de ciclos ...........................................................................................................................................................53

4.2 Laço condicional pré-teste .............................................................................................................................................54

4.3 Laço condicional pós-teste ............................................................................................................................................57

4.4 Laço incondicional .........................................................................................................................................................60

Agora é com você! .................................................................................................................................................................62

Capítulo 5 - Programação com Matrizes .................................................................................... 63

5.1 Estrutura de dados ..........................................................................................................................................................63

5.2 Vetores ou matrizes unidimensionais ..........................................................................................................................64

5.3 abelas ou matrizes bidimensionais .............................................................................................................................68

Agora é com você! .................................................................................................................................................................71

Capítulo 6 - Aplicação Prática de Matrizes ................................................................................. 73

6.1 Ordenação de elementos ................................................................................................................................................73

6.2 Pesquisa de elementos ....................................................................................................................................................79

Agora é com você! .................................................................................................................................................................84

Capítulo 7 - Programação com Registros ................................................................................... 85

7.1 ipos de dados derivados ..............................................................................................................................................85

7.2 ipo de dado derivado: registro ....................................................................................................................................86

7.3 Estrutura de um registro com matriz ...........................................................................................................................89

7.4 ipo de dado derivado: novo tipo ................................................................................................................................90

7.5 Matriz de registro ............................................................................................................................................................92

Agora é com você! .................................................................................................................................................................95

Capítulo 8 - Utilização de Sub-rotinas ........................................................................................ 97

8.1 Dividir para conquistar ..................................................................................................................................................978.2 Programação top-down e bottom-up....................................................................................................................... 102

8.3 Procedimentos ..............................................................................................................................................................102

8.4 Funções ..........................................................................................................................................................................104

8.5 Escopo de variáveis .......................................................................................................................................................105

8.6 Passagem de parâmetros ..............................................................................................................................................106

Agora é com você! ...............................................................................................................................................................108

Capítulo 9 - Medidas de Complexidade de Algoritmos ............................................................... 109

9.1 Análise de algoritmos ...................................................................................................................................................109

9.2 Modelo de tempo e espaço: otimilidade de algoritmos ...........................................................................................111

9.3 Busca de padrões em cadeias de caracteres ...............................................................................................................117

9.4 Fundamentos de retrocesso .........................................................................................................................................121

Agora é com você! ...............................................................................................................................................................124

Bibliografia .......................................................................................................................... 125



7

Apresentação

Este livro é um trabalho voltado para o ensino de lógica de programação de computadorespara jovens e adolescentes dos cursos técnicos de inormática da rede brasileira de ensino. O obje-

tivo do estudo e uso das ações de lógica de programação de computadores é permitir ao aluno oacesso ao conhecimento das etapas necessárias a serem dominadas para a produção de sofware paraas áreas de comércio, educação e indústria de modo geral.

A linguagem usada se caracteriza por ser voltada ao público mais jovem. O desenvolvimentodeste livro veio da necessidade de conciliarmos o ensino de técnicas de programação com os pro-gramas curriculares nacionais de maneira que se encaixasse em um semestre de curso. Esta obra estádividida em nove capítulos que tratam os seguintes temas:

O Capítulo 1 apresenta uma pequena introdução aos conceitos essenciais a serem conheci-dos para o desenvolvimento do estudo de lógica de programação de computadores. Nesse capítulo,

é possível ter uma visão básica sobre a história da computação, o que é a lógica de programação ealgoritmos, os paradigmas de programação, diagrama de blocos, linguagem de projeto de programa-ção e os princípios de resolução de problemas entre outros aspectos, entre outros pontos.

No Capítulo 2 o aluno tem contato com o primeiro passo do que eetivamente é a programa-ção de computadores. Nele estudamos os conceitos de entrada, de processamento e de saída. É apre-sentado, também, o uso de tipos de dados, variáveis, constantes, operadores aritméticos, expressõesaritméticas na elaboração e uso do processamento matemático.

A tomada de decisão, segundo passo na aprendizagem de aplicação da lógica de programação,é tema do Capítulo 3. Neste estudo é mostrado o uso de condições e seus desvios, além do conheci-

mento e aplicação dos operadores relacionais e lógicos no uso do processamento lógico. É dada aten-ção ao uso dos princípios de divisibilidade na tarea de programar computadores.

No Capítulo 4 é apresentado o terceiro passo na aprendizagem e uso do conceito de lógica deprogramação. Nessa etapa de estudo, o conhecimento de uso do processamento lógico é ampliadocom o uso das técnicas de laços condicional pré-teste, condicional pós-teste e incondicional.

Após a visão da base inicial dada nos Capítulos 2, 3 e 4, o Capítulo 5 apresenta a técnica deprogramação com matrizes de uma e duas dimensões. Nessa etapa é eita uma introdução ao con-ceito mais simples de estruturação de dados em memória, com a finalidade de acilitar as ações deprogramação pelo programador e, assim, aumentar sua produtividade operacional.

O Capítulo 6 apresenta um nível de aplicação prática da técnica de programação apresentadano Capítulo 5. Nessa etapa é apresentado o uso de técnicas práticas que visam manter uma matrizcom dados classificados de acordo com certa ordem, além de estabelecer um algoritmo para busca elocalização de elementos nessas estruturas de dados.




No Capítulo 7 é apresentada a técnica de criação e uso de registros, uma maneira de incorpo-rar em uma única matriz dados de tipos dierentes.

A organização de um programa em módulos é tema do Capítulo 8, onde são apresentadasas definições e uso de unções, procedimentos e passagens de parâmetro. Nesse capítulo são apre-sentados, ainda, o escopo de uso de variáveis, as ideias de uso dos métodos de trabalho top-down e

bottom-up, além da visão sobre os princípios de dividir para conquistar.O Capítulo 9, último deste trabalho, apresenta temas relacionados a princípios de uso de

algoritmos. Nesse contexto, é indicada, de orma introdutória, noções sobre undamentos de medi-das de complexidade de algoritmos, undamentos de otimalidade de algoritmos, undamentos debacktracking e ações de busca de padrões em strings.

Esperamos que este trabalho seja útil não só ao aluno, mas também ao proessor.

Um abraço a todos!

Os autores



9

1Introduçãoaos Algoritmos

Com o objetivo de desenvolver um bom raciocínio lógico, é apresentado neste capítulo um brevepanorama da história do computador, bem como os conceitos de lógica de programação e, com base em

normas internacionais (ISO 5807:1985), as ormas de representação em diagrama de bloco e portuguêsestruturado. No fim do capítulo, você encontrará uma apresentação do princípio usado para resoluçãode problemas.

Para começar

1.1 Breve história da computação

Atualmente, o computador está presente em praticamente todas as nossas atividades de ormadireta ou indireta. A origem da computação como a conhecemos remete aos primórdios da socie-dade humana, pois o homem sempre teve a necessidade de construir equipamentos e máquinas que

realizassem cálculos. A primeira máquina construída com o objetivo de auxiliar nas operações mate-máticas surgiu por volta de 3500 a.C., na região da Mesopotâmia (vale dos rios igre e Eurades,atual Iraque) e oi batizada de ábaco (ALCALDE; GARCIA; PENUELAS, 1991).

O ábaco influenciou muitas outras culturas, como da Babilônia, Egito, Grécia, Roma, Índia,China e Japão durante vários séculos.




W i k i m e d i a C o m m o n s / M i k e C o w l i s h a w

Figura 1.1 - Ábaco.

Somente em 1642, o rancês Blaise Pascal cria uma máquina com capacidade para realizarsomas e subtração de orma automática. Essa máquina, batizada de Pascalina, simulava por meio derodas dentadas o uncionamento do ábaco. Alguns anos depois, em 1672, Gottried Wilhelm Leibnizconsegue modificar a máquina de Pascal com o objetivo de incluir operações de multiplicar e dividir.

W i k i m e d i a C o m m o n s / T i e u m 5 1 2

Figura 1.2 - Máquina de somar e subtrair de Pascal.

Diversas máquinas oram criadas ao longo do tempo por diversos inventores. O objetivo dasmáquinas sempre oi auxiliar em cálculos complexos ou substituir o homem em alguma atividade.Entre as diversas máquinas que oram criadas, temos: máquina de tear (1804), de Joseph MarieJacquard; máquina de dierenças (1822); máquina analítica, (1837) de Charles Babbage; e máquinade Hollerith (1890), de Hermann Hollerith.



11Introdução aos Algoritmos

W i k i m e d i a C o m m o n s / G e o r g e O n l i n e

Figura 1.3 - Máquina de tear de Joseph Marie Jacquard.

W i k i m e d i a C o m m o n s / B r u n o B a r r a l ( B y B )

Figura 1.4 - Máquina de dierenças e máquina analítica de Charles Babbage.




W i k i m e

d i a C o m m o n s / C e n s u s M a c h i n e

Figura 1.5 - Máquina de Hermann Hollerith.

odas as máquinas criadas até então eram dispositivos mecânicos e não utilizavam nenhumtipo de circuito elétrico.

A utilização de circuitos elétricos só oi possível depois que um matemático chamado GeorgeBoole criou um sistema lógico no qual tudo poderia ser representado por meio de dois algarismos:0 ou 1. Nascia aí a Lógica Booleana, utilizada até hoje em todos os modernos computadores. Em

sua teoria, 0 (zero) representa algo que esteja desligado, apagado, sem valor. Já o valor 1 (um) repre-senta ligado, aceso. Com a combinação desses algarismos, podemos criar outros valores. Vejamosum exemplo que utilize 2 algarismos:

00 - Apagado

01 - Luz verde

10 - Luz amarela

11 - Luz vermelha

Para cada algarismo utilizado, damos o nome de bit. No exemplo acima, temos dois bits. Para construir os símbolos uti-lizados em nosso alfabeto (letras e números) utilizamos oito algarismos, ou seja, oito bits. Para um conjunto de oito bits

damos o nome de byte. Portanto, para formar uma letra ou número do nosso alfabeto, utilizamos um byte.

1 byte = 8 bits

Fique de olho!




1.2 Lógica de programação e algoritmos

Antes de entendermos o que vem a ser lógica de programação, devemos entender que umcomputador nada mais é do que uma máquina com circuitos eletrônicos capaz de executar um algo-ritmo, e um algoritmo é um conjunto lógico de operações predefinidas que resolva determinadoproblema. De orma intuitiva, já utilizamos algoritmos em nosso dia a dia para realizar nossas tare-

as. Em poucas palavras, um algoritmo é uma receita para resolver um problema bem específico.

Por exemplo:

» Observe os passos para se tomar um banho: tirar a roupa, entrar no box, ligar o chuveiro eassim por diante.

» Agora, veja os passos para imprimir o resultado da soma de dois números. Primeiro,devemos ornecer (ou digitar) os dois números a serem somados. Em seguida, realizamosa operação de soma, armazenando o resultado em algum lugar. Por fim, basta imprimir oresultado da soma.

No exemplo 2, os números ornecidos inicialmente são chamados de dados e a soma final éo resultado do processamento desses dados, ou seja, a inormação útil esperada. odo computadorprocessa um conjunto de dados e os transorma em uma inormação.

Entrada Processamento Saída

Figura 1.6 - Estrutura de processamento de dados.

Para que o tratamento dos dados de entrada ocorra, ou seja, para transormar (processar) osdados em inormação de saída, é necessário o uso de um algoritmo desenvolvido para tal finalidade.

Os algoritmos são utilizados para descrever os passos necessários para que um programa de compu-tador execute uma tarea que ele oi designado a azer. Portanto, a lógica de programação é a ormacomo se escreve esse algoritmo, significando o uso correto das leis do pensamento, da “ordem darazão” e de processos de raciocínio (FORBELLONE; EBERSPACHER, 2000) para resolver o pro-blema proposto.

A literatura está repleta de definições para algoritmo:

» processo sistemático para a resolução de um problema (SZWARCFIER; MARKENZON,1994);

» sequência de passos que visam atingir um objetivo bem definido (FORBELLONE;

EBERSPACHER, 2000); » sequência ordenada de passos que deve ser seguida para a realização de uma tarea

(SALIBA, 1993; BERG; FIGUEIRÓ, 1998).

Um programador de computador poderá criar um projeto de algoritmo utilizando uma repre-sentação gráfica (diagrama de blocos) ou até mesmo uma representação textual (português estrutu-rado). Ambas são bastante utilizadas no mercado e podemos defini-las como:




» Representação gráfica: conjunto de símbolos que representam todos os passos do algo-ritmo. Cada símbolo possui uma ação específica a ser executada.

» Representação textual: o português estruturado é uma orma genérica (sem considerarlinguagens de programação) de representar as ações do algoritmo.

1.3 Paradigmas de programaçãoNo mundo da programação, existem algumas ormas ou metodologias para a construção de

algoritmos. A essas metodologias, dá-se o nome de paradigma de programação. As mais conhecidassão o paradigma de programação estruturada e o paradigma da programação orientada a objetos(MANZANO; FIGUEIREDO, 2012).

» No Paradigma Orientado a Objetos ou simplesmente Programação Orientada a Objetos, oprogramador abstrai um programa como uma coleção de objetos que interagem entre si;

» No Paradigma Estruturado ou apenas Programação Estruturada, o algoritmo é construídocomo sequência linear de unções ou módulos.

Neste livro, daremos ênase à programação estruturada que, entre outras, apresenta as seguin-tes vantagens:

» acelera o processo de construção do programa;

» simplifica e reconhece as alhas apresentadas pelos programas;

» por meio de módulos (também chamados de unções ou procedimentos), aprimora a reu-tilização de códigos;

» simplifica a leitura dos programas;

»

simplifica as alterações e atualizações dos programas; » simplifica a manutenção dos programas.

Na construção de um algoritmo estruturado, fique atento para as recomendações a seguir:

» preste atenção no problema a ser resolvido, no objetivo a ser alcançado, compreendendosua complexidade e destacando os pontos principais;

» defina os dados de entrada, ou seja, quais dados serão ornecidos ao programa;

» defina quais inormações saíram do programa depois do processamento;

» defina quais cálculos arão parte do processamento.

Se o projeto de determinado algoritmo é extenso e longo, ele poderá consumir semanas oumeses de desenvolvimento. Neste caso, será necessária uma equipe de programadores trabalhandoem conjunto sob a supervisão de um programador-chee. Nesse contexto, recomenda-se observar osseguintes passos:

» as instruções devem estar em sequências e ligadas entre si apenas por estruturas de sele-ção, tomadas de decisão ou laços de repetição;

» escreva instruções em grupos pequenos e combine-as na orma de sub-rotinas ou demódulos estruturados;




» distribua módulos do programa entre os dierentes programadores que trabalharão sob asupervisão de um programador-sênior, chee de programação ou analista de sistemas deinormação;

» revise o trabalho executado em reuniões regulares e previamente programadas, em quecompareçam apenas programadores do mesmo nível.

Em 1961, no Instituto Tecnológico de Aeronáutica (ITA), foi criado o primeiro computador brasileiro, chamado Zezinho.No ano seguinte, ele foi desmontado e suas peças foram usadas em outros projetos.

Fique de olho!

1.4 Diagrama de blocos

O diagrama de blocos caracteriza-se por um conjunto de símbolos gráficos, cada qual repre-sentando uma ação específica e básica a ser executada por um computador. O diagrama de blocosmostra a linha de raciocínio usada pelo programador para resolver o problema proposto.

odos os símbolos adotados pelo diagrama de blocos estão normatizados na ISO 5807:1985(E) e este deve ser construído de modo que outros profissionais da área de desenvolvimento de pro-gramas (analistas de sistemas e programadores) entendam o que certo desenvolvedor quis dizersobre o que o programa eetivamente az sem haver preocupação com os rigores sintáticos de qual-quer linguagem de programação que tenha sido usada.

abela 1.1 - Os principais símbolos utilizados

Símbolo Significado Descrição

Terminal Representa a definição de início e fim do fluxo lógico a ser definido em um pro-grama. É utilizado também na definição de sub-rotinas.

Entrada manual Representa a definição de entrada manual de dados, comumente realizada pormeio de um teclado conectado ao computador.

Processamento Representa a definição da execução de ações de processamento normalmenterelacionadas a operações matemáticas.

Exibição Representa a definição de execução da operação de saída de dados em ummonitor de vídeo conectado ao computador.

DecisãoRepresenta a definição de desvios condicionais nas operações de tomadas dedecisões e laços condicionais para repetição de trechos de programa.

PreparaçãoRepresenta a definição de execução de um laço incondicional que permite amodificação de instruções ou grupo de instruções limitadas no laço.

Processo predefinidoRepresenta a definição de um grupo de operações relacionadas a uma sub-rotinade processamento.

Conector Representa pontos de conexão entre trechos de programas apontados a outraspartes do diagrama de blocos.

LinhaRepresenta os vínculos existentes entre os símbolos de um diagrama de blocos.Deve ter a ponta de uma seta indicando a direção que o fluxo de um programadeve seguir.




Exercício resolvido

Construa o diagrama de bloco para calcular e imprimir a soma de dois números inteiros or-necidos pelo usuário.

Solução

Início

N1, N2

RESULTADO N1+N2

RESULTADO

Fim

Figura 1.7 - Diagrama de bloco para o cálculo da soma de dois números.

1.5 Linguagem de projeto de programação

Você viu que um algoritmo pode ser escrito por meio de uma representação gráfica (diagrama

de bloco). Contudo, podemos representar o mesmo algoritmo por meio de uma linguagem de projeto de programação, que é muito semelhante à linguagem utilizada para a nossa comunicação.

Assim como os diagramas de blocos, a linguagem de projeto de programação deve ser simplesao ponto de qualquer pessoa que não conheça as rotinas de programação entender o raciocínio utili-zado para resolver o problema em questão.

Neste trabalho, utilizaremos o português estruturado, ou simplesmente pseudocódigo oualgoritmo, para reerenciar a resolução de um problema em uma linguagem de projeto de progra-mação. Uma vez que o algoritmo é traduzido para uma linguagem de programação específica (porexemplo, C, C++, Pascal, BASIC, Lua, Java, PHP etc.) o chamaremos de programa.

» Algoritmo: cojunto sequencial finito de instruções definidas em ordem lógica para resolver um problema ou problemas da mesma natureza.

» Programa: o programa é por sua natureza.

O programador, ao escrever um algoritmo, deverá ficar atento à lógica e à sequência dos pas-sos empregados na resolução do problema e não deverá se preocupar com a sintaxe da linguagem deprogramação, já que não se sabe em qual linguagem será implementado.





Construa o algoritmo para calcular e imprimir a soma de dois números inteiros ornecidospelo usuário.

Português estruturado

programa SOMA

var

N1, N2, RESULTADO : real

inicio

leia N1, N2

RESULTADO ← N1 + N2

escreva RESULTADO

m

Um computador quântico é um equipamento com a capacidade de executar cálculos com base no uso de propriedades deMecânica Quântica, como interferência e sobreposição. Um exemplo de computador desse tipo é o D-Wave Two, desen-volvido pela empresa D-Wave Systems, Inc.

Fique de olho!

1.6 Interpretadores, compiladores e tradutores

Para que um programa seja executado por um computador, é necessário que se aça a con- versão do algoritmo escrito em linguagem de alto nível (C, C++, Pascal, PHP, Java etc.) para umalinguagem de máquina (codificação binária), pois só dessa orma o computador irá executá-lo.O algoritmo escrito em linguagem de alto nível recebe o nome de código-onte (ou programa o-ne) e o algoritmo resultado é denominado código executável (ou programa executável).

De modo geral, dá-se o nome de compilador a qualquer sofware que az essa conversão,porém, existem três métodos dierentes para se gerar o código executável:

» interpretadores;

» compiladores;

» tradutores.

1.6.1 Interpretadores

São chamados interpretadores quando o programa conversor lê uma instrução do código--onte, a converte em instrução de máquina (código binário) e já a executa. Em seguida, ele pega apróxima instrução e repete o processo até que todas as instruções sejam executadas.




» Vantagens

Correções e alterações são realizadas mais rapidamente.

Consome menos memória.

» Desvantagens

Execução mais lenta (necessidade de interprestar comando por comando).

Necessidade de sempre ler o código original (código-onte) para que ele seja executado.

Exemplos: Javascript, Lua, Ruby, PHP etc.

1.6.2 Compiladores

Um compilador trabalha de orma semelhante ao interpretador, porém, ao final do processo deconversão, é gerado um arquivo chamado código executável (programa executável). O código execu-tável é um arquivo binário que será executado diretamente pela máquina sem a necessidade de inter-pretação linha a linha.

» Vantagens

É executado de orma mais rápida e diretamente ao nível de máquina.

» Desvantagens

A manutenção só é possível a partir do código-onte.

O código executável gerado só poderá ser executado em máquinas de mesma arquitetura.

Exemplos: C, C++, C#, Pascal etc.

1.6.3 TradutoresExiste um terceiro método que trabalha de orma intermediária entre os compiladores e inter-

pretadores. Um tradutor gera, a partir do código-onte, um código intermediário, mas que não exigetanto espaço de memória quanto o código original. É gerado, a partir do código intermediário, ocódigo executável da orma que um interpretador unciona.

» Vantagens

Independência da arquitetura que ará a execução final.

» Desvantagens

Necessidade de um interpretador específico na máquina do usuário final que ará a inter-pretação.

Exemplo: Java




A equipe de desenvolvimento deverá escolher entre os diversos tipos de erramentas de pro-gramação, ou linguagens de programação, disponíveis no mercado, levando em consideração diver-sos atores como hardware, sistema operacional, velocidade de execução, limitação tecnológica etc.

1.7 Recomendações para resolução de problemas

A construção de algoritmos requer tempo e paciência, porém, em diversas literaturas, são cita-das algumas técnicas que acilitam e aceleram esse processo. Antes de começar a desenhar o dia-grama de blocos, que irá orientar a construção do algoritmo e, por fim, a elaboração do programa,deve-se ficar atento ao problema a ser resolvido, ou seja, ao objetivo a ser alcançado, que é o que oprograma deverá gerar de saída. ambém deve-se pensar em quais dados serão necessários parao processamento, em como esses dados serão processados e em quais cálculos devem ser criados.

Observe, a seguir, quatro regras simples para a construção dos diagramas de blocos de ormacorreta:

1) Níveis: divida os diagramas de blocos em vários níveis. Os primeiros devem conter apenasas ideias principais e não os detalhes. Deixe o refinamento para as etapas seguintes.

2) De cima para baixo: uma boa prática é sempre construir os blocos de cima para baixo.

3) Não cruzar linhas: evite e, se possível, nunca cruze as linhas de fluxo de dados nos diagra-mas de bloco.

4) Português estruturado: assim que os diagramas de blocos orem concluídos, transcrevapara o português estruturado.

Exercício resolvidoUm uncionário recebe determinado salário mensal. Faça um programa que leia o valor dosalário mensal e o índice (em porcentagem) do reajuste a ser concedido. O programa deveráimprimir na tela o novo salário do uncionário.

Solução

Em primeiro lugar, devemos entender o principal problema a ser resolvido. Nesse caso, calcu-lar o valor do novo salário.

A segunda etapa apresenta um detalhamento no que se reere à entrada e saída, ou seja, deve--se entrar com o valor do salário atual e com o índice do reajuste para que, após o cálculo, sejaexibido o valor do novo salário.





Na terceira etapa, vamos trabalhar o processo de gerar o cálculo do novo salário, introduzin-do o conceito de variáveis (você verá mais sobre isso nos próximos capítulos). Serão digitadosdois valores, um para o salário atual e outro para o índice de reajuste (em porcentagem). Com

esses dados, será calculado o novo salário. Sendo assim, temos a Figura 1.9.

Início

SALÁRIO, ÍNDICE

novoSalário salário + salário índice/100

novoSalário

Fim

Figura 1.9 - Diagrama de bloco nível 2 para o cálculo do novo salário.

Você viu, na Figura 1.10, a primeira orma de notação gráfica. Agora, iremos transcrever o dia-grama de blocos para uma orma narrativa denominada pseudocódigo ou português estruturado.

O português estruturado se aproxima muito da linguagem (por exemplo, PASCAL, C,FORRAN, BASIC, JAVA, PHP etc.) utilizada pelos computadores para gerarem o programa a

ser executado, porém, não tem o mesmo rigor sintático de sua escrita.

A seguir, é apresentado um exemplo do algoritmo escrito em português estruturado.

programa SALARIO

var

SALÁRIO, ÍNDICE, NOVOSALÁRIO: real

inicio

leia SALÁRIO , ÍNDICE

NOVOSALÁRIO ← SALÁRIO + SALÁRIO * ÍNDICE / 100

escreva NOVOSALÁRIO

m

1.8 Tabela ASCII

A tabela ASCII (pronúncia é “asqui”), ou American Standard Code or Inormation Interchange (Código Americano Padrão para Intercâmbio de Inormações), é composta por 256 símbolos, que sãoutilizados pelos computadores eletrônicos. Foi criada entre os anos de 1963 e 1968 com participação e




colaboração de várias companhias de comunicação norte-americanas, com o objetivo de substituir oaté então utilizado código de Baudot, que era limitado apenas a 32 combinações dierentes.

As tabelas a seguir mostram, respectivamente, a tabela ASCII padrão e a parte estendida utili-zada para a representação de caracteres da página de código 850 definida pela Microsof, destinadasaos caracteres acentuados usados em diversos idiomas.

abela 1.2 - abela ASCII padrão (códigos de caracteres 0-127)

000d 00h (nul)

001d 01h ☺ (soh)

002d 02h ☻ (stx)

003d 03h ♥ (etx)

004d 04h ♦ (eot)

005d 05h ♣ (enq)

006d 06h ♠ (ack)

007d 07h • (bel)

008d 08h ◘ (bs)

009d 09h ○ (tab)010d 0Ah ◙ (lf)

011d 0Bh ♂ (vt)

012d 0Ch ♀ (np)

013d 0Dh ♪ (cr)

014d 0Eh ♫ (so)

015d 0Fh ☼ (si)

016d 10h ► (dle)

017d 11h ◄ (dc1)

018d 12h ↕ (dc2)

019d 13h ‼ (dc3)

020d 14h ¶ (dc4)

021d 15h § (nak)022d 16h ▬ (syn)

023d 17h ↕ (etb)

024d 18h ↑ (can)

025d 19h ↓ (em)

026d 1Ah → (eof)

027d 1Bh ← (esc)

028d 1Ch ∟ (fs)

029d 1Dh ↔ (gs)

030d 1Eh ▲ (rs)

031d 1Fh ▼ (us)

032d 20h

033d 21h !

034d 22h "

035d 23h #

036d 24h $

037d 25h %

038d 26h &

039d 27h '

040d 28h (

041d 29h )

042d 2Ah *

043d 2Bh +

044d 2Ch ,

045d 2Dh -

046d 2Eh .

047d 2Fh /

048d 30h 0

049d 31h 1

050d 32h 2051d 33h 3

052d 34h 4

053d 35h 5

054d 36h 6

055d 37h 7

056d 38h 8

057d 39h 9

058d 3Ah :

059d 3Bh ;

060d 3Ch <

061d 3Dh =

062d 3Eh >063d 3Fh ?

064d 40h @

065d 41h A

066d 42h B

067d 43h C

068d 44h D

069d 45h E

070d 46h F

071d 47h G

072d 48h H

073d 49h I

074d 4Ah J

075d 4Bh K

076d 4Ch L

077d 4Dh M

078d 4Eh N

079d 4Fh O

080d 50h P

081d 51h Q




082d 52h R

083d 53h S

084d 54h T

085d 55h U

086d 56h V

087d 57h W

088d 58h X

089d 59h Y

090d 5Ah Z

091d 5Bh [

092d 5Ch \

093d 5Dh ]

094d 5Eh ^

095d 5Fh _

096d 60h `

097d 61h a

098d 62h b

099d 63h c

100d 64h d101d 65h e

102d 66h f

103d 67h g

104d 68h h

105d 69h i

106d 6Ah j

107d 6Bh k

108d 6Ch l

109d 6Dh m

110d 6Eh n

111d 6Fh o

112d 70h p

113d 71h q

114d 72h r

115d 73h s

116d 74h t

117d 75h u

118d 76h v

119d 77h w

120d 78h x

121d 79h y

122d 7Ah z

123d 7Bh {124d 7Ch |

125d 7Dh }

126d 7Eh ~

127d 7Fh ⌂

abela 1.3 - abela ASCII estendida (códigos de caracteres 128-255; página de código 850)

128d 80h Ç

129d 81h ü

130d 82h é

131d 83h â

132d 84h ä

133d 85h à

134d 86h å

135d 87h ç

136d 88h ê

137d 89h ë

138d 8Ah è

139d 8Bh ï

140d 8Ch î

141d 8Dh ì

142d 8Eh Ä

143d 8Fh Å144d 90h É

145d 91h æ

146d 92h Æ

147d 93h ô

148d 94h ö

149d 95h ò

150d 96h û

151d 97h ù

152d 98h ÿ

153d 99h Ö

154d 9Ah Ü

155d 9Bh ø

156d 9Ch £

157d 9Dh Ø

158d 9Eh ×

159d 9Fh ƒ

160d A0h á

161d A1h í

162d A2h ó

163d A3h ú

164d A4h ñ

165d A5h Ñ

166d A6h ª

167d A7h º168d A8h ¿

169d A9h ®

170d AAh ¬

171d ABh ½

172d ACh ¼

173d ADh ¡

174d AEh «

175d AFh »




176d B0h ░ 177d B1h ▒ 178d B2h ▓179d B3h │180d B4h ┤181d B5h Á

182d B6h Â

183d B7h À

184d B8h ©

185d B9h ╣186d BAh ║187d BBh ╗188d BCh ╝189d BDh ¢

190d BEh ¥

191d BFh ┐192d C0h └ 193d C1h ┴

194d C2h ┬ 195d C3h ├ 196d C4h ─ 197d C5h ┼ 198d C6h ã

199d C7h Ã

200d C8h ╚ 201d C9h ╔ 202d CAh ╩

203d CBh ╦ 204d CCh ╠ 205d CDh ═ 206d CEh ╬ 207d CFh ¤208d D0h ð

209d D1h Ð

210d D2h Ê

211d D3h Ë

212d D4h È

213d D5h ¹

214d D6h Ì

215d D7h Î

216d D8h Ï

217d D9h ┘218d DAh ┌ 219d DBh █ 220d DCh ▄ 221d DDh ¦

222d DEh Ì

223d DFh ▀ 224d E0h Ó

225d E1h ß

226d E2h Ô

227d E3h Ò

228d E4h õ

229d E5h Õ

230d E6h µ

231d E7h Þ

232d E8h þ

233d E9h Ú

234d EAh Û235d EBh Ù

236d ECh ý

237d EDh Ý

238d EEh ¯

239d AFh ´

240d F0h -

241d F1h ±

242d F2h =

243d F3h ¾

244d F4h ¶

245d F5h §

246d F6h ÷

247d F7h ¸

248d F8h °

249d F9h ¨

250d FAh ·

251d FBh ¹

252d FCh ³

253d FDh ²

254d FEh ■255d FFh

Foi apresentado a você um panorama básico da história do computador, bem como os conceitosde lógica de programação de computadores, suas ormas de representação em diagrama de blocos e por-tuguês estruturado, permitindo um contato inicial com o conteúdo que será abordado mais detalhada-mente ao longo desta obra.

Vamos recapitular?




gora é com você

1) Considerando o que oi estudado neste capítulo, explique:

a) Por que o ábaco tem sido considerado o precursor dos computadores.

b) A importância do matemático George Boole para a computação.

2) Apresente as principais recomendações estudadas para a construção de algoritmosem computação.

3) Explique em poucas palavras a dierença entre algoritmo e programa. odo algorit-mo poderia se tornar um programa? Por quê?



25

2ProgramaçãoSequencial

Neste capítulo, vamos estudar uma das mais importantes técnicas de programação de computado-res: a programação sequencial. Ao final do capítulo, será possível identificar e implementar programas

sequenciais usando tipos primitivos de dados, variáveis, constantes, operadores undamentais e mecanis-mos básicos de entrada de dados, processamento e saída de dados.

Para começar

2.1 Etapas operacionais

Programa sequencial, como o próprio nome diz, é um conjunto de rotinas programáveis executa-das em sequência, ou seja, uma após a outra. Podemos organizar essas rotinas em três macroetapas:

» entrada de dados;

»

processamento de dados; » saída de dados.

Durante a entrada de dados, o computador recebe os dados que serão processados. Esses dadospodem ser ornecidos pela pessoa que opera o programa ou por outro programa; por exemplo, aaltura e o peso (massa corporal) de uma pessoa. Para realizar essa etapa, o computador emprega ins-truções específicas da linguagem de programação utilizada.

Somente após a entrada de algum dado será possível passar à etapa de processamento de dados.Nesse momento, o computador será capaz de transormar os dados inseridos por meio de operações




lógicas e/ou aritméticas, como em um cálculo de índice de massa corporal, ou, ainda, utilizá-los parageração de outros dados e inormações.

A última etapa, saída de dados, só ocorre após haver algum tipo de processamento, pois elaapresenta os dados novos ou transormados por ele, com os quais é possível verificar situações etomar decisões; por exemplo, procurar estudar mais a fim de aprender e ser considerado aprovado

em determinada disciplina, ao verificar que, após o cálculo, a média parcial do aluno está muitoabaixo do valor mínimo para aprovação.

2.2 Tipos de dados

No mundo real, manipulamos dierentes tipos de dados para representar as mais variadasinormações, além de sentimentos, desejos e intenções, como representações visuais (cores, luzes),táteis (texturas) e cinestésicas (eições e gestos).

Na computação, os dados devem ser definidos de acordo com tipos predefinidos pela linguagemde programação ou estabelecidos pelo programador. Os tipos predefinidos são conhecidos como tipos

primitivos de dados. Para eetuar qualquer uma das etapas da programação sequencial, é necessáriodefinir os dados de modo que o computador compreenda o tipo de inormação que eles representam.

Os tipos primitivos estão organizados em três grupos:

» Numéricos: representam valores numéricos, como preços de produtos, volume de umaembalagem, altura de uma pessoa.

» Caracteres: representam valores alabéticos ou que combinem algarismos numéricos ealabéticos (alanuméricos), como o nome de uma pessoa, o endereço de um estabeleci-mento, o teleone de um consultório médico.

» Lógicos: representam valores lógicos, ou seja, que só podem ser verdadeiros ou alsos; por

exemplo: indicar se alguém está ou não aprovado ou, ainda, se tem direito ou não a isen-ção de pagamento de passagem no transporte coletivo.

Os dados numéricos podem, ainda, ter uma subclassificação, a depender do tipo de númeroque representam na memória do computador: inteiro ou real. Para entender melhor, acompanhe asexplicações nos tópicos a seguir.

2.2.1 Dado numérico inteiro

O dado numérico do tipo inteiro, positivo ou negativo, pertence ao conjunto dos númerosinteiros (o mesmo da Matemática - Z), ou seja, todos aqueles que não são racionários. São valores

numéricos inteiros: 1; −567; 0; 8.980; −8, entre outros.

2.2.2 Dado numérico real

O dado numérico do tipo real, positivo ou negativo, pertence ao conjunto dos números reais(o mesmo da matemática - R), ou seja, todos aqueles que são racionários. São valores numéricosreais: −1.2; −567; 0; 8.980; 8.9 (por questões de paridade computacional, está sendo usado o pontocomo separador de casas decimais em vez da orma oficial do idioma), entre outros. Perceba quetodo número inteiro também é real, mas o contrário não é verdade.



27Programação Sequencial

2.2.3 Dado caractere/cadeia

O dado do tipo caractere costuma ser representado por um único símbolo entre aspas ingle-sas (“ ”). Os valores podem ser representados isoladamente por letras (maiúsculas ou minúsculas),numerais (0-9) e símbolos do computador, como aqueles presentes no teclado.

Quando o valor caractere possui mais de um símbolo (mais de uma letra, número ou outros

símbolos do teclado entre aspas inglesas), o dado que o representa é chamado de cadeia de caracteres ou string (que significa cordão ou colar). Podemos considerar exemplos de cadeia os valores: “Pro-gramação de computadores”, “CEP: 03909-020”, “Av. São Luiz, 340” e “8.908” e como exemplos decaracteres “A”, “b”, “1” e “-”.

O espaço em branco (“ ”) também é um caractere e deve ser considerado como tal.

Fique de olho!

Geralmente, não conseguimos azer cálculos com dados do tipo string, sendo mais utilizados

em operações de entrada e saída de dados, como receber o nome de um profissional (entrada dedados) ou emitir um parecer sobre sua habilitação (saída de dados).

2.2.4 Dado lógico

ambém conhecido como booleano, é o tipo de dado mais simples, caracterizando-se porrepresentar apenas valores binários, ou seja, que indiquem duas possibilidades. São exemplos de valores binários: verdadeiro e also; 1 e 0; sim e não. Apenas um desses valores pode ser atribuído,por vez, a um dado lógico.

2.3 Variáveis

Variável é uma entidade computacional que representa um espaço reservado na memóriado computador para armazenamento de dados durante a execução de um programa. Esses dadospodem sorer modificação ao longo da execução do programa, por isso têm esse nome.

Para definir as variáveis, é necessário atribuir um nome a elas, conhecido como identificador .Identificar previamente as variáveis é muito importante para usá-las adequadamente no programa.Em muitas linguagens, isso é obrigatório. Antes de identificar as variáveis, é preciso saber que tipode dado elas representarão. Você pode, inclusive, definir um padrão de nomenclatura para acilitar aidentificação do tipo de dado que a variável contém.

Além disso, há algumas regras que todo programador deve seguir ao estabelecer o nome deuma variável:

» Inicie o nome apenas por caractere alabético ou “_” (underline); nenhum outro caractereé aceito no início de um identificador (nome de variável).

» Não utilize caracteres especiais na nomenclatura de uma variável (é, ç, ã, &, %, #, @, *, -,entre outros), exceto o caractere “_” (underline).




» Se a variável or identificada por um nome composto, não pode haver espaço em branco;um modo comum de identificar variáveis com nomes compostos é utilizar o caractere “_”(underline).

» Não escolha nomes que já sejam utilizados pela linguagem de programação para representarcomandos ou instruções predefinidas; esses nomes são chamados de palavras reservadas.

»

Crie identificadores que representem o conteúdo da variável. » Não utilize o mesmo nome para mais de uma variável.

São exemplos de nomes válidos: ipoDeInvestimento; CPF_itular; FUNCIONAL_SEOR10;endereco. Por sua vez, os identificadores a seguir não são válidos, pois violam as regras expostasanteriormente: Endereço; 1a.Avaliacao; 7FONE; Resultado#Calculo; E-mail.

Há, ainda, palavras reservadas às linguagens de progra-mação (mas isso varia conorme a linguagem), as quais orampreviamente definidas para uncionarem como comandos ou ins-truções do computador, não podendo ser usadas para outro fim.

Para declarar variáveis em algoritmos, ou seja, criar variá- veis com identificador único, utilizamos o comando var . Logoabaixo da palavra var podemos indicar as variáveis que deseja-mos criar, sempre respeitando a sintaxe apresentada a seguir:

var

<identicador da variável> : <tipo primitivo associado à variável>

2.4 Constantes

Além das variáveis, temos as entidades conhecidas como constantes, que são valores fixos, está- veis. Uma vez atribuído, o valor de uma constante mantém-se o mesmo até o final da execução doprograma.

Constantes são muito úteis na definição de valores que serão usados diversas vezes no pro-grama e que não devem sorer alteração. Como exemplos, temos a grandeza matemática pi (π), cujo valor aproximado é 3,14159, ou, ainda, a alíquota base de cálculo do INSS (11%).

No programa, esses valores poderiam ser definidos como constantes e ser representados pelosidentificadores dessas constantes. Por exemplo: pi e aliquota_inss.

Para declarar constantes em algoritmos, ou seja, criar constantes com identificador único, uti-lizamos o comando const . Logo abaixo da palavra const podemos indicar as constantes que deseja-mos criar, sempre observando a sintaxe apresentada a seguir:

const

PI = 3.14159

ALIQUOTA_INSS = 0.11

Os identificadores são de uso único.

Em geral, algumas palavras reservadassão típicas, tais como: int, integer, real,

boolean, function, result, return, entre outras.




As regras para definição dos identificadores de constantes são as mesmas utilizadas paranomear variáveis.

2.5 Operadores aritméticos

Para realizar cálculos, os programas azem uso de operadores aritméticos. odas as operaçõesmatemáticas realizadas pelo computador são realizadas por meio de operadores aritméticos, quepodem ser binários ou unários. Os operadores binários são aqueles que são utilizados com dois ope-randos; por exemplo, o operador de soma (+): A + B. Os operadores unários são aqueles que reali-zam operações aritméticas com apenas um operando; por exemplo, a inversão de sinal: −A.

O Quadro 2.1 apresenta alguns dos operadores aritméticos utilizados na concepção de algorit-mos programáveis. Assim como na aritmética, na computação os operadores têm ordem de prece-dência; por isso, sempre que or preciso, utilize parênteses para deixar clara a ordem de prioridadeda operação.

Quadro 2.1 - Operadores aritméticos

Operador Descrição Tipo Prioridade Resultado Exemplo

+ x Manutenção de sinal Unário sem Inteiro ou real +3

– x Inversão de sinal Unário sem Inteiro ou real –4

x ↑ a Exponenciação de xa Binário 1 Inteiro ou real RAIO ↑ 2

x ↑ (1 / a) Radiciação de a√x Binário 1 Inteiro ou real VOLUME ↑ (1 / 3)

x / z Divisão de x por z Binário 2 Real MEDIA / 3

x * z Multiplicação de x por z Binário 2 Inteiro ou real SALARIO * BONUS

x – z Subtração de x e z Binário 3 Inteiro ou real SALARIO – IRRFx + z Adição de x e z Binário 3 Inteiro ou real SALARIO + COMISSAO

x div z Divisão de x por z Binário 4 Inteiro QTDPRATOS div CLIENTES

A operação matemática para o cálculo da exponenciação é definida de maneira muito variada nas linguagens de progra-mação de computadores. Considerando a operação de ax, esse cálculo pode ser executado, dependendo da linguagem deprogramação em uso, como: pow(a,x); power(a,x); a^x ou a**x, entre outras formas. No entanto, há uma maneira gené-rica de realizar esse cálculo: por meio das funções dos logaritmos neperiano e exponencial, com base na expressão ex ln a,que pode ser escrita de modo genérico - para as linguagens de programação - pela expressão exp(x * ln(a)), considerando que

as funções exp() e ln() podem ser referenciadas, na linguagem em uso, de modo um pouco diferente do apresen-tado neste livro, mas mantendo essa característica.

Fique de olho!

2.6 Expressões aritméticas

Para a realização de muitos dos processamentos computacionais, é necessário utilizar expres-sões aritméticas, cuja sintaxe diere da sintaxe matemática.




Por exemplo, considere o cálculo do salário dos uncionários de uma empresa de logística, cujaórmula é a seguinte: SALÁRIO = COMISSÃO2 – (SALÁRIO x ALÍQUOA DO INSS). SALÁRIO eCOMISSÃO contêm valores que variam conorme o uncionário. Por sua vez, ALÍQUOA DO INSSpossui um valor fixo (0.11) que vale para todos os uncionários daquela instituição.

Ao converter essa órmula na linguagem computacional, é preciso azer algumas adequações.

A primeira é definir os identificadores das variáveis e das constantes, de acordo com as regras estudadas.A segunda é substituir os operadores matemáticos pelos aritméticos da computação. Por exemplo, osímbolo que representa a operação de multiplicação - x - será substituído pelo operador *.

Logo, a órmula do salário ora apresentada poderia ser implementada no algoritmo da seguinteorma:

SALARIO ← (COMISSAO ↑ 2) – (SALARIO * ALIQUOA_INSS)

ou

SALARIO ← (COMISSÃO * COMISSAO) – (SALARIO * ALIQUOA_INSS)

Em programação, utilizamos parênteses para indicar qualquer ordem de prioridade; logo, aschaves e os colchetes empregados em operações aritméticas, na matemática, são substituídos pelosparênteses. O sinal de igual (=) também é substituído pelo sinal de atribuição de valores (←); eleindica que o valor da expressão aritmética será armazenado na variável à esquerda do sinal. Noexemplo, o cálculo será armazenado na variável SALARIO. Antes de eetuar a atribuição, o compu-tador limpa o conteúdo da variável para não haver intererência do valor antigo sobre o novo valor.

Considere, ainda, a necessidade de representar a órmula de cálculo da área da coroa circular:

r

R A = (R2 r2)cc

Figura 2.1 - Representação do cálculo da área da coroa circular.

Na órmula, π é um valor constante (π = 3,14159), R é o raio do círculo e r é o raio do círculoinscrito.

Para computarmos essa órmula, é necessário converter seus símbolos nos correspondentes emcomputação, ficando da seguinte orma:

A ← PI * (R ↑ 2 – r ↑ 2)

ou

A ← PI * ((R * R) – (r * r))

A constante PI guarda o valor de π.




O programador deve converter expressões matemáticas em expressões aritméticas computa-cionais equivalentes, de modo que o cálculo seja realizado corretamente.

2.7 Instruções e comandos

Os comandos são definidos pela linguagem de programação utilizada, ou seja, variam con-orme a linguagem. São representados por palavras reservadas, definidas no conjunto que chamamosde gramática da linguagem. A gramática da linguagem define todas as regras de uso da linguagem deprogramação, bem como o seu uncionamento. O conjunto de todas as palavras reservadas da lin-guagem de programação é conhecido como vocabulário. Portanto, comandos com a mesma unçãopodem ter grafias dierentes em linguagens distintas, mas executar a mesma ação. Por exemplo, paraescrever a saída de dados na linguagem C, utilizamos a instrução print(“%d”, valor). Para a mesmainstrução na linguagem Pascal, utilizamos write (valor). Já em português estruturado, usamos a ins-trução leia valor.

Programadores também podem criar os próprios comandos, a depender da linguagem de pro-

gramação utilizada. De modo geral, os comandos servem para indicar ao computador uma ação aser tomada, como ler um valor, que pode ser a nota de um aluno ou a quantia solicitada para saque,por exemplo. O conjunto de comandos ordenados denomina-se instrução.

Citamos, no início do capítulo, que a programação sequencial pode ser dividida em três eta-pas: entrada de dados, processamento e saída de dados. Para a leitura de dados, é imprescindívelsolicitá-los à onte de dados, a qual pode ser o próprio usuário. Podemos, por exemplo, solicitar queo usuário inorme quanto ele deseja sacar. Em português estruturado (uma das notações que utiliza-mos para construir algoritmos), o comando que inorma algo na tela para o usuário é o escreva (porexemplo, escreva “Qual é o valor do saque?”); o comando que lerá o valor digitado pelo usuário no

teclado será o leia (por exemplo, leia valor_saque). Esses dois comandos, juntos, ormam uma ins-trução de entrada de dados.

As instruções devem ser passadas corretamente para o computador; senão, corre-se o risco deele executar ações não desejadas e, até mesmo, de não uncionar. Portanto, é preciso ter cuidado aoescolher os comandos que serão usados e escrevê-los corretamente, seguindo as regras de cada lin-guagem. Por enquanto, trabalharemos com a linguagem algorítmica, que é genérica e mais flexível,mas, aos poucos, você conhecerá sintaxes (modos de escrever) de outras linguagens de programação.

Citamos a escrita em tela de computador (saída) e a leitura do teclado, mas existem outras or-mas de entrada e saída de dados. Por exemplo, podemos escrever dados em uma impressora, em fitas

magnéticas, em discos (como CD e DVD) etc. O programa também pode ler dados de outras ontes,como discos, arquivos na Internet, leitores ópticos (como aqueles que decodificam códigos de bar-ras), entre outras.

Por conta da vasta possibilidade de mecanismos de entrada e saída de dados, os algoritmosserão escritos, neste livro, utilizando leia como comando de entrada de dados e escreva como coman-do de saída de dados.




Diagrama de bloco

Diagrama de bloco é uma notação utilizada para descrever algoritmos. Veja na Figura 2.2alguns dos símbolos mais comuns.

Entrada manual de dados Saída-padrão de dados

Figura 2.2 - Estrutura dos símbolos para as instruções de entrada e de saída de dados.


Outra forma de descrever algoritmos é por meio do formato português estruturado, em que oalgoritmo é definido textualmente, muito próximo de como será implementado no computador, masem idioma português. Por exemplo, podemos utilizar a seguinte sintaxe para escrever um pequeno

trecho de programa para saque bancário:[...]

escreva "Quanto deseja sacar?"

leia VALOR_SAQUE

se (SALDO >= VALOR_SAQUE) então

SALDO ← SALDO – VALOR_SAQUE

escreva "Saque realizado com sucesso, retire seu dinheiro."

senão

escreva "Saque não realizado."

fi m_se

[...]

rograma é um conjunto estruturado de instruç es que permitem ao computador realizar operaç es de transformaç o dedados. Para isso, o programa deve apresentar um conjunto de instruç es que indiquem ao computador como executarais operaç es. Essas instruç es s o formadas por estruturas de controle que variam de uma linguagem para outra. Osodos mais comuns de estruturaç o desse controle s o:

» struturação monolítica: baseada em desvios (condicionais ou n o).

» struturaç o iterativa: baseada em controle de iteraç o (ciclos); n o permite desvios incondicionais.

» struturaç o recursiva: baseada em mecanismos de sub-rotinas recursivas, ou seja, que se utilizam de si próprias paradefinir a próxima operaç o, sendo uma forma indutiva de especificar operaç es; assim como a estruturaç o iterativa,

o permite desvios incondicionais.

ara saber mais, leia Diverio e Menezes (2011).

Amplie seus conhecimentosAmplie seus conhecimentos




Para auxiliá-lo na compreensão do que oi apresentado, seguem alguns problemas resolvidoscom o uso de algoritmos computáveis.

Exemplo

Elaborar um programa de computador que calcule e apresente o volume de um cubo.Solução

Para calcular o volume de um cubo, é necessário conhecer dois elementos. O primeiro é a ór-mula de cálculo do volume de cubo, sendo V = L3, em que L é o valor de um dos lados do cubo(todos os lados têm o mesmo comprimento) e V é o volume calculado. Sendo assim, bastaestabelecer que a órmula matemática deve ser convertida em uma expressão aritmética algo-rítmica equivalente, que pode ser:

V ← L * L * L ou V ← L ↑ 3.

Diagrama de bloco

Início

L

V L 3

V

Fim

Figura 2.3 - Diagrama de blocos para o cálculo do volume do cubo.


programa VOLUME_CUBO

var

L : real

V : real

início

leia L

V ← L ↑ 3

escreva V

m




Desenvolver um programa que calcule o índice de massa corpórea (IMC) de uma pessoa. Paraelaborar o programa, é necessário possuir dois dados: altura e peso da pessoa. Para cálculo doIMC, a órmula matemática é a seguinte: IMC = peso (altura x altura).

Solução

Para solucionar o problema, é necessário realizar os seguintes passos:

1) Eetuar a leitura do peso da pessoa (quantidade de massa).

2) Ler a altura da pessoa.

3) Calcular o IMC.

4) Exibir o valor do IMC calculado.

A ordem de leitura dos dados de entrada não az dierença no cálculo e na computação dosdados.

Diagrama de bloco

INÍCIO

PESO;ALTURA

IMC PESO /(ALTURA ) ALTURA

IMC

FIM

Figura 2.4 - Diagrama de bloco do programa de cálculo do IMC.


programa IMC

var

IMC : real

PESO, ALTURA : real

início

leia PESO

leia ALTURA

IMC ← PESO / (ALTURA * ALTURA)

escreva IMC

m




Desenvolver um programa que calcule o IPVA, dado o valor venal do veículo. Considere a alí-quota única para cálculo de IPVA.

Solução

Para a solução do problema, considere a

existência de um valor constante que repre-sentará a alíquota do IPVA, não importa o valor do veículo, ou seja, um valor fixo quenão mudará ao longo do programa e que se-rá o mesmo para qualquer dado de entra-da. Nesse caso, podemos trabalhar comuma constante e duas variáveis. A constan-te representará a alíquota do IPVA e podeser nomeada como ALIQUOA. As variá- veis representarão o valor venal do veículo

e o resultado do cálculo do IPVA, poden-do ser identificadas como VALOR_VENAL e IPVA, respectivamente.

Diagrama de bloco

INÍCIO

VALOR_VENAL

IPVA VALOR_VENAL ALIQUOTA

IPVA

FIM

ALIQUOTA = 0.04

Figura 2.5 - Diagrama de bloco doprograma de cálculo do IPVA.


programa CALC_IPVA

const

ALIQUOTA = 0.04

var

VALOR_VENAL : real

IPVA : real

início

leia VALOR_VENAL

IPVA ← VALOR_VENAL * ALIQUOTA

escreva IPVA

m

Como regra geral de trabalho e de organização, as constantes com o comando const sempreserão definidas à rente das variáveis com o comando var.

Neste capítulo, estudamos alguns elementos undamentais da programação sequencial, como a defi-nição dos tipos de dados primitivos e sua finalidade. Vimos, também, identificadores, variáveis, constantes,operadores relacionais, expressões aritméticas e sua adequação à linguagem algorítmica, além das etapas deprocessamento de um programa sequencial (entrada de dados, processamento e saída de dados).

Vamos recapitular?




gora é com você

1) Quais sentenças a seguir são verdadeiras?

a) O dado −457,90 é do tipo numérico inteiro.

b) O dado 0 (zero) é do tipo numérico inteiro.

c) O dado <<verdadeiro>> é do tipo lógico.

d) odo dado numérico inteiro também é numérico real.

e) O dado “1,99” é do tipo numérico real.

) O dado “Rua A, quadra 2” é do tipo cadeia/string.

g) O dado −4 é do tipo numérico inteiro.

h) O dado “cinco” é do tipo numérico inteiro.

i) Na instrução leia numRG, numRG é considerado um dado de entrada. j) Após atribuir valor a uma constante, o computador aceita que esse valor seja

alterado apenas uma vez.

k) Nota é um identificador válido para uma variável/constante.

l) O identificador enDereco não é válido para uma variável/constante.

m) Fone&Email é um identificador válido para uma variável/constante.

n) E-mail não é um identificador válido para uma variável/constante.

2) Elabore algoritmos dos seguintes problemas, utilizando diagramas de blocos e codifi-

cação em português estruturado:a) Ler o valor gasto com combustível nos três primeiros meses do ano, calcular e

exibir a média aritmética desse gasto.

b) Ler a altura de um homem e calcular o peso ideal. O peso ideal, neste problema,deve ser calculado por meio da órmula Peso ideal = (K x altura) − B, sendo K =72.7 e B = 58.

c) Ler os valores X e Y e eetuar o swap, ou seja, a troca de valores entre X e Y. Aofinal, apresentar os novos valores de X e Y.

d) Ler o valor do raio de uma circunerência, calcular seu diâmetro e sua área e exi-bi-los. A órmula para cálculo da área de uma circunerência é Área = π x raio2,sendo π = 3.14159.

e) Ler um valor numérico inteiro e exibi-lo elevado à quarta potência.



37

3Programaçãocom Desvios

O objetivo principal deste capítulo é o estudo dos mecanismos para que possamos eetuar umatomada de decisão simples, composta ou encadeada, por meio do processamento lógico. Para que

uma tomada de decisão seja eetuada pela máquina, destacamos, também, operadores lógicos e relacionais.

Para começar

3.1 Tomada de decisões

Na construção de algoritmos, muitas vezes é necessário que uma parte do código só seja executa-da se determinada condição or satiseita. Essa condição é definida por uma expressão lógica cujoresultado sempre será um valor also ou verdadeiro. A expressão lógica, que testará as condiçõesimpostas pelo algoritmo, utiliza uma relação entre um par de elementos, o qual pode ser composto por variável versus variável ou variável versus constante, e um operador relacional (apresentado no pró-

ximo tópico).Ao desenvolver os diagramas de blocos, deve-se utilizar os símbolos de decisão e conexão,

conorme a Figura 3.1.

Figura 3.1 - Símbolos de decisão e conexão, necessários ao desenvolvimento de diagramas de blocos.




ocê sabia que o ENIAC (Electronic Numerical Integrator and Computer) é considerado o primeiro computador eletrônicodigital? Foi construído entre 1943 e 1945, entrando em operação em julho de 1946 com a finalidade de ser usado emcálculos de balística. Para seu funcionamento havia 17.468 válvulas, 1.500 relés, além de diversos outros componenteseletrônicos, pesando 30 toneladas! Os técnicos que o operavam trabalhavam dentro do computador.

ara saber um pouco mais, consulte: <http://www.hardware.com.br/guias/historia-informatica/eniac.html>. Acesso em:28 jan. 2014.


3.2 Operadores relacionais

Um operador relacional é utilizado para comparar a relação entre pares de valores definidospor variáveis ou constantes. Sempre deve existir um par de valores para determinar se a condição é verdadeira ou alsa.

Pela análise dos operadores relacionais, um computador consegue determinar as ações a serem

tomadas pela máquina. A abela 3.1 apresenta os operadores relacionais utilizados na programaçãode computadores.

abela 3.1 - Operadores relacionais

Operador Descrição

= Igual a

> Maior que

< Menor que

>= Maior ou igual a

<= Menor ou igual a<> Diferente de

Veja exemplos de operações válidas entre variáveis e constantes:

A = B; A > B; A < B; A >= B; A <= B; A <> B; A = 2; A > 2; A < 2; A >= 2; A <= 2; A <> 2

Observe que sempre deve existir um par de valores para a devida validação.

Exemplos de operações NÃO válidas:

A = B = C ou A > 5 > 2

odos os operadores relacionais possuem o mesmo nível de precedência, portanto não hánecessidade de se preocupar em alterá-lo.



39Programação com Desvios

3.3 Desvios condicionais

Com os conhecimentos adquiridos nos capítulos anteriores, já temos condições de resolverdiversos tipos de problemas que envolvam entradas de dados, processamentos e saídas com a utilizaçãode variáveis, constantes e operadores aritméticos. Em diversos casos, porém, para que o proces-samento seja mais adequado, a máquina deverá decidir quais trechos de código serão ou não execu-

tados, por meio dos desvios condicionais.

Basicamente, há três modos de desvio condicional: simples, composto e seletivo.

3.3.1 Desvio condicional simples

Em um desvio condicional simples, determinado bloco só será executado se a condiçãoimposta or verdadeira; caso contrário, todo o bloco será ignorado. No caso, utilizaremos a instru-ção: se...então...fim_se.

No diagrama de blocos da Figura 3.2, observe que a letra S representa sim, a fim de mostrar

o fluxo de execução quando a condição or verdadeira. Já a letra N representa não e será executadaquando a condição or alsa. Quando a condição or alsa, note que nada será executado. O símbolode decisão deve ser utilizado quando houver a necessidade de tomar uma decisão no programa.

Diagrama de blocos

N SCondição

Bloco de comandos quesó será executado quandoa condição for verdadeira

Bloco de comandos quesempre será executado

Figura 3.2 - Estrutura do símbolo para a instrução se...então...fim_se.


se (<condição>) então

<Bloco de comandos que só será executado quando a condição for verdadeira>

m_se

<bloco de comandos que sempre será executado>




Exemplo

Construir um programa que aça a leitura de dois números reais e imprima na tela a média arit-mética simples. Se a média or maior ou igual a 7.0, deve imprimir também a palavra “aprovado”.

Solução

Para este exercício, precisamos definir apenas três variáveis reais, ou seja, numero1, numero2 emedia. Após calcular e imprimir a média, devemos testar, por meio de desvio condicional sim-ples, se a média é maior ou igual a 7.0, imprimindo a mensagem “aprovado”.

Diagrama de blocos

INÍCIO

NUMERO1, NUMERO2

( 1+ 2)/2NUMERO NUMERO

MEDIA

FIM

‘ APROVADO’’‘

NMEDIA >= 7

S

Figura 3.3 - Exemplo de utilização da estrutura se...então...fim_se.


programa MEDIA

var

NUMERO1, NUMERO2, MEDIA : real

início

leia NUMERO1

leia NUMERO2 MEDIA ← (NUMERO1 + NUMERO2)/ 2

escreva MEDIA

se (MEDIA > 7) então

escreva "aprovado"

m_se

m




3.3.2 Desvio condicional composto

Em um desvio condicional composto, é possível determinar o bloco a ser executado para umacondição verdadeira e o bloco a ser executado para uma condição alsa. No caso, utilizaremos a ins-trução: se...então...senão...fim_se.

Diagrama de blocos

N SCondição

Bloco de comandos quesó será executado quando

a condição for falsa


Bloco de comandos quesó será executado quandoa condição for verdadeira

Figura 3.4 - Diagrama de blocos para a instrução se...então...senão...fim_se.


se (<condição>) então

<instruções para condição verdadeira>

senão

<instruções para condição falsa>

m_se

Exemplo

Construir um algoritmo que leia dois números reais e calcule a média aritmética desses núme-ros. O programa deve imprimir APROVADO se a média or maior ou igual a 7.0; caso contrá-

rio, deve imprimir REPROVADO.Solução

Para este exemplo, tomaremos como base o exemplo anterior, em que não é possível optar porimprimir APROVADO, se a média or superior ou igual a 7, ou, do contrário, REPROVADO.Note que devemos utilizar, aqui, o SENÃO.




Diagrama de blocos

N SMEDIA >=7

INÍCIO

NUMERO1, 2NUMERO

MEDIA ( 1+ 2)/2NUMERO NUMERO

MEDIA

FIM

‘ APROVADO’’‘‘ REPROVADO’’‘

Figura 3.5 - Exemplo de utilização da estrutura se...então...senão...fim_se.


programa MEDIA_2

var

NUMERO1, NUMERO2, MEDIA : real

início

leia NUMERO1

leia NUMERO2

MEDIA ← (NUMERO1 + NUMERO2)/ 2

escreva MEDIA

se (MEDIA > 7) então

escreva "aprovado"

senão

escreva "reprovado"

m_se

m

3.3.3 Desvio condicional encadeado

Se existem muitas possibilidades de resolver determinado problema, o tipo de desvio condicio-nal mais apropriado é o encadeado. No caso, utilizaremos a estrutura no seguinte ormato: se...entãose...então se... senão...fim_se.




Diagrama de blocos

Condição 1

Condição 2

Ação executada quandoCondição 1 e Condição 2

forem verdadeiras

N S

NS

Figura 3.6 - Desvio condicional encadeado com decisão simples.


se(<condição 1>) então


<ação executada quando condição 1 e condição 2 forem verdadeiras>

m_se

m_se

Condição 1

Condição 2

SN

S N

Ação executada quando

Condição 1 for falsa


Condição 1 e Condição 2forem verdadeiras


Condição 1 for verdadeirae Condição 2 for falsa

Figura 3.7 - Desvio condicional encadeado com decisão composta.






<ação executada quando condição 1 e condição 2 forem verdadeiras>

senão

<ação executada quando condição 1 for verdadeira e condição 2 for falsa>

m_se

senão

<ação executada quando condição 1 for falsa>

m_se

3.3.4 Desvio com múltipla escolha

Nos casos em que se tem uma mesma condição, porém com múltiplos valores, a estruturase...senão se... seria muito grande, portanto cansativa de se construir. Nesses casos, é recomendadoconstruir o algoritmo utilizando a estrutura de desvio com múltipla escolha. Como restrição, a

condição só aceita o operador relacional de igualdade; na construção da instrução, utilizaremos oscomandos caso/seja...aça/senão/fim_caso.

Diagrama de blocos

SCondição 1

N

SCondição 2

N

SCondição 3

N

Bloco de comandos quesó será executado quando a

condição 1 for verdadeira





Bloco de comandos que sóserá executado quando todas

as condições forem falsas


Figura 3.8 - Estrutura de tomada de decisão por seleção.





caso <variável>

seja <opção 1> faça

[ação para condição 1 verdadeira]

seja <opção 2> faça

[ação para condição 2 verdadeira] seja <opção 3> faça

[ação para condição 3 verdadeira]

senão

[ação para nenhuma condição satisfeita]

m_caso

3.4 Divisibilidade

Vamos ver agora um assunto que com certeza já é conhecido dos primeiros anos do ensino

básico, que são operações aritméticas de divisão realizadas com números naturais1

. Operações aritmé-ticas de divisão com números naturais são aquelas que possuem valor de resto com quociente inteiro.

A Figura 3.10 nos apresenta os passos da divisão do número natural 5 com o número natural 2,que dá como resultado um quociente igual a 2 e um valor de resto igual a 1.

5 2 5 22

5 22 x

Dividendo

Divisor

25

2

1

- 45 2

24

5 2

2- 41Quociente

Resto

Figura 3.11 - Exemplo de divisão de dois números naturais.

A Figura 3.11 nos mostra que para obter o valor do resto, devemos azer a subtração do valordo quociente multiplicado pelo divisor sob o valor do dividendo. Assim, devemos usar a expressãoResto = Dividendo – Divisor ⋅ Quociente, que, computacionalmente, pode ser escrita como sendo:Resto ← Dividendo – Divisor * (Dividendo div Divisor), onde o operador aritmético div az o cál-culo de divisão com quociente inteiro.

Exemplo

Desenvolver um programa de computador que leia um valor numérico inteiro e mostre men-sagem inormando se o número lido é par ou ímpar.

1 Números naturais são ormados pelo conjunto de todos os números inteiros positivos, incluindo-se zero e representado pela letraN maiúscula, sendo: N = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, ... }.




Solução

Para resolver este problema, é necessário verificar se a condição do valor lido é ou não divisívelpor 2. Para tanto, leia um valor numérico inteiro qualquer (variável N), calcule o resto da divi-são de N por 2 (variável R) e verifique se a variável R possui o valor de resto igual a zero e, se

sim, apresentar a mensagem “Valor par”; caso contrário, mostrar a mensagem “Valor impar”.Diagrama de blocos

INÍCIO

N

RESTO = 0

RESTO N-2 (N DIV 2)

FIM

‘‘VALORPAR ’’

‘‘VALORIMPAR ’’

N S

Figura 3.12 - Diagrama de blocos para verificar se N é par ou ímpar.


programa PAR_OU_IMPAR

var

N , RESTO : inteiro

início

leia N

RESTO ← N - 2 * (N div 2)

se (RESTO = 0) então

escreva "Valor par"

senão

escreva "Valor impar"

m_se

m

Observe o uso da expressão RESO ← N − 2 * (N div 2), que obtém o valor de divisibili-dade da operação de divisão entre a variável N (dividendo) e o valor 2 (divisor) gerando o valor doRESO da divisão entre N e 2. A instrução de tomada de decisão az uso da condição (RESO = 0),que é verdadeira se o valor de RESO or igual a zero.




3.5 Operadores lógicos

Para solucionar determinados problemas, temos a necessidade de combinar várias condiçõesem uma instrução condicional. Nesses casos, utilizamos os operadores lógicos: .e., .ou. e .não..

3.5.1 Operador lógico .e.

Com a utilização do operador lógico .e., todas as condições da operação devem ser verdadeiraspara que o bloco de comandos seja executado. Observe a abela 3.2.

abela 3.2 - abela-verdade para o operador lógico .e.

Condição 1 Condição 2 Condição 1 .e. Condição 2

Falsa Falsa Falsa

Verdadeira Falsa Falsa

Falsa Verdadeira Falsa

Verdadeira Verdadeira Verdadeira

Diagrama de blocos

N SCondição 1.e.

Condição 2

Bloco de comandos que

sempre será executado

Bloco de comandos que sóserá executado quando acondição for verdadeira

Figura 3.8 - Exemplo de utilização do operador lógico .e.


se (<condição1>) .e. (<condição2>) então

<instruções executadas se condição1 e condição2 verdadeiras>

m_se




O operador lógico .e. permite que uma operação seja executada somente se todas as condiçõesem uso orem verdadeiras. Veja o exemplo a seguir:

Exemplo

Construir um algoritmo que leia dois valores. Um valor representa a média aritmética; o outro, o

número total de altas. O programa deve imprimir APROVADO se a média or maior ou igual a7.0 e o número total de altas or inerior a 20; caso contrário, deve mostrar REPROVADO. programa APROVADO_REPROVADO

var

FALTAS : inteiro

MEDIA : real

início

leia FALTAS

leia MEDIA

se (MEDIA >= 7.0) .e. (FALTAS < 20) então

escreva "aprovado"

senão

escreva "reprovado"

m_se

m

Note que, na sentença do SE, ambas as condições devem ser verdadeiras para que sejaimpresso “aprovado” na tela. Sendo assim, observe na abela 3.3 algumas simulações de digitação:

abela 3.3 - Exemplo de utilização do operador lógico .e.

Média Faltas Média >= 7.0 Faltas < 20 Condição 1 .e. Condição 28.0 30 Verdadeira Falsa Falsa

5.0 15 Falsa Verdadeira Falsa

7.0 10 Verdadeira Verdadeira Verdadeira

3.5.2 Operador lógico .ou.

O operador lógico .ou. será utilizado em situações nas quais basta qualquer uma das condiçõesser verdadeira para que o resultado também seja verdadeiro e, consequentemente, o bloco de instru-

ções seja executado. Na abela 3.4, veja o emprego do operador .ou. para duas condições.abela 3.4 - abela-verdade para o operador lógico .ou.

Condição 1 Condição 2 Condição 1 .ou. Condição 2

Falsa Falsa Falsa

Verdadeira Falsa Verdadeira

Falsa Verdadeira Verdadeira

Verdadeira Verdadeira Verdadeira




Diagrama de blocos

N SCondição 1.ou.

Condição 2



Figura 3.9 - Exemplo de utilização do operador lógico .ou.


se (<condição1>) .ou. (<condição2>) então

<instruções executadas se a condição 1 for verdadeira OU a condição 2 for verdadeira>

m_se

Veja o exemplo a seguir:

Exemplo programa TESTE_OU

var

CODIGO : inteiro

início

leia CODIGO

se (CODIGO = 100) .ou. (CODIGO = 200) então

escreva "código válido"

senão

escreva "o código digitado está inválido"

m_se

m




Observe, no exemplo anterior, que tanto az o usuário digitar 100 ou 200, pois a mensagem“código válido” sempre será emitida; se, porém, or digitado qualquer outro valor, a mensagem “ocódigo digitado está inválido” será mostrada.

A abela 3.5 simula algumas digitações para o algoritmo ESE_OU:

abela 3.5 - Exemplo de utilização do operador lógico .ou.

CODIGO CODIGO = 100 CODIGO = 200 Condição 1 .ou. Condição 2

50 Falsa Falsa Falsa

100 Verdadeira Falsa Verdadeira

200 Falsa Verdadeira Verdadeira

3.5.3 Operador lógico .não.

O operador lógico .não., de negação, será usado quando or necessário inverter o valor de uma

condição, ou seja, tornar verdadeiro o que era also e tornar also o que era verdadeiro. A abela 3.6demonstra a sua utilização; na Figura 3.10, veja a sua representação em um diagrama de blocos.

abela 3.6 - abela-verdade para o operador lógico .não.

Condição .não. condição

Verdadeira Falsa

Falsa Verdadeira

Diagrama de blocos

N S.não.condição



Figura 3.10 - Exemplo de utilização do operador lógico .não.





se .não. (<condição>) então

<instruções executadas se condição não for verdadeira>

m_se

O operador lógico .não. inverte o resultado da condição e é muito utilizado em diversas cons-truções.

Veja o exemplo a seguir:

Exemplo

programa TESTA_NÃO

var

NÚMERO : inteiro

início escreva "Digite um número par: "

leia NÚMERO

RESTO ← NÚMERO – 2 * (NÚMERO div 2)

se .não. (RESTO <> 0) então

escreva "Você digitou um número par"

senão

escreva "Você não digitou um número par"

m_se

m

Neste exemplo, utilizamos o operador matemático mod (visto brevemente no Capítulo 2), queretorna o resto de uma divisão inteira. No exemplo, mod é utilizado para verificar se o número digi-tado pelo usuário é divisor de 2. Se o resto da divisão de qualquer número por 2 or igual a 0, indi-cará que o número é par. No entanto, 0 indica alsidade; sendo assim, para que a condição de SE seja verdadeira, a fim de imprimir corretamente a mensagem desejada, invertemos o conteúdo da variá- vel RESO de maneira a transormá-la em 1 (verdadeiro). Para compreender melhor, fique atento aopróximo tópico.

Aprendemos, neste capítulo, como azer a máquina tomar decisões. Esse aprendizado é de sumaimportância para a compreensão dos próximos capítulos. Outro assunto abordado oram os operadoresrelacionais e lógicos, que ampliam o uso das estruturas de seleção ao compor mais de uma condição namesma cláusula de consulta.

Vamos recapitular?




gora é com você

1) Assuma os seguintes valores: X = 5, A = 2, B = 3, C = 1 e D = 2. Utilizando as tabelas--verdade de .ou., .e. e .não., responda se o resultado das expressões seguintes é verda-

deiro ou also:a) .não. ( A > 3) .ou. (2 < 7)

b) .não. ( X < 5)

c) (C > 5) .ou. (D > 0)

d) .não. (D < 0) .e. (B > 7)

e) .não. ( X = 2) .ou. (C < 2)

) ( X < 2) .ou. .não. ( A < D)

g) ( X >= 5)

h) ( X < 6) .e. (B >= D)

i) ( A > B) .e. .não. (C < B)

j) ( A > B) .ou. (C < B)

2) Para cada um dos problemas a seguir construa o diagrama de blocos e o algoritmoem português estruturado:

a) Determinar o maior entre dois números ornecidos pelo usuário.

b) Dar continuidade ao exercício do item “a”, mas agora o usuário vai ornecer três valores e o algoritmo deve imprimi-los em ordem crescente.

c) Em determinada instituição de ensino, um aluno é considerado APROVADO sea média aritmética simples de três provas or igual ou superior a 6. Se a médiado aluno or maior que 4, porém menor que 6, o aluno estará de EXAME; agora,se a média do aluno estiver abaixo de 4, ele será considerado REPROVADO.

d) Dados três valores inteiros: A, B e C, determinar se eles ormam um triângulo.Atenção! riângulo é uma figura geométrica em que a medida de qualquer umdos lados é menor do que a soma das medidas dos outros dois.

e) Altere o exercício “d” de tal modo a classificar o triângulo em equilátero, isósce-les e escaleno. Lembre-se de que:

Equilátero: todos os lados possuem a mesma medida.

Isósceles: dois lados possuem a mesma medida.

Escaleno: todos os lados possuem medidas dierentes.

) Ler cinco números inteiros e apresentar a dierença (subtração) entre o menor eo maior número lido.



53

4Programaçãocom Laços

Neste capítulo, vamos estudar como implementar uma técnica undamental em programação:laços ou repetições. Ela permite executar trechos de um programa quantas vezes or necessário. A quan-

tidade de vezes pode ser parametrizada pelo programador ou pela própria situação-problema. Vamosexplicar o laço com teste prévio de veracidade (pré-teste), o laço com texto de veracidade a posteriori(pós-teste) e o laço incondicional.

Para começar

4.1 Controle de ciclos

Geralmente, ao escrever um programa, precisamos que ele execute a mesma rotina maisde uma vez. Em muitos casos, o número de vezes é muito alto e inviabiliza qualquer tentativa dereescrever a rotina n vezes. Além de trabalhoso, isso geraria um código de programação de diícil

suporte e dificultaria a correção de alhas.

Com a técnica de laços resolvemos esse problema, permitindo que o programador controlequantas vezes determinada porção de instruções deve ser repetida. Normalmente, esse controle nãoé fixo; depende de variáveis dinâmicas. Por exemplo, para calcular o atorial de um número x , o usuá-rio precisa inormar o valor de x como dado de entrada. Ao receber o valor de x , o programa entraem um laço que será executado um número de vezes proporcional ao tamanho de x , ou seja, quantomaior o valor de x , mais repetições o programa ará.




ecnicamente, costumamos chamar o laço pelo seu correspondente em língua inglesa: loop oulooping . Os laços podem ser executados mediante uma condição predefinida pelo programador (laçocondicional) ou sem uma condição predefinida (laço incondicional).

Além disso, é importante esclarecer que, durante a execução de um laço condicional, podemoster operações interativas (com a intervenção do usuário) e iterativas (sem o n - sem intervenção do

usuário, apenas iteração/repetição). Os laços incondicionais permitem apenas operações iterativas.Veremos adiante os principais comandos para controle de laço ou repetição: enquanto...aça e

repita...até que, para loops condicionais, e a instrução para...de...até...passo...aça, para loops incondicionais.

odo algoritmo tem um custo de processamento associado. Para analisar esse custo, existe uma área, na Ciência da Compu-ação, chamada Análise de Algoritmos e Otimização. Por meio de estudos nessa área é possível verificar, dentre outras infor-ações, a complexidade do programa (por meios matemáticos), o seu tempo de execução, o espaço de memória necessário

e a robustez do programa. O laço tem papel importante no cálculo da complexidade de um algoritmo. Muitos laços podemaumentar o nível de complexidade de processamento do programa, portanto use esse recurso com parcimônia.

ara saber mais, consulte: Complexidade de Algoritmos Série Livros Didáticos Informática – UFRGS. Vol. 13, 3. ed.aira Vieira Toscani; Paulo A. S. Veloso. Editora Bookman, 2012.


4.2 Laço condicional pré-teste

Dentre os laços condicionais, temos aqueles que eetuam o teste condicional antes de executara rotina de loop (laço condicional pré-teste) e aqueles que executam a rotina e, depois, o teste para verificar se devem ou não continuar executando o laço (laço condicional pós-teste).

O laço condicional pré-teste executa um teste lógico no início do laço para confirmar se deveou não executar a porção de código do laço. Uma das estruturas mais conhecidas para esse tipo delaço é enquanto...aça, que testa se a condição definida no início do loop é verdadeira. Enquanto essacondição or verdadeira, o conjunto de instruções do loop será executado. Assim que a condição setornar alsa, o processamento deixará o loop e seguirá o caminho de execução sequencial do pro-grama. Vale ressaltar que, caso a condição em seu primeiro teste seja alsa, as instruções internas aolaço jamais serão executadas.

Verifique, na Figura 4.1, um exemplo de uncionamento da estrutura de controle enquanto...aça por meio de diagrama de blocos.

Diagrama de blocos

Teste lógico

N

S

Instruções aserem executadas

Condição

Figura 4.1 - Exemplo de uncionamento da estrutura enquanto...aça.



55Programação com Laços


enquanto (<condição>) faça

<instruções a serem executadas>

m_enquanto

ExemploDesenvolver um programa de computador que leia um valor inteiro qualquer, divida-o suces-sivas vezes por 2, até que o seu valor seja menor que 5, e apresente como resultado a quantidadede sucessivas divisões realizadas.

Solução

O programa deve possuir a variável de entrada (N) e uma segunda variável que será usada para cal-cular a quantidade de ações (divisões sucessivas) realizadas. A variável R será iniciada com valor 0e, a cada iteração, deverá ser acrescida de 1.

Diagrama de blocos

Início

R 0

N

N >= 5

N

S

N N div 2

R R + 1

R

Fim

Figura 4.2 - Exemplo de uso da estrutura enquanto...aça.


programa DIVISOES_SUCESSIVAS

var

N , R : inteiro

início

R ← 0

leia N

enquanto (N >= 5) faça

N ← N div 2

R ← R + 1

m_enquanto

escreva R

m

No exemplo, utilizamos a variável R para dois propósitos: guardar o resultado final a ser exi-bido e servir de contador. O laço apresentado eetua um pré-teste antes de permitir a execução darotina associada à repetição: N >= 5. Isso significa que, se o valor de N or inerior a 5, as instruçõessubordinadas ao laço não serão (mais) executadas.

Ao entrar no laço, o valor de N é alterado por 2 pela divisão inteira (div). Repare que o processa-mento está sendo realizado e o valor da variável de entrada é alterado por esse processamento. Não oinecessário criar outra variável para guardar o cálculo. Logo em seguida, e ainda dentro do laço, o valordo contador é alterado. Isso se repetirá até que o valor de N se torne menor que 5. Quando isso aconte-cer, o laço será interrompido e o valor do contador, apresentado como saída do programa.




Vimos, no exemplo, o uso de um laço pré-teste condicional iterativo. Vejamos, agora, outroexemplo, mas com uma situação interativa, ou seja, com intervenção do usuário no laço.

Exemplo

Desenvolver um programa de computa-

dor que leia as avaliações de consumidoressobre determinado produto. Essas avaliaçõessão valores reais entre 5 e 10. Calcule a notamédia atribuída ao produto. O usuário digi-tará quantas avaliações considerar necessário,até que o valor digitado seja inválido (menorque 5 ou maior que 10).

Diagrama de blocos

Início

R 0

CONT 0

N

NN >= 5

.e.

N <= 10

S

R R + N

CONT CONT + 1

N

N

CONT > 0

S

R

Fim

R R / CONT

Figura 4.3 - Exemplo de laço controlado pelo usuário.

Solução

O programa deve possuir, além da variávelde entrada (N), uma segunda variável (R)para acumular os valores lidos e uma ter-ceira variável (CON) para contar quantos valores já oram lidos. É o valor lido a cadaiteração que será acrescido à variável R.A variável CON será iniciada com valor0 e, a cada leitura dierente de 0, deve seracrescida de 1.

Português estruturado programa LACO_INTERATIVO

var

N , R : real

CONT : inteiro

início

R ← 0

CONT ← 0

leia N

enquanto (N >= 5) .e. (N <= 10) faça

R ← R + N

CONT ← CONT + 1

leia N

m_enquanto

se (CONT > 0) então

R ← R / CONT

escreva R

m




No programa apresentado, enquanto o valor lido estiver dentro do intervalo aceitável, a rotinade repetição será executada. Dierentemente do exemplo anterior, o controle do laço será, agora, dousuário, ou seja, o usuário definirá quantas vezes a rotina será executada.

Note que, além das variáveis R (armazena o resultado) e N (variável de entrada), utilizamos a variável auxiliar CON. Chamamos de auxiliar toda variável criada para ajudar determinado proces-

samento, não sendo, portanto, nem variável de entrada nem de saída. No exemplo, a variável CONserviu como contador, sendo-lhe atribuído o valor 0 no início da operação, uma vez que as instru-ções subordinadas ao laço ainda não haviam sido executadas.

A instrução enquanto (N >= 5 e N <= 10) verifica se o último valor de N lido está no intervalo desejado. Se estiver, acumulará (soma de valores) em R os valores de N lidos. Caso o valor de Nesteja ora do intervalo admitido, o laço será interrompido e o contador será conerido, calculando--se o resultado e imprimindo-o. Perceba que o resultado a ser exibido é calculado eetivamente apóso laço. Isso mostra que o laço serve para outras ações de processamento, como, no caso, acumulardeterminado valor após sucessivas leituras de dados de entrada.

Verifique o controle condicional ao final do algoritmo, testando se o valor da variável CONé positivo. Isso é eito para evitar a divisão por 0 (R ← R / CON), caso o primeiro valor lido para a variável N seja inválido (ora do intervalo definido).

4.3 Laço condicional pós-teste

O laço condicional pós-teste unciona de modo similar ao laço condicional pré-teste. A grandedierença é que o teste lógico ocorre somente após a execução das instruções subordinadas ao laço.Logo, primeiro se executam as instruções, depois se verifica, por meio de teste, se elas devem conti-nuar a ser executadas.

A estrutura de repetição que executa esse tipo de laço é repita...até que. Nesse tipo de laço, per-ceba que as instruções são executadas ao menos uma vez antes do teste lógico; já no laço condicionalpré-teste (consulte o ópico 4.2), existe a possibilidade de as instruções subordinadas ao laço nuncaserem executadas.

Nesse sentido, podemos dizer que repita...até que tem uncionamento invertido quando comparada àestrutura enquanto...aça, pois sempre executa as instru-ções ao menos uma vez enquanto a condição do laço oralsa. Atente a esta dierença: em repita...até que, as ins-truções serão executadas enquanto a condição do laçopermanecer alsa. Quando o teste lógico dessa condiçãoor verdadeiro, o laço será encerrado, ou seja, o proces-samento deixará o loop e seguirá o caminho de execu-ção sequencial do programa.

Na Figura 4.4, veja um exemplo de unciona-mento da estrutura de controle repita...até que por meiode diagrama de blocos.

Diagrama de blocos

Condição

Instruções executadas no períodoem que a condição permanece falsa

S

N

Figura 4.4 - Exemplo de uncionamentoda estrutura repita...até que.





repita

<instruções executadas>

até_que (<condição - para quando verdadeiro>)

Para exemplificar o uso do laço condicional pós-teste, considere o exemplo seguinte:

Exemplo

Desenvolver um programa de computador que apresente a soma dos cinco primeiros númerosinteiros.

Solução

O programa deve possuir uma variável de processamento do cálculo (R) que será modificadaa cada interação. ambém será necessária uma segunda variável (I) para controle do laço.

A variável I será iniciada com valor 1 e, a cada iteração, deverá ser acrescida de 1 até o limitede 5. Note que este programa é semelhante ao do exemplo anterior, mas, para solucioná-lo,será usado um laço pós-teste.

Diagrama de blocos

Início

I 1

R 0

R R + I

I I + 1

I > 5

R

Fim

S

N

Figura 4.5 - Exemplo de utilizaçãoda instrução repita...até_que.


programa LACO_POSTESTE

var

R, I : inteiro

início

I ← 1

R ← 0

repita

R ← R + I

I ← I + 1

até que (I > 5)

escreva R

m

No exemplo, também utilizamos uma variável (I) que servirá como contador. Foi atribuído o valor 1, pois usaremos a estrutura de repetição repita...até que, a qual garante ao menos uma itera-ção. Portanto, o programa executará as instruções subordinadas ao laço ao menos uma vez.




odo o trecho de instruções compreendido entre os comandos repita e até que será repetidoenquanto a condição (I > 5) or alsa, ou seja, só deixará de ser executado quando I <= 5. Para queessa condição se torne alsa, é imprescindível que o valor de I seja alterado (aumentado) ao longodas iterações. Se isso não acontecer, o laço pode ser executado “infinitamente”, causando o trava-mento do programa.

A seguir, veja um exemplo em que não se utiliza o contador como orma de controlar quantas vezes uma rotina é executada em uma estrutura de repetição. Considere que o usuário pode encerraro processamento quando desejar.

Exemplo

Desenvolver um programa de computador que leia um número inteiro qualquer, eleve-o aoquadrado e apresente o resultado do cálculo. Essa operação deve ocorrer até que o usuário res-ponda SIM à pergunta “Deseja encerrar cálculo?”.

Solução

O programa deve possuir, além das variáveis de entrada (N) e de processamento do cálculo (R)solicitado, uma terceira variável que será usada para guardar a resposta do usuário (ENCER).A variável ENCER é iniciada com valor NÃO e, cada vez que a resposta dada or dierente deSIM, o programa repetirá o laço, que somente será interrompido quando a resposta or SIM.

Diagrama de blocos

Início

ENCER ‘‘NÃO’’

N

R N * N

‘‘Desejaencerrar?’’

RESP

ENC = ‘‘SIM’’

Fim

Sim

Não

Figura 4.6 - Exemplo de laço controlado pelo usuário.


programa CALCULO_INTERATIVO

var

N , R : inteiro ENCER: cadeia

início

ENCER ← "NÃO"

repita

leia N

R ← N * N

escreva R

escreva "Deseja encerrar?"

leia ENCER

até que (ENCER = "SIM")

m




4.4 Laço incondicional

Até agora, vimos duas estruturas de repetição para laços condicionais: enquanto...aça erepita...até que. Além delas, há uma que costuma acilitar o trabalho do programador; é a estruturade laço incondicional.

Algumas vezes, o laço não depende de uma condição explícita, mas de uma contagem de valo-res que, ao atingirem determinado patamar, interrompem o laço. Nesse caso, o laço unciona combase em uma variável contador, que controla o fluxo de iterações. Para esse tipo de laço, o programa-dor pode usar a estrutura para..de..até..passo..aça.

No diagrama de blocos, esse tipo de laço recebe um componente dierenciado com ormatohexagonal: o símbolo preparation. Verifique, na Figura 4.7, um exemplo de uso do laço incondicionalcom diagrama de blocos.

Diagrama de blocos

Var Início, Fim,Incremento

Instruções

Figura 4.7 - Exemplo de uso da estrutura para..de...até...passo...aça.


para <variável> de <início> até <m> passo <incremento> faça

<instruções subordinadas>

m_para

Atenção! Observe que não houve uso de condição para a escrita desse laço; não há, portanto,teste lógico: verifica-se, apenas, se a variável de controle já chegou ao seu limite superior/inerior.

Para exemplificar o uso do laço incondicional, considere o exemplo seguinte:




Exemplo

Desenvolver um programa de computador que some os dez números naturais subsequentes deum número N dado como entrada.

Solução

O programa deve receber como dado de entrada o valor de N, que será atribuído a uma variávelde mesmo nome. ambém criaremos a variável R para guardar o resultado a ser exibido. Para oprocessamento do laço, será necessário criar outra variável, a ser chamada de variável auxiliar I,cujo objetivo é auxiliar o loop, servindo de variável de controle do laço incondicional. A variávelI será inicializada com o valor N + 1 para indicar o primeiro valor subsequente a N. A cada itera-ção (ciclo do laço), a variável auxiliar terá 1 acrescido ao seu valor, até o limite de 10.

Diagrama de blocos

I N + 1,

N + 10, 1

Início

N

R R + I

R

Fim

Figura 4.8 - Exemplo de uso da estrutura para...de...até...passo...aça...fim_para.


programa SOMA_NATURAIS

var

N , R, I : inteiro

início

leia N

para I de N + 1 até N + 10 passo 1 faça

R ← R + I

m_para

escreva R

m

Verifique a dierença deste exemplo em relação aos demais. Neste, desde o início o programa-dor sabia quantas iterações seriam necessárias; ele não dependia de nenhuma condição a ser veri-ficada a cada ciclo. A variável de controle oi iniciada com o valor N + 1 e incrementada de 1 em 1




pelo comando passo até atingir o valor correspondente a N + 10. Essa estrutura de repetição é a maisadequada quando se conhece a quantidade de iterações que devem ser realizadas, tendo-se os valo-res inicial e final da variável de controle.

Neste capítulo, estudamos o conceito de laço e as principais técnicas de loop, utilizando as seguin-tes estruturas de repetição: enquanto...aça, para laços interativos e iterativos com pré-teste condicional

verdadeiro; repita...até que, para laços interativos e iterativos com pós-teste condicional also; e para...de...até...passo...aça , para laços incondicionais.

Vamos recapitular?

Agora é com você!

1) Escreva algoritmos (diagrama de blocos e português estruturado) para os problemasa seguir. Para tanto, será necessário escolher uma estrutura de repetição dentre asestudadas. Faça isso e explique o porquê da escolha.

a) Ler um número inteiro positivo N e apresentar a contagem regressiva a partirde N.

b) Apresentar o produto dos dez primeiros números inteiros (1 ⋅ 2 ⋅ 3 ⋅ 4 ⋅ 5...10).

c) Apresentar o cubo de todos os números inteiros entre 0 e N, sendo N um núme-ro inteiro recebido como entrada.

d) Apresentar a tabuada de um número inteiro N recebido como entrada.

e) Calcular e exibir a média aritmética das notas recebidas pelos alunos de umaturma. O número de alunos (maior que 0) deve ser inormado pelo usuário noinício do programa.

) Apresentar o quadrado dos números pares entre 0 e N, sendo N um númerointeiro positivo recebido como entrada.

g) Apresentar o somatório de K2, de k = 1 até N (∑1,n k 2), sendo N um númeronatural positivo recebido como entrada.

h) Apresentar todos os valores numéricos inteiros ímpares situados na aixa entreM e N, sendo M e N números inteiros positivos e M <= N.

i) A série de Fibonacci é 1, 1, 2, 3, 5, 8, 13, 21, 34, 55... Os dois primeiros ter-mos são iguais a 1 e, a partir do terceiro, o termo é dado pela soma dos dois termosanteriores. Dado um número N, exiba o N-ésimo termo da série de Fibonacci.



63

5Programaçãocom Matrizes

Neste capítulo, vamos explicar a criação e o uso das variáveis compostas homogêneas (de uma eduas dimensões, respectivamente denominadas vetores e matrizes), as quais possibilitam o armazena-

mento de mais de um valor em certa região de memória.

Para começar

5.1 Estrutura de dados

A primeira ação de um projetista de sofware deve ser a definição dos dados que serão arma-zenados e processados pelo programa a ser criado. Com base nessa inormação será possível especi-ficar os tipos de dados (inteiro, real, cadeia, caractere e lógico) e as estruturas de armazenamento aserem utilizados.

Nos capítulos anteriores, vimos diversos exemplos e exercícios que utilizam os chamados tiposde dados primitivos, caracterizados, entre outras coisas, por armazenar um único valor por vez em suaposição de memória. Em diversas aplicações, todavia, é necessário armazenar grande quantidade deinormações de um mesmo tipo; por exemplo, as notas de uma prova para uma turma de 80 alunos.

Com o conhecimento adquirido até o momento, seria necessário criar 80 variáveis de ummesmo tipo (no caso, do tipo real) para resolver esse problema, o que tornaria o trabalho bastantetedioso e moroso. Para acilitar a criação de programas com esse perfil, podemos utilizar as variáveiscompostas homogêneas ou, simplesmente, matrizes ou vetores; assim, em uma única variável pode-mos armazenar um valor em diversas posições. Ainda vale a restrição de se armazenar um único




valor em uma posição de memória, mas podemos criar diversas posições de memória, cada umacom um valor, e chamar esse conjunto de memória por meio de uma única variável.

O conjunto de dados reerenciado em memória com um único nome recebe dierentes nomescomo variável indexada, variável subscrita, arranjo, vetor, matriz, tabela em memória, lista ou arrays.Neste livro ela será chamada apenas de vetor quando se tratar de uma linha e diversas colunas e dematriz quando tratar de diversas linhas e colunas.

As variáveis compostas homogêneas podem ter qualquer dimensão (linhas x colunas). Vetoressão comumente utilizados para estruturas de dados com uma dimensão; já matrizes são usadas paraestruturas com duas dimensões. Neste capítulo, vamos abordar apenas os vetores e as matrizes porserem suficientes para tratar a maioria dos problemas, além de servirem de base para a criação deestruturas com outras dimensões, como os cubos.

A criação do nome de uma variável composta segue as mesmas regras atribuídas aos nomes de variáveis simples; o nome também é definido por meio do comando var, com auxílio do comando conjunto. Além disso, a dimensão de uma matriz é ormada por constantes inteiras e sempre positivas.

A linguagem de programação BASIC, criada em 1956, não deve ser traduzida literalmente como “básica”. O nome é, naverdade, uma sigla para o termo: Beginner’s All-purpose Symbolic Instruction Code, que significa código de instrução sim-bólica de uso geral para principiantes.

Fique de olho!

5.2 Vetores ou matrizes unidimensionais

Entende-se por vetor ou matriz unidimensional a estrutura ormada apenas por uma linha e várias colunas. Lembramos que em um vetor é possível armazenar várias inormações, desde quesejam do mesmo tipo. A Figura 5.1 mostra esse tipo de variável, considerando-se uma variável com-

posta vetoreste que tem a capacidade de armazenar cinco elementos.

vetorTeste Índice

Valor

1

25 65 10 2 45

2 3 4 5

Figura 5.1 - Exemplo de vetor.

Em um vetor, cada posição tem um endereço conhecido como índice. Dependendo da lingua-gem de programação utilizada, esse índice pode ser iniciado com 0 ou com 1. Para reerenciar deter-minada posição dentro do vetor, devemos utilizar o nome da variável seguido do número do índice.Sendo assim, para o exemplo da Figura 5.1, temos vetoreste[3] = 10.

Exemplo

Desenvolver um programa que leia cinco valores e armazene os dados em um vetor de cincoposições. Em seguida, o programa deve imprimir o valor lido e o quadrado desse número.

Solução

Para este exercício, vamos ler cinco números inteiros e, em seguida, apresentar o vetor, impri-mindo o valor armazenado e o seu quadrado.



65Programação com Matrizes

Exemplo

Diagrama de blocos

I 1, 5, 1

INÍCIO

I 1, 5, 1

NUM[I]

FIM

QUADRADO NUM[I]*NUM[I]

NUM[I],QUADRADO

Figura 5.2 - Diagrama de blocos para cálculodo quadrado de um número por meio de vetor.


programa QUADRADO

var

NUM : conjunto[1..5] de inteiro

I : inteiro

QUADRADO : inteiro

início

para I de 1 até 5 passo 1 faça

leia NUM[I]

m_para


QUADRADO ← NUM[I] * NUM[I]

escreva NUM[I]

escreva QUADRADO

m_para

m

Note como o vetor é criado (matriz unidimensional). No código, observe que o vetor num(aparece no espaço de criação de variáveis) é seguido pelo comando conjunto (que indica a utiliza-

ção de matrizes) e pela indicação de sua dimensão. Sendo assim, a criação de vetores pode utilizar aseguinte regra:

VARIÁVEL : conjunto[<dimensão>] de <tipo de dado>

Em que:

<dimensão> é a indicação dos valores inicial e final do tamanho do vetor;

<tipo de dado> é o tipo de dado utilizado (por exemplo: real, inteiro, lógico ou caractere).

Lembre-se de que um vetor pode armazenar diversos valores, mas em cada posição (índice) só

é possível armazenar um valor, assim como nas variáveis simples.

Observe ainda que, no caso do exemplo anterior, temos o cálculo do quadrado para cada umadas cinco posições do vetor. Se precisarmos ampliar esse cálculo, basta substituir 5 pelo valor desejado.

Outro detalhe importante é com relação à variável i, aqui chamada de índice. O índice nadamais é que uma variável do tipo inteiro que indexa o vetor. Para acessar determinada posição dentrodo vetor, devemos utilizar a variável vetor com o índice: Variável[indice].




Exemplo

Construir um programa que tenha dois vetores (matrizes unidimensionais) com tamanho 10cada. Os elementos do primeiro vetor, chamado de A, serão ornecidos pelo usuário. Já os ele-mentos do vetor B serão gerados dos elementos de A, em que:

B[i] = A[i]*i, para i par 2 = 0B[i]= A[i]*2, para i ímpar 2 <> 0

Após os cálculos, o algoritmo deverá exibir os dados dos dois vetores.

Solução

No caso, temos a construção de dois vetores: o primeiro (A) será eito por simples digitação; osegundo (B), construído de orma automática de acordo com a lei de ormação indicada. Essalei diz que, se o índice do vetor A or par, seu conteúdo deve ser multiplicado pelo próprioíndice. O resultado desse produto será atribuído ao vetor B. De orma semelhante, caso o índi-

ce seja ímpar, o conteúdo do vetor A deve ser multiplicado por 2. Novamente, o resultado doproduto será atribuído ao vetor B de mesma posição.

Diagrama de blocos

INÍCIO

I 1, 10, 1

A[I]

I 1, 10, 1

RESTO I - 2 (I DIV 2)

RESTO 0=

B[I] A[I] I B[I] A[I] 2

I 1, 10, 1

A[I], B[I]

FIM

S N

Figura 5.3 - Diagrama de blocospara operação com índice.


programa MANIPULACAO_INDICE

var

I , RESTO : inteiro

A , B : conjunto[1..10] de real

início


leia A [i]

m_para


RESTO ← I - 2 (I DIV 2)

se (RESTO = 0) então

B[I] ← A[I] * I

senão

B[I] ← A[i] * 2

m_se m_para


escreva A [I ], B[I ]

m_para

m




Por meio do exemplo apresentado notamos que é possível manipular o índice do vetor. Nocaso, temos a variável i, que cumpre exatamente esse papel.

Exemplo

Desenvolver um programa que leia cinco elementos e armazene-os em um vetor. O programa

deve imprimir na tela a média aritmética dos elementos lidos.

Solução

Utilizando o princípio de ENRADA → PROCESSAMENO → SAÍDA, devemos ler todosos dados, processá-los conorme a solicitação e, por fim, executar a impressão na tela. Sendoassim, aremos três laços, um para cada etapa. A variável i (índice) será utilizada em todas asetapas e vai controlar o acesso ao conteúdo do vetor.

Diagrama de blocos

INÍCIO

I 1, 5, 1

A[I]

SOMA 0

I 1, 5, 1

SOMA SOMA+A[I]

MEDIA SOMA/5

MEDIA

FIM

Figura 5.4 - Diagrama de blocospara operação em elementos.


programa MEDIA

var

I , SOMA : inteiro

MEDIA : real

A : conjunto[1..5] de inteiro

início


leia A [I ]

m_para

SOMA ← 0


SOMA ← SOMA + A[I]

m_para

escreva soma

MÉDIA ← SOMA I 5

m

Em 2008, Frances Allen, cientista norte-americana da IBM, foi a primeira mulher a receber o prêmio Turing, aos 75 anosde idade.

Para saber mais, consulte: <http://www.sitedecuriosidades.com/curiosidade/cientista-da-ibm-e-primeira-mulher-a-receber--nobel-da-informatica.html>. Acesso em: 28 jan. 2014.





5.3 Tabelas ou matrizes bidimensionais

A estrutura com duas dimensões, ou seja, com linhas e colunas, recebe o nome matriz de duasdimensões (tabela) ou, simplesmente, matriz. A Figura 5.5 exibe a matriz A[5,4] e mostra exata-mente como podemos visualizar essa importante - e muito utilizada - estrutura de dados.

Índice das colunas

Índice

das

linhas

1 2 3 4

1

2

3

4

5

54

Figura 5.5 - Exemplo de matriz com cinco linhas e quatro colunas.

Os elementos de uma matriz são manipulados de orma individualizada; basta reerenciar osíndices de linha e coluna dos quais se deseja obter alguma inormação ou aos quais se deseja enviaralgum dado. Na Figura 5.5, para acessar a posição do número 54, devemos indicar A[linha,coluna],ou seja, A[3,2].

Exemplo

Considerar uma sala de aula com cinco alunos e uma disciplina, com três provas aplicadaspelo proessor. Construir um programa (diagrama de blocos e português estruturado) que leiaas notas dessas provas para cada aluno. Ao final, o programa deve imprimir as notas.

Solução

Neste exercício, vamos usar uma tabela semelhante à exibida anteriormente na Figura 5.5.

Índice das colunas

Índice

das

linhas

1 2 3

1

2

3

4

5

Figura 5.6 - Matriz que exemplifica o enunciado do exercício.




Exemplo

Note que temos dois índices: um deve gerenciar as linhas; o outro, as colunas. Os índices sãomanipulados de orma individual. Para acilitar o aprendizado, utilizaremos dois laços enca-deados: o mais externo vai gerenciar as linhas; o mais interno, as colunas (você pode geren-

ciar primeiro as colunas e depois as linhas, mas isso requer mais experiência e estudos).Vamos utilizar o índice i para as linhas e o índice j para as colunas. Após a leitura das notas, va-mos imprimi-las na tela.

Diagrama de blocos

INÍCIO

I 1, 5, 1

I 1, 5, 1

NOTAS[I,J]

FIM

J 1, 3, 1

NOTAS[I,J]

J 1, 3, 1

Figura 5.7 - Diagrama de blocos para operação com matrizes.




Exemplo


programa MANIPULACAO_MATRIZ

var

NOTAS : conjunto[1..5, 1..3] de real

I, J : inteiro

início


para J de 1 até 3 passo 1 faça

leia NOTAS[I,J]

m_para

m_para



escreva NOTAS[I,J]

m_para

m_para

m

Na criação de um vetor, devemos indicar apenas uma dimensão, ou seja, a quantidade de colu-nas, já que a quantidade de linhas é sempre igual a 1. Já na criação de uma matriz de duas dimen-sões, serão atribuídas ao comando conjunto as inormações de duas dimensões, isto é, a quantidadede linhas e de colunas. A sintaxe geral de criação é:

VARIÁVEL: conjunto[<dimensão1:dimensão2>] de <tipo de dado>

Em que:

<dimensão1> e <dimensão2> indicam a quantidade de linhas e colunas, respectivamente;

<tipo de dado> é o tipo de dado utilizado (por exemplo: real, inteiro, lógico ou caractere).

Nos vetores, devemos processar um elemento por vez; nas matrizes, o procedimento é omesmo, ou seja, os dados são manipulados passo a passo, um elemento de cada vez.




Diversas são as aplicações em que é preciso armazenar grande quantidade de inormações de ummesmo tipo; por exemplo, as notas para uma sala de aula. Neste capítulo, aprendemos como usar as estru-turas de dados conhecidas como variáveis compostas homogêneas. As mais utilizadas são os vetores e as

matrizes que, com a utilização de índices, permitem manipular de orma bem específica cada elemento.

Vamos recapitular?

Agora é com você!

1) Sabendo que os exercícios a seguir envolvem a manipulação de vetores, desenvolvaos diagramas de blocos e as representações textuais em português estruturado cor-respondentes:

a) Considere o seguinte programa e inorme o que será impresso na tela: programa EXERCICIO_A

var

VETOR : conjunto[1..10] de inteiro

I : inteiro

início

para i de 1 até 10 passo 1 faça

VETOR[I] ← i * I – 2 * I + 5

m_para

para i de 1 até 10 passo 1 faça

escreva VETOR[I]

m_para

m

1 2 3 4

vetor

5 6 7 8 9

b) Construa um programa em que o usuário deve ler dois vetores, A e B, cada qual com20 elementos. O código deve montar os elementos de uma terceira matriz, C,

em que cada elemento é o produto dos elementos da matriz A com a B. Ao final,mostre na tela os elementos das três matrizes.

c) Faça um programa que leia os elementos de dois vetores: o primeiro com dezelementos e o segundo com 15 elementos. O usuário deve digitar os elemen-tos dos dois vetores já em ordem crescente, ou seja, do menor para o maior.O programa deve criar de orma automática um terceiro vetor que seja a junçãodos dois vetores lidos, mas todos os elementos devem estar em ordem crescente.Para ilustrar, veja o exemplo a seguir:




Considere um vetor A com três elementos e um vetor B com quatro elementos:

Índice

Valor

Índice

Valor

Índice

Valor

O vetor C, tido como resultado, será:

Vetor A

Vetor B

Vetor C

1 2 3

10 12 23

1 2 3 4

5 15 18 25

1 2 3 4 5 6 7

5 10 12 15 18 23 25

2) Agora que já sabemos trabalhar com vetores, vamos exercitar o que aprendemos commatrizes. Para cada um dos exercícios seguintes, desenvolva os diagramas de blocos e

o português estruturado:a) Faça um programa em que o usuário deve digitar números inteiros para uma

matriz de ordem 5 (linhas e colunas iguais a 5). Após a digitação dos núme-ros, o usuário deve digitar um número aleatório e verificar se ele se encontra namatriz. Ao final, os índices da linha e da coluna devem ser impressos se o ele-mento or encontrado; caso contrário, a mensagem “elemento não encontrado”deve ser impressa.

b) Desenvolva um programa que leia duas matrizes de cinco linhas por três colu-nas e apresente na tela a soma delas. É preciso utilizar uma terceira matriz paraarmazenar o resultado.

c) Desenvolva um programa que leia duas matrizes quadradas de ordem 3. Eledeve construir uma terceira matriz que seja o produto das duas matrizes lidas.



73

6Aplicação Práticade Matrizes

Neste capítulo, vamos estudar exemplos práticos de matrizes com base em duas técnicas muitoimportantes: ordenação e busca de elementos. Ao final do capítulo, será possível implementar rotinas

para ordenar dados armazenados em matrizes, bem como desenvolver algoritmos para buscar valoresarmazenados em matrizes.

Para começar

6.1 Ordenação de elementos

Matriz é um elemento de programação usado de diversas ormas na computação. Além deconhecer matrizes, é muito importante saber utilizá-las, escolhendo, dentre as diversas possibilida-des que essa estrutura apresenta, a mais adequada a determinado fim, principalmente quando se tra-balha com um conjunto volumoso de dados.

Uma das diversas operações que tipicamente usam matrizes consiste na organização de dadosde acordo com alguma regra. A regra pode ser, por exemplo, a classificação (ordenação) dos dados pa-ra acilitar sua busca na estrutura. A ordenação pode ser numérica, alabética ou alanumérica, emordem crescente ou decrescente, de acordo com a tabela ASCII (American Standard Code or Inor-mation Interchange, que significa código americano padrão para troca de inormações), dependendodo tipo de dados armazenado na matriz. Lembre-se de que a matriz só armazena dados de ummesmo tipo (estrutura homogênea).




Considerando a ordenação da tabela ASCII, quando a classificação dos dados é alabética, pri-meiro se ordenam os caracteres maiúsculos, depois os minúsculos. Além dos caracteres convencio-nais, esse tipo de ordenação abrange os demais elementos gráficos previstos na tabela ASCII (consulteessa tabela no Capítulo 1).

Para classificar dados, há diversos algoritmos clássicos na Ciência da Computação. Cada um

tem seus pontos ortes e suas ragilidades. O programador precisa apenas escolher o algoritmo a serimplementado, considerando o seu problema e, principalmente, a quantidade de dados que possui.Dentre os algoritmos de classificação de dados mais conhecidos, destacam-se os seguintes grupos(AZEREDO, 1996):

» Classificação por inserção: método da inserção direta, método da inserção direta combusca binária, método dos incrementos decrescentes - shellsort .

» Classificação por troca: método da bolha - bubblesort , método da agitação - shakesort ,método do pente - combsort , método de partição e troca - quicksort .

» Classificação por seleção: método da seleção direta, método da seleção em árvore - heapsort ,

método de seleção em árvore amarrada - threadedheapsort . » Classificação por distribuição de chaves: método de indexação direta - radixsort .

» Classificação por intercalação: método da intercalação simples - mergesort , método deintercalação de sequências naturais.

» Classificação por cálculo de endereços: método das listas de colisão, método da soluçãopostergada das colisões.

Neste capítulo, você estudará um algoritmo do tipo classificação por troca, por ser um dosmétodos mais simples, útil para ordenar um conjunto com poucos dados. Apesar de sua simplici-dade e eficácia (atinge o objetivo de ordenar), ele não é eficiente quando comparado a outros mais

complexos, como o radixsort , o mergesort ou o quicksort . É importante ressaltar que um algoritmo éconsiderado não eficiente se o seu tempo de execução or muito alto quando comparado a outros domesmo gênero/finalidade.

O método de classificação de dados a ser apresentado executa trocas sucessivas de valoresentre os elementos da matriz até que os dados estejam totalmente ordenados. Por esse motivo, a téc-nica é considerada um método de classificação por troca.

Para acilitar o entendimento, imagine uma matriz de inteiros com cinco elementos, conormea abela 6.1.

abela 6.1 - Matriz de inteiros com cinco elementos

Matriz: A

Índice Elemento

1 45

2 8

3 17

4 5

5 2



75Aplicação Prática de Matrizes

Considerando a ordem numérica crescente, a matriz está “desordenada”, ou seja, os dados nãoestão ordenados. Repare que os elementos estão na seguinte ordem: 45, 8, 17, 5 e 2. Após a ordena-ção, eles devem estar armazenados nesta ordem: 2, 5, 8, 17 e 45.

Para eetuar a ordenação, trocaremos os elementos de posição (permutas) até chegarmos àordem desejada. emos, então, a seguinte situação:

A[1] = 45 | A[2] = 8 | A[3] = 17 | A[4] = 5 | A[5] = 2

Iniciaremos o processo de troca por meio da comparação um a um, ou seja, vamos começarpelo elemento A[1] e compará-lo com todos os demais, um por vez. Assim que encontrarmos umelemento com valor menor que A[1], aremos uma permuta, mas continuaremos o procedimento atéque A[1] tenha sido comparado com todos os outros elementos.

Após a permuta do elemento A[1], o processo deve ser repetido para A[2]. Não será necessáriocompará-lo com o novo valor de A[1] porque, após a primeira permuta, já sabemos que esse valor éo menor de todos e, portanto, está na posição adequada. Esse processo será repetido sucessivas vezescom os demais elementos até que tenhamos ordenado todo o conjunto.

Vamos, então, executar o algoritmo de troca no conjunto de dados da matriz A. Para iniciar,basta comparar o valor do elemento armazenado em A[1] com o valor do elemento em A[2]. Comoo elemento em A[2] é menor que o elemento em A[1], é preciso azer uma permuta entre A[1] eA[2], deixando a matriz com os elementos nesta ordem:

A[1] = 8 | A[2] = 45 | A[3] = 17 | A[4] = 5 | A[5] = 2

Continuaremos a comparação do valor de A[1] = 8 com o valor de A[3] = 17. Nesse caso, A[3]não é menor que A[1], portanto não haverá troca. Seguiremos, assim, com a execução do algoritmo,comparando o valor de A[1] com o de A[4].

O elemento em A[4] é menor que o valor em A[1], então esses elementos serão trocados, dei-xando a matriz com a seguinte configuração:

A[1] = 5 | A[2] = 45 | A[3] = 17 | A[4] = 8 | A[5] = 2

Perceba que, à medida que o algoritmo executa a ordenação, o valor do primeiro elemento ficamais baixo, mais próximo do ideal, que, nesse caso, é o número 2.

Continuamos o processo, desta vez comparando o valor de A[1] com o de A[5]. Como A[5]possui o valor 2, que é menor que o valor 5 armazenado em A[1], haverá permuta entre esses dois

elementos. Após essa troca, a matriz fica da seguinte orma:A[1] = 2 | A[2] = 45 | A[3] = 17 | A[4] = 8 | A[5] = 5

Não há mais elementos a serem comparados com A[1] e, por esse motivo, já temos o valorfinal esperado para o elemento A[1]. Assim, não precisamos mais eetuar comparações com o ele-mento A[1].

A[1] = 2 | A[2] = 45 | A[3] = 17 | A[4] = 8 | A[5] = 5




Repetiremos o procedimento no elemento A[2], mas vamos compará-lo com A[3], A[4] eA[5]. Comparando os elementos A[2] e A[3], verificamos que o valor de A[3] é menor que o deA[2], por isso haverá troca.

A[1] = 2 | A[2] = 17 | A[3] = 45 | A[4] = 8 | A[5] = 5

Em seguida, o valor de A[2] deve ser comparado com o valor de A[4]. Como 8 é menor que17, aremos uma permuta entre A[2] e A[4], deixando a matriz com a seguinte configuração:

A[1] = 2 | A[2] = 8 | A[3] = 45 | A[4] = 17 | A[5] = 5

Por fim, comparamos o valor do elemento A[2] com o valor de A[5], que também é menor queo atual valor de A[2]; logo, haverá nova permuta, conorme indicado no esquema:

A[1] = 2 | A[2] = 5 | A[3] = 45 | A[4] = 17 | A[5] = 8

Agora, vamos comparar a próxima posição (A[3]) com os elementos restantes (A[4] e A[5]). O valor 45 do elemento A[3] será comparado com o valor 17 do elemento A[4]. Como 17 é menor que

45, haverá permuta entre A[3] e A[4].A[1] = 2 | A[2] = 5 | A[3] = 17 | A[4] = 45 | A[5] = 8

O valor 17 do elemento A[3] será comparado, desta vez, com o valor 8 do elemento A[5].Como 8 é menor que 17, haverá permuta.

A[1] = 2 | A[2] = 5 | A[3] = 8 | A[4] = 45 | A[5] = 17

Não há mais elementos a serem comparados com A[3], portanto o valor 8 já está na posição final.

A[1] = 2 | A[2] = 5 | A[3] = 8 | A[4] = 45 | A[5] = 17

Para finalizar o algoritmo, alta apenas comparar o elemento A[4] com o A[5]. Como o valor17 de A[5] é menor que o valor 45 de A[4], eles serão trocados: A[4] passa a ter o valor 17 e A[5],o valor 45:

A[1] = 2 | A[2] = 5 | A[3] = 8 | A[4] = 17 | A[5] = 45

Não há mais comparações a serem eitas. Pode-se notar que a classificação oi realizada, ouseja, a matriz está ordenada:

A[1] = 2 | A[2] = 5 | A[3] = 8 | A[4] = 17 | A[5] = 45

Para outros tipos de dados, como caractere ou string (cadeia), o processo de classificação segueos mesmos passos; o algoritmo é o mesmo, só muda o tipo de dado. Lembre-se de que a ordem aser considerada é a da tabela ASCII. Logo, “A” tem valor menor (vem antes) que “B” e “A” também émenor que “a”; essa ordem é dada pelo valor numérico associado a cada caractere.




Exemplo

Desenvolver um programa que leia um conjunto de nomes de 20 estudantes inscritos na provado ENEM. Com esses nomes, realizar uma ordenação crescente para acilitar a localização donome na lista que será afixada no quadro de avisos da escola.

SoluçãoDeve-se utilizar uma matriz de uma dimensão (vetor) para armazenar os nomes dos estudan-tes. Essa matriz pode ser preenchida por meio de um laço. A cada iteração o sistema receberáum nome e alimentará o vetor. Para a ordenação, é preciso aplicar o algoritmo de troca estuda-do, azendo as devidas comparações, de modo que, ao final, o conjunto esteja ordenado.

Diagrama de blocos

Início

I 1, 20, 1

I 1, 19, 1

ESTUD[I]

Fim

ESTUD[I]

J 1, 20, 1

I 1, 20, 1

N

SESTUD[I] >ESTUD[J]

X ESTUD [I]ESTUD [I] ESTUD [J]

ESTUD [J] X

Figura 6.1 - Diagrama de blocos para aordenação dos nomes dos estudantes.


programa LISTA_NOME_ORDENADA

var

ESTUD : conjunto[1..20] de cadeia

I , J : inteiro

X : cadeia

início


leia ESTUD [I ]

m_para


para J de I + 1 até 20 passo 1 faça

se (ESTUD [I ] > ESTUD [J ]) então

X ← ESTUD [I]

ESTUD[I] ← ESTUD[J]

ESTUD[J] ← X

m_se

m_para

m_para


escreva ESTUD [I ]

m_para

m




A Figura 6.1 ilustra o diagrama de blocos que representa a entrada dos nomes dos 20 estudan-tes, o armazenamento dos nomes no vetor, o processo de classificação crescente com trocas sucessivas e a apresentação dos nomes dos estudantes de orma ordenada.

Observe que oi necessário usar o recurso de laços encadeados (ou aninhados) no trecho emque havia troca:



se (ESTUDANTES [I ] > ESTUDANTES [J ]) então

X ← ESTUDANTES [I]

ESTUDANTES [I] ← ESTUDANTES [J]

ESTUDANTES [J] ← X

m_se

m_para

m_para

Isso acontece porque precisamos eetuar, para cada elemento do vetor, as comparações e pos-síveis trocas com todos os elementos posteriores (laço interno). Esse processo é repetido para cadaelemento do vetor (laço mais externo).

No primeiro laço, oi utilizada uma variável auxiliar I para controlar o elemento do vetorusado como base de comparação. Observe que a variável I começa com o valor 1 (primeiro ele-mento do vetor) e termina com 19 (penúltimo elemento do vetor). Isso acontece porque o último elemen-to (de número 20) nunca será base de comparação, já que não há elemento após ele a ser comparado.

Veja, também, que a variável J começa com o valor I + 1 porque o primeiro elemento a sercomparado será sempre o subsequente (I + 1) ao elemento utilizado como base de comparação

naquela iteração. Dessa orma, se I = 1 (estamos alando do elemento A[1]), J terá de ser igual a I + 1;logo, compararemos A[I] com A[J] ou A[1] com A[2] e assim por diante.

Ao longo da execução do algoritmo, a variável J tomará vários valores. Verifique a abela 6.2.

abela 6.2 - Variação dos valores de I e J durante a execução do algoritmo de ordenação por troca

Tabela de valores das variáveis I e J

Quando I for J será

1 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20

2 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20

3 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20

4 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20

5 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20

[...]




Tabela de valores das variáveis I e J

Quando I for J será

15 16, 17, 18, 19, 20

16 17, 18, 19, 20

17 18, 19, 20

18 19, 20

19 20

O valor de J sempre será subsequente ao de I e seguirá incrementado até atingir o valor 20, quecorresponde ao índice do último elemento desse vetor de 20 posições, pois o problema considera20 estudantes.

Ao final de cada iteração do laço mais interno (controlado por J), o fluxo do programa voltaao laço externo (controlado por I) e acrescenta 1 ao valor de I, até chegar a 19, o que significa que oprograma alcançou sua última iteração de processamento da ordenação.

Um ponto importante a observar é o algoritmo de troca de valores (swap). Verifica-se, antesda troca, se o elemento comparado tem valor menor que o elemento-base. Se houver, a troca é reali-zada. Para eetuar a troca sem perder os valores, utiliza-se uma variável auxiliar (X) de mesmo tipo.

Por que o termo inglês bug, que significa inseto, é empregado para representar um erro computacional? Acredita-se que otermo foi inicialmente usado em 1878, por Thomas Edson, quando um inseto causou problemas de leitura em seu fonó-grafo. No entanto, foi Grace Murray Hopper (criadora da linguagem COBOL) que, em 1945, documentou um erro provo-cado por uma mariposa que teria ficado presa entre os relés do computador que ela usava.

Para saber mais, consulte: <http://www.fernandamaria.com.br/curiosidades-sobre-o-mundo-da-computacao/>. Acessoem: 28 jan. 2014.


6.2 Pesquisa de elementos

Ao utilizar matrizes, podemos ter dificuldade para encontrar, rapidamente, valores em suaestrutura. Perceba que a matriz pode gerar grandes tabelas, portanto a localização de determinadoelemento nem sempre é simples, mesmo que o conjunto de dados esteja previamente ordenado.

Para resolver problemas como esse, há técnicas de programação e algoritmos específicos para

pesquisa de elementos em matrizes e outras estruturas de dados. Apresentaremos, a seguir, uma dastécnicas mais simples de pesquisa: a busca sequencial.

No método de pesquisa/busca sequencial, o dado desejado é procurado sequencialmentedesde o primeiro elemento até chegar ao último. Se a pesquisa chegar ao final do conjunto e nãolocalizar o dado, é porque ele não está armazenado na matriz. Vejamos um exemplo na abela 6.3.




abela 6.3 - Exemplo de dados para pesquisa sequencial

Índice Nomes

1 Ludmila

2 João

3 Jefferson

4 Maria Luísa

5 Silvia Amélia

6 Clodis

7 Alexandre

A abela 6.3 representa uma matriz unidimensional (vetor) com sete elementos do tipo string(cadeia). Deseja-se pesquisar um dos seus elementos (eetuar uma busca). Essa busca pretendeencontrar Jefferson que, no caso, está na posição de índice 3.

A pesquisa sequencial é a mais simples e corriqueira. Verifica-se, elemento por elemento, seo valor armazenado corresponde à chave de busca (elemento que se procura). Isso é eito até que apesquisa localize o elemento desejado ou chegue ao final do arquivo sem obter resultado.

No exemplo da abela 6.3, o valor da chave de busca (Jefferson) oi comparado com o valordo primeiro elemento. Como eram dierentes, a comparação passou ao segundo elemento; tambémdierentes. A chave de busca oi comparada, então, com o próximo elemento, cujo valor era igual aoprocurado. Assim, o algoritmo parou a pesquisa e inormou que ela oi realizada com sucesso.

Exemplo

Em uma aula de Biologia, o proessor deseja que a classe descubra os nomes de determinadosanimais após descrever suas características. Cada grupo de alunos deve, portanto, tentar des-cobrir o nome de um animal procurando-o no computador. Se ele não or encontrado no conjunto de dados do programa, é porque o grupo escolheu o animal errado. Deve-se elaborar umprograma que leia e armazene dez nomes de animais, além de permitir a busca e a apresenta-ção do nome de certo animal utilizando o algoritmo de pesquisa sequencial.

Solução

O algoritmo para este problema deve receber como entrada dez nomes de animais que possam

ser solicitados como chaves de busca. Para realizar a pesquisa sequencial, será necessário umlaço que eetue a busca enquanto o usuário desejar. ambém deve ser solicitada a chave debusca (dado a ser pesquisado), que será comparada com cada um dos dez nomes de animaisdo conjunto. Além disso, o nome deve ser mostrado, quando encontrado. Caso ele não sejalocalizado, é preciso inormar que o nome pesquisado não existe no conjunto.




Exemplo


programa PESQUISA

var

ANIM : conjunto[1..10] de cadeia

I : inteiro

PESQ , RESP : cadeia

ACHA : lógico

início


leia ANIM [I ]

m_para

RESP ← "SIM"

enquanto (RESP = "SIM") faça

escreva "Digite o nome do animal a ser pesquisado: "

leia PESQ

I ← 1

ACHA ← Falso

enquanto (I <= 10) e (ACHA = Falso) faça

se (PESQ = ANIM [I ]) então

ACHA ← Verdadeiro

senão

I ← I + 1

m_se

m_enquanto

se (ACHA = Verdadeiro) então

escreva PESQ , " foi localizado na posição ", I

senão

escreva PESQ , " não foi localizado no conjunto de dados"

m_se escreva "Deseja continuar? (SIM/NÃO): "

leia RESP

m_enquanto

m




Exemplo

Diagrama de blocos

RESP ‘‘SIM’’

RESP = ‘‘SIM’’

N

S

PESQ

I 1 ACHA F

N

S

SN

I <= 10 e ACHA = F

PESQ=ANIM[I]

I I + 1 ACHA V

SN

ACHA = V

PESQ ‘‘não foilocalizado’’

PESQ ‘‘foilocalizado na

posição’’ I

RESP

Fim

Figura 6.2 - Diagrama de blocos para a pesquisa sequencial de nomes.

Anteriormente, oi montada a rotina de pesquisa com base em um contexto. Observe, a seguir,o trecho que executa a pesquisa com seus comentários:




1 - leia PESQ

2 - I ← 1

3 - ACHA ← Falso

4 - enquanto (I <= 10) e (ACHA = Falso) faça

5 - se (PESQ = ANIMAIS[I]) então

6 - ACHA ← Verdadeiro

7 - senão

8 - I ← I + 1

9 - m_se

10 - m_enquanto

11 - se (ACHA = Verdadeiro) então

12 - escreva PESQ , "foi localizado na posição", I

13 - senão

14 - escreva PESQ , "não foi localizado no conjunto de dados"

15 - m_se

A primeira linha solicita o nome do animal que servirá de chave de busca, o qual será atribuí-do à variável PESQ. Na segunda linha, o contador recebe o valor-base 1 para que possa atuar noloop; ele é incrementado até 10, que é o total de elementos do conjunto de dados (vetor).

Na linha 3, a variável flag (bandeira - utilizada para indicar algo) ACHA é colocada como alsa;ela inorma se o dado procurado oi encontrado no vetor. No começo, como o dado ainda não oiencontrado, seu valor inicial deve ser Falso. A linha 4 inicia o laço com a condição de verificar seainda há dados a pesquisar; para isso, utiliza a variável I, comparando-a com a quantidade máximade elementos (10); enquanto I <= 10 e o nome pesquisado não tiver sido encontrado (ACHA =also), o laço continuará a ser executado (linhas 5 a 9).

A partir da linha 5, a pesquisa é executada no vetor ANIMAIS, comparando a chave de busca(valor da variável PESQ) com cada elemento desse vetor. Se o nome procurado estiver na posiçãoI do vetor, a flag ACHA será alterada para Verdadeiro; caso contrário, a variável de controle I seráincrementada apenas para a próxima iteração. Isso acontecerá até que I atinja o valor 10 ou a flag tenha valor verdadeiro.

Ao final do laço por um dos motivos mencionados, nas linhas 11 a 15 verificaremos o valor da flag . Se or Verdadeiro, significa que o nome do animal pesquisado existe no conjunto de dados; docontrário, será inormado que o nome pesquisado não consta no conjunto de dados.

Atente para a importância de uma variável flag como ACHA. No começo da execução do algo-ritmo, a bandeira fica “abaixada”, ou seja, indica alsidade. Quando o nome pesquisado é encontrado,ela passa a ter valor verdadeiro, como se tivesse sido “levantada”.




Neste capítulo, estudamos algumas operações práticas para ordenação e pesquisa de elementos emmatrizes. Com esse conhecimento você pode escrever algoritmos mais elaborados no paradigma de pro-gramação sequencial!

Vamos recapitular?

Agora é com você!

1) Desenvolva os algoritmos em diagrama de blocos e a codificação em portuguêsestruturado dos seguintes exercícios:

a) Ler uma matriz de uma dimensão (vetor) com valores coletados em uma pesquisade preços. Colocar os valores em ordem crescente e exibir a matriz reorganizada.

b) Ler duas matrizes unidimensionais (vetores) de números inteiros A e B de cin-co posições cada. Preencher uma terceira matriz SOMA, de mesma dimensão,com a soma das matrizes A e B (a primeira posição de A será somada à primeiraposição de B; o resultado será atribuído à primeira posição da matriz SOMA).Por fim, apresentar a matriz SOMA em ordem crescente.

c) Ler uma matriz 3 x 5 com valores coletados em uma pesquisa de preços por pro-duto. São três produtos e cinco preços por produto. Apresentar os elementos damatriz C em ordem decrescente de preço (por produto). Em seguida, calcular eexibir o valor médio de cada produto.

d) Um programa deve gerar um vetor V contendo os dez primeiros números intei-ros múltiplos de 3, ler um valor inteiro N e, conorme o que você aprendeu sobrepesquisa em matrizes, verificar se existe algum elemento de V que seja igual a N.

e) Ler duas matrizes do tipo vetor A com dez elementos e B com oito elementos. Lerum valor N do mesmo tipo das matrizes A e B. Construir uma matriz C, que seráa junção das outras duas, e pesquisar se o valor N lido está armazenado na matrizC. A pesquisa deve retornar o valor e indicar a matriz que o originou, A ou B.

) Um programa deve ler um vetor com dez códigos alanuméricos dos cursos téc-nicos oertados por uma instituição e deixá-los em ordem crescente. Então, develer um código alanumérico e, em seguida, pesquisar se ele está no vetor, indi-

cando sua posição.



85

7Programaçãocom Registros

Este capítulo mostra como eetuar o trabalho de estruturação de dados com base na criação detipos de dados derivados. Assim sendo, serão apresentados os detalhes para definição, implementação e

uso de registros e definição de novos tipos de dados com base nos dados básicos existentes.

Para começar

7.1 Tipos de dados derivados

Na programação e no desenvolvimento de sistemas para computador, utilizamos diversos tiposde dados básicos (também chamados de tipos primitivos). No Capítulo 2, estudamos os tipos primi-tivos utilizados (inteiro, real, caractere, cadeia e lógico) pelas linguagens de programação, bem comode suas aplicações e limitações. A maioria dos problemas computacionais pode ser resolvida utili-zando os tipos primitivos, porém, em alguns casos, a tarea de programar pode se tornar cansativa e

tediosa, se não buscarmos outras ormas de trabalhar com os dados.

Com o objetivo de acilitar a programação, temos os tipos de dados derivados ou, como emalgumas bibliografias, tipo composto de dados. Um tipo de dados derivado é construído baseando-senos tipos de dados primitivos e são, em sua maioria, utilizados em necessidades específicas; por essemotivo, cada desenvolvedor cria a estrutura necessária para cada projeto a ser desenvolvido.




Um tipo de dados derivado, após a sua criação, será visto por todo o projeto e deve ser defi-nido antes da criação de uma variável.

Para a criação de novos tipos com base nos tipos primitivos, deve-se seguir a seguinte sintaxe:

tipo

<identi cador> = <tipo de dado primitivo>

Em que:

» Identificador: é a definição do nome do novo tipo a ser utilizado no sistema.

» ipo de dado primitivo: é um dos tipos de dados primitivos já existentes.

Partindo da definição de um novo tipo de dados, é possível criar uma variável baseada no tipode dados que acaba de ser criado.

Por exemplo:

tipo

NOTA = real

var

NOTA_PROVA : NOTA

Veja que nota_prova é uma variável definida com base no tipo NOA.

ocê sabia que o sítio The Language List apresenta informações básicas de 2500 linguagens de programação. Para saberais, consulte o endereço Web: <http://people.ku.edu/~nkinners/LangList/Extras/langlist.htm>. Acesso em: 21 nov. 2013.


7.2 Tipo de dado derivado: registro

Estudamos no Capítulo 5 as variáveis compostas homogêneas, úteis quando se deseja arma-zenar grande quantidade de inormações de um mesmo tipo de dados, porém, quando se tem umaestrutura semelhante a uma tabela, em que cada dado pertence a um conjunto de inormações die-rentes, o processo de programação pode se tornar muito mais complicado.

Nesse caso, temos as variáveis compostas heterogêneas ou simplesmente registro. Um registro éum tipo de dado derivado dos dados primitivos (muitas vezes de dierentes tipos) e é uma estruturacustomizada para atender às necessidade do projeto no qual se está trabalhando.

A sintaxe para a ormação de um registro é ormada com base na seguinte definição:

tipo

<identi cador> = registro

<lista de campos e seus tipos>

m_registro



87Programação com Registros

Em que:

» Identificador: é a definição do nome do registro a ser utilizado no sistema.

» Registro e fim registro: marca início e fim do bloco que contém as variáveis do registro.

» Lista de campos e seus tipos: são os campos e seus respectivos tipos de dados.

Observe a Figura 7.1, em que temos a imagem de uma ficha de acompanhamento acadêmico.A ficha é composta por Dados pessoais (nome do aluno, série, turma e disciplina) e por Evoluçãodas notas/altas (notas e altas para os quatro bimestres). Observe que as inormações a serem arma-zenadas em cada campo são dierentes. Por exemplo, o campo Aluno é uma cadeia de caracteres, jáas Faltas sempre serão um número inteiro, porém uma Nota é composta por um número real . Poresse motivo, um registro é uma estrutura de dados também denominada heterogênea.

Dados pessoais

Ficha acadêmica

Evolução das notas/faltas

Nome:

Série: Turma: Disciplina:

1º bimestre 2º bimestre 3º bimestre 4º bimestre

Falta Nota Falta Nota Falta Nota Falta Nota

Figura 7.1 - Exemplo de um registro.

Com o objetivo de acilitar a montagem do diagrama de bloco, do português estruturado e, porfim, da programação, devem ser tomados os devidos cuidados com relação à identificação dos campose aos tipos de dados que serão armazenados. Na abela 7.1, temos um simples - porém muito útil -quadro utilizado para documentar a estrutura de dados do projeto a ser desenvolvido.

Para o preenchimento da abela 7.1, basta observar quais inormações se deseja armazenar eprocessar pelo algoritmo que se está criando. Para cada registro a ser criado, devemos montar umquadro dierente, no qual em Nome do registro se coloca o nome do registro a ser utilizado, e naspartes Nome do campo e ipo de dados, colocam-se, respectivamente, os nomes dos campos e o tipode dado a ser usado para o campo mencionado. Na abela 7.2 temos o quadro de definição de regis-tro já com as inormações da ficha acadêmica preenchidos.

abela 7.1 - Quadro de definição de uma estrutura de registro

Nome do registro

Nome do campo Tipo de dados




abela 7.2 - Documentação da estrutura do registro FICHA_ACADEMICA

FICHA_ACADEMICA


nome cadeia

série inteiro

turma caractere

disciplina cadeia

falta1 inteiro

nota1 real

falta2 inteiro

nota2 real

falta3 inteiro

nota3 real

falta4 inteiro

nota4 real

Vale lembrar que o correto preenchimento do quadro de definição de registros acilita a cons-trução de todo algoritmo que processa os dados. Essa documentação dever estar acessível a todosaqueles da equipe de desenvolvimento que estão envolvidos na criação do projeto.

Com base na estrutura definida na abela 7.2, tem-se a codificação do seguinte portuguêsestruturado:

tipo

FICHA_ACADEMICA = registro

NOME : cadeia

SERIE : inteiro

TURMA : caractere

DISCIPLINA : cadeia

FALTA1 : inteiro

NOTA1 : real

FALTA2 : inteiro

NOTA2 : real

FALTA3 : inteiro

NOTA3 : real

FALTA4 : inteiro

NOTA4 : real

m_registro

var

aluno : cha_academica




Foi definido, primeiramente, o tipo de dados, isto é, a FICHA_ACADEMICA, para depois criar a variável aluno, definidacomo do tipo FICHA_ACADEMICA. Sendo assim, aluno seria uma variável como outra qualquer, se não fosse por umadiferença: é criada para um projeto específico; por esse motivo que recebe o nome de variável composta heterogênea.Observe que, dessa forma, podemos guardar em uma única estrutura vários tipos diferentes de dados.

Fique de olho!

Em todas as operações (leitura e escrita) que manipula, a variável aluno, é necessário utilizar-mos um operador de escopo, já que ela é composta por diversos campos. A sintaxe geral de acesso é:

[nome da variável de registro].[nome do campo]

Observe o exemplo:

Para acessar o campo NOME do registro FICHA_ACADEMICA, utilizaremos:

ALUNO.NOME

7.3 Estrutura de um registro com matriz

Na FICHA_ACADEMICA, temos estruturas que se repetem, como é o caso de Faltas e Notas(observe que temos Falta1, Falta2, Falta3, Falta4 e Nota1, Nota2, Nota3, Nota4). Nesses casos, é maisinteressante criar um vetor (ou matriz unidimensional) para gerenciar essas inormações. Assim, épossível definir dois vetores, um para nota e outro para alta, em que cada um possui quatro índices.A Figura 7.2 mostra a ficha acadêmica com essa alteração.

Dados pessoais

Ficha acadêmica

Evolução das notas/faltas

Nome:

Série: Turma: Disciplina:

Nota Falta1 2 3 4 1 2 3 4

Figura 7.2 - Alteração do layout da FICHA_ACADEMICA considerando vetores e sua estrutura.

A documentação também deve ser ajustada para a nova configuração, pois temos, agora, aestrutura de dois vetores dentro da ficha acadêmica. Observe a documentação da estrutura propostana abela 7.3 e sua descrição em português estruturado.




abela 7.3 - Nova estrutura para o registro FICHA_ACADEMICA

FICHA_ACADEMICA


nome cadeia

série inteiro

turma caractere

disciplina cadeia

falta conjunto[1..4] de inteiro

nota conjunto[1..4] de real

tipo


NOME : cadeia

SERIE : inteiro

TURMA : caractere

DISCIPLINA : cadeia

FALTA : conjunto[1..4] de inteiro

NOTA : conjunto[1..4] de real

m_registro

var

aluno : cha_academica

Note que a definição para a criação da variável não soreu ajuste; houve alteração apenas naestrutura do registro.

7.4 Tipo de dado derivado: novo tipo

No início deste capítulo, vimos que podemos criar e definir um novo tipo de dados com basenos tipos primitivos. A acilidade de criar novos tipos dá a liberdade aos desenvolvedores de abstrairinormações em estruturas mais simples de ser entendidas do ponto de vista do desenvolvimento.Assim, imagine que queremos criar um tipo de dado denominado bimestre, que conterá dois vetoresde quatro posições, um para as altas para armazenar dados inteiros e outro para as notas, o qual écapaz de receber dados reais. Então, podemos criar o tipo BIMESRE, conorme abela 7.4, e defini--lo dentro do registro FICHA_ACADEMICA (observe na abela 7.5) por meio da variável boletim.




abela 7.4 - Definição do tipo BIMESRE

BIMESTRE


falta conjunto[1..4] de inteiro

nota conjunto[1..4] de real

abela 7.5 - Estrutura do registro FICHA_ACADEMICA com uso do tipo bimestre

FICHA_ACADEMICA


nome cadeia

série inteiro

turma caractere

disciplina cadeia

boletim bimestre

O português estruturado para a estrutura criada na abela 7.5 pode ser observado a seguir:

tipo

BIMESTRE = registro



m_registro


NOME : cadeia

SERIE : inteiro

TURMA : caractere

DISCIPLINA : cadeia

BOLETIM : bimestre

m_registro

var

ALUNO : cha_academica

emos na especificação do registro FICHA_ACADEMICA a criação do campo boletim cujotipo é BIMESRE. Já o tipo BIMESRE é ormado por dois vetores (matriz unidimensional) predefi-nidos. Mais uma vez, observe que nada oi modificado na definição da variável aluno.




7.5 Matriz de registro

Com o que aprendemos até agora, conseguimos criar estruturas para armazenar grande quan-tidade de dados heterogêneos, porém a estrutura de registro criada até então suporta armazenarsomente os dados de um aluno por vez, o que nos remete ao mesmo problema trabalhado no Capí-tulo 5, quando vimos que, para armazenar mais de uma inormação do mesmo tipo, podemos criar

um vetor ou uma matriz com várias posições (índices), em que cada dado específico tem sido arma-zenado em uma posição.

Aqui, em registros, podemos nos utilizar da mesma estrutura de vetores e matrizes, ou seja,criar um vetor de registros com várias posições; em cada posição (indexada por um índice), temosum conjunto de dados totalmente isolado.

Note que, uma vez criada a estrutura do registro, conorme visto anteriormente, basta criar-mos uma variável que seja definida como um vetor do tipo do registro. Vejamos o seguinte exemplo:

Considere uma sala de aula com cinco alunos.

tipo BIMESTRE = registro



m_registro


NOME : cadeia

SERIE : inteiro

TURMA : caractere

DISCIPLINA : cadeia

BOLETIM : bimestre m_registro

var

ALUNO : conjunto[1..5] de cha_academica

Após o uso do comando var, é indicada a variável de registro aluno, ormada por um conjunto(vetor) de cinco registros do tipo de dado derivado FICHA_ACADEMICA.




Exemplo

Crie um programa que eetue a leitura dos dados de uma FICHA-ACADEMICA - como jádefinida - para uma sala de aula com cinco alunos. Ao final, o sistema deve imprimir o nomede cada aluno, sua série, turma, disciplina, o total de altas e a média aritmética.

SoluçãoUma vez definida a estrutura de dados quecomportará os dados, deve-se eetuar a leitu-ra de todos os dados e, em seguida (na ase deprocessamento), calcular e imprimir a somade todas as altas e as médias de cada aluno.

Diagrama de blocos

I 1, 5, 1

INÍCIO

ALUNO[I].NOME

ALUNO[I].SERIE

ALUNO[I].TURMA

ALUNO[I].DISCIPLINA

J 1, 4, 1

ALUNO[I].BOLETIM.FALTA[J]

ALUNO[I].BOLETIM.NOTA[J]

1

Figura 7.3a - recho responsável pelaentrada de dados dos registros.

i 1, 5, 1

j 1, 4, 1

1

total_faltas 0soma_notas 0

total_faltas total_faltas + aluno[i].boletim.falta[j]soma_notas soma_notas + aluno[i].boletim.nota[j]

media soma_notas/4

aluno[i].nome

aluno[i].serie

aluno[i].turma

aluno[i].disciplina

total_faltas

media

Fim

Figura 7.3b - recho responsável peloprocessamento e pela saída de dados.





programa MEDIA_SALA_AULA

tipo

BIMESTRE = registro


NOTA : conjunto[1..4] de real m_registro


NOME : cadeia

SERIE : inteiro

TURMA : caractere

DISCIPLINA : cadeia

BOLETIM : bimestre

m_registro

var

ALUNO : conjunto[1..5] de cha_academica

TOTAL_FALTAS : inteiro

SOMA_NOTAS : real

MEDIA : real

início


leia ALUNO[I].NOME

leia ALUNO[I].SERIE

leia ALUNO[I].TURMA

leia ALUNO[I].DISCIPLINA


leia ALUNO[I].BOLETIM.FALTA[J]

leia ALUNO[I].BOLETIM.NOTA[J] m_para

m_para


TOTAL_FALTAS ← 0

SOMA_NOTAS ← 0


TOTAL_FALTAS ← TOTAL_FALTAS + ALUNO[I].BOLETIM.FALTA[J]

SOMA_NOTAS ← SOMA_NOTAS + ALUNO[I].BOLETIM.NOTA[J]

m_para

MEDIA ← SOMA_NOTAS / 4

escreva ALUNO [I ].NOME escreva ALUNO [I ].SERIE

escreva ALUNO [I ].TURMA

escreva ALUNO [I ].DISCIPLINA

escreva TOTAL_FALTAS

escreva MEDIA

m_para

m




Aprendemos neste capítulo como criar e definir uma variável heterogênea, ou seja, um registro.Vimos, também, como é possível trabalhar com vetores/matrizes com base em um registro.

Vamos recapitular?

Agora é com você!

1) Com base na estrutura definida na abela 7.5, crie o português estruturado de umprograma de computador que, por meio de um menu de opção:

a) Cadastre os dez registros.

b) Pesquise um registro de cada vez pelo campo nome.

c) Imprima na tela os nomes dos alunos em ordem crescente.

d) Imprima o nome do aluno com a maior e a menor média.

e) Imprima o nome do aluno com a maior e a menor quantidade total de altas.

) Imprima o nome do aluno com a maior e a menor nota.

g) Saia do programa de cadastro.

2) Considere a seguinte ficha para uma escola de inormática:

Dados

Ficha cadastral

Nome:

Série: Turma: Sexo: M F Ano de

nascimento:

Média: Aprovado: Sim Não

Construa um programa (definição do registro e português estruturado), que possaler os dados para 20 alunos e responder, por meio de um menu de opções, as seguin-tes questões:

a) Qual a porcentagem de alunos aprovados e reprovados?

b) Qual a porcentagem de alunos do sexo masculino e a do sexo eminino?

c) Quais são os alunos com melhor nota de uma mesma série?

d) Quantos alunos nasceram em um mesmo ano?

e) Qual a listagem dos alunos por ordem alabética separados por sexo?




3) A tabela a seguir se reere ao cadastro dos distribuidores de uma determinada revista.

Distribuidor

Campo Tipo Descrição

DIS_Codigo Inteiro Código único

DIS_Nome Cadeia Razão Social do Distribuidor

DIS_Endereco Cadeia Endereço completo

DIS_Zona Cadeia Divisão de uma cidade. Ex.: Norte, Oeste, Leste e Sul

DIS_Cota Inteiro Número de exemplares recebidos

DIS_Cidade Cadeia Nome da Cidade

Elaborar um programa que armazene todos os dados do registro acima. O programadeve ser manipulado por meio de um menu que execute as seguintes etapas:

a) Cadastrar 15 registros.

b) O usuário deverá ornecer uma determinada cidade e o programa apresentar aRazão Social de todos os distribuidores daquela cidade.

c) Apresentar um relatório que inorme a quantidade de exemplares recebidos porcidade.

d) Apresentar um relatório completo com todos os campos ordenado em ordem cres-cente de cota.



97

8Utilização deSub-rotinas

Neste capítulo você aprenderá a utilizar sub-rotinas e técnicas de programação mais avançadas,como a técnica conhecida por “dividir para conquistar”. Com esse conhecimento, você poderá produzir

códigos-onte mais legíveis, áceis de azer manutenção e essencialmente mais modularizados. Com o usoadequado das técnicas avançadas de programação, você desenvolverá programas ainda mais profissionais.

Para começar

8.1 Dividir para conquistar

A atividade de programar requer conhecimentos lógico-conceituais e, principalmente, técni-cos. Nesse sentido, o pleno domínio das principais técnicas de programação é undamental para aelaboração de algoritmos e programas eficientes e de ácil manutenção. Em computação, algoritmossão considerados eficientes se conseguem resolver um determinado problema com o melhor desem-

penho possível.

Uma das técnicas para projeto de algoritmos mais usuais e importantes da programação decomputadores é conhecida por “dividir para conquistar”. Mais que uma técnica, dividir para con-quistar tem sido considerado um paradigma, uma vez que inspira o desenvolvimento de diversasoutras técnicas de programação e, também, de análise de sistemas.

A técnica de dividir para conquistar consiste basicamente em três procedimentos:




1) Dividir: separar o problema em dois ou mais subproblemas menores similares ao original,pois solucionar vários pequenos problemas, em vez de um grande, é, do ponto de vistacomputacional, supostamente mais ácil;

2) Conquistar: resolver cada subproblema em separado utilizando o próprio algoritmo queestá sendo projetado;

3) Combinar: obter uma solução para o problema original a partir da combinação das solu-ções dos subproblemas.

Cada um desses procedimentos pode ser implementado de modo dierente, de acordo como algoritmo que projetamos e com as necessidades do nosso problema. Por exemplo, para dividir oproblema original, podemos usar divisão binária (dividir o problema em dois subproblemas) oudivisão n-ária (dividir o problema em n partes), conorme mostra a Figura 8.1.

Problemaoriginal

Subproblema1

Subproblema2

Subproblema3

SubproblemaN

Solução 1 Solução 2 Solução 3 Solução N

D i v i s ã o

C o n q u

i s t a

C o m

b i n a ç

ã o

Soluçãodo problema

original

...

Figura 8.1 - Macroprocesso de divisão e conquista.

Os processos de divisão em subproblemas e combinação das soluções são undamentais parao desenvolvimento de algoritmos eficientes. Essa técnica tem sido utilizada na resolução de váriosproblemas da computação, como problemas de ordenação (Quicksort e Mergesort), problemas de

busca (pesquisa binária), problemas geométricos (algoritmo do par mais próximo e convex hull ),entre outros. Para mais inormações sobre esses e outros algoritmos com uso da técnica de divisão econquista, veja Cormen et al. (2002) e Feofiloff (2008).

Em ambiente de desenvolvimento de sofware, é comum ouvir-se o termo “instância de pro-blema”. Instância de um problema computacional são casos específicos de um determinado problema.Ao se projetar um algoritmo utilizando a divisão e conquista, o programador gera quantas instân-cias do problema original orem necessárias. Essas instâncias são reduzidas em termos de dados, oque temos chamado de subproblema, de modo que a solução de cada instância tenha um custo de



99Utilização de Sub-rotinas

processamento muito baixo. Por exemplo, digamos que o nosso problema original seja pesquisar pelapalavra “incondicional” em um glossário com 1000 verbetes. Se utilizarmos um algoritmo que divideo problema em dois subproblemas, podemos ter duas instâncias de 500 verbetes cada.

Para ficar mais ácil de entender, imaginemos uma situação na qual precisemos computar asoma de n números x0 a xn-1. Considerando que n > 0, podemos, então, dividir o problema em pelo

menos dois subproblemas: » soma dos n/2 primeiros números do conjunto;

» soma dos n/2 últimos números do conjunto.

Na prática, houve um desmembramento dos dados de entrada. Dividimos o conjunto de dadosem dois. Logo, surgiram dois subproblemas menores, mas similares ao problema original: computara soma. O próximo passo é, portanto, resolver os dois subproblemas. Uma vez resolvidos, a combi-nação das soluções nos garante a solução do problema original:

Sx(0,n-1) = (x0 + ... + x(n/2)-1) + (xn/2 + ... + xn-1)

Note que esse é um problema simples que poderíamos resolver de uma orma igualmente sim-ples, pela orça bruta, sem uso de técnicas sofisticadas. Inclusive, não há ganho de eficiência se resol- vermos esse algoritmo por meio de um único laço, considerando de uma só vez todo o conjunto dedados. Isso mostra que nem todos os problemas são melhorados por meio da técnica de divisão econquista. Essa premissa é verdadeira até mesmo para outras técnicas de programação. Eis, então,a responsabilidade do programador em escolher a técnica mais adequada para o seu problema.

Então, quando devo aplicar a técnica de divisão e conquista? Basicamente quando:

» o seu problema puder ser particionado em problemas similares menores, o que chama-mos de resolução por indução;

» os subproblemas gerados possam ser solucionados independentemente uns dos outros;

» or possível combinar as soluções dos subproblemas de modo eficiente.

Vejamos agora outro exemplo, um pouco mais complexo. Digamos que desejamos eetuar umabusca em um vetor ordenado.

O modo mais trivial de solucionar esse problema é por meio da pesquisa sequencial, estudada noCapítulo 6. odavia, em um conjunto de dados muito grande, a pesquisa sequencial é pouco eficiente.Nesse caso, a divisão e conquista passam a ser uma estratégia interessante se o conjunto de dados estiver ordenado. Um dos algoritmos de busca por divisão e conquista mais utilizados é a pesquisa binária.

A pesquisa binária consiste em dividir o conjunto de dados (com n elementos) em duas partes,por isso o adjetivo “binário”. Logo, o problema também é reduzido a dois subproblemas menores. Seo conjunto tiver apenas um valor (n = 1) e o elemento procurado or a1, então o valor procurado oiencontrado; caso contrário, esse valor não está no conjunto.

Se n > 1, então verificaremos se a chave de busca está na posição do meio (n/2), ou seja, sek = an/2. Se estiver, o valor procurado oi encontrado; caso contrário, será necessário continuar abusca. Como o conjunto está ordenado, é simples saber se o valor procurado, caso exista, está na pri-meira ou na segunda parte do conjunto.




Dividimos, portanto, o problema em dois a depender do valor da chave de busca:

» busca binária nos elementos a1 até a(n/2)-1 do vetor;

» busca binária nos elementos a(n/2)+1 até an do vetor.

O processo de divisão e conquista se repete até que, então, o valor procurado seja encontradoou descubra-se que o valor não está no vetor. Note que o processo de divisão é realizado quantas vezes or necessário.

Perceba também que nesse algoritmo, os processos de dividir e de conquistar são iterativos eincrementais, ou seja, ocorrem várias vezes, e a cada vez que ocorrem, o algoritmo está mais pró-ximo de encontrar a chave de busca1 (ou de inormar que ela não consta no conjunto de dados).

Note que esse método é semelhante ao que realizamos ao procurar uma palavra (nossa chavede busca) em um dicionário.

Vejamos um exemplo da aplicação desse algoritmo. Encontrar o número 4 no vetor ordenadoV = {1, 3, 4, 9, 10, 11, 15}. Antes de resolver, saiba que o vetor V possui 7 elementos, logo n = 7.

A primeira decisão é aplicada: 4 está na posição n/2, ou seja, na posição 3? Não, pois nessaposição está o valor 9. Então, dividiremos o vetor em dois subconjuntos:

» valores abaixo da posição 3: V1 = {1, 3, 4};

» valores acima da posição 3: V2 = {10, 11, 15}.

Como 4 é menor que 9, então o conjunto representado pelo vetor V2 será descartado e, maisuma vez, o algoritmo de busca binária será executado, dessa vez sobre o vetor V1.

Neste subproblema, a primeira decisão será similar à utilizada no problema original: 4 é menor

que o elemento do meio? A reposta é não. O elemento do meio (posição 1) é 3. Então, o vetor seránovamente dividido em dois novos subconjuntos:

» valor abaixo da posição 1: V11 = {1};

» valor acima da posição 1: V12 = {4}.

Como 4 é maior que 3, o conjunto de valoresabaixo de 3 (vetor V11) será descartado. Sobre o vetor V12 será aplicado novamente o algoritmo debusca binária. Verifique que o V12 possui apenas umelemento. Logo, se o valor procurado or dierente do

valor desse elemento, o algoritmo deve inormar queo valor procurado não se encontra no conjunto dedados. Nesse caso, o valor procurado (4) é igual aoelemento único de V12, logo, o valor procurado oiencontrado, conorme se observa na Figura 8.2.

1 3 4 9 10 11 15

9 10 11 151 3 4

3 41

4

Figura 8.2 - Visualização da execuçãodo algoritmo de busca binária.

1 Chave de busca é o valor procurado no conjunto de dados.




Veja, a seguir, o algoritmo em português estruturado e em diagrama de blocos.

Diagrama de blocos

INÍCIO

I 1, 20, 1

V [I]

X

NESQUERDA<= DIREITA

MEIO (ESQUERDA + DIREITA) DIV 2

V [MEIO] = X

S

MEIOV [MEIO] < X

DIREITA MEIO - 1

FIM

N 20ESQUERDA 0DIREITA N

ESQUERDA MEIO + 1

SN

N S

Figura 8.3 - Diagrama de blocospara o algoritmo de busca binária.


programa BUSCA_BINARIA

var

V : conjunto[1..20] de inteiro

X, N, MEIO, ESQUERDA, DIREITA, I : inteiro

início


leia V [I ]

fm_para

N ← 20

ESQUERDA ← 0

DIREITA ← N

leia X

enquanto (ESQUERDA <= DIREITA) faça

MEIO ← (ESQUERDA + DIREITA) DIV 2

se (V [MEIO ] = X ) então

escreva MEIO

senão

se (V [MEIO ] < X) então

ESQUERDA ← MEIO + 1

senão

DIREITA ← MEIO - 1

fm_se

fm_se

fm_enquanto

fm




8.2 Programação top-down e bottom-up

Ao projetar um sofware, o programador e o projetista podem optar por desenvolvê-lo dasestruturas mais gerais para as mais específicas (top-down) ou vice-versa (bottom-up).

Se optar pelo método top-down, primeiro será desenvolvida a estrutura geral do sofware e

definidos os componentes menores, mas estes serão desenvolvidos conorme o processo de desenvolvimento avançar.

No método bottom-up, os módulos/componentes menores são desenvolvidos e testados, sóentão são agregados para ormar o sofware projetado.

Numa programação top-down o sofware é desenvolvido a partir de refinamentos sucessivos,ou seja, o projeto e a implementação do sofware evolui incrementalmente ao longo do processo dedesenvolvimento. Essa abordagem também é conhecida como método incremental. Um das van-tagens do método top-down é eetuar todas as etapas do processo de desenvolvimento em partespequenas do sofware, logo, ações que só ocorreriam no final do processo são “adiantadas” e execu-

tadas várias vezes em pequenas porções do produto, como os testes unitários e testes com usuários.Para ser eetivo, é preciso que as etapas de refinamento sejam simples e bem definidas e, além

disso, ao longo do desenvolvimento a estrutura basilar do projeto de sofware deve ser definida, oque acilita, inclusive, os testes.

Por sua vez, a programação bottom-up também desenvolve o sofware em etapas. odavia,nessa abordagem, uma proposta inicial do sofware é definida no início do processo de desenvolvi-mento. Essa proposta contém inormações sobre todos os módulos/componentes que serão desenvolvidos. Em seguida, são desenvolvidos os módulos/componentes detalhados.

8.3 Procedimentos

O programador deve sempre se lembrar de manter a legibilidade dos algoritmos e códigos--onte dos seus programas. Para isso, é preciso utilizar-se de vários mecanismos. Um deles é a modu-larização do programa. Ao criar módulos de programas, o programador permite estabelecer açõespontuais para cada porção de código, deixando o programa mais limpo e, consequentemente, maisácil de eetuar manutenção.

Atualmente, há diversas ormas de modularização. Neste capítulo, estudaremos duas ormas:procedimentos e unções.

Procedimentos são subprogramas (também conhecidas por sub-rotinas), ou seja, partes de umprograma maior, com finalidade específica. Os procedimentos executam uma determinada tarea comuso ou não de parâmetros de entrada, mas jamais retornam valores ao programa que o chamou. Osparâmetros são valores enviados pelo programa principal para correta execução dos procedimentos.

odo procedimento deve ter uma assinatura. A assinatura é composta pelo identificador doprocedimento e seus parâmetros de entrada, caso tenha. ambém pode ter espaço para declaração de variáveis. Essas variáveis só poderão ser utilizadas dentro do procedimento onde oram declaradas.




Em português estruturado, podemos definir um procedimento desta orma:

Procedimento <nome do procedimento>(<lista de parâmetros>)

<comandos>

m_procedimento

Vejamos um exemplo de uso de procedimento:

procedimento Ordenacao_Vetor (VET: conjunto[1..N] de inteiro, N: inteiro)

var

I , J : inteiro

X : cadeia

início



se (VET [I ] > VET [J ]) então

X ← VET [I]

VET [I] ← VET [J] VET [J] ← X

m_se

m_para

m_para

m_procedimento

Para que um procedimento seja executado, é necessário que o computador processe umcomando de chamada. Esse comando, em geral, é ormado pelo identificador do procedimentoseguido dos parâmetros necessários, como no exemplo abaixo, em que o procedimento Ordenacao_

Vetor é chamado: programa LISTA_NOME_ORDENADA

var

ESTUD : conjunto[1..20] de cadeia

I : inteiro

início


leia ESTUD [I ]

m_para

Ordenacao_Vetor (ESTUD, 20)


escreva ESTUD [I ]

m_para

m




8.4 Funções

Similar aos procedimentos, unções são subprogramas (também conhecidas por sub-rotinas), ouseja, partes de um programa maior. Uma das principais dierenças é que unções obrigatoriamenteretornam valores ao programa ou subprograma que as chamaram. Esse retorno é conhecido comoparâmetro de saída. Os parâmetros de saída, assim como os de entrada, devem ter um tipo de dado

associado, tais como interiro, real, cadeia ou lógico.

A execução de uma unção pode se dar pela chamada da unção, como no procedimento ou,ainda, por meio de avaliação de uma expressão que contenha a unção, como no excerto:

[...] se (SALARIO > Media_Anual(SALARIOS[], N)) então [...]

Nesse exemplo, a unção Media_Anual será executada ao programa tentar validar a condiçãoSALARIO > Media_Anual (VEOR, N). Para eetuar a comparação do salário com a média anual,será necessário executar a unção Media_Anual. Essa unção recebe o vetor com os salários de todosos meses como parâmetro de entrada e, ao final, retorna como parâmetro de saída o valor médio dossalários recebidos durante o ano.

oda unção deve ter uma assinatura. A assinatura é composta pelos parâmetros de saída, o iden-tificador da unção e pelos parâmetros de entrada, caso tenha. No corpo da unção pode ter espaçopara declaração de variáveis, que só poderão ser utilizadas dentro da unção onde oram declaradas.

Em português estruturado, podemos definir uma unção da seguinte orma:

tipo_retorno Função <nome da função>(<lista de parâmetros>)

<comandos>

m_funcao

Vejamos um exemplo de uso de unção:

função Media_Anual(VET : conjunto de inteiro, N : inteiro) : real

var

I , ACUMULADOR : inteiro

início

para I de 1 até N passo 1 faça

ACUMULADOR ← VET [I ]

m_para

retorne ACUMULADOR / 12

m_função

ocê sabia que o conceito de linguagem de programaç o advém da linguística? Os linguistas tentaram definir precisa-ente quais eram as sentenças válidas descritas em uma determinada linguagem, bem como definiram regras de escrita.

O mesmo ocorre com as linguagens de programaç o. Muitos dos códigos-fonte escritos em linguagens de programaç oassam por analisadores baseados em processos linguísticos de análise léxica, sintática e semântica. Para saber mais,

consulte Price e Toscani (2008).





8.5 Escopo de variáveis

Como vimos ao longo do curso, variáveis podem ser declaradas no programa principal (orade procedimentos e unções), como parâmetros em procedimentos e unções ou, ainda, no corpodessas sub-rotinas.

A variável atende a um determinado escopo, a depender do local onde oi declarada. emosdois tipos dierentes de escopo de variáveis: global ou local.

Variáveis globais devem ser declaradas ora de qualquer sub-rotina, isto é, devem ser declara-das no programa principal. Essas variáveis são inicializadas no começo da execução do programa econtinuam a existir durante todo o processo.

Variáveis locais são aquelas declaradas como parâmetro ou dentro de uma sub-rotina (proce-dimento ou unção). Variáveis desse tipo só poderão ser utilizadas dentro pela unção ou procedi-mento onde oi declarada, não sendo possível seu uso em outra parte em nenhuma hipótese.

Dierente das variáveis globais, as locais são criadas somente quando a sub-rotina é executadae são destruídas ao final da execução da sub-rotina. Essa é uma das vantagens de se utilizar variáveislocais, uma vez que elas ficam em memória somente enquanto são necessárias.

Variáveis de escopos dierentes podem ter o mesmo nome. Portanto, cuidado ao nomear variá- veis locais para que não ocorra duplicidade de nomes entre as variáveis e isso prejudique a manu-tenção do sofware. Quando houver variável local com o mesmo nome de uma global, a sub-rotinaconsiderará a variável local em detrimento da global.

No exemplo a seguir, SALARIOS, SALARIO e QDSAL são variáveis globais e VET , N, I eACUMULADOR são variáveis locais.

programa PAGAMENTOvar

SALARIOS : conjunto[1..20] de real

SALARIO, QTDSAL: inteiro

início

leia SALARIO

QTDSAL ← 12

se (SALARIO < Media_Anual(SALARIOS, QTDSAL)) então

escreva "Este empregado tem direito à bonicação"

m_se

função Media_Anual (VET : conjunto[1..N] de inteiro, N : inteiro) : real

var


início


ACUMULADOR ← VET [I ]




m_para

retorne ACUMULADOR / 12

m_funcao

m

8.6 Passagem de parâmetros

Ao criarmos unções e procedimentos, definimos parâmetros de entrada com tipos associados.Ao serem chamados, as unções e os procedimentos podem receber esses parâmetros por reerência ou por valor.

Na passagem de parâmetros por reerência, a sub-rotina recebe apenas a reerência da variável,ou seja, o endereçamento de memória. O parâmetro passado por reerência se comporta como uma variável global dentro do subprograma e todas as alterações realizadas nela aetarão diretamente a variá-

vel do programa principal passado como parâmetro. Isso porque o subprograma se encarrega de irao endereço passado e capturar o valor que lá está. Essa orma de passagem de parâmetros tambémpermite à sub-rotina alterar o valor da variável diretamente na memória.

Na passagem de parâmetros por valor, o parâmetro tem as características de uma variávellocal. Logo, alterações realizadas nessa variável ficam restritas ao escopo do subprograma, sem aetaro programa principal, como na unção produto do exemplo a seguir. programa EXEMPLO_PASS_VALOR

var

N : inteiro

RESULTADO : inteiro

início

leia N

escreva N

procedimento cálculo (X : inteiro) : inteiro

X ← X * X

retorna X

m_funcao

escreva N

m

Nesse exemplo, considerando que oi lido o valor N = 10, será apresentada na tela aseguinte saída:

10

100

10




O último valor reere-se à variável N, que, por ter sido passada por valor à unção Cálculo, não oi alterado dentro dessa unção. O valor inicial de N é 10 e se mantém o mesmo até o final da execu-ção desse programa.

Veja que a principal dierença entre as duas ormas de passagem de parâmetros é que na passa-gem por valor o conteúdo da variável é “copiado” para o parâmetro da sub-rotina. Na passagem por

reerência, o endereço de memória é atribuído ao parâmetro do subprograma. Com esse endereço, osubprograma pode azer as alterações que desejar, e todas elas serão vistas em qualquer parte do pro-grama, como neste exemplo:

Em português estruturado, podemos definir uma unção da seguinte orma:

função <nome da função>(<lista de parâmetros>) : tipo_retorno

Vejamos um exemplo de uso de unção:

função Media_Anual(VET : conjunto[1..N ] de inteiro, N : inteiro) : realvar


início


ACUMULADOR ← ACUMULADOR + VET[I]

m_para

Media_Anual← ACUMULADOR / 12

m_função

Nesse exemplo, considerando que oi lido o valor N = 10, será apresentada na tela aseguinte saída:

10

100

100

O último valor reere-se à variável N, que, por ter sido passada por reerência à unçãoCálculo, oi alterado dentro dessa unção, dierente do que ocorreu no exemplo em que N oi pas-sada por valor. Veja, também, que para passar valor por reerência a uma unção ou procedimento énecessário colocar a palavra “var” antes do nome do parâmetro na assinatura da sub-rotina.

Neste capítulo, estudamos as características undamentais das sub-rotinas ou subprogramas, osseus tipos (procedimentos e unções) e as características mais importantes, como passagem de parâme-tros por valor e por reerência, escopo de variáveis e métodos top-down/bottom-up.

Vamos recapitular?




gora é com você

1) Escreva uma sub-rotina que receba por parâmetro um número inteiro e imprima seele é divisível por 7 ou não. Decida se usará procedimento ou unção e explique o

porquê da escolha.2) Escreva um procedimento que receba por parâmetro o código do grupo ao qual um

determinado animal pertence e, em seguida, imprima o nome do grupo e a constanteK para cálculo da taxa metabólica basal (MB), conorme tabela a seguir:

Código do grupo Nome do grupo Constante (K)

1 Passeriformes 129

2 Não passeriformes 78

3 Mamíferos Placentários 70

4 Marsupiais e Edentatas 49

5 Répteis 10

3) Escreva uma unção que receba por parâmetro o peso metabólico (PM) de um ani-mal (peso total do animal expresso em quilogramas) e o grupo ao qual esse animalpertence e calcule a taxa metabólica basal (MB). A taxa metabólica basal é o pesometabólico elevado a 0,75 e multiplicado por uma constante K. O valor de K depen-de do grupo do animal, conorme tabela do exercício anterior.

Fórmula de cálculo da taxa metabólica basal: MB = (PM ↑ 0,75) * K

4) Escreva um procedimento que receba por parâmetro o peso metabólico (PM) de umanimal (peso total do animal expresso em quilogramas), o grupo ao qual esse animalpertence e uma letra (flag). Se a letra or B, o procedimento deve chamar uma unçãopara calcular a taxa metabólica basal (MB). Se a letra or E, o procedimento devechamar uma unção para calcular a taxa metabólica específica (ME). Para o cálculoda ME, usar a órmula a seguir. O valor da constante K corresponde ao grupo doanimal, sendo o mesmo tanto para o cálculo da MB como da ME.

Fórmula de cálculo da taxa metabólica específica: ME = (PM ↑ 0,25) * K



109

9Medidas deComplexidadede Algoritmos

Neste capítulo, serão abordados de maneira introdutória e mais didática possível conceitos preli-minares do uso de medidas de complexidade de algoritmos para estudantes iniciantes em programação

de computadores.

Para começar

9.1 Análise de algoritmos

O que apresentamos aqui sobre análise de algoritmos e suas complexidades não é comum emum livro introdutório sobre lógica de programação de computadores para programadores iniciantes,como este. A disponibilidade de livros em português é pequena e o oco desse estudo é ministradoem cursos mais avançados de programação. Assim sendo, o tema ora abordado constitui-se em uma visão preliminar com o objetivo de indicar ao nosso estudante os próximos passos a serem seguidos

no estudo da lógica de programação e no aproundamento desse estudo, que se estende com a apren-dizagem de uma disciplina denominada Estrutura de Dados.

A expressão Análise de Algoritmos, como é usada e como a conhecemos, oi idealizada porDonald E. Knuth quando publicou em 1968 o primeiro volume de uma série de sete livros intituladoTe Art o Computer Programming ( A Arte da Programação de Computadores) não tendo este traba-lho tradução para o português.




A disciplina de Análise de Algoritmos tem por objetivo estudar os problemas computacionaisque se apresentam de orma recorrente, que se mostram de dierentes ormas (FEOFILOFF, 2013).Nesse sentido, podemos entender que essa disciplina visa, para um dado problema, nos mostrar:

» a prova de que o algoritmo que estamos usando está correto.

» a estimativa da complexidade do tempo que a execução do algoritmo consome.

» a estimativa do espaço de memória usada para seu armazenamento.

Veja que, com base no exposto fica ácil concordar com as palavras de Almeida (2000, p. 3)que nos diz que um “algoritmo não é a solução de um problema, pois, se assim osse, cada problemateria um único algoritmo”. Note que poderão existir para a solução de um problema vários cami-nhos, vários algoritmos. Assim sendo, um problema poderá ser resolvidos com o uso de vários algo-ritmos (PRESES, 2011), Almeida (2000, p. 3) acrescenta ainda que “algoritmo é um caminho paraa solução de um problema, e em geral, os caminhos que levam a uma solução são muitas”. Análise de

Algoritmos é a orma com a qual poderemos medir qual algoritmo é o melhor para responder a certoproblema, pois como afirma Prestes (2011) “o ato de um algoritmo resolver um dado problema não

significa que seja aceitável na prática”.Se tivermos dois algoritmos para a solução de um mesmo problema, a ação prática da Análise

de Algoritmos nos permitirá decidir dos dois algoritmos ornecidos, aquele que seja melhor eficiente(otimilidade de algoritmos). É undamental sabermos que eficiência é a orma como um algoritmorealiza sua tarea até atingir seu objetivo e que eficácia é o objetivo em si. Os algoritmos devem sereficazes, devem atender seus objetivos, devem ornecer uma solução de boa qualidade a certo pro-blema. Assim, a eficiência é o grau de satisação de boa qualidade medido pela Análise de Algoritmos para saber qual dos algoritmos encontrados é o melhor para solucionar o problema existente.

Para analisar a eficiência no uso de certo algoritmo, é necessário levar em consideração a exis-

tência de duas possibilidades de análise, como mostra Matos (2008, p. 13):» Pormenorizada: mais exata e direta, em geral menos útil, pois:

é expressa em segundos;

resultado da avaliação da eficiência (por exemplo, tempo gasto): único e dependente da velocidade e características do processador.

» Por meio de ordens de grandeza: ignora as constantes multiplicativas e é uma análiseassintótica (método para medir o tempo total gasto por um algoritmo para realizar certatarea computacional), isto é:

expressa em ordens de grandeza;resultado da avaliação da eficiência: paramétrico (uma unção do comprimento dosdados) e independente da velocidade e características do processador.

Com base nessa explicação, podemos dizer que a Análise de Algoritmos é uma disciplina deEngenharia, de Matemática ou da Ciência da Computação, dependendo do enoque que queira sedar, que procura prever o comportamento de um algoritmo antes mesmo que seja implementado



111Medidas de Complexidade de Algoritmos

e eetivamente colocado “em produção” (FEOFILOFF, 2013, p. 9). Este tipo de análise possibilitaganho econômico na produção de sofware.

O estudo de análise e complexidade de algoritmos pode ser ampliado com base na consulta de diversos outros materiaispublicados na grande rede mundial (Internet), em português, a partir dos seguintes sítios (acesso em: 19 dez. 2013):

http://www.inf.ufrgs.br/~prestes/site/Welcome.html (slides);

http://www.youtube.com/watch?v=j7BKN7phIeY (vídeo aula);

http://www.ime.usp.br/~pf/analise_de_algoritmos/ (diversos materiais);

http://www.ime.usp.br/~pf/livrinho-AA/AA-BOOKLET.pdf (minicurso de análise de algoritmos);

http://www.decom.ufop.br/toffolo/ (diversos materiais de apoio);

http://www.dcc.fc.up.pt/~ap/taa/1011/ (apostila com notas de aula).


9.2 Modelo de tempo e espaço: otimilidadede algoritmos

Nós, programadores de computador, temos que sempre levar em consideração que todo projeto de programa pode vir a ser influenciado pelo estudo de seus comportamentos. Após um pro-blema ser analisado e as decisões sobre o projeto serem tomadas, o algoritmo em si deve ser imple-mentado na orma de um programa de computador. Nesse instante, devemos analisar as inúmerasalternativas que poderemos aplicar, devemos considerar os aspectos de tempo de execução e espaçode memória ocupado. As alternativas encontradas para o desenvolvimento desses algoritmos podemser localizadas em outras disciplinas tais como: pesquisa operacional, otimização, teoria de graos,estatísticas, probabilidades etc. (CLAUDINO, 2013).

Knuth (apud CLAUDINO, 2013, p. 8) inorma que “na área de estudo dos algoritmos, há doistipos de problemas bem distintos” a serem considerados: a análise de um algoritmo particular e aanálise de uma classe de algoritmos e assim os especifica:

» A análise de um algoritmo particular leva em conta o custo do uso de um dado algoritmopara equacionar um problema específico. Características importantes do algoritmo devemser investigadas, geralmente uma análise do número de vezes que cada parte do algoritmodeve ser executada, seguida do estudo da quantidade de memória necessária a ser utili-zada por certo computador.

» A análise de uma classe de algoritmos visa identificar o algoritmo de menor custo possívelpara resolver um determinado problema particular. oda uma amília algoritmos para resolver um problema específico deve ser investigada com o objetivo de identificar o algoritmoque seja o melhor possível. Isso significa colocar limites para a complexidade computacio-nal dos algoritmos pertencentes à classe. Por exemplo, é possível estimar o número mínimode comparações necessárias para ordenar “n” números por meio de comparações sucessivas.




Quando determinamos o menor custo possível e usamos para resolver problemas de determi-nada ordem, como no caso das ordenações de valores ou dos padrões usados para estabelecer o pro-cessamento de uma pesquisa de dados em vetores, temos nestes a medida da dificuldade inerente pararesolvê-los. Além disso, quando o custo de um algoritmo é igual ao menor custo possível, então po-demos concluir que o algoritmo é ótimo para a medida de custo considerada (LOUREIRO, 2005;OFFOLO, 2012). É com base nessas considerações que nós podemos medir o nível de otimilidade de

um algoritmo.

Em relação à otimilidade de algoritmos Potros (2013, p. 3) nos orienta que “para um deter-minado problema, pode existir várias resoluções algorítmicas, então se az necessário escolher omelhor” e acrescenta que “se a mesma medida de custo é aplicada a dierentes algoritmos, então épossível compará-los e escolher o mais adequado para resolver o problema”.

Entre as várias maneiras a qual se pode medir o custo de utilização de um algoritmo Ziviani(1999, p. 4) nos mostra que a ”orma mais adequada de se medir o custo de utilização de um algoritmoé através do uso de um modelo matemático”, acrescenta que “o conjunto de operações a serem execu-tadas deve ser especificado, assim como o custo associado com a execução de cada operação”. Destaorma, o modelo matemático indicado para medir o custo de execução de certo algoritmo reere-se aouso de uma unção de complexidade denominada (n).

A unção de complexidade (n) pode ser utilizada para a obtenção da métrica de tempo(medida do tempo de execução consumida, dado um conjunto de entrada de dados, que certoalgoritmo requer para produzir uma resposta) ou da métrica de espaço (medida da quantidade dememória de computador que o algoritmo necessita para sua execução).

Se a unção de complexidade (n) or usada para medir a quantidade do tempo necessáriopara executar certo algoritmo de tamanho n, então é considerada como unção de complexidadede tempo do algoritmo. Caso a unção de complexidade (n) seja usada para medir a quantidade damemória de computador necessária para executar um algoritmo de tamanho n, então é chamada

unção de complexidade de espaço do algoritmo (ZIVIANI, 1999, p. 4). Podemos considerar comorelações uncionais os aspetos:

» emporal: unção de complexidade de tempo que tem por finalidade relacionar o tama-nho da entrada com o tempo de execução:

t = (n)

» Espacial: unção de complexidade de espaço que tem por finalidade relacionar o tamanhoda entrada com o espaço de memória necessário para o armazenamento requerido:

e = (n)Em termos práticos o ator de medida mais usado é a unção de complexidade de tempo: t = (n).

Isso significa que essa unção é normalmente calculada em primeira instância, ficando, a unção de com-plexidade de espaço: e = (n) em segunda instância. A escolha da unção de complexidade a ser usadadependerá do tipo de métrica que se deseja avaliar para escolher o algoritmo de melhor otimilidade.




Quando se ala em medidas de otimilidade de algoritmos (temporal ou espacial), podem ocor-rer duas possibilidades de resultados, sendo:

» Melhor caso: quando o teste de medição eetuado mostra o tempo mais rápido para a exe-cução do algoritmo ou o menor consumo de espaço em memória;

» Pior caso: quando o teste de medição eetuado mostra o tempo mais longo para a execu-

ção do algoritmo ou o maior consumo de espaço em memória.É importante considerar que o ato de um algoritmo ser mais rápido em sua execução que outro

algoritmo não guarda este relação direta com o ator de consumo de espaço em memória. Assim, poderáocorrer de um primeiro algoritmo ser executado mais rápido que um segundo algoritmo ocupandoeste mais espaço de memória que o segundo algoritmo.

A escolha do melhor ator de medição de otimilidade de algoritmos (espacial e temporal)depende de certa análise, pois se a escolha é pelo algoritmo mais rápido usa-se a unção de comple-xidade de tempo, se or obter o menor consumo de espaço em memória usa-se a unção de complexi-dade espacial. Normalmente leva-se em consideração o tempo de execução (os programas necessitam

ser rápidos), daí o ato de ser a unção de complexidade de tempo a mais usada, mas há momentos emque a rapidez de processamento é mais irrelevante (rotinas de programas menos críticas) proporcio-nando o uso da medida de complexidade de espaço. Em termos práticos é diícil encontrar um pontode equilíbrio entre as unções temporal e espacial, prevalecendo na mediação uma delas.

As métricas de tempo e espaço podem ser usadas de duas maneiras: na orma abstrata e naorma concreta. Na orma abstrata (orma mais comum) az-se a análise da complexidade dos algo-ritmos em papel, considerando-se o grau de inteligência usada para a solução do problema. Naorma concreta az-se a análise da complexidade dos algoritmos em um computador real, onde sepode aerir o desempenho do algoritmo em tempo de execução de máquina. No entanto, o uso des-

sas métricas na esera real dependerá de alguns atores a serem ortemente considerados, tais como:quantidade de memória utilizada e disponível na máquina, tipo de sistema operacional usado, resul-tados dependem do tipo de compilador de linguagem utilizado, dependência da configuração dehardware, entre outras variáveis que podem intererir nas medições realizadas.

ExemploComo exemplo de métrica de tempo de execução (a mais comum) em nível abstrato consi-dere o uso dos algoritmos de pesquisa sequencial e binária para localizar em um vetor A de1000 posições classificados em ordem crescente determinado valor pesquisado. Os valores do vetor A são compostos por números reais múltiplos de 10 iniciando-se em 10. Assim sendo,A[1] = 10, A[2] = 20, A[3] = 30, A[4] = 40, ..., A[1000] = 10000.




Exemplo

Situação-problemaO estudo do método de pesquisa sequencial oi apresentado no Capítulo 6. Apesar de eficaz(se determinado valor existir no vetor este é apresentado) o método não é muito eficiente, uma

vez que para localizar, por exemplo, o elemento 10000 (pior caso) que se encontra na últimaposição do vetor necessitará percorrer um a um cada um dos elementos anteriores, ocorren-do assim um alto custo do tempo de processamento. Se certo elemento pesquisado não existiro algoritmo sequencial percorrerá todas as posições do vetor. Este algoritmo é eficiente se oelemento a ser pesquisado estiver na primeira posição do vetor, caso não esteja o método setorna vagaroso à medida que avança a cada posição do vetor. Em uma situação média de buscao elemento pesquisado é encontrado após n/2 comparações. A unção de complexidade paramétrica de tempo para a situação-problema exposta configura-se como t = (1000). De ormahipotética, imagine que o ciclo de processamento para cada verificação (comparação, locali-zação ou não do elemento) no vetor pesquisado seja executada em um segundo. Assim, para

localizar o elemento 10000 ou responder que não há o elemento pesquisado no vetor o tempogasto na operação será de 1000 segundos (aproximadamente 16,6 minutos).

Um algoritmo de pesquisa bem mais eficiente é o método binário, baseado na ideia de divisãoe conquista (padrão logarítmico), desde que o vetor a ser pesquisado esteja previamente orde-nado. Neste algoritmo, o vetor é dividido em duas partes, a parte central é então comparadacom o elemento pesquisado, se o elemento que estiver na posição central or o elemento pes-quisado a busca é encerrada, se não or é verificada se a possibilidade de encontrar o elementoestá na parte de cima ou na parte de baixo do vetor (considerando um vetor vertical). Se a pro-babilidade de encontrar o elemento pesquisado or a parte de baixo, o início é movimentadopara a primeira posição após o meio da tabela. Se or a parte de cima o final da tabela é movi-

mentado para a posição que antecede o meio. A partir desta sequência, az-se a repetição destealgoritmo até localizar ou não o elemento pesquisado. Considerando-se a estrutura do vetor A o tempo médio de pesquisa na pior situação é em torno de 10 segundos. A unção de comple-xidade para métrica de tempo para a um algoritmo de pesquisa binária configura-se comot = (log 2 1000). Se cada comparação leva o tempo de 1 segundo para ser realizada a localizaçãodo elemento 10000 no vetor ocorrerá em torno de apenas 10 segundos, pois log2 1000 é apro-ximadamente 9.96 (praticamente os 10 segundos indicados). O valor 9,96 é obtido a partir docálculo do log de 1000 sobre log de 2 (log 1000 / log 2).

Ao observar os relatos de uncionamento dos algoritmos de pesquisa nota-se que o de pesqui-

sa binária é em média mais rápido que o sequencial possibilitando menor custo de processa-mento no tempo de execução de um computador. Considerando para esta análise a situaçãomais crítica de uso dos dois algoritmos.

Atente para o trecho de processamento de pesquisa binária do diagrama de blocos da Figu-ra 9.1 e na sequência o código completo do programa em português estruturado, observando otrecho em negrito correspondente a imagem da Figura 9.1.

A operação de pesquisa binária se assemelha ao mesmo tipo de ação que usamos quando con-sultamos uma palavra em um dicionário para descobrirmos o seu significado.




ExemploDiagrama de blocos

RESP ''SIM' '

RESP= ''SIM''

PESQ

COMEÇO 1FINAL 1000 ACHA .F.

COMEÇO <= FINAL.e.

ACHA = F

MEIO (COMEÇO + FINAL) DIV 2

PESQ = A [MEIO]

ACHA .V.

PESQ < A [MEIO]

FINAL MEIO - 1COMEÇO MEIO + 1

ACHA = .V.

PESQ, ''não foilocalizado''

PESQ, ''foi localizadona posição', MEIO'

RESP

N

S

N

S

SN

SN

SN

Figura 9.1 - Exemplo de um algoritmo de pesquisa binária.





programa PESQUISA_BINÁRIA

var

A : conjunto[1..1000] de real

I , J , COMEÇO , FINAL, MEIO : inteiro

RESP : cadeia

PESQ : real

ACHA : lógico

Início

A [1] ← 10


A [I ] ← A [I - 1] + 10

m_para

RESP ← "SIM "

enquanto (RESP = "SIM ") faça

escreva "Entre valor a ser pesquisado: "

leia PESQ

COMEÇO ← 1

FINAL ← 1000

ACHA ← .Falso.

enquanto (COMEÇO <= FINAL ) .e. ( ACHA = .Falso.) faça

MEIO ← (COMEÇO + FINAL ) div 2

se (PESQ = A [ MEIO ]) então

ACHA ← .Verdadeiro.

senão

se (PESQ < A[ MEIO ]) então

FINAL ← MEIO - 1

senão

COMEÇO ← MEIO + 1

m_se

m_se

m_enquanto

se ( ACHA = .Verdadeiro.) então

escreva PESQ , " foi localizado na posição ", MEIO

senão escreva PESQ , " não foi localizado"

m_se

escreva "Deseja continuar? (SIM/NÃO): "

leia RESP

m_enquanto

m




Exemplo

No trecho em negrito, que corresponde ao diagrama de blocos da Figura 9.1 observe a con-dição (COMEÇO <= FINAL) .e. (ACHA = .Falso.) reerente ao segundo laço da imagem, estelaço é responsável por verificar se a pesquisa continua ou não.

Na execução da pesquisa é eetuado o processamento do cálculo MEIO ← (COMEÇO +FINAL) div 2 que tem por finalidade encontrar o valor do meio do vetor.

Após ter o valor da variável MEIO a condição PESQ = A[MEIO] verifica se o valor pesquisa-do (variável PESQ) está na posição A[MEIO] se a condição or verdadeira a variável ACHA é atribuída ao valor .Verdadeiro. e a pesquisa é encerrada. Caso a condição seja alsa o pro-grama é desviado para a segunda decisão com a condição PESQ < A[MEIO] que az a opera-ção de divisão e conquista para a definição da pesquisa binária. Se a condição or verdadeira,ou seja, o valor pesquisado está acima da posição A[MEIO] o fim do vetor identificado pela variável FINAL é atualizado com o valor da variável MEIO menos 1. Se o resultado lógico da

segunda condição or also, ou seja, o valor pesquisado está abaixo da posição central, a variá- vel COMEÇO será atribuída com o valor da variável MEIO mais 1.

Uma curiosidade em relação à medida de otimilidade deste exemplo é que o método de pesquisabinário é sem dúvida, em média, mais rápido que o método de pesquisa sequencial em virtudeda possibilidade que o método de pesquisa binária possui de evitar a percorrer uma parte desne-cessária do vetor e por esta razão ele é mais eficiente. No sentido de agilizar as ações de pesqui-sa em um sistema deve o método de pesquisa binária ser mais utilizado. No entanto o custo deespaço em memória para gerenciá-lo é maior em razão da quantidade de variáveis em uso.

O método de pesquisa sequencial usa as variáveis de apoio PESQ, RESP e ACHA, além das

variáveis que representam o vetor e o acesso a cada posição do vetor. O método de pesquisabinária além das variáveis que representam o vetor e o acesso a posição de cada elemento no vetor e das variáveis PESQ, RESP e ACHA usa as variáveis COMEÇO, FINAL e MEIO con-sumindo, assim, mais memória de máquina. Note que, nesse caso, escolher o algoritmo pelaquantidade de memória usada não é uma boa opção.

9.3 Busca de padrões em cadeias de caracteres

O tratamento e manipulação de cadeias de caracteres (strings) é uma tarea operacional muito

requisitada nos sistemas computacionais. anto é verdade, que é muito comum as linguagens de pro-gramação ormais para computadores ornecerem para seus programadores um extenso conjunto deunções com a finalidade de eetuar o tratamento dessa estrutura de dados.

Um dos problemas mais comuns na manipulação de cadeias de caracteres é o de eetuar a buscade padrões de caracteres em determinada sequência de caracteres. A essa ação se dá o nome de bus-ca de padrões em cadeias de caracteres. Para realizar o tratamento de strings, principalmente as opera-ções de busca de padrões existem diversos algoritmos a disposição para este tipo de ação, destacando-se:Knuth-Morris-Pratt (KPM), Boyer-Moore, Rabin-Karp, Harrison, Força Bruta, entre outros.




Veremos, neste tópico, o método de busca de padrões em cadeias de caracteres por orça bruta.O método por orça bruta recebe essa denominação por usar a “orça” de processamento dos compu-tadores, em vez da inteligência do programador. Caracteriza-se por ser a orma mais simples de ee-tuar a ação pretendida e a orma mais trabalhosa de azê-lo, não sendo o mais eficiente dos métodosexistentes, mas adequado para a operação em sequências de caracteres pequenas (MOREIRA, 2012).

O método de orça bruta, também conhecido como método intuitivo tem por objetivo azeruma operação de busca de um conjunto de caracteres (que chamamos de janela) dentro de umasequência de caracteres definida (que chamamos de sentença). A busca inicia-se, preerivelmente, junto ao primeiro caractere da sentença e avança até o último caractere da sentença. Se a janela pes-quisada existir este pode ser impresso à medida que é encontrado na sentença. Se a janela pesqui-sada não or encontrado nada deverá ser apresentado. A janela de pesquisa poderá ser ormada porum ou mais caracteres a serem pesquisados em uma sentença.

Para azer uso deste algoritmo é necessário conhecer algumas definições operacionais:

» o conjunto de caracteres, a sentença chamaremos de S que tem seu início na posição 1 e

estendendo-se até o limite n, sendo representada pelo vetor S[1..n]; » a definição do conjunto de caracteres, a janela chamaremos de J iniciando-se na posição 1

e estendendo-se até o limite m, sendo representada pelo vetor J[1..m];

» o algoritmo de orça bruta para ser operado deve considerar o ato do valor limite m sermenor ou igual ao valor do limite n.

Para azermos a demonstração neste tópico do uso da ação de busca de padrões de caracteresprecisamos levar em consideração um detalhe muito importante, a linguagem de projeto de progra-mação, português estruturado, não possui internamente um conjunto de unções para realizar tare-as específicas, como é o caso da manipulação de certa sequência de caracteres. Assim sendo, essas

operações devem ser definidas logicamente e para não ficar em uma esera abstrata vamos construirmanualmente a lógica de toda ação do programa que será exemplificado.

Para realizar as operação nas estruturas S[1..n] e J[1..n] necessitaremos de uma unção queeetue o cálculo do tamanho dessas sequências de caracteres. odas as linguagens de programaçãopossuem uma unção do tipo length (comprimento) que retorna o tamanho em caracteres de umstring (cadeia de caracteres). A linguagem português estruturado não possui essa e outras unçõesinternas pelo ato de ser uma linguagem de documentação de código, mas nada impede de que aça-mos a implementação desta uncionalidade desde que tenhamos o cuidado de usar nas sequênciasde caracteres manipuladas pela unção tamanho() um caractere de finalização, neste caso, será usadoum ponto final para que o algoritmo de cálculo de tamanho do string saiba o ponto onde parar a exe-cução do programa.

Assim, para a linguagem de programação português estruturado fica definida a unção do tipointerna tamanho() que retornará a quantidade de caracteres de uma sequência de caracteres finali-zada com um ponto final ornecida como seu parâmetro. Para tanto, observe a Figura 9.2 que mostrao diagrama de blocos da unção e seu código em português estruturado definidos a seguir.




Diagrama de blocos

T Texto + ''.''

Tamanho (texto)

I 1

T[I] <> ''.''

I I + 1

Tamanho I - 1

Retorna tamanho

N

S

Figura 9.2 - Função interna tamanho().


função TAMANHO(TEXTO : cadeia) : inteiro

var

I : inteiro

T : cadeiainício

I ← 1

T ← TEXTO + "."

enquanto (T [I ] <> ".") faça

I ← I + 1

m_enquanto

TAMANHO ← I - 1

m

A partir da definição da unção tamanho() para a linguagem português estruturado fica ácilimplementar um programa que localize certa janela de caracteres em uma sentença definida pelométodo de orça bruta.

Exemplo

Como exemplo de busca de padrões em uma sequência de caracteres considere um programaque eetue a busca de uma janela em uma sentença pelo método da orça bruta e retorne comoresultado de sua operação as posições iniciais onde os padrões de caracteres ocorrem na sen-tença. A sentença será “YCABWAAB” e a janela a ser pesquisada será “AB”.

Observe a seguir a disposição do conteúdo da sentença em cada uma das posições do vetorque az parte com certa sequência de caracteres.

Sentença

1 2 3 4 5 6 7 8 9 10

Y C T A B W A T A B

A seguir, é mostrada a janela com a sequência de caracteres a ser pesquisada.

Janela

A B




Ao azer vista no conteúdo da janela podemos perceber que a sequência AB se encontra a par-tir das posições 4 e 9 do vetor onde a sentença se encontra definida.

O programa em questão deverá testar a janela ornecida em todas as posições da sentença,posição por posição a partir do início da sentença. Assim sendo, tentaremos “casar” o conte-

údo da janela dentro da extensão da sentença, Caso os caracteres indicados na janela sejamiguais aos que estão na sentença ocorrerá a apresentação a partir de que posição os carac-teres da janela se encontram na sentença. Se os caracteres da janela orem dierentes doscaracteres da sentença, paramos a comparação e deslocamos a rente da janela para a próxi-ma posição da sentença e é iniciada a ação de busca novamente até que se chegue ao fim dasentença. Observe a seguir a Figura 9.3 com o algoritmo de orça bruta implementado e seurespectivo código em português estruturado.

Diagrama de blocos

N TAMANHO (FRASE)M TAMANHO (JANELA)

INÍCIO

FRASE ''YCTABWATAB''JANELA ''AB''

I 1, N - M + 1, 1

J O

J < M.E.

FRASE [I + J] = JANELA [I + 1]

J J + 1

J = M

FIM

I

SN

N

Figura 9.3 - Diagrama para buscade padrões de caracteres.


programa FORÇA_BRUTA

var

FRASE , JANELA : cadeia

N , M , I , J : inteiro

início

FRASE ← "YCTABWATAB"

JANELA ← "AB"

N ← tamanho(FRASE )

M ← tamanho(JANELA )

para I de 1 até N – M + 1 passo 1 faça

J ← 0

enquanto (J < M ) .e. (FRASE [I + J ] = JANELA[I + 1]) faça

J ← J + 1

m_enquanto

se (J = M ) então

escreva I m_se

m_para

m




As instruções N ← tamanho(FRASE) e M ← tamanho(JANELA) azem uso da unção tama-nho() definida na Figura 9.2. Ao ser verificada a execução do programa por meio de um testede mesa obter-se-á como resultado da ação da execução da instrução escreva I a apresentaçãodos valores 4 e 9 reerentes às posições iniciais onde a janela AB ocorre na sentença FRASE.

9.4 Fundamentos de retrocesso

Um algoritmo de retrocesso (backtraking ) é um mecanismo de ação em proundidade que visa verificar de maneira exaustiva todas as possibilidades de solução de certo problema.

Um mecanismo de backtraking bem popular e comum é o uso de unções recursivas. Uma un-ção recursiva é uma unção que az chamadas a si mesma. O uso de recursividade proporciona aescrita de um código mais elegante com alto grau de abstração.

Exemplo

Como exemplo de recursividade considere uma unção que calcule o valor do atorial de umnúmero inteiro qualquer N.

Diagrama de blocos

Início

LIMITE

Fim

FATORIAL(LIMITE)

FATORIAL (N)

FATORIAL FATORIAL (N - 1) NX

N <= 1

N S

FATORIAL 1

RETORNA FATORIAL

Figura 9.4 - Diagramas de blocos com unção FAORIAL recursiva.





programa CALC_FAT

função FATORIAL(N : inteiro) : inteiro

início

se (N <= 1) então

FATORIAL ← 1

senão

FATORIAL ← FATORIAL(N - 1) * N

m_se

m

var

LIMITE : inteiro

início

escreva "Qual fatorial: " leia LIMITE

escreva FATORIAL(LIMITE )

m

Ao observar a unção recursiva FAORIAL() do algoritmo de programa CALC_FA, nota--se dentro do bloco adjacente para condição N <= 1 (alsa) a operação de cálculo matemático

FAORIAL← atorial(N − 1) * N, em que FAORIAL é atribuído pelo resultado da operaçãoFAORIAL(N − 1) * N. O parâmetro N determina o número de vezes que a operação deve sereetuada e atorial(N − 1) é uma nova instância de chamada da unção a si mesma com o valordo parâmetro N menos 1.

Imagine a unção recursiva FAORIAL() receber como passagem de parâmetro por valor o 5.Neste caso, o resultado dessa operação será 120. Para chegar a esse resultado, são necessáriosos seguintes passos:

1) Ao passar o conteúdo 5 para a unção recursiva FAORIAL() e pelo ato de esse valornão ser menor ou igual a 1, será eetuada a operação FAORIAL← FAORIAL(N − 1) *

N. Neste caso, FAORIAL← FAORIAL(4) * 5, sendo o valor 5 armazenado na pilha dememória.

2) Em seguida, o conteúdo 4 obtido a partir de 5 − 1, não sendo um valor menor ou iguala 1, é passado à unção recursiva FAORIAL() que eetua a operação FAORIAL ← FAORIAL(N − 1) * N. Neste caso, FAORIAL ← FAORIAL(3) * 4, sendo o valor 4 armazenado na pilha de memória.




3) O conteúdo 3 obtido a partir de 4 − 1, não sendo um valor menor ou igual a 1, é passadoà unção recursiva FAORIAL() que eetua a operação FAORIAL← FAORIAL(N − 1)* N. Neste caso, FAORIAL← FAORIAL(2) * 3, sendo o valor 3 armazenado na pilhade memória.

4) Depois, o conteúdo 2 obtido a partir de 3 − 1, não sendo um valor menor ou igual a1, é passado à unção recursiva FAORIAL() que eetua a operação FAORIAL ← FAORIAL(N − 1) * N. Neste caso, FAORIAL ← FAORIAL(1) * 2, sendo o valor 2 armazenado na pilha de memória.

5) Por último, o conteúdo 1 obtido a partir de 2 − 1 é menor ou igual a 1 e, por esta razão,é atribuído à variável FAORIAL o valor 1. Neste caso, a unção recursiva FAORIAL()retorna o valor 1 e multiplica-o pelo valor 2 armazenado na pilha, obtendo o resultado 2 que é então retornado pela própria unção recursiva FAORIAL(). Neste caso o valor 1 édestruído na memória, permanecendo em memória apenas o valor 2.

6) Na sequência, o valor 2 retornado é multiplicado pelo valor empilhado 3, obtendo o valor 6 que é então retornado pela unção recursiva FAORIAL() e o valor 2 é destruídoda memória, permanecendo em memória apenas o valor 6.

7) Após o retorno, o valor 6 é multiplicado pelo valor empilhado 4, obtendo o valor 24 que é então retornado pela unção recursiva FAORIAL() e o valor 6 é destruído da memó-ria, permanecendo em memória apenas o valor 24.

8) Por último, o valor 24 é multiplicado pelo valor empilhado 5, obtendo o valor 120 que éentão retornado pela unção recursiva FAORIAL() e o valor 24 é destruído da memó-ria, permanecendo em memória apenas o valor 120.

Após a obtenção do valor 120, chega-se à quin-ta e última etapa do empilhamento dos valorescalculados, em virtude da passagem de parâ-metro de valor do conteúdo 5 para a unçãoFAORIAL(5). Neste caso, ocorre o encerra-mento da unção e o retorno do valor 120 parao trecho do programa que eetuou a chamadada unção. A Figura 9.5 demonstra grafica-mente a lógica de uncionalidade e de ação emostra como unciona uma unção recursiva

(backtraking ). Cada instância de chamada daunção recursiva FAORIAL() ocorre de ormaa empilhar cada uma das instâncias da unçãoem operação para depois, no retorno, eetuar amultiplicação sucessiva típica do valor retorna-do com o valor armazenado na pilha, a fim decalcular a atorial solicitada.

FATORIAL (5)

FATORIAL (5 - 1) * 5





FATORIAL 1

RETORNA 1

RETORNA 2 * 1

RETORNA 3 * 2

RETORNA 4 * 6

RETORNA 5 * 24

RETORNA 120

Figura 9.5 - Esquema lógico deuncionalidade e ação de unção recursiva.

(MANZANO; FIGUEIREDO, 2012)




A Figura 9.6 apresenta outra perspectiva do processamento da unção recursiva FAORIAL().

FATORIAL (N)

5!

Processamentodeexecuções

recursivas.

Açãodeempilhamen

to.

FATORIAL FATORIAL(N - 1) * N

FATORIAL FATORIAL (N - 1) * N

FATORIAL FATORIAL (N - 1) * N



24 * 54! * 5

3! * 4

2! * 3

1! * 2

0! * 1

120

6 * 4 24

2 * 3 6

1 * 2 2

1 * 1 1

Valoresretornadosdaação

recursiva.

Açãodedesempilhamento.

Figura 9.6 - Perspectiva de unção recursiva. (MANZANO; FIGUEIREDO, 2012)

O processo de recursividade (backtraking ) é considerado elegante, pois acilita a abstração e amodularidade na criação de unções que podem ser complexas. No entanto, devido ao eeitode empilhamento, essa estratégia pode consumir grande espaço de memória.

Sobre aç es de uso de backtraking pesquise os algoritmos relacionados aos problemas: da mochila, do labirinto, das oitoainhas e do passeio do cavalo.


São descritas no capítulo as ações conceituais do uso da análise e complexidade de algoritmos.Foram apresentados em linhas gerais e de orma teórica, sem aproundamento técnico, temas sobre: aná-lise de algoritmos, otimalidade de algoritmos - métricas de tempo e de espaço -, algoritmos de busca depadrões em cadeias de caracteres e algoritmos de retrocesso (backtracking ).

Vamos recapitular?

Agora é com você!

1) Qual é o objetivo da disciplina Análise de Algoritmos?

2) O que deve ser analisado pelo programador de computador após um problema serexaminado e as decisões sobre o projeto serem tomadas?

3) Em que consiste a busca de padrões em cadeias de caracteres?

4) O que é uma unção recursiva?



125Bibliografia

Bibliografa

ALCALDE, E.; GARCIA, M.; PENUELAS, S. Inormática básica. São Paulo: Makron, 1991.

ALMEIDA, C. écnicas de Linguagem de Programação. Portugal: Escola Secundária de Emídio

Navarro, 2000. Disponível em: <http://www.esenviseu.net/Recursos/Recursos.ASP?CodId=59>.Acesso em: 19 dez. 2013.

ALVAREZ, B.; ESMERALDA, M. Organização, Sistemas e Métodos. São Paulo: Makron, 1991.

AZEREDO, P. A. Métodos de Classificação de Dados e Análise de suas Complexidades. Rio deJaneiro: Campus, 1996.

BAISA, L. Elementos de Programação. São Paulo: Edgard Blücher, 1983.

BELLIS, M. Fortran: Te First Successul High Level Programming Language. About.com Inven-

tors, Disponível em: <http://inventors.about.com/od/computersofware/a/Fortran.htm>. Acesso em:12 nov. 2013.

BERG, A. C.; FIGUEIRÓ, J. P. Lógica de Programação. Editora ULBRA, Rio Grande do Sul: EditoraULBRA, 1998.

BIO. Ada Augusta. Bio. rue History. Disponível em: <http://www.biography.com/people/ada-love-lace-20825323>. Acesso em: 12 nov. 2013

BOUE, R. . Te Euclidean definition o the unctions div and mod. ACM ransactions on Pro-gramming Languages and Systems (OPLAS). v. 14, p. 127-144, 2 abr. 1992.

CAINE, S.; GORDON, K. PDL: A ool or Sofware Design. Proc. National Computer Conerence,AFIPS Press, 1975.

CHAPIN, N. A New Format or Flowcharts. Sofware - Practice and Experience, v. 4, n. 4, 1974.

CLAUDINO, R. Análise de Algoritmos. Minas Gerais: Universidade Federal de Itajubá, 2013. Dis-ponível em: < https://sites.google.com/site/analgorit/cc140-12>. Acesso em: 19 dez. 2013.

CORMEN, . H.; LEISERSON, C. E.; RIVES, R. L.; SEIN, C. Algoritmos: teoria e prática. radu-ção da segunda edição americana. radutor: Vandenberg D. de Souza. Rio de Janeiro: Elsevier, 2002.

DAHL, O. J.; et al. Structured Programming . Academic Press, 1972.

DIVERIO, . A.; MENEZES, P. B. eoria da computação: máquinas universais e computabilidade.3. ed. Porto Alegre: Bookman, 2011. v. 5. (Série Livros Didáticos - Instituto de Inormática UFRGS).

FARRER, H. Algoritmos Estruturados. Guanabara, 1986.

FEOFILOFF, P. Algoritmos em linguagem C. Rio de Janeiro: Elsevier, 2008.

FEOFILOFF, P. Minicurso de Análise de Algoritmos. São Paulo: Universidade de São Paulo, 2013. Dis-ponível em: <http://www.ime.usp.br/~p/livrinho-AA/AA-BOOKLE.pd>. Acesso em: 19 dez. 2013.




FORBELLONE, A. L. V.; EBERSPÄCHER, H. F. Lógica de programação: A construção de Algorit-mos e Estruturas de Dados. São Paulo: Makron, 2000.

GUIMARÃES, A. M.; LAGES, N. A. C. Algoritmos e Estruturas de Dados. Rio de Janeiro: LC, 1994.

HOUAISS, A. Dicionário Eletrônico Houaiss da Língua Portuguesa: Versão 2.0a. Brasil: InstitutoAntônio Houaiss/Editora Objetiva, 2007.

KNUH, D. E. Te Art o Computer Programming: Fundamental Algorithms. Massachusetts:Addison-Wesley, vol 1, 1972.

LEIJEN, D. Division and Modulus or Computer Scientists. 2001. Disponível em: <http://research.microsof.com/en-us/um/people/daan/download/papers/divmodnote.pd>. Acesso em: 6 dez. 2013.

LOUREIRO, A. A. F. Algoritmos e Estruturas de Dados II – Introdução. Belo Horizonte: Univer-sidade Federal de Minas Gerais, 2005. Disponível em: <http://homepages.dcc.umg.br/~loureiro/alg/052/>. Acesso em: 19 dez. 2013.

MANZANO, J. A. N. G.; FIGUEIREDO, J. Algoritmos: Lógica para Desenvolvimento de Programa-ção de Computadores. São Paulo: Érica, 2012.

MARIN, J. écnicas Estruturadas e Case. São Paulo: Makron, 1991.

MAOS, A. ópicos Avançados de Algoritmos. Portugal: Universidade do Porto, 2008. Disponívelem: <http://www.dcc.c.up.pt/~ap/taa/1011/>. Acesso em: 18 dez. 2013.

MOREIRA, G de A. Algoritmos para Busca de Padrões: uma análise empírica. São Paulo: Facul-dade de ecnologia de São Paulo, 2012. Disponível em: <http://www.atecsp.br/dti/tcc/tcc00058.pd>. Acesso em: 22 de dez. de 2013.

NASSI, I.; SHNEIDERMAN, B. Flowchart echiques or Structured Programming . SIGPLANNotices, ACM, 1973.

PACIEVICH, Y. Lógica de Programação. Nov. 2013. Disponível em: <http://www.inoescola.com/inormatica/logica-de-programacao/>. Acesso em: 11 nov. 2013.

POROS, J. de P. Medida do empo de Execução. Minas Gerais: IF Sudeste de MG, 2013. Disponí- vel em: <https://sistemas.riopomba.isudestemg.edu.br/dcc/index.php?arquivo=disciplina_materiais.php&codigo_disciplina=166&codigo_proessor=6593>. Acesso em: 20 dez. 2013.

PRESSMAN, R. S. Engenharia de Sofware. São Paulo: Makron, 1995.

PRESES, E. Complexidade de Algoritmos. Rio Grande do Sul: Universidade Federal do RioGrande do Sul, 2011. Disponível em: <http://www.in.urgs.br/~prestes/Courses/Complexity/>Acesso em: 18 dez. 2013.

PRICE, A. M. A.; OSCANI, S. S. Implementação de Linguagens de Programação: compiladores.3. ed. Porto Alegre: Bookman, 2008.

PRINCEON. ALGOL. Princeton University. Disponível em: <http://www.princeton.edu/~achaney/tmve/wiki100k/docs/ALGOL.html>. Acesso em: 12 nov. 2013



127Bibliografia

SALIBA, W. L. C. écnica de Programação: Uma Abordagem Estruturada. São Paulo: Makron, 1993.

SCIENCE MUSEUM. Te Babbage Engine. Computer History Museum. Disponível em: <http://www.computerhistory.org/babbage/adalovelace/>. Acesso em: 12 nov. 2013.

SEBESA, R. W. Conceitos de Linguagens de Programação. 5. ed. Rio Grande do Sul: Bookman, 2003.

SIMCSIK, . OMIS: Organização, Métodos, Inormação, Sistemas. São Paulo: Makron, 1992.SZWARCFIER, J. L.; MARKENZON, L. Estruturas de Dados e seus Algoritmos. Editora LC,Rio de Janeiro: Editora LC, 1994.

OFFOLO, . Análise de Algoritmos. Minas Gerais: universidade Federal de Ouro Preto, 2012.Disponível em: <http://www.decom.uop.br/toffolo/ensino/todas/bcc202_2012-1/aulas/>. Acessoem: 19 dez. 2013.

VENANCIO, C. F. Desenvolvimento de Algoritmos: Uma Nova Abordagem. São Paulo: Érica, 1998.

VERZELLO, R. J. Processamento de Dados. São Paulo: McGraw-Hill, 1984.

WEBER, R. F. Fundamentos de Arquitetura de Computadores. 3. ed. Porto Alegre: Instituto deInormática UFRGS: Editora Sagra Luzzato, 2004.

WIRH, N. Algoritmos e Estruturas de Dados. São Paulo: Prentice-Hall, 1989.

ZIVIANI, N. Projeto de Algoritmos com Implementação em Pascal e C. 4. ed. São Paulo: Pio-neira, 1999.



Marcas Registradas

odos os nomes registrados, marcas registradas ou direitos de uso citados neste livro pertencem aosseus respectivos proprietários.

algoritmos - técnicas de programação

Documents