Livro Texto Unidade 1

Algoritmos
Autor: Prof. Marcelo Henrique dos Santos

Colaboradores: Prof. Antônio Palmeira de Araújo Neto
Profa. Fabiola Mariana Aguiar Ribeiro
Professor conteudista: Marcelo Henrique dos Santos
Mestre em Educação pela Universidade Interamericana (2019) com dissertação sobre a utilização dos jogos digitais
no ensino superior, especialista em Negócios e Mídias Digitais pelas Faculdades Metropolitanas Unidas (FMU, 2018),
possui MBA na área de Marketing em Vendas pela também pela FMU (2016), além de ser especialista na área de
Games: Produção e Programação pelo Centro Universitário Senac (2011) e bacharel em Sistemas de Informação pela
Universidade de Mogi das Cruzes (UMC, 2008).
Atualmente é microempreendedor na área de jogos digitais e professor universitário na área de tecnologia na

UNIP e na Universidade Estácio de Sá. Tem experiência na área de Computação, com ênfase em desenvolvimento de
aplicativos, jogos digitais e desenvolvimento web, além de TV digital e sistemas interativos.
Possui, ainda, experiência no âmbito da Educação, com ênfase no desenvolvimento de games e hipermídia,
atuando principalmente nos campos de fundamentação e desenvolvimento de metodologias e protótipos. É também
autor de diversos livros técnicos na área de Computação e Jogos Digitais.
Dados Internacionais de Catalogação na Publicação (CIP)
S237a Santos, Marcelo Henrique dos.
Algoritmos / Marcelo Henrique dos Santos. – São Paulo: Editora

Sol, 2021.
180 p., il.
Nota: este volume está publicado nos Cadernos de Estudos e

Pesquisas da UNIP, Série Didática, ISSN 1517-9230.
1. Programação. 2. Dados. 3. Algoritmos. I. Título.
CDU 519.67
U511.43 – 21
© Todos os direitos reservados. Nenhuma parte desta obra pode ser reproduzida ou transmitida por qualquer forma e/ou
quaisquer meios (eletrônico, incluindo fotocópia e gravação) ou arquivada em qualquer sistema ou banco de dados sem
permissão escrita da Universidade Paulista.
Prof. Dr. João Carlos Di Genio
Reitor
Prof. Fábio Romeu de Carvalho

Vice-Reitor de Planejamento, Administração e Finanças
Profa. Melânia Dalla Torre

Vice-Reitora de Unidades Universitárias
Profa. Dra. Marília Ancona-Lopez

Vice-Reitora de Pós-Graduação e Pesquisa
Profa. Dra. Marília Ancona-Lopez

Vice-Reitora de Graduação
Unip Interativa – EaD
Profa. Elisabete Brihy

Prof. Marcello Vannini
Prof. Dr. Luiz Felipe Scabar
Prof. Ivan Daliberto Frugoli
Material Didático – EaD
Comissão editorial:
Dra. Angélica L. Carlini (UNIP)
Dr. Ivan Dias da Motta (CESUMAR)
Dra. Kátia Mosorov Alonso (UFMT)
Apoio:
Profa. Cláudia Regina Baptista – EaD
Profa. Deise Alcantara Carreiro – Comissão de Qualificação e Avaliação de Cursos
Projeto gráfico:
Prof. Alexandre Ponzetto
Revisão:
Talita Lo Ré
Bruno Barros
Sumário
Algoritmos
APRESENTAÇÃO.......................................................................................................................................................9
INTRODUÇÃO............................................................................................................................................................9
Unidade I
1 INTRODUÇÃO À PROGRAMAÇÃO.............................................................................................................. 11
1.1 Programando um computador........................................................................................................ 12
1.1.1 Arquitetura de computador................................................................................................................ 12
1.1.2 O que impulsiona o trabalho de um projetista de computadores....................................... 16
1.2 Código fonte e código objeto.......................................................................................................... 17
1.2.1 O que é o código fonte?....................................................................................................................... 17
1.2.2 O que é código de objeto?................................................................................................................... 19
1.2.3 Qual é a diferença entre código fonte e código do objeto?.................................................. 19
1.3 Linguagens formais e ambiente de programação................................................................... 20
1.3.1 Visão geral sobre os ambientes de desenvolvimento de software...................................... 21
1.3.2 Programação em geral........................................................................................................................... 22
1.4 Algoritmos e fluxogramas................................................................................................................. 23
1.4.1 Algoritmo.................................................................................................................................................... 24
1.4.2 Fluxograma................................................................................................................................................. 26
2 TÉCNICAS BÁSICAS DE PROGRAMAÇÃO................................................................................................ 36
2.1 Tipos de dados........................................................................................................................................ 36
2.1.1 Tipos primitivos (primitive types)...................................................................................................... 39
2.2 Operadores............................................................................................................................................... 41
2.2.1 Operadores aritméticos......................................................................................................................... 41
2.2.2 Operadores relacionais........................................................................................................................... 43
2.2.3 Operadores lógicos.................................................................................................................................. 43
2.3 Expressões................................................................................................................................................ 44
2.4 Variáveis.................................................................................................................................................... 46
Unidade II
3 ESTRUTURA DE DADOS.................................................................................................................................. 54
3.1 Dados homogêneos.............................................................................................................................. 54
3.1.1 Variáveis indexadas unidimensionais.............................................................................................. 55
3.1.2 Matriz bidimencional............................................................................................................................. 62
3.2 Dados heterogêneos............................................................................................................................ 65
3.2.1 Tipo de dado derivado: estrutura de registro............................................................................... 66
3.2.2 Estrutura de matriz de registros........................................................................................................ 68
4 LINGUAGEM C................................................................................................................................................... 70
4.1 Noções de ambiente de desenvolvimento de programas em C......................................... 71
4.1.1 Linha de comentário.............................................................................................................................. 71
4.1.2 Directiva do pré-processador (preprocessor directive)............................................................. 72
4.1.3 Declaração global (global declaration)........................................................................................... 72
4.1.4 A função main........................................................................................................................................... 72
4.1.5 Etapas para compilar e executar os programas em C.............................................................. 73
4.1.6 Nomenclatura dos identificadores (nome das variáveis)........................................................ 76
4.2 Estrutura e estilo de programas em linguagem C................................................................... 76
4.2.1 Palavra-chave (keyword)....................................................................................................................... 76
4.2.2 Sequências de escape............................................................................................................................ 77
4.2.3 Especificadores de formato................................................................................................................. 77
4.3 Tipos e variáveis primitivos............................................................................................................... 78
4.3.1 Tipos de dados (data types)................................................................................................................. 78
4.3.2 Variáveis (variables)................................................................................................................................. 78
4.4 Operadores matemáticos e lógicos................................................................................................ 80
4.4.1 Expressões................................................................................................................................................... 80
4.4.2 Operadores.................................................................................................................................................. 80
4.5 Estrutura de decisão e laços de repetição................................................................................... 83
4.5.1 Estrutura de decisão............................................................................................................................... 83
4.5.2 Laços de repetição................................................................................................................................... 99
Unidade III
5 FUNÇÕES...........................................................................................................................................................118
5.1 Objetos e classes..................................................................................................................................122
5.1.1 Introdução à programação orientada a objetos...................................................................... 122
5.1.2 Objetos...................................................................................................................................................... 123
5.1.3 Classes....................................................................................................................................................... 124
5.1.4 Storage classes....................................................................................................................................... 124
5.2 Atributos e associações.....................................................................................................................126
5.2.1 Atributos................................................................................................................................................... 126
5.2.2 Associações.............................................................................................................................................. 127
5.3 Métodos..................................................................................................................................................127
6 UTILIZAÇÃO DE ARQUIVOS, DIRETÓRIOS E DISCOS.........................................................................129
6.1 Formatação de impressão................................................................................................................129
6.1.1 Entrada e saída de dados................................................................................................................... 129
6.1.2 Arquivos.................................................................................................................................................... 133
Unidade IV
7 VETORES, MATRIZES E ESTRUTURAS......................................................................................................144
7.1 Matrizes...................................................................................................................................................144
7.1.1 Matriz unidimensional........................................................................................................................ 144
7.1.2 Matriz bidimensional........................................................................................................................... 147
7.1.3 Matriz interna........................................................................................................................................ 150
7.2 Estruturas...............................................................................................................................................152
7.2.1 Estruturas e typedef............................................................................................................................ 152
8 ALGORITMOS DE BUSCA E ORDENAÇÃO..............................................................................................155
8.1 Algoritmos de ordenação.................................................................................................................156
8.2 Algoritmos de busca..........................................................................................................................163
8.2.1 Pesquisa sequencial............................................................................................................................. 164
8.2.2 Pesquisa binária..................................................................................................................................... 167
APRESENTAÇÃO
O objetivo desta disciplina é trazer os principais conceitos envolvidos na área a partir da

introdução da linguagem de programação C para desenvolvimento de softwares básicos e
de controle.
Ao longo de sua leitura, será discutido que o algoritmo é usado para fornecer uma solução para
um problema específico na forma de etapas bem definidas. Sempre que utilizamos um dispositivo
como o computador para resolver um problema específico, as etapas que levam à solução devem
ser adequadamente comunicadas e planejadas. Durante a execução de um algoritmo em um
computador, várias operações, como adições e subtrações, são combinadas para executar operações
matemáticas mais complexas. Os algoritmos podem ser expressos usando linguagem natural,
fluxogramas etc.
Ao ler este livro-texto, espera-se que você compreenda as noções mais básicas de programação
de computadores através do ensino de algoritmos com o uso de uma linguagem e de um ambiente de
programação. Detalhando de forma melhor, os objetivos da disciplina são: desenvolver as habilidades
de programação com estruturas de controle e modularização a partir do uso da linguagem de
programação C.
Este livro-texto foi divido em quatro unidades e cada unidade foi subdividida em dois capítulos.
Na primeira unidade, o foco é apresentar a importância da definição do algoritmo a partir da construção
do Portugol e Fluxograma, compreendendo as técnicas básicas de programação. Na segunda unidade, são
apresentas a aplicação dos princípios da estrutura de dados e a linguagem C. Aborda-se, ainda, a
programação como o processo de criação de um conjunto de instruções que informam ao computador
como executar uma tarefa. A terceira unidade volta-se ao uso das funções e à utilização de arquivos,
diretórios e discos. Para finalizar, a quarta unidade tem como objetivo apresentar a utilização dos vetores
e matrizes no trabalho com os dados, sendo tratados também a aplicação do conceito de estruturas, os
algoritmos de busca e algoritmos de ordenação.
Esperamos que você tenha uma boa leitura e se sinta motivado a ler e conhecer mais sobre o
desenvolvimento de algoritmo e a sua implementação na linguagem C.
INTRODUÇÃO
Para usar um computador com a finalidade de executar processos, é necessário realizar algumas
tarefas, como:
• projetar o algoritmo para descrever como o processo será executado;
• usar uma linguagem de programação para expressar o algoritmo em um programa;
• executar o programa no computador ou no dispositivo.
9
Para isso, é importante entender que os algoritmos são independentes da linguagem de programação
usada e que cada algoritmo pode ser expresso em diferentes linguagens de programação, executadas em
computadores diferentes. Essa é a razão pela qual o design de algoritmos é um aspecto fundamental da
ciência da computação: o design de um algoritmo é uma atividade intelectual, significativamente
mais difícil do que expressar o algoritmo como um programa. Entre as habilidades necessárias para
projetar algoritmos, estão a criatividade e o raciocínio lógico.
As linguagens de programação preenchem a lacuna entre o pensamento humano e os processos

e circuitos binários de computador. Elas correspondem a uma série de comandos definidos
especificamente e projetados por programadores humanos para dar instruções aos computadores
digitais. Os comandos são escritos como conjuntos de instruções (chamados programas). Todas
as instruções da linguagem de programação devem ser expressas em código binário para que o
computador possa executá-los.
A linguagem de máquina refere-se ao comando específico que você deseja que o computador
execute. Cada comando tem o seu significado específico, que pode representar, por exemplo,
um comando de entrada ou de saída dados. Existem três elementos fundamentais da linguagem
que contribuem para o sucesso ou falha do ciclo de comunicação: a semântica, a sintaxe e os
participantes desse processo.
Neste livro-texto, discutiremos a integração de tais estruturas a partir da construção de

fluxogramas que ilustram como essa integração ajuda o programador na resolução de problemas.
Finalmente, a partir da compreensão da lógica de programação, implementaremos a solução dos
problemas matemáticos em uma linguagem de programação.
Uma linguagem de programação é mais do que um veículo para instruir os computadores

