Hallo en welkom.
Ik wil graag een oplossing bieden voor de boter-kaas-en-eieren-uitdaging.
Onthoud nu dat er veel zijn oplossingen voor een bepaald probleem.
Dit wordt gewoon mijn oplossing.
Als uw oplossing anders is zolang je goede programmeerpraktijken
volgt en je gebruikt de programmeertaal c op de juiste manier,
dan is dat prima.
Ik geef alleen mijn oplossing.
Ik weet zeker dat het kan worden verbeterd.
Dus laten we beginnen.
Ik ga een nieuwe maken project heet het natuurlijk boter-kaas-en-eieren, en
dat gaan we doen probeer het te moduleren.
Ik heb geprobeerd het op te splitsen zoals ik deed in de beschrijving van de lezing.
ik ga een maken slechts een paar modules of ik moet
zeggen een paar functies.
Hopelijk wordt dit oke en werk goed voor je.
Ik gebruik kameelhoes voor al mijn naamgeving conventies precies wat ik gewend ben.
We zouden zelfs uit elkaar kunnen gaan dit ook in meerdere bronbestanden als
we dat wilden.
Dus we hebben onze belangrijkste.
Laten we van deze print afkomen.
ik ga opnemen een extra omvatten.
Hierdoor kan ik in principe doe wat opruiming van ons systeem en een paar
leuke dingen, sta toe mij ook om ik denk een char te verwijderen.
Dus naast deze 2 bibliotheken, laten we conio opnemen. H.
En wat ik wil doen en ik dit probleem willen aanpakken.
Ik wil proberen te moduleren zoveel als ik kan.
Ik zei dat ik ga om een eendimensionale
array te gebruiken, een tweedimensionale array misschien zelfs beter werken.
Maar ik ga implementeren dit met behulp
van een eendimensionale array die ons spel vertegenwoordigt board, ons boter-kaas-en-eieren-bord.
Ik ga dit maken als globale variabele.
Ik gebruik een globale variabele hier omdat ik
het concept van niet heb gedemonstreerd het doorgeven van gegevens door middel van verwijzing in c.
Ik wil je niet in verwarring brengen.
Ik zou niet globaal hoeven te gebruiken gegevens hier
en ik zou de gegevens kunnen doorgeven aan functies, maar ik zou moet pass-by-referentie gebruiken.
Ik zou moeten passeren tips, en daar hebben we het
nog niet over gehad.
Dus ik ga globale gegevens gebruiken.
Vergeef me, onthoud dat globale gegevens zijn meestal niet goed
om te doen, maar omdat we, nogmaals, proberen demonstreren leren, verdelen heersen en we proberen
te demonstreren hoe functies te gebruiken, ik moet globale gegevens gebruiken omdat
we heb nog niet gesproken over wijzers.
Dus mijn wereldwijde gegevens hier dat ik ga te gebruiken is mijn vierkant dat
mijn raster vertegenwoordigt, mijn boter-kaas-en-eieren bord.
Dit wordt een single dimensionale oppervlakte van
10 elementen voornamelijk omdat I wil het 0-element niet gebruiken.
Ik ga deze array gebruiken om kies nummers om het spel te spelen.
Het gaat ook zorgen voor mij om mijn coördinaten te hebben.
Ik ga dit initialiseren met alleen de waarden 1 tot en met 9.
En dit wordt een karakterarray omdat ik er x's
en o's in moet zetten.
We hebben het nog niet over karakter gehad arrays, maar hierdoor kan ik
enkele tekens plaatsen.
Het is net als het array-concept van ints behalve dat het tekens bevat.
Personages, onthoud, hebben enkele aanhalingstekens om hen heen.
Dus een 2 3 9 de, 0 daar de o ik ga gewoon overslaan,
ik ga niet eens gebruiken, omdat ik die wil gebruiken.
Het maakt het programmeren wat makkelijker.
Ik kan de waarde gebruiken die de gebruiker komt binnen als een index, als een geldige index.
ik moet ook maak 2 globale variabelen voor keuze tijdens de
beurt van de speler.
Dus de keuze wordt wat ze ingevoerd via het toetsenbord, ofwel een tot en met
9, afhankelijk van waar ze willen hun x of o plaatsen.
Speler gaat gewoon vertegenwoordigen wiens speler aan
de beurt is, speler één of speler 2.
Ik heb geen andere globale gegevens nodig.
Ik heb gewoon mijn functie nodig aangiften hier.
ik ga beginnen met het creëren van 3 functies.
Dus ik ga 3 . hebben functieverklaringen.
ik ga er een hebben om te controleren op een overwinning.
Er zullen geen gegevens nodig zijn.
Het gaat een int teruggeven.
Ik ga er een hebben die dat niet doet retourneer alle
gegevens die alleen het bord met de juiste tekens weergeven.
Er zijn ook geen gegevens nodig.
En ik ga ook een functie die gewoon het bord markeert.
Dit vereist de invoer van de gebruiker.
En afhankelijk van wat ze binnenkwamen, het zal een x of o op de juiste plek in
de array plaatsen en vervolgens weergeven die array met behulp van display board.
Dus hier gaan we gewoon zeggen markeringsbord en dat krijgt eigenlijk een
markering met een x of o.
Deze kan ik dus hergebruiken.
Ik kan dit hergebruiken voor speler één of speler 2.
3 functieverklaringen zodat ik kan plaats mijn functies overal in het programma,
ik heb ze bovenaan aangegeven.
En je zult merken dat de 2 van deze functies retourneren geen
gegevens en slechts één neemt een parameter.
Laten we deze functies implementeren voordat we de gameplay implementeren.
Dus laten we eerst implementeren check voor overwinning.
Deze functie gaat in principe: werk waar het het bord gaat controleren om te
zien of er winst is.
Dus het gaat bevatten veel if-statements.
Ik zou waarschijnlijk kunnen verbeteren deze code nogal wat.
Maar ik ga wat opmerkingen plaatsen hier omdat we altijd
opmerkingen bovenaan onze functie moeten hebben.
Deze zijn behoorlijk vereenvoudigd.
We zouden de functienaam moeten hebben.
Dit zegt eigenlijk dat de functie zal een
spelstatus van één teruggeven als het spel voorbij is, vertel je of je gewonnen hebt, een
resultaat van een negatieve als de spel aan de gang is en 0 als het spel voorbij
is en het een gelijkspel was.
Dus deze functie controleert op men retourneert een int.
Dus ik ga vooruit en definieer dit.
En dit alles gaat doen is het gaat naar
de array kijken en kijken of er plekken zijn daarin, als 3x overeenkomt.
Dus er is veel verschillende if-statements.
Dus hoe weten we of een speler er een is.
Nou, we weten of een speler is één als ze overeenkomen in een
rijdiagonaal of een kolom.
Dus we moeten ze allemaal controleren een van die situaties.
En we kennen de rijen in de kolommen op basis van de array.
Dus als mijn vierkant gelijk is naar vierkant 2 en
vierkant 2 is gelijk aan vierkant 3, dat betekent dat we een wedstrijd hebben op onze eerste rij.
Dus ik ga ook maak hier een retourwaarde aan.
Op de top, ik ga gewoon zeggen retourwaarde, initialiseert u deze naar 0.
We zullen dit initialiseren naar 0 voor game over.
En als we een match hebben in de eerste rij, ik
ga er een teruggeven, het spel is voorbij.
We moeten dan een serie hebben van andere andere ifs die overeenkomen en eigenlijk
wil ik niet terugkeren? een Ik wil mijn retourwaarde instellen.
Omdat we konden terugkeren, maar het? maakt het programma moeilijker te volgen.
Anders gaan we check al onze andere rijen.
Dus ik ga kopiëren en plakken hier wat code
omdat het veel overbodige code is.
Het enige dat is interessant is als we een gelijkspel hebben.
Dus laat me alle anders ifs voor winnaars.
En dan ga ik ook verschillende waarden retourneren.
In plaats van een heleboel anders te hebben ifs, ik zou ampersands kunnen hebben,
maar dat is nog moeilijker te lezen.
Dus als we een match hebben op de eerste rij.
En laten we ervoor zorgen dat onze inspringing klopt.
Als we een match op onze tweede rij hebben, dat is wat de tweede doet.
Als we een match hebben op onze derde rij, retourneer een voeg enkele nieuwe regels toe voor
de leesbaarheid, geen haakjes nodig omdat het losse uitspraken zijn.
Op regel 37 lijkt het erop: we matchen een, 4 en 7.
Dit ziet er dus uit als een diagonale overeenkomst, retourneer één.
Veertig, we matchen 2 5 en 8.
Dat ziet eruit als een match van het centrum naar beneden, dus de tweede kolom.
3 6, zie je de ook andere wedstrijden.
We moeten in principe alle wedstrijden vangen voor rijen, kolommen en diagonalen.
En dat hebben we allemaal gedaan deze verklaringen kijken in de array.
Nu is het enige dat ons vertelt of we... geen wedstrijd hebben of we hebben een gelijkspel, we moeten
ze allemaal vergelijken en zorg er in feite voor dat dit niet de nummers
zijn die zijn geïnitialiseerd.
Dus als we ons matrixvierkant hebben en het bevat geen 1 2 3 1 2 3 4 5 6
8 of 9 voor een van de waarden, dat betekent dat we een gelijkspel hebben omdat ze
een 0 of een x bevatten.
Dus kunnen we nog een ander schrijven
als dat in feite zegt dat het gelijkspel is en we de retourwaarde kunnen instellen naar 0, retourwaarde gelijk aan 0.
En nogmaals, dit is gewoon in wezen dit als laatste controleren, anders als,
als de nummers hetzelfde zijn zoals ze zijn geïnitialiseerd.
Als ze allemaal anders zijn, dan? dat betekent dat we 0 kunnen retourneren.
Laten we dat er een op zetten.
Anders, als we geen a . hebben loting en we hebben geen winnaar, dat betekent
dat we nog niet klaar zijn.
Dus een laatste else-verklaring kan gewoon zeggen: retourwaarde is gelijk aan een negatieve.
Want onthoud, de functie is: een negatief teruggeven voor het
spel in uitvoering een voor het spel is voorbij en 0 voor spel zonder resultaat.
En dan het laatste wat ik wil doen is Ik wil de geretourneerde waarde retourneren.
Dus hier ga ik gewoon naar toe zeg retour, retourwaarde.
En dit zal de functie voltooien.
En wat merk je wanneer? we doen dit, we zijn aan
het verdelen en heersen.
Alles waar we ons op focussen is juist controleert nu het bord om te zien of
er een overwinning is.
We zouden in het klein werken brokken zoals deze en we
zouden constant testen.
Hierdoor kunnen wij ons focussen op onze ontwerp en stelt ons ook in staat om onze fouten
gemakkelijker te verminderen of te isoleren.
Nu we klaar zijn met de spelbord, willen we doorgaan
en het weergavebord implementeren.
Het displaybord is gewoon: gaat het bord laten zien.
Dus alles wat dit echt hoeft te doen is teken de array in een specifiek formaat.
Dus we gaan schrijven a functie genaamd display board.
Het gaat geen gegevens teruggeven, er zijn geen parameters voor nodig.
De reden dat het een functienummer is een
daarvan is omdat we het bord vaak moeten tekenen en het is ook gewoon beter
omdat het een specifieke taak uitvoert.
Nu gaat deze het gewoon hebben een heleboel printf-functies erin.
En het zal hebben een hoop opmaak.
Dus ik ga het kopiëren en plakken.
Wat hier uniek is, is Ik maak het scherm elke keer leeg.
Maar als je systeem zegt en windows en je zegt cls, dat maakt
het scherm leeg.
Het maakt het alleen maar schoner.
We gaan dan gewoon doe een heleboel printfs.
We gaan de titel van het spel uitprinten. We gaan speler 1 en 0 uitprinten.
En dan gaan we om het bord uit te printen.
Het bord wordt mooi opgemaakt met een paar parallelle staven en
dan gaan we de . afdrukken waarden van alle waarden in de array.
En als de waarde x of . is 0, het wordt weergegeven.
Als dit niet het geval is, wordt een weergegeven nummer zodat we dat nummer kunnen gebruiken
om onze optie om te tekenen te selecteren en dat is het, dat is alles wat deze functie doet.
Nu we klaar zijn met als we het
bord weergeven, willen we nu onze laatste functie maken die het bord markeert.
Dus mark board gaat set de array met een bepaalde waarde,
en het gaat typen een teken in een x of een o.
Er zal dus een karakter voor nodig zijn.
Wat dit gaat doen is het zal
een heleboel andere else if-statements hebben.
Dus hier in ons markeringsbord zijn
we wil eigenlijk wat opmerkingen geven en zeggen dat dit gaat het bord
instellen met het juiste teken x of o op de juiste plek in de array.
Dus hopelijk is dat logisch.
Zoals je de code ziet I moet mijn opmerkingen beëindigen.
Ik wil het mooi formatteren dus het zijn hier 2 regels.
En dit gaat allemaal gebeuren gaat het
controleren om te zien wat de gebruiker heeft ingevoerd.
Dus onthoud, we hebben 2 globale gegevens waarden voor wat de gebruiker heeft ingevoerd.
We hebben ook een waarde voor de huidige speler.
Dus de keuze zal in principe zijn wat er via het toetsenbord wordt ingevoerd.
We hebben dit nog niet geïmplementeerd omdat we dat in
de hoofdfunctie gaan implementeren.
Speler wordt de huidige speler.
We hebben beide nodig hiervan om onze stempel te drukken.
Dus wat we gaan doen, is dat we ik ga
een heleboel else-statements hebben, if else-statements.
We gaan de keuze controleren, dat is wat de gebruiker invoert.
En als de keuze gelijk is aan 1, we iets in dat vierkant willen tekenen.
We willen er ook zeker van zijn dat dat plein beschikbaar is.
Dus als het gelijk is aan 1 en het is niet momenteel gelijk aan 1, dat betekent dat
in feite iemand al een x . heeft gezet of een o daar en we kunnen het niet gebruiken.
Als het gelijk is aan een en zij één hebt ingevoerd, betekent dit dat we de
array op een specifieke waarde kunnen instellen.
We gaan de array instellen op wat werd doorgegeven in ofwel de o de x.
En we gaan het herhalen om dit voor elke keuze te doen.
Als het keuzes 2 3 4 5 6 8 of 9 zijn.
Dus een heleboel andere ifs die hetzelfde doen.
Als de gebruiker keuze 2 heeft ingevoerd, zijn we: ga ervoor zorgen dat
de inspringing goed is en vierkant 2 beschikbaar is, we gaan vierkant 2 markeren met wat we
hier hebben doorgegeven.
En afhankelijk van welke speler aan de beurt is is, we gaan een of een x doorgeven.
Nu het laatste wat we moeten doen in deze functie moeten we valideren.
Als ze ergens in geslaagd zijn anders dan één tot en met 9,
dan is dat een ongeldige zet.
Dus onze laatste else-verklaring hier zal een bericht worden afgedrukt met de melding ongeldige zet, het zal markeer
de speler één.
Want onthoud spelers zijn één of 2.
En we gaan de speler markeren terug en dan gaan we het verhogen
in onze lus op onze hoofdfunctie.
En dan krijg je dit laatste char pauzeert gewoon het programma zodat
de gebruiker op . moet drukken terugkeer na ongeldige zet.
Anders zou een ongeldige zet worden weergegeven en dan zou het onmiddellijk
worden gewist omdat we zouden het bord opnieuw tekenen.
Dus laat char het pauzeren.
Het dwingt je om op de enter-knop te drukken om verder te gaan om een andere waarde in te voeren.
En dit zijn onze 3 functies.
Onthoud, deze functie geeft niets terug.
Dus we kunnen het onderaan houden.
Nu moeten we eigenlijk het spel uit te voeren.
Het spel gaat in de hoofdfunctie.
Dus voor de gameplay, dit is waar we gaan de gebruiker vragen een getal in te
voeren, we gaan de . tekenen board, we gaan controleren op winst.
Dus we gaan 2 . maken lokale variabelen hier, en
we gaan onze speler initialiseren.
Hier gaan we naar toe maak ons geheel getal I.
Dit wordt gebruikt voor onze lus.
En ons cijfer wordt ofwel x of o, afhankelijk van wiens beurt het is.
Mark wordt x of o geloof ik.
Mark wordt x of o.
En de keuze wordt wat de gebruiker komt binnen via het toetsenbord.
Dus 2 lokale variabelen.
We gaan ook onze player, wat een globale variabele is.
In eerste instantie gaat het gewoon wees speler één om het spel te starten.
Dan krijgen we een lus.
We gaan in principe een een lus totdat we klaar zijn met spelen.
Ik ga een do while gebruiken loop hier omdat ik wil dat
het minstens één keer wordt uitgevoerd.
Ik wil de . weergeven minstens één keer aan boord.
Dus ik ga de . weergeven bord en
speel het spel totdat ik in feite gelijkspel of win.
Dus ik ga het zo lang doen zoals I is gelijk aan min 1.
Wat stelt een min 1 voor, het geeft aan dat het spel bezig is.
Ik zal de terugkeer zijn waarde voor het controleren op winst.
En dat zul je zo zien, maar eigenlijk
als ik een lus heb die steeds hetzelfde blijft doen en over tot het spel voorbij is.
En het spel gaat worden over als het niet negatief is.
Dus wat moeten we eerst doen.
Het eerste wat we moeten doen is we moeten het bord laten zien.
Dus ik kan gewoon bellen met de functie display bord.
Dan moeten we de speler berekenen.
En de speler begint met speler één.
Wat we hier gaan doen
is we gaan een ternaire operator gebruiken, en we gaan zeggen: als de speler mod 2 is,
dan is de speler gelijk aan 1 anders is gelijk aan 2.
Dit is een manier om te bepalen de juiste speler.
Elke iteratie van de lus gaat om van één naar 2 of van 2 naar één te veranderen.
Als het begint als speler één, het gaat om speler mod
2 te zeggen, één gedeeld door 2 of de rest van één gedeeld door 2 is wat, één.
Dus als het er een is, ben je speler één wordt.
En als je teruggaat voor de volgende iteratie
wordt speler gelijk aan 2 omdat we gaan het verhogen.
2 mod2 is 0.
Dus als het niet gelijk is aan één, dan wordt speler
gelijk aan speler 2.
Het gaat alleen om het in te stellen op speler één als speler mod 2 één is.
Onthoud, die draaier exploitant hopelijk.
Het volgende wat ik moet doen is I input van de gebruiker nodig hebben.
Dus hier ga ik zeggen, ik ga om de gebruiker te vragen een nummer in te voeren.
Ik ga zeggen speler procent d ofwel speler 1 of 2, voer een nummer in, en dan ga ik de speler plaatsen
om uit te printen, speler één of 2.
Dan ga ik de lezen invoer van de gebruiker met scanf.
En dat wordt een geheel getal, dat zal een plek op
het bord één tot en met 9 vertegenwoordigen.
En ik ga opslaan dat in mijn keuzevariabele.
Keuze is een inch, dus ik moet het adres doorgeven, en
ik moet zeggen keuze.
Alleen als het een string is, zou ik dat doen het adres niet doorgeven.
Dan kan ik in principe bepalen al dan niet wat het merkteken is.
Ik moet bepalen of het merk is een x of nee op basis van de speler.
Dus ik ga de . gebruiken ternaire operator opnieuw.
En ik ga toewijzen om een x of o te markeren.
Als de speler gelijk is aan 1, ga ik toewijzen om de x, hoofdletter x te markeren.
Anders ga ik geef het een o, hoofdletter o.
Dus deze ternaire operator is erg handig wanneer u variabelen moet
toewijzen op basis van een voorwaarde.
Nogmaals wat dit zegt is als de speler gelijk is aan 1,
zal mark gelijk zijn aan x.
Anders wordt het gelijk aan o.
Het vraagteken staat voor als de Booleaanse evaluatie is waar, de dubbele punt
geeft aan of het onwaar is.
Nu ik de juiste brief heb gekregen, Ik kan mijn functie voor
het markeren van het bord oproepen door gewoon mark te zeggen bord, waarbij de x of de o wordt doorgegeven.
Nadat ik het bord heb gemarkeerd en zij hun selectie hebben gemaakt,
moet ik kijken of er een winnaar is.
Ik heb mijn variabele I die zou
eigenlijk een betere naam moeten zijn.
Noem het statuscontrole, spel controleer hoe zit dat of spelstatus.
En de spelstatus wordt gelijk is aan één negatieve één of 0.
Spelstatus gaat naar gelijk zijn aan wat er wordt geretourneerd door
de cheque om te winnen.
Want onthoud, deze functie zal: retourneer een één een 0 of een negatieve één.
Een als het spel voorbij is het resultaat, negatief als het spel aan de gang is, 0 als
het voorbij is zonder resultaat.
Dus nu we het spel hebben opgeslagen status, willen we ook de
toestand van de lus wijzigen.
Dus als de spelstatus is gelijk is aan min één, dan
springen we uit de lus.
Anders hoeven we alleen maar te doen is de beurt van de speler.
Hoe veranderen we de beurt van de speler, we verhogen de speler gewoon met één.
Zo gaat het de volgende keer omhoog en het zal 2 zijn, en speler zal gelijk
zijn aan 2 en we gaan terug naar beneden.
Wat als ze ongeldige pogingen doen? gebeurt in de ongeldige sjablonen,
wordt het aantal spelers verlaagd.
Wanneer u het aantal spelers verlaagt, je gaat terug naar de juiste speler.
Dus als het er één is, verlaag je het naar 0, de volgende beurt zal er één zijn,
het is in wezen weer dezelfde beurt.
Daarom verhogen we het.
Als het nu speler 2 is, we verhogen het met één.
En wat er gebeurt is 2 gedeeld 2 is 0.
Dus het zet eigenlijk in de speler terug naar één.
Zo werkt dat.
Maar dit is allemaal de logica.
We hebben hier veel gedaan.
Je moet niet alles schrijven deze code en test tegelijk.
Je had moeten werken met het verdeel en heers, constant testend terwijl
je de code uitvoert.
Nu ga ik bieden deze oplossing, maar laten we het
uitvoeren en testen.
Het gaat werken zoals het deed in de demo van de challenge lezing.
Maar nogmaals, bestudeer deze code en maak weet je zeker wat er aan de hand is.
Het gebruik van arrays en het verdelen veroveren aanpak, maar kijk eens hoe
mooi deze hoofdmethode eruit ziet.
Het is heel gemakkelijk om te weten wat er is gebeurt in de hoofdmethode.
Toon bord, wissel van speler en jij wil hier waarschijnlijk opmerkingen plaatsen.
Verander van beurt, en dan krijg ook hier input.
En stel dan de juiste in letter, stel het juiste teken in op
basis van de beurt van de speler.
Je hebt niet eens echt nodig deze opmerkingen
omdat de functies zo beschrijvend zijn.
Markeer bord, stel het bord in op basis van de gebruikerskeuze of ongeldige keuze.
En dan de spelstatuscontrole om te winnen, spreekt voor zich.
En dan springen we eruit als het spel afgelopen is.
Laten we dit bouwen.
Hopelijk krijg je geen fouten, nee waarschuwingen, dat doen we niet, wat leuk is.
Laten we het nu uitvoeren en je gaat zie dat het net zo werkt als in onze demo.
Het eerste wat het doet is het scherm gaat weergeven.
En het zal toestaan ons om een enter af te drukken.
En het heeft ons raster, één 2 3 4 5 6 7 8 9 ons assortiment.
Dus het vertelt me speler één voer iets in en ik
voer iets geldigs in.
En het tekent het, en het maakt het scherm leeg.
Dus het ziet er leuk uit.
En nu is er een x in 3.
Nu is het de beurt aan speler 2.
Ik ga iets ongeldigs laten doen.
Het zegt ongeldige zetten, het pauzeert.
Ik druk op Return, ik krijg om weer te gaan speler 2.
Nu raak ik er een, hertekent met de o op de ene plek.
En ik ga hiermee door tot we hebben een winnaar of een verliezer.
Dus laten we zorgen voor een winnaar voor o zo.
Nu wordt x, 2 o is wordt 5, x wordt 6
en o wordt 9.
Game over, want we hebben net 3 0'en getrokken.
Dus het enige wat ik vergat was na de while-lus om de
gewonnen felicitaties weer te geven.
En alles wat we daar hoeven te doen is we moeten de spelstatus controleren.
Als de spelstatus gelijk is aan één, dat betekent een speler één en het zou de
laatste speler zijn die wint.
Dus we zouden uitprinten speler procent d wint.
Anders gaan we om gewoon een gelijkspel uit te printen.
Want als we uit onze lus zouden raken en de status was
negatief, we weten dat het spel voorbij was en had een resultaat, het zou
kunnen, dus we moeten dat laatste hebben als statement om de resultaten weer te geven.
Dus laten we het nu opnieuw als een winnaar uitvoeren.
En nu gaan we eigenlijk iemand zien winnen.
Dus ik ga gewoon geldig invoeren getallen hier, zorgen
voor een quick win voor x en moeten het hier echt in doen programma omdat die weggaat.
Daar gaat het, speler één wint en het speelde daar nog een mooi geluid.
Dit was dus een lange lezing.
Mijn excuses voor de lange lezing.
Bestudeer deze code, ik zal geef het op als een bronbestand.
Hopelijk leer je er veel over methoden van verdeel en heers.
Dank u