Uitwerking Tentamen Programmeermethoden 6 augustus 1999

1.a. void Wissel (int A[ ], int i, int j) {
       int temp = A[i]; A[i] = A[j]; A[j] = temp; 
     }  // Wissel 
  b. void Bergop (int A[ ], int i) {
       while ( ( i > 0 ) && ( A[i-1] < A[i] ) ) {
         Wissel (A,i-1,i);
	 i--;
       }  // while
     }  // Bergop
  c. void InsertionSort (int A[ ], int n) {
       int i;
       for ( i = 1; i < n; i++ )
         Bergop (A,i);
     }  // InsertionSort
  d. 1 + 2 + 3 + ... + (n-1) = n (n-1) / 2. 
  e. Als toevallig i en j gelijk zijn: n-1 stuks.
     Als i en j verschillen: (n-1) + 2 |i-j| - 1 stuks.
     (Als i of j toevallig 0 is: (n-1) + |i-j| - 1 stuks.)

2.b. 3 0 0   3 6 8 13
  c. 2 0 0   2 2 0 13
  d. Ja (call by value, en de waarde van de functie hangt niet
     af van de volgorde van de argumenten/parameters).
  e. De functie-aanroep ggd2 (r,s) verandert de waarde van zijn 
     parameters: r wordt de GGD van de oorspronkelijke r en s, 
     s wordt 0. Dus zou het antwoord nee kunnen zijn.
     Nu is de GGD van (de GGD van de oude r en s) en 0 toevallig
     weer de GGD van de oude r en s, dus is het antwoord toch ja.
  f. { x = ggd (x,y); y = 0; cout << x << y << 0 << endl; return x; }
  
3.a. int verschillende (char R[m][n], int i) {
       int tel[10]; int j, aantal = 0;
       for ( j = 0; j < 10; j++ ) tel[j] = 0;
       for ( j = 0; j < n; j++ ) tel[(int)R[i][j] - '0'] = 1;
       for ( j = 0; j < 10; j++ ) aantal += tel[j];
       return aantal;
     }  // verschillende
  b. int meest (char R[m][n]) {
       int i, vers, rij = 0, hoeveel = 0;
       for ( i = 0; i < m; i++ ) {
         vers = verschillende (R,i);
	 if ( vers > hoeveel ) { 
	   hoeveel = vers; rij = i; 
	 }  // if
       }  // for
       return rij;
     }  // meest
  c. int telsom (char R[m][n], int i, int j) {
       int som = (int)R[i][j] - '0';
       while ( ( som < 1000 ) && 
         ( i == 0 || j == 0 || (int)R[i-1][j-1] != (int)R[i][j] + 1 ) && 
         ( i == 0 || j == n-1 || (int)R[i-1][j+1] != (int)R[i][j] + 1 ) &&
         ( i == m-1 || j == 0 || (int)R[i+1][j-1] != (int)R[i][j] + 1 ) && 
         ( i == m-1 || j == n-1 || (int)R[i+1][j+1] != (int)R[i][j] + 1 ) ) 
       {
         j++;
	 if ( j == n ) {
	   j = 0; i++;
	   if ( i == m ) i = 0;
	 }  // if
         som += (int)R[i][j] - '0';
       }// while 
       return som;
     }  // telsom

4.a. void hOOFD (Mens* Groep) {
       if ( 'a' <= Groep->naam && Groep->naam <= 'z' )
         Groep->naam = Groep->naam + 'A' - 'a';
       else 
         Groep->naam = Groep->naam + 'a' - 'A';
       if ( Groep->volgende != NULL )
         if ( 'a' <= Groep->volgende->naam && Groep->volgende->naam <= 'z' )
           Groep->volgende->naam = Groep->volgende->naam + 'A' - 'a';
         else 
	   Groep->volgende->naam = Groep->volgende->naam + 'a' - 'A';
     }  // hOOFD
  b. void Verwijder (Mens* & Groep) {
       Mens* temp;
       if ( ( Groep != NULL ) && ( Groep->naam != Groep->verweg->naam ) ) {
         temp = Groep; Groep = Groep->volgende; delete temp;
       }  // if
     }  // Verwijder
  c. void Voegtoe (Mens* & Groep, char naampje, int afstand) {
       Mens* nieuw = new Mens; 
       nieuw->naam = naampje; nieuw->volgende = Groep;
       nieuw->hoever = afstand;
       if ( afstand == 0 ) nieuw->verweg = nieuw;
       else if ( afstand == 1 ) nieuw->verweg = nieuw->volgende;
       else nieuw->verweg = nieuw->volgende->volgende;
       Groep = nieuw;
     }  // Voegtoe
  d. Bij b en c moet er een & bij staan: de pointer Groep kan (bij c zelfs
     zeker) veranderen. Bij a maakt het niet uit: de ingangspointer
     verandert toch niet. Staat er geen & bij, dan wordt er met een lokale
     kopie van Groep gewerkt.
  e. bool Controle (Mens* Groep) {
       int i; bool okee = true;
       Mens* p = Groep; Mens* q;
       while ( p != NULL && okee ) {
         q = p;
	 for ( i = 0; i < p->hoever && q != NULL; i++ )
           q = q->volgende;
	 if ( q != p->verweg )
	   okee = false;
         p = p->volgende;
       }  // while
       return okee;
     }  // Controle