Programando a linguagem algorítmica executável, Manuais, Projetos, Pesquisas de Engenharia Biológica

Baixe Programando a linguagem algorítmica executável e outras Manuais, Projetos, Pesquisas em PDF para Engenharia Biológica, somente na Docsity!

Jaime Evaristo

Professor da Universidade Federal de Alagoas

Sérgio Crespo

Professor da Universidade do Vale do Rio dos Sinos

Aprendendo

a

Programar

Programando numa

linguagem algorítmica

executável (ILA)

Segunda Edição

Formato digital

Maceió

solucionam os exercícios propostos. Naturalmente, o leitor deve resistir a tentação de consultar a solução de um problema proposto diante da primeira dificuldade em resolvê-lo. Aprende-se a programar programando e ao se escrever um programa invariavelmente se comete erros. A descoberta destes erros, a procura de formas de solucioná-los são ações que facilitam o desenvolvimento da lógica de programação. Neste sentido, é importantíssimo implementar as soluções obtidas no ILA (disponível para download em http://inf.unisinos.br/~crespo) e executar os programas correspondentes para que, estando a solução correta, tenha-se a sensação de vitória e o desejo de resolver outras questões; estando a solução incorreta, procure-se aprender com os erros cometidos. Como também estamos aprendendo, quaisquer críticas e sugestões dirigidas a [email protected] ou a [email protected] serão bem vindas. Jaime Evaristo Sérgio Crespo

Prefácio (à segunda edição) Esta é a edição digital do livro Aprendendo a Programar Programando numa Linguagem Algorítmica Executável publicado em 2000, no formato impresso, pela Editora Book Express, baseada na cidade do Rio de Janeiro. O esgotamento da edição impressa e o encerramento da atividades da editora ensejaram-nos a oportunidade de disponibilizar o conteúdo do livro, que pode ser utilizado como livro texto em disciplinas do tipo Lógica de Programação ou para aprendizagem autodidática de programação de computadores. Ao contrário da versão impressa, esta edição não contém as respostas dos exercícios propostos. Para obter o caderno das soluções dos exercícios basta encaminhar e-mail para [email protected] com assunto RESPOSTAS LIVRO ILA e contendo NOME, CATEGORIA (docente, discente, autodidata), CIDADE/ESATADO e, se for o caso, INSTITUIÇÃO/CURSO. Os autores aproveitam a ocasião para agradecer aos vários colegas que têm referido o livro nos planos pedagógicos de suas disciplinas e aos pesquisadores que o citam nos seus trabalhos de pesquisa. Sendo uma edição digital, correções e inclusões no texto podem ser feitas a qualquer momento. Assim, os autores rogam a participação dos leitores no sentido da melhoria do livro (inclusive, com a inclusão de novos exercícios) e prometem registrar estas intervenções. Toda e qualquer observação deve ser encaminhada para [email protected] com o assunto LIVRO ILA. Em julho de 2010 Jaime Evaristo Sérgio Crespo

• 1 INTRODUÇÃO À PROGRAMAÇÃO..........................................................................................
  • 1.1 ORGANIZAÇÃO BÁSICA DE UM COMPUTADOR.........................................................................................
  • 1.2 LINGUAGEM DE MÁQUINA.................................................................................................................
  • 1.3 PROGRAMAS DE COMPUTADORES........................................................................................................
  • 1.4 LÓGICA DE PROGRAMAÇÃO................................................................................................................
  • 1.5 RESOLUÇÃO DE PROBLEMAS..............................................................................................................
  • 1.6 PROCESSADOR DE UM ALGORITMO....................................................................................................
  • 1.7 EXEMPLOS DE ALGORITMOS MATEMÁTICOS.........................................................................................
  • 1.8 LINGUAGENS DE ALTO NÍVEL............................................................................................................
  • 1.9 SINTAXE E SEMÂNTICA DE UMA INSTRUÇÃO........................................................................................
  • 1.10 SISTEMAS DE COMPUTAÇÃO...........................................................................................................
  • 1.11 EXERCÍCIOS PROPOSTOS................................................................................................................
• 2. INTRODUÇÃO À LINGUAGEM ALGORÍTMICA...............................................................
  • 2.1 VARIÁVEIS SIMPLES........................................................................................................................
  • 2.2 EXPRESSÕES ARITMÉTICAS...............................................................................................................
  • 2.3 RELAÇÕES....................................................................................................................................
  • 2.4 EXPRESSÕES LÓGICAS.....................................................................................................................
  • 2.5 ESTRUTURA/EXECUÇÃO DE UM PROGRAMA EM ILA............................................................................
  • 2.6 COMANDO DE ENTRADA..................................................................................................................
  • 2.7 COMANDO DE SAÍDA......................................................................................................................
  • 2.8 COMANDO DE ATRIBUIÇÃO...............................................................................................................
  • 2.9 EXEMPLOS PARTE I........................................................................................................................
  • 2.10 FUNÇÕES PRÉ-DEFINIDAS...............................................................................................................
  • 2.11 EXEMPLOS PARTE II.....................................................................................................................
  • 2.12 EXERCÍCIOS PROPOSTOS................................................................................................................
• 3. ESTRUTURAS DE SELEÇÃO...................................................................................................
  • 3.1 INTRODUÇÃO.................................................................................................................................
  • 3.2 COMANDO SE...............................................................................................................................
  • 3.3 EXEMPLOS PARTE III.....................................................................................................................
  • 3.4 COMANDO FACA CASO....................................................................................................................
  • 3.5 EXERCÍCIOS PROPOSTOS..................................................................................................................
• 4. ESTRUTURAS DE REPETIÇÃO..............................................................................................
  • 4.1 INTRODUÇÃO.................................................................................................................................
  • 4.2 COMANDO PARA PROXIMO...............................................................................................................
  • 4.3 COMANDO FACA ENQUANTO............................................................................................................
  • 4.4 EXEMPLOS PARTE III.....................................................................................................................
  • 4.5 EXERCÍCIOS PROPOSTOS..................................................................................................................
• 5. FUNÇÕES.....................................................................................................................................
  • 5.1 INTRODUÇÃO.................................................................................................................................
  • 5.2 EXEMPLOS PARTE IV.....................................................................................................................
  • 5.3 RECURSIVIDADE............................................................................................................................
  • 5.4 EXERCÍCIOS PROPOSTOS..................................................................................................................
• 6. VARIÁVEIS COMPOSTAS........................................................................................................
  • 6.1 INTRODUÇÃO.................................................................................................................................
  • 6.2 EXEMPLOS PARTE V......................................................................................................................
  • 6.3 FORMATAÇÃO DA SAÍDA/INTERFACE COM O USUÁRIO............................................................................
  • 6.4 EXERCÍCIOS PROPOSTOS..................................................................................................................
• 7. PESQUISA E ORDENAÇÃO.....................................................................................................
  • 7.1 INTRODUÇÃO.................................................................................................................................
  • 7.2 PESQUISA SEQUENCIAL....................................................................................................................
  • 7.3 PESQUISA BINÁRIA.........................................................................................................................
  • 7.4 ORDENAÇÃO PELO ALGORITMO SELECTSORT......................................................................................
  • 7.5 ORDENAÇÃO PELO ALGORITMO BUBBLESORT.....................................................................................
  • 7.6 EXERCÍCIOS PROPOSTOS..................................................................................................................
• 8. CADEIAS DE CARACTERES...................................................................................................
  • 8.1 INTRODUÇÃO.................................................................................................................................
  • 8.2 O OPERADOR CONCATENAÇÃO E AS FUNÇÕES PARTE E VALOR...............................................................
  • 8.3 EXEMPLOS PARTE VII....................................................................................................................
  • 8.4 EXEMPLOS PARTE VIII..................................................................................................................
  • 8.5 EXERCÍCIOS PROPOSTOS..................................................................................................................
• ÍNDICE REMISSIVO......................................................................................................................
• BIBLIOGRAFIA..............................................................................................................................

1 Introdução à Programação 1.1 Organização básica de um computador Um computador é constituído de quatro unidades básicas: unidade de entrada , unidade de saída , unidade de processamento central e memória. Uma unidade de entrada é um dispositivo que permite que o usuário interaja com o computador, fornecendo-lhe dados e informações que serão processadas. O teclado o seu exemplo mais trivial. Uma unidade de saída , por seu turno, serve para que sejam fornecidos ao usuário do computador os resultados do processamento realizado. O monitor de vídeo e uma impressora são exemplos de unidades de saída. A unidade central de processamento é responsável por todo o processamento requerido, sendo muito conhecida por cpu , acrossemia de c entral p rocessing u nit. Já a memória armazena temporariamente dados e informações que serão utilizados no processamento. 1.2 Linguagem de máquina

Linguagens de comunicação

Evidentemente, há a necessidade de que as unidades que compõem um computador se comuniquem. Por exemplo, um dado fornecido pelo teclado deve ser armazenado na memória; para a cpu realizar uma operação aritmética, ela vai “buscar” valores que estão armazenados na memória, e assim por diante. Para que haja comunicação entre as unidades do computador é necessário que se estabeleça uma linguagem. Os seres humanos se comunicam através de várias linguagens. Entre elas estão as linguagens escrita e e oral. Uma comunicação através de uma linguagem escrita é constituída de parágrafos , os quais contêm períodos , que contêm frases, que são constituídas de palavras , sendo cada uma das palavras formadas por letras e esta seqüência termina aí. Assim, uma letra é um ente indivisível da linguagem escrita e, em função disto, é chamada símbolo básico desta linguagem. Este exemplo foi apresentado para que se justifique a afirmação de que toda linguagem requer a existência de símbolos básicos, como os fonemas para a linguagem falada.

A linguagem de comunicação entre as unidades

Como a comunicação entre as unidades do computador teria que ser obtida através de fenômenos físicos, os cientistas que conceberam os computadores atuais estabeleceram dois símbolos básicos para a linguagem. Esta quantidade de símbolos foi escolhida pelo fato de que através de fenômenos físicos é muito fácil obter dois estados distintos e não confundíveis, como passar corrente elétrica/não passar corrente elétrica, estar magnetizado/não estar magnetizado, etc., podendo cada um destes estados ser um dos símbolos. Assim a linguagem utilizada para comunicação interna num computador, chamada linguagem de máquina , possui apenas dois símbolos. Cada um destes símbolos é denominado bit ( bi nary digi t ) e eles são representados por 0 (zero) e 1 (um). Esta forma de representar os bit's justifica a sua denominação: binary digit , que significa dígito binário (além disto, bit em inglês significa fragmento). Portanto, as palavras da linguagem de máquina são seqüências de bits, ou seja, seqüências de dígitos zero e um.

O código ASCII

Para que haja a possibilidade da comunicação do homem com o computador, é necessário que as palavras da linguagem escrita sejam traduzidas para a linguagem de máquina e vice-versa. Para que isto seja possível, é necessário que se estabeleça qual a seqüência de bit's que corresponde a cada caractere usado na linguagem escrita. Ou seja, é necessário que se estabeleça uma codificação em seqüência de bit's para cada um dos caracteres. Uma codificação muito utilizada é o código

milhares. Rigorosamente falando, um programa dos acima citados são conjunto de programas menores, cada um deles com objetivos mais restritos, e que podem ser executados de forma integrada. É comum se utilizar a palavra oriunda do inglês software para designar um conjunto de programas com objetivos mais restritos que, sendo executados de forma integrada, propiciam a execução de ações bem mais genéricas. A parte da Ciência da Computação que trata do desenvolvimento de softwares é denominada Engenharia de Software. O estudo da Engenharia de Software deve ser precedido da aprendizagem do desenvolvimento de programas “menores”, ação que comumente é denominada de Programação de Computadores. 1.4 Lógica de programação Sendo um conjunto de instruções cujas execuções redundam na realização da tarefa para a qual foi desenvolvido, o desenvolvimento de um programa requer a utilização de um raciocínio ímpar em relação aos raciocínios utilizados na solução de problemas de outros campos do saber. Por exemplo (e de forma simplificada) ao se tentar resolver um problema de Mecânica Newtoniana deve-se procurar capturar da especificação da questão as grandezas físicas envolvidas e aplicar as fórmulas que relacionam estas grandezas. Para se desenvolver um programa que resolva um determinado problema é necessário que encontremos uma seqüência de instruções que cujas execuções resultem na solução da questão. É comum se utilizar a termo algoritmo para indicar uma seqüência de instruções que resolvem um dado problema, ficando, neste caso, o termo programa para indicar um algoritmo que pode ser executado por um computador. A Lógica de Programação pode ser entendida como o conjunto de raciocínios utilizados para o desenvolvimento de algoritmos (e, portanto, de programas). Por exemplo, imagine a seguinte questão: um senhor, infelizmente bastante gordo, está numa das margens de um rio com uma raposa, uma dúzia de galinhas e um saco de milho. O senhor pretende atravessar o rio com suas cargas, num barco a remo que só comporta o senhor e uma das cargas. Evidentemente, o senhor não pode deixar em uma das margens, sozinhos, a raposa e a galinha, nem a galinha e o milho. A questão é escrever um algoritmo que oriente o senhor a realizar o seu intento. Naturalmente, na primeira viagem, ele não pode levar a raposa (neste caso, as galinhas comeriam o milho), nem o milho (caso em que a raposa devoraria as galinhas). Logo, na primeira viagem ele deve levar as galinhas. Como ele estará presente na chegada, na segunda viagem ele pode levar a raposa ou o milho. Mas, e a volta para apanhar terceira carga? A solução é ele voltar com as galinhas e, aí, atravessar o milho, já que não há problema em que a raposa e o milho fiquem juntos. Escrevendo as instruções na seqüência em que elas devem ser executadas, teremos o seguinte algoritmo.

1. Atravesse as galinhas.
2. Retorne sozinho.
3. Atravesse a raposa.
4. Retorne com as galinhas.
5. Atravesse o milho.
6. Retorne sozinho.
7. Atravesse as galinhas. 1.5 Resolução de problemas Uma pergunta que o leitor pode estar se fazendo é: como vou "descobrir" que a primeira instrução deve ser a travessia das galinhas? Algumas tarefas para as quais se pretende escrever um algoritmo podem ser vistas como um problema a ser resolvido. O exemplo anterior é um exemplo claro de uma tarefa com esta característica. Existem algumas técnicas que podem ser utilizadas para a resolução de problemas.

No exemplo anterior, para se definir qual seria a primeira instrução, como existem apenas três possibilidades, verifica-se o que aconteceria ao se escolher determinada instrução. Foi o que, de passagem, foi feito acima: se o homem atravessasse primeiro o milho, a raposa devoraria as galinhas; se o homem atravessasse primeiro a raposa, as galinhas comeriam o milho. Neste caso, podemos dizer que foi utilizada a técnica da exaustão: como o número de alternativas era pequeno, analisamos todas elas, uma a uma. Esta técnica pode ser utilizada também na solução do seguinte problema: dispõe-se de três esferas idênticas na forma, sendo duas delas de mesmo peso e a terceira de peso maior. A questão é descobrir qual a esfera de peso diferente, realizando-se apenas uma pesagem numa balança de dois pratos. Para isto chamemos de A e B as esferas de mesmo peso e de C a de maior peso. Se optarmos por colocar duas esferas num dos pratos (indicando por X + Y, o fato de colocarmos as esferas X e Y num mesmo prato da balança) e a outra esfera no outro, temos as seguintes possibilidades: a) (A+B, C). b) (A+C, B). c) (B+C, A). No primeiro caso, pode acontecer qualquer coisa: a balança pode ficar equilibrada, se Peso(C) = Peso(A+B); ficar inclinada para o lado esquerdo, se Peso(C) > Peso(A+B) ou ficar inclinada para o lado direito se Peso(C) < Peso(A+B). Observe que nada pode distinguir a esfera C. Nos dois últimos casos, a balança se inclinará para a esquerda, mas, outra vez, nada distingue a esfera C. Por exaustão, resta então escolhermos duas esferas e colocarmos cada uma delas num dos pratos da balança. Agora os casos possíveis são: a) (A, B). b) (A, C). c) (B, C). No primeiro caso, a balança ficará equilibrada, o que indica que a mais pesada é aquela não escolhida; nos outros dois casos, a balança se inclinará para a direita, indicando que a esfera mais pesada é aquela que ocupa o prato respectivo. Temos então o seguinte algoritmo:

1. Escolha duas esferas.
2. Coloque cada uma das esferas escolhidas num dos pratos da balança.
3. Se a balança ficar equilibrada, forneça como resposta a esfera não escolhida; caso contrário, forneça como resposta a esfera do prato que está num nível mais baixo. Uma outra técnica de resolução de problemas consiste em se tentar resolver casos particulares da questão ou resolver a questão para dados menores do que os dados que foram fixados. Para exemplificar, consideremos a seguinte questão: como obter exatamente 4 litros de água dispondo de dois recipientes com capacidades de 3 litros e 5 litros^1? Como 4 = 3 + 1 ou 4 = 5 – 1 conseguiremos resolver a questão se conseguirmos obter 1 litro. Mas isto é fácil, pois 1 = 3 + 3 – 5! Temos então o seguinte algoritmo:
4. Encha o recipiente de 3 litros.
5. Transfira o conteúdo do recipiente de 3 litros para o recipiente de 5 litros.
6. Encha o recipiente de 3 litros.
7. Com o conteúdo do recipiente de 3 litros, complete o recipiente de 5 litros.
8. Esvazie o recipiente de 5 litros.
9. Transfira o conteúdo do recipiente de três litros para o recipiente de 5 litros.
10. Encha o recipiente de 3 litros.
11. Transfira o conteúdo do recipiente de 3 litros para o recipiente de 5 litros. Para compreender o algoritmo, sejam A e B os recipientes de 3 litros e de 5 litros, respectivamente, e indiquemos por (X, n) o fato de o recipiente X conter n litros de água. No início (^1) A solução desta questão foi necessária num filme da série Duro de Matar para o protagonista desativar uma bomba.

