O documento discute conceitos fundamentais sobre algoritmos e programação. Em 3 frases: Discutem-se os conceitos de algoritmo, programa, linguagem de programação e máquina. Também são apresentadas as principais estruturas de dados e comandos utilizados em algoritmos, como variáveis, constantes, atribuições, condicionais e laços de repetição. Por fim, é descrito o interpretador LIA, uma ferramenta para desenvolvimento e execução de algoritmos.

1. Rafael Martins – rafael84@gmail.com
Instituto Superior de Tecnologia em Ciência da Computação
Petrópolis, Outubro de 2007

3. O Algoritmo
 Organização das idéias em passos:
 Bem estruturados
 Concisos
 Coerentes com o resultado esperado
 Disciplina base para o estudo das linguagens de programação
 Possibilita avaliar os pormenores do programa a ser desenvolvido

4. O Algoritmo
 Construído e validado através de lápis e papel:
 Estimula o raciocínio, porém torna o aprendizado
mais difícil.
 Impossibilita a visualização dos resultados de
algoritmos complexos.
 Construído e executado no computador:
 Facilita e agiliza o aprendizado.

5. Algoritmos e Programas
 Programação: codificação de um algoritmo, segundo
uma linguagem de programação específica
 Formas de representar um algoritmo:
 Fluxogramas
 Linguagens naturais
 Pseudo-linguagens

6. Algoritmos e Programas
 Fluxograma:
 É um tipo de diagrama
 Representa um processo
 Permite visualizar os caminhos (fluxos) e as etapas de
processamento
 Mais intuitivo que uma descrição textual
 Linguagem natural:
 Linguagem convencional, escrita e/ou falada

7. Algoritmos e Programas
Pseudo-linguagem:
Linguagem textual
Pseudocódigo:
Uma das formas mais utilizadas atualmente
Instruções descritas de forma imperativa
Sintaxe semelhante à do Português

9. Conceitos
 Linguagem de máquina:
 Linguagem que os computadores podem compreender
 Linguagem de baixo nível:
 Utiliza números binários, hexadecimais, alguns símbolos e letras
 Próxima da linguagem de máquina
 Linguagens de alto nível:
 Utilizam notações matemáticas e grupos de palavras
 Próxima da linguagem natural

10. Conceitos
 Código fonte: programa escrito em linguagem de programação
 Código objeto: programa escrito em linguagem de máquina
 Tradutor: transforma o código fonte em código objeto
 Ligador (Linker): programa ou módulo que faz a ligação entre o
programa e as bibliotecas relacionadas

11. Conceitos
 Programação estruturada:
 Simples
 Amplamente utilizada
 Segmentação da solução em sub-rotinas

12. Linguagem de Máquina
 Totalmente expressa em forma binária (0s e 1s)
 É a única linguagem diretamente reconhecida pelo
computador
 Exige grande conhecimento dos dispositivos de
máquina

13. Linguagem de Máquina
 Extremamente trabalhosa
 Difícil aprendizado
 Pouco expressiva para a maioria das pessoas

14. Linguagens de Programação
 Criadas para tornar a programação mais acessível
 Utilizadas para a codificação de algoritmos
 Indispensáveis para o desenvolvimento de software comercial

15. Tradução e Execução de Programas
 Estratégias dos tradutores
 Compilação
 Interpretação
 Híbrida

16. A Solução LIA
 LIA – Linguagem Interpretada de Algoritmos:
 Ferramenta que objetiva facilitar o aprendizado do processo de
construção de algoritmos e programas de computador
 Aperfeiçoamento de programadores experientes
 O pacote LIA:
 Linguagem
 Interpretador
 Ambiente de Desenvolvimento Integrado (ADI)
 Manual
 Exemplos

17. Backus-Naur Form

18. Definições
 Modelo para a representação de gramáticas
 Proposto por John Backus e aprimorado por Peter Naur
 Baseia-se em regras de produção
 Utilizado para expressar gramáticas livres de contexto
 EBNF

19. Notações
Notação Representação Descrição
Produções ::= Separa o lado esquerdo do lado direito de uma produção
Terminais “terminal” Texto delimitado por aspas
Não-terminais <não-terminal> Texto delimitado pelos símbolos < e >
Operadores | Operador lógico “OU”
[...] Opcional
{...} Opcional com repetição (zero ou mais)
{...}+ Repetição (uma ou mais)
(...|...|...) Escolha múltipla

