Uitwerking Tentamen Programmeermethoden 27 maart 2025

OPGAVE 1
a. bool zoek (int A[ ], int X, int n) {
     int i;
     for ( i = 0; i < n; i++ ) { if ( X == A[i] ) { return true; }}//if&for
     return false;
   }//zoek
b. int invers (int A[ ], int n) {
     int i, totaal = 0;
     for ( i = 0; i < n-1; i++ ) { if ( A[i] > A[i+1] ) { totaal++; }}//if&for
     return totaal;
   }//invers
c, void drie (int A[ ], int i, int n) {
     int temp;
     if ( A[i] > A[i+1] ) { temp = A[i]; A[i] = A[i+1]; A[i+1] = temp; }//if
     if ( A[i+1] > A[i+2] ) { 
       temp = A[i+1]; A[i+1] = A[i+2]; A[i+2] = temp; }//if
     if ( A[i] > A[i+1] ) { temp = A[i]; A[i] = A[i+1]; A[i+1] = temp; }//if
   }//drie
d. int sort (int A[ ], int n) {
     int i, teller = 0;
     while ( invers (A,n) > 0 ) { // n-1 vergelijkingen per keer
       teller++;
       for ( i = 0; i < n-2; i++ ) drie (A,i,n); 
     }//while
     return teller;
   }//sort
e. Elke invers(...) doet n-1 vergelijkingen, en de for-loop (n-2)*3 stuks.
   En dat n/2 (naar beneden afgerond) keer, dus n/2*{n-1+3*(n-2)} stuks.
   De laatste keer geen for-loop, dus dan alleen n-1.
   Maximaal als het rijtje omgekeerd gesorteerd was.

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. 65,8,4,-1 en 2 <LF> 66,8,5,-1 en 1 <LF> 67,1,2,-1 en 8 <LF> 42,4 en 67
   Hierbij is <LF> een LineFeed (regelovergang).
c. 65,4,4,-1 en 2 <LF> 66,1,1,-1 en 16 <LF> 67,16,2,-1 en 8 <LF> 42,0 en 67
d. Als het call by reference is mag het niet (dan moet er een variabele 
   (l-value) staan op beide plekken). 

OPGAVE 3
a. int kruis (int Zee[ ][n], int i, int j) {
     int teller = 0;
     if ( Zee[i][j] != 0 ) teller++;
     if ( i > 0 && Zee[i-1][j] != 0 ) teller++;
     if ( i < m-1 && Zee[i+1][j] != 0 ) teller++;
     if ( j > 0 && Zee[i][j-1] != 0 ) teller++;
     if ( j < n-1 && Zee[i][j+1] != 0 ) teller++;
     return teller;
   }//kruis
b. int meeste (int Zee[ ][n], int & i) {
     int i1, j, maxschip = -1, telschip;
     for ( i1 = 0; i1 < m; i1++ ) {
       telschip = 0;
       for ( j = 0; j < n; j++ )
         if ( Zee[i1][j] != 0 && ( j == 0 || Zee[i1][j-1] != Zee[i1][j] ) ) {
	   telschip++: }}//if&for
       if ( telschip > maxschip ) { maxschip = telschip; i = i1; }//if
     }//for
     return maxschip;
   }//meeste
c. bool plaats (int Zee[ ][n], int & i, int & j, int k) {
     int i, j, t; bool okee;
     for ( i = 0; i < m-k+1; i++ ) {
       for ( j = 0; j < n; j++ ) {
         okee = true;
	 for ( t = 0; t < k; t++ ) {
	   if ( kruis (Zee,i+t,j) > 0 ) { okee = false; }}//if&for
	 if ( okee ) { return true; }//if
     }}//for&for
     i = -1; j = -1; return false;
   }//plaats

OPGAVE 4
a. void voegtoe (object* & ingang, int info1, int info2) {
     object* nieuw1 = new object; nieuw1->info = info1;
     object* nieuw2 = new object; nieuw2->info = info2;
     nieuw1->zig = nieuw2; nieuw2->zig = ingang;
     nieuw1->zag = ingang;
     if ( ingang != nullptr ) {
       nieuw2->zag = ingang->zag; }//if
     else { nieuw2->zag = nullptr; }//else
     ingang = nieuw1;
   }//voegtoe
b. void verwijder (object* & ingang) {
     object* weg = ingang;
     if ( ingang != nullptr ) {
       ingang = ingang->zag;
       if ( weg->zig != nullptr ) { delete weg->zig; }//if
       delete weg;
     }//if
   }//verwijder
c. void ruil (object* & ingang) {
     object* bottom; object* temp;
     if ( ingang != nullptr && ingang->zig != nullptr 
          && ( ingang->info + ingang->zig->info ) % 3 == 0 ) {
       bottom = ingang->zig; temp = bottom->zag;
       bottom->zig = ingang; bottom->zag = ingang->zag;
       ingang->zig = ingang->zag; ingang->zag = temp;
       ingang = bottom;
     }//if
   }//ruil
d. Bij a, b en c moet er een & bij: de ingangs-pointer gaat bij a zeker, 
   en bij b en c meestal ook wel wijzigen.
e. void repareer (object* ingang, int w) {
     object* p = ingang; object* prev = nullptr;
     while ( p != nullptr ) {
       if ( p->zig == nullptr ) {
         p->zig = new object; p->zig->info = w; p->zig->zig = p->zag;
	 p->zig->zag = nullptr; // voor de laatste
	 if ( prev != nullptr ) { prev->zag = p->zig; }//if
       }//if
       prev = p->zig; p = p->zag;
     }//while
   }//repareer