/* feedback bij reeks 2
 * PROBLEEM :        zoeken en rangschikken
 * INHOUD FEEDBACK : enkele 'algemeenheden'
 */

OPM 1

Gelezen: twee functies die zoeken - de ene zonder eerst rangschikken;
de andere met eerst rangschikken. Commentaar staat na //+/.

void zoekOngesorteerd(vector<int> &g, vector<int> &z) {
     for (int i = 0; i < z.size(); i++) {
       vector<int>::iterator it;
       it = find(g.begin(), g.end(), z[i]);
       if(*it != 0) {        //+/ HIER MAG JE NIET OP TESTEN!!
                             //+/ find geeft g.end() terug indien niet gevonden 
        cout << *it << ", ";
       }
     }
}

void zoekGesorteerd(vector<int> &g, vector<int> &z) {
     sort(g.begin(), g.end());
     for (int i = 0; i < z.size(); i++) {
       vector<int>::iterator it;
       it = find(g.begin(), g.end(), z[i]);  //+/ je gebruikt dezelfde methode
          //+/ als hierboven om te zoeken - nl. lineair. 
		  //+/ Waarom sorteerde je dan eerst?
          //+/ gebruik binary_search!!
       if(*it != 0) {
        cout << *it << ", ";
       }
     }
}


OPM 2

Gelezen en becommentarieerd:
    //print(v): drukt de elementen af gescheiden door een spatie. 
    template <typename T>
    void print(vector<T> &v) {   //+/ vergeet 'const' niet bij de parameter!!
        for (int i = 0; i < v.size(); i++) {
            cout << v[i] << " ";
        }
    }
    	    
OPM 3

Gelezen en becommentarieerd:	    
    //is_range(n, vi): gaat na of vector vi de getallen 0..n-1 bevat
    template <typename T>  //+/ is de template hier wel nuttig?
                           //+/ als je vi[i] vergelijkt met i,
                           //+/ kan vi enkel variabelen van type int bevatten
                           //+/ (desnoods double, maar dan heeft 
						   //+/ controleren op 'is_range'
                           //+/ toch niet zoveel zin!!)
    bool is_range (int n, vector<T> &vi) {
        bool check = true;
        for(int i = 0; i < n; i++) {   //+/ FOEI !!
            if(vi[i] != i) {           //+/ hier loop je heel de tabel af, ook 
                check = false;         //+/ als check al onmiddellijk op 'false'
            }                          //+/ staat! INEFFICIENT!!
        }
        return check;
    }
    
Opmerking:
	Als je niet op voorhand weet hoe dikwijls je een herhaling moet uitvoeren,
	moet je een WHILE-lus gebruiken. Dus geen geknoei meer met for-lussen
	waarin je graag een break zou schrijven - maar dat dan toch maar niet doet
	omdat dat 'niet mag' van ons! 
    
OPM 4

Gelezen en becommentarieerd:
    //draai_om(v): verwisselt de volgorde van elementen in v
    template <typename T>
    void draai_om(vector<T> &v) {
        int maxI = v.size() - 1;
        for (int i = 0; i <= maxI / 2; i ++) {
            int tmp = v[i];    //+/ tmp moet van juiste type (T) zijn!!
            v[i] = v[maxI-i];
            v[maxI-i] = tmp;
        }
    }
    
Opmerking:
	Probeer geparametrizeerde functies minstens op 2 verschillende manieren
	te gebruiken; zodat je T niet enkel door het voor de hand liggende
	type 'int' vervangt. Dan komen fouten zoals hierboven snel aan het licht.
    

OPM 5

Gelezen:
   for(int i = 0; i<AANTAL; i++) {
       random = rand() % 10 + 1;  
       v.push_back(random);
   }
   
Bedenking:
	Dan heb je superveel dubbels in je vector v zitten. Is dat de bedoeling?

OPM 6

Gelezen:
	void print(vector<T> * v) // drukt de elementen af gescheiden door een spatie.
    {
        for(int i = 0; i<v->size(); i++)
        {
            cout << v->at(i) << "  ";
        }
        cout << endl;
    };
    
Bedenking:
	Waarom wil je de parameter per se van het type pointer (*) hebben?
	Dat bemoeilijkt het oproepen van de print-functie!
	(nl. print(&v) in plaats van print(v) )
	
	Bovendien zal er aan de parameter niets wijzigen, dus schrijf je const
	bij in het parametertype:
    void print(const vector<T> * v)
	
	Alternatief zonder (zichtbare) pointer, met aanroep print(v):
	void print (const vector<T> & v)    

OPM 7

Gelezen:
    bool is_stijgend(vector<T> * v){           // true indien v[i]<=v[j] als i<j
        for(int i = 0; i < v->size()-1; i++){
            if(v->at(i) >= v->at(i+1)){
                return false;
            }
        }
        return true;
    };

Bedenking:
	Je mag er vanuitgaan dat de operatoren < en == zeker geimplementeerd zijn.
	De andere operatoren zijn dat niet altijd voor alle types. 
	Dus gebruik bij voorkeur < in plaats van >=.