existentes, ela auxilia principalmente o programador nos aspectos mais difíceis de sua arte, no
design de programas e na depuração. Em outras palavras, uma boa linguagem de programação
deve ajudar a expressar como o programa será executado e o que se pretende realizar. Isso deve
ser alcançado em vários níveis, desde a estratégia geral até os detalhes da codificação e da
representação de dados. Em um sentido mais amplo, uma linguagem de programação transforma
a máquina subjacente em uma máquina virtual.
10
ALGORITMOS
Unidade I
1 INTRODUÇÃO À PROGRAMAÇÃO
Pense em algumas das maneiras diferentes pelas quais as pessoas usam computadores. Na
escola, os alunos usam computadores para desenvolver tarefas como escrever, pesquisar artigos,
enviar e-mail e participar de aulas on-line. No trabalho, as pessoas utilizam computadores para
analisar dados, fazer apresentações, realizar transações comerciais, comunicar-se com clientes e
colegas de trabalho, controlar máquinas nas instalações da fábrica e fazer muitas outras coisas.
Em casa, as pessoas usam computadores para desenvolver tarefas como efetuar o pagamento de
contas, realizar compras on-line, falar com amigos e familiares e jogar.
O uso de um computador é quase ilimitado em nossa vida cotidiana. Os computadores podem

