Enum Array Rekursiv abarbeiten

[ocsme]

Guten Tag zusammen,

ich hab ein Problem und zwar benötige ich eine Rekursive Funktion um ein Array Feld abzulaufen.
Wieso ich das benötige ist weil wir das Spiel Master Mind implementieren müssen. Nun habe ich mir eine Enum-Klasse Namens: MasterMindColour angelegt. Dort sind Farben drin.

Jetzt habe ich folgenden Code erstellt:

        mmc[0]=MasterMindColour.RED;
        mmc[1]=MasterMindColour.BLUE;
        mmc[2]=MasterMindColour.RED;
        mmc[3]=MasterMindColour.BLUE;
       
        MasterMindColour[] gamer=new MasterMindColour[4];
        gamer[0]=MasterMindColour.YELLOW;
        gamer[1]=MasterMindColour.BLACK;
        gamer[2]=MasterMindColour.BLACK;
        gamer[3]=MasterMindColour.RED;
       
        System.out.println(finde(mmc,gamer));

public static MasterMindColour finde(MasterMindColour[] codier, MasterMindColour[] gamer) {
       
        for(int j=0;j<codier.length;j++)
            for(int k=0;k<gamer.length;k++) {
                if(j==k && codier[j].ordinal()==gamer[k].ordinal())
                    return MasterMindColour.BLACK;
                else if(codier[j].ordinal()==gamer[k].ordinal())
                    return MasterMindColour.WHITE;
            }
       
        return null;
    }

Da ich in der finde Methode die Farbe zurück gebe springt er nach dem Return ja raus. Was ich noch tun könnte wäre ein weiteres Array anlegen dieses zurück gebe mit den Werten drin Das sollte nicht schwer sein aber ich wollte es Rekursiv versuchen.
Doch mein Problem ist dann schon die übergab wie muss das hier heißen: finde(MasterMindColour[] codier, MasterMindColour[] gamer)?

Kann mir jemand weiter helfen?


LG

 

[ocsme]

Irgendwas stimmt nicht.
Ich wollte es jetzt versuchen mit der Rückgabe eines Arrays doch bei gleichen Werten kommt nur "misst" raus

Hier mal meine Codes
enum Klasse:

public enum MasterMindColour {
    RED (true), BLUE(true), GREEN(true), ORANGE(true), YELLOW(true), VIOLET(true), BLACK(false), WHITE(false);
   
    private final boolean show;
   
    boolean getShow() {
        return show;
    }
   
    MasterMindColour (boolean show) {
        this.show=show;
    }
   
    boolean equals(MasterMindColour m) {
        return this.ordinal()==m.ordinal();
    }
   
    }

Hauptprogramm:

import java.util.Scanner;

public class MasterMind {
  public static MasterMindColour[] finde(MasterMindColour[] codier, MasterMindColour[] gamer) {
        MasterMindColour[] back=new MasterMindColour[gamer.length];
       
        for(int j=0;j<codier.length;j++)
            for(int k=j;k<gamer.length;k++) {
                System.out.println(j+" "+k);
                if((j==k) && (codier[j].equals(gamer[k])) )
                    back[j]=MasterMindColour.BLACK;
                else if(codier[j].equals(gamer[k]))
                    back[j]=MasterMindColour.WHITE;
                else back[j]=null;
            }
       
        return back;
    }
   
    public static void main(String[] args) {
        Scanner input= new Scanner(System.in);
        MasterMindColour[] mmc = new MasterMindColour[4];
       
        System.out.println("Es stehen folgende Farben zur verfuegung: ");
        for(MasterMindColour m: MasterMindColour.values())
            if (m.getShow())
                System.out.print(m+" "+m.ordinal()+" ");
       
        System.out.println();
        mmc[0]=MasterMindColour.RED;
        mmc[1]=MasterMindColour.BLUE;
        mmc[2]=MasterMindColour.RED;
        mmc[3]=MasterMindColour.BLUE;
       
        MasterMindColour[] gamer=new MasterMindColour[4];
        gamer[0]=MasterMindColour.RED;
        gamer[1]=MasterMindColour.BLUE;
        gamer[2]=MasterMindColour.RED;
        gamer[3]=MasterMindColour.BLUE;
       
        for(int i=0;i<mmc.length;i++)
            for(int j=i;j<gamer.length;j++) {
                if(mmc[i].equals(gamer[j]))
                    System.out.println("treffer"+i+" "+j);
            }
       
       
        MasterMindColour[] spielstand=finde(mmc,gamer);
        for(MasterMindColour m: spielstand)
            System.out.println(m);
    }

}