1. i = 1.
2. Soma = 8. 3.1.1. i = 2. 3.2.1. Soma = 8 + 4 = 12 3.1.2. i = 3. 3.2.2. Soma = 12 + 9 = 21. 3.1.3. i = 4. 3.2.3. Soma = 21 + 13 = 34. 3.1.4. i = 5. 3.2.4. Soma = 34 + 7 = 41. Naturalmente, na execução acima estamos indicando por 3.1.x e 3.2.x a execução de ordem x das instruções 3.1 e 3.2. Como veremos ao longo do livro, este algoritmo é bastante utilizado em programação, sendo que é mais comum que até o primeiro termo da relação seja "somado" dentro da repetição. Neste caso, para que o primeiro seja somado, é necessário que Soma seja inicializado com 0 (zero), ficando assim o algoritmo:
3. Faça i = 0.
4. Faça Soma = 0.
5. Repita n vezes as instruções 3.1 e 3.2. 3.1. Substitua i por i + 1. 3.2. Substitua Soma por Soma + ai. Conhecendo este algoritmo, é fácil então resolver a questão de se calcular o produto de n números nas mesmas condições, e aí vemos como utilizar uma solução conhecida para resolver um problema. Deve-se inicializar uma referência Produto com 1 e, numa repetição, multiplicar os números como foi feito no caso da soma:
6. Faça i = 0.
7. Faça Produto = 1.
8. Repita n vezes as instruções 3.1 e 3.2. 3.1. Substitua i por i + 1. 3.2. Substitua Produto por Produto x ai. 1.6 Processador de um algoritmo Obviamente, um algoritmo deve ser executado por algum agente. Este agente pode ser uma pessoa munida de certos equipamentos e utensílios ou por máquinas projetadas para executar automaticamente algumas instruções básicas. O algoritmo para a travessia do senhor gordo com as galinhas, sua raposa e seu saco de milho seria executado pelo tal senhor, que estava para tal munido do barco e de remos. O algoritmo para obtenção de quatro litros de água a partir de recipientes de conteúdos cinco litros e três litros poderia ser executado por uma pessoa que dispusesse dos dois recipientes e de água em abundância. Neste último caso, quem sabe, a pessoa poderia ser substituída por um robô. O agente que executa um algoritmo é chamado processador e para que o algoritmo seja executado é necessário que o processador seja capaz de executar cada uma das suas instruções. Se o senhor gordo não souber remar ele não será capaz de atravessar o rio. Uma pessoa que não seja capaz de esvaziar um recipiente que pese cinco quilos não será capaz de executar o algoritmo dos quatro litros de água. Alguns autores de livros com objetivos idênticos a este - facilitar a aprendizagem da programação de computadores - iniciam seus textos discorrendo exclusivamente sobre resolução de problemas , encarando o processador como uma "caixa preta" que recebe as instruções formuladas pelo algoritmo e fornece a solução do problema, não levando em conta o processador quando da

