Algoritmo material apoio

Disciplina: Algoritmo e Programação
Professor: Esp. Fábio Marques
Breves - PA
Fevereiro/2012

1
Conteúdo
Plano de Ensino .............................................................................................................................. 1
Apresentação .................................................................................................................................. 2
Unidade 1: Introdução a algoritmos e programas............................................................................. 3
1.1 Introdução............................................................................................................................. 3
1.2 Formas de representação........................................................................................................ 3
1.2.1 Fluxograma .................................................................................................................... 3
1.2.2 Diagrama de bloco (ou diagrama de fluxo): .................................................................... 4
1.2.3 Algoritmo ....................................................................................................................... 4
1.2.4 UML: Unified Model Language (Linguagem de modelagem unificada).......................... 5
1.2.5 Português estruturado ..................................................................................................... 6
Unidade 2: Elementos básicos variáveis e constantes. ..................................................................... 7
2.1 Tipos de dados....................................................................................................................... 7
2.1.1 Dados numéricos ............................................................................................................ 7
2.1.2 Tipo caractere................................................................................................................. 8
2.1.2 Tipo lógico ..................................................................................................................... 8
2.2 Variáveis................................................................................................................................ 8
2.3 Constantes............................................................................................................................. 9
Unidade 3: Operadores e Expressões............................................................................................. 10
3.1 Operação de atribuição ........................................................................................................ 10
3.2 Operadores aritméticos........................................................................................................ 10
3.3 Expressões aritméticas......................................................................................................... 10
Unidade 4: Entrada e Saída de Dados............................................................................................ 12
Unidade 5: Comandos de Controle................................................................................................ 15
5.1 Desvio condicional simples ................................................................................................. 15
5.2 Operadores relacionais ........................................................................................................ 15
5.3 Desvio condicional composto.............................................................................................. 15
5.4 Desvios condicionais encadeados ........................................................................................ 16
5.5 Operadores lógicos.............................................................................................................. 18
Unidade 6: Estruturas de repetição ................................................................................................ 19
6.1 Repetição do tipo: Teste lógico no inicio do looping............................................................ 20
6.2 Repetição do tipo: Teste lógico no fim do looping ............................................................... 20
6.3 Repetição do tipo: variável de controle................................................................................ 21
6.4 Estruturas de controle encadeadas........................................................................................ 22
6.4.1 Encadeamento de estruturas de repetição enquanto com enquanto................................. 22
6.4.2 Encadeamento de estruturas de repetição enquanto com repita...................................... 23
6.4.3 Encadeamento de estruturas de repetição enquanto com para........................................ 23
6.4.4 Encadeamento de estruturas de repetição repita com repita ........................................... 23
6.4.5 Encadeamento de estruturas de repetição repita com enquanto...................................... 23
6.4.6 Encadeamento de estruturas de repetição repita com para ............................................. 23
6.4.7 Encadeamento de estruturas de repetição para com para................................................ 24
6.4.8 Encadeamento de estruturas de repetição para com enquanto........................................ 24
6.4.9 Encadeamento de estruturas de repetição para com repita ............................................. 24
Unidade 7: Tipos Estruturados de Dados....................................................................................... 25
7.1 Vetores unidimensionais ...................................................................................................... 25
7.2 Vetores bidimensionais........................................................................................................ 26
7.3 Vetores multidimensionais................................................................................................... 27
Unidade 8: Apresentação da linguagem de programação C............................................................ 28
8.2 Nosso primeiro programa .................................................................................................... 28
8.2 Entrada e Saída de Dados .................................................................................................... 30

8.3: Comandos de Controle ....................................................................................................... 31
8.3.1 Desvio condicional simples........................................................................................... 32
8.3.2 Desvio condicional composto ....................................................................................... 32
8.3.4 Desvios condicionais encadeados.................................................................................. 33
8.4 Estruturas de repetição......................................................................................................... 34
8.4.1 Repetição do tipo: Teste lógico no inicio do looping ..................................................... 34
8.4.2 Repetição do tipo: Teste lógico no fim do looping......................................................... 34
8.4.3 Repetição do tipo: variável de controle ......................................................................... 34
8.5 Tipos Estruturados de Dados ............................................................................................... 35
Referência Bibliográficas.............................................................................................................. 36

1
Plano de Ensino
Identificação Geral
Instituição: IFPa – Instituto Federal de Educação, Ciência e Tecnologia do Pará
Curso: Licenciatura em Computação
Disciplina: Algoritmos e Programação
Professor: Esp. Fábio Marques
Hora Aula Presencial: 64h
Hora Aula Auto-estudo: 16h
Total de Hora Aula: 80h
Ementa
Introdução a algoritmos e programas: Conceitualização das formas de representação;
Elementos básicos variáveis e constantes. Operadores e Expressões: Operação de atribuição;
Operadores e expressões relacionais e lógicas. Entrada e saída de dados por teclado e vídeo.
Comandos de Controle: Uso de estruturas de decisão em algoritmos; Uso de estruturas de repetição
em algoritmos. tipos Estruturados de Dados: Vetores unidimensionais e multidimensionais;
Desenvolvimento de algoritmos. Apresentação de uma Linguagem de Programação (linguagem C).
Componentes Básicos de um Programa na Linguagem C. Desenvolvimento e Programação na
linguagem C. Modularização. Depuração de programas.
Objetivo
Apresentar ao aluno a estrutura e a funcionalidade de uma linguagem de programação
utilizando formas de representações de problemas com construções de algoritmos e programas.
Introduzir componentes básicos de um programa utilizando uma linguagem imperativa (linguagem
C) e desenvolver a habilidade de programação utilizando de forma básica, elementos, variáveis,
operadores, laços de repetição, expressões e tipos estruturados de dados.
Bibliografia básica
MANZANO J. A. N. G.; OLIVEIRA J. F. O. Algoritmos: lógica para desenvolvimento de
programação de computadores. 14.ed. São Paulo: Érica, 2002.
KERNINGHAN, B. W.; RITCHIE, D. C A Linguagem de Programação. Rio de Janeiro: Campus,
2003.
ZIVIANI, Nívio. Projeto de Algoritmos: com implementações em Pascal e C. 4.ed. São Paulo:
Pioneira. 1999.
Bibliografia complementar:
SEBESTA, ROBERT W. Conceitos de Linguagem de Programação. Porto Alegre: Bookman. 2003.

2
Apresentação
Os algoritmos estão presentes no nosso dia a dia, em todas as nossas mais simples rotinas, as
instruções para o uso de medicamentos e uma receita de culinária são alguns exemplos de
algoritmos. E é claro, que formam uma importante etapa do desenvolvimento de sistemas, em toda
linguagem de programação, independente de paradigma ou classificação da linguagem de
programação adotada.
O presente curso mostra os principais recursos disponíveis na grande maioria das linguagens
de programação existentes, tais como variáveis, constantes, operadores, laços e estrutura de decisão.
São utilizados pseudocódigos para facilitar o entendimento dos conceitos e elaboração de exemplos,
alguns exemplos ora apresentados em pseudocódigos serão recodificados utilizando a linguagem C.