fazer uma variedade tão grande de coisas porque podem ser programados. Isso significa que
os computadores não foram projetados para executar apenas um trabalho, mas para executar
qualquer trabalho que seus programas estabeleçam. Um programa é um conjunto de instruções
escritas em um idioma (como o C, C#, Java, .NET, BASIC etc.) compreensível pelo computador para
executar uma função específica. Um programa bem escrito pode formar um pacote de aplicativos
personalizado para resolver tipos específicos de problemas. Assim, um programador de computador
é um cientista da computação especializado no uso de construções de linguagens de programação
para desenvolver programas de computador executáveis. Os programadores geralmente trabalham
lado a lado com analistas de sistemas em diversos tipos de projetos.
As linguagens de programação são linguagens de notação artificial criadas ou desenvolvidas

para serem usadas para executar instruções codificadas no computador. São, geralmente, compostas
de uma série de regras de uso (sintaxe) que determinam o significado (semântica) das expressões
(conforme a linguagem/idioma). Programação é a arte de desenvolver programas de computador
com a ajuda de programas selecionados a partir de uma linguagem de programação. É uma
habilidade especial cuja qualidade é testada pela qualidade do programa ou software resultante.
Na programação, as etapas devem ser seguidas adequadamente, ou seja, da definição do problema
à manutenção e à revisão.
Este tópico criará uma base sólida de conhecimento que você utilizará continuamente
ao estudar ciência da computação. Primeiro, discutiremos os componentes físicos dos quais
os computadores geralmente são feitos. Em seguida, examinaremos como os computadores
armazenam dados e executam programas. Finalmente, vamos discutir o processo de documentação
a partir da construção dos fluxogramas.
11
Unidade I
Lembrete
Programação é a arte de desenvolver programas de computador

com a ajuda de programas selecionados a partir de uma linguagem
de programação.
1.1 Programando um computador
Muitas pessoas pensam que a programação de computadores é uma arte misteriosa, mas,
quando lhe perguntam como chegar a um local específico, você responde com um programa,
mesmo que você provavelmente o chame de “instruções”. Suas instruções podem não funcionar
porque você se esqueceu de uma curva ou não se deu conta de um beco que a pessoa iria encontrar
no meio do caminho, algo que seria denominado pelos programadores de computador como bug.
Uma partitura musical é outra forma de programa com símbolos especiais que devem ser
colocados corretamente dentro de duas dimensões. Um programa de música (partitura) também
pode ser convertido para algum formato mecânico ou eletrônico para que dispositivos, como
teclados modernos, possam tocá-lo automaticamente (o que vale também para rolos de piano,
dispositivos que já existiam há muito tempo antes de os primeiros computadores eletrônicos serem
inventados). Tenho certeza de que você seguiu e forneceu diversas instruções ao longo de sua vida,
e a programação de computadores é apenas outra maneira de fornecer um conjunto exato de
instruções para alcançar um determinado objetivo.
1.1.1 Arquitetura de computador
Se você consultar a literatura da área da ciência da computação, parecerá complexo encontrar

uma definição aceita universalmente para a expressão “arquitetura de computadores”. De acordo
com Stallings (2010), os especialistas muitas vezes discordam sobre a diferenciação exata entre as
expressões “arquitetura de computadores” e “organização de computadores”.
O termo “arquitetura” é usado para incluir a arquitetura do conjunto de instruções (a abstração

do programador de computador), organização ou microarquitetura (a estrutura interna e a
implementação de um computador no registro e na unidade funcional) e arquitetura do sistema
(a organização do computador a partir da memória cache e no nível do barramento). Com base
nessa proposta, a expressão “arquitetura de computadores” abrange todos os aspectos de um
computador que você deve conhecer para entender como um computador executa um programa.
Portanto, a arquitetura de computador inclui os seguintes elementos:
• os componentes físicos fundamentais que constituem um computador e o seu sistema

(o hardware);
• o tipo de instruções/idioma que o computador pode entender;
12
ALGORITMOS
• a tecnologia de computador subjacente que manipula essas instruções (por vezes, chamadas de
microarquitetura).
Stallings (2010) apresenta que a arquitetura de Von Neumann descreve a estrutura na qual os
computadores de hoje são construídos, e sua ideia original está associada ao computador ENIAC.
Embora o computador ENIAC pudesse ser programado, entrar nos programas ou alterá-los era
um procedimento difícil, pois era necessário programar de forma manual, girando interruptores
e cabos de conexão e desconexão. O matemático John von Neumann (1903-1957) é geralmente
creditado com a ideia de que armazenar o código do programa junto com os dados armazenados
é a melhor alternativa para superar os inconvenientes da programação externa (de forma manual,
como acontecia com o ENIAC).
Observação
O ENIAC (Electronic Numerical Integrator And Computer), projetado

e construído na Universidade da Pensilvânia, foi o primeiro computador
digital eletrônico de uso geral do mundo. A máquina era enorme, pesando
30 toneladas, ocupando 1.500 pés quadrados de espaço e contendo
mais de 18 mil tubos de vácuo. Era também substancialmente mais
rápido que qualquer computador eletromecânico, realizando 5 mil adições
por segundo.
Em 1945, o conceito de “programa armazenado” foi sugerido pela primeira vez como base
nesse escopo para a construção do projeto do EDVAC (Electronic Discrete Variable Computer), e,
em 1946, o computador IAS foi desenvolvido no Princeton Institute for Advanced Studies. Essa
máquina foi concluída apenas em 1952, mas sua estrutura ainda pode ser considerada a base
original das arquiteturas dos computadores de hoje. Você pode pensar que isso é óbvio: é claro
que os programas são armazenados com os dados “restantes”. No entanto, tente entender que
nos primeiros anos da computação, foi feita uma distinção rigorosa entre os dados que estavam
armazenados e os métodos de processamento (programas) aplicados para manipular os dados. A
percepção de que as instruções podem ser codificadas e armazenadas como dados “comuns” foi
uma grande inovação (BROOKSHEAR, 2009).
Com a primeira versão do EDVAC, surgiram ideias muito importantes que representaram um
dos marcos dos computadores mais importantes da história. Entre elas, podemos relacionar:
• um dispositivo de entrada através do qual dados e instruções podem ser inseridos;
• um armazenamento no qual os dados podem ser lidos/gravados (instruções são como os dados,
eles residem na mesma memória);
• uma unidade aritmética para processar dados;
13
Unidade I
• uma unidade de controle que busca instruções, as decodifica e executa;
• dispositivos de saída para o usuário acessar os resultados.
Os computadores baseados no conceito de programa armazenado ou na arquitetura de

Neumann armazenam seu código de programa (ou seja, as instruções) e os dados necessários
para que possam ser executados na memória do computador. Durante o cálculo do programa,
as instruções são recuperadas da memória e executadas uma após a outra. O componente que
controla esse cálculo é conhecido como unidade central de processamento (a CPU, hoje em dia
frequentemente referida apenas como processador). Compõem a CPU:
• a unidade lógica aritmética (que executa operações como adição e subtração nos dados);
• a unidade de controle (que coordena as atividades do computador);
• os registros (células de armazenamento de dados usadas para o armazenamento temporário de

dados – por exemplo, os dados necessários em um cálculo a ser realizado).
As melhorias na tecnologia de computadores têm sido tremendas desde que as primeiras

máquinas apareceram. Um computador pessoal, que pode ser comprado hoje por um valor acessível,
tem mais desempenho (em termos de, digamos, multiplicações de ponto flutuante por segundo),
mais memória principal e mais capacidade de disco do que uma máquina que custava milhões
nas décadas de 1950 e 1960. Com relação a tal evolução, podemos relacionar quatro linhas que
surgiram dos primeiros computadores.
• Mainframes: computadores grandes que podem suportar muitos usuários enquanto oferecem
um grande poder de computação. A maioria das inovações, tanto na arquitetura quanto na
organização, foram feitas principalmente nos mainframes.
• Minicomputadores: adotaram muitas das técnicas do mainframe, projetadas para vender por
um valor mais acessível e satisfazendo as necessidades de computação para grupos menores de
usuários. Trata-se do grupo de minicomputadores que apresentou um ritmo mais rápido de evolução
(desde 1965, quando a DEC introduziu o primeiro minicomputador, o PDP-8), principalmente
devido à evolução da tecnologia de circuitos integrados (o primeiro circuito integrado, CI,
apareceu em 1958).
• Supercomputadores: projetados para aplicações científicas, apresentam o custo mais caro

(mais de um milhão de dólares), e o processamento geralmente é feito no modo batch, por
razões de desempenho.
• Microcomputadores: apareceram na era do microprocessador (o primeiro microprocessador,

Intel 4004, foi lançado em 1971). O termo “micro” refere-se apenas às dimensões físicas, não ao
desempenho computacional – um microcomputador típico (um PC ou uma estação de trabalho)
pode ser bem acomodado em uma mesa. Os microcomputadores são diretamente o produto dos
14
ALGORITMOS
avanços tecnológicos: CPUs mais rápidas, semicondutores, memórias etc. Ao longo do tempo,
muitos dos conceitos anteriormente usados em
mainframes e minicomputadores tornaram-se
comuns e foram aplicados nos microcomputadores.
Observação
A CPU determina a disponibilidade das linguagens de programação e

pacotes de programas.
Por muitos anos, a evolução dos computadores preocupou-se com o problema de compatibilidade
de código de objeto. Uma nova arquitetura tinha que ser alterada, pelo menos em parte, tornando‑se
compatível com os mais antigos, da mesma forma que programas mais antigos deveriam continuar
funcionando (sendo executados) sem alterações nas novas máquinas. Um exemplo dramático é a
arquitetura IBM-PC, lançada em 1981, a qual se mostrou tão bem-sucedida que os desenvolvimentos
tiveram que estar em conformidade com o primeiro lançamento, apesar das falhas que se tornaram
evidentes alguns anos depois.
Segundo Manzano, “o computador eletrônico, não importando seu tamanho, é uma coleção de
componentes interligados com o objetivo de efetuar (processar) operações aritméticas e lógicas
de grandes quantidades de dados” (2019, p. 17). A figura a seguir mostra, de forma esquemática, os
componentes de um computador eletrônico.
Memória principal
Memória RAM Memória ROM
Unidade central de processamento

Unidade de Unidade lógica Unidade de Unidade de
Registradores
entrada e aritmética controle saída
Memória secundária
Figura 1 – Estrutura dos componentes de um computador eletrônico
Ainda segundo Manzano:
O componente denominado unidade de entrada é responsável pela entrada

de dados no computador. Os dados inseridos em um computador podem
ser armazenados no componente memória secundária ou processados
no componente memória principal, mais precisamente na memória RAM
(Random Access Memory – Memória de Acesso Randômico). Esse tipo
de componente pode ser representado pelos periféricos teclado, scanner,
15
Unidade I
mouse, câmeras de vídeo, arquivos, sensores de movimento, entre

outros componentes.
O componente unidade de saída é responsável pela apresentação de dados

e/ou informações que tenham sido processados na memória principal ou
que estejam armazenados na memória secundária do computador. Esse tipo
de componente pode ser representado pelos periféricos monitores de vídeo,
impressoras, arquivos, entre outros.
O componente denominado unidade central de processamento é responsável

pelo controle das operações de entrada e de saída de um computador.
Além disso, esse componente é também responsável por todo o controle
operacional, sendo o “cérebro” e o “sistema nervoso” de um computador
(MANZANO, 2019, p. 18).
Saiba mais
Para conhecer um pouco mais sobre a arquitetura de computadores,

leia o livro indicado a seguir.
STALLINGS, W. Arquitetura e organização de computadores. São Paulo:

Pearson, 2017.
1.1.2 O que impulsiona o trabalho de um projetista de computadores
Projetar um computador é uma tarefa desafiadora. Envolve o software (pelo menos quanto ao
design do conjunto de instruções) e o hardware (em todos os seus níveis: organização funcional,
projeto lógico e implementação). A própria implementação lida com o design/especificação de
ICS (Integrated Computer Systems), embalagens, ruídos, energia, refrigeração etc. Seria um erro
terrível desconsiderar um aspecto ou outro do design do computador, pois o designer dessa área
precisa projetar uma máquina ideal em todos os níveis mencionados. Você não pode encontrar um
aspecto que não esteja familiarizado com uma ampla gama de tecnologias, desde o compilador e
o projeto do sistema operacional para o projeto lógico e a embalagem.
Um arquiteto de computador deve especificar os requisitos de desempenho de várias partes

de um sistema (de computador) a fim de definir as interconexões necessárias para mantê-lo
harmoniosamente equilibrado. O trabalho do arquiteto de computadores é mais do que projetar o
conjunto de instruções, como tem sido entendido por muitos anos; aliás, quanto mais um arquiteto
é exposto a todos os aspectos do design de computadores, mais eficiente ele será. A arquitetura
do conjunto de instruções refere-se ao que o programador vê como o conjunto de instruções
da máquina. O conjunto de instruções é o limite entre o hardware e o software, e a maioria das
decisões relativas ao conjunto de instruções afeta o hardware, da mesma forma como o inverso
16
ALGORITMOS
é verdadeiro, pois muitas decisões de hardware podem afetar de maneira benéfica/adversa o

conjunto de instruções.
A implementação de uma máquina refere-se à lógica e às técnicas de design que são usadas
para implementar uma instância da arquitetura. É possível ter diferentes implementações para
alguma arquitetura, da mesma forma que existem possibilidades diferentes para construir uma
casa usando os mesmos planos, mas com materiais e técnicas distintos. A implementação tem
dois aspectos:
• a organização refere-se a aspectos lógicos de uma implementação (em outras palavras, refere-se
ao alto nível dos aspectos do design: design da CPU, sistema de memória, barramento etc.);
• o hardware refere-se às especificidades de uma implementação.
1.2 Código fonte e código objeto
De acordo com Difference between source code and object code (2018), um software é uma
coleção de programas. Um programa é um conjunto de instruções fornecidas a um computador
para executar uma tarefa específica. Suas instruções são escritas por um programador utilizando
uma linguagem de programação. Portanto, desenvolver um software significa desenvolver um
conjunto de programas. A atividade de escrever programas é conhecida como programação. O
processo seguido para desenvolver um software completo é chamado de Software Development
Life Cycle (SDLC).
Observação
O SDLC é uma estrutura ou processo conceitual que considera a

estrutura dos estágios envolvidos no desenvolvimento de uma aplicação
desde o estudo inicial de viabilidade até a implantação no campo e a
manutenção. Um SDLC geralmente é usado para descrever as etapas que
são seguidas dentro da estrutura do ciclo de vida do software.
As etapas envolvidas no SDLC fornecem uma compreensão do código fonte e do código do objeto.
A diferença entre o código fonte e o código objeto é que o primeiro é uma coleção de instruções
de computador escritas usando um manual legível por humanos a partir de uma linguagem de
programação, enquanto o código do objeto (object code) representa uma sequência de instruções
em uma linguagem de máquina e é a saída após o compilador converter o código fonte.
1.2.1 O que é o código fonte?
Segundo Difference between source code and object code (2018), antes de desenvolver o software,
deve haver uma compreensão dos requisitos (funcionais e não funcionais). Os analistas obtêm as
funcionalidades necessárias do usuário e as documentam. Esse documento contém justamente a
17
Unidade I
especificação dos requisitos do sistema (System Requirement Specification – SRS), fornecendo a

documentação descritiva das funcionalidades necessárias. Com base nesse documento, o sistema
poderá ser projetado.
O projeto do sistema pode ser feito usando fluxogramas, diagramas de fluxo de dados (Data
Flow Diagrams – DFD). As saídas da fase de design podem ser a produção do design de banco
de dados, design de processo etc. Após a fase de design ser concluída, esses projetos podem ser
implementados usando uma linguagem de programação relevante por um programador.
As linguagens de baixo nível possibilitam uma comunicação mais natural com a máquina. É uma
maneira de codificação considerada por muitos como de grande dificuldade para uso. Destacam-se
nessa categoria as linguagens de máquina e Assembly. A linguagem Assembly (e não assembler) é
mais fácil de usar do que uma linguagem de máquina, por ser baseada em comandos de instruções
em formato mnemônico (siglas com significado definido de suas ações) (MANZANO, 2019, p. 24).
A linguagem Assembly não é mais a linguagem na qual novos aplicativos são escritos, embora as
partes mais sensíveis continuem sendo escritas nela, e isso se deve aos avanços nas linguagens de
programação e na tecnologia dos compiladores. A obsolescência da programação em linguagem Assembly,
bem como a criação de sistemas operacionais portáteis (como UNIX) reduziram os riscos de introduzir
novas arquiteturas. Novas famílias de computadores estão surgindo, muitos deles híbridos de famílias
“clássicas”: supercomputadores gráficos, multiprocessadores, Massively Parallel Processors (MPP),
minisupercomputadores etc.
Observação
A linguagem Assembly é uma linguagem de programação de baixo nível

que tem uma correspondência de 1 para 1 para o código de máquina.
Existem muitas linguagens de programação. Algumas delas são C, C++, C#, Python, Java
etc. O programador pode selecionar a linguagem de programação de acordo com o projeto do
software e converter os diagramas e a documentação em programas de computador. As instruções
foram escritas para alcançar as funcionalidades do software necessário usando a linguagem de
programação. As instruções têm uma sintaxe semelhante ao idioma inglês e legível por um ser humano.
Essa coleção de instruções escritas usando uma linguagem de programação legível por humanos é
chamada de código fonte.
As linguagens de alto nível possibilitam maior facilidade de comunicação com um computador

pelo fato de serem expressadas de maneira mais próxima à comunicação humana, pois baseiam‑se
em palavras do idioma inglês. Destacam-se, nessa categoria, linguagens de programação como
FORTRAN, COBOL, BASIC, PASCAL, C, JAVA, Lua, C++, entre outras. Esse tipo de linguagem é mais
facilmente assimilado por seres humanos. Assim, o número de pessoas que as conhece é bastante
grande. Nesse sentido, considere o exemplo de um programa que apresenta a palavra mundo na
18
ALGORITMOS
tela, codificado nas linguagens de alto nível (Pascal, C++ e C), e observe que elas são mais fáceis de
expressar uma ideia do que suas equivalentes em baixo nível (MANZANO, 2019).
1.2.2 O que é código de objeto?
Difference between source code and object code (2018) apresenta que o código-fonte é
compreensível por humanos porque possui uma sintaxe semelhante à do inglês. Não é compreensível
por um computador ou uma máquina. Os computadores ou máquinas compreendem uma linguagem
binária que consiste em zeros e um. Portanto, é necessário converter o código-fonte em um formato
compreensível pela máquina. O compilador converte o código-fonte em uma linguagem binária ou
linguagem de máquina.
Esse código convertido é conhecido como código do objeto, o qual é compreensível pelo
computador (ou seja, as instruções dadas pelo ser humano são compreensíveis pelo computador a
partir dessa conversão).
Observação
A semelhança entre o código fonte e o código do objeto é o fato de

ambos estarem relacionados à programação de computadores.
1.2.3 Qual é a diferença entre código fonte e código do objeto?
Os programas de computador são úteis para fornecer instruções ao computador para executar
uma tarefa específica. Esses programas são escritos usando linguagens de programação. Existem
diversas linguagens de programação e o programador pode selecionar uma linguagem para
desenvolver os seus programas ou software. “Código fonte” e “código objeto” são dois termos
associados à área de programação, e, como vimos, a diferença entre eles é que o código fonte é
uma coleção de instruções de computador escritas usando um código legível por humanos a partir
de uma linguagem de programação, enquanto o código do objeto é uma sequência de instruções
na linguagem de máquina, a saída após o compilador converter o código fonte. O quadro a seguir
detalha melhor a comparação entre o código fonte e o código do objeto.
Quadro 1 – Código fonte versus código do objeto
Característica Código fonte Código do objeto

É uma coleção de instruções do computador É uma sequência de instruções escritos em
Definição escritas a partir de uma linguagem de linguagem de máquina ou binário e é a saída
programação legível por humanos após o compilador converter o código-fonte
É legível pelo computador (linguagem de
Compreensibilidade É legível pelo programador de sistema máquina)
Geração Gerado pelo ser humano Gerado por compilador
19
Unidade I
Característica Código fonte Código do objeto

Está na forma textual (a partir da linguagem Está na forma de números binários (linguagem
Formato de programação) de máquina)
É uma coleção de instruções do computador É uma sequência de instruções escritos em
Definição escritas a partir de uma linguagem de linguagem de máquina ou binário e é a saída
programação legível por humanos após o compilador converter o código fonte
É legível pelo computador (linguagem de
Compreensibilidade É legível pelo programador de sistema máquina)
Geração Gerado pelo ser humano Gerado por compilador
Está na forma textual (a partir da linguagem Está na forma de números binários (linguagem
Formato de programação) de máquina)
Adaptado de: Difference... (2018, p. 3).
Saiba mais
Para conhecer um pouco mais sobre o código fonte e o código do

objeto, você pode ler a obra sugerida a seguir.
ZHIRKOV, I. Programação em baixo nível: C, Assembly e execução de

programas na arquitetura Intel 64. São Paulo: Novatec, 2018.
1.3 Linguagens formais e ambiente de programação
De acordo com Slonneger e Kurtz (1995), a linguagem fornece um meio de comunicação sonora
e escrita. Os seres humanos aprendem uma língua como consequência de suas experiências de vida,
mas na linguística (a ciência das línguas) as formas e os significados das línguas são submetidos a
um exame mais rigoroso. Essa ciência também pode ser aplicada no processo de desenvolvimento de
programas computacionais. Em contraste com as linguagens naturais, com as quais comunicamos
nossos pensamentos e sentimentos, as linguagens de programação podem ser vistas como linguagens
artificiais definidas por homens e mulheres inicialmente para fins de comunicação com computadores,
e, o que é mais importante, para comunicar algoritmos entre as pessoas.
Slonneger e Kurtz (1995) mostram que muitos dos métodos e grande parte da terminologia
da linguística se aplicam às linguagens de programação. Por exemplo, as definições de idioma
consistem em dois componentes:
• Sintaxe: refere-se à maneira como os símbolos podem ser combinados para criar frases (ou programas)
no idioma relacionado. Ela define as relações formais entre os constituintes de uma linguagem,
fornecendo, assim, uma descrição estrutural das várias expressões que a compõem. A sintaxe lida
apenas com a forma e a estrutura dos símbolos em um idioma, sem se deter ao seu significado.
• Semântica: revela o significado das cadeias sintaticamente válidas em um idioma. Para as

linguagens naturais, isso significa correlacionar sentenças e frases com os objetos, pensamentos
20
ALGORITMOS
e sentimentos de nossas experiências. Para as linguagens de programação, a semântica descreve

o comportamento que um computador segue ao executar um programa em sua linguagem.
Podemos divulgar esse comportamento descrevendo o relacionamento entre a entrada e a saída
de um programa ou uma explicação passo a passo de como um programa será executado em uma
máquina real ou abstrata.
Na programação, as linguagens incluem questões como a facilidade de implementação, a

eficiência na aplicação e a metodologia de programação. A sintaxe deve ser especificada antes
da semântica, pois o significado pode ser dado apenas para as expressões que são formadas em
uma linguagem específica. Da mesma forma, a semântica precisa, antes, considerar as questões
pragmáticas, uma vez que a interação com os usuários pode ser considerada apenas para expressões
cujo significado é entendido.
1.3.1 Visão geral sobre os ambientes de desenvolvimento de software
De acordo com Dart et al. (1992), os ambientes de desenvolvimento de software referem-se à

coleção de ferramentas de hardware e software que um sistema desenvolvedor utiliza para construir
sistemas de software. À medida que a tecnologia melhora e as expectativas do usuário aumentam,
a funcionalidade de um ambiente tende a mudar. Ao longo dos últimos anos, o conjunto de
ferramentas de software disponíveis para desenvolvedores está expandido de forma considerável.
Podemos ilustrar essa mudança observando algumas distinções na terminologia: o ambiente de
programação e o ambiente de desenvolvimento de software são frequentemente usados como
sinônimos, porém, faremos uma distinção entre esses dois termos. Por “ambiente de programação”,
entendemos um ambiente que suporta apenas a fase de codificação do ciclo de desenvolvimento
de software, ou seja, apenas as tarefas pequenas de programação, como edição e compilação.
Já por “ambiente de desenvolvimento de software” entendemos um ambiente que aumenta ou
automatiza as atividades que compreendem o ciclo de desenvolvimento de software (incluindo
as grandes tarefas de programação, como o gerenciamento de configuração, e a programação de
diversas tarefas, como o gerenciamento de projetos e equipes) e que suporta uma manutenção em
larga escala e a longo prazo.
Exemplo de aplicação
Pesquise os ambientes de desenvolvimento de software disponíveis no mercado e observe as

vantagens e desvantagens de cada um desses ambientes.
A evolução dos ambientes também exige a distinção dos recursos básicos do sistema operacional
(serviços fundamentais como memória, dados e o gerenciamento de vários programas) a partir da
funcionalidade aprimorada que caracteriza os ambientes de última geração. Essa funcionalidade
aprimorada é normalmente obtida por meio de ferramentas como navegadores, gerenciadores de
janelas, gerenciadores de configuração e gerenciadores de tarefas. Em certo sentido, os ambientes
têm evoluído de acordo com o entendimento da comunidade de engenharia de software sobre as
tarefas envolvidas no desenvolvimento de sistemas de software.
21
Unidade I
Dart et al. (1992) citam em sua obra uma taxonomia dessas tendências. Segundo os autores, a
taxonomia compreende quatro categorias, cada uma representando tendências com um impacto
significativo nos ambientes (em suas ferramentas, interfaces de usuário e arquiteturas). Tais
categorias são:
• Ambientes centrados na linguagem: são criados em torno de um idioma, fornecendo um

conjunto de ferramentas adequadas para esse idioma. Esses ambientes são altamente interativos
e oferecem recursos limitados e um suporte para programação em geral.
• Ambientes orientados à estrutura: incorporam técnicas que permitem ao usuário manipular

estruturas de forma direta. A independência linguística das técnicas levou à noção dos geradores
para os ambientes.
• Ambientes do kit de ferramentas: fornecem uma coleção de ferramentas que incluem o suporte
independente da linguagem para tarefas de programação de forma ampla, como o gerenciamento
de configuração e o controle de versão.
• Ambientes baseados em métodos: incorporam suporte para uma ampla gama de atividades
no processo de desenvolvimento de software, incluindo tarefas como gerenciamento de equipe
e projeto. Esses ambientes também incorporam ferramentas para o desenvolvimento de métodos
específicos e design.
Os requisitos do usuário para ambientes abrangem um amplo espectro. A funcionalidade dos

ambientes inclui o suporte para um único usuário, a coordenação e o gerenciamento de vários usuários
e o gerenciamento do ciclo de desenvolvimento de software. A natureza da interface do usuário é de
considerável importância. Sem dúvida, o usuário de um ambiente precisa personalizá‑lo, adaptando ou
estendendo uma ferramenta específica ou criando ferramentas especializadas por meio da configuração
de suas funcionalidades. Para apoiar isso, o ambiente deve ser implementado de modo a permitir que
ferramentas sejam facilmente integradas a ele.
O usuário precisa de instalações para oferecer suporte ao desenvolvimento incremental de

software para auxiliar na criação de protótipos. Em essência, o usuário requer o suporte para todo
o ciclo do desenvolvimento de software (desde a especificação, passando pela codificação até a
manutenção), incluindo a capacidade de rastrear informações entre fases.
1.3.2 Programação em geral
Conforme Dart et.al. (1992), os ambientes centrados na linguagem oferecem ao usuário

um universo de diversas linguagens de programação. Esses ambientes são adequados para a
fase de codificação do ciclo de desenvolvimento de software e fornecem técnicas incrementais
de compilação ou interpretação para ajudar a reduzir o impacto de pequenas alterações de
código durante a manutenção. O estilo exploratório de programação que eles suportam ajuda o
usuário a experimentar protótipos de software. Ferramentas como navegadores, além de serem
extremamente úteis para o usuário durante o desenvolvimento do programa exploratório, podem
22
ALGORITMOS
ser bastante eficazes para a manutenção de grandes sistemas de software. Devido às técnicas
especializadas usadas para implementá-las, esses ambientes geralmente não oferecem suporte
a várias linguagens e, em alguns casos, não facilitam a portabilidade de programas e aplicativos.
Além disso, os ambientes centrados na linguagem podem se tornar grandes demais para uma
pessoa compreender e expandir.
Os ambientes para linguagens imperativas suportam recursos de programação, como o controle

de versão, mas eles atualmente não suportam o processo de implementar muitas tarefas, como
o gerenciamento de projetos, nem fornecem suporte para as tarefas de desenvolvimento que
não sejam a codificação. Não está claro se esses ambientes podem ampliar suas instalações para
atender a esses requisitos, mas provavelmente formarão um componente de ambientes futuros
que dará suporte a todo o ciclo de vida do software. Os desenvolvedores de sistemas comerciais
de software estão tentando refinar suas técnicas de implementação para melhorar o desempenho.
Eles estão construindo ambientes centrados na linguagem para linguagens imperativas como C e
estão tentando ampliar esses ambientes para dar suporte à fase de design e incorporar algumas
técnicas de gerenciamento de projetos.
Dart et al. (1992) afirmam que a motivação inicial para ambientes orientados para a estrutura
era dar aos usuários uma ferramenta interativa. Esse recurso foi estendido para fornecer aos
ambientes de programação de usuário um suporte quanto à semântica interativa, processo de
execução de programa e sua depuração. O editor é o componente central de tais ambientes, é a
interface pela qual o usuário interage e pela qual todas as estruturas são manipuladas. Os esforços
foram continuados para possibilitar o suporte à programação, pois os ambientes orientados à
estrutura fizeram várias contribuições para a tecnologia do ambiente, como o fornecimento
da manipulação direta do programa, a verificação incremental da semântica estática e diversas
informações acessíveis ao usuário; além disso, e talvez o mais importante, a capacidade de
descrever formalmente a sintaxe e a semântica de uma linguagem a partir da qual uma instância
de um editor de estrutura pode ser gerada.
Saiba mais
Para conhecer um pouco mais sobre as principais construções das

linguagens de programação, você pode consultar a obra indicada a seguir.
SEBESTA, R. W. Conceitos de linguagens de programação. Porto Alegre:

Bookman, 2011.
1.4 Algoritmos e fluxogramas
Charntaweekhun e Wangsiripitak (2006) afirmam que o processo de programar centrado apenas

na linguagem de programação é o caminho que muitos programadores utilizam para desenvolver
programas e softwares. O processo para a programação, usando uma linguagem de computador,
possui três etapas centrais:
23
Unidade I
• digitar o código de acordo com o algoritmo;
• utilizar um código fonte de compilação;
• verificar e validar a partir de um programa de teste e depuração.
O primeiro e o último passo estão atrelados às tarefas que os programadores devem realizar,
porém a segunda etapa está relacionada com uma demanda do complier (compilador). A maioria
dos programadores investe muito tempo na primeira etapa, pois converter a ideia (problema)
em um código fonte é muito difícil quando estamos diante de algoritmos complexos; às vezes,
é possível inclusive finalizar a codificação do projeto, porém, depara-se com diversos erros de
compilação. Encontrar esses erros e corrigi-los é uma tarefa muito árdua.
Por esse motivo, uma das possibilidades que temos disponíveis é desenvolver os algoritmos a
partir da criação dos fluxogramas, que nada mais são do que a base do modelo que os desenvolvedores
podem utilizar para redigir suas ideias em papéis (de forma manual). Dessa forma, é fácil encontrar
os erros no processo de criação sem ao menos implementar uma linha de código.
1.4.1 Algoritmo
Olhe à sua volta, os computadores e as redes estão por toda parte, permitindo diversas atividades
humanas complexas, como a educação, o comércio, o entretenimento, a pesquisa, a fabricação, a
gestão da saúde, a comunicação e até a guerra. Dos dois principais fundamentos tecnológicos dessa
incrível proliferação, um é o ritmo veloz com o qual avança a microeletrônica, que possibilitou um
hardware cada vez mais rápido, o outro é a possibilidade de construir algoritmos eficientes que
estão alimentando a revolução do computador.
Observação
Em termos de ciência da computação, um algoritmo é um resumo, uma

descrição formalizada de um procedimento computacional. Os algoritmos
se dividem em tipos diferentes, de acordo com as suas propriedades ou
domínios (por exemplo, o processo de lidar com algoritmos combinatórios
com contagem e enumeração), além de poder variar em termos de critérios
analíticos (por exemplo, características generalizadas de desempenho ou
desempenho médio).
Em matemática, ciência da computação e assuntos relacionados, um algoritmo é uma

sequência finita de etapas expressa para resolver um problema. Um algoritmo pode ser definido
como um processo que executa algumas sequências de operações para resolver um problema.
Os algoritmos são usados para
a execução de cálculo, processamento de dados e muitos outros
campos. Na computação, os algoritmos são essenciais porque servem como o procedimento
sistemático exigido pelos computadores.
24
ALGORITMOS
O termo algoritmo normalmente causa certa estranheza a algumas pessoas, pois muitas
acreditam que está escrito ou pronunciado de forma incorreta. A palavra algoritmos vem do latim,
dos termos algorismos ou algorithmos, que estão associados à ideia de algarismos por influência
do idioma grego a partir do termo arithmós, que remete a números. A palavra algoritmo é aplicada e
empregada, segundo o dicionário Houaiss, em matemática e computação. Na esfera matemática, está
associada a um processo de cálculo; encadeamento das ações necessárias ao cumprimento de uma
tarefa; processo efetivo, que produz uma solução para um problema em um número finito de etapas.
Na ciência da computação (informática), está associada a um conjunto das regras e procedimentos
lógicos perfeitamente definidos que levam à solução de um problema em um número finito de etapas
(MANZANO, 2019, p. 30).
De acordo com Charntaweekhun e Wangsiripitak (2006), na programação de computadores,

muitas vezes existem diferentes algoritmos para realizar qualquer tarefa. Cada algoritmo possui
diversas vantagens e desvantagens em diferentes situações. É possível incentivar a utilização da
construção dos algoritmos a partir de três razões: eficiência, abstração e reutilização.
A eficiência é um dos elementos fundamentais para auxiliar no processo de resolução de

problemas. Os algoritmos eficientes devem ser usados para resolver tais problemas considerando
o tempo e o fator de custo envolvidos em cada algoritmo. A abstração é a análise sistemática
dos algoritmos que podem fornecer um nível de abstração para resolver problemas. Alguns
elementos/problemas são aparentemente complicados e, quando são abstraídos (divididos em
partes menores), podem ser destilados em outros mais simples, para os quais existem algoritmos
conhecidos. Por exemplo, imagine tentar encontrar o caminho mais curto para rotear um pacote
entre dois gateways em uma internet. Uma vez que percebemos que esse problema é apenas
uma variação do problema que apresenta o caminho mais curto, podemos resolvê-lo usando a
abordagem generalizada. Já a reutilização é a aplicação das soluções que foram implementadas
anteriormente em diferentes situações.
Walia (2020) afirma que a palavra algorithm (algoritmo) refere-se ao nome do matemático
Al‑khowarizmi, que significa um procedimento ou uma técnica. O engenheiro de software geralmente
usa um algoritmo para planejar e resolver os problemas, isso ocorre porque um algoritmo é uma
sequência de etapas para resolver um problema específico ou um conjunto ordenado de etapas
inequívocas que produz um resultado e termina em um tempo finito.
Muitos profissionais da área de programação de computadores (principalmente os mais

experientes, cautelosos e cuidadosos) preferem elaborar seus programas com base em um projeto
que aborde todos os aspectos técnicos do desenvolvimento, com atenção especial sempre à
parte do projeto lógico. O projeto de desenvolvimento de sistemas (conjunto de programas
de computador com o mesmo propósito e interligados) segue diversas etapas de um processo
normalmente conhecido como análise de sistemas. O foco desta obra é o projeto lógico, a parte
do desenvolvimento do programa de um sistema em si. Assim, apenas os aspectos relacionados ao
desenvolvimento e à escrita de rotinas de programas e seu projeto serão abordados (MANZANO,
2019, p. 34).
25
Unidade I
A partir desse princípio, o algoritmo possui as seguintes características:
• Input (entrada): um algoritmo pode ou não exigir a entrada de dados.
• Output (saída): espera-se que cada algoritmo produza pelo menos um resultado (processo).
• Definiteness (definitividade): cada instrução deve ser clara e inequívoca.
• Finiteness (finitude): caso as instruções de um algoritmo sejam executadas, o algoritmo deve

terminar após um número finito de etapas.
A seguir, são apresentadas as quatro etapas para se escrever algoritmos.
• Definir a entrada de seus algoritmos: muitos algoritmos recebem dados para serem
processados, por exemplo, para calcular a área de entrada do retângulo, podem ser a altura e a
largura do retângulo.
• Definir as variáveis: as variáveis do algoritmo permitem que você as utilize em mais de um lugar.
Podemos definir duas variáveis p ara altura e largura do retângulo como height e width (ou H & W).
• Descrever as operações do algoritmo: use a variável de entrada para fins de cálculo, por
exemplo. Para encontrar a área do retângulo, multiplique as variáveis height
e width e armazene
o valor em uma nova variável que poderíamos nomear como area. As operações de um algoritmo
podem assumir a forma de várias etapas e depender do valor das variáveis de entrada.
• Saída dos resultados das operações do seu algoritmo: no caso da área do retângulo, a saída
será o valor armazenado na variável area. Caso as variáveis de
entrada descrevam um retângulo
com uma altura de 5 e uma largura de 2, o algoritmo produzirá o valor 10.
Lembrete
O algoritmo é uma representação passo a passo de uma solução para

um determinado problema. Ele utiliza um procedimento definido e não
depende de nenhuma linguagem de programação, por esse motivo é fácil
de compreender, mesmo sem um conhecimento prévio de programação.
1.4.2 Fluxograma
De acordo com Walia (2020), o primeiro design do fluxograma foi desenvolvido em 1945, por
John Von Neumann. Diferentemente de um algoritmo, o fluxograma utiliza símbolos para projetar
uma solução para um problema. Ao olhar para um fluxograma, você pode entender as operações e
a sequência de operações que serão executadas em um sistema. O fluxograma é frequentemente
considerado como a planta de um projeto usado para resolver um problema específico.
26
ALGORITMOS
Os símbolos de identificação gráfica representam sempre uma operação ou conjunto de

operações similares, podendo ser identificados por um rótulo relacionado à própria ação do símbolo
em uso, somente quando necessário.
Os símbolos devem ser conectados uns aos outros por linhas de setas que mostrem explicitamente
a direção do fluxo a ser executado pelo programa.
A estrutura visual do diagrama deve, a princípio, estar orientada no sentido de cima para baixo,
da direita para a esquerda e ser desenhada no centro da folha de papel. No entanto, dependendo da
situação, esse critério pode ser alterado, o que leva à necessidade de manter o uso das linhas de seta
indicando a direção do fluxo.
A definição de inicialização e finalização de um diagrama ocorre com o uso do símbolo

“terminal” devidamente identificado com um dos rótulos: início, fim, retorno ou a definição de um
nome particular, quando for necessário, desde que seguidas as regras de utilização de sub-rotinas
(a serem apresentadas em momento oportuno) (MANZANO, 2019, p. 38).
Observação
O fluxograma é muito importante para desenvolver a compreensão de

como um processo será realizado, além de melhorar a comunicação com
os membros da equipe (todas as pessoas envolvidas no mesmo processo) e
documentar os processos que serão implementados.
De acordo com Soffner (2013), os algoritmos podem ser representados de forma gráfica por
meio de símbolos padronizados; são os fluxogramas, também chamados de diagramas de blocos. A
seguir, temos uma imagem mostrando como os algoritmos são representados.
Direção do fluxo de Início ou fim do Entrada ou saída de

Conexão
dados algoritmo dados
Processamento Decisão Saída na tela Saída impressa
Função, procedimento Repetição com variável

ou sub-rotina de controle
Figura 2 – Simbologia para diagramas de blocos
27
Unidade I
Manzano apresenta os símbolos normatizados que devem ser utilizados na construção do

fluxograma, além de suas respectivas descrições.
Quadro 2 – Símbolos normatizados (ISO 5807)
Símbolo Significado Descrição

O símbolo representa a definição de início e fim do
fluxo lógico de um programa. Também é utilizado
Terminal/terminator na definição de sub-rotinas de procedimento ou de
função
Representa a entrada manual de dados, normalmente
Entrada manual/ efetuada em um teclado conectado diretamente ao
manual input console do computador
Representa a execução de uma operação (ou grupo
Processamento/ de operações) que estabelece(m) o resultado de uma
process operação lógica ou matemática
Representa a execução da operação de saída visual de
Exibição/display dados em um monitor de vídeo conectado ao console
do computador
O símbolo representa o uso de desvios condicionais
Decisão/decision para outros pontos do programa de acordo com
situações variáveis
Representa a modificação de instruções (ou grupo
Preparação/ de instruções) existente(s) em relação à ação de sua
preparation atividade subsequencial
Definição de um grupo de operações estabelecidas
Processo predefinido/ como uma sub-rotina de processamento anexa ao
predefined process diagrama de blocos
Representa a entrada ou a saída em outra parte do
diagrama de blocos. Pode ser usado na definição de
Conector/connector quebras de linha e na continuação da execução de
decisões
O símbolo representa a ação de vínculo existente
entre os vários símbolos de um diagrama de blocos.
Linha/line Possui a ponta de uma seta indicando a direção do
fluxo de ação
Fonte: Manzano (2019, p. 36).
Vejamos o que diz Manzano:
As operações de entrada de dados para esta obra serão genericamente

representadas com o uso do símbolo de “entrada manual”, uma vez que o
teclado será utilizado como periférico genérico dessa ação. As operações
de saída de dados serão genericamente definidas com o símbolo “exibição”,
considerando o fato de um monitor de vídeo estar sempre em uso.
A definição das variáveis nas operações de entrada e saída será feita nos
símbolos apropriados. Quando houver mais de uma variável a ser utilizada,
serão separadas por vírgulas.
28
ALGORITMOS
As operações de processamento matemático e lógico estarão definidas com

o símbolo “processamento”. Quando houver mais de uma operação a ser
definida em um mesmo símbolo, devem estar separadas por linhas de ação
sem o uso de vírgulas ou serem escritas em símbolos distintos.
As operações de tomada de decisão para condições simples, compostas,

sequenciais, encadeadas ou de execução de laços interativos (condicionais)
serão representadas pelo símbolo de “decisão”, que conterá a condição a
ser avaliada logicamente. Cada símbolo de decisão pode possuir apenas
uma condição lógica. É considerada lógica uma condição isolada ou de um
conjunto de condições vinculadas com o uso de um operador lógico de
conjunção, disjunção ou disjunção exclusiva.
As operações de laços interativos e interativos (incondicionais) serão

representadas com o símbolo “preparação”, que permite a realização de um
grupo de tarefas predefinidas e relacionadas (MANZANO, 2019, p. 38).
A figura a seguir apresenta a estrutura lógica de operação computacional mais trivial e comum,
a estrutura de operação computacional de sequência. Sendo definidas três variáveis (A, B e R),
pede-se para realizar a soma das variáveis A e B e exibir o resultado (R).
Início
A, B
R←A+B
Fim
Figura 3 – Estrutura de operação computacional de sequência
Complementa Soffner:
A decisão simples testa uma condição e realiza uma ação caso esta seja
verdadeira, sem se preocupar em realizar uma ação no caso de verificação da
condição oposta. Por exemplo, se um número digitado for menor que zero,
29
Unidade I
solicito uma nova digitação; se não for, o programa simplesmente continua

na próxima linha abaixo da decisão. A decisão composta, ao contrário, tem
uma ação prevista em caso de verificação da condição oposta. Por exemplo,
se a média de um aluno for maior ou igual a seis, vou imprimir na tela
“Aprovado”. Se não for (ou seja, se a média for menor que seis), imprimirei
“Reprovado” (SOFFNER, 2013, p. 24).
A seguir, temos a representação da estrutura de operação computacional de decisão simples e

a estrutura de operação computacional de decisão composta.
Simples Composta
Start Start
( ) ( )
T F T
Stop Stop
( ) ( )
Figura 4 – Decisão (ou seleção) simples e composta, em que “start” indica o início do
fluxograma e “stop” indica o fim (conclusão) do fluxograma
A repetição com teste no início avalia uma condição antes de executar as ações previstas e repetitivas;
se válida, o processamento entra em iteração (loop), até que tal condição não seja mais verdadeira,
quando o programa seguirá normalmente para o restante das rotinas programadas. Essa repetição é
perfeita para testes de senhas antes do acesso a funções repetitivas do programa. Já a repetição com
teste no fim executará uma ação pelo menos uma vez antes de decidir se ela continuará. É muito
utilizada em validações de entradas de dados, antes que se dê a sequência ao programa (SOFFNER,
2013, p. 24).
30
ALGORITMOS
A) Com teste no início B) Com teste no fim C) Com variável de controle
Start Start Start

