Würfelspiel

[chk1102]

Hallo,

ich möchte ein Programm schreiben, dass es mir ermöglicht in einem Array x-Mal zu würfeln.
Das klappt auch.
Nächste Teilaufgabe ist es wie viele gleiche Serien von Augenzahlen (von 10x Würfeln wurde 2 Mal die 3 gewürfelt) gewürfelt worden sind.
Ab da beginnt mein Problem.
Wie man im Code sehen kann, vergleich ich immer i mit i+1. Kommt es jedoch beim Würfeln zu einem 3er Pasch oder mehr, zählt das Programm die Variable treffer anstatt 1 dann 2 hoch.
Daher dachte ich, wenn man if (wurf == wurf[i+1] && wurf[i+1] == wurf[i+2]) rechnen würde, stünden die Chancen besser das Problem anzugehen. :autsch: Pustekuchen.
Im Grunde genommen möchte ich die vorherige Zahl im Array mit dem nachfolgenden i vergleichen, ob es nicht doch zu einem 3er, 4er usw -Pasch gekommen ist.

Ich würd mich über Ansätze freuen, erst mal keine Lösungen.

package Proggen1_2;

import java.util.Arrays;

public class Wuerfeln {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub

		int ran;
		int wurf[] = new int[10];
		wurf[0] = 4;
		wurf[1] = 2;
		wurf[2] = 6;
		wurf[3] = 6;
		wurf[4] = 5;
		wurf[5] = 3;
		wurf[6] = 3;
		wurf[7] = 3;
		wurf[8] = 1;
		wurf[9] = 1;
		int treffer = 0;
		int serie = 0;
		int anzserie = 1;
		int anzseriepos = 0;
		int alteZahl = 0;
		
		/*
		for (int i = 0; i < wurf.length; i++) {
			ran = (int) (Math.random() * 6 + 1);
			wurf[i] = ran;
		}
*/
		System.out.println("Der Wurf: "+ Arrays.toString(wurf));

		for (int i = 0; i < wurf.length-1; i++) {
			//System.out.println("die " + (i +1) + " Zahl: " + wurf[i]);
			alteZahl = wurf[i];
			System.out.println("Alte Zahl: " + alteZahl);
			if (wurf[i] == wurf[i+1]) {
				treffer++;
				serie = i;
				System.out.println("Die Serie nach Erhöhung beim Index: " + serie);
			}
			if ( serie< anzserie) 
				anzseriepos = i;
			}
		System.out.println();
		System.out.println("Anzahl gleicher Augenzahlen: " + treffer);
		System.out.println("Die Serie beginnt ab: " + serie + " und geht bis Stelle " );
		System.out.println("Anzahl von Serien: " + anzserie +  " an der Pos " + anzseriepos);
	}

}

Dann soll ich ausgeben, welche Zahl in den Serien gewürfelt worden sind und mit dem wievielten Wurf Serien begannen.

 

[kaetzacoatl]

Zu deinem Hauptproblem:

import java.util.Arrays;
import java.util.Random;

public class Wuerfeln {
 
    /**
     * @param args
     */
    public static void main(String[] args) {
        int wurf[] = new int[10];
        int treffer = 0;
        int serie = 0;
        
        for (int i = 0; i < wurf.length; i++) {
        	wurf[i] = new Random().nextInt(6)+1;
        }
 
        for (int i = 0; i < wurf.length; i++) {
            for(int a = 1;i+a < wurf.length && wurf[i] == wurf[i+a];a++){
            	if(a == 1)serie++;
            	treffer++;
            }
        }
        
        System.out.println(Arrays.toString(wurf));
        System.out.println(treffer+ " Treffer in " + serie + " Serien!");
    }
 
}

 

[hüteüberhüte]

@TO: Hab ich dich jetzt richtig verstanden, du willst nur die längste Serie ermitteln oder? Oder alle Serien? Die Idee ist einfach, innerhalb der Schleife in einer anderen Schleife die folgenden Elemente zu prüfen

