Algoritmos e Programação
de Computadores
Norton Trevisan Roman
http://www.ic.unicamp.br/~norton/
Material obtido na Internet e editado
com autorização do autor através de e-mail
disponibilizado na próxima página
Prof. José Garibaldi de Carvalho
Prepare-se para as provas
Estude fácil! Tem muito documento disponível na Docsity
Ganhe pontos para baixar
Ganhe pontos ajudando outros esrudantes ou compre um plano Premium
Guias e Dicas
Prepare-se para as provas
Estude fácil! Tem muito documento disponível na Docsity
Encontrar documentos
Prepare-se para as provas com trabalhos de outros alunos como você, aqui na Docsity
Encontra documentos específicos para os exames da tua universidade
Encontra documentos específicos para os exames da tua universidade
Videoaulas
Prepare-se com as videoaulas e exercícios resolvidos criados a partir da grade da sua Universidade
Quiz
Responda perguntas de provas passadas e avalie sua preparação.
Ganhe pontos para baixar
Ganhe pontos ajudando outros esrudantes ou compre um plano Premium
Algoritmo e Programação, Notas de estudo de Algoritmos
Muito Boa - Muito Boa
Tipologia: Notas de estudo
Antes de 2010
1 / 172
Esta página não é visível na pré-visualização
Não perca as partes importantes!
Documentos relacionados
Pré-visualização parcial do texto
Baixe Algoritmo e Programação e outras Notas de estudo em PDF para Algoritmos, somente na Docsity!
Algoritmos e Programação
de Computadores
Norton Trevisan Roman
[email protected]
http://www.ic.unicamp.br/~norton/
Material obtido na Internet e editado
com autorização do autor através de e-mail
disponibilizado na próxima página
Prof. José Garibaldi de Carvalho
[email protected]
Data: Wed, 23 Jun 2004 01:00:26 +
De: ntr
Para: [email protected]
Assunto: Apostilas disponibilizadas
Boa noite.
Bom, não posso responder pelos outros, mas da minha parte, tu podes usá- la à vontade.
Aliás, me chamou a atenção... a apostila de grafos também é minha... tá errado no site (o link leva à minha página...) enfim, acredito que queiras a apostila de Pascal. Então não há problema algum. E se quiser a de
grafos, pode usar também.
Abraço
Norton
p.s. Por um lapso meu, a apostila não está completa... mas na página principal da disciplina, eu
indico o que está completo e o que não está. Consulte:
http://www.dcc.unicamp.br/~norton/paginas/mc102/mc102.html.
p.s2. Gostaria muito de receber qualquer comentário sobre ela... partes que não estão claras, erros etc. Isso ajudaria muito a melhorá- la. Obrigado.
Prezados Professores:
Sou professor do curso Técnico de Informática (segundo grau) do Colégio Santa
Catarina em Novo Hamburgo - RS.
Ministro as disciplinas de Algoritmos e Lógica e Programação.
Nosso colégio participou da Olimpíada 2004 na modalidade programação. Na página
disponibilizada pela OBI, encontram-se apostilas (excelentes) elaboradas pelos
Senhores.
Minha pergunta é:
Existe a possibilidade de as utilizarmos (impressas - resguardando autoria) com os
alunos do Colégio em nossas aulas?
Desde já agradeço pela atenção.
Prof. José Garibaldi de Carvalho
mail: [email protected]
Colégio Santa Catarina
Rua General Osório, 729 Cep: 93510-160 Novo Hamburgo - RS
Fone: (51) 527-
- INTRODUÇÃO
- ESTRUTURA DE UM PROGRAMA ............................................................................
- COMENTÁRIOS..............................................................................................................
- SAÍDA
- PROCEDIMENTOS.........................................................................................................
- IDENTIFICADORES.....................................................................................................
- EXPRESSÕES
- VARIÁVEIS
- ATRIBUIÇÕES ..............................................................................................................
- O COMANDO FOR .......................................................................................................
- ITERAÇÃO.....................................................................................................................
- LAÇOS ANINHADOS ..................................................................................................
- ITERAÇÕES ANINHADAS
- DOWNTO
- RECURSÃO....................................................................................................................
- MEMÓRIA DINÂMICA
- LISTAS LIGADAS ........................................................................................................
- FILAS
- PILHAS
- ARQUIVOS DE ACESSO SEQÜENCIAL..................................................................
- STRINGS.........................................................................................................................
- VETORES (ARRAY).....................................................................................................
- MATRIZES
- BUSCA BINÁRIA..........................................................................................................
- REGISTROS
- TIPOS ENUMERADOS
- PRED E SUCC..............................................................................................................
- O COMANDO CASE...................................................................................................
- TIPO SUBRANGE (INTERVALO) ...........................................................................
- TYPE
- FUNÇÕES.....................................................................................................................
- PASSAGEM DE PARÂMETROS
- POR VALOR E REFERÊNCIA
- VARIÁVEIS LOCAIS E GLOBAIS...........................................................................
- PROCEDIMENTOS.....................................................................................................
- DIAGRAMAS DE EXECUÇÃO
- ENTRADA E SAÍDA...................................................................................................
- CARACTERES.............................................................................................................
- LENDO E ESCREVENDO CARACTERES
- CARACTERES E A TABELA ASCII........................................................................
- TABELA ASCII............................................................................................................
- O COMANDO REPEAT..............................................................................................
- O COMANDO WHILE................................................................................................
- TIPO BOOLEAN..........................................................................................................
- OPERADORES BOOLEANOS
- TIPO REAL...................................................................................................................
- CONVERSÃO DE TIPOS
- O COMANDO IF..........................................................................................................
- CONDIÇÕES
- ELSE..............................................................................................................................
- AND...............................................................................................................................
- OR ..................................................................................................................................
- ANIMAÇÃO BÁSICA.................................................................................................
- ENTRADA....................................................................................................................
- CONSTANTES.............................................................................................................
INTRODUÇÃO
Para a parte prática do curso, a linguagem ensinada é o Pascal. A partir de agora, as
notas de aula se destinarão ao aprendizado desta linguagem. Todos os programas
apresentados aqui funcionam corretamente se compilados usando o Pascal
ESTRUTURA DE UM PROGRAMA
A estrutura de um programa pascal é a seguinte:
PROGRAM nome; {declarações} BEGIN {comandos} END.
"PROGRAM nome" dá um nome ao programa, enquanto que "BEGIN" avisa o
computador onde começa o programa e "END" onde termina.
A parte de "{declarações}" será vista mais tarde. Já "{comandos}" deve conter os
comandos a serem executados no programa (vistos a seguir). No caso acima, como não
há nenhum comando no corpo do programa (espaço entre o BEGIN e o END), nosso
programa não executa nada.
COMENTÁRIOS
Comentários são observações que o programador faz no código do programa para poder
entendê-lo melhor mais tarde, ou permitir que outros possam entender mais facilmente o
programa. É parte da documentação do programa.
Em Pascal há 2 formas de escrevermos comentários:
Entre (* e *)
Entre { e }
Assim, as palavras "declarações" e "comandos" no código acima são comentários. Uma
observação importante sobre comentários é que você não precisa "casar" os { ou (*. O
computador, ao encontrar um { ou (* ignora o que vem após até encontrar um } ou *)
(se você abriu com (*, ele ignora até encontrar um *) e se abriu com { até encontrar um
Assim, {{{{comentário} está certo, enquanto que {{com}} está errado, pois o primeiro
} é suficiente para terminar o comentário, e o segundo será visto como erro.
Notou? um em cada linha. O comando writeln pode também ser usado para incluir uma
quebra de linha, assim:
PROGRAM escreve; BEGIN write('alô '); writeln; write('você'); END.
Gera:
alô você
E:
PROGRAM escreve; BEGIN writeln('alô '); writeln; write('você'); END.
Gera:
alô
você
Podemos também combinar os comandos:
PROGRAM escreve; BEGIN write('alô '); writeln('você'); write('aí!'); END.
E teremos:
alô você aí!
Uma consideração final: e se quisermos imprimir a aspa simples (')? Como vimos, ela é
parte integrante do write e writeln. Para imprimir uma aspa simples precisamos usar
duas aspas simples. Assim:
PROGRAM escreve; BEGIN write(''''); END.
Escreverá na tela:
Ou seja:
PROGRAM escreve; BEGIN write('copo d''água'); END.
Escreverá na tela:
copo d'água
Agora vamos inserir o código para desenhar um quadrado nesse nosso procedimento:
PROCEDURE dois_quad; BEGIN writeln('****'); writeln('* '); writeln(' *'); writeln('****'); END;
Ótimo, mas agora onde colocamos isso no programa?
PROGRAM quad;
PROCEDURE dois_quad; BEGIN writeln('****'); writeln('* '); writeln(' *'); writeln('****'); END;
BEGIN {comandos} END.
Simples não? Lembre que esse é o lugar da definição de procedimentos.
Mas esse nosso programa não faz nada! Como fazemos para desenhar os dois
quadrados? Bom, lembra o nosso segundo algoritmo? Desenho um quadrado, dou uma
linha em branco e desenho o outro. Ou seja:
PROGRAM quad;
PROCEDURE dois_quad; BEGIN writeln('****'); writeln('* '); writeln(' *'); writeln('****'); END;
BEGIN dois_quad; writeln; dois_quad; END.
E a saída será:
Você pode estar se perguntando: mas isso deu mais trabalho do que escrever os 2
quadrados. Sim, para dois deu, mas veja que para 3 não mais e, se o número de
quadrados a serem desenhados for grande, você pode poupar muito tempo de trabalho.
Essa é a vantagem do uso de procedimentos, você só precisa escrever códigos
repetitivos uma só vez.
Agora, como isso funciona? É, de fato, simples. Cada vez que o computador encontra o
nome de um procedimento ele faz um desvio para o início deste procedimento, executa
seu código (o que está entre seu BEGIN e END) e, ao terminar o procedimento, retorna
ao comando seguinte à chamada deste. A figura abaixo ilustra essa situação:
Por fim, note que declaramos o procedimento antes de usá-lo. Em Pascal temos que
fazer isso sempre.
IDENTIFICADORES
Um identificador é um nome que damos a algo no pascal, seja um procedimento, o
nome do programa etc.
Agora, vejamos um outro uso do write e writeln (os exemplos abaixo valem para os
dois):
Comando Saída
write(5+9,' é a soma'); write('5 + 9 = ',5+9); write('5 + 9 = ',5+9,' (total)');
14 é a soma 5 + 9 = 14 5 + 9 = 14 (total)
Note o espaço no início da frase "é a soma". Se ele não existir, a saída será "14é a
soma".
Podemos ter, também, operações múltiplas:
Comando Saída
write(5 + 6 + 7); write(5 + 6 - 7); write(3 + 4 * 5);
Ops. E agora? Qual o resultado de 3+4*5? Podemos escolher a operação que será
executada antes usando parênteses:
Comando Saída
write(3 + (4 * 5)); write((3 + 4) * 5);
Porém, nesse caso simples, onde queremos efetivamente 3 + (4 * 5), não precisamos de
parênteses. Como o computador sabe a ordem então? Em pascal, cada operador tem
uma precedência, indicando a ordem em que as operações podem ser executadas.
A ordem em que as operações serão executadas é:
DIV, MOD, *, / , +, -
Quando dois operadores de igual precedência ocorrem, são executados da esquerda para
a direita. Então:
3 + 4 * 5 equivale a 3 + (4 * 5)
6 - 7 + 8 equivale a (6 - 7) + 8
Mas sempre podemos mudar a precedência, usando parênteses. Por exemplo, fazendo 4
- 6 + 7 estaremos fazendo (4 - 6) + 7. Agora, se colocarmos os seguintes parênteses 4 -
( 6 + 7 ) e s t a r e m o s f o r ç a n d o a a d i ç ã o a s e r c a l c u l a d a a n t e s.
Nesse caso, o computador considera como sendo a subtração de dois termos, sendo um
deles uma expressão que deve ser calculada antes da subtração.
Isso nos mostra uma característica importante da linguagem: parênteses têm a maior
precedência dentre todos os operadores e, se houverem parênteses dentro de parênteses,
o mais interno tem precedência maior.
Então, de um modo geral:
? Calculamos o que está dentro dos parênteses (do mais interno ao mais externo):
? Calculamos as operações de maior precedência da esquerda para a direita:
? Por fim, calculamos os termos de menor precedência da esquerda para a direita.
Agora, veja a saída desse comando:
Comando Saída
writeln(2 + 3 / 2); 3.500000000000000e+
Naturalmente, essa não é a saída desejada. Gostaríamos que tivesse, por exemplo,
apenas 2 casas decimais apenas. Mas como fazer isso?
Comando Saída
writeln(2 + 3 / 2 : 2 : 2); 3.
O número após o primeiro ":" indica o tamanho mínimo reservado para a variável, já o
número após o segundo ":" indica o número de casas decimais (no caso de variável
REAL).
variável := expressão;
Onde "expressão" pode ser um número ou uma expressão matemática, por exemplo:
x := 3; O valor 3 é armazenado na variável x.
y := 4; O valor 4 é armazenado na variável y.
z := x + y;
O valor que está em x é somado ao
que está em y, sendo o resultado
armazenado na variável z.
Vale lembrar que quando guardamos um valor numa variável, o valor antigo que estiver
lá será perdido.
Agora não confunda! x := 2 não quer dizer "x é igual a 2", mas sim "o valor 2 será
guardado em x". Assim:
Comando Significado
x := y;
uma cópia do valor que está em y será guardada em
x. O valor que estava antes em x, se havia algum,
será perdido.
x := x; uma cópia do valor que está em x será guardada em
x de volta, perdendo o valor antigo.
Dessa forma podemos fazer coisas do tipo:
x := x + 1;
O que isso faz? O computador pega o valor de x, soma 1 a esse e guarda o resultado
novamente em x. Então, se x continha o valor 2, após a atribuição x := x + 1; ele conterá
Viram? Isso mostra por que não podemos ver x:=2 como "x é igual a 2", pois senão
x:=x+1 seria um erro matemático.
Agora que sabemos como abastecer valores em variáveis, como fazemos para escrever
seus valores na tela?
Comando O que faz
x := 2; Abasteço x com o valor 2.
write(x); Escreve o valor de x na tela, no caso, 2.
mas podemos enfeitar ainda mais, veja abaixo:
Comando Saída
write('x = ',x); x = 2
write('x = ',x,' (total)'); x = 2 (total)
reparou nos espaços entre o "=" e o "'" e entre o "'" e "(total)"? São necessários, senão a
saída seria x =2(total).
Agora vamos ver uma aplicação bem simples:
PROGRAM media; USES crt; {para entrada e saída} VAR p1 : REAL; {nota da prova 1} p2 : REAL; {nota da prova 2} p3 : REAL; {nota da prova 3} m : REAL; {média das provas}
BEGIN {dou as 3 notas} p1 := 3.0; p2 := 5.5; p3 := 6.5;
{calculo a média} m := (2p1 + 3p2 + 5*p3) / 10;
writeln('A média de ',p1:3:2,', ',p2:3:2,' e ',p3:3:2,' é ',m:3:2,'.'); END. saída:
A média de 3.00, 5.50 e 6.50 é 5.50.
Veja a seguinte seqüência de comandos e a saída:
Comandos Saída
x := 2; y := 3; write(x,y);
Viu como as duas variáveis foram escritas lado a lado? Tome cuidado com isso!
Por fim, uma outra boa dica é sempre inicializar as variáveis antes de usá-las, atribuindo
a elas um valor inicial.
Ou seja, "para cont valendo inicialmente 1 até 10 faça algo. Peraí, cont só recebeu 1.
Como seu valor pode chegar a 10? é que, a cada repetição, o comando for incrementa
cont, ou seja, soma 1 a cont. Assim, ele executa isso 10 vezes, pois após 10 vezes somar
1 a cont, esse chegará a ter 10 (se teve 1 como valor inicial).
Então, o for age assim:
1. atribui um valor inicial a cont
2. verifica se esse valor é menor ou igual ao limite 10
3. se for:
3.1. executa o corpo do for (o que está entre o begin e o end)
3.2. faz cont := cont + 1
4. se não for:
4.1. sai do for
5. volta a 2.
Agora repare que poderíamos por o writeln dentro do procediemtno um_quad. Façamos:
PROCEDURE um_quad; BEGIN writeln('****'); writeln('* '); writeln(' *'); writeln('****'); writeln END;
Mas, e nesse caso, como usaríamos o for? simples:
FOR cont:=1 TO 10 DO BEGIN um_quad END;
Somente assim? Não. Há um outro modo: como o corpo do FOR (o que está entre
BEGIN e END) contém um só comando, podemos fazer assim:
FOR cont:=1 TO 10 DO um_quad;
Economizamos duas linhas de escrita!
Atenção! Não confunda! Se dentro do for você quiser mais de um comando, deve
colocar esses comandos entre BEGIN e END. Por exemplo:
FOR cont:=1 TO 10 DO um_quad; writeln('quad');
O que isso faz? Não deixe a edentação te enganar, isso é o mesmo que:
FOR cont:=1 TO 10 DO um_quad; writeln('quad');
Ou seja, isso desenha 10 quadrados dando uma linha em branco após cada um e então
escreve 'quad'. Se quisermos escrever quad 10 vezes temos que fazer assim:
FOR cont:=1 TO 10 DO BEGIN um_quad; writeln('quad'); END;
Então, eis o programa completo:
PROGRAM quad; VAR cont : integer;
PROCEDURE um_quad; BEGIN writeln('****'); writeln('* '); writeln(' *'); writeln('****'); writeln; END;
BEGIN FOR cont:=1 TO 10 DO um_quad END
Poderíamos também por tudo isso no procedimento. Veja onde foi posta agora a
declaração da variável:
PROGRAM quad;
PROCEDURE dez_quad; VAR cont : integer; BEGIN FOR cont:=1 TO 10 DO BEGIN writeln('****'); writeln('* '); writeln(' *'); writeln('****'); writeln END END;
BEGIN dez_quad END.