Lógica de Programação

SÉRIE TECNOLOGIA DA INFORMAÇÃO - HARDWARE
LÓGICA DE
PROGRAMAÇÃO
CONFEDERAÇÃO NACIONAL DA INDÚSTRIA – CNI
Robson Braga de Andrade

Presidente
DIRETORIA DE EDUCAÇÃO E TECNOLOGIA – DIRET
Rafael Esmeraldo Lucchesi Ramacciotti

Diretor de Educação e Tecnologia
Julio Sergio de Maya Pedrosa Moreira

Diretor Adjunto de Educação e Tecnologia
SERVIÇO NACIONAL DE APRENDIZAGEM INDUSTRIAL – SENAI
Conselho Nacional
Robson Braga de Andrade

Presidente
SENAI – Departamento Nacional
Rafael Esmeraldo Lucchesi Ramacciotti

Diretor-Geral
Julio Sergio de Maya Pedrosa Moreira

Diretor Adjunto de Educação e Tecnologia
Gustavo Leal Sales Filho

Diretor de Operações
TECNOLOGIA DA INFORMAÇÃO - HARDWARE
LÓGICA DE
PROGRAMAÇÃO
© 2018. SENAI – Departamento Nacional
© 2018. SENAI – Departamento Regional de Santa Catarina
A reprodução total ou parcial desta publicação por quaisquer meios, seja eletrônico, mecâ-
nico, fotocópia, de gravação ou outros, somente será permitida com prévia autorização, por
escrito, do SENAI.
Esta publicação foi elaborada pela equipe de Educação a Distância do SENAI de Santa Cata-
rina, com a coordenação do SENAI Departamento Nacional, para ser utilizada por todos os
Departamentos Regionais do SENAI nos cursos presenciais e a distância.
SENAI Departamento Nacional

Unidade de Educação Profissional e Tecnológica - UNIEP
SENAI Departamento Regional de Santa Catarina

Gerência de Educação e Tecnologia - GEDUT
SENAI Sede
Serviço Nacional de Setor Bancário Norte • Quadra 1 • Bloco C • Edifício Roberto
Aprendizagem Industrial Simonsen • 70040-903 • Brasília – DF • Tel.: (0xx61) 3317-
Departamento Nacional 9001 Fax: (0xx61) 3317-9190 • http://www.senai.br
Lista de Ilustrações
Figura 1 - Processo de execução de um algoritmo................................................................................................19
Figura 2 - Figuras geométricas para representação de fluxogramas...............................................................22
Figura 3 - Fluxograma para apresentar a média de três notas..........................................................................23
Figura 4 - Fluxograma para indicar a aprovação ou reprovação de um aluno.............................................24
Figura 5 - Batalha naval....................................................................................................................................................91
Figura 6 - Os Cinco fatores de satisfação no trabalho numa abordagem multidimensional.............. 115
Figura 7 - Acidente típico ............................................................................................................................................ 131
Figura 8 - Acidente de trajeto..................................................................................................................................... 131
Figura 9 - Representação do ruído em um ambiente de trabalho................................................................ 133
Figura 10 - Óleo derramado no local de trabalho representa um agente químico ............................... 134
Figura 11 - Representação de um Mapa de Riscos simplificado.................................................................... 142
Quadro 1 - Facetas comuns da satisfação no trabalho ..................................................................................... 115

Quadro 2 - Equipamentos de proteção individual mais comuns.................................................................. 138
Quadro 3 - Equipamentos de Proteção Coletiva.................................................................................................. 141
Quadro 4 - Tipos de Inspeção..................................................................................................................................... 143
Quadro 5 - Riscos ambientais...................................................................................................................................... 145
Tabela 1 - Operadores.......................................................................................................................................................36
Sumário
1 Introdução.........................................................................................................................................................................13
2 Conceitos Básicos...........................................................................................................................................................15
2.1 Lógica...............................................................................................................................................................16
2.2 Lógica de programação.............................................................................................................................18
2.3 Formas de representação .........................................................................................................................19
2.3.1 Descrição narrativa....................................................................................................................19
2.3.2 Fluxogramas ...............................................................................................................................21
2.3.3 Pseudocódigo.............................................................................................................................25
2.4 Linguagem de programação...................................................................................................................27
3 Tipos de Dados e Operadores....................................................................................................................................31

3.1 Variáveis...........................................................................................................................................................32
3.2 Constantes......................................................................................................................................................33
3.3 Tipos de dados .............................................................................................................................................34
3.4 Operadores.....................................................................................................................................................34
3.4.1 Operadores de atribuição.......................................................................................................35
3.4.2 Operadores aritméticos ..........................................................................................................36
3.4.3 Operadores relacionais............................................................................................................40
3.4.4 Operadores lógicos ..................................................................................................................42
3.4.5 Precedência de operadores ...................................................................................................44
4 Iniciando com Algoritmos...........................................................................................................................................47

4.1 Iniciando um algoritmo.............................................................................................................................48
4.2 Declaração de variáveis..............................................................................................................................50
4.3 Entrada e saída de dados...........................................................................................................................52
4.4 Documentação de código .......................................................................................................................55
5 Estruturas de Controle e Repetição..........................................................................................................................59

5.1 Comandos de decisão................................................................................................................................60
5.1.1 Seleção simples..........................................................................................................................60
5.1.2 Seleção composta .....................................................................................................................61
5.1.3 Seleção composta encadeada .............................................................................................63
5.1.4 Escolha-caso ...............................................................................................................................65
5.2 Comandos de repetição.............................................................................................................................67
5.2.1 Enquanto.......................................................................................................................................68
5.2.2 Repita.............................................................................................................................................69
5.2.3 Para..................................................................................................................................................70
5.3 Exemplo utilizando diversas estruturas de controle.......................................................................72
6 Estruturas Homogêneas..............................................................................................................................................79
6.1 Vetores..............................................................................................................................................................80
6.2 Matrizes............................................................................................................................................................90
7 Manipulação de Arquivos...........................................................................................................................................99
7.1 Criação e manipulação de arquivos.................................................................................................... 100
8 Trabalho em Equipe, Planejamento e Organização do Trabalho............................................................... 111

8.1 Comportamento e equipes de trabalho........................................................................................... 112
8.1.1 O homem como ser social................................................................................................... 112
8.1.2 O papel das normas de convivência em grupos sociais........................................... 113
8.1.3 A influência do ambiente de trabalho no comportamento.................................... 114
8.1.4 Fatores de satisfação no trabalho..................................................................................... 115
8.1.5 Relacionamento interpessoal............................................................................................. 116
8.1.6 Planejamento e organização no local de trabalho..................................................... 117
8.2 Ética................................................................................................................................................................ 119
8.2.1 Ética no Ambiente de trabalho.......................................................................................... 120
8.3 Qualidade..................................................................................................................................................... 121
8.3.1 Qualidade total........................................................................................................................ 123
8.4 Pesquisa........................................................................................................................................................ 124
8.4.1 Tipos de Pesquisa.................................................................................................................... 124
8.4.2 Estruturação e Métodos de Pesquisa............................................................................... 125
9 Segurança no Trabalho............................................................................................................................................. 129

9.1 Acidentes de trabalho............................................................................................................................. 130
9.1.1 Tipo de Acidentes de trabalho........................................................................................... 130
9.1.2 Causas dos acidentes de trabalho.................................................................................... 132
9.1.3 Riscos de acidentes................................................................................................................ 136
9.1.4 Equipamentos de proteção individual e coletiva........................................................ 137
9.1.5 Orientações de prevenção de acidentes........................................................................ 141
Referências......................................................................................................................................................................... 148
Minicurrículo do autor................................................................................................................................................... 150
Índice .................................................................................................................................................................................. 152

Introdução
Em um mundo globalmente conectado, possuir conhecimentos específicos em tecnologia

da informação podem aumentar as opções no mercado de trabalho. A utilização das redes
locais cabeadas e sem fio vem crescendo consideravelmente e, com isso, a demanda por pro-
fissionais com conhecimentos para lidar com estes cenários também aumenta. Esta Unidade
Curricular vai tratar de conceitos essenciais para funcionamento adequado de uma rede local,
demonstrando os papéis dos dispositivos e as diferenças entre infraestrutura física e lógica de
redes. Ao longo dos capítulos, serão estudados protocolos essenciais para o funcionamento de
uma rede local, conceitos básicos de arquitetura de redes LAN e WLAN, tipos de endereçamen-
to de redes, dispositivos de rede e técnicas básicas de resolução de problemas.
Conceitos Básicos
Para iniciar os estudos sobre lógica de programação, é importante que você compreenda
alguns conceitos básicos que norteiam este aprendizado. Para tanto, você irá começar com-
preendendo o significado e a aplicação de lógica. Na sequência, é apresentado o conceito de
lógica de programação, assim como as suas principais formas de representação.
Ao final deste capítulo, você terá subsídios para:
a) utilizar técnicas de abstração para resolução de problemas;
b) interpretar a simbologia das representações gráficas para definição do fluxo do algoritmo.
LÓGICA DE PROGRAMAÇÃO
14
2.1 LÓGICA
O filósofo Copi (1978) define que “o estudo da lógica é o estudo dos métodos e princípios usados para
distinguir o raciocínio correto do incorreto”. Em outras palavras, pode-se dizer que a lógica consiste em
utilizar de princípios e conhecimentos a fim de buscar atingir um raciocínio correto.
Carlos André M. A. (2018)
A lógica é um conhecimento que todos possuem e que todos utilizam no seu dia a dia. Este conceito é
necessário para formular uma sequência de raciocínio que permita a você utilizar de premissas e informa-
ções para ser possível obter uma conclusão.
No argumento a seguir, você tem as duas premissas inicias (a) e (b), que servem como evidências que
sustentam a conclusão (c).
a) Florianópolis pertence ao estado de Santa Catarina.
b) Santa Catarina é uma unidade federativa do Brasil.
c) Logo, Florianópolis pertence ao Brasil.
O filósofo Copi (1978) define que um raciocínio lógico falho pode levar a uma conclusão incorreta, caso
forem feitas interpretações errôneas das evidências.
A utilização de raciocínio lógico é algo tão trivial e natural para o ser humano que estamos constante-
mente utilizando esse artificio, porém, na maioria das vezes, não percebemos. Como exemplo, pense nos
passos necessários para passar por uma porta que se encontra trancada, para tanto, pode-se executar a
seguinte sequência:
2 CONCEITOS BÁSICOS
15
a) colocar a chave na fechadura;

b) girar a chave no sentido anti-horário para destrancar a porta;
c) retirar a chave da fechadura;
d) girar a maçaneta;
e) puxar a porta para abri-la;
f) passar pela entrada;
g) puxar a porta novamente para fecha-la;
h) colocar novamente a chave na fechadura;
i) girar a chave no sentido horário para trancar a porta;
j) retirar a chave da fechadura.
Essa sequência de passos envolve um raciocínio lógico que pode ser executado para passar por uma
porta trancada, um procedimento comum, realizado no seu dia a dia, porém, provavelmente, nunca anali-
sado desse ponto de vista.
Esse é um exemplo simples de uma atividade que envolve raciocínio lógico, porém, sabe-se que todas
as atividades envolvem a lógica, portanto, busque perceber as sequências lógicas que são executadas no
seu dia a dia, desde atividades como tomar banho e escovar os dentes até atividades como pegar um ôni-
bus ou dirigir um carro.
O intuito deste subcapítulo foi mostrar que todos conhecem e trabalham os conceitos de lógica,
o que é extremamente necessário para a codificação de códigos a serem desenvolvidos utilizando
Lógica de Programação.
No século passado, Albert Einstein desenvolveu um teste de raciocínio lógico e afir-

CURIOSI mou que 98% das pessoas NÃO são capazes de resolvê-lo. Esse teste é conhecido
DADES pelo nome Teste de Einstein e está disponível em <https://rachacuca.com.br/teste-
-de-einstein/>, será que você consegue resolvê-lo?
Confira, na sequência, um “Casos e relatos” que trata da importância de seguir uma sequência lógica
para resolução de problemas.
16
CASOS E RELATOS
Trocando o pneu
Um motorista dirigia solitário, quando percebeu que o pneu do seu carro estava furado e que
precisava encostar para realizar a troca. Sem pensar duas vezes, seguiu o seu instinto e, antes de
qualquer coisa, montou e posicionou o triângulo a fim de sinalização. Na sequência, observou o
pneu que estava furado, montou o macaco e levantou o carro. Na etapa seguinte, o motorista se
deparou com um problema: ao posicionar a chave de roda e colocar força para desparafusar a
roda, percebeu que ela começou a girar, não permitindo afrouxar o parafuso. Neste momento,
percebeu que algo estava errado, e que precisaria repensar os seus passos até aquele ponto. Foi
quando percebeu que a sequência lógica aplicada para a resolução deste problema estava resul-
tando em uma conclusão incorreta e que precisaria retornar algumas etapas. Neste momento,
desceu o carro novamente e aí sim conseguiu desparafusar as rodas, na sequência, levantou o
carro novamente, trocou a roda, e como já havia aprendido com a situação anterior, desceu o car-
ro para posteriormente parafusar a roda novamente. Neste contexto, é possível observar que um
passo errado dentro da sequência lógica levou a uma conclusão falha, sendo necessário refazer o
trabalho para atingir uma conclusão correta.
A seguir, você irá entender como surgiu a lógica de programação. Acompanhe!
2.2 LÓGICA DE PROGRAMAÇÃO
A lógica de programação surgiu a partir dos princípios da lógica e consiste em uma técnica de encadear
pensamento para atingir um determinado objetivo. Para tanto, é necessário utilizar de sequência lógica,
que é um conjunto de passos a serem executados para atingir um objetivo ou a solução de um problema.
Quando se fala em sequência lógica, está se falando de algoritmos. Um algoritmo é representado por
uma sequência de instruções que resolve uma determinada tarefa, de forma que, estas instruções indicam
as ações a serem executadas. É importante ter a ciência de que um algoritmo não representa a solução de
um problema, mas sim um conjunto de passos que representam a solução de um pequeno problema.
Todo algoritmo segue um princípio básico de execução que consistem em entrada, processamento e
saída. Para a resolução de um algoritmo, inicialmente, devem ser observadas quais são as entradas deste
algoritmo. Após isto, é possível realizar o processamento tendo como base as entradas obtidas para, ao
término, apresentar o resultado obtido como a saída do problema.
17
Carlos André
M. A. (2018)
Entrada Processamento Saída
Figura 1 - Processo de execução de um algoritmo

Fonte: Fonte: Do autor (2018)
Para exemplificar, tem-se como exemplo um problema em que serão obtidas as três notas de um aluno,
para na sequência informar se o aluno foi aprovado, ficou em exame ou foi reprovado, com base na média
final. Para a resolução deste problema, serão necessários dois algoritmos, sendo que cada um resolverá um
pequeno problema desta situação.
O primeiro algoritmo consiste em calcular a média do aluno. Para tanto, você tem como entrada as três
notas obtidas durante o semestre; como processamento, o cálculo da média, realizando a soma das três
notas do aluno para posteriormente realizar a divisão por três; por fim, a saída será a média obtida por este
aluno.
O segundo algoritmo consiste em verificar a situação final do aluno. Para tanto, a entrada deste algo-
ritmo será a média obtida com o primeiro algoritmo; o processamento será a verificação desta média para
descobrir se foi maior ou igual a sete, menor que sete e maior ou igual a cinco, ou menor que cinco; com
essa verificação, é possível definir a saída deste algoritmo, informando se o aluno foi aprovado, ficou em
exame ou foi reprovado.
2.3 FORMAS DE REPRESENTAÇÃO
Você aprendeu sobre o que é lógica e lógica de programação, e que um programa é formado por um ou
mais algoritmos, os quais representam uma sequência lógica de passos que levam a resolução de um de-
terminado problema. Para realizar a representação destes algoritmos, existem três formas tradicionais que
são utilizadas, umas para fins mais didáticos e outras para representações mais próximas da linguagem de
programação. Acompanhe cada uma delas a seguir.
2.3.1 DESCRIÇÃO NARRATIVA
De todas as formas de representação, esta é estritamente utilizada para fins didáticos, possibilitando
um primeiro contato com a elaboração de um algoritmo. Para tanto, utiliza linguagem natural para expres-
sar os algoritmos, permitindo a definição da sequência lógica, passo a passo, em busca da resolução de um
determinado problema.
18
No exemplo descrito anteriormente, em que foi desenvolvido um algoritmo para passar por uma porta
trancada, foi utilizada a descrição narrativa para a elaboração do algoritmo. Uma das vantagens da utiliza-
ção dessa forma de representação é que fica aberto para que sejam utilizados mais ou menos detalhes a
fim de resolver o algoritmo. Enquanto uma das desvantagens é que nesse formato é dada uma oportuni-
dade para más interpretações, justamente pelo fato de ser utilizada a linguagem natural.
Para exemplificar, serão apresentados dois algoritmos utilizando descrição narrativa. O primeiro repre-
senta os passos para realizar a troca de uma lâmpada, os quais são descritos a seguir:
a) desligar o interruptor;
b) pegar uma escada;
c) posicionar a escada embaixo da lâmpada;
d) buscar uma lâmpada nova;
e) subir na escada;
f) retirar a lâmpada antiga;
g) colocar a lâmpada nova;
h) descer da escada;
i) guardar a escada;
j) ligar o interruptor.
Esse algoritmo representa uma das formas de realizar a troca de uma lâmpada, porém, inúmeros outros
algoritmos poderiam ser desenvolvidos. Por exemplo, um algoritmo poderia entrar em mais detalhes, adi-
cionando novos passos entre a etapa de retirar a lâmpada antiga e colocar a lâmpada nova, especificando
para qual lado deverá girar a lâmpada.
O segundo exemplo apresenta um algoritmo um pouco mais complexo, para a partir das quatro notas
de um aluno, calcular a média e informar se o aluno está aprovado ou não, para tanto, será necessário adi-
cionar uma tomada de decisão para tornar possível a obtenção desta saída.
19
a) obter as quatro notas do aluno;

b) somar as quatro notas obtidas;
c) dividir o resultado da adição por quatro;
d) se a média obtida for maior ou igual a 7 (sete),
o aluno foi aprovado; caso contrário, o aluno foi reprovado.
Você pode observar que este algoritmo envolve uma complexidade maior que o anterior, pois é preciso
decidir com base no cálculo da média se o aluno está aprovado ou reprovado.
FIQUE A ordem de execução do algoritmo é muito importante para a sua conclusão final.
Para todos os algoritmos aqui apresentados, se em alguns casos for alterada a sequ-
ALERTA ência lógica de execução, o resultado obtido passaria a estar incorreto.
Na sequência, você compreenderá como definir os algoritmos utilizando uma forma de representação
com maior proximidade de como é a realidade perante a lógica de programação.
2.3.2 FLUXOGRAMAS
Esta forma de representação é feita a partir de figuras geométricas, as quais descrevem diferentes ações
a serem realizadas durante a execução do algoritmo. Por serem utilizadas figuras geométricas, esta é uma
forma de representação considerada universal.
O fluxograma auxilia na elaboração do raciocínio lógico a ser seguido para a resolução de um proble-
ma. Por utilizar uma representação gráfica, ajuda a visualizar melhor um processo, compreendê-lo mais
facilmente e encontrar falhas ou problemas de eficiência. Toda a execução do algoritmo segue as setas de
fluxo, que por ser a representação de um algoritmo, deve seguir apenas um caminho, obedecendo uma
sequência lógica, salvo quando existe a divisão do algoritmo por conta de um processo de decisão.
20
Processo Início / Fim
Entrada Setas de Fluxo

Leitura
Escrita
Figura 2 - Figuras geométricas para representação de fluxogramas

Fonte: Do autor (2018)
Veja as figuras geométricas que você tem para realizar a representação de algoritmo com fluxogramas.
a) Início/Fim: todo fluxograma deve iniciar e encerrar com este símbolo. O fluxograma deve conter
apenas um início, porém, poderá possuir mais de um fim, pois pode se dividir durante o processo.
b) Leitura: representa uma entrada do usuário, quando o programa fará uma leitura de uma informa-
ção digitada pelo usuário.
c) Escrita: representa a impressão de alguma informação na tela pelo programa, a fim de informar algo
ao usuário.
d) Setas de Fluxo: representam o caminho do fluxograma, a partir do início. A leitura do fluxograma é
feita seguindo as setas de fluxo.
e) Processo: utilizado quando algo deve ser processado pelo programa, por exemplo, para cálculos
matemáticos.
f) Decisão: divide a execução do fluxograma em dois caminhos. Sempre que for utilizado, uma pergun-
ta deve ser feita, caso a resposta for verdadeira o fluxograma segue por um caminho, caso contrário
segue por outro. Esta é a única situação em que devem ser utilizadas duas setas de fluxo a partir de
uma figura geométrica.
Para uma exemplificação simples, a figura a seguir apresenta um fluxograma que solicita três notas,
calcula e apresenta a média.
21
Início
Informe a
primeira nota:
Fim
nota1
Informe a media
segunda nota:
media =
nota2 (nota1+nota2+nota3)/3

Informe a nota3
terceira nota:
Figura 3 - Fluxograma para apresentar a média de três notas

Analisando o diagrama, após o início você tem a solicitação das três notas do aluno, para tanto, é uti-
lizada a escrita para apresentar ao usuário que este deve informar a nota, na sequência de cada escrita é
feita a leitura da nota informada. Para as leituras, utiliza-se um nome genérico, como nota1, nota2 e nota3.
Isso acontece porque a ideia do fluxograma é poder ser executado para qualquer situação que se adeque
a este problema, portanto, se utilizar valores fixos, se adequaria apenas aquela situação. Após a solicitação
das três notas, é realizado um processo para calcular a média, e o resultado é considerado o nome genérico
“média”, por fim, escreve-se para o usuário a média calculada e finaliza o fluxograma.
Para testar a execução do fluxograma, você pode simular passo a passo, a fim de identificar se o resulta-
do final estará correto ou não. Para tanto, pode-se seguir os passos abaixo:
22
Informe a primeira nota:

10
Informe a segunda nota:
9
Informe a terceira nota:
5
[media = (10+9+5)/3]
8
Utilizando os valores apresentados anteriormente, o fluxograma calculou e apresentou a média final do

aluno como sendo 8 (oito).
Para exemplificar um algoritmo um pouco mais complexo, além de calcular a média, o fluxograma
também apresentará ao aluno se ele foi aprovado ou reprovado, para tanto, considerará a média 7 (sete)
para aprovação.
Início
Reprovado Fim
Informe a Não
primeira nota:
A média é Sim
maior ou igual Aprovado
a 7?
nota1
Informe a media
segunda nota:
media =
nota2 (nota1+nota2+nota3)/3
Informe a nota3
terceira nota:
Figura 4 - Fluxograma para indicar a aprovação ou reprovação de um aluno

23
Neste exemplo, foi inserida uma decisão após o cálculo e apresentação da média do aluno. Como para
toda decisão precisamos ter uma pergunta, nesta situação, a pergunta foi “A média é maior ou igual a 7?”,
caso a resposta for sim, seguirá a seta de fluxo que irá imprimir para o usuário a palavra Aprovado, caso
contrário, seguirá o caminho que irá imprimir a palavra Reprovado. Por fim, pode-se observar que, indife-
rentemente de qual caminho o fluxograma seguir, ele irá parar na figura que representa o fim.
Portanto, o fluxograma é uma forma simplificada de observarmos a execução de um ou mais algoritmos
e recomenda-se a sua utilização quando for necessário analisar o fluxo de um algoritmo de forma mais
visual.
2.3.3 PSEUDOCÓDIGO
É uma forma de representação de algoritmo que mantém uma proximidade entre uma linguagem de
programação e a linguagem natural. Assim como o fluxograma, o pseudocódigo auxilia na elaboração do
raciocínio lógico a ser seguido para a resolução de um problema, porém, ao invés de utilizar figuras geo-
métricas para esta representação, utiliza uma linguagem estruturada, que pode ser escrita em qualquer
idioma.
Segundo Puga e Rissetti (2009), a palavra pseudocódigo significa “falso código”, e isso se deve a pro-
ximidade entre um programa escrito em pseudocódigo e um programa escrito em linguagem de progra-
mação.
O pseudocódigo é representado por três etapas, a identificação do algoritmo, a declaração das variáveis
e o corpo do algoritmo, o qual contém a sequência lógica para a resolução deste. Na sequência, você tem
um exemplo do programa que realiza o cálculo da média e apresenta se o aluno está aprovado ou não, o
qual foi representado por fluxograma anteriormente, utilizando pseudocódigo.
24
1. algoritmo CalcularMedia
2. var
3. nota1, nota2, nota3, media : real
4.
5. início
6. escrever (“Digite a primeira nota:”)
7. ler (nota1)
8. escrever (“Digite a segunda nota:”)
9. ler (nota2)
10. escrever (“Digite a terceira nota:”)
11. ler (nota3)
12. media <- (nota1+nota2+nota3)/3
13. escrever (media)
14. se media >= 7 então
15. escrever (“Aprovado”)
16. senão
17. escrever (“Reprovado”)
18. fimse
19. fim.
Como é possível observar, esse algoritmo escrito em pseudocódigo permite uma fácil interpretação por
se aproximar muito da linguagem natural. Na linha 1, você tem a etapa de identificação do algoritmo, que
define o nome “CalcularMedia” para o algoritmo. Nas linhas 2 e 3, tem a etapa de declaração das variáveis,
que define as variáveis nota1, nota2, nota3 e média com o tipo real, ou seja, estes nomes genéricos podem
ter números com vírgulas relacionados a eles. Por fim, é definido o corpo do algoritmo entre as linhas 5
e 19, onde são solicitadas as três notas do aluno, entre as linhas 6 e 11, é realizado o cálculo da média, na
linha 12, e, entre as linhas 14 e 18, é realizada a decisão, que definirá se o aluno está aprovado ou não com
base na verificação se a média é maior ou igual a 7 (sete).
25
Portanto, o pseudocódigo já nos aproxima da linguagem de programação, porém, não é possível de-
senvolver programas utilizando essa forma de representação. É recomendável a sua utilização para fins
de análise e elaboração de algoritmos, por facilitar a compreensão, assim como para a documentação de
algoritmos, por se tratar de uma linguagem universal e próxima da linguagem natural.
2.4 LINGUAGEM DE PROGRAMAÇÃO
As linguagens de programação existem para facilitar a comunicação entre os programadores e o com-

