ACFrOgCCS86qIRP13FQU4F3TVXus69lZt3Ki0A9i-IxK-Ue9MS7Hv3ysx9-Z-h8OzRIj3VRKNu75vs1AfTFU4SU07fyNBAjrR5dFSnIUHNglaauZ2pVjsIOlY9r_8MjbIiSDxn-lZlHyd4L1hGyt

Prévia do material em texto

Sumário
Capítulo 1. Introdução a Lógica de Programação...................................................................9
1.1. Noções de Lógica.........................................................................................................9
1.2. O que é lógica.............................................................................................................9
1.3. A real lógica do dia a dia.............................................................................................9
1.4. Lógica de programação.............................................................................................10
1.5. O que é um algoritmo...............................................................................................11
1.6. Porque é importante construir um algoritmo............................................................11
1.7. As maneiras de representarmos um algoritmo. ........................................................12
1.7.1. Descrição Narrativa.   ........................................................................................12
1.7.2. Fluxograma Convencional.................................................................................12
1.7.3. Português Estruturado ou Pseudocódigo............................................................14
1.8. EXERCÍCIOS PROPOSTOS  ......................................................................................15
Capítulo 2. Tópicos Preliminares..........................................................................................16
2.1. Tipos primitivos.........................................................................................................16
2.1.1.   Tipos de Primitivos de Dados...........................................................................16
2.2. Constantes.................................................................................................................16
2.3. Variável......................................................................................................................17
2.4. Formação de identificadores.....................................................................................17
2.5. Declaração de variáveis.............................................................................................17
2.6. Comandos de entrada e saída...................................................................................18
2.6.1. COMANDO DE ENTRADAS DE DADOS.............................................................18
2.6.2. COMANDO DE SAIDAS DE DADOS...................................................................19
2.7. Expressões aritméticas..............................................................................................20
2.8. Operadores aritméticos.............................................................................................21
2.9. Expressões lógicas.....................................................................................................22
2.10. Operadores relacionais............................................................................................22
2.11. Operadores lógicos..................................................................................................23
2.12. Comando de atribuição...........................................................................................24
2.12.1. PRIORIDADE DE OPERADORES:.....................................................................24
2.13. EXERCÍCIOS PROPOSTOS  ....................................................................................25
Capítulo 3. Estruturas de Controle.......................................................................................26
3.1. Estrutura sequencial..................................................................................................26
3.2. Estrutura de seleção..................................................................................................27
3.2.1. Seleção Simples.................................................................................................27
3.2.2. Seleção Composta..............................................................................................29
3.2.3. Seleção encadeada.............................................................................................30
3.3. Seleção de múltipla escolha......................................................................................32
3.4. Estruturas de repetição.............................................................................................33
3.5. Repetição com teste no início e no final....................................................................34
3.5.1. TESTE INÍCIO....................................................................................................34
3.5.2. TESTE FINAL.....................................................................................................35
3.6. Repetição com variável de controle...........................................................................37
3.7. Comparação entre estruturas de repetição.   ............................................................39
3.8. EXERCÍCIOS PROPOSTOS  ......................................................................................41
Capítulo 4. Estruturas de Dados...........................................................................................42
4.1. O que é estruturas de dados......................................................................................42
4.2. Variáveis compostas homogêneas..............................................................................42
4.3. Variáveis compostas unidimensionais........................................................................43
4.4. Declaração e manipulação(unidimensional).............................................................44
4.4.1. Leitura de Dados de Uma Matriz do Tipo Vetor.................................................44
4.5. Variáveis compostas multidimensionais....................................................................45
4.6. Declaração e manipulação(multidimensionais ).......................................................46
4.7. Variáveis compostas heterogêneas............................................................................46
4.8. Registros (declaração e manipulação).......................................................................47
4.9. Registros de conjuntos (declaração e manipulação).   .............................................48
4.10. EXERCÍCIOS PROPOSTOS  ....................................................................................49
4.11. Referencias:.............................................................................................................50
Capítulo 5. Introdução a PHP...............................................................................................53
5.1. O que é PHP..............................................................................................................53
5.1.1. Um pouco da História do PHP............................................................................54
5.2. Instalação do Servidor PHP.......................................................................................54
5.2.1. Instalação Apache..............................................................................................55
5.2.2. Instalação Php5..................................................................................................56
5.2.3. Instalação MYSQL..............................................................................................57
5.2.4. Instalação phpMyAdmin....................................................................................57
5.3. Características de um programa PHP.........................................................................58
5.3.1. COMANDOS DE SAÍDA(OUTPUT).....................................................................59
5.4. EXERCÍCIOS PROPOSTOS  ......................................................................................60Capítulo 6. Atribuições em PHP............................................................................................61
6.1. Variáveis....................................................................................................................61
6.2. Tipos de Variáveis......................................................................................................63
6.2.1. Tipo booleano....................................................................................................63
6.2.2. Tipo inteiro........................................................................................................63
6.2.3. Tipo ponto flutuante:.........................................................................................64
6.2.4. Tipo numérico....................................................................................................64
6.2.5. Tipo String.........................................................................................................64
6.2.6. Tipo array..........................................................................................................65
6.2.7. Tipo objeto.........................................................................................................65
6.2.8. Tipo recurso.......................................................................................................65
6.2.9. Tipo null.............................................................................................................65
6.3. Constantes.................................................................................................................65
6.3.1. Constantes pré­definidas....................................................................................65
6.3.2. Definindo constantes.........................................................................................65
6.4. Conversão de variável...............................................................................................66
6.5. EXERCÍCIOS PROPOSTOS  ......................................................................................67
Capítulo 7. Operadores.........................................................................................................68
7.1. Operadores de strings...............................................................................................68
7.2. Operadores de atribuição..........................................................................................68
7.3. Operadores de decremento e incremento.................................................................70
7.4. Operadores aritméticos.............................................................................................71
7.5. Operadores relacionais .............................................................................................71
7.6. Operadores lógicos ou booleanos..............................................................................72
7.7. Precedência de Operadores.......................................................................................73
7.8. EXERCÍCIOS PROPOSTOS  ......................................................................................76
Capítulo 8. Estruturas de Controle e Repetição....................................................................77
8.1. Blocos de controle.....................................................................................................77
8.2. IF e ELSE...................................................................................................................77
8.3. Atribuição condicional (ternário)..............................................................................79
8.4. SWITCH....................................................................................................................79
8.4.1. SWITCH com BREAK.........................................................................................80
8.5. WHILE.......................................................................................................................81
8.6. DO...WHILE...............................................................................................................82
8.7. FOR...........................................................................................................................83
8.8. FOREACH..................................................................................................................84
8.9. BREAK.......................................................................................................................85
8.10. CONTINUE..............................................................................................................86
8.11. EXERCÍCIOS PROPOSTOS  ....................................................................................88
Capítulo 9. Manipulação de Arrays......................................................................................88
9.1. Criando um Array......................................................................................................88
9.2. Arrays Associativos....................................................................................................89
9.3. Interações..................................................................................................................90
9.4. Acessando um Array..................................................................................................91
9.5. Alterando um Array...................................................................................................91
9.6. Arrays multidimensionais..........................................................................................92
9.7. Funções com Arrays..................................................................................................94
9.8. EXERCÍCIOS PROPOSTOS  ......................................................................................98
Capítulo 10. Manipulações de Funções................................................................................99
10.1. Declarando uma Função.........................................................................................99
10.2. Escopo de Variáveis em Funções...........................................................................100
10.3. Passagem de Parâmetro.........................................................................................101
10.4. Valor de Retorno....................................................................................................102
10.5. Recursão................................................................................................................102
10.6. EXERCÍCIOS PROPOSTOS  ..................................................................................103
Capítulo 11. Manipulação de arquivos e diretórios............................................................104
11.1. Criando e Abrindo um Arquivo.............................................................................104
11.2. Gravando em um arquivo......................................................................................105
11.3. Fechando um arquivo............................................................................................106
11.4. Lendo um arquivo.................................................................................................106
11.5. Copiando,Renomeando e Apagando um Arquivo..................................................107
11.6. Manipulando Diretório..........................................................................................108
11.7. EXERCÍCIOS PROPOSTOS  ..................................................................................109
Capítulo 12. Interações PHP com HTML............................................................................110
12.1. Formulários ..........................................................................................................110
Elementos de um formulário......................................................................................11012.2. Exemplo de formulário..........................................................................................112
12.3. Método Post e Get.................................................................................................114
12.3.1. Método Get....................................................................................................114
Recebendo dados via método GET.............................................................................115
12.3.2. Método Post...................................................................................................116
12.4. Interações com o Browser.....................................................................................117
12.5. Cookies..................................................................................................................118
Acessando um cookie:................................................................................................120
12.6. Sessão....................................................................................................................120
12.7. Requisição de Arquivos.........................................................................................122
12.8. Tratamentos de erro..............................................................................................123
12.9. EXERCÍCIOS PROPOSTOS  ..................................................................................124
Capítulo 13. Introdução ao MySQL....................................................................................125
13.1. O que é o MYSQL?................................................................................................125
13.2. Trabalhando com MYSQL......................................................................................125
13.2.1. Estruturas de Dados.......................................................................................126
13.2.2. Criando Banco e Tabelas................................................................................127
13.2.3. Manipulando dados das tabelas.....................................................................128
13.3. Trabalhando com PhpMyAdmin............................................................................130
13.3.1. Manipulando banco de dados no PhpMyadmin.............................................131
13.4. EXERCÍCIOS PROPOSTOS  ..................................................................................134
Capítulo 14. PHP com Banco de dados MYSQL..................................................................135
14.1. Criando e Selecionando a Conexão.......................................................................135
14.2. Manipulando Dados do Database..........................................................................136
mysql_query...............................................................................................................136
mysql_result...............................................................................................................136
mysql_fetch_array......................................................................................................137
14.3. Criação de CRUD...................................................................................................138
14.4. EXERCÍCIOS PROPOSTOS  ..................................................................................141
Capítulo 15. História do Joomla.........................................................................................144
15.1. Introdução.............................................................................................................144
15.2. Vantagens de utilizar o Joomla!............................................................................144
15.3. O Joomla tem como principais características:.....................................................145
15.4. Ferramentas CMS – Sistema de Gerenciamento de Conteúdo...............................145
Capítulo 16. Instalação do Joomla.....................................................................................146
16.1. Iniciando os Servidores.........................................................................................147
16.1.1. Passos para instalação do Joomla..................................................................147
16.1.2. Copiando o Joomla para a Pasta HTDOCS.....................................................147
Capítulo 17. Vamos a Instalação.........................................................................................148
17.1. 1º Passo ­ Idiomas.................................................................................................148
17.2. 2º Passo – Pré­Instalação.......................................................................................149
17.3. 3º Passo ­ Licença..................................................................................................149
17.4. 4º Passo – Banco de Dados....................................................................................150
17.5. 5º Passo – Configuração do FTP............................................................................151
17.6. 6º Passo ­ Configuração.........................................................................................151
17.7. 7º Passo ­ Fim........................................................................................................152
Capítulo 18. Frontend e Backend.......................................................................................153
18.1. Frontend – Área de Usuários.................................................................................153
18.2. Backend – Área de Administradores.....................................................................154
18.2.1. Login de Acesso.............................................................................................154
18.2.2. Nível de usuário – Papel ................................................................................155
18.2.3. Papéis no Site principal (Frontend)...............................................................155
18.2.4. Papeis na Área de administração (BackEnd).................................................155
Capítulo 19. Conhecendo a Área de Administração...........................................................155
19.1. Acessos..................................................................................................................155
19.2. Registrando os usuários........................................................................................156
19.3. Categorias de Usuários Registrados......................................................................156
19.4. Usuários Responsáveis pelo Conteúdo..................................................................156
19.4.1. Usuário Registrado.........................................................................................156
19.4.2. Autor..............................................................................................................156
19.4.3. Editor.............................................................................................................156
19.4.4. Publicador (publisher)...................................................................................156
19.5. Usuários de Administração....................................................................................157
19.5.1. Super Administrador......................................................................................157
19.5.2. Administrador................................................................................................157
19.5.3. Gerenciador (Manager).................................................................................157
Capítulo 20. Gerenciando as Categorias e Seções..............................................................157
20.1. Como criar uma Seção..........................................................................................15820.2. Como criar uma categoria.....................................................................................159
Capítulo 21. Inserindo um Novo Texto...............................................................................159
21.1. Para inserir um texto, siga os seguintes passos:....................................................159
Capítulo 22. Como criar um link no menu para um item de conteúdo..............................160
22.1. Criando um link para o item de conteúdo.............................................................160
22.2. Administração dos menus.....................................................................................162
22.2.1. Tela de configuração de menus......................................................................162
22.3. Especificação de Alguns Itens de Menu.................................................................163
22.3.1. Conteúdo.......................................................................................................163
22.3.2. Miscellaneous................................................................................................163
22.3.3. Componentes    .............................................................................................163
22.3.4. Links   ...........................................................................................................163
Capítulo 23. Administração de Mídia.................................................................................163
23.1. Observando a imagem acima, teremos os seguintes tópicos:................................164
23.1.1. Primeiro tópico..............................................................................................164
23.1.2. Segundo tópico..............................................................................................164
23.1.3. Terceiro tópico...............................................................................................164
23.1.4. Quarto tópico.................................................................................................164
23.1.5. Quinto tópico.................................................................................................164
23.1.6. Sexto tópico...................................................................................................164
Capítulo 24. Conhecendo alguns componentes..................................................................164
24.1. Componente Weblinks...........................................................................................164
24.2. Componente Contatos...........................................................................................165
24.3. Componente Banner..............................................................................................167
Capítulo 25. Módulos e Componentes................................................................................168
25.1. Criando um módulo utilizando o próprio Joomla.................................................169
25.1.1. Veja os pontos necessários para criação de um módulo:................................169
25.2. Instalação de Módulos..........................................................................................170
25.2.1. Passos para instalar um novo módulo:...........................................................170
25.3. Componentes........................................................................................................170
Capítulo 26. Estrutura........................................................................................................171
26.1. Designer................................................................................................................171
26.2. Programação.........................................................................................................171
26.3. Conteúdo MySQL..................................................................................................171
26.4. Posições de Módulos.............................................................................................172
26.4.1. Vejamos exemplo no Código PHP:.................................................................172
26.4.2. Vejamos agora o exemplo no Painel de Administração (BackEnd)................172
26.5. Estendendo a Estrutura do Template (Tema)........................................................172
26.5.1. Você pode usar os seguintes atributos para os módulos:...............................172
Caro Aluno(a), 
Este Material foi criado com o objetivo de ser utilizado na aprendizagem da lógica voltada 
para programação,  onde será  utilizado a programação estruturada em português,   também 
chamada de português estruturado ou Portugol.  Para auxílio na aprendizagem usaremos a 
ferramenta (programa) chamada Visualg. 
Será   dividido   o   conteúdo   em   quatro   capítulos,   desde   princípios   básicos   até   algo   mais 
avançado dentro de um contexto lógico, e que traz ao aluno uma base inicial para futuras 
programações em outras linguagens. As diagramações desse material foram feitas com o uso 
da ferramenta Dia, porém não entraremos em detalhes sobre ela. 
Vale ressaltar que o conteúdo aqui visto, devido a limitação da ferramenta Visualg, não tem 
aparo completo de seu uso dentro da ferramenta, mas será tratado de forma coerente todos os 
conceitos que serão abordados. 
Esperamos que esse material seja um contribuinte para todos aqueles que querem aprender 
de forma dedicada e que principalmente tenha um significado importante para inicialização da 
formação dos que querem seguir a carreira de programador.
Logica de Programação 9
Capítulo 1.  Introdução a Lógica de Programação
Objetivos
  Apresentar os conceitos elementares de lógica e sua aplicação no cotidiano; Definir o que é um 
