Algoritmen en Tuinkabouters

• implementeer de functies beneden.
• schrijf er ook telkens testgevallen om te achterhalen of je functie zo werkt als je verwacht.
• probeer het eerst alleen > kijk in de cursus > zoek online een oplossing > vraag je buur > of vraag je leerkracht.

pi = 3.1415926535897932384626433832795028841971  # waarde van de constante "pi"

• schrijf een functie “deg” die hoekwaarden omzet van graden naar radialen.
• maak er de omgekeerde functie “rad” aan en formuleer de algoritme!

def deg(radialen):
    graden = radialen * 180/pi
    return graden

def rad(graden):
    radialen = graden * pi/180
    return radialen

print(deg(pi/2))
print(rad(deg(pi/2)))

90.0
1.5707963267948966

(achtergrond)

• maak een functie “faculteit” die een natuurlijk getal “n” krijgt voor invoer
  • indien het getal 0 of 1 is, geef 1 terug (basisconditie)
  • anders:
  • bereken de “faculteit” van n-1
  • vermenigvuldig het resultaat met n
  • geef de uitkomst terug.

def faculteit(n):

    if (n == 1) or (n == 0):
        # Checking the number is 1 or 0 then return 1
        return 1

    else:
        # otherwise return factorial
        return (n * faculteit(n - 1))

print(faculteit(5))
print(faculteit(20))

120
2432902008176640000

De volgende functie berekent de hoek tussen twee lijnen. Lees de functie en begrijp de stappen: probeer eerst met je eigen symbolen de wiskundige formules op te schrijven.

Formuleer dan de algoritme!

def LineAngle(p1, p2, p3, p4):

    dx1 = p2[0]-p1[0]
    dy1 = p2[1]-p1[1]

    dx2 = p4[0]-p3[0]
    dy2 = p4[1]-p3[1]

    from math import atan2
    ang1 = atan2(dy1, dx1)
    ang2 = atan2(dy2, dx2)

    angle_total = ang2-ang1

    return angle_total

print (deg(LineAngle((0., 0.), (1., 0.), (0., 0.), (-1., -0.5))))

(achtergrond)

• maak een functie “euclid” aan die de afstand berekent tussen twee punten `p1 = (x1, y1)` en `p2 = (x2, y2)`
  • bereken het verschil tussen de punten: d = (x2-x1, y2-y1)
  • neem de elementen van dat verschil tot de macht twee
  • tel de elementen het resultaat samen (som)
  • neem ervan de vierkantewortel
    • (dus, we hebben hier de vierkantswortel van de som van het quadraat van de elementen van het verschil.)
  • geef het resultaat terug.
• bonus voor gevoorderden: aanpassen zo dat er vectoren van grotere dimensie mogelijk zijn, bv. 3D of 4D

(achtergrond)

• schrijf er een functie voor de conversie van een hoek.
  • de functie krijgt dus een hoek “x” binnen (in radialen) en geeft een getal (“float”) terug.
• definieer een “resultaat” dat in het begin gelijk aan de waarde van x is.
• maak er een variable “sign” aan die aanvankelijk de waarde “-1” heeft.
• ga in een “while”-lus, met een loopvariabele “i” die bij 3 begint en voortgaat zolang i kleiner dan 100 is.
  • bereken een tussenresultaat = sign * (x**i)/faculteit(i)
  • tel het resultaat van die tussenberekening bij het resultaat
  • verhoog de loopvariabele om twee
  • vermenigvuldig het “sign” met -1
  • (eind van de lus)
• geef het resultaat terug.

• testen met de volgende getalen (rad): [0., 1., pi/2, pi ]
• bonusvraag: komt je het resultaat bekend voor? Over welke conversie gaat het hier?

(hier een tipp als je helemaal geen idee hebt)

• https://en.wikipedia.org/wiki/Gnome_sort

Dick Grune described the sorting method with the following story:[3]

Gnome Sort is based on the technique used by the standard Dutch Garden Gnome (Du.: tuinkabouter). Here is how a garden gnome sorts a line of flower pots. Basically, he looks at the flower pot next to him and the previous one; if they are in the right order he steps one pot forward, otherwise, he swaps them and steps one pot backward. Boundary conditions: if there is no previous pot, he steps forwards; if there is no pot next to him, he is done.

— “Gnome Sort - The Simplest Sort Algorithm”. Dickgrune.com