Enum Array Rekursiv abarbeiten

ocsme

Top Contributor
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:

Java:
        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));

Java:
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

Top Contributor
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 :p
enum Klasse:
Java:
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:
Java:
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

Top Contributor
Es hat in der Methode ein abbruch gefehlt somit läuft jetzt wenigstens die Methode :)
Java:
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;
    }
 

ocsme

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

LG
 

mihe7

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

ocsme

Top Contributor
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 :D
Java:
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
 

ocsme

Top Contributor
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

Top Contributor
So ich denke nun habe ich es aber endlich!
Java:
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

Top Contributor
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

Top Contributor
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!
Java:
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

Top Contributor
o_O 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" :D

LG
 

ocsme

Top Contributor
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 :D

LG
 

httpdigest

Top Contributor
Ich habe meine Lösung zum besseren Verständnis einmal refactored. Vielleicht hilft dir das weiter:
Java:
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

Top Contributor
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 :D
 

httpdigest

Top Contributor
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

Top Contributor
o_O 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

Top Contributor
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

Top Contributor
Java:
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

Top Contributor
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:

Java:
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 :D
 

ocsme

Top Contributor
Java:
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);
       

       
   
    }

}
 

mihe7

Top Contributor
@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

Top Contributor
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

Top Contributor
was machst du eigentlich hiermit?
Java:
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

Top Contributor
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)
 

ocsme

Top Contributor
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
 

ocsme

Top Contributor
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
 

ocsme

