Vous êtes sur la page 1sur 70

Algoritmo e Programação de Computadores

DISCIPLINA:
Algoritmo e Programação de Computadores

CURSOS:
Sistema de Informação

PROFESSOR:
Cleyton Ferrari
Prof. Cleyton Ferrari – cleytonferrari@hotmail.com – (69) 9975-0504
Algoritmo e Programação de Computadores 2

SUMÁRIO

1 Introdução a Lógica de Programação................................................................................................... 5

1.1 Lógica ............................................................................................................................................. 5

1.2 Seqüência Lógica ........................................................................................................................... 5

1.3 Instruções....................................................................................................................................... 5

1.4 Algoritmo ....................................................................................................................................... 5

1.5 Programas ...................................................................................................................................... 6

1.6 Lista de Exercícios ......................................................................................................................... 6

2 Desenvolvendo Algoritmos ................................................................................................................... 7

2.1 Pseudocódigo ................................................................................................................................. 7

2.2 Regras para construção do algoritmo .......................................................................................... 7


FAAr – Faculdades Associadas de Ariquemes

2.3 Fases ............................................................................................................................................... 7

2.4 Exemplo de Algoritmo .................................................................................................................. 8

2.5 Teste de Mesa ................................................................................................................................ 9

2.6 Lista de Exercícios ......................................................................................................................... 9

3 Diagrama de Bloco ............................................................................................................................... 10

3.1 O que é um diagrama de bloco ................................................................................................... 10

3.2 Simbologia ................................................................................................................................... 10

3.3 Lista de Exercícios ........................................................................................................................ 11

4 Constantes, Variáveis e Tipos de Dados ............................................................................................. 12

4.1 Constates ...................................................................................................................................... 12

4.2 Variáveis ....................................................................................................................................... 12

4.3 Tipos de Variáveis ....................................................................................................................... 13

4.4 Declaração de Variáveis .............................................................................................................. 14


Prof. Cleyton Ferrari – cleytonferrari@hotmail.com – (69) 9975-0504
Algoritmo e Programação de Computadores 3

4.5 Atribuição..................................................................................................................................... 15

4.6 Lista de Exercícios ....................................................................................................................... 15

5 Expressões ............................................................................................................................................ 16

5.1 Aritméticas ................................................................................................................................... 16

5.1.1 Soma......................................................................................................................................... 16

5.1.2 Subtração ................................................................................................................................. 16

5.1.3 Multiplicação ........................................................................................................................... 16

5.1.4 Divisão ..................................................................................................................................... 16

5.1.5 Exponenciação..........................................................................................................................17

5.1.6 Resto..........................................................................................................................................17

5.1.7 Divisão Inteira ..........................................................................................................................17

5.2 Relacional......................................................................................................................................17

5.3 Lógica ou Booleana ..................................................................................................................... 18


FAAr – Faculdades Associadas de Ariquemes

5.3.1 Tabela verdade do operador && (e) ....................................................................................... 19

5.3.2 Tabela verdade do operador || (ou) ....................................................................................... 19

5.3.3 Tabela verdade do operador ! (não) .......................................................................................20

5.4 Lista de Exercícios .......................................................................................................................20

6 Funções................................................................................................................................................. 21

6.1 Biblioteca de Funções.................................................................................................................. 21

6.1.1 Funções Predefinidas .............................................................................................................. 21

6.1.2 Manipulando strings ............................................................................................................... 22

7 Comando de Saída e de Entrada ......................................................................................................... 26

7.1 Comando de Saída ....................................................................................................................... 26

7.2 Comando de Entrada .................................................................................................................. 31

7.3 Só Reforçando.............................................................................................................................. 33

7.4 Lista de Exercícios ....................................................................................................................... 33


Prof. Cleyton Ferrari – cleytonferrari@hotmail.com – (69) 9975-0504
Algoritmo e Programação de Computadores 4

8 Estruturas de Seleção .......................................................................................................................... 34

8.1 Conceitos ...................................................................................................................................... 34

8.1.1 Seleção Simples ....................................................................................................................... 36

8.1.2 Seleção Composta.................................................................................................................... 36

8.1.3 Analisando cada linha do IF ................................................................................................... 37

8.1.4 A execução do comando IF ..................................................................................................... 38

8.1.5 Alguns exemplos...................................................................................................................... 39

8.2 IFs aninhados (encaixados) ........................................................................................................40

8.3 Lista de Exercícios ....................................................................................................................... 42

9 Alternativa de Múltiplas Escolhas ...................................................................................................... 43

9.1 Lista de Exercícios ....................................................................................................................... 45

10 Estruturas de repetição: for, while e do-while ................................................................................... 46

10.1 Estrutura do for ........................................................................................................................... 46


FAAr – Faculdades Associadas de Ariquemes

10.2 for dentro de for........................................................................................................................... 50

10.3 Lista de Exercícios ....................................................................................................................... 51

10.4 Estrutura do while ....................................................................................................................... 51

10.5 Estrutura do ... while ................................................................................................................... 55

10.6 Lista de Exercícios ....................................................................................................................... 59

11 Estruturas homogêneas: Vetores e Matrizes .....................................................................................60

11.1 Conceitos Gerais ..........................................................................................................................60

11.2 Ordenando Vetores ..................................................................................................................... 65

11.3 Lista de Exercícios ....................................................................................................................... 70


Prof. Cleyton Ferrari – cleytonferrari@hotmail.com – (69) 9975-0504
Algoritmo e Programação de Computadores 5

1 Introdução a Lógica de Programação

1.1 Lógica
A lógica de programação é necessária para pessoas que desejam trabalhar com desenvolvimento de
sistemas e programas, ela permite definir a seqüência lógica para o desenvolvimento.
Então o que é lógica?

Lógica de programação é a técnica de encadear pensamentos para atingir


determinado objetivo.

1.2 Seqüência Lógica


Estes pensamentos podem ser descritos como uma seqüência de instruções, que devem ser seguidas
para se cumprir uma determinada tarefa.

Seqüência Lógica são passos executados até atingir um objetivo ou


solução de um problema.
FAAr – Faculdades Associadas de Ariquemes

1.3 Instruções
Na linguagem comum, entende-se por instruções “um conjunto de regras ou normas definidas para
a realização ou emprego de algo”.
Em informática, porém, instrução é a informação que indica a um computador uma ação elementar
a executar.
Convém ressaltar que uma ordem isolada não permite realizar o processo completo, para isso é
necessário um conjunto de instruções colocadas em ordem seqüencial lógica.
Por exemplo, se quisermos fazer uma omelete de batatas, precisaremos colocar em prática uma
série de instruções: descascar as batatas, bater os ovos, fritar as batatas, etc...
É evidente que essas instruções têm que ser executadas em uma ordem adequada – não se podem
descascar as batatas depois de fritá-las.
Dessa maneira, uma instrução tomada em separado não tem muito sentido; para obtermos o
resultado, precisamos colocar em prática o conjunto de todas as instruções, na ordem correta.

Instruções é um conjunto de regras ou normas definidas para a realização


ou emprego de algo. Em informática, é o que indica a um computador uma
ação elementar a executar.

1.4 Algoritmo
Um algoritmo é formalmente uma seqüência finita de passos que levam a execução de uma tarefa.
Podemos pensar em algoritmo como uma receita, uma seqüência de instruções que dão cabo de
Prof. Cleyton Ferrari – cleytonferrari@hotmail.com – (69) 9975-0504
Algoritmo e Programação de Computadores 6

uma meta específica. Estas tarefas não podem ser redundantes nem subjetivas na sua definição,
devem ser claras e precisas.
Como exemplos de algoritmos podem citar os algoritmos das operações básicas (adição,
multiplicação, divisão e subtração) de números reais decimais. Outros exemplos seriam os manuais
de aparelhos eletrônicos, como um videocassete, que explicam passo-a-passo como, por exemplo,
gravar um evento.
Até mesmo as coisas mais simples, podem ser descritas por seqüências lógicas. Por exemplo:
“Chupar uma bala”.
 Pegar a bala
 Retirar o Papel
 Chupar a bala
 Jogar o papel no lixo
“Somar dois números quaisquer”.
 Escrever o primeiro número no retângulo A
 Escrever o segundo número no retângulo B
 Some o número do retângula A com número do retângulo B e coloque o resultado no
retângulo C
Retângulo A Retângulo B Retângulo C
FAAr – Faculdades Associadas de Ariquemes

+ =