( ) ( ) ( )
T
Contador
=1
Contador T
<=10
T F
F
Ação
Stop Stop
( ) ( )
Contador
++
Stop
( )
Figura 5 – Estrutura de repetição
A seguir, temos uma estrutura de operação computacional de decisão simples. Sendo definidas
três variáveis (A, B e R), pede-se para realizar a soma das variáveis A e B e exibir o resultado (R),
mas isso apenas caso o valor atribuído para a variável A seja maior do que o valor da variável B.
Início
A, B
N S
A>B
R←A+B
Fim
Figura 6 – Estrutura de operação computacional de decisão simples
31
Unidade I
Crie um fluxograma que solicite para o usuário digitar dois números (numA e numB). Caso o dobro
do primeiro número (numA) seja maior do que o segundo número (numB), o programa deve exibir a
seguinte mensagem: “O dobro do primeiro número é maior do que o segundo número que foi digitado”.
A seguir temos uma estrutura de operação computacional de decisão composta com três
variáveis (A, B e R). Se o valor de A for maior do que o valor de B (A>B), pede-se para realizar a
soma das variáveis A e B e exibir o resultado (R); já se o valor de A for menor ou igual ao valor de B,
pede-se para realizar a subtração das variáveis A e B e exibir o resultado (R).
Início
A, B
N S
A>B
R←A-B R←A+B
Fim
Figura 7 – Estrutura de operação computacional de decisão composta
Crie um fluxograma no qual é possível solicitar ao usuário que digite seu sexo utilizando as seguintes
siglas: M (sexo masculino) ou F (sexo feminino). Ao final do fluxograma, o programa deve exibir qual é
o sexo que o usuário digitou por extenso.
32
ALGORITMOS
A seguir temos uma estrutura de operação computacional de laço de repetição condicional