formulação do tal algoritmo. Entendemos que esta não é a melhor abordagem, visto que o conhecimento do que o processador pode executar pode ser definidor na elaboração do algoritmo. Por exemplo: imagine que queiramos elaborar um algoritmo para extrair o algarismo da casa das unidades de um inteiro dado (apresentaremos posteriormente uma questão bastante prática cuja solução depende deste algoritmo). Evidentemente, o algoritmo para resolver esta “grande” questão depende do processador que vai executá-lo. Se o processador for um ser humano que saiba o que é número inteiro, algarismo e casa das unidades, o algoritmo teria uma única instrução:

1. Forneça o algarismo das unidades do inteiro dado. Porém, se o processador for um ser humano que saiba o que é número inteiro e algarismo, mas não saiba o que é casa das unidades, o algoritmo não poderia ser mais esse. Neste caso, para resolver a questão, o processador deveria conhecer mais alguma coisa, como, por exemplo, ter a noção de "mais à direita", ficando o algoritmo agora como:
2. Forneça o algarismo "mais à direita" do número dado. E se o processador é uma máquina e não sabe o que é algarismo, casa das unidades, "mais à direita", etc.? Nesta hipótese, quem está elaborando o algoritmo deveria conhecer que instruções o processador é capaz de executar para poder escrever o seu algoritmo. Por exemplo, se a máquina é capaz de determinar o resto de uma divisão inteira, o algoritmo poderia ser:
3. Chame de n o inteiro dado;
4. Calcule o resto da divisão de n por 10;
5. Forneça este resto como o algarismo pedido. Algumas das questões anteriores são importantes para se desenvolver o raciocínio, mas não é este tipo de questão que se pretende discutir ao longo deste livro. Estamos interessados em algoritmos para:
6. Resolver problemas matemáticos, como algoritmos para determinar a média aritmética de vários números dados, determinar as raízes de uma equação do segundo grau, encontrar o máximo divisor comum de dois números dados, totalizar as colunas de uma tabela, etc.
7. Resolver questões genéricas, como algoritmos para colocar em ordem alfabética uma relação de nomes de pessoas, atualizar o saldo de uma conta bancária na qual se fez um depósito, corrigir provas de um teste de múltipla escolha, cadastrar um novo usuário de uma locadora, etc.. Na linguagem natural, o algoritmo para o cálculo da média pode ser escrito de forma muito simples:
8. Determine a quantidade de números;
9. Some os números dados;
10. Divida esta soma pela quantidade de números. Qualquer pessoa que saiba contar, somar e dividir números é capaz de executar este algoritmo dispondo apenas de lápis e papel. A questão que se põe é: e se a relação contiver 13.426 números? A tal pessoa é capaz de executar, porém, quanto tempo levará para fazê-lo? Um outro aspecto a ser observado é que nem sempre a linguagem natural é eficiente para que as instruções sejam escritas. Nessa linguagem o algoritmo para determinação das raízes de uma equação do segundo grau teria uma instrução difícil de escrever e difícil de compreender como: n. Subtraia do quadrado do segundo coeficiente o produto do número quatro pelo produto dos dois outros coeficientes. Isto pode ser parcialmente resolvido utilizando-se uma linguagem próxima da linguagem matemática que já foi utilizada em exemplos da seção anterior. No caso da equação do segundo grau teríamos o seguinte algoritmo, que nos é ensinado nas últimas séries do ensino fundamental:
11. Chame de a, b e c os coeficientes da equação.

