Introdução a Pascal

Prévia do material em texto

Este material aborda o conteúdo de uma 
disciplina de introdução à programação 
para cursos de Ciência da Computação e 
Engenharias. A linguagem de 
programação utilizada é Pascal. A 
primeira parte engloba o histórico da 
computação e os fundamentos para 
compreender a representação de dados 
no mundo digital. A segunda parte 
contempla os principais elementos de 
programação do paradigma imperativo e 
procedural. 
Introdução à 
Programação: 
Conceitos e Práticas. 
Jorge Habib Hanna El Khouri 
 
Introdução à Programação: Conceitos e Práticas. Página 1 
 
 
 
Introdução à Programação: 
Conceitos e Práticas. 
(notas de aulas) 
 
 
 
Introdução à Programação: Conceitos e Práticas. Página 2 
 
 
Introdução à Programação: 
Conceitos e Práticas. 
(notas de aulas) 
 
 
 
Jorge Habib Hanna El Khouri 
 
 
 
 
Professor Assistente do Centro de Engenharias e Ciências Exatas 
Universidade Estadual do Oeste do Paraná 
Campus de Foz do Iguaçu 
 
 
 
Revisão Técnica: 
 
 
 
 
 
 
 
 
 
Abr-2014 
 
 
 
Introdução à Programação: Conceitos e Práticas. Página 3 
 
 
 
 
 
CONTEÚDO 
 
 
 
 
1. História da Computação ..................................................................................................... 10 
1.1. Principais Eventos ............................................................................................................... 10 
1.2. Gerações de Computadores .............................................................................................. 16 
1.2.1. Primeira Geração (1938 - 1953) ............................................................................... 16 
1.2.2. Segunda Geração (1952 - 1963) .............................................................................. 17 
1.2.3. Terceira Geração (1962 - 1975) ................................................................................ 20 
1.2.4. Quarta Geração (1972 - ...) ........................................................................................ 22 
2. Sistemas de Numeração .................................................................................................... 24 
2.1. Sistema de Numeração Egípcio ........................................................................................ 24 
2.2. Sistema de Numeração Romano ...................................................................................... 25 
2.3. Sistema de Numeração Maia ............................................................................................ 25 
2.4. Sistema de Numeração Decimal....................................................................................... 27 
3. Conceito de Bases .............................................................................................................. 31 
3.1. Sistema Decimal .................................................................................................................. 31 
3.2. Sistema Hexadecimal ......................................................................................................... 32 
3.3. Sistema Binário .................................................................................................................... 33 
3.4. Base Qualquer ..................................................................................................................... 34 
3.5. Conversão entre Bases ...................................................................................................... 35 
3.5.1. Conversão de Qualquer Base para a Base 10 ....................................................... 35 
3.5.2. Conversão da Base 10 para Qualquer Base .......................................................... 37 
3.6. Exercícios ............................................................................................................................. 39 
3.6.1. Conversão da Base 2n para a Base 2 ...................................................................... 39 
3.6.2. Conversão da Base 4 para a Base 2 ....................................................................... 40 
3.6.3. Conversão da Base 8 para a Base 2 ....................................................................... 40 
3.6.4. Conversão da Base 16 para a Base 2 ..................................................................... 41 
3.7. Exercícios ............................................................................................................................. 42 
4. Operações com Números Binários ................................................................................... 43 
4.1. Operações Aritméticas ....................................................................................................... 43 
4.1.1. Soma ............................................................................................................................. 43 
4.1.2. Subtração ...................................................................................................................... 44 
4.1.3. Multiplicação ................................................................................................................. 45 
 
Introdução à Programação: Conceitos e Práticas. Página 4 
4.1.4. Divisão ........................................................................................................................... 45 
4.1.5. Exercícios ..................................................................................................................... 46 
4.2. Operações Lógicas ............................................................................................................. 47 
4.2.1. AND / E ......................................................................................................................... 47 
4.2.2. OR / OU ......................................................................................................................... 49 
4.2.3. NOT / NÃO ................................................................................................................... 50 
4.2.4. XOR / OU EXCLUSIVO .............................................................................................. 51 
4.2.5. Exemplos ...................................................................................................................... 52 
4.3. Operações Aritméticas Binárias com Circuitos Lógicos ................................................ 53 
4.3.1. Somador Completo ..................................................................................................... 54 
4.3.2. Subtrator Completo ..................................................................................................... 55 
5. Representação de Dados................................................................................................... 58 
5.1. Representação de Números Inteiros ................................................................................ 59 
5.1.1. Inteiros Sem Sinal – Binário Puro ............................................................................. 59 
5.1.2. Inteiro Com Sinal ......................................................................................................... 59 
5.1.2.1. Módulo Sinal ............................................................................................................. 59 
5.1.2.2. Complemento de 1 .................................................................................................. 60 
5.1.2.3. Complemento de 2 .................................................................................................. 61 
5.1.2.4. Excesso de 2N-1 ........................................................................................................ 62 
5.1.3. Soma em Complemento de 2 .................................................................................... 63 
5.1.4. Exercícios .....................................................................................................................65 
5.2. Representação de Números Reais................................................................................... 65 
5.2.1. Formato IEEE 754 ....................................................................................................... 69 
5.2.2. Exercícios ..................................................................................................................... 71 
5.3. Representação de Informações Textuais ........................................................................ 72 
6. Introdução a Arquitetura ..................................................................................................... 75 
6.1. Processador - CPU ............................................................................................................. 77 
6.1.1. Seção de Controle ....................................................................................................... 78 
6.1.2. Seção de Processamento .......................................................................................... 79 
6.1.3. Barramentos ................................................................................................................. 79 
6.1.4. O sinal de Clock ........................................................................................................... 82 
6.1.5. Organização do Computador .................................................................................... 82 
6.1.5.1. Pipeline ...................................................................................................................... 83 
6.1.5.2. Cache ........................................................................................................................ 84 
6.1.5.3. Outras Técnicas ....................................................................................................... 85 
7. Introdução à Programação................................................................................................. 86 
8. O Processo de Tradução ................................................................................................... 89 
9. A Linguagem Pascal ........................................................................................................... 90 
10. Estrutura de um Programa Pascal .................................................................................... 93 
11. Identificadores ...................................................................................................................... 93 
12. Variáveis e Tipos de Dados ............................................................................................... 94 
13. Comando de Atribuição ...................................................................................................... 95 
14. Expressões Numéricas ....................................................................................................... 96 
14.1. Tipos Numéricos .......................................................................................................... 96 
14.2. Constantes .................................................................................................................... 99 
14.3. Operadores Matemáticos ......................................................................................... 105 
 
Introdução à Programação: Conceitos e Práticas. Página 5 
14.4. Funções Matemáticas ............................................................................................... 106 
14.5. Exemplos .................................................................................................................... 111 
15. Comandos de Entrada e Saída ....................................................................................... 113 
15.1. Entrada ........................................................................................................................ 113 
15.2. Saída ........................................................................................................................... 114 
15.3. Exemplos .................................................................................................................... 114 
16. Implementando Funções .................................................................................................. 116 
16.1. Exemplos .................................................................................................................... 117 
16.2. Exercícios ................................................................................................................... 119 
17. Passagem de Parâmetros ................................................................................................ 126 
17.1. Por Cópia .................................................................................................................... 126 
17.2. Por Referência ........................................................................................................... 129 
18. Implementando Procedures ............................................................................................. 133 
19. Expressões Textuais ......................................................................................................... 137 
19.1. Tipos Textuais ............................................................................................................ 137 
19.2. Constantes .................................................................................................................. 137 
19.3. Operadores ................................................................................................................. 142 
19.4. Funções....................................................................................................................... 143 
19.5. Exemplos .................................................................................................................... 148 
20. Expressões Lógicas .......................................................................................................... 151 
20.1. Tipo de Dado Boolean .............................................................................................. 151 
20.2. Operadores Lógicos .................................................................................................. 151 
20.3. Operadores Relacionais ........................................................................................... 153 
20.4. Exemplos .................................................................................................................... 154 
21. Instruções de Controle ...................................................................................................... 157 
21.1. Seleção – IF-THEN-ELSE ........................................................................................ 158 
21.1.1. Sintaxe e Semântica ................................................................................................. 158 
21.1.2. Exemplos .................................................................................................................... 160 
21.2. Seleção – CASE ........................................................................................................ 168 
21.2.1. Sintaxe e Semântica ................................................................................................. 168 
21.2.2. Exemplos .................................................................................................................... 170 
21.3. Repetição – FOR⋯DO .............................................................................................. 175 
21.3.1. Sintaxe e Semântica ................................................................................................. 175 
21.3.2. Exemplos .................................................................................................................... 177 
21.4. Repetição – WHILE⋯DO .........................................................................................194 
21.4.1. Sintaxe e Semântica ................................................................................................. 194 
21.4.2. Exemplos .................................................................................................................... 196 
22. Array .................................................................................................................................... 209 
22.1. Vetor ............................................................................................................................ 210 
22.2. Sintaxe e Semântica ................................................................................................. 211 
22.3. Exemplos .................................................................................................................... 213 
22.4. Matriz ........................................................................................................................... 234 
22.5. Sintaxe e Semântica ................................................................................................. 235 
22.6. Exemplos .................................................................................................................... 237 
23. Arquivos .............................................................................................................................. 258 
23.1. Arquivo Texto: Funções e Procedimentos............................................................. 262 
 