pré-teste. Sendo definida a variável I e atribuído um valor inicial de 1 (um), a instrução será
repetida até que a variável I seja menor ou igual a 10 (observe que o teste acontece no início do
processamento). Em caso afirmativo, será apresentado o valor da variável I e incrementado 1 (um)
no valor dessa mesma variável.
Início
I←1
N
I <= 10
S
I
I←I+1
Fim
Figura 8 – Estrutura de operação computacional de laço de repetição condicional pré-teste
Crie um fluxograma que solicite ao usuário digitar o nome de 15 frutas utilizando a estrutura de
operação computacional de laço de repetição condicional pré-teste.
A seguir temos uma estrutura de operação computacional de laço de repetição condicional

pós-teste. Sendo definida a variável I e atribuído um valor inicial de 1 (um), a instrução será
repetida até que a variável I seja menor ou igual a 10 (observe que o teste acontece no final do
processamento). Em caso afirmativo, será apresentado o valor da variável I e incrementado 1 (um)
no valor dessa mesma variável.
33
Unidade I
Início
I←1
I←I+1
N
I > 10
S
Fim
Figura 9 – Estrutura de operação computacional de laço de repetição condicional pós-teste
Crie um fluxograma que solicite ao usuário digitar o CPF dos cem funcionários que trabalham na filial
de uma empresa de confecção utilizando a estrutura de operação computacional de laço de repetição
condicional pós-teste.
A seguir, temos uma estrutura de operação computacional de laço de repetição incondicional.

