Uitwerking Tentamen Programmeermethoden 23 januari 2026

OPGAVE 1
a. int aantal(int A[], int n, int L, int H) {
     int tel = 0;
     for (int i = 0; i < n; i++) {
       if (A[i] >= L && A[i] <= H) { tel++; }} // if&for
     return tel;
   } // aantal
b. void niet_uniek(int A[], int n) {
     for (int i = 0; i < n; i++) {
       if (aantal(A, n, A[i], A[i]) == 1) { A[i] = 0; }} // if&for
   } // niet_uniek
c. Elke aantal(...) doet maximaal 2n vergelijkingen (als A[i] >= L) en
   we roepen aantal(...) n keer aan. Dus: n * n * 2; allemaal dezelfde
   getallen in A.
d. int getal(int A[], int n) {
     int waarde = 0;
     for (int i = 0; i < n && A[i] >= 0; i++) {
       if (A[i] <= 9) { waarde = waarde * 10 + A[i]; }} // if&for
     return waarde;
   } // getal
e. int langste(int A[], int n, int &s) {
     int tel = 1, lang = 1, som = A[0];
     for (int i = 1; i < n; i++) {
       if (A[i - 1] > A[i]) {
         tel++; som += A[i];
         if (tel >= lang) { lang = tel; s = som; }} // if&if
       else { tel = 1; som = A[i]; }} // else&for
     return lang;
   } // langste

OPGAVE 2
a. Globale variabelen gelden in het gehele programma, en worden helemaal
   bovenin aangemaakt. Lokale variabelen gelden (tijdelijk) alleen in de
   functie waarin ze aangemaakt zijn.
   Variabelen kunnen call by value en call by reference worden meegegeven
   aan een functie. Bij call by value gaat alleen de waarde van de parameter
   naar de functie, alwaar een lokale variabele deze waarde opvangt, en er
   met deze lokale variabele wordt verder gerekend. De oorspronkelijk
   variabele behoudt zijn waarde. Bij call by reference (&) gaat als het ware
   de variabele zelf naar de functie, en kan dan ook blijvend veranderd
   worden. Eigenlijk wordt het adres (de reference) doorgegeven.
   Formeel: in functieheading, bijvoorbeeld x, y in  int f (int x, bool y) {
   Actueel: bij aanroep, bijvoorbeeld r en y in z = f (r,y);
b. 2, 3 en 2026 <LF> 2, 6 en 2026 <LF> 1, 3 en 2
   Hierbij is <LF> een LineFeed (regelovergang).
c. 1, 1 en 26 <LF> 1, 6 en 26 <LF> 1, 1 en 1
d. Er is sprake van indirecte recursie bart roept lisa aan en lisa roept
   bart aan, maar dat heeft niets met de regel x = bart(...) te maken. Of
   iets over de parameter ok die de recursie tegen houdt.
   De tweede parameter van bart en lisa moeten call-by-value zijn, want
   y-z is geen variabele (geen l-value) net als lisa (z-x,x).

OPGAVE 3
a. int tel(bool Z[][n], int i) {
     int teller = 0;
     for (int j = 1; j < n - 1; j++) {
       if (Z[i][j - 1] && !Z[i][j] && Z[i][j + 1]) { teller++; }} // if&for
     return teller;
   } // tel
b. int leeg(bool Z[][n]) {
     for (int j = 0; j < n; j++) {
       bool oke = true;
       for (int i = 0; i < m; i++) {
         if (Z[i][j]) { oke = false; break; }} // if&for
       if (oke) { return j; }} // if&for
     return -1;
   } // leeg
c. int raak(bool Z[][n], int i, int j) {
     if (i < 0 || i >= m || j < 0 || j >= n || !Z[i][j]) { return 0; }
     Z[i][j] = false;
     return 1 + raak(Z, i - 1, j) + raak(Z, i + 1, j) +
                raak(Z, i, j - 1) + raak(Z, i, j + 1);
   } // raak

OPGAVE 4
a. void verwijder(vakje* &ingang) {
     vakje* weg = ingang;
     if (ingang != nullptr && ingang->getal % 3 != 0) {
       ingang = ingang->volg; delete weg;
     } // if
   } // verwijder
b. void wissel(vakje* ingang) {
     int temp; vakje* hulp;
     if (ingang != nullptr && ingang->volg != nullptr &&
          ingang->getal != ingang->volg->getal) {
       temp = ingang->getal; ingang->getal = ingang->volg->getal;
       ingang->volg->getal = temp;
       hulp = ingang->verder; ingang->verder = ingang->volg->verder;
       ingang->volg->verder = hulp;
     } // if
   } // wissel
c. void voegtoe(vakje* &ingang, int gt) {
     vakje* nieuw = new vakje;
     nieuw->getal = gt; nieuw->volg = ingang;
     ingang = nieuw; nieuw = nieuw->volg;
     while (nieuw != nullptr && nieuw->getal != gt) {
       nieuw = nieuw->volg; } // while
     ingang->verder = nieuw;
   } // voegtoe
d. Bij a en c moet de ingangspointer (doorgaans) wijzigen, dus moet er 
   een & bij. Bij b maakt het niet uit, de ingangspointer wijzigt nooit.
e. int hoeveel(vakje* ingang, int gt) {
     int teller = 0; vakje* loper = ingang;
     while (loper != nullptr && loper->getal != gt) {
       loper = loper->volg; } // while
     while (loper != nullptr) {
       loper = loper->verder; teller++; } // while
     return teller;
   } // hoeveel