Zahlenratespiel mit Strategie

[Altasha]

Huhu,

ich habe eine Frage bezüglich eines Programms, welches ich geschrieben habe. es funktioniert soweit und spuckt mir das aus, was ich will. Es geht mal wieder um das tolle Zahlenraten :>

Folgendes habe ich schon fertig:
Zahlenraten in einem wachsenden Intervall (erst 1 bis 10, dann 1 bis 100, usw.), der Spieler wird am Ende jedes Intervall-Ratens gefragt, ob er weitermachen möchte, wenn er mit 'j' antwortet erhöht sich das Intervall.
Dazu gehört ja auch, dass der Computer eine Zufallszahl würfelt in dem Intervall und auch, dass der Spieler eine Zahl eingibt. Weiterhin habe ich auch einen Rundenzähler drin.

Nun besteht die letzte Teilaufgabe darin, dass man ja bei so einem Spiel auch eine gewisse Strategie anwendet, ich teile dabei immer durch 2.
Ich soll nun genau das in eine Formel packen und ausgeben, in wie vielen Schritten man das maximal erraten könnte. (z.B. beim Intervall 1 bis 10: da ich immer durch 2 teile könnten es maximal um die 4 Schritte/Versuche sein).

Ich habe nun schon einiges ausprobiert, z.B. do-while-Schleifen.

Nun beendet sich das Programm immer selber und springt aus der Schleife.

Um das ganze auf einen Nenner zu bringen: Ich bräuchte ja egtl nur folgendes: Teile solange durch 2 bis das Ergebnis noch größer als Null ist und sage mir, wie oft du das gemacht hast. (Könnte man ja in eine do-while-Schleife setzen mit Rundenzähler)...Nur, wie gesagt, das funktioniert nicht so, wie ich mir das vorstelle. Und es ist ja auch das wachsende Intervall zu beachten.

Ich hoffe, jmd kann mir helfen (den Javacode würde ich ungern posten, es geht ja auch nur um einen kleinen allgemeinen Teil, den man vllt. sogar in einem anderen Programm mal verwenden könnte)

Gruß,
Altasha

 

[Landei]

In der Regel macht Java schon genau das, was du sagst, "von selbst" passiert da fast nie etwas. Insofern wäre etwas Code schon nützlich, denn ich habe meine Glaskugel schon wieder verlegt.

Nun steht der Code ganzer Applikations-Server, Java-IDEs und Kryptographie-Programmen frei im Netz herum, da wirkt es schon komisch, wenn man sich wegen zehn Zeilen eines Zahlenratespiels ziert. Also baue den betreffenden Teil aus, mache am besten ein KSKB daraus. Es ist gut, wenn du von einer "professionellen" Lösung lernen kannst, aber mindestens genauso wichtig ist, zu verstehen, warum die eigene nicht funktioniert - sonst tappst du immer wieder in dieselben Fallen. Wenn das Ausbauen schwer fällt, ist das übrigens ein Indiz, dass es bei deinem Design noch an der Modularisierung hapert.

 

[Phash]

schoen gesagt, Landei

denke auch nicht, dass man mit so einem Algorithmus Geld verdienen kann...

die Veroeffentlichung hindert dich allerdings nicht daran, das weiterhin zu verwenden

 

[nillehammer]

Als Ansatz folgender Code. Keine Garantie für vollständige Richtigkeit, weil ich nicht lange drüber nachgedacht und es auch nicht ausgiebig getestet habe. Es sollte aber leicht sein, ggf. den Code anzupassen.

static int maximumNeededIterations(final int zahl) {

  int divisionResult = zahl;
    
  int runs = 0;
   
  do{
    divisionResult = divisionResult /2;
      
    runs++;
      
  }while(divisionResult > 0);
    
  return runs;
}

Hatte keine Lust, lange zu diskutieren, warum Du auf sowas nicht selbst kommst oder, warum Du so einen Code nicht posten möchtest. :noe: Deswegen gab's das mal frei Haus... ist ja bald Weihnachten.

 

[Altasha]