algoritmo; Estabelecer uma relação entre a lógica e o algoritmo; Mostrar exemplos de como utilizar a  
lógica em situações do dia a dia, apresentando de forma simples e coerente. 
1.1.  Noções de Lógica
Lógica é algo muito comum na nossa vida, a prova disso é o que fazemos durante o dia, pois 
mesmo sem perceber usamos a lógica todo momento, por exemplo:
    Ao acordamos:
      • Tomamos um banho.
      • Escovamos os dentes.
      • Tomamos o café da manhã.
    Para irmos ao trabalho:
      • Colocamos uma roupa apropriada.
      • Pegamos um ônibus. 
      • Chegamos no trabalho.
Perceba que podemos detalhar mais coisas a respeito do exemplo anterior, nessa sequência foi 
definida alguns fatos comuns.
Quando queremos chegar a um objetivo final, temos que traçar uma lógica coerente que tenha 
sentido, onde em uma sequência lógica temos definido todos os passos que devemos seguir até o 
final.
1.2.  O que é lógica.
Lógica   vem  do   grego   clássico   logos(λογική),   que   significa 
palavra, pensamento, ideia, argumento, relato, razão lógica ou 
princípio   lógico.  É   uma   parte   da   filosofia   que   estuda   o 
fundamento,   a   estrutura   e   as   expressões   humanas   do 
conhecimento. A lógica foi criada por Aristóteles no século IV a.C. 
Para estudar o pensamento humano e distinguir interferências e 
argumentos certos e errados.
Já que o pensamento é a manifestação do conhecimento, e que 
o conhecimento busca a verdade, é preciso estabelecer algumas 
regras para que essa meta possa ser atingida.
1.3.  A real lógica do dia a dia.
Sempre   que   estamos  pensando  em algo,   a   lógica  nos   acompanha.  Usamos   a   lógica  quando 
falamos ou quando escrevemos para por em ordem o nosso pensamento que está sendo expressado.
A automação é o processo em que uma tarefa deixa de ser desempenhada pelo homem e passa a 
ser   realizada   por   máquinas,   sejam   estes   dispositivos   mecânicos,   eletrônicos   (como   os 
computadores) ou de natureza mista.  Para que a automação de uma tarefa seja bem sucedida é 
Projeto E­jovem ­ Módulo II
Ao acordar, tenho
 um algoritmo para 
