UITWERKING Tentamen Programmeermethoden 31 maart 2022

OPGAVE 1
a. int maxi (int A[ ], int k) {
     int i, groot = 0;
     for ( i = 1; i <= k; i++ ) { 
       if ( A[i] > A[groot] ) { groot = i; } }//for
     return groot;
   }//maxi
b. void flip (int A[ ], int k) {
     int i, temp;
     for ( i = 0; i <= k/2; i++ ) { // of i < (k+1)/2
       temp = A[i]; A[i] = A[k-i]; A[k-i] = temp; }//for
   }//flip
c. void sorteer (int A[ ], int n) {
     int k, groot;
     for ( k = n-1; k > 0; k-- ) {
       groot = maxi (A,k);
       if ( groot != k ) {
         flip (A,groot); // grootste vooraan
	 flip (A,k);     // en naar achter
       }//if
     }//for
   }//sorteer
d. minimaal 0 (al gesorteerd rijtje)
   maximaal: 2(n-1), bijvoorbeeld voor 10 8 7 9 en 10 8 6 4 2 1 3 5 7 9

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. 4,0 LF 3,1 LF 2,2 LF 1,3 LF 4 LF 21 LF 4,7 LF
   (LF = regelovergang)
c. 4,0 LF 3,1 LF 1,2 LF 3 LF 16 LF 1,15 LF
d. Dan groeit x verschrikkelijk, tot die door INT_MAX heen gaat 
   en waarschijnlijk negatief wordt, en de loop afbreekt. De y is dan
   onveranderd (2). Onderweg krijg je rare karakters te zien
   omdat na de '9' van alles komt. De eerste stap is 10,0, dan 19,1,
   dan 37,2 etcetera.
e. Dan moet er een prototype int don (int x, int y); boven cor
   staan, en moet de tweede parameter van don call by value zijn,
   want -7 is geen l-value (geen variabele).

OPGAVE 3
a. int plaats (int A[ ][n], int k) {
     int i = 1;
     if ( k < 0 || k >= n || A[0][k] != 0 ) { return -1; }//if
     while ( i < m && A[i][k] == 0 ) { j++; }//while
     return i-1;
   }//plaats
b. bool beneden (int A[ ][n]) {
     int i, j;
     for ( i = 1; i < m; i++ ) for ( j = 0; j < n; j++ )
       if ( A[i][j] == 0 && A[i-1][j] != 0 ) { return false; }//if
     return true;
   }//beneden
c. int wie (int A[ ][n]) {
     int i, j, tel1 = 0, tel2 = 0;
     // if ( ! beneden (A) ) { return 0; }//if
     for ( i = 0; i < m; i++ ) for ( j = 0; j < n; j++ )
       if ( A[i][j] == 1 ) { tel1++; }//if
       else if ( A[i][]j == 2 ) { tel2++; }//if
     if ( tel1 == tel2 ) { return 1; }//if
     if ( tel1 == tel2 + 1 ) { return 2; }//if
     return 0;
   }//wie
d. bool vier (int A[ ][n], int p, int q) {
     int tel = 1, j;
     j = q+1; while ( j < n && A[p][j] == A[p][q] ) { tel++; j++; }//while
     j = q-1; while ( j >= 0 && A[p][j] == A[p][q] ) { tel++; j--; }//while
     return ( tel >= 4 );
   }//vier

OPGAVE 4
a. void verwijder (pers* & ingang) {
     pers* weg = ingang; pers* onder;
     if ( ingang != nullptr ) {
       onder = ingang->rest;
       if ( onder != nullptr ) { delete onder; }//if
       ingang = ingang->volg;
       delete weg;
     }//if
   }//verwijder
b. void voegtoe (pers* & ingang, char name, int age) {
     if ( age >= 18 ) {
       pers* nieuw = new pers;
       nieuw->naam = name; nieuw->lt = age;
       nieuw->volg = ingang; ingang = nieuw;
       nieuw->rest = new pers; nieuw = nieuw->rest;
       nieuw->naam = name; nieuw->lt = age;
       nieuw->volg = nullptr; nieuw->rest = nullptr;
     }//if
   }//voegtoe
c. void wisselen (pers* ingang) {
     pers* een; perst* twee; int tempi; char tempc;
     if ( ingang != nullptr && ingang->volg != nullptr 
          && ingang->rest ! nullptr && ingang->volg->rest != nullptr ) {
       een = ingang->rest; twee = ingang->volg->rest;
       tempi = een->lt; een->lt = twee->lt; twee->lt = tempi;
       tempc = een->naam; een->naam = twee->naam; twee->naam = tempc;
     }//if
   }//wisselen
d. Bij a en b gaat doorgaans de ingangspointer veranderen, en moet 
   er een & bij; bij c wijzigt de ingangspointer niet, en hoeft
   het niet --- maar het mag wel.
e. void weggooien (pers* & ingang) {
     pers* loper = ingang; pers* achter = nullptr;
     while ( loper != nullptr ) {
       if ( loper->rest == nullptr ) {
         if ( achter == nullptr ) {
           ingang = loper->volg; delete loper; loper = ingang;
	 }//if
	 else {
           achter->volg = loer->volg; delete loper;
	   loper = achter->volg;
	 }//else
       }//if
       else { achter = loper; loper = loper->volg; )//else
     }//while
   }/weggooien