In de programmering, het algoritme is veel all-around gekarakteriseerd richtingen in ordening om het probleem aan te pakken.

Kenmerken van een fatsoenlijk algoritme

Informatie en opbrengst moeten ondubbelzinnig worden gekarakteriseerd.

Elke vooruitgang in de berekening zou duidelijk en ondubbelzinnig moeten zijn.

Het algoritme zou de beste moeten zijn onder een breed scala aan benaderingen om een probleem op te lossen.

Een algoritme zou geen PC-code moeten hebben. In plaats daarvan zou de berekening zo moeten worden geschreven dat deze in vergelijkbare programmeerdialecten wordt gebruikt.

Voorbeelden van algoritmen in de programmering

Schrijf een algoritme om twee getallen toe te voegen die door de gebruiker zijn ingevoerd.

Stap 1: Starten

Stap 2: Geef de variabelen num1, num2 en som op.

Stap 3: Lees de waarden num1 en num2 af.

Stap 4: Tel nummer 1 en nummer 2 op en wijs het resultaat toe aan de som.

sum←num1+num2

Stap 5: Weergave van de som

Stap 6: Stop

Schrijf een algoritme om de grootste van de drie verschillende getallen te vinden die door de gebruiker zijn ingevoerd.

Stap 1: Starten

Stap 2: Verklaar de variabelen a,b en c.

Stap 3: Lees de variabelen a,b en c.

Stap 4: Indien a>b

Indien a>c

Toon a is het grootste getal.

Anders

Weergave c is het grootste getal.

Anders

Indien b>c

Weergave b is het grootste getal.

Anders

Weergave c is het grootste getal.

Stap 5: Stop

Schrijf een algoritme om alle wortels van een kwadratische vergelijking ax2+bx+c=0 te vinden.

Stap 1: Begin

Stap 2: Geef de variabelen a, b, c, D, x1, x2, rp en ip op;

Stap 3: Bereken discriminant

D←b2-4ac

Stap 4: Als D≥0

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

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

Toon r1 en r2 als wortels.

Anders

Bereken het reële deel en het denkbeeldige deel

rp←b/2a

ip←√(-D)/2a

Toon rp+j(ip) en rp-j(ip) als wortels

Schrijf een algoritme om de factorial van een door de gebruiker ingevoerd getal te vinden.

Stap 1: Starten

Stap 2: Verklaar de variabelen n,factorial en i.

Stap 3: Initialiseren van variabelen

factorial←1

i←1

Stap 4: Leeswaarde van n

Stap 5: Herhaal de stappen tot i=n

5.1: factorial←factorial*i

5.2: i←i+1

Stap 6: Weergavefactor

Stap 7: Stop

Schrijf een algoritme om te controleren of een door de gebruiker ingevoerd nummer al dan niet prime is.

Stap 1: Starten

Stap 2: Verklaar de variabelen n,i,flag.

Stap 3: Initialiseren van variabelen

flag←1

i←2

Stap 4: Lees n van de gebruiker.

Stap 5: Herhaal de stappen tot i<(n/2)

5.1 Als de rest van n÷i gelijk is aan 0

flag←0

Ga naar stap 6

5.2 i←i+1

Stap 6: Indien vlag=0

Weergave n is niet prime

anders

Weergave n is prime

Stap 7: Stop

Schrijf een algoritme om de Fibonacci-reeks te vinden tot term≤1000.

Stap 1: Begin

Stap 2: Verklaar de variabelen eerste_term,tweede_term en temp.

Stap 3: Initialiseren van variabelen eersteterm←0 tweedeterm←1

Stap 4: Weergave eerste_termijn en tweede_termijn

Stap 5: Herhaal de stappen tot second_term≤1000

5.1: temp←second_termijn

5.2: tweede_term←second_term+eerste termijn

5.3: eerste_term←temp

5.4: Weergave tweede_termijn

Stap 6: Stop

Waarom elke programmeur zou moeten leren om algoritmes te optimaliseren

Wat zijn Algoritmen?

Terloops, een berekening is slechts een mededeling van stappen om een probleem op te lossen. Ze zijn in principe een antwoord.

Bijvoorbeeld, een berekening om de kwestie van de factorialen af te handelen kan er zo uitzien:

Probleem: Zoek de factorial van n

Feit initialiseren = 1

Voor elke waarde v in het bereik van 1 tot n:

Vermenigvuldig het feit met v

feit bevat de factorial van n

Hier is het algoritme in het Engels geschreven. Als het in een programmeertaal was geschreven, zouden we het in plaats daarvan code noemen. Hier is een code voor het vinden van een factorial van een getal in C++.

int factorial(int n) {

int feit = 1;

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

feit = feit * n;

}

terugkeer feit;

}

Programmering gaat over informatiestructuren en berekeningen. Informatiestructuren worden gebruikt om informatie vast te houden, terwijl berekeningen worden gebruikt om het probleem aan te pakken met behulp van die informatie.

Informatiestructuren en berekeningen (DSA) geven antwoorden op standaardvraagstukken in detail en geven u kennis van het feit dat het zo productief is om ze allemaal te gebruiken. Het toont u ook de studie van het beoordelen van de productiviteit van een berekening. Dit stelt u in staat om de beste van de verschillende beslissingen te kiezen.