20. Exemplo de gramática em EBNF
<programa> ::= “begin” <comandos> “end”
<comandos> ::= <comando> {";" <comando>}
<comando> ::= <ident> "=" <expressão>
<ident> ::= <letra> {<letra> | <digito>}
<letra> ::= A | B | C | ... |Z
<digito> ::= 0 | 1 | 2 | ... | 9
<expressão> ::= <termo> [ (+|-) <expressão> ]
<termo> ::= <fator> [ (*|/) <termo> ]
<fator> ::= <identificador>
| "(" <expressão> ")"

21. Histórico, hierarquia, projeto e construção

22. Início
 Os primeiros compiladores:
 Datam em torno do ano 1950
 Consumiam muito tempo de desenvolvimento
 FORTRAN (FORmula TRANslator):
 Primeira linguagem de alto nível
 Desenvolvida entre 1954 e 1957

23. Hierarquia das Linguagens

24. Fases de um compilador
 Análise
 Análise Léxica
 Análise Sintática
 Análise Semântica
 Síntese
 Geração e Otimização de código
 Interpretação de código

25. Fases de um compilador

26. Fase de Análise

27. Definição
 Realizada a análise do código fonte:
 Caracteres  Lexemas
 Lexemas  Tokens
 Geralmente implementada como uma função ou classe:
 Código fonte só é lido uma vez

28. Exemplo
 Como exemplo, a análise léxica da instrução de atribuição:
Horas <- Minutos / 60;
 Agrupa os caracteres nos seguinte tokens:
 Identificador Horas
 Símbolo de atribuição
 Identificador Minutos
 Símbolo de divisão
 Número 60

29. Fase de Análise

30. Definição
 Agrupa tokens em frases gramaticais
 A frase gramatical é uma regra da sintaxe da
linguagem

31. Funções
 Assegurar que a sintaxe da linguagem é atendida
 Reunir os tokens em estruturas básicas para
geração de instruções

32. Fase de Análise

33. Conceitos
 A especificação da sintaxe:
 Apenas define os padrões de formação das instruções
 Não determina o significado coletivo de cada construção
 Exemplo: “Fulano comeu cinco litros de roupa.”

34. Definição
 Processo de validação das estruturas sintáticas no
contexto geral do programa fonte
 Regras semânticas não possuem um modelo
representação amplamente difundido

35. Funções
 Análise de escopo
 Múltiplas declarações de uma mesma variável
 Compatibilidade entre tipos
 Coerência entre declaração e uso de identificadores
 Correlação entre parâmetros formais e atuais

36. Técnicas utilizadas

37. Resumo
 Implementação sem o auxilio de ferramentas de apoio
 Programação Orientada a Objetos (POO)
 Etapas de compilação e interpretação estão em uma DLL
 Funções ativadas por uma interface gráfica

38. Diagrama – O Interpretador LIA

39. Regras em EBNF e algoritmos exemplo

40. Elementos Básicos
Núm. Regras
1 <id> ::= "_" | <letra> { "_" | <letra> | <digito> }
2 <letra> ::= "a" | "b" | ... | "z" | "A" | "B" | ... | "Z"
3 <digito> ::= "0" | "1" | ... | "9"
4 <num_int> ::= { <digito> }+
5 <num_real> ::= <num_int> "." <num_int>
6 <caracteres> ::= """ { <caractere ASCII> } """
7 <const> ::=
<num_int> | <num_real> | "verdadeiro" | "falso" |
<caracteres>
8 <tipo> ::= "inteiro" | "real" | "caractere" | "logico"

41. Expressões
Núm. Regras
9 <expressao> ::= <log_rel>
10 <log_rel> ::=
<soma_sub> [ ("="|">"|">="|"<"|"<="|"<>"|"e"|"ou")
<soma_sub>]
11 <soma_sub> ::= <mult_div> [ ("+"|"-") <mult_div> ]
12 <mult_div> ::= <unario> [ ("*"|"/"|"mod"|"div") <unario> ]
13 <unario> ::= [ ("nao"|"+"|"-") ] <parenteses>
14 <parenteses> ::=
"(" <log_rel> ")" | <id> [<elem_vet>|<params_atuais>] |
<const>
15 <elem_vet> ::= "[" <expressoes> "]"
16 <expressoes> ::= <expressao> ["," <expressao>]
17 <params_atuais> ::= "(" <expressoes> ")"