Introdução à Programação: Conceitos e Práticas. Página 6 
23.2. Exemplos .................................................................................................................... 269 
24. Conjuntos ............................................................................................................................ 290 
24.1. Operadores ................................................................................................................. 290 
24.2. Exemplos .................................................................................................................... 292 
25. Registro ............................................................................................................................... 297 
25.1. Sintaxe......................................................................................................................... 299 
25.2. Exemplos .................................................................................................................... 302 
26. Tipos Ordinais Definidos pelo Usuário ........................................................................... 307 
26.1. Enumerados ............................................................................................................... 307 
26.2. Subdomínio................................................................................................................. 310 
27. Expressões Binárias ......................................................................................................... 313 
27.1. Operadores Binários ................................................................................................. 313 
27.2. Operadores de Deslocamento de Bits ................................................................... 314 
27.3. Exemplos .................................................................................................................... 316 
28. Ponteiros ............................................................................................................................. 322 
28.1. Sintaxe......................................................................................................................... 322 
28.2. Operação com Ponteiros .......................................................................................... 323 
28.3. Exemplos .................................................................................................................... 324 
29. Estrutura de dados dinâmica ........................................................................................... 334 
29.1. Organização da memória de um programa em execução .................................. 334 
29.2. Alocação dinâmica .................................................................................................... 336 
29.3. Exemplos .................................................................................................................... 338 
30. Interpretador da Linha Comando .................................................................................... 347 
31. Recursividade..................................................................................................................... 349 
31.1. Conceito ...................................................................................................................... 349 
31.2. Exemplos .................................................................................................................... 351 
32. Referências Bibliográficas ................................................................................................ 356 
 
 
 
Introdução à Programação: Conceitos e Práticas. Página 7 
 
 
 
 
 
FIGURAS 
 
 
 
 
Figura 1: Ábaco. ............................................................................................................ 10 
Figura 2: Ábaco e o seu uso. ......................................................................................... 10 
Figura 3: O mecanismo de Anticítera. ........................................................................... 11 
Figura 4: Réplica do mecanismo de Anticítera. ............................................................. 11 
Figura 5: Esquema da máquina de Anticítera................................................................ 11 
Figura 6: Tabela de Logaritmo de Napier ...................................................................... 11 
Figura 7: Manuscrito Original de Schickard. .................................................................. 12 
Figura 8: Réplica da Calculadora de Schickard. ............................................................ 12 
Figura 9: La Pascaline. .................................................................................................. 12 
Figura 10: La Pascaline. ................................................................................................ 12 
Figura 11: Régua de Cálculo. ........................................................................................ 13 
Figura 12: Máquina de Leibniz. ..................................................................................... 13 
Figura 13: Tear Automático de Jacquard. ..................................................................... 13 
Figura 14: Máquina Analítica de Babbage. .................................................................... 14 
Figura 15: Formulário: Primeiro algoritmo de Ada. ........................................................ 14 
Figura 16: Cartão perfurado de Hollerith. ...................................................................... 15 
Figura 17: Máquina de Tabulação. ................................................................................ 15 
Figura 18: ENIAC. ......................................................................................................... 16 
Figura 19: Memória de Núcleo. ..................................................................................... 18 
Figura 20: Ambiente de Programação da Segunda Geração. ....................................... 19 
Figura 21: Evolução no nível de Programação. ............................................................. 21 
Figura 22: Circuitos Digitais: Contribuições ................................................................... 43 
Figura 23: Circuito Somador Completo de 1 bit. ............................................................ 55 
Figura24: Circuito da Soma de N bits. .......................................................................... 55 
Figura 25: Circuito Subtrator Completo de 1 bit. ............................................................ 57 
Figura 26: Mundo Real x Mundo Digital. ....................................................................... 58 
Figura 26: Métodos de Representação de Dados ......................................................... 58 
Figura 28: Representação em Módulo-Sinal ................................................................. 60 
Figura 29: Faixa de Representação de Números Reais. ............................................... 68 
Figura 30: Organização típica de um computador. ........................................................ 75 
Figura 31: Programa na Memória RAM: Código + Dados. ............................................ 76 
 
Introdução à Programação: Conceitos e Práticas. Página 8 
Figura 32: Unidade Central de Processamento típica. .................................................. 77 
Figura 33: Passos na execução de uma instrução. ....................................................... 78 
Figura 34: A sincronização da execução de uma instrução com o sinal de clock. ........ 82 
Figura 35: Execução e Pipeline. .................................................................................... 83 
Figura 36: Memória Cache. ........................................................................................... 84 
Figura 37: Genealogia das Linguagens – Base FORTRAN. ......................................... 86 
Figura 38: Genealogia das Linguagens. ........................................................................ 87 
Figura 39: Níveis de Programação. ............................................................................... 87 
Figura 40: Ciclo de Desenvolvimento de Software. ....................................................... 88 
Figura 41: Processo de Tradução ................................................................................. 89 
Figura 42: Estilo de Programação Spaghetti. ................................................................ 90 
Figura 43: Evolução no estilo de programação. ............................................................ 91 
Figura 44: Modos do Compilador. ................................................................................. 97 
Figura 45: Acesso a tela com as diretivas de compilação. ............................................ 98 
Figura 46: Alocação das variáveis na memória. ............................................................ 99 
Figura 47: Programa fonte e janela de execução ........................................................ 114 
Figura 48: Estrutura de uma função. ........................................................................... 117 
Figura 49: Contexto da chamada da função foo. ......................................................... 127 
Figura 50: Ponto 1 – Passagem por Cópia. ................................................................. 128 
Figura 51: Ponto 2 – Passagem por Cópia. ................................................................. 128 
Figura 52: Ponto 3 – Passagem por Cópia. ................................................................. 129 
Figura 53: Ponto 1 – Passagem por Referência. ......................................................... 130 
Figura 54: Ponto 2 – Passagem por Referência. ......................................................... 131 
Figura 55: Ponto 3 – Passagem por Referência. ......................................................... 131 
Figura 56: Ponto 1 – Calculo Raizes. .......................................................................... 134 
Figura 57: Ponto 2 – Calculo Raizes. .......................................................................... 135 
Figura 58: Ponto 3 – Calculo Raizes. .......................................................................... 136 
Figura 59: Diagrama lógico para o cálculo das raízes de uma equação do 2º grau. ... 162 
Figura 60: Instrução CASE .......................................................................................... 169 
Figura 61: Repetição do tipo FOR. .............................................................................. 176 
Figura 62: Estrutura de Controle do tipo FOR ............................................................. 176 
Figura 63: Instrução BREAK. ....................................................................................... 189 
Figura 64: Conversão Decimal - Binário ...................................................................... 197 
Figura 65: Correspondência entre Definição do Vetor e a Atribuição. ......................... 213 
Figura 66: Cópia de Sub-Vetor. ................................................................................... 229 
Figura 67: Posição de Sub-Vetor. ................................................................................ 229 
Figura 68: Eliminação de um Sub-Vetor. ..................................................................... 230 
Figura 69: Comparação Escalar, Vetor e Matriz .......................................................... 234 
Figura 70: Entrada/Saída de grande volume de dados sem o uso de arquivos .......... 258 
Figura 71: Entrada/Saída de grande volume de dados com o uso de arquivos .......... 259 
Figura 72: Visualização de um arquivo texto como sequência de caracteres. ............ 260 
Figura 73: Visualização de um arquivo executável como sequência de caracteres. ... 260 
Figura 74: Dado em Memória gravado em arquivo como binário ................................ 261 
Figura 75: Dado em Memória gravado em arquivo como texto ................................... 261 
Figura 76: Manipulação de Arquivo por um programa ................................................. 262 
Figura 77: Organização dos dados da disciplina na memória ..................................... 277 
Figura 78: Abstrações típicas de uma linguagem procedural ...................................... 298 
 
Introdução à Programação: Conceitos e Práticas. Página 9 
 
 
 
 
 
PREFÁCIO 
 
 
 
 
O conteúdo deste material é fruto de um conjunto de notas de aulas preparadas para a 
disciplina introdutória à programação da grade do curso de Ciência da Computação e 
posteriormente estendido para cursos de engenharias, principalmente Engenharia Elétrica 
e Mecânica. A estrutura do material não está centrada em uma linguagem de 
programação, mas sim no estabelecimento de uma sequência natural de conteúdos que 
proporcione, desde o seu princípio, o suporte logico para a construção de programas 
elementares. No avançar das temáticas o conhecimento vai sendo refinado e ao mesmo 
tempo testado com problemas mais elaborados. 
 