1.5 Programas
Os programas de computadores nada mais são do que algoritmos escritos numa linguagem de
computador (C, Pascal, C#, Java entre outras) e que são interpretados e executados por uma
máquina, no caso um computador. Notem que dada esta interpretação rigorosa, um programa é por
natureza muito específica e rígida em relação aos algoritmos da vida real.

1.6 Lista de Exercícios


Os exercícios seguem em anexo a apostila.
Prof. Cleyton Ferrari – cleytonferrari@hotmail.com – (69) 9975-0504
Algoritmo e Programação de Computadores 7

2 Desenvolvendo Algoritmos

2.1 Pseudocódigo
Os algoritmos são descritos em uma linguagem chamada pseudocódigo. Este nome é uma alusão à
posterior implementação em uma linguagem de programação, ou seja, quando for programar em
uma linguagem, por exemplo, C# (C Sharp), estaremos gerando código em C#. Por isso os algoritmos
são independentes das linguagens de programação. Ao contrário de uma linguagem de programação
não existe um formalismo rígido de como deve ser escrito o algoritmo.
O algoritmo deve ser fácil de interpretar e fácil de codificar. Ou seja, ele deve ser o intermediário
entre a linguagem falada e a linguagem de programação.

2.2 Regras para construção do algoritmo


Para escrever um algoritmo precisamos descrever a seqüência de instruções, de maneira simples e
objetiva. Pra isso utilizaremos algumas técnicas:
 Usar somente um verbo por frase
 Imaginar que você está desenvolvendo um algoritmo para pessoas que não trabalham com
informática
 Usar frases curtas e simples
FAAr – Faculdades Associadas de Ariquemes

 Ser objetivo
 Procurar usar palavras que não tenham sentido impreciso

2.3 Fases
Já foi apresentado que algoritmo é uma seqüência lógica de instruções que podem ser executadas.
É importante ressaltar que qualquer tarefa que siga determinado padrão pode ser descrita por um
algoritmo, como por exemplo:
COMO FAZER ARROZ DOCE
Ou então
CALCULAR O SALDO FINANCEIRO DE UM ESTOQUE
Entretanto ao montar um algoritmo, precisamos primeiro dividir o problema apresentado em três
fases fundamentais.

ENTRADA
» PROCESSAMENTO
» SAÍDA

Onde Temos:
Entrada: São os dados de entrada do algoritmo
Processamento: São os procedimentos utilizados para chegar ao resultado Final
Prof. Cleyton Ferrari – cleytonferrari@hotmail.com – (69) 9975-0504
Algoritmo e Programação de Computadores 8

Saída: São os dados já processados


Analogia com o homem
ENTRADA PROCESSAMENTO SAÍDA
FAAr – Faculdades Associadas de Ariquemes

2.4 Exemplo de Algoritmo


Imagina o seguinte problema: Calcular a média final dos alunos da 3ª Série. Os Alunos
realizarão quatro provas: P1, P2, P3 e P4.
Onde:
Média Final = P1 + P2 + P3 + P4
4
Para montar o algoritmo proposto, faremos três perguntas:
a. Quais são os dados de entrada?
R: Os dados de entrada são P1, P2, P3 e P4
b. Qual será o processamento a ser utilizado?
R: O procedimento será somar todos os dados de entrada e dividi-los por 4
P1 + P2 + P3 + P4
4
c. Quais serão os dados de saída?
R: O dado de saída será a média final
Algoritmo
Receba a nota da prova1
Receba a nota da prova2
Prof. Cleyton Ferrari – cleytonferrari@hotmail.com – (69) 9975-0504
Algoritmo e Programação de Computadores 9

Receba a nota da prova3


Receba a nota da prova4
Some todas as notas e divida o resultado por 4
Mostre o resultado da divisão

2.5 Teste de Mesa


Após desenvolver um algoritmo ele deverá sempre ser testado. Este teste é chamado de teste de
mesa, que significa seguir as instruções do algoritmo de maneira precisa para verificar se o
procedimento utilizado está correto ou não.
Veja o exemplo:
Receba a nota da prova1
Receba a nota da prova2
Receba a nota da prova3
Receba a nota da prova4
Some todas as notas e divida o resultado por 4
Mostre o resultado da divisão Utilize a tabela abaixo:
P1 P2 P3 P4 Média
FAAr – Faculdades Associadas de Ariquemes

2.6 Lista de Exercícios


Os exercícios seguem em anexo a apostila.
Prof. Cleyton Ferrari – cleytonferrari@hotmail.com – (69) 9975-0504
Algoritmo e Programação de Computadores 10

3 Diagrama de Bloco

3.1 O que é um diagrama de bloco


O diagrama de blocos é uma forma padronizada e eficaz para representar os passos lógicos de um
determinado processamento.
Com o diagrama podemos definir uma seqüência de símbolos, com significado bem definido,
portanto, sua principal função é a de facilitar a visualização dos passos de um processamento.

3.2 Simbologia
Existem diversos símbolos em um diagrama de bloco. No decorrer do curso apresentaremos os mais
utilizados.
Veja no quadro abaixo alguns dos símbolos que iremos utilizar:

Símbolo Função

Indica o Início ou Fim de um processamento


Exemplo: Início do Algoritmo
FAAr – Faculdades Associadas de Ariquemes

Terminal

Processamento em geral
Exemplo: Calculo de dois números
Processamento

Indica entrada de dados através do Teclado


Exemplo: Digite a nota da prova 1
Entrada de Dados
Manual

Mostra informações ou resultados


Exemplo: Mostre o resultado do cálculo
Exibir

Dentro do símbolo sempre terá algo escrito, pois somente os símbolos não nos dizem nada. Veja no
exemplo a seguir:
Exemplo de diagrama de Bloco
Prof. Cleyton Ferrari – cleytonferrari@hotmail.com – (69) 9975-0504
Algoritmo e Programação de Computadores 11

Chupar uma Bala Calcular Média de 4 Notas


FAAr – Faculdades Associadas de Ariquemes

Veja que no exemplo da bala seguimos uma seqüência lógica somente com informações diretas, já
no segundo exemplo da média utilizamos cálculo e exibimos o resultado do mesmo.

3.3 Lista de Exercícios


Os exercícios seguem em anexo a apostila.
Prof. Cleyton Ferrari – cleytonferrari@hotmail.com – (69) 9975-0504
Algoritmo e Programação de Computadores 12

4 Constantes, Variáveis e Tipos de Dados


Variáveis e constantes são os elementos básicos que um programa manipula. Uma variável é um
espaço reservado na memória do computador para armazenar um tipo de dado determinado.
Variáveis devem receber nomes para poderem ser referenciadas e modificadas quando necessário.
Um programa deve conter declarações que especificam de que tipo são as variáveis que ele
utilizará e às vezes um valor inicial. Tipos podem ser, por exemplo: inteiro, reais, caracteres, etc.
As expressões combinam variáveis e constantes para calcula novos valores.

4.1 Constates
Constantes é um determinado valor fixo que não se modifica ao longo do tempo, durante a
execução de um programa. Conforme o seu tipo, a constante é classificada como sendo numérica,
lógica e literal.
Exemplo de constantes:
FAAr – Faculdades Associadas de Ariquemes

4.2 Variáveis
Variável é a representação simbólica dos elementos de certo conjunto. Cada variável corresponde a
uma posição de memória, cujo conteúdo pode ser alterado ao longo do tempo durante a execução
de um programa. Embora uma variável possa assumir diferentes valores, ela só pode armazenar um
valor a cada instante.
Exemplo de variáveis:
Prof. Cleyton Ferrari – cleytonferrari@hotmail.com – (69) 9975-0504
Algoritmo e Programação de Computadores 13

4.3 Tipos de Variáveis


As variáveis e as constantes podem ser basicamente de quatro tipos: Numéricas, caracteres,
Alfanuméricas ou lógicas.

 Numéricas: Específicas para armazenamento de números, que posteriormente poderão ser


utilizados para cálculos. Podem ser ainda classificadas como Inteiras ou Reais.
o Inteira (int): Os números inteiros são aqueles que não possuem componentes
decimais ou fracionários, podendo ser positivos ou negativos.
 Como exemplos:
 12 (número inteiro positivo)
 -12 (número inteiro negativo)
o Real (double): Os números reais são aqueles que podem possuir componentes
decimais ou fracionários, podendo também ser positivos ou negativos.
 Como exemplos:
 24.01 (número real positivo com duas casas decimais)
 144 (número real positivo com zero casa decimal)
 -13.3 (número real negativo com uma casa decimal)
 0.0 (número real com uma casa decimal)
FAAr – Faculdades Associadas de Ariquemes

 Alfanuméricas (string): Também conhecida como caractere, alfanumérica ou literal. Esse


tipo de variável armazena dado que contêm letras, dígitos e/ou símbolos especiais.
 Como exemplos:
 “Miely” (string de comprimento 5)
 “123” (string de comprimento 3)
 “A” (string de comprimento 1)
 Lógicas (bool): Também conhecido como booleano. É representado no algoritmo pelos dois
únicos valores lógicos possíveis: verdadeiro ou falso. Porém, é comum encontrar em outras
referências outros tipos de pares de valores lógicos como: sim/não, 1/0, true/false,
verdadeiro/falso.
 Como exemplos:
 true (valor lógico verdadeiro)
 false (valor lógico falso)

A seguinte tabela mostra os tipos de variáveis e os valores possíveis de se armazenar em cada uma
delas.
Prof. Cleyton Ferrari – cleytonferrari@hotmail.com – (69) 9975-0504
Algoritmo e Programação de Computadores 14

C# Type Valores possíveis de armazenamento


bool Verdadeiro ou Falso (Valores booleanos)
byte 0 a 255 (8 bits)
sbyte -128 a 127 (8 bits)
char Um caractere (16 bits)
decimal ±1.0 x 10-28 a ± 7.9 x 1028 (128 bits)
double ±5.0 x 10-324 a ± 1.7 x 10308 (64 bits)
float ±1.5 x 10-45 a ± 3.4 x 1038 (32 bits)
int -2.147.483.648 a 2.147.483.647 (32 bits)
uint 0 a 4.294.967.295 (32 bits)
long - 9.223.373.036.854.775.808 a 9.223.372.036.854.775.807 (64 bits)
ulong 0 a 18.446.744.073.709.551.615 (64 bits)
object Qualquer Tipo
short -32.768 a 32.767 (16 bits)
ushort 0 a 65.535 (16 bits)
FAAr – Faculdades Associadas de Ariquemes

string Seqüência de Caracteres (16 bits por caractere)

4.4 Declaração de Variáveis


As variáveis só podem armazenar valores de um mesmo tipo.
Tipo da variável nome da variável ;
Quando formos dar nome às variáveis, se faz necessário seguirmos algumas regras. É bom ressaltar
que estas regras irão variar de acordo com a linguagem. As seguintes regras:
 O primeiro caractere é uma letra.
 Se houver mais de um caractere, só podemos usar: letra ou algarismo.
 Nomes de variáveis escritas com letras maiúsculas serão diferentes de letras minúsculas.
Lembre-se: média é diferente de MÉDIA.
 Nenhuma palavra reservada poderá ser nome de variável.

Nomes Válidos:
Media, alt, a2, PESO
Nomes Não-Válidos:
2w – começa por algarismo.
Media aluno – o caractere espaço não é permitido.
Prof. Cleyton Ferrari – cleytonferrari@hotmail.com – (69) 9975-0504
Algoritmo e Programação de Computadores 15

Um dos objetivos de se declarar uma variável no início do algoritmo é para que seja alocada
(reservada) uma área na memória (endereço de memória) para a variável. Outro objetivo da
declaração de variáveis é que, após a declaração, o algoritmo sabe os tipos de operações que cada
variável pode realizar; explicando: algumas operações só podem ser realizadas com variáveis do
tipo inteiro, outras só podem ser realizadas com variáveis dos tipos inteiro ou real, outras só com
variáveis de caractere etc.
Exemplos:
int x;
bool opcao;
string texto1;

4.5 Atribuição
É a principal forma de se armazenar um dado em uma variável. Esse comando permite que você
forneça um valor a uma variável, onde o tipo desse valor tem de ser compatível com a variável.
Uma Variável nunca é eternamente igual a um valor, seu conteúdo pode ser alterado a qualquer
momento. Portanto para atribuir valores a variáveis devemos usar o sinal de “=”.

Identificador = expressão ;
Legenda:
Identificador é o nome da variável à qual está sendo atribuído um valor.
FAAr – Faculdades Associadas de Ariquemes

= é o símbolo de atribuição, formado pelo =.


Expressão pode ser uma expressão aritmética, uma expressão lógica ou literal cuja
avaliação (resultado) é atribuída ao identificador (variável).
; finaliza o comando.

Exemplo:
x = 10; //Lê se: a variável x recebe o valor 10, ou, x recebe 10
opcao = false;
texto1 = "Cleyton Ferrari";

4.6 Lista de Exercícios


Os exercícios seguem em anexo a apostila.
Prof. Cleyton Ferrari – cleytonferrari@hotmail.com – (69) 9975-0504
Algoritmo e Programação de Computadores 16

5 Expressões
O conceito de expressões em termos computacionais está intimamente ligado ao conceito de
expressão (ou fórmulas) matemáticas, onde um conjunto de variáveis e constantes numéricas
relaciona-se por meio de operadores compondo uma fórmula que, uma vez avaliada, resulta num
valor. As expressões dividem-se em:

5.1 Aritméticas
Expressões aritméticas são aquelas cujo resultado da avaliação é do tipo numérico, seja ele inteiro
ou real. Somente o uso de operadores aritméticos e variáveis numéricas é permitido em expressões
deste tipo.
Como exemplo:

5.1.1 Soma
Na matemática, representada pelo sinal + e, em expressões em termos computacionais, pelo
mesmo sinal.
A + B Expressão que simboliza a soma do valor de duas variáveis.
2+3 Nessa expressão, o valor retornado é a soma dos valores dados, isto é, 5.

5.1.2 Subtração
FAAr – Faculdades Associadas de Ariquemes

Na matemática, representada pelo sinal – e, em expressões em termos computacionais, pelo


mesmo sinal.
A–B Expressão que simboliza a subtração do valor de duas variáveis.
3 -2 Nessa expressão, o valor retornado é o resto, isto é, 1.

5.1.3 Multiplicação
Na matemática, representada pelos sinais X ou . e, em expressões em termos computacionais, pelo
sinal *.
B*D Expressão que simboliza a multiplicação do valor de duas variáveis.
3*2 Nessa expressão, o valor retornado é o produto dos valores dados, isto é, 6.

5.1.4 Divisão
Na matemática, representada pelo sinal ÷ e, em expressões computacionais, pelo sinal /.
A / B Expressão que simboliza a divisão do valor de duas variáveis.
6/2 Nessa expressão, o valor retornado é a divisão dos valores dados, que, no caso, será 3.
5/2 Nessa expressão, o valor retornado é a divisão dos valores dados, que, no caso, será 2.5.
Dica: Normalmente, as linguagens de programação assumem que a divisão é uma operação que
retorna um valor REAL. Atenção especial, portanto, para variáveis que receberão o resultado de
uma divisão.
Prof. Cleyton Ferrari – cleytonferrari@hotmail.com – (69) 9975-0504
Algoritmo e Programação de Computadores 17

5.1.5 Exponenciação
Na matemática, representada pela base e por um expoente e em expressões em termos
computacionais pela função Math.Pow( ).
Math.Pow(A, 2); Expressão que simboliza o valor da variável ao quadrado.
Math.Pow(3, 2); Nessa expressão, o valor retornado é o resultado da exponenciação do valor 3
ao quadrado 2 que, no caso, será equivalente a 9.
Math.Pow(2, 3); Nessa expressão, o valor retornado é o resultado da exponenciação do valor 2
ao cubo 3, que no caso será equivalente a 8.00.

5.1.6 Resto
É usado em expressões em termos computacionais quando se deseja encontrar o resto da divisão de
dois números inteiros. Em termos computacionais pelo símbolo %
K % Y Expressão que simboliza a intenção de achar o resto da divisão do valor da variável K pelo
valor da variável Y.
5 % 2 Nessa expressão, o valor retornado é o resto da divisão do primeiro pelo segundo número,
que, no caso, será equivalente a 1.
7 % 4 Nessa expressão, o valor retornado é o resto da divisão do primeiro pelo segundo número,
que, no caso, será equivalente a 3.
FAAr – Faculdades Associadas de Ariquemes

5.1.7 Divisão Inteira


É usado em expressões em termos computacionais quando se deseja encontrar o quociente da
divisão de dois números inteiros, além de retornar também o resto da divisão.
Math.DivRem(A, B, out C); Expressão que simboliza a intenção de achar o valor do divisor
na divisão do valor da variável A pelo valor da variável B, e joga o resto da divisão na variável C.
Math.DivRem(20, 7, out X); Nessa expressão, o valor retornado é o coeficiente da divisão do
primeiro pelo segundo número, que, no caso, será equivalente a 2, e o resto da divisão será
armazenada em X, que neste caso é 6.
Math.DivRem(8, 3, out X); Nessa expressão, o valor retornado é o coeficiente da divisão do
primeiro pelo segundo número, que, no caso, será equivalente a 2, e o resto da divisão será
armazenada em X, que neste caso é 2.

5.2 Relacional
Uma expressão relacional, ou simplesmente relação, é uma comparação realizada entre dois
valores de mesmo tipo básico. Estes valores são representados na relação através de constantes,
variáveis ou expressões aritméticas.
Como exemplos de operadores relacionais matematicamente conhecidos têm:
Prof. Cleyton Ferrari – cleytonferrari@hotmail.com – (69) 9975-0504
Algoritmo e Programação de Computadores 18

Operador Matemática Usaremos em C#


Igual = ==
Diferente ≠ !=
Maior > >
Menor que < <
Maior ou Igual a ≥ >=
Menor ou Igual a ≤ <=

Como exemplos de expressões relacionais têm:


A != B A diferente de B
X == 1 X igual a 1
7>6 7 maior que 6
8<9 8 menor que 9
1 <= Y 1 menor ou igual ao valor da variável Y
4 >= W 4 maior ou igual ao valor da variável W
FAAr – Faculdades Associadas de Ariquemes

Símbolo Função

Indica uma decisão a ser tomada.


No exemplo, ta comparando o campo Codigo
com Codant, se forem iguais, o fluxo segue para
a direita, se não forem iguais, o fluxo segue para
baixo.

Decisão

5.3 Lógica ou Booleana


Denomina-se expressão lógica a expressão cujos operadores são lógicos e cujos operandos são
relações, constantes e/ou variáveis do tipo lógico.
Como exemplos de operadores lógicos, matematicamente conhecidos têm:
Prof. Cleyton Ferrari – cleytonferrari@hotmail.com – (69) 9975-0504
Algoritmo e Programação de Computadores 19

Operador Matemática Usaremos em C# Significa


Conjunção e && É verdade se todas as condições
forem verdadeiras.
Disjunção ou || É Verdadeira se pelo menos uma
condição for verdadeira
Negação não ! Inverte o valor da expressão ou
condição, se verdadeira inverte para
falsa e vice-versa.

5.3.1 Tabela verdade do operador && (e)


Suponha duas perguntas feitas a quatro pessoas. Se a resposta do candidato for falsa, deverá falar
0 (zero), caso contrário, falará 1 (um).
Suponha também que só será chamado para entrevista o candidato que dominar as duas linguagens.

Você Conhece a Linguagem Você conhece a linguagem Saída


C# ? PASCAL?
0 0 0
FAAr – Faculdades Associadas de Ariquemes

0 1 0
1 0 0
1 1 1
Nesse exemplo, somente o quarto candidato seria chamado para a entrevista, pois o operador &&
(e) só considera a expressão como verdadeira se todas as expressões testadas forem verdadeiras.

5.3.2 Tabela verdade do operador || (ou)


Suponha duas perguntas feitas a quatro pessoas. Se a resposta do candidato for falsa, deverá falar
0 (zero), caso contrário, falará 1 (um).
Suponha também que será chamado para entrevista o candidato que dominar pelo menos uma
linguagem.

Você conhece a linguagem Você conhece a linguagem Saída


C++ ? JAVA?
0 0 0
0 1 1
1 0 1
1 1 1
Prof. Cleyton Ferrari – cleytonferrari@hotmail.com – (69) 9975-0504
Algoritmo e Programação de Computadores 20

Nesse exemplo, somente o primeiro candidato não seria chamado para a entrevista, pois o
operador || (ou) considera a expressão como verdadeira se pelo menos uma expressão testada for
verdadeira.

5.3.3 Tabela verdade do operador ! (não)


Observe a tabela a seguir e as afirmativas:
 Suponha que temos duas varáveis, A = 5 e B = 3.

Camisa Saída
! (A > B) Falso
! (B < A) Falso
! (B <> B) Verdadeiro
! (A == B) Verdadeiro

O operador ! (não) inverte a saída.


Considerem a, b e c variáveis numéricas, e cor uma variável string.
FAAr – Faculdades Associadas de Ariquemes

a + b == 0 && c <> 1 Essa expressão verifica se o resultado da soma dos valores das variáveis
a e b é igual a 0 (zero) e (&&) se o valor da variável c é diferente de 1. O resultado será
considerado verdadeiro se as duas expressões relacionais foram verdadeiras.
Cor == “azul” || a * b > c Essa expressão verifica se o conteúdo armazenado na variável cor é
azul ou (||) se o resultado do produto dos valores variáveis a e b é maior do que o valor
armazenado na variável c. O resultado será considerado verdadeiro se, pelo menos uma das
expressões relacionais for verdadeira.
O resultado obtido de uma avaliação de uma expressão lógica é sempre um valor lógico, isto é,
falso ou verdadeiro. Por esse motivo, pode-se considerar uma única relação como sendo uma
expressão lógica.

5.4 Lista de Exercícios


Os exercícios seguem em anexo a apostila.
Prof. Cleyton Ferrari – cleytonferrari@hotmail.com – (69) 9975-0504
Algoritmo e Programação de Computadores 21

6 Funções
Uma função é um instrumento (Sub–algoritmo) que tem como objetivo retornar um valor ou uma
informação.
A chamada de uma função é feita através da citação do seu nome seguido opcionalmente de seu
argumento inicial entre parênteses.
As funções podem ser predefinidas pela linguagem ou criadas pelo programador de acordo com o
seu interesse.
Exemplos:
FAAr – Faculdades Associadas de Ariquemes

6.1 Biblioteca de Funções


Armazenam um conjunto de funções que podem ser usadas pelos programas.

6.1.1 Funções Predefinidas


As funções abaixo são mais comuns e importantes para nosso desenvolvimento lógico, entretanto,
cada linguagem possui suas funções próprias.
As funções podem ser aritméticas, temporais, de texto e etc.
Prof. Cleyton Ferrari – cleytonferrari@hotmail.com – (69) 9975-0504
Algoritmo e Programação de Computadores 22

Função em C# Descrição
Math.PI; Função que resulta no valor 3.14159265. Sem Argumentos
Função que resulta no valor do seno de um ângulo qualquer em
Math.Sin(x); radianos.
Função que resulta no valor do co-seno de um de um ângulo
Math.Cos(x); qualquer em radianos.
Função que resulta no valor d tangente de um ângulo qualquer em
Math.Tan(x); radianos.
Math.Abs(x); Função que resulta no valor absoluto de um número qualquer.
Função que resulta no valor do número e elevado a um número
Math.Exp(x); qualquer.
Função que resulta no valor do logaritmo neperiano de um número
Math.Log(x); qualquer.
Função que resulta no valor da raiz quadrada de um número
Math.Sqrt(x); positivo.
(int)x; Função que converte um número real em inteiro.

(double)x; Função que converte um número inteiro em real.


FAAr – Faculdades Associadas de Ariquemes

6.1.2 Manipulando strings


A classe string possui uma série de métodos estáticos e não estáticos, que são utilizamos para
formatação, concatenação, desmembramento, substring, etc. Vamos analisar alguns destes
métodos da classe string.

6.1.2.1 O método Substring


O método substring é um método não estático que permite pegarmos uma porção de uma string.
Para utilizarmos o método substring, basta chamar o método a partir de uma variável string ou
mesmo de uma string literal, conforme o exemplo.

string nome = "Cleyton Ferrari";


string sobreNome = nome.Substring(8, 7);

O método substring aceita como parâmetro a posição inicial que queremos obter e quantos
caracteres devem ser extraídos. Caso não seja informado o número de caracteres a ser extraído, a
função retornará o restante da string a partir da posição inicial informada.

6.1.2.2 O método IndexOf


O método IndexOf é utilizado para localizar uma determinada palavra dentro da string. Este
método retornará a posição da string desejada. Caso a string não seja encontrada, será retornado o
valor -1.
Prof. Cleyton Ferrari – cleytonferrari@hotmail.com – (69) 9975-0504
Algoritmo e Programação de Computadores 23

string nome = "Cleyton Ferrari - Programando em C#";


int pos = nome.IndexOf("Programando");
//A partir do índice 5
int pos2 = nome.IndexOf("Ferrari", 5);
Conforme vimos no exemplo, é possível informar a posição inicial para busca como um parâmetro
adicional.

6.1.2.3 Funções ToUpper e ToLower


As funções ToUpper e ToLower permitem colocar uma string em letra minúsculas ou maiúsculas,
conforme o exemplo a seguir.

string nome = "Cleyton Ferrari";


string min = "";
string mai = "";
min = nome.ToUpper();
mai = nome.ToLower();

6.1.2.4 Funções StartsWith e EndsWith


As funções startswith e endswith verificam se a string começo ou termina com uma determinada
FAAr – Faculdades Associadas de Ariquemes

palavra ou caracter. Estas funções retornam um valor booleano (true ou false).

string arquivo = "comctl32.dll";


if (nome.StartsWith("com"))
Console.WriteLine("Começa com COM!");
if (nome.EndsWith(".dll"))
Console.WriteLine("É uma dll!");

6.1.2.5 Funções TrimStart, TrimEnd e Trim


As funções de Trim servem para remover espaços em branco das strings. A função TrimStart remove
os espaços em branco do início da string, já a função TrimEnd remove os espaços em branco do
final da string. A função Trim remove os espaços em branco do inicio e do fim da string.

string nome = " MAURICIO ";


nome = nome.TrimEnd();
nome = nome.TrimStart();
nome = nome.Trim();
Prof. Cleyton Ferrari – cleytonferrari@hotmail.com – (69) 9975-0504
Algoritmo e Programação de Computadores 24

6.1.2.6 Funções PadLeft e PadRight


As funções PadLeft e PadRight servem para preencher uma string a esquerda ou a direita com um
caracter especificado. Os exemplos a seguir mostra o uso das funções PadLeft e PadRight.

string nome = "Cleyton";


nome = nome.PadRight(10, ' '); // "Cleyton "
string codigo = "123";
codigo = codigo.PadLeft(6, '0'); // "000123"

6.1.2.7 Funções String.Join e String.Split


A função Split serve para quebrar uma string em um array de strings de acordo com um separador.
Ao contrário da função split, a função Join concatena um array de string inserindo um separador.

string linha = "Teste, 10, 20, 10/06/2007";


string[] campos = linha.Split(',');
string linhaNova = String.Join(';', campos);

6.1.2.8 A Função String.Format


FAAr – Faculdades Associadas de Ariquemes

A função String.Format é uma das funções mais versáteis da classe string. Esta função permite a
criação de uma string baseada em um padrão. Podemos colocar dentro do padrão da string de
formatação alguns tokens que poderam ser substituídos por variáveis passadas por parâmetro no
comando format.

string teste = String.Format("Vou colocar o {0} aqui.", "parâmetro");

No exemplo acima, o padrão da string (primeiro parâmetro) contém um token {0}. Este token indica
que este valor deve ser substituído pelo segundo parâmetro passado para a função (neste caso a
palavra “parâmetro”).

sTeste = String.Format("Formatação de string com {0} parâmetro. ",


"Agora são {1}. Valor numérico: {2}", 1, DateTime.Now, 15.5);

No exemplo acima, temos o padrão da string com mais de um token, com números de 0 à 2. A
função também recebe 3 parâmetros adicionais que correspondem aos valores que serão
substituídos na string. Além de informarmos os tokens, podemos informar regras de formatação que
serão utilizadas de acordo com o tipo de dado passado por parâmetro, conforme o exemplo.

sTeste = String.Format("Custom Format: {0:d/M/yyy HH:mm:ss}", DateTime.Now);


sTeste = String.Format("Formatação do número inteiro: {0:D}.", 32);
sTeste = String.Format("Formatação do número inteiro: {0:D4}.", 21);
Prof. Cleyton Ferrari – cleytonferrari@hotmail.com – (69) 9975-0504
Algoritmo e Programação de Computadores 25

6.1.2.9 A classe StringBuilder


Apesar da versatilidade da classe string, operações com string podem consumir muitos recursos e
causar perda de desempenho. Isto ocorre porque a cada operação o framework cria um novo buffer
para a string resultante da operação, ao invés de aproveitar o buffer que está sendo utilizado. Isto
é mais aparente em operações de concatenação.
Para não criar este tipo de problema, podemos utilizar a classe StringBuilder, do namespace
System.Text. Esta classe permite a criação de strings aproveitando o buffer utilizado, o que torna o
código mais eficiente.
No exemplo a seguir temos um trecho de código com uma operação feita de forma ineficiente e
outra mais eficiente usando o stringBuilder, veja a diferença.

// Codigo ineficiente
string sql;
sql = "SELECT * FROM Products";
sql += " WHERE CategoryId=1 AND";
sql += " AND UnitPrice>10";
// Codigo Eficiente
StringBuilder sb = new StringBuilder();
sb.Append("SELECT * FROM Products");
sb.Append(" WHERE CategoryId=1 AND");
sb.Append(" AND UnitPrice>10");
FAAr – Faculdades Associadas de Ariquemes

sql = sb.ToString();
Prof. Cleyton Ferrari – cleytonferrari@hotmail.com – (69) 9975-0504
Algoritmo e Programação de Computadores 26

7 Comando de Saída e de Entrada

7.1 Comando de Saída


É o comando responsável por enviar um resultado, uma informação ao usuário. O valor de cada
variável é buscado na memória e inserido em um dispositivo de saída. Através desse comando o
computador pode emitir os resultados e outras mensagens para o usuário através da tela do
computador ou uma impressora.

Console.Write( imprima expressão ou variável ou constantes );

Algoritmo 1

using System;
class Program
{
static void Main()
{
Console.Write("Aprendendo Algoritmos!!!");
}
FAAr – Faculdades Associadas de Ariquemes

Vídeo:

Aprendendo Algoritmo!!!

Esse algoritmo faz com que seja exibida, na tela do computador, a mensagem: Aprendendo
Algoritmo!!!
Neste nosso algoritmo desenvolvido em C# é possível notar a semelhanças com as demais linguagens
de programação a baixo:

Linguagem: Java

public class imp1


{
public static void main(String args[])
{
System.out.println("Aprenda Algoritmo!!!");
}
}
Prof. Cleyton Ferrari – cleytonferrari@hotmail.com – (69) 9975-0504
Algoritmo e Programação de Computadores 27

Linguagem: Pascal

program imp1;
uses crt;
begin
writeln('Aprenda Algoritmo!!!');
end.

Linguagem: C

#include <stdio.h>
#include <stdlib.h>
int main()
{
printf("Aprenda Algoritmo!!!");
return(0);
}

Agora que criamos o nosso primeiro algoritmo em C# é possível notar que o importante é a nossa
lógica e não a sintaxe da linguagem.
FAAr – Faculdades Associadas de Ariquemes

Algoritmo 2

using System;
class Program
{
static void Main()
{
Console.Write("Aprendendo algoritmos!!!");
Console.Write("Com Cleyton Ferrari");
}
}

Vídeo:

Aprendendo algoritmo!!!Com Cleyton Ferrari

Embora tenhamos duas linhas de comandos, o que nos levaria a pensar que teríamos duas linhas no
vídeo, o interpretador só alimenta linha se assim especificarmos através do símbolo \n. Esse
símbolo é uma string e deverá vir entre aspas.
Prof. Cleyton Ferrari – cleytonferrari@hotmail.com – (69) 9975-0504
Algoritmo e Programação de Computadores 28

Algoritmo 3

using System;
class Program
{
static void Main()
{
Console.Write("Aprendendo algoritmos!!!");
Console.Write("\nCom Cleyton Ferrari");
}
}

Vídeo:

Aprendendo algoritmo!!!
Com Cleyton Ferrari

Algoritmo 4

using System;
class Program
FAAr – Faculdades Associadas de Ariquemes

{
static void Main()
{
Console.Write("Aprendendo algoritmos!!!\n");
Console.Write("Com Cleyton Ferrari");
}
}

Vídeo:

Aprendendo algoritmo!!!
Com Cleyton Ferrari

Observe que o símbolo \n poderá ser colocado ao final da linha anterior ou no início da próxima
linha que produzirá o mesmo efeito, mas, lembre-se, sempre entre aspas.
Prof. Cleyton Ferrari – cleytonferrari@hotmail.com – (69) 9975-0504
Algoritmo e Programação de Computadores 29

Algoritmo 5

using System;
class Program
{
static void Main()
{
Console.Write("Aprendendo algoritmo !!!\nCom Cleyton
Ferrari\n\nFica muito mais fácil !!!"); //digite tudo na mesma linha
}
}

Vídeo:

Aprendendo algoritmo !!!


Com Cleyton Ferrari

Fica muito mais fácil !!!


FAAr – Faculdades Associadas de Ariquemes

Observe que podemos, usando um único comando Console.Write() e fazendo uso do símbolo \n,
mostrar várias mensagens em várias linhas, inclusive deixando linha em branco quando colocamos
\n\n.
Ou simplesmente usar o comando Console.WriteLine(); que já quebra a linha automaticamente no
final de cada frase.

using System;
class Program
{
static void Main()
{
Console.WriteLine("Aprendendo algoritmo !!!");
Console.WriteLine("Com Cleyton Ferrari");
Console.WriteLine("Fica muito mais fácil !!!");
}
}
Prof. Cleyton Ferrari – cleytonferrari@hotmail.com – (69) 9975-0504
Algoritmo e Programação de Computadores 30

Algoritmo 6

using System;
class Program
{
static void Main()
{
int x;
x = 10;
Console.Write(x);
}
}

Vídeo:

10

Esse trecho é de muita importância, pois x recebe o valor 10. Como já vimos, na memória do
computador, existe uma variável chamada x e o valor 10 seria armazenado dentro da variável.
Quando o comando Console.Write(x) é executado, o valor de x, que está na memória do
computador, é exibido pelo comando no vídeo.
FAAr – Faculdades Associadas de Ariquemes

Algoritmo 7

using System;
class Program
{
static void Main()
{
int x;
x = 10;
Console.Write("Valor de x= {0}", x);
}
}

Vídeo:

Valor de x = 10

Esse trecho permite a exibição de uma mensagem e do conteúdo de uma variável na tela do
computador. Ao executar o comando Console.Write() o valor entre aspas {0} será substituído pelo
valor do primeiro parâmetro passado ao comando, no caso pelo valor da variável x.
Prof. Cleyton Ferrari – cleytonferrari@hotmail.com – (69) 9975-0504
Algoritmo e Programação de Computadores 31

Algoritmo 8

using System;
class Program
{
static void Main()
{
int x;
x = 10;
Console.Write("Valor de x= {0}", x+1);
}
}

Vídeo:

Valor de x = 11

Esse trecho é bem parecido com o anterior. O conteúdo da variável x é copiado da memória e
acrescido de um, sendo impresso, após a string, no lugar de {0}, sem alterar o valor de x na
memória.

7.2 Comando de Entrada


FAAr – Faculdades Associadas de Ariquemes

É o comando que permite que o usuário digite dados, possibilitando um “diálogo com o
computador”. O dado digitado é armazenado temporariamente em um registrador e, depois,
copiado para a posição de memória indicada no comando. Lembre-se de que o nome de uma
variável representa uma posição na memória.

nome de uma variável = Console.ReadLine();

Exemplo:

using System;
class Program
{
static void Main()
{
string nome = "";
Console.Write("Digite seu Nome: ");
nome = Console.ReadLine(); //Lê-se: leia um valor para a
variavel nome
Console.Write("Seu Nome é: {0}",nome);
}
}
Prof. Cleyton Ferrari – cleytonferrari@hotmail.com – (69) 9975-0504
Algoritmo e Programação de Computadores 32

O que faz o computador?


O computador fica “esperando” o usuário digitar um dado; neste exemplo, um nome qualquer. A
variável nome, tendo sido declarada como string, recebe o valor informado pelo usuário.

Observe o algoritmo a seguir que envolve a maioria das funções numéricas:

Algoritmo 9

using System;
class Program
{
static void Main()
{
string c, c1, d, d1;
Console.Write("\n Digite palavra 1: ");
c = Console.ReadLine();
Console.Write("\n Digite palavra 2: ");
c1 = Console.ReadLine();
Console.Write("\n tamanho da 1 palavra: {0}", c.Length);
Console.Write("\n concatenando sem armazenar: {0}", c + c1);
d = c;
Console.Write("\n o conteúdo de d: {0}", d);
d1 = c + c1;
Console.Write("\n concatenação: {0}", d1);
Console.Write("\n primeiro caractere: {0}", c.Substring(0, 1));
FAAr – Faculdades Associadas de Ariquemes

Console.Write("\n último caractere: {0}", c1.Substring(c1.Length - 1, 1));


Console.Write("\n todos menos o primeiro: {0}", d1.Substring(1));
Console.Write("\n o terceiro elemento: {0}", c.Substring(3, 1));// 4º caracter
Console.Write("\n os três primeiros elementos: {0}", c.Substring(0, 3));
Console.Write("\n os três últimos elementos: {0}", c1.Substring(c1.Length - 3, 3));
}
}

Vídeo:

Digite palavra 1: TESTANDO

Digite palavra 2: UAL

tamanho da 1 palavra: 8
concatenando sem armazenar: TESTANDOUAL
o conteúdo de d: TESTANDO
concatenação: TESTANDOUAL
primeiro caractere: T
último caractere: L
todos menos o primeiro: ESTANDOUAL
o terceiro elemento: T
os três primeiro elementos: TES
os três últimos elementos: UAL
Prof. Cleyton Ferrari – cleytonferrari@hotmail.com – (69) 9975-0504
Algoritmo e Programação de Computadores 33

Observe que o usuário digitou TESTANDO para o valor da primeira palavra que foi armazenado na
variável c, depois foi solicitado que o usuário digita-se a segunda palavra, no caso, UAL, que foi
armazenado na variável c1, imprimiu na tela o tamanho da primeira palavra armazenada em c,
concatenou c com c1 sem armazenar em nenhuma variável e imprimiu na tela, copiou o conteúdo
de c para a variável d, imprimiu na tela o conteúdo de d, concatenou c e c1 e armazenou em d1, e
imprimiu na tela o valor de d1, imprimiu o primeiro caractere da variável c, o último da c1, todos
menos o primeiro da d1, o terceiro elemento da variável c, que neste caso é T, pois a função
Substring() começa a contar da posição zero, depois, imprimiu os três primeiros elementos de c,
os três últimos elementos de d1.

7.3 Só Reforçando
 Todas as palavras reservadas são escritas com letras minúsculas.
 O Operador de atribuição deverá ser formado pelo sinal =
 Os identificadores (nome do algoritmo e das variáveis deverão começar por uma letra ou
algarismo).
 Os comandos: Write(), ReadLine(), atribuição e as declaração de variáveis terminam com ;

7.4 Lista de Exercícios


Os exercícios seguem em anexo a apostila.
FAAr – Faculdades Associadas de Ariquemes
Prof. Cleyton Ferrari – cleytonferrari@hotmail.com – (69) 9975-0504
Algoritmo e Programação de Computadores 34

8 Estruturas de Seleção

8.1 Conceitos
Nossos algoritmos até agora seguiram um mesmo padrão: entrava-se com dados, estes eram
processados e alguma informação era mostrada na tela.
Dessa forma, o computador mais parecia uma máquina de calcular. O aprendizado de novos
conceitos, como a estrutura de seleção, nos dará uma visão maior da complexidade de tarefas que
ele poderá executar.

Vamos refletir sobre a importância dessa estrutura, lendo com atenção as afirmativas a seguir:
A. Distribuição gratuita de cestas básicas.
B. Distribuição gratuita de cestas básicas para famílias com 4 ou mais componentes.
C. Distribuição gratuita de ingressos para o teatro, sendo dois para pessoas do sexo feminino e
um para pessoas do sexo masculino.
Se observarmos essas afirmativas pode concluir que:
 Na primeira, todas as pessoas recebem a cesta básica, o que equivaleria a um comando
seqüencial.
FAAr – Faculdades Associadas de Ariquemes

 Na segunda, só recebem as cestas básicas as famílias com pelo menos quatro integrantes.
 Na terceira, dependendo do sexo, recebe-se um ou dois ingressos.
Assim, podemos avaliar a importância do teste nas duas últimas afirmativas, pois ações diferentes
são executadas de acordo com o resultado.

Vejamos alguns exemplos:


Imaginemos que algumas pessoas não gostem de chupar bala de Morango, neste caso o algoritmo
para chupar uma bala seria:
“CHUPAR UMA BALA”
 Pegar a bala
 A bala é de morango?
o Se sim, não chupe a bala
o Se não, continue com o algoritmo
 Retirar o papel
 Chupar a bala
 Jogar o papel no lixo
Agora veremos como fica o Algoritmo “CHUPAR BALA” utilizando diagrama de blocos
Prof. Cleyton Ferrari – cleytonferrari@hotmail.com – (69) 9975-0504
Algoritmo e Programação de Computadores 35

Chupar Bala
FAAr – Faculdades Associadas de Ariquemes

Outro exemplo do nosso dia-a-dia: Imagine-se diante de um caixa eletrônico e suponha que sua
senha seja 1234.

Na tela aparece a mensagem: Digite sua Senha: |


O cursor ( | ) fica piscando:
Você digita os algarismos da sua senha 1234 1233
Neste momento, a Unidade Aritmética e Lógica (um dos VÁLIDA INVÁLIDA
componentes da CPU) verifica se os números que você digitou são
iguais a 1234.
Caso tenha sido, aparece na tela a mensagem: VÁLIDA; mas se você
digitou algo diferente, aparece na tela a mensagem: INVÁLIDA.

Conceito: é uma estrutura de controle de fluxo, executando um ou vários comandos se a condição


testada for verdadeira e, em alguns casos, executando um ou vários comandos se for falsa.
Prof. Cleyton Ferrari – cleytonferrari@hotmail.com – (69) 9975-0504
Algoritmo e Programação de Computadores 36

Sintaxes

8.1.1 Seleção Simples

if (condição)
{
comando ; ou
< seqüência de comandos separados por ; >
}

A sintaxe acima representa à afirmativa B, pois se a família tiver, no mínimo, quatro componentes,
recebe a cesta básica; mas se a família tiver menos que quatro componentes não recebem nada.

8.1.2 Seleção Composta

if (condição)
{
comando ; ou
< seqüência de comandos separados por ; >
}
FAAr – Faculdades Associadas de Ariquemes

else
{
comando ; ou
< seqüência de comandos separados por ; >
}
A sintaxe acima representa à afirmativa C onde, dependendo do sexo, recebe-se um ou dois
convites.
Observações

 Podemos constatar que esta estrutura faz parte do nosso cotidiano:


o Se eu não tiver prova, vou à festa; senão vou estudar.
o Se eu tiver aumento, troco de carro; senão espero o 13º Salário.
o Se minha média for maior ou igual a sete, passo direto; senão vou à prova final.
 A única coisa diferente é a forma como iremos escrevê-la, pois as chaves { e } são
obrigatórias uma vez que delimitam os comandos que pertencem a cada bloco, assim como
os parênteses ( e ) que delimitam a condição.
 Essa é uma estrutura muito importante em algoritmos porque nos dá a possibilidade de
verificar o que foi digitado pelo usuário ou qual o conteúdo de uma variável após um
processamento etc.
Prof. Cleyton Ferrari – cleytonferrari@hotmail.com – (69) 9975-0504
Algoritmo e Programação de Computadores 37

8.1.3 Analisando cada linha do IF


1ª linha: if (condição)
Condição
 A condição é uma expressão lógica testa pela Unidade Aritmética e Lógica, devolvendo
como resposta: verdadeiro ou falso.
Convém aqui recordar os operadores relacionais e os operadores lógicos:

Operadores Usaremos Operadores Lógicos


Relacionais
Igual == Conjunção (e) &&

Diferente != Disjunção (ou) ||

Maior > Negação (não) !

Menor que <


Maior ou Igual a >=
Menor ou Igual a <=
FAAr – Faculdades Associadas de Ariquemes

a) A condição pode ser uma simples expressão relacional formada de dois operandos do
mesmo tipo e de um operador relacional ( >, <, >=, <=, == e !=).
A>B lê-se: o conteúdo da variável A é maior que o conteúdo da variável B?
A < 12 lê-se: o conteúdo da variável A é menor do que 12?
resp != “S” lê-se: o conteúdo da variável resp é diferente da letra S.
resp == “BRASIL” lê-se: o conteúdo da variável resp é igual a BRASIL?
b) A condição pode ser uma expressão lógica formada de pelo menos duas expressões
relacionais que precisarão ser unidas por um dos operadores lógicos (&& ou ||)
A >= 1 && A < 9 lê-se: o conteúdo da variável A é maior ou igual a 1 e
menor que 0?
resp == “S” || resp == “s” lê-se: o contudo da variável resp é igual a S ou igual a s?

Você deve estar perguntado: e os parênteses, não são necessários?


Não, porque as operações aritméticas têm maior prioridade, depois as relacionas e por último as
lógicas, mas, cuidado, nem todas as linguagens agem dessa maneira.
Você deverá ter uma atenção especial quando unir vários operadores lógicos para fazer seus testes.
Veremos isso mais adiante.
2ª linha: {
Indica o início do bloco caso a condição testada seja verdadeira.
Prof. Cleyton Ferrari – cleytonferrari@hotmail.com – (69) 9975-0504
Algoritmo e Programação de Computadores 38

3ª linha: comando ; ou <seqüência de comandos separados por ; >


Nesta parte, são relacionados os comandos que serão executados caso a condição seja verdadeira.

4ª linha: }
Indica o fim do bloco caso a condição testada seja verdadeira.

5ª linha: else
Este comando faz parte da estrutura do se e só deverá ser usado quando pelo menos uma ação tiver
de ser executada se a condição testada for falsa.

6ª linha: {
Indica o início do bloco caso a condição testada seja falsa.

7ª linha: comando ; ou <seqüência de comandos separados por ; >


Nesta parte, são relacionados os comandos que serão executados caso a condição seja falsa.

3ª linha: }
FAAr – Faculdades Associadas de Ariquemes

Indica o fim do bloco caso a condição testada seja falsa.

8.1.4 A execução do comando IF


1. Primeiro, a condição é avaliada pela Unidade Aritmética e Lógica sendo a condição uma
expressão que possa retornar um valor lógico (verdadeiro ou falso).
2. Se o valor retornado for verdadeiro, todos os comandos que se encontram entre o primeiro
par de chaves serão executados; após a execução dos comandos, o fluxo do algoritmo passa
para o primeiro comando depois do fechamento do bloco else, representado pelo símbolo }
(se existir; caso contrário, será executado o primeiro comando depois de } do próprio bloco.
3. Se o valor retornado for falso, todos os comandos que se encontram entre o primeiro par de
chaves serão ignorados e, se existir o comando else, serão executados os comandos que se
encontrarem entre o segundo par de chaves; caso contrário, nada acontecerá e o fluxo do
algoritmo seguirá para o próximo comando.
Prof. Cleyton Ferrari – cleytonferrari@hotmail.com – (69) 9975-0504
Algoritmo e Programação de Computadores 39

