字符串|| Ruby中的比较运算符

Question

我是Ruby的新手，我正在尝试编写一个简单的TicTacToe游戏。

我刚刚遇到一个小问题，评估一名球员是否赢了比赛。

从本质上讲，游戏适用于一个等于：

board = ["#",' ',' ',' ',' ',' ',' ',' ',' ',' ']

每次玩家移动时，他们的“标记”（X或O）都被添加到棋盘上，并且有功能来检查是否采取了该位置，是否是平局或者玩家是否赢了。

所以临时董事会可能看起来像这样：

board = ["#",' ',' ','O',' ','X',' ','O',' ',' ']

在评估是否有人获胜时，我的问题就出现了。我已经为此编写了一个函数:(前3个表达式检查水平获胜，接下来3个是垂直获胜，后续2个表示对角线获胜。

def check_for_win(board)
  if [board[1],board[2],board[3]].uniq == [("X" || "O")] || [board[4],board[5],board[6]].uniq == [("X" || "O")] ||
    [board[7],board[8],board[9]].uniq == [("X" || "O")] || [board[1],board[4],board[7]].uniq == [("X" || "O")] ||
    [board[5],board[2],board[8]].uniq == [("X" || "O")] || [board[6],board[9],board[3]].uniq == [("X" || "O")] ||
    [board[1],board[5],board[9]].uniq == [("X" || "O")] || [board[7],board[5],board[3]].uniq == [("X" || "O")] 
    true
  else
    false
  end 
end 

此函数似乎评估是否存在具有“X”标记的获胜者，但是对于“O”标记，如果不能评估为真。应该注意的是，表达式的左侧仍然评估我想要的内容，例如：

board = ["#",' ',' ','O',' ','O',' ','O',' ',' ']
p [board[7],board[5],board[3]].uniq 
>> ["O"]

我似乎无法理解为什么，并且对此的任何指示都将非常感激。

Answer 1

'X' || 'O'只是说X或O.并且因为任何字符串都是真的它总是返回X.所以你说过[('X' || 'O')]的任何地方，你真的只是说['X']。

因此，你只是检查整行3是否都是X.

我真的不明白你是怎么试着测试这个的，但是我觉得你最好先运行这个功能两次，先交出X然后交给O，如果它没有找到X作为胜利者，反对尝试同时检查两者。

或者你可以让函数返回'X'，'O'或nil然后你可以让它只运行一次函数。返回的字符串将是谁赢了，如果它是零则没有人赢了。我还建议为此制作一个循环。我发现它更容易阅读。

这是我如何解决问题。

ROWS = [
  [1,2,3],
  [4,5,6],
  [7,8,9],

  [1,4,7],
  [2,5,8],
  [3,6,9],

  [1,5,9],
  [7,5,3],
]

def find_winner(board)
  ROWS.each do |row|
    # subtract 1 because the ROWS is 1-indexed (like a phone dial) but arrays are 0-indexed
    row_values = row.map { |v| board[v - 1] }
    return('X') if row_values.all?('X')
    return('O') if row_values.all?('O')
  end

  return(nil)
end


test1 = [
  'X', 'X', 'X',
  'O', 'X', 'O',
  'O', 'O', '',
]
puts "Winner of test1: #{find_winner(test1).inspect}"
"X"

test2 = [
  'X', '',  'X',
  'X', 'O', 'O',
  'X', 'O', 'X',
]
puts "Winner of test2: #{find_winner(test2).inspect}"
"X"

test3 = [
  'O', 'X', 'X',
  'O', 'X', 'O',
  'O', 'O', '',
]
puts "Winner of test3: #{find_winner(test3).inspect}"
"O"

test4 = [
  'O', 'X', 'O',
  'X', 'O', 'X',
  'O', 'O', 'X',
]
puts "Winner of test4: #{find_winner(test4).inspect}"
"O"

test5 = [
  'O', 'X', 'O',
  'O', 'X', 'O',
  'X', 'O', 'X',
]
puts "Winner of test5: #{find_winner(test5).inspect}"
nil

Answer 2

@Nate已回答你的问题。这是您编写方法的一种方法。

码

def check_for_win(board)
  check_rows(board)                              ||
  check_rows(board.transpose)                    ||
  check_rows([[0,1,2].map { |i| board[i][i] }])  ||    
  check_rows([[0,1,2].map { |i| board[i][2-i] }])
end

def check_rows(rows)
  rows.find { |row| row.uniq.size == 1 && row.first != :_ }&.first
end

&的check_rows是safe navigation operator。如果.first的区块返回nil，它会导致find被忽视并且nil返回。

例子

check_for_win [[:O, :_, :O],
               [:O, :X, :_],
               [:X, :X, :X]]
  #=> :X

check_for_win [[:O, :_, :O],
               [:O, :X, :X],
               [:O, :X, :X]]
  #=> :O

check_for_win [[:X, :O, :X],
               [:O, :X, :O],
               [:O, :X, :X]]
  #=> :X

check_for_win [[:X, :O, :O],
               [:X, :O, :_],
               [:O, :X, :X]]
  #=> :O

check_for_win [[:X, :O, :X],
               [:X, :O, :O],
               [:O, :X, :X]]
  #=> nil

check_for_win [[:_, :_, :_],
               [:X, :O, :O],
               [:O, :X, :X]]
  #=> nil