putador. O processamento de um computador funciona por intermédio de números binários, ou seja, um
computador apenas compreende os números 0 e 1. Uma das primeiras formas de programação era deno-
minada Cartão Perfurado, criado no século XX, que trabalhava basicamente com a presença e ausência de
furos, representando os números binários.
Com o tempo, as linguagens de programação foram sendo aprimoradas, facilitando a interação entre o
humano e o computador. Hoje, não existem mais linguagens que necessitam da programação em núme-
ros binários, porém, as linguagens de programação são divididas em duas: as de baixo nível, que consistem
em linguagens mais próximas da linguagem de máquina, e ao mesmo tempo mais complexas, porém com
uma melhor performance; e as de alto nível, que são linguagens mais próximas da linguagem natural, sim-
plificando o desenvolvimento de algoritmos, as quais são largamente utilizadas nos dias de hoje.
No decorrer deste livro, será dado ênfase nas linguagens de alto nível, justamente por serem muito mais
utilizadas que as de baixo nível. Para tanto, é preciso compreender que existem duas formas de execução
de um algoritmo desenvolvido em linguagem de programação, as quais são chamadas de linguagem in-
terpretada e compilada, e em ambas acontece a tradução da linguagem de alto nível para a linguagem de
máquina, porém de formas diferentes.
As linguagens de programação interpretadas executam o código do programa à medida que este vai
sendo traduzido, o que torna a sua execução mais flexível, pois podem interagir com o ambiente mais fa-
cilmente. Como exemplos de linguagens de programação interpretadas temos JavaScript e Python.
As linguagens de programação compiladas, primeiramente, traduzem todo o código do programa para
apenas depois executar. Para tanto, é necessário a existência de um compilador, o qual é responsável pela
realização desta tradução para a linguagem de máquina. Com isso, ao realizar a compilação de um progra-
ma, ele pode ser executado infinitas vezes, sem a necessidade de refazer esse processo de compilação, pois
o código compilado é armazenado para futuras execuções. Portanto, toda linguagem compilada necessita
da existência de um compilador específico para a linguagem de programação em questão, e alguns exem-
plos de linguagens compiladas são Java, C++ e C#.
26
Outro conceito sobre o qual é importante você ter o conhecimento é referente a linguagens de progra-
mação. Existem, basicamente, dois tipos de linguagens, as Estruturadas e as Orientadas a Objetos. Uma lin-
guagem de programação estrutura trabalha com apenas um arquivo, codificando o algoritmo linha após
linha, seguindo uma sequência lógica de evento. Esse é o tipo de programação que você aprenderá nesta
Unidade Curricular, por ser a forma mais simples de ingressar nos conceitos de programação.
O artigo da Oficina da Net apresenta uma abordagem bem interessante sobre a dife-
SAIBA rença entre a programação estruturada e a programação orientada a objetos. Realize
a leitura do artigo para aplicar o seu conhecimento sobre este assunto. Disponível em:
MAIS <https://www.oficinadanet.com.br/post/14463-qual-a-diferenca-entre-programacao-
-estruturada-e-programacao-orientada-a-objetos>.
Você chegou ao final deste capítulo. Reveja os principais pontos estudados aqui lendo o “Recapitulando” a seguir.
RECAPITULANDO
Neste capítulo, você compreendeu o quão trivial é a utilização da lógica e compreendeu os con-
ceitos referentes à lógica de programação, a qual tem como base o conceito de algoritmo, que é
representado por uma sequência lógica de passos para nos levar a resolução de um determinado
problema. Além disso, você também conheceu as três principais formas de representação de algo-
ritmo e aprendeu como utilizar cada uma delas.
Tipos de Dados
e Operadores
Para iniciar o aprendizado dos conceitos que norteiam o conteúdo de lógica de programa-
ção, primeiramente, você deve compreender os tipos de dados que existem em uma linguagem
de programação e os quatro operadores básicos para o desenvolvimento de um algoritmo, que
consistem em aritméticos, atribuição, relacionais e lógicos.
Ao término deste capítulo, você será de capaz de:
a) utilizar expressões aritméticas, relacionais e lógicos para codificação do algoritmo;
b) identificar estruturas de dados para construção de algoritmos;
c) utilizar padrões de nomenclatura e convenções de linguagem na codificação de algoritmos.
30
3.1 VARIÁVEIS
Quando você realiza o desenvolvimento de algoritmos, é necessário armazenar dados e informações

para posterior utilização. Por exemplo, se você for implementar um algoritmo para solicitar dois números
para, na sequência, apresentar a soma entre eles, será necessário primeiramente solicitar o valor do pri-
meiro número e armazenar esse dado em algum lugar. Depois, será solicitado o valor do segundo número,
também sendo necessário armazenar essa informação para utilização futura. Por fim, será preciso recu-
perar as duas informações armazenadas anteriormente, que consistem nos dois números, para conseguir
realizar a soma entre eles.
Para realizar o armazenamento dessas informações, utiliza-se de variáveis. Você pode observar uma
variável como uma informação que será armazenada na memória RAM do computador, assim, será possí-
vel recuperar esse dado posteriormente.
Toda variável é composta por três informações bases: um identificador, um valor e um tipo de dado.
O identificador é o nome que definirá a variável, o qual será chamado quando você quiser recuperar
o dado. É uma boa prática, e uma questão importante para a produtividade, que você utilize nomes que
correspondam com o objetivo da criação da variável. Por exemplo, se for criada uma variável para definir o
nome de uma pessoa, um bom identificador para essa variável seria a palavra “nome”.
Algumas regras devem ser seguidas na hora de definir o nome de uma variável, obedecendo os carac-
teres válidos para a maioria das linguagens de programação, que são:
a) palavras: palavras com letras maiúsculas ou minúsculas, sem espaço e sem acento;
b) números: podem ser utilizados desde que apareçam após uma ou mais letras;
c) underline (_) e cifrão ($): são considerados caracteres válidos e são aceitos em qualquer local do
identificador. Esses caracteres não são muito utilizados, porém, algumas poucas linguagens utilizam
o underline para identificar variáveis que tenham espaço no nome.
Existem alguns nomes que não são aceitos como identificadores de variáveis pela grande parte das lin-
guagens de programação, pelo motivo que são considerados palavras reservadas da linguagem, ou seja,
identificam outras operações já definidas pela linguagem de programação. Portanto, as palavras reserva-
das dependem diretamente da linguagem de programação, não existindo uma tabela padrão para definir
todas as existentes, então, quando você definir a sua linguagem, pode pesquisar pelas palavras reservadas
para não cometer esse erro.
Existe uma convenção mundialmente seguida que define padrões para a declaração
de variáveis, a qual define que o identificador de uma variável sempre deve iniciar
com letra minúscula, e caso o identificador seja formado por mais de uma palavra,
deve-se escrever tudo junto, com a primeira palavra toda em minúsculo, e, a par-
CURIOSI tir da segunda palavra, iniciar com a primeira letra em maiúsculo. Seguem alguns
exemplos:
DADES
nome
nomeCompleto
valorDescontoCedido
3 TIPOS DE DADOS E OPERADORES
31
Além do identificador, uma variável também possui um tipo de dado. Mesmo que existam linguagens
de programação que possuam variáveis tipadas e não tipadas, de alguma forma uma variável é definida
por um tipo de dado, que representa que tipo de informação que poderá ser armazenada nesta variável.
O terceiro e último conceito que compõe uma variável é o seu valor, o qual deverá ser de acordo com
o seu tipo de dado. O valor sempre será a informação que você deseja guardar, a qual possuirá um tipo
específico de dado e um identificador para auxiliar você na recuperação deste dado.
Existem linguagens de programação tipadas e não tipadas. A diferença entre elas é

que as variáveis tipadas são inicializadas com a identificação de qual o seu tipo de
dado, e a partir deste momento, essa variável apenas poderá receber valor que corres-
pondam ao seu tipo de dado.
SAIBA As variáveis não tipadas, por sua vez, tornam desnecessária a definição do tipo de
MAIS dado na inicialização da variável, podendo definir valores de diferentes tipos para uma
mesma variável durante o algoritmo.
Como exemplos de linguagens de programação com variáveis tipadas temos Java, C++
e C#. E como linguagens não tipadas temos JavaScript e PHP.
Além de saber o conceito sobre variáveis, e como definir uma variável, você também deve compreen-
der que existem dois tipos de variáveis que podem ser declaradas, as quais são denominadas variáveis
globais e variáveis locais.
Uma variável global consiste em uma variável declarada, de forma que todo o código poderá acessá-la,
ou seja, se for de interesse definir uma variável que possa ser acessada a qualquer momento, em qualquer
parte do código, é importante que ela seja global.
A variável local possui um acesso mais restrito. Ela é sempre declarada dentro de um bloco de código
específico, o qual pode pertencer a uma estrutura de controle ou um procedimento. Portanto, antes de op-
tar por criar uma variável com visibilidade local, é importante que você tenha certeza que esta variável não
precisará ser acessada a qualquer momento, em qualquer parte do código, mas sim que ela seja necessária
apenas para um pequeno processamento pertencente a um mesmo bloco de código.
Agora que você já conhece o conceito de variável, siga adiante para compreender quais são os tipos de
dados que existem.
3.2 CONSTANTES
São consideradas variáveis, porém, trabalham com valores fixos, imutáveis, que devem ser definidos
no início do algoritmo e não podem ter seus valores alterados durante a execução do algoritmo. Seguem
alguns exemplos clássicos de constantes:
32
PI <- 3.14159265359
MESES <- 12
POLEGADA <- 2.54
Por padrão de nomenclatura, todas as constantes devem ser definidas utilizando apenas letras maiúsculas.
3.3 TIPOS DE DADOS
Agora que você compreendeu o que é uma variável, é hora de conhecer os tipos de dados existentes.
Cada linguagem de programação possui os seus tipos de dados, porém, a maioria das linguagens segue
uma padronização quanto aos nomes. Todos os tipos de dados primitivos possuem como base quatro
tipos, que são:
a) inteiro: tipo numérico que define números inteiros negativos e positivos;
b) real: tipo numérico que define números decimais com vírgula negativos e positivos;
c) lógico: tipo de dado que aceita apenas dois valores, verdadeiro (1) ou falso (0);
d) literal: tipo de dado que define cadeias de caracteres, aceitando letras, números e símbolos.
FIQUE Toda variável criada ocupará um espaço de memória, portanto, todo desenvolvi-
mento deve considerar a otimização e melhor utilização das variáveis, a fim de evitar
ALERTA uma grande quantidade de memória utilizada para um simples algoritmo.
Agora que você já conheceu os tipos de dados, na sequência irá estudar os operadores. Acompanhe!
3.4 OPERADORES
Os operadores estão disponíveis em todas as linguagens de programação para representar expressões

de cálculo, comparação, condição e expressão. Eles são divididos em quatro tipos principais: de atribuição,
aritméticos, relacionais e lógicos.
33
3.4.1 OPERADORES DE ATRIBUIÇÃO
Considerado um dos mais simples, este tipo de operador é responsável por simplesmente atribuir
um valor para uma variável, podendo este valor ser definido pelo desenvolvedor ou resultante de um
processamento.
Na pseudolinguagem, este operador é representado pelo símbolo “<-“, porém, também é aceito a utili-
zação do símbolo “:=” como um operador de atribuição.
Para exemplificar, parta do princípio que você possui as variáveis numero1 e numero2 do tipo inteiro,
e deseja atribuir os números 5 e 7, respectivamente, para estas variáveis. Para tanto, o código para esta
operação de atribuição seria o seguinte.
v1 <- 5
v2 <- 7
Este algoritmo pode ser lido como uma atribuição do número 5 à variável v1, assim como, está atribuin-
do o número 7 à variável v2. Com isso, você também consegue reforçar o conhecimento adquirido ante-
riormente sobre variáveis. Com base nesse algoritmo, temos as variáveis v1 e v2 que identificam posições
na memória onde os números 5 e 7 estão armazenados.
Um outro exemplo que também é válido na pseudolinguagem, conforme mencionado anteriormente,
é o código apresentado a seguir, que utiliza o operador “:=” para representar a atribuição:
v1 := 5
v1 := 7
Agora que você já conhece o operador de atribuição, que tal continuar a leitura para conhecer os de-
mais operadores?
34
3.4.2 OPERADORES ARITMÉTICOS
Estes operadores são utilizados para representar os cálculos matemáticos mais clássicos, tendo como
base cinco operações: adição, subtração, multiplicação, divisão e módulo. A tabela a seguir apresenta os
operadores, com seus símbolos e exemplos.
OPERADOR SÍMBOLO EXEMPLO

Adição + 2+2
Subtração - 2–2
Multiplicação * 2*2
Divisão de inteiro DIV 2 DIV 2
Divisão de real / 2/2
Módulo MOD 4%3
Tabela 1 - Operadores
O operador de adição representa a clássica soma matemática e é representado pelo símbolo “+”. Um
exemplo de operação de soma atribuindo o resultado para uma variável é apresentado a seguir:
soma1 <- 5 + 10
soma2 <- 10 + 15 + 20
Com base nessas operações, a variável soma1 receberá o resultado da adição representada pela expres-
são “5 + 10”, o qual será 15, enquanto a variável soma2 receberá o resultado da adição representada pela
expressão “10 + 15 + 20”, o qual resultará em 45.
O operador de subtração representa a operação matemática conhecida como menos, a qual irá calcular
o resultado de um número menos o outro. Um exemplo dessa operação atribuindo o resultado para uma
variável é apresentado a seguir:
subtracao <- 10 – 3
Nesse caso, a variável denominada subtração irá receber o resultado da expressão “10 – 3”, a qual resul-
tará em 7.
35
O operador de multiplicação é responsável por calcular o resultado referente à multiplicação entre dois
números. Um exemplo dessa operação atribuindo o resultado para uma variável é apresentado a seguir:
multiplicacao <- 10 * 4
Nesse caso, a variável denominada multiplicação irá receber o resultado da expressão “10 * 4”, a qual
resultará em 40.
O operador de divisão possui duas variações quando utilizado em pseudolinguagem, um represen-
tado por DIV e o outro pelo símbolo da divisão “/”. A diferença entre eles é que o DIV consiste na divisão
de números inteiros, ou seja, o resultado consiste apenas no quociente da divisão, enquanto a divisão
representada pelo símbolo “/” resulta em um valor real, que consiste na razão da divisão, ou seja, um valor
numérico com vírgula.
A fim de exemplificar a utilização do operador DIV, será apresentado um exemplo para realizar a divisão
entre dois números inteiros e armazenar o resultado em uma variável do tipo inteiro.
divisao1 = 36 div 4
Nesse caso, você pode observar uma divisão exata tendo o 36 como dividendo e o 4 como divisor, re-
sultando em 9. No próximo exemplo, você verá uma divisão para a qual teria um resto caso a divisão não
fosse realizada entre números inteiros.
divisao2 = 35 div 4
O resultado desta divisão entre números inteiros será 8, pois conforme mencionado anteriormente, o
operador DIV trabalha apenas como quociente da divisão.
O operador “/” retorna a razão da divisão, portanto, o resultado deve ser atribuído a uma variável do
tipo real, pois será retornado um valor com casas decimais. Como exemplo, serão realizadas duas opera-
ções de divisão que atribuirão o resultado para variáveis do tipo real.
36
divisao3 <- 36 / 4
divisao4 <- 35 / 4
No primeiro exemplo, o dividendo consiste no número 36 e o divisor no número 4, com isso, o resul-
tado desta operação será o número 9 atribuído ao tipo de dado real. Já no segundo exemplo, você pode
identificar como dividendo o valor 35 e como divisor o valor 4, portanto, o resultado será um número real,
considerando a razão da divisão, que será atribuída a variável divisao4.
O último operador aritmético que você verá é denominado MOD, o qual é responsável por retornar o
resto de uma divisão. O tipo de dado referente a variável que recebe o resultado a partir de uma operação
de módulo pode ser tanto inteiro quanto real. No exemplo a seguir, a variável resto receberá o valor refe-
rente ao resto da divisão entre os dois números.
resto <- 35 MOD 4
Neste caso, o resultado atribuído a variável resto será 3. Muitas vezes surge o questionamento de por-
que o resultado ser 3. Isso acontece com base no cálculo da divisão do valor 35 por 4, como o resultado não
consiste em uma divisão exata, esta divisão ficará com um resto de 3, o qual será retornado pelo operador
módulo. Veja um exemplo da divisão.
35 4
-32 8
3
Nesse exemplo, foi divido o valor 35 por 4. Como não é possível realizar uma divisão exata, busca-se
o primeiro valor abaixo de 35 que seja possível dividir pelo número 4, o qual é 32. Com isso, subtrai-se o
dividendo pelo valor encontrado e chega-se ao valor 3. Como, nesse exemplo, não é possível continuar
dividindo o valor 3 por 4, pois o dividendo é menor que o divisor, tem-se como resto desta divisão, ou
módulo, o número 3.
Quando se realiza uma operação de módulo que tem como dividendo um número
menor que o divisor, o resultado desta operação sempre será o dividendo, veja um
SAIBA exemplo para auxiliar.
MAIS resto <- 4 MOD 5
O resultado desta operação será 4, que corresponde ao valor do dividendo.
37
Para trabalhar com os operadores aritméticos, você sempre deverá se lembrar das regras de priori-
dade da matemática, ou seja, qual operação deve ser feita primeiro. A seguinte ordem de prioridade
deve ser seguida:
a) primeira: parênteses;
b) segunda: módulo, divisão e multiplicação;
c) terceira: adição e subtração.
Primeiro devem ser executadas todas as operações que estiverem dentro dos parênteses, lembrando
que se deve partir dos parênteses mais internos para os mais externos. Na sequência, deverão ser realiza-
dos os cálculos referentes ao módulo, divisão e multiplicação, todos presentes no mesmo nível de priori-
dade, e por fim os cálculos de adição e subtração.
Tendo como base a seguinte expressão, qual seriam as ordens de prioridade?
5 * (3 + 4) + 4
Inicialmente, deverá ser resolvida a adição presente dentro dos parênteses, na sequência a multiplica-
ção e, por fim, a adição. Se você resolver essa operação passo a passo, terá o seguinte:
5 * (3 + 4) + 4
5*7+4
35 + 4
39
E se a expressão que você precisar resolver for a seguinte, 5 * 4 / 2 MOD 6, qual seria a ordem de
prioridade?
Como você deve ter percebido, todas as operações pertencem a mesma classe de prioridade. Nesse
caso, deve-se começar a resolução da esquerda para a direita. A resolução passo a passo dessa expressão
ficará da seguinte forma:
5 * 4 / 2 MOD 6
20 / 2 MOD 6
10 MOD 6
4
Confira a seguir, no “Casos e relatos”, a importância na utilização das prioridades junto aos opera-
dores aritméticos.
38
CASOS E RELATOS
Uma empresa de desenvolvimento de software recebeu uma demanda de uma escola para o de-
senvolvimento de um sistema de gerenciamento escolar, o qual deve, entre as suas funções, regis-
trar as notas dos alunos e realizar o cálculo da média final. Toda a implementação foi realizada de
acordo com as solicitações da escola, porém, na hora dos testes, estava acontecendo uma incon-
sistência na geração das médias, as quais, por algum motivo, geralmente ficavam acima de 10 em
valores absurdos. Após uma profunda análise no código que realiza o cálculo da média, descobriu-
-se que o motivo desse erro consistia na errada utilização das prioridades junto aos operadores
aritméticos, estando o cálculo da seguinte forma:
n1+n2+n3/3
Desta forma, este cálculo primeiro estava dividindo o valor da nota 3 pelo número 3, para pos-
teriormente adicionar os valores referentes as notas 1 e 2, o que estava ocasionando as médias
absurdas. Para solucionar o problema, adicionaram os parênteses nas adições para dar prioridade
a elas e posteriormente dividir, ficando da seguinte forma:
(n1+n2+n3)/3
Após isso, o sistema passou em todos os testes e foi entregue para a escola conforme solicitado.
Agora que você já aprendeu sobre os operadores aritméticos, siga em frente para conhecer os opera-
dores relacionais.
3.4.3 OPERADORES RELACIONAIS
São operadores utilizados para realizar a comparação entre dois valores. Assim como os operadores
aritméticos, estes também possuem como base operadores existentes na matemática, que consistem em:
a) igualdade;
b) diferença;
c) maior que;
d) maior ou igual que;
e) menor que;
f) menor ou igual que.
39
Esses operadores sempre retornarão como resultado um valor lógico, ou seja, verdadeiro ou falso. Se
você observar os seis tipos de operadores, não é possível obter uma resposta diferente de um resultado
lógico, pois ou um valor é maior que o outro ou não é, por exemplo.
A tabela a seguir aponta o nome, símbolo e exemplo referente aos operadores relacionais descritos
anteriormente.
OPERADOR SÍMBOLO EXEMPLO

Igualdade = 5=5
Diferença <> 5 <> 4
Menor que < 4<5
Menor ou igual que <= 5 <= 5
Maior que > 5>4
Maior ou igual que >= 5 >= 5
A igualdade é representada pelo sinal “=”, e pode ser utilizada para verificar a igualdade entre valores de
um mesmo tipo, podendo ser aplicada a todos os tipos de dados. Se você quiser verificar a igualdade entre
dois números, pode utilizar o comando “2 = 2”, que neste caso retornará verdadeiro. Caso os dois valores
a serem comparados não forem iguais, retornará falso. Essa comparação pode acontecer entre valores de
variáveis também, por exemplo “a = b”.
A diferença, representada pelo símbolo “<>”, realiza a comparação inversa ao da igualdade, realizando
a comparação entre dois valores e retornando verdadeiro caso sejam diferentes, e falso, caso sejam iguais.
É possível realizar a verificação entre dois valores literais ou utilizando de variáveis para auxiliar na
comparação.
O operador “menor que”, representado pelo símbolo “<”, representa a verificação se um valor é menor
que o outro. É importante se atentar para o fato de que o retorno será verdadeiro caso o número localizado
à esquerda for menor do que o da direita; caso for maior ou igual ao outro número, então o retorno será
falso. Ao realizar a verificação “4 < 5” você verifica se o número 4, localizado à esquerda da expressão, é
menor que o número 5, localizado à direita. Nesse caso, o retorno da expressão será um valor verdadeiro.
Semelhante ao operador anterior, o operador “menor ou igual que”, definido pelo símbolo “<=”, re-
presenta a verificação considerando também se os números são iguais. Nesse caso, o valor localizado à
esquerda deve ser menor ou igual ao número localizado à direita para retornar verdadeiro, caso contrário,
será retornado falso. Nesse caso, a verificação “5 <= 5” retornará verdadeiro.
Assim como temos os operadores para verificar se um valor é menor que o outro, também temos valo-
res para verificar se um número é maior que outro. Começando pelo operador “Maior que”, o qual é repre-
sentado pelo símbolo “>”, o qual verifica se o valor localizado à esquerda do operador é maior que o valor
localizado à direita, caso seja retornado verdadeiro, senão falso. Se você tiver a seguinte expressão “3 > 4”,
o resultado será falso, pois está verificando se o valor à esquerda, no caso 3, é maior que o valor à direita,
que corresponde a 4, ou seja, o resultado será falso.
40
O operador “maior ou igual que”, representado pelo símbolo “>=” é semelhante ao apresentando ante-
riormente, porém considera também como verdadeiro caso os dois valores sejam iguais. Por exemplo, se
você tiver a expressão “6 >= 6”, estará verificando se o valor à esquerda do operador é maior ou igual ao
operador da direita; nesse caso, são iguais, retornando verdadeiro.
Agora que você já conhece os operadores relacionais, o próximo e último tipo de operador que você
precisa conhecer são os operadores lógicos.
3.4.4 OPERADORES LÓGICOS
Os operadores lógicos são utilizados exclusivamente para a realização de operações entre valores do
tipo lógico, ou seja, verdadeiro ou falso.
Muitas vezes é necessário verificar se mais de uma expressão relacional é verdadeira para dar prosse-
guimento ao código. É nesse ponto que os operadores lógicos entram em ação. São quatro os tipos de
operadores lógicos, denominados por E (AND), OU (OR), XOU (XOR) e NÃO (NOT).
Iniciando pelo operador E, este é utilizado para verificar se um conjunto de valores do tipo lógico são
todos verdadeiros ou não. Para tanto, é utilizada a seguinte tabela verdade, tendo como base a expressão
“a E b”, que representa os resultados obtidos.
AEB
A B RESULTADO
Verdadeiro Verdadeiro Verdadeiro
Verdadeiro Falso Falso
Falso Verdadeiro Falso
Falso Falso Falso
Para que você consiga ler esta tabela, inicialmente, é preciso compreender que está utilizando como
base a expressão “a E b”, ou seja, quer verificar se o valor correspondente à variável “a” e o valor correspon-
dente à variável “b” são verdadeiros, caso contrário, deverá retornar falso.
Pela tabela, é possível observar que apenas caso os dois valores forem verdadeiros que o resultado será
verdadeiro. Toda expressão que utilize o operador E segue essa tabela, ou seja, apenas será considerado
verdadeiro se todos forem verdadeiros.
O operador lógico ou tem como objetivo verificar se pelo menos uma das expressões é verdadeira,
ou seja, é preciso que pelo menos a primeira OU a segunda expressão seja verdade. Mantendo a ex-
pressão anterior como base, apenas alterando o operador lógico, você pode analisar a tabela verdade
do operador OU.
41
A OU B
A B RESULTADO
Verdadeiro Verdadeiro Verdadeiro
Verdadeiro Falso Verdadeiro
Falso Verdadeiro Verdadeiro
Falso Falso Falso
Diferentemente do operador E, no caso do operador OU, você possui apenas uma possibilidade de a ex-
pressão retornar falsa, que consiste em quando todas as operações forem falsas. Do contrário, o resultado
será verdadeiro, por ser preciso pelo menos uma das operações retornando verdade.
Outro operador lógico existente é o operador XOU, também conhecido como OU EXCLUSIVO. Para esse
caso, apenas uma das expressões pode ser verdadeira, de forma que ou a primeira ou a segunda expressão
deve ser verdade, caso ambas sejam falsas ou verdadeiras o resultado é considerado falso. A seguir, é apre-
sentada a tabela verdade para o operador XOU.
A XOU B
A B RESULTADO
Verdadeiro Verdadeiro Falso
Verdadeiro Falso Verdadeiro
Falso Verdadeiro Verdadeiro
Falso Falso Falso
Por fim, existe o operador denominado NÃO, também conhecido como negação. Esse é o mais simples
dos operadores lógicos, pois tudo o que faz é negar um valor lógico. Ou seja, ao negar um valor verdadeiro,
você está dizendo que este valor é falso. Assim como, ao negar um valor falso, entende-se que esse valor
é verdadeiro.
Pode-se compreender melhor esse operador ao identificar que ele inverte um valor lógico, conforme
os exemplos a seguir.
a <- nao verdadeiro

