Uitwerkingen tentamen Programmeermethoden maandag 6 januari 2014

OPGAVE 1
a. int hoevaak (int A[ ], int X, int n) {
     int i, teller = 0;
     for ( i = 0; i < n; i++ )
       if ( X == A[i] )
         teller++;
     return teller;
   }//hoevaak
b. bool uniek (int A[ ], int n) {
     int i;
     for ( i = 0; i < n; i++ )
       if ( hoevaak (A,A[i],n) > 1 )
         return false;
     return true;
   }//uniek
c. int meest (int A[ ], int n) {
     int i, tel, vaak = A[0], aantal = hoevaak (A,A[0],n);
     for ( i = 1; i < n; i++ ) {
       tel = hoevaak (A,A[i],n);
       if ( tel > aantal || ( tel == aantal && A[i] < vaak ) ) {
         vaak = A[i];
	 aantal = tel;
       }//if
     }//for
     return vaak;
   }//meest
d. void sorteer (int A[ ], int n) {
     int i, j, temp;
     for ( i = 1; i < n; i++ )
       for ( j = 0; j < n-i; j++ )
         if ( hoevaak (A,A[j],n) > hoevaak (A,A[j+1],n) ) {
	   temp = A[j]; A[j] = A[j+1]; A[j+1] = temp; }//if
   }//sorteer
e. 2 ( 1+2+...+n-1) = n (n-1) keer

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,3,6   2,3,8   3,3,11   5,11   4,16
c. 2,3,2   6,3,6   7,7   7,14
d. 2,2   1,4
e. Als n >= 0: s + n(n+1)/2; anders: s
f. Er moet dan een prototype van barbara boven tommy worden gezet,
   en y moet een call-by-value parameter van barbara zijn.

OPGAVE 3
a. bool horbaan (int H[ ][n], int Ax, int Ay, int Bx, int By) {
     int j;
     if ( Ax != Bx || Ay >= By ) return false;
     for ( j = Ay; j < By; j++ )
       if ( H[Ax][j] < H[Ax][j+1] ) return false;
     return true;
   }//horbaan
b. bool maxhorbaan (int H[ ][n], int Ax, int Ay, int Bx, int By) {
     if ( ! horbaan (H,Ax,Ay,Bx,By) ) return false;
     if ( By == n-1 || H[Ax][By] < H[Ax][By+1] ) return true;
     return false;
   }//maxhorbaan
c. int aantal (int H[ ][n], int Ax, int Ay) {
     int teller = 1; bool klaar = false;
     while ( ! klaar ) {
       klaar = true;
       while ( Ay < n-1 && H[Ax][Ay] > H[Ax][Ay+1] ) {
         Ay++; teller++; klaar = false; }//while 
       while ( Ax < m-1 && H[Ax][Ay] > H[Ax+1][Ay] ) {
         Ax++; teller++; klaar = false; }//while
     }//while
     return teller;
   }//aantal

OPGAVE 4
a. void verwijder (klant* & eerste) {
     klant* vor = eerste->voorganger; klant* vol = eerste->opvolger;
     delete eerste; eerste = vol;
     vol->voorganger = vor; vor->opvolger = vol;
   }//verwijder
b. void voegtoe (klant* & eerste, int klantnr) {
     klant* nieuw = new klant;
     nieuw->nummer = klantnr;
     nieuw->opvolger = eerste;
     nieuw->voorganger = eerste->voorganger;
     eerste->voorganger = nieuw; 
     nieuw->voorganger->opvolger = nieuw;
     eerste = nieuw;
   }//voegtoe
c. void wissel (klant* eerste) {
     int temp;
     if ( eerste != NULL && eerste->nummer != eerste->opvolger->nummer 
          && eerste->nummer % 2 == 0 && eerste->opvolger->nummer % 2 == 0 ) {
       temp = eerste->nummer; eerste->nummer = eerste->opvolger->nummer;
       eerste->opvolger->nummer = temp; }//if
   }//wissel
d. Bij a en b moet er een & bij, de ingangspointer gaat immers wijzigen.
   Bij c mag het, maar het hoeft niet. De ingangspointer wijzigt niet.
e. void draaiom (klant* eerste) {
     klant* p = eerste; klant* q;
     if ( eerste == NULL ) return;
     do {
       q = p->opvolger; p->opvolger = p->voorganger; 
       p->voorganger = q; p = q;
     } while ( p != eerste );
   }//draaiom