[Lolomoloko]

wie man dem titel entnehmen kann, schreibe ich grade einen kniffel clon und hänge bei der überprüfung auf eine kleine straße.

Jetzt wollte ich mir hier ein paar denkanstöße hohlen, da ich selbst nicht drauf komme wie es gut zu bewerkstelligen ist.

Hier nochmal die bedingung für eine kl. Straße:
Von den fünf würfeln müssen 4 aufeinanderfolgende sein.
Also es ergeben sich dabei folgende kombinationsmöglichkeiten {1, 2, 3, 4}, {2, 3, 4, 5} oder {3, 4, 5, 6}

Ich hab nun also einen aufsteigend sortierten array und möchte nun überprüfen ob die bedingung erfüllt sind.
Über tipps wäre ich sehr erfeut.
ihr könnte auch gerne pseudocode posten um die idee zu veranschaulichen.

[Sumpfkrautjunkie]

Das mit dem aufsteigend sortierten Array ist schon mal gut, ich würde das ganze in einer For Schleife durchgehen und die Differenz zweier benachbarter Werte ermitteln (muss 1 sein, wenn es aufeinander folgend sein soll).

In "Pseudo"Code:

int folge=0;
for(int i=0;i<array.Count-1;i++) //-1 um nicht aus dem Array zu laufen
{
    if(array[i+1]-array[i]==1)//wenn 2 aufeinander folgen, ist die Differenz 1
    {
      folge++;//wenn folge hinterher den Wert 4 hat, dann war die Reihe komplett
    }
    else if(i>1) //sind ja nur 5 Würfel, also entweder ab dem 0. oder dem 1. Würfel muss die Folge da sein
    {
       break; //raus, macht keinen Sinn weiterzugucken
    }   
}

if (folge==4)//wenn ==4, dann wurden 4 aufeinander folgende Zahlen gefunden (das >= habe ich absichtlich nicht verwendet, da bei 5 wohl eine große Straße kommt und dies ja ein anderer Fall wäre)
{
}

Ich hoffe, ich habe nichts Wesentliches vergessen.

[Satans Krümelmonster]

man spielt kniffel aber doch mit 5 würfeln...
was machst du also, wenn dein array {1,2,2,3,4} ist?
man sollte also die doppelt auftretenden zahlen vor der überprüfung rauswerfen.

[Lookbehind]

Ich würde den sortierten Array durchlaufen und jehweils überprüfen ob das folgende ellement genau 1 größer ist, als das vorige. Wenn ja, soll ein Zähler hoch gezählt werden, komm ich insgesammt auf 3 Zähler punkte hab ich eine kleine Straße. Man muss nur den Fall abfangen das eine Folge wie (1,2,4,5,6) ebenfalls als solch eine Folge erfasst wird.

int folge=0;

for (int i=0; i<4; i++)
{
     if ((sortedarray[i]+1) == sortedarray[i+1])
     {
          folge++;
     }else if ((sortedarray[i]+1) != sortedarray[i+1] && folge >= 1)
     {
          break;
     }
}
if (folge == 3)
{
     print("kleine Straße");
} else if (folge == 4)
{
     print("große Straße");
}

Eine andere Möglichkeit wäre den Array in einen String aus 5 zeichen zu wandeln und zu prüfen ob eine der 3 möglichen Verbindungen darin vor kommen.
Das ist hier aber nur deshalb denkbar weil die Anzahl der möglichen Kombinationen recht klein ist. Die andere Variante funktioniert auch bei Würfeln mit 12 Augen.

Edith sagt ich bin VIEL zu langsam!

[Lolomoloko]

Das mit dem aufsteigend sortierten Array ist schon mal gut, ich würde das ganze in einer For Schleife durchgehen und die Differenz zweier benachbarter Werte ermitteln (muss 1 sein, wenn es aufeinander folgend sein soll).

das war auch mein erster gedanke, aber krümli hat ja schon ein problem davon angesprochen.

man sollte also die doppelt auftretenden zahlen vor der überprüfung rauswerfen.

wie würde man das am elegantesten lösen?^^

ps.
seid wann und vor allem wo bist du webbi?
auf jedenfall herzliches beileid dazu

[Satans Krümelmonster]

wie würde man das am elegantesten lösen?^^

int[] newarray;
for(int i=0;i<array.Count-1;i++){
  if(array[i] != newarr[i-1] && i>0)
    newarr[i]=array[i];
}