Fazer o café?
Logica de Programação 10
necessárioque  a  máquina  que   irá   realizá­la   seja   capaz  de  desempenhar  cada  uma das  etapas 
constituintes do processo a ser automatizado com eficiência, de modo a garantir a repetição do 
mesmo. Assim, é necessário que seja especificado com clareza e exatidão o que deve ser realizado 
em cada uma das fases do processo a ser automatizado, bem como a sequência em que estas fases 
devem ser realizadas.
A essa especificação da sequência ordenada de passos que deve ser seguida para a realização de 
uma tarefa, garantindo a sua repetibilidade, dá­se o nome de algoritmo.
Ao   contrário   do   que   se   pode   pensar,   o   conceito   de 
algoritmo não foi criado para satisfazer as necessidades da 
computação. Pelo contrário,a programação de computadores 
é  apenas um dos campos de aplicação dos algoritmos.  Na 
verdade, há   inúmeros casos que podem exemplificar o uso 
(involuntário ou não) de algoritmos para a padronização do 
exercício de tarefas rotineiras. No entanto, daqui por diante 
a   nossa   atenção   se   volta   para   automação   de   tarefas 
utilizando computadores e para isto definiremos o que lógica 
de   programação.   Os   algoritmos   são     descritos   em   uma 
linguagem chamada pseudocódigo.
Este nome é uma alusão à posterior implementação em uma linguagem de programação,ou seja, 
quando formos programar em uma linguagem, por exemplo Visual Basic,C,C++,java,etc, estaremos 
gerando nossos código usando a ferramenta VisuAlg. 
Exemplo: 
   Preciso pagar um conta de luz.
O valor da conta e de R$ 45,25 reais.
Portanto preciso de R$ 45,25 reais para pagar a conta. 
Pagarei a conta as 3:00h da tarde.
Voltei para casa.
1.4.  Lógica de programação.
A lógica de programação é necessária para pessoas que desejam trabalhar com desenvolvimento 
de sistemas e programas, assim, ela permite definir a sequência lógica para a criação de aplicativos. 
Significa o uso correto das leis do pensamento, da “ordem da razão”, do processo de raciocínio e 
simbolização formais na programação de computadores. Com isso cria­se técnicas que cooperam 
para  a  produção de  soluções   logicamente  válidas  e   coerentes,  que  resolvam com qualidade os 
problemas que se deseja programar. 
Então o que é lógica? 
Lógica de programação é a técnica de encadear pensamentos para atingir determinado objetivo. 
Usar o raciocínio é algo abstrato, intangível. Os seres humanos tem a capacidade de expressá­lo 
através de palavras ou escrita, que por sua vez se baseia em um determinado idioma, que segue 
uma série de padrões(gramática). Um mesmo raciocínio pode ser expresso em qualquer um dos 
inúmeros, mas continuará representando o mesmo raciocínio, usando apenas outra convenção.
Em   programação   temos   várias   linguagens   como,   java,   C,   php, 
Python, delphi dentre muitas outras que existem, porem cada uma 
delas tem um padrão próprio. Essas por sua vez, são muito atreladas 
a uma grade diversidade de detalhes computacionais,  mas com o 
mesmo raciocínio, seguindo as regras da linguagem, pode ser obtido 
o mesmo resultado.  
Projeto E­jovem ­ Módulo II
Logica de Programação 11
1.5.  O que é um algoritmo
Um algoritmo é   formalmente uma sequência   finita  de passos  que  levam a execução de uma 
tarefa. Podemos pensar em algoritmo como uma receita, uma sequência de instruções que busca 
uma meta específica. Estas tarefas não podem ser redundantes nem subjetivas na sua definição, 
logo, devem ser claras e precisas.
Os   algoritmos   servem   como   modelo   para   programas,   pois   sua   linguagem  é   intermediária   a 
linguagem humana e as linguagens de programação, sendo então, uma boa ferramenta na validação 
da lógica de tarefas a serem automatizadas. Os algoritmos, servem para representar a solução de 
qualquer problema, mas no caso do processamento de dados, eles devem seguir as regras básicas de 
programação para que sejam compatíveis com as linguagens de programação.
Por esse motivo os algoritmos são independentes das linguagens. Ao contrário de uma linguagem 
de   programação,   não   existe   um   formalismo   rígido   de   como   deve   ser   escrito   o   algoritmo.   O 
algoritmo deve ser fácil de se interpretar e fácil de codificar, ou seja, ele deve ser o intermediário 
entre a linguagem falada e a linguagem de programação a qual for definir.
Como   exemplos   de   algoritmos   podemos   citar   os   algoritmos   das   operações   básicas   (adição, 
multiplicação, divisão e subtração) de números reais decimais. Outros exemplos seriam os manuais 
de aparelhos eletrônicos, como um DVD player, aparelhos celulares, televisores, que explicam passo 
a passo como operar, programar, gravar um evento,listar suas fotos,etc.
Até mesmo as coisas mais simples, podem ser descritas por sequências lógicas. Por exemplo: 
         “Trocar uma lâmpada”. 
         •  Pegar uma escada 
         •  Colocar a escada no local certo.
         •  Pegar a lâmpada nova
         •  Subir na escada.
         •  Retirar a lâmpada velha.
         •  Colocar a lâmpada nova.
         •  Descer da escada.
         •  Guardar a escada.
         •  Colocar a lâmpada velha no lixo.
         •  Ligar o interruptor para testar.
  
         “Somar dois números quaisquer”. 
         •  Escreva o primeiro número no retângulo A 
         •  Escreva o segundo número no retângulo B 
         •  Some o número do retângulo A com número do retângulo B e coloque o resultado no 
            retângulo C 
1.6.  Porque é importante construir um algoritmo.
Saber   construir   algoritmos   é   fundamental   na   formação   de   profissionais   de   informática   ou 
computação e como tal, proporcionar condições para essa aprendizagem é um constante desafio aos 
professores e profissionais da área.
Um algorítimo tem um papel importante, pois ele determina de que formas podemos resolver um 
determinado  problema,  um programa de  computador  por  exemplo,   é   desenvolvido   com muita 
lógica e principalmente um conjunto de algorítimos.
Outra importância da construção dos algoritmos é que um vez concebida uma solução algorítmica 
para   um   problema,   esta   pode   ser   traduzida   para   qualquer   linguagem   de   programação   e   ser 
agregada  das   funcionalidades  disponíveis  nos  diversos   ambientes;   costumamos  denominar  esse 
processo de codificação.
Projeto E­jovem ­ Módulo II
Logica de Programação 12
1.7.  As maneiras de representarmos um algoritmo. 
Existem diversas formas de representação de algoritmos, mas não há um consenso com relação a 
melhor   delas   para   ser   aplicada   na   resolução   do   problema   proposto.   Algumas   formas   de 
representação de algoritmos tratam os problemas apenas em nível lógico, abstraindo­se de detalhes 
de implementação muitas vezes relacionados com alguma linguagem de programação específica.
 Por outro lado existem formas de representação de algoritmos que possuem uma maior riqueza 
