UITWERKING TENTAMEN PROGRAMMEERMETHODEN 17 JANUARI 2024

OPGAVE 1
a. bool hoofd (char kar) {
     return ( 'A' <= kar && kar <= 'Z' );
   }//hoofd
b. bool gelijk (char A[ ], int n) {
     int i;
     for ( i = 0; i < n-1; i++ ) {
       if ( A[i+1] = A[i] - 'a' + 'A' || A[i+1] = A[i] - 'A' + 'a' ) {
	 return true; }}//if&for
     return false;
   }//gelijk
c. int lang (char A[ ], int n, int & begin, int & hoeveel) {
     int i, teller = 0, langste = 0; begin = -1; hoeveel = -1;
     for ( i = 0; i < n; i++ ) {
       if ( A[i] == 'a' || A[i] == 'e' || A[i] == 'i' || A[i] == 'o' 
            || A[i] == 'u' ) {
         teller++;
	 if ( teller == langste ) { hoeveel++; }//if
	 else if ( teller > langste ) { 
	   langste = teller; hoeveel = 1; begin = i - teller + 1; }//if
       }//if
       else { teller = 0; }//else
     }//for
     return langste;
   }//lang
d. void sort (char A[ ], int n) {
     int i, ronde; char temp;
     for ( ronde = 1; ronde < n; ronde++ ) {
       for ( i = 0; i < n - ronde; i++ ) {
         if ( ( ! hoofd (A[i+1]) && hoofd (A[i]) )
	       || ( hoofd (A[i]) == hoofd (A[i+1]) && A[i] > A[i+1] ) ) {
           temp = A[i]; A[i] = A[i+1]; A[i+1] = temp; }//if
     }}//for&for
   }//sort
e. n-1 + n-2 + ... + 3 + 2 + 1 = n(n-1)/2 = O(n^2)

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. 1<LF>0<LF>Bobbie 0<LF>5<LF>2<LF>Bobbie 2<LF>3,0,8<LF>5<LF>3,2,5<LF>
   (hierbij is <LF> een regelovergang)
c. 1<LF>0<LF>Bobbie 0<LF>Bobbie -1<LF>1,3,8<LF>8<LF>1,3,5<LF>
d. Dan moet er een prototype int ernst (int x, int y); boven bobbie
   staan (functies mogen alleen eerder vermelde functies aanroepen),
   en de eerste parameter van ernst moet call-by-value zijn, want 
   42 * y is geen variabele (geen l-value).

OPGAVE 3
a. int top (int W[ ][n]) {
     int i, j, teller = 0;
     for ( i = 0; i < m; i++ ) { for ( j = 0; j < n; j++ ) {
       if ( ( i == 0 || W[i][j] > W[i-1][j] )
	    && ( i == m-1 || W[i][j] > W[i+1][j] )
	    && ( j == 0 || W[i][j] > W[i][j-1] )
	    && ( j == n-1 || W[i][j] > W[i][j+] ) ) { teller++; }//if
     }}//for&for
     return teller;
   }//top
b. bool verboden (int W[ ][n], int & p, int & q) {
     for ( p = 0; p < m; p++ ) { for ( q = 1; q < n; q++ ) {
       if ( W[p][q-1] == W[p][q] ) { return true; }//if
     }}//for&for
     for ( q = 0; q < n; q++ ) { for ( p = 1; p < m; p++ ) {
       if ( W[p-1][q] == W[p][q] ) { return true; }//if
     }}//for&for
     p = -1; q = -1; return false;
   }//verboden
c. int route (int W[ ][n], int i, int j, double & d) {
     int stappen = 0, newi, newj, value, orig = W[i][j]; 
     bool doorgaan = true;
     while ( doorgaan ) {
       doorgaan = false; value = W[i][j];
       if ( i > 0 && W[i-1][j] < value ) { 
         newi = i-1; newj = j; value = W[i-1][j]; doorgaan = true; }//if
       if ( i < m-1 && W[i+1][j] < value ) { 
         newi = i+1; newj = j; value = W[i+1][j]; doorgaan = true; }//if
       if ( j > 0 && W[i][j-1] < value ) { 
         newi = i; newj = j-1; value = W[i][j-1]; doorgaan = true; }//if
       if ( j < n-1 && W[i][j+1] < value ) { 
         newi = i; newj = j+1; value = W[i][j+1]; doorgaan = true; }//if
       if ( doorgaan ) { stappen++; i = newi; j = newj; }//if
     }//while
     if ( stappen != 0 ) { 
       d = ( orig - W[i][j] ) / static_cast<double> (d); }//if 
     return stappen;
   }//route

OPGAVE 4
a. void verwijder (mens* & ingang) {
     mens* weg = ingang;
     if ( ingang != nullptr ) {
       ingang = ingang->volg;
       if ( ingang != nullptr ) {
         if ( ingang->sprong < 0 ) { ingang->ander = ingang; }//if
         if ( ingang->volg != nullptr && ingang->volg->sprong == -2 ) { 
	   ingang->volg->ander = ingang; }//if
       }//if
       delete weg;
     }//if
   }//verwijder
b. void voegtoe (mens* & ingang, char name, int ver) {
     mens* nieuw = new mens; nieuw->naam = name; 
     nieuw->sprong = ver; nieuw->volg = ingang;
     if ( ver <= 0 || ingang == nullptr ) { nieuw->ander = nieuw; }//if
     else { nieuw->ander = ingang; }//else
     ingang = nieuw;
   }//voegtoe
c. void wisselen (mens* ingang) { 
     char temp;
     if ( ingang != nullptr && ingang->sprong % 2 == 1 ) {
       temp = ingang->naam; ingang->naam = ingang->ander->naam; 
       ingang->ander->naam = temp;
     }//if
   }//wisselen
d. Bij a en b moet de ingangspointer (doorgaans) wijzigen, dus moet er 
   een & bij. Bij c maakt het niet uit, de ingangspointer wijzigt nooit.
e. int aantal (mens* ingang) {
     int teller = 0; mens* loper = ingang;
     while ( loper != nullptr ) {
       if ( loper->sprong > 0 && loper->ander->volg != nullptr ) {
         teller += loper->sprong; loper = loper->ander; }//if
       else { teller++; loper = loper->volg; }//else
     }//while
     return teller; }//aantal