kann aber sein, dass es nicht funktioniert. ich hab's nicht versucht

ps.
seid wann und vor allem wo bist du webbi?
auf jedenfall herzliches beileid dazu

assassin's creed.
danke

[Sumpfkrautjunkie]

Ach stimmt, verdammt.

Könntest ja übers Hashen machen:
Da bräuchtest du nicht mal sortieren, du packst aller erwürfelten Elemente in eine Hash-Tabelle und guckst hinterher einfach, wie lang diese ist.
Wobei es für diesen Fall wohl eher mit Kanonen auf Spatzen schießen heißen würde^^

...

Neuer Ansatz:

int folge=0;
for(int i=0;i<array.Count-1;i++) //-1 um nicht aus dem Array zu laufen
{
    if(array[i+1]-array[i]==1)//wenn 2 aufeinander folgen, ist die Differenz 1
    {
      folge++;//wenn folge hinterher den Wert 3 hat, dann war die Reihe komplett
    }
   
}

if (folge==3)//wenn ==3, dann wurden 4 aufeinander folgende Zahlen gefunden (das >= habe ich absichtlich nicht verwendet, da bei 5 wohl eine große Straße kommt und dies ja ein anderer Fall wäre)
{
}

Dann fällt das break eben weg.
Dürfte aber immer noch schneller sein, als nochmal vorher das Array nach doppelten Einträgen zu durchkämmen.

Probe:
1,2,2,3,4
i=0
Differenz der 0. und 1. Zahl ist 1 also folge=1;
i=1
Differenz der 1. und 2. Zahl (2,2) =0, folge=1;
i=2
Differenz der 2. und 3. Zahl (2,3)=1, folge=2;
i=3;
Differenz der 3. und 4. Zahl (3,4)=1 folge =3;
passt also.

[Vertaler]

Hier ein etwas anderer () Code (und nicht einmal Pseudo-):

run(A) :- small_straight(A), !.
run(A) :- 
	remove_one(A, B),
	small_straight(B),
	!.

small_straight([_]) :- !.
small_straight([A,B|Rest]) :-
	1 is B-A,
	small_straight([B|Rest]).

remove_one([A,B|Rest], [A|Rest]) :- %front
	not(1 is B-A).
remove_one([A,B|Rest], [B|Rest]) :- %back
	not(1 is B-A).
remove_one([A|Rest], [A|Return]) :-
	remove_one(Rest, Return).

Ineffizient, aber logisch.
(Prüft auf n-1 aufeinanderfolgende Zahlen in einer aufsteigend sortierten Liste der Länge n.)

[Satans Krümelmonster]

Probe:
1,2,2,3,4
i=0
Differenz der 0. und 1. Zahl ist 1 also folge=1;
i=1
Differenz der 1. und 2. Zahl (2,2) =0, folge=1;
i=2
Differenz der 2. und 3. Zahl (2,3)=1, folge=2;
i=3;
Differenz der 3. und 4. Zahl (3,4)=1 folge =3;
passt also.

Versch das mal mit {1,3,4,5,5}

@Vertaler: welche Programiersprache ist das denn?

[Vertaler]

Prolog.

[Lolomoloko]

Versch das mal mit {1,3,4,5,5}

funktioniert.

also danke für die tipps, manchmal steht man einfach auf dem schlauch

@vertaler
hübsch

[Pyrokar]

int[] newarray;
for(int i=0;i<array.Count-1;i++){
  if(array[i] != newarr[i-1] && i>0)
    newarr[i]=array[i];
}

kann aber sein, dass es nicht funktioniert. ich hab's nicht versucht

Das würde im ersten Durchlauf zu einer Verletzung der Arraygrenze führen (wenn man nicht eine Sprache nutzt, die wie z.B. Delphi eigens definierte Indizes erlaubt) - allerdings würde es (je nach Compiler/Sprache) funktionieren, wenn du die Reihenfolge der boolschen Ausdrücke vertauschst, da ggf. wegen i=0 abgebrochen würde.
Die Idee an sich passt aber - nur dass man das erste Element direkt übernehmen würde und danach mit deiner Schleife vergleichen kann.
In Sprachen mit statischen Arrays würde ich aber auf eine Liste o.ä. setzen.

[ojas]

bool testFourOfAKind(int[] roll) {
  int mask = 0;
  for (int i = 0; i < 5; ++i) {
    mask |= ( 1 << roll[i] );
  }
  return (mask == 30 || mask == 60 || mask == 120);
}