Na programação, o algoritmo é uma grande quantidade de direções em arranjo para resolver o problema.
Características de um algoritmo decente
A informação e o rendimento devem ser caracterizados inequivocamente.
Toda progressão nos cálculos deve ser clara e inequívoca.
O algoritmo deve ser o melhor entre uma ampla gama de abordagens para cuidar de um problema.
Um algoritmo não deve ter código de PC. Ao contrário, o cálculo deve ser escrito de forma que, tende a ser utilizado em dialetos de programação comparáveis.
Exemplos de Algoritmos em Programação
Escreva um algoritmo para adicionar dois números inseridos pelo usuário.
Passo 1: Início
Passo 2: Declare as variáveis num1, num2 e soma.
Passo 3: Leia os valores num1 e num2.
Passo 4: Adicione o num1 e o num2 e atribua o resultado à soma.
sum←num1+num2
Passo 5: Soma de exibição
Passo 6: Parada
Escreva um algoritmo para encontrar o maior entre três números diferentes inseridos pelo usuário.
Passo 1: Início
Passo 2: Declare as variáveis a,b e c.
Passo 3: Leia as variáveis a,b e c.
Passo 4: Se a>b
Se a>c
Exibir a é o maior número.
Senão
O display c é o maior número.
Senão
Se b>c
O display b é o maior número.
Senão
O display c é o maior número.
Passo 5: Parar
Escreva um algoritmo para encontrar todas as raízes de uma equação quadrática ax2+bx+c=0.
Passo 1: Início
Passo 2: Declare as variáveis a, b, c, D, x1, x2, rp e ip;
Passo 3: Calcular discriminante
D←b2-4ac
Passo 4: Se D≥0
r1←(-b+√D)/2a
r2←(-b-√D)/2a
Mostrar r1 e r2 como raízes.
Senão
Calcular parte real e parte imaginária
rp←b/2a
ip←√(-D)/2a
Mostrar rp+j(ip) e rp-j(ip) como raízes
Escreva um algoritmo para encontrar o fatorial de um número inserido pelo usuário.
Passo 1: Início
Passo 2: Declare as variáveis n, factorial e i.
Passo 3: Inicializar variáveis
factorial←1
i←1
Passo 4: Leia o valor de n
Passo 5: Repita os passos até i=n
5.1: factorial←factorial*i
5.2: i←i+1
Passo 6: Exibir fatorial
Passo 7: Parada
Escreva um algoritmo para verificar se um número inserido pelo usuário é prime ou não.
Passo 1: Início
Passo 2: Declare as variáveis n,i,flag.
Passo 3: Inicializar variáveis
flag←1
i←2
Passo 4: Leia n do usuário.
Passo 5: Repita os passos até i<(n/2)
5,1 Se o restante de n÷i for igual a 0
flag←0
Ir para o passo 6
5.2 i←i+1
Passo 6: Se bandeira=0
O visor n não é primo
mais
Display n é prime
Passo 7: Parada
Escreva um algoritmo para encontrar a série Fibonacci até term≤1000.
Passo 1: Início
Passo 2: Declare as variáveis primeiro_term,segundo_term e temporário.
Passo 3: Inicializar variáveis primeiro_term←0 segundo_term←1
Passo 4: Exibir primeiro_terminal e segundo_terminal
Etapa 5: Repita os passos até a segunda_term≤1000
5.1: temp←second_term
5.2: segundo_term←second_term+primeiro prazo
5.3: primeira_term←temp
5.4: Exibir segundo_terminal
Passo 6: Parada
Por que todo programador deve aprender a otimizar algoritmos
O que são Algoritmos?
Casualmente, um cálculo é apenas um aviso de passos para cuidar de um problema. Eles são basicamente uma resposta.
Por exemplo, um cálculo para cuidar da questão dos fatoriais pode parecer algo assim:
Problema: Encontre o fatorial de n
Inicializar o fato = 1
Para cada valor v na faixa de 1 a n:
Multiplique o fato por v
fato contém o fatorial de n
Aqui, o algoritmo é escrito em inglês. Se fosse escrito em uma linguagem de programação, nós o chamaríamos de código. Aqui está um código para encontrar factorial de um número em C++.
int factorial(int n) {\i1}
fato int = 1;
para (int v = 1; v <= n; v++) {
fato = fato * n;
}
fato de retorno;
}
A programação é sobre estruturas de informação e cálculos. As estruturas de informação são utilizadas para conter informações enquanto os cálculos são utilizados para resolver o problema utilizando essas informações.
As estruturas de informação e cálculos (DSA) experimentam respostas para questões padrão em detalhes e lhe dá um conhecimento sobre o fato de que é tão produtivo utilizar cada uma delas. Mostra também o estudo de avaliação da produtividade de um cálculo. Isso permite que você escolha o melhor de diferentes decisões.
Utilização de Estruturas de Dados e Algoritmos Torne seu Código Escalável
O tempo é valioso.
Suponha, Alice e Bob estão tentando cuidar de uma questão básica de encontrar o total de 1011 números normais iniciais. Enquanto Bob estava compondo o cálculo, Alice o atualizou demonstrando que ele é tão básico quanto condenar Donald Trump.
Algoritmo (por Bob)
Inicializar soma = 0
para cada número natural n na faixa de 1 a 1011 (inclusive):
adicionar n à soma
soma é a sua resposta
Código (por Alice)
int findSum() {
int soma = 0;
para (int v = 1; <= 100000000000; v++) {
soma += v;
}
soma de retorno;
}
Alice e Bob estão se sentindo eufóricos de que poderiam fabricar algo próprio em questão de segundos. Que tal entrarmos sorrateiramente no espaço de trabalho deles e nos sintonizarmos com a discussão deles.
Alice: Vamos correr este código e descobrir o todo.
Balançar: Eu corri este código alguns momentos atrás, mas ainda não indica o rendimento. O que há com ele?
Oh não, algo saiu mal! Um PC é a máquina mais determinista. Voltar e tentar rodá-la novamente não vai ajudar. Então devemos dissecar o que está acontecendo com este código simples.
Dois dos ativos mais significativos para um programa de PC são o tempo e a memória.
O tempo que o PC leva para executar um código é:
Tempo para executar código = número de instruções * tempo para executar cada instrução
A quantidade de direções depende do código utilizado, e o tempo necessário para executar cada código depende de sua máquina e compilador.
Para esta situação, o número completo de diretrizes executadas (suponha x) será x = 1 + (1011 + 1) + (1011) + 1, que é x = 2 * 1011 + 3
Nos dê uma chance de aceitar que um PC possa executar y = 108 diretrizes em um único segundo (ele pode flutuar exposto à disposição da máquina). O tempo necessário para executar acima do código é
Tempo de execução do código = x/y (mais notável que 16 minutos)
É possível melhorar o cálculo com o objetivo de que Alice e Bob não precisem ficar pendurados por 16 minutos cada vez que executam este código?
Estou certo de que você já especulou anteriormente a técnica correta. O conjunto dos primeiros N números característicos é dado pela receita:
Entidade = N * (N + 1)/2
Trocá-lo em código será algo parecido com isto:
int sum(int N) {\i1}
retornar N * (N + 1)/2;
}
Este código é executado em apenas uma orientação, e completa a tarefa independentemente do valor. Dá-lhe uma chance de ser mais notável do que o número total de partículas conhecidas pela humanidade. Ele vai descobrir o resultado em um piscar de olhos.
Neste caso, o número total de instruções executadas (digamos x) são x = 1 + (1011 + 1) + (1011) + 1, que é x = 2 * 1011 + 3
Vamos supor que um computador pode executar y = 108
Nos dê uma chance de aceitar que um PC possa executar y = 108 diretrizes em um único segundo (ele pode flutuar exposto à configuração da máquina). O tempo necessário para executar acima do código é:
Tempo gasto para executar código = x/y (mais notável que 16 minutos)
É possível melhorar o cálculo com o objetivo de que Alice e Bob não precisem ficar pendurados por 16 minutos cada vez que executam este código?
Estou certo de que você já especulou anteriormente a técnica correta. A totalidade dos primeiros N números normais é dada pela equação:
Inteiro = N * (N + 1)/2
Trocá-lo em código será algo parecido com isto:
int sum(int N) {\i1}
retornar N * (N + 1)/2;
}
Este código é executado em apenas uma orientação, e completa a tarefa independentemente do valor. Dá-lhe uma chance de ser mais proeminente do que o número total de moléculas conhecidas pela humanidade. Ele vai descobrir o resultado em questão de momentos.
O tempo necessário para enfrentar a questão para esta situação é de 1/y (que é de 10 nanossegundos). Coincidentemente, a resposta combinada de uma bomba nuclear leva 40-50 ns, o que implica que seu programa terminará efetivamente independentemente de alguém jogar uma bomba nuclear no seu PC ao mesmo tempo em que você executou seu código. 🙂
Nota: Os computadores levam um par de diretrizes (e não 1) para calcular o aumento e a divisão. Eu disse 1 apenas para o simples.