42. Declarações
Núm. Regra
18 <decs> ::=
[ { <vars_dec>
| <consts_dec>
| <func_dec>
| <proc_dec> } ]
Algoritmo decs;
Procedimento SubRotina;
Constantes
A = 1; B = 2; C = 3;
Constante
N = “XYZ”;
Procedimento Aninhado;
Variavel AA: real;
Inicio
AA <- A + B + C;
Fim;
Inicio { SubRotina}
Aninhado;
Fim;
Inicio { decs }
SubRotina;
Fim.

43. Declaração de Variáveis
Núm. Regras
19 <vars_dec> ::=
"variavel" <var_dec> ";"
| "variaveis" { <var_dec> }+ ";"
20 <var_dec> ::= <id> {"," <id>} ":" [<vet_def>] <tipo> ";"
21 <vet_def> ::= ( "matriz" | "vetor" ) "[" <faixas> "]" "de"
22 <faixas> ::= { <faixa> }+
23 <faixa> ::= <num_int> ":" <num_int>
algoritmo MultiDeclaracoes;
variaveis nota1,nota2,media: real; nome: caractere;
inicio
escreva("Digite o seu nome: ", nome); leia(nome);
escreva("Entre com Nota 1: "); leia(nota1);
escreva("Entre com Nota 2: "); leia(nota2);
media <- (nota1 + nota2) / 2;
escrevaln("Aluno: ", nome, " - Média: ", media);
fim.

44. Declaração de Constantes
Núm. Regras
24 <consts_dec> ::= "constante" <const_dec> ";” | "constantes" { <const_dec> }+ ";"
25 <const_dec> ::= <id> "=" <expressao> ";"
algoritmo MultiDeclaracoes2;
constantes APROVADO = 7.0; RECUPERACAO = 4.0;
variaveis nota1,nota2,media: real; nome: caractere;
inicio
escreva("Digite o seu nome: ", nome); leia(nome);
escreva("Entre com Nota 1: "); leia(nota1);
escreva("Entre com Nota 2: "); leia(nota2);
media <- (nota1 + nota2) / 2;
se media >= APROVADO entao
escrevaln("Aluno: ", nome, " aprovado.");
senao
se media >= RECUPERACAO então
escrevaln("Aluno: ", nome, " em recuperação.");
senao
escrevaln("Aluno: ", nome, " reprovado.");
fim_se;
fim_se;
fim.

45. Declaração de Funções
Núm. Regras
26 <func_dec> ::=
"funcao" [<param_formais>] ":" <tipo> ";"
<decs>
"inicio"
<cmds>
"fim" ";"
27 <param_formais> ::= "(" {<param_formal>}+ ")"
28 <param_formal> ::= ["ref"] <id> {"," <id>} ":" <tipo> ";"
algoritmo testeFunc;
funcao PI: real;
inicio
retorno <- 3.14159;
fim;
variavel C, r: real;
inicio
r <- 3;
C <- 2 * PI * r;
escrevaln(C);
fim.

46. Declaração de Procedimentos
Núm. Regras
29 <proc_dec> ::= "procedimento" <params_formais> ";"
<decs>
"inicio"
<cmds>
"fim" ";"
algoritmo testeProc;
procedimento Imprimir(nome,valor: caractere);
inicio
escrevaln(nome, “: ”, valor);
fim;
inicio
Imprimir(“LIA”, “Linguagem Interpretada de Algoritmos”);
fim.

47. Comandos
Núm. Regras
30 <cmds> ::= { <cmd> ";" }
31 <cmd> ::= <cmd_atrib>
| <cmd_se>
| <cmd_para>
| <cmd_enq>
| <cmd_rep>
| <cmd_esc>
| <cmd_escreva>
| <cmd_escrevaln>
| <cmd_leia>
| <sub_rot>

48. Comando de Atribuição
Núm. Regra
32 <cmd_atrib> ::= <id> [<elem_vet>] "<-" <expressao>
algoritmo Atribuicoes;
variaveis
i: inteiro;
r: real;
l: logico;
c: caractere;
inicio
r <- 3.14159;
r <- r * r;
escrevaLn(r);
l <- verdadeiro ou falso;
escrevaLn(l);
l <- 2 > 1;
escrevaLn(l);
c <- "Como é fácil fazer uma atribuição de valor!";
escrevaLn(c);
fim.