de detalhes e muitas vezes acabam por obscurecer as ideias principais do algoritmo, dificultando 
seu entendimento. Sendo assim temos as seguintes formas:
• Descrição Narrativa;
• Fluxograma Convencional;
• Pseudocódigo,também conhecido como Português Estruturado ou Portugol. 
1.7.1.  Descrição Narrativa.   
Nesta   forma   de   representação   os   algoritmos   são   expressos   diretamente   em   linguagem 
natural. Como exemplo, observe os algoritmos seguintes:
Esta representação é pouco usada na prática porque o uso da linguagem natural muitas vezes da 
oportunidade a mas interpretações,ambiguidades e imprecisões.
Por exemplo, a instrução afrouxar ligeiramente as “porcas” no algoritmo da troca de pneus esta 
sujeita a interpretações diferentes por pessoas distintas. Uma instrução mais precisa seria: “afrouxar 
a porca, girando­a 30 grau no sentido anti­horário”.
Por   mais   simples   que   seja   um   algoritmo  narrativo,   pode  haver   uma   grande  quantidade   de 
detalhes, que por sua vez segue um conjunto de regras dentro da sequencia a qual pertencem.1.7.2. Fluxograma Convencional.
É uma representação gráfica de algoritmos onde formas geométricas diferentes implicam ações 
(instruções,comandos) distintos.  Tal propriedade facilita o entendimento das ideias contidas nos 
algoritmos e justifica sua popularidade.
Esta forma é aproximadamente intermediária a descrição narrativa e ao pseudocódigo (subitem 
seguinte), pois é menos imprecisa que a primeira e, no entanto, não se preocupa com detalhes de 
implementação   do   programa,   como   o   tipo   das   variáveis   usadas.   Nota­se   que   os   fluxogramas 
convencionais  preocupam­se   com detalhes  de  nível   físico  da   implementação  do  algoritmo.  Por 
exemplo, figuras geométricas diferentes são adotadas para representar operações de saída de dados 
realizadas em dispositivos distintos.
Existem diversas ferramentas para criação de fluxograma como Jude, Microsoft Visio, Dia(usado 
no linux), dentre outras, cada uma delas tem uma vantagem em particular.  
Projeto E­jovem ­ Módulo II
Logica de Programação 13
Trabalharemos com o editor de diagrama chamado  Dia, onde podemos facilmente instalar no 
Linux e sua licença é de livre acesso. 
Dica: Pesquise o uso dessas ferramentas por meios da internet, amigos ou professores.
Observe   as   principais   formas   geométrica   usadas   para   representação   de   Fluxogramas   de 
algoritmos:
Início ou fim do fluxograma            Operação de entrada de  dados
              
                             Operação de atribuição                       Decisão 
                           Operação de saída de dados
Um fluxograma se resume a um único símbolo inicial por onde a execução do algoritmo começa, 
e um ou mais símbolos finais, que são pontos onde a execução do algoritmo se encerra. Partindo do 
símbolo inicial, há sempre um único caminho orientado a ser seguido, representando a existência de 
uma única sequência de execução das instruções. Isto pode ser melhor visualizado pelo fato de que, 
apesar de vários caminhos poderem convergir para uma mesma figura do diagrama, há sempre um 
único caminho saindo desta. Exceções a esta regra são os símbolos finais, dos quais não há nenhum 
fluxo   saindo,   e   os   símbolos   de   decisão,   de   onde   pode   haver   mais   de   um   caminho   de   saída 
(usualmente dois caminhos), representando uma bifurcação no fluxo. 
O   exemplo   ao   lado   representa   um  fluxograma 
convencional,  mostrando a representação do algoritmo 
de cálculo da média de um aluno sob a  forma de um 
fluxograma.   
A imagem abaixo é uma representação no diagrama de 
Chapin.   (não   abordaremos   esse   diagrama,   nessa 
apostila).
Projeto E­jovem ­ Módulo II
Logica de Programação 14
1.7.3.  Português Estruturado ou Pseudocódigo.
Esta forma de representação de algoritmos é rica em detalhes,como a definição dos tipos das 
variáveis   usadas  no   algoritmo.  Por   assemelhar­se   bastante  a   forma  em que  os  programas   são 
escritos, encontra muita aceitação.  Na verdade, esta representação é  suficientemente geral  para 
permitir   a   tradução  de  um algoritmo  nela   representado  para  uma  linguagem de  programação 
específica seja praticamente direta. A forma geral da representação de um algoritmo na forma de 
pseudocódigo é a seguinte:
Algoritmo   é   uma   palavra   que   indica   o   início   da   definição   de   um   algoritmo   em   forma   de 
pseudocódigo.
I   ­  Nome do programa:  é  um nome simbólico  dado ao algoritmo com a  finalidade de 
distingui­los dos demais.
II – Var: consiste em uma porção opcional onde são declaradas as variáveis globais usadas 
no algoritmo principal;
III ­ Início e Fim:  são respectivamente as palavras que delimitam o início e o término do 
conjunto de instruções do corpo do algoritmo.
O algoritmo do cálculo da média de  um aluno,  na  forma de um pseudocódigo,   fica  da 
seguinte forma no visualg:          
Dica:  O  Visual  será   a   ferramenta   que   utilizaremos   no   decorrer   do   aprendizado, 
lembrando que não usaremos todos os recursos disponíveis diretamente na ferramenta, 
uma parte é pratica com programação lógica dentro do Visualg,  a outra mostra conceitos 
que são logicamente utilizados nas maiorias das linguagens de programação, uma vez 
que,  até  então,  a versão do Visual não abrange praticar todo conteúdo contido nessa 
apostila como registos, manipulação de arquivo,dentre outros.  
Projeto E­jovem ­ Módulo II
Logica de Programação 15
1.8.  EXERCÍCIOS PROPOSTOS  
1°)Crie uma sequência lógica para sacar dinheiro em um caixa eletrônico.
2°)Crie uma sequência lógica para determinar se um numero é par ou impar.
3°)Crie um fluxograma para as questões um e dois.
4°)dado o fluxograma abaixo determine:
C = capital,ex: R$ 1.000,00
T = tempo em anos,ex: 2 anos
I = Taxa de juros,ex: 5%
o usuário entra com esses valores e sabe quanto e calculado em juros simples.
a)quais as entradas de dados.
b)qual o processo que está sendo executado.
c)qual será a saída de informação se o usuário digitar 1025, 3, 12.
5º)Resolva as seguintes lógicas:
I ­  Um time de futebol ganhou 8 jogos mais do que perdeu e empatou 3 jogos menos do que 
ganhou, em 31 partidas jogadas. Quantas partidas o time venceu?
II ­ Uma pessoa supõe que seu relógio está  5 minutos atrasado, mas, na verdade, ele está  10 
minutos adiantado. Essa pessoa que chega para um encontro marcado, julgando estar 15 minutos 
atrasada em relação ao horário combinado, chegou, na realidade, na hora certa em quantos minutos 
atrasados?
III ­ Três músicos, João, Antônio e Francisco, tocam harpa, violino e piano. Contudo, não se sabe 
quem toca o quê. Sabe­se que o Antônio não é o pianista. Mas o pianista ensaia sozinho à Terça. O 
João ensaia com o Violoncelista às Quintas . Quem toca o quê?
IV – Existem três mulheres, Dona Rosa, Dona Branca, Dona Lilas,  Dona branca diz: ­ as cores  de  
vestido que estamos  usando combinam com nossos  nomes,  mas não estamos  usando a  cor  do 
próprio nome, a pessoa que está de lilas diz: ­ é verdade, quis as cores que cada uma está usando? 
6°) Supondo que você tenha planejado no seu dia posterior ir para o colégio, após isso pagar uma 
conta  no  banco,   após   isso   ir   trabalhar,crie  um algoritmo o  mais  detalhado  possível   que  possa 
satisfazer todo o planejamento citado:
7º)Faça um algoritmo para imprimir um documento. Descreva com detalhes.
8º)Faça um algoritmo para colocar um quadro em uma parede. Descreva com detalhes.
 