Antecedendo o conteúdo de programação são apresentados tópicos que ilustram os 
pontos na história que marcaram a evolução da computação, onde conhecimentos das 
mais diversas áreas foram combinados a fim de delinear o estado atual da tecnologia da 
informação. Uma parte fundamental da computação está na compreensão da natureza 
dos dados e como eles circulam no ambiente computacional. Assim, os sistemas de 
numeração são abordados visando alcançar um entendimento sobre a notação binária 
que predomina no mundo digital. Uma breve exposição sobre a Á������	
�	����� destaca 
o trânsito da informação entre as camadas de ℎ��
���� e de ��������, e expõe a 
importância de se compreender toda a transformação a que é submetido um determinado 
problema até se transformar efetivamente em um programa ativo na arquitetura do 
computador. Um estudante de computação ou de engenharia (relacionada ao tema) deve 
ter a clara noção de todas as camadas de abstração que formam o contexto 
computacional. Os principais métodos de representação de dados elementares são 
expostos e proporcionam conhecimentos essenciais ao entendimento dos seus impactos 
nos algoritmos.A parte de programação estabelece uma sequência de exposição do conteúdo tanto nos 
aspectos conceituais quanto nas aplicações práticas. Os recursos de programação 
apresentados são os típicos da família de linguagens denominada imperativa ou 
procedural, e a linguagem ������ é a escolhida para concretizar os ensinamentos. A 
grande similaridade entre as linguagens procedurais atuais faz com que a transposição 
dos conhecimentos apresentados para outras linguagens seja muito facilitada. 
 
Introdução à Programação: Conceitos e Práticas. Página 10 
 
 1. História da Computação 
 
Este capítulo resume os principais eventos históricos que culminaram com o estágio 
atual da tecnologia digital. Os desenvolvimentos ocorreram nas mais variadas áreas da 
Ciência e o processo de evolução tecnológica foi gerado em grande parte pelo 
cruzamento destes conhecimentos. Destaca-se como fonte de consulta para 
aprofundamento dos temas aqui citados a publicação ��������	07�� . Além disso, o 
acervo do �!"!#�
!� e do site ℎ��#://���. ��'#(���ℎ!����). ���, principalmente as 
fotos, também serviram de fonte de consulta. 
 
 
 1.1. Principais Eventos 
 
O uso de ferramentas para apoiar as atividades do homem não é recente, e desde os 
primórdios de nossa história tem-se observado um constante aumento no uso de 
equipamentos e instrumentos que auxiliam nas tarefas normalmente realizadas por seres 
humanos. 
 
No campo da informática, o processo de evolução se deu de forma lenta durante séculos, 
experimentando uma explosão tecnológica acentuada na segunda metade do século 
passado. 
 
Na busca por alternativas para o trabalho realizado pelo homem, principalmente na 
mecanização do processo de contagem e na realização de trabalhos exaustivos, 
obstáculos importantes foram sendo superados, a saber: 
 
a) 3500 a.C. - uso do ábaco no vale entre os rios Tigre e Eufrates; 
b) 2600 a.C. - aparecimento do ábaco chinês, chamado Suan-Pan, e do Soroban no 
Japão; 
 
 
Figura 1: Ábaco. 
 
Figura 2: Ábaco e o seu uso. 
 
 
Introdução à Programação: Conceitos e Práticas. Página 11 
c) 100 a.C. – uso de um mecanismo denominado Anticítera1 com um complexo sistema 
de engrenagens provavelmente aplicado à navegação. Foi resgatado em 1901 na 
costa da ilha grega de Anticítera. O sistema de engrenagens simulava as órbitas da 
lua, sol e de mais cinco planetas, além de prever eclipses da lua e do sol. 
 
Figura 3: O mecanismo de 
Anticítera. 
 
 
Figura 4: Réplica do 
mecanismo de Anticítera
2
. 
 
Figura 5: Esquema da máquina de 
Anticítera. 
 
d) séc. 012 - John Napier (Edimburgo - Escócia, 1550 — 4 de abril de 1617) inventou o 
logaritmo e uma máquina capaz de multiplicar e dividir automaticamente; 
 
 
Figura 6: Tabela de Logaritmo de Napier 
 
 
1
 http://pt.wikipedia.org/wiki/Máquina_de_Anticítera 
2
 Disponível no Museu Arqueológico Nacional de Atenas (feita por Robert J. Deroski, com base em Derek J. de Solla 
Price. http://pt.wikipedia.org/wiki/Máquina_de_Anticítera 
 
Introdução à Programação: Conceitos e Práticas. Página 12 
e) 1623 - Wilhelm Schickard (22 de abril de 1592, Herrenberg, Alemanha — 23 de 
outubro de 1635, Tübingen) construiu uma calculadora mecânica, baseada em rodas 
dentadas, capaz de realizar as 4 operações básicas com números de seis dígitos e 
indicar um overflow através do toque de um sino. 
 
 
Figura 7: Manuscrito Original de Schickard. 
 
Figura 8: Réplica da Calculadora de Schickard. 
 
f) 1642 - Blaise Pascal (Clermont-Ferrand - França, 19 de Junho de 1623 — Paris, 19 de 
Agosto de 1662) utilizando o princípio do ábaco, implementou uma máquina 
automática de calcular - La pascaline. Efetuava somas e subtrações; 
 
 
Figura 9: La Pascaline. 
 
Figura 10: La Pascaline. 
 
g) 1622 – Padre Willian Oughtred (Eton-Inglaterra, 5 de Março de 1575 — Albury, 30 de 
Junho de 1660) inventou a régua de cálculo (Slide rule/ slipstick) baseada nos 
logaritmos de Napier e divulgou o uso do sinal ‘ 5 ’ para multiplicação, tendo 
introduzido os termos ��7�, �����7� e ��7��7��. 
 
 
Introdução à Programação: Conceitos e Práticas. Página 13 
h) 1657 – Seth Patridge, Inglês, desenvolveu a régua de cálculo deslizante. Este 
dispositivo foi muito utilizado até os anos setenta; 
 
Figura 11: Régua de Cálculo. 
i) 1672 - Gottfried Wilhelm von Leibniz (Leipzig - Alemanha, 1 de julho de 1646 — 
Hanover, 14 de novembro de 1716) aprimorou a máquina de Pascal e obteve uma 
calculadora que somava, subtraía, multiplicava e dividia; 
 
 
Figura 12: Máquina de Leibniz. 
j) 1801 – Joseph Marie Charles - apelido Jacquard (Lyon – França, 7 de Julho de 1752 – 
7 de Agosto de 1834), mecânico, construiu um tear automático com entrada de dados 
via cartões perfurados para controlar a confecção dos tecidos e seus desenhos; 
 
 
Figura 13: Tear Automático de Jacquard. 
 
Introdução à Programação: Conceitos e Práticas. Página 14 
k) 1833 – Charles Babbage (Londres - Inglaterra, 26 de Dezembro de 1791 — Londres, 
18 de Outubro de 1871) projetou a sua Máquina Analítica ou Diferencial, que possuía 
memória, programa, unidade de controle e periféricos; 
 
 
Figura 14: Máquina Analítica de Babbage. 
 
l) 1842 - Ada Augusta Byron King, Condessa de Lovelace (Londres – Inglaterra, 10 de 
Dezembro de 1815 - 27 de Novembro de 1852), conhecida como Ada Lovelace, fez os 
primeiros estudos sobre aritmética binária. Escreveu o primeiro algoritmo para ser 
processado por uma máquina, a máquina analítica de Charles Babbage. 
 
 
Figura 15: Formulário: Primeiro algoritmo de Ada. 
 
 
Introdução à Programação: Conceitos e Práticas. Página 15 
m) 1854 - George Boole (Lincoln - Inglaterra, 2 de Novembro de 1815 — Ballintemple, 8 
de Dezembro de 1864) desenvolveu a teoria da Álgebra de Boole (livro: An 
Investigation of the Laws of Thought), que permitiu o desenvolvimento da Teoria dos 
Circuitos Lógicos; 
 
