558924_Introdução_Revisão

Prévia do material em texto

Algoritmos
DEFINIÇÃO: Algoritmo é uma sequência de passos finitos e 
não ambíguos, com o objetivo de solucionar um problema.
• OBSERVAÇÕES:
• Um algoritmo não é a solucão do problema e sim, uma 
sequência de passos finitos para resolvê-lo ou para chegar à 
conclusão de que não é possível fazê-lo.
• Um problema pode ser resolvido por vários algoritmos.
 
Ex 1: Algoritmo para Fritar um Ovo
ALG – Fritar um Ovo
 1) Pegar frigideira, ovo e óleo.
 2) Colocar óleo na frigideira.
 3) Acender o fogo.
 4) Colocar a frigideira no fogo.
 5) Esperar o óleo esquentar.
 6) Colocar o ovo.
 7) Retirar quando pronto.
FIM
 
Ex 2: Fazer Purê de Batatas
ALG – Fazer Purê de Batatas
 1) Colocar 5 xícaras de água na panela.
 2) Acender o fogo e colocar a panela sobre o fogo.
 3) Pegar 6 batatas médias e descascá-las.
 4) Lavar as batatas e cortá-las ao meio.
 5) Colocar as batatas na água fervendo.
 6) Colocar sal a gosto.
 7) Deixar cozinhar por aproximadamente 20 minutos
 8) Amassar as batatas.
 9) Acrescentar uma xícara de leite aproximadamente (sub-alg)
 10) Acrescentar manteiga e misturar até obter um aspecto cremoso
FIM
 
Características de um bom algoritmo
Simplicidade: Chegar à solução do problema com o menor número de 
passos e com os passos mais simples que se possa.
Objetividade: Envolver somente os pontos necessários à solução do 
problema em questão.
Clareza: Sempre indicar (comentários) o que se está fazendo para que 
outra pessoa possa entender, sem dificuldade. 
Facilidade de Manutenção: Construir o algoritmo de maneira que, 
se um dia for necessário mudar algum detalhe, seja fácil fazê-lo sem 
ter que alterar nada além do que se deseja. (EX: Uso de constantes)
 
Método de Trabalho com Algoritmos
→ Cada algoritmo é completamente inédito para o computador e, 
logicamente, ele deve ser alimentado com todos os detalhes necessários 
à solução do problema. 
→ Sequência aconselhada para desenvolver um bom algoritmo: 
 1) Compreender o problema a resolver
 2) Dividí-lo em passos simples
 3) Escrever um algoritmo para cada passo simples
 4) Encadeá-los de maneira a que, juntos, cheguem à solução do 
problema original. 
→ OBS: Se aprende a programar com os dedos (programando) 
 
Componentes de um Algoritmo
→ Ordens ou Comandos
→ Destinatário (das ordens ou comandos)
→ Capacidade básica do destinatário
• OBSERVAÇÕES:
• Οrdens completas: de completo conhecimento por 
parte do destinatário.
• Algoritmo completo: Aquele em que seu destinatário 
sabe como cumprir com todas as suas ordens. 
 
Algoritmos – Exercício Prático
Autômata Controlado por voz 
 - Comandos Conhecidos: 
 - Inclinar Tronco para frente(Xgraus) - Inclinar Tronco para trás(Xgraus)
 - Erguer Tronco sobre as pernas -Baixar Tronco sobre suporte traseiro
 - Colocar peso do corpo sobre a perna(QPerna)
 - Levar perna à frente() - Unir pernas()
 - VoltarADireita() - VoltarAEsquerda()
 -Estruturas Conhecidas:
 -Repetir (Nvezes) …. Fim_Repetir
 -Repetir Enquanto (Condição) … Fim_Repetir 
 -Se (condição) … então …. [Senão …] Fim_Se
 - Construir Novo Comando: Comando <Nome> Parâmetros <n1,...nu/vazio>
 Fim_Parâmetros
 … …
 Fim_Comando
 - Criar Comandos: Ficar em Pé()
 Sentar()
 VoltarARetaguarda()
 PassosEmFrente(QuantPassos)
 
 
FicarEmPé()
Comando <FicarEmPé> Parâmetros <Vazio> FimParâmetros
 Inclinar Tronco para Frente(45)
 Erguer Tronco sobre as pernas
 Inclinar Tronto para Trás(45) 
Fim_Comando
 
Sentar()
Comando <Sentar> Parâmetros <Vazio> FimParâmetros
 Inclinar Tronco para Frente(45)
 Baixar Tronco sobre suporte traseiro
 Inclinar Tronto para Trás(45) 
Fim_Comando
 
VoltarARetaguarda()
Comando <VoltarARetaguarda> Parâmetros <Vazio> FimParâmetros
 Repetir(2)
 VoltarAEsquerda()
 Fim_Repetir 
Fim_Comando
 
Passos em Frente(QuantPassos)
Comando <PassosEmFrente> Parâmetros <QuantPassos> FimParâmetros
 Colocar peso do corpo sobre a perna(Direita)
 Repetir (QuantPassos)
 Levar perna à frente()
 Colocar peso do corpo sobre a perna(DaFrente)
 Fim_Repetir
 Unir pernas()