Projeto E­jovem ­ Módulo II
Logica de Programação 16
Capítulo 2.  Tópicos Preliminares
Objetivos
Apresentar basicamente alguns tipos de dados a ser implementados e adotados; Falar qual sua 
importância; Diferenciar variável e constante; Apresentar comados e processo de entrada. 
2.1.  Tipos primitivos.
Todo  o   trabalho   realizado   por   um  computador   é   baseado   na   manipulação   das   informações 
contidas   em   sua   memória.   A   grosso   modo   de   expressar­se,   estas   informações   podem   ser 
classificadas em dois tipos:
As  instruções,  que comandam o  funcionamento da máquina e determinam a maneira   como 
devem ser tratados os dados. As instruções são específicas para cada modelo de computador, pois 
são funções do tipo particular de processador utilizado em sua implementação.
Os dados propriamente ditos, que correspondem a porção das informações a serem processadas 
pelo computador.
2.1.1.    Tipos de Primitivos de Dados
Quaisquer dados a ser tratado na construção de um algoritmo deve pertencer a algum tipo, que 
irá determinar o domínio de seu conteúdo. Os tipos mais comuns de dados são conhecidos como 
tipos   primitivos   de   dados,   são   eles:   inteiro,   real,   caractere   e   lógico.   A   classificação   que   será 
apresentada não se aplica a nenhuma linguagem de programação específica, pelo contrário, ela 
sintetiza os padrões utilizados na maioria das linguagens.
­Inteiro: todo e qualquer dado numérico que pertença ao conjunto de númerosinteiros relativos (negativo, nulo ou positivo). Exemplos: {...­4,­3,­2,­1,0,1,2,3,4,...}.
­Real: todo e qualquer dado numérico que pertença ao conjunto de números reais
(negativo, nulo ou positivo). Exemplos: {15,34; 123,08 ; 0,005 ­12,0 ; 510,20}.
­Numérico:  trata­se de todo e qualquer número que pertença ao conjunto dos inteiros ou 
reais, também abrange números binários, octal e hexadecimal.
­Dados literais: todo e qualquer dado composto por um conjunto de caracteres
alfanuméricos  (números, letras e caracteres especiais). Exemplos: {“Aluno Aprovado”, “10% de 
multa”, “Confirma a exclusão ??”, “S”, “99­3000­2”, “email”,”123nm”,”fd54fd”}.
­Lógico: A existência deste tipo de dado é, de certo modo, um reflexo da maneira como os 
computadores funcionam. Muitas vezes,estes tipos de dados são chamados de booleanos, devido à 
significativa contribuição de  Boole  a área da lógica matemática.  A todo e qualquer dado que só 
pode  assumir  duas   situações  dados  biestáveis,algo   como por   exemplo  {0/  1,   verdadeiro/falso, 
sim/não,  true/false }.
2.2.  Constantes.
Uma constante é um determinado valor fixo que não se modifica ao longo do tempo, durante a 
execução de um programa. Conforme o seu tipo, a constante é classificada como sendo numérica, 
lógica e literal.
Projeto E­jovem ­ Módulo II
Logica de Programação 17
Nesse exemplo temos o número 4 como constante, ou seja, ele nunca se altera.
2.3.  Variável.
Uma variável é um espaço reservado na memória do computador para armazenar um tipo de 
dado   determinado.   As   variáveis   devem   receber   nomes   para   poderem   ser   referenciadas   e 
modificadas quando necessário. Um programa deve conter declarações que especificam de que tipo 
são as variáveis que ele utilizará e as vezes um valor inicial. Tipos podem ser por exemplo:  inteiros, 
reais,caracteres,etc. As expressões combinam variáveis e constantes para calcular novos valores. 
 Veja um exemplo de variáveis do tipo carácter e outra do tipo inteiro,ele serão armazenados na 
memória :
Veja um exemplo onde atribuímos valores as variáveis nome e idade:
2.4.  Formação de identificadores.
Toda variável deve possuir um nome para sua identificação dentro de um algoritmo, mas vale 
ressaltar que não podemos atribuir qualquer nome a ela,e uma vez atribuindo, verificar se ele é um 
identificador válido ou não. Na figura abaixo observamos um resumo através de um gráfico que 
segue resumidamente as regras.
Representamos   nomes   escolhidos   para   rotular   as   variáveis,procedimentos   e   funções, 
normalmente, obedecem as seguintes regras:
1. O primeiro carácter deve ser uma letra.
2. Os   nomes   devem   ser   formados   por   caracteres   pertencentes   ao   seguinte   conjunto   :
{a,b,c,..z,A,B,C,...Z,0,1,2,...,9,_}.
3. Os nomes escolhidos devem explicitar seu conteúdo. EX: A, B1, BC3D,SOMA, CONTADOR.
obs.: Um exemplo de identificador inválido seria 2AB ou qualquer outro iniciado por um dígito.
2.5.  Declaração de variáveis
Toda variável possui algum conteúdo, que será armazenado por ela e manipulado pelo algoritmo. 
As variáveis que serão utilizadas nos algoritmos devem ser declaradas inicialmente. A declaração de 
uma variável indica o tipo de dado que ela pode “guardar” no decorrer da execução do algoritmo 
(ou no decorrer da execução do programa que futuramente será construído).
Para declararmos uma variável, temos que criar um identificador para ela, que será o nome da 
variável no algoritmo, e também temos que definir o tipo de dado que a variável pode armazenar. 
Faremos a declaração de variáveis obedecendo ao seguinte padrão:
Projeto E­jovem ­ Módulo II
Logica de Programação 18
Portugol:  [nome do tipo de variável] : [ nome da variável] ;
Padrão Visualg: [nome da variável] : [ nome do tipo de variável] 
Percebemos que existe duas diferença na declaração das variáveis do portugol em relação a do 
Visual,que é justamente a troca de posições e a ausência de ponto­e­virgula. 
Exemplo:
Visualg: Portugol:
alunos : caracter caracter : alunos ;
valor : inteiro inteiro : valor ;
b : real real : b ;
2.6.  Comandos de entrada e saída.
Em um  algoritmo é preciso representar a troca de informações que ocorrerá entre o mundo da 
máquina e o nosso mundo, para isso, devemos utilizar comandos de entrada e saída, sendo que,a 
nível   de   algoritmo   esses   comandos   representam   apenas   a   entrada   e   a   saída   da 
informação,independe   do   dispositivo   utilizado   (teclado,   discos,   impressora,   monitor,...),   mas, 
sabemos que nas linguagens de programação essa independência não existe, ou seja, nas linguagens 
de programação temos comandos específicos para cada tipo de unidade de Entrada/Saída.
2.6.1.  COMANDO DE ENTRADAS DE DADOS
Para   que   possamos   obter   dados   do   meio   exterior   para   uso   do   computador   (memória 
principal),estes têm de vir através dos dispositivos de entrada. Da mesma forma, as informações que 
são produzidas, tem de ser levadas ao meio externo (um arquivo, um a impressora, uma tela etc.) 
através de um dispositivo de saída. Para isso, utilizamos dois comandos assim definidos:
Comando “leia” tem a finalidade de lê, do meio externo, a próxima informação disponível para 
leitura  e  armazena na(s)  variável(eis)  discriminada(s)  após  o comando,  entre  parênteses.  Mais 
tarde aprenderemos como especificar a leitura de um dado que está armazenado em um arquivo e 
de que arquivo está sendo lido o dado.
Exemplo: leia (v) O valor da variável (v) é dado por um dispositivo de entrada.
Projeto E­jovem ­ Módulo II
Logica de Programação 19
2.6.2.  COMANDO DE SAIDAS DE DADOS
Comando  escreva  ou  escreval:   Imprime   (na   tela   ou   na   impressora)   o   conteúdo   da(s) 
variável(eis)  especificada(s)   após  o   comando,   entre  parênteses.  Não   será   preocupação  nossa  a 
formatação de relatórios, mas o comando permite a impressão de texto (entre “ ”), se for necessária 
para clareza ou especificação do que está sendo impresso.
  Exemplo: escreva(x) O valor atual da variável (x) é informado para um dispositivo de saída.
 Vale ressaltar que em linguagens de programação geralmente termina um comando com 
ponto e virgula( ; ), mas para o uso no Visualg, não precisamos usar ; para fechar o comando,uma 
vez que isso ocorre de forma automática.
Exemplo: escreva(x) O valor atual da variável (x) é informado para um dispositivo de saída.
em visualg: numero : inteiro
portugol: inteiro numero;
Também podemos concatenar valores no comando de saída. Isso varia muito de uma linguagem 
para outra, por exemplo: 
ao executar(tecla de atalho F9) isso imprime na tela resultado seguinte:
Esse exemplo ao lado utilizamos os a 
subtração de dois números e logo após 
imprimimos o resultado na tela.
Projeto E­jovem ­ Módulo II
Logica de Programação 20
O resultado da saída desse programa é a seguinte:
Exemplo com o comando leia e escreva:
código­fonte. saída da execução:
utilizamos o “escreval” quando queremos uma quebra de linha, troque por “escreva” e perceba o que 
acontece:
2.7.  Expressões aritméticas.
Quando   construímos  algoritmos   é   comum  trabalharmos   com expressões  matemáticas   para   a 
resolução   de   alguns   problemas.   As   expressões   matemáticas   podem   fazer   uso   de   operadores 
aritméticos e relacionais. As variáveis (ou constantes) manipuladas pelos operadores são chamadas 
de operandos. Observe o diagrama:
Exemplos:
 