Ich "ziere" mich net, aber egal...genau so wie der Code nillehammer habe ich das ganze auch schon aufgebaut. dennoch flieg ich immer aus der schleife

 private void auswertung()
  {
    int maxRunden = berechneMaxRunden();

    String str = "Richtig!";
    str += "\nBenoetigte Versuche:       " + runde;
    str += "\nMaximal notwendige Anzahl: " + maxRunden;

    System.out.println( str);
  }

 private int berechneMaxRunden()
  {
    maxRunden = 0;
    int n;
    // Berechnen der max. notwendigen Runden maxRunden

    	    
            maxRunden++;
    	   
    	    n = max / 2;

    
    return 0;
  }

Das ist jetzt ein Teil des Programms. max ist dabei der Wert der oberen Grenze. Das mit der do-while-Schlefie habe ich wieder rausgenommen, damit das Programm überhaupt funktioniert und return hab ich auf Null gesetzt.

 

[Landei]

Als Ansatz folgender Code. Keine Garantie für vollständige Richtigkeit, weil ich nicht lange drüber nachgedacht und es auch nicht ausgiebig getestet habe. Es sollte aber leicht sein, ggf. den Code anzupassen.

static int maximumNeededIterations(final int zahl) {

  int divisionResult = zahl;
    
  int runs = 0;
   
  do{
    divisionResult = divisionResult /2;
      
    runs++;
      
  }while(divisionResult > 0);
    
  return runs;
}

Wenn Zahl schon 0 ist, wird die Schleife einmal durchlaufen, was einmal zu viel wäre. Mit

while

statt

do-while

müsste es gehen.

 

[nillehammer]

Wenn Zahl schon 0 ist, wird die Schleife einmal durchlaufen, was einmal zu viel wäre.

Das war tatsächlich Absicht, weil es in der Frage darum ging, wieviele Zugriffe man mit der Strategie maximal braucht, um aus einem Intervall eine Zahl zu finden. Da dachte ich: "Einen braucht man ja mindestens..."

 

[Altasha]

Ich danke!

Hat geklappt, hab das Schema so übernommen

 private int berechneMaxRunden()
  {
    maxRunden = 0;
    int n = max;
    // Berechnen der max. notwendigen Runden maxRunden
    do
    {
    	    n = n / 2;
    	    maxRunden++;
    }
    while(n > 0);

    
    return maxRunden;
  }

Nur komisch, dass ich das so ähnlich schonmal geschrieben habe und das aber nicht funktionierte, egal^^
Danke nochmal

 

[nillehammer]

Ganz Unrecht hat Landei mit seiner Kritik an meinem Code aber nicht. Es ist in der Tat doof, dass man immer die Schleife betritt. Damit werden ggf. unnötige Zuweisungen gemacht. Besser ist es so:
Mein Code:

static int maximumNeededIterations(final int zahl) {
 
  int divisionResult = zahl;
    
  int runs = 1;
   
  while(divisionResult > 0) {

    divisionResult = divisionResult /2;
      
    runs++;
      
  };
    
  return runs;
}

Und angepasst auf Deinen Code:

private int berechneMaxRunden()
{
    maxRunden = 1;
    int n = max;
    // Berechnen der max. notwendigen Runden maxRunden
     while(n > 0)
     {
          n = n / 2;
          maxRunden++;
     }

    return maxRunden;
 }

 

[Altasha]

Es ist in der Tat doof, dass man immer die Schleife betritt.

Es soll ja aber so sein, dass das immer mit ausgespuckt wird. Also auch, dass er immer die Schleife betritt.

Da ich ja am Ende ausgebe, welches die zu eratende Zahl war (wenn man sie dann erraten hat), dazu die Anzahl der Versuche und noch in wie vielen Schritten man dies strategisch ermitteln hätte können.

Oder denke ich da jetzt falsch?^^

 

[Dow Jones]

Oder denke ich da jetzt falsch?^^

Ob die Schleife nun mindestens einmal betreten wird oder nicht ist reichlich egal, solange das richtige Ergebnis herauskommt (und das ist in beiden Versionen der Methode der Fall). Welche der beiden Methoden man nun verwendet ist reine Geschmackssache. Nimm halt diejenige die du leichter nachvollziehen kannst.
Oder verzichte komplett auf die Schleifen: (Matheunterricht kann manchmal schon nützlich sein )

        maxRunden = (int)Math.floor( Math.log(max) / Math.log(2) )+1;