Nella programmazione, l’algoritmo è caratterizzato da molte direzioni a tutto tondo nella disposizione per affrontare il problema.

Caratteristiche di un algoritmo decente

L’informazione e il rendimento devono essere caratterizzati in modo inequivocabile.

Ogni progressione nel calcolo deve essere chiara e inequivocabile.

dovrebbe essere il migliore tra una vasta gamma di approcci per risolvere un problema.

Un algoritmo non dovrebbe avere un codice PC. Piuttosto, il calcolo dovrebbe essere scritto in modo che, tende ad essere utilizzato in dialetti di programmazione comparabili.

Esempi di algoritmi in programmazione

Scrivere un algoritmo per aggiungere due numeri inseriti dall’utente.

Fase 1: Inizio

Passo 2: Dichiarare le variabili num1, num2 e somma.

Fase 3: leggere i valori num1 e num2.

Fase 4: Aggiungere i numeri 1 e 2 e assegnare il risultato alla somma.

        somma←num1+num2

Passo 5: Visualizzare la somma

Passo 6: Stop

Scrivete un algoritmo per trovare il più grande tra tre diversi numeri inseriti dall’utente.

Fase 1: Inizio

Fase 2: Dichiarare le variabili a,b e c.

Fase 3: leggere le variabili a,b e c.

Passo 4: Se a>b

           Se a>c

              Il numero più grande è il display a.

           Altrimenti

              Il display c è il numero più grande.

        Altrimenti

           Se b>c

              Il display b è il numero più grande.

           Altrimenti

              Il display c è il numero più grande. 

Passo 5: Stop

Scrivere un algoritmo per trovare tutte le radici di un’equazione quadratica ax2+bx+c=0.

Fase 1: Inizio

Passo 2: Dichiarare le variabili a, b, c, D, x1, x2, rp e ip;

Fase 3: Calcolo del discriminante

         D←b2-4ac

Fase 4: Se D≥0

              r1←(-b+√D)/2a

              r2←(-b-√D)/2a

              Visualizzare r1 e r2 come radici.

        Altrimenti    

              Calcolare la parte reale e la parte immaginaria

              rp←b/2a

              ip←√(-D)/2a

              Visualizzare rp+j(ip) e rp-j(ip) come radici

Scrivere un algoritmo per trovare il fattoriale di un numero inserito dall’utente.

Fase 1: Inizio

Fase 2: Dichiarare le variabili n,fattoriale e i.

Passo 3: Inizializzare le variabili

          fattoriale←1

          i←1

Fase 4: leggere il valore di n

Passo 5: Ripetere i passi fino a i=n

     5.1: fattoriale←fattoriale*i

     5.2: i←i+1

Fase 6: Visualizzare il fattoriale

Passo 7: Stop

Scrivere un algoritmo per verificare se un numero inserito dall’utente è primo o no.

Fase 1: Inizio

Fase 2: Dichiarare le variabili n,i,flag.

Passo 3: Inizializzare le variabili

        bandiera←1

        i←2 

Passo 4: Leggere n dall’utente.

Fase 5: Ripetere i passi fino a i<(n/2)

     5.1 Se il resto di n÷i è uguale a 0

            bandiera←0

            Vai al punto 6

     5.2 i←i+1

Passo 6: Se flag=0

           Il display n non è primario

        altro

           Il display n è il primo

Passo 7: Stop

Scrivere un algoritmo per trovare la serie Fibonacci fino al termine≤1000.

Fase 1: Inizio

Passo 2: Dichiarare le variabili first_term,second_term e temp.

Passo 3: Inizializzare le variabili first_term←0 second_term←1

Passo 4: Visualizzazione first_term e second_term

Passo 5: Ripetere i passi fino al secondo_term≤1000

     5.1: temp←secondo_termine

     5.2: secondo_termine←secondo_termine+primo termine

     5.3: primo_termine←temp

     5.4: Visualizzazione secondo_termine

Passo 6: Stop

Perché ogni programmatore dovrebbe imparare ad ottimizzare gli algoritmi

Cosa sono gli Algoritmi?

Casualmente, un calcolo è solo un avviso di passi da compiere per risolvere un problema. Sono fondamentalmente una risposta.

Per esempio, un calcolo che si occupi della questione dei factorials può avere questo aspetto:

Problema: trovare il fattoriale di n

Inizializza fatto = 1

Per ogni valore v nel campo da 1 a n:

    Moltiplicare il fatto per v

fatto contiene il fattoriale di n

Qui l’algoritmo è scritto in inglese. Se fosse scritto in un linguaggio di programmazione, lo chiameremmo invece codice. Qui c’è un codice per trovare fattoriale di un numero in C++.

int factorial(int n) {

    int fatto = 1;

    per (int v = 1; v <= n; v+++) {

        fatto = fatto * n;

    }

    fatto di ritorno;

}

La programmazione riguarda le strutture informative e i calcoli. Le strutture informative sono utilizzate per contenere le informazioni, mentre i calcoli sono utilizzati per affrontare il problema utilizzando tali informazioni.