49. Comando Se
Núm. Regra
33 <cmd_se> ::= "se" <expressao> "entao"
<cmds>
["senao" <cmds>]
"fim_se"
algoritmo teste_condicional;
inicio
se 2 > 1 entao
escrevaln("Esta instrução será escrita na tela.");
escrevaln("E esta também.");
senão
escrevaln("Já esta será ignorada.");
fim_se;
fim.

50. Comando Para
Núm. Regras
34 <cmd_para> ::= "para" <id> "de" <expressao> "ate" <expressao> "faca"
<cmds>
"fim_para"
algoritmo instrucao_para_10;
variavel
i: inteiro;
inicio
para i de 1 ate 10 faca
escrevaln("Valor de i é: ", i);
fim_para;
fim.

51. Comando Enquanto
Núm. Regra
35 <cmd_enq> ::= "enquanto" <expressao> "faca"
<cmds>
"fim_enquanto"
algoritmo testeValor;
variavel
val: inteiro;
inicio
escreva("Digite 9 para sair: ");
leia(val);
enquanto val <> 9 faca
escreva("Digite 9 para sair: ");
leia(val);
fim_enquanto;
fim.

52. Comando Repita
Núm. Regra
36 <cmd_rep> ::= "repita"
<cmds>
"ate" <expressao>
algoritmo testeValor;
variavel
val: inteiro;
inicio
repita
escreva("Digite 9 para sair: ");
leia(val);
ate val = 9;
fim.

53. Comando EscolhaNúm. Regras
37 <cmd_esc> ::= "escolha" <expressao>
<casos>
["senao" <cmds>]
"fim_escolha"
38 <casos> ::= {<caso>}+
39 <caso> ::= "caso" <expressoes> ":" <cmds> "fim_caso" ";"
algoritmo Calculadora;
variaveis
op1,op2: inteiro;
operacao: caractere;
inicio
escreva("Operando 1: "); leia(op1);
escreva("Operando 2: "); leia(op2);
escreva("Operacao: "); leia(operacao);
escolha operacao
caso "+","somar": escreva(op1 + op2); fim_caso;
caso "-","subtrair": escreva(op1 - op2); fim_caso;
caso "*","multiplicar": escreva(op1 * op2); fim_caso;
caso "/","dividir": escreva(op1 / op2); fim_caso;
fim_escolha;
fim.

54. Comando Escreva / EscrevaLn
Núm. Regras
40 <cmd_escreva> ::= "escreva" [ "(" <expressões> ")" ]
41 <cmd_escrevaln> ::= "escrevaln" [ "(" <expressões> ")" ]
algoritmo Tabuada;
variaveis
t: inteiro;
i: inteiro;
v: vetor[1:10] de inteiro;
inicio
para t de 1 ate 10 faca
escrevaln ("-------------");
escrevaln ("Tabuada de ", t);
escrevaln ("-------------");
para i de 1 ate 10 faca
v[i] <- i * t;
escrevaln(t, " x ", i , " = ", v[i]);
fim_para;
escrevaln;
fim_para;
fim.

55. Comando Leia
Núm. Regra
42 <cmd_leia> ::= "leia" "(" <var> { "," <var> } ")"
43 <var> ::= <id> [<elem_vet>]
algoritmo teste_leia;
variaveis
n1,n2: inteiro;
soma: inteiro;
inicio
escrevaln("Calculo de Soma");
escrevaln;
escreva("Entre com o primeiro número: ");
leia(n1);
escreva("Entre com o segundo número: ");
leia(n2);
soma <- n1 + n2;
escreva("Resultado: ", soma);
fim.

56. Chamadas à sub-rotinas
Núm. Regra
17 <params_atuais> ::= "(“ <expressoes> ")"
44 <sub_rot> ::= <id> [<param_atuais>]
Algoritmo rotinas;
Procedimento A;
Inicio
Fim;
Procedimento B(i: inteiro);
Inicio
Fim;
Inicio
A;
B(1);
Fim.

57. Algoritmo
Núm. Regras
45 <algoritmo> ::= "algoritmo" <id> ";"
<decs>
"inicio"
<cmds>
"fim" "."

58. Para a Linguagem LIA

59. Definições
 Tipos especiais de variáveis
 Capacidade para armazenar mais um valor ao mesmo tempo
 Para a linguagem LIA, vetor é sinônimo de matriz
 Multidimensionais
 Possuem um tipo e um nome pré-definidos

60. Acesso aos elementos
 Através do índice do elemento entre COLCHETES, logo após
o nome do vetor:
Nome do vetor [ índice do elemento ]
 No modelo acima, índice do elemento é qualquer expressão