3
Unidade 1: Introdução a algoritmose programas
1.1 Introdução
Os algoritmos estão presentes no nosso dia a dia, e pode ser visto como uma sequencia bem
definida de ações a serem seguidas para se alcançar um determinado objetivo, ou para se alcançar a
resolução de um conjunto de problemas de um determinado tipo. Segundo Dijkstra (1971) um
algoritmo corresponde a uma descrição de um padrão de comportamento, expresso em termos de
um conjunto finito de ações.
Desenvolver um programa é basicamente estruturar dados e construir algoritmos. Os
algoritmos construídos pelos programadores precisam possuir uma característica vital: serem
seguidos por computadores. No entanto, computadores só são capazes de seguir programas (ou
algoritmos) escritos em linguagem de máquina, que são sequencias binárias (zeros e uns) de difícil
compreensão. Para facilitar o desenvolvimento de programas, utilizamos linguagens de
programação construídas para este fim, normalmente utilizando-se de códigos próximos a
linguagem falada.
Para alguns programadores mais experientes, criar algoritmos intermediários, antes da
codificação em uma linguagem de programação propriamente dita pode parecer perda de tempo, no
entanto, a eliminação desta etapa de planejamento pode causar erros e atraso na entrega do produto
final, pois a solução do problema não foi pensada de forma detalhada e com maior profundidade.
Com a evolução do oficio de desenvolver sistemas, e das técnicas de programação, as
formas de representação dos algoritmos e do raciocínio lógico também foram evoluindo e se
modificando, conforme será apresentado no próximo item.
1.2 Formasde representação
Muitas formas de representação dos algoritmos e do raciocínio lógico foram utilizadas no
decorrer da evolução do oficio de se desenvolver sistemas. Independente da técnica ou da forma
adotada, o objetivo era sempre obter um produto que estabelecia a sequencia de ações a serem
executadas em um programa, sem o detalhamento de instruções ou comandos específicos,
permitindo assim, uma posterior codificação em qualquer linguagem de programação. Veremos, a
seguir, algumas das formas de representação já utilizadas.
1.2.1 Fluxograma
Ferramenta gráfica desenvolvida pelos profissionais da área de análise de sistemas, que
utiliza símbolos convencionais (ISO 5807:1985) tais como desenhos geométricos básicos, com a
finalidade de descrever o fluxo de ação de um determinado trabalho lógico, manual ou mecânico. A
Figura 1 mostra um exemplo de um fluxograma.

4
1.2.2 Diagrama de bloco (ou diagrama de fluxo):
Ferramenta gráfica desenvolvida pelos
profissionais envolvidos diretamente com a
programação, utiliza-se de diversos símbolos
geométricos (ISO 5807:1985), podendo ser
elaborado em diversos níveis de detalhamento. Tem
por objetivo a descrição do método e sequencia de
processo num computador, podendo, logo após a
elaboração deste diagrama, ser realizada a
codificação do programa. Na Figura 2 podemos ver
um diagrama de bloco, perceba que para utilização
destes diagramas, faz-se necessário o conhecimento
prévio de cada um dos símbolos utilizados.
1.2.3 Algoritmo
São um conjunto de regras formais para a obtenção de um resultado ou para a solução de um
conjunto de problemas, que se utiliza de fórmulas e expressões aritméticas para alcançar seu
objetivo e é utilizado sempre que é exigido um resultado final “correto” e/ou “coerente”. Na área de
desenvolvimento de sistemas, o termo algoritmo foi, muitas vezes, relacionado a diagrama de
blocos, neste caso, um algoritmo gráfico. Podemos visualizar na Figura 3 um algoritmo para cálculo
da situação de um estudante, mediante análise das notas obtidas pelo mesmo.
Figura 1: Exemplo de fluxograma
Figura 2: Exemplo de diagrama de bloco

5
1.2.4 UML:Unified Model Language (Linguagem de modelagem unificada).
A UML é uma linguagem de modelagem não proprietária que está se tornando um padrão da
indústria, sendo criada como uma forma de padronização para as diversas técnicas de representação
de algoritmos e outros artefatos do desenvolvimento de sistemas. É composta por 16 diagramas,
formados por um conjunto de regras e símbolos, cada um com a finalidade de documentar uma faze
específica do desenvolvimento de sistemas.
Na figura X, temos o diagrama de sequencia, responsável pela representação das trocas de
mensagens e fluxo de dados entre as entidades do sistema. Neste caso, as trocas de mensagens
necessárias entre o cliente e o servidor de e-mails.
Figura 3: Algoritmo representado em diagrama de blocos

6
1.2.5 Portuguêsestruturado
É uma técnica de algoritmização que se utiliza de narrativa em idioma corrente, denominada
pseudocódigo, também conhecida por portugol. A forma original faz uso do idioma inglês,
conhecido como inglês estruturado, muito próximo da notação utilizada na linguagem de
programação PASCAL.
Tem por vantagem ser genérica, e independente da linguagem de implementação do
algoritmo. Algoritmos escritos em português estruturado podem ser facilmente utilizados para a
elaboração de código em linguagem computacional (C, PASCAL, Delphi ou Java). A seguir, vemos
um algoritmo escrito em português estruturado que calcula a área de um triângulo.
algoritmo “AreaTriangulo”
var
b, h, a: REAL
inicio
Escreva(“Entre com o valor da base: ”)
Leia (b)
Escreva(“Entre com o valor da altura: ”)
Leia (h)
a  (b * h) / 2
Escreva(“A área desse triângulo é: ”, a)
fimalgoritmo
Figura 4: Exemplo de diagrama de sequencia

7
Unidade 2: Elementosbásicosvariáveise constantes.
Para se construir algoritmos usando pseudocódigo é necessário se conheça conceitos básicos
sobre dados e tipos de dados, independente da linguagem de programação. A partir desta unidade
veremos a parte mais prática do desenvolvimento de algoritmos, culminando com a codificação de
alguns códigos em C.
Como vimos anteriormente, um algoritmo é uma sequencia bem definida de ações a serem
seguidas para se alcançar um determinado objetivo, utilizaremos computadores como a ferramenta
para executar esses algoritmos. Podemos dizer, a grosso modo, que a solução de problemas
envolvem a manipulação de dados e instruções para a manipulação.
2.1 Tiposde dados
Os dados representam as informações que serão manipuladas nos algoritmos elaborados e
submetidos a um computador. Podemos dividir os dados em três tipos básicos, de acordo com a
essência dos mesmos.
São exemplo de dados manipuladas por algoritmos computacionais:
As vendas de uma loja de departamentos;
Nomes e endereços de um cadastro de clientes;
Notas dos alunos de um curso;
Medidas de uma experiência;
Como podemos observar nos exemplos acima, os dados podem ter várias representações e
são manuseados de formas diferentes no computador. Para trabalhar com esta variedade de tipos de
dados é necessário conhecer bem o problema a ser resolvido, para que seja escolhido o tipo de dado
certo.
2.1.1 Dadosnuméricos
Os dados numéricos podem ser representados de duas maneiras distintas: inteiros ou reais, e
são aqueles passíveis das operações aritméticas.
2.1.1.1 Tiponuméricointeiro
São dados do tipo numérico, quer sejam negativos, positivos ou nulo, correspondendo aos
números inteiros da aritmética. Também são conhecidos como números de ponto fixo, embora não
apresentem pontos (ou vírgulas) em sua representação.
São exemplos de números inteiros: 1508 602 0 -10 -56

