UITWERKING TENTAMEN PROGRAMMEERMETHODEN 4 januari 2023

OPGAVE 1
a. bool pos (int A[ ], int n) {
     int i;
     for ( i = 0; i < n; i++ ) {
       if ( A[i] < 0 ) { return false; }//if
     }//for
     return true;
   }//pos
b. int abso (int x) {
     if ( x < 0 ) { return -x; }//if
     return x;
   }//abso
c. int on (int A[ ], int p, int n) {
     int i, som = 0;
     for ( i = 0; i < n; i++ ) {
       som += ( p - i ) * A[i]; }//for
     return abso (som);
   }//on
d. int best (int A[ ], int n) {
     int p, beste = 0, result = on (A,0,n), kandidaat;
     for ( p = 1; p < n; p++ ) {
       kandidaat = on (A,p,n);
       if ( kandidaat < result ) { result = kandidaat; beste = p; }//if
     }//for
     return beste;
   }//best
e. void sort (int A[ ], int n) {
     int i, j, temp;
     for ( i = 1; i < n; i++ ) {
       for ( j = 0; j < n-i; j++ ) {
         if ( A[j] < A[j+1] ) {
	   temp = A[j]; A[j] = A[j+1]; A[j+1] = temp; }}}
   }//sort
   De functie doet n-1 + n-2 + ... + 2 + 1 = n(n-1)/2 vergelijkingen.

OPGAVE 2
a. Globale variabelen gelden in het gehele programma, en worden helemaal
   bovenin aangemaakt. Locale 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 locale variabele deze
   waarde opvangt, en er met deze locale 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. 11,7 LF 19,7 LF 28,7 LF 4 LF 35 LF 4,8 LF
   (LF = regelovergang)
c. 11,5 LF 3 LF 17 LF 11,6 LF
d. 0,0 (of -2,-2) LF 3 LF 0 (of -4) LF 0,42 (of -2,42) LF
   De "of": als eerst v door lionel met 2 wordt afgelaagd.
   De volgorde bij "+" ligt niet geheel vast.
e. De functie lionel mag de functie kylian alleen aanroepen als er een
   prototype van kylian boven lionel staat. En verder moet de eerste
   parameter van kylian call-by-value zijn: 2 * s is geen l-value.

OPGAVE 3
a. int eind (char M[ ][n]) {
     int i, j, tel = 0;
     for ( j = 0; j < n; j++ ) {
       if ( M[0][j] == '^' ) { tel++; }//if
       if ( M[m-1][j] == 'v' ) { tel++; }//if
     }//for
     for ( i = 0; i < m; i++ ) {
       if ( M[i][0] == '<' ) { tel++; }//if
       if ( M[i][n-1] == '>' ) { tel++; }//if
     }//for
     return tel;
   }//eind
b. bool verboden (char M[ ][n], int & p, int & q) {
     for ( p = 0; p < m; p++ ) for ( q = 0; q < n; q++ ) [
       if ( q < n-1 && M[p][q] == '>' && M[p][q+1] == '<' ) {
         return true; }//if
       if ( p < m-1 && M[p][q] == 'v' && M[p+1][q] == '^' ) {
         return true; }//if
     }//forfor
     p = -1; q = -1; return false;
   }//verboden
c. int volg (char M[ ][n], int i, int j) {
     int tel = 0;
     while ( tel <= m*n && i >= 0 && i < m && j >= 0 && j < n ) {
       tel++;
       if ( M[i][j] == '<') { j--; }//if
       else if M[i][j] == '>' ) { j++; }//if
       else if M[i][j] == '^' ) { i--; }//if
       else { i++; }//else
     }//while
     if ( tel > m*n ) { return -1; } else { return tel; }
   }//volg
d. bool uit (char M[ ][n]) {
     int i, j;
     for ( i = 0; i < m; i++ ) for ( j = 0; j < n; j++ ) [
       if ( volg (M,i,j) >= 2 ) { return true; }//if
     }//forfor
     return false;
   }//uit

OPGAVE 4
a. void verwijder (persoon* & ingang) {
     persoon* weg = ingang;
     if ( ingang != nullptr && ingang->nr == 1 ) {
       ingang = ingang->volg;
       ingang->vorig = nullptr;
       delete weg;
     }//if
   }//verwijder
b. void voegtoe (persoon* & ingang, char name, int verder) {
     persoon* nieuw = new persoon;
     nieuw->vorig = nullptr; nieuw->naam = name; nieuw->nr = verder;
     if ( verder == 0 ) { nieuw->volg = nieuw; }//if
     else { nieuw->volg = ingang; }//else
     ingang->vorig = nieuw; ingang = nieuw;
   }//voegtoe;
c. void wisselen (persoon* ingang) {
     char temp;
     if ( ingang != nullptr && ingang->volg != nullptr ) {
       temp = ingang->naam; ingang->naam = ingang->volg->naam;
       ingang->volg->naam = temp; } //if
   }//wisselen
d. Bij a en b gaat de ingangspointer doorgaans veranderen, dus moet er
   een & bij (call-by-reference). Bij c verandert de ingangspointer niet,
   due hoeft het niet. Het mag wel.
e. void repareer (persoon* ingang) {
     persoon* p = ingang; persoon* q;
     while ( p != nullptr ) {
       q = p->volg; p->volg = nullptr; p->nr = 1;
       while ( q != p ) { p->volg = q; q = q->vorig; }//while
       p = p->volg;
     }//while
   }//repareer