O laço de repetição é composto da declaração dos três argumentos necessários (inicialização,
validação/verificação e incremento/decremento). No caso do exemplo, será exibido o valor da
variável I até que o contator seja menor ou igual a 10.
Início
I ← 1, 10, 1
Fim
Figura 10 – Estrutura de operação computacional de laço de repetição incondicional
34
ALGORITMOS
Crie um fluxograma que exiba todos os números pares do intervalo de 1 a 100 utilizando a estrutura
de operação computacional de laço de repetição incondicional.
Vejamos algumas vantagens do fluxograma:
• é uma excelente maneira de comunicar a lógica de um programa;
• é uma maneira fácil e eficiente para analisar os problemas;
• durante o ciclo de desenvolvimento do programa, desempenha o papel de um blueprint, o que

facilita esse processo;
• após o desenvolvimento bem-sucedido de um programa, é necessária uma manutenção contínua

e oportuna durante todo o seu funcionamento (e vida útil); o fluxograma facilita o processo de
alterações e manutenção do sistema;
• é fácil de ser convertido em qualquer linguagem de programação.
Ao usar ferramentas gráficas para representar a linha lógica de raciocínio a ser

implementada em um computador eletrônico, como é o caso dos diagramas
de blocos ou dos diagramas de quadros, torna-se necessário diferenciar
quatro subcategorias entre esses diagramas (MANZANO, 2019, p. 41).
O algoritmo e o fluxograma incluem os seguintes tipos de estruturas de controle:
• Sequence (sequência): na estrutura de sequência, as instruções são colocadas uma após a outra
e a execução ocorre de cima para baixo.
• Branching (ramificação/seleção): no controle de ramificação, existe uma condição e, de acordo

com uma condição, uma decisão de verdadeiro ou falso é alcançada. No caso de true, um dos dois
ramos é explorado; mas, no caso de condição false, a outra alternativa é tomada. Geralmente, o
if-then é usado para representar o controle de ramificação.
• Loop (repetição): a estrutura de repetição permite que uma instrução seja executada
repetidamente com base em certas condições de loop.
35
Unidade I
Saiba mais
Para conhecer um pouco mais sobre a construção de algoritmos e

fluxogramas, sugere-se a leitura da obra indicada a seguir.
CORMEN, T. Algoritmos: teoria e prática. São Paulo: LTC, 2012.
2 TÉCNICAS BÁSICAS DE PROGRAMAÇÃO
2.1 Tipos de dados
O computador digital moderno foi inventado e planejado como um dispositivo que deve
facilitar e acelerar cálculos complicados e demorados. Na maioria dos aplicativos, a capacidade de
armazenar e acessar grandes quantidades de informação desempenha um papel preponderante,
sendo considerada sua principal característica. Já a capacidade de calcular (ou seja, executar
aritmética) em muitos casos se tornou quase irrelevante.
Em todos esses casos, a grande quantidade de informações a serem processadas em algum

sentido representa uma abstração de uma parte da realidade. As informações disponíveis para
o computador consistem em um conjunto selecionado de dados sobre o problema real, ou seja,
os dados representam uma abstração da realidade no sentido de que certas propriedades e
características dos objetos reais são ignoradas por serem periféricas e irrelevantes para o problema
em particular. Uma abstração é, portanto, também uma simplificação dos fatos.
Consideremos um arquivo pessoal de um empregador como exemplo. Todo funcionário é

representado nesse arquivo por um conjunto de dados relevantes para o empregador ou para os
seus procedimentos contábeis. Esse conjunto pode incluir alguma identificação do funcionário
(por exemplo, nome e salário), mas provavelmente não incluirá dados irrelevantes para a situação,
como cor do cabelo, peso e altura.
Ao resolver um problema, com ou sem um computador, é necessário escolher uma abstração

da realidade, ou seja, definir um conjunto de dados que representa a situação real. Essa escolha
deve ser guiada pelo problema a ser resolvido. Em seguida, há uma escolha de representação dessas
informações. Essa escolha é guiada pela ferramenta que será utilizada para resolver o problema, isto
é, pelas facilidades oferecidas pelo computador. Na maioria dos casos, essas duas etapas não são
totalmente separadas. A escolha da representação dos dados geralmente é bastante difícil e não é
determinada exclusivamente pelas instalações disponíveis, cabendo sempre levar em consideração
as operações que devem ser executadas a partir desses dados. Um bom exemplo é a representação
de números, que são abstrações de propriedades de objetos a serem caracterizados.
36
ALGORITMOS
Os computadores usam uma representação interna baseada em dígitos binários (bits),

representação essa inadequada para os seres humanos devido ao número geralmente grande de
dígitos envolvidos, mas bastante adequada para circuitos eletrônicos, uma vez que os dois valores,
0 e 1, podem ser representados convenientemente e de forma confiável pela presença ou ausência
de correntes elétricas, carga elétrica ou campos magnéticos.
Nesse contexto, o significado das linguagens de programação torna-se aparente. Uma linguagem
de programação representa um computador abstrato capaz de interpretar os termos usados nesse
idioma, que podem incorporar um certo nível de abstração dos objetos usados pela máquina
real. A importância de usar uma linguagem que ofereça um conjunto conveniente de abstrações
básicas comuns à maioria dos problemas do processamento de dados está principalmente na
área de confiabilidade dos programas resultantes. É mais fácil projetar um programa baseado no
raciocínio com noções familiares de números, conjuntos, sequências e repetições do que em bits e
unidades de armazenamento. Obviamente, um computador real representa todos os dados, sejam
números, conjuntos ou sequências, como uma grande massa de bits. Mas isso é irrelevante para
o programador, uma vez que não é necessário se preocupar com os detalhes de representação
das abstrações escolhidas e podemos utilizar a representação correspondente escolhida pelo
computador (ou compilador) para o desenvolvimento dos fins declarados.
Um tipo de dado é um conjunto de valores (os dados) e um conjunto de operações definidas

nos dados. Uma implementação de um tipo de dados é uma expressão dos dados e operações
em termos de uma programação específica, como as linguagens Java, C, C++, C# etc. Um tipo de
dado abstrato (abstract data type – ADT) é uma especificação de um tipo de dado, sem levar em
consideração nenhuma linguagem de implementação ou programação específica. Finalmente, a
realização de um ADT envolve duas partes: interface, especificação ou documentação do ADT (qual
é o objetivo de cada operação e qual é a sintaxe para usá-la) e a implementação do ADT (como
cada operação é expressa usando as estruturas de dados e as declarações de uma linguagem de
programação) (UNIVERSITY OF CRETE, 2020).
De acordo com Yang (s.d.), um tipo de dados define uma coleção de valores de dados e um
conjunto de operações predefinidas nesses valores. A partir desse princípio, é possível afirmar que:
• programas de computador produzem resultados manipulando dados;
• um descritor é a coleção dos atributos de uma variável;
• em uma implementação, um descritor é uma coleção de células de memória que armazenam as

variáveis e os atributos;
• se os atributos forem estáticos, o descritor será necessário apenas no momento da compilação;
• esses descritores são criados pelo compilador, geralmente como parte da tabela de símbolos, e são
usados durante a compilação;
37
Unidade I
• para atributos dinâmicos, parte ou todo o descritor deve ser mantido durante a execução;
• os descritores são usados para verificação de tipo e por operações de alocação e desalocação.
Wirth (1985) afirma que, na Matemática, é costume classificar variáveis de acordo com certas
características importantes. Claro que são feitas distinções entre variáveis reais,
complexas e
lógicas ou entre variáveis que representam os valores individuais, conjuntos de valores, conjuntos
de conjuntos, ou, ainda, entre funções ou conjuntos de funções. Essa noção de classificação é
igualmente (se não mais) importante no processamento de dados. A partir do princípio de que
toda constante, variável, expressão ou função é de um certo tipo, esse tipo caracteriza o conjunto
de valores aos quais uma constante pertence, que pode ser assumida por uma variável ou
expressão ou que pode ser gerada por uma função. Em textos matemáticos, o tipo de uma variável
é geralmente dedutível do tipo de letra sem consideração de contexto, o que não é viável em
programas de computador. Geralmente, há um tipo de letra disponível no computador, portanto,
a regra amplamente aceita é a de que o tipo associado deve ser feito de maneira explícita em
uma declaração da constante, variável ou função, e que essa declaração precede textualmente a
aplicação dessa constante, variável ou função.
Observação
É costume classificar variáveis de acordo com certas características

importantes. Claro que devem ser feitas distinções entre variáveis reais,
complexas e lógicas ou entre variáveis q ue representam os valores individuais
ou conjuntos de valores ou conjuntos de conjuntos ou entre funções,
conjuntos de funções e assim por diante. Essa noção de classificação é
igualmente aplicada no processamento de dados.
Essa regra é particularmente pertinente se considerarmos o fato de que um compilador deve

fazer uma escolha de representação do objeto. Evidentemente, a quantidade de armazenamento
alocado para uma variável terá que ser escolhida de acordo com o tamanho do intervalo de valores
que a variável pode assumir. Se essa informação é conhecida por um compilador, a chamada alocação
dinâmica de armazenamento pode ser evitada. Muitas vezes, essa é a chave para uma realização
eficiente de um algoritmo. Como consequência, um compilador pode usar essas informações
em tipos para verificar a legalidade de várias construções. Por exemplo, a atribuição incorreta
de um valor booleano (lógico) a uma variável aritmética pode ser detectada sem se executar o
programa. Esse tipo de redundância no texto do programa é extremamente útil como uma ajuda no
desenvolvimento de programas, devendo ser considerada uma vantagem. Evidentemente, os dados
serão finalmente representados por um grande número de dígitos binários, independentemente
de o programa ter sido inicialmente ou não concebido em uma linguagem de alto nível usando o
conceito de tipo.
Os dados são elementos do mundo exterior que representam, dentro de um computador

digital, as informações manipuladas pelos seres humanos. Os dados a serem utilizados devem
38
ALGORITMOS
primeiramente ser abstraídos para serem, então, processados. Eles podem ser classificados em
três tipos primitivos ou tipos básicos: numéricos (representados por valores numéricos inteiros ou
reais), caracteres (representados por valores alfabéticos ou alfanuméricos) e lógicos (valores dos
tipos falso e verdadeiro) (MANZANO, 2019, p. 51).
2.1.1 Tipos primitivos (primitive types)
Segundo Wirth (1985), os tipos primitivos padrão são aqueles que estão disponíveis na maioria
dos computadores como recursos internos. Eles incluem os números inteiros, os valores lógicos
(verdadeiro ou falso) e um conjunto de caracteres (texto). Em muitos computadores, números
fracionários também são incorporados, juntamente com as operações aritméticas padrão dos
números reais. Nós classificamos esses identificadores a partir da seguinte nomenclatura: integer
(números inteiros), real (números fracionários), boolean (valores lógicos: verdadeiro e falso) e
char (caracter).
Inteiro: os dados numéricos positivos e negativos pertencem ao conjunto

de números inteiros, excluindo dessa categoria qualquer valor numérico
fracionário (que pertence ao conjunto de números reais); por exemplo, os
valores 35, 0, 234, -56, -9, entre outros. Nesta obra, a representação do dado
inteiro é feita em português estruturado com o comando inteiro. O tipo de
dado inteiro é utilizado em operações de processamento matemático.
Real: são reais os dados numéricos positivos e negativos que pertencem

ao conjunto de números reais, incluindo nessa categoria todos os valores
fracionários e inteiros; por exemplo, os valores 35, 0, -56, -9, -45.999, 4.5,
entre outros. Nesta obra, o tipo de dado real será representado em português
estruturado pelo comando real. O tipo de dado real é utilizado em operações
de processamento matemático.
Caractere/cadeia: são caracteres delimitados pelos símbolos aspas (“ “). Eles

são representados por letras (de A até Z), números (de 0 até 9), símbolos
(por exemplo, todos os símbolos imprimíveis existentes em um teclado) ou
palavras contendo esses símbolos. O tipo de dado caractere é conhecido
também como alfanumérico, string (em inglês, cordão, colar), literal ou
cadeia, por exemplo, os valores “PROGRAMAÇÃO”, “Rua Alfa, 52 – Apto. 1”,
“Fone: (0xx99) 5544-3322”, “CEP: 11222-333”, “ “ (espaço em branco), “7”,
“-90”, “45.989”, entre outros.
Lógico: são lógicos os dados com valores binários do tipo sim e não,
verdadeiro e falso, 1 e 0, entre outros, em que apenas um dos valores
pode ser escolhido. Para que um dado do tipo lógico seja devidamente
usado, é necessário estabelecer a forma de sua representação, que, nesse
caso, será feita com os valores .F. (para representar falso, pode-se também
fazer referência como .FALSO.) e .V. (para representar verdadeiro, pode-se
também fazer referência como .VERDADEIRO.) (MANZANO, 2019, p. 51-52,
grifo do autor).
39
Unidade I
Observação
Os tipos primitivos são aqueles que estão disponíveis na maioria dos