Fim_Comando
 
Variáveis (princípios)
1) Um espaço alocado na memória RAM para ser 
utilizada por um ou mais processos que necessitam 
de armazenar ou manipular alguma informação.
2) Representam locais de armazenamento
3) Devem ser declaradas, assim terão um tipo 
associado a elas que determinará que valores 
podem ser armazenados e manipulados.
 
Variáveis(Nomeação)
1) Regras de nomeação: 
 - O nome deve conter letras, números, ou 
caracteres de sublinhado( _ ).
 - Deve conter no máximo 255 caracteres.
 - Pensando sempre em “Facilidade de Manutenção” 
e em “Clareza”, é importante ressaltar que você adote 
um padrão para a declaração dessas variáveis.
 
Variáveis – Declaração (C#)
 
 TIPO <nome> [ = Valor] ;
 Ex 1: int QuantPassos;
 Ex 2: int Qpassos = 3;
Dica: utilize nomes significativos. Não utilize nomes de 
variáveis temporárias, nem reutilize nomes – isso vai fazer o 
código ficar muito confuso!
 
 
Tipos Básicos
1) Inteiro (sem parte decimal)
TIPO DESCRIÇÃO
byte Inteiro de 1 byte sem sinal (0 a 255)
sbyte Inteiro de 1 byte com sinal (-127 a 128)
int Inteiro de 4 bytes com sinal (-2.147.483.648 a 2.147.483.147)
uint Inteiro de 4 bytes sem sinal (0 a 4.294.967.295)
long Inteiro de 8 bytes com sinal (-9.223.372.036.854.775.808 a 9.223.372.036.854.775.807)
ulong Inteiro de 8 bytes sem sinal (0 a 18.446.744.073.709.551.615)
short Inteiro de 2 bytes com sinal (-32.768 a 32.767)
ushort Inteiro de 2 bytes sem sinal (0 a 65.535)
 
Tipos Básicos
2) Ponto Flutuante 
TIPO DESCRIÇÃO
float
double
Ponto flutuante binário de 4 bytes ( ≅ 1.5 x 10 -45 a ≅ 3.4 x 10 38 )
Este tipo tem uma precisão de 7 casas decimais.
 Ponto flutuante binário de 8 bytes ( ≅ 1.5 x 10 -45 a ≅ 1.7 x 10 308 ) 
 Este tipo tem uma precisão de 15 casas decimais.
 
Tipos Básicos
3) Lógico
TIPO DESCRIÇÃO
bool true ou false
 
Tipos Básicos
4) Caracter
 char letra = 'a'; 
 letra = '\x61'; letra = '\u61'; 
 letra = (char)97; 
TIPO DESCRIÇÃO
char Um único caracter unicode de 2 bytes
 
Tipos Básicos
5) String
 string VarNome = “lranaldo”;
 string VarNemail = “ira@hotmail.com”; 
 string VarCaminho = @”c:\temp\nara.txt”;
TIPO DESCRIÇÃO
string Unicode com até 1 GB de caracteres
 
Tipos Básicos
5) String
 string VarNome = “lranaldo”;
 string VarNemail = “ira@hotmail.com”; 
 string VarCaminho = @”c:\temp\nara.txt”;
TIPO DESCRIÇÃO
string Unicode com até 1 GB de caracteres
 
Constantes
Constante é um valor que não se altera 
durante a execução de um programa
Constantes Numéricas: 
 
Sufixo Descrição
l,L Constante tipo Long
u,U Constante tipo Uint
ul,UL Constante tipo Ulong
f, F Constante tipo float
m, M Constante tipo decimal
 
Constantes
Exemplo: Constantes Numéricas
 Console.Writeline(2000L); // long
 Float saldo1 = 1900.0F; // float (decimal)
 Float saldo2 = 7.0e3f // float (exponencial)
 Int limite1 = 0xF; // decimal 15
 
 
 
Constantes
Constantes Simbólicas: valor constante identificado por 
um nome.
 Exemplo:
 const double PI = 3.1415;
 const int limite = 10;
 int[] valores = new int[limite];
 // constante simbólica do tipo string
 const string texto =“Digite seu nome:” ;
 
 
 
 
Arrays
Arrays: coleção de elementos de um 
mesmo tipo em que o acesso a cada 
elemento é feito por meio de índices.
 Arrays Unidimensionais: acesso por um 
único índice.
 Tipo [] nome = new tipo[[n]] ; 
 
Arrays “tipados”
Exemplo:
 var pares = new[] {2,4,6,8}; //do tipo int
 var nomes = new[] {“Roberto”, “Arnalcema”, 
“Paulo”} 
 
 
 
 
 
Arrays
 Public static void Main()
 {
 var pares = new[] { 2, 4, 6, 8, 10, 12, 14, 16, 18, 20 }; // array tipado -> int
 var nomes = new[] { "Arnalberto", "Paulo", "Arnalcema", "Roberto" }; // 
array tipado - string
 int[] val1 = new int[3]; // array inicializado automaticamente.
 double[] val2 = new [] { 154e-1, 1725e-2, 256e-1 };
 
...
...
 }
 
