Algoritmo e Programação de Computadores

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

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

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

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
9 Alternativa de Múltiplas Escolhas ...................................................................................................... 43
10 Estruturas de repetição: for, while e do-while ................................................................................... 46
10.1 Estrutura do for ........................................................................................................................... 46

10.2 for dentro de for........................................................................................................................... 50
10.4 Estrutura do while ....................................................................................................................... 51
10.5 Estrutura do ... while ................................................................................................................... 55
11 Estruturas homogêneas: Vetores e Matrizes .....................................................................................60
11.1 Conceitos Gerais ..........................................................................................................................60
11.2 Ordenando Vetores ..................................................................................................................... 65

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.
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
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
+ =
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.
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
 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
Saída: São os dados já processados

Analogia com o homem
ENTRADA PROCESSAMENTO SAÍDA
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

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:
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

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
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
Chupar uma Bala Calcular Média de 4 Notas

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.

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:
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:
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)
 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.
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)
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.
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.
= é 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";

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
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.
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.
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:
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
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:
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
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
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.
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.

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:
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.
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.

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.
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
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();
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

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);
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");
sql = sb.ToString();
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!!!");
}
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!!!");
}
}
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.
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.
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
{
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.
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 !!!

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 !!!");
}
}
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.
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.
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

É 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);
}
}
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));
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
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 ;

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.
 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
Chupar Bala
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.
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
}
else
{
comando ; ou
}
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.
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 <=
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.
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: }
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.
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
Metade: 20.0
Algoritmo 11
using System;
class Program
{
{
double numero = 0;
numero = double.Parse(Console.ReadLine());
if (numero % 2 == 0)
{
Console.WriteLine("PAR");
}
else
{
Console.WriteLine("IMPAR");
}
}
}
Vídeo:
PAR
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
{
{
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);
}
}
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
{
{
double num = 0;

num = double.Parse(Console.ReadLine());
if ( num > 0)
{
Console.WriteLine("POSITIVO");
}
else
{
if (num < 0)
{
Console.WriteLine("NEGATIVO");
}
else
{
Console.WriteLine("NULO");
}
}
}
}
Vídeo:
Digite um número: -5
NEGATIVO
POSITIVO
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
{
{
double num = 0;
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.

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;
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
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
{
{
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");
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;
}
}
}
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”.

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:
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;
}
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:

< 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.
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
{
{
int c = 0;
int num = 0;
for (c = 1; c <= 5; c++)
{
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
16
25
64
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.
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
{
{
int c = 0;
for (c = 2; c <= 10; c = c + 2)
{
Console.WriteLine(c);
}
}
}
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.
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
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
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
{
{
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
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.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.
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.
Algoritmo 18
using System;
class Program
{
{
int num;
while (num > 0)
{
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.
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
{
{
int num;
while (num > 0)
{
}
}
}
Vídeo:
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 >.
Algoritmo 20
using System;
class Program
{
{
int num;
while (num > 0)
{
}
}
}
Vídeo:
Dobro do número: 16
Dobro do número: 90
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.
Algoritmo 21
using System;
class Program
{
{
int a;
a = 1;
while ( a <= 5 )
{
Console.WriteLine(a);
a++;
}
}
}
Vídeo:
1
2
3
4
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:
Exemplo:
Neste caso primeiro são executados

os comandos, e somente depois é
realizado o teste da condição.
Sintaxe:
do
{
< bloco de comandos >
}
while(condição);
Algoritmo 22
using System;
class Program
{
{
int a;
a = 1;
do
{
Console.WriteLine(a);
a++;
}
while (a <= 5);
}
}
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
{
{
string op, menor, p1, p2, p3, np = "";
int n = 0;
double num = 0;
do
{
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();
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: ");
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")
{
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");
else
Console.WriteLine("Opção Invalida!");
}
}
}
Console.ReadLine();
} while (op != "F" && op != "f");
}
}
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
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.

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.
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]
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
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.
Algoritmo 24
Criar um algoritmo que entre com cinco nomes e imprima uma listagem contendo todos os nomes.
using System;
class Program
{
{
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);
}
//fim do trecho de entrada
//trecho de saída
for (L = 0; L <= 4; L++)
{
Console.WriteLine(nomes[L]);
}
//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
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
{
{
int L = 0;
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);
Console.Write(">>Digite a 1ª nota: ");
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;
}
//trecho de saída
{
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]);
}
}
}
Vídeo:

>>Digite a 1ª nota: 9.0
Digite o 3º nome: Anderson
Digite o 5º nome: Neto
1 - Cleyton
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
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
inverta-os.
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
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
inverta-os.
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
inverta-os.
ANTES DEPOIS
NOMES AUX NOMES
0 ANA RUI 0 ANA
1 RUI 1 JOAO
2 JOAO 2 RUI
3 IVO 3 IVO
4 BIA 4 BIA
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
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
inverta-os.
ANTES DEPOIS
NOMES AUX NOMES

0 ANA RUI 0 ANA
1 BIA 1 BIA
2 RUI 2 JOAO
3 JOAO 3 RUI
4 IVO 4 IVO
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.
4ª Fase
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:
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;
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
{
{
int L = 0;
int c = 0;
string aux = "";
//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
{
Console.WriteLine("{0} - {1}", L + 1, nomes[L]);
}
}
}
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
{
{
int L = 0;
int num = 0;
{
}
Console.Write("Digite o número da pessoa: ");
while (num < 1 || num > 5)
{
Console.WriteLine("Número fora do intervalo");
Console.Write("Digite o número da pessoa: ");

}
Console.WriteLine("Nome: {0}", nomes[num - 1]);
}
}
Vídeo:

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


Algoritmo e Programação de Computadores

Hochgeladen von

Dokumentinformationen

Originalbeschreibung:

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Algoritmo e Programação de Computadores

Hochgeladen von

Copyright:

Verfügbare Formate

Algoritmo e Programação de Computadores

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

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

1.2 Seqüência Lógica ........................................................................................................................... 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

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

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

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

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

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

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

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

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

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.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.4 Lista de Exercícios ....................................................................................................................... 33

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

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