8.1.5 Alguns exemplos


Ler um número e se ele for maior do que 20, então imprimir a metade do número.

Algoritmo 10

using System;
class Program
{
static void Main(string[] args)
{
double numero = 0;
Console.Write("Digite um número: ");
numero = double.Parse(Console.ReadLine());
if (numero > 20)
{
Console.WriteLine("Metade: {0}", numero/2);
}
}
}
Vídeo:

Digite um número: 40
FAAr – Faculdades Associadas de Ariquemes

Metade: 20.0

Algoritmo 11

using System;
class Program
{
static void Main(string[] args)
{
double numero = 0;
Console.Write("Digite um número: ");
numero = double.Parse(Console.ReadLine());
if (numero % 2 == 0)
{
Console.WriteLine("PAR");
}
else
{
Console.WriteLine("IMPAR");
}
}
}
Prof. Cleyton Ferrari – cleytonferrari@hotmail.com – (69) 9975-0504
Algoritmo e Programação de Computadores 40

Vídeo:

Digite um número: 24
PAR

Digite um número: 25
IMPAR

8.2 IFs aninhados (encaixados)


Muitas vezes, em algumas aplicações, sentiremos a necessidade de tomar outras decisões dentro de
uma das alternativas da estrutura do if; a isso chamamos de ifs aninhados.
Vejamos um exemplo clássico de algoritmos:

Algoritmo 12

Armazene e imprima na variável max o maior número entre 3 informados.


using System;
class Program
{
static void Main(string[] args)
{
FAAr – Faculdades Associadas de Ariquemes

double a, b, c, max = 0;
Console.Write("Digite primeiro número: ");
a = double.Parse(Console.ReadLine());
Console.Write("Digite segundo número: ");
b = double.Parse(Console.ReadLine());
Console.Write("Digite terceiro número: ");
c = double.Parse(Console.ReadLine());
if ( a > b)
{
if (a > c)
{ max = a; }
else
{ max = c; }
}
else
{
if (b > c)
{ max = b; }
else
{ max = c; }
}
Console.WriteLine("O maior número é: {0}", max);
}
}
Prof. Cleyton Ferrari – cleytonferrari@hotmail.com – (69) 9975-0504
Algoritmo e Programação de Computadores 41

Vídeo:

Digite primeiro número: 7


Digite segundo número: 9
Digite terceiro número: 3
O maior número é: 9

Digite primeiro número: 4


Digite segundo número: 2
Digite terceiro número: 6
O maior número é: 6

Algoritmo 13

Ler um número e imprimir se ele é positivo, negativo ou nulo


using System;
class Program
{
static void Main(string[] args)
{
double num = 0;
FAAr – Faculdades Associadas de Ariquemes

Console.Write("Digite um número: ");


num = double.Parse(Console.ReadLine());

if ( num > 0)
{
Console.WriteLine("POSITIVO");
}
else
{
if (num < 0)
{
Console.WriteLine("NEGATIVO");
}
else
{
Console.WriteLine("NULO");
}
}
}
}
Prof. Cleyton Ferrari – cleytonferrari@hotmail.com – (69) 9975-0504
Algoritmo e Programação de Computadores 42

