Treffen Sie Entscheidungen basierend auf Werten aus einem Array

Question

Ich habe ein assoziatives Array, das ich in aufsteigender Reihenfolge sortiert habe und jetzt möchte ich einige Entscheidungen über diese Werte treffen. Ich kann nicht verstehen, wie ich vorgehen soll. Jetzt

Array 
(
    [0] => Array 
     (
      [cell] => a1 
      [sign] => ◯ 
     ) 
    [1] => Array 
     (
      [cell] => b2 
      [sign] => ✘ 
     ) 
) 

:

Lassen Sie mich erklären, was ich erreichen möchte:

Angenommen: Ich habe die folgenden Ausgangs Array:

Array 
(
    [0] => Array 
     (
      [cell] => b2 
      [sign] => ✘ 
     )  
    [1] => Array 
     (
      [cell] => a1 
      [sign] => ◯ 
     ) 
) 

, die dann sortiert ich es als Ich möchte Entscheidungen treffen wie zB ob die Werte der Zellen a1 = b1 = c1 oder a1 = b2 = c3 usw. sind. Wie kann ich das nun machen?

Answer 1

Hier ist eine verallgemeinerte Implementierung in Javascript.Es wird nur auf 2x2 und 3x3 Spiel Staaten getestet, kann für andere Spielgrößen Debugging benötigen:

// xxx 
 
// oo- 
 
// o-- 
 
alert("game a: " + WhoIsWinningGeneratePaths('xxxoo-o--')); 
 

 

 
// x-x 
 
// oo- 
 
// o-- 
 
alert("game b: " + WhoIsWinningGeneratePaths('x-xoo-o--')); 
 

 
// x-x 
 
// ooo 
 
// --- 
 
alert("game c: " + WhoIsWinningGeneratePaths('x-xooo---')); 
 

 
// x- 
 
// oo 
 
alert("game d: " + WhoIsWinningGeneratePaths('x-oo')); 
 

 
// x- 
 
// ox 
 
alert("game e: " + WhoIsWinningGeneratePaths('x-ox')); 
 

 

 
// x- 
 
// o- 
 
alert("game f: " + WhoIsWinningGeneratePaths('x-o-')); 
 

 

 
function WhoIsWinningGeneratePaths(state) { 
 

 
    var n = Math.sqrt(state.length); 
 

 
    var rows = IsWin(state, GenPaths(n, 0,  1, n, n)); 
 
    var cols = IsWin(state, GenPaths(n, 0,  n, 1, n)); 
 
    var diUp = IsWin(state, GenPaths(1, n-1, n-1, 0, n)); 
 
    var diDn = IsWin(state, GenPaths(1, 0, n+1, 0, n)); 
 

 
    if (rows !== '-') return rows; 
 
    if (cols !== '-') return cols; 
 
    if (diUp !== '-') return diUp; 
 
    return diDn; 
 

 
} 
 

 
function GenPaths(count, start, incrementA, incrementB, lengthToWin) { 
 
    var paths = []; 
 
    for (var i = 0; i < count; i++) { 
 
    var path = []; 
 
    for (var j = 0; j < lengthToWin; j++) { 
 
     path.push(start + i * incrementB + j * incrementA) 
 
    } 
 
    paths.push(path); 
 
    } 
 
    return paths; 
 
} 
 

 

 
function IsWin(state, paths) { 
 
    for (var i = 0; i < paths.length; i++) { 
 
    var currentPathResult = IsPathWin(state, paths[i]); 
 
    if (currentPathResult != '-') 
 
     return currentPathResult; 
 
    } 
 
    return '-'; 
 
} 
 

 
function IsPathWin(state, path) { 
 
    var first = state[path[0]]; 
 
    for (var j = 1; j < path.length; j++) 
 
    { 
 
    var compareToFirst = state[path[j]]; 
 
    if (compareToFirst !== first) 
 
     return '-'; 
 
    } 
 
    return first; 
 
}

Answer 2

Erraten, dass Ihr Platz ist nur 3x3, würde ich sagen, der einfachste Weg, um die Spiele zu gewinnen innerhalb eines Arrays zu speichern wäre und vergleichen sie nur durch array_intersect() mit denen zwei Arrays kombiniert und liefert die duplizierte Werte in einem Array . Um die Anzahl der Duplikate zu erhalten, wickle einfach die count()-Funktion um und vergleiche, ob die Werte des einen oder anderen Spielers mit $winArr übereinstimmen. Offensichtlich gibt es noch Arbeit zu tun, indem duplizierte Werte für dein Eingangsarray gestoppt werden, indem du nach jeder Eingabe deine foreach() schleife ... aber deine Logik wird zumindest korrekt sein.