Le strutture informative e i calcoli (DSA) sperimentano in dettaglio le risposte alle questioni standard e vi danno una conoscenza del fatto che è così produttivo utilizzarle tutte. Allo stesso modo vi mostra lo studio della valutazione della produttività di un calcolo. Questo vi permette di scegliere il meglio delle diverse decisioni.

L’utilizzo di strutture dati e algoritmi rende il codice scalabile

Il tempo è prezioso.

Ipotizziamo che Alice e Bob stiano cercando di occuparsi di una questione di base per trovare il totale dei 1011 numeri normali iniziali. Mentre Bob componeva il calcolo, Alice lo attualizzava dimostrando che è fondamentale quanto condannare Donald Trump.

Algoritmo (di Bob)

Inizializza somma = 0

per ogni numero naturale n nell’intervallo da 1 a 1011 (compreso):

    aggiungi n alla somma

la somma è la tua risposta

Codice (di Alice)

int findSum() {

somma int = 0;

per (int v = 1; <= 10000000000000; v+++) {

somma += v;

}

restituire la somma;

}

Alice e Bob si sentono euforici di poter fabbricare qualcosa di proprio in pochi secondi. Che ne dite se ci intrufoliamo nel loro spazio di lavoro e ci sintonizziamo sulla loro discussione?

Alice: Eseguiamo questo codice e scopriamo il tutto.

Sway: Ho eseguito questo codice qualche istante fa, ma non indica ancora la resa. Che cosa c’è?

Oh no, qualcosa è andato a finire male! Il PC è la macchina più deterministica. Tornare indietro e tentare di farla funzionare di nuovo non servirà a nulla. Quindi dovremmo sezionare cosa c’è in questo semplice codice.

Due delle risorse più significative per un programma per PC sono il tempo e la memoria.

Il tempo impiegato dal PC per eseguire un codice è:

Tempo di esecuzione codice = numero di istruzioni * tempo di esecuzione di ogni istruzione

La quantità di indicazioni si basa sul codice che avete utilizzato, e il tempo impiegato per eseguire ogni codice si basa sulla vostra macchina e sul compilatore.

Per questa situazione, il numero completo di linee guida eseguite (supponiamo x) sarà x = 1 + (1011 + 1) + (1011) + 1, che è x = 2 * 1011 + 3

Dateci la possibilità di accettare che un PC possa eseguire le linee guida y = 108 in un solo secondo (può fluttuare esposto alla disposizione della macchina). Il tempo necessario per eseguire il codice è

Tempo di esecuzione del codice = x/y (più degno di nota di 16 minuti)

E’ possibile migliorare il calcolo con l’obiettivo che Alice e Bob non abbiano bisogno di aspettare 16 minuti ogni volta che eseguono questo codice?

Sono certo che in precedenza avete ipotizzato la tecnica corretta. L’insieme dei primi N numeri caratteristici è dato dalla ricetta:

Intero = N * (N + 1)/2

Il passaggio al codice avrà un aspetto simile a questo:

int sum(int N) {

ritorno N * (N + 1)/2;

}

Questo codice viene eseguito in un’unica guida e completa l’incarico indipendentemente dal suo valore. Dagli la possibilità di essere più degno di nota del numero totale di particelle conosciute dall’umanità. Scoprirà il risultato in un batter d’occhio.

In questo caso, il numero totale di istruzioni eseguite (diciamo x) è x = 1 + (1011 + 1) + (1011) + 1, che è x = 2 * 1011 + 3

Supponiamo che un computer possa eseguire y = 108

Darci la possibilità di accettare che un PC possa eseguire le linee guida y = 108 in un solo secondo (può fluttuare esposto alla configurazione della macchina). Il tempo necessario per eseguire il codice è:

Tempo di esecuzione del codice = x/y (più di 16 minuti)

E’ possibile migliorare il calcolo con l’obiettivo che Alice e Bob non abbiano bisogno di aspettare 16 minuti ogni volta che eseguono questo codice?

Sono certo che in precedenza avete ipotizzato la tecnica corretta. L’insieme dei primi N numeri normali è dato dall’equazione:

Intero = N * (N + 1)/2

Il passaggio al codice avrà un aspetto simile a questo:

int sum(int N) {

ritorno N * (N + 1)/2;

}

Questo codice viene eseguito in un’unica guida e completa l’incarico indipendentemente dal suo valore. Dagli la possibilità di essere più prominente del numero totale di molecole conosciute dall’umanità. Scoprirà il risultato in pochi istanti.

Il tempo necessario per affrontare la questione per questa situazione è di 1/y (che è di 10 nanosecondi). Per coincidenza, la risposta combinata di una bomba nucleare richiede 40-50 ns, il che implica che il vostro programma terminerà efficacemente indipendentemente dal fatto che qualcuno lanci una bomba nucleare sul vostro PC contemporaneamente avete eseguito il vostro codice 🙂

Nota: I computer seguono un paio di linee guida (non 1) per l’incremento e la divisione delle figure. Ho detto 1 solo per semplicità.