Vídeo:

Digite um número: -5
NEGATIVO
Digite um número: 4
POSITIVO
Digite um número: 0
NULO

Você deve estar fazendo algumas perguntas:


1. Porque não se perguntou se o número era igual a zero?
Resposta: Quando temos a possibilidade de três respostas, só precisamos fazer duas
perguntas, pois a segunda pergunta nos dá as duas últimas respostas. Veja bem: se
descartarmos a possibilidade de o número ser maior do que 0, ficamos com duas
possibilidades: o número ser igual 0 ou menor do que 0; dessa forma, uma pergunta é
satisfatória.
2. Mas se eu fizer estarei errado(a)?
Resposta: Não, mas não é necessário, e lembre-se de uma coisa em algoritmos existem
muitas maneiras de resolver o mesmo problema! Cada pessoa tem a sua própria lógica.
3. Por que a solução não poderia ser como a seguir?
using System;
class Program
FAAr – Faculdades Associadas de Ariquemes

{
static void Main(string[] args)
{
double num = 0;
Console.Write("Digite um número: ");
num = double.Parse(Console.ReadLine());
if (num > 0)
{ Console.WriteLine("POSITIVO"); }
if (num < 0)
{ Console.WriteLine("NEGATIVO"); }
if (num == 0)
{ Console.WriteLine("NULO"); }
}
}
Resposta: Esta solução, embora você consiga atingir os objetivos do algoritmo, apresenta um
grande inconveniente: sempre serão executados três testes, mesmo quando já tivermos
classificado o número. Entretanto, na 1ª solução, outro texto só será executado se ainda não
tivermos chegado a uma conclusão sobre o número.
Essa estrutura precisa de vários ciclos para ser executada; portanto, evite usá-la
desnecessariamente.

8.3 Lista de Exercícios


Os exercícios seguem em anexo a apostila.
Prof. Cleyton Ferrari – cleytonferrari@hotmail.com – (69) 9975-0504
Algoritmo e Programação de Computadores 43

9 Alternativa de Múltiplas Escolhas


É uma alternativa para os ses aninhados, deixando o algoritmo com uma estrutura melhor.
A estrutura de decisão de múltiplas escolhas é utilizada para testar, na condição, uma única
expressão, que produz um resultado, ou, então, o valor de uma variável, em que está armazenado
um determinado conteúdo. Compara-se, então, o resultado obtido no teste com os valores
fornecidos em cada cláusula “caso”.
Sintaxe:
switch (expressão)
{
case < rótulo 1 >:
comando1;
break;
case < rótulo 2 >:
comando1;
comando2;
break;
case < rótulo n >:
comando1;
comandoN;
break;
FAAr – Faculdades Associadas de Ariquemes

default:
comando1;
break;
}
Considerações:
1. A expressão é avaliada e o valor será comparado com um dos rótulos.
2. A opção default é opcional.
3. O rótulo será aqui definido com uma constante caracter ou uma constante numérica
inteira, pode ser usada constante caracter com mais de um caracter.
4. A estrutura é muito usada em algoritmos com menus, tornando-os mais claros do que
quando usamos if aninhados.