Da die Eingaben Theoretisch Identisch sind müsste dort 4x BLACK stehen doch das tut es bei mir nicht es steht dort:
null
WHITE
null
BLACK

Danke im voruas

LG

 

[ocsme]

Es hat in der Methode ein abbruch gefehlt somit läuft jetzt wenigstens die Methode

public static MasterMindColour[] finde(MasterMindColour[] codier, MasterMindColour[] gamer) {
        MasterMindColour[] back=new MasterMindColour[gamer.length];
        boolean abbruch=false;
        for(int j=0;j<codier.length;j++,abbruch=false)
            for(int k=j;!abbruch&&k<gamer.length;k++) {
                System.out.println(j+" "+k);
                if((j==k) && (codier[j].equals(gamer[k])) ) {
                    back[j]=MasterMindColour.BLACK;
                    abbruch=true;
                }
                else if(codier[j].equals(gamer[k])) {
                    back[j]=MasterMindColour.WHITE;
                    abbruch=true;
                }
                else back[j]=null;
            }
       
        return back;
    }

 

[mihe7]

Ist es beabsichtigt, dass der letzte Stift nicht weiß werden kann?

 

[ocsme]

Nein das ist nicht beabsichtigt Ich bekomme es gerade nicht hin.
Werde es morgen früh wieder weiter probieren
Denke das sollte klappen hab nur mal wieder Probleme (

LG

 

[mihe7]

Wenn der Code {RED, RED, BLUE, BLUE} wäre und der Spieler {GREEN, GREEN, RED, RED} tippt, was soll dann als Ergebnis rauskommen?

 

[ocsme]

null null white white sollte raus kommen!

so hab ein neuen versuch total überstrapaziert mit Arrays und der gleichen aber ich denke es läuft so

public static MasterMindColour[] black(MasterMindColour[] mmc, MasterMindColour[] gamer) {
        MasterMindColour[] back=new MasterMindColour[gamer.length];
        for(int i=0;i<gamer.length;i++)
            if(mmc[i].equals(gamer[i]))
                back[i]=MasterMindColour.BLACK;
      
        return back;
    }
  
    public static MasterMindColour[] white(MasterMindColour[] mmc, MasterMindColour[] gamer, MasterMindColour[] b) {
        MasterMindColour[] back=new MasterMindColour[gamer.length];
        for(int k=0;k<b.length;k++)
            back[k]=b[k];
        for(int i=0;i<gamer.length;i++)
            for(int j=0;j<gamer.length;j++) {
                if(b[i]==null)
                if(gamer[i].equals(mmc[j]))
                    back[i]=MasterMindColour.WHITE;
            }
        return back;
    }
  
    public static MasterMindColour[] finde(MasterMindColour[] mmc, MasterMindColour[] gamer) {
        MasterMindColour[] back=new MasterMindColour[gamer.length];
        MasterMindColour[] back2=new MasterMindColour[gamer.length];
        back=black(mmc,gamer);
        back2=white(mmc,gamer,back);
        return back2;
    }

Es geht doch nicht denn bei:
mmc[0]=MasterMindColour.BLUE;
mmc[1]=MasterMindColour.RED;
mmc[2]=MasterMindColour.BLUE;
mmc[3]=MasterMindColour.RED;

MasterMindColour[] gamer=new MasterMindColour[4];
gamer[0]=MasterMindColour.RED;
gamer[1]=MasterMindColour.RED;
gamer[2]=MasterMindColour.RED;
gamer[3]=MasterMindColour.RED;

kommt raus:
WHITE
BLACK
WHITE
BLACK

es sollte aber raus kommen:
WHITE
BLACK
NULL
BLACK

 

[mihe7]

Du sollst nicht wie wild irgendwelchen Code produzieren, sondern Dir das Problem klar machen und eine Lösung dafür finden

null null white white sollte raus kommen!

ok, was ist, wenn der Code {RED, BLUE, BLUE, BLUE} ist und der Spieler {GREEN, GREEN, RED, RED} tippt?

 

[ocsme]

Dann sollte null null white null raus kommen.
Ich versuche es heute wieder mit einem Boolean Array das dann sagt das diese Feld schon getippt wurde.
LG

 

[ocsme]

So ich denke nun habe ich es aber endlich!

import java.util.Scanner;

public class MasterMind {
   
   
    public static MasterMindColour[] finde(MasterMindColour[] eingabe, MasterMindColour[] spieler) {
        MasterMindColour[] win=new MasterMindColour[4];
        boolean[] getippt=new boolean[4];
       
        for(int i=0;i<win.length;i++) {
            if(eingabe[i].equals(spieler[i])) {
                win[i]=MasterMindColour.BLACK;
                getippt[i]=true;
            }
        }
       
        for(boolean a:getippt)
            System.out.println(a);
       
        for(int i=0;i<win.length;i++)
            for(int j=0;j<win.length;j++) {
                if(!getippt[i] && spieler[j].equals(eingabe[i])) {
                    win[j]=MasterMindColour.WHITE;
                    getippt[i]=true;
                }
            }
       
        for(boolean a:getippt)
            System.out.println(a);
       
        return win;
    }
   
    public static void main(String[] args) {
        Scanner input= new Scanner(System.in);
        MasterMindColour[] eingabe = new MasterMindColour[4];
        MasterMindColour[] spieler=new MasterMindColour[4];
        MasterMindColour[] win=new MasterMindColour[4];
//        int counter=0; int i=0;
//       
//        System.out.println("Es stehen folgende Farben zur verfuegung: ");
//        for(MasterMindColour m: MasterMindColour.values())
//            if (m.getShow())
//                System.out.print(m+" "+m.ordinal()+" ");
//       
//        System.out.println("");
//        System.out.println("Spieler 1 (Codierer) bitte 4 Stelligen"
//                + " Farbcode eingeben. Farbcodes stehen hinter der Farbe: ");
//       
//        while(counter<4) {
//            int n=input.nextInt();
//            switch(n) {
//            case 0: { eingabe[i]=MasterMindColour.RED; i++;    } break;
//            case 1: { eingabe[i]=MasterMindColour.BLUE; i++; } break;
//            case 2: { eingabe[i]=MasterMindColour.GREEN; i++; } break;
//            case 3: { eingabe[i]=MasterMindColour.ORANGE; i++; } break;
//            case 4: { eingabe[i]=MasterMindColour.YELLOW; i++; } break;
//            case 5: { eingabe[i]=MasterMindColour.VIOLET; i++; } break;
//            default: System.out.println("Falsche Eingabe!");
//            }
//            counter++;
//        }
//       
//        System.out.println("Die Farbordnung laudet: ");
//        for(MasterMindColour m: eingabe)
//            System.out.print(m+" ");
//       
//       
//        System.out.println("");
//        System.out.println("Da das Spielfeld nun gesetzt ist Spielerwechsel. ");
//       
//        System.out.println("Es stehen folgende Farben zur verfuegung: ");
//        for(MasterMindColour m: MasterMindColour.values())
//            if (m.getShow())
//                System.out.print(m+" "+m.ordinal()+" ");
//       
//        counter=0;
//        i=0;
//        while(counter<4) {
//            int n=input.nextInt();
//            switch(n) {
//            case 0: { spieler[i]=MasterMindColour.RED; i++;    } break;
//            case 1: { spieler[i]=MasterMindColour.BLUE; i++; } break;
//            case 2: { spieler[i]=MasterMindColour.GREEN; i++; } break;
//            case 3: { spieler[i]=MasterMindColour.ORANGE; i++; } break;
//            case 4: { spieler[i]=MasterMindColour.YELLOW; i++; } break;
//            case 5: { spieler[i]=MasterMindColour.VIOLET; i++; } break;
//            default: System.out.println("Falsche Eingabe!");
//            }
//            counter++;
//        }
       
        eingabe[0]=MasterMindColour.RED;
        eingabe[1]=MasterMindColour.BLUE;
        eingabe[2]=MasterMindColour.BLUE;
        eingabe[3]=MasterMindColour.BLUE;
       
        spieler[0]=MasterMindColour.GREEN;
        spieler[1]=MasterMindColour.GREEN;
        spieler[2]=MasterMindColour.RED;
        spieler[3]=MasterMindColour.RED;

        win=finde(eingabe,spieler);
        for(MasterMindColour m: win)
            System.out.print(m+" ");
    }

}

 

[ocsme]

zu früh gefreut jetzt macht er aus
RED RED RED RED
RED BLUE RED BLUE

WITHE null BLACK null
Ich hab keine Lust mehr denke ich lass es so!

desweitern geht sowas auch nicht:
Rot Blau Rot Blau
Blau Rot Blau Rot
Weiß Weiß null null
mhhh... Ich mag nicht mehr!
Post nicht mehr beachten ich lass es so und gebe es Fehlerhaft ab!

 

[httpdigest]

Hey, habe es gerade mal versucht, zu lösen. Deckt zumindest bislang alle deine Fälle ab, und die, die ich sonst so schnell gegoogled und ausprobiert hab. Es ist nicht rekursiv und aber gibt die Ergebnisliste ohne Null-Elemente aus.
Viel Spaß damit!

import static java.lang.Boolean.*;
import static java.util.Collections.*;
import static java.util.stream.Collectors.*;
import static java.util.stream.IntStream.*;
import java.util.*;
import java.util.function.*;
public class Mastermind {
  private static <T, R> List<R> check(T[] code, T[] guess, Supplier<R> black, Supplier<R> white) {
    class PotentialMatch {
      int i;
      Set<Integer> idxs;
      PotentialMatch(PotentialMatch m, int i, int j) {
        this.i = i;
        this.idxs = m != null
            ? singleton(j)
            : range(0, code.length).boxed()
             .filter(k -> code[k].equals(guess[i]))
             .collect(toSet());
      }
    }
    return
     range(0, guess.length)
    .mapToObj(i -> new PotentialMatch(null, i, -1))
    .sorted((o1, o2) -> compare(o2.idxs.contains(o2.i), o1.idxs.contains(o1.i)))
    .collect(ArrayList<PotentialMatch>::new, (l, m) -> {
          Integer j = code[m.i].equals(guess[m.i])
              ? (Integer) m.i
              : m.idxs.stream()
                      .filter(k -> l.stream()
                                    .noneMatch(e -> e.idxs.contains(k)))
                      .findFirst()
                      .orElse(null);
          if (j != null)
            l.add(new PotentialMatch(m, m.i, j));
        }, ArrayList::addAll)
    .stream()
    .map(o -> o.idxs.contains(o.i) ? black.get() : white.get())
    .collect(toList());
  }
  public static void main(String[] args) {
    System.out.println(check(
      new Object[] {"y", "r", "r", "g"},
      new Object[] {"g", "y", "r", "o"},
      () -> "b",
      () -> "w"
    ));
  }
}

 

[ocsme]

viel zu Kompliziert für mich aber danke
Collections und der gleichen hatten wir noch nicht
Ich denke ich werde es so lassen denn hab ja so viel ausprobiert doch bekomme es einfach nicht hin also "pech"

LG

 

[ocsme]

Vielleicht hat ja jemand eine andere Idee wie ich makieren kann das das Element schon mal vorgekommen ist?
Mit dem boolean Array komme ich nicht klar vielleicht einfach zu doof

LG

 

[mihe7]

Vielleicht hat ja jemand eine andere Idee wie ich makieren kann das das Element schon mal vorgekommen ist?

Schon aber was genau verstehst Du unter "Element schon mal vorgekommen"? Welches Element soll wo schon mal vorgekommen sein?

 

[httpdigest]

Ich habe meine Lösung zum besseren Verständnis einmal refactored. Vielleicht hilft dir das weiter:

import static java.lang.Boolean.*;
import static java.util.Collections.*;
import static java.util.stream.Collectors.*;
import static java.util.stream.IntStream.*;
import java.util.*;
import java.util.function.*;
import java.util.stream.*;
public class Mastermind {
  private static class Matches {
    int i;
    Set<Integer> idxs;
    Matches(int i, Set<Integer> idxs) {
      this.i = i;
      this.idxs = idxs;
    }
  }
  private static <T> IntStream allGuessPositions(T[] guess) {
    return range(0, guess.length);
  }
  private static Comparator<? super Matches> exactMatchesFirst() {
    return (m1, m2) -> compare(isExactMatch(m2), isExactMatch(m1));
  }
  private static <R> Function<Matches, R> toMatchResult(
      Supplier<R> black, Supplier<R> white) {
    return m -> isExactMatch(m) ? black.get() : white.get();
  }
  private static boolean isExactMatch(Matches m) {
    return m.idxs.contains(m.i);
  }
  private static <T> IntFunction<Matches> potentialMatches(
      T[] code, T[] guess) {
    return i -> new Matches(i, range(0, code.length)
                              .boxed()
                              .filter(k -> code[k].equals(guess[i]))
                              .collect(toSet())
                           );
  }
  private static <T> BiConsumer<ArrayList<Matches>, Matches>
      collectMatches(T[] code, T[] guess) {
    return (l, m) -> {
      Integer j = isExactMatch(code, guess, m)
          ? (Integer) m.i
          : firstUnusedMatchIndex(l, m);
      if (j != null) {
        l.add(new Matches(m.i, singleton(j)));
      }
    };
  }
  private static <T> boolean isExactMatch(T[] code, T[] guess, Matches m) {
    return code[m.i].equals(guess[m.i]);
  }
  private static Integer firstUnusedMatchIndex(ArrayList<Matches> l,
      Matches m) {
    return m.idxs.stream()
            .filter(k -> l.stream()
                          .noneMatch(e -> e.idxs.contains(k)))
            .findFirst()
            .orElse(null);
  }
  public static <T, R> List<R> check(T[] code, T[] guess,
      Supplier<R> exactMatch, Supplier<R> inexactMatch) {
    return
       allGuessPositions(guess)
      .mapToObj(potentialMatches(code, guess))
      .sorted(exactMatchesFirst())
      .collect(ArrayList::new, collectMatches(code, guess), ArrayList::addAll)
      .stream()
      .map(toMatchResult(exactMatch, inexactMatch))
      .collect(toList());
  }
  public static void main(String[] args) {
    System.out.println(check(
      new Object[] {1, 2, 2, 3},
      new Object[] {3, 1, 2, 4},
      () -> "b", () -> "w"
    ));
  }
}

 

[ocsme]

httpdigest sry das ist viel zu hoch für mich. Da fehlt alleine viel zu viel Stoff damit ich das Verstehen kann!

Naja wir haben 2 Spieler.
1er Speiler gibt ein
Red Blue Blue Blue
das muss erraten werden vom 2ten Spieler. Dieser sagte:
Blue Red Blue Yellow
dann sollte raus kommen
White White Black null

somit muss ich mir ja aber die Stelle merken das Rot und Blau schon erraten wurden! oder etwa nicht? Denn eine andere Lösungsidee habe ich nicht.
Wenn man das nicht macht dann sagt er ja immer wenn z. B. Spieler 2 dann so was sagen würde:
Red Red Red Blue
White White White Black obwohl nur 1 Red vorkommt würde er mir 3x white ausgeben statt 1x.

also muss ich mir merken das red schon weg ist. Das habe ich einfach versucht mit einem boolean Array doch es klappt nicht

 

[httpdigest]

somit muss ich mir ja aber die Stelle merken das Rot und Blau schon erraten wurden! oder etwa nicht?

Genau. Du musst zuerst zu jedem Stein vom "Codeknacker" herausfinden, auf welchen Stein bzw. welche Steine vom "Codemaster" dieser Stein passt. Das können genau ein exakter oder 'n' inexakte Matches sein. Dann musst du diese Matches sortieren, so dass die exakten Matches höherpriorisiert werden. Und dann kannst du damit anfangen, die tatsächlich auszugebenden Matches zu generieren, indem du die potenziellen Matches durchgehst, und prüfst, ob der Stein des Codemasters eines Matches bereits schon einmal für einen früheren Match verwendet wurde. Das ist genau das, was mein Code tut. Ich hatte nur gehofft, dass dieses Prinzip dadurch etwas hervorgeht.

 

[ocsme]

das hört sich jetzt super kompliziert an ich dachte mir das ganze etwas leichter.
Leider verstehe ich deinen Code ja nicht sry ich blicke da überhaupt nicht durch wir haben bis jetzt nur bis zur Vererbung den Stoff!

Wieso sortierst du das ganze und auch mit Prio wie gesagt so Kompliziert dachte ich mir das ganze nicht
LG

 

[httpdigest]

Es ist aber leider kompliziert wegen den Mehrdeutigkeiten bei Codes mit mehreren gleichen Farben und unterschiedlicher Anzahl gleicher Farben bei dem Code und dem Rateversuch.
Theoretisch könnte ja bei code=[ROT, ROT] und guess=[ROT, ROT] herauskommen: [SCHWARZ, SCHWARZ] oder auch [WEISS, WEISS], je nachdem, welchen Algorithmus du verwendest, um einen Match zu identifizieren, wobei natürlich nur [SCHWARZ, SCHWARZ] richtig ist. Aber um eben zu erkennen, dass [SCHWARZ, SCHWARZ] richtig ist, musst du eben exakte Matches vor inexakten Matches bevorzugen. Und wie du das machst, hängt dann wiederum davon ab, wie du z.B. auch inexakte Matches bei unterschiedlicher Anzahl an gleichen Farben zwischen Code und Rateversuch herausfindest. Ich habe eben einen Algorithmus gewählt, der zuerst alle Matches identifiziert und dann nach exakten Matches sortiert, um diese eben zu bevorzugen.

 

[mihe7]

import java.util.Arrays;

enum Color { BLUE, RED, GREEN, BLACK, WHITE }

public class Test {

    public static Color[] finde(Color[] codier, Color[] gamer) {
        Color[] code = new Color[codier.length];
        System.arraycopy(codier, 0, code, 0, codier.length);

        Color[] result = new Color[codier.length];
        for (int i = 0; i < gamer.length; i++) {
            if (code[i] == gamer[i]) {
                code[i] = Color.BLACK;
                result[i] = Color.BLACK;
            }
        }
        finde(result, code, gamer, 0);
        return result;
    }

    private static void finde(Color[] r, Color[] code, Color[] gamer, int i) {
        if (i == gamer.length) {
            return;
        }
        if (code[i] != Color.BLACK) {
            int j = 0;
            boolean found = false;
            while (j < code.length && !found) {
                found = gamer[i] == code[j];
                j++;
            }

            if (found) {
                code[j-1] = Color.WHITE;
                r[i] = Color.WHITE;
            }
        }

        finde(r, code, gamer, i+1);
    }

    public static void show(Color[] code, Color[] gamer) {
        System.out.println(String.format("%s ./. %s = %s\n",
            Arrays.toString(code), Arrays.toString(gamer),
            Arrays.toString(finde(code, gamer))));
    }

    public static void main(String[] args) {
        show(new Color[]{Color.RED, Color.RED, Color.RED, Color.RED},
             new Color[]{Color.RED, Color.BLUE, Color.RED, Color.BLUE});
        show(new Color[]{Color.RED, Color.BLUE, Color.RED, Color.BLUE},
             new Color[]{Color.BLUE, Color.RED, Color.BLUE, Color.RED});
        show(new Color[]{Color.RED, Color.BLUE, Color.BLUE, Color.BLUE},
             new Color[]{Color.GREEN, Color.GREEN, Color.RED, Color.RED});

    }
}

Die Rekursion ersetzt hier allerdings nur eine for-Schleife.

 

[ocsme]

Okay ich habe es so gemacht das ich erst die exakten raus nehme dann die nicht exakten doch leider spinnen bei mir ja die nicht exakten rum.
wenn du willst und vielleicht Zeit hast kannst du ja mal drüber schauen wieso das rum spinnt

Zuerst besuche ich meine zwei übergeben Arrays und schaue wo Posistion und Farbe übereinstimmen und Färbe das ganze im win Array dann schwarz. Danach versuche ich die anderen als Weiß zu identifizieren doch das klappt nicht so ganz.

Hier der Code:

public static MasterMindColour[] finde(MasterMindColour[] eingabe, MasterMindColour[] spieler) {
        MasterMindColour[] win=new MasterMindColour[4];
        boolean[] getippt=new boolean[4];
        boolean abbruch=false;
        for(int i=0;i<win.length;i++) {
            if(eingabe[i].equals(spieler[i])) {
                win[i]=MasterMindColour.BLACK;
                getippt[i]=true;
            }
        }
       
        for(int i=0;i<win.length;i++,abbruch=false)
            for(int j=0;j<win.length;j++) {
                if(!abbruch && !getippt[i] && spieler[j].equals(eingabe[i])) {
                    win[j]=MasterMindColour.WHITE;
                    getippt[i]=true;
                    abbruch=true;
                }
            }
       
        return win;
    }

Mein ganzes Programm schreibe ich mal in ein neuen Post drunter

 

[ocsme]

import java.util.Scanner;

public class MasterMind {
   
    public static void spiele(int versuche) {
        Scanner input= new Scanner(System.in);
        MasterMindColour[] eingabe = new MasterMindColour[4];
        MasterMindColour[] spieler=new MasterMindColour[4];
        MasterMindColour[] win=new MasterMindColour[4];
        int counter=0; int i=0;
       
        System.out.println("Es stehen folgende Farben zur verfuegung: ");
        for(MasterMindColour m: MasterMindColour.values())
            if (m.getShow())
                System.out.print(m+" "+m.ordinal()+" ");
       
        System.out.println("");
        System.out.println("");
        System.out.println("Spieler 1 bitte 4 Stelligen"
                + " Farbcode eingeben. (Farbcodes stehen hinter der Farbe)");
       
        while(counter<4) {
            int n=input.nextInt();
            switch(n) {
            case 0: { eingabe[i]=MasterMindColour.RED; i++;    } break;
            case 1: { eingabe[i]=MasterMindColour.BLUE; i++; } break;
            case 2: { eingabe[i]=MasterMindColour.GREEN; i++; } break;
            case 3: { eingabe[i]=MasterMindColour.ORANGE; i++; } break;
            case 4: { eingabe[i]=MasterMindColour.YELLOW; i++; } break;
            case 5: { eingabe[i]=MasterMindColour.VIOLET; i++; } break;
            default: System.out.println("Falsche Eingabe!");
            }
            counter++;
        }
       
        System.out.println("Die Farbordnung laudet: ");
        for(MasterMindColour m: eingabe)
            System.out.print(m+" ");
   
        System.out.println("");
        System.out.println("Da das Spielfeld nun gesetzt ist Spielerwechsel. ");
        System.out.println("");

        while(versuche>0) {
            System.out.println("Spieler zwei hat noch: "+versuche+" Versuche!");
            System.out.println("");
            System.out.println("Es stehen folgende Farben zur verfuegung: ");
            for(MasterMindColour m: MasterMindColour.values())
                if (m.getShow())
                    System.out.print(m+" "+m.ordinal()+" ");
            System.out.println();
            counter=0;
            i=0;
            while(counter<4) {
                int n=input.nextInt();
                switch(n) {
                case 0: { spieler[i]=MasterMindColour.RED; i++;    } break;
                case 1: { spieler[i]=MasterMindColour.BLUE; i++; } break;
                case 2: { spieler[i]=MasterMindColour.GREEN; i++; } break;
                case 3: { spieler[i]=MasterMindColour.ORANGE; i++; } break;
                case 4: { spieler[i]=MasterMindColour.YELLOW; i++; } break;
                case 5: { spieler[i]=MasterMindColour.VIOLET; i++; } break;
                default: System.out.println("Falsche Eingabe!");
                }
                counter++;
            }
           
            win=finde(eingabe,spieler);
            int wincounter=0;
            for(int k=0;k<win.length;k++) {
                if(win[k]==MasterMindColour.BLACK) {
                    System.out.print(win[k]+" ");
                    wincounter++;
                }
                else System.out.print(win[k]+" ");
            }
               
           
            if(wincounter==4) {
                System.out.println("Spieler 2 hat gewonnen");
                versuche=0;
            }
            else versuche--;
        }
       
    }
   
    public static MasterMindColour[] finde(MasterMindColour[] eingabe, MasterMindColour[] spieler) {
        MasterMindColour[] win=new MasterMindColour[4];
        boolean[] getippt=new boolean[4];
        boolean abbruch=false;
        for(int i=0;i<win.length;i++) {
            if(eingabe[i].equals(spieler[i])) {
                win[i]=MasterMindColour.BLACK;
                getippt[i]=true;
            }
        }
       
        for(boolean a:getippt)
            System.out.println(a);
       
        for(int i=0;i<win.length;i++,abbruch=false)
            for(int j=0;j<win.length;j++) {
                if(!abbruch && !getippt[i] && spieler[j].equals(eingabe[i])) {
                    win[j]=MasterMindColour.WHITE;
                    getippt[i]=true;
                    abbruch=true;
                }
            }
       
        for(boolean a:getippt)
            System.out.println(a);
       
        return win;
    }
   
    public static void main(String[] args) {
        /*
         * Programm laueft leider nicht korrekt da einige Eingaben wie z. B.:
         * Spieler 1: BLUE RED BLUE RED Spieler 2: RED BLUE RED BLUE ist die Ausgabe:
         * WHITE WHITE null null
         * oder bei
         * Spieler 1: RED RED RED RED Spieler 2: RED BLUE RED BLUE ist die Ausgabe:
         * WHITE null BLACK null
         *
         */
        int versuche=5;
        spiele(versuche);
       

       
   
    }

}

 

[ocsme]

mihe7 danke hab es mir angeschaut werde es mir morgen nochmal genauer anschauen
hatte den Post nicht gesehen gerade eben

 

[mihe7]

@ocsme bedank Dich nicht zu früh, hab das nur mal runtergeschrieben, evtl. noch irgendwelche Fälle übersehen.

Bin gerade noch am Überlegen für eine schöne rekursive Lösung.

 

[mihe7]

Wenn wir die geratenen Farben von links nach rechts durchgehen, dann würde ich meinen, dass gilt: eine geratene Farbe f an Position i führt zu
- einem schwarzen Stift, wenn im Code an Position i die Farbe f steht,
- sonst einem weißen Stift, wenn rechts von i ein Überschuss im Code an Farbe f vorliegt,
- sonst keinem Stift

 

[ocsme]

was machst du eigentlich hiermit?

boolean found = false;
            while (j < code.length && !found) {
                found = gamer[i] == code[j];
                j++;
            }

Ich bin für jede Hilfe immer sehr dankbar ich denke das habt ihr schon gemerkt
Natürlich weiß ich auch das ich manchmal (sehr oft) Danke schreibe bzw. mich bedanke. Doch man kann sich eigentlich wenn man geholfen bekommt nicht genug bedanken. Ihr verbringt damit ja schließlich eure Zeit die ihr sicherlich auch anders investieren könntet Und bei vielen wenn man sie um Hilfe fragt kommen doofe Kommentare oder sie wollen gleich Geld deswegen bin ich für solche Communitys heut zu Tage sehr dankbar und euch noch mehr da Ihr die Stützpfeiler einer solchen community seit

LG

 

[httpdigest]

Wenn wir die geratenen Farben von links nach rechts durchgehen, dann würde ich meinen, dass gilt: eine geratene Farbe f an Position i führt zu
- einem schwarzen Stift, wenn im Code an Position i die Farbe f steht,
- sonst einem weißen Stift, wenn rechts von i ein Überschuss im Code an Farbe f vorliegt,
- sonst keinem Stift

Die zweite Aussage ist, denke ich, nicht 100%ig korrekt, da die geratene Farbe auch links von i im Code vorkommen kann. Beispiel (ich verwende mal Zahlen, da das einfacher ist):
rate=[5, 1, 2, 3]
code=[1, 2, 3, 4]
Hier würdest du ja (laut der Aussage) weder einen weißen noch einen schwarzen Stift generieren, aber hingegen zwei weiße für:
rate=[2, 3, 5, 1]
code=[1, 2, 3, 4]
('rate' ist nur rotiert)

 

[mihe7]

Die zweite Aussage ist, denke ich, nicht 100%ig korrekt, da die geratene Farbe auch links von i im Code vorkommen kann.

Richtig...

 

[httpdigest]

Obwohl dein Code aber korrekt zu sein scheint, bzw. nicht nach der Aussage implementiert ist.

 

[mihe7]

Obwohl dein Code aber korrekt zu sein scheint, bzw. nicht nach der Aussage implementiert ist.

Das war ja auch nur eine Überlegung bzgl. einer schöneren rekursiven Lösung.

 

[ocsme]

Danke euch nochmal
Hab es nun mit meinen Fehlern abgegeben.
Wenn es euch nicht weiter Interessiert könnt ihr es sein lassen
Vielleicht bekomme ich es über die nächsten Tage ja noch hin jetzt ist es zu spät bzw. hab auch keine Lust mehr darauf hab noch mehr zu machen

LG

 

[mihe7]

Hab es nun mit meinen Fehlern abgegeben.

Was hat an meiner Lösung nicht gepasst?

Wenn es euch nicht weiter Interessiert könnt ihr es sein lassen

Sagen wir so: mir ist keine andere rekursive Lösung eingefallen, die schöner gewesen wäre.

 

[ocsme]

misst ich dachte da würde was nicht gehen bei deiner Lösung
deswegen habe ich mir das nicht mehr weiter angeschaut! Hab ich etwas miss verstanden so ein misst!
Naja bekomme ich Punkt abzug das ist halb so wild *Wie schon gesagt ich muss ja noch mehr lernen *

werde mir dein Programm nochmal anschauen und es dann später (die Tage!) neu machen. Das Poste ich dann hier wieder.
Leider habe ich den Stoff noch nicht um https Lösung zu verstehen

Nochmals Danke an euch =)
LG

 