2. O algoritmo abaixo determina o menor divisor maior que 1 de um inteiro dado. A idéia é verificar se d = 2 é divisor e, não sendo, verificar se 3 ou 4 ou 5, etc, é divisor. A procura por um divisor vai até que um divisor seja encontrado. Naturalmente, utilizando o algoritmo anterior, o nosso processador agora sabe determinar o resto da divisão inteira de um inteiro x por outro inteiro y não nulo. Isto será indicado por Resto(x, y). Para encontrar um divisor de n basta encontrar um inteiro d tal que Resto(n, d) = 0.

1. Chame de N o inteiro dado.
2. Faça D = 2.
3. Repita 3.1 enquanto Resto(N, D) ≠ 0 3.1 Substitua D por D + 1
4. Forneça D para o divisor procurado. 3. Como se depreende facilmente da sua denominação, o máximo divisor comum ( mdc ) de dois números dados é o maior número que os divide. Antes o mdc só era utilizado para simplificações de frações ordinárias; atualmente ele é utilizado na determinação de chaves públicas para sistemas de criptografia RSA [Evaristo, J, 2010]. Por exemplo, mdc(64, 56) = 8. De maneira óbvia, o algoritmo abaixo determina o mdc de dois números dados:
5. Chame de x e de y os números.
6. Determine D(x), o conjunto dos divisores de x.
7. Determine D(y), o conjunto dos divisores de y.
8. Determine I, a interseção de D(x) e D(y).
9. Determine M, o maior elemento do conjunto I.
10. Forneça M como o mdc procurado. O cálculo de mdc(120, 84) com este algoritmo seria:
11. x = 120, y = 84.
12. D(120) = {1, 2, 3, 4, 5, 6, 8, 10, 12, 15, 20, 24, 30, 40, 60, 120}.
13. D(84) = {1, 2, 3, 4, 6, 7, 12, 14, 21, 28, 42, 84}.
14. I = {1, 2, 3, 4, 6, 12}.
15. M = 12. Observe que o algoritmo anterior determina o menor divisor de um inteiro não determinando todos os divisores, como necessário neste exemplo. Observe também que estamos supondo que o nosso processador é capaz de determinar a interseção de dois conjuntos. A Matemática fornece uma outra forma de se calcular o mdc de dois inteiros: determina-se a decomposição em fatores primos dos dois inteiros e o mdc é o produto dos fatores primos comuns as duas decomposições com as menores multiplicidades. Para o exemplo dado acima teríamos: 120 2 84 2 60 2 42 2 30 2 21 3 15 3 7 7 5 5 1 1 1 o que nos dá 120 = 2^3 x3x5 e 84 = 2^2 x3x7 e, portanto, mdc(120, 84) = 2^2 x3 = 12. Vale observar que escrever este algoritmo na linguagem informal que estamos utilizando é bastante complicado. Na há dúvida que o primeiro algoritmo para o cálculo do mdc apresentado é de compreensão bastante simples. Porém, comentaremos posteriormente que ele é computacionalmente bastante ineficiente no sentido de que sua execução pode, dependendo dos valores de x e y , demandar um tempo acima do razoável.

