Uitwerking Tentamen Programmeermethoden 4 januari 2021

OPGAVE 1
a. bool stijg (int A[ ], int n) {
     int i;
     for ( i = 0; i < n-1; i++ ) if ( A[i] > A[i+1] ) return false;
     return true;
   }//stijg
b. void extreem (int A[ ], int beg, int eind, int & min, int & max) {
     int i; min = beg; max = beg;
     for ( i = beg + 1; i <= eind; i++ ) {
       if ( A[i] < A[min] ) min = i;
       else if ( A[i] > A[max] ) max = i;
     }//for
   }//extreem
c. Bij een dalend rijtje doet extreem eind-begin vergelijkingen, bij
   een stijgend rijtje 2*(eind-begin).
d. Eerst komt het minimale element vooraan. Als daar het maximale element
   stond (als max == 0), komt dat in A[min], en gaat het dus mis.
   Als M...m --> m...M --> M...m, gaat dus fout
   Als M...m...L --> m...M...L --> L...M...m, ook foute boel
e. void sorteer (int A[ ], int n) {
     int beg, min, max, temp;
     for ( beg = 0; beg < n/2; beg++ ) {
       extreem (A,beg,n-1-beg,min,max);
       temp = A[beg]; A[beg] = A[min]; A[min] = temp;
       if ( max != beg ) { 
         temp = A[n-1-beg]; A[n-1-beg] = A[max]; A[max] = temp; }//if
       else { temp = A[min]; A[min] = A[n-1-beg]; A[n-1-beg] = temp; }//else 
     }//for
   }//sorteer

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. 5,2 LF 5,4 LF 5,6 LF 4,3,5 LF 12,3,5 LF (LF is LineFeed)
c. joe: als r < s: (s-r)*t; anders 0 
   kamala: als 1 <= r < s: (s-r)*r*(r+1)/2; anders 0
   ofwel (s-r)*(1+2+...+r)
d. Variabele a: 5,2 LF 5,0 LF 5,0 LF 5,0 LF 5,0 LF 6,5,5 LF 2,3,5 LF
e. Dan moet er een prototype int kamala (int u, int v); boven joe staan,
   en de eerste parameter (u) van kamala moet call by value zijn,
   evenals de derde (c) van joe (hier staan nu geen l-values).

OPGAVE 3
a. int balans (char B[ ][n]) {
     int bal = 0, i, j;
     for ( i = 0; i < m; i++ )
       for ( j = 0; j < n; j++ )
         if ( 'A' <= B[i][j] && B[i][j] <= 'Z' ) // hoofdletter?
	   bal += B[i][j] - 'A';
	 else
	   bal -= B[i][j] - 'a';
     return bal;
   }//balans
b. bool slaat (char B[ ][n], int i, int j, int p, int q) {
     return ( ( ( i == p && ( j == q - 1 || j == q + 1 ) ) 
                || ( j == q && ( i == p - 1 || i == p + 1 ) ) )
	      && ( 'A' <= B[i][j] && B[i][j] <= 'Z' 
	           && 'a' <= B[p][q] && B[p][q] <= 'z' // kleine letter
	           && B[i][j] - 'A' > B[p][q] - 'a' ) );
   }//slaat
   Of met Booleaanse functie hoofdletter.
c. int besteH (char B[ ][n], int & p, int & q) {
     int beste = 0, i, j, som; p = 0; q = 0;
     for ( i = 0; i < m; i++ ) for ( j = 0; j < n; j++ ) {
       som = 0;
       if ( i > 0 && slaat (B,i,j,i-1,j) ) som += B[i-1][j] - 'a';
       if ( i+1 < m && slaat (B,i,j,i+1,j) ) som += B[i+1][j] - 'a';
       if ( j > 0 && slaat (B,i,j,i,j-1) ) som += B[i][j-1] - 'a';
       if ( j+1 < n && slaat (B,i,j,i,j+1) ) som += B[i][j+1] - 'a';
       // OF: for ( int r = 0; r < m; r++ ) for ( int s = 0; s < n; s++ )
       //       if ( slaat (B,i,j,r,s) ) som += B[r][s] - 'a';
       if ( som > beste ) { beste = som; p = i; q = j; }//if
     }//for
     return beste;
   }//besteH

OPGAVE 4
a. void erbij (object* & ingang, int getal1, int getal2) {
     object* p = new object; object* q = new object;
     p->info = getal1; q->info = getal2;
     p->onder = q; q->onder = p;
     if ( ingang != nullptr ) q->rechts = ingang->onder;
     else q->rechts = nullptr;
     p->rechts = ingang; ingang = p;
   }//erbij
b. void verwijder (object* & ingang) {
     object* weg = ingang;
     if ( ingang != nullptr && ingang->info > 0 
          && ingang->onder->info > 0 ) {
       ingang = ingang->rechts; delete p->onder; delete p; }//if
   }//verwijder
c. void som (object* ingang) {
     if ( ingang != nullptr && ingang->rechts != nullptr 
          && ( ingang->info + ingang->rechts->onder->info ) % 8 == 0 )
     ingang->info += ingang->rechts->onder->info;
   }//som
d. Bij a en b moet de ingangspointer (doorgaans) wijzigen, dus moet er een
   & bij; bij c maakt het niet uit, de ingangspointer wijzigt toch niet.
e. void sorteer (object* ingang) {
     object* p; bool wissel = true; int temp;
     if ( ingang == nullptr ) return;
     while ( wissel ) {
       wissel = false; p = ingang;
       while ( p->rechts != nullptr ) {
         if ( p->info > p->rechts->info ) {
           temp = p->info; p->info = p->info->rechts; 
           p->rechts->info = temp; wissel = true; }//if
         p = p->rechts;
       }//while
     }//wissel
   }//sorteer