Arrays
Inicialização Automática
TIPO DESCRIÇÃO
numérico(int, float, etc) 0
bool False
char \0
string null
 
Arrays – Ingresso de dados
 ...
Console.Write("Entre com o tamanho do vetor de inteiros: ");
N = long.Parse(Console.ReadLine());
int[] V = new int[N];
for (int i = 0; i < N; i++)
 {
 Console.Write("Ingresse valor para V[{0}]: ", i);
 V[i] = int.Parse(Console.ReadLine());
 }
 ...
 
Arrays – Parâmetro de Método
 ...
public void Exibe(int []V, int N)
 {
 if (N == 1)
 Console.Write(“{0}”,V[0]); // condição de parada
 else { Exibe(V,N-1)
 Console.Write(“ - {0}”,V[N-1]);
 }
 }
 ...
 
Arrays – Passagem de Argumento
public static void Main() {
 Console.Write("Entre com o tamanho do vetor de inteiros: ");
 N = long.Parse(Console.ReadLine());
 int[] V = new int[N];
 for (int i = 0; i < N; i++){
 Console.Write("Ingresse valor para V[{0}]: ", i);
 V[i] = int.Parse(Console.ReadLine());
 }
 Exibe(V,N);
}
 
Arrays Bidimensionais (Matrizes) 
-Comparados a Tabelas
- Acesso por meio de 2 índices.
 Tipo [ , ] nome = new tipo[[n1,n2]] ; 
 
Matrizes - Inicialização
public static void Main() {
...
 // tres formas de declarar inicializando
 int[,] M1 = new int[2, 3] { { 1, 2, 3 }, { 4, 5, 6 } };
 int[,] M2 = new int[,] { { 2, 4, 6 }, { 8, 10, 12 } };
 int[,] M3 = { { 1, 3, 5 }, { 2, 4, 6 } };
...
}
 
Matrizes - Inicialização
...
 // inicializando depois.
 int[,] M4 = new int[3, 3];
 M4[0, 0] = 1;
 M4[0, 1] = 2;
 M4[0, 2] = 3;
 for(int i = 1; i < 3; i++)
 for (int j = 0; j < 3; j++)
 { Console.Write(" Ingresse M4[{0},{1}]: ", i, j);
 M4[i, j] = int.Parse(Console.ReadLine());
 }
...
}
 
Método
- Corresponde às ações a serem 
executadas sobre objetos
- Conjunto de comandos definidos 
em uma Classe ou estrutura.
 
Método
INTERFACE DESCRIÇÃO
void metodo() não retorna valor e não recebe argumento
void metodo(int valor) não retorna valor mas recebe argumento
int metodo() retorna valor mas não recebe argumento
int metodo(int valor) retorna valor e recebe argumento
 
Método – Passagem valor
...
public int Somar(int n1, int n2)
{
 Console.WriteLine("n1: {0} ",n1);
 Console.WriteLine("n2: {0} ",n2);
 n1 += 800;
 Console.WriteLine("Novo valor de n1: {0} ", n1);
 return (n1 + n2);
}
…
 Calcular Obj = new Calcular();
 tot = Obj.Somar(num1, num2);
 
}
 
Método – Passagem referência
...
public int Somar2(ref int n1, ref int n2)
{
 Console.WriteLine("n1: {0} ",n1);
 Console.WriteLine("n2: {0} ",n2);
 n1 += 800;
 Console.WriteLine("Novo valor de n1: {0} ", n1);
 return (n1 + n2);
}
…
 Calcular Obj = new Calcular();
 tot2 = Obj.Somar2(ref num1, ref num2);
 
}
 
Método – Observações
● Somar e Somar2 são métodos definidos na Classe 
Calcular
● Obj é um objeto da classe Calcular, declarado 
assim:
 Calcular Obj = new Calcular();
 
Método – Argumentos nomeados
 static void Main()
 {
 exibe(idade: 35, nome: "Paula", sexo: 'F');
 exibe(sexo: 'M', nome: "Arnalberto", idade: 51);
 exibe("Paulo Roberto", 47, 'M');
 }
 static void exibe(string nome, int idade, char sexo)
 {
 string s = (sexo == 'F') ? "Feminino" : "Masculino";
 Console.WriteLine(" {0} tem {1} anos e é do sexo {2}.", nome, idade, s);
 }
	Slide 1
	Slide 2
	Slide 3
	Slide 4
	Slide 5
	Slide 6
	Slide 7
	Slide 8
	Slide 9
	Slide 10
	Slide 11
	Slide 12
	Slide 13
	Slide 14
	Slide 15
	Slide 16
	Slide 17
	Slide 18
	Slide 19
	Slide 20
	Slide 21
	Slide 22
	Slide 23
	Slide 24
	Slide 25
	Slide 26
	Slide 27
	Slide 28
	Slide 29
	Slide 30
	Slide 31
	Slide 32
	Slide 33
	Slide 34
	Slide 35
	Slide 36
	Slide 37
	Slide 38
	Slide 39