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.
