Uitwerking Tentamen Programmeermethoden 5 januari 2022

OPGAVE 1
a. bool oneven (int A[ ], int n) {
     int i, teller = 1;
     for ( i = 1; i < n; i++ ) {
       if ( A[i] == A[i-1] ) { teller++; }//if
       else {
         if ( teller % 2 == 1 ) { return true; }//if
         teller = 1; 
       }//else
     }//for
     if ( teller % 2 == 1 ) { return true; }//if
     return false;
   }//oneven
b. void twee (int A[ ], int n, int & x, int & y, int & t) {
     int i, temp; x = A[0]; t = 1;
     for ( i = 1; i < n; i++ ) {
       if ( A[i] == x ) { t++; }//if
       else { y = A[i]; }//else
     }//for
     if ( x > y ) { temp = x; x = y; y = temp; t = n - t; }//if
   }//twee
c. void sorteer (int A [ ], int n) {
     int x, y, t, i; twee (A,n,x,y,t);
     for ( i = 0; i < t; i++ ) { A[i] = x; }//for
     for ( i = t; i < n; i++ ) { A[i] = y; }//for
   }//sorteer
d. void bubblesort (int A[ ], int n) {
     int i, r = 0, temp; bool klaar = false;
     while ( ! klaar ) {
       klaar = true; r++;
       for ( i = 0; i < n-r; i++ ) { // of < n-1
         if ( A[i] > A[i+1] ) {
           temp = A[i]; A[i] = A[i+1]; A[i+1] = temp; klaar = false; }}}
   }//bubblesort
e. n-t+1: de n-t grootste getallen moeten naar achteren, en een extra
   ronde om te zien dat we klaar zijn (en dit is maximaal)

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. 3,2 LF  4,7,12 LF  5,6,24 LF  6,5,48  LF 42  LF  4,8 LF 
   (LF = regelovergang)
c. freek (m,n) = ceiling(m/n) * n
   (eventueel apart noemen dat het n is als m <= n)
d. 3,2 LF  4,3,12 LF  4 LF  3,12 LF
e. Dan moet er een prototype int suzan (int a, int b); boven freek
   staan, en moet de eerste parameter van suzan call by value zijn,
   want 42 is geen l-value.

OPGAVE 3
a. int geen (int C[ ][n]) {
     int teller = 0, i, j; bool okee;
     for ( j = 0; j < n; j++ ) {
       okee = true;
       for ( i = 0; i < m; i++ ) {
         if ( C[i][j] != 0 ) { okee = false; }}//if&for
       if ( okee ) { teller++; }}//if&for
     return teller;
   }//geen
b. bool beter (int C[ ][n], int i, int j, int & tot) {
     int k; tot = 0;
     for ( k = 0; k < n; k++ ) {
       if ( C[i][k] <= C[j][k] && ! ( C[i][k] == 0 && C[j][k] == 0 ) ) { 
         tot = 0; return false; }//if
       tot += C[i][k] - C[j][k]; }//for
     return true;
   }//beter
c. double debeste (int C[ ][n]) {
     int i, j, waarde, totaal; bool okee;
     for ( i = 0; i < m; i++ ) {
       okee = true; totaal = 0;
       for ( j = 0; j < m; j++ ) {
         if ( i != j ) {
           if ( beter (C,i,j,waarde) ) { totaal += waarde; }//if
           else { okee = false; }//else
         }//if
       }//for
       if ( okee ) { return (double) totaal / (m-1); }//if
     }//for
     return -1; // of -1.0
   }//debeste

OPGAVE 4
a. void voegtoe (vakje* & ingang, int getal) {
     vakje* nieuw;
     if ( getal % 10 == 0 ) {
       nieuw = new vakje; nieuw->info = getal;
       nieuw->beneden = new vakje; nieuw->beneden->info = getal;
       nieuw->beneden->beneden = nullptr; nieuw->volg = ingang;
       if ( ingang != nullptr) {
         nieuw->beneden->volg = ingang->beneden; }//if
       else { nieuw->beneden->volg = nullptr; }//else
       ingang = nieuw;
     }//if
   }//voegtoe
b. void verwijder (vakje* & ingang) {
     vakje* weg = ingang;
     if ( ingang != nullptr ) {
       ingang = ingang->volg;
       delete weg->beneden; delete weg;
     }//if
   }//verwijder
c. int tweede (vakje* ingang) {
     if ( ingang != nullptr && ingang->beneden->volg != nullptr ) {
       return ingang->beneden->volg->info; }//if
     else { return -1; }//else
   }//tweede
d. Bij a en b moet er een & bij, de ingangspointer gaat daar doorgaans
   veranderen. Bij c maakt het niet uit, die pointer wijzigt niet.
e. void ruimop (vakje* ingang) {
     vakje* p;
     if ( ingang != nullptr && ingang->volg != nullptr ) {
       while ( ingang->beneden->volg != ingang->volg->beneden ) {
         p = ingang->beneden-volg;
         ingang->beneden->volg = p->volg;
         delete p;
       }//while
     }//if
   }//ruimop