1 | //Programmeermethoden opdracht 3
|
---|
2 | //Gemaakt door Rick van der Zwet & Pascal de Vos
|
---|
3 | //
|
---|
4 | //IVM met versie problemen zult u in clearall() en in de main() de juiste functie moeten commenten
|
---|
5 |
|
---|
6 |
|
---|
7 |
|
---|
8 | #include <iostream>
|
---|
9 | #include <cstdio>
|
---|
10 | #include <ctime>
|
---|
11 | #include <climits>
|
---|
12 |
|
---|
13 | using namespace std;
|
---|
14 |
|
---|
15 | //
|
---|
16 | //Variable voor het 3x+1 programma
|
---|
17 | //
|
---|
18 | const int MAX = 25;
|
---|
19 |
|
---|
20 |
|
---|
21 |
|
---|
22 | //Het maken van een random getal
|
---|
23 | int randomgetal(int x) { // tussen 0 en x
|
---|
24 | static int getal = time (NULL) % x;
|
---|
25 | getal = ( 621 * getal + 1 ) % x;
|
---|
26 | return getal;
|
---|
27 | }
|
---|
28 |
|
---|
29 | //
|
---|
30 | // === SORTEREN ===
|
---|
31 | //
|
---|
32 |
|
---|
33 | class grootgetal {
|
---|
34 | public:
|
---|
35 | grootgetal();
|
---|
36 | ~grootgetal() { };
|
---|
37 | void vul(int aantal, int deelgetal);
|
---|
38 | void vulrandom(int aantal);
|
---|
39 | bool testop1();
|
---|
40 | bool iseven(int i);
|
---|
41 | bool maal3plus1();
|
---|
42 | void deeldoor2();
|
---|
43 | void vermoedentest();
|
---|
44 | void drukaf();
|
---|
45 | private:
|
---|
46 | int groot[MAX];
|
---|
47 | };
|
---|
48 |
|
---|
49 | grootgetal::grootgetal() {
|
---|
50 | for (int i = 0; i < MAX; i++) {
|
---|
51 | groot[i] = 0;
|
---|
52 | } // end for
|
---|
53 | } // end grootgetal::grootgetal
|
---|
54 |
|
---|
55 | void grootgetal::vul(int deelgetal, int aantal) {
|
---|
56 | for(int i = 0; i < aantal; i++) {
|
---|
57 | groot[i] = deelgetal;
|
---|
58 | } //end for
|
---|
59 | } //end grootgetal::vul
|
---|
60 |
|
---|
61 | void grootgetal::vulrandom(int aantal) {
|
---|
62 | for (int i = 0; i < aantal; i++) {
|
---|
63 | groot[i] = randomgetal(10000);
|
---|
64 | } // end for
|
---|
65 | } // end grootgetal::vulrandom
|
---|
66 |
|
---|
67 | bool grootgetal::iseven(int i) {
|
---|
68 | return(not(groot[i] % 2));
|
---|
69 | } // end grootgetal::iseven
|
---|
70 |
|
---|
71 | void grootgetal::deeldoor2() {
|
---|
72 | int rest = 0;
|
---|
73 | for (int i = MAX - 1; i >= 0; i--) {
|
---|
74 | if (iseven(i)) {
|
---|
75 | groot[i] = groot[i]/2 + rest;
|
---|
76 | rest = 0;
|
---|
77 | }
|
---|
78 | else {
|
---|
79 | groot[i] = groot[i]/2 + rest;
|
---|
80 | rest = 5000;
|
---|
81 | } // end if
|
---|
82 | } // end for
|
---|
83 | } // end grootgetal::deeldoor2
|
---|
84 |
|
---|
85 | bool grootgetal::maal3plus1() {
|
---|
86 | int rest = 1; // Alvast +1
|
---|
87 |
|
---|
88 | for(int i = 0; i < MAX; i++) {
|
---|
89 | groot[i] = (groot[i] * 3) + rest;
|
---|
90 | if(groot[i] >= 10000){
|
---|
91 | rest = (groot[i] / 10000);
|
---|
92 | groot[i] = (groot[i] - (rest * 10000));
|
---|
93 | }
|
---|
94 | else {
|
---|
95 | rest = 0;
|
---|
96 | } //end if
|
---|
97 | } //end for
|
---|
98 |
|
---|
99 | if (groot[MAX] > 9999) {
|
---|
100 | return (false);
|
---|
101 | }
|
---|
102 | else {
|
---|
103 | return (true);
|
---|
104 | } //end if
|
---|
105 |
|
---|
106 | } //end grootgetal::maal3plus1
|
---|
107 |
|
---|
108 | bool grootgetal::testop1() {
|
---|
109 | if (groot[0] == 1) {
|
---|
110 | for (int i = 1; i < MAX - 1; i++) {
|
---|
111 | if (groot[i] != 0) {
|
---|
112 | return (false);
|
---|
113 | } //end if
|
---|
114 | } //end for
|
---|
115 | return (true);
|
---|
116 | }
|
---|
117 | return (false);
|
---|
118 | } //end grootgetal::testop1
|
---|
119 |
|
---|
120 | void grootgetal::vermoedentest() {
|
---|
121 | int aantalintaraties = 1; //aantal keer (3x+1) (/2) noodzakelijk
|
---|
122 | //stap 0 bestaat niet volgens de PM opgave, dus gelijk stap 1.
|
---|
123 | //hoewel strikt genomen aantalintaraties op 0 begint.
|
---|
124 | cout << "Stap ";
|
---|
125 | cout.width(6);
|
---|
126 | cout.fill(' ');
|
---|
127 | cout << aantalintaraties - 1 << ": ";
|
---|
128 | drukaf();
|
---|
129 | cout << endl;
|
---|
130 | //end stap error fix
|
---|
131 |
|
---|
132 | while (not(testop1())) {
|
---|
133 |
|
---|
134 | if ((aantalintaraties % 100) == 0) {
|
---|
135 | cout << "Stap ";
|
---|
136 | cout.width(6);
|
---|
137 | cout.fill(' ');
|
---|
138 | cout << aantalintaraties << ": ";
|
---|
139 | drukaf();
|
---|
140 | cout << endl;
|
---|
141 | } //end if
|
---|
142 |
|
---|
143 | if (iseven(0)) {
|
---|
144 | deeldoor2();
|
---|
145 | }
|
---|
146 | else {
|
---|
147 | maal3plus1();
|
---|
148 | } //end if
|
---|
149 |
|
---|
150 | aantalintaraties++;
|
---|
151 |
|
---|
152 | } //end while
|
---|
153 | cout << "Totaal aantal intaraties: " << aantalintaraties << endl;;
|
---|
154 | } //end grootgetal::vermoedentest()
|
---|
155 |
|
---|
156 | void grootgetal::drukaf() {
|
---|
157 | cout << groot[MAX - 1];
|
---|
158 | for (int i = MAX - 2; i >= 0; i--) {
|
---|
159 | if (groot[i] > 999) {
|
---|
160 | cout << groot[i];
|
---|
161 | }
|
---|
162 | else if (groot[i] > 99) {
|
---|
163 | cout << "0" << groot[i];
|
---|
164 | }
|
---|
165 | else if (groot[i] > 9) {
|
---|
166 | cout << "00" << groot[i];
|
---|
167 | }
|
---|
168 | else {
|
---|
169 | cout << "000" << groot[i];
|
---|
170 | }//end if
|
---|
171 | } //end for
|
---|
172 | } //end grootgetal::drukaf
|
---|
173 |
|
---|
174 | //
|
---|
175 | // === END SORTEREN ===
|
---|
176 | //
|
---|
177 |
|
---|
178 | //
|
---|
179 | // == MASTERMIND ===
|
---|
180 | //
|
---|
181 |
|
---|
182 | //Vraag de gebruiker om zijn invoer
|
---|
183 | //AantalGetallen_pt = aantal getallen (pointer)
|
---|
184 | //AantalKleuren_pt = aantal mogelijkheiden (pointer)
|
---|
185 | //Invoer_pt = array met ingevoerde getallen door gebruiker (pointer)
|
---|
186 | void MastermindInvoer(int *AantalGetallen_pt, int *AantalKleuren_pt, int *Invoer_pt) {
|
---|
187 | cout << endl << "Plaats gokje: " << endl;
|
---|
188 | int IngevoerdeGetallen = 0;
|
---|
189 | while (IngevoerdeGetallen < *AantalGetallen_pt) {
|
---|
190 | cout << "Voer getal " << (IngevoerdeGetallen + 1) << " (van de " << *AantalGetallen_pt << ") in "
|
---|
191 | << "[0-" << *AantalKleuren_pt << "] (gevolgd door een enter): ";
|
---|
192 | if (cin >> *(Invoer_pt + IngevoerdeGetallen)) {
|
---|
193 | IngevoerdeGetallen++;
|
---|
194 | }
|
---|
195 | else {
|
---|
196 | cout << "Dit is geen (geldig) getal, gelieve een geldig getal invoeren" << endl;
|
---|
197 | cin.clear();
|
---|
198 | cin.ignore(INT_MAX,'\n');
|
---|
199 | } // end if
|
---|
200 | } // end while
|
---|
201 | } //end MastermindInvoer
|
---|
202 |
|
---|
203 | //Bereken of de bebruiker iets goeds ingevoerd heeft
|
---|
204 | //AG_pt => AantalGetallen_pt = aantal getallen (pointer)
|
---|
205 | //AK_pt => AantalKleuren_pt = aantal mogelijkheiden (pointer)
|
---|
206 | //Invoer_pt = array met ingevoerde getallen door gebruiker (pointer)
|
---|
207 | //Antwoord_pt = array met antwoorden (pointer)
|
---|
208 | //ATA_pt => AantalTekensAanwezig_pt = Aantal tekens aanwezig, maar niet goed geplaatst (pointer)
|
---|
209 | //ATJP => AantalTekensGoedePlek_pt = Aantal tekens op de goede plek (pointer)
|
---|
210 |
|
---|
211 | void MastermindBereken(int *AG_pt, int *ATA_pt, int *ATJP_pt, int *Antwoord, int *Invoer){
|
---|
212 |
|
---|
213 | bool HulpArray[*AG_pt]; //array die nodig is bij het testen van de geldigheid van het
|
---|
214 | //gegeven antwoord, als de plek corresponderend met plek in array antwoord true is dan is het
|
---|
215 | //getal nog niet gebruikt voor het antwoord.
|
---|
216 |
|
---|
217 | //hulp array op true stellen
|
---|
218 | for (int i = 0; i < *AG_pt; i++) {
|
---|
219 | HulpArray[i] = true;
|
---|
220 | }
|
---|
221 |
|
---|
222 | //Gegokte invoer array doorlopen
|
---|
223 | for (int i = 0;i < *AG_pt; i++) { //loop_1
|
---|
224 |
|
---|
225 | //debug (invoer + antwoord laten zien)
|
---|
226 | cout << *(Invoer + i) << " antwoord: " << *(Antwoord + i) << endl;
|
---|
227 | //end debug
|
---|
228 |
|
---|
229 | if (*(Invoer + i) == *(Antwoord + i)) { //getal op de goede plek
|
---|
230 | (*ATJP_pt)++;
|
---|
231 | HulpArray[i] = false;
|
---|
232 | }
|
---|
233 | } //end loop_1
|
---|
234 | for (int i = 0; i < *AG_pt; i++) { //loop_2
|
---|
235 | if (HulpArray[i]) {
|
---|
236 | for (int j = 0; j < *AG_pt; j++) { //loop_3
|
---|
237 | if ((*(Invoer + i) == *(Antwoord + j)) && (HulpArray[j])) { //getal aanwezig
|
---|
238 | (*ATA_pt)++;
|
---|
239 | HulpArray[j] = false;
|
---|
240 | j = *AG_pt; //uit loop_2 stappen, hij mag namelijk maar 1 keer tellen
|
---|
241 | }
|
---|
242 | } //end loop_3
|
---|
243 | }
|
---|
244 | } //end loop_2
|
---|
245 | } //end MastermindBereken
|
---|
246 |
|
---|
247 |
|
---|
248 | //hoofdmodule voor spel mastermind.
|
---|
249 | void MastermindMain() {
|
---|
250 |
|
---|
251 | //variabelen voor invoer
|
---|
252 | int AantalGetallen = 4; //Aantal getallen dat de code lang is
|
---|
253 | int AantalKleuren = 6; //Aantal mogelijkheden per code teken
|
---|
254 |
|
---|
255 | cout << "Geef het aantal getallen ( <20 ) dat u wilt raden (gevolgd door enter): ";
|
---|
256 | if (cin >> AantalGetallen) {
|
---|
257 | if(AantalGetallen > 20) {
|
---|
258 | cout << "Dit is meer als 20" << endl;
|
---|
259 | return;
|
---|
260 | } // end if
|
---|
261 | }
|
---|
262 | else {
|
---|
263 | cout << "Dit is GEEN getal" << endl;
|
---|
264 | return;
|
---|
265 | } // end if
|
---|
266 |
|
---|
267 | cout << "Geef het aantal kleuren ( <20 )dat u wilt raden (gevolgd door enter): ";
|
---|
268 | if (cin >> AantalKleuren) {
|
---|
269 | if(AantalKleuren > 20) {
|
---|
270 | cout << "Dit is meer als 20" << endl;
|
---|
271 | return;
|
---|
272 | } // end if
|
---|
273 | }
|
---|
274 | else {
|
---|
275 | cout << "Dit is GEEN getal" << endl;
|
---|
276 | return;
|
---|
277 | } // end if
|
---|
278 |
|
---|
279 | int Invoer[AantalGetallen]; //Array waar de invoer van de gebruiker wordt opgeslagen
|
---|
280 |
|
---|
281 | //variabelen voor de berekeing
|
---|
282 | bool NogNietGeraden = true; //Waar zolang code (Antwoord) nog niet geraden
|
---|
283 |
|
---|
284 | //variabelen voor uitvoer
|
---|
285 | int AantalTekensJuistePlek = 0; //Pinnetje van de juiste kleur op de juiste plek
|
---|
286 | int AantalTekensAanwezig = 0; //Pinnetje van de juiste kleur, maar niet op de goede plek
|
---|
287 |
|
---|
288 | //variabelen voor antwoord
|
---|
289 | int Antwoord[AantalGetallen]; //array met gezochte antwoorden
|
---|
290 |
|
---|
291 | //antwoord genereren
|
---|
292 | for (int i = 0; i < AantalGetallen; i++) {
|
---|
293 | Antwoord[i] = randomgetal(AantalKleuren);
|
---|
294 |
|
---|
295 | //debug (antwoord laten zien)
|
---|
296 | cout << Antwoord[i] << endl;
|
---|
297 | //end debug
|
---|
298 | } //end for
|
---|
299 |
|
---|
300 | while (NogNietGeraden) { //gebruiker code laten raden
|
---|
301 |
|
---|
302 | MastermindInvoer(&AantalGetallen, &AantalKleuren, Invoer); //gebruikers invoer opvragen
|
---|
303 | MastermindBereken(&AantalGetallen, &AantalTekensJuistePlek, &AantalTekensAanwezig, Antwoord, Invoer); //vergelijking uitvoeren
|
---|
304 |
|
---|
305 | //gebruikers resultaat laten zien
|
---|
306 | if (AantalTekensJuistePlek == AantalGetallen) {
|
---|
307 | cout << "Zeer goed, u heeft het goede antwoord geraden, druk op enter om verder te gaan";
|
---|
308 | cin.get();
|
---|
309 | NogNietGeraden = false;
|
---|
310 | }
|
---|
311 | else {
|
---|
312 | cout << "Aantal op de juiste plek: \t" << AantalTekensJuistePlek << endl;
|
---|
313 | cout << "Aantal niet op de juiste plek:\t" << AantalTekensAanwezig << endl;
|
---|
314 | } //end gebruiker code laten raden
|
---|
315 | } // end while
|
---|
316 | return;
|
---|
317 | } // end MasterMindMain
|
---|
318 |
|
---|
319 | //
|
---|
320 | // == END MASTERMIND ===
|
---|
321 | //
|
---|
322 |
|
---|
323 | //
|
---|
324 | // === SORTEREN GEDEELTE ===
|
---|
325 | //
|
---|
326 |
|
---|
327 | //Een list bestaat uit allemaal vakjes.
|
---|
328 | class Vakje {
|
---|
329 | public:
|
---|
330 | Vakje( );
|
---|
331 | int Getal_int; //Waarde van het vakje
|
---|
332 | Vakje * Volgende_Vakje_pt; //Zijn 'rechterbuur'
|
---|
333 | Vakje * Vorige_Vakje_pt; //Zijn 'linkbuur'
|
---|
334 | };
|
---|
335 |
|
---|
336 | Vakje::Vakje() {
|
---|
337 | Getal_int = 0;
|
---|
338 | Volgende_Vakje_pt = NULL;
|
---|
339 | Vorige_Vakje_pt = NULL;
|
---|
340 | }
|
---|
341 |
|
---|
342 | class listvak {
|
---|
343 | public:
|
---|
344 | //default constuctor (NULL pointers)
|
---|
345 | listvak( );
|
---|
346 | //destructor: niks doen
|
---|
347 | ~listvak( ) { };
|
---|
348 | //creer de list van random lengte met randomgetallen
|
---|
349 | void randomlist();
|
---|
350 | //druk de list van links naar rechts af
|
---|
351 | void drukaf_l_r();
|
---|
352 | //druk de list van recht naar links af
|
---|
353 | void drukaf_r_l();
|
---|
354 | //sorteer de list, volgens bubblesort methode
|
---|
355 | int sorteren();
|
---|
356 | //merge L1 en L2 met opvolgend principe
|
---|
357 | void merge(listvak * L1, listvak * L2);
|
---|
358 | //vernietig de list.
|
---|
359 | void vernietig();
|
---|
360 | private:
|
---|
361 | Vakje * Eerste_Vakje_pt; //pointer naar het eerste vakje
|
---|
362 | Vakje * Laatste_Vakje_pt; //pointer naar het laatste vakje
|
---|
363 | };
|
---|
364 |
|
---|
365 | listvak::listvak( ) {
|
---|
366 | Eerste_Vakje_pt = NULL;
|
---|
367 | Laatste_Vakje_pt = NULL;
|
---|
368 | }
|
---|
369 |
|
---|
370 | //voeg een AantalGetallen_int getallen toe aan de List die door Lbgin wordt gepointerd.
|
---|
371 | void listvak::randomlist() {
|
---|
372 | Vakje * VakjeNew_Vakje_pt;
|
---|
373 |
|
---|
374 | for (int i = 0; i < randomgetal(1000); i++) {
|
---|
375 | VakjeNew_Vakje_pt = new Vakje;
|
---|
376 | VakjeNew_Vakje_pt->Getal_int = randomgetal(10000);
|
---|
377 | if (Eerste_Vakje_pt != NULL) {
|
---|
378 | VakjeNew_Vakje_pt->Volgende_Vakje_pt = Eerste_Vakje_pt;
|
---|
379 | VakjeNew_Vakje_pt->Volgende_Vakje_pt->Vorige_Vakje_pt = VakjeNew_Vakje_pt;
|
---|
380 | }
|
---|
381 | else {
|
---|
382 | Laatste_Vakje_pt = VakjeNew_Vakje_pt;
|
---|
383 | } //end if
|
---|
384 |
|
---|
385 | Eerste_Vakje_pt = VakjeNew_Vakje_pt;
|
---|
386 | } //end for
|
---|
387 | } //end listvak::randomlist
|
---|
388 |
|
---|
389 | //druk de list af van links naar rechts
|
---|
390 | void listvak::drukaf_l_r() {
|
---|
391 | Vakje * Hulp_Vakje_pt = Eerste_Vakje_pt;
|
---|
392 | while (Hulp_Vakje_pt != NULL) {
|
---|
393 | cout << Hulp_Vakje_pt->Getal_int << " ";
|
---|
394 | Hulp_Vakje_pt = Hulp_Vakje_pt->Volgende_Vakje_pt;
|
---|
395 | } //end while
|
---|
396 | } //end listvak::drukaf_lr
|
---|
397 |
|
---|
398 | //druk de list af van rechts naar links
|
---|
399 | void listvak::drukaf_r_l() {
|
---|
400 | Vakje * Hulp_Vakje_pt = Laatste_Vakje_pt;
|
---|
401 | while (Hulp_Vakje_pt != NULL) {
|
---|
402 | cout << Hulp_Vakje_pt->Getal_int << " ";
|
---|
403 | Hulp_Vakje_pt = Hulp_Vakje_pt->Vorige_Vakje_pt;
|
---|
404 | } //end while
|
---|
405 | } //end listvak::drukaf_rl
|
---|
406 |
|
---|
407 | //sorteren volgens de bubblesort methode (grootste getal achteraan)
|
---|
408 | //uitvoer: aantal verwisselingen die plaatsgevonden hebben.
|
---|
409 | int listvak::sorteren() {
|
---|
410 | int Verwisselingen_int = 0;
|
---|
411 | Vakje * BubbleHulp_Vakje_pt = Eerste_Vakje_pt; //Dit is het vakje dat gechecked wordt
|
---|
412 | Vakje * BubbleStop_Vakje_pt = Laatste_Vakje_pt; //Hierna hoeft niet meer gechecked worden
|
---|
413 | Vakje * BubbleVakA_Vakje_pt;
|
---|
414 | Vakje * BubbleVakB_Vakje_pt;
|
---|
415 | Vakje * BubbleVakC_Vakje_pt;
|
---|
416 | Vakje * BubbleVakD_Vakje_pt;
|
---|
417 |
|
---|
418 | //geen waardes dus gelijk stoppen
|
---|
419 | if (Laatste_Vakje_pt == NULL) {
|
---|
420 | return(0);
|
---|
421 | }
|
---|
422 |
|
---|
423 | while (BubbleStop_Vakje_pt->Vorige_Vakje_pt != NULL) {
|
---|
424 | while ( BubbleHulp_Vakje_pt != BubbleStop_Vakje_pt ) {
|
---|
425 | if (BubbleHulp_Vakje_pt->Getal_int > BubbleHulp_Vakje_pt->Volgende_Vakje_pt->Getal_int) {
|
---|
426 | /* Methode voor het omwisselen van vak B en C
|
---|
427 | * Oude situtatie
|
---|
428 | * ___________________________________
|
---|
429 | * | Vorige | Vak Nummer | Volgende |
|
---|
430 | * |========|=============|===========|
|
---|
431 | * | | A | 1->B |
|
---|
432 | * | 2->A | B | 3->C |
|
---|
433 | * | 4->B | C | 5->D |
|
---|
434 | * | 6->C | D | |
|
---|
435 | * ------------------------------------
|
---|
436 | *
|
---|
437 | * Nieuwe situatie
|
---|
438 | * ___________________________________
|
---|
439 | * | Vorige | Vak Nummer | Volgende |
|
---|
440 | * |========|=============|===========|
|
---|
441 | * | | A | 1->C |
|
---|
442 | * | 2->C | B | 3->D |
|
---|
443 | * | 4->A | C | 5->B |
|
---|
444 | * | 6->B | D | |
|
---|
445 | * ------------------------------------
|
---|
446 | *
|
---|
447 | * Uitzondering betreft als A de pointer in het begin is of als
|
---|
448 | * D de eind pointer is.
|
---|
449 | */
|
---|
450 | BubbleVakA_Vakje_pt = BubbleHulp_Vakje_pt->Vorige_Vakje_pt;
|
---|
451 | BubbleVakB_Vakje_pt = BubbleHulp_Vakje_pt;
|
---|
452 | BubbleVakC_Vakje_pt = BubbleHulp_Vakje_pt->Volgende_Vakje_pt;
|
---|
453 | BubbleVakD_Vakje_pt = BubbleHulp_Vakje_pt->Volgende_Vakje_pt->Volgende_Vakje_pt;
|
---|
454 |
|
---|
455 | //Pointer 1,2
|
---|
456 | if (BubbleVakA_Vakje_pt == NULL) {
|
---|
457 | Eerste_Vakje_pt = BubbleVakC_Vakje_pt;
|
---|
458 | BubbleVakC_Vakje_pt->Vorige_Vakje_pt = NULL;
|
---|
459 | }
|
---|
460 | else {
|
---|
461 | BubbleVakA_Vakje_pt->Volgende_Vakje_pt = BubbleVakC_Vakje_pt;
|
---|
462 | BubbleVakC_Vakje_pt->Vorige_Vakje_pt = BubbleVakA_Vakje_pt;
|
---|
463 | } //end if
|
---|
464 |
|
---|
465 | //Pointer 3,4
|
---|
466 | BubbleVakB_Vakje_pt->Vorige_Vakje_pt = BubbleVakC_Vakje_pt;
|
---|
467 | BubbleVakC_Vakje_pt->Volgende_Vakje_pt = BubbleVakB_Vakje_pt;
|
---|
468 |
|
---|
469 | //Pointer 5,6
|
---|
470 | if (BubbleVakD_Vakje_pt == NULL) {
|
---|
471 | Laatste_Vakje_pt = BubbleVakB_Vakje_pt;
|
---|
472 | BubbleVakB_Vakje_pt->Volgende_Vakje_pt = NULL;
|
---|
473 | BubbleStop_Vakje_pt = BubbleVakB_Vakje_pt;
|
---|
474 | }
|
---|
475 | else {
|
---|
476 | BubbleVakD_Vakje_pt->Vorige_Vakje_pt = BubbleVakB_Vakje_pt;
|
---|
477 | BubbleVakB_Vakje_pt->Volgende_Vakje_pt = BubbleVakD_Vakje_pt;
|
---|
478 | } //end if
|
---|
479 |
|
---|
480 | //In het geval dat het vakje van de stop pointer kleiner is als het vakje ervoor,
|
---|
481 | //zal de stop pointer over het nieuwe vakje moeten vallen, anders komt hij het stop
|
---|
482 | //teken nooit tegen.
|
---|
483 | // A B C D
|
---|
484 | // 5 9 7 10
|
---|
485 | // ^ ^
|
---|
486 | // | |Stop pointer
|
---|
487 | // | Huidige Waarde
|
---|
488 | //
|
---|
489 | // ZONDER AANPASSING MET AANPASSING
|
---|
490 | //
|
---|
491 | // A C B D A C B D
|
---|
492 | // 5 7 9 10 5 7 9 10
|
---|
493 | // ^ ^ ^ ^
|
---|
494 | // | |Huidige Waarde | |Huidige Waarde + Stop Pointer
|
---|
495 | // | Stop Pointer |
|
---|
496 | //
|
---|
497 | if (BubbleStop_Vakje_pt == BubbleVakC_Vakje_pt) {
|
---|
498 | BubbleStop_Vakje_pt = BubbleVakB_Vakje_pt;
|
---|
499 | } //end if
|
---|
500 |
|
---|
501 | Verwisselingen_int++;
|
---|
502 | }
|
---|
503 | else {
|
---|
504 | BubbleHulp_Vakje_pt = BubbleHulp_Vakje_pt->Volgende_Vakje_pt;
|
---|
505 | } //end if
|
---|
506 | } //end while
|
---|
507 | BubbleHulp_Vakje_pt = Eerste_Vakje_pt;
|
---|
508 | BubbleStop_Vakje_pt = BubbleStop_Vakje_pt->Vorige_Vakje_pt;
|
---|
509 | } //end while
|
---|
510 | return (Verwisselingen_int);
|
---|
511 | } //end listvak::sorteren
|
---|
512 |
|
---|
513 | void listvak::merge(listvak * L1, listvak * L2) {
|
---|
514 | bool Toevoegen_bool = true; //zolang true bestaan er nog waardes die toegevoegd moeten worden
|
---|
515 |
|
---|
516 | Vakje * HulpL1_Vakje_pt = L1->Laatste_Vakje_pt; //pointer die bijhoudt waar we in L1 zijn
|
---|
517 | Vakje * HulpL2_Vakje_pt = L2->Laatste_Vakje_pt; //pointer die bijhoudt waar we in L2 zijn
|
---|
518 |
|
---|
519 | Vakje * VakjeNew_Vakje_pt; //pointer bij gebruikt wordt bij het maken van nieuwe vakjes
|
---|
520 |
|
---|
521 | while (Toevoegen_bool) {
|
---|
522 | if ((HulpL1_Vakje_pt != NULL) || (HulpL2_Vakje_pt !=NULL)) { //er zijn nog waardes aanwezig
|
---|
523 | VakjeNew_Vakje_pt = new Vakje;
|
---|
524 |
|
---|
525 | if (Eerste_Vakje_pt != NULL) {
|
---|
526 | VakjeNew_Vakje_pt->Volgende_Vakje_pt = Eerste_Vakje_pt;
|
---|
527 | VakjeNew_Vakje_pt->Volgende_Vakje_pt->Vorige_Vakje_pt = VakjeNew_Vakje_pt;
|
---|
528 | }
|
---|
529 | else if (Laatste_Vakje_pt == NULL) {
|
---|
530 | Laatste_Vakje_pt = VakjeNew_Vakje_pt;
|
---|
531 | } //end if
|
---|
532 | Eerste_Vakje_pt = VakjeNew_Vakje_pt;
|
---|
533 |
|
---|
534 | if ((HulpL1_Vakje_pt != NULL) && (HulpL2_Vakje_pt != NULL)) { //beiden bevatten nog een getal
|
---|
535 | if (HulpL1_Vakje_pt->Getal_int > HulpL2_Vakje_pt->Getal_int) {
|
---|
536 | VakjeNew_Vakje_pt->Getal_int = HulpL1_Vakje_pt->Getal_int;
|
---|
537 | HulpL1_Vakje_pt = HulpL1_Vakje_pt->Vorige_Vakje_pt;
|
---|
538 | }
|
---|
539 | else {
|
---|
540 | VakjeNew_Vakje_pt->Getal_int = HulpL2_Vakje_pt->Getal_int;
|
---|
541 | HulpL2_Vakje_pt = HulpL2_Vakje_pt->Vorige_Vakje_pt;
|
---|
542 | } //end if
|
---|
543 | }
|
---|
544 | else if (HulpL1_Vakje_pt != NULL) { //L2 leeg, enkel waardes uit L1 plakken
|
---|
545 | VakjeNew_Vakje_pt->Getal_int = HulpL1_Vakje_pt->Getal_int;
|
---|
546 | HulpL1_Vakje_pt = HulpL1_Vakje_pt->Vorige_Vakje_pt;
|
---|
547 | }
|
---|
548 | else if (HulpL2_Vakje_pt != NULL) { //L1 leeg, enkel waardes uit L2 plakken
|
---|
549 | VakjeNew_Vakje_pt->Getal_int = HulpL2_Vakje_pt->Getal_int;
|
---|
550 | HulpL2_Vakje_pt = HulpL2_Vakje_pt->Vorige_Vakje_pt;
|
---|
551 | }
|
---|
552 | }
|
---|
553 | else { //alles leeg, 'over en sluiten'
|
---|
554 | Toevoegen_bool = false;
|
---|
555 | } //end if
|
---|
556 | } //end while
|
---|
557 | } //end listvak::merge
|
---|
558 |
|
---|
559 | //vernietig de list
|
---|
560 | void listvak::vernietig() {
|
---|
561 | Vakje * Hulp_Vakje_pt;
|
---|
562 | while (Eerste_Vakje_pt != NULL) {
|
---|
563 | Hulp_Vakje_pt = Eerste_Vakje_pt->Volgende_Vakje_pt;
|
---|
564 | delete Eerste_Vakje_pt;
|
---|
565 | Eerste_Vakje_pt = Hulp_Vakje_pt;
|
---|
566 | } //end while;
|
---|
567 | Laatste_Vakje_pt = NULL;
|
---|
568 | } //end listvak::vernietig
|
---|
569 |
|
---|
570 | //
|
---|
571 | // === END SORTEREN ===
|
---|
572 | //
|
---|
573 |
|
---|
574 |
|
---|
575 | //
|
---|
576 | // === MENU GEDEELTE ===
|
---|
577 | //
|
---|
578 |
|
---|
579 |
|
---|
580 | //scherm leegmaken, ivm met verschillen tussen DOS en UNIX de juiste commenten
|
---|
581 | void clearall() {
|
---|
582 | system("cls"); //maakt scherm leeg in Dos
|
---|
583 | system("clear"); //maakt scherm leeg
|
---|
584 | cin.clear(); //maak invoerbuffer leeg
|
---|
585 | cin.ignore(INT_MAX, '\n'); //alles was nog te wachten staat negeren
|
---|
586 | }
|
---|
587 |
|
---|
588 |
|
---|
589 | void SubMenuMasterMind() {
|
---|
590 | MastermindMain();
|
---|
591 | } //end SubMenuMasterMind
|
---|
592 |
|
---|
593 | void SubMenu3keerplus1() {
|
---|
594 | char MenuKeuze = ' ';
|
---|
595 | int lengte, getal;
|
---|
596 | grootgetal BigGetal;
|
---|
597 |
|
---|
598 | while (true) {
|
---|
599 | cout << " --------------------- 3x+1 ----------------- " << endl
|
---|
600 | << "Maak een keuze uit de volgende opties: " << endl
|
---|
601 | << "- Bepaal de lengte, random generatie getal (R/r)" << endl
|
---|
602 | << "- Bepaald de lengte, bepaal het getal zelf (Z/z) " << endl
|
---|
603 | << "- Terug naar Het hoofdmenu (T/t) " << endl
|
---|
604 | << " " << endl
|
---|
605 | << "Keuze: "; cin >> MenuKeuze;
|
---|
606 | clearall();
|
---|
607 |
|
---|
608 | switch (MenuKeuze) {
|
---|
609 | case 't': case 'T': //Terug naar Hoofdmenu
|
---|
610 | return;
|
---|
611 | break;
|
---|
612 | case 'r': case 'R': //Vul L1 random
|
---|
613 | cout << "Vul het aantal elementen in: ";
|
---|
614 | cin >> lengte;
|
---|
615 | BigGetal.vulrandom(lengte);
|
---|
616 | BigGetal.vermoedentest();
|
---|
617 | break;
|
---|
618 | case 'z': case 'Z': //Vul L2 random
|
---|
619 | cout << "Vul het aantal elementen in: ";
|
---|
620 | cin >> lengte;
|
---|
621 | cout << endl;
|
---|
622 | cout << "Vul het getal in: ";
|
---|
623 | cin >> getal;
|
---|
624 | BigGetal.vul(getal,lengte);
|
---|
625 | BigGetal.vermoedentest();
|
---|
626 | break;
|
---|
627 | default:
|
---|
628 | cout << "GEEN GOEDE INVOER ..." << endl;
|
---|
629 | break;
|
---|
630 | } // end switch
|
---|
631 | } // end while
|
---|
632 | } // end Menu3keerplus1
|
---|
633 |
|
---|
634 |
|
---|
635 | void SubMenuSorteren() {
|
---|
636 | char Menukeuze = ' ';
|
---|
637 | listvak L1,L2,L3;
|
---|
638 |
|
---|
639 | while (true) {
|
---|
640 | cout << " ------------- Sorteren --------------- " << endl
|
---|
641 | << "Maak een keuze uit de volgende opties: " << endl
|
---|
642 | << "- Vul L1 random (A/a) " << endl
|
---|
643 | << "- Vul L2 random (B/b) " << endl
|
---|
644 | << "- Vul L3 random (C/c) " << endl
|
---|
645 | << "- Vernietig L1 (D/d) " << endl
|
---|
646 | << "- Vernietig L2 (E/e) " << endl
|
---|
647 | << "- Vernietig L3 (F/f) " << endl
|
---|
648 | << "- Bubblesort L1 (G/g) " << endl
|
---|
649 | << "- Bubblesort L2 (H/h) " << endl
|
---|
650 | << "- Bubblesort L3 (I/i) " << endl
|
---|
651 | << "- Merge L1 en L2 naar L3 (J/j) " << endl
|
---|
652 | << "- Hierbij wordt L1,L2 gesorteerd en L3 gewist " << endl
|
---|
653 | << "- Terug naar Algoritmen (T/t) " << endl
|
---|
654 | << " " << endl
|
---|
655 | << "Keuze: "; cin >> Menukeuze;
|
---|
656 | clearall();
|
---|
657 |
|
---|
658 | switch (Menukeuze) {
|
---|
659 | case 'a': case 'A': //Vul L1 random
|
---|
660 | L1.randomlist();
|
---|
661 | L1.drukaf_r_l();
|
---|
662 | cout << endl <<endl;
|
---|
663 | break;
|
---|
664 | case 'b': case 'B': //Vul L2 random
|
---|
665 | L2.randomlist();
|
---|
666 | L2.drukaf_r_l();
|
---|
667 | cout << endl << endl;
|
---|
668 | break;
|
---|
669 | case 'c': case 'C': //Vul L3 random
|
---|
670 | L3.randomlist();
|
---|
671 | L3.drukaf_r_l();
|
---|
672 | cout << endl << endl;
|
---|
673 | break;
|
---|
674 | case 'd': case 'D': //Vernietig L1
|
---|
675 | L1.vernietig();
|
---|
676 | cout << "L1 vernietiged" << endl << endl;
|
---|
677 | break;
|
---|
678 | case 'e': case 'E': //Vernietig L2
|
---|
679 | L2.vernietig();
|
---|
680 | cout << "L2 vernietiged" << endl << endl;
|
---|
681 | break;
|
---|
682 | case 'f': case 'F': //Vernietig L3
|
---|
683 | L3.vernietig();
|
---|
684 | cout << "L3 vernietiged" << endl << endl;
|
---|
685 | break;
|
---|
686 | case 'g': case 'G': //Bubblesort L1
|
---|
687 | L1.sorteren();
|
---|
688 | L1.drukaf_l_r();
|
---|
689 | cout << endl << endl;
|
---|
690 | break;
|
---|
691 | case 'h': case 'H': //Bubblesort L2
|
---|
692 | L2.sorteren();
|
---|
693 | L2.drukaf_l_r();
|
---|
694 | cout << endl << endl;
|
---|
695 | break;
|
---|
696 | case 'i': case 'I': //Bubblesort L3
|
---|
697 | L3.sorteren();
|
---|
698 | L3.drukaf_l_r();
|
---|
699 | cout << endl << endl;
|
---|
700 | break;
|
---|
701 | case 'j': case 'J': //Merge L1 en L2 naar L3
|
---|
702 | L1.sorteren();
|
---|
703 | L2.sorteren();
|
---|
704 | L3.vernietig();
|
---|
705 | L3.merge(&L1,&L2);
|
---|
706 | cout << endl << endl;
|
---|
707 | L3.drukaf_l_r();
|
---|
708 | cout << endl;
|
---|
709 | break;
|
---|
710 | case 't': case 'T': //Naar AlgoritmeMenu
|
---|
711 | return;
|
---|
712 | break;
|
---|
713 | default:
|
---|
714 | cout << "GEEN GOEDE INVOER ..." << endl;
|
---|
715 | break;
|
---|
716 | } // end switch
|
---|
717 | } // end while
|
---|
718 | } //end SubMenuSorteren
|
---|
719 |
|
---|
720 |
|
---|
721 | void SubMenuAlgoritmen() {
|
---|
722 | char Menukeuze = ' ';
|
---|
723 |
|
---|
724 | while (true) {
|
---|
725 | cout << " ------------- Algoritmen ------------- " << endl
|
---|
726 | << "Maak een keuze uit de volgende opties: " << endl
|
---|
727 | << "->Sorteren (S/s) " << endl
|
---|
728 | << "->3x+1 (X/x) " << endl
|
---|
729 | << "->Terug naar het Hoofdmenu (T/t) " << endl
|
---|
730 | << " " << endl
|
---|
731 | << "Keuze: "; cin >> Menukeuze;
|
---|
732 | clearall();
|
---|
733 |
|
---|
734 | switch (Menukeuze) {
|
---|
735 | case 's': case 'S':
|
---|
736 | SubMenuSorteren();
|
---|
737 | break;
|
---|
738 | case 'x': case 'X':
|
---|
739 | SubMenu3keerplus1();
|
---|
740 | break;
|
---|
741 | case 't': case 'T':
|
---|
742 | return;
|
---|
743 | break;
|
---|
744 | default:
|
---|
745 | cout << "GEEN GOEDE INVOER" << endl
|
---|
746 | << endl;
|
---|
747 | break;
|
---|
748 | } // end switch
|
---|
749 | } // end while
|
---|
750 |
|
---|
751 | } // end SubMenuAlgoritmen
|
---|
752 |
|
---|
753 |
|
---|
754 | void HoofdMenu() {
|
---|
755 | char Menukeuze = ' ';
|
---|
756 | while (true) { //oneindige loop
|
---|
757 | cout << "-----Hoofdmenu----" << endl
|
---|
758 | << "->Algoritmen (a/A)" << endl
|
---|
759 | << "->Mastermind (m/M)" << endl
|
---|
760 | << "->Stoppen (s/S)" << endl
|
---|
761 | << " " << endl
|
---|
762 | << "Keuze: ";
|
---|
763 | cin >> Menukeuze;
|
---|
764 | clearall();
|
---|
765 |
|
---|
766 | switch (Menukeuze) {
|
---|
767 | case 'a': case 'A': //sub menu Algoritmen
|
---|
768 | SubMenuAlgoritmen();
|
---|
769 | break;
|
---|
770 | case 'm': case 'M': //Mastermind
|
---|
771 | SubMenuMasterMind();
|
---|
772 | break;
|
---|
773 | case 's': case 'S': // Stoppen
|
---|
774 | cout << "Goodbye" << endl;
|
---|
775 | return;
|
---|
776 | break;
|
---|
777 | default:
|
---|
778 | cout << "GEEN GOEDE INVOER" << endl
|
---|
779 | << endl;
|
---|
780 | } //end switch
|
---|
781 | } // end while
|
---|
782 | } // end HoofdMenu
|
---|
783 |
|
---|
784 | void IntroScherm() {
|
---|
785 | cout << "---------------------------------------------------" << endl
|
---|
786 | << "| University of Leiden (12-11-2004) |" << endl
|
---|
787 | << "| Programmeermethoden opdracht 3 |" << endl
|
---|
788 | << "| |" << endl
|
---|
789 | << "| Gemaakt door: |" << endl
|
---|
790 | << "| Rick van der Zwet |" << endl
|
---|
791 | << "| Pascal de Vos |" << endl
|
---|
792 | << "| |" << endl
|
---|
793 | << "| |" << endl
|
---|
794 | << "| Getest op: Unix systeem (Sun OS) |" << endl
|
---|
795 | << "| Windows XP (Dev-C++ 4.9.9.0) |" << endl
|
---|
796 | << "| Freebsd 5.2.1-r11 gcc version 3.3.3 |" << endl
|
---|
797 | << "---------------------------------------------------" << endl
|
---|
798 | << endl;
|
---|
799 | }
|
---|
800 |
|
---|
801 | //
|
---|
802 | // === END MENU GEDEELTE ===
|
---|
803 | //
|
---|
804 |
|
---|
805 |
|
---|
806 | int main() {
|
---|
807 | system("cls"); //maakt scherm leeg in Dos
|
---|
808 | system("clear"); //maakt scherm leeg
|
---|
809 | //geen cin.clear(), blijft ie op hangen
|
---|
810 | IntroScherm();
|
---|
811 | HoofdMenu();
|
---|
812 | }
|
---|
813 |
|
---|