8
2.1.1.2 Tiponuméricoreal
São dados do tipo numérico, quer sejam negativos, positivos ou nulo, inclusos os números
fracionários, e são utilizados por algoritmos que necessitam de um maior domínio (valor) que o
oferecido pelos números inteiros. Os números reais sempre apresentam o ponto (vírgula) decimal,
sendo também utilizados para representar as frações.
Por limitações técnicas, a representação gráfica de frações é diferente da representação
matemática, assim a representação gráfica da fração é representada da seguinte forma: 1/2.
Numericamente, a fração equivale a 0.5, pois não há mecanismos para guardar numeradores e
numeradores, logo, apenas o valor numérico equivalente será guardado.
São exemplos de números reais: -21.04 1.44 100.8 0.0 0.5
2.1.2 Tipo caractere
São dados não numéricos (aqueles não passíveis das operações aritméticas), tais como os
caracteres alfabéticos, dígitos numéricos e caracteres especiais. Este tipo também é conhecido como
alfanumérico, string, literal ou cadeia.
Uma sequencia de caracteres deve sempre ser delimitada por um apóstrofo ( ‘’ ). Para efeito
de programação deve-se notar a sintaxe da linguagem a ser utilizada, pois esses delimitadores
variam de linguagem para linguagem de programação.
São exemplos de cadeias de caracteres: ‘Pará’ ‘3233-3331’ ‘ ’ ‘7’ ‘BELÉM’
2.1.2 Tipo lógico
Caracterizam-se como tipo lógico os dados com valor VERDADEIRO ou FALSO, este tipo de dado
pode assumir apenas um valor a cada momento. É também conhecido como tipo boleano, devido
aos estudos sobre lógica matemática do filósofo inglês George Boole. A representação deste tipo de
dado, quando estamos usando uma linguagem de programação, varia de linguagem para linguagem.
2.2 Variáveis
O termo variável dá-se ao fato de que, em problemas computacionalmente trabalhados, o
volume de informações serem extremamente grande e diversificado, ou seja, variáveis.
Para que possamos armazenar algum dado na memória do computador, possibilitando assim
que o mesmo seja utilizado e manipulado posteriormente, faz-se necessária a identificação do tipo
do dado, ou seja, o dado precisa ser classificado segundo sua essência.
O conceito de variáveis é muito familiar na matemática, e em um programa de computador
ela é conhecida como uma entidade que possui um valor. Como na matemática, em informática, as
variáveis têm nome e recebem valores e para identificarmos identificá-la melhor.
Imagine a memória de um computador como um grande arquivo com várias gavetas,

9
conforme é visualizado na Figura 5, sendo que em cada gaveta é possível guardar apenas um único
valor por vez, e essas gavetas, como em um arquivo, deverão estar identificadas com uma
“etiqueta” contendo um nome. Este nome, será utilizado posteriormente para utilização da variável,
sendo assim, deve ser único e seguir as seguintes regras:
 Nomes de variáveis podem possuir um ou mais caracteres, sendo que o primeiro caractere
deve ser sempre uma letra;
 O nome de uma variável não poderá possuir espaços em branco, caso seja necessário deve-
se usar um caractere de ligação ( _ ) para representar um espaço;
 Não poderá ser usado como nome de variável uma palavra reservada para uso do
compilador;
 Alguns caracteres especiais não poderão ser utilizados.
São exemplos de nomes válidos de variáveis: Totalizacao, LaTA, lado3, B52, Rua_das_Flores,
CodProd, CPF
São contra exemplos de nomes válidos de variáveis: Totalização, 3Quarteiroes, Rua das Flores,
X+Y
Além de seguirmos estas regras devemos prestar atenção, ainda, para o tipo de dado que
uma variável deve receber. Este tipo dever ser previamente identificado para podermos
armazenar o valor correto.
2.3 Constantes
Por definição, constante é tudo aquilo que não se altera, que é fixo, que é estável, em
programação existem diversos momentos onde este conceito pode ser aplicado, como por exemplo:
no cálculo da área de uma circunferência. 2
rA   . Onde A é a variável responsável por
armazenar a área, r é a variável que guardará o comprimento do raio da circunferência, que deve ser
fornecido pelo usuário, e π é a constante matemática (aproximadamente 3.1415).
A definição do nome da constante segue exatamente as mesmas regras que apresentamos
para definição do nome de uma variável.
Figura 5: Abstração gráfica da memória de um computador
em nível de variável de programação.

10
Unidade 3: Operadorese Expressões
Variáveis e constantes, desde que definidas como tipos numéricos, poderão ser utilizadas
para a elaboração de cálculos matemáticos, através da elaboração de expressões aritméticas,
fazendo uso dos operadores aritméticos.
O resultado da avaliação de uma expressão é o valor que será atribuído à variável indicada.
Vale lembrarmos que o tipo da variável indicada também deve ser cuidadosamente analisado.
3.1 Operação de atribuição
Esta operação especifica que um determinado valor está sendo atribuído (guardado) em uma
determinada variável, e é representada pelo símbolo de seta (  ).
Logo A  3 (leia-se: variável “A” recebe três), indica que a variável A está recebendo para
armazenamento o valor numérico inteiro três. A operação de atribuição de valores é destrutiva, isto
é, ao atribuir-se um novo valor a variável, o valor anterior é perdido.
3.2 Operadoresaritméticos
Os operadores aritméticos são classificados como binários ou unários. São classificados
como binários quando envolvem dois operandos, como é o caso da multiplicação, exponenciação,
divisão, adição e subtração, e são classificados como unários quando envolvem apenas um
operando, como é o caso da inversão de sinais (positivo e negativo).
A seguir, veremos a tabela de operadores aritméticos, bem como a ordem de prioridade dos
mesmos, além do tipo e retorno de cada um deles:
OPERADOR OPERAÇÃO TIPO PRIORIDADE RESULTADO
+ Manutenção de sinal Unário 1 Positivo
- Inversão de sinal Unário 1 Negativo
 Exponenciação Binário 2 Inteiro ou real
* Multiplicação Binário 3 Inteiro ou real
/ Divisão Binário 3 Real
div Resto da divisão Binário 4 Inteiro
+ Adição Binário 4 Inteiro ou real
- Subtração Binário 4 Inteiro ou real
3.3 Expressõesaritméticas
Dado ao fato que grande parte do trabalho computacional utilizar-se de cálculos
matemáticos, o estudo e a utilização de expressões aritméticas (e fórmulas matemáticas) serão
bastante comuns no desenvolvimento de programas. As expressões são basicamente o
relacionamento entre variáveis e constantes através da utilização dos operadores aritméticos.
Iremos considerar novamente, a fórmula para o cálculo da área de uma circunferência.
2
rA   , onde A representa a área da circunferência, r representa o comprimento do raio da