Vielleicht hab ich dich aber auch voll valsch verstanden

Erkläre bitte genauer

 

[hüteüberhüte]

public class Sequence implements Comparable<Sequence> {

    private int startIndex;
    private int length;
    private int value;

    public Sequence(int startIndex, int length, int value) {
        this.startIndex = startIndex;
        this.length = length;
        this.value = value;
    }

    // getter...

    @Override
    public int compareTo(Sequence o) {
        return length < o.length ? 1 : length > o.length ? -1 : 0;
    }

    @Override
    public String toString() {
        return "Sequence{" + "startIndex=" + startIndex + ", length=" + length + ", value=" + value + '}';
    }
}

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Main {

    public static void main(String[] args) {
        int[] wurf = {1, 2, 2, 2, 2, 3, 3, 4, 5, 6};

        List<Sequence> s = new ArrayList<Sequence>(wurf.length);

        for (int i = 0; i < wurf.length;) {
            int j = i;
            while (j < wurf.length && wurf[i] == wurf[j]) {
                j++;
            }
            s.add(new Sequence(i, j - i, wurf[i]));
            i = j;
        }

        Collections.sort(s);

        System.out.println(s);
    }
}

[Sequence{startIndex=1, length=4, value=2},
 Sequence{startIndex=5, length=2, value=3},
 Sequence{startIndex=0, length=1, value=1},
 Sequence{startIndex=7, length=1, value=4},
 Sequence{startIndex=8, length=1, value=5},
 Sequence{startIndex=9, length=1, value=6}]

Ich find das einfach sehr schön

 

[hüteüberhüte]

Ich bin ein noob, also verlangt keine Signatur von mir!

Dein Code funktioniert auch nicht, i wird immer nur um 1 erhöht,

serie++;

könnte außerdem vor der Schleife stehen. Unsinnig

 

[chk1102]

Erstmal vielen Dank an euch alle!

Die Aufgabe beschreibt folgendes:
- welche Länge besaß die Serie,
- welche Augenzahl wurde in jedem Wurf dieser Serie erzielt,
- mit dem wievielten Wurf begann die Serie
Es geht immer nur um die größte Serie

???:L:rtfm:

Ich darf nur mit Arrays arbeiten. Keine ArrayLists

 

[hüteüberhüte]

- welche Länge besaß die Serie,

Siehe

Sequence.getLength()

- welche Augenzahl wurde in jedem Wurf dieser Serie erzielt,

Siehe

Sequence.getValue()

oder

Sequence.getValue() * Sequence.getLength()

- mit dem wievielten Wurf begann die Serie

Siehe

Sequence.getStartIndex() + 1

Ich darf nur mit Arrays arbeiten. Keine ArrayLists

Ok, also keine Listen. Dann nur über das Array iterieren und die längste Serie ermitteln:

int[] wurf = {1, 2, 2, 2, 2, 3, 3, 4, 5, 6};

int start = 0;
int länge = 0;

for (int i = 0; i < wurf.length;) {
  int j = i + 1;
  while (j < wurf.length && wurf[i] == wurf[j])
    j++;
  if (j - i > länge) {
    start = i;
    länge = j - i;
  }
  i = j;
}

System.out.println("start = " + (start + 1));
System.out.println("länge = " + länge);
System.out.println("wert = " + wurf[start]);

start = 2
länge = 4
wert = 2

Nicht getestet, aber hoffe mal, es ist verständlich und läuft

Lg

 

[hüteüberhüte]

Mit ein bisschen Trickserei, aber zu Kosten der Lesbarkeit, geht auch:

for (int i = 0; i < wurf.length;) {
  int j = i;
  while (i < wurf.length && wurf[j] == wurf[i])
    i++;
  if (i - j > länge) {
    start = j;
    länge = i - j;
  }
}