A+B (A e B são os operados, e + é o operador da expressão).
((2 * A) + 5)
(B/A)
((A//2)*B) – 15
Projeto E­jovem ­ Módulo II
Logica de Programação 21
2.8.  Operadores aritméticos
Chamamos  de  operadores  aritméticos  o  conjunto  de   símbolos  que   representa  as  operações 
básicas da matemática.
Para representa potencia e radiciação utilizamos:
Operador Função Significado Exemplos
^ Potenciação x elevado a y  2^8
raizQ(x) Radiciação Raiz quadrada de x raizQ(9)
Exemplo:
   código­fonte.Saída da execução.
Usaremos outras operações matemáticas não convencional, porém muito úteis nas construção de 
algoritmo, que são o resto e o quociente da divisão inteira, conforme abaixo:
Operador  Função Exemplo
mod Resto da divisão 9 mod 4 resolta em 1
div  Quociente da divisão  9 div 4 resulta em 2
Exemplo:
  algorítimo que possui as quatros operações:
  código­fonte.  Saída da execução.
algorítimo que calcula o quociente e resto de uma divisão: 
código­fonte. Saída da execução.
Projeto E­jovem ­ Módulo II
Logica de Programação 22
2.9.  Expressões lógicas
As  expressões   lógicas   sempre   retornaram  True  (Verdadeiro)   e  False  (Falso).  Para   se  montar 
expressões lógicas utilizamos de operadores relacionais e operadores lógicos.
Exemplo:
Visualg: Portugol:
a <- verdadeiro a <- verdadeiro;
b <- falso b <- falso;
2.10.  Operadores relacionais.
São utilizados para relacionar variáveis ou expressões, resultando num valor lógico (Verdadeiro 
ou Falso), sendo eles mostrados na tabela abaixo:
Obs.: utilizamos somente o “=” no lugar de “==”, e “<>” no lugar de “!=”, mas isso somente no 
Visualg.
Exemplos: 
comparações:
num != 3              {compara se num é diferente de 3,se for igual retorna falso}
nome = ‘DENISE’  {compara se nome é igual a ‘DENISE’ ,se for retorna verdadeiro}
num > 5 é falso (0) {3 não é maior que 5}
Algorítimo abaixo mostra o uso desse operadores relacionais.
código-fonte. Saída da execução.
Projeto E­jovem ­ Módulo II
Logica de Programação 23
2.11.  Operadores lógicos.
São utilizados para avaliar expressões lógicas. Estes operadores servem para avaliar expressões 
que resultam em valores lógico sendo verdadeiro ou falso:
Esses  operadores   tem a   finalidade  de  novas  proposições   lógicas   composta  a   partir   de  outra 
proposições lógicas simples. Observe:
Operador  Função
não negação
e conjunção
ou disjunção
Com   isso   podemos   podemos   construir   a   Tabela   verdade   onde   trabalhamos   com   todas   as 
possibilidades combinatória entre os valores de diversas variáveis envolvidas, as quais se encontram 
em apenas duas situações (V e F), e um conjunto de operadores lógicos. Veja o comportamento 
dessas variáveis:
Operação de Negação:
A (not) não A
F V
V F
Operação de conjunção:
A B A e B
F F F
F V F
V F F
V V V
Operação de disjunção não­exclusiva:
A B A ou B
F F F
F V V
V F V
V V V
Exemplos:  
ACHOU = falso ,  ACHOU = true;
NUM = 9
( 4 > 5 ) e ( 5 > 3) => falso e verdadeiro (1) = falso (0)
não ACHOU => verdadeiro
Projeto E­jovem ­ Módulo II
Logica de Programação 24
Exemplo:
código-fonte. Saída da execução.
2.12.  Comando de atribuição.
O   operador   de   atribuição   é   utilizado   para   atribuir   valores   aos   identificadores(variáveis   e 
constantes) e na montagem de expressões(aritméticas,lógicas e literal).
Com isso podemos definir   sempre que um tipo de dado deve  ser  compatível  com o  tipo da 
variável.
A figura abaixo mostra em diagrama a sua sintaxe:
O valor da expressão é atribuído ao identificador (variável).
 X <- 2 y <- 5-x Z <- (3*(y- 9)) w <- (4*((w+2y)/2)*x)
Este comando permite que se forneça ou altere o valor de uma determinada variável, onde o tipo 
desse valor seja compatível ao tipo de variável na qual está sendo armazenado, de acordo com o 
especificado na declaração.
Exemplo:
NUM <­ 8 {A variável NUM recebe o valor 8}
NOME <­ “Guilherme” {A variável NOME recebe o valor ‘Guilherme’}
2.12.1.  PRIORIDADE DE OPERADORES:
Durante a execução de uma expressão que envolve vários operadores, é necessário a existência de 
prioridades, caso contrário poderemos obter valores que não representam o resultado esperado. A 
maioria das linguagens de programação utiliza as seguintes prioridades de operadores:
1. Efetuar operações embutidas em parênteses "mais internos".
2. Efetuar Funções.
3. Efetuar multiplicação e/ou divisão.
4. Efetuar adição e/ou subtração.
5. Operadores Relacionais.
6. Operadores Lógicos
Projeto E­jovem ­ Módulo II
Logica de Programação 25
2.13.  EXERCÍCIOS PROPOSTOS  
1º)Como podemos definir o conceito de tipos primitivos de dados.
2°)Cite alguns tipos primitivos e der exemplos.
3°)Qual a diferença entre constantes e variáveis.
4°)Como podemos definir a formação de um identificador válido? crie cinco identificadores no 
Visualg (o nome devera ser uma única letra e após isso os tipos). 
5°)Crie o seguinte código no Visualg e diga qual o resultado final.
6°)Crie um programa no onde podemos receber dois números digitados pelo usuário no final ele 
some os números e imprima o resultado.
7°)Dado a formula: 
        
     ­crie um programa para calcular a formula de Bhaskara. Onde no final mostre ao usuário x1 e 
x2 separadamente.
Dica:o usuário digita três valores, a,b e c,o programa terá duas variáveis para receber o calculo, 
x1  e  x2.Para calcular raiz quadrada use o comando  raizQ(x)  onde  x  é o numero que tem valor 
inteiro,atribua o resultado da raiz a soma e depois a subtração.
ex: b   ← raizQ(25) , b recebe 5,pois é raiz de 25, e b deve ser do tipo real.
8º)Crie um diagrama onde podemos representar o programa da questão 7.
9°)Crie um programa que receba pelo usuário o nome,ano de nascimento, ano atual, e calcule a 
idade,mostrando a seguinte saída ex:  meu nome é Janaína e tenho 23 anos de idade.
10°)crie um diagrama para representação da questão 9.
11°) usando o comando o tipo de dado logico do Visualg, teste  os operadores relacionais. ex: a : 
logico , a   12 <=5 ,escreva(a).←
Projeto E­jovem ­ Módulo II
Logica de Programação 26
Capítulo 3.  Estruturas de Controle
Objetivos
     Mostrar conceitos e estrutura sequencial de fluxo, em etapas lógicas, onde pode­se assimilar 
suas variações, combinações e equivalências; Apresentar estruturas de repetição e sua aplicação. 
As estrutura de controle de dado são responsáveis pela manipulação dos dados conforme seja 
necessário na realização de um processamento. Cada instrução programável possui uma lógica de 
operação e estabelece uma sequencia de ações a serem efetuadas ou verificadas.
Quando   estivermos   criando   os   algoritmos   serão   necessárias   as   manipulações   de   dados 
respeitando a sequencia lógica de cada comando, buscando sempre alcançar os objetivos almejados 
pelos algoritmos. Basicamente as estruturas de controle de dados são de três tipos principais:
­Sequencial: conjunto de comandos separados por ponto e vírgula (;) que são executados em 
uma sequência linear de cima para baixo. 
­Seleção:a partir de um teste condicional, uma instrução, ou um conjunto de instruções, podem 
ser executados ou não, dependendo exatamente do resultado do teste efetuado. 
­Repetição:uma instrução ou o conjunto de  instruções que será  executado repetidamente,  de 
acordo com o resultado de um teste condicional.
3.1.  Estrutura sequencial.
A estrutura   sequencial   é   a  mais   convencional   entre   todas  as   possíveis,   pois   ela   consiste   na 
execução de uma instrução de cada vez, onde o encerramento da primeira instrução permite o 
acionamento da instrução seguinte, respeitando a ordem de cima para baixo.
Observe o exemplo a seguir:
Declarações 
 real NOTA; 
Inicio 
 escreva("Informa a nota da prova: "); 
 leia(NOTA); 
 escreva("Nota =", NOTA);
Fim
O mesmo exemplo no Visualg fica:
Projeto E­jovem ­ Módulo II
Logica de Programação 27
O algoritmo proposto no exemplo anterior é  descritivo e respeita as regras de organização e 
sintaxe   do   português   estruturado.   Porém,   qual   é   a   primeira   instrução   a   ser   executada   neste 
algoritmo?
Ele será executado de maneira sequencial, onde a partir da palavra reservada  Declarações  as 
instruções vão sendo executadas de cima para baixo e a próxima instrução só é executada após a 
anterior ser encerrada. O ponto e vírgula marca exatamente o final da instrução a ser executada, no 
caso dos comandodo Visualg vale lembrar que suas instruções não finalizam com ponto e virgula, 
pois ao passar pra próxima linha o programa reconhece como finalização da instrução anterior.
1. Primeira execução será a criação da variável NOTA.
2. Segunda será a escrita da mensagem que orienta o usuário.
3. Na terceira será armazenado o valor informado pelo usuário.
4. A quarta e última mostrará uma mensagem e o valor lido 
            É   importante observar que sempre será  executado primeiro o bloco de declarações e na 