[Xyz1]

Leider habe ich den Stoff noch nicht

Ich sitze auch schon auf dem Trockenem

 

[ocsme]

Ich sitze auch schon auf dem Trockenem

so meinte ich das nicht

 

[mihe7]

Das sagen sie alle.

 

[Xyz1]

so meinte ich das nicht

Schnapp Dir ein Wasser.

 

[ocsme]

Wasser und Grüner Tee mehr gibt es nicht
so ich muss schon wieder ein neuen Post eröffnen da ich wieder was nicht hin bekomme

 

[mihe7]

Wasser und Grüner Tee mehr gibt es nicht

Wer sowas trinkt, frisst kleine Kinder

 

[ocsme]

Wer sowas trinkt, frisst kleine Kinder

Wer Wasser trinkt frisst kleine Kinder?
Grüner Tee trinke ich nur mit Aromen
Bin kein Kaffee trinker. Hab mal eine Zeit lang viele Energys getrunken aber davon wird man nur Dick und super Ungesund sind Sie auch noch

 

[mihe7]

Wer Wasser trinkt frisst kleine Kinder?

Wer sonst?

trinke ich nur mit Aromen

So, so, Aromen nennt man das heute...

Jetzt aber Schluss mit Unsinn.

 

[ocsme]

Wer sonst?


So, so, Aromen nennt man das heute...

Jetzt aber Schluss mit Unsinn.

Ja der Post ist am Ende nur eine Frage hätte ich noch was trinkst du den?

 

[mihe7]

Nur gute Sachen.

 

[Xyz1]

nur eine Frage hätte ich noch was trinkst du den?

Wir sollten vielleicht eine Umfrage machen wer welchen Getränk möchte.

Cappuccino.