Gebruik van datastructuren en -algoritmen maken uw code schaalbaar

Tijd is waardevol.

Stel, Alice en Bob proberen een basisprobleem op te lossen, namelijk het vinden van het totaal van de initiële 1011 normale getallen. Terwijl Bob de berekening opstelde, actualiseerde Alice deze om aan te tonen dat deze net zo fundamenteel is als het veroordelen van Donald Trump.

Algoritme (door Bob)

Initialiseer som = 0

voor elk natuurlijk getal n in het bereik van 1 tot en met 1011 (inclusief):

n bij elkaar optellen

som is uw antwoord

Code (door Alice)

int findSum() {

int som = 0;

voor (int v = 1; <= 100000000000; v++) {

som += v;

}

retourbedrag;

}

Alice en Bob voelen zich euforisch dat ze in een paar seconden iets van zichzelf zouden kunnen verzinnen. Wat dacht je ervan om hun werkruimte binnen te sluipen en ons af te stemmen op hun discussie.

Alice: Laten we deze code uitvoeren en het geheel ontdekken.

Sway: Ik heb deze code enkele ogenblikken geleden uitgevoerd, maar het geeft nog steeds niet de opbrengst aan. Wat is er aan de hand?

Oh nee, er is iets slecht uitgepakt! Een PC is de meest deterministische machine. Terugkeren en het opnieuw proberen te draaien zal niet helpen. Dus we moeten ontleden wat er met deze eenvoudige code gebeurt.

Twee van de belangrijkste troeven voor een PC-programma zijn tijd en geheugen.

De tijd die de PC nodig heeft om een code uit te voeren is:

Tijd om code uit te voeren = aantal instructies * tijd om elke instructie uit te voeren

De hoeveelheid aanwijzingen is afhankelijk van de code die u gebruikt, en de tijd die nodig is om elke code uit te voeren is afhankelijk van uw machine en compiler.

Voor deze situatie zal het volledige aantal uitgevoerde richtlijnen (stel dat x) x = 1 + (1011 + 1) + (1011) + 1 zijn, wat x = 2 * 1011 + 3 is.

Geef ons een kans om te accepteren dat een PC y = 108 richtlijnen kan uitvoeren in een enkele seconde (het kan schommelen blootgesteld aan machinale opstelling). De tijd die nodig is om bovenstaande code uit te voeren is

Tijd die nodig is om de code uit te voeren = x/y (meer dan 16 minuten)

Is het denkbaar om de berekening te verbeteren met als doel dat Alice en Bob niet elke keer 16 minuten vast hoeven te zitten als ze deze code uitvoeren?

Ik ben er zeker van dat je eerder hebt gespeculeerd over de juiste techniek. Het geheel van de eerste N-kenmerkgetallen wordt gegeven door het recept:

Geheel = N * (N + 1)/2

Het omzetten in code zal er zoiets als dit uitzien:

int sum(int N) {

terugkeer N * (N + 1)/2;

}

Deze code voert slechts in één keer de opdracht uit, en voltooit de opdracht ongeacht wat de waarde ervan is. Geef het een kans om meer waard te zijn dan het alom bekende aantal deeltjes. Het zal de uitkomst in een oogwenk ontdekken.

In dit geval is het totaal aantal uitgevoerde opdrachten (laten we zeggen x) x = 1 + (1011 + 1) + (1011) + 1, wat x = 2 * 1011 + 3 is.

Laten we aannemen dat een computer y = 108 kan uitvoeren.

Geef ons een kans om te accepteren dat een PC y = 108 richtlijnen kan uitvoeren in een enkele seconde (het kan schommelen blootgesteld aan de machine setup). De tijd die nodig is om bovenstaande code uit te voeren is:

Tijd die nodig is om de code uit te voeren = x/y (meer dan 16 minuten)

Is het denkbaar om de berekening te verbeteren met als doel dat Alice en Bob niet elke keer 16 minuten vast hoeven te zitten als ze deze code uitvoeren?

Ik ben er zeker van dat je eerder hebt gespeculeerd over de juiste techniek. Het geheel van de eerste N normale getallen wordt gegeven door de vergelijking:

Hele = N * (N + 1)/2

Het omzetten in code zal er zoiets als dit uitzien:

int sum(int N) {

terugkeer N * (N + 1)/2;

}

Deze code voert slechts in één keer de opdracht uit, en voltooit de opdracht ongeacht wat de waarde ervan is. Geef het een kans om prominenter te zijn dan het alom bekende aantal moleculen van de mensheid. Het zal de uitkomst in een kwestie van momenten ontdekken.

De tijd die nodig is om het probleem aan te pakken voor deze situatie is 1/j (dat is 10 nanoseconden). Toevallig duurt het combineren van een kernbom 40-50 ns, wat betekent dat je programma effectief zal eindigen, ongeacht of iemand een kernbom op je PC gooit en tegelijkertijd je code uitvoert).

Opmerking: Computers nemen een paar richtlijnen (niet 1) om augmentatie en deling in te schatten. Ik heb alleen gezegd 1 voor rechtdoorzee.