source: liacs/pm/menu.cc@ 197

#include <iostream>
#include <cstdio>
#include <ctime>
#include <climits>

using namespace std;

//
//Variable voor het 3x+1 programma
//
const int MAX = 25;


void Intro() {
        cout    << "---------------------------------------------------" << endl
                          << "|        University of Leiden  (XX-XX-2004)       |" << endl
                          << "|         Programmeermethoden opdracht 3          |" << endl
                          << "|                                                 |" << endl
                          << "|                 Gemaakt door:                   |" << endl
                          << "|               Rick van der Zwet                 |" << endl
                          << "|                 Pascal de Vos                   |" << endl
                          << "|                                                 |" << endl
                          << "|                                                 |" << endl
                          << "| Getest op: Unix systeem (Sun OS)                |" << endl
                          << "|            Windows XP (Dev-C++ 4.9.9.0)         |" << endl
                          << "|            Freebsd 5.2.1-r11 gcc version 3.3.3  |" << endl
                          << "---------------------------------------------------" << endl
                          << endl;
}


//Het maken van een random getal
int randomgetal(int x) { // tussen 0 en x 
  static int getal = time (NULL) % x; 
  getal = ( 621 * getal + 1 ) % x; 
  return getal;
}

//
// === SORTEREN ===
//

class grootgetal {
  public:
    grootgetal();
    ~grootgetal() { };
    void vul(int aantal, int deelgetal);
    void vulrandom(int aantal);
    bool testop1();
    bool iseven(int i);
    bool maal3plus1();
    void deeldoor2();
    void vermoedentest();
    void drukaf();
  private:
    int groot[MAX];
};

grootgetal::grootgetal() {
  for (int i = 0; i < MAX; i++) {
    groot[i] = 0;
  } // end for
} // end grootgetal::grootgetal

void grootgetal::vul(int deelgetal, int aantal) {
  for(int i = 0; i < aantal; i++) {
    groot[i] = deelgetal;
  } //end for
} //end grootgetal::vul

void grootgetal::vulrandom(int aantal) {
  for (int i = 0; i < aantal; i++) {
    groot[i] = randomgetal(10000);
  } // end for
} // end grootgetal::vulrandom

bool grootgetal::iseven(int i) {
 return(not(groot[i] % 2));     
} // end grootgetal::iseven

void grootgetal::deeldoor2() {
  int rest = 0;
  for (int i = MAX - 1; i >= 0; i--) {
    if (iseven(i)) {
      groot[i] = groot[i]/2 + rest; 
      rest = 0;
    }
    else {
      groot[i] = groot[i]/2 + rest;
      rest = 5000;
    } // end if
  } // end for
} // end grootgetal::deeldoor2

bool grootgetal::maal3plus1() { 
  int rest = 1; // Alvast +1
        
  for(int i = 0; i < MAX; i++) { 
                groot[i] = (groot[i] * 3) + rest;
    if(groot[i] >= 10000){
      rest = (groot[i] / 10000);
      groot[i] = (groot[i] - (rest * 10000));
    } 
    else {
      rest = 0;
    } //end if
  } //end for
  
  if (groot[MAX] > 9999) {
    return (false);
  }
  else { 
    return (true); 
  } //end if
  
} //end grootgetal::maal3plus1    

bool grootgetal::testop1() {
  if (groot[0] == 1) {
    for (int i = 1; i < MAX - 1; i++) {
      if (groot[i] != 0) {
        return (false);
      } //end if
    } //end for
    return (true);
  }
  return (false);
} //end grootgetal::testop1

void grootgetal::vermoedentest() {
  int aantalintaraties = 0; //aantal keer (3x+1) (/2) noodzakelijk
  while (not(testop1())) {
    
    if ((aantalintaraties % 100) == 0) { 
      cout << "Stap "; 
      cout.width(6);
      cout.fill(' ');
      cout << aantalintaraties << ": "; 
      drukaf(); 
      cout << endl;
    } //end if
    
    if (iseven(0)) {
      deeldoor2();
    }
    else {
      maal3plus1();
    } //end if
  
    aantalintaraties++;
    
  } //end while
  cout << "Totaal aantal intaraties: " << aantalintaraties << endl;;
} //end grootgetal::vermoedentest()