b <- nao falso
Nesses casos, as variáveis a e b são do tipo lógico, e no caso da variável a, está sendo atribuída a nega-
ção do valor verdadeiro, ou seja, essa variável receberá o valor falso. Referente à variável b, esta recebe a
negação do valor falso, ou seja, o valor verdadeiro.
42
Assim como os operadores aritméticos, os operadores lógicos também possuem uma ordem de priori-
dade, que consiste no seguinte:
a) NÃO;
b) E;
c) OU.
Lembrando que, caso existam expressões entre parênteses, estas devem ser resolvidas primeiramente,
e, caso existam apenas expressões de um único tipo, vamos supor, operador lógico E, deve-se iniciar a re-
solução da esquerda para a direita.
3.4.5 PRECEDÊNCIA DE OPERADORES
Durante o seu aprendizado sobre os tipos de operadores existentes na lógica de programação, você
já aprendeu sobre a ordem de precedência dos operadores aritméticos e lógicos. Porém, e se você tiver a
seguinte expressão:
5 + 5 < 10 * (17 – 15) E NÃO 4 > 3 E 5 <> 4 OU 7 MOD 3 < 8 DIV 3
Nesse caso, é possível verificar que existem três tipos de operadores em uma única expressão. Para tan-
to, é preciso seguir a ordem de precedência dos operadores para a sua resolução. A seguir, é apresentada
esta ordem:
a) primeira: parênteses;
b) segunda: Multiplicação, Divisão e Módulo;
c) terceira: adição e subtração;
d) quarta: relacionais;
e) quinta: NÃO;
f) sexta: E;
g) sétima: OU.
Portanto, a sequência de resolução da expressão indicada anteriormente será a seguinte:
5 + 5 < 10 * (17 – 15) E NÃO 4 > 3 E 5 <> 4 OU 7 MOD 3 < 8 DIV 3
5 + 5 < 10 * 2 E NÃO 4 > 3 E 5 <> 4 OU 7 MOD 3 < 8 DIV 3
10 < 20 E NÃO 4 > 3 E 5 <> 4 OU 1 < 2
verdadeiro E NÃO verdadeiro E verdadeiro OU verdadeiro
verdadeiro E falso E verdadeiro OU verdadeiro
falso E verdadeiro OU verdadeiro
falso OU verdadeiro
VERDADEIRO
Existem alguns pontos importantes a serem observados na resolução desta expressão:

a) no passo 2, foram realizadas todas as operações aritméticas juntas; isso foi possível porque não exis-
tia relação entre elas, caso contrário, seria necessário realizar primeiro uma operação, para posterior-
mente utilizar o resultado em outra, conforme realizado no passo 1;
b) quando chegou nos operadores lógicos, foi necessário realizá-los na ordem de precedência, pois o
resultado é diretamente influenciado por isto;
c) os passos 5 e 6 poderiam ser realizados juntos, pois ambos tratavam do operador E, e você viu na
tabela verdade que este operador precisa que todas as operações sejam verdadeiras, portanto, como
o segundo valor referente a estes operadores é falso, já é possível identificar que o resultado das ope-
rações será falso.
A ordem de precedência dos operadores é um dos conceitos mais comuns de se esquecer no desenvol-
vimento de um algoritmo, portanto, você deve reforçar bem este conteúdo, com o objetivo de lembrar-se
sempre desta ordem.
Você finalizou este capítulo. Relembre os principais conceitos estudados aqui lendo o “Recapitulando”
a seguir.
RECAPITULANDO
Neste capítulo, você compreendeu conceitos fundamentais para o desenvolvimento de algorit-

mos, compreendendo o que significa uma variável e como esta é armazenada na memória do
computador, quais os principais tipos de dados que as linguagens de programação possuem e,
por fim, todos os tipos de operadores existentes, que consistem em operadores de atribuição, arit-
méticos, relacionais e lógicos, assim como as suas ordens de precedência. Agora, que tal iniciar a
aplicação desses conceitos no desenvolvimento de algoritmos? No próximo capítulo, você apren-
derá conceitos básicos sobre a elaboração de um algoritmo. Vamos em frente?
Iniciando com Algoritmos
Agora que você já compreende conceitos básicos de lógica de programação como algorit-
mo, variáveis e operadores, chegou o momento de conhecer o software que você utilizará para
realizar a implementação destes algoritmos, conhecendo as suas principais funcionalidades,
como criar um projeto, declarar variáveis, realizar a leitura de valores do teclado e apresentar
informações para o usuário.
a) utilizar ferramentas para elaboração de algoritmos.
46
4.1 INICIANDO UM ALGORITMO
Para realizar o desenvolvimento de algoritmos, você irá utilizar um ambiente de desenvolvimento que
utiliza pseudocódigo, que é o Visual G, uma ferramenta gratuita disponível em <http://visualg3.com.br/>.
A seguir, é possível verificar a tela inicial da ferramenta:
Visual G (2018)
Fonte: Captura de tela realizada pelo autor (2018)
Nessa tela é possível identificar os seguintes componentes:

a) à esquerda, você pode visualizar a área dos algoritmos, local onde será realizada a edição do código
para implementação do algoritmo;
b) à direita, você tem a área das variáveis de memória, local onde é possível monitorar todas as variáveis
criadas durante o algoritmo, incluindo os seus respectivos identificadores e valores;
c) também à direita, está a área de visualização dos resultados, local que possibilita verificar as entradas
e saídas que acontecem durante a execução do algoritmo;
d) na parte superior, você tem o menu de operações, onde constam opções para salvar, carregar e criar
novos algoritmos, assim como a opção para realizar a execução do algoritmo, que também pode ser
realizada pela tecla de atalho F9.
Tendo conhecimento da ferramenta Visual G, agora você irá compreender melhor a área de edição
dos algoritmos, onde deverá ser realizada a implementação do código. A figura abaixo apresenta apenas
esta janela.
4 INICIANDO COM ALGORITMOS
47
Visual G (2018)
Fonte: Captura de tela realizada pelo autor (2018)
Na primeira linha do editor, é denominado o nome do algoritmo que você irá desenvolver, o qual deve
ser precedido pela palavra Algoritmo, e na sequência, entre aspas duplas, o nome que você desejar definir
para o seu algoritmo.
Nas linhas 2 a 6, é possível observar uma sequência de comentários, os quais sempre são precedidos pe-
los caracteres “//”. É importante ressaltar que um comentário não é processado pelo interpretador, ou seja,
a execução do algoritmo irá ignorar essas linhas. Nesse caso, constam os comentários padrões do Visual G,
o nome do professor sempre virá como Antonio Carlos Nicolodi, pois é o criador da ferramenta Visual G.
Na linha 7, consta a palavra reservada “Var”, o que indica que, abaixo desta linha, deverá acontecer as
declarações das variáveis. É muito importante você lembrar que todas as variáveis que vierem a ser utiliza-
das no algoritmo deverão ser declaradas nessa sessão.
Todas as variáveis declaradas aparecerão à direita na área das variáveis de memória. Com isso você
consegue monitor de uma forma melhor o que está desenvolvendo.
Na linha 11, está a palavra reservada “Inicio”. Isso significa que, a partir dessa linha virá a implementa-
ção do algoritmo, e tudo que estiver entre as palavras “Inicio” e “Fimalgoritmo” será executado em ordem
sequencial pelo interpretador quando o código for executado, ou seja, toda a lógica de desenvolvimento
deve estar entre essas palavras.
SAIBA gora que você já conheceu um pouco sobre a ferramenta Visual G, que tal realizar a
MAIS declaração de algumas variáveis?
48
Agora que você já conheceu um pouco sobre a ferramenta Visual G, que tal realizar a declaração de
algumas variáveis?
4.2 DECLARAÇÃO DE VARIÁVEIS
Como você já viu, as variáveis possuem sessão específica no editor de código para serem declaradas, e,
lembrando, todas as variáveis que forem utilizadas durante o algoritmo devem ser declaradas nessa área.
Para isso, deve-se declarar as variáveis abaixo da palavra reservada “Var”, sempre definindo o identificar
e o tipo da variável, conforme o exemplo abaixo.
Visual G (2018)
Nesse caso, você pode identificar quatro variáveis criadas, cada uma definida com um tipo de dado
diferente. A variável identificada como num1, poderá receber apenas valores do tipo inteiro. A variável
valor pode receber apenas números reais, ou seja, com casas decimais. A variável texto foi definida para
trabalhar com valores do tipo caractere. E a variável identificada como verificação receberá apenas valores
do tipo lógico, que consiste em verdadeiro e falso.
A nomenclatura para a definição da variável sempre deverá obedecer ao seguinte padrão:
Identificador : Tipo de Dado
Se você executar o código pressionando a tecla F9, tendo realizado a declaração dessas variáveis no
código, a área referente às variáveis de memória apresentarão os seguintes valores:
49
Visual G (2018)
Observe que todas as quatro variáveis criadas são apresentadas nessa sessão, apresentado o escopo,
neste caso global, ou seja, todo o código terá acesso à variável; o nome da variável, que representa o iden-
tificador definido na declaração; o tipo da variável, sendo I (Inteiro), R (Real), C (Caractere) e L (Lógico); e o
valor armazenado na variável.
Referente ao valor, mesmo não sendo inicializado nenhum valor para as variáveis, elas sempre iniciarão
com um valor padrão, como se pode observar. Estes valores padrão são:
a) inteiro: 0 (zero);
b) real: 0,00000000000000;
c) caractere: “” (Um texto vazio);
d) lógico: Falso.
Para atribuir valores às variáveis, deve-se realizar essa implementação durante a execução do algoritmo,
que terá seu início após a declaração das variáveis, e é definido no código pela palavra reservada início. A
imagem abaixo demonstra a atribuição de valores para as variáveis.
50
Visual G (2018)
Após a palavra reservada início, foi dado início à atribuição de valores para as variáveis declaradas ante-
riormente. Para tanto, utiliza-se o operador de atribuição, representado pelo símbolo “<-“.
FIQUE Lembre-se de que é importante que o identificador da variável seja um nome que re-
presente o motivo da existência desta variável e para que ela serve. Assim, fica mais
ALERTA fácil de identificar o porquê desta variável estar sendo utilizada durante o algoritmo.
Dois pontos importantes a serem ressaltados são referentes à atribuição para a variável valor e texto.
Para a variável valor, que é do tipo Real, a separação das casas decimais deve ocorrer utilizando um “.”. E
a variável texto, que é do tipo Real, deve receber seu valor entre aspas duplas (“”), o que representa uma
cadeia de caracteres.
4.3 ENTRADA E SAÍDA DE DADOS
Até o momento, você trabalhou apenas com a atribuição de valores predeterminados para as variáveis.
Porém, é extremamente comum a realização de leituras obtidas a partir do teclado para a definição dos
valores das variáveis. Para isso, o Visual G possui um comando denominado “leia”, o qual é responsável por
solicitar que o usuário digite um valor e, ao pressionar a tecla ENTER, atribui este valor a uma determinada
variável, como no exemplo a seguir:
Visual G (2018)

51
Foram definidas duas variáveis, identificadas por num1 e num2, do tipo inteiro. Para definir os valores
dessas variáveis, na implementação do algoritmo, foi utilizando o comando “leia”, nas linhas 12 e 13. Ob-
serve que este comando é seguido por um valor entre parênteses, o qual aponta para a variável onde o
valor lido pelo teclado deverá ser atribuído.
Nesse caso, ao executar a linha 12, o algoritmo ficará esperando que o usuário digite um valor e pressio-
ne ENTER. Após, atribuirá o valor digitado pelo usuário à variável identificada por num1. Na sequência, fará
o mesmo processo para a linha 13, atribuindo o valor à variável num2. Execute esse algoritmo e ao término
observe os valores apresentados na área de variáveis de memória.
Além de solicitar valores do usuário, é possível imprimir valores na tela para apresentar informações ao
usuário. Para tanto, utiliza-se o comando “escreva”. Esse comando também deve conter um valor entre pa-
rênteses, do tipo caractere, que pode ser definido diretamente utilizando aspas duplas. O exemplo anterior
foi expandido para realizar a soma entre os dois números e apresentar o resultado.
Visual G (2018)
Nesse exemplo, três variáveis foram definidas: num1 e num2 serão responsáveis por armazenar os va-
lores informados pelo usuário e a soma armazenará o resultado da operação de adição entre os números.
Na implementação do algoritmo, foi utilizado o comando “escreva” para informar ao usuário o que deve
digitar, para, na sequência, realizar a operação de “leia”. Portanto, são lidos os valores num1 e num2, e, na
sequência, a variável soma recebe a adição entre os valores representados por essas variáveis. Por fim, é
utilizado o comando “escreva” para apresentar o resultado para o usuário.
Perceba que o último comando “escreva” possui dois valores, um caractere com a palavra “Resultado: “,
uma vírgula e a variável soma. Nesse caso, a vírgula é utilizada para realizar a concatenação entre valores,
apresentando desta forma, a palavra “Resultado: “ seguida do valor armazenado pela variável soma.
Se você executar esse algoritmo e informar os valores 10 e 20 para as variáveis num1 e num2, respecti-
vamente, a console apresentará o seguinte:
52
Visual G (2018)
Você pode observar que o valor informado pelo comando “escreva” e o valor informado para o co-
mando “leia” aparecem sempre na mesma linha. Caso queira quebrar linha após a utilização do comando
“escreva”, deve-se utilizar o comando “escreval”. Como no exemplo a seguir:
escreval(“Digite o primeiro número!”)
Os comandos LEIA e ESCREVA, quando aprendidos, costumam gerar confusão, pois

o comando LEIA irá solicitar uma informação para o usuário, enquanto o comando
CURIOSI ESCREVA irá apresentar uma informação para o usuário. Aos nossos olhos, parece
uma lógica invertida, porém o Visual G parte do princípio de que estes comandos
DADES devem ser interpretados pelo computador, ou seja, o comando LEIA define que o
computador irá ler uma informação vinda do usuário e o ESCREVA que o computa-
dor irá escrever uma informação para o usuário.
Dando sequência aos seus estudos, você irá aprender os conceitos de documentação de código.
Confira!
53
4.4 DOCUMENTAÇÃO DE CÓDIGO
Dificilmente um programa de computador será desenvolvido por apenas uma pessoa. Em qualquer em-
presa que você vier a trabalhar, todas trabalharão, sem dúvida, com equipes de desenvolvedor. Por conta
disso, é muito importante compreender e aplicar os conceitos de documentação de código nos algoritmos
que você desenvolve.
Imagine a seguinte situação: você recebe uma tarefa a ser desenvolvida, que consiste em realizar a
manutenção de um algoritmo que foi desenvolvido por um programador que não trabalha mais na em-
presa. Quando você abre o código, percebe que é de extrema complexidade, e não existe nenhuma docu-
mentação explicando o funcionamento deste algoritmo. O que isso significa? Que você terá que dedicar
um bom tempo para compreender o algoritmo. Nesse ponto, você irá concordar que, se o programador
tivesse documentado o código, ou pelo menos as suas partes principais, você perderia menos tempo para
compreendê-lo, assim como não correria o risco de interpretar o algoritmo de forma incorreta.
Para documentar um código do Visual G, utiliza-se de comentários de código, os quais devem ser apli-
cados junto ao comando que você deseja explicar o funcionamento. Não é necessário documentar todo o
código, o mais importante é documentar as partes mais complexas do seu algoritmo, de forma a auxiliar
os futuros desenvolvedores que vierem a trabalhar no seu código. Portanto, para adicionar um comentário
em uma linha, você deve utilizar duas barras “//”. Este é um comentário de linha, portanto, ao pressionar
ENTER, caso deseje continuar os comentários, deverá iniciar a linha com duas barras novamente. Veja um
exemplo a seguir:
//Apresenta uma mensagem informando que o usuário deve

//informar seu nome
escreval(“Digite o seu nome”)
//Solicita o nome do usuário, e armazena o valor digitado na
//variável nomeUsuario.
leia(nomeUsuario)
Veja que, em ambos os casos, o comentário deixa claro o que a linha a seguir irá fazer, além disso, ambos
os comentários utilizados como exemplo ocuparam mais de uma linha, portanto, em todas as linhas que
foram ocupadas para comentário, iniciou-se com as duas barras.
Em muitas linguagens de programação, o que não é o caso do Visual G, existe a possibilidade de adicio-
nar um comentário que ocupará mais de uma linha, o qual é representado da seguinte forma:
54
/* Comentário
Com
Mais de
Uma linha
*/
Veja que o comando “/*” inicia o bloco de comentário, e a partir disto, tudo o que for digitado será con-
siderado um comentário, apenas finalizando quando encontrar um comando “*/”, o qual é utilizado para
fechar o bloco de comentário.
É importante ressaltar que, ao executar um código, tudo o que estiver definido como comentário será
desconsiderado na execução, dessa forma, apenas as linhas que não estão comentadas serão executadas,
uma após a outra. Como dito anteriormente, a documentação de código existe para facilitar a compreen-
são dos demais desenvolvedores referente ao seu código, o que torna a existência dos comentários um
dos pontos mais importantes do desenvolvimento de um software.
Acompanhe a seguir o “Casos e relatos” que mostra a importância de realizar a documentação das tarefas.
55
CASOS E RELATOS
Um desenvolvedor, recém-contratado, começou a receber algumas tarefas de manutenção do sis-

tema para compreender a arquitetura e o funcionamento do código utilizado para desenvolver o
programa no qual irá ajudar a desenvolver. Como a empresa sempre prezou muito pela documen-
tação do código, este desenvolvedor estava tranquilo, pois todas as tarefas que havia recebido até
o momento trabalhavam com códigos muito bem documentados, o que estava ajudando muito
em seu trabalho. Porém, em uma determinada tarefa, que envolvia um algoritmo extremamente
complexo, que tinha como objetivo analisar e ordenar as colocações de participantes de um pro-
cesso seletivo, levando em consideração, além da nota, todos os critérios como idade, formação,
escolaridade, entre outros, toda a documentação que este desenvolvedor encontrou foi uma linha
no início do algoritmo que dizia o seguinte:
“Não mexa, está funcionando desta forma”.
O rapaz ficou um pouco confuso, pois, na verdade, não estava funcionando corretamente, tan-
to que recebeu uma tarefa para consertar isso. Analisou todo o código e realmente não existia
mais nenhuma linha de comentário. Questionou com os colegas quem havia desenvolvido este
algoritmo e, para a sua surpresa, a pessoa não estava mais trabalhando na empresa. Ou seja, este
desenvolvedor precisou analisar o código e compreendê-lo antes de realizar qualquer alteração, e,
por ser de extrema complexidade, essa tarefa ocupou três dias de trabalho, enquanto, se estivesse
documentada corretamente, teria ocupado no máximo um dia. Veja a queda de produtividade de
uma empresa por simplesmente não ter documentado um código corretamente.
RECAPITULANDO
Neste capítulo, você conheceu a ferramenta de edição de algoritmos denominada Visual G e

aprendeu a criar um novo projeto, realizar a criação das variáveis e utilizar os comandos de entre-
ga e saída. Com esse conhecimento, junto ao que você já aprendeu referente aos operadores, é
possível iniciar o desenvolvimento de algoritmos mais complexos. Para tanto, na próxima etapa,
você aprenderá sobre as estruturas de controle, vamos nessa?
Estruturas de Controle
e Repetição
Neste capítulo, você compreenderá as estruturas básicas para o desenvolvimento de um

algoritmo, partindo das estruturas de decisão, que consiste em seleção e escolha-caso, e finali-
zando com as estruturas de repetição, definidas por “enquanto”, “faça-enquanto” e “para”.
a) utilizar estruturas de controle e repetição.
58
5.1 COMANDOS DE DECISÃO
Os comandos de decisão são utilizados para permitir que o algoritmo possa decidir entre dois ou mais
caminhos para continuar a execução. Muitas vezes, serão necessárias diferentes execuções de acordo
com resultados obtidos a partir de processamentos anteriores. Neste ponto, os comandos de decisão
são primordiais.
Para exemplificar a necessidade de um comando de decisão, imagine a situação em que é necessário
definir se um aluno foi aprovado ou reprovado em uma matéria, tendo como base a sua média. Nesse caso,
são possíveis duas situações:
a) O aluno está aprovado caso obtenha média superior ou igual a 7 (sete);
b) O aluno está reprovado caso obtenha média inferior a 7 (sete).
Como é possível observar, dependendo do valor obtido a partir da média, o algoritmo pode realizar
uma ação para o caso de aprovação e outra para o caso de reprovação.
Para uma melhor compreensão, você pode supor que se o aluno obtiver a aprovação, receberá uma
mensagem com os dizeres “Boas Férias!”. Porém, se o aluno obtiver a reprovação, dependendo da sua mé-
dia ainda poderá realizar um exame final, para posteriormente definir sobre a reprovação ou não.
Na sequência, serão apresentados os quatro tipos de decisão possíveis: Seleção Simples, Seleção Com-
posta, Seleção Composta Encadeada e Escolha-caso.
5.1.1 SELEÇÃO SIMPLES
Uma seleção é definida pelo comando “se”, o qual decidirá sobre a execução ou não de um determina-
do bloco de código com base em uma expressão que deve, obrigatoriamente, retornar um valor lógico. De
acordo com a seguinte nomenclatura:
se (<<expressão lógica>>) entao

//Bloco de código
Fimse
Essa é a estrutura básica de um comando de seleção simples, o qual apenas decidirá se executará o blo-
co de código ou não. Para tanto, é verificado o resultado da expressão lógica, caso seja verdadeiro, executa
o bloco de código, caso seja falso, apenas ignora o bloco entre o se e o fimse e continua a execução do
algoritmo. Veja a seguir um exemplo no Visual G.
5 ESTRUTURAS DE CONTROLE E REPETIÇÃO
59
Visual G (2018)
O objetivo deste algoritmo é apenas verificar se o valor digitado pelo usuário é maior do que 10 (dez).
Para tanto, é solicitado um valor para o usuário e na sequência, como pode ser observado na linha 13, é
realizada uma seleção para com base no resultado obtido a partir da operação relacional “valor > 10”, que,
conforme foi visto anteriormente, sempre retornará um valor lógico, definir se será executado o bloco de
código referente ao comando “se” ou não. Para realizar essa execução, é necessário que o valor retornado
pela expressão lógica seja verdadeiro, ou seja, caso o valor digitado for maior que 10, será realizada a exe-
cução do comando “escreval”. Caso for falso, a execução desse bloco de código será ignorada e continuará
a partir da linha 16.
Um comando de seleção parte do princípio de que será executado caso o resultado da

SAIBA expressão lógica, que vai entre parênteses, for verdadeiro. Porém, caso seja necessário
MAIS testar o inverso, ou seja, caso o valor da expressão lógica for falso, é possível utilizar o
operador lógico “não”.
5.1.2 SELEÇÃO COMPOSTA
A seleção composta também trabalha com uma verificação que tem como base uma expressão lógica,
porém, é adicionada a esta seleção uma opção para o caso de a expressão ser falsa. Para tanto, a nomen-
clatura deste comando de seleção é a seguinte:
60

//Bloco de código caso a expressão for verdadeira
senao
//Bloco de código caso a expressão for falsa
Fimse
A primeira parte, referente ao comando “se”, é exatamente igual ao conceito de seleção simples, porém,
caso o resultado da expressão lógica for falso, ao invés de simplesmente ignorar o comando de seleção,
será executado o bloco de código referente ao senão.
Portanto, no caso da seleção composta, um dos dois blocos de código deverá, obrigatoriamente, ser
executado. Lembrando que uma expressão lógica retornará ou verdadeiro ou falso, e nenhuma outra op-
ção, portanto, ou o comando “se” ou o comando “senão” será executado. A seguir um exemplo utilizando
a linguagem Visual G.
Visual G (2018)
Foi utilizado o mesmo exemplo apresentado anteriormente, porém, com a inclusão de um bloco de có-
digo para o comando “senão”. Nesse caso, se o usuário digitar um valor maior que 10, o algoritmo executa-
rá a linha 14, referente ao comando “se”, porém, caso o valor digitado for menor ou igual a 10, a linha a ser
executará será a 16. Independente de executar o bloco de código referente ao comando “se” ou “senão”, a
execução continuará a partir da linha 18.
Sempre deverá ser analisada qual das opções de comando de seleção é mais vanta-
FIQUE josa. Caso precise apenas verificar um valor para verdadeiro ou falso, a seleção sim-
ALERTA ples é o suficiente, porém, caso precise realizar uma diferente execução para o caso
de verdadeiro ou falso, então a seleção composta é necessária.
61
5.1.3 SELEÇÃO COMPOSTA ENCADEADA
Este tipo de seleção é utilizado quando se possui um grande número de verificações, as quais devem
ser testadas em sequência até que encontre uma expressão verdadeira. Fazendo uso destas e não sendo
mais necessário testar as demais.
Ela segue o conceito da seleção composta, porém o encadeamento de seleção se dá com a criação
de outros comandos “se” dentro do bloco de código referente ao comando “senão”. A estrutura segue
o seguinte modelo:

//Executa este bloco de código.
senao
senao
fimse
fimse
Observe que o comando “senão” referente ao primeiro comando “se” possui outra seleção em seu blo-
co de código, isso significa que, caso a expressão referente ao primeiro comando “se” for falsa, será execu-
tado o código referente a comando “senão”, onde é realizada outra seleção, decidindo qual entre os dois
blocos de código será executado.
Pode-se enxergar uma seleção composta encadeada como uma sequência de verificações à procura da
expressão que se encaixa na necessidade do algoritmo, pois sempre terá uma expressão lógica que será
verificada, e caso for falsa, testará a próxima, e assim por diante. A seguir um exemplo melhor demonstran-
do a utilização desta seleção.
62
Visual G (2018)
Nesse exemplo, é solicitado um valor e são realizadas algumas verificações a fim de definir em que in-
tervalo este valor pertence. Para tanto, após solicitar o valor, primeiramente, verifica-se se o valor é menor
que 10 (dez). Caso o resultado desta operação relacional for verdadeiro, apresenta a mensagem “O valor
informado é menor que 10” e finaliza a execução da seleção composta encadeada. Verifique que as outras
seleções não serão realizadas, pois estão no comando “senão”, o qual não será atingido caso a verificação
do comando “se” for verdadeira.
Agora, caso o valor não seja menor que 10 (dez), entrará no comando “senão” e realizará a próxima
verificação, que consiste em saber se o valor é menor do que 20. Observe que, se chegar nessa verificação,
já se sabe que o valor não é menor que 10, ou seja, caso a verificação retorne verdadeiro, significa que o
valor é menor que 20 e maior ou igual a 10, portanto, apresentará o conteúdo “O valor é maior ou igual a
10 e menor que 20”.
Caso a verificação resulte em falso, o próximo passo será verificar executar o comando “senão” desta
seleção, o qual possui outra seleção para verificar se o número é menor que 30. Se esta verificação for ver-
dadeira, apresentará a mensagem “O valor é maior ou igual a 20 e menor que 30”.
Por fim, você pode observar a existência apenas de um comando “senão”, ou seja, se nenhuma das ex-
pressões lógicas executadas até o momento for verdadeira, então, entrará neste último comando “senão”
que não possui mais nenhuma verificação no seu corpo, apenas apresentará a mensagem “O valor é maior
ou igual a 30”.
Esse comando é extremamente útil em casos em que vários valores precisam ser verificados, seguindo
uma sequência lógica de verificações. Você pôde observar que os testes acontecem em uma sequência,
até que encontre uma verificação que retorne verdadeiro, finalizando a execução da seleção composta
encadeada.
63
Sempre que uma seleção é aberta, por intermédio do comando “se (...) senao”, este
FIQUE deverá ser fechado utilizando o comando “fimse”. No exemplo anterior, referente à
ALERTA seleção composta encadeada, você pode observar que foram inicializados três co-
mandos de seleção, portanto, ao término, tem-se três comandos “fimse”.
Como as expressões lógicas dos comandos de seleção precisam realizar operações