Top Contributor
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 :(
 
Ähnliche Java Themen
  Titel Forum Antworten Datum
J Datentypen Array in enum, ?? Wozu ?? Java Basics - Anfänger-Themen 3
P Enum oder normale Klasse? Java Basics - Anfänger-Themen 10
volcanos enum und switch (neu): falschen Wert mit IllegalArgumentException oder mit EnumConstantNotPresentException abfangen ? Java Basics - Anfänger-Themen 51
X Enum Abfrage ohne if, for, while oder switch Java Basics - Anfänger-Themen 21
U Warum kann ich die Methode in der ENUM Klasse nicht aufrufen? Und warum geht die Switch nicht? Java Basics - Anfänger-Themen 8
D Frage bzgl. Enum-Handhabung Java Basics - Anfänger-Themen 16
S Java Enum Java Basics - Anfänger-Themen 2
I Validation, ob String ein Wert aus einem Enum enthält Java Basics - Anfänger-Themen 3
V Enum Java Basics - Anfänger-Themen 1
C Farben als Enum Java Basics - Anfänger-Themen 3
N enum Attribut von Objekten einer Hashmap ausgeben Java Basics - Anfänger-Themen 6
I JAXB und Enum Java Basics - Anfänger-Themen 7
M Enum-Variable HashMap zuweisen Java Basics - Anfänger-Themen 5
B Enum innerhalb einer Klasse / anderes Konzept Java Basics - Anfänger-Themen 8
N Enum Typen, was passiert intern mit ihnen? Java Basics - Anfänger-Themen 2
A enum Java Basics - Anfänger-Themen 6
B ENUM to List<String> konvertieren Java Basics - Anfänger-Themen 2
N Java Enum converter Methode Java Basics - Anfänger-Themen 5
F Enum von Ländern Java Basics - Anfänger-Themen 8
J Klassen Enum als Informationsträger Java Basics - Anfänger-Themen 10
T Datentypen enum static Chaos (blutiger anfänger) Java Basics - Anfänger-Themen 5
R Enum ist das gleiche wie? Java Basics - Anfänger-Themen 15
P Klassen Richtige Anwendung einer Enum-Klasse Java Basics - Anfänger-Themen 11
E Datentypen Problem beim Speichern von enum. Java Basics - Anfänger-Themen 10
J Compiler-Fehler class interface or enum expected Java Basics - Anfänger-Themen 1
E Objektvergleich Enum Java Basics - Anfänger-Themen 7
kilopack15 Euromünzen in enum als Liste ausgeben Java Basics - Anfänger-Themen 11
N Enum als generischer Typ Java Basics - Anfänger-Themen 4
H Datentypen Fehler bei Verwendung von enum Java Basics - Anfänger-Themen 9
lBlKha0s Fehlermeldung : class interface or enum expected Java Basics - Anfänger-Themen 9
T error: class, interface, or enum expected Java Basics - Anfänger-Themen 5
S Menüauswahl per Enum Java Basics - Anfänger-Themen 12
F Enum via String definieren Java Basics - Anfänger-Themen 2
L Compiler-Fehler error: class, interface or enum expected Java Basics - Anfänger-Themen 2
M java.lang.Enum.valueOf(Unknown Source) Java Basics - Anfänger-Themen 2
M Enum-Variabel-Abfrage funktioniert nicht? Java Basics - Anfänger-Themen 2
P Fallunterscheidung mit Überprüfung (enum) Java Basics - Anfänger-Themen 11
H enum Type Java Basics - Anfänger-Themen 6
F Operatoren Enum aus Textdabei laden Java Basics - Anfänger-Themen 3
P enum: cannot be resolved to a type Java Basics - Anfänger-Themen 2
kaoZ Variablen Konstantensammlung vs. Enum Java Basics - Anfänger-Themen 9
H Enum außerhalb einer Klasse? Java Basics - Anfänger-Themen 2
K OOP Aufzählungstypen! enum Currency!!! Java Basics - Anfänger-Themen 5
F ENUM als Variable Java Basics - Anfänger-Themen 4
M Enum: Zugriff auf Konstanten Java Basics - Anfänger-Themen 7
W Enum Konstruktor Type Java Basics - Anfänger-Themen 2
A Erste Schritte ENUM - Werte zurückgeben Java Basics - Anfänger-Themen 5
D Enum als Parameter Java Basics - Anfänger-Themen 6
B Variablen Instanz von Enum zur Laufzeit erstellen und zuweisen Java Basics - Anfänger-Themen 2
B Datentypen Enum vererben/gruppieren? Java Basics - Anfänger-Themen 6
F Datentypen enum Java Basics - Anfänger-Themen 5
J Enum zählen Java Basics - Anfänger-Themen 8
D Einlesen eines Enum-Wertes per console Java Basics - Anfänger-Themen 3
K String mit ENUM vergleichen? Java Basics - Anfänger-Themen 6
N enum vergleiche Klammern? Java Basics - Anfänger-Themen 5
J public enum? in Java Java Basics - Anfänger-Themen 9
D Erste Schritte Enum - das unbekannte Wesen Java Basics - Anfänger-Themen 3
Y ENUM auslesen (Name des ENUM als Variable) Java Basics - Anfänger-Themen 4
P Compiler-Fehler "class, interface, or enum expected" Java Basics - Anfänger-Themen 5
K class, interface or enum expected Java Basics - Anfänger-Themen 14
pg1337 enum-Aufgabe Java Basics - Anfänger-Themen 5
N was sagt enum aus? Java Basics - Anfänger-Themen 3
S Methoden Enum Parameter in Methode Java Basics - Anfänger-Themen 7
G Datentypen enum Frage Java Basics - Anfänger-Themen 3
R Probleme mit Enum Java Basics - Anfänger-Themen 10
B Enum: Instanzen Java Basics - Anfänger-Themen 10
B Generic? Enum - So lösbar? Java Basics - Anfänger-Themen 8
T class, interface, or enum expected Java Basics - Anfänger-Themen 2
M Vererbung Enum Vererbung/Polymorphie Java Basics - Anfänger-Themen 2
P Enum Attribut in Konstruktoren Java Basics - Anfänger-Themen 10
4 Enum Problem Java Basics - Anfänger-Themen 2
turmaline Bindestrich in enum? Java Basics - Anfänger-Themen 5
T Enum - Key als Value ermitteln Java Basics - Anfänger-Themen 7
X enum Fehlermeldung "The public type Day must be defined in its own file" Java Basics - Anfänger-Themen 8
T ist enum.ordinal keine Konstante? Java Basics - Anfänger-Themen 7
R State machine mit enum Java Basics - Anfänger-Themen 9
L enum aus Integer umwandeln Java Basics - Anfänger-Themen 3
C Klasseninstanzierung mit enum-Parameter erzwingen Java Basics - Anfänger-Themen 2
I Enum in String Java Basics - Anfänger-Themen 4
N enum richtig verwenden Java Basics - Anfänger-Themen 5
M for(Enum..., ButtonGroup.getElements()... Java Basics - Anfänger-Themen 3
StrikeTom Fragen zu enum Java Basics - Anfänger-Themen 4
A Was ist performanter für Konstanten, enum oder static variablen Java Basics - Anfänger-Themen 5
L String zu Enum parsen Java Basics - Anfänger-Themen 8
S OOP Durch ein Enum iterieren... Java Basics - Anfänger-Themen 47
K Datentypen enum und liste Java Basics - Anfänger-Themen 7
S String - Enum Java Basics - Anfänger-Themen 3
H Eine enum switchen? Java Basics - Anfänger-Themen 7
G enum für Typsicherheit Java Basics - Anfänger-Themen 9
J class, interface, or enum expected - finde Fehler nicht. Java Basics - Anfänger-Themen 4
J OOP enum Java Basics - Anfänger-Themen 2
O Problem (Enum) Java Basics - Anfänger-Themen 14
S Enum als Index Java Basics - Anfänger-Themen 5
H Enum --> int ?? Java Basics - Anfänger-Themen 3
tanja enum in java Java Basics - Anfänger-Themen 3
D class, interface or enum expected Java Basics - Anfänger-Themen 2
A OOP Übergabe eines Wertes an den enum Konstruktor Java Basics - Anfänger-Themen 12
T Simple Enum Fragen Java Basics - Anfänger-Themen 6
J class, interface, or enum expected Java Basics - Anfänger-Themen 4
R Enum und dann setter Setzen? Java Basics - Anfänger-Themen 44

Ähnliche Java Themen

Neue Themen


Oben