void grootgetal::drukaf() {
  cout << groot[MAX - 1];
  for (int i = MAX - 2; i >= 0; i--) {
    if (groot[i] > 999) {
      cout << groot[i];
    }
    else if (groot[i] > 99) {
      cout << "0" << groot[i];
    }
    else if (groot[i] > 9) {
      cout << "00" << groot[i];
    } 
    else {
    cout << "000" << groot[i];
    }//end if
  } //end for
} //end grootgetal::drukaf

//
// === END SORTEREN  ===
//

// 
// == MASTERMIND ===
//

//Vraag de gebruiker om zijn invoer
//AantalGetallen_pt = aantal getallen (pointer)
//AantalKleuren_pt = aantal mogelijkheiden (pointer)
//Invoer_pt = array met ingevoerde getallen door gebruiker (pointer)
void MastermindInvoer(int *AantalGetallen_pt, int *AantalKleuren_pt, int *Invoer_pt) {
  cout << endl << "Plaats gokje: " << endl;
  int IngevoerdeGetallen = 0;
  while (IngevoerdeGetallen < *AantalGetallen_pt) { 
    cout << "Voer getal " << (IngevoerdeGetallen + 1) << " (van de " << *AantalGetallen_pt << ") in "
    << "[0-" << *AantalKleuren_pt << "] (gevolgd door een enter): "; 
    if (cin >> *(Invoer_pt + IngevoerdeGetallen)) {
      IngevoerdeGetallen++;
    }
    else {
      cout << "Dit is geen (geldig) getal, gelieve een geldig getal invoeren" << endl;
      cin.clear();
      cin.ignore(INT_MAX,'\n');
    } // end if
  } // end while
} //end MastermindInvoer

//Bereken of de bebruiker iets goeds ingevoerd heeft
//AG_pt => AantalGetallen_pt = aantal getallen (pointer)
//AK_pt => AantalKleuren_pt = aantal mogelijkheiden (pointer)
//Invoer_pt = array met ingevoerde getallen door gebruiker (pointer)
//Antwoord_pt = array met antwoorden (pointer) 
//ATA_pt => AantalTekensAanwezig_pt = Aantal tekens aanwezig, maar niet goed geplaatst (pointer)
//ATJP => AantalTekensGoedePlek_pt = Aantal tekens op de goede plek (pointer)

void MastermindBereken(int *AG_pt, int *ATA_pt, int *ATJP_pt, int *Antwoord, int *Invoer){
    
  bool HulpArray[*AG_pt]; //array die nodig is bij het testen van de geldigheid van het 
  //gegeven antwoord, als de plek corresponderend met plek in array antwoord true is dan is het
  //getal nog niet gebruikt voor het antwoord.

  //hulp array op true stellen
  for (int i = 0; i < *AG_pt; i++) {
    HulpArray[i] = true;
  }   
  
  //Gegokte invoer array doorlopen
  for (int i = 0;i < *AG_pt; i++) { //loop_1
    
    //debug (invoer + antwoord laten zien)
    cout << *(Invoer + i) << " antwoord: " << *(Antwoord + i) << endl;
    //end debug
    
    if (*(Invoer + i) == *(Antwoord + i)) { //getal op de goede plek
      (*ATJP_pt)++;
      HulpArray[i] = false;
    }
  } //end loop_1
  for (int i = 0; i < *AG_pt; i++) { //loop_2
    if (HulpArray[i]) {
      for (int j = 0; j < *AG_pt; j++) { //loop_3
        if ((*(Invoer + i) == *(Antwoord + j)) && (HulpArray[j])) { //getal aanwezig
          (*ATA_pt)++;
          HulpArray[j] = false;
          j = *AG_pt; //uit loop_2 stappen, hij mag namelijk maar 1 keer tellen
        }
      } //end loop_3 
    }
  } //end loop_2
} //end MastermindBereken 