que retornem valores lógicos, além da utilização dos operadores relacionais, como
foi apresentado anteriormente, também pode-se utilizar os operadores lógicos, pois
CURIOSI assim como os relacionais estes retornam um valor lógico. Veja um exemplo:
DADES se (num1 <> 0 E num2 <> 0) entao
escreval(“Ambos os números são diferentes de zero!”)
fimse.
5.1.4 ESCOLHA-CASO
Este comando referente a estrutura de seleção é diferente das anteriores no que diz respeito a nomen-
clatura. O que você viu até o momento foi a utilização dos comandos “se” e “senão”, já o comando escolha-
-caso, é utilizando para situações onde para um determinado valor tem-se um conjunto de opções para
escolha.
Este também pode ser representado utilizando a seleção composta encadeada, porém, sugere-se que a
partir de uma sequência maior que três seleções encadeadas se utilize o comando escolha-caso.
Veja a nomenclatura para a codificação desse comando:
64
escolha (<<variável>>)
caso 1
//Comandos caso o valor da variável for 1.
caso 2
caso 3
outrocaso
//Comandos caso nenhuma das opções acima correspondam
//ao valor da variável.
Fimescolha
Aqui utiliza-se uma variável como referência para a verificação, e os casos correspondem ao valor que a
variável possui no momento da verificação. Ou seja, caso o valor da variável for 1 (um), executará o bloco
de código referente ao comando “caso 1”. Se nenhum dos casos definidos corresponder ao valor da variá-
vel, então será executado o bloco de código referente ao comando “outrocaso”.
O exemplo apresentado a seguir fará a leitura de um valor inteiro e apresentará como saída a escrita
referente a este número por extenso, caso nenhum dos casos seja correspondam será apresentada a men-
sagem “valor inválido”.
Visual G (2018)
Agora você conhece todos os comandos de decisão existentes no contexto de lógica de programação.
Lembre-se de sempre analisar a situação para identificar qual a melhor estrutura para a resolução do seu
problema. Continue os seus estudos para compreender sobre os comandos de repetição.
65
5.2 COMANDOS DE REPETIÇÃO
Em algumas situações, é necessário realizar a repetição de uma parte do código diversas vezes a fim de
simplificar e reduzir a quantidade de código. Por exemplo, imagine que você precise solicitar vinte núme-
ros para realizar um cálculo de média. Ao invés de digitar vinte linhas de código solicitando valores para
posteriormente realizar o cálculo da média, com o uso de um comando de repetição, é possível repetir a
linha de código que solicita um valor do usuário vinte vezes, simplificando o código e reduzindo a quanti-
dade de linhas do algoritmo.
Uma situação importante é que estas repetições devem ser finitas, caso contrário, o algoritmo entrará
em um loop infinito, travando a sua execução.
Toda estrutura de repetição possui como base uma expressão lógica que definirá se um determinado
trecho de código deverá ser repetido ou não. Para tanto, caso o retorno da expressão lógica for verdadeiro,
significa que o bloco de código referente à estrutura de repetição deve ser executado, caso contrário a re-
petição finaliza. Para todas as estruturas de repetição, a expressão lógica é executada a cada repetição do
bloco de código, garantindo que finalize o laço de repetição quando o retorno for falso.
Um importante ponto da estrutura de repetição é que a expressão lógica empregada deve utilizar um
valor que seja alterado no corpo da estrutura de repetição, pois apenas isso garantirá que a repetição
chegue ao fim.
CASOS E RELATOS
Um determinado aluno da Unidade Curricular de Lógica de Programação, ao realizar a implemen-

tação de um trabalho que deveria utilizar estruturas de repetição, parou em um problema onde o
seu algoritmo está entrando no que chamamos de loop infinito, ou seja, a sua estrutura de repeti-
ção nunca chegava ao fim. Ao analisar o seu código diversas vezes e não conseguindo encontrar
o seu problema, pediu ajuda ao seu professor. Após analisar o código, o professor explicou ao
aluno que o seu problema estava sendo ocasionado por duas situações, a expressão lógica utiliza-
da como teste para finalizar o algoritmo e os valores atribuídos a variável que era utilizada nessa
estrutura.
O seguinte estava acontecendo: o aluno iniciou o valor dessa variável em 0 e, a cada repetição, in-
crementava dois ao valor dessa variável, porém, na expressão lógica que utilizava como teste para
finalizar o loop, definia que o loop deveria parar apenas quando o valor da variável fosse igual a 9,
ou seja, isso nunca iria acontecer. Iniciando em zero, e incrementando o valor de 2 em 2, a variável
iria atingir o valor 8 e 10, mas nunca o valor 9, portanto, um erro na utilização do operador relacio-
nal estava ocasionando todo o problema de loop infinito, corrigido e alterando o teste para repetir
enquanto o valor da variável fosse menor que 9.
66
Para tanto, existem três tipos de comandos de repetição, os quais são denominados “enquanto”, “repi-
ta” e “para”. A seguir você conhecerá essas estruturas.
5.2.1 ENQUANTO
É uma estrutura que realiza o teste da expressão lógica antes de entrar no laço de repetição, ou seja,
caso ao iniciar o comando de repetição a condição for verdadeira, executará o bloco de código referente
as instruções, caso contrário, a estrutura não chegará a ser executada. A nomenclatura dessa estrutura
é a seguinte:
enquanto (<<expressão lógica>>) faca

//Bloco de código a ser repetido
Fimenquanto
Ao chegar na execução do “enquanto”, inicialmente será testada a expressão lógica, caso verdadeiro,
executará o bloco de código a ser repetido, e ao chegar ao fim, retornará a expressão lógica para verificar
se esta continua verdadeira, ou seja, a partir do momento que o retorno da expressão passar a ser falso, a
repetição é finalizada.
O exemplo a seguir apresenta um contador que irá de 0 a 10. Verifique que, no bloco de código que é
repetido, o valor referente ao contador é alterado, garantindo assim que essa repetição chegue ao final,
que será quando o valor do contador passar a ser maior que 10.
Visual G (2018)
Vale lembrar que, se você iniciar o contador com um valor maior que 10, o bloco de código referente ao
“enquanto” não chegará a ser executando, pois a verificação acontece antes.
67
5.2.2 REPITA
Estrutura de repetição semelhante ao “enquanto”, porém o diferencial é que essa estrutura realiza a ve-
rificação da expressão lógica apenas ao término da execução do bloco de código a ser repetido, conforme
pode ser visto na nomenclatura da estrutura apresentada a seguir.
repita
//Bloco de código a ser repetido
ate (<<expressão lógica>>)
Nesse caso, a estrutura iniciará executando o bloco a ser repetido para posteriormente realizar o teste
da expressão lógica. Isso garante que o bloco de código a ser repetido será executado pelo menos uma
vez, indiferente da expressão lógica iniciar verdadeira ou falsa. Após isso, apenas continuará a execução se
o retorno da expressão for verdadeiro.
A seguir, é demonstrado o mesmo exemplo utilizado anteriormente, porém utilizando a estrutura
“repita”.
Visual G (2018)
Nesse caso, veja que a condição referente à expressão lógica mudou, pois aqui foi definido até quando
o bloco de código será executado, nesse caso, até que o valor referente à variável contador seja maior do
que 10. Ou seja, enquanto o valor for menor ou igual a 10, a repetição irá acontecer.
Para essa estrutura, caso inicialize o valor da variável com um valor maior que 10, o bloco de código
referente ao comando “repita” será executado pelo menos uma vez, apresentando o valor inicialmente de-
finido para a variável, para, posteriormente, realizar a verificação da expressão lógica e finalizar a repetição.
68
5.2.3 PARA
Para a utilização desta estrutura de repetição, você precisa saber quantas iterações serão necessárias se-
rem executadas. Isso porque o comando de repetição “para” deve receber o seu ponto de início e término.
A seguir, é apresentada a nomenclatura desta estrutura de repetição.
para <<variável de controle>> de <<valor de início>> até

<<valor de término>> passo <<valor de incremento ou decremento>>
faca
<<bloco a ser repetido>>
Fimpara
Nesse caso, você possui diversas variáveis a serem completadas, as quais serão descritas a seguir.
a) Variável de controle: esta variável deve ser definida anteriormente no bloco de declaração de variá-
veis. Deve ser do tipo inteiro e será a variável de controle da repetição, a qual terá seu valor modifica-
do a cada repetição e será utilizada para a realização do teste lógico, o qual define o fim da repetição.
A literatura costuma utilizar os identificadores “i” e “j” para definir esta variável de controle.
b) Valor de início: neste ponto é definido o valor inicial da variável de controle. O valor adicionado aqui
será atribuído a esta variável ao iniciar a execução do comando “para”.
c) Valor de término: define o valor a ser testado junto à variável de controle para definir o término da
repetição. A cada repetição do comando “para”, será realizado o teste lógico entre o valor da variável
de controle (a qual é modificada a cada repetição do comando “para”) e o valor de término. Quando
estes dois valores forem iguais, é definido o término da repetição.
d) Valor de incremento ou decremento: por fim, neste ponto é definido o valor que será incrementa-
do ou decremento ao valor atual da variável de controle. A cada repetição, essa operação será feita,
até chegar ao término da repetição. Para incrementar um valor, utilize um número inteiro positivo,
enquanto, para decrementar, utilize um número inteiro negativo.
Agora que você já conhece a estrutura do comando “para” e todos os valores que compõem essa estru-
tura, analise alguns exemplos para uma melhor compreensão.
Visual G (2018)

69
Inicialmente, é definida a criação da variável denominada “i”, a qual será utilizada como variável de con-
trole do comando “para”. Posteriormente, inicia-se o comando de repetição “para”, o qual você pode ver
da seguinte forma: utilizando a variável de controle identificada por “i”, definindo que inicialmente o valor
desta variável será 1, e que a repetição seguirá até que a variável de controle “i” atinja o valor 10, e incre-
mentando o valor da variável em 1 a cada repetição, escreva o valor da variável “i” seguido de um espaço
em branco e repita o bloco de código.
Vale reforçar que, a cada repetição, o valor da variável de controle será incrementado com base no valor
definido como “passo” na estrutura do comando de repetição, nesse caso, a variável será incrementada de
um em um. Ao término da execução do comando “para”, será exibida a seguinte informação para o usuário.
1 2 3 4 5 6 7 8 9 10
Ou seja, na primeira vez que executou a estrutura referente ao comando “para”, o valor da variável “i”
foi 1. A cada repetição, o valor dessa variável foi incrementado em 1 até chegar ao valor 10, encerrando a
estrutura de repetição.
Para apresentar outro exemplo utilizando essa estrutura de repetição, será apresentado o inverso do
exemplo anterior, ou seja, serão impressos os números em ordem decrescente, iniciando em 10 e finalizan-
do em 1, conforme o exemplo a seguir.
Visual G (2018)
Nesse caso, novamente, inicia-se definindo a variável identificada por “i” como inteira e, na sequência,
executa-se o comando “para”, realizando a execução inversa à anterior.
Você pode ler da seguinte forma: tendo como variável de controle a variável identificada por “i”, e de-
finindo o valor inicial desta variável como 10, repita a estrutura até que o valor desta variável seja 1, de-
crementando 1 a cada repetição, e apresentando na console o valor referente a variável “i” seguido de um
espaço. Após a execução desse algoritmo, o seguinte será impresso no console.
10 9 8 7 6 5 4 3 2 1
Aqui você pode observar que ocorreu exatamente o inverso do exemplo anterior, realizando uma re-
petição “para” decrementar, ou seja, inicia o valor de “i” em 10 e diminui um referente a este valor a cada
repetição, até atingir o valor 1.
70
O valor que aparece após a palavra “passo” na estrutura do comando “para” define o
SAIBA valor que será incrementado ou decrementado à variável de controle. Ou seja, caso
MAIS você insira “... passo 4 ...”, a cada repetição será adicionado 4 ao valor referente à variá-
vel de controle.
Agora você já conhece todas as estruturas de decisão e repetição básicas disponíveis em praticamente
todas as linguagens de programação existentes, porém, lembre-se de que a sintaxe pode alterar de uma
linguagem para a outra. Na sequência, você poderá analisar um exemplo que irá englobar todo o conteú-
do abordado até o momento, para a construção de um único programa.
5.3 EXEMPLO UTILIZANDO DIVERSAS ESTRUTURAS DE CONTROLE
Agora que você já conhece as estruturas de seleção e repetição, você está apto a analisar um programa
de computador que utiliza da combinação das estruturas de seleção e repetição, assim como dos conteú-
dos vistos no início desta unidade curricular, como operadores e variáveis.
O programa consiste em simular um autoatendimento de um caixa eletrônico, apresentando para o
cliente opções como consulta de saldo, saque, depósito e finalizar o atendimento. A ideia é que, ao iniciar
o atendimento, o sistema pergunte ao usuário qual das operações ele deseja fazer. Caso deseje realizar um
saque ou depósito, deverá ser solicitado o valor correspondente para analisar se é possível ou não realizar
a operação. Caso selecione a opção para visualizar o saldo da conta, apenas será impresso na tela o saldo
atual e caso decida por sair do sistema, será apresentada uma mensagem de finalização e o programa será
encerrado.
Veja primeiro o programa completo, e na sequência ele será analisado, parte por parte, para que você
possa compreender melhor o seu funcionamento.
71
Algoritmo “sistemaBancario”
Var
saldo, valor : real
opcao : inteiro
Inicio
opcao := 0
valor := 0
escreval(“Bem-vindo ao nosso sistema bancário”)
enquanto opcao <> 4 faca
escreval(“Qual operação deseja realizar?”)
escreval(“1 – Saldo da conta”)
escreval(“2 – Saque”)
escreval(“3 – Depósito”)
escreval(“4 – Sair”)
leia(opcao)
escolha opcao
caso 1
escreval(“Seu saldo é: R$”, saldo)
caso 2
valor := -1
escreval(“Digite o valor do saque”)
repita
leia(valor)
se valor < 0 entao
escreval(“O valor de saque deve ser maior
que zero! Digite novamente o valor do saque”)
senao
Se valor > saldo entao
escreval(“O valor de saque é superior ao seu saldo!
Digite novamente o valor do saque”)
senao
saldo := saldo – valor
escreval(“Saque efetuado! Retire o seu dinheiro!”)
valor := 0
fimse
fimse
ate valor = 0
caso 3
escreval(“Digite o valor do depósito”)
repita
leia(valor)
se valor < 0 entao
72
escreval(“Não é possível depositar um valor nulo ou

negativo! Digite novamente o valor do depósito!”)
senao
saldo := saldo + valor
escreval(“Depósito realizado!”)
valor := 0
fimse
ate valor = 0
caso 4
escreval(“Obrigado por utilizar nosso sistema!”)
fimescolha
fimenquanto
Fimalgoritmo
O programa foi iniciado declarando as variáveis que eram necessárias no decorrer do código. Nesse
caso, foram definidas duas variáveis do tipo “real”, uma para armazenar o saldo da conta e outra para arma-
zenar o valor de depósito ou saque, e uma variável do tipo “inteiro”, para armazenar a opção selecionada
pelo usuário.
O algoritmo é iniciado definindo como valor inicial das variáveis “opção” e “saldo” o valor zero. É impres-
sa uma mensagem de boas-vindas ao sistema e um comando “enquanto” é iniciado. Esse comando “en-
quanto” realiza um teste para verificar se o valor correspondente à variável opção é diferente de zero. Caso
o resultado seja verdadeiro, o bloco de código referente ao sistema bancário é executado, caso contrário,
o programa é finalizado. Ou seja, quando o usuário escolher a opção 4, o comando de “repetição” principal
do sistema não será mais executado.
Portanto, enquanto o valor referente à variável opção não for 4, e observe que na primeira vez que pas-
sar pelo comando de “repetição” o valor referente a esta variável será 0, pois assim foi definido no início do
algoritmo, o bloco referente a esse comando será executado. Para esse bloco, inicialmente, são executados
alguns comandos “escreval” para apresentar as opções que o usuário pode selecionar, na sequência, o co-
mando “leia” é definido e o valor digitado pelo usuário é armazenado na variável opção.
Após selecionar uma opção, é utilizada uma estrutura de decisão do tipo Escolha-Caso, testando as
quatro possibilidades descritas nas opções anteriormente. Portanto, o comando escolha terá como base o
valor referente à variável opção, que será definida pelo usuário na etapa anterior.
Caso a opção selecionada seja 1, apenas será apresentado para o usuário o valor da variável denomina-
da saldo, e o comando de repetição “enquanto” será executado novamente. Como o valor da opção será 1,
o que é diferente do valor 4, será solicitado para que o usuário selecione uma nova opção.
73
Caso a opção selecionada seja 2, será apresentada a mensagem solicitando que o usuário digite o valor
do saque, e antes do comando “leia” é definida uma estrutura de repetição do tipo “repita-ate”. Optou-se
por essa estrutura, pois será garantido que antes de realizar qualquer teste para continuar ou não no co-
mando de repetição, o usuário terá de digitar um valor. No bloco de código referente ao comando repita,
primeiramente, é solicitado ao usuário o valor que deseja sacar. Na sequência, são realizadas algumas va-
lidações, como se o valor digitado é negativo ou se o valor digitado é maior do que o saldo disponível na
conta. Caso alguma dessas validações seja verdadeira, apresentará uma mensagem informando o proble-
ma e solicitará um novo valor de saque. Caso passe por todas as validações, subtrairá do valor do saldo o
valor informado para saque e, na sequência, alterará o conteúdo da variável “valor” para zero, fazendo com
que, dessa forma, a estrutura “repita” finalize. Ao finalizar essa estrutura, o comando “enquanto” será exe-
cutado novamente, verificando que a opção continua sendo diferente do valor 4, solicitando que o usuário
escolha uma nova opção. Vale ressaltar que, como o valor 0 está sendo utilizado como teste lógico do
comando “repita”, caso o usuário digite 0, finalizará o comando de repetição realizando um saque “vazio”.
Caso a opção selecionada seja 3, será apresentada uma mensagem solicitando que o usuário digite o
valor do depósito e, antes do comando “leia”, também será definida uma estrutura de repetição do tipo
“repita-ate”. Os motivos para a utilização desse comando são os mesmos descritos no caso do saque. Na
sequência, será solicitado o valor do depósito por intermédio do comando “leia” e armazenado na variável
denominada “valor”. Como validações, são utilizados comandos de seleção do tipo SE, verificando se o
valor de depósito é inferior a 0. Caso seja, apresenta uma mensagem e solicita que digite um novo valor;
caso contrário, adicionará à variável saldo o valor de depósito informado e, na sequência, definirá a variável
valor como zero. Com isso, o comando de repetição do tipo “repita” será finalizado, e será realizado nova-
mente o teste da opção no comando “enquanto”, que resultará ser diferente do valor 4 e solicitará uma
nova opção ao usuário.
Caso a opção selecionada for 4, apenas apresenta uma mensagem de encerramento do sistema e, na se-
quência, realizará novamente o teste da estrutura “enquanto”. Nesse caso, como o valor da variável opção
não será diferente do valor 4, o comando será finalizado, encerrando também o algoritmo.
Agora que você conheceu o processo de execução de um algoritmo mais complexo, que intercala co-
mandos de decisão e repetição, transcreva este código para o Visual G e execute-o para uma melhor com-
preensão de todo o processo.
Você finalizou mais um capítulo desta Unidade Curricular. Para rever os conceitos estudados aqui, leia
o “Recapitulando” a seguir.
74
RECAPITULANDO
Neste capítulo, você conheceu as estruturas de controle, compreendendo o que são as estruturas
de seleção e aprendendo a utilizar as duas estruturas existentes, que são SE-SENÃO e ESCOLHA-
-CASO. Você também conheceu as três estruturas de repetição existentes, conhecendo as suas
sintaxes e tendo a possibilidade de analisar exemplos de utilização, comandos estes denominados
“enquanto”, “repita” e “para”. Por fim, você teve a oportunidade de analisar um algoritmo de maior
complexidade que integre todos os conceitos abordados até o momento. Siga em frente para
conhecer sobre as estruturas homogêneas e como elas podem ser úteis para o desenvolvimento
de algoritmos.
Estruturas Homogêneas
Até o momento, você aprendeu e trabalhou com variáveis que aceitam valor único, ou seja,
caso declare uma variável do tipo inteira denominada idade, essa variável poderá receber ape-
nas um valor inteiro. Para os exemplos que você viu até o momento, essas variáveis foram o
suficiente, sendo utilizadas para armazenar valores e gerenciar repetições.
Em alguns momentos, você irá precisar armazenar diferentes valores para utilizá-los poste-
riormente para comparações, ordenações, ou outras operações. Por exemplo, caso você precise
desenvolver um algoritmo para receber dez notas de um aluno e calcular a média final, isso
poderia ser feito criando 10 variáveis, uma para cada nota, para ao fim somar todas e dividir o
resultado por 10, porém, se você utilizar um vetor, poderá armazenar as dez notas em apenas
uma variável. Outro exemplo, apresentado por Puga e Rissetti, é referente a definição de um
grid de largada de fórmula 1, sendo necessário armazenar todos os tempos realizados pelos
pilotos para, posteriormente, ordenar, em ordem crescente. O mais viável é armazenar esses
tempos em um vetor, ao invés de criar inúmeras variáveis, uma para cada tempo.
As estruturas homogêneas, que recebem esse nome por poderem armazenar um conjunto
de dados referente a um mesmo tipo de dado, podem ser unidimensionais ou multidimensio-
nais. Na sequência, você conhecerá esses dois segmentos das estruturas homogêneas, sendo
os vetores uma estrutura unidimensional e as matrizes uma estrutura bidimensional.
a) aplicar lógica de programação para resolução de problemas.
b) aplicar técnicas de ordenação e busca de dados para construção de algoritmo.
78
6.1 VETORES
São estruturas homogêneas unidimensionais, ou seja, você pode observar os vetores como uma es-
trutura que recebe um conjunto de valores de um mesmo tipo de dado, o que caracteriza o fato de ser
homogêneo, e que possuirá um conjunto de valores que podem ser observados como armazenados em
uma tabela contendo apenas uma linha, e um valor predefinido de colunas, o que caracteriza o fato de ser
unidimensional. A imagem a seguir exemplifica uma estrutura de um vetor.
0 1 2 3 4 5 6
Carlos André M. A.
(2018)
Ao criar um vetor, é reservado um espaço na memória para armazenar as informações contidas neste
vetor, e esse espaço terá como base a quantidade de itens a serem armazenados e o tamanho em bytes
que cada um destes itens irá ocupar. Para o cálculo da quantidade de bytes necessárias para cada posição,
tem-se como base o tipo do dado, o que também define quantos bytes são necessários para armazenar
esse valor.
Na imagem acima, pode-se observar um vetor com sete posições, o que define o seu tamanho. Em cada
uma dessas posições é possível armazenar um valor, lembrando que todos os valores devem corresponder
a um mesmo tipo de dado a ser definido na criação do vetor.
Os valores observados anteriormente de cada uma das posições do vetor são chamados de índices, e é
a partir dos índices que é possível atribuir ou obter um valor correspondente a uma determinada posição.
Para a maior parte das linguagens de programação, a primeira posição de um vetor é representada
pelo índice zero, enquanto a última posição de um vetor é representada pelo índice n-1, ou seja, pelo ta-
manho do vetor menos um. Assim, observando a imagem contendo o vetor apresentado como exemplo,
identifica-se que esse vetor possui sete posições, ou seja, um tamanho igual a 7 e os índices referentes às
posições iniciam em 0, o qual é o padrão na maioria das linguagens de programação, e finalizam em 6, que
corresponde ao cálculo de n-1, nesse caso, um vetor de 7 posições menos 1, totalizando 6. Portanto, os
índices para acesso as posições deste vetor vão de 0 até 6.
São muito comuns erros ao utilizar vetores causados pela tentativa de acesso a po-
FIQUE sições inexistentes. Fique ligado quanto ao índice inicial do vetor na linguagem de
programação que você estiver utilizando, pois essa informação irá definir o índice
ALERTA final do vetor. Caso o inicial for 0, o final será n-1, porém, caso o inicial for 1, o final
será “n”.
6 ESTRUTURAS HOMOGÊNEAS
79
É de extrema importância obedecer aos limites de um vetor, pois, nesse caso, se você tentar acessar
uma posição não reservada, vamos dizer, a posição 10, obterá um erro informando que este índice não
pertence aos limites do vetor.
Para a criação de um vetor no Visual G, você deve seguir a seguinte regra:
<identificador do vetor> : vetor [<índice inicial>..<índice final>] de