Algoritmo 14

Escrever um algoritmo que leia um peso na Terra e o número de um planeta e imprima o valor do
seu peso neste planeta. A relação de planetas é dada a seguir juntamente com o valor das
gravidades relativas à Terra:
# gravidade relativa planeta
1 0,37 Mercúrio
2 0,88 Vênus
Prof. Cleyton Ferrari – cleytonferrari@hotmail.com – (69) 9975-0504
Algoritmo e Programação de Computadores 44

3 0,38 Marte
4 2,64 Júpiter
5 1,15 Saturno
6 1,17 Urano

Para calcular o peso no planeta use a fórmula:


Pplaneta * Pterra * gravidade
10

using System;
class Program
{
static void Main(string[] args)
{
int op = 0;
double pterra = 0;
Console.WriteLine("Planetas que podem ser analisados: ");
Console.WriteLine("1 Mercúrio");
Console.WriteLine("2 Vênus");
Console.WriteLine("3 Marte");
Console.WriteLine("4 Júpiter");
Console.WriteLine("5 Saturno");
Console.WriteLine("6 Urano");
FAAr – Faculdades Associadas de Ariquemes

Console.Write("Escolha o planeta a ser analisado: ");


op = int.Parse(Console.ReadLine());
Console.Write("Entre com o peso na Terra: ");
pterra = double.Parse(Console.ReadLine());
switch (op)
{
case 1:
Console.WriteLine("Peso em Mercúrio é: {0:0.00}", (pterra / 10) * 0.37);
break;
case 2:
Console.WriteLine("Peso em Vênus é: {0:0.00}", (pterra / 10) * 0.88);
break;
case 3:
Console.WriteLine("Peso em Marte é: {0:0.00}", (pterra / 10) * 0.38);
break;
case 4:
Console.WriteLine("Peso em Júpiter é: {0:0.00}", (pterra / 10) * 2.64);
break;
case 5:
Console.WriteLine("Peso em Saturno é: {0:0.00}", (pterra / 10) * 1.15);
break;
case 6:
Console.WriteLine("Peso em Urano é: {0:0.00}", (pterra / 10) * 1.17);
break;
default:
Console.WriteLine("Este planeta não pode ser analisado");
break;
}
}
}
Prof. Cleyton Ferrari – cleytonferrari@hotmail.com – (69) 9975-0504
Algoritmo e Programação de Computadores 45

Vídeo:

Planetas que podem ser analisados:


1 Mercúrio
2 Vênus
3 Marte
4 Júpiter
5 Saturno
6 Urano
Escolha o planeta a ser analisado: 5
Entre com o peso na Terra: 71
Peso em Saturno é: 8.165

No exemplo do diagrama de blocos abaixo, é recebido uma variável “Op” e testado seu conteúdo,
caso uma das condições seja satisfeita, é atribuído para a variável titulo a string “Opção X”, caso
contrário é atribuído a string “Opção Errada”.
FAAr – Faculdades Associadas de Ariquemes

9.1 Lista de Exercícios


Os exercícios seguem em anexo a apostila.
Prof. Cleyton Ferrari – cleytonferrari@hotmail.com – (69) 9975-0504
Algoritmo e Programação de Computadores 46

10 Estruturas de repetição: for, while e do-while

10.1 Estrutura do for


Usada quando o número de repetições for conhecido durante a elaboração do algoritmo ou quando
puder ser fornecido durante a execução.
Exemplo: Criar um algoritmo que possa entrar com o a nota de 20 alunos e imprimir a média da
turma.

Símbolo Função

Permite o desvio para um ponto qualquer do


programa.
Desvio

Exemplo:
FAAr – Faculdades Associadas de Ariquemes

O teste da condição será


sempre realizado antes de
qualquer operação.
Enquanto a condição for
verdadeira o processo se
repete

Sintaxe

for ( valor inicial ; <condição> ; <valor do incremento> )


{
Bloco de comandos;
}
Prof. Cleyton Ferrari – cleytonferrari@hotmail.com – (69) 9975-0504
Algoritmo e Programação de Computadores 47

Vamos analisar esta sintaxe:


< valor inicial >; É uma expressão do tipo:
<identificador = <valor inicial>;
Exemplos:
a = 0; A variável a recebe o valor inicial 0.
c = 100; A variável c recebe o valor inicial 100.
x = a.Length -1; A variável x recebe o valor inicial que é igual ao número de caracteres
da variável a menos 1.

< condição >; É uma expressão do tipo:


< identificador > <=, <, > ou >= <valor final >;
Exemplos:
a <= 10; A variável a poderá receber valores enquanto forem menor ou igual a 10.
c >= 2; A variável c poderá receber valores enquanto forem maiores ou iguais a 2.
x >= 0; A variável x poderá receber valores enquanto forem maiores ou iguais a 0.

< valor do incremento > É uma expressão do tipo:


FAAr – Faculdades Associadas de Ariquemes

< identificador > = < identificador > + ou – valor


Exemplos:
a = a + 1; A variável a é incrementada de 1 (contador).
c = c – 2; A variável c é decrementada de 2.
x = x – 1; A variável x é decrementada de 1.

Já vimos que os operadores ++ e -– são equivalentes aos comandos de atribuição quando a variável
é incrementada ou decrementada de 1; por isso, o primeiro e o terceiro exemplos poderiam ser
escritos assim:
a ++; A variável a é incrementada em 1.
x --; A variável x é decrementada de 1.

Observações
a. O identificador tem de ser do tipo int.
b. Os valores iniciais e finais poderão ser constantes numéricas inteiras, funções que retornem
números inteiros ou expressões que retornem números inteiros.
c. O valor que é incrementado ou decrementado da variável poderá ser constante ou outra
variável.
Prof. Cleyton Ferrari – cleytonferrari@hotmail.com – (69) 9975-0504
Algoritmo e Programação de Computadores 48

d. O número de repetições do bloco de comandos será igual ao número de termos da série,


portanto, na maioria das vezes, não importam os valores que a variável que controla a
repetição assumirá.
e. A variável que controla a repetição deverá ser declarada e poderá ser impressa se
precisarmos dela pra numerar uma lista, posicionar etc.
f. A variável que controla a repetição jamais aparecerá num comando de leitura dentro do
bloco de repetição.

Algoritmo 15

Criar um algoritmo que entre com cinco números e imprimir o quadrado de cada número.
using System;
class Program
{
static void Main(string[] args)
{
int c = 0;
int num = 0;
for (c = 1; c <= 5; c++)
{
FAAr – Faculdades Associadas de Ariquemes

Console.Write("Digite o {0}º número: ", c);


num = int.Parse(Console.ReadLine());
Console.WriteLine("quadrado: {0}", num * num);
}
}
}

Vídeo:

Digite o 1º número: 2
4
Digite o 2º número: 4
16
Digite o 3º número: 5
25
Digite o 4º número: 8
64
Digite o 5º número: 12
144

Vamos explicar:
1. Após serem reservadas posições na Memória Principal para as variáveis c e num, é
executado o comando for.
2. O primeiro argumento c = 1 só é executado uma vez antes do loop.
Prof. Cleyton Ferrari – cleytonferrari@hotmail.com – (69) 9975-0504
Algoritmo e Programação de Computadores 49

3. Os comandos Write, ReadLine e WriteLine são executados pela primeira vez.


4. Após }, o comando c++ é executado.
5. O comando c = 5 é executado e enquanto a variável c estiver armazenado um valor menor
ou igual a 5, o bloco se repete; mas, quando o valor ultrapassar 5, como no exemplo 6, o
fluxo do algoritmo passa para o primeiro comando após }.

Algoritmo 16

Criar um algoritmo que imprima todos os números pares no intervalo 1-10


using System;
class Program
{
static void Main(string[] args)
{
int c = 0;
for (c = 2; c <= 10; c = c + 2)
{
Console.WriteLine(c);
}
}
}
FAAr – Faculdades Associadas de Ariquemes

Vídeo:

2
4
6
8
10

Vamos explicar:
1. Após ser reservada uma posição na Memória Principal para a variável c, o comando for é
executado.
2. O primeiro argumento c = 2 só é executado uma vez antes do loop.
3. O comando Console.WriteLine(c); é executado pela primeira vez.
4. Após }, o comando c = c + 2 é executado.
5. O comando c <= 10 é executado e enquanto a variável c estiver armazenando um valor
menor ou igual a 10, o bloco se repete; mas, quando o valor ultrapassar 10, o fluxo do
algoritmo passa para o primeiro comando após }.
6. Nenhuma série tem entrada de dados no bloco de repetição.
Prof. Cleyton Ferrari – cleytonferrari@hotmail.com – (69) 9975-0504
Algoritmo e Programação de Computadores 50

10.2 for dentro de for


Imagine você dando uma volta na Lagoa Rodrigo de Freitas (Rio de Janeiro): passa uma vez pelo
Corte do Cantagalo, uma vez pelo Clube do Flamengo, uma vez pelo Clube Piraquê, uma vez pelos
fundos do Clube Militar; esse trajeto representa seus algoritmos feitos até agora com os comandos
aprendidos.
Imagine que seu preparo físico melhorou e agora você consegue dar três ou cinco voltas ou, quem
sabe, até dez voltas na Lagoa; isso significa que você passara dez vezes pelos mesmos lugares. Esse
exemplo representa a estrutura do Para.
Imagine agora que você, orientado por um profissional especializado passou a dar três voltas na
Lagoa, mas, em frente ao Clube do Flamengo, você fará cinco abdominais. Se, em cada volta você
faz cinco abdominais, ao final, você terá feito 15 abdominais e terá dado três voltas na Lagoa. Isso
representa um Para dentro de um PARA. Acompanhe:
voltaLagoa abdominais
1 1ª volta na Lagoa
1 1º abdominal
2 2º abdominal
3 3º abdominal
4 4º abdominal
5 5º abdominal
6 Quando ia contar o 6º abdominal, PAROU e voltou a correr
2 2ª volta na Lagoa
FAAr – Faculdades Associadas de Ariquemes

1 1º abdominal
2 2º abdominal
3 3º abdominal
4 4º abdominal
5 5º abdominal
6 Quando ia contar o 6º abdominal, PAROU e voltou a correr
3 3ª volta na Lagoa
1 1º abdominal
2 2º abdominal
3 3º abdominal
4 4º abdominal
3 5 5º abdominal
4 6 Quando ia contar o 6º abdominal, PAROU e voltou a correr
6 Quando ia contar a 4ª volta, PAROU e foi para casa
Vejamos como poderíamos representar em algoritmo:

Algoritmo 17

using System;
class Program
{
static void Main(string[] args)
{
Prof. Cleyton Ferrari – cleytonferrari@hotmail.com – (69) 9975-0504
Algoritmo e Programação de Computadores 51

int voltaLagoa = 0;
int abdominais = 0;
for (voltaLagoa = 1; voltaLagoa <= 3; voltaLagoa++)
{
Console.WriteLine("{0}ª volta na Lagoa", voltaLagoa);
for (abdominais = 1; abdominais <= 5; abdominais++)
{
Console.WriteLine("{0}º abdominal", abdominais);
}
}
}
}

Vídeo:

1ª volta na Lagoa
1º abdominal
2º abdominal
3º abdominal
4º abdominal
5º abdominal
2ª volta na Lagoa
1º abdominal
2º abdominal
FAAr – Faculdades Associadas de Ariquemes

3º abdominal
4º abdominal
5º abdominal
3ª volta na Lagoa
1º abdominal
2º abdominal
3º abdominal
4º abdominal
5º abdominal

Você pode observar que, cada vez que chegava em frente ao Clube do Flamengo, começava a conta
a partir do 1 seus abdominais e só parava quando sua próxima contagem fosse 6.

10.3 Lista de Exercícios


Os exercícios seguem em anexo a apostila.

10.4 Estrutura do while


Estrutura recomendada quando o número de repetições for desconhecido, sendo necessária uma
chave (um teste) para interromper a repetição.
É uma estrutura que testa a condição no início, e só repete se a condição for verdadeira.
Prof. Cleyton Ferrari – cleytonferrari@hotmail.com – (69) 9975-0504
Algoritmo e Programação de Computadores 52

Chave, teste ou flag. O que é isto?