//hoofdmodule voor spel mastermind.
void MastermindMain() {
  
  //variabelen voor invoer
  int AantalGetallen = 4; //Aantal getallen dat de code lang is
  int AantalKleuren = 6;        //Aantal mogelijkheden per code teken

  cout << "Geef het aantal getallen ( <20 ) dat u wilt raden (gevolgd door enter): ";
  if (cin >> AantalGetallen) {
    if(AantalGetallen > 20) {
      cout << "Dit is meer als 20" << endl;
      return;
    } // end if
  } 
  else {
    cout << "Dit is GEEN getal" << endl;
    return;
  } // end if
  
  cout << "Geef het aantal kleuren ( <20 )dat u wilt raden (gevolgd door enter): ";
  if (cin >> AantalKleuren) {
    if(AantalKleuren > 20) {
      cout << "Dit is meer als 20" << endl;
      return;
    } // end if
  }
  else {
    cout << "Dit is GEEN getal" << endl;
    return;
  } // end if
 
  int Invoer[AantalGetallen]; //Array waar de invoer van de gebruiker wordt opgeslagen
  
  //variabelen voor de berekeing
  bool NogNietGeraden = true; //Waar zolang code (Antwoord) nog niet geraden 
    
  //variabelen voor uitvoer
  int AantalTekensJuistePlek = 0; //Pinnetje van de juiste kleur op de juiste plek
  int AantalTekensAanwezig = 0; //Pinnetje van de juiste kleur, maar niet op de goede plek
  
  //variabelen voor antwoord
  int Antwoord[AantalGetallen]; //array met gezochte antwoorden
  
  //antwoord genereren 
  for (int i = 0; i < AantalGetallen; i++) {
    Antwoord[i] = randomgetal(AantalKleuren); 
    
    //debug (antwoord laten zien)
    cout << Antwoord[i] << endl;
    //end debug
  } //end for

  while (NogNietGeraden) { //gebruiker code laten raden
    
    MastermindInvoer(&AantalGetallen, &AantalKleuren, Invoer); //gebruikers invoer opvragen     
    MastermindBereken(&AantalGetallen, &AantalTekensJuistePlek, &AantalTekensAanwezig, Antwoord, Invoer); //vergelijking uitvoeren

    //gebruikers resultaat laten zien
          if (AantalTekensJuistePlek == AantalGetallen) {
      cout << "Zeer goed, u heeft het goede antwoord geraden, druk op enter om verder te gaan";
      cin.get();
      NogNietGeraden = false;
          }
    else {
      cout << "Aantal op de juiste plek: \t" << AantalTekensJuistePlek << endl;
      cout << "Aantal niet op de juiste plek:\t" << AantalTekensAanwezig << endl;
          } //end gebruiker code laten raden 
        } // end while 
  return;
} // end MasterMindMain 

//
// == END MASTERMIND ===
//

//
// === SORTEREN GEDEELTE ===
//

//Een list bestaat uit allemaal vakjes.
class Vakje {
 public:
  int Getal_int; //Waarde van het vakje
  Vakje * Volgende_Vakje_pt; //Zijn 'rechterbuur'
  Vakje * Vorige_Vakje_pt; //Zijn 'linkbuur'
};

class listvak {
  public:
    //default constuctor (NULL pointers)
    listvak( );
    //destructor: niks doen
    ~listvak( ) { };
    //creer de list van random lengte met randomgetallen
    void randomlist();
    //druk de list van links naar rechts af
    void drukaf_l_r();
    //druk de list van recht naar links af
    void drukaf_r_l();
    //sorteer de list, volgens bubblesort methode
    int sorteren();
    //merge L1 en L2 met opvolgend principe
    void merge(listvak * L1, listvak * L2);
    //vernietig de list.
    void vernietig();
  private:    
    Vakje * Eerste_Vakje_pt; //pointer naar het eerste vakje
    Vakje * Laatste_Vakje_pt; //pointer naar het laatste vakje
};

listvak::listvak( ) {
  Eerste_Vakje_pt = NULL;
  Laatste_Vakje_pt = NULL;
}