cujo valor seja um número inteiro.

61. Exemplos
notas[1] <- 6.5;
notas[2] <- 7.5;
media <- notas[1] + notas[2];
dias[1+2] <- "Terça-feira";
alunos[1] <- "Ana";
alunos[2] <- "Beto";
reprovados[1] <- 2;
escrevaLn("Aluno reprovado: ", alunos[ reprovados[1] ]);

62. Declaração
VARIAVEL nome: VETOR [ dimensão1, dimensão2, ... , dimensãoN ] : TIPO;
VARIAVEIS nomes: VETOR [ dimensão1, dimensão2, ... , dimensãoN ] : TIPO;
VARIAVEL nome: MATRIZ [ dimensão1, dimensão2,... , dimensãoN ] : TIPO ;
VARIAVEIS nomes: MATRIZ [ dimensão1, dimensão2,... , dimensãoN ] : TIPO;
 Dimensões
 Limite Inferior : Limite Superior

63. Exemplo
algoritmo Media;
variaveis
notas: vetor[1:3] de real;
soma, media: real;
inicio
notas[1] <- 5.5;
notas[2] <- 6.0;
notas[3] <- 8.0;
soma <- notas[1] + notas[2] + notas[3];
media <- soma / 3;
escreva(media);
fim.

64. Ambiente de Desenvolvimento Integrado

65. Apresentação
 Interface gráfica para facilitar a manipulação de algoritmos
na linguagem LIA
 Principais funcionalidades
 Editor de textos com suporte à coloração do código fonte;
 Execução passo a passo (instrução a instrução) de algoritmos;
 Inspeção de símbolos do algoritmo em estrutura de árvore;

66. Funcionalidades
 Exportação de entradas e saídas de dados para arquivo
 Controle de ativação de sub-rotinas representada em
estrutura de pilha numerada
 Especificação de pontos de parada em instruções

67. Funcionalidades
 Possibilidade de manter vários arquivos abertos
simultaneamente
 Histórico dos últimos arquivos abertos
 Manual integrado da linguagem LIA

68. Tela Principal

69. Manipulando algoritmos LIA
 Manipulando diversos arquivos simultaneamente

70. Módulo de Entrada e Saída
 Meio pelo qual as rotinas de entrada e saída de dados coletam e
exibem dados ao usuário.
 Assemelha-se a uma janela de comandos tipo DOS,
normalmente chamada de console.
 Registra histórico de leituras e escritas realizadas pelo algoritmo
 Na leitura de valor o nome da variável é exibido na barra
horizontal azul

71. Módulo de Entrada e Saída

72. Módulo Inspetor de Símbolos
 Instrumento de depuração
 Permite visualizar automaticamente o conteúdo de cada variável
modificada ao longo do processo de execução do algoritmo
 Monitora
 Variáveis simples
 Vetores/matrizes
 Constantes
 Dados organizados em estrutura de árvore, por escopo

73. Módulo Inspetor de Símbolos

74. Módulo Pilha de Ativação
 Registra as ativações de sub-rotinas em uma lista numerada
e organizada em forma de pilha
 Exibe o nome e os valores dos parâmetros

75. Módulo Pilha de Ativação

76. Utilizando o ADI para a linguagem LIA

77. Funcionalidades do Depurador
 Execução passo a passo
 Pausar e abortar a execução
 Acompanhar todo o processo de execução, instrução a instrução
 Visualizar o conteúdo das variáveis
 Observar a pilha de ativação das sub-rotinas
 Inspecionar a entrada e a saída de dados

78. Tratamento de Erros
 Apresenta mensagens que auxiliam a correção
 Sempre que possível, o cursor do teclado é movido
para a coluna e a linha onde está o erro

79. Modos de Execução
Funcionalidade ou Característica Padrão Rápido
Abortar execução Sim Sim
Execução passo a passo Sim Não
Inspeção de símbolos Sim Não
Pilha de ativação Sim Não
Eficiência – Velocidade de execução Não Sim
Baixa utilização de memória e processador Não Sim
Possibilidade de salvar o histórico de E/S Sim Sim
Pontos de parada Sim Não

81. Conclusão
 O propósito do autor/desenvolvedor é disseminar a
solução LIA que foi construída:
 Linguagem
 Interpretador
 Ambiente de Desenvolvimento Integrado
 Sempre que possível, funcionalidades e eventuais
correções serão incluídas em novas versões