Por incrível que possa parecer, um dos algoritmos mais eficientes para o cálculo do máximo divisor comum de dois números foi desenvolvido pelo matemático grego Euclides duzentos anos Antes de Cristo. O algoritmo de Euclides nos é apresentado nas séries intermediárias do ensino fundamental através de um esquema como o diagrama do exemplo abaixo, cujo objetivo é determinar (de novo!) o máximo divisor comum de 120 e 84. 120 84 36 12 0 1 2 3 O esquema funciona da seguinte forma: divide-se 120 por 84 obtendo-se resto 36; a partir daí, repetem-se divisões até que o resto seja zero, sendo o dividendo da divisão atual o divisor da divisão anterior e o divisor da divisão atual o resto da divisão anterior. O último divisor é o máximo divisor procurado. Como se pode ver, estas instruções escritas desta forma não são nada compreensíveis, o que faz com elas sejam transmitidas oralmente nas salas do ensino fundamental. No capítulo 4 (quatro), teremos a oportunidade de discutir este algoritmo com detalhes e veremos que ele é um algoritmo bastante interessante no desenvolvimento da lógica de programação.

4. Discutiremos agora o algoritmo para o cálculo da média de uma relação contendo um número grande (digamos, 10 000) de números dados. No caso da equação do segundo grau, eram três os dados de entrada e, portanto, os chamamos de a , b , e c. Mas agora são 10 000 os dados de entrada! Uma solução possível é receber os números um a um, somando-os antes de receber o seguinte, conforme vimos na seção 1.5.