//voeg een AantalGetallen_int getallen toe aan de List die door Lbgin wordt gepointerd.
void listvak::randomlist() {
  Vakje * VakjeNew_Vakje_pt;
  
  for (int i = 0; i < randomgetal(1000); i++) {
    VakjeNew_Vakje_pt = new Vakje;
    VakjeNew_Vakje_pt->Getal_int = randomgetal(10000);
    if (Eerste_Vakje_pt != NULL) {
      VakjeNew_Vakje_pt->Volgende_Vakje_pt = Eerste_Vakje_pt;
      VakjeNew_Vakje_pt->Volgende_Vakje_pt->Vorige_Vakje_pt = VakjeNew_Vakje_pt;
    }
    else {
      Laatste_Vakje_pt = VakjeNew_Vakje_pt;
    } //end if
    
    Eerste_Vakje_pt = VakjeNew_Vakje_pt;
  } //end for
} //end listvak::randomlist

//druk de list af van links naar rechts
void listvak::drukaf_l_r() {
 Vakje * Hulp_Vakje_pt = Eerste_Vakje_pt;
 while (Hulp_Vakje_pt != NULL) {
  cout << Hulp_Vakje_pt->Getal_int << " ";
  Hulp_Vakje_pt = Hulp_Vakje_pt->Volgende_Vakje_pt;
  } //end while
} //end listvak::drukaf_lr
  
//druk de list af van rechts naar links
void listvak::drukaf_r_l() {
 Vakje * Hulp_Vakje_pt = Laatste_Vakje_pt;
 while (Hulp_Vakje_pt != NULL) {
  cout << Hulp_Vakje_pt->Getal_int << " ";
  Hulp_Vakje_pt = Hulp_Vakje_pt->Vorige_Vakje_pt;
  } //end while
} //end listvak::drukaf_rl

