# MasterMind



## girl.power (22. Jun 2011)

Ich hab da mal ne frage 

also ich programmier gerade mastermind. Dabei muss ich ja logischer weise die Zufallszahlen am anfang festlegen, darf sie aber erst am schluss anzeigen.
Ich vermute der PC speichert diese zufallszahlen aber wie kann ich das verzögern, bzw wie mach ich das das diese zahlen erst später angezeigt werden??

danke für die hoffentlich hilfreichen beiträge  :toll:


----------



## Andi_CH (22. Jun 2011)

Was hast du denn schon geschrieben? Was willst du verzögern???:L 

Ähm - Hast du schon einmal ein "hello world" geschrieben?


----------



## girl.power (22. Jun 2011)

ja hab ich schon..

bis jetzt hab ich nur die oberfläche zum größten teil fertig und die zufallszahlen programmiert.. 
ich weis noch nicht einmal wie ich die zwei zahlen vergleichen kann, weil ich ja nicht weis wo die zufallszahlen stehen.. aber hier mein programm der zufallszahlen:

```
public MasterMind()                            
    {
        Random generator= new Random (9);          
        
        for(int i=0; i<4; i++)                      
        {                                           
            Zufallszahlen[i] = generator.nextInt(9);
        }

       
        
    }
    
    
    
    
    public static void main(String[] args) {       
    String name1;
    String name2;
    Random generator= new Random (9);
    int num1;
    name1= new String ();
    name2= new String ();
    num1= generator.nextInt(9);
    
    }
```


----------



## chalkbag (22. Jun 2011)

Mir ist jetzt unklar, was uns dein Code sagen soll.

Der Konstruktor von MasterMind erstellt 4 Zufallszahlen und speichert sie in ein Array.

Deine Main-Methode erstellt zwei leere String (umständlich über 4 Zeilen, warum auch immer) sowie eine Zufallszahl num1.

Ich sehe weder eine graphische Oberfläche noch wo du die Funktionalität von MasterMind nutzen würdest.

So atme bitte erstmal tief durch, denke ein paar Minuten darüber nach was du erreichen willst und wo überhaupt ein Problem / eine Unklarheit besteht. Dann kannst du eine Frage stellen die wir hoffentlich verstehen und somit beantworten können.

[Edit]
ich weiß das machen nur so Anfänger wie ich, aber zeichne den typischen Programmablauf von MasterMind doch mal auf (d.h. Papier + Stift), sehr beliebt ist hier UML insbesondere die Ausprägung Sequenzdiagramm


----------



## Shulyn (22. Jun 2011)

girl.power hat gesagt.:


> [..]
> ich weis noch nicht einmal wie ich die zwei zahlen vergleichen kann
> [..]



Zahlen vergleicht man mit dem opperator " == ".
[Java]
int i = 3;
int k = 4;

if ( i == k ) {
// Do something
} else {
// Do something
}
[/Java]

Strings (Objecte im allgemeinen) vergleicht man mit .equals
[Java]
String vorname = "hans";
String nachname = "meier";

if( vorname.equals(nachname) ) {
    // do some....
}
[/Java]


Zu deinem Programm :

[Java]
public MasterMind()                            
    {
        Random generator= new Random (9);          

        for(int i=0; i<4; i++)                      
        {                                           
            Zufallszahlen_ = generator.nextInt(9);
        }       
    }
[/Java]

In dem Konstruktor erzeugst du 4 Zufallszahlen. In dem Array : * Zufallszahlen *. Leider können wir die deklaration von diesem NICHT erraten. Aber gehen wir von folgendem fall aus :

[Java]
Class Mastermind  {
 public Integer[] Zufallszahlen = new Integer[4];  // varriablen schreibt man klein...
}
[/Java]

dann könntest du z.B. so darauf zugreifen :