1. Chame de A o primeiro número dado.
2. Faça S = A.
3. Repita 9 999 vezes as instruções 3.1 e 3.2. 3.1 Chame de A o próximo número dado. 3.2 Substitua o valor de S por S + A.
4. Calcule M = S/10 000.
5. Forneça M para o valor da média. Por exemplo, se a relação de números fosse {5, 3, 8, 11, ...} até a quarta execução de 3.1 e 3. teríamos a seguinte tabela: A S M 5 5 3 8 8 16 11 27 Está fácil perceber que após 9.999ª execução das instruções 3.1 e 3.2 a variável S conterá a soma de todos os números da relação, o que justifica a instrução 4. 5. Um outro exemplo que justifica plenamente a necessidade do conhecimento do que o processador é capaz de executar é a determinação do maior número de uma relação de números. Se o processador for um aluno do ensino médio e a relação contiver poucos números, uma simples olhada na relação permitirá se identificar o maior número. Mas, e se o processador for um aluno das classes iniciais do ensino fundamental? E se a relação contiver 10 000 números? E se os números estiverem escritos em forma de fração ordinária? Uma solução possível é supor que o maior número é o primeiro da relação e comparar este suposto maior com os demais números, alterando-o quando for encontrado um número na relação maior do que aquele que até aquele momento era o maior.
6. Chame de A o primeiro número dado.
7. Faça M = A.
8. Repita 9 999 vezes as instruções 3.1 e 3.2. 3.1 Chame de A o próximo número dado.

quando não são obedecidas dizemos que existe erro de sintaxe. Se o programa fonte contém algum erro de sintaxe, o compilador não o traduz para a linguagem de máquina (isto é, o compilador não compila o programa) e indica qual o tipo de erro cometido e a instrução onde este erro aconteceu. Se o programa fonte for interpretado, ele é executado até a instrução que contém o erro, quando então é interrompida a sua execução e o tal erro é indicado.

O que é semântica

Naturalmente, cada instrução tem uma finalidade específica. Ou seja, a execução de um instrução resulta na realização de alguma ação, digamos parcial , e é a seqüência das ações parciais que redunda na realização da tarefa para a qual o programa foi escrito. A ação resultante da execução de uma instrução é chamada semântica da instrução. Infelizmente, um programa pode não conter erros de sintaxe (e, portanto, pode ser executado), mas a sua execução não fornecer como saída o resultado esperado para alguma entrada. Neste caso, dizemos que o programa contém erros de lógica que, ao contrário dos erros de sintaxe que são detectados pelo compilador ou pelo interpretador, são, às vezes, de difícil detecção. No nosso entendimento, para aprender a programar numa determinada linguagem é necessário que se aprenda as instruções daquela linguagem (para que se conheça o que o processador é capaz de fazer), a sintaxe de cada um destes instruções e as suas semânticas. Aliado a isto, deve-se ter um bom desenvolvimento de lógica programação para que se escolha as instruções necessárias e a seqüência segundo a qual estas instruções devem ser escritas, para que o programa, ao ser executado, execute a tarefa pretendida. Felizmente ou infelizmente, para cada tarefa que se pretende não existe apenas uma seqüência de instruções que a realize. Ou seja, dado um problema não existe apenas um programa que o resolva. Devemos procurar o melhor programa , entendendo-se como melhor programa um programa que tenha boa legibilidade , cuja execução demande o menor tempo possível e que necessite, para sua execução, a utilização mínima da memória. Existe um conjunto de instruções que é comum a todas as linguagens de alto nível e cujas semânticas permitem executar a maioria das tarefas. A aprendizagem das semânticas destas instruções e das suas sintaxes em alguma linguagem de programação (aliado ao desenvolvimento da lógica de programação ) permite que se aprenda com facilidade outra linguagem do mesmo paradigma. 1.10 Sistemas de computação Como foi dito anteriormente, a cpu de um computador é capaz de executar instruções (escritas em linguagem de máquina, permitam a repetição). Ou seja, um computador é capaz de executar programas e só para isto é que ele serve. Se um computador não estiver executando um programa ele para nada está servindo. Como foram concebidos os computadores atuais, um programa para ser executado deve estar armazenado na sua memória. O armazenamento dos programas (e todo o gerenciamento das interações entre as diversas unidades do computador) é feito por um programa chamado sistema operacional. Um dos primeiros sistemas operacionais para gerenciamento de microcomputadores foi o DOS (Disk Operating System). Quando um computador é ligado, de imediato o sistema operacional é armazenado na memória e só a partir daí o computador está apto a executar outros programas. Estes programas podem ser um game , que transforma o "computador" num poderoso veículo de entretenimento; podem ser um processador de texto , que transforma o "computador" num poderoso veículo de edição de textos; podem ser uma planilha eletrônica , que transforma o "computador" num poderoso veículo para manipulação de tabelas numéricas, podem ser programas para gerenciar, por exemplo, o dia a dia comercial de uma farmácia e podem ser ambientes que permitam o desenvolvimento de games ou de programas para gerenciar o dia a dia comercial de uma farmácia. Talvez com exceção de um game , os programas citados acima são, na verdade, conjuntos de programas que podem ser executados de forma integrada. Um conjunto de

