Une façon compacte de représenter toutes les "rangées" valides dans une grille de morpion.

Question

J'ai écrit le morpion dans une variété de langages à titre d'exercice, et l'une des caractéristiques qui est apparue est que toutes les représentations que j'ai trouvées pour définir les lignes gagnantes valides étaient décevantes et codées en dur. Elles se répartissent généralement en deux catégories :

Tout d'abord, le plateau est représenté sous la forme d'un tableau à une ou deux dimensions, et les rangées sont explicitement définies par des triplets de positions (les chiffres sont des espaces vides) :

board = [1, x, 3, 4, o, 6, 7, 8, x]

def match3(x,y,z)
  board[x] == board[y] && board[y] == board[z]
end

def winner
  match3(1,2,3) || match3(4,5,6) || ...
end

Cela a l'avantage d'une explicitation non-magique, mais cela semble verbeux.

L'autre approche consiste à utiliser un tableau de tableaux et à faire un mapping+reduce des lignes. C'est légèrement mieux, mais ça ne me permet pas d'aller jusqu'au bout :

board = [[nil, 1, nil], [nil, -1, nil], [nil, nil, 1]]

def diag(x,y,z)
  [board[x/3,x%3], board[y/3,y%3], board[z/3,z%3]]
end

def winner
  rows = board + board.transpose << diag(0,4,8) << diag(2,4,6)
  rows.map { |r| r.reduce(:&) }.reduce { |m,c| m || c }
end

Les correspondances verticales et horizontales sont excellentes, mais je continue à coder en dur les diagonales.

Quelqu'un peut-il penser à un moyen de caractériser les diagonales (ou à une approche totalement différente) qui ne repose pas sur des adresses explicites ?

Mon pseudo-code est en Ruby, mais n'hésitez pas à poster dans la langue de votre choix. J'ai vu le golf du code tic-tac-toe, et bien que certaines de ces solutions soient ingénieuses (surtout les carrés magiques !), je cherche quelque chose d'un peu moins obscur.