UITWERKING Tentamen Programmeermethoden NA
16 december 2016


OPGAVE 1

a.

def evenveel(A):
    aantal_pos, aantal_neg = 0, 0

    for getal in A:
        if getal >= 0:
            aantal_pos += 1
        else:
            aantal_neg += 1

    return aantal_pos == aantal_neg

b.

def epo(negpos,A,start):
    for i in range(start, len(A)):
        if negpos and A[i] >= 0:
            return i
        elif not negpos and A[i] < 0:
            return i

    return len(A)

c.

def omenom(A):
    for i in range(len(A)):
        if (i % 2 == 0 and A[i] < 0) or (i % 2 != 0 and A[i] >= 0):
            j = epo(i % 2 == 0, A, i + 1)
            A[i], A[j] = A[j], A[i]

Alternatief waarbij je de check voor het huidige element via epo
laat lopen:

def omenom(A):
    pos = True
    for i in range(len(A)-1):
        j = epo(pos,A,i)
        if i != j:
            A[i], A[j] = A[j], A[i]

        pos ^= 1


d. Een test of een getal positief of negatief is telt als 1
vergelijking tussen getallen. Je komt dan uit op

(n/2-1) + (n/2-2) + ... + 1 + n


e.

def controle(A):
    for i in range(len(A)):
        if i % 2 == 0 and A[i] < 0:
            return False
        elif i % 2 != 0 and A[i] >= 0:
            return False

    return True

Alternatief:

def controle(A):
    pos = True
    for getal in A:
        if pos and getal < 0:
            return False
        elif not pos and getal >= 0:
            return False

        pos ^= 1

    return True

f.

def langste(A):
    langste = 0
    lengte = 1
    som = A[0]

    for i in range(1, len(A)):
        if A[i] >= A[i-1]:
            # daalt niet: rij gaat verder
            lengte += 1
            som += A[i]
        else:
            # reset
            lengte = 1
            som = A[i]

        if lengte >= langste:
            langste = lengte
            gem = som / float(lengte)

    return langste, gem


OPGAVE 2

a.
Globale variabelen gelden in het gehele programma, en worden in de
regel helemaal bovenin aangemaakt.

Locale variabelen gelden (tijdelijk) alleen in de functie waarin ze
aangemaakt zijn.

Formeel: in functieheading, bijvoorbeeld x, y in def f(x, y):

Actueel: bij aanroep, bijvoorbeeld 3 en z in print func(3,z)

b.

S 3 3 2   S 2 6 1   S 1 9 0   S 3 3 2   S 2 6 1   S 1 9 0
1 18 3   18 4 en 2

c.

def dagobert(a, b):
    return (a + b) * (a - 1)

(donald(x, y) levert x * y op, bovenstaande is vereenvoudigd vanuit
(b + 1) * (a - 1) + (a - 1) * (a - 1) ).


d.

In de eerste run wordt de globale variabele x nu op 1 gezet en de
uitvoer "4 en 2" van het print-statement verandert in "1 en 2".

Bij elke volgende aanroep van katrien zal voor de formele parameter a nu
steeds 1 worden ingevuld. Hierdoor zal de loop in de functie donald niet
meer draaien (y is nu immers 0) waardoor iets = 0 wordt geretourneerd. De
uitvoer van de tweede en latere aanroep is nu:

1 0 3
0 1 en 2


OPGAVE 3

a. M[:,4]
b. M[2,4:]
c. M[:,5:]
d. M[2:,::2]
e. np.sum(M, axis=0)


OPGAVE 4

a.

def leeg(S):
    leeg = 0
    for i in range(n):
        for j in range(n):
            if S[i,j] == 0:
                leeg += 1

    return leeg

b.

def okee(S,i):
    hulp = [0] * (n+1)
    for getal in S[i,:]:
        hulp[getal] += 1
        if hulp[getal] > 1:
            return False

    # Er mag geen vakje leeg zijn
    return hulp[0] == 0


c.

# Opmerking: de check of vakje al gevuld is niet verplicht
def invulbaar(S, i, j):
    mogelijkheden = 0
    k = 0
    for kl in reversed(range(1, n+1)):
        ok = True
        # Check rij
        for p in range(n):
            if p != j and S[i,p] == kl:
                ok = False
        # Check kolom
        for p in range(n):
            if p != i and S[p,j] == kl:
                ok = False
        if ok:
            mogelijkheden += 1
            k = kl

    return mogelijkheden, k


d.

def invullen(S):
    aangepast = True
    while aangepast:
        aangepast = False
        for i in range(n):
            for j in range(n):
                if S[i,j] == 0:
                    aantal, kleinste = invulbaar(S,i,j)
                    if aantal > 0:
                        aangepast = True
                        S[i,j] = kleinste

    return leeg(S) == 0