computadores como recursos internos. Eles incluem os números inteiros,
os valores lógicos da verdade e um conjunto de caracteres imprimíveis. Em
muitos computadores, os números fracionários também são incorporados,
juntamente com as operações aritméticas padrão. Podemos classificar os
tipos primitivos como os elementos INTEGER, REAL, BOOLEAN, CHAR.
Segundo Yang (s.d.), na linguagem de programação C, os tipos de dados se referem a um extenso

sistema usado para declarar as variáveis ou
funções de diferentes tipos. O tipo de uma variável
determina quanto espaço ela ocupa no armazenamento e como o padrão de bits armazenados é
interpretado. Os tipos em C podem ser classificados conforme descrito no quadro a seguir.
Quadro 3 – Tipos e descrição
Tipos básicos Eles são tipos aritméticos e podem ser calssificados como tipos inteiros (integer) ou
(basic Types) tipos de ponto flutuante/números reais (floatingpoint)
Tipos enumerados São tipos aritméticos usados para definir as variáveis a que só podem ser
(enumerated types) atribuídos certos valores inteiros discretos (discrete integer) ao longo do programa
Tipo nulo
(the type void) O especificador de tipo void indica que nenhum valor está disponível
Tipos derivados Eles incluem os seguintes tipos: ponteiro (Pointer), matriz (Array), estrutura
(derived types) (Structure types), Union e função (Function)
Segundo Soffner (2013, p. 32):
A maioria das linguagens declara os tipos inteiro, real, caractere, cadeia de

caracteres e lógico. A linguagem C não definiu como tipos originais o lógico
e a cadeia de caracteres (que chamamos de string) [...]; assim, devemos
utilizar funções predefinidas para manipular esse tipo de dado, em C. Em
linguagem C, temos os seguintes tipos de dados primitivos:
• inteiro: palavra reservada int (exemplos: 3, 6, 9, 27);
• real: palavra reservada float (exemplos: 3.1416. 8.8);
• caractere: palavra reservada char (exemplos: ‘a’, ‘8’);
• real de precisão dupla: palavra reservada double;
• tipo sem um valor inicial: palavra reservada void.
40
ALGORITMOS
Saiba mais
A relação entre algoritmos e programação é um tema complexo e de

grande importância em nossa área. Para aprofundar seu conhecimento no
assunto, sugerimos a leitura da obra indicada a seguir.
SOUZA, M. R. F. de et al. Algoritmos e lógica da programação. São Paulo:

Cengage Learning, 2019.
2.2 Operadores
Um operador é um símbolo que ajuda o usuário a comandar o computador para realizar um

determinado cálculo matemático ou desenvolver alguma manipulação lógica. Os operadores são
usados na linguagem de programação para operar os dados e variáveis.
Os operadores podem ser classificados como:
• operadores aritméticos;
• operadores relacionais;
• operadores lógicos;
• operadores de incremento e decréscimo.
2.2.1 Operadores aritméticos
Segundo Manzano:
Uma operação muito comum em programação de computadores é

usar expressões aritméticas para o estabelecimento de processamentos
matemáticos. As expressões aritméticas são realizadas a partir do
relacionamento existente entre variáveis e constantes numéricas com a
utilização dos operadores aritméticos (MANZANO, 2019, p. 54).
Você pode usar um operador aritmético com um ou dois argumentos para adicionar, subtrair,
multiplicar e dividir os valores numéricos. Os operadores aritméticos podem ser definidos nos
seguintes itens:
41
Unidade I
+ (adição)
- (subtração)
* (multiplicação)
/ (divisão)
% (MOD/divisão do módulo)
Por exemplo:
a-b
a+b
a*b
a/b
p% q
A divisão do módulo produz o restante de uma divisão inteira. O operador de divisão de módulo
não pode ser usado em dados de ponto flutuante.
Aritmética inteira (números inteiros)
Quando ambos os operandos em uma única expressão aritmética são inteiros, a expressão é
chamada de expressão inteira e a operação é chamada aritmética inteira. Durante a divisão do
módulo, o sinal do resultado é sempre o sinal do primeiro operando.
Seguem alguns exemplos da operação utilizando o operador % (MOD):
-14% 3 = -2
-14% -3 = -2
14% -3 = 2
Aritmética real (números reais)
Uma operação aritmética envolvendo apenas operandos reais é chamada aritmética real. Se x e y
são números reais, teremos:
x = 6,0 / 7,0 = 0,857143

y = 1,0 / 3,0 = 0,333333
O quadro a seguir apresenta os operadores segundo a ordem de prioridade matemática em

que as operações são realizadas. Caso seja necessário alterar o nível de prioridade de um referido
cálculo, ele deve ser colocado entre parênteses.
42
ALGORITMOS
Quadro 4 – Operadores aritméticos
Operador Operação Descrição Tipo Prioridade Resultado

+ “+n“ ou “n“ Manutenção de sinal Unário - Positivo
- -n Inversão de sinal Unário - Negativo
← x←n Atribuição do valor “n” a “x” Binário - Positivo ou negativo
↑ x↑n Exponenciação de x n
Binário 1 Inteiro ou real
n
↑ (y/n) x ↑ (y/n) Radiciação de √x n
Binário 1 Real
n
↑ (1/n) x ↑ (1/n) Radiciação de √x Binário 1 Real
/ x/n Divisão de “x” por “n” Binário 2 Real (quociente relativo)
* x*n Multiplicação de “x” por “n” Binário 2 Inteiro ou real
+ x+n Adição de “x” com “n” Binário 3 Inteiro ou real
- x-n Subtração de “n” de “x” Binário 3 Inteiro ou real
div x div n Divisão de “x” por “n” Binário 4 Inteiro (quociente absoluto)
Fonte: Manzano (2019, p. 54).
2.2.2 Operadores relacionais
As comparações podem ser feitas com a ajuda de operadores relacionais. A expressão contendo
um operador relacional é denominada expressão relacional. O valor de um relacionamento dessa
expressão são os valores um ou zero.
A seguir, são listados os operadores relacionais:
< (menor que)
<= (menor ou igual a)
> (maior que)
>= (maior ou igual a)
== (igual a)
!= (não é igual a)
2.2.3 Operadores lógicos
Os operadores lógicos são fundamentais para auxiliar no processo de validação e verificação de

nossos programas. A princípio, iremos trabalhar com os três operadores lógicos principais, que são:
&& (e / AND), || (ou / OR) e o ! (negação / NOT). Por exemplo:
43
Unidade I
• se (idade> 55 && sal <1000);
• se (número <0 || número> 100);
• se ! (número <0).
2.3 Expressões
Informalmente, um algoritmo é uma sequência finita de instruções inequívocas para executar

uma tarefa específica. Um algoritmo tem um nome e, a princípio, é necessário iniciar com uma
entrada especificada com precisão e terminar com uma saída especificada com precisão. De acordo
com Soicher e Vivaldi (2004), a entrada e a saída são sequências finitas de objetos matemáticos.
Diz-se que um algoritmo está correto se, ao receber uma entrada, conforme descrito em suas
especificações (de entrada):
• o algoritmo termina em um tempo finito;
• na terminação, o algoritmo retorna a saída conforme descrito nas especificações de saída.
Essas expressões aritméticas e algébricas são formadas pela montagem de modos familiares
de números e operadores aritméticos. A seguir, temos um modelo dessas expressões aritméticas
e matemáticas.
1+ 1
2+ 1
( x − y ) ( x + y ) (x2 + y2 ) (x 4 + y 4 )
3+ 1
x8 − y8
1
4+
5
1 1 2 1 3
(x – 1, x + 1, x2 + x + 1, x2 + 1) 0, 1, , , , ,
2 3 3 4 4
Figura 11 – Representação das expressões algébricas e aritméticas
Expressões em programação são como fórmulas em matemática: ambas usam valores para
calcular um resultado. Mas, diferentemente do que se dá na matemática, as expressões que criamos
através das linguagens de programação podem calcular resultados a partir de uma ampla variedade
de tipos (por exemplo, booleano e string), não apenas resultados matemáticos. Em outras palavras,
as expressões são como as moléculas: construídas a partir de literais e nomes, que possuem valores
(os “átomos”), e operadores e chamadas de função (as “ligações químicas” que mantêm os átomos
no lugar).
44
ALGORITMOS
A programação matemática prática em larga escala envolve mais do que apenas a minimização
ou maximização de uma função. Antes que qualquer algoritmo de otimização possa ser aplicado,
é necessário algum esforço para formular o modelo subjacente e gerar as estruturas de dados
computacionais necessárias. Se os algoritmos podem lidar com problemas de otimização como as
pessoas, então a formulação e as fases de geração e de modelagem podem ser relativamente fáceis.
Na realidade, porém, existem algumas diferenças entre a forma como matemáticos e programadores
entendem um problema e a maneira como são implementados os algoritmos e a sua codificação.
A princípio, o trabalho é dividido entre o humano e o computador. O primeiro passo que podemos
relacionar seria um profissional que entenderá a dinâmica da tarefa que deve ser automatizada
e convertida em uma linguagem de programação. Após a codificação, o computador deve compilar e
executar o programa para criar a forma do algoritmo. Esse arranjo geralmente é caro e propenso a
erros, por isso, o programa deve ser depurado por um modelador humano, mesmo que a sua saída
(a forma do algoritmo) não tenha como fim ser lida por pessoas. Na programação linear, a maior
parte do algoritmo e a forma de representação da matriz são formadas por linhas e colunas que
são numeradas em centenas ou milhares e cujo elementos que são diferentes de zero aparecem
em padrões complexos.
Um programa de computador que produz uma representação compacta dos coeficientes é

chamado de gerador de matriz. Várias linguagens de programação foram projetadas especificamente
para escrever os geradores de matriz (CREEGAN, 1985) e idiomas padrão como o Fortran também
são frequentemente usados (BEALE, 1970).
Uma operação muito comum em programação de computadores é usar expressões aritméticas

para o estabelecimento de processamentos matemáticos. As expressões aritméticas são realizadas
a partir do relacionamento existente entre variáveis e constantes numéricas com a utilização
dos operadores aritméticos. Como exemplo de uma expressão aritmética, considere a fórmula de
cálculo de área de circunferência: ÁREA = π · RAIO2, em que estão presentes as variáveis área, raio,
a constante π (pi = 3.14159265), os operadores aritméticos de multiplicação e exponenciação
quando se eleva o valor da variável raio ao quadrado (MANZANO, 2019, p. 54).
Saiba mais
Para conhecer um pouco mais sobre expressões e construção de

algoritmo, leia a obra indicada a seguir.
HUMBLE, J. Entrega contínua: como entregar software de forma rápida

e confiável. Porto Algre: Bookman, 2013.
45
Unidade I
2.4 Variáveis
Na concepção de Soffner:
Variáveis são endereços de memória de trabalho que guardam,

temporariamente, um valor utilizado pelo programa. Toda variável deve ter
atributos do tipo nome, tipo, tamanho (que vem do tipo escolhido) e valor.
As variáveis podem ter o chamado escopo local, quando são vistas apenas
dentro da função em que foram chamadas e perdem seu valor quando o
processamento sai de tal função, ou podem ser declaradas static, quando
guardarão seu valor entre as diversas chamadas dessa função. Podem, ainda,
ser de escopo global, quando tem validade em qualquer ponto do programa
(SOFFNER, 2013, p. 33).
De acordo com Manzano (2019), podemos conceituar o princípio de variável conforme a

ilustração a seguir. Nela, é possível observar que a composição da memória principal do computador
é atrelada a partir da junção de muitas gavetas, e cada uma delas pode armazenar apenas um valor
por vez, seja um dado inteiro, real, lógico ou caractere. Por ser um arquivo com várias gavetas, é
necessário que cada uma delas seja identificada com um nome.
Figura 12 – Representação gráfica da memória de um computador com variáveis. Imagine a memória de um computador como um
grande arquivo, com várias gavetas, nas quais é possível guardar apenas um valor por vez, e, como em um arquivo, essas gavetas
devem estar identificadas por uma etiqueta com um nome
Variável é tudo que está sujeito a variações, que é incerto, instável ou