//sorteren volgens de bubblesort methode (grootste getal achteraan)
//uitvoer: aantal verwisselingen die plaatsgevonden hebben.
int listvak::sorteren() {
  int Verwisselingen_int = 0;
  Vakje * BubbleHulp_Vakje_pt = Eerste_Vakje_pt; //Dit is het vakje dat gechecked wordt
  Vakje * BubbleStop_Vakje_pt = Laatste_Vakje_pt; //Hierna hoeft niet meer gechecked worden
  Vakje * BubbleVakA_Vakje_pt;
  Vakje * BubbleVakB_Vakje_pt;
  Vakje * BubbleVakC_Vakje_pt;
  Vakje * BubbleVakD_Vakje_pt;
  
  while (BubbleStop_Vakje_pt->Vorige_Vakje_pt != NULL) {  
    while ( BubbleHulp_Vakje_pt != BubbleStop_Vakje_pt ) { 
      if (BubbleHulp_Vakje_pt->Getal_int > BubbleHulp_Vakje_pt->Volgende_Vakje_pt->Getal_int) {
        /* Methode voor het omwisselen van vak B en C
         *            Oude situtatie
         * ___________________________________
         * | Vorige | Vak Nummer  | Volgende  |
         * |========|=============|===========|
         * |        |     A       |   1->B    |
         * | 2->A   |     B       |   3->C    |
         * | 4->B   |     C       |   5->D    |
         * | 6->C   |     D       |           |
         * ------------------------------------
         *        
         *            Nieuwe situatie
         * ___________________________________
         * | Vorige | Vak Nummer  | Volgende  |
         * |========|=============|===========|
         * |        |     A       |   1->C    |
         * | 2->C   |     B       |   3->D    |
         * | 4->A   |     C       |   5->B    |
         * | 6->B   |     D       |           |
         * ------------------------------------
         *
         * Uitzondering betreft als A de pointer in het begin is of als
         * D de eind pointer is.
         */
        BubbleVakA_Vakje_pt = BubbleHulp_Vakje_pt->Vorige_Vakje_pt;
        BubbleVakB_Vakje_pt = BubbleHulp_Vakje_pt;
        BubbleVakC_Vakje_pt = BubbleHulp_Vakje_pt->Volgende_Vakje_pt;
        BubbleVakD_Vakje_pt = BubbleHulp_Vakje_pt->Volgende_Vakje_pt->Volgende_Vakje_pt;
        
        //Pointer 1,2 
        if (BubbleVakA_Vakje_pt == NULL) {
          Eerste_Vakje_pt = BubbleVakC_Vakje_pt;
          BubbleVakC_Vakje_pt->Vorige_Vakje_pt = NULL;
        }
        else {
          BubbleVakA_Vakje_pt->Volgende_Vakje_pt = BubbleVakC_Vakje_pt;
          BubbleVakC_Vakje_pt->Vorige_Vakje_pt = BubbleVakA_Vakje_pt;
        } //end if
       
        //Pointer 3,4
        BubbleVakB_Vakje_pt->Vorige_Vakje_pt = BubbleVakC_Vakje_pt;
        BubbleVakC_Vakje_pt->Volgende_Vakje_pt = BubbleVakB_Vakje_pt;

        //Pointer 5,6
        if (BubbleVakD_Vakje_pt == NULL) {
          Laatste_Vakje_pt = BubbleVakB_Vakje_pt;
          BubbleVakB_Vakje_pt->Volgende_Vakje_pt = NULL;
          BubbleStop_Vakje_pt = BubbleVakB_Vakje_pt;
        }
        else {
          BubbleVakD_Vakje_pt->Vorige_Vakje_pt = BubbleVakB_Vakje_pt;
          BubbleVakB_Vakje_pt->Volgende_Vakje_pt = BubbleVakD_Vakje_pt;
        } //end if

        //In het geval dat het vakje van de stop pointer kleiner is als het vakje ervoor,
        //zal de stop pointer over het nieuwe vakje moeten vallen, anders komt hij het stop
        //teken nooit tegen.
        // A B C D
        // 5 9 7 10
        //   ^ ^ 
        //   | |Stop pointer 
        //   | Huidige Waarde
        // 
        // ZONDER AANPASSING          MET AANPASSING
        //
        // A C B D                    A C B D
        // 5 7 9 10                   5 7 9 10
        //   ^ ^                        ^ ^
        //   | |Huidige Waarde          | |Huidige Waarde + Stop Pointer
        //   | Stop Pointer             |
        //
        if (BubbleStop_Vakje_pt == BubbleVakC_Vakje_pt) {
          BubbleStop_Vakje_pt = BubbleVakB_Vakje_pt; 
        } //end if
        
        Verwisselingen_int++;
      }
      else {
        BubbleHulp_Vakje_pt = BubbleHulp_Vakje_pt->Volgende_Vakje_pt;
      } //end if
    } //end while
    BubbleHulp_Vakje_pt = Eerste_Vakje_pt;
    BubbleStop_Vakje_pt = BubbleStop_Vakje_pt->Vorige_Vakje_pt;
  } //end while
  return (Verwisselingen_int);
} //end listvak::sorteren

void listvak::merge(listvak * L1, listvak * L2) {
  bool Toevoegen_bool = true; //zolang true bestaan er nog waardes die toegevoegd moeten worden
  
  Vakje * HulpL1_Vakje_pt = L1->Laatste_Vakje_pt; //pointer die bijhoudt waar we in L1 zijn
  Vakje * HulpL2_Vakje_pt = L2->Laatste_Vakje_pt; //pointer die bijhoudt waar we in L2 zijn
  
  Vakje * VakjeNew_Vakje_pt; //pointer bij gebruikt wordt bij het maken van nieuwe vakjes

  while (Toevoegen_bool) {
    VakjeNew_Vakje_pt = new Vakje;
    if (Eerste_Vakje_pt != NULL) {
      VakjeNew_Vakje_pt->Volgende_Vakje_pt = Eerste_Vakje_pt;
      VakjeNew_Vakje_pt->Volgende_Vakje_pt->Vorige_Vakje_pt = VakjeNew_Vakje_pt;
    }
    else {
      Laatste_Vakje_pt = VakjeNew_Vakje_pt;
    } //end if
    Eerste_Vakje_pt = VakjeNew_Vakje_pt;
 
    if ((HulpL1_Vakje_pt != NULL) && (HulpL2_Vakje_pt != NULL)) { //beiden bevatten nog een getal
      if (HulpL1_Vakje_pt->Getal_int > HulpL2_Vakje_pt->Getal_int) {
        VakjeNew_Vakje_pt->Getal_int = HulpL1_Vakje_pt->Getal_int;
        HulpL1_Vakje_pt = HulpL1_Vakje_pt->Vorige_Vakje_pt;
      }
      else {
        VakjeNew_Vakje_pt->Getal_int = HulpL2_Vakje_pt->Getal_int;
        HulpL2_Vakje_pt = HulpL2_Vakje_pt->Vorige_Vakje_pt;
      } //end if
    }  
    else if (HulpL1_Vakje_pt != NULL) { //L2 leeg, enkel waardes uit L1 plakken
        VakjeNew_Vakje_pt->Getal_int = HulpL1_Vakje_pt->Getal_int;
        HulpL1_Vakje_pt = HulpL1_Vakje_pt->Vorige_Vakje_pt;
    }
    else if (HulpL2_Vakje_pt != NULL) { //L1 leeg, enkel waardes uit L2 plakken
        VakjeNew_Vakje_pt->Getal_int = HulpL2_Vakje_pt->Getal_int;
        HulpL2_Vakje_pt = HulpL2_Vakje_pt->Vorige_Vakje_pt;
    }
    else { //alles leeg, 'over en sluiten'
      Toevoegen_bool = false;
    } //end if
  } //end while
} //end listvak::merge