sequencia  o bloco de  instruções.  A execução da  palavra  reservada  Fim  encerra  a  execução do 
algoritmo.
3.2.  Estrutura de seleção.
Este   tipo   de   estrutura   permitir   a   escolha   de   um   caminho   sequencial   a   ser   executado. 
Primeiramente, ela efetua um teste condicional que definirá o caminho de execução do algoritmo 
baseado no resultado deste teste.
Os   testes   condicionais   são   baseados   na   lógica   convencional,   podem   obter   o   resultado   de 
verdadeiro ou falso. Estes testes podem ser efetuados sobre operações relacionais simples ou com 
expressões lógicas complexas que resultem em um valor lógico (verdadeiro ou falso).
As estruturas de seleção podem ser classificadas de 4 formas diferentes, sendo esta classificação 
baseada na organização lógica existente em cada situação. Esta classificação se resume em:
       >  Seleção simples. 
       >   Seleção composta. 
       >  Seleção encadeada.  
       >  Seleção de múltipla escolha.
3.2.1.  Seleção Simples
Neste   tipo  de   seleção é   proposto  um  teste   condicional,  que   sendo verdadeiro  possibilitará   a 
execução de uma instrução ou um conjunto de instruções (bloco condicional) específica.
Português estruturado:
Acompanhe   a   seguir   as   regras   de   representação   em  algoritmo   para   a   técnica   descritiva   do 
português estruturado.
Sintaxe: 
 
 : 
se (<condição>) então 
 comando 1; 
 comando 2; 
 : 
 : 
 comando n; 
fim se; 
Projeto E­jovem ­ Módulo II
Logica de Programação 28
Exemplo: No Visualg:
Declarações 
 inteiro IDADE; 
 Inicio 
 escreva("Informe sua idade: "); 
 leia(IDADE); 
 se (IDADE < 15) então 
 escreva ("Você é uma criança"); 
 fim se; 
 Fim
Este algoritmo será executado sequencialmente até chegar ao comando SE (comando condicional 
SE) que realizará o teste condicional para verificar a veracidade do valor informado pelo usuário e 
armazenado na variável IDADE.
Se ela for verdadeira, ou seja, for menor que 15 a mensagem "Você é uma criança" será mostrada 
na tela. Se o valor informado pelo usuário não atender ao teste condicional, a mensagem não será 
exibida e o bloco condicional não será executado.
Fluxograma: 
Abaixa temos no fluxograma o simbolo que representa uma decisão ou seleção e a seguinte: 
As suas vértices indica qual a saída caso ela for     
verdadeira ou falsa. 
 
Acompanhe   a   seguir   a   representação   em 
algoritmo na técnica gráfica do fluxograma:
 
Exercício rápido:
1°) Crie um algoritmo que leia um número e diga se 
ele é maior ou menor que 10.
2°)   Crie   um   algoritmo   que   leia   dois   números   e 
determine qual é o maior entre eles, imprimindo na 
tela   (“o   primeiro   número   é   o   maior”,   “o   segundo 
número e o maior” ) de acordo com o valor digitado.
Projeto E­jovem ­ Módulo II
Logica de Programação 29
3.2.2.  Seleção Composta
A seleção composta sempre executará  um bloco condicional, pois se o resultado do teste 
condicional   for  verdadeiro  um conjunto  de   instruções  ou   somente  uma será   executada  e   se  o 
resultado não for verdadeiro um outro conjunto de instruções, ou somente uma, será executada 
também.
Este tipo de seleção sempre identificará um único caminho de instruções a ser percorrido, 
dependendo sempre do resultado da veracidade do testes condicional executado.
Sintaxe: 
 : 
se (<condição>) então 
 comando 1; 
 : 
 comando n; 
senão 
 comando 5; 
 : 
 comando m; 
fim se;
Exemplo: no Visualg
Declarações 
 inteiro idade; 
Inicio 
 escreva("Informe sua idade: "); 
 leia(idade); 
 se (idade < 15) então 
 escreva ("Você é uma criança"); 
 senão 
 escreva("Você é adulto"); 
 fim se; 
Fim
Se a idade informada for menor que 15 então a mensagem a classificará como uma criança, senão 
a mensagem apresentada será que Você é adulto.
Projeto E­jovem ­ Módulo II
Logica de Programação 30
Veja como é o fluxograma que representa o código anterior abaixo:
Exercício rápido:
1°)  Crie  um algoritmo que   leia   sua 
idade e diga se você é de “maioridade” 
ou de “menoridade”.
2°)   Crie   um   algoritmo   que   um 
número,   caso   ele   seja   menor   que   0, 
transforme   ele   em   positivo,   se   não, 
imprima seu valor na tela.
3.2.3.  Seleção encadeada
A instrução de seleção (SE) pode ser encadeada uma dentro da outra, seja no bloco verdadeiro 
(então) ou falso (senão). Todas as instruções programáveis podem estar dentro de qualquer um dos 
blocos da instrução de seleção.
O encadeamento destas instruções também é chamada de aninhamento de instruções de seleção 
ou condicional várias, não existindo um limite de quantos testes condicionais podem estar dentro de 
outro. Quem estabelece este tipo de limite é a solução lógica proposta no algoritmo para alcançar 
uma solução eficiente.
Sintaxe: 
 : 
se (<condição_1>) então 
 <bloco de comandos 1>; 
senão 
 se (<condição_2>) então 
 <bloco de comandos 2>; 
senão 
se (<condição_3>) então 
 : 
fim se; 
 fim se; 
fim se; 
Projeto E­jovem ­ Módulo II
Logica de Programação 31
Exemplo:  no Visualg:
Declarações 
 inteiro idade; 
Início 
 escreva("Informe sua idade: "); 
 leia(idade); 
 se (idade < 20) então 
 se(idade < 15) então 
 escreva ("Você é criança"); 
 senão 
 escreva ("Você é adolescente"); 
 fim se; 
 senão 
 se(idade < 50) então 
 escreva("Você é adulto"); 
 senão 
 escreva("Você é velho"); 
 fim se; 
 fim se; 
Fim 
Fluxograma:
Exercício rápido:
1°) Crie um algorítimo que receba os três lados(A,B,C) de um triângulo e diga de ele é  
triângulo escaleno(todos os lados diferente), isósceles(somente dois lados iguais) ou 
equilátero(todos os lados iguais). 
2°) Dado três variáveis, crie um algoritmo que determine quem é a maior, a intermediaria e a 
menor. 
Projeto E­jovem ­ Módulo II
Logica de Programação 32
3.3.  Seleção de múltipla escolha.
Uma outra instrução condicional,  muito utilizada nas avaliações de igualdade, é  a seleção de 
múltipla escolha. Ela verifica somente a igualdade do valor avaliado, onde sua veracidade resultará 
na execução de um bloco, ou de uma única instrução específica.
Sintaxe: 
 : 
escolha (X) 
 caso <v1>: 
 comandos; 
 caso <v2>: 
 comandos; 
 caso <v3>: 
 comandos; 
 caso contrario: 
 comandos; 
fim escolha;
<v1>,   <v2>,   <v3>   são   supostos   valores   a   serem   relacionados   por   meio   da   operação   de 
igualdade.
Exemplo:
Declarações 
 inteiro estação; 
Inicio 
 escreva("Digite o período trimestral do ano em que estamos: "); 
 leia(estação); 
 escolha (estação) { instrução de múltipla escolha sobre estação } 
caso 1: escreva ("verão"); { testes de igualdades sobre estação } 
caso 2: escreva ("outono"); 
caso 3: escreva ("inverno"); 
caso 4: escreva ("primavera"); 
caso contrario: escreva ("período inválido"); 
 fim escolha; 
Fim
Projeto E­jovem ­ Módulo II
Logica de Programação 33
No Visualg
   Temos algumas diferenças de sintaxe, onde uma delas é a ausência de dois pontos após caso, a 