programas que podem ser executados de forma integrada é chamado software. Por seu turno, as unidades do computador, associadas a outros equipamentos chamados periféricos , como uma impressora, constituem o hardware. O que nos é útil é um conjunto software + hardware. Um conjunto deste tipo é chamado de um sistema de computação. De agora em diante, os nossos processadores serão sistemas de computação. Isto é, queremos escrever programas que sejam executado por um sistema de computação. Como foi dito acima, o desenvolvimento de um programa que gerencie o dia a dia comercial de uma farmácia requer um compilador (ou um interpretador) que o traduza para a linguagem de máquina. Antigamente, as empresas que desenvolviam compiladores desenvolviam apenas estes programas, de tal sorte que o programador necessitava utilizar um processador de texto à parte para edição do programa fonte. Atualmente, os compiladores são integrados num sistema de computação que contém, entre outros:

1. Processador de texto , para a digitação dos programas fontes;
2. Depurador , que permite que o programa seja executado comando a comando, o que facilita a descoberta de erros de lógica;
3. Help , que descreve as sintaxes e as semânticas de todas as instruções da linguagem;
4. Linker , que permite que um programa utilize outros programas. Rigorosamente falando, um sistema constituído de um compilador e os softwares listados acima deveria ser chamado de ambiente de programação ; é mais comum, entretanto, chamá-lo simplesmente de compilador. O ambiente de programação utilizado neste livro, denominado ILA , contém um interpretador, um depurador e um help e foi desenvolvido pelo Professor Sérgio Crespo, da Universidade do Vale do rio dos Sinos, UNISINOS. O interpretador interpreta programas desenvolvidos numa linguagem algorítmica na qual os comandos são escritos em português e possuem sintaxes bastante simples. Como o ILA não tem integrado um editor de texto, os programas devem editados num processador de texto que grave os textos editados em código ASCII, como, por exemplo, o bloco de nota s do Windows. 1.11 Exercícios propostos 1. Três índios precisam afastar de suas terras três brancos invasores. Para tal e dispondo de um barco cuja capacidade é de apenas duas pessoas, precisam atravessar um rio. Por questões de segurança, os índios não querem ficar em minoria, em nenhum momento e em nenhuma das margens. Escreva um algoritmo que oriente os índios para realizarem a travessia nas condições fixadas. (Cabe observar que, usualmente, este exercício é enunciado envolvendo três jesuítas e três canibais. A alteração feita é uma modesta contribuição para o resgate da verdadeira história dos índios). 2. O jogo conhecido como Torre de Hanói consiste de três torres chamadas origem , destino e auxiliar e um conjunto de n discos de diâmetros diferentes, colocados na torre origem na ordem decrescente dos seus diâmetros. O objetivo do jogo é, movendo um único disco de cada vez e não podendo colocar um disco sobre outro de diâmetro menor, transportar todos os discos para torre destino , podendo usar a torre auxiliar como passagem intermediária dos discos. Escreva algoritmos para este jogo nos casos n = 2 e n = 3. 3. Imagine que se disponha de três esferas numeradas 1, 2 e 3 iguais na forma, duas delas com pesos iguais e diferentes do peso da outra. Escreva um algoritmo que, com duas pesagens numa balança de dois pratos, determine a esfera de peso diferente e a relação entre seu peso e o peso das esferas de pesos iguais. 4. A média geométrica de n números positivos é a raiz n-ésima do produto destes números. Supondo que o processador é capaz de calcular raízes n-ésimas, escreva um algoritmo para determinar a média geométrica de n números dados. 5. Sabendo que o dia 01/01/1900 foi uma segunda-feira, escreva um algoritmo que determine