[Java]
public static void main(String args[]) {
    MasterMind mM = new MasterMind();
    System.Out.Println(nM.Zufallszahlen[0]);
    System.Out.Println(nM.Zufallszahlen[1]);
    System.Out.Println(nM.Zufallszahlen[2]); 
    System.Out.Println(nM.Zufallszahlen[3]);
}

[/Java]_


----------



## Corben (24. Jun 2011)

Hallo,
da es schon so viele Threads zu Mastermind gibt, schreib ich die kleine Frage mal in diesen.

Also ich bin dabei das Getippte mit der Lösung zu vergleichen um die direkten und indirekten Treffer zu ermitteln.
Ich weiß nicht wie ich das machen soll, damit wirklich nur alles einzelt gezählt wird.

Ich hab folgendes, durch 
	
	
	
	





```
if (pos==i){}
```
 gehn jetzt echt viele Fälle  aber halt nich alle.
Thx für die Hilfestellungen von euch :applaus:


```
public Bewertung bewerte(Muster versuch) {
		int sw=0, ws=0;
		int pos=0;
		for(int i=0; i<4; i++){
			for(int j=0; j<4; j++){
				if (farben[i]==versuch.farben[j]){
					if(i==j){
						sw++;
					}
					else {
						if (pos==i){}
						else{
							ws++;
							pos=i;
						}
					}											
				}
			}
		}
		System.out.println("ws: "+ws);
		System.out.println("sw: "+sw);
		ws-=sw;
		if (ws<0)
			ws=0;
		Bewertung a = new Bewertung(sw,ws);
		return a;
}
public static void main (String[] args){
		Muster a1 = new Muster (0,0,1,1);
		Muster a2 = new Muster (0,1,0,1);
		System.out.println("a1: "+a1);
		System.out.println("a2: "+a2);
		System.out.println(a1.bewerte(a2));		
		
	}
```


----------



## Firephoenix (24. Jun 2011)

Hi,
ich hab auf der basis von super-mastermind mal einen solver geschrieben der immer gewinnt egal was man ihm vorsetzt 
Mein Ansatz da war, dass ich die Ausgabe wieviele richtig und falsch sind in deinem Checker-Objekt zusammenfasse, ein Checker zusammen mit einem Versuch (also bei super 5 gesetzte Farben) ergibt dann jeweils einen Spielzug.
Beim überprüfen der Farben habe ich jeweils boolean-arrays benutzt um zu prüfen ob eine Farbe schonmal genommen wurde.
Farben habe ich dabei direkt als Int gespeichert (1= z.b. rot, 2 = blau usw).
Jeweils ein Array aus 5 Farben ergibt dann eine Kombination.
Die Methode hat dann den 2 Kombinationen bekommen (den Versuch und die Lösung) und daraus meinen Checker erstellt.
Ich habs dir mal auf die int[] Arrays umgeschrieben, bei mir sieht da so aus:

```
public static void main(String[] args) {
		int[] result = generateCheckerPseudocode(new int[]{1,1,1,2,1}, new int[]{1,2,1,4,5});
		System.out.println("Correct:"+result[0]+", Wrong Position:"+result[1]);
	}
	
	public static int[] generateCheckerPseudocode(int[] combination, int[] correctCombination) {
		int correct = 0;
		int badPos = 0;
		boolean[] checked = new boolean[correctCombination.length];
		boolean[] used = new boolean[combination.length];
		//Nach gleichen suchen
		for(int i = 0; i < combination.length; i++){
			if(combination[i] == correctCombination[i]){
				correct++;
				checked[i] = true;
				used[i] = true;
			}
		}
		//Nach falschen Positionen suchen
		for(int i = 0; i < combination.length; i++){
			for(int j = 0; j < correctCombination.length; j++){
				if(j == i || checked[j] || used[i]){
					continue;
				}else{
					if(combination[i] == correctCombination[j] && !checked[j]){
						badPos++;
						checked[j] = true;
						break;
					}
				}
			}
		}
		return new int[]{correct, badPos};
	}
```

Die Ausgabe dazu wäre:


> Correct:2, Wrong Position:1


Gruß


----------