Eine Zeile eingespart

PS: Danke für Danke

 

[chk1102]

Läuft :toll::applaus:

Könntest du mir die Schleife erklären?

 for (int i = 0; i < wurf1.length - 1;) {
	          int j = i + 1;
	          while (j < wurf1.length && wurf1[i] == wurf1[j])
	            j++;
	          if (j - i > länge) {
	            start = i;
	            länge = j - i;
	          }
	          i = j;
	        }

Die While-Schleife macht mich etwas stutzig..
(j < wurf1.length && wurf1 == wurf1[j]) ???:L

Diese Methode hab ich noch nicht so gesehen:
wurf1 = new Random().nextInt(6)+1;

ich kenn sie nur so:
for (int i = 0; i < wurf.length; i++) {
ran = (int) (Math.random() * 6 + 1);
wurf = ran;

scheint dasselbe zu sein und sieht optimierter aus, richtig?

 

[hüteüberhüte]

Es gibt zwei Möglichkeiten (die ich der Einfachheit halber weggelassen hab):

Random r = new Random();
for (int i = 0; i < wurf.length; i++)
  wurf[i] = r.nextInt(6) + 1;

oder

for (int i = 0; i < wurf.length; i++)
  wurf[i] = (int) (Math.random() * 6.0) + 1;

r

ist ein Random-Objekt.

Math.random()

ist eine statische Methode der Klasse Math

Math.random()

liefert ein double zurück zwischen 0 (inklusive) und 1 (exklusive), es sollte mit einem double-Wert multipliziert und dann gecastet werden

Die while-Schleife läuft einfach solange, bis der aktuelle Wert nicht mehr dem Anfangswert entspricht. Nach der Schleife besitzt

j

also den Index des ersten Werts, der nicht mehr zu der Serie gehört

 

[chk1102]

kurze Frage noch:
steht in folgenden Schleifen nicht dasselbe? Also die Bedingungen meine ich.

1. Schleife:

for (int i = 0; i < wurf.length - 1;i++) {
	          int j = i + 1;
	          while (j < wurf.length && wurf[i] == wurf[j])

und die 2.Schleife:

 //
	        for (int i = 0; i < wurf.length; i++) {
	        	//j = 1, die for läuft solange wie i+j kleiner ist als die Arraylänge (<10) und
	        	//wurf[i](0) gleich ist mit wurf[i+j] (0+1)
	        	//die 2. For zählt erst hoch, wenn die Bedingung stimmt!!!
	            for(int j = 1;i+j < wurf.length && wurf[i] == wurf[i+j];j++){

???:L???:L???:L

 

[hüteüberhüte]

Ja, sind ähnlich. Wenn j allerdings im Schleifenkopf deklariert wird, dann ist darauf nach der Schleife nicht mehr zugreifbar. Das bedeutet, dass hinterher nicht mehr ersichtlich ist, wie lang eine Serie war

 

[hüteüberhüte]

Damit lassen sich relativ simpel auch längere Folgen untersuchen:

        // initialize
        int[] a = new int[1000000];
        Random r = new Random();
        for (int i = 0; i < a.length; i++) {
            a[i] = r.nextInt(6) + 1;
        }

        // count
        int index = 0;
        int length = 0;
        for (int i = 0; i < a.length;) {
            int j = i;
            while (i < a.length && a[j] == a[i]) {
                i++;
            }
            int newLength = i - j;
            if (newLength > length) {
                index = j;
                length = newLength;
            }
        }

        // print
        System.out.println("index = " + index);
        System.out.println("length = " + length);
        System.out.println("a = " + a[index]);
        for (int i = index; i < index + length; i++) {
            System.out.print(a[i] + ", ");
        }

index = 70032
length = 10
a = 2
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

Die Frage, welche Würfe die längste Serie beinhalten, ist also nur eine Frage danach, wie oft gewürfelt wurde. (Zumindest bei einem echten Zufall.)