Uitwerking Tentamen Programmeermethoden 27 maart 2009

OPGAVE 1
a. int larun (int A[ ], int n) {
     int lang = 1, len = 1, i;
     for ( i = 1; i < n; i++ ) {
       if ( A[i] == A[i-1] ) len++;
       else len = 1;
       if ( len > lang ) lang = len;
     }//for
     return lang;
   }//larun
b. bool meer (int A[ ], int n) {
     int i, j;
     for ( i = 1; i < n; i++ )
       if ( A[i] != A[i-1] )
         for ( j = 0; j < i-1; j++ )
	   if ( A[i] == A[j] ) return true;
     return false;
   }//meer
c. void schuif (int A[ ], int n) {
     int i, k = 1;
     for ( i = 1; i < n; i++ )
       if ( A[i] != A[i-1] ) { A[k] = A[i]; k++; }//if
     while ( k < n ) { A[k] = 0; k++; }//while
   }//schuif
d. void sorteer (int A[ ], int n) {
     int ronde, i, temp;
     for ( ronde = 1; ronde < n; ronde++ )
       for ( i = 0; i < n-ronde; i++ )
         if ( A[i] > A[i+1] ) {
	   temp = A[i]; A[i] = A[i+1]; A[i+1] = temp; }//if
   }//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 7 en y in z = f (7,y);
b. 10,7,1  10,7,2  10,7,3  10,7,4  17,7,68  68  17,7,4
c. 10,7,1  3,7,1  3,4,1  3,1,1  2,1,1  1,1,1  1,0,1  1,0,44  44  1,0,0
d. Als er geen &'s staan, verandert doedit niets aan zijn parameters,
   en is dus temp steeds gelijk aan a+b; verder hoogt doedit altijd k op,
   die dus ooit een keer >= 4 wordt.
   Als er wel &'s staan, wordt of v of w kleiner en steeds >= 0, en zal dus 
   a of b een keer 0 worden. 
e. Die is gelijk aan de ggd (grootste gemeenschappelijk deler) van p en q.

OPGAVE 3
a. bool aanvalkoning (int i, int j, int p, int q) { // valt ook zichzelf aan
     return ( i-p <= 1 && p-i <= 1 && j-q <= 1 && q-j <= 1 );
   }//aanvalkoning
b. bool aanvaldame (int i, int j, int p, int q) {
     return ( i == p || j == q || i+j == p+q || i-j == p-q );
   }//aanvaldame
c. bool dame (int schaak[ ][n], int i, int j) {
     int p, q;
     if ( schaak[i][j] != 2 ) return false;
     for ( p = 0; p < m; p++ )
       for ( q = 0; q < n; q++ )
         if ( ( i != p || j != q ) && aanvaldame (i,j,p,q) 
	      && schaak[p][q] != 0 )
	   return false;
     return true;  
   }//dame
d. int aantal (int schaak[ ][n]) {
     int i, j, p, q, teller = 0; bool doorgaan;
     for ( p = 0; p < m; p++ )
       for ( q = 0; q < n; q++ ) {
         doorgaan = true;
         for ( i = 0; i < m && doorgaan; i++ )
	   for ( j = 0; j < n && doorgaan; j++ )
	     if ( ( schaak[i][j] == 2 && aanvaldame (i,j,p,q) ) ||
                  ( schaak[i][j] == 1 && aanvalkoning (i,j,p,q) ) ) {
	       teller++; doorgaan = false; }//if
         }//for
     return teller;
   }//aantal

OPGAVE 4
a. void verwissel (getal* ingang) {
     int temp;
     if ( ingang != NULL ) {  // we mogen weten dat ingang->andere != NULL
       temp = ingang->info; ingang->info = ingang->andere->info;
       ingang->andere->info = temp; 
     }//if
   }//verwissel
b. void toevoegen (getal* & ingang, int cf1, int cf2) {
     getal* nieuw1 = new getal; getal* nieuw2 = new getal;
     nieuw1->info = cf1; nieuw2->info = cf2;
     nieuw1->andere = nieuw2; nieuw2->andere = nieuw1;
     if ( ingang != NULL ) nieuw2->volg = ingang->andere;
     else nieuw2->volg = NULL;
     nieuw1->volg = ingang; ingang = nieuw1;
   }//toevoegen
c. void verwijder (getal* & ingang) {
     getal* weg = ingang;
     if ( ingang != NULL && ingang->info != ingang->andere->info ) {
       ingang = ingang->volg;
       delete weg->andere; delete weg;
     }//if
   }//verwijder
d. Bij b en c kunnen (of moeten) de pointers veranderen, dus moet er een
   & bij. Bij a mag het: de pointer verandert toch niet.
e. void repareer (getal* ingang) {
     getal* loper = ingang;
     while ( loper != NULL ) {
       if ( loper->volg != NULL || loper->andere->volg != NULL )
         if ( loper->volg == NULL )
           loper->volg = loper->andere->volg->andere;
	 else
	   loper->andere->volg = loper->volg->andere;
       loper = loper->volg;
     }//while
   }//repareer