//vernietig de list
void listvak::vernietig() {
  Vakje * Hulp_Vakje_pt;
  while (Eerste_Vakje_pt != NULL) {
    Hulp_Vakje_pt = Eerste_Vakje_pt->Volgende_Vakje_pt;
    delete Eerste_Vakje_pt;
    Eerste_Vakje_pt = Hulp_Vakje_pt;
  } //end while;    
  Laatste_Vakje_pt = NULL;
} //end listvak::vernietig

//
// === END SORTEREN ===
//


//
// === MENU GEDEELTE ===
//


//scherm leegmaken
void clearall() {
  system("cls"); //maakt scherm leeg in Dos
  system("clear"); //maakt scherm leeg
  cin.clear(); //maak invoerbuffer leeg
  cin.ignore(INT_MAX, '\n'); //alles was nog te wachten staat negeren
}


void SubMenuMasterMind() {
  MastermindMain();
} //end SubMenuMasterMind

void SubMenu3keerplus1() { 
  char MenuKeuze = ' ';
  int lengte, getal;
  grootgetal BigGetal;
 
  while (true) {
    cout  << " --------------------- 3x+1 -----------------    " << endl
          << "Maak een keuze uit de volgende opties:           " << endl
          << "- Bepaal de lengte,  random generatie getal (R/r)" << endl
          << "- Bepaald de lengte, bepaal het getal zelf (Z/z) " << endl
          << "- Terug naar Het hoofdmenu (T/t)                 " << endl
          << "                                                 " << endl
          << "Keuze: " << endl; cin >> MenuKeuze;
   clearall();
                                                   
    switch (MenuKeuze) {
      case 't': case 'T': //Terug naar Hoofdmenu
        return;
        break;
      case 'r': case 'R': //Vul L1 random
        cout << "Vul het aantal elementen in: ";
        cin >> lengte;
        BigGetal.vulrandom(lengte);
        BigGetal.vermoedentest();
        break;
      case 'z': case 'Z': //Vul L2 random
        cout << "Vul het aantal elementen in: ";
        cin >> lengte;
        cout << endl;
        cout << "Vul het getal in: ";
        cin >> getal;
        BigGetal.vul(getal,lengte);  
        BigGetal.vermoedentest();                    
        break;
      default:
        cout << "GEEN GOEDE INVOER ..." << endl;
        break;
    }  // end switch
  }  // end while
} // end Menu3keerplus1 


