Introdução à Programação

Prévia do material em texto

Autor: Prof. Marcelo Henrique dos Santos
Colaboradores: Prof. Antônio Palmeira de Araújo Neto
 Profa. Fabiola Mariana Aguiar Ribeiro
Algoritmos
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.
© 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.
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
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 binária .................................................................................................................................... 167
9
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ípiosda 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.
10
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.
11
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.
12
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 noregistro 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;
13
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;
14
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 
15
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
Unidade central de processamento
Memória secundária
Memória RAM
Unidade lógica 
e aritmética Registradores
Unidade de 
controle
Unidade de 
saída
Unidade de 
entrada
Memória ROM
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, 
16
Unidade I
mouse, câmeras de vídeo, arquivos, sensores de movimento, entre 
outros componentes.
O componente unidade de saída é responsável pelaapresentaçã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 
17
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 
18
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 
19
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
Definição
É uma coleção de instruções do computador 
escritas a partir de uma linguagem de 
programação legível por humanos
É uma sequência de instruções escritos em 
linguagem de máquina ou binário e é a saída 
após o compilador converter o código-fonte
Compreensibilidade É legível pelo programador de sistema É legível pelo computador (linguagem de máquina)
Geração Gerado pelo ser humano Gerado por compilador
20
Unidade I
Característica Código fonte Código do objeto
Formato Está na forma textual (a partir da linguagem de programação)
Está na forma de números binários (linguagem 
de máquina)
Definição
É uma coleção de instruções do computador 
escritas a partir de uma linguagem de 
programação legível por humanos
É uma sequência de instruções escritos em 
linguagem de máquina ou binário e é a saída 
após o compilador converter o código fonte
Compreensibilidade É legível pelo programador de sistema É legível pelo computador (linguagem de máquina)
Geração Gerado pelo ser humano Gerado por compilador
Formato Está na forma textual (a partir da linguagem de programação)
Está na forma de números binários (linguagem 
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 
21
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.
22
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 
23
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:
24
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 executaalgumas 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.
25
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).
26
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 para 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.
27
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 gráfica por 
meio de símbolos padronizados; são os fluxogramas, também chamados de diagramas de blocos. A 
seguir, temos uma imagem mostrando como os algoritmos são representados.
Direção do fluxo de 
dados Conexão
Início ou fim do 
algoritmo
Entrada ou saída de 
dados
Processamento Decisão Saída na tela Saída impressa
Função, procedimento 
ou sub-rotina
Repetição com variável 
de controle
Figura 2 – Simbologia para diagramas de blocos
28
Unidade I
Manzano apresenta os símbolos normatizados que devem ser utilizados na construção do 
fluxograma, alémde suas respectivas descrições.
Quadro 2 – Símbolos normatizados (ISO 5807)
Símbolo Significado Descrição
Terminal/terminator
O símbolo representa a definição de início e fim do 
fluxo lógico de um programa. Também é utilizado 
na definição de sub-rotinas de procedimento ou de 
função
Entrada manual/
manual input
Representa a entrada manual de dados, normalmente 
efetuada em um teclado conectado diretamente ao 
console do computador
Processamento/
process
Representa a execução de uma operação (ou grupo 
de operações) que estabelece(m) o resultado de uma 
operação lógica ou matemática
Exibição/display
Representa a execução da operação de saída visual de 
dados em um monitor de vídeo conectado ao console 
do computador
Decisão/decision
O símbolo representa o uso de desvios condicionais 
para outros pontos do programa de acordo com 
situações variáveis 
Preparação/
preparation
Representa a modificação de instruções (ou grupo 
de instruções) existente(s) em relação à ação de sua 
atividade subsequencial
Processo predefinido/
predefined process
Definição de um grupo de operações estabelecidas 
como uma sub-rotina de processamento anexa ao 
diagrama de blocos
Conector/connector
Representa a entrada ou a saída em outra parte do 
diagrama de blocos. Pode ser usado na definição de 
quebras de linha e na continuação da execução de 
decisões
Linha/line
O símbolo representa a ação de vínculo existente 
entre os vários símbolos de um diagrama de blocos. 
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.
29
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).
A, B
R
R ← A + B
Início
Fim
Figura 3 – Estrutura de operação computacional de sequência
Complementa Soffner:
A decisão simples testa uma condição e realiza uma ação caso esta seja 
verdadeira, sem se preocupar em realizar uma ação no caso de verificação da 
condição oposta. Por exemplo, se um número digitado for menor que zero, 
30
Unidade I
solicito uma nova digitação; se não for, o programa simplesmente continua 
na próxima linha abaixo da decisão. A decisão composta, ao contrário, tem 
uma ação prevista em caso de verificação da condição oposta. Por exemplo, 
se a média de um aluno for maior ou igual a seis, vou imprimir na tela 
“Aprovado”. Se não for (ou seja, se a mé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.
Start
( )
Start
( )
Stop
( )
Stop
( )
F
T TF
Simples Composta
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 repetição com teste no início avalia uma condição antes de executar as ações previstas e repetitivas; 
se válida, o processamento entra em iteração (loop), até que tal condição não seja mais verdadeira, 
quando o programa seguirá normalmente para o restante das rotinas programadas. Essa repetição é 
perfeita para testes de senhas antes do acesso a funções repetitivas do programa. Já a repetição com 
teste no fim executará uma ação pelo menos uma vez antes de decidir se ela continuará. É muito 
utilizada em validações de entradas de dados, antes que se dê a sequência ao programa (SOFFNER, 
2013, p. 24).
31
ALGORITMOS
F
F
F
T
T
T
Stop
( )
Stop
( )
Stop
( )
Start
( )
Start
( )
Start
( )
Ação
Contador
++
Contador
= 1
Contador
<=10
A) Com teste no início B) Com teste no fim C) Com variável de controle
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.
Fim
A, B
R
R ← A + B
Início
A > B
N S
Figura 6 – Estrutura de operação computacional de decisão simples
32
Unidade I
Exemplo de aplicação
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).
Fim
A, B
R
Início
A > B
N S
R ← A + BR ← A - B
Figura 7 – Estrutura de operação computacional de decisão composta
Exemplo de aplicação
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.
33
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.
Fim
I ← 1
I
Início
N
S
I ← I + 1
I <= 10
Figura 8 – Estrutura de operação computacional de laço de repetição condicional pré-teste
Exemplo de aplicação
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 incrementado1 (um) 
no valor dessa mesma variável.
34
Unidade I
Fim
I
Início
N
S
I ← I + 1
I ← 1
I > 10
Figura 9 – Estrutura de operação computacional de laço de repetição condicional pós-teste
Exemplo de aplicação
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.
Fim
I
Início
I ← 1, 10, 1
Figura 10 – Estrutura de operação computacional de laço de repetição incondicional
35
ALGORITMOS
Exemplo de aplicação
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.
36
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.
37
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;