[Java] Mastermind in Java

[Verwijderd]

Hoi,
Wij moeten als projectje Mastermind in Java maken (OO).
Nu we zitten vast met het algoritme voor te zien of het pionnetje juist staat...
(pionnetje en kleur juist plaats = zwart || pionnetje juist maar fouter plaats = wit)
Onze code werkt maar half. Als bv de geheime oplossing
1 2 2 0 is en de speler geeft in
3 2 1 4 geeft het spel Zwart en wit terug terwijl er maar 1 juist staat en geen 2de van dezelfde kleur fout...
dit is em:

code:

for(int l = 0; l < 4; l++)
{
   for(int a = 0; a < 4; a++)
     {
if (nummer[l] == keuze[k][a] && nummer[l] == keuze[k][l])
{
plaats++;
}
else
{ 
   if (nummer[l] == keuze[k][a] && nummer[l] != keuze[k][l])
   {
 kleur++;
   }
}
}

Die plaats en kleur worden dan later gebruikt voor eerst zwart en daarna wit terug te geven.
De array keuze is 12*4 en nummer is 4 (dit is de geheime code)
we kijken dus bv nummer[0] == keuze[0][0] ....
volgende zal zijn nummer[0] == keuze[0][1]
Dus elk nummer doorloopt een ingegeven rij en vandaar de dubbel voorkomende Zwarten en witten... heeft iemand een oplossing of tip...??


Bedankt
Wim

[NetForce1]

Op donderdag 14 maart 2002 18:20 schreef Mallo het volgende:
Als bv de geheime oplossing
1 2 2 0 is en de speler geeft in
3 2 1 4 geeft het spel Zwart en wit terug

Ik zie niet wat daar fout aan is.
De 1 die de speler geeft is goed, maar op de foute plaats, dus wit. De 2 die de speler geeft is goed en ook op de goede plaats, dus zwart.

[Ericston]

Tip:
Veel koffie drinken en goed nadenken.

Wat is trouwens het OO gedeelte van je proggel?

[Soultaker]

Code tussen [code] tags, s.v.p. Verder gaat het er natuurlijk om dat je per ingevoerde getal (kleur) van de gebruiker één signaal kan geven: fout (geen staafje), verkeerd geplaatst (wit) of goed (zwart).

De constructie is dus ook simpel: je beschouwt één voor één de door de speler gegeven kleuren en kijkt of deze ofwel direct goed zijn (zwart) en zo niet, of ze dan toch op een andere plaats voorkomen (wit), of zelfs dat niet.

Jouw algoritme doorloopt de kleuren van de oplossing en dat lijkt me niet de juiste manier, aangezien je dan bijvoorbeeld 1 zwarte en 3 witte staafjes uitdeelt als de oplossing 1111 is en de gebruiker 1234 ingevoerd heeft.

Wat je precies wilt berekenen hangt er natuurlijk vanaf hoe je er tegen aan kijkt. Dat is uit je bericht niet duidelijk en ik weet helaas niet uit m'n hoofd hoe dat bij MasterMind zit.

[Verwijderd]

Op donderdag 14 maart 2002 19:17 schreef Soultaker het volgende:
Code tussen [code] tags, s.v.p. Verder gaat het er natuurlijk om dat je per ingevoerde getal (kleur) van de gebruiker één signaal kan geven: fout (geen staafje), verkeerd geplaatst (wit) of goed (zwart).

De constructie is dus ook simpel: je beschouwt één voor één de door de speler gegeven kleuren en kijkt of deze ofwel direct goed zijn (zwart) en zo niet, of ze dan toch op een andere plaats voorkomen (wit), of zelfs dat niet.

Jouw algoritme doorloopt de kleuren van de oplossing en dat lijkt me niet de juiste manier, aangezien je dan bijvoorbeeld 1 zwarte en 3 witte staafjes uitdeelt als de oplossing 1111 is en de gebruiker 1234 ingevoerd heeft.

Wat je precies wilt berekenen hangt er natuurlijk vanaf hoe je er tegen aan kijkt. Dat is uit je bericht niet duidelijk en ik weet helaas niet uit m'n hoofd hoe dat bij MasterMind zit.

Ja sorry maar ik kende da comman code niet!
Euhm mjah je hebt gelijk ik doe het zo en zo loopt het dus mis...
Nu dus wat je voorstelt heb ik ook al anagedacht maar kreeg het niet in Java omgezet.
Dus je moet kijken of je keuze voorkomt in nummer
is dit het geval als dan ze op dezelfde plaats staan zwart anders wit.
is dit juist?

[Verwijderd]

Op donderdag 14 maart 2002 18:52 schreef Ericston het volgende:
Tip:
Veel koffie drinken en goed nadenken.

Wat is trouwens het OO gedeelte van je proggel?

Misschien de pionnen?

[Soultaker]

Op donderdag 14 maart 2002 19:25 schreef Mallo het volgende:
Ja sorry maar ik kende da comman code niet!

Hebben we een TOPIX-FAQ voor, maar vooruit.

Nu dus wat je voorstelt heb ik ook al anagedacht maar kreeg het niet in Java omgezet.
Dus je moet kijken of je keuze voorkomt in nummer
is dit het geval als dan ze op dezelfde plaats staan zwart anders wit.
is dit juist?

Mja, hoewel ik eerst zou checken voor 'zwart' en daarna pas voor 'wit'. Met jou code wordt 't dus zoiets: (niet getest)

code:

for(int i=0;i<4;i++)
{
    if(keuze[k][i]==nummer[i])
        plaats++;
    else
    for(int j=0;j<4;++j)
        if(keuze[k][j]==nummer[i])
        {
            kleur++;
            break;
        }
}

Ik kan me trouwens nettere implementaties voorstellen, maar laten we het niet te ingewikkeld maken.

[Verwijderd]

Makkelijkste is een pionnetje "af te vinken" als je er een zwart/wit pinnetje voor hebt gezet, als je dat dan meeneemt in je if statement, wordt elk pionnetje zeker maar 1 keer bekeken.

[Verwijderd]

By the way:

code:

1 2 2 0
3 2 1 4

Geeft in ieder geval toch echt 1 witte en 1 zwarte! 1 staat verkeerd, en 2 staat goed!

[Soultaker]

Op donderdag 14 maart 2002 20:29 schreef Hieronymus het volgende:
Makkelijkste is een pionnetje "af te vinken" als je er een zwart/wit pinnetje voor hebt gezet, als je dat dan meeneemt in je if statement, wordt elk pionnetje zeker maar 1 keer bekeken.

Dat vind ik maar een vieze hack die nergens voor nodig is. Als je dit soort trucs moet uithalen is dat vaak een teken dat je niet goed over je algoritme nagedacht hebt.

[Verwijderd]

Op donderdag 14 maart 2002 20:31 schreef Hieronymus het volgende:
By the way:

code:

1 2 2 0
3 2 1 4

Geeft in ieder geval toch echt 1 witte en 1 zwarte! 1 staat verkeerd, en 2 staat goed!

Ja soory het mijn algortime geeft 2 witten dat is het probleem....

[Verwijderd]

Op donderdag 14 maart 2002 19:30 schreef Soultaker het volgende:

[..]

Hebben we een TOPIX-FAQ voor, maar vooruit.
[..]

Mja, hoewel ik eerst zou checken voor 'zwart' en daarna pas voor 'wit'. Met jou code wordt 't dus zoiets: (niet getest)

code:

for(int i=0;i<4;i++)
{
    if(keuze[k][i]==nummer[i])
        plaats++;
    else
    for(int j=0;j<4;++j)
        if(keuze[k][j]==nummer[i])
        {
            kleur++;
            break;
        }
}

Ik kan me trouwens nettere implementaties voorstellen, maar laten we het niet te ingewikkeld maken.

Mja dit lijkt ook niet te werken heb nu weer wat tijd om zelf na te denken... maar handige tips zijn nog steeds welkom

[Verwijderd]

Mja deze laatste code ziet er mooier uit
maar stel:
2 0 0 2
en ik geef in
2 4 4 4
dan geeft ie terug 1 zwarte en 1 witte ipv 1 zwarte.
Ik moet in die laatste if-test iets zetten dat ie ervoor zorgt of weet dat die 2 al gezet is ofzoiets...

[Verwijderd]

Dat vind ik maar een vieze hack die nergens voor nodig is. Als je dit soort trucs moet uithalen is dat vaak een teken dat je niet goed over je algoritme nagedacht hebt.

Sja, zonder verdere code van de poster kan ik er ook zo niets voor bedenken. Van wat ik nu zie is het niet eens een echt OO programma. Ik zie in het kleine stukje code niet een object staan, alleen maar wat variabelen.

Nu even nadenken over de code die er staat:

code:

for(int l = 0; l < 4; l++) { // de index van het geheime nummer
  for(int a = 0; a < 4; a++) { // k=huidige keuze, a=index in keuze
    if (nummer[l] == keuze[k][a] && nummer[l] == keuze[k][l]) { // dus eigenlijk het nummer staat erin EN a==l
    plaats++; // nummer op goede plaats
    } else if (nummer[l] == keuze[k][a] && nummer[l] != keuze[k][l]) { // anders: als nummer wel voorkomt en a!=l
    kleur++; // nummer komt voor maar niet op goede plaats
    } // else if
  } // for
} // for

Dit is volgens mij wel recursief te doen, zeer goed zelfs... moet ik ff over nadenken... Edit dit bericht zo wel

Hint aan Mallo: Plaats es wat commentaar bij je code. Welke for-loop doet wat, welke variabele doet wat... En nog belangrijker, indent je code netjes, en zet er [code] tags omheen als je hier post

[Verwijderd]

code:

void recursief(int keuze[][], nummer[], a, l, k, *kleur, *plaats) {
  if(keuze[k][a]==nummer[l]) {
    if(a == l) { 
    plaats++;
    } else { // a != l
    kleur++;
    }
  } else {
    if(l < 4) {
    recursief(keuze, nummer, a, l+1, k, kleur, plaats);
    } else if(a < 4) { // l is rondgeweest, a verhogen
    recursief(keuze, nummer, a+1, 0, k, kleur, plaats);
    }
  }
}

aanroep:
recursief(keuze, nummer, 0, 0, k, var1, var2);

Tadaaa...
Mijn pointers zijn een beetje roestig, dus het kan zijn dat je daar nog ff op moet kloten. idee is gewoon 2 var variabelen meegeven (dus die worden gaandeweg gewijzigd door de loops, en zijn na afloop beschikbaar in var1 en var2)
Ben benieuwd of dit werkt.

edit:
Volgens mij zit hier nog steeds een probleem in... Jeps, volgens mij kan je als je gelijke nummers wilt ondersteunen bijna niet om mijn "hack" heen van bijhouden wat je al afgestreept hebt, en dan wel aan beide kanten! dus nog een extra var meegeven waarin je kijkt en controleert. Ik zie der echt geen andere weg omheen.

[Verwijderd]

code:

        double[] tempKeuze = new double[4];
        double[] tempOpl= new double[4];
        int misleiding = 5;
        boolean antwoord = false;
        
        for(int i = 0; i < 4; i++)
        {
            tempOpl[i] = nummer[i];
            tempKeuze[i]= keuze[k][i];
        }
        
        for(int i=0; i < 4; i++)
        {
            if(tempKeuze[i] == tempOpl[i])
        {
            plaats++;
            tempKeuze[i] = misleiding;
            misleiding++; 
            tempOpl[i] = misleiding;
            misleiding++;
        }
      }
      
      
      
        for(int i = 0; i < 4; i++)
        {
            for(int j = 0; j < 4; j++)
            {
                if(tempKeuze[i] == tempOpl[j])
                {
                    kleur++;
                    tempKeuze[i] = misleiding;
                    misleiding++;
                    tempOpl[j] = misleiding;
                    misleiding++;
                }
            }
        }

Hier is de oplossing, commentaar enzo moet nog komen...
Maar ik maak 2 nieuwe arrays aan zodat ik niet de oorspornkelijke verander en pas deze aan zodat de mogelijkheden kloppen....
Bedankt allemaal voor jullie hulp

[Verwijderd]

Ik geloof je onmiddellijk als je zegt dat dit werkt, want zonder commentaar kom ik er nu ff nie meer uit... En jijzelf over een half jaartje ook nie meer, laat staan de docent voor wie je deze opdracht aan het maken bent.

De oplossing die je nu geeft moet volgens mij heeel gemakkelijk in een recursief dingetje passen... hoef je mijn oplossing maar een klein beetje voor aan te passen...
Wat je bijvoorbeeld kan doen (vuil trucje)

code:

void recursief(int keuze[][], *kopienummer[], a, l, k, *kleur, *plaats) {
  if(keuze[k][a]==kopienummer[l]) {
    if(a == l) { 
    plaats++;
    } else { // a != l
    kleur++;
    }
    kopienummer[l]=-1; // een waarde die niet voor kan komen
    // dit mag omdat je dit cijfer uit het nummer hebt gebruikt
  } else {
    if(l < 4) {
    recursief(keuze, kopienummer, a, l+1, k, kleur, plaats);
    } else if(a < 4) { // l is rondgeweest, a verhogen
    recursief(keuze, kopienummer, a+1, 0, k, kleur, plaats);
    }
  }
}
aanroep:
recursief(keuze, Tempnummer, 0, 0, k, &var1, &var2);

Ik geef geen garantie dat deze code foutloos is, maar wel dattie 100% beter leesbaar is dan jou loops, en een heel stuk sneller

edit:

ff ampersandjes toegevoegd in aanroep, die horen daar, omdat je naar het adres verwijst (als ik mijn pointer leer goed heb onthouden). en je moet natuurlijk niet het echte nummer erin stoppen maar een kopie daarvan...

[krietjur]

Op vrijdag 15 maart 2002 00:33 schreef Hieronymus het volgende:
ff ampersandjes toegevoegd in aanroep, die horen daar, omdat je naar het adres verwijst (als ik mijn pointer leer goed heb onthouden). en je moet natuurlijk niet het echte nummer erin stoppen maar een kopie daarvan...

Euhm.. het gaat hier over Java, en daarin heb je geen pointers..toch?
Correct me if I'm wrong

[Tomatrix]

Op donderdag 14 maart 2002 21:02 schreef Hieronymus het volgende:
Dit is volgens mij wel recursief te doen

Waarom zou je het recursief willen doen?

[Verwijderd]

Euhm.. het gaat hier over Java, en daarin heb je geen pointers..toch?
Correct me if I'm wrong

Kweet het niet meer zeker, is ook alweer ff geleden dat ik een fatsoenlijk java proggie heb geschreven. Der is in ieder geval een manier om zogenaamde VAR variabelen mee te geven. In de meeste prog.talen gebeurt dit dmv pointers

Waarom zou je het recursief willen doen?

Waarom zou je het met 3x2 loops willen doen, als het ook recursief kan? Dit is echt een probleem om juist recursief op te lossen. Je weet exact hoe 'diep' je moet gaan, het is de hele tijd een herhalende bewerking. Toch zonde om dat met een x aantal loops op te lossen als het recursief veel eleganter gaat

[Verwijderd]

C++ code, VAR variabelen in Java?!?

Wij hebben dit project ook moeten maken in Blok 1.1 van de opleiding KennisTechnologie, Universiteit Maastricht.

Wij hebben het toen gewoon ongeveer zo gedaan als jij het al had, alleen een boolean array bijgehouden voor als je in de eerste loop al een pinnetje had gezet.
Voor welke opleiding is het eigenlijk?

Greetz, daRoBBie.

PS: Java heeft inderdaad geen pointers, en wat er met VAR variabelen bedoeld wordt weet ik niet. Als je zoiets als VARIANT bedoeld, no way m8. Java is volledig OO. Je kunt natuurlijk wel objecten van het type Object binnen laten komen, en deze dan weer casten.

[Verwijderd]

Je hebt gelijk, dit is meer C++ code dan java. Maar ja, ik denk native in c++
Maar ja, dan los je het toch op zonder pointers (ik moet in java weer ff inkomen hoor), der is volgens mij wel een mechanisme, maar goed...

Maak gewoon alle integer variabelen, behalve de a, l en k "global", dwz beschikbaar binnen de scope van je functie, en dan is het simpel, geen troep, etc...

code:

void recursief(a, l, k) {
  if(keuze[k][a]==kopienummer[l]) {
    if(a == l) { 
    plaats++;
    } else { // a != l
    kleur++;
    }
    kopienummer[l]=-1; // een waarde die niet voor kan komen
    // dit mag omdat je dit cijfer uit het nummer hebt gebruikt
  } else {
    if(l < 4) {
    recursief(a, l+1, k);
    } else if(a < 4) { // l is rondgeweest, a verhogen
    recursief(a+1, 0, k);
    }
  }
}
aanroep:
recursief(0, 0, k);

Alles opgelost en geen pointers of andere vieze dingen die niet mogen kunnen

[Belgar]

Als meester van de ranzige code moet ik hier toch ff op reageren. Ik zie een hoop conversies etc die niet echt nodig zijn. Ik heb toevallig ooit zo'n code geschreven, en daarbij moest het aantal pinnetjes ook nog in te stellen zijn. In dat geval heb je er VEEL meer aan om de kleuren gewoon een nummer te geven en op nummer de lijst af te werken. het makkelijkst gaat dat in HEX.

bijv

0x76832 kleur 7,6,8,3 en 2

antwoord ook als HEX wegschrijven.

hierna kun je heel makkelijk de loop expanden, de compare gaat dan zo in pseudo:

if (antwoord&(15*16*loop_variabele+1) == code&(15+16*loop_variabele+1)
goed++
endif

om te zien hoeveel kleuren eventueel nog goed zijn:

for loop_variable = 0 tot loop_variabele < aantal_pinnetjes
for loop_variable2 = loop_variable tot loop_variabele2 < aantal_pinnetjes

if loop_variable != loop_variable 2
if (antwoord&(15*16*loop_variabele2+1) == code&(15*16*loop_variabele1+1)
goede_plaats++
endif
endif

endfor
endfor

paar dingetjes moeten mischien omgedraaid worden, maar deze code werkt dus tot 16 pinnetjes en met longints nog eens het dubbele

[/einde zeveren]