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.