Kleine Straße C++

Guten Morgen.

Ich fummel seit einiger Zeit an einem Programm herum. Dieses soll eigentlich nichts weiter machen, als erkennen wenn ich eine kleine Straße "Gewürfelt" worden ist.

Es gibt 5 Würfel, diese können natürlich 6 Zahlen darstellen. Zahlen können bei 5 Würfeln natürlich doppelt vorkommen und die Reihenfolge ist natürlich auch immer anders.

Soweit bin ich gekommen. Ich begehe aber ganz sicher irgendwo einen Denkfehler. Kann jemand helfen? Hat jemand Tipps?

Code:

---

#include <iostream>
#include <string>
using namespace std;

int main()
{
        int tmp;
        int b = 1;
        int wuerfel[5];
        int wuerfels[5];
        wuerfel[0] = 2;
        wuerfel[1] = 4;
        wuerfel[2] = 3;
        wuerfel[3] = 5;
        wuerfel[4] = 4;
        wuerfel[5] = 2;
        int max = 6;
       
       
        // Hier wird sortiert.
        int min,i,j,x;
        for(i = 0; i < max; i++)
        {
                        min = i;
                        for (j = i + 1; j < max; j++)
                        if ( wuerfel[j] < wuerfel[min] )
                                min=j;
                                x = wuerfel[min];
                                wuerfel[min] = wuerfel[i];
                                wuerfel[i] = x;
                       
    }
       
        //hier wird das neue arry voll gemacht
        for (int a = 0; a < 6; a++)
        {
                if (wuerfel[a] == wuerfel[b])
                {
                wuerfels[b] = 0;
                wuerfels[a] = wuerfel[a];
                a++;
                b++;
                }
                else
                {
                wuerfels[a] = wuerfel[a];
                }
                b++;
               
        }
                tmp = wuerfels[0] + wuerfels[1] + wuerfels[2] + wuerfels[3] + wuerfels[4] + wuerfels[5];
        if ( tmp == 18 or 23 or 24 or 25 or 33)
        {
                printf("Kleine Strasse");
        }
        else
        {
                printf("Keine kleine Strasse");
        }
       
       
        return 0;
}

---

MFG

Ich komme bei der ganzen wuerfe-wuerfel-wuerfels Geschichte nicht draus aber ich glaube nicht dass dein Test am Ende ausreichend ist. Ich meine die Summe 18 kann man ja auch auf x andere Arten erreichen.

MfG Peschmä

Hallo!

Hm, das habe ich mir auch schon gedacht... Ich komme nur nicht drauf wie ich es irgendwie prüfen kann.

Im oberen Teil habe ich die Würfel in ein Array gepackt. wuerfel[0]... wuerfel[1].... steht jeweils für einen Würfel. Wenn ich jetzt "würfle" kann ja eine kleine Straße dabei herauskommen. Es kann dabei auch sein das Würfel die gleichen Zahlen zeigen und natürich können die Würfel durcheinander sein.

Darum habe ich im Array die Werte der Größe nach sortiert. Tja.. und jetzt stehe ich da mit meinem sortierten Array, komme aber leider nicht weiter :(


Der Teil des Codes hier unten ist eher ein "schwachsinniger" Versuch.....

Code:

---

min=j;
                                x = wuerfel[min];
                                wuerfel[min] = wuerfel[i];
                                wuerfel[i] = x;
                       
    }
       
        //hier wird das neue arry voll gemacht
        for (int a = 0; a < 6; a++)
        {
                if (wuerfel[a] == wuerfel[b])
                {
                wuerfels[b] = 0;
                wuerfels[a] = wuerfel[a];
                a++;
                b++;
                }
                else
                {
                wuerfels[a] = wuerfel[a];
                }
                b++;
               
        }
                tmp = wuerfels[0] + wuerfels[1] + wuerfels[2] + wuerfels[3] + wuerfels[4] + wuerfels[5];
        if ( tmp == 18 or 23 or 24 or 25 or 33)
        {
                printf("Kleine Strasse");
        }
        else
        {
                printf("Keine kleine Strasse");
        }

---

MFG

Mit dem sortierten Array hast kannst du ja einfach mit einer Monsterbedingung prüfen:

Code:

---

if ( (a[0] == 1 && a[2] == 2 && a[3] ==3 .... ) || (a[1] == 2 && a[2] == 3 ...) || bla)

---

Brute-force quasi. Oder du machst was mit ner Schleife à la:

Code:

---

bool strasse = true;
for (int i = 1; i < 6; i++)
{
  if (array[0]+i != array[i])
  {
    strasse = false;
    break;
  }
}

---

d.h. du nimmst den Wert im ersten Arrayfeld und guckst dann fürs nächste ob das eins grösser ist. Wenn dem so ist guckst du weiter, wenn nicht ist eh schon fertig.

MfG Peschmä

Hi!

Zitat:

---

Zitat von peschmae

d.h. du nimmst den Wert im ersten Arrayfeld und guckst dann fürs nächste ob das eins grösser ist. Wenn dem so ist guckst du weiter, wenn nicht ist eh schon fertig.

---

Das habe ich mir auch schon überlegt!
Nur, wenn ich z.B. folgendes Werfe:

2 2 3 4 5 Dann habe ich eine kleine Straße. Denn 2 3 4 5 ist ja eine :)

Der zweite Wert ist aber nicht größer als der erste...



