UITWERKING TENTAMEN PROGRAMMEERMETHODEN 28 maart 2024

OPGAVE 1
a. int verschil (int A[ ], int n) {
     int i, gr = 0, ver;
     for ( i = 0; i < n-1; i++ ) {
       ver = A[i] - A[i+1]; 
       if ( ver < 0 ) { ver = -ver; }//if
       if ( ver > gr ) { gr = ver; }}//if&for
     return gr;
   }//verschil
b. int bouw (int A[ ], int X, int Y, int n) {
     int i, totaalsom = X + Y; A[0] = X; A[1] = Y;
     for ( i = 2; i < n; i++ ) { 
       A[i] = A[i-2] + A[i-1];
       totaalsom += A[i]; }//for
     return totaalsom;
   }//bouw
c. bool som3 (int A[ ], int & i, int & j, int & k, int n) {
     for ( i = 0; i < n-2; i++ ) { 
       for ( j = i+1; j < n-1; j++ ) {
         for ( k = j+1; k < n; k++ ) {
           if ( A[i] + A[j] == A[k] 
                || A[i] + A[k] == A[j]
	        || A[j] + A[k] == A[i] ) { 
	 return true; }}}}//if&for&for&for
     i = -1; j = -1; k = -1; return false;
   }//som3
d. void sort (int A[ ]. int n) {
     int i, temp; bool wissel = true;
     while ( wissel ) {
       wissel = false;
       for ( i = 0; i < n-1; i++ ) {
         if ( A[i] < A[i+1] ) { 
	   temp = A[i]; A[i] = A[i+1]; A[i+1] = temp;
	   wissel = true; }}//if&for 
     }//while
   }//sort
e. Bij een oplopend gesorteerd rijtje: n-1 + n-2 + ... + 2 + 1 = n(n-1)/2 
   vergelijkingen.

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,4,43,2,12 LF 3,10,43,4,13 LF Caro 18,3,42,43,13 LF 21 LF 1,3,13
   (hierbij is LF een regelovergang)
c. Als a >= 0: a + b + a^2, en anders a + b
d. 1,4,43,2,12 LF 4,17,43,5,13 LF Caro 26,4,42,43,13 LF 30 LF 26,4,13
   De volgorde bij + zou in C++ niet vast kunnen liggen, en dat heeft
   wellicht vreemde consequenties.
e. Dan moet er een prototype int piet (int a, int b); boven caro
   staan (functies mogen alleen eerder vermelde functies aanroepen),
   en de eerste parameter van caro en de tweede van piet moeten 
   call-by-value zijn, want 7 en caro (7,m) zijn geen variabelen 
   (geen l-values).

OPGAVE3 
a. bool cijfers (char H[ ][n]) {
     int cijfers = 0, i, j;
     for ( i = 0; i < m; i++ ) { for ( j = 0; j < n; j++ ) {
       if ( '0' <= H[i][j] && H[i][j] <= '9' ) { cijfers++; }}}//if&for&for
     return ( cijfers >= m * n - cijfers );
   }//cijfers
b. int cijferkolom (char H[ ][n], int & som) {
     int i, j; bool okee;
     for ( j = 0; j < n; j++ ) { 
       okee = true; som = 0;
       for ( i = 0; i < m; i++ ) { 
         if ( ! ( '0' <= H[i][j] && H[i][j] <= '9' ) ) { okee = false; }//if
	 else { som += H[i][j] - '0'; }//else
       if ( okee ) { return j; }//if
     }//for
     som = 0; return -1;
   }//cijferkolom
c. bool wandel (char H[ ][n], int & u, int & v, int d) {
     int i, j, stap;
     for ( u = 0; u < m; u++ ) { for ( v = 0; v < n; v++ ) {
       i = u; j = v; stap = 0;
       while ( i < m && j < n ) {
         if ( '0' <= H[i][j] && H[i][j] <= '9' ) { stap++;
	   if ( H[i][j] - '0' ) % 2 == 0 ) { j++; } else { i++; }}//if&else
	 else { i = m+1; }//else: breek de while-loop
       }//while
       if ( stap >= d ) { return true; }//if
     }}//for&for
     u = -1; v = -1; return false;
   }//wandel

OPGAVE 4
a. void verwijder (vakje* & ingang) {
     vakje* weg = ingang;
     if ( ingang != nullptr ) {
       ingang = ingang->rechts;
       delete weg->onder; delete weg; }//if
   }//verwijder
b. void voegtoe (vakje* & ingang, int x, int y) {
     vakje* nieuw = new vakje;
     nieuw->rechts = ingang; nieuw->info = x;
     nieuw->onder = new vakje; nieuw->onder->info = y;
     nieuw->onder->onder = nieuw;
     if ( ingang != nullptr ) { nieuw->onder->rechts = ingang->onder; }//if
     else { nieuw->onder->rechts = nullptr; }//else
     ingang = nieuw;
   }//voegtoe
c. void desom (vakje* ingang) {
     if ( ingang != nullptr && ingang->rechts != nullptr
          && ( ingang->info + ingang->rechts->onder->info % 4 == 0 ) ) {
       ingang->info += ingang->rechts->onder->info; }//if
   }//desom
d. Bij a en b moet de ingangspointer (doorgaans) wijzigen, dus moet er 
   een & bij. Bij c maakt het niet uit, de ingangspointer wijzigt nooit.
e. void wissel (vakje* ingang) {
     vakje* loper = ingang; int temp; bool wissel = true;
     while ( loper != nullptr ) {
       if ( wissel ) {
         temp = loper->info; 
	 loper->info = loper->onder->info;
         loper->onder->info = temp; }//if
       wissel = ! wissel;
       loper = loper->rechts; }//while
   }//wissel