Sendo redundante, para sermos bem claros, toda estrutura de repetição repete um conjunto de
comandos várias vezes. A estrutura do for tem uma variável para controlar o número de repetições,
mas a estrutura do while não agrega nenhuma variável contadora e, desta forma, a repetição não
pararia nunca (é quando dizemos: entrou em loop). Para impedir que isto aconteça, é montada
uma expressão condicional, igual à que você utilizou na estrutura do if, para interromper a
repetição. Um número, um caractere ou uma palavra deverá ser utilizado na expressão e passado
para o usuário para que ele possa digitar quando desejar parar.
Simula, com facilidade, a estrutura do do while desde que usemos um comando de atribuição e a
estrutura do for desde que criemos uma variável que terá seu valor incrementado dentro da
estrutura de repetição. É a mais “poderosa” estrutura de repetição.
A variável ou variáveis do teste deverão ter seu valor atribuído através de um comando de leitura
ou de atribuição, antes da estrutura, e dentro da estrutura, na maioria das vezes, como último
comando antes do }.
Sintaxe:
while (condição)
{
< bloco de comando >
}
Nos exemplos a seguir, mostraremos a importância da chave e da inicialização da variável que faz
parte da expressão que controla a repetição.
FAAr – Faculdades Associadas de Ariquemes

Algoritmo 18

using System;
class Program
{
static void Main(string[] args)
{
int num;
while (num > 0)
{
Console.Write("Digite um número: ");
num = int.Parse(Console.ReadLine());
Console.WriteLine("Dobro do Número: {0}", num * 2);
}
}
}
Vídeo:

Fail: Use of unassigned local variable 'num'

Explicando:
A primeira tendência quando aprendemos a estrutura do while é tentar montar o corpo da
repetição da mesma forma que fazíamos com o for.
Prof. Cleyton Ferrari – cleytonferrari@hotmail.com – (69) 9975-0504
Algoritmo e Programação de Computadores 53

Mas tendo em vista que assumiremos que as variáveis não são inicializadas automaticamente,
teremos problema com a estrutura do while.

Como fazer um teste com uma variável que não tem nenhum valor?

Algoritmo 19

using System;
class Program
{
static void Main(string[] args)
{
int num;
Console.Write("Digite um número: ");
num = int.Parse(Console.ReadLine());
while (num > 0)
{
Console.WriteLine("Dobro do Número: {0}", num * 2);
}
}
}
FAAr – Faculdades Associadas de Ariquemes

Vídeo:

Digite um número: 8
Dobro do Número: 16
Dobro do Número: 16
Dobro do Número: 16
Dobro do Número: 16
Dobro do Número: 16
Dobro do Número: 16
Dobro do Número: 16
Dobro do Número: 16
Dobro do Número: 16
Dobro do Número: 16
... Observação: O algoritmo entra em loop

Explicando:
Tendo em vista que nossa experiência anterior falhou, nossa segunda tendência é deslocar a leitura
para fora da estrutura.
Mas, desta vez, teremos outro problema: o algoritmo entra em loop, pois nunca mais atribuímos
valor à variável num. É preciso interromper pressionando < ctrl >+< c >.
Prof. Cleyton Ferrari – cleytonferrari@hotmail.com – (69) 9975-0504
Algoritmo e Programação de Computadores 54

Algoritmo 20

using System;
class Program
{
static void Main(string[] args)
{
int num;
Console.Write("Digite um número: ");
num = int.Parse(Console.ReadLine());
while (num > 0)
{
Console.WriteLine("Dobro do Número: {0}", num * 2);
Console.Write("Digite um número: ");
num = int.Parse(Console.ReadLine());
}
}
}

Vídeo:

Digite um número: 8
Dobro do número: 16
FAAr – Faculdades Associadas de Ariquemes

Digite um número: 45
Dobro do número: 90
Digite um número: 0

Explicando:

Depois de várias tentativas, percebemos que precisaríamos de um comando de leitura para poder
entrar na estrutura do while e um para poder sair.

LEMA: Um comando ReadLine() ( ou de atribuição ) antes do while para entrar na repetição e um


comando ReadLine() ( ou de atribuição ) antes do }, para sair da repetição.
Prof. Cleyton Ferrari – cleytonferrari@hotmail.com – (69) 9975-0504
Algoritmo e Programação de Computadores 55

Algoritmo 21

using System;
class Program
{
static void Main(string[] args)
{
int a;
a = 1;
while ( a <= 5 )
{
Console.WriteLine(a);
a++;
}
}
}

Vídeo:

1
2
3
4
FAAr – Faculdades Associadas de Ariquemes

10.5 Estrutura do ... while


Estrutura recomendada quando o número de repetições for desconhecido, sendo necessária uma
chave (um teste) para interromper a repetição.

Sua diferença em relação ao while é que ela testa ao final, significando que ela executa o trecho
pelo menos uma vez.

Essa estrutura também precisa de uma chave para interromper a repetição.

Muitas pessoas não entendem por que existe essa estrutura se a estrutura do while pode fazer o
que ela faz. Na verdade, tem muito programador que nem faz uso dela e, quando faz, é em
programas que usam menus:
Prof. Cleyton Ferrari – cleytonferrari@hotmail.com – (69) 9975-0504
Algoritmo e Programação de Computadores 56

Exemplo:

Neste caso primeiro são executados


os comandos, e somente depois é
realizado o teste da condição.

Sintaxe:
FAAr – Faculdades Associadas de Ariquemes

do
{
< bloco de comandos >
}
while(condição);

Algoritmo 22

using System;
class Program
{
static void Main(string[] args)
{
int a;
a = 1;
do
{
Console.WriteLine(a);
a++;
}
while (a <= 5);
}
}
Prof. Cleyton Ferrari – cleytonferrari@hotmail.com – (69) 9975-0504
Algoritmo e Programação de Computadores 57

Vídeo:

1
2
3
4
5

Agora veremos com criar um algoritmo que funcione através do menu a seguir:

Algoritmo 23