$winner; //Winner --> Used when game finished 

$winArr = [ 

    ['c1','c2','c3'], 
    ['b1','b2','b3'], // --> Vertical Win 
    ['a1','a2','a3'], 

    ['a1','b2','c3'], 
    ['c1','b2','c3'], // --> Diagonal Win 

    ['a1','b1','c1'], 
    ['a2','b2','c2'], // --> Horizontal Win 
    ['a3','b3','c3'], 

]; 

$gameArr = [ // --> `Input Values Array = Dimension for P1 & P2 for ease 

'playerOne' => ['a1', 'b1', 'c2', 'c1'], 
'playerTwo' => ['a3', 'b3', 'a2'],  

]; 



foreach ($winArr as $k=>$v) { 

    if (count(array_intersect($v, $gameArr['playerOne'])) === 3) { 

     $winner = 'Player One!';  
     break; 

    } elseif(count(array_intersect($v, $gameArr['playerTwo'])) === 3) { 

     $winner = 'Player Two!'; 
     break; 

    } 

} 

if (isset($winner)) { 

    echo $winner; 

} 

Ausgang:

Player One! 

See:http://www.php.net/manual/en/function.array-intersect.php

Answer 3

Ich schlage vor, die sich auf die Positionen der Zellen durch einen nullbasierten Index. Es erleichtert die Verwendung von mathematischen Tricks wie Modulo oder Integer-Division zur Auswahl von Zeilen oder Spalten. Andernfalls müssen Sie eine Menge Offsets verwenden, um Fehler in Einzelschritten zu vermeiden.

IE, könnte das Board beschriftet werden:

0 1 2 
3 4 5 
6 7 8 

Der Spielzustand kann mit einem Zeichenfeld dargestellt werden, mit Zeichen ‚-‘ leer bedeutet, und x und o x und o bedeutet dort gespielt.

Hier ist eine menschliche Spielansicht und das Spiel in einer String-Array gespeichert:

x 
o x o 
o x 

var state = "-x-oxoox-"; 

Um zu überprüfen, ob ein Spiel gewonnen hat, läßt eine Funktion machen.

Die Funktion gibt '-' zurück, wenn niemand gewonnen hat, 'x' wenn x gewonnen hat und 'o' wenn o gewonnen hat.

Ich werde Sie mit einer Implementierung starten, die jeden Pfad hart zu überprüfen hart überprüft. Dann zeige ich, wie man die zu prüfenden Pfade erzeugt.

function WhoIsWinningHardCode(state) { 

    var rows  = IsWin(state, [[0,1,2],[3,4,5],[6,7,8]]); 
    var cols  = IsWin(state, [[0,3,6],[1,4,7],[2,5,8]]); 
    var diagUp = IsWin(state, [[6,4,2]]); 
    var diagDown = IsWin(state, [[0,4,8]]); 

    if (rows  !== '-') return rows; 
    if (cols  !== '-') return cols; 
    if (diagUp !== '-') return diagUp; 
    return diagDown; 

} 

function WhoIsWinningGeneratePaths(state) { 

    var rows  = IsWin(state, GenPaths(3, 0, 1, 3)); 
    var cols  = IsWin(state, GenPaths(3, 0, 3, 1)); 
    var diagUp = IsWin(state, GenPaths(1, 2, 2, 0)); 
    var diagDown = IsWin(state, GenPaths(1, 0, 4, 0)); 

    if (rows  !== '-') return rows; 
    if (cols  !== '-') return cols; 
    if (diagUp !== '-') return diagUp; 
    return diagDown; 

} 

function GenPaths(count, start, incrementA, incrementB) { 
    var paths = []; 
    for (var i = 0; i < count; i++) { 
     var path = []; 
     for (var j = 0; j < 3; j++) { 
     path.push(start + i*incrementB + j*incrementA) 
     } 
     paths.push(path); 
    } 
    return paths; 
} 

function IsWin(state, paths) { 
    for (var i = 0; i < paths.length; i++) { 
    var path = paths[i]; 
    var a = state[path[0]]; 
    var b = state[path[1]]; 
    var c = state[path[2]]; 
    if (a !== '-') 
     if (a == b) 
     if (a == c) 
      return a; 
    } 

    return '-'; 
}