outra é o comando “outrocaso” que no portugol é representado por “casocontrario”.
3.4.  Estruturas de repetição.
O processamento de valores pode ocorrer diversas vezes sobre uma mesma lógica,  porém os 
dadosa serem manipulados podem ser diferentes, como no calculo da tabuada de um número. Este 
calculo realiza a mesma operação de multiplicação sobre os valores numéricos inteiros sequencias, 
normalmente iniciados em um (1) e seguindo até o número dez (10) quando estamos aprendendo a 
calcular e memorizar o resultado obtido nesta operação.
Sendo assim, Vamos criar um algoritmo que leia um número positivo e apresente o resultado de 
sua tabuada de um a dez (1 à 10). Observe o exemplo proposto:
Exemplo:
Supondo que o valor 
desejado seja 2 então:  Solução (algoritmo descritivo): 
2 x 1 = 2 
2 x 2 = 4 
2 x 3 = 6 
2 x 4 = 8 
2 x 5 = 10 
2 x 6 = 12 
2 x 7 = 14 
2 x 8 = 16 
2 x 9 = 18 
2 x 10 = 20
Projeto E­jovem ­ Módulo II
Logica de Programação 34
Para o exemplo acima foi desenvolvido um algoritmo que atende ao problema apresentado, mas 
se os valores tivessem que ser gerados até 1000? .Assim o algoritmo não ficaria mais complexo, pois 
a operação a ser realizada seria a mesma, e ele ficaria bem maior. Adiante veremos a solução para 
esse problema.
Dica: os laços de repetição são conhecidos em inglês como loops ou looping.
3.5.  Repetição com teste no início e no final.
3.5.1.  TESTE INÍCIO
Com   o   intuito   de   controlarmos   as   manipulações   necessários   sobre   os   dados   armazenados, 
também podemos utilizar as instruções de repetição, que permitem a repetição de uma operação 
quantas vezes forem necessárias, baseando esta repetição no resultado de um teste condicional.
Para isso temos a estrutura enquanto <condição> faça.
A instrução de repetição ENQUANTO ...  FAÇA permite a execução do conjunto de comandos 
pertencentes ao seu bloco de repetição, sendo eles executados a partir de um teste condicional 
verdadeiro.  Enquanto este teste permanecer  verdadeiro a repetição é  executada continuamente, 
sendo encerrada somente quando a condição for falsa.
Sintaxe:
 : 
enquanto (< condição >) faça
<bloco de repetição>; { com um ou vários comandos }
fim enquanto;
Exemplo (descritivo): No Visualg:
  
Declarações 
real nota, media; 
inteiro aux; 
Início 
aux   1; ←
media   0; ←
enquanto  aux < 50 faca
       escreva("Informe sua nota: "); 
       leia(nota); 
       media   ← media + nota; 
       aux   ← aux + 1; 
fim enquanto
escreva("Média da turma = ",media /50);
Fim 
Projeto E­jovem ­ Módulo II
Logica de Programação 35
Fluxograma:
Observe   ao   lado   a   representação   genérica   em   um   algoritmo   gráfico   usando   o 
ENQUANTO ...FAÇA.
Exercício rápido:
1°) Crie um algorítimo que conte de 1 até 100.
2°) Crie um algorítimo que receba 10 números e 
imprima na tela após cada digitação.
3°) Crie um programa que conte de ­1 a ­52.
3.5.2.  TESTE FINAL
Para o teste final temos a instrução REPITA ... ATÉ, onde  possui características relevantes na 
sua lógica de execução.
As principais características dessa instrução são:
• O teste condicional para realizar a repetição sobre o bloco de instruções existente 
entre a palavra reservada REPITA e ATÉ é executado somente no final do bloco, conforme 
organização sequencial do algoritmo 
• O bloco entre as duas palavras reservadas desta instrução será executado no mínimo 
uma vez 
• A repetição é  executada somente se o teste condicional  for  falso,  pois sendo ele 
verdadeiro a repetição é encerrada. 
Sintaxe:
: 
repita
<bloco de repetição>;{ com um ou vários comandos }
até (<condição>);
:
Projeto E­jovem ­ Módulo II
Logica de Programação 36
Exemplo (descritivo): No Visualg:
Declarações 
 real nota, media; 
 inteiro aux; 
Início 
 aux ← 1; 
 media ← 0; 
 repita 
 escreva("Informe sua nota: "); 
 leia(nota); 
 media ← media + nota; 
 aux ← aux + 1; 
 até (aux > 50); 
escreva("Média da turma = ",media /50);
Fim 
Usando a representação gráfica, vamos observar o mesmo exemplo usando a instrução REPITA ... 
ATÉ.
O bloco de repetição vai ser executado até a condição for maior que 50.
Observe Fluxograma ao lado:
Exercício rápido:
1°) Crie um algorítimo que leia um número e 
mostre vários “*” na tela de acordo com esse 
número. Ex: 10 vai imprimir  **********.
2°) Crie um algoritmo que leia dois números e 
mostre o intervalo entre eles. Ex: 5 e 12 vai  
mostra: 6,7,8,9,10,11.
Projeto E­jovem ­ Módulo II
Logica de Programação 37
3.6.  Repetição com variável de controle.
Na estrutura de repetição vista até agora, ocorrem casos que fica difícil determinar o números de 
vezes que um bloco vai executar. Ou seja,será executado enquanto a condição for satisfatória.
A instrução de repetição PARA ... FAÇA executa um conjunto de instruções por uma quantidade 
de vezes bem definidas (conhecidas).
Sintaxe:
 : 
para X de i até f passo p faça 
 <comandos>; 
fim para;
onde:
X é uma variável inteira que auxiliará na contagem da repetição iniciada com o valor i até o valor 
final de f ,p é o valor do incremento dado a variável X. 
O problema da tabuada, apresentado anteriormente, pode ser solucionado com o algoritmo que 
usa eficientemente a instrução de repetição para ... faça. 
Solução da tabuada (descritiva):
Declarações 
 inteiro valor, contador; 
Início 
 escreva ("Informe o valor desejado: "); 
 leia(valor); 
 para contador de 1 até 10 passo 1 faça 
 escreval(valor, " x ",contador," = ", ( valor * contador) ); 
 fim para; 
Fim
No Visualg:
Projeto E­jovem ­ Módulo II
Logica de Programação 38
Vamos acompanhar outro exemplo na aplicação desta instrução de repetição.
Exemplo (descritivo): No Visualg:
Declarações 
 real nota, soma, media; 
 inteiro aux; 
Início 
 soma <- 0; 
 para aux de 1 até 50 passo 1 faça 
 escreva("Informe sua nota: "); 
 leia(nota); 
 soma<- soma + nota; 
 fim para; 
 media <- soma / 50; 
 escreva ("Média da turma = ", MEDIA); 
Fim
Neste exemplo, a repetição, ou looping, realizado pela instrução para ... faça efetua a leitura e a 
soma de 50 notas de alunos de uma turma, apresentando no seu final a média desta turma.
Fluxograma: 
Acompanhe   a   seguir   o   algoritmo   gráfico   da 
solução   descrita   anteriormente   em     português 
estruturado. 
Exercício rápido:
1°) Faça um algoritmo que receba 10 
números e imprima somente os 5 primeiros.
2°) Faça um algoritmo que imprima somente 
números pares de 2 até 20.
Projeto E­jovem ­ Módulo II
Logica de Programação 39
3.7.  Comparação entre estruturas de repetição.   
As  estruturas  de   repetição possuem uma forma diferenciada  para  controlar  a  quantidade de 
repetições   a   serem   executadas.   Estes   controles   podem   ser   genericamente   classificados   em 
automático ou controlado pelo usuário do programa. 
AUTOMÁTICO: Uma variável auxiliar contará de quantas vezes será executado o conjunto 
de   comandos   (bloco   de   repetição),   sem   interferência   direta  do   usuário.   O  bloco   será 
repetido sempre a quantidade de vez prevista pelo desenvolvedor do programa.
CONTROLADO   PELO   USUÁRIO:  O   programa   sempre   respeitará   a   solicitação   do   usuário, 
executando um bloco de repetição quantas  vezes   forem solicitadas  pelo  usuário,   respeitando a 
lógica existente no programa desenvolvido. 
Na tabela a seguir podemos ver um comparativo de estruturas de repetição;
Estrutura Condição Quantidade de execuções Condição de existência
Enquanto Início 0 ou muitas Condição verdadeira
Repita Final Minimo 1 Condição falsa
Para Não tem ((vf-vi) div p)+1 v<=vf
Onde:
v       variável de controle;→
vi      é a variável de controle;→
vf      é o valor final da variável v;→
p       é o valor o incremento dado à variável;→
Diagrama:
enquanto:
repita:
para:
Projeto E­jovem ­ Módulo II
Logica de Programação 40
Repare que a  estrutura  para  é  a  mais  complexa,  uma vez que acontece  vários  processos  no 
mesmo,  as  estruturas   repita  e  enquanto são muito  semelhantes.  A diferença  está  na  ordem da 
expressão e ação, pois em repita