void SubMenuSorteren() {
  char Menukeuze = ' ';
  listvak L1,L2,L3;  

  while (true) {
    cout << " ------------- Sorteren --------------- " << endl
         << "Maak een keuze uit de volgende opties:  " << endl
         << "- Vul L1 random (A/a)                   " << endl
         << "- Vul L2 random (B/b)                   " << endl
         << "- Vul L3 random (C/c)                   " << endl
         << "- Vernietig L1 (D/d)                    " << endl
         << "- Vernietig L2 (E/e)                    " << endl
         << "- Vernietig L3 (F/f)                    " << endl
         << "- Bubblesort L1 (G/g)                   " << endl
         << "- Bubblesort L2 (H/h)                   " << endl
         << "- Bubblesort L3 (I/i)                   " << endl
         << "- Merge L1 en L2 naar L3 (J/j)          " << endl
         << "- Hierbij wordt L1,L2 gesorteerd en L3 gewist " << endl
         << "- Terug naar Algoritmen (T/t)           " << endl
         << "                                        " << endl
         << "Keuze: ";

    cin >> Menukeuze;
    clearall();  
                                    
    switch (Menukeuze) {
      case 'a': case 'A': //Vul L1 random
        L1.randomlist();
        L1.drukaf_r_l();
        break;
      case 'b': case 'B': //Vul L2 random
        L2.randomlist(); 
        L2.drukaf_r_l();                          
        break;
      case 'c': case 'C': //Vul L3 random
        L3.randomlist();
        L3.drukaf_r_l();
        break;
      case 'd': case 'D': //Vernietig L1
        L1.vernietig();
        break;
      case 'e': case 'E': //Vernietig L2
        L2.vernietig();
        break;
      case 'f': case 'F': //Vernietig L3
        L3.vernietig();
        break;
      case 'g': case 'G': //Bubblesort L1
        L1.sorteren();
        L1.drukaf_l_r();
        cout << endl << endl;
        break;
      case 'h': case 'H': //Bubblesort L2
        L2.sorteren();
        L2.drukaf_l_r();
        cout << endl << endl;
        break;
      case 'i': case 'I': //Bubblesort L3
        L3.sorteren();
        L3.drukaf_l_r();
        cout << endl << endl;
        break;
      case 'j': case 'J': //Merge L1 en L2 naar L3
        L1.sorteren();
        L2.sorteren();
        L3.vernietig();
        L3.merge(&L1,&L2);
        cout << endl << endl;
        L3.drukaf_l_r();
        cout << endl;
        break;
      case 't': case 'T': //Naar AlgoritmeMenu
        return;
        break;
      default:
        cout << "GEEN GOEDE INVOER ..." << endl;
        break;
    }  // end switch
  } // end while
} //end SubMenuSorteren
  

void SubMenuAlgoritmen() {
char Menukeuze = ' ';

  while (true) {
    cout << " ------------- Algoritmen ------------- " << endl
         << "Maak een keuze uit de volgende opties:  " << endl
         << "->Sorteren (S/s)                        " << endl
         << "->3x+1 (X/x)                            " << endl
         << "->Terug naar het Hoofdmenu (T/t)        " << endl
         << "                                        " << endl
         << "Keuze: ";
    cin >> Menukeuze;
    clearall();
  
    switch (Menukeuze) {
    case 's': case 'S':
      SubMenuSorteren();
      break;
    case 'x': case 'X':
      SubMenu3keerplus1(); 
      break;
    case 't': case 'T':
      return;
      break;
    default:
      cout << "GEEN GOEDE INVOER" << endl
           << endl;
      break;
    } // end switch
  } // end while

} // end SubMenuAlgoritmen

 
void HoofdMenu() {
  char Menukeuze = '';
  while (true) { //oneindige loop
    cout << "-----Hoofdmenu----" << endl
         << "->Algoritmen (a/A)" << endl
         << "->Mastermind (m/M)" << endl
         << "->Stoppen    (s/S)" << endl
         << "                  " << endl
         << "Keuze: ";
    cin >> Menukeuze;
    clearall(); 
  
    switch (Menukeuze) {
      case 'a': case 'A':  //sub menu Algoritmen
        SubMenuAlgoritmen();
        break;
      case 'm': case 'M': //Mastermind
        SubMenuMasterMind();
        break;
      case 's': case 'S': // Stoppen
        cout << "Goodbye" << endl;
        return;
        break;
      default:
        cout << "GEEN GOEDE INVOER" << endl
            << endl;
      } //end switch
  } // end while 
} // end HoofdMenu

//
// === END MENU GEDEELTE ===
//


int main() {
  clearall();
  HoofdMenu();
}