11
circunferência e onde π representa a constante matemática (aproximadamente 3.1415). A equação
matemática representada na forma computacional ficaria da seguinte forma: A 3.1415 * r  2
Para a representação de expressões aritméticas em programas precisaremos nos ater a
algumas diferenças existentes entre as formas matemática e computacional.
A primeira característica é a inexistência de colchetes ou chaves na forma computacional,
devendo ser substituídos por parênteses, que serão resolvidos dos mais internos para os mais
externos da expressão. A expressão matemática )]}230(:55[43{ x será representada
computacionalmente como x  (43 * (55 / (30 + 2))).
Outra mudança percebida é a substituição do sinal de igualdade (=) pelo sinal de atribuição
(), que indica que o valor resultante da expressão aritmética será atribuído a variável em questão
(x).

12
Unidade 4: Entrada e Saída de Dados
Um programa executável em um computador usualmente possui três itens básicos de
trabalho: a entrada de dados, o seu processamento e a saída do resultado, logo, trabalharemos todas
as soluções computacionais através da elaboração de programas com estes três itens. Uma
consequencia disto é que se os dados forem entrados de forma errada, ou se estiverem sendo
processados de forma equivocada, a resposta será um resultado errado.
Agora já sabemos que qualquer erro antes atribuído a um computador, na realidade fora
causado por um erro humano, quer seja voluntario ou involuntário. Quando recebemos uma
cobrança indevida, ou detectamos um erro no nosso saldo bancário, podemos afirmar que se trata de
um erro humano.
A Figura 6 ilustra os três pontos básicos do trabalho de resolver problemas de forma
computacional e suas relações.
Em um programa real, a entrada e saída de dados poderão ocorrer de diferentes formas. Uma
entrada de dados pode ser realizada, por exemplo, de tais formas: via teclado, via modem, através
de um leitor ótico, dentre outras. Enquanto as saídas de dados podem ser realizadas, por exemplo,
das seguintes formas: em vídeo, em impressora, em um arquivo em disco e etc.
Devido à grande variedade de dispositivos de entrada e saída existentes, e devido à
complexidade de manipulação destes nas diversas linguagens de programação, iremos nos ater em
utilizar os comandos Leia, Escreva e Escreval, para representar a entrada e a saída de dados
respectivamente, abstraindo a interface dos dispositivos existentes. Por motivos didáticos,
adotaremos que toda entrada será realizada através do teclado, e toda saída realizada através do
monitor. A diferença entre os comandos Escreva e Escreval está apenas no fato do segundo pular
uma linha após escrever a lista de dados.
Em Português estruturado:
Leia (<lista de dados>)
Escreva (<lista de dados>)
Escreval (<lista de dados>)
Como exemplo de um problema resolvível computacionalmente por um programa, podemos
ter: “Deverá ser criado um programa que efetue a leitura de dois valores numéricos. Calcule a
média aritmética dos dois valores e apresente o resultado obtido.”
Figura 6: Três pontos básicos de um programa

13
Para a resolução de problemas como estes, precisaremos compreender bem o mesmo, e
buscarmos uma solução computacional para o mesmo, delimitando os passos a serem seguidos pelo
computador para resolução de tal problema de forma genérica.
Para tanto, deveremos observar que será realizada a leitura de dois valores que não
conhecemos (e que realmente não precisamos conhecer), e para isto, utilizaremos duas variáveis
para trabalhar com as incógnitas do problema, v1 e v2. E, para trabalhar com o resultado da média,
utilizaremos uma terceira variável, chamada de M.
O algoritmo para resolução de tal problema seria muito parecido com o seguinte:
1. Ler dois valores numéricos (variáveis v1 e v2);
2. Efetuar o cálculo da média aritmética dos valores obtidos e guardar o resultado em M.
2
21 vv
M


3. Apresentar o valor da variável M após a realização do cálculo.
O algoritmo acima representa apenas uma das soluções corretas para o problema acima,
podendo ser feito de diversas formas, haja vista que se trata da interpretação do referido
problema.
Tendo estabelecido os passos para resolução do problema de forma genérica, podemos
iniciar a resolução do mesmo através da codificação, para tanto, utilizaremos a técnica da
utilização do português estruturado.
Todo algoritmo escrito em português estruturado deverá seguir uma estrutura rígida,
conforme apresentada a seguir:
Primeiro devemos definir o nome do algoritmo, que deve ser algo sugestivo, para que
possamos nos lembrar do se trata o algoritmo apenas pela análise do nome, sem ter que analisar
o algoritmo na integra.
algoritmo “MediaAritmetica”
Após a definição do nome do algoritmo, temos uma área destinada à declaração (identificação)
de todas as variáveis que serão necessárias para a execução do algoritmo e obtenção do respectivo
resultado. Esta área inicia-se com a palavra var, conforme abaixo:
var
v1, v2, M: REAL
Percebe-se que as variáveis foram agrupadas, pois todas pertencem ao mesmo tipo de dado, o
tipo Real. A sintaxe para declaração de variáveis é a seguinte: <lista de variáveis>: <tipo de dado>
A partir de agora, podemos utilizar as variáveis, dando prosseguimento à resolução do
problema. Para delimitar a área de execução das instruções que irão realizar o passo a passo
utilizaremos o par inicio/fim. Note que o bloco de instruções de programa (bloco compreendido
pelo par inicio/fim) é apresentado um pouco deslocado para a direita, isto se chama endentação, e
facilita a leitura de um bloco do programa, por tanto, trata-se de uma boa prática endentar seus
códigos de blocos. No entanto, a endentação não influencia na execução das instruções.

14
Para a realização da leitura do valor de uma variável utilizaremos o comando Leia indicando
como argumento para o mesmo a variável desejada. Para fins informativos, e para instrução do
operador do sistema, serão exibidas mensagens indicando o que o operador deve fazer, a exibição
de mensagens será realizada pelo comando Escreva recebendo como argumento a mensagem a ser
exibida, conforme a seguir:
Escreva(“Entre com o primeiro valor: ”)
Leia(v1)
A seguir, realizaremos a conversão da equação
2
21 vv
M

 do modelo matemático para o
computacional, e a atribuição do resultado a variável M:
M  (v1 + v2) / 2
Só nos resta agora, exibir o resultado da expressão aritmética atribuído a variável M
conforme a seguir:
Escreva(“A média dos valores é: ”, M)
Perceba que utilizamos o comando Escreva com dois argumentos, uma mensagem e a
variável M, desta forma serão exibidos a mensagem e o valor de M respectivamente.
O algoritmo completo pode ser visualizado a seguir:
algoritmo “MediaAritmetica”
var
v1, v2, M: REAL
inicio
Escreva(“Entre com o primeiro valor: ”)
Leia(v1)
Escreva(“Entre com o segundo valor: ”)
Leia(v2)
M  (v1 + v2) / 2
Escreva(“A média aritmética dos valores é: ”, M)
fimalgoritmo
Em linhas gerais, basta que a estratégia acima adotada seja seguida sempre que se necessita
escrever um algoritmo para a resolução de um problema genérico, por tanto, vamos rever a
estratégia para uma melhor fixação:
1. Compreender bem o problema;
2. Buscarmos uma solução computacional para o mesmo, delimitando os passos a serem
seguidos.
3. Elaborar a resolução do mesmo através da codificação em português estruturado
Adicionalmente, poderíamos realizar testes sobre o nosso algoritmo: uma forma seria a reescrita
do mesmo uma linguagem de programação, para que o compilador possa convertê-lo em linguagem
de máquina, ou ainda a utilização de uma ferramenta que interprete o nosso português estruturado
(pseudocódigo) e o execute.
Uma ferramenta que realiza a interpretação de nossos pseudocódigos escritos em português
estruturado é o Visualg (Visualizador de Algoritmos) como se nossos algoritmos fossem programas
de computador (APOIO INFORMÁTICA, 2012).

15
Unidade 5: Comandosde Controle
Com as informações apresentadas até agora, já conseguimos solucionar alguns problemas,
como por exemplo: calcula a média das notas de um aluno. No entanto, ainda temos algumas
limitações, como por exemplo, tratar a média deste aluno para realizarmos um processamento mais
adequado, como a exibição de uma mensagem informando se o aluno foi ou não aprovado. Observe
que a média do aluno terá de ser verificada de acordo com um parâmetro e então terá de ser tomada
uma decisão: qual mensagem imprimir.
5.1 Desvio condicional simples
Para a resolução do problema da mensagem de aprovação do aluno, será necessário
conhecermos uma nova instrução: se...então...fimse. Esta instrução desvia a execução do algoritmo
para uma determinada área de acordo com a condição, caso a condição seja VERDADEIRA, serão
executados todos os comandos entre o se...então, e caso a condição seja FALSA serão executados
todos os comandos após o fimse.
se <condição> entao
<sequencia de comandos>
fimse
5.2 Operadoresrelacionais
Para a utilização da instrução se...entao...fimse precisaremos conhecer os operadores relacionais
para que possamos verificar o estado de uma variável enquanto VERDADEIRO ou FALSO. Esta
verificação é efetuada com a utilização dos operadores relacionais, conforme tabela a seguir:
SÍMBOLO SIGNIFICADO
= Igual a
<> Diferente de
> Maior que
< Menor que
>= Maior ou igual que
<= Menor ou igual que
5.3 Desvio condicional composto
Para a realização de desvios condicionais compostos, faremos uso da instrução
se...então...senao...fimse, onde sendo a condição VERDADEIRA, serão executadas todas as
instruções que estiverem localizadas entre o se...entao e a instrução senao, enquanto que se a
condição for FALSA, serão executadas todas as instruções que estiverem localizadas entre o senao
e a instrução fimse.
<sequencia de comandos para condição VERDADEIRA>
senao
<sequencia de comandos para condição FALSA>
fimse

16
Com o conhecimento prévio das estruturas de decisão simples e composta, podemos retomar
a solução do problema da média: “Deverá ser criado um programa que efetue a leitura das duas
notas obtidas por um aluno. Calcule a média aritmética dos dois valores e apresente a mensagem
APROVADO caso a média seja maior ou igual a 7 ou REPROVADO, caso contrário.”
1. Ler dois valores numéricos (variáveis n1 e n2);
2
21 nn
M


3. Se o valor da variável M for maior que 7 apresentar a mensagem APROVADO ou
REPROVADO caso contrário.
Algoritmo em português estruturado:
algoritmo “SituacaoAluno”
var
n1, n2, M: REAL
inicio
Escreva(“Entre com a primeira nota: ”)
Leia(n1)
Escreva(“Entre com a segunda nota: ”)
Leia(n2)
M  (n1 + n2) / 2
Se (M >= 7) entao
Escreva(“APROVADO”)
Senao
Escreva(“REPROVADO”)
Fimse
fimalgoritmo
5.4 Desvioscondicionaisencadeados
Em alguns problemas, será necessário combinar condições sucessivas para garantir que uma
ação somente seja executada se o conjunto de condições seja satisfeito. Para o conjunto de
instruções, ainda pode ser definido um novo conjunto de condições para serem testadas. Para este
tipo de estrutura de desvios condicionais, com diversos níveis de condição chamamos de
aninhamento ou encadeamento.
< comandos para condição1 VERDADEIRA>
senao
se <condição2> entao
<comandos para condição1 e condição2 VERDADEIRAS>
senao
<comandos para condição1 VERDADEIRA e condição2 FALSA>
fimse
fimse
O encadeamento foi realizado apenas na condição1 sendo FALSA, no entanto, o mesmo
poderá ser aplicado caso a condição1 fosse VERDADEIRA, ou até mesmo nos dois casos.

17
Com o conhecimento de desvios condicionais encadeados, podemos resolver o seguinte
problema: “Deverá ser criado um programa que efetue a leitura das duas notas obtidas por um
aluno. Calcule a média aritmética dos dois valores e apresente a mensagem APROVADO caso a
média seja maior ou igual a 7 ou RECUPERACAO caso a média seja maior que 5 ou ainda
REPROVADO, caso contrário.”
1. Ler dois valores numéricos (variáveis n1 e n2);
2
21 nn
M


3. Se o valor da variável M for maior que 7 apresentar a mensagem APROVADO ou
RECUPERACAO caso a média seja maior que 5 ou REPROVADO caso contrário.
algoritmo “SituacaoAluno2”
var
n1, n2, M: REAL
inicio
Escreva(“Entre com a primeira nota: ”)
Leia(n1)
Escreva(“Entre com a segunda nota: ”)
Leia(n2)
M  (n1 + n2) / 2
Se (M >= 7) entao
Escreva(“APROVADO”)
Senao
Se (M >= 5) entao
Escreva(“RECUPERAÇÃO”)
Senao
Escreva(“REPROVADO”)
Fimse
Fimse
fimalgoritmo

18
5.5 Operadoreslógicos
Os operadores lógicos, assim como os operadores aritméticos, realizam a operação entre
operandos, neste caso, operandos lógicos. Também se classificam em unários e binários, de forma
análoga aos operadores aritméticos.
A seguir, veremos a tabela de operadores lógicos, bastante reduzida, se compararmos a
tabela de operadores aritméticos.
OPERADOR OPERAÇÃO TIPO RESULTADO
AND E Binário VERDADE se ambas as variáveis de
entrada forem VERDADE.
OR OU Binário VERDADE se pelo menos uma das
variáveis de entrada forem
VERDADE.
XOR OU
EXCLUSIVO
Binário VERDADE se e somente se
exatamente uma das variáveis de
entrada for VERDADE.
NOT NÃO Unário Negação da variável atual.
A seguir, veremos as tabelas-verdade (resultados) dos operadores acima relacionados.
Tabela verdade para o operador lógico AND.
OPERANDO 1 OPERANDO 2 OP1 AND OP2
VERDADEIRO VERDADEIRO VERDADEIRO
VERDADEIRO FALSO FALSO
FALSO VERDADEIRO FALSO
FALSO FALSO FALSO
Tabela verdade para o operador lógico OR.
OPERANDO 1 OPERANDO 2 OP1 OR OP2
VERDADEIRO VERDADEIRO VERDADEIRO
VERDADEIRO FALSO VERDADEIRO
FALSO VERDADEIRO VERDADEIRO
FALSO FALSO FALSO
Tabela verdade para o operador lógico XOR.
OPERANDO 1 OPERANDO 2 OP1 XOR OP2
VERDADEIRO VERDADEIRO FALSO
VERDADEIRO FALSO VERDADEIRO
FALSO VERDADEIRO VERDADEIRO
FALSO FALSO FALSO
Tabela verdade para o operador lógico NOT.
OPERANDO NOT OP
VERDADEIRO FALSO
FALSO VERDADEIRO

19
Unidade 6: Estruturasde repetição
Em alguns problemas faz-se necessária a repetição de um determinado trecho de instruções
por um determinado número de vezes. Nesses casos, realiza-se um looping que efetue a repetição
do determinado trecho pelo determinado número de vezes. Os loopings também são conhecidos
como laços de repetição ou malhas de repetição.
Com os conhecimentos adquiridos até o momento, teríamos de repetir o trecho de código
quantas vezes fossem necessárias, por exemplo, no seguinte problema: “Deverá ser criado um
programa que efetue a leitura de três valores numéricos. Calcule o triplo de cada um deles e
apresente o valor obtido respectivamente.”
1. Ler um valor numérico (variável valor);
2. Efetuar o cálculo do triplo do valor e guardar o resultado em triplo. 3 valortriplo
3. Apresentar o valor da variável triplo.
algoritmo “ValorTripo1”
var
valor, triplo: REAL
inicio
// primeira vez
Escreva(“Entre com o valor: ”)
Leia(valor)
triplo  valor * 3
Escreval(“O triplo do valor é: ”, triplo)
// segunda vez
Leia(valor)
// terceira vez
Leia(valor)
fimalgoritmo
Para a resolução deste tipo de problema, existem instruções mais apropriadas que
determinam um número variado de repetições, gerando códigos mais elegantes e menores.

20
6.1 Repetição do tipo: Teste lógico no inicio do looping
Tem como principal característica a realização de um teste lógico no início do looping,
verificando se o trecho de instruções subordinadas ao looping poderá ou não ser executada. Esta
estrutura de repetição é a enquanto...faça...fimenquanto.
enquanto <condição> faça
<sequencia de instruções>
fimenquanto
Reescrita do algoritmo ValorTripo em português estruturado com o uso do
enquanto...faça...fimenquanto:
var
i: INTEIRO
valor, triplo: REAL
inicio
i  1
Enquanto i <= 3 faca
Leia(valor)
Escreval(“O triplo do valor é: ”, valor)
i  i + 1
Fimenquanto
fimalgoritmo
Para a resolução deste problema, com o uso da estrutura de repetição
enquanto...faça...fimenquanto, precisamos criar uma variável para controlar as iterações
(repetições), esta variável foi chamada de i e é do tipo INTEIRO. Esta variável recebe o valor 1
antes do início do looping, e é incrementada ao final de cada looping, para que possa ser testada no
início da próxima iteração.
6.2 Repetição do tipo: Teste lógico no fim do looping
Esta estrutura assemelha-se a anterior, diferindo apenas no fato de que o teste será realizado
apenas no final do looping, sendo assim, podemos dizer que esta estrutura de repetição tem o
funcionamento no sentido contrário da anterior. Por consequencia disso, tem-se que o bloco de
instruções será executado sempre, pelo menos uma vez. A estrutura de repetição é a repita...ate.
repita
ate <condição>

21
Reescrita do algoritmo ValorTripo em português estruturado com o uso do repita...ate:
var
i: INTEIRO
valor, triplo: REAL
inicio
i  1
Repita
Leia(valor)
i  i + 1
Ate i > 3
fimalgoritmo
Para esta solução, utilizando a estrutura de repetições repita...ate também utilizamos uma
variável de controle chamada i, no entanto, perceba que a condição demonstrou-se contrária a
condição da estrutura enquanto...faça...fimenquanto.
6.3 Repetição do tipo: variável de controle
Nas duas estruturas de repetição anteriores, fizemos o uso de uma variável para controlar o
número de iterações, no entanto, existem estruturas de repetição que realizam o controle dessa
variável de forma controlada pela própria estrutura de repetição. Com a estrutura para...faça
poderemos executar loopings com um número finito de iterações, ou seja, nesses casos, não é
obrigatório conhecer antecipadamente o número de interações que devem ser executadas.
para <variável> de <inicio> ate <fim> [passo <incremento>] faca
fimpara
Reescrita do algoritmo ValorTripo em português estruturado com o uso do para...faça:
var
i: INTEIRO
valor, triplo: REAL
inicio
Para i de 1 ate 3 faca
Leia(valor)
i  i + 1
Fimpara
Fimalgoritmo

22
6.4 Estruturasde controle encadeadas
Dependendo do problema a ser resolvido, também é possível o aninhamento, ou
encadeamento, de estruturas de controle, assim como nas estruturas de decisão.
6.4.1 Encadeamento de estruturasde repetição enquanto com enquanto
Neste caso particular, utilizaremos duas instruções enquanto encadeadas, onde a sequencia
de instruções contidas dentro do enquanto mais interno será executada enquanto a condição1 e
condição2 forem verdadeiras. Perceba que o laço mais interno é executado a cada iteração do laço
mais externo.
enquanto <condição1> faca
fimenquanto
fimenquanto
Vamos analisar o algoritmo em português estruturado abaixo.
algoritmo “EnquantosEncadeados”
var
i, j: INTEIRO
inicio
i  1
j  1
Enquanto i < 3 faca
Enquanto j < 5 faca
Escreval(“i vale ”, i, “ e j vale ”, j)
j  j + 1
Fimenquanto
i  i + 1
Fimenquanto
Fimalgoritmo
Agora, vamos analisar a saída do console:
i vale 1 e j vale 1
i vale 1 e j vale 2
i vale 1 e j vale 3
i vale 1 e j vale 4
i vale 2 e j vale 1
i vale 2 e j vale 2
i vale 2 e j vale 3
i vale 2 e j vale 4
*** Fim da execução.
Perceba que houve duas iterações de j (laço mais interno), uma para cada iteração de i (laço
mais externo.

23
6.4.2 Encadeamento de estruturasde repetição enquanto com repita
Neste caso particular, utilizaremos uma instrução enquanto e uma instrução repita.
repita
ate <condição2>
fimenquanto
6.4.3 Encadeamento de estruturasde repetição enquanto com para
Neste caso particular, utilizaremos uma instrução enquanto e uma instrução para.
fimpara
fimenquanto
6.4.4 Encadeamento de estruturasde repetição repita com repita
Neste caso particular, utilizaremos duas instruções repita encadeadas.
repita
repita
ate <condição2>
ate <condição1>
6.4.5 Encadeamento de estruturasde repetição repita com enquanto
Neste caso particular, utilizaremos uma instrução repita e uma instrução enquanto.
repita
fimenquanto
ate <condição1>
6.4.6 Encadeamento de estruturasde repetição repita com para
Neste caso particular, utilizaremos uma instrução repita e uma instrução para.
repita
fimpara
ate <condição1>

24
6.4.7 Encadeamento de estruturasde repetição para com para
Neste caso particular, utilizaremos duas instruções para encadeadas.
fimpara
fimpara
6.4.8 Encadeamento de estruturasde repetição para com enquanto
Neste caso particular, utilizaremos uma instrução para e uma instrução enquanto.
enquanto <condição> faca
fimenquanto
fimpara
6.4.9 Encadeamento de estruturasde repetição para com repita
Neste caso particular, utilizaremos uma instrução para e uma instrução repita.
repita
ate <condição>
fimpara

25
Unidade 7: TiposEstruturadosde Dados
Até o momento, realizamos o estudo apenas de variáveis do tipo simples, ou seja, aquelas
que armazenam apenas um valor por vez. A partir de agora, estaremos estudando uma técnica que
nos permitirá manipular um agrupamento de dados homogêneos dentro de uma única variável.
Classifica-se como uma estrutura de dados homogêneos, pois os dados armazenados sempre
obedecerão ao mesmo tipo de dado definido no momento da declaração da estrutura.
Na literatura encontramos diversas nomenclaturas para este tipo estruturado de dados, tais
como: variáveis indexadas, variáveis compostas, variáveis subscritas, arranjos, arrays (do inglês),
vetores, matrizes e outros. No nosso estudo defini-las-emos como vetores. Vale lembrar que as
regras para nomenclatura de tipos estruturados de dados seguem as mesmas regras das variáveis do
tipo simples, vistas anteriormente.
7.1 Vetoresunidimensionais
Caracteriza-se pela definição de uma única variável dimensionada por uma constante inteira
positiva que define o tamanho da mesma.
Para entendermos melhor o uso deste tipo de estrutura, vamos imaginar a seguinte situação:
suponha que exista uma relação de alunos com o nome de cada estudante e a nota da primeira prova
da disciplina Algoritmos e Programação. Deve-se imprimir o nome de cada estudante cuja nota é
maior do que a nota média da classe.
Utilizando variáveis simples, deveríamos criar uma variável para armazenar o nome de cada
estudante (isto é: nome1, nome2, nome3, ..., nomeN: CARACTERE), e uma variável para cada nota
de cada aluno (isto é: nota1, nota2, nota3, ..., notaN: REAL). Note que para a existência de um
número consideravelmente grande de alunos haverá um número extraordinariamente grande de
variáveis.
Uma solução mais adequada seria utilizarmos um conjunto para armazenar os nomes e um
conjunto para armazenar as notas dos estudantes, neste caso, tanto a variável de nomes quanto de
notas, seriam vetores unidimensionais. Caso a relação possua 20 alunos, as variáveis nomes e notas
seriam um conjunto com 20 elementos cada.
Sendo assim, a variável nome[1] indica o nome do primeiro aluno, sendo chamada de
variável indexada. O índice da variável poderá ser substituído por uma variável, sendo utilizado o
valor da mesma para descobrir-se a posição no vetor.
Utilizando os conhecimentos a respeito de vetores, podemos agora escrever o algoritmo para
a solução do problema com cinco alunos
1. Ler o nome e a primeira nota de cada um dos alunos;
2. Efetuar o cálculo da média das notas lidas, guardando o resultado em M.
5

notas
M
3. Verificar quais alunos ficaram acima da média e imprimir seus nomes.

26
algoritmo “VetorUnidimensional”
var
nomes: vetor [1..5] de caractere
notas: vetor [1..5] de real
i: INTEIRO
media: REAL
inicio
media  0
// Lendo o nome e notas; somando as notas
Escreva(“Entre com o nome do ”, i, “º aluno: ”)
Leia(nomes[i])
Escreva(“Entre com a nota do ”, i, “º aluno: ”)
Leia(notas[i])
media  media + notas[i]
Fimpara
// Calculando a média
media  media / 5
// Imprimindo os nomes dos alunos acima da média
Escreval (“*** Lista de alunos acima da média”)
Se notas[i] > media entao
Escreval(nomes[i])
Fimse
Fimpara
Fimalgoritmo
7.2 Vetoresbidimensionais
Anteriormente, vimos que os vetores unidimensionais possuíam apenas uma dimensão, no
entanto, a partir de agora, conheceremos uma nova opção, que será a de utilizarmos vetores
bidimensionais. Devemos lembrar que trata-se de um tipo homogêneo de dados, logo, todos os
elementos devem obedecer o tipo declarado.
Os vetores bidimensionais são usados para a representação de tipos estruturados de dados na
forma de tabelas. O vetor bidimensional também é uma variável do tipo indexada, no entanto, esta
possui dois índices: um para especificar as linhas, o primeiro; outro para especificar a coluna, o
segundo.
A seguir, vemos a representação gráfica de uma tabela de vendas de uma loja de
eletrodomésticos, tal estrutura poderá ser armazenada utilizando-se um vetor bidimensional. A
célula em destaque, que representa as vendas da quarta semana do “Eletrodoméstico 2” será
representada pelo índice [4, 2].

27
Semana Eletrodoméstico 1 Eletrodoméstico 2 Eletrodoméstico 3 Eletrodoméstico 4
1 6 3 9 5
2 5 10 3 2
3 7 8 8 5
4 8 10 12 7
5 4 7 3 3
6 7 15 5 4
7.3 Vetoresmultidimensionais
Como visto, podemos ter vetores com uma única dimensão, os monodimensionais, com duas
dimensões, os bidimensionais, e agora, veremos que os vetores podem apresentar mais de duas
dimensões, sendo classificados como vetores multidimensionais.
Suponha que o Museu de Carros Antigos está conduzindo um levantamento dos carros
antigos do Estado de São Paulo. Cada carro possui um registro com as seguintes informações:
fabricante (um código inteiro de zero a trinta), o ano do carro (de 1900 a 1950) e as condições do
carro (1 - ruim, 2 - regular, 3 - boa, 4 - excelente). Para permitir a execução de várias análises nos
dados, estes são armazenados num conjunto tridimensional, como o mostrado abaixo:
Logo, para o carro em destaque seria indexado pelo código do fabricante [26], pelo ano
[1904] e pelo estado de conservação [2] e teria o código 6. Logo, se o vetor chamar-se carros,
teríamos um item como: carros[26, 1904, 2] = 6.
Condição
Fabricante
Ano
1900 1950
30
0
4
2
26
1904
6

28
Unidade 8: Apresentação da linguagem de programação C
Estaremos apresentando, neste capítulo, aspectos básicos de uma poderosa linguagem de
programação, sendo bastante genérica para ser utilizada para a criação de diversos programas, tais
como: processadores de texto, sistemas operacionais, programas para solução de diversos
problemas da Engenharia, Física e outras ciências. Estaremos apresentando uma estrutura particular
do C, padronizada pela ANSI, chamada de ANSI C.
Esta unidade visa apresentar apenas os aspectos mais elementares da linguagem, que permita
ao aluno desenvolver os algoritmos acima expostos, bem como os exercícios disponibilizados, um
curso mais completo da linguagem C, bastante consolidado, que vêm sendo disponibilizado desde
1996, pode ser acessado gratuitamente a partir da página da UFSC (CPDEE/UFMG, 2012).
A linguagem de programação C nasceu ainda na década de 70, sendo implementada por
Dennis Ritchie, derivada de uma outra linguagem chamada B, criada por Ken Thompson.
Originalmente, o C foi implementada em DEC PDP-11 rodando o sistema operacional UNIX.
Uma das características primeiramente percebidas pelos iniciantes da programação, é que o
C é case-sensitive, e isso significa dizer que as letras maiúsculas são diferentes das letras
minúsculas, isso é: “Media” é diferente de “media”, que é diferente de “mEdia”, logo, o nome de
variáveis e de instruções tem de ser grafados exatamente como o exposto.
Por tratar-se de uma verdadeira linguagem de programação, nossos códigos escritos na
linguagem C (muito próximos do inglês) têm de ser traduzidos para a linguagem compreendida pelo
computador, ou seja, linguagem binária. A tradução do nosso arquivo em formato texto para um
arquivo binário é realizada pelo compilador. Existem diversos compiladores C disponíveis
gratuitamente na internet, aconselhamos o compilador Dev-C++ (BLOODSHED, 2012), que possui
um ambiente de desenvolvimento para o ambiente Windows, além de estar com este ambiente quase
todo traduzido para o Português Brasileiro.
8.2 Nosso primeiro programa
Estaremos agora, elaborando o nosso primeiro programa utilizando a linguagem C, trata-se
do mais famoso primeiro programa desenvolvido pelos aprendizes de uma linguagem de
programação: Hello word! (Olá mundo!). Logo o problema seria descrito da seguinte forma:
“Deverá ser criado um programa que apresente a mensagem: Olá Mundo !”
O algoritmo para resolução de tal problema seria muito parecido com o seguinte:
1. Apresentar a mensagem “Olá mundo!”.
Em português estruturado teríamos o seguinte código:
algoritmo “OlaMundo”
inicio
Escreva(“Olá mundo!”)
Fimalgoritmo

29
A tradução para a linguagem C é apresentada abaixo:
#include <iostream>
int main() {
printf(“Olá mundo!n”);
system(“PAUSE”);
}
Observando o código, percebemos o primeiro comando #include < iostream>, este comando,
informa ao compilador deve incluir o arquivo-cabeçalho iostream. Este arquivo é responsável
declarações de funções úteis para entrada e saída de dados, daí o seu nome: Standard Input/Output
(entrada e saída padrão, do inglês). Esse comando, de inclusão do arquivo-cabeçalho stdio.h será
utilizado sempre que formos utilizar algum comando de entrada ou saída (Escreva / Leia do
português estruturado).
Outra característica da linguagem é a obrigatoriedade da criação de uma função chamada
main, pois é ela quem será chamada quando o programa for executado, e possui por padrão a
seguinte assinatura.
int main() {
}
Entre as chaves deverão ser escritos todos os códigos na linguagem C, seria o equivalente ao
par início/fimalgoritimo do português estruturado.
A apresentação do texto na tela deve-se a instrução printf que recebe como parâmetro o
conteúdo a ser exibido, neste caso “Olá Mundo!”. Já o comando system(“PAUSE”) faz a pausa ao
final da execução do programa, do contrário, a janela se fecharia tão rápido que não conseguiríamos
ler a mensagem exibida.
Uma curiosidade da linguagem é a existência constante de controle ou especiais, chamas
constante barra ou constantes barra invertida, que podem ser adicionados as mensagens a serem
exibidas para causar um determinado efeito, neste caso, utilizamos os caracteres n (new line) que
gera uma quebra de linha, dando um efeito similar ao comando Escreval do português estruturado,
logo, após imprimir “Ola Mundo!” o cursor passará para a próxima linha.
Os caracteres barra existentes na linguagem C são os seguintes:
Caractere Significado Descrição
t Tabulação horizontal Move o cursor para a próxima parada de tabulação.
r Carriage return Posiciona o cursor no início da linha atual.
a Alerta Faz soar a campainha do sistema.
0 Null Caractere que em C termina um conjunto de caracteres.
n Nova linha Posiciona o cursor no início da nova linha.
Observe também que as instruções escritas em C possuem um ponto-e-vírgula (;) para
identificar o término daquela instrução.

30
8.2 Entrada e Saída de Dados
Agora que já vimos os primeiros conceitos da linguagem C, podemos nos aventurar em um
programa mais completo, contendo uma entrada e saída de dados. Veja o seguinte problema:
“Deverá ser criado um programa leia um valor numérico referente a uma quantidade em dias, e
imprima a quantidade de anos referentes aos dias.”
1. Ler um valor numérico referente a quantidade de dias (variável dias);
2. Realizar a conversão de dias em anos e guardar na variável anos.
25.365
dias
anos  .
3. Apresentar o conteúdo da variável anos após o cálculo.
Em português estruturado teríamos:
algoritmo “DiasAnos”
var
dias: INTEIRO
anos: REAL
inicio
Escreva(“Entre com o número de dias: ”)
Leia(dias)
anos  dias / 365.25
Escreva(dias, “ dia(s) equivalem a ”, anos, “ ano(s).”)
Fimalgoritmo
Já o mesmo algoritmo escrito em C seria:
#include <iostream>
int main () {
// declaração das variáveis
int dias;
float anos;
// Entrada, processamento e saída de dados
printf ("Entre com o número de dias: ");
scanf ("%d", &dias);
anos = dias / 365.25;
printf ("nn%d dias equivalem a %f anos.n", dias, anos);
}
Pudemos observar algumas novidades no código acima, como por exemplo, a declaração das
variáveis dias e anos, dos tipos int (inteiro) e float (real) respectivamente. Os tipos básicos
suportados pelo C são os seguintes:

31
Tipo Significado Descrição
char Caractere O valor armazenado é um caractere. Caracteres geralmente são
armazenados em códigos (usualmente o código ASCII).
int Inteiro Número inteiro é o tipo padrão e o tamanho do conjunto que pode ser
representado normalmente depende da máquina em que o programa
está rodando, normalmente de -2.147.483.648 a 2.147.483.647
float Real Número em ponto flutuante (real) de precisão simples, com seis dígitos
de precisão.
double Precisão dupla Número em ponto flutuante (real) de precisão dupla, com dez dígitos
de precisão.
void Indefinido Este tipo serve para indicar que um resultado não tem um tipo definido.
Uma das aplicações deste tipo em C é criar um tipo vazio que pode
posteriormente ser modificado para um dos tipos anteriores.
Utilizamos também a instrução scanf (equivalente ao Leia do português estruturado), ela
recebe como parâmetros, o tipo de dado a ser lido, “%d” neste caso, que representa que será lido um
dado inteiro, e o endereço da variável onde será guardada a informação lida (representa-se o
endereço de uma variável pelo símbolo de percentual % e o nome da variável).
Há também o uso de uma expressão aritmética bem simples e similar aquelas que vínhamos
utilizando em nossos pseudo-códigos em português estruturado.
A instrução printf (equivalente ao Escreva do português estruturado) também está
recebendo dois caracteres barra n (nova linha), e os caracteres %d e %f que exibirão um inteiro e
um real respectivamente na tela, no meio do restante do texto.
Segue uma lista dos códigos % disponíveis na linguagem C:
Código Significado
%d Inteiro
%f Float
%c Caractere
%s String
%% Coloca um % na tela
8.3: Comandosde Controle
Veremos agora as equivalências entre os comandos de controle existentes no português
estruturado e na linguagem C.

32
8.3.1 Desvio condicional simples
Sintaxe em português estruturado:
fimse
Sintaxe em C:
if (<condição>) {
}
Código escrito em C:
#include <iostream>
int main () {
int num;
printf (“Digite um numero: ”);
scanf (“%d”, &num);
if (num > 10) {
printf (“O número digitado é maior que 10!n”);
}
}
8.3.2 Desvio condicional composto
senao
fimse
Sintaxe em C:
if (<condição>) {
} else {
}

33
#include <iostream>
int main () {
int num;
if (num >= 10) {
printf (“O número digitado é maior ou igual a 10!n”);
} else {
printf (“O número digitado é menor que 10!n”);
}
}
8.3.4 Desvioscondicionaisencadeados
Sintaxe em português estruturado
< comandos para condição1 VERDADEIRA>
senao
senao
<comandos para condição1 VERDADEIRA e condição2 FALSA>
fimse
fimse
Sintaxe em C:
if (<condição1>) {
<sequencia de comandos para condição1 VERDADEIRA>
} else {
if (<condição2>) {
} else {
<sequencia comandos para condição1 VERDADEIRA e condição2 FALSA>
}
}
#include <iostream>
int main () {
int num;
if (num >= 10) {
printf (“O número digitado é maior ou igual a 10!n”);
} else {
if (num >= 5) {
printf (“O número digitado está entre 5 e 10!n”);
} else {
printf (“O número digitado está entre 0 e 5!n”);
}
}
}

34
8.4 Estruturasde repetição
Veremos agora as equivalências entre as estruturas de repetição existentes no português
estruturado e na linguagem C.
8.4.1 Repetição do tipo: Teste lógico no inicio do looping
enquanto <condição> faça
fimenquanto
Sintaxe em C:
while (<condição>) {
}
8.4.2 Repetição do tipo: Teste lógico no fim do looping
repita
ate <condição>
Sintaxe em C:
do {
} while (<condição>);
8.4.3 Repetição do tipo: variável de controle
fimpara
Sintaxe em C:
for (<inicialização>; <condição> ; <incremento>) {
}
#include <iostream>
int main () {
int i;
for (i = 1; i <= 100; i = i + 1) {
printf ("%d n", i);
}
}

35
8.5 TiposEstruturadosde Dados
Como vimos anteriormente, existem os tipos simples de dados e os tipos estruturados,
vejamos agora como utilizar os tipos estruturados no C.
A declaração de um vetor em C, é caracterizada pelo tipo de dado a ser armazenado, o nome
e o tamanho do vetor. Adicionalmente o vetor poderá ser inicializado no momento de sua
declaração.
Sintaxe em C:
tipo nome_vetor[tamanho] = {lista_de_valores};
Veja o exemplo de código C que utiliza um vetor unidimensional.
#include <iostream>
int main () {
int i, soma, valores[10];
for (i = 1; i <= 10; i = i + 1) {
printf (“Entre com o %dº valor: ”, i);
scanf (“%d”, &valores[i]);
}
soma = 0;
for (i = 1; i <= 10; i = i + 1) {
soma = soma + valores[i];
}
printf (“nnA soma dos valores informados foi: %dn”, soma);
}

36
Referência Bibliográficas
Apoio Informática. VisuAlg: Editor e Interpretador de Pseudocódigos. Disponível em:
<http://www.apoioinformatica.inf.br/o-visualg>. Acesso em 30 Jan 2012.
Bloodshed. Dev-C++. Disponível em: <http://www.bloodshed.net/dev/>. Acesso em 01 Fev 2012.
CPDEE/UFMG. Curso de C. Disponível em: < http://www.mtm.ufsc.br/~azeredo/cursoC/>. Acesso
em 01 Fev 2012.
Dijkstra, E.W. (1971) A Short Introduction to the Art of Programming. Technological University
Endhoven.

Algoritmo material apoio

Mais conteúdo relacionado

Mais procurados (20)

Semelhante a Algoritmo material apoio (20)

Último (20)

Algoritmo material apoio