<tipo de dado>
Para uma melhor exemplificação, veja como fica a criação de um vetor de inteiro, contendo 10 posições
para armazenar as notas de um aluno.
var
notas : vetor[0..9] de inteiro
Nesse caso, você tem um vetor identificado pelo nome “notas”, que tem seu índice inicial em zero e
índice final em 9, totalizando 10 posições, que deverão ser preenchidas com dados do tipo inteiro. Vale
lembrar que o tipo de dado que o vetor irá armazenar pode ser qualquer um disponível na linguagem de
programação, como inteiro e caractere. Porém, não será possível criar um vetor que aceite mais de um tipo
de dado, afinal, eles são homogêneos.
Agora que você já sabe como criar um vetor, irá aprender a inserir e obter valores de um vetor. Toda a
manipulação de um vetor é feita por intermédio do seu índice, sendo que você definirá o índice inicial e
final na criação do vetor. Lembrando que, na maioria das linguagens de programação, o índice inicia em
zero, portanto, a fim de minimizar as dificuldades ao migrar do Visual G para qualquer linguagem de pro-
gramação, é recomendado que você inicie na posição 0 até a posição n-1.
Para inserir um valor em uma posição específica de um vetor, você precisa de duas informações básicas,
o nome do vetor e a posição deste vetor onde deseja adicionar o valor. Veja um exemplo:
notas[0] := 20
80
Nesse caso, está sendo atribuído o valor 20 para a posição referente ao índice 0 do vetor denominado
notas. Sempre que você desejar atribuir um valor para um vetor é essa sintaxe que deve seguir. Os colche-
tes são um padrão para definir o índice do vetor a ser acessado, tanto que você utiliza os colchetes para
definir a posição inicial e final do vetor na sua criação. Portanto, lembre-se, para atribuir um valor a um
vetor, precisará do nome do vetor, entre colchetes adicionará a posição do vetor na qual deseja inserir o
valor, a qual deve ser uma posição existente, e, por fim, atribua o valor desejado a essa posição do vetor.
Segue-se o mesmo conceito para obter um dos valores armazenados em um vetor. Para isso, você tam-
bém precisará do nome do vetor e, entre colchetes, definir a posição onde está armazenado o valor. Assim,
será retornado o valor correspondente a posição. No exemplo apresentado a seguir, optou-se por utilizar o
comando “escreval” para apresentar a nota correspondente a posição de índice 3 do vetor. Como as posi-
ções do vetor iniciam em zero, isso significa que o índice 3 do vetor corresponde ao seu quarto elemento.
escreval(notas[3])
Aqui foi utilizado o “escreval” para apresenta o valor referente ao índice indicado apenas como exempli-
ficação, porém todos os tipos de operações podem ser realizados com base no valor disponível no índice
solicitado, afinal, você está obtendo um valor correspondente aquela posição do vetor, o que lhe possibi-
lita utilizar para os fins que desejar. Veja, a seguir, um exemplo que demonstra a possibilidade de realizar
uma adição com base em três valores armazenados em um vetor.
Var
numeros : vetor[0..2] de inteiro
soma : inteiro
Inicio
numeros[0] := 5
numeros[1] := 3
leia(numeros[2])
soma := numeros[0] + numeros[1] + numeros[2]
escreval(soma)
Fimalgoritmo
Nesse caso, são criadas as variáveis “números”, que corresponde a um vetor de inteiros com três posi-
ções, que vão de 0 até 2, e uma variável denominada soma do tipo inteiro. Referente ao algoritmo, foram
utilizadas duas formas para atribuir valores as posições do vetor, a primeira, correspondente as posições 0
e 1, consiste em uma atribuição simples, ou seja, é apenas definido um valor para ser atribuído a estas po-
sições do vetor. Referente ao índice 2, é utilizado o comando “leia” para solicitar um valor ao usuário, e este
valor será armazenado no índice do vetor. Após as atribuições dos valores ao vetor, é realizada a adição,
81
quando é atribuída à variável soma a adição correspondente aos valores armazenados nas três posições do
vetor, para ao final apresentar este resultado ao usuário utilizando o comando “escreval”.
Até aqui, você aprendeu o que é um vetor, como criá-lo e como atribuir e recuperar valores das posições
de um vetor. Agora, pense na seguinte situação, como você deve proceder para solicitar ao usuário as dez
notas de um aluno, para armazená-las, cada uma em uma posição do vetor? Provavelmente uma das ideias
que você teve consiste no seguinte algoritmo.
Var
Inicio
escreval(“Digite a 1ª nota”)
leia(numeros[0])
leia(numeros[1])
leia(numeros[2])
leia(numeros[3])
leia(numeros[4])
leia(numeros[5])
leia(numeros[6])
leia(numeros[7])
leia(numeros[8])
leia(numeros[9])
Fimalgoritmo
Obviamente, esse algoritmo funcionará, porém veja o tamanho do algoritmo apenas para solicitar
o valor correspondente a 10 notas e armazenar em um vetor, meio extenso você não acha? Agora
pense o seguinte, e se você tiver 100 notas para preencher, quantas vezes mais terá que repetir essas
linhas de código?
82
Como você deve imaginar, existe sim uma forma melhor e mais lógica de realizar essa implementação,
e essa forma consiste em utilizar comandos de repetição, mais especificamente, o comando PARA. Pri-
meiramente, veja o exemplo a seguir utilizando o comando de repetição PARA a fim de preencher as dez
posições do vetor de notas, para, na sequência, acompanhar uma explicação detalhada do algoritmo.
Var
notas : vetor[0..9] de inteiro
i : inteiro
Inicio
para i de 0 ate 9 passo 1 faca
escreval(“Informe a “, (i+1), “ª nota”)
leia(notas[i])
fimpara
fimalgoritmo
Referente a este algoritmo, inicialmente, cria-se o vetor de notas com 10 posições que correspondem
aos índices de 0 até 9, e uma variável inteira denominada “i”, a qual será utilizada como controle do coman-
do de repetição “para”. Como você pode observar, dessa vez não foi repetido o mesmo código 10 vezes
para solicitar as notas. Ao invés, foi utilizado o comando de repetição “para”, o qual utilizará a variável “i”
como controle, que iniciará em 0 e finalizará em 9, incrementando 1 a cada passo. Dessa forma, a cada
repetição é impresso na tela uma mensagem para que o usuário informe a nota e, na sequência, é feita a
leitura, armazenando o valor digitado na posição referente ao valor da variável “i”. Com isso, como o va-
lor da variável “i” será incrementado a cada repetição, cada valor digitado será armazenado em uma
posição diferente.
Por exemplo, inicialmente, o valor da variável “i” é 0, portanto, o valor digitado será armazenado na
posição 0 do vetor. No próximo ciclo de repetição do comando “para”, a variável “i” será incrementada
em 1, portanto, como o valor digitado é armazenado na posição correspondente ao valor da variável 1, o
próximo valor será armazenado na posição 1. Assim, as leituras vão sendo gravadas nas posições seguintes,
até atingir a última posição que é representada pelo índice 9. O que você achou? Dessa forma o código fica
bem mais simples e limpo, não?
No exemplo apresentado, você pôde observar que foi utilizada a seguinte operação
para escrever um valor para o usuário dentro do comando de repetição:
CURIOSI (i+1)
DADES Mas por que utilizar esta operação? O motivo é que o valor de “i” referente ao co-
mando de repetição inicia em 0, e para não apresentar ao usuário a mensagem
“Informe a 0ª nota”, utiliza-se do valor da variável adicionando 1 para apresentar um
valor que corresponda com o que deve ser feito.
83
No exemplo anterior, você viu como utilizar um comando de repetição para preencher um vetor com
dados solicitados pelo usuário, porém o comando “para” pode ser utilizado para qualquer ação que se de-
seja realizar junto a um vetor. Outros exemplos clássicos que utilizam o comando de repetição “para” junto
a um vetor é a realização de uma busca por um valor específico em um vetor, a realização da ordenação de
valores em um vetor, a busca para uma inserção ordenada em um vetor, entre inúmeras outras situações
que existem onde a interação entre o comando de repetição e o vetor são necessárias.
Para apresentar mais um exemplo, será desenvolvido um algoritmo um pouco mais complexo, o qual
consiste em preencher um vetor de cinco posições com valores aleatórios que podem estar entre os núme-
ros zero e vinte, para, na sequência, solicitar que o usuário tente acertar quais foram os cinco valores sor-
teados. O algoritmo finalizará apenas quando o usuário acertar todos os cinco números. A seguir, você po-
derá verificar o exemplo para, na sequência, acompanhar uma descrição passo a passo sobre o algoritmo.
Var
i, tentativa, acertos : inteiro
Inicio
numeros[i] := Randi(50)
fimpara
acertos := 0
enquanto acertos < 5 faca
escreval(“Digite um número de 0 a 50”)
leia(tentativa)
se (numeros[i] <> -1) e (numeros[i] = tentativa) entao
escreval(“Você acertou o número”)
numeros[i] := -1
acertos := acertos + 1
fimse
fimpara
fimenquanto
escreval(“Parabéns! Você acertou os 5 números”)
Fimalgoritmo
Como de costume em todos os algoritmos, inicialmente são declaradas as variáveis que serão necessá-
rias. Nesse caso, você pode observar um vetor de inteiros denominado números que possui cinco posições,
com índices de 0 a 4, e três variáveis do tipo inteira, a variável denominada “i”, a ser utilizada para controle
do comando de repetição “para”, a variável “tentativa”, que receberá as entradas realizadas pelo usuário e
84
a variável “acertos”, que iniciará em zero e terá o incremento de um a cada acerto do usuário. Após a decla-
ração das variáveis, é iniciada a codificação da lógica do algoritmo.
Primeiramente, é utilizado um comando de repetição “para”, que utiliza a variável de controle denomi-
nada “i” iniciando em zero e finalizando em 4 incrementando 1 a cada repetição. Esse comando de repeti-
ção tem como objetivo passar por todas as posições do vetor para definir qual valor cada posição receberá.
Como o intuito do algoritmo é solicitar que o usuário acerte os números, é utilizada uma função do Visual
G para obter um número aleatório. Essa função é denominada “Randi”, onde Rand significa randômico e a
letra i significa inteiro, ou seja, ela gera um número inteiro aleatório. Entre parênteses, é definido o limite
do valor aleatório que será gerado, o qual sempre inicia em zero e finaliza no valor passado entre parênte-
ses, nesse caso, será gerado um número aleatório inteiro entre 0 e 50.
Após a definição dos valores que cada posição do vetor receberá, os quais serão aleatórios, inicia-se a
solicitação de valores para que o usuário acerte os cinco números sorteados. Para tanto, primeiramente, é
definido que a variável acertos iniciará com o valor zero, isso porque esta variável será utilizada para geren-
ciar o comando de repetição enquanto, o qual será executado até que o valor da variável acertos seja igual
a 5, ou seja, até que o usuário acerte os cinco valores sorteados.
A cada repetição do comando enquanto, é solicitado que o usuário informe um número de 0 a 50. Para
isso, utilizou-se o comando escreval para informar o usuário o que deve fazer, e o comando leia para arma-
zenar o número digitado pelo usuário na variável tentativa. Após o usuário digitar um número, é iniciada
a execução de um comando “para” a fim de passar por todas as posições do vetor verificando se o valor
correspondente aquela posição é diferente de -1 e se o valor digitado pelo usuário, que está armazenado
na variável tentativa, é igual ao valor da posição referente a variável “i” correspondente ao vetor números.
Como você está utilizando um comando de repetição, a cada tentativa todas as posições serão verificadas.
Caso a verificação de igualdade entre o valor da tentativa e o valor correspondente a uma das posições
do vetor for verdadeira, é apresentada uma mensagem informando que o usuário acertou um número, o
valor correspondente à posição onde o usuário acertou o número é alterado para -1, com isso o mesmo
número não poderá ser acertado duas vezes, e o valor correspondente a variável “acertos” é incrementado
em 1. Por fim, após acertar os cinco valores armazenados no valor números, o comando de repetição “en-
quanto” é finalizado e uma mensagem de parabéns é apresentada.
Com esse exemplo, você pode observar um algoritmo mais complexo, utilizando vetores junto aos de-
mais conteúdos abordados anteriormente. Além disso, uma lógica mais elaborada foi utilizada para geren-
ciamento do vetor e dos acertos, utilizando, inclusive, um comando de repetição dentro do outro.
Confira no “Casos e relatos” a seguir o desafio de um desenvolvedor.
85
CASOS E RELATOS
Um desenvolvedor recebeu o desafio de obter um vetor de 10 posições e copiar os valores deste

vetor de forma invertida para um outro vetor de 10 posições, ou seja, o valor referente à posição 0
do primeiro vetor deverá ser o valor da posição 9 do segundo vetor. Após inúmeras tentativas, o
desenvolvedor sempre caía no mesmo problema: como, em um comando de repetição, trabalhar
com uma variável que incrementa e outra que decrementa ao mesmo tempo? Foi quando seu co-
lega de trabalho sinalizou que ele deveria trabalhar com duas variáveis, uma que irá ser controlada
pelo comando de repetição “para”, e outra que deverá ser controlada pelo próprio desenvolver
dentro do bloco de código referente ao comando de repetição “para”. Com essa ideia, o algoritmo
foi desenvolvido rapidamente, e a tarefa foi finalizada.
Uma das aplicações mais comuns de vetores consiste na sua utilização para a realização de ordenação
de valores. Imagine que você receba um vetor com valores desordenados, distribuídos de forma aleatória
entre as posições, e que precise ordená-lo, colocando os valores em ordem crescente. Para isso, existem
algoritmos famosos e validados chamados de algoritmos de ordenação, e entre os mais comuns têm-se o
Bubblesort, MergeSort e QuickSort. Você verá a seguir a aplicação do método Bubblesort, porém, sinta-se
desafiado para buscar aprender também sobre o método MergeSort e QuickSort.
O método BubbleSort consiste em percorrer um vetor diversas vezes e, a cada repetição, comparar os
elementos dois a dois, realizando a troca caso não estejam na ordem correta. A cada repetição, garante-se
que o último valor do vetor estará ordenado. Veja a seguir uma simulação do algoritmo.
5 3 1 4 2
5 3 1 4 2
3 5 1 4 2
3 1 5 4 2
3 1 4 5 2
3 1 4 2 5

86
Veja que inicialmente você tem um vetor desordenado da seguinte forma {5,3,1,4,2}. O objetivo da
primeira repetição é garantir que a última posição do vetor esteja com o maior valor existente, portanto,
partindo da posição 0, os valores serão verificados em pares e, caso o valor da esquerda for maior que o da
direita, deverá ser realizada a troca. Primeiro, o valor da posição 0, que é 5 será comparado com o valor da
posição vizinha, no caso 1, obtendo-se o valor 3. Como o valor 5 é maior que o valor 3, eles serão trocados
de posição. Na sequência, o valor correspondente a posição 1 é comparado com o valor correspondente
ao seu vizinho, a posição 2. Como anteriormente houve uma troca, novamente é pego o valor 5 e com-
parado, dessa vez, com o valor 1, e novamente é feita a troca. Esse procedimento seguirá até que o valor
correspondente à última posição seja comparada com o valor correspondente a penúltima posição, neste
caso, o valor 5, que estava na posição 0 inicialmente, é o maior valor do vetor, portanto, ao término desta
repetição, o valor 5 estará na última posição do vetor, garantindo que esta posição já se encontra ordena-
da. Veja agora o próximo ciclo de repetição:
3 1 4 2 5
3 1 4 2 5
1 3 4 2 5
1 3 4 2 5
1 3 2 4 5
O objetivo agora é garantir que a penúltima posição esteja ordenada, portanto, o mesmo processo exe-
cutado anteriormente será executado, realizando as trocas necessárias, porém, dessa vez, a última posição
do vetor não entrará nas comparações, pois se sabe que está ordenado. Portanto, após todas as trocas, o
valor 4 ficou na penúltima posição, garantindo também que esta posição se encontra ordenada.
Esse procedimento irá ocorrer até que sobre apenas a primeira e a segunda posição, de forma que, será
feita a verificação entre as duas e, caso necessário, a troca. Após, é garantido que o vetor estará ordenado,
conforme a imagem a seguir:
87
1 2 3 4 5
1 2 3 4 5
1 2 3 4 5

1 2 3 4 5
Após analisar de forma gráfica o funcionamento do método BubbleSort, veja a seguir como é imple-
mentado o algoritmo para executar este método de ordenação.
Algoritmo “bubblesort”
Var
vet : vetor[0..9] de inteiro
i, j, k, aux : inteiro
Inicio
vet[i] := Randi(50)
fimpara
para i de 8 ate 1 passo -1 faca
para j de 0 ate i passo 1 faca
k := j+1
se vet[j] > vet[k] entao
aux := vet[j]
vet[j] := vet[k]
vet[k] := aux
fimse
fimpara
fimpara
Fimalgoritmo
88
Se você analisar o algoritmo, verá que está fazendo exatamente o que foi descrito anteriormente com
o auxílio das imagens. Nesse caso, inicialmente são adicionados valores aleatórios ao vetor, para que seja
possível ordená-los posteriormente.
Na sequência, estão os dois comandos de repetição “para”. O primeiro é o responsável por gerenciar
quantas posições ainda faltam ser ordenadas, portanto, essa repetição inicia em 8, que corresponde ao
penúltimo índice do vetor, e finaliza em 1, decrementando um da variável de controle “i” a cada repetição.
O segundo comando de repetição é utilizado para analisar os valores em pares, um por um, para caso
necessário realizar as trocas. Veja que essa repetição é controlada por uma variável denominada “j”, a qual
é diferente do outro comando de repetição que utiliza a variável de controle “i”, isso ocorre para que uma
repetição não interfira na outra. Além disso, esse segundo comando de repetição inicia no índice 0 e finali-
za no índice correspondente ao valor da variável “i”. Isso ocorre pelo fato que você viu anteriormente, que,
ao término de cada repetição do primeiro comando “para”, o último índice correspondente do vetor será
considerado ordenado, portanto, não é mais necessário verificá-lo.
Referente às trocas, perceba que uma variável denominada “k” é utilizada para armazenar o índice vizi-
nho ao valor representado pela variável “j”. Caso o valor correspondente ao índice “j” seja maior que o valor
correspondente ao índice “k”, então a troca é feita. Essa troca ocorre em três etapas:
1º) o valor correspondente ao índice “j” é atribuído a variável “aux”;
2º) a posição do vetor correspondente ao índice “j” recebe o valor correspondente ao índice “k”;
3º) a posição do vetor correspondente ao índice “k” recebe o valor correspondente a variável “aux”, a
qual contém o valor antigo correspondente ao índice “j”.
Após todas as repetições finalizarem e o valor da variável “i” chegar a 1, significa que você tem como
resultado um vetor ordenado de forma crescente.
Agora que você obteve uma boa base sobre vetores, e acompanhou dois exemplos para a sua utiliza-
ção, você vai avançar mais nos estudos e aprender a utilizar matrizes.
6.2 MATRIZES
Também consistem em uma estrutura de dados homogênea, porém bidimensional. Quando se fala em
matrizes, não se trabalha apenas com uma linha e diversas colunas com informações, mas sim com um
conjunto de linhas e colunas, em que o índice de uma linha junto ao índice de uma coluna aponta para
uma determinada célula, que conterá um valor correspondente ao tipo da matriz. Veja a seguir uma ima-
gem que demonstra de forma gráfica uma matriz e os seus índices.
89
0 1 2 3 4

4
Fonte: Fonte: Do autor (2018)
A partir dessa ilustração, é possível compreender de uma melhor forma a estrutura de uma matriz.
Nesse caso, você vê uma matriz 5x5, ou seja, uma matriz com 5 linhas e 5 colunas, onde o índice inicial é 0
e o índice final é 4. Também é possível observar que cada cruzamento de linha com coluna nos leva a uma
célula específica, onde será armazenado o valor correspondente a esta célula.
Você pode relacionar o conceito de matrizes com um jogo de batalha naval. Relembrando, o objetivo
de um jogo de batalha naval é atingir todos os navios do seu adversário, para tanto, deve indicar um núme-
ro e uma letra, chegando a uma célula específica. O tabuleiro desse jogo pode ser observado na imagem
a seguir:
A B C D E F G H I J A B C D E F G H I J
1 1
2 2
3 3
4 4
5 5
6 6
7 7
8 8
9 9
10 10
Figura 5 - Batalha naval

Fonte: Adaptado de Ainda sou do tempo (2016)
90
Portanto, você pode falar, por exemplo, A2, o que significa que você está indicando a célula referente
a coluna A e linha 2. Dessa forma, o jogo continua até que alguém atinja todos os navios do adversário.
Você conseguiu identificar a semelhança do jogo batalha naval com os conceitos de matrizes? Muito seme-
lhante não? A única diferença é que matrizes em lógica de programação não trabalham com letras, apenas
números para indicar tanto as linhas quanto as colunas.
Agora que você já compreendeu o conceito de matrizes, você irá verificar como codificar matrizes no
Visual G. Inicialmente, você vai conhecer a sintaxe de criação de uma matriz, a qual é muito semelhante à
criação de um vetor, porém, trabalhando de forma bidimensional.
Var
<nome da matriz> : vetor[<índice inicial das linhas>..<índice final
das linhas>, <índice inicial das colunas>..<índice final das colunas]
de <tipo de dado>
A principal diferença para a sintaxe dos vetores é que você precisa definir dois conjuntos de índices de
início e fim, separados por vírgula. Esses índices normalmente representam linhas e colunas, respectiva-
mente. Para uma melhor compreensão, veja um exemplo de criação de uma matriz.
Var
matriz : vetor[0..4, 0..4] de inteiro
Está sendo criada uma estrutura homogênea bidimensional denominada matriz, do tipo inteiro, com
as linhas iniciando no índice 0 e finalizando no índice 4. Da mesma forma, as colunas iniciarão no índice 0
e finalizarão no índice 4. Como você pode observar, toda estrutura de dados homogênea é denominada
vetor no Visual G, apenas alterando a quantidade de dimensões que são definidas na sua criação.
Para inserir valores nas células de uma matriz, é preciso chamá-la pelo seu identificador e informar o
índice da linha e da coluna onde deseja adicionar este valor. No exemplo abaixo, estamos adicionando o
valor 20 na célula referente à linha 2 e coluna 1.
matriz[2, 1] := 20
Quando quiser obter um valor referente a uma célula de uma matriz, deve-se chamar a matriz pelo seu
identificador e informar os índices correspondentes à linha e à coluna, respectivamente. Feito isso, você
obterá o valor correspondente à célula, o qual pode utilizar para imprimir ou realizar operações, conforme
a necessidade do algoritmo. Veja alguns exemplos:
91
escreval(matriz[2, 1])
matriz[0, 0] := matriz[0, 1] + matriz[0, 2]
multiplicacao := matriz[1, 1] * matriz[2, 2]
Na primeira linha, apenas está sendo impresso o valor correspondente à linha 2 e coluna 1 da matriz.
Na segunda linha, está sendo atribuído à linha e coluna zero da matriz a adição entre os valores correspon-
dentes à linha 0 e coluna 1 e à linha 0 e coluna 2 da matriz. Por fim, na terceira linha, a variável denominada
multiplicação está recebendo o resultado da multiplicação entre o valor da linha 1 e da coluna 1 e o valor
da linha 2 e da coluna 2 da matriz.
Assim como para os vetores, também é possível utilizar estruturas de repetição a fim de passar por to-
das as células de uma matriz para realizar operações como escrita, leitura, verificações, entre outras. Porém,
quando se trata de uma matriz, por ser uma estrutura bidimensional, é necessário utilizar dois comandos
de repetição “para”, caso contrário não será possível passar por todas as linhas e colunas de uma matriz.
Isso torna essa estrutura um pouco mais complexa, portanto, você deve analisar e compreender perfeita-
mente o exemplo a seguir, dessa forma, compreenderá a utilização das estruturas de repetição para passar
por toda a matriz.
Var
matriz : vetor[0..4,0..4] de inteiro
linha, coluna : inteiro
Início
para linha de 0 ate 4 passo 1 faca
para coluna de 0 ate 4 passo 1 faca
escreval(“Digite um valor para a célula [“, linha, “][”, coluna, “]”)
leia(matriz[linha, coluna])
fimpara
fimpara
Nesse exemplo, é criada uma matriz de inteiro com as linhas e as colunas indo do índice 0 até o índice
4, e duas variáveis a serem utilizadas para controle das estruturas de repetição “para”, uma denominada
linha e outra denominada coluna.
Na sequência, são utilizados dois comandos de repetição “para”, um dentro do outro. O primeiro co-
mando de repetição é utilizado para iterar sobre as linhas, iniciando em 0 e finalizando em 4. Para cada
repetição da linha, é executado todo o segundo comando de repetição, o qual é utilizado para iterar sobre
as colunas, as quais neste exemplo também vão de 0 até 4. Portanto, a cada repetição de uma linha, passa-
-se por todas as colunas, e apenas após a última coluna irá passar para a próxima linha, conforme apresen-
92
tado por intermédio de setas na imagem abaixo. A fim de uma melhor exemplificação, inicialmente será
selecionada a primeira linha da matriz, no caso a de índice 0. Posteriormente, será executando o segundo
comando de repetição que passará por todas as colunas, ou seja, primeiro será a linha 0 e coluna 0, na se-
quência a linha 0 e coluna 1, até chegar na linha 0 e coluna 4. Após, como finalizaram as colunas da matriz,
passará para a próxima linha, e iniciará o mesmo processo para a linha 1, passando por todas as colunas
novamente. Isto continuará até chegar a última linha e última coluna, no caso, linha 4 e coluna 4.
Por fim, para cada conjunto de linha e coluna, é executado um comando “escreval” solicitando que o
usuário digite um valor e um comando leia, o qual obterá um valor inteiro do usuário e armazenará na linha
e coluna correspondente as variáveis.
0 1 2 3 4
3
Agora que você já conhece todos os conceitos referentes a estruturas homogêneas bidimensionais, no
caso, matrizes, irá analisar mais um exemplo, mais complexo, a fim de fortalecer o seu conhecimento.
Esse exemplo consiste em um algoritmo que contará com uma matriz bidimensional 3x3, a qual terá
seus valores definidos aleatoriamente, e verificará se a matriz gerada é uma matriz identidade, uma
matriz nula ou nenhuma das opções. Veja a seguir o código do algoritmo para posteriormente analisar
a sua execução.
93
Var
matriz : vetor[0..2,0..2] de inteiro
linha, coluna : inteiro
identidade, nula : logico
Inicio
//Definindo valores aleatórios para a matriz
matriz[linha,coluna] := Randi(2)
fimpara
fimapra
//Verificando se é uma matriz identidade
identidade := verdadeiro
se (linha-coluna = 0) entao
se (matriz[linha,coluna] <> 1) entao
identidade := falso
fimse
senao
identidade := falso
fimse
fimse
fimpara
fimpara
//Verificando se é uma matriz nula
nula := verdadeiro
nula := falso
fimse
fimpara
fimpara
//Comparando as variáveis lógicas.
se identidade = verdadeiro entao
escreval(“Matriz Identidade”)
senao
se nula = verdadeiro entao
escreval(“Matriz Nula”)
94
senao
escreval(“A matriz não é identidade nem
nula”)
fimse
fimse
Fimalgoritmo
Como todo algoritmo, este inicia pela sessão de declaração de variáveis, que contém a declaração da
matriz a ser utilizada, a qual foi denominada “matriz” do tipo inteiro e definida como 3x3, iniciando no ín-
dice 0 e finalizando no 2, tanto para linha quanto para coluna. Também foram definidas as variáveis linha
e coluna do tipo inteiro, a serem utilizadas como variáveis de controle da estrutura de repetição “para”
e duas variáveis lógicas, denominadas identidade e nula, que serão utilizadas para ao final do algoritmo
identificar se a matriz corresponde a uma das duas situações.
Para a execução do algoritmo, inicialmente serão definidos os valores para cada célula desta matriz.
Para tanto, são utilizados os dois comandos de repetição “para” que servem para passar por todas as linhas
e colunas da matriz. E para cada conjunto de linha e coluna, e gerado um valor aleatório utilizando a função
Randi passando como limite para o número a ser gerado o número 2. Nesse caso, será sorteado um valor
entre 0 e 1, pois o limite é descartado.
O motivo para a geração de um número aleatório tão pequeno, que fica apenas entre dois números
na verdade, é por conta de querermos identificar uma matriz nula ou identidade. Lembrando que uma
matriz nula consiste em todas as posições da matriz serem 0, enquanto a identidade consiste na diagonal,
da esquerda superior para a direita inferior, conter apenas o número 1, enquanto o restante da matriz é
composto por 0.
Após definir os valores para a matriz, deve-se iniciar as verificações para saber se ela é identidade ou
nula. Nesse exemplo, optou-se por se iniciar verificando se a matriz é identidade, portanto, antes de iniciar
a verificação, define-se que o valor da variável lógica denominada identidade é verdadeiro, ou seja, antes
da verificação presume-se que você tem uma matriz identidade.
Para a verificação, são utilizados novamente os dois comandos de repetição “para” a fim de passar por
todas as linhas e colunas da matriz. Para cada célula, verifica-se se a subtração do valor referente a variável
linha pelo valor referente a variável coluna é 0. Caso for, significa que está sendo verificada uma das diago-
nais, que neste caso são compostas por [0,0], [1,1], [2,2]. Portanto, caso estiver em uma diagonal, verifica-se
se o valor correspondente a esta célula é diferente de 1; se for, significa que não você não tem uma matriz
identidade, portanto, o valor da variável lógica denominada identidade é definido como falso. Agora, caso
a subtração da linha pela coluna não for zero, significa que não você não está em uma diagonal, portanto,
verifica-se se o valor da célula é diferente de zero; se for, significa que você não tem uma matriz identidade,
portanto, o valor da variável lógica denominada identidade é definido como falso.
Veja que, como você partiu do princípio que a matriz é identidade, definindo a variável inicialmente
como verdadeira, deve utilizar as estruturas de repetição para testar a hipótese contrária, ou seja, se a ma-
95
triz não é identidade. Portanto, caso passe por todas as células sem entrar em nenhum dos comandos de
seleção SE, significa que a matriz é identidade e o valor da variável continuará verdadeiro.
A mesma lógica é utilizada para testar se a matriz é nula. Para tanto, define-se inicialmente que o valor
da variável lógica denominada nula será verdadeiro, e novamente utiliza-se as duas estruturas de repeti-
ção “para” a fim de passar por todas as células da matriz e analisar todas as células. Para cada repetição,
é verificado se o valor correspondente à linha e à coluna em questão é diferente de 0. Caso seja, significa
que você não tem uma matriz nula, portanto, o valor da variável denominada nula é definido como falso.
Por fim, são feitas as verificações para saber se o valor de uma das variáveis lógicas, identidade ou nula,
ficou verdadeiro. Caso o valor da variável identidade seja verdadeiro, significa que a matriz é identida-
de. Utilizou-se o senão para realizar a próxima verificação, pois não existe a possibilidade de a matriz ser
identidade e nula ao mesmo tempo, portanto, apenas se a matriz não for identidade que será realizada a
verificação se a matriz é nula. Por fim, caso também não for nula, apresenta-se uma mensagem dizendo
que não é nenhuma das duas.
Aprenda mais sobre os conceitos de vetores e matriz no seguinte link, onde você en-
SAIBA contrará inclusive exemplos utilizando outras linguagens de programação.
MAIS <https://pt.wikibooks.org/wiki/Algoritmos_e_Estruturas_de_Dados/Vetores_e_Matri-
zes>.
Com todos esses conceitos e exemplos, você já é capaz de analisar e utilizar estruturas homogêneas
unidimensionais e bidimensionais para auxiliar na resolução de algoritmos. O próximo passo é compreen-
der como utilizar arquivos na resolução de algoritmos.
Leia o “Recapitulando” a seguir e reveja os principais conceitos estudados neste capítulo.
RECAPITULANDO
Neste capítulo, você conheceu as estruturas homogêneas unidimensionais e bidimensionais, tam-