Ich bin im Moment hier... Das scheint auch zu funktionieren. Der Code ist zwar nur für 5 Würfel, man sollte ich aber auch so für 6 nutzen können... ich teste aber noch dran herum.

Code:

---

#include <iostream>
#include <string>
using namespace std;

int main()
{
        int tmp;
        int b = 1;
        int wuerfel[4];
        int wuerfels[4];
        wuerfel[0] = 5;
        wuerfel[1] = 2;
        wuerfel[2] = 2;
        wuerfel[3] = 4;
        wuerfel[4] = 3;
        int max = 5;
       
       
        // Hier wird sortiert.
        int min,i,j,x;
        for(i = 0; i < max; i++)
        {
                        min = i;
                        for (j = i + 1; j < max; j++)
                        if ( wuerfel[j] < wuerfel[min] )
                                min=j;
                                x = wuerfel[min];
                                wuerfel[min] = wuerfel[i];
                                wuerfel[i] = x;
                       
    }
       
        wuerfels[0] = wuerfel[2] - wuerfel[0];
        wuerfels[1] = wuerfel[3] - wuerfel[1];
        wuerfels[2] = wuerfel[4] - wuerfel[2];
        tmp = wuerfels[0] + wuerfels[1] + wuerfels[2];
        if (tmp == 4 or tmp == 5)
        {
                printf("Kleine Strasse");
        }
        else
        {
                printf ("Keine Kleine Strasse");
        }
       

       
       
        return 0;
}

---

Oder sehe ich das falsch?

Grüße

Hallo....

Zitat:

---

Zitat von Kernel-Error

Ich bin im Moment hier... Das scheint auch zu funktionieren. Der Code ist zwar nur für 5 Würfel, man sollte ich aber auch so für 6 nutzen können... ich teste aber noch dran herum.

---

Pustekuchen.... Das geht auch nicht.

2 2 2 3 5 wüde auch als Straße gewertet....

Ich verzweifle hier noch :(

MFG

Zitat:

---

Zitat von Kernel-Error

Das habe ich mir auch schon überlegt!
Nur, wenn ich z.B. folgendes Werfe:

2 2 3 4 5 Dann habe ich eine kleine Straße. Denn 2 3 4 5 ist ja eine :)

Der zweite Wert ist aber nicht größer als der erste...

---

Mist. Ich hab da irgendwie das klein in Strasse ignoriert. :D

Dann machst du halt einen "Fehlercounter" - d.h. ein Int der am Anfang bei 0 ist. Dann gehst du das Array durch und jedesmal wenn die nächste Zahl nicht eins grösser ist als die vorher gibts ein ++ auf den Counter...
[Edit]Nein, das ginge dann ja auch mit 2 3 3 4 5 6 oder so.
Dann halt noch irgendwie einbauen dass die "Fehlerstelle" nur zwischen dem ersten und zweiten oder den beiden letzten sein darf oder so?
[/Edit]

MfG Peschmä

Hallo!

Öhm.... wie meinst du das?

MFG

So in pseudo-Code:

public boolean checkObZahlVorhanden(int zahl, int[] arr){
for(int i=0; i<arr.length(); i++){
if(arr[i] == zahl){
return true;
}
}
return false;
}

// Hier Strasse prüfen
for(int i=1; i<6;i++){
if(!checkObZahlVorhanden(i,wurefel)){
std::cout << "keine Strasse";
}
}

ist ne kleine strasse eine kombi aus 4 zahlen?
ich denke das sollte tun ...

array zahl wird 0 gesetzt ... dann die würfel durchgegangen .. und einfach dem würfelwert entsrpechend an die position bei zahl geschrieben ...

der check ob es eine strasse ist, geht wie folgt ... fange
bei 1 an und checke dann ob die nächsten 4 folgenden zahlen multipliziert nicht null geben ...
ansonsten noch bei der 2 und bei der 3 anfangen, fertig

Code:

---


bool isStreet(int *wuerfel)
{
int i,j;
int x;
int zahl[6];

for (i=0;i<6;i++)
  zahl[i]=0;

for (i=0;i<6;i++)
  {
  zahl[wuerfel[i]]++;
  }


for (i=0;i<=2;i++)
  {
  x=1;
  for (j=0;j<4;j++)
    x=x*zahl[i+j];
  if (x !=0)
      return true;
  }
return false;
}

---

moe

EDIT: oh, genau bischi hat das schon genauso gebastelt

1. Schritt: bestimme Häufigkeit aller Zahlen (auch für andere Auswertungen gut)

2. checke, ob eine der beiden n-1er Reihen vorkommt:
2a: die mittleren Zahlen müssen mindestens 1x besetzt sein.
2b: entweder kommt die 1 oder die 6 zusätzlich vor.

Code:

---


// Häufigkeit, direkt als 1.Schritt bei Auswertung:
for (i=1; i<=6; i++) hw[i]=0;
for (i=0; i<nwuerfel; i++) hw[wurf[i]]++;

bool kleine_strasse(int hw[])
{
  // entweder 1 oder 6 ist besetzt
  bool ok=((hw[1]>0) || (hw[6]>0));

  // fehlt was in der Mitte, keine kl.Straße:
  if (ok) for (int i=2; i<=5; i++) if (hw[i]<1) ok=false; 
  return ok;
}

---

so long,
BlueJay