n) 1885 - Herman Hollerith (Buffalo - EUA, 29 de Fevereiro de 1860 — Washington, D.C., 
17 de Novembro de 1929) empresário norte-americano, construiu a Máquina de 
recenseamento utilizada no censo de 1890 dos EUA. A máquina efetuava a leitura dos 
cartões de papel perfurados com as informações em código ��9 (Decimal Codificado 
em Binário). Os dados do censo de 1890 foram tabulados em apenas um ano. O 
censo de 1880 levou oito anos para ser tabulado; 
 
 
Figura 16: Cartão perfurado de 
Hollerith. 
 
 
Figura 17: Máquina de Tabulação. 
 
 
o) 1924 - Hollerith e Watson fundam a IBM; 
p) 1936 - Alan Mathison Turing (Londres – Inglaterra, 23 de Junho de 1912 — 7 de Junho 
de 1954) desenvolveu a teoria de uma 'á;(!7� capaz de resolver qualquer problema 
computável. Foi denominada de <á;(!7�	
�	=(�!7�; 
q) 1937 - Claude Elwood Shannon (Petoskey, Michigan – EUA, 30 de Abril de 1916 — 
24 de Fevereiro de 2001) escreve sua tese de mestrado “A Symbolic Analysis of Relay 
and Switching Circuits” onde utiliza aritmética binária e Álgebra de Boole para 
implementar lógicas através de circuitos com chaves e relés, tornando-se um marco 
para os circuitos digitais; 
r) 1943 - sob a liderança de Alan Turing foi projetado o ������(�, computador inglês 
utilizado na Segunda Guerra Mundial para quebrar o segredo alemão codificado pela 
máquina �7!�'�. 
 
 
Introdução à Programação: Conceitos e Práticas. Página 16 
Este processo evolutivo culminou com o surgimento das primeiras máquinas capazes de 
realizar cálculos mais complexos do que as operações básicas. A partir de então, várias 
gerações de computadores foram surgindo até os dias atuais. 
 
 
 1.2. Gerações de Computadores 
 
Na sequência são listadas as principais contribuiçõesem cada geração de 
computadores, enfatizando-se a tecnologia utilizada para a construção do hardware e a 
forma de programação. Trata-se apenas de um sumário bastante resumido, que serve 
como referência de termos para pesquisas mais detalhadas. 
 
 
 1.2.1. Primeira Geração (1938 - 1953) 
 
A primeira geração foi marcada pela construção do primeiro computador eletrônico, o 
��2��V (Electronic Numerical Integrator and Computer), em 1946, tornando-se um marco 
na evolução da computação. O ��2�� começou a operar em 1943, sendo concluído 
totalmente em 1946 e encerrando suas operações em 1955. 
 
O desenvolvimento do ��2�� se deu na Universidade da Pensilvânia (Filadélfia, EUA), e 
contou com o apoio de John von Neumann. 
 
 
 
Figura 18: ENIAC. 
 
O ��2�� continha 18.000 válvulas, 1.500 relés, 70.000 resistores, 10.000 capacitores o 
que resultava em mais de 27 toneladas de equipamentos distribuídos em 167	'>. Seu 
consumo chegava a 150	"?. A entrada e saída de dados eram feitas por meio de leitora 
de cartões de perfurados, enquanto que a programação se dava pela construção de 
 
Introdução à Programação: Conceitos e Práticas. Página 17 
circuitos específicos para tratar o problema por ajustes manuais de chaves e conexões de 
cabos. 
 
A unidade de sincronização trabalhava com ciclos de 200 microsegundos (20 ciclos de 
clock de 100	"@A), sendo capaz de executar 5000 adições/subtrações ou 360 
multiplicações ou 35 divisões ou raiz quadrada por segundo. A memória era capaz de 
conter 20 números (80 bytes). 
 
Sua utilização inicial foi em trabalhos com soluções numéricas de problemas relacionados 
com trajetórias balísticas e no desenvolvimento da bomba de hidrogênio. 
 
Em junho de 1945, von Neumann publicou o trabalho sobre o �91�� (Electronic Discrete 
Variable Automatic Computer), e estabeleceu as bases para as arquiteturas de 
computadores das gerações seguintes, atualmente conhecida como “arquitetura de von 
Neumann”, que trazia o conceito de programa armazenado. 
 
O esforço de guerra levou à construção, em 1943, pelos ingleses da máquina ��B�����, 
concebida para quebrar o código da máquina alemã ��2C<�, utilizada na transmissão de 
mensagens. Pelo fato de ser uma máquina estratégica no campo militar, a sua divulgação 
foi bastante limitada, o que restringiu o reconhecimento da sua importância no 
desenvolvimento da computação. Os trabalhos de Alan Turing sobre computabilidade 
foram consideravelmente relevantes na construção dos algoritmos da máquina 
��B�����. 
 
Nesta geração, a programação era em linguagem de máquina composta da codificação 
binária das instruções da máquina. Por exemplo, a soma de dois números produzindo um 
resultado na memória tinha um código semelhante à: 
 
�1	00	�0	40	00	03	05	04	�0	40	00	�3	08	�0	40	00	
 
O entendimento desta lógica era restrito aos profissionais com conhecimento da 
arquitetura do computador. 
 
Em resumo, a primeira geração se caracterizou por: 
 
• Surgimento do ��2��; 
• Utilização de relés como dispositivos de chaveamento; 
• Utilização de válvulas a vácuo; 
• Hardware caro, grande e de difícil manutenção; 
• Programação em linguagem de máquina; 
• �91�� permitiu o uso de software. 
 
 
 1.2.2. Segunda Geração (1952 - 1963) 
 
 
Introdução à Programação: Conceitos e Práticas. Página 18 
A segunda geração foi caracterizada pela invenção do ���7�!���� por John Bardeen, 
Walter Brattain e William Shockley. Em dezembro de 1947 Brattain e Moore apresentaram 
o dispositivo para um grupo da Bell Labs. 
 
Em 1954 a Bell Labs conclui o =D�92�, tido como o primeiro computador totalmente 
transistorizado. As vantagens dos transistores em relação às válvulas a vácuo são 
principalmente: menos consumo de energia, peso e tamanho menores, reduzida perda de 
calor e aquecimento, maior confiabilidade e robustez, maior duração e resistência a 
impacto e vibração. 
 
Também nesta geração foram consolidados dispositivos como as impressoras, as fitas 
magnéticas e os discos para armazenamento, dentre outros. 
 
A memória do computador passou a utilizar tecnologia de núcleo magnético, também 
denominada ����	'�'��), composta por diminutos anéis magnéticos conectados por fios 
que permitiam a leitura e gravação de informação. Os valores A��� e (' eram associados 
ao sentido de magnetização deste núcleo. 
 
 
Figura 19: Memória de Núcleo. 
 
O surgimento dos sistemas operacionais e das linguagens de programação acelerou o 
desenvolvimento dos computadores. 
 
A forma de programação evoluiu da �!7�(���'	
�	'á;(!7� para �!7�(���'	����'��), 
onde os códigos binários eram associados a mnemônicos que indicavam o tipo de 
operação realizada. Assim, a soma de dois números produzindo um resultado na memória 
tinha um código semelhante à: 
 
LINGUAGEM ASSEMBLY LINGUAGEM DE MÁQUINA 
<�1	��0, 0	
�99	��0, F	
<�1	G, ��0 
�1	00	�0	40	00	
03	05	04	�0	40	00	
�3	08	�0	40	00	
 
A percepção do poder de codificação em linguagens mais acessíveis levou a um 
importante salto das linguagens de alto nível com a criação do FORTRAN em 1956 e 
COBOL em 1960, iniciando assim um forte ciclo de desenvolvimento de novas linguagens. 
 
O mesmo problema podia agora ser codificado em uma �!7�(���'	
�	����	7íI�� de forma 
muito semelhante à sua notação matemática: 
 
Introdução à Programação: Conceitos e Práticas. Página 19 
 
LINGUAGEM DE ALTO NÍVEL LINGUAGEM ASSEMBLY LINGUAGEM DE MÁQUINA 
A	 J 	K	 L 	);	
<�1	��0, 0	
�99	��0, F	
<�1	G, ��0 
�1	00	�0	40	00	
03	05	04	�0	40	00	
�3	08	�0	40	00	
 
A forma de utilização dos computadores era semelhante a de uma calculadora, onde o 
programa e dados eram introduzidos via cartões perfurados, fita de papel perfurado ou fita 
magnética e os resultados eram gerados para estes mesmos dispositivos. Em 1953 a 
primeira impressoraVI, fabricada pela Remington-Rand, foi utilizada como dispositivo de 
saída integrado ao computador N�21��, dos mesmos criadores do ��2��. 
 
Neste período, os computadores ocupavam salas específicas que acomodavam toda a 
estrutura de equipamentos e sua operação demandava técnicos especializados. É 
importante lembrar que os computadores eram caros e de uso restrito a governos, 
universidades e grandes corporações. Os programas eram produzidos e escritos em 
formulário próprio e levados à sala de perfuração de cartão. O maço de cartões era levado 
á sala com a leitora, onde um operador procedia a leitura e processamento do pacote com 
o programa. Ao encerrar o processamento deste lote de cartões então o operador se 
dirigia a sala de impressora para retirar o relatório para entrega ao usuário. A seguinte 
figura esboça este fluxo: 
 
 
Figura 20: Ambiente de Programação da Segunda Geração. 
 
Cada programa que necessitava de processamento tinha que seguir este fluxo. A 
necessidade de melhores mecanismos de interação entre usuário e o computador, 
facilidades para administrar o processamento dos programas e formas de gerenciar o 
 
Introdução à Programação: Conceitos e Práticas. Página 20 
computador e seus periféricos levou ao desenvolvimento de um conjunto de programas 
que foi denominado de �!���'�	�#����!�7��. 
 
Assim, surgiu a ideia de processamento em lote onde grupos de programas (maços de 
cartões) eram lidos e gravados em uma fita. A fita era levada à sala de processamento e 
lida para o computador, que processava toda a sequência e gerava uma saída também 
em fita, cuja impressão acontecia em uma unidade separada (impressão off-line). 
 
Em resumo, a segunda geração se caracterizou por: 
 
• invenção do transistor; 
• 1º computador a transistor (=D�92�) pela BELL Labs; 
• uso de transistores e diodos; 
• uso de memória de núcleo; 
• uso de linguagem Assembly até 1956, e de FORTRAN e COBOL a partir daí; 
• surgimento dosSistemas Operacionais para Processamento em ����ℎ (Lote) de 
programas. 
 
 
 1.2.3. Terceira Geração (1962 - 1975) 
 
Na geração anterior, o elemento básico para construção dos processadores evoluiu da 
válvula a vácuo para os transistores. Na terceira geração, o transistor continuou a ser o 
dispositivo de construção elementar, porém surgiu o circuito integrado (�2 ou chip) em 
pequena (10 componentes eletrônicos por �2) e média escala (100 componentes 
eletrônicos por �2), que são circuitos eletrônicos em miniatura compostos principalmente 
por dispositivos semicondutores. 
 
A invenção do circuito integrado ou �ℎ!# (1958) é atribuída a Jack Kilby da Texas 
Instruments e Robert Noyce, da Fairchild Semiconductor, cabendo a Kilby o Prêmio Nobel 
de Física no ano 2000 pela participação na criação. 
 
O uso de circuitos integrados permitiu maior compactação e confiabilidade dos 
computadores com expressiva redução de custos. A tecnologia de fabricação da memória 
de acesso aleatório (RAM) evolui da ����	'�'��) para dispositivos de estado sólido. 
 
O ℎ��
���� tinha as maiores atenções no projeto de um computador, porém o �������� 
estava ganhando importância rapidamente. Foram criadas várias linguagens de 
programação, entre elas �����, B!�#, �, ������, ������, �
� dentre outras. O processo 
de produção de programas começou a ser visto como atividade de engenharia, com todo 
o rigor que isto significa. 
 
A figura a seguir ilustra como o programador foi se afastando da necessidade de 
codificar diretamente em binário na medida em que surgiam novas linguagens de 
programação. Inicialmente a B!7�(���'	����'��) permitiu maior produtividade na 
programação, e a tradução para a B!7�(���'	
�	<á;(!7� era feita por um software 
 
Introdução à Programação: Conceitos e Práticas. Página 21 
tradutor denominado ����'����. Em seguida, com o surgimento da 
B!7�(���'	
�	����	�íI��, como o ��D=D��, o programador codificava de forma mais 
adequada aos problemas matemáticos, sendo que a tradução para o ����'��) era feita 
por um software denominado ��'#!��
��. 
 
 
Figura 21: Evolução no nível de Programação. 
 
Houve importante melhoria nos compiladores, que passaram a produzir códigos tão 
eficientes quanto um bom programador de linguagem assembly. 
 
O mercado de computadores era majoritariamente dominado pelos produtos da IBM, com 
destaque para os '�!7���'�� ou computadores de grande porte. Os sistemas 
operacionais apresentaram significativa melhora e incorporaram recursos de 
multiprogramação, time-sharing e memória-virtual. A multiprogramação permitia que o 
sistema operacional trabalhasse com vários programas ativos. Neste caso, se um 
determinado programa demandava dados armazenados em fita, então outro programa 
entrava em processamento, até que o recurso do programa anterior fosse disponibilizado. 
O �!'��ℎ��!7�, similar ao multiprocessamento, permitiu que um único computador tivesse 
seu uso compartilhado por múltiplos usuários com acesso via terminal on-line. A memória 
virtual é um técnica que permite que programas utilizem mais memória do que o 
disponível fisicamente na memória principal. A memória secundária (em disco, fita ou 
outro meio de armazenamento) é utilizada como suporte para esta técnica de 
gerenciamento de memória. 
 
Outro recurso típico da terceira geração permitiu que programas fossem carregados 
diretamente dos cartões para discos. Assim, logo que um determinado programa tivesse 
sua execução encerrada, o sistema operacional iria carregar um dos programas do disco 
para a partição de memória destinada aos serviços em execução. Este recurso recebeu o 
nome de ����B (�!'(���7���	���!#ℎ����	�#����!�7	�7 O B!7�). 
 
Em resumo, a terceira geração se caracterizou por: 
 
• uso de circuitos integrados em pequena (SSI) e média escala (MSI); 
• uso de circuitos impressos em multicamadas; 
• uso de memória de estado sólido; 
 
Introdução à Programação: Conceitos e Práticas. Página 22 
• linguagens de alto nível com compiladores inteligentes; 
• uso de multiprogramação 
• sistemas operacionais para uso em �!'��ℎ��!7� (tempo-compartilhado); 
• utilização de memória virtual. 
 
 1.2.4. Quarta Geração (1972 - ...) 
 
Os circuitos integrados apresentaram um aumento significante na quantidade de 
transistores. A tecnologia foi denominada de Integração em Escala Muito Grande 
(1B�2	– 	1��)	B����	�����	27������!�7), incorporando de 10.000 a 100.000 transistores. 
As escalas seguintes de integração, ultra e super, comportam 10Q a 10R e 10R a 10S 
dispositivos semicondutores respectivamente. 
 
Este nível de integração e compactação permitiu que os CI´s incorporassem cada vez 
mais blocos funcionais da arquitetura do computador, ao ponto que todos os elementos 
básicos de uma CPU (Central Processing Unit) coubessem em um único chip, surgindo o 
microprocessador. 
 
A Intel teve importante papel no desenvolvimento dos microprocessadores, tendo iniciado 
com o modelo Intel 4004 produzido em 1969. Este processador era um dispositivo de 4 
bits que continha uma ALU (Aritmetic and Logic Unit), uma unidade de controle e alguns 
registradores. O marco importante foi o lançamento em 1979, do seu primeiro 
processador de 16 bits, o 8086. 
 
Logo em seguida, a IBM lança em 1981 o IBM PC que se tornou padrão para 
microcomputadores. O respaldo da IBM foi essencial para a aceitação e o crescimento 
deste equipamento. Uma série de fabricantes passou a produzir componentes para esta 
arquitetura, enquanto que a própria IBM se manteve na linha dos computadores de grande 
porte, os '�!7���'��. 
 
Os meios de armazenamentos tais como unidades de disco e fita ocupavam espaços 
consideráveis nos CPD´s (Centro de Processamento de Dados), tornando assim um 
desafio produzir uma unidade que fosse compatível com uso pessoal. Neste ponto, as 
unidades de discos flexíveis (floppy disk) foram fundamentais para a viabilização dos 
PC´s. 
 
Os sistemas operacionais incorporavam cada vez mais facilidades de gerenciamento dos 
recursos computacionais, tais como CPU, memória, processos e arquivos. Os sistemas 
operacionais DOS e Unix tiveram seu período de consolidação, sendo o DOS no ambiente 
PC Intel e o UNIX basicamente nas ���"����!�7� RISC. A Microsoft iniciou sua trajetória 
com o DOS, e esta plataforma estimulou o surgimento de um novo mercado de 
desenvolvimento de softwares. 
 
A necessidade de compartilhar informações e itens de ℎ��
���� impulsionou o 
surgimento das redes de computador e do processamento distribuído. E os sistemas 
 
Introdução à Programação: Conceitos e Práticas. Página 23 
operacionais tiveram que ampliar suas capacidades para incluir o gerenciamento de mais 
estes recursos, fazendo que toda esta complexidade fosse transparente ao usuário. 
 
O nível de integração dos circuitos integrados alavancou arquiteturas de computadores 
com múltiplos processadores permitindo o processamento paralelo. 
 
Em resumo, a quarta geração se caracterizou por: 
 
• uso de circuitos integrados em escala muito grande (VLSI); 
• compactação em alta densidade (computadores menores); 
• Linguagens de alto nível que manuseiam tanto dados escalares como vetores; 
• sistema operacionais em Time-sharing e Memória Virtual; 
• sistemas com multiprocessadores; 
• Processadores paralelos; 
• aparecimento dos microprocessadores; 
• uso de disquetes (floppy disk) como meio de armazenamento; 
 
Algumas literaturas qualificam o estágio atual como sendo 5ª	����çã�, principalmente pelo 
forte emprego da tecnologia de 27���!�ê7�!�	���!�!�!��. Porém, é difícil classificar uma 
geração fazendo parte dela, pois o avanço tecnológico atual traz inovações a todo o 
momento. Por exemplo, poderíamos qualificar como marco extraordinário a abertura da 
internet e o surgimento da ?���
	?!
�	?�� e do primeiro browserem 1990, por Tim 
Berners-Lee. O interessante é que seria uma geração caracterizada principalmente por 
criações de ��������. 
 
O quadro a seguir destaca os principais elementos de �������� e de ℎ��
���� que 
caracterizaram as gerações: 
 
GERAÇÕES 1ª 2ª 3ª 4ª 
Software Ling. Máquina Ling. Assembly Ling. Alto Nível Sistema Operacional 
Compiladores Inteligentes 
Hardware Relés 
Válvulas 
Diodo 
Transistor 
Circuitos 
Integrados 
Circuitos Integrados VLSI 
Microprocessadores 
 
 
 
 
Introdução à Programação: Conceitos e Práticas. Página 24 
 2. Sistemas de Numeração 
 
Há cerca de 10.000 anos o homem começou a ter necessidade de contar (agricultura e 
pastoreio), onde os pastores de ovelhas tinham necessidades de controlar os rebanhos. 
Precisavam saber se não faltavam ovelhas. (III) 
Alguns vestígios indicam que os pastores faziam o controle de seu rebanho usando 
conjuntos de pedras. Ao soltar as ovelhas, o pastor separava uma pedra para cada 
animal que passava e guardava o monte de pedras. 
Quando os animais voltavam, o pastor retirava do monte uma pedra para cada ovelha 
que passava. Se sobrassem pedras, ficaria sabendo que havia perdido ovelhas. Se 
faltassem pedras, saberia que o rebanho havia aumentado. Desta forma mantinha tudo 
sob controle. 
Uma ligação do tipo: para cada ovelha, uma pedra chama-se, em Matemática, 
correspondência um a um. Provavelmente passou a utilizar o dedo como apoio à 
contagem, sem, no entanto poder guardar a informação. 
O processo de contagem evoluiu para o agrupamento quando tratava de grandes 
quantidades, p. ex: João fez pontos (12 pontos). 
 
 2.1. Sistema de Numeração Egípcio 
 
Essa ideia de agrupar marcas foi utilizada nos sistemas mais antigos de numeração. Os 
egípcios da antiguidade criaram um sistema muito interessante para escrever números, 
baseado em agrupamentos. 
• 1 era representado por uma marca que se parecia com um bastão | 
• 2 por duas marcas || 
• E assim por diante. 
 
Símbolo descrição valor 
 
bastão 1 
 
calcanhar 10 
 
rolo de corda 100 
 
flor de lótus 1.000 
 
dedo apontando 10.000 
 
peixe 100.000 
 
homem 1.000.000 
 
Introdução à Programação: Conceitos e Práticas. Página 25 
 
Os números eram compostos pela associação destes símbolos e a quantidade 
representada era obtida pela soma dos valores individuais. Por exemplo, 35624 é 
representado por: 
 
 2.2. Sistema de Numeração Romano 
 
O sistema de numeração romano possui um conjunto símbolos, conforme tabela 
abaixo, sendo que um número é representado pela combinação destes símbolos e o 
valor é a soma de cada uma das parcelas. 
 
 
2 1 0 B � 9 < 
1 5 10 50 100 500 1000 
 
A fim de evitar representações muito extensas, um determinado valor pode ser 
representado a partir de um símbolo de referência acompanhado de símbolos a 
esquerda (subtração do valor principal) ou a direita (soma ao valor principal). Por 
exemplo, 022 (10	 L 	2	 J 	12) e 20 (10	– 	1	 J 	9). 
 
Este sistema é bastante limitado para aplicações da matemática que vão além da 
representação de números, onde mesmo as operações básicas são difíceis de serem 
efetuadas. 
 
 
 
Introdução à Programação: Conceitos e Práticas. Página 26 
 
 
Os números são estruturados pela combinação destes símbolos, sendo cada símbolo 
contribuindo com o seu valor multiplicado por 20 elevado a sua posição. A soma destas 
parcelas fornece o valor do número. Por exemplo, o número 49	 J 	2 5 20X L 9 5 20Y, 
que no sistema '�!� fica: 
 
 
Este sistema permite a execução das operações básicas com a mesma facilidade que 
fazemos no nosso sistema decimal. Vejamos o exemplo que segue: 
 
 
 
 
 
A coluna 1 indica a operação desejada. As colunas 2 e 3 indicam a decomposição do 
38 J 1 5 20X L 18 5 20Y e 73 J 3 5 20X L 13 5 20Y no sistema vigesimal. As colunas 4 e 
5 contém o 38 e 73 no sistema '�!�. A coluna 6 indica a soma provisória que se 
●●●● 
●●● 
●● 
● 
●●●● 
●●● 
●● 
● 
●●●● 
●●● 
●● 
● 
●●●● 
●●● 
●● 
● 
Z 5 20X 
[ 5 20Y 
●● 
●●●● 
 
Introdução à Programação: Conceitos e Práticas. Página 27 
obtém juntando as parcelas. Na sequência vêm os ajustes necessários, transferindo os 
excedentes a 20, ou seja, cada 20 unidades excedentes em uma casa equivale a uma 
unidade na casa superior. Como o símbolo equivale a ●●●●●, então na coluna 7 
são transferidas 20 unidades ( 3 e 5 ●) da posição 20Y para a posição 20X. Isto 
faz surgir um símbolo ● a mais na posição 20X. Na coluna 8 tem-se os ●●●●● da 
posição 20X substituídos por um . Na coluna 9 tem-se a notação '�!� convertida 
para uma expressão convencional e o resultado da soma destas parcelas é indicado na 
coluna 10, tal como se esperava da soma 38 L 73 J 111. 
 
 2.4. Sistema de Numeração Decimal 
 
Além dos sistemas numéricos egípcio, romano e maia, outras civilizações da 
antiguidade, como os babilônios, gregos, chineses e hindus, criaram seus próprios 
sistemas numéricos. Com exceção dos maias, que habitavam a América, as civilizações 
da Europa, Oriente e Oriente Médio trocavam mercadorias e conhecimentos. 
No campo da matemática, a ciência dos gregos atingiu grande desenvolvimento no 
século 21	�. �., com Euclides, cuja obra sobre Geometria (Os Elementos) é importante 
até os atuais no ensino desse campo da matemática. Os gregos criaram seu próprio 
sistema de numeração, com base 10, utilizando letras para representar os números, o 
que não facilitava os cálculos. 
Os romanos, que expandiram seus domínios a partir do século 1	�. �., assimilaram uma 
parte da ciência grega, mas interessaram-se sobretudo por suas aplicações práticas, na 
engenharia (construção de estradas e aquedutos) e na medicina, porém sem 
contribuição relevante na matemática. 
As invasões bárbaras, nos séculos 1 e 12 
. �., colocaram fim ao Império Romano e 
conduziu o mundo ocidental a um período de trevas no campo da Ciência. 
Entretanto, enquanto o Império Romano declinava, uma grande civilização florescia no 
Oriente, no vale do rio Indo, entre as regiões que atualmente constituem o Paquistão e 
a Índia. 
É importante destacar que os sistemas de numeração egípcio e romano não eram 
propícios para efetuar cálculos. As dificuldades destes sistemas foram superadas pelos 
hindus, que foram os criadores do moderno sistema de numeração. Eles souberam 
reunir três características que já apareciam em outros sistemas numéricos da 
antiguidade: 
• o sistema de numeração hindu é decimal (o egípcio, o romano e o chinês 
também o eram); 
• o sistema de numeração hindu é posicional (o babilônio também era); 
• o sistema de numeração hindu tem o zero, isto é, um símbolo para o nada. 
Estas três características, reunidas, tornaram o sistema de numeração hindu o mais 
prático de todos. Não é sem motivo que hoje ele é usado quase no mundo todo. 
Enquanto os hindus, que habitavam o vale do rio Indo e tinham contatos com muitos 
outros povos; grandes acontecimentos tiveram início na Península Arábica. 
 
Introdução à Programação: Conceitos e Práticas. Página 28 
No século VII floresce o Islamismo, e estabelece um grande império que, um século 
depois da morte de Maomé, atingia, a leste, a região do rio Indo e, a oeste, o norte da 
África e a Península Ibérica; 
Os árabes tiveram um papel importantíssimo no campo da cultura e da ciência, 
especialmente na Matemática. Estudiosos árabes entram em contato com as mais 
variadas culturas. 
Seus sábios estudaram e traduziram as obras dos filósofos e matemáticos gregos, 
preservadas na célebre biblioteca de Alexandria, no Egito. Não fossem as traduções 
para o árabe, essas obras teriam sido perdidas para sempre com a destruição daquela 
biblioteca, no final do século 122. 
No extremooriental do seu império, os árabes entraram em contato com a cultura hindu 
e interessaram-se especialmente pela astronomia, a aritmética e a álgebra, muito 
desenvolvidas naquela civilização. Estudaram sobretudo o sistema numérico hindu, 
reconhecendo sua simplicidade e praticidade. Esses conhecimentos já eram dominados 
pelos hindus há vários séculos, mas não haviam se difundido entre os povos do 
ocidente. 
Os árabes, que haviam penetrado na Europa e dominavam a Península Ibérica, foram 
os introdutores da ciência oriental na Europa medieval. Entre os séculos 1222 e 0222, por 
iniciativa dos árabes, foram criadas muitas universidades e bibliotecas, desde Bagdá, 
no Oriente Médio, até Granada e Córdoba, na atual Espanha. Nesses centros, as obras 
dos hindus foram traduzidas para o árabe e difundidas entre os estudiosos. 
Um marco importante na tentativa de introduzir o sistema hindu-arábico na Europa foi a 
publicação de Leonardo de Pisa (também conhecido por �!��7���!), intitulada 
B!���	����! (O Livro do Ábaco). O pai de Fibonacci era dono de casas de comércio 
ultramarino, sendo uma no norte da África. Ainda jovem Fibonacci mudou-se para esta 
região e conviveu com esta nova matemática e aprofundou seus conhecimentos no 
sistema árabe de numerais e cálculo. Ao retornar a Pisa, Leonardo deu sequência a 
seus estudos e publicou pela primeira vez em 1202 o referido livro, cujo conteúdo 
introduzia a notação árabe, as operações fundamentais com números inteiros, cálculo 
envolvendo séries, proporções, raízes quadradas e cúbicas, e uma breve abordagem 
sobre geometria e álgebra. Neste livro foi apresentado o problema de crescimento da 
população de coelhos de acordo com uma série que levou o nome de �é�!�	
�	�!��7���!. As 459 páginas do livro tornavam difíceis a reprodução de 
exemplares dado que este processo era totalmente manual, o que limitou sua difusão.IV 
Outro destaque foi o início da retomada, em 1085, do território ibérico dos mouros pelo 
rei da Espanha, o que permitiu que populações árabes passassem ao domínio europeu, 
facilitando a absorção do conhecimento escrito em árabe, principalmente os trabalhos 
de �� − ]ℎ���A'!. 
Entretanto, na Europa Medieval houve grande resistência à introdução do saber 
oriental, sobretudo ao sistema de numeração hindu e à maneira de realizar as 
operações nesse sistema. Estabeleceu-se um conflito entre os partidários do velho 
ábaco, herança dos romanos, e os que reconheciam as vantagens do método hindu. 
 
 
Introdução à Programação: Conceitos e Práticas. Página 29 
A Resistência ao Novo 
 
O sistema numérico criado pelos romanos foi usado na Europa durante muitos séculos. 
Isto aconteceu, sobretudo, devido ao grande poder da Igreja Católica Apostólica 
Romana durante toda a Idade Média (do século 1 ao século 01, aproximadamente). O 
sistema de numeração decimal, como vimos, chegou à Europa, levado pelos árabes, 
por volta do século 1222. Portanto, quando a numeração hindu chegou à Europa, os 
europeus estavam acostumados com a numeração romana. 
Na comparação dos dois sistemas, é muito fácil perceber as enormes vantagens que o 
sistema numérico decimal tem sobre a numeração romana. Mesmo assim, o histórico 
apresentado evidencia que a numeração hindu-arábica não foi imediatamente aceita 
pelos europeus, não obstante sua superioridade. 
Foram necessários alguns séculos para que as novas ideias triunfassem 
definitivamente. Isto só aconteceu no século 012. 
Durante muitos anos, uma verdadeira batalha foi travada entre os adeptos do novo 
sistema e os defensores do sistema antigo. Os numerais hindu-arábicos chegaram a 
ser proibidos nos documentos oficiais, mas eram usados na clandestinidade. 
A perseguição, contudo, não conseguiu impedir a disseminação do novo sistema, que 
se impôs pelas suas qualidades. 
Antes da invenção da imprensa, que ocorreu no século 01, os livros eram copiados 
manualmente, um a um. Como cada copista tinha a sua caligrafia, durante os longos 
séculos de copiagem manual as letras e os símbolos para representar números 
sofreram muitas modificações. Além disso, como o sistema de numeração criado pelos 
hindus foi adotado pelos árabes e passado aos europeus, é natural que, nesse 
percurso, a forma de escrever os 
�A algarismos sofresse alterações. A seguinte tabela 
ilustra as modificações: 
 
Por volta do século 21, os hindus 
representavam os algarismos assim, ainda 
sem um símbolo para o nada: 
 
No século 20, já com o A���, a representação 
evoluiu para: 
 
No século 02 os hindus representavam os 
dez dígitos assim: 
 
No mesmo século 02, os árabes que 
estavam no Ocidente representaram assim: 
 
 
Introdução à Programação: Conceitos e Práticas. Página 30 
No século 012 os árabes orientais 
empregavam esta representação: 
 
As formas usadas pelos europeus nos 
séculos 01 e 012: 
 
 
A representação atual: 
 
0 9 8 7 6 5 4 3 2 1 
١ ٢ ٣ ٤ ٥ ٦ ٧ ٨ ٩ ٠ 
 
 
Introdução à Programação: Conceitos e Práticas. Página 31 
 3. Conceito de Bases 
 
Em nosso cotidiano lidamos com números representados na base decimal. Isto se deve a 
razões e históricas, talvez fundamentadas na quantidade de dedos nas mãos. Porém, os 
computadores consolidaram o sistema binário como elemento de referência no projeto dos 
circuitos. A utilização da base 2 proporciona grande facilidade na representação eletrônica 
e digital dos números 0 e 1. A possibilidade de representar os dígitos binários através de 
valores de tensões ou correntes, por exemplo, L51 e O51, simplifica a construção dos 
processadores e demais elementos de uma arquitetura. Combinado com este fato há toda 
uma álgebra desenvolvida no contexto da informação binária/digital, que inclui uma série 
de operações sobre dados binários/lógicos que serviu de base para a construção das 
principais funcionalidades computacionais (memória, circuitos aritméticos, ...). 
 
Um sistema de numeração é determinado fundamentalmente pela base, que é o número 
de símbolos utilizados. A base é o coeficiente que estabelece o valor de cada símbolo de 
acordo com a sua posição. 
 
Na notação posicional os dígitos assumem valores diferentes para cada posição que 
ocupa na representação do número. 
 
Tomando o ponto	^. _ como separador para a parte inteira e a parte fracionária, temos que 
a cada posição que se desloca o dígito a esquerda do ponto o seu valor é multiplicado 
cumulativamente pela base. Da mesma forma, a cada posição que se desloca o dígito a 
direita do ponto o seu valor é dividido cumulativamente pela base. 
 
 
 3.1. Sistema Decimal 
 
O sistema decimal é o mais comumente utilizado nas operações do dia a dia. O conjunto 
de dígitos utilizados é: 
 
 
� J `0,1,2,3,4,5,6,7,8,9a → Base 10 → 10 Símbolos. 
 
 
Por exemplo, partindo do número decimal 373,2, observa-se que cada dígito ^3,7,3, 2_ 
possui um valor diferente dependendo da posição que ocupa no número, a saber: 
 
 
bcb, Z 
 
 
 
 
 
Posição 2 Posição 0 Posição 1 Posição -1 
 
Introdução à Programação: Conceitos e Práticas. Página 32 
 
Esta característica é um dos pilares do sistema decimal utilizado, dando-lhe o aspecto 
���2�2���B, que atribui a cada posição do número um peso distinto. Decompondo 373,2 
em uma somatória, levando em conta o peso da posição, tem-se: 
 
bcb, Z J 300 L 70 L 3 L 0,2 J 3 5 10> L 7 5 10X L 3 5 10Y L 2 5 10dX 
 
As parcelas mostram claramente, através da sua forma geral Dígito 5 Basenopqção, a contribuição de cada elemento ^9í�!��, ���� � ���!çã�_ do 
sistema de numeração utilizado. 
 
 
EXERCÍCIOS: Representar na forma de polinômio os seguintes números na base 10: 
 i. 467,27 
ii. 2609,03 
iii. 2000,006 
 
 3.2. Sistema Hexadecimal 
 
O sistema hexadecimal tem todas as características do sistema decimal, porém utiliza 16 
símbolospara a representação dos dígitos. Logo: 
 
 � J `0,1,2,3,4,5,6,7,8,9, �, �, �, 9, �, �a → Base 16 → 16 Símbolos. 
 
Os símbolos utilizados são os 10 do sistema decimal, acrescidos dos seguintes símbolos, 
com seus respectivos valores: 
 
Símbolo Valor 
Absoluto 
� 10 � 11 � 12 9 13 � 14 � 15 
 
 
EXERCÍCIOS: Representar na forma de polinômio os seguintes números na base 16: 
 
i. ^�32.17_XR 
ii. ^�021.32_XR 
iii. ^����. ����_XR 
 
Introdução à Programação: Conceitos e Práticas. Página 33 
 
 3.3. Sistema Binário 
 
O sistema binário também tem todas as características do sistema decimal porém 
utilizando dois dígitos: 
 
 � J `0,1a → Base 2 → 2 Símbolos. 
 
É o sistema de numeração utilizado internamente pelos computadores modernos. Em 
informática, cada dígito de um número representado neste sistema é denominado de bit 
(binary digit). Além disso, alguns conjuntos destes bits recebem denominação específica, 
a saber: 
 
♦ �F=� = conjunto de 8	�!�� (exemplo: 10001110); 
♦ ��B�1D� (?�D9) = conjunto de 1, 2 ou mais bytes, que determina a 
capacidade de processamento do computador (exemplo: �� O 286 palavra = 16 
bits, �� O 386 palavra = 32	�!��, Arquitetura Pentium = 64	�!��); 
♦ 1	"!���)�� = conjunto de 1024	�)��� (KBytes); 
♦ 1	'����)�� = conjunto de 1024	]�)��� (MBytes); 
♦ 1	�!���)�� = conjunto de 1024	<�)��� (GBytes); 
De acordo com a norma 2��	80000 O 13: Quantities and units – Part 13: Information 
science and technology, de 2008, foram estabelecidos os seguintes prefixos: 
Potência de 10 Potência de 2 
Potência Valor 
Nome Símbolo Nome Símbolo 
quilo k kibi Ki 2XY 1024 
mega M mebi Mi 2>Y 1 048 576 
giga G gibi Gi 2rY 1 073 741 824 
tera T tebi Ti 2sY 1 099 511 627 776 
peta P pebi Pi 2QY 1 125 899 906 842 624 
exa E exbi Ei 2RY 1 152 921 504 606 846 976 
zetta Z zebi Zi 2SY 1 180 591 620 717 411 303 424 
yotta Y yobi Yi 2tY 1 208 925 819 614 629 174 706 176 
Apesar de diferentes, é comum utilizar os termos das potências de 10 para se referir às 
potências de 2. 
 
Introdução à Programação: Conceitos e Práticas. Página 34 
EXERCÍCIOS: Representar na forma de polinômio os seguintes números na base 2: 
 
i. ^1101.11_> 
ii. ^101.01_> 
iii. ^100.001_> 
 
 3.4. Base Qualquer 
É possível generalizar os conceitos anteriores para números em qualquer base, bastando 
selecionar a quantidade de símbolos adequada, e seguir os princípios do sistema de 
numeração, cuja essência é a notação posicional. Assim, uma base � qualquer, pode ser 
estabelecida da seguinte forma: 
� J `yY, yX, y>, … , y{dXa → Base � → � Símbolos, onde o último símbolo 
representa o valor � O 1. 
Denotando um número 0 na base � com seus dígitos, temos: 
^0_{ J ^9|dX9|d> … 9>9X9Y. 9dX9d>9dr…9d}_{, 
sendo a parte inteira com 7 dígitos e a parte fracionária com ' dígitos, sendo que 
9~ ∈ �. Expandindo na forma de polinômio, tem-se: 
^0_{ J 9|dX 5 �|dX L ⋯ L 9X 5 �X L 9Y 5 �Y L 9dX 5 �dX L ⋯ L9d} 5 �d} 
Ou, colocando este #��!7ô'!� ����� 
� �!���'� 
� 7('���çã� sob a forma de 
somatório, tem-se: 
^0_{ J  9~ 5 �~
|dX
~‚d}
 
 
Desta forma, temos todos os elementos para formar um sistema em qualquer base: os 
dígitos 9~ a base � e as posições em !. Por exemplo, para a ���� 7, teria: 
 
 
 � ∈ `0,1,2,3,4,5,6a → Base 7 → 7 Símbolos/Dígitos. 
 
 
Uma determinada quantidade pode ser representada por diferentes números em 
qualquer base. Quanto menor a base mais dígitos são necessários para representar a 
mesma quantidade. 
 
 
 
Introdução à Programação: Conceitos e Práticas. Página 35 
 3.5. Conversão entre Bases 
 
Uma determinada quantidade pode ser representada de forma distinta dependendo da 
base utilizada. Por exemplo, a quantidade trinta pode ser representada na base 10 
como ^30_XY, enquanto que em outras bases sua representação será diferente. Mais 
especificamente, no mundo computacional é muito comum sermos requisitados a 
interpretar informações codificadas em binário (����	 J 	2), sendo, porém estarmos 
habituados ao sistema decimal. Neste contexto, será necessário frequentemente 
lançarmos mão de processos de conversão nos dois sentidos. 
 
Além disso, é fundamental que um profissional da área de computação ou engenharia 
relacionada, compreenda as transformações aplicadas a uma informação em todo o 
seu trajeto, desde a forma natural no mundo real até a completa representação no 
ambiente digital, tanto por software quanto pelo hardware. 
 
Desta forma, serão apresentados métodos para realizar as seguintes conversões de 
quantidades: 
 
i. ^? _„…†‡	ˆ‰…Šˆ‰‡‹ → ^? _XY	
ii. ^? _XY → ^? _„…†‡	ˆ‰…Šˆ‰‡‹ 	
iii. ^? _> ↔ ^? _>Ž 	
 
 3.5.1. Conversão de Qualquer Base para a Base 10 
Para converter de uma base � qualquer para a base 10, basta aplicar o 
#��!7ô'!�	�����	
�	�!���'�	
�	7('���çã� de um número na base �: ^0_{ J
∑ 9~ 5 �~|dX~‚d} , e efetuar as operações tal como estamos habituados na base 10, e o 
resultado obtido será nesta base 10. 
Exemplos: 
 
^10011_> J	 ^? _XY O número com as posições dos dígitos:  4 3 2 1 01 0 0 1 1‘> 
^10011_> J	1 5 2s L 0 5 2r L 0 5 2> L 1 5 2X L 1 5 2Y	
^10011_> J 	16 L 0 L 0 L 2 L 1	
^10011_> J	 ^19_XY 
^1110.01_> J	 ^? _XY O número com as posições dos dígitos:  3 2 1 0 	 O1O21 1 1 0 . 0 1 ‘> 
^1110.01_> J	1 5 2r L 1 5 2> L 1 5 2X L 1 5 2d>	
^1110.01_> J 	8 L 4 L 2 L 0.25	
^1110.01_> J	 ^14.25_XY 
^�37.1_XR J	 ^? _XY O número com as posições dos dígitos:  2 1 0 	 O1� 3 7 . 1 ‘XR 
^�37.1_XR J	� 5 16> L 3 5 16X L 7 5 16Y L 1 5 16dX	
 
Introdução à Programação: Conceitos e Práticas. Página 36 
^�37.1_XR = 	2560 + 48 + 7 + 0.0625	^�37.1_XR =	 ^2615.0625_XY 
 
É importante conhecer os limites estabelecidos em termos de quantidade de dígitos em 
uma determinada base. Por exemplo, sabemos que com três dígitos decimais é possível 
representar 1000 quantidades distintas, que vão do número 000 ao número 999. 
Depreende-se que a maior quantidade representável é quando todas as posições forem 
ocupadas pelo dígito de maior valor. Assim, para o sistema binário e para o tamanho de 
um �)��, a maior quantidade possível de ser representada é obtida quando todos os bits 
forem iguais a 1. A questão é: “Quanto é este valor em decimal ?”. A resposta vem da 
conversão deste binário para decimal, conforme segue: 
 <t = ^11111111_> = 1 × 2S + 1 × 2R + 1 × 2Q + 1 × 2s + 1 × 2r + 1 × 2> + 1 × 2X + 1 × 2Y 
 <t = ^11111111_> = 1 + 2 + 4 + 8 + 16 + 32 + 64 + 128 =	 ^Z’’_“” 
 
De uma forma geral, o equivalente decimal do maior número possível ^<•_XY de ser 
representado por � bits é obtido através da fórmula: 
 ^<•_XY = ^11…1111_> = 1 × 2•dX + 1 × 2•d> +⋯+ 1 × 2r + 1 × 2> + 1 × 2X + 1 × 2Y 
 ^<•_XY = 1 + 2 + 4 + 8 +⋯+ 2•d> + 2•dX 
 
Observa-se que temos o somatório de uma Progressão Geométrica de � termos: 
 � = �X^;| − 1_; − 1 
 ^<•_XY = 1^2• − 1_2 − 1 
 ^–—_“” = Z— − “ 
 
 
 Para o caso em que �	 = 	8	�!�� (1 �)��) temos: 	^<•_XY = 2• − 1 = 2t − 1 = 256 − 1 = ^255_XY = ^<t_XY. 
 
 
 
Introdução à Programação: Conceitos e Práticas. Página 37 
 3.5.2. Conversão da Base 10 para Qualquer Base 
A conversão da base 10 para uma base qualquer é feita de forma distinta para a Parte 
inteira e para a Parte fracionária: 
i. Parte inteira: 
 
• Divide-se a parte inteira pela base desejada, obtendo-se assim um quociente 
e um resto. Repita esta divisão com o quociente, e assim sucessivamente 
com os demais quocientes até obter quociente zero. Agrupe os restos, 
conforme exemplo a seguir, para obter o número convertido para a base 
desejada, sabendo que o primeiro resto é o dígito menos significativo; 
Exemplos: 
 ^47_XY J 	 ^? _> ^33_XY J	 ^? _> 
47 
 
2 
 1 
 
23 
 
2 
 
 
1 
 
11 
 
2 
 
 
1 
 
5