bém conhecidas como vetores e matrizes, respectivamente. Você compreendeu os conceitos so-
bre essas estruturas e também aprendeu como utilizá-las, assim como teve a oportunidade de ver
e analisar algoritmos complexos utilizando estruturas como o jogo de adivinhação dos números
para os vetores e a verificação de matrizes para descobrir se são identidade ou nula. Continue os
estudos para conhecer sobre a utilização de arquivos junto à lógica de programação para a reso-
lução de algoritmos.
Manipulação de Arquivos
Neste último capítulo, você compreenderá como realizar a manipulação de arquivos utili-
zando linguagem de programação. Para tanto, você aprenderá como criar um novo arquivo ou
abrir um arquivo já existente e realizar a leitura e escrita de dados neste arquivo. Ao término,
será apresentado um exemplo utilizando os arquivos para armazenamento de informações jun-
to a todo o conteúdo abordado anteriormente nesta apostila.
a) criar arquivos utilizando linguagem de programação;
b) manipular arquivos utilizando linguagem de programação.
98
7.1 CRIAÇÃO E MANIPULAÇÃO DE ARQUIVOS
Você aprendeu a realizar leituras do teclado, para realizar a captura de informações a partir do usuário
e a realizar escritas na tela, para apresentar informações para os usuários. Além dessas opções, também
é possível e muito comum realizar as escritas e leituras por intermédio de arquivos. Esse método é muito
utilizado quando se deseja armazenar as informações obtidas para utilizações futuras ou, principalmente,
para viabilizar a partir de um arquivo uma sequência de informações a serem utilizadas para testar um al-
goritmo. Dessa forma, ao invés de digitar as informações todas as vezes para testar as funcionalidades de
um algoritmo, é possível buscar essas informações do arquivo.
O Visual G, por ser uma linguagem desenvolvida com base em pseudocódigo que prioriza o ensino de
lógica de programação, não possui um dos melhores suportes à utilização de arquivos, porém nos permite
obter o conhecimento necessário referente a este assunto. Todas as linguagens de programação irão per-
mitir realizar manipulação de arquivos, geralmente por intermédios de funções como realizar a criação de
um arquivo, verificar a existência de um determinado arquivo, abrir um arquivo para edição, escrever no
arquivo, ler informações do arquivo e deletar um arquivo.
No Visual G, você pode informar o caminho de um arquivo para um determinado algoritmo. Caso
este arquivo já exista, o algoritmo apenas poderá realizar a leitura das informações nele contidas, porém,
caso o arquivo não exista no diretório indicado, será realizada a criação deste arquivo e será permitida
a gravação de informações neste arquivo. Veja a seguir a sintaxe para a definição da utilização de um
arquivo no Visual G.
Algoritmo “Nome do Algoritmo”

arquivo “Caminho para o arquivo\nome do arquivo.txt”
Var
//Seção de Declarações das variáveis
Inicio
//Seção de Comandos
Fimalgoritmo
Na segunda linha, deve ser informado o caminho do arquivo e seu nome, e ao realizar isso, todo o algo-
ritmo passará a trabalhar com base nesse arquivo. Caso você defina o nome do arquivo conforme demons-
trado a seguir, o Visual G realizará a busca de um arquivo com este nome no diretório principal do Visual
G. encontre, realizará a leitura deste, caso contrário, criará um novo arquivo com este nome no diretório.
7 MANIPULAÇÃO DE ARQUIVOS
99
arquivo “exemplo.txt”
Caso seja de interesse indicar um diretório específico para o armazenamento do arquivo, deverá ser
informado todo o caminho para este diretório na hora da definição do arquivo, conforme apresentado no
código a seguir, o qual armazena o arquivo na pasta c:
arquivo “C:\exemplo.txt”
FIQUE Tome cuidado com o caminho do arquivo que você irá determinar, é preciso que
você tenha permissão de escrita e leitura a pasta indicada, caso contrário um erro irá
ALERTA ocorrer.
Veja que em ambas as situações, o formato do arquivo criado é do tipo TXT. Este é o único formato acei-
to pelo VisualG, pois é o mais simples dos formatos. Outras linguagens de programação irão permitir criar
arquivos PDF, DOCX, XLSX, entre outros, porém, dificilmente você encontrará estas essas funcionalidades
de forma nativa nas linguagens de programação, sendo necessário adicionar bibliotecas ao seu código, a
fim de permitir a criação e manipulação desses tipos de arquivos.
Para trabalhar com leitura e escrita de dados em arquivos, é necessário utilizar o comando LEIA do Vi-
sual G. Quando estiver escrevendo em um arquivo, toda vez que o comando LEIA for executado, e que o
usuário entrar com informações por intermédio do teclado e pressionar a tecla ENTER, uma linha com as
informações digitadas será registrada no arquivo de texto. Por outro lado, sempre que você estiver reali-
zando a leitura de um arquivo, quando utilizado o comando LEIA, este não irá solicitar que o usuário entre
com um dado, irá ler uma linha do arquivo, a qual será impressa na tela e também pode ser armazenada
em uma variável.
Para exemplificar, primeiramente, você irá analisar um exemplo de escrita de dados em um arquivo.
Este exemplo, apresentado a seguir, criará um arquivo denominado pessoas.txt na pasta raiz onde está
localizado o seu Visual G.
100
Algoritmo “Nomes”
Arquivo “pessoas.txt”
Var
pessoa : caracter
i : inteiro
Inicio
escreval(“Digite um nome”)
leia(pessoa)
fimpara
Fimalgoritmo
Como você pôde observar, após a definição do nome do algoritmo, foi definido o arquivo para criação
denominado pessoas.txt. Na sequência, é definida a variável denominada pessoa do tipo caractere, a qual
será utilizada para receber o nome das pessoas e uma variável inteira denominada “i” para gerenciar o
controle de repetição. Para a execução do algoritmo, é definido um comando de repetição “para” que
repetirá 10 vezes, e a cada repetição será apresentada uma mensagem ao usuário solicitando um nome, e
será realizada a leitura de um nome que será digitado pelo usuário. Nesse momento, o comando leia, além
de obter a digitação do usuário, também escreverá no arquivo definido anteriormente. Portanto, cada um
dos dez nomes que forem digitados será armazenado em uma linha deste arquivo. Para testar, execute
o algoritmo, digite os dez nomes e, na sequência, abra a pasta onde foi descompactado o seu Visual G e
verifique o arquivo criado.
De forma semelhante pode ser feita a leitura dessas linhas do arquivo criado. Para tanto, será criado um
novo algoritmo, que utilizará o mesmo arquivo e realizará a leitura dos dados nele contidos. Lembrando
que, para que a leitura aconteça, será necessário que este arquivo já exista. Veja a seguir o exemplo de
algoritmo de leitura.
101
Algoritmo “LerPessoas”
arquivo “pessoas.txt”
Var
pessoas : vetor[0..9] de caracter
i : inteiro
Inicio
leia(pessoas[i])
fimpara
Fimalgoritmo
Para este algoritmo, também após o seu nome é definido o arquivo que será utilizado, nesse caso, o
mesmo do exemplo anterior, o qual é denominado pessoas.txt, e parte-se do princípio que este já foi cria-
do e preenchido, existindo dentro da pasta onde o Visual G foi descompactado no seu computador. Para
as variáveis, é criado um vetor de caractere com dez posições, que vão do índice 0 ao índice 9, denominado
pessoas. Perceba que esse vetor possui exatamente a mesma quantidade de nomes que foram digitados
anteriormente. Além disso, também é definida a variável inteira denominada “i”, a qual será utilizada para
gerenciar o comando de repetição “para”.
Referente a execução do algoritmo, neste caso você quer apenas realizar a leitura do arquivo. Para tan-
to, é definido um comando de repetição “para”, que irá de 0 até 9, ou seja, será executado 10 vezes. A cada
repetição, o comando LEIA é executado, como você está trabalhando com a leitura de um arquivo, este
comando não irá solicitar dados para o usuário, mas sim realizar a leitura de uma linha do arquivo e arma-
zenar o seu conteúdo na posição correspondente ao valor da variável “i” no vetor de pessoas. Ao término
das 10 repetições, todas as linhas deste arquivo terão sido lidas, portanto, qualquer novo comando LEIA
será executado normalmente, solicitando uma informação para o usuário.
Lembre-se de que um arquivo estará em situação de escrita ou leitura, não é possível ler todo um ar-
quivo para posteriormente voltar a escrever neste, ao menos não no Visual G; em outras linguagens de
programação este tipo de ação é aceita.
102
Nos exemplos mostrados aqui, sempre foi criado um arquivo utilizando um algorit-
mo desenvolvido no Visual G para posteriormente realizar a leitura deste, porém,
CURIOSI não é obrigatório criar um arquivo por intermédio de algoritmo para realizar a leitu-
DADES ra. Você pode criar um arquivo de texto com os valores específicos para reproduzir
um teste, por exemplo, e apenas realizar a leitura deste arquivo utilizando um algo-
ritmo. Isso é válido e muito utilizado em lógica de programação..
Agora que você já aprendeu como é feita a escrita e leitura de arquivos, você conhecerá dois algoritmos,
um para trabalhar a escrita, que solicitará os nomes e notas de um aluno, e outro para trabalhar a leitura,
que obterá os dados para executar o cálculo da média.
Algoritmo “InformarNotas”
arquivo “notas.txt”
Var
nota : real
numNotas, numAlunos, contNotas, contAlunos : inteiro
nomeAluno : caracter
Inicio
escreval(“Informe a quantidade de alunos a serem cadastrados”)
leia(numAlunos)
escreval(“Informe o número de avaliações realizadas”)
leia(numNotas)
para contAlunos de 1 ate numAlunos passo 1 faca
leia(nomeAluno)
para contNotas de 1 ate numNotas passo 1 faca
escreval(“Informe a nota “, contNotas)
leia(nota)
fimpara
fimpara
Fimalgoritmo
Nesse primeiro algoritmo, você está realizando a leitura dos dados para a construção do documento.
Inicialmente, define-se que iremos trabalhar com um arquivo e que seu nome é notas.txt. Na sessão de va-
riáveis, são definidas todas as necessárias para o processo. A variável denominada nota do tipo real, as vari-
áveis numNotas e numAlunos do tipo inteiro, que receberão a quantidade de notas que serão informadas
para cada aluno e a quantidade de alunos que serão cadastrados. As variáveis contNotas e contAlunos, que
103
serão utilizadas para controle dos comandos de repetição “para”, e por fim, uma variável do tipo caractere
denominada aluno, a qual receberá o nome dos alunos.
Antes de iniciar a compreensão do algoritmo, vale lembrar que, por ter sido definido um arquivo, e por
este arquivo ainda não existir, todas as informações fornecidas pelo comando LEIA serão gravadas neste
arquivo.
Inicialmente, é solicitado quantos alunos serão cadastrados, e esta informação é armazenada na pri-
meira linha do arquivo. Posteriormente, é solicitado quantas notas serão digitadas para cada aluno, infor-
mação que é armazenada na segunda linha do arquivo. Portanto, as duas primeiras linhas consistem em
informações sobre a quantidade de iteração necessárias para realizar a leitura do arquivo.
Após, iniciam-se as repetições, a primeira tem como base a quantidade de alunos, portanto, para cada
repetição será solicitado o nome do aluno, e será realizada outra repetição para solicitar as notas, que
possuem como base para a quantidade de iterações o número de notas que será digitado para cada aluno
informado anteriormente. Todo o processo de solicitar o nome do aluno e suas notas repetirá de acordo
com os números informados no início, e ao término, a estrutura do arquivo notas.txt deve ser a seguinte:
<quantidade de alunos>
<quantidade de notas>
<nome do aluno 1>
<nota 1 do aluno 1>
<nota 2 do aluno 1>
...
<nota n do aluno 1>
<nome do aluno 2>
<nota 1 do aluno 2>
<nota 2 do aluno 2>
...
<nota n do aluno 2>
...
<nome do aluno n>
<nota 1 do aluno n>
<nota 2 do aluno n>
...
<nota n do aluno n>
104
É de grande importância a definição de uma estrutura para facilitar o processo de leitura deste arquivo,
portanto, é sempre preciso conhecer a forma como o arquivo foi escrito para possibilitar o desenvolvimen-
to do algoritmo que realizará a sua leitura, o qual é apresentado na sequência.
Algoritmo “leituraNotas”
arquivo “notas.txt”
Var
aluno : caracter
media, nota : real
contAlunos, contNotas, numAlunos, numNotas : inteiro
Inicio
leia(numAlunos)
leia(numNotas)
leia(aluno)
media := 0
leia(nota)
media := media + nota
fimpara
media := media + nota
escreval(“Média Final: “, media)
se media >= 7 entao
escreval(“Aprovado”)
senao
se media >= 5 entao
escreval(“Em exame”)
senao
escreval(“Reprovado”)
fimse
fimse
fimpara
Fimalgoritmo
105
Este algoritmo, além de realizar a leitura para obter as notas, também realiza e apresenta o cálculo
da média, assim como a verificação da situação do aluno, podendo esta ser “Aprovado”, “Em exame” ou
“Reprovado”.
Observe que este algoritmo também define o arquivo notas.txt para utilização, portanto, trabalhará so-
bre o arquivo que foi escrito no algoritmo anterior. Como variáveis, foram definidas as necessárias para ler
as informações do arquivo, iterar sobre o comando de repetição e realizar o cálculo da média, para tanto,
você tem uma variável denominada “aluno” do tipo caractere, as variáveis “nota” e “média” do tipo real e
as variáveis “contAlunos”, “contNotas”, “numAlunos” e “numNotas” do tipo inteiro.
A primeira coisa que o algoritmo faz é ler as duas primeiras linhas do arquivo, que contém o número de
alunos e o número de notas que foram digitados, respectivamente. Essas informações são armazenadas
nas variáveis que foram denominadas “numAlunos” e “numNotas”.
Na sequência, inicia-se o processo de leitura dos nomes dos alunos e suas notas. Para tanto, são utiliza-
dos comandos de repetição “para”, o primeiro, para obter os alunos, utiliza a variável de controle “contAlu-
nos” iniciando em 1 e finalizando com base no valor obtido para a variável “numAlunos”. Para cada aluno,
realiza a leitura de uma linha do arquivo, a qual contém o nome do aluno, e armazena na variável deno-
minada aluno, na sequência, define que o valor da variável média inicia em 0 e realiza a repetição para ler
todas as notas deste aluno, que utiliza a variável “contAlunos” para controle da repetição que vai de 1 até
o número de notas lido no início do algoritmo. Para cada repetição, realiza a leitura da nota no arquivo, ar-
mazena a informação na variável denominada nota e acrescenta este valor ao valor atual da variável média.
Ao final da leitura das notas, é realizado o cálculo das médias, para o qual é utilizado o valor da soma de
todas as notas, a qual foi armazenado na variável média, e divido pelo número de notas, o qual foi lido no
início do algoritmo. Após, é apresentada a média e são realizadas verificações para caso a média seja maior
ou igual a 7, informar que o aluno está aprovado. Caso não seja maior ou igual a 7, mas for maior ou igual
a 5, informa que o aluno está em exame. Caso contrário, o aluno estará reprovado. Vale ressaltar que essa
iteração acontecerá até a leitura do último aluno cadastrado.
Com base nesse exemplo, você pode observar uma utilização de arquivos para inicialmente armazenar
informações e posteriormente ler estas informações para processá-las.
Reveja, no “Recapitulando” a seguir, os principais conceitos estudados neste capítulo.
106
RECAPITULANDO
Neste capítulo, você conheceu sobre a criação e manipulação de arquivos utilizando a lingua-
gem Visual G, e compreendeu que outras linguagens de programação podem possuir recursos
mais avançados para realizar este processo. Aprendeu como escrever e ler em arquivos, e como
aplicar estes recursos com base em um exemplo de leitura e processamento de notas de alunos.
Dessa forma, você chegou ao final dos seus estudos sobre lógica de programação, mas lembre-
-se de nunca pare de praticar, pois a melhor forma de compreender e praticar a sua lógica é
desenvolvendo.
Trabalho em Equipe,
Planejamento e
Organização do Trabalho
A competitividade do mercado global gera cada vez mais a necessidade de as organizações

buscarem profissionais que auxiliem no desenvolvimento da empresa. As competências téc-
nicas, isoladamente, não se sustentam mais. Com isso, é necessário que o profissional seja um
diferencial no mercado também com relação a outras habilidades e capacidades. Hoje existe
nas organizações uma grande valorização do trabalho em equipe, dos relacionamentos inter-
pessoais, de métodos e técnicas que venham a otimizar o trabalho. Partindo deste pressuposto,
neste capítulo, você irá conhecer alguns fatores importantes do bom relacionamento interpes-
soal nas organizações, do planejamento e organização do trabalho e da ética profissional. Essas
informações são importantes, pois irão lhe auxiliar nas atividades do dia a dia e no relaciona-
mento no ambiente de trabalho. Partindo destes estudos, você terá subsídios para:
a) compreender como as habilidades básicas de relacionamento interpessoal são importan-
tes nas relações de trabalho;
b) reconhecer a importância do planejamento e organização do trabalho;
c) entender o conceito de ética;
d) conhecer os diferentes tipos de pesquisa;
e) entender o conceito de qualidade, melhoria contínua e os conceitos de eficiência e eficácia.
Você irá iniciar seus estudos entendendo o que são as equipes de trabalho. Vamos lá?
110
8.1 COMPORTAMENTO E EQUIPES DE TRABALHO
Hoje em dia, muitas empresas têm adotado o termo “colaborador” para fazer referência aos seus fun-
cionários.
Atualmente, os resultados empresariais estão diretamente relacionados à participação conjunta desses
colaboradores, ou seja, as equipes bem estruturadas permitem que todos os integrantes somem esforços.
Para entender essa relação sobre o comportamento e equipes de trabalho, você irá estudar, a seguir, o
homem como ser social.
8.1.1 O HOMEM COMO SER SOCIAL
O homem é um ser que vive em sociedade e se relaciona com outros seres. De acordo com a descrição
de Barroco (2009, p. 20),
o ser social passa a construir mediações – cada vez mais articuladas –, ampliando seu
domínio sobre a natureza e sobre si mesmo. Desse modo, sem deixar de se relacionar
com a natureza – pois precisa dela para se manter vivo – vai moldando sua natureza
social.
Pelo fato de o homem ter características de um ser pensante, não pode ser impedido de conviver em
sociedade. Ele é, por natureza, um ser sociável.
Esta forma particular de fixação e transmissão das aptidões humanas

se deve à atividade fundamental humana: o trabalho (LEONTIEV, 2004).
O ponto de partida para a humanização do homem é justamente o trabalho e as relações que a partir
dele se estabelecem. É claro que a sociedade tem bastante influência na constituição desse homem social,
e o trabalho, que não é resultado de uma ação individual, estabelece relações e determina as demais rela-
ções da vida social do homem.
CURIOSI De acordo com Iamamoto e Carvalho (1988), os homens estabelecem determinados

vínculos e relações mútuas, por meio das quais exercem uma ação transformadora
DADES da natureza, ou seja, realizam a produção..
8 TRABALHO EM EQUIPE, PLANEJAMENTO E ORGANIZAÇÃO DO TRABALHO
111
O trabalho é, portanto, fator preponderante do homem como ser social. Isto é, o homem é o produto
da vida em sociedade e da adaptação à cultura em que foi inserido. Dessa forma, o homem passa a se apo-
derar de valores, comportamentos e conhecimentos adquiridos por meio da vivência em grupo, e isso é
definido por humanização.
8.1.2 O PAPEL DAS NORMAS DE CONVIVÊNCIA EM GRUPOS SOCIAIS
Para que haja uma boa convivência entre todos os homens dentro da sociedade, valores e algumas
regras básicas de convivência são cruciais para garantir harmonia. São alguns desses valores e regras: o di-
álogo, o estabelecimento de limites, o acompanhamento da educação, a honestidade, a responsabilidade,
o respeito, os cuidados com a natureza e o saber ouvir.
As normas de convivência sustentam a ordem social. Essas normas, mais conhecidas como boas manei-
ras, permitem-nos conviver com os outros e manter uma sociedade digna de se viver. Essas boas práticas
diárias permitem uma evolução de nós mesmos enquanto seres sociais, nos tornando melhores e mais
felizes, portanto, vale a pena aplicar e internalizar esses hábitos que, muito provavelmente, nos tornarão
mais disciplinados e tolerantes em todos os nossos ambientes de convívio social.
Millann (2018)
Imagina o caos se não houvessem essas normas ou se elas não fossem respeitadas pela maioria. Elas
estão ao alcance de todos, portanto, cabe a cada um de nós fazer a sua parte.
112
8.1.3 A INFLUÊNCIA DO AMBIENTE DE TRABALHO NO COMPORTAMENTO
O ambiente em que serão realizadas suas atividades podem ressaltar o pior ou o melhor de cada cola-
borador. Isto é, muitos fatores do ambiente de trabalho podem alterar os resultados do seu trabalho.
FIQUE Um excelente vendedor pode fazer uma grande venda e alguém mais adiante na ca-
ALERTA deia produtiva atrapalhar a entrega do produto.
Tanto se fala de trabalho em equipe e na interdependência de tarefas, não é mesmo? Portanto, torna-
-se cada vez mais fundamental que os ambientes de trabalho sejam organizados para permitir e incentivar
uma comunicação eficaz.
De acordo com Cohen (1999), os resultados mais desejáveis no ambiente de trabalho incluem altos
níveis de produtividade, de satisfação dos colaboradores e um contínuo aprendizado e aperfeiçoamento
profissional.
É importante avaliar o seu ambiente de trabalho em termos de ruídos, privacidade, ergonomia e
organização. Verifique se em sua empresa não há um programa de melhoria na qualidade de vida no am-
biente de trabalho.
A qualidade de vida no ambiente de trabalho claramente influencia a produtividade.

O ambiente deve facilitar o desenvolvimento de suas tarefas diárias
Para tanto, as organizações devem desenvolver e implantar programas específicos que envolvam o
grau de satisfação do colaborador com o ambiente de trabalho, como: o melhoramento das condições am-
bientais gerais; a promoção da saúde e segurança; a integração social; o desenvolvimento das capacidades
humanas; entre outros fatores.
A Organização Mundial da Saúde (2010) dimensiona a saúde, o bem-estar e a segu-

rança no trabalho como aspectos de fundamental importância na produtividade,
competitividade e sustentabilidade das organizações: “A riqueza do negócio depen-
CURIOSI de da saúde dos trabalhadores” e define local de trabalho saudável como aquele
em que “trabalhadores e gestores colaboram em um processo contínuo de melhoria
DADES para proteger e promover a saúde, o bem-estar, a segurança e sustentabilidade do
local de trabalho” (Organização Mundial da Saúde. Healthy workplaces: a model for
action. For employers, workers, policy-makers and practitioners. 2010. Disponível em:
<www.who.int>).
113
Afinal, as pessoas tendem a ser mais produtivas e a estarem mais satisfeitas quando seu am-
biente de trabalho é capaz de proporcionar qualidade de vida.
8.1.4 FATORES DE SATISFAÇÃO NO TRABALHO
Encontrar maneiras de integrar e equilibrar o trabalho e a vida pessoal tem se mostrado muito favorável
atualmente.
Segundo Spector (2006), a satisfação do trabalho é uma variável de atitude que mostra como as pessoas
se sentem em relação ao trabalho que têm, seja no todo, seja em relação a algum de seus aspectos. O qua-
dro a seguir apresenta, segundo o autor, os principais fatores de satisfação no trabalho.
SALÁRIO OPORTUNIDADES DE PROMOÇÃO BENEFÍCIOS

Supervisão Companheiros de trabalho Condições de trabalho
Natureza do trabalho Comunicação Segurança
Quadro 1 - Facetas comuns da satisfação no trabalho
Fonte: Spector (2006)
A satisfação no trabalho deve ser avaliada conforme o sentimento do colaborador em relação as suas
atividades. A figura a seguir representa os fatores de satisfação no trabalho segundo Zanelli, Borges-An-
drade e Bastos & Cols (2004).
O Trabalho
Cliente Promoções
VISÃO
MULTIDIMENSIONAL
DE SATISFAÇÃO
NO TRABALHO
Colegas Salário
Figura 6 - Os Cinco fatores de satisfação no trabalho numa abordagem multidimensional

Fonte: Adaptado de Zanelli, Borges-Andrade e Bastos & Cols (2004)
114
É possível concluir que a satisfação resulta em desempenho, ou seja, as pessoas que gostam do seu
trabalho se empenharão mais e, consequentemente, terão um desempenho melhor. Além disso, conforme
Spector (2006), o desempenho também gera satisfação, isto é, pessoas com bom desempenho tendem a
se beneficiar, e os benefícios podem aumentar a satisfação.
Você vai conhecer agora alguns aspectos relacionados a relacionamento Interpessoal. Acompanhe!
8.1.5 RELACIONAMENTO INTERPESSOAL
Você sabia que o relacionamento interpessoal é de extrema importância para um bom ambiente
de trabalho?
Um relacionamento interpessoal positivo entre dois ou mais membros de uma equipe de trabalho con-
tribui para um clima saudável e colaborativo dentro de uma empresa, e quando se conhece as pessoas e se
faz uso da empatia, fica mais fácil resolver os problemas e partilhar as soluções.
Jacoblund (2018)
Conforme destacado por Pereira (2014), você deve se esforçar para desenvolver qualidades que irão
contribuir para o relacionamento interpessoal.
A seguir, confira algumas dessas qualidades.
a) Autoconhecimento – quanto mais você se conhece, mais compreende sua maneira de ser, suas
qualidades e limitações. Assim poderá reconhecer o outro como ele é e aceitá-lo com suas qualidades
e limitações também. Isso permitirá que você administre melhor os relacionamentos.
b) Respeito – você deve manifestar atitudes gentis e evitar as más condutas. Respeitar os mais humil-
des, cumprimentar com carinho as pessoas, não fazer parte de fofocas, não ser ríspido, acalmar os
ânimos e dizer o quanto todos são importantes.
115
c) Cordialidade – tratar as pessoas com cordialidade é ser gentil, solícito e simpático, é demonstrar
consideração pelo outro de várias formas. Por exemplo, pode ser com o “bom dia” com que se cum-
primenta um colega de trabalho na mensagem de e-mail.
d) Disciplina – a disciplina obriga você a ter comprometimento com suas atividades diárias, sejam elas
simples, rotineiras ou bastante complexas. Manter a disciplina no local de trabalho é vital para você
contribuir para um ambiente de trabalho seguro e confortável para seus colegas de trabalho e para a
administração.
e) Empatia – muitas vezes, para você manter um entendimento com outra pessoa, precisa se colocar
no lugar dela e compreender seu ponto de vista. Isso é empatia, a habilidade de você considerar os
outros, suas opiniões, sentimentos e motivações. Entre as várias coisas que se pode fazer para praticá-
-la, a mais básica é saber ouvir.
f) Responsabilidade – tornar-se uma pessoa mais responsável requer de você mais atitude do que um
simples desejo de mudança, é uma transformação de dentro para fora nas pessoas que não têm, ou
uma questão de atitude para as que têm. Quando você não é responsável, raramente alguém terá
confiança em seu trabalho e também no seu desejo de ajudar alguém.
g) Comunicação – imagine um assistente administrativo que não consegue responder de forma clara
a seu líder, relatar suas atividades, seus resultados, compartilhar suas ideias e se relacionar bem com
os colegas. O seu dia a dia exigirá que saiba expor argumentos firmes e coerentes de forma clara e
objetiva. Por isso, saber como se posicionar e conversar em diferentes situações profissionais é uma
competência fundamental para você alcançar o sucesso. Comunicação não é apenas saber falar, mas
também saber ouvir.
h) Cooperação – se você ouvir o outro, respeitar, acolher, compartilhar ideias e decisões, demonstrará
atitudes que mostram cooperação.
Um ambiente de trabalho é composto de pessoas, mas um ambiente no qual as pessoas não trabalham
juntas de uma maneira positiva nunca alcançará todo o seu potencial.
i) Assertividade – para ter relacionamentos saudáveis, não basta você ouvir. É preciso que você expres-
se suas opiniões de forma franca, direta, clara, serena e respeitosa.
Essas são algumas das qualidades que você deve desenvolver para manter um bom ambiente de traba-
lho em sua empresa. Outro assunto bastante discutido nas empresas é a questão da ética, assunto muito
importante que será tratado na sequência. Acompanhe!
8.1.6 PLANEJAMENTO E ORGANIZAÇÃO NO LOCAL DE TRABALHO
No mundo corporativo, o planejamento é a identificação dos objetivos de uma organização a fim de tra-
çar metas para atingi-lo, identificando os recursos, dados e a melhor forma de utilizar os meios disponíveis
para o fim desejado. Pensando em você como profissional, poderá realizar um planejamento pessoal, no
qual você pode estabelecer suas próprias metas pessoais e/ou profissionais.
116
Para que você possa realizar um planejamento que seja eficaz, você deve considerar as prioridades.
Assim, o essencial é ordenar as prioridades segundo alguns critérios, como:
a) urgência;
b) praticidade;
c) menor custo;
d) grau de dificuldade ou facilidade;
e) prazer.
Você deve, ainda, priorizar critérios nesse processo, sejam eles de tempo, de execução e/ou custo
de execução.
Jat306 (2018)
É muito importante que o local de trabalho esteja sempre limpo e organizado, evitando perda de do-
cumentos, atraso na realização de tarefas, entre outros. Descarte tudo o que não é necessário e organize
de forma que facilite o seu acesso quando necessário. Dessa forma, a tendência é que seu trabalho seja
realizado com mais qualidade.
A seguir, acompanhe o “Casos e relatos” que demonstra a importância do planejamento e da organiza-
ção no ambiente de trabalho.
117
RECAPITULANDO
A importância do planejamento e organização

Franciele, estagiária de uma grande empresa de desenvolvimento de software, está um pouco
atrapalhada com suas atividades e percebeu que suas tarefas diárias começaram a acumular e ela
não conseguia mais cumprir os prazos de entregas solicitadas pelo seu gestor. A última entrega
que ela precisava fazer era o levantamento de alguns fornecedores, porém Franciele não localizou
todos os contratos e demorou muito para entregar a relação dos fornecedores para o seu gestor.
Como sua situação estava ficando crítica, Franciele resolveu pesquisar sobre como ela poderia
planejar e se organizar para executar suas tarefas diárias.
Durante a pesquisa, Franciele descobriu uma ferramenta chamada 5S e resolveu utilizá-la para
organizar seu posto de trabalho. Os colegas de Franciele observaram o movimento de limpeza das
gavetas, eliminação de papéis não utilizados, enfim, e resolveram “entrar no clima”.
Foi um dia divertido, em que todos trabalharam em equipe organizando seu ambiente de traba-
lho como um todo. Franciele ficou animada, pois além do apoio dos seus colegas, pode ver sua
mesa mais limpa e organizada, assim ela poderá localizar os documentos necessários com mais
facilidade.
Dando continuidade aos seus estudos, a seguir você irá entender o que é ética e a sua importância no
ambiente de trabalho.
8.2 ÉTICA
É muito comum você ouvir dizer que “isso” ou “aquilo” não é ético. “Eu faço assim porque eu sou “ético”
e até há os que digam “se ele fosse ético como eu agiria dessa forma”.
Mas você já pensou sobre o que realmente significa ética?
Ética significa os valores morais e princípios que orientam o homem dentro de uma sociedade. Serve
para equilibrar as atitudes sociais, não devendo ser confundida com lei, pois a ética está relacionada a sen-
timentos de justiça social.
118
CURIOSI Você sabia que existem países que aceitam a utilização e o sacrifício de animais para
pesquisas científicas, e outros países não aceitam? Nesses países que não aceitam,
DADES utilizar animais seria um desrespeito ao princípio ético..
A ética é construída com base em valores culturais e históricos da sociedade. Existe também ética para
determinados grupos, como ética profissional, ética educacional, ética médica, ética nos esportes, ética na
política, entre outras.
A seguir, você irá entender o que é a ética no ambiente de trabalho. Confira!
8.2.1 ÉTICA NO AMBIENTE DE TRABALHO
Uma conduta ética no trabalho também é essencial para que você alcance sucesso profissional. A ética
profissional é necessária para o bom andamento da empresa, tanto nas atividades diárias quanto nas
relações entre os colaboradores.
Dentre as vantagens, é possível citar que a ética no trabalho proporciona:
a) ambiente de trabalho agradável;
b) aumento e agilidade na produção;
c) maior interação entre os colegas de trabalho.
A ética no trabalho compreende o compartilhamento de informações e respeito entre colegas de tra-
balho e à hierarquia, gera um clima agradável que surge por meio de ações e do comportamento dos
colaboradores (bom humor), respeito às regras e normas da empresa, entre outros.
Desprezar os serviços do concorrente é uma atitude antiética que pode ter grandes
FIQUE impactos, visto que pode ser percebida negativamente pelo consumidor, gerando
ALERTA desconfiança. Ou até mesmo falar mal do trabalho de um colega para seu chefe, essa
atitude causará má impressão.
Agir eticamente não é fácil num mercado de trabalho tão competitivo como o atual, mas são essas
diferenças de comportamento que fazem com que o colaborador se destaque e consiga ocupar melhores
cargos na empresa, pois deixa seus superiores com a certeza de que, em situações adversas, o colaborador
será justo e imparcial.
119
O comportamento do ser humano, em geral, é um tema muito rico e deve ser explorado com profundi-
dade, pois geralmente o diferencial das empresas de sucesso é o reflexo das relações humanas.
Agora que você já aprendeu o significado de ética e a importância da ética no ambiente de trabalho,
você irá estudar o que é qualidade e quais as suas ferramentas. Acompanhe!
8.3 QUALIDADE
A qualidade está relacionada à cultura, a um produto ou serviço, e à percepção do indivíduo, suas ex-
pectativas e necessidades, ou seja, o atendimento completo das necessidades de um cliente depende de
implantação de processos para uma melhoria contínua.
Hoje, fala-se muito sobre vários tipos de qualidade: qualidade de um produto, qualidade de um serviço,
qualidade de ensino, qualidade de vida.
Para todos esses casos, os objetivos são bem parecidos, pois a preocupação está em:
a) satisfazer as necessidades dos clientes – utilizar a qualidade de forma a atender o que o cliente neces-
sita com o que se produz na empresa;
b) aumentar a produtividade – utilizar a qualidade para diminuir custo e diminuir todas as falhas inter-
nas do produto ou serviço;
c) promover a realização socioprofissional dos trabalhadores – utilizar a qualidade para promover a mo-
tivação dos profissionais.
A qualidade pode, ainda, ser definida sob várias perspectivas que, apesar de diferentes, são comple-
mentares, como:
a) qualidade quanto ao desempenho do produto – o aumento da qualidade está relacionado ao au-
mento de custo, porém, gera satisfação sob a ótica do consumidor;
b) qualidade quanto à existência de deficiências – o objetivo é reduzir desperdícios, encargos após a
venda e melhoria da imagem da empresa, por meio do aumento da qualidade em todas as fases da
produção, motivando a diminuição do custo.
Segundo a ISO – International Organization for Standardization

(Organização Internacional para Padronização) –, o conceito de
qualidade é visto como “o grau no qual um conjunto de caracte-
rísticas inerentes satisfaz a requisitos”. (ABNT NBR ISO 9000:2005)
120
Qualidade pode, então, estar relacionada à conformidade do produto com relação às normas técnicas,
com a adequação do produto ao uso a que ele se destina, ou ainda a um produto com maior desempenho
e durabilidade.
DIMITRE CAMARGO MARTINS (2018);
Alguns atributos da qualidade de um produto são, por exemplo:

a) desempenho;
b) conveniência de uso;
c) disponibilidade;
d) confiabilidade;
e) mantenabilidade;
f) conformidade;
g) assistência técnica;
h) imagem, entre outros.
No próximo tópico, você irá estudar sobre a qualidade total. Acompanhe!
121
8.3.1 QUALIDADE TOTAL
Você já ouviu falar no termo Qualidade Total? Pois bem, a qualidade total é decorrente da aplicação da
melhoria contínua (Filosofia Kaizen) nos processos de uma organização e tem como objetivo implicar toda
a empresa, bem como fornecedores, distribuidores e demais parceiros.
Ela é um conjunto de ferramentas, programas e métodos aplicados no controle do processo de pro-
dução das empresas, a fim de obter bens e serviços pelo menor custo e melhor qualidade, objetivando
atender as exigências e a satisfação dos clientes.
A gestão pela qualidade total nada mais é do que uma estratégia que tem como objetivo central ma-
ximizar a competitividade da empresa, ou seja, ampliar sua eficiência e eficácia. Essa gestão é vista por
muitos como uma filosofia permeada por um conjunto de fundamentos, sustentada por um conjunto de
ferramentas e técnicas.
Quando se trata de qualidade, alguns termos acabam tendo o seu significado confundido, como é o
caso de “eficiência” e “eficácia”, que muitas vezes são empregados de forma incorreta. Confira a diferença
entre esses termos.
EFICIÊNCIA
A eficiência preocupa-se com os métodos, procedimentos e os meios para a melhor execução das coi-
sas, a fim de otimizar recursos (máquinas, matéria-prima, pessoas) e aplicá-los de forma racional. Eficiência
é realizar as coisas de maneira adequada, resguardar os recursos aplicados e resolver problemas.
EFICÁCIA
A eficácia indica o grau de sucesso obtido nos resultados. Ela visa aos resultados alcançados indepen-
dentemente dos recursos utilizados, ou seja, conseguir atingir o objetivo. É possível atingir o ótimo e con-
seguir a eficácia e eficiência juntas, de forma a obter o resultado almejado utilizando o mínimo de recurso.
Você pode atingir um resultado (eficácia), mas os recursos utilizados para atingir o resultado foram des-
proporcionais (falta de eficiência).
FIQUE Lembre-se de que a qualidade não é mais um diferencial, e sim essencial para a sus-
ALERTA tentabilidade das empresas.
122
A seguir, você continuará seus estudos aprendendo sobre pesquisa e seus principais tipos. Acompanhe!
8.4 PESQUISA
O termo pesquisa pode ser entendido como o “procedimento racional e sistemático que tem como
objetivo proporcionar respostas aos problemas que são propostos” (GIL, 2007, p. 17).
A pesquisa constitui um processo de várias etapas e seu desenvolvimento percorre a formulação do
problema até a apresentação dos resultados. É importante constar que uma pesquisa só terá o porquê de
ser iniciada se houver uma pergunta que a estruture, afinal o objetivo será encontrar a resposta para esse
questionamento.
A seguir você vai conhecer os diferentes tipos de pesquisa.
8.4.1 TIPOS DE PESQUISA
Existem diversos tipos de pesquisa, como, por exemplo: a pesquisa bibliográfica, a pesquisa de campo,
a pesquisa laboratorial e a pesquisa acadêmica. Na sequência, você vai conhecer um pouco sobre cada
uma delas.
PESQUISA BIBLIOGRÁFICA
A pesquisa bibliográfica, segundo Fonseca (2002, p. 32), é feita a partir do levantamento de referências
teóricas já analisadas e publicadas por meios escritos e eletrônicos, como livros, artigos científicos, páginas
de web sites.
Qualquer trabalho científico inicia-se com uma pesquisa bibliográfica, que permite ao pesquisador
conhecer o que já se estudou sobre o assunto. Porém, existem pesquisas científicas que se baseiam
unicamente na pesquisa bibliográfica, procurando referências teóricas publicadas com o objetivo
de recolher informações ou conhecimentos prévios sobre o problema a respeito do qual se pro-
cura a resposta.
PESQUISA DE CAMPO
A pesquisa de campo caracteriza-se pelas investigações em que, além da pesquisa bibliográfica, realiza-
-se a coleta de dados junto a pessoas. Essa coleta pode ser feita por meio de entrevistas, baseadas em al-
gum questionário físico, ou não. A pesquisa de campo é muito utilizada pelas empresas, que sempre estão
interessadas em identificar a opinião do seu público-alvo sobre alguma questão. Após a coleta, os dados
são analisados e interpretados conforme a fundamentação teórica escolhida.
123
PESQUISA LABORATORIAL
A pesquisa laboratorial ocorre em situações controladas. Como o próprio nome indica, são pesquisas
que acontecem, costumeiramente, nos ambientes de laboratório, pois fica mais fácil de controlar o item
que está sendo pesquisado. Para que você entenda melhor, pense em um estudo de sementes, por exem-
plo. Para que elas possam ser analisadas, é preciso que haja um ambiente próprio que monitore todos os
acontecimentos.
De acordo com o Portal Educação, a pesquisa acadêmica, por sua vez, é realizada nas instituições de en-
sino e sempre são acompanhadas e conduzidas por pesquisadores do tema em questão. O objetivo central
deste tipo de pesquisa é aprofundar o conhecimento em determinada disciplina de estudo.
8.4.2 ESTRUTURAÇÃO E MÉTODOS DE PESQUISA
A estruturação e os métodos de uma pesquisa variam conforme os autores, mas, habitualmente, é pos-
sível observar que a busca pelos materiais que serão utilizados nela é de suma importância. Definido o
tema da pesquisa, a coleta de dados pode ser iniciada. Deve-se ressaltar que o que se julga mais válido em
pesquisas é a verdade dos fatos. O desenvolvimento e a análise do autor vão compor a estrutura junto à
conclusão.
Quando se destaca a questão da verdade dos fatos, está se enfatizando o caráter ético que deve conter
nas pesquisas. Assim, torna-se possível garantir a veracidade das informações e a não discriminação de
qualquer dado durante a pesquisa.
Dito isso, é importante que você saiba também sobre a propriedade intelectual que abrange os direitos
relativos às pesquisas. Ou seja, é a área do Direito que garante, por meio de leis, a preservação do autor e
da sua obra.
Confira, a seguir, os principais conceitos estudados neste capítulo.
124
RECAPITULANDO
Neste capítulo, você pôde verificar a importância de desenvolver algumas habilidades básicas para
manter um bom relacionamento interpessoal nas relações de trabalho. Além disso, pôde verificar
como o planejamento e a organização do trabalho são fundamentais para se ter um bom desem-
penho em suas atividades profissionais. Estudou ainda sobre a ética no ambiente de trabalho e o
quanto a qualidade é indispensável para o alcance de resultados da organização. Para finalizar,
aprendeu o que é pesquisa e os seus principais tipos. Todos esses conhecimentos e habilidades
são fundamentais para que você seja um profissional de destaque no mercado de trabalho. No
próximo capítulo, você irá estudar sobre a segurança no trabalho. Siga em frente.
Segurança no Trabalho
Atualmente, muito tem-se falado sobre a saúde e segurança no trabalho. Como identificar
situações de risco no local de trabalho e como é possível evitar acidentes de trabalho são ques-
tões fundamentais e preocupação constante para qualquer organização. Esses são assuntos
centrais dentro das organizações e são sempre discutidos por meio de palestras, treinamentos
de prevenção a acidentes etc. Neste capítulo, você vai estudar temas relacionados à segurança
no trabalho. Aprenderá, entre outras coisas, a reconhecer riscos à saúde e segurança do traba-
lhador e as formas de proteção a esses riscos.
Ao final deste capítulo, você estará apto a:
a) entender o que são os acidentes de trabalho;
b) reconhecer os diferentes tipos de acidentes de trabalho;
c) identificar as possíveis causas de acidentes de trabalho;
d) compreender a importância da utilização dos equipamentos de proteção individual
e coletiva.
Para iniciar seus estudos, você vai entender o conceito de acidente de trabalho. Acompanhe!
128
9.1 ACIDENTES DE TRABALHO
O art. 19 da Lei n. 8.213/1991 define acidente de trabalho como aquele “que ocorre pelo exercício do
trabalho a serviço da empresa ou pelo exercício do trabalho”. Mas só será considerado acidente de tra-
balho quando provocada uma lesão corporal ou perturbação funcional que cause a morte, a perda ou a
redução (permanente ou temporária) da capacidade para o trabalho.
Perceba que são considerados acidentes de trabalho não apenas aqueles decor-
rentes de atividades laborais1 exercidas a cargo das empresas, mas também to-
dos os acidentes ocorridos no exercício de atividades laborais individuais ou em
regime de economia familiar.
Para entender melhor, são caracterizados como acidentes de trabalho:

a) aqueles ocorridos durante o trajeto entre a residência do trabalhador e a empresa;
b) doença profissional produzida pelo exercício de uma determinada tarefa;
c) doença do trabalho que pode ser adquirida ou desencadeada pelas condições em que a função
é exercida.
Na sequência, você aprenderá sobre três tipos de acidentes de trabalho.
9.1.1 TIPO DE ACIDENTES DE TRABALHO
Existem três tipos de acidentes de trabalho: acidente típico, de trajeto e doença profissional ou do tra-
balho. Conheça em detalhes cada um deles a seguir.
ACIDENTE TÍPICO
Esse tipo de acidente ocorre na execução da atividade profissional do indivíduo.

Pode-se considerar um acidente típico de trabalho, por exemplo, um carpinteiro que está construindo
um piso de madeira e, enquanto prega uma tábua, erra a martelada e acerta seu dedo.
1 Adjetivo que relaciona alguma coisa com o mundo do trabalho.

9 SEGURANÇA NO TRABALHO
129
Pojoslaw ([20--?])
Figura 7 - Acidente típico
ACIDENTE DE TRAJETO
Os acidentes de trajeto são aqueles que podem ocorrer no trajeto que o trabalhador faz de casa até o
trabalho e vice-versa, como, por exemplo, acidente de trânsito ou outros.
Um de acidente de trajeto, seria, por exemplo, um auxiliar de escritório que faz seu trajeto até o traba-
lho de motocicleta diariamente e, certo dia, durante o trajeto, ele colide sua motocicleta com um carro e
machuca o pescoço.
KatarzynaBialasiewicz (2018)
Figura 8 - Acidente de trajeto

130
DOENÇA PROFISSIONAL
A doença profissional ou do trabalho também é considerada um acidente e é desencadeada pelo exercí-

cio de uma determinada função que tem ligação com o ambiente onde a atividade profissional é exercida.
Um exemplo seria o caso de um profissional que trabalha com digitação e que, após anos executando
a mesma função, começa a sentir dores no punho, que são diagnosticadas como LER2 ou DORT3.
Você aprendeu o que é um acidente de trabalho e como pode ser caracterizado. E quanto às causas dos ChesiireCat (2018)
acidentes de trabalho? Siga em frente e confira.
9.1.2 CAUSAS DOS ACIDENTES DE TRABALHO
Você terá a oportunidade de aprender sobre as principais causas de acidentes de trabalho. Você vai
iniciar esse tópico estudando sobre os agentes agressores à saúde. Acompanhe!
2 LER: sigla para as Lesões por Esforços Repetitivos. A exposição a movimentos repetitivos com frequência elevada e agravada
por aspectos ergonômicos causa a LER.
A LER, uma vez diagnosticada e caracterizada como decorrente do trabalho, é caracterizada como uma DORT.
3 DORT: sigla para as Doenças Osteoarticulares Relacionadas ao Trabalho.
131
AGENTES AGRESSORES À SAÚDE
Agentes agressores também podem ser chamados de agentes ambientais. Os agentes agressores po-
dem ser: físicos, químicos, biológicos, ergonômicos e de acidentes, presentes nos ambientes de trabalho.
Esses agentes podem causar danos à saúde e à integridade física do trabalhador.
Na sequência, você conhecerá cada um dos tipos de agentes agressores. Acompanhe.
Agentes Físicos
Os agentes físicos estão presentes no ambiente de trabalho e são de naturezas diversas. Eles podem
ser ruídos, vibrações, radiações ionizantes, radiações não ionizantes, frio, calor, pressões anormais, umida-
de e luminosidade. Os agentes agressores estão diretamente relacionados com o ramo de atividade das
empresas. Por exemplo, em uma construtora, estarão presentes o ruído, frio, calor e umidade. Já em uma
fábrica de cosméticos, os agentes agressores presentes podem incluir também a luminosidade como um
fator de risco.
O trabalhador deve estar bem informado quanto ao prejuízo que cada um desses agentes oferece à sua
saúde e saber quais os meios necessários para que medidas de controle sejam adotadas, conforme o risco
a que está exposto.
Highwaystarz-Photography ([20--?])
Figura 9 - Representação do ruído em um ambiente de trabalho
Você já percebeu que quando fica por um período exposto a um som muito alto tem a impressão de
estar “surdo” por um tempo? Essa exposição por pequenos períodos dá esta sensação. Já se esses períodos
forem longos e frequentes, você acaba perdendo a audição gradativamente e permanentemente.
132
Agentes Químicos
Em muitas empresas, o contato com produtos químicos durante o processo produtivo é necessário. A
enorme utilização de produtos químicos acarreta grande incidência de doenças profissionais causadas por
esses produtos. Esses produtos podem ser encontrados nas formas líquida, gasosa, de vapores e sólida, e
podem penetrar no organismo pelas vias respiratórias, digestiva e, também, através da pele.
LIsherwood ([20--?])
Figura 10 - Óleo derramado no local de trabalho representa um agente químico
A efetiva proteção a esses riscos se inicia com a identificação de cada um deles. Mais à frente, você vai
conhecer os equipamentos de proteção para cada um desses riscos.
Agentes Biológicos
Os agentes biológicos desencadeiam doenças causadas por microrganismos, ou seja, bactérias, vírus,
fungos e protozoários adquiridos no exercício da atividade laboral. Eles podem ser encontrados em sanitá-
rios, hospitais, laboratórios, lavanderias e outros mais variados lugares.
133
ClaudioVentrella (2018)
Um aspecto muito importante para se evitar os riscos biológicos é a manutenção dos ambientes limpos!
Agentes Ergonômicos
A ergonomia estuda as relações entre o homem e o seu ambiente de trabalho. Os agentes ergonômicos
causadores de doenças se caracterizam por atitudes e hábitos profissionais prejudiciais à saúde, mas não
se limitam a isso.
Endopack (2018)
134
Outros aspectos como o mau dimensionamento de um posto de trabalho podem apresentar riscos para
o trabalhador, que pode estar sendo forçado a trabalhar com uma postura inadequada.
São exemplos de riscos ergonômicos: esforço físico intenso, posturas inadequadas, imposição de ritmos
excessivos, jornadas de trabalho prolongadas, e monotonia e repetitividade.
FIQUE O seu posto de trabalho está bem dimensionado? Você se sente confortável – ergo-
ALERTA nomicamente falando – em executar suas tarefas? Atente-se a isso!
Os problemas ergonômicos são muito comuns. Dores em certas partes do corpo como ombros e costas,
por exemplo, são comuns em pessoas que ficam muito tempo na frente de um computador em uma pos-
tura inadequada. Esses problemas podem ser diagnosticados como LER, que segundo o INSS, é o campeão
no ranking de afastamento do trabalho.
Você sabia que existem manuais que nos ajudam a garantir um posto de trabalho
ergonomicamente adequado? A Microsoft, grande multinacional norte-americana
que desenvolve softwares, desenvolveu um manual para orientar como trabalhar de
CURIOSI maneira saudável em frente a um computador.
DADES
Dê uma olhada no Guia de Saúde e Computadores e aprenda mais sobre o assunto.
O texto está disponível em: <http://www.microsoft.com/hardware/pt-br/support/
healthy-computing-guide>. Acesso em: 19 jun. 2018.
Uma vez que você estudou sobre as causas dos acidentes de trabalho, conhecerá agora os riscos desses
acidentes. Acompanhe na sequência.
9.1.3 RISCOS DE ACIDENTES
Os riscos de acidentes são os responsáveis por uma série de lesões nos trabalhadores, como cortes,
fraturas, escoriações e queimaduras.
Vale lembrar que, para que o acidente ocorra, é necessário que se tenha a combinação de vários fatores,
como, por exemplo: o tempo de exposição, a possibilidade de a pessoa absorver as substâncias químicas
ou biológicas e as condições do ambiente de trabalho. Por isso, a prevenção é de extrema importância e
deve ser constante.
135
Na sequência de seus estudos, você estudará sobre os equipamentos que protegem o trabalhador do
risco de acidentes.
9.1.4 EQUIPAMENTOS DE PROTEÇÃO INDIVIDUAL E COLETIVA
Você estudou que possivelmente está ou estará exposto a algum tipo de risco e que esse risco pode
trazer prejuízos para a saúde. Mas o que fazer para se proteger?
Para minimizar os riscos de acidentes, é preciso fazer o uso de Equipamentos de Proteção Individual
(EPI) e Equipamentos de Proteção Coletiva (EPC). A empresa contratante deve fornecer esses equipamen-
tos sempre que necessário.
Acompanhe os tipos de equipamentos que existem e como eles podem ajudar a proteger a saúde do
trabalhador.
EQUIPAMENTOS DE PROTEÇÃO INDIVIDUAL
Os Equipamentos de Proteção Individual são dispositivos ou produtos de uso individual do trabalhador,