using System;
class Program
{
static void Main(string[] args)
{
string op, menor, p1, p2, p3, np = "";
int n = 0;
double num = 0;
do
{
FAAr – Faculdades Associadas de Ariquemes

Console.Clear();
Console.WriteLine("MENU – um pouco de tudo");
Console.WriteLine("A – Armazena na variável menor e imprime o nome que
tiver o menor número de caracteres entre três");
Console.WriteLine("B – Gera e imprime uma nova palavra");
Console.WriteLine("C – Calcula e imprime o dobro de um número");
Console.WriteLine("F - Finalizar");
Console.Write("OPÇÃO: ");
op = Console.ReadLine();
if (op == "A" || op == "a")
{
Console.Write("Digite 1ª palavra: ");
p1 = Console.ReadLine();
Console.Write("Digite 2ª palavra: ");
p2 = Console.ReadLine();
Console.Write("Digite 3ª palavra: ");
p3 = Console.ReadLine();
if (p1.Length < p2.Length)
menor = p1;
else
menor = p2;
if (p3.Length < menor.Length)
menor = p3;
Console.WriteLine(menor);
}
else
{
if (op == "B" || op == "b")
{
Console.Write("Digite uma palavra: ");
Prof. Cleyton Ferrari – cleytonferrari@hotmail.com – (69) 9975-0504
Algoritmo e Programação de Computadores 58

p1 = Console.ReadLine();
if (p1.Length > 5)
{
n = p1.Length - 1;
p2 = p1.Substring(0, 1);
p3 = p1.Substring(1, n);
np = p3 + p2;
Console.WriteLine(np);
}
else
Console.WriteLine("UUU" + p1 + "UUU");
}
else
{
if (op == "C" || op == "c")
{
Console.Write("Digite um número: ");
num = double.Parse(Console.ReadLine());
if (num > 0)
Console.WriteLine("Dobro do número: {0}", num * 2);
else
Console.WriteLine("NãoPode!");
}
else
{
if (op == "F" || op == "f")
Console.WriteLine("Programa Finalizado");
FAAr – Faculdades Associadas de Ariquemes

else
Console.WriteLine("Opção Invalida!");
}
}
}
Console.ReadLine();
} while (op != "F" && op != "f");
}
}
Prof. Cleyton Ferrari – cleytonferrari@hotmail.com – (69) 9975-0504
Algoritmo e Programação de Computadores 59

Vídeo:

MENU – um pouco de tudo


A – Armazena na variável menor e imprime o nome que
tiver o menor número de caracteres entre três
B – Gera e imprime uma nova palavra
C – Calcula e imprime o dobro de um número
F – Finaliza
OPÇÃO: A
Digite 1ª palavra: Cleyton
Digite 2ª palavra: Miely
Digite 3ª palavra: Ferrari
Miely

MENU – um pouco de tudo


A – Armazena na variável menor e imprime o nome que
tiver o menor número de caracteres entre três
B – Gera e imprime uma nova palavra
C – Calcula e imprime o dobro de um número
F – Finaliza
OPÇÃO: F
Programa Finalizado
FAAr – Faculdades Associadas de Ariquemes

Dicas:

1. Não use enquanto no lugar do para, só se não tiver alternativa.


2. Na dúvida entre enquanto e faca ... enquanto, use enquanto.
3. Para simular a estrutura do faca ... enquanto, usando a estrutura do enquanto, basta
inicializar a variável da condição com qualquer valor válido.

10.6 Lista de Exercícios


Os exercícios seguem em anexo a apostila.
Prof. Cleyton Ferrari – cleytonferrari@hotmail.com – (69) 9975-0504
Algoritmo e Programação de Computadores 60

11 Estruturas homogêneas: Vetores e Matrizes

11.1 Conceitos Gerais


Apesar de você ter feito uso das estruturas de repetição que lhe permitiram a entrada vários dados,
ainda não foi possível o armazenamento de todos esses dados, de uma vez só, ou não, pois lhe
faltava conhecer a estrutura do vetor.
Um vetor é um arranjo de elementos armazenados na Memória Principal, um após o outro, todos
com o mesmo nome. A idéia é a mesma de uma matriz linha da matemáticas, isto é, várias colunas
e uma linha.
Assumiremos que a primeira posição do vetor é 0 (zero).

2 4 5 8 12 3 56 34
0 1 2 3 4 5 6 7
A[ 2 4 5 8 12 3 56 34 ]

Esse é um vetor de 8 elementos, isto é, tem 8 variáveis, todas com o mesmo nome e diferentes por
sua posição dentro do arranjo que é indicada por um índice.
FAAr – Faculdades Associadas de Ariquemes

Quando se tem somente uma linha, podemos omiti-la e colocar somente a coluna.
A0=2 A1=4 A2=5 A3=8 A4=12 A5=3 A6=56 A7=34
Em algoritmos, representamos da seguinte forma:
A[0]=2 A[1]=4 A[2]=5 A[3]=8 A[4]=12 A[5]=3 A[6]=56 A[7]=34
Para dimensionar um vetor, usamos o seguinte comando na declaração de variáveis:

tipo[] nome = new tipo[ dimensão ]

Onde dimensão, na prática, é o número de elementos:

[5] 5 elementos ( de 0 a 4 )

tipo Poderá ser: int, double ou string


nome Será o que você dará ao vetor dentro das regras para nomear uma variável

No exemplo acima seria:


int[] numero = new int[5]
Prof. Cleyton Ferrari – cleytonferrari@hotmail.com – (69) 9975-0504
Algoritmo e Programação de Computadores 61

Um algoritmo com vetor implica vários trechos para que possa funcionar corretamente. Esses
trechos são independentes.
 TRECHOS DE DIMENSIONAMENTO – já visto anteriormente.
 TRECHO DE ENTRADA DE DADOS
o Normalmente, uma estrutura de repetição.
o Se for a estrutura do for, deverá ter o valor final igual à última posição do vetor -1.
o Se for a estrutura do while ou do while, deverá ter uma variável que será
incrementada e nunca poderá assumir um valor igual ou maior do que a última
posição do vetor.
for (L = 0; L <= < tamanho vetor - 1 >; L++)
{
Console.Write("Digite o {0}º nome: ", L+1);
nomes[L] = Console.ReadLine();
}
o O trecho anterior poderá ser incrementado com outros comandos;
o Nunca deverá ter um comando Write ou WriteLine tendo como argumento o
nomedovetor [L].
o Poderá ter: estrutura de seleção, atribuição, outro for etc.
 TRECHO DE SAÍDA
FAAr – Faculdades Associadas de Ariquemes

o Normalmente, uma estrutura de repetição.


o Se for a estrutura do for, deverá ter o valor final igual à penúltima posição do
vetor.
o Se for a estrutura do while ou do while, deverá ter uma variável que será
incrementada e nunca poderá assumir um valor igual ou maior do que a última
posição do vetor.
for (L = 0; L <= < tamanho vetor - 1 >; L++)
{
Console.WriteLine(nomes[L]);
}
o O trecho acima poderá ser incrementado de outro comandos;
o Poderá ter: estrutura de seleção, atribuição, outro for etc.
Prof. Cleyton Ferrari – cleytonferrari@hotmail.com – (69) 9975-0504
Algoritmo e Programação de Computadores 62

Algoritmo 24

Criar um algoritmo que entre com cinco nomes e imprima uma listagem contendo todos os nomes.
using System;
class Program
{
static void Main(string[] args)
{
int L = 0;
string[] nomes = new string[5];
//trecho de entrada
for (L = 0; L <= 4; L++)
{
Console.Write("Digite o {0}º nome: ", L+1);
nomes[L] = Console.ReadLine();
}
//fim do trecho de entrada
//trecho de saída
for (L = 0; L <= 4; L++)
{
Console.WriteLine(nomes[L]);
}
FAAr – Faculdades Associadas de Ariquemes

//fim do trecho de saída


}
}

Vídeo:

Digite o 1º nome: Cleyton


Digite o 2º nome: Miely
Digite o 3º nome: Anderson
Digite o 4º nome: Luciana
Digite o 5º nome: Juliana
Cleyton
Miely
Anderson
Luciana
Juliana
Prof. Cleyton Ferrari – cleytonferrari@hotmail.com – (69) 9975-0504
Algoritmo e Programação de Computadores 63

Algoritmo 25

Criar um algoritmo que armazene nome e duas notas de 5 alunos e imprima uma listagem contendo
nome, as duas notas e a média de cada aluno.
using System;
class Program
{
static void Main(string[] args)
{
int L = 0;
string[] nomes = new string[5];
double[] pr1 = new double[5];
double[] pr2 = new double[5];
double[] media = new double[5];
//trecho de entrada
for (L = 0; L <= nomes.Length - 1; L++)
{
Console.Write("Digite o {0}º nome: ", L + 1);
nomes[L] = Console.ReadLine();
Console.Write(">>Digite a 1ª nota: ");
FAAr – Faculdades Associadas de Ariquemes

pr1[L] = double.Parse(Console.ReadLine());
Console.Write(">>Digite a 2ª nota: ");
pr2[L] = double.Parse(Console.ReadLine());
media[L] = (pr1[L] + pr2[L]) / 2;
}
//fim do trecho de entrada
//trecho de saída
for (L = 0; L <= nomes.Length - 1; L++)
{
Console.WriteLine("{0} - {1}", L + 1, nomes[L]);
Console.WriteLine("{0:0.00} - {1:0.00} - Média:
{2:0.00}", pr1[L], pr2[L], media[L]);
}
//fim do trecho de saída
}
}
Prof. Cleyton Ferrari – cleytonferrari@hotmail.com – (69) 9975-0504
Algoritmo e Programação de Computadores 64

Vídeo:

Digite o 1º nome: Cleyton


>>Digite a 1ª nota: 9.0
>>Digite a 2ª nota: 10.0
Digite o 2º nome: Miely
>>Digite a 1ª nota: 7.0
>>Digite a 2ª nota: 8.0
Digite o 3º nome: Anderson
>>Digite a 1ª nota: 8.0
>>Digite a 2ª nota: 9.0
Digite o 4º nome: Juliana
>>Digite a 1ª nota: 7.5
>>Digite a 2ª nota: 8.5
Digite o 5º nome: Neto
>>Digite a 1ª nota: 9.0
>>Digite a 2ª nota: 8.0
1 - Cleyton
FAAr – Faculdades Associadas de Ariquemes

9.0 – 10.0 - Média: 9.5


2 - Miely
7.0 – 8.0 - Média: 7.5
3 - Anderson
8.0 – 9.0 - Média: 8.5
4 - Juliana
7.5 – 8.5 - Média: 8.0
5 - Neto
9.0 – 8.0 - Média: 8.5
Prof. Cleyton Ferrari – cleytonferrari@hotmail.com – (69) 9975-0504
Algoritmo e Programação de Computadores 65

11.2 Ordenando Vetores


Compare o elemento que está na 1ª posição com todos os seguintes a ele. Quando for necessário,
troque-o de lugar, fazendo uso da variável aux.
Repita essa operação até que tenha feito todas as comparações.

1ª Fase

1º passo: Se o nome da posição 0 na ordem alfabética vier depois do nome na posição 1, então
inverta-os. Como isso não acontece tudo fica igual.

ANTES DEPOIS
NOMES AUX NOMES
0 JOAO 0 JOAO
1 RUI 1 RUI
2 IVO 2 IVO
3 BIA 3 BIA
4 ANA 4 ANA

2º passo: Se o nome da posição 0 na ordem alfabética vier depois do nome na posição 2, então
inverta-os.
FAAr – Faculdades Associadas de Ariquemes

ANTES DEPOIS
NOMES AUX NOMES
0 JOAO JOAO 0 IVO
1 RUI 1 RUI
2 IVO 2 JOAO
3 BIA 3 BIA
4 ANA 4 ANA

3º passo: Se o nome da posição 0 na ordem alfabética vier depois do nome na posição 3, então
inverta-os.

ANTES DEPOIS
NOMES AUX NOMES
0 IVO IVO 0 BIA
1 RUI 1 RUI
2 JOAO 2 JOAO
3 BIA 3 IVO
4 ANA 4 ANA

4º passo: Se o nome da posição 0 na ordem alfabética vier depois do nome na posição 4, então
inverta-os.
Prof. Cleyton Ferrari – cleytonferrari@hotmail.com – (69) 9975-0504
Algoritmo e Programação de Computadores 66

ANTES DEPOIS
NOMES AUX NOMES
0 BIA BIA 0 ANA
1 RUI 1 RUI
2 JOAO 2 JOAO
3 IVO 3 IVO
4 ANA 4 BIA
 Após essas comparações e trocas, conseguimos colocar na posição 0 o nome ANA.
 Partiremos para a busca do segundo nome da lista.
 Não mais nos preocuparemos com a posição 0.

2ª Fase

1º passo: Se o nome da posição 1 na ordem alfabética vier depois do nome na posição 2, então
inverta-os.

ANTES DEPOIS
NOMES AUX NOMES
0 ANA RUI 0 ANA
1 RUI 1 JOAO
FAAr – Faculdades Associadas de Ariquemes

2 JOAO 2 RUI
3 IVO 3 IVO
4 BIA 4 BIA

2º passo: Se o nome da posição 1 na ordem alfabética vier depois do nome na posição 3, então
inverta-os.

ANTES DEPOIS
NOMES AUX NOMES
0 ANA JOAO 0 ANA
1 JOAO 1 IVO
2 RUI 2 RUI
3 IVO 3 JOAO
4 BIA 4 BIA
Prof. Cleyton Ferrari – cleytonferrari@hotmail.com – (69) 9975-0504
Algoritmo e Programação de Computadores 67

3º passo: Se o nome da posição 1 na ordem alfabética vier depois do nome na posição 4, então
inverta-os.

ANTES DEPOIS
NOMES AUX NOMES
0 ANA IVO 0 ANA
1 IVO 1 BIA
2 RUI 2 RUI
3 JOAO 3 JOAO
4 BIA 4 IVO
 Após essas comparações e trocas, conseguimos colocar na posição 1 o nome BIA.
 Partiremos para a busca do terceiro nome da lista.
 Não mais nos preocuparemos com as posições 0 e 1.

3ª Fase

1º passo: Se o nome da posição 2 na ordem alfabética vier depois do nome na posição 3, então
inverta-os.

ANTES DEPOIS
FAAr – Faculdades Associadas de Ariquemes

NOMES AUX NOMES


0 ANA RUI 0 ANA
1 BIA 1 BIA
2 RUI 2 JOAO
3 JOAO 3 RUI
4 IVO 4 IVO

2º passo: Se o nome da posição 2 na ordem alfabética vier depois do nome na posição 4, então
inverta-os.

ANTES DEPOIS
NOMES AUX NOMES
0 ANA JOAO 0 ANA
1 BIA 1 BIA
2 JOAO 2 IVO
3 RUI 3 RUI
4 IVO 4 JOAO
 Após essas comparações e trocas, conseguimos colocar na posição 2 o nome IVO.
 Partiremos para a busca do quarto nome da lista.
 Não mais nos preocuparemos com as posições 0, 1 e 2.
Prof. Cleyton Ferrari – cleytonferrari@hotmail.com – (69) 9975-0504
Algoritmo e Programação de Computadores 68

4ª Fase

1º passo: Se o nome da posição 3 na ordem alfabética vier depois do nome na posição 4, então
inverta-os.

ANTES DEPOIS
NOMES AUX NOMES
0 ANA RUI 0 ANA
1 BIA 1 BIA
2 IVO 2 IVO
3 RUI 3 JOAO
4 JOAO 4 RUI

Conclusões

 Apesar de termos cinco nomes só tiveram quatro fazes, pois quando comparamos o
penúltimo com o último foi diminuído em cada fase. Isso se explica porque o número de
combinação também estava diminuído, uma vez que diminuía o número de nomes abaixo do
que estava em evidência.
 Vamos tentar montar o trecho de ordenação:
FAAr – Faculdades Associadas de Ariquemes

1ª Linha:
for ( L = 0; L <= 4; L++) Por que de 0 até < 4?
Porque as fases envolveram as buscas das posições 0,
1, 2 e 3.
2ª Linha:
{ Inicia o bloco do para.
3ª Linha:
for ( c = L + 1; c <= 4; c++) Por que de L + 1 até <= 4?
Porque, em cada fase, comparávamos a posição em
evidência com todas as outras posições até a última.
4ª Linha:
{ Inicia o bloco do para.
5ª Linha:
if ( Pense no L como sendo a fase e, em c como sendo
string.CompareOrdinal(nomes[L], uma das etapas da fase.
nomes[c]) > 0)
6ª Linha:
{ Inicia o bloco do se.
7ª Linha / 8ª Linha / 9ª Linha:
aux = nomes[L]; Este trecho permite a troca entre as duas variáveis.
nomes[L] = nomes[c];
nomes[c] = aux;
Prof. Cleyton Ferrari – cleytonferrari@hotmail.com – (69) 9975-0504
Algoritmo e Programação de Computadores 69

10ª Linha:
} Finaliza o bloco do se.
11ª Linha:
} Finaliza o bloco para.
12ª Linha:
} Finaliza o bloco do para.
Programa de Ordenação
using System;
class Program
{
static void Main(string[] args)
{
int L = 0;
int c = 0;
string[] nomes = new string[5];
string aux = "";
//trecho de entrada
for (L = 0; L <= nomes.Length - 1; L++)
{
Console.Write("Digite o {0}º nome: ", L + 1);
nomes[L] = Console.ReadLine();
FAAr – Faculdades Associadas de Ariquemes

}
//fim do trecho de entrada
//trecho de processamento/ORDENAÇÃO
for ( L = 0; L <= 4; L++)
{
for ( c = L + 1; c <= 4; c++)
{
if ( string.CompareOrdinal(nomes[L], nomes[c]) > 0)
{
aux = nomes[L];
nomes[L] = nomes[c];
nomes[c] = aux;
}
}
}
//fim do trecho de processamento
//trecho de saída
for (L = 0; L <= nomes.Length - 1; L++)
{
Console.WriteLine("{0} - {1}", L + 1, nomes[L]);
}
//fim do trecho de saída
}
}
Prof. Cleyton Ferrari – cleytonferrari@hotmail.com – (69) 9975-0504
Algoritmo e Programação de Computadores 70

Algoritmo 26

Criar um algoritmo que armazene cinco nomes em um vetor e depois possa ser digitado um número
que corresponde a uma pessoa imprimir esse nome.
using System;
class Program
{
static void Main(string[] args)
{
int L = 0;
int num = 0;
string[] nomes = new string[5];
for (L = 0; L <= nomes.Length - 1; L++)
{
Console.Write("Digite o {0}º nome: ", L + 1);
nomes[L] = Console.ReadLine();
}
Console.Write("Digite o número da pessoa: ");
num = int.Parse(Console.ReadLine());
while (num < 1 || num > 5)
{
Console.WriteLine("Número fora do intervalo");
FAAr – Faculdades Associadas de Ariquemes

Console.Write("Digite o número da pessoa: ");


num = int.Parse(Console.ReadLine());
}
Console.WriteLine("Nome: {0}", nomes[num - 1]);
}
}

Vídeo:

Digite o 1º nome: Cleyton


Digite o 2º nome: Miely
Digite o 3º nome: Amauri
Digite o 4º nome: Renato
Digite o 5º nome: Juliana
Digite o número da pessoa: 9
Número fora do intervalo
Digite o número da pessoa: 4
Nome: Renato

11.3 Lista de Exercícios


Os exercícios seguem em anexo a apostila.