inconstante. Quando se fala de computadores, é preciso ter em mente
que o volume de dados a serem tratados é grande e diversificado. Dessa
forma, os dados a serem processados são bastante variáveis. Todo dado
a ser armazenado na memória de um computador deve ser previamente
identificado segundo seu tipo, ou seja, primeiramente é necessário saber o
tipo do dado para depois fazer seu armazenamento adequado. Armazenado
o dado desejado, ele pode ser utilizado e processado a qualquer momento
(MANZANO, 2019, p. 52).
Uma variável é um nome simbólico atribuído a um item de dados pelo programador. Em qualquer
momento, uma variável representará um dado específico, chamado de valor de uma variável, que
pode mudar de tempos em tempos durante um processo de computação. O valor de uma variável
46
ALGORITMOS
pode mudar muitas vezes durante a execução de um programa. Uma variável geralmente deve
receber um nome atrelado ao conteúdo que será armazenado e processado pelo processo.
O nome de uma variável é utilizado para sua identificação e representação

em um programa de computador. É necessário estabelecer e seguir algumas
regras para uso de variáveis:
- Os nomes de identificação de uma variável podem utilizar um ou mais

caracteres, limitando-se a restrições da própria linguagem formal
de programação em uso. No caso do português estruturado essa
restrição não existe.
- O primeiro caractere de identificação do nome de uma variável não

pode ser, em hipótese nenhuma, numérico ou um símbolo gráfico
(cifrão, tralha, cachimbo, vírgula, ponto e vírgula, traço, parênteses,
chaves, colchetes, entre outros). O primeiro caractere deve ser sempre
alfabético. Os demais caracteres do nome de uma variável podem ser
alfanuméricos (números ou letras).
- Na definição de um nome composto de variável não pode haver

espaços em branco. Caso deseje separar nomes compostos, deve-se
utilizar o caractere de separação “_” underline.
- Jamais uma variável pode ser definida com o mesmo nome de uma
palavra que represente um dos comandos ou instruções de uma
linguagem de programação de computadores.
- Não pode ser utilizado como nome de variável algum rótulo que já
tenha sido usado para identificar o nome de um programa ou mesmo
de outra variável. Um nome torna-se exclusivo no programa em que
foi definido (MANZANO, 2019, p. 52).
A operação de atribuição é usada para atribuir um nome a um valor. Assim, é usada sempre que
for necessário acompanhar um valor necessário de forma posterior. Alguns usos típicos incluem:
• inicializar uma variável (contagem = 0);
• aumentar/diminuir um contador (contagem = contagem + 1);
• acumular valores (soma = soma + item);
• capturar o resultado de uma expressão matemática (y = 3 * x + 4);
• trocar dois valores (t = x; x = y; y = t).
47
Unidade I
O operador de atribuição não é comutado, ou seja, x = y não é o mesmo que y = x. As variáveis

usadas na expressão devem ser definidas (têm valores). O tipo da expressão deve ser compatível
com o tipo da variável. A ordem na qual as tarefas são executadas é importante, por exemplo,
se a primeira e a segunda atribuição na sequência de troca foram trocadas, x e y terminariam
atribuindo o mesmo valor.
Resumo
A ideia desta primeira unidade foi apresentar uma introdução à

programação e observar as técnicas básicas de programação, além
de sua estrutura.
Inicialmente, o foco foi o conceito do desenvolvimento de sistemas

e softwares a partir da programação. Vimos que a programação é a arte
de desenvolver programas de computador com a ajuda de programas
selecionados a partir de uma linguagem de programação. É uma habilidade
especial cuja qualidade é testada pela qualidade do programa ou software
resultante. Na programação, as etapas devem ser seguidas adequadamente,
ou seja, da definição do problema à manutenção e à revisão.
Viu-se que o ato de projetar um computador é uma tarefa desafiadora.

Envolve o software (pelo menos quanto ao design do conjunto de instruções)
e o hardware (em todos os seus níveis: organização funcional, projeto lógico,
implementação). A própria implementação lida com o design/especificação
de ICs, embalagens, ruídos, energia, refrigeração etc. Mencionou-se ainda
que um algoritmo é uma sequência de etapas para resolver um problema
específico ou, ainda, um conjunto ordenado de etapas inequívocas que
produz um resultado e termina em um tempo finito.
Posteriormente, foram apresentadas as técnicas básicas de programação

que envolvem a definição e a conceitualização dos tipos de dados,
operadores e expressões. Na sequência, trabalhou-se a importância da
definição e da manipulação das variáveis.
Uma variável é um nome simbólico atribuído a um item de dados pelo

programador. Em qualquer momento, uma variável representará um dado
específico, chamado de valor de uma variável, que pode mudar de tempos
em tempos durante um processo de computação. O valor de uma variável
pode mudar muitas vezes durante a execução de um programa. Uma
variável geralmente deve receber um nome atrelado com o conteúdo que
será armazenado e processado pelo processo.
48
ALGORITMOS
Exercícios
Questão 1. Os funcionários da empresa WL são classificados, de acordo com a função exercida,

nas categorias C1, C2, C3, C4 e C5. Os diretores da WL pretendem conceder aumentos salariais aos
empregados conforme a categoria e de acordo com as especificações a seguir.
C1: funcionários receberão 5% de aumento sobre o salário.

Assinale a alternativa que indica um algoritmo que escreve corretamente o nome, a categoria
e o salário reajustado do funcionário.
A)
programa salario
var
categoria : caractere
sal, novo_sal : real
escreva (“Digite o nome do funcionário:”)
leia (nome)
escreva (“Digite a categoria do funcionário:”)
leia (categoria)
escreva (“Digite o salário do funcionário:”)
leia (sal)
escolha
caso (categoria = “C1”)
novo_sal ← sal + (sal * 5/100)
senão
fim_escolha
escreva (“O salário reajustado do funcionário”, nome, “da categoria”, categoria, “é:”, novo_sal)
fim
49
Unidade I
B)
programa salario
var
nome, categoria : real
leia (nome)
leia (categoria)
leia (sal)
escolha
senão
fim_escolha
fim
C)
programa salario
var
nome, categoria : caractere
leia (nome)
leia (categoria)
leia (sal)
escolha
senão
fim_escolha
fim
50
ALGORITMOS
D)
programa salario
var
leia (nome)
leia (categoria)
leia ( )
escolha
senão
fim_escolha
fim
E)
programa salario
var
leia (nome)
leia (categoria)
leia (sal)
escolha
novo_sal ← sal + (sal *7/100)
senão
fim_escolha
fim
Resposta correta: alternativa E.

51
Unidade I
Análise da questão
Para elaborarmos o algoritmo pedido, devemos seguir as etapas especificadas na sequência

dada a seguir.
1) Dar nome ao programa.
2) Declarar as variáveis (nome, categoria, sal e novo_sal) e seus tipos (nome e categoria são do
tipo caractere e sal e novo_sal são do tipo real).
3) Solicitar as entradas de dados e fazer suas leituras.
4) Usar o comando “escolha” e realizar o cálculo do novo salário (novo_sal) de acordo com a
categoria do funcionário.
5) Escrever as saídas solicitadas.
Questão 2. Considere o diagrama de blocos e analise as afirmativas a seguir.
Início
F N mod 2 = 0
V
(I) (II)
Fim
Figura 13
I – O algoritmo representado no fluxograma apresenta uma estrutura de repetição.
II – Podemos substituir (I) por “é múltiplo de 2” e (II) por “não é múltiplo de 2”.
III – Podemos substituir (I) por “é ímpar” e (II) por “é par”.
IV – A saída do algoritmo é uma saída impressa.
52
ALGORITMOS
É correto apenas o que se afirma em:
A) I.
B) II e IV.
C) III.
D) I e II.
E) II, III e IV.
Resposta correta: alternativa C.
Análise da questão
I – Afirmativa incorreta.
Justificativa: o algoritmo do fluxograma apresenta uma estrutura condicional, e não uma

estrutura de repetição. Note que não temos um looping no diagrama de blocos.
II – Afirmativa incorreta.
Justificativa: o operador mod do critério da estrutura condicional (N mod 2=0) dá o resto

inteiro da divisão. Logo, se o resto inteiro da divisão de N por 2 é igual a zero, N é múltiplo de 2. De
outra forma, N não é múltiplo de 2.
III – Afirmativa correta.
Justificativa: o algoritmo representado no diagrama de blocos classifica o número atribuído a

N dado como par ou ímpar. Se N mod 2=0, então N é múltiplo de 2.
IV – Afirmativa incorreta.
Justificativa: a estrutura de saída do diagrama de blocos representa uma saída na tela, e não
uma saída impressa.
53

Livro Texto Unidade 1

Enviado por

Dados do documento

Título original

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

Livro Texto Unidade 1

Enviado por

Direitos autorais:

Formatos disponíveis

Algoritmos

Autor: Prof. Marcelo Henrique dos Santos

Atualmente é microempreendedor na área de jogos digitais e professor universitário na área de tecnologia na

Dados Internacionais de Catalogação na Publicação (CIP)

S237a Santos, Marcelo Henrique dos.

Algoritmos / Marcelo Henrique dos Santos. – São Paulo: Editora

180 p., il.

Nota: este volume está publicado nos Cadernos de Estudos e

1. Programação. 2. Dados. 3. Algoritmos. I. Título.

Prof. Fábio Romeu de Carvalho

Profa. Melânia Dalla Torre

Profa. Dra. Marília Ancona-Lopez

Profa. Dra. Marília Ancona-Lopez

Unip Interativa – EaD

Profa. Elisabete Brihy

Material Didático – EaD

O objetivo desta disciplina é trazer os principais conceitos envolvidos na área a partir da

• projetar o algoritmo para descrever como o processo será executado;

• usar uma linguagem de programação para expressar o algoritmo em um programa;

• executar o programa no computador ou no dispositivo.

As linguagens de programação preenchem a lacuna entre o pensamento humano e os processos

Neste livro-texto, discutiremos a integração de tais estruturas a partir da construção de

Uma linguagem de programação é mais do que um veículo para instruir os computadores

O uso de um computador é quase ilimitado em nossa vida cotidiana. Os computadores podem

As linguagens de programação são linguagens de notação artificial criadas ou desenvolvidas

Programação é a arte de desenvolver programas de computador

1.1 Programando um computador

1.1.1 Arquitetura de computador

Se você consultar a literatura da área da ciência da computação, parecerá complexo encontrar

O termo “arquitetura” é usado para incluir a arquitetura do conjunto de instruções (a abstração

• os componentes físicos fundamentais que constituem um computador e o seu sistema

• o tipo de instruções/idioma que o computador pode entender;

O ENIAC (Electronic Numerical Integrator And Computer), projetado

• um dispositivo de entrada através do qual dados e instruções podem ser inseridos;

• uma unidade aritmética para processar dados;

• uma unidade de controle que busca instruções, as decodifica e executa;

• dispositivos de saída para o usuário acessar os resultados.

Os computadores baseados no conceito de programa armazenado ou na arquitetura de

• a unidade de controle (que coordena as atividades do computador);

• os registros (células de armazenamento de dados usadas para o armazenamento temporário de

As melhorias na tecnologia de computadores têm sido tremendas desde que as primeiras

• Supercomputadores: projetados para aplicações científicas, apresentam o custo mais caro

• Microcomputadores: apareceram na era do microprocessador (o primeiro microprocessador,

A CPU determina a disponibilidade das linguagens de programação e

Memória RAM Memória ROM

Unidade central de processamento

Figura 1 – Estrutura dos componentes de um computador eletrônico

Ainda segundo Manzano:

O componente denominado unidade de entrada é responsável pela entrada

mouse, câmeras de vídeo, arquivos, sensores de movimento, entre

O componente unidade de saída é responsável pela apresentação de dados

O componente denominado unidade central de processamento é responsável

Para conhecer um pouco mais sobre a arquitetura de computadores,

STALLINGS, W. Arquitetura e organização de computadores. São Paulo:

1.1.2 O que impulsiona o trabalho de um projetista de computadores

Um arquiteto de computador deve especificar os requisitos de desempenho de várias partes

é verdadeiro, pois muitas decisões de hardware podem afetar de maneira benéfica/adversa o

• o hardware refere-se às especificidades de uma implementação.

1.2 Código fonte e código objeto

O SDLC é uma estrutura ou processo conceitual que considera a

1.2.1 O que é o código fonte?

especificação dos requisitos do sistema (System Requirement Specification – SRS), fornecendo a

A linguagem Assembly é uma linguagem de programação de baixo nível