destinados à proteção contra os riscos capazes de ameaçar a sua segurança e a sua saúde.
O quadro a seguir mostra os tipos mais comuns de equipamentos de proteção individual e suas aplica-
ções. Acompanhe!
136
TIPO DE EPI IMAGEM ILUSTRATIVA DESCRIÇÃO DO TIPO DE PROTEÇÃO
Proteção do crânio contra impactos, choques

Capacete elétricos e no combate a incêndios.
Proteção contra partículas, luz intensa, radia-

Óculos de Segurança
ção, respingos de produtos químicos.
Luvas de Segurança Proteção contra riscos químicos e físicos.
Proteção contra riscos de origem térmica, umi-

Sapato de Segurança
dade, produtos químicos e quedas.
Proteção contra quedas e alturas

Cintos de Segurança
superiores a dois metros.
Proteção respiratória Proteção contra gases, névoas, vapores e

(máscaras) poeiras.
Protetores auriculares Proteção contra ruídos.
Quadro 2 - Equipamentos de proteção individual mais comuns.

É importante lembrar que o uso do equipamento por parte do colaborador também é obrigatório sem-
pre que os riscos não forem eliminados com o uso de Equipamentos de Proteção Coletiva (EPCs).
Mas o que são os Equipamentos de Proteção Coletiva? Acompanhe a seguir!
EQUIPAMENTOS DE PROTEÇÃO COLETIVA
São dispositivos utilizados no ambiente de trabalho com o objetivo de proteger os trabalhadores dos
riscos inerentes aos processos. Como o nome diz, são equipamentos de proteção coletiva.
Por exemplo, um equipamento que emite muito ruído pode ser enclausurado acusticamente. Esse
equipamento pode ser fechado dentro de uma câmara com isolação acústica com a finalidade de reduzir
o nível de ruído no local de trabalho.
Acompanhe, na sequência, uma lista com os principais Equipamentos de Proteção Coletiva.
TIPO DE EPC IMAGEM ILUSTRATIVA DESCRIÇÃO DO TIPO DE PROTEÇÃO
Enclausuramento
Este EPC é usado para diminuir o ruído gerado por um
acústico de fontes de
determinado equipamento.
ruído
É utilizado para garantir a circulação de ar em ambientes

Ventilação dos locais
quentes ou mesmo ambientes poluídos com gases,
de trabalho
fumos e poeira.
São usadas para garantir que partes móveis de máquinas

Proteção de partes
não fiquem expostas. Essas proteções evitam que o cola-
móveis de máquinas
borador prenda partes de seu corpo nas máquinas.
Exaustores para Os exaustores servem para sugar gases e vapores de

gases e vapores ambientes fechados.
Tela/grade para
proteção de polias, Tem a mesma função das proteções de partes móveis de
peças ou engrena- máquinas.
gens móveis
Ar-condicionado/
São utilizados para garantir um padrão fisiologicamente
aquecedor para
aceitável de temperatura para a execução do trabalho.
locais frios
138
A sinalização de segurança serve para apontar de forma

Sinalização de segu- visual os perigos de um ambiente de trabalho. Também
rança é utilizada para delimitar áreas seguras de circulação de
pessoas com a demarcação de corredores.
Exemplo de EPC - 170438097
Serve como ponto de apoio para evitar quedas em

Corrimão
escadas.
Fitas antiderrapantes As fitas antiderrapantes servem para ser colocadas em

de degrau de escada pisos e escadas para evitar escorregões acidentais.
Visa a atender os limites aceitáveis de iluminação para a

Iluminação
execução do trabalho.
Piso antiderrapante Visa a evitar escorregões e quedas na área protegida.
O guarda-corpos oferece uma barreira em uma altura

Guarda-corpos mínima para que uma pessoa não corra o risco de cair de
uma determinada altura.
A sirene de alarme de incêndio é ligada a um dispositivo

Sirene de alarme
de disparo manual ou automático e serve para sinalizar
incêndio
uma emergência.
139
As cabines para pintura servem para limitar a área con-

taminada com tinta nos processos de pintura. Algumas
Cabines para pintura
cabines são dotadas de equipamentos que retiram a tinta
do ar como exaustores, filtros e barreiras de água.
Quadro 3 - Equipamentos de Proteção Coletiva.

Fonte: Adaptado do Portal da Educação (s.d)
O quadro mostra uma variedade de equipamentos de proteção coletiva. Esses são os mais comuns,
no entanto, existe uma infinidade de equipamentos para os mais variados tipos de riscos. A aplicação
correta dos EPCs pode eliminar um risco do ambiente de trabalho, tornando o uso de determinado EPI
desnecessário.
Na sequência, veja quais as orientações para prevenção de acidentes.
9.1.5 ORIENTAÇÕES DE PREVENÇÃO DE ACIDENTES
Você estudou sobre os tipos de acidentes, causas, agentes agressores e riscos. Mas será que é possível
prevenir-se desses riscos? Claro que sim! No entanto, para se prevenir de acidentes do trabalho, é preciso
seguir algumas orientações. Confira a seguir!
MAPA DE RISCOS
O Mapa de Risco é uma representação gráfica que tem o objetivo de apresentar de forma simples e
padronizada os riscos presentes no ambiente de trabalho.
É apresentado de acordo com o layout do local analisado, com círculos de acordo com o nível dos riscos
e com as cores correspondentes a eles.
O tamanho dos círculos varia de acordo com o tamanho do risco no local sendo, risco: pequeno, médio
e grande.
140
DIMITRE CAMARGO MARTINS (2018);

Figura 11 - Representação de um Mapa de Riscos simplificado
Fonte: CRK Automação (s.d)
O mapa de riscos serve para mostrar quais são os riscos presentes nas áreas demonstradas e conscien-
tizar as pessoas dos riscos existentes nos locais de trabalho.
INSPEÇÕES DE SEGURANÇA
As inspeções de segurança são procedimentos avaliativos e investigativos sobre determinados servi-

ços, ambientes ou produtos. Elas visam à detecção de possíveis riscos que possam ocasionar acidentes de
trabalho e/ou doenças ocupacionais.
Entre os principais objetivos da inspeção de segurança, estão:
a) detecção dos riscos que possam contribuir para a ocorrência de acidentes de trabalho e/ou doenças
ocupacionais;
b) redução do número de acidentes de trabalho e doenças ocupacionais;
c) elevação do interesse dos trabalhadores pelas questões de segurança e saúde do trabalho;
d) diminuição da ocorrência de danos ao patrimônio físico da empresa;
e) redução dos encargos trabalhistas e previdenciários.
Existem cinco tipos de inspeção de segurança. Aprenda quais são os tipos distintos observando o qua-
dro a seguir.
141
TIPOS DE INSPEÇÃO DESCRIÇÃO DA INSPEÇÃO

Esta inspeção deve ser diária ou sempre que um determinado proce-
Inspeção de Rotina dimento a exigir. Um exemplo deste tipo de inspeção é a checklist que
um piloto faz antes de decolar um avião.
A inspeção periódica é realizada em períodos e locais preestabeleci-
dos, podendo ser realizada em intervalos regulares de tempo, como
Inspeção Periódica
semanal, mensal ou anual. A verificação periódica das pastilhas de freio
de um carro é um exemplo deste tipo de inspeção.
A inspeção especial é realizada somente em casos especiais, fora do
comum. É uma inspeção bastante técnica e deve ser executada por
Inspeção Especial pessoal capacitado. Um exemplo de inspeção especial são as gran-
des caldeiras pressurizadas que só podem ser executada por pessoal
especializado.
É um tipo de inspeção realizada em local e período não predetermina-
Inspeção Eventual do. Pode acontecer a qualquer momento para garantir a segurança de
um posto de trabalho ou equipamento.
É a inspeção realizada pelos agentes dos órgãos oficiais. Por exemplo:
Inspeção Oficial Bombeiros, Delegacia Regional do Trabalho (DRT), Vigilância Sanitária e
Ministério do Trabalho e Emprego (MTE).
Quadro 4 - Tipos de Inspeção.

Fonte: Dos autores (2018)
As inspeções pretendem determinar as medidas preventivas e corretivas para eliminar ou minimizar

os riscos.
Na sequência, estude sobre o Plano de Prevenção Contra Incêndios (PPCI).
142
PLANO DE PREVENÇÃO CONTRA INCÊNDIOS (PPCI)
O PPCI foi criado pelo corpo de bombeiros e é exigido por órgãos públicos para qualquer imóvel, a fim
de proporcionar maior segurança às pessoas. Esse mesmo plano é utilizado para os diversos imóveis, des-
de os residenciais até os industriais.
Kldy (2018)
O PPCI é regulamentado pela NR 23 – Proteção Contra Incêndios – e sua finalidade é garantir itens
básicos de segurança contra incêndios. O PPCI regulamenta, por exemplo, o número mínimo de saídas de
emergência, equipamentos suficientes e treinamento para combate a incêndios.
PROGRAMA DE PREVENÇÃO DE RISCOS AMBIENTAIS (PPRA)
O PPRA visa à identificação dos riscos ambientais e à tomada de decisão para a contenção desses ris-
cos. O plano está dividido em quatro fases: antecipação dos riscos, reconhecimento dos riscos, controle e
avaliação dos riscos ambientais.
O PPRA está em conformidade com a NR-9. Este programa deve ser elaborado pelo setor de Engenharia
de Segurança e Medicina do Trabalho, caso a empresa o tenha. Se por ventura a empresa for desobrigada
de manter esse departamento, o PPRA pode ser elaborado por empresas terceirizadas especializadas na
elaboração e aplicação de PPRA.
O quadro a seguir traz exemplos de riscos ambientais, acompanhe:
143
GRUPO I GRUPO II GRUPO III GRUPO IV GRUPO V

Agentes Químicos Agentes Físicos Agentes Biológicos Agentes Ergonômicos Agentes Mecânicos
Poeira Ruído Vírus Trabalho físico pesado Arranjo físico deficiente
Fumos metálicos Vibração Bactéria Posturas incorretas Máquinas sem proteção
Radiação ionizante e Treinamento inadequado, Matéria-prima fora de especi-
Névoas Protozoários
não ionizante inexistente ficação
Jornadas prolongadas de Equipamentos inadequados
Vapores Pressões anormais Fungos
trabalho defeituosos ou inexistentes
Temperaturas extre- Ferramentas defeituosas/ina-
Gases Bacilos Trabalho noturno
mas dequadas ou inexistentes
Produtos químicos em Frio Responsabilidade e conflitos Iluminação deficientes
Parasitas
geral Calor Tensões emocionais Eletricidade
Substâncias, com- Incêndio
Insetos Desconforto
postos ou produtos Umidade Edificações
cobras, aranhas etc. Monotonia
químicos em geral Armazenamento
Outros Outros Outros Outros Outros
VERMELHO VERDE MARROM AMARELO AZUL
Quadro 5 - Riscos ambientais

Fonte: Grupo Alpha Seg (s.d)
Perceba que, no quadro, os riscos são divididos em grupos. Eles representam os agentes químicos, físi-
cos, biológicos, ergonômicos e mecânicos.
Agora, se você analisar coluna a coluna, encontrará seu respectivo risco ambiental. Por exemplo, os
insetos estão na coluna do grupo III, que são agentes biológicos.
O PPRA deve ser visto como um programa de ação contra os riscos ambientais, e não apenas como um
documento que deve estar à disposição da fiscalização. O PPRA é um programa que visa reduzir a exposi-
ção dos trabalhadores aos riscos nos processos.
Confira a seguir um “Casos e relatos”.
144
CASOS E RELATOS
Segurança no Trabalho
João Pedro foi contratado recentemente por uma empresa metalúrgica para assumir a função de
Técnico em Segurança do Trabalho.
Logo que João Pedro iniciou suas atividades, constatou que o número de acidentes dentro da
empresa era muito alto.
Para prevenir e diminuir o risco de acidentes, João Pedro fez um plano de ação. Esse plano era
composto pela elaboração de um mapa de risco para cada ambiente da empresa, implementação
de inspeções de segurança rotineiras, elaboração do Programa de Prevenção de Riscos Ambien-
tais (PPRA), entre outros.
O que mais chamou a atenção de João Pedro foi que grande parte dos colaboradores não utiliza-
vam Equipamentos de Proteção Individual (EPIs). Diante disso, iniciou-se, junto ao plano de ação,
uma campanha interna para a conscientização da utilização dos EPIs de acordo com cada ativida-
de executada. Os gestores também começaram a dar mais atenção a esse ponto e começaram a
cobrar dos colaboradores o uso dos EPIs.
Após 30 dias, já foi possível constatar uma redução de 30% nos acidentes. João Pedro ficou orgu-
lhoso do próprio trabalho, pois sabe que ainda há muito a ser feito para a prevenção dos acidentes
e que esse índice tende a melhorar cada dia mais.
A seguir, reveja no “Recapitulando” os principais conceitos estudados neste capítulo.

145
RECAPITULANDO
Você estudou neste capítulo sobre os aspectos da Saúde e Segurança do Trabalho. Aprendeu o
que são os acidentes de trabalho e a reconhecer os seus diferentes tipos e as suas possíveis causas.
Compreendeu também a importância da utilização dos equipamentos de proteção individual e
coletiva e conheceu os principais equipamentos. Por fim, entendeu o que é o Programa de Preven-
ção de Riscos Ambientais (PPRA).
REFERÊNCIAS
BARROCO, M. L. S. Ética: fundamentos sócio-históricos. 2. ed. São Paulo: Cortez, 2009.

BARSANO, Paulo Roberto; BARBOSA, Rildo Pereira. Controle de Riscos: Prevenção de Acidentes no
Ambiente Ocupacional. 1. Ed. São Paulo: Érica, C2014. 120 p.
BRASIL. Equipamento de Proteção Individual. 2014. Disponível em: <http://portal. mte.gov.br/
data/files/8A7C816A47594D04014767F2933F5800/NR-06%20(atualizada)%202014.pdf> Acesso
em: 02 abr 2015.
CARDELLA, Benedito. Segurança no trabalho e prevenção de acidentes: uma abordagem
holística: segurança integrada á missão organizacional com produtividade, qualidade ambiental e
desenvolvimento de pessoas. São Paulo (SP): Atlas, 1999c.
COPI, Irving Marmer. Introdução à Lógica. São Paulo: Mestre Jou, 1978.
COSTA, Marco Antonio F. da; COSTA, Maria de Fátima Barrozo da. Segurança e saúde no trabalho:
cidadania, competitividade e produtividade. Rio de Janeiro (RJ): Qualitymark, 2005c. 195 p.
FONSECA, J. J. S. Metodologia da pesquisa científica. Fortaleza: UEC, 2002.
GIL, A C. Como elaborar projetos de pesquisa. 4. ed. São Paulo: Atlas, 2007.
GOODRICH, Michael T.; TAMASSIA, Roberto. Estruturas de dados e algoritmos em Java. 5. ed.
Porto Alegre: Ciência Moderna, 2013. 713 p.
IAMAMOTO, M. V.; CARVALHO, R. Relações sociais e serviço social no Brasil. 12 ed., São Paulo:
CELATS/Cortez, 1998.
LEONTIEV, A. O Desenvolvimento do Psiquismo. São Paulo: Centauro, 2004.
NETO, Nestor Waldhelm. Check list Máquina de solda. In: SEGURANÇA do Trabalho. Disponível em:
<http://segurancadotrabalhonwn.com/check-list-maquina-de-solda/>. Acesso em: 12 fev. 2015.
PUGA, Sandra; RISSETTI, Gerson. Lógica de Programação e estruturas de dados: com aplicações em
Java. 2. ed. São Paulo: Pearson, 2009.
SPECTOR, Paul E. Psicologia nas organizações. 2 ed. São Paulo: Saraiva, 2006.
ZANELLI, J. C.; BORGES-ANDRADE, J.; BASTOS, A. V. B. Psicologia organizações e trabalho no
Brasil. Porto Alegre: Artmed, 2004.
MINICURRÍCULO DO AUTOR
EVANDRO MEDEIROS MARQUES

Evandro Medeiros Marques tem formação em Engenharia de Produção e Sistemas e 15 anos de
experiência em atividades industriais. É especialista em estratégias de redução de custos ligadas à
redução de desperdícios nos processos fabris englobando a padronização de atividades laborais,
conservação de equipamentos e desenho de sistemas logísticos enxutos.
FELIPE DEMARCHI
Felipe Demarchi é bacharel em Ciência da Computação pela Universidade de Blumenau (FURB)
desde 2012, especialista em Tecnologias para Aplicações Web pela Universidade Norte do Paraná
(UNOPAR) e mestrando em Ciência da Computação pela Universidade Federal de Santa Catari-
na (UFSC). Atualmente, é professor no SENAI/SC, unidade de Florianópolis, desde 2013. Minis-
tra aulas nos cursos técnicos de Informática, Informática para Internet e Programação de Jogos
Digitais e na Faculdade de Análise e Desenvolvimento de Sistemas, trabalhando com unidades
curriculares como Criação e Manipulação de Banco de Dados, Programação Orientada a Objetos,
Projeto de Banco de Dados, Lógica de Programação, Programação para Jogos, Estrutura de Dados
e Programação Web.
PRISCILA CARNEIRO GALLASSE CESCONETTO

Priscila Carneiro Gallasse Cesconetto é Pós-graduada em Economia e Gestão das Estratégias Em-
presariais pela Universidade Federal de Santa Catarina. Economista graduada pela Universidade
Federal de Santa Catarina. Atuou como consultora especialista no SENAI Florianópolis e como
Auditora interna da qualidade ISO 9001. Atualmente coordena o Núcleo de Consultoria em Edu-
cação do SENAI Florianópolis.
ÍNDICE
A
Algoritmos,5, 7, 13, 16, 17, 18, 19, 20, 22, 23, 24, 25, 26, 29, 30, 31, 32, 33, 43, 45, 46, 47, 48, 49, 50,
51, 53, 55, 57, 58, 59, 60, 61, 65, 69, 72, 73, 74, 77, 80, 81, 82, 83, 84, 85, 87, 88, 90, 92, 94, 95, 98,
100, 101, 102, 103, 104, 105, 147
C
Constantes, 7, 31, 32, 127, 134
D
Dados, 7, 25, 29, 30, 31, 32, 36, 39, 43, 48, 50, 77, 78, 79, 83, 88, 90, 95, 97, 99, 100, 101, 102, 115,
122, 123, 147, 149
Documentação, 7, 25, 52, 53, 54, 55
E
Enquanto, 7, 18, 34, 35, 52, 55, 57, 65, 66, 67, 68, 72, 73, 74, 78, 84, 94, 111, 128
Equipe, 8, 109, 112, 114, 117
Ética, 8, 109, 115, 117, 118, 119, 124, 147
L
Lógica, 1, 3, 7, 11, 13, 14, 15, 16, 17, 19, 23, 26, 29, 42, 45, 47, 52, 58, 59, 60, 61, 62, 64, 65, 66, 67,
77, 82, 84, 90, 94, 95, 98, 102, 106, 147, 149
Lógica de Programação, 1, 3, 7, 13, 15, 16, 17, 19, 26, 29, 42, 45, 64, 65, 77, 90, 95, 98, 102, 106,
147, 149
M
Matrizes, 8, 77, 88, 89, 90, 92, 95
O
Operadores, 5, 7, 29, 32, 33, 34, 37, 38, 39, 40, 41, 42, 43, 45, 55, 63, 70
Organização, 8, 109, 112, 115, 116, 117, 121, 124, 127
P
Para, 5, 7, 11, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 29, 30, 31, 32, 33, 34, 35, 36, 37,
38, 39, 40, 41, 42, 43, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 57, 58, 59, 60, 62, 63, 64, 65, 66, 67,
68, 69, 70, 72, 73, 74, 77, 78, 79, 80, 81, 82, 83, 84, 85, 87, 88, 89, 90, 91, 92, 94, 95, 97, 98, 99, 100,
101, 102, 103, 104, 105, 106, 109, 110, 111, 112, 114, 115, 116, 117, 118, 119, 121, 122, 123, 124,
127, 128, 131, 132, 133, 134, 135, 137, 138, 139, 140, 141, 142, 144, 149
Pesquisa, 8, 109, 117, 122, 123, 124, 147
Planejamento, 8, 109, 115, 116, 117, 124
Q
Qualidade, 8, 109, 112, 113, 116, 119, 120, 121, 124, 147, 149
Qualidade total, 8, 120, 121
R
Relacionamento interpessoal, 8, 109, 114, 124
Repita, 7, 66, 67, 69, 73, 74
Riscos, 5, 8, 53, 127, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 147
S
Saída de dados, 7, 50
Segurança no trabalho, 8, 112, 124, 127, 144, 147
V
Variáveis, 7, 23, 24, 30, 31, 32, 33, 35, 39, 41, 45, 46, 47, 48, 49, 50, 51, 55, 68, 70, 72, 77, 80, 83, 84,
85, 91, 92, 94, 95, 101, 102, 105
Vetores, 8, 77, 78, 84, 85, 88, 90, 91, 95
SENAI – DEPARTAMENTO NACIONAL
UNIDADE DE EDUCAÇÃO PROFISSIONAL E TECNOLÓGICA – UNIEP
Felipe Esteves Morgado

Gerente Executivo
Luiz Eduardo Leão

Gerente de Tecnologias Educacionais
Catarina Gama Catão

Coordenação Geral do Desenvolvimento dos Livros Didáticos
SENAI – DEPARTAMENTO REGIONAL DE SANTA CATARINA
Jefferson de Oliveira Gomes

Diretor Regional SENAI/SC
Mauricio Cappra Pauletti

Diretor Técnico do SENAI/SC
Roberto de Medeiros Junior

Diretor Instituto da Indústria e Novos Produtos do SENAI/SC
Leonardo Bernardo de Oliveira

Gerente de Educação e Tecnologia – Instituto da Indústria – CTAI
Jehan Carla Zunino Lückmann, Me

Coordenadora de Educação e Tecnologia - Instituto da Indústria - CTAI
Priscila Carneiro Gallasse Cesconetto

Gestora de Projetos
Evandro Medeiros Marques

Felipe Demarchi
Priscila Carneiro Gallasse Cesconetto
Elaboração
Mauro César Matias

Revisão técnica
Sabrina Paula Soares Scaranto

Design educacional
Davi Leon Dias
Ilustrações e tratamento de imagens
IStock
SENAI/SC
Banco de imagens
Leandro Rosa da Silva

Tatiana Daou Segalin
Diagramação
Tatiana Daou Segalin

Revisão e Fechamento de Arquivos
Luciana Effting Takiuchi

CRB – 14/937
Ficha Catalográfica
i-Comunicação
Projeto Gráfico
Editorar Multimídia Ltda.

Revisão Ortográfica e Gramatical
Editorar Multimídia Ltda.

Normalização

Lógica de Programação

Enviado por

Dados do documento

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Lógica de Programação

Enviado por

Direitos autorais:

Formatos disponíveis

SÉRIE TECNOLOGIA DA INFORMAÇÃO - HARDWARE

Robson Braga de Andrade

DIRETORIA DE EDUCAÇÃO E TECNOLOGIA – DIRET

Rafael Esmeraldo Lucchesi Ramacciotti

Julio Sergio de Maya Pedrosa Moreira

SERVIÇO NACIONAL DE APRENDIZAGEM INDUSTRIAL – SENAI

Robson Braga de Andrade

SENAI – Departamento Nacional

Rafael Esmeraldo Lucchesi Ramacciotti

Julio Sergio de Maya Pedrosa Moreira

Gustavo Leal Sales Filho

© 2018. SENAI – Departamento Regional de Santa Catarina

SENAI Departamento Nacional

SENAI Departamento Regional de Santa Catarina

Quadro 1 - Facetas comuns da satisfação no trabalho ..................................................................................... 115

3 Tipos de Dados e Operadores....................................................................................................................................31

4 Iniciando com Algoritmos...........................................................................................................................................47

5 Estruturas de Controle e Repetição..........................................................................................................................59

8 Trabalho em Equipe, Planejamento e Organização do Trabalho............................................................... 111

9 Segurança no Trabalho............................................................................................................................................. 129

Minicurrículo do autor................................................................................................................................................... 150

Índice .................................................................................................................................................................................. 152

Em um mundo globalmente conectado, possuir conhecimentos específicos em tecnologia

Carlos André M. A. (2018)

a) colocar a chave na fechadura;

No século passado, Albert Einstein desenvolveu um teste de raciocínio lógico e afir-

A seguir, você irá entender como surgiu a lógica de programação. Acompanhe!

2.2 LÓGICA DE PROGRAMAÇÃO

Figura 1 - Processo de execução de um algoritmo

2.3 FORMAS DE REPRESENTAÇÃO

2.3.1 DESCRIÇÃO NARRATIVA

a) obter as quatro notas do aluno;

Processo Início / Fim

Entrada Setas de Fluxo

Carlos André M. A. (2018)

Figura 2 - Figuras geométricas para representação de fluxogramas

Carlos André M. A. (2018)

Figura 3 - Fluxograma para apresentar a média de três notas

Informe a primeira nota:

Utilizando os valores apresentados anteriormente, o fluxograma calculou e apresentou a média final do

Figura 4 - Fluxograma para indicar a aprovação ou reprovação de um aluno

2.4 LINGUAGEM DE PROGRAMAÇÃO

As linguagens de programação existem para facilitar a comunicação entre os programadores e o com-

Quando você realiza o desenvolvimento de algoritmos, é necessário armazenar dados e informações

Existem linguagens de programação tipadas e não tipadas. A diferença entre elas é

3.3 TIPOS DE DADOS

Os operadores estão disponíveis em todas as linguagens de programação para representar expressões

3.4.1 OPERADORES DE ATRIBUIÇÃO

3.4.2 OPERADORES ARITMÉTICOS

OPERADOR SÍMBOLO EXEMPLO

resto <- 35 MOD 4

3.4.3 OPERADORES RELACIONAIS

OPERADOR SÍMBOLO EXEMPLO

Fonte: Do autor (2018)

3.4.4 OPERADORES LÓGICOS

Fonte: Do autor (2018)

Fonte: Do autor (2018)

a <- nao verdadeiro

3.4.5 PRECEDÊNCIA DE OPERADORES

5 + 5 < 10 * (17 – 15) E NÃO 4 > 3 E 5 <> 4 OU 7 MOD 3 < 8 DIV 3

Existem alguns pontos importantes a serem observados na resolução desta expressão:

Neste capítulo, você compreendeu conceitos fundamentais para o desenvolvimento de algorit-

4.1 INICIANDO UM ALGORITMO

Nessa tela é possível identificar os seguintes componentes: