代码高尔夫：井字游戏

Question

按字符数发布您的最短代码，以检查玩家是否获胜，如果获胜，是哪一个。

假设变量 b（棋盘）中有一个整数数组，其中包含 Tic Tac Toe 棋盘和玩家的动作，其中：

• 0 = 没有设置
• 1 = 玩家 1 (X)
• 2 =玩家 2 (O)

因此，给定数组 b = [ 1, 2, 1, 0, 1, 2, 1, 0, 2 ] 将代表棋盘

X|O|X
-+-+-
 |X|O
-+-+-
X| |O

对于这种情况，您的代码应该输出1 表示玩家 1 获胜。如果没有人获胜，您可以输出 0 或 false。

我自己的（Ruby）解决方案很快就会推出。

编辑：抱歉，忘记将其标记为社区维基。您可以假设输入格式正确，并且不必进行错误检查。

---

更新：请以函数的形式发布您的解决方案。大多数人已经这样做了，但有些人还没有，这并不完全公平。该板作为参数提供给您的函数。结果应该由函数返回。该函数可以有您选择的名称。

Answer 1

疯狂的 Python 解决方案 - 79 个字符

max([b[x] for x in range(9) for y in range(x) for z in range(y)
    if x+y+z==12 and b[x]==b[y]==b[z]] + [0])

但是，这假设 b 中的棋盘位置有不同的顺序：

 5 | 0 | 7
---+---+---
 6 | 4 | 2
---+---+---
 1 | 8 | 3

即 b[5] 代表左上角，所以在。

为了最大限度地减少上述内容：

r=range
max([b[x]for x in r(9)for y in r(x)for z in r(y)if x+y+z==12and b[x]==b[y]==b[z]]+[0])

93 个字符和一个换行符。

更新： 使用按位 AND 技巧减少至 79 个字符和一个换行符：

r=range
max([b[x]&b[y]&b[z]for x in r(9)for y in r(x)for z in r(y)if x+y+z==12])

Answer 2

C，77 (83) 个字符

这是 dmckee' 的变体s 解决方案，不同之处在于紧凑编码中的每对数字现在都是 ASCII 字符的基于 9 的数字。

77-char 版本，不适用于 MSVC：

// "J)9\t8\r=,\0" == 82,45,63,10,62,14,67,48,00 in base 9.
char*k="J)9 8\r=,",c;f(int*b){return(c=*k++)?b[c/9]&b[c%9]&b[*k--%9]|f(b):0;}

此 83-char 版本，应该适用于每个 C 编译器：（

f(int*b){char*k="J)9    8\r=,",s=0,c;while(c=*k++)s|=b[c%9]&b[c/9]&b[*k%9];return s;}

请注意，9 和 8 之间的空格应该StackOverflow 将所有制表符转换为空格。）

---

测试用例：

#include <stdio.h>  
void check(int* b) {
    int h0 = b[0]&b[1]&b[2];
    int h1 = b[3]&b[4]&b[5];
    int h2 = b[6]&b[7]&b[8];
    int h3 = b[0]&b[3]&b[6];
    int h4 = b[1]&b[4]&b[7];
    int h5 = b[2]&b[5]&b[8];
    int h6 = b[0]&b[4]&b[8];
    int h7 = b[2]&b[4]&b[6];
    int res = h0|h1|h2|h3|h4|h5|h6|h7;
    int value = f(b);
    if (value != res)
        printf("Assuming f({%d,%d,%d, %d,%d,%d, %d,%d,%d}) == %d; got %d instead.\n", 
            b[0],b[1],b[2], b[3],b[4],b[5], b[6],b[7],b[8], res, value);
}
#define MAKEFOR(i) for(b[(i)]=0;b[(i)]<=2;++b[(i)])

int main() {
    int b[9];

    MAKEFOR(0)
    MAKEFOR(1)
    MAKEFOR(2)
    MAKEFOR(3)
    MAKEFOR(4)
    MAKEFOR(5)
    MAKEFOR(6)
    MAKEFOR(7)
    MAKEFOR(8)
        check(b);

    return 0;
}

Answer 3

Python 80 (69) char

不是最短的 Python 解决方案，但我喜欢它如何将“DICE”引入井字游戏：

W=lambda b:max([b[c/5-9]&b[c/5+c%5-9]&b[c/5-c%5-9]for c in map(ord,"DICE>3BQ")])

69 个字符用于更简单的表达式：

max([b[c/5-9]&b[c/5+c%5-9]&b[c/5-c%5-9]for c in map(ord,"DICE>3BQ")])

Answer 4

Perl，87 85 个字符

当然，使用正则表达式返回 0、1 或 2 的函数（换行符只是为了避免滚动条）：

sub V{$"='';$x='(1|2)';"@_"=~
/^(...)*$x\2\2|^..$x.\3.\3|$x..\4..\4|$x...\5...\5/?$^N:0}

它可以被称为 V(例如，@b)。

Answer 5

J，50 个字符

w=:3 : '{.>:I.+./"1*./"1]1 2=/y{~2 4 6,0 4 8,i,|:i=.i.3 3'

Answer 6

我不满意重复自己（水平/垂直和对角线），但我认为这是一个公平的开始。

C# w/LINQ：

public static int GetVictor(int[] b)
{
    var r = Enumerable.Range(0, 3);
    return r.Select(i => r.Aggregate(3, (s, j) => s & b[i * 3 + j])).Concat(
        r.Select(i => r.Aggregate(3, (s, j) => s & b[j * 3 + i]))).Aggregate(
        r.Aggregate(3, (s, i) => s & b[i * 3 + i]) | r.Aggregate(3, (s, i) => s & b[i * 3 + (2 - i)]),
        (s, i) => s | i);
}

策略：按位 AND 行/列/对角线的每个元素与其他元素（以 3 作为种子）以获得该子集的胜利者，以及 OR< /code> 最后将它们全部放在一起。

Answer 7

Ruby，115 个字符

哎呀：不知怎的，我数错了很多。这实际上是 115 个字符，

def t(b)[1,2].find{|p|[448,56,7,292,146,73,273,84].any?{|k|(k^b.inject(0){|m,i|m*2+((i==p)?1:0)})&k==0}}||false end

# Usage:
b = [ 1, 2, 1,
      0, 1, 2,
      1, 0, 2 ]
t(b) # => 1

b = [ 1, 1, 0,
      2, 2, 2,
      0, 2, 1 ]
t(b) # => 2

b = [ 0, 0, 1,
      2, 2, 0,
      0, 1, 1 ]
t(b) # => false

而不是 79 个。出于教育目的，扩展的代码：

def tic(board)
  # all the winning board positions for a player as bitmasks
  wins = [ 0b111_000_000,  # 448
           0b000_111_000,  #  56
           0b000_000_111,  #   7
           0b100_100_100,  # 292
           0b010_010_010,  # 146
           0b001_001_001,  #  73
           0b100_010_001,  # 273
           0b001_010_100 ] #  84

  [1, 2].find do |player| # find the player who's won
    # for the winning player, one of the win positions will be true for :
    wins.any? do |win|
      # make a bitmask from the current player's moves
      moves = board.inject(0) { |acc, square|
        # shift it to the left and add one if this square matches the player number
        (acc * 2) + ((square == player) ? 1 : 0)
      }
      # some logic evaluates to 0 if the moves match the win mask
      (win ^ moves) & win == 0
    end
  end || false # return false if the find returns nil (no winner)
end

我确信这可以缩短，尤其是大数组，可能还有用于获取玩家动作的位掩码的代码——三元让我烦恼—— -但我认为目前这已经相当不错了。

Answer 8

Perl, 76 char

sub W{$n=$u=0;map{$n++;$u|=$_[$_-$n]&$_[$_]&$_[$_+$n]for/./g}147,4,345,4;$u}

水平取胜有三种方法：

0,1,2   ==>   1-1, 1, 1+1
3,4,5   ==>   4-1, 4, 4+1
6,7,8   ==>   7-1, 7, 7+1

一种从左下到右上对角取胜的方法：

2,4,6   ==>   4-2, 4, 4+2

垂直取胜的三种方法：

0,3,6   ==>   3-3, 3, 3+3
1,4,7   ==>   4-3, 4, 4+3
2,5,8   ==>   5-3, 5, 5+3

从左上到右下对角取胜的一种方法：

0,4,8   ==>   4-4, 4, 4+4

阅读中间的列以获得魔力数字。

Answer 9

Octave/Matlab，97 个字符，包括空格和换行符。如果没有获胜者，则输出 0；如果玩家 1 获胜，则输出 1；如果玩家 2 获胜，则输出 2；如果两个玩家都“获胜”，则输出 2.0801：

function r=d(b)
a=reshape(b,3,3)
s=prod([diag(a) diag(fliplr(a)) a a'])
r=sum(s(s==1|s==8))^(1/3)

如果我们更改规格并从一开始将 b 作为 3x3 矩阵传入，我们可以删除重塑线，将其减少到 80 个字符。

Answer 10

因为正确玩时没有人会在 tictactoe 中获胜，我认为这是最短的代码

echo 0; 

7 个字符

更新：bash 的更好条目是这样的：

86 个字符或 81 个字符，不包括函数定义（win（））。

win()for q in 1 28 55 3 12 21 4 20;{ [[ 3*w -eq B[f=q/8]+B[g=q%8]+B[g+g-f] ]]&&break;}

但是，这是来自 bash 中的 tic-tac-toe 程序的代码，因此它不太符合规范。

# player is passed in caller's w variable. I use O=0 and X=2 and empty=8 or 9
# if a winner is found, last result is true (and loop halts) else false
# since biggest test position is 7 I'll use base 8. could use 9 as well but 10 adds 2 characters to code length
# test cases are integers made from first 2 positions of each row
# eg. first row (0 1 2) is 0*8+1 = 1
# eg. diagonal (2 4 6) is 2*8+4 = 20
# to convert test cases to board positions use X/8, X%8, and X%8+(X%8-X/8)
# for each test case, test that sum of each tuplet is 3*player value

Answer 11

Ruby, 85 char

def X(b)
u=0
[2,6,7,8,9,13,21,-9].each do|c|u|=b[n=c/5+3]&b[n+c%5]&b[n-c%5]end
u
end

如果输入有两个玩家都获胜，例如，

     X | O | X
    ---+---+---
     X | O | O
    ---+---+---
     X | O | X

则输出为 3。

Answer 12

Haskell，假设上面的幻方。 77 字符

77 排除导入和定义 b．

import Data.Bits
import Data.Array

b = listArray (0,8) [2,1,0,1,1,1,2,2,0]
w b = maximum[b!x.&.b!y.&.b!z|x<-[0..8],y<-[x+1..8],z<-[12-x-y],z<8,z>=0,z/=y]

或者 82 假设正常排序：

{-# LANGUAGE NoMonomorphismRestriction #-}
import Data.Bits
import Data.Array

b = listArray (0,8) [1,2,1,0,1,2,1,0,2]
w b = maximum[b!x.&.b!y.&.b!z|x<-[0..8],d<-[1..4],y<-[x+d],z<-[y+d],d/=2||x==2,z<9]

Answer 13

C，99 个字符

不是赢家，但也许还有改进的空间。以前从未这样做过。原始概念，初稿。

#define l w|=*b&b[s]&b[2*s];b+=3/s;s
f(int*b){int s=4,w=0;l=3;l;l;l=2;--b;l=1;b-=3;l;l;return l;}

感谢 KennyTM 提供的一些想法和测试工具。

“开发版本”：

#define l w|=*b&b[s]&b[2*s];b+=3/s;s // check one possible win
f( int *b ) {
        int s=4,w=0; // s = stride, w = winner
        l=3;     // check stride 4 and set to 3
        l;l;l=2; // check stride 3, set to 2
        --b;l=1; // check stride 2, set to 1
        b-=3;l;l; return l; // check stride 1
}

Answer 14

(Iron)python，75 个字符

75 个字符代表一个完整的函数

T=lambda a:max(a[b/6]&a[b/6+b%6]&a[b/6+b%6*2]for b in[1,3,4,9,14,15,19,37])

66 个字符，如果你像其他人一样省略函数定义

r=max(a[b/6]&a[b/6+b%6]&a[b/6+b%6*2]for b in[1,3,4,9,14,15,19,37])

8 个不同的方向由起始值 + 增量器表示，压缩为可以使用除法提取的单个数字和模块。例如 2,5,8 = 2*6 + 3 = 15。

使用 & 检查一行是否包含三个相等的值。操作员。 （如果它们不相等，则结果为零）。 max 用于寻找可能的获胜者。

Answer 15

C 语言解决方案（162 个字符）：

这利用了玩家一值 (1) 和玩家二值 (2) 具有独立位集的事实。因此，您可以将三个测试框的值按位与在一起 - 如果该值非零，则所有三个值必须相同。另外，结果值==获胜的玩家。

到目前为止，这不是最短的解决方案，而是我能做的最好的解决方案：

void fn(){
    int L[]={1,0,1,3,1,6,3,0,3,1,3,2,4,0,2,2,0};
    int s,t,p,j,i=0;
    while (s=L[i++]){
        p=L[i++],t=3;
        for(j=0;j<3;p+=s,j++)t&=b[p];
        if(t)putc(t+'0',stdout);}
}

更具可读性的版本：

void fn2(void)
{
    // Lines[] defines the 8 lines that must be tested
    //  The first value is the "Skip Count" for forming the line
    //  The second value is the starting position for the line
    int Lines[] = { 1,0, 1,3, 1,6, 3,0, 3,1, 3,2, 4,0, 2,2, 0 };

    int Skip, Test, Pos, j, i = 0;
    while (Skip = Lines[i++])
    {
        Pos = Lines[i++];   // get starting position
        Test = 3;           // pre-set to 0x03 (player 1 & 2 values bitwise OR'd together)

        // search each of the three boxes in this line
        for (j = 0; j < 3; Pos+= Skip, j++)
        {
            // Bitwise AND the square with the previous value
            //  We make use of the fact that player 1 is 0x01 and 2 is 0x02
            //  Therefore, if any bits are set in the result, it must be all 1's or all 2's
            Test &= b[Pos];
        }

        // All three squares same (and non-zero)?
        if (Test)
            putc(Test+'0',stdout);
    }
}

Answer 16

Python，102 个字符

由于您没有真正指定如何获取输入和输出，因此这是可能必须包装到函数中的“原始”版本。 b 是输入列表； r 是输出（0、1 或 2）。

r=0
for a,c in zip("03601202","11133342"):s=set(b[int(a):9:int(c)][:3]);q=s.pop();r=r if s or r else q

Answer 17

Lua，130 个字符

130 个字符只是函数大小。如果没有找到匹配，该函数不返回任何内容，这在 Lua 中类似于返回 false。

function f(t)z={7,1,4,1,1,3,2,3,3}for b=1,#z-1 do
i=z[b]x=t[i]n=z[b+1]if 0<x and x==t[i+n]and x==t[i+n+n]then
return x end end end

assert(f{1,2,1,0,1,2,1,0,2}==1)
assert(f{1,2,1,0,0,2,1,0,2}==nil)
assert(f{1,1,2,0,1,2,1,0,2}==2)
assert(f{2,1,2,1,2,1,2,1,2}==2)
assert(f{2,1,2,1,0,2,2,2,1}==nil)
assert(f{1,2,0,1,2,0,1,2,0}~=nil)
assert(f{0,2,0,0,2,0,0,2,0}==2)
assert(f{0,2,2,0,0,0,0,2,0}==nil)

assert(f{0,0,0,0,0,0,0,0,0}==nil)
assert(f{1,1,1,0,0,0,0,0,0}==1)
assert(f{0,0,0,1,1,1,0,0,0}==1)
assert(f{0,0,0,0,0,0,1,1,1}==1)
assert(f{1,0,0,1,0,0,1,0,0}==1)
assert(f{0,1,0,0,1,0,0,1,0}==1)
assert(f{0,0,1,0,0,1,0,0,1}==1)
assert(f{1,0,0,0,1,0,0,0,1}==1)
assert(f{0,0,1,0,1,0,1,0,0}==1)

Answer 18

Visual Basic 275 254（宽松打字）字符

 Function W(ByVal b())

    Dim r

    For p = 1 To 2

            If b(0) = b(1) = b(2) = p Then r = p
            If b(3) = b(4) = b(5) = p Then r = p
            If b(6) = b(7) = b(8) = p Then r = p
            If b(0) = b(3) = b(6) = p Then r = p
            If b(1) = b(4) = b(7) = p Then r = p
            If b(2) = b(5) = b(8) = p Then r = p
            If b(0) = b(4) = b(8) = p Then r = p
            If b(6) = b(4) = b(2) = p Then r = p

    Next

    Return r

End Function

Answer 19

JavaScript - 下面的函数“w”是 114 个字符

<html>   
<body>
<script type="text/javascript">

var t = [0,0,2,0,2,0,2,0,0];

function w(b){
    i = '012345678036147258048642';
    for (l=0;l<=21;l+=3){
        v = b[i[l]];
        if (v == b[i[l+1]]) if (v == b[i[l+2]]) return v;   
    }
}

alert(w(t));

</script>
</body>
</html>

Answer 20

J，97 个字符。

1+1 i.~,+./"2>>(0 4 8,2 4 6,(],|:)3 3$i.9)&(e.~)&.>&.>(]<@:#"1~[:#:[:i.2^#)&.>(I.@(1&=);I.@(2&=))

我本来打算发布其工作原理的解释，但那是昨天的事，现在我无法阅读这段代码。

我们的想法是，我们创建一个包含所有可能获胜三元组的列表 (048,246,012,345,678,036,147,258)，然后计算每个玩家拥有的方格的幂集，然后将两个列表相交。如果有比赛，那就是胜利者。

Answer 21

Python - 75 个字符 (64)

我想出了 2 个表达式，每个 64 个字符：

max(a[c/8]&a[c/8+c%8]&a[c/8-c%8]for c in map(ord,'\t\33$#"!+9'))

当

max(a[c/5]&a[c/5+c%5]&a[c/5+c%5*2]for c in[1,3,4,8,12,13,16,31])

你添加“W=lambda b:”使其成为一个函数时，就会产生 75 个字符。
迄今为止最短的Python？

Answer 22

Python，285 字节

b,p,q,r=["."]*9,"1","2",range
while"."in b:
 w=[b[i*3:i*3+3]for i in r(3)]+[b[i::3]for i in r(3)]+[b[::4],b[2:8:2]]
 for i in w[:3]:print i
 if["o"]*3 in w or["x"]*3 in w:exit(q)
 while 1:
  m=map(lambda x:x%3-x+x%3+7,r(9)).index(input())
  if"."==b[m]:b[m]=".xo"[int(p)];p,q=q,p;break

...哦，这不是你说的“Code Golf: Tic Tac Toe”的意思？ ;)（输入小键盘数字来放置 x 或 o，即 7 是西北）

长版本

board = ["."]*9   # the board
currentname = "1" # the current player
othername = "2"   # the other player

numpad_dict = {7:0, 8:1, 9:2, # the lambda function really does this!
               4:3, 5:4, 6:5,
               1:6, 2:7, 3:8}

while "." in board:
    # Create an array of possible wins: horizontal, vertical, diagonal
    wins = [board[i*3:i*3+3] for i in range(3)] + \ # horizontal
           [board[i::3]      for i in range(3)] + \ # vertical
           [board[::4], board[2:8:2]]               # diagonal

    for i in wins[:3]: # wins contains the horizontals first,
        print i        # so we use it to print the current board

    if ["o"]*3 in wins or ["x"]*3 in wins: # somebody won!
        exit(othername)                    # print the name of the winner
                                           # (we changed player), and exit
    while True: # wait for the player to make a valid move
        position = numpad_dict[input()] 
        if board[position] == ".": # still empty -> change board
            if currentname == "1":
                board[position] = "x"
            else:
                board[position] = "o"
            currentname, othername = othername, currentname # swap values

Answer 23

我确信有一种更短的方法可以做到这一点，但是...... Perl，141 个字符（函数内有 134 个字符）

sub t{$r=0;@b=@_;@w=map{[split//]}split/,/,"012,345,678,036,147,258,048,246";for(@w){@z=map{$b[$_]}@$_;$r=$z[0]if!grep{!$_||$_!=$z[0]}@z;}$r;}

Answer 24

c -- 144 个字符

缩小：

#define A(x) a[b[x%16]]
int c,b[]={4,8,0,1,2,4,6,0,3,4,5,2,8,6,7,2};int
T(int*a){for(c=0;c<16;c+=2)if(A(c)&A(c+1)&A(c+2))return A(c);return 0;}

两者都返回计数（一个是必需的，另一个需要用空格替换）。

从偶数位置开始并取模 16 的八种获胜方式的数组代码。

从 埃里克·皮。

---

更易读的形式：

#define A(x) a[b[x%16]]

// Compact coding of the ways to win.
//
// Each possible was starts a position N*2 and runs through N*2+2 all
// taken mod 16
int c,b[]={4,8,0,1,2,4,6,0,3,4,5,2,8,6,7,2};

int T(int*a){
  // Loop over the ways to win
  for(c=0;c<16;c+=2)
    // Test for a win
    if(A(c)&A(c+1)&A(c+2))return A(c);
  return 0;
}

测试脚手架：

#include <stdlib.h>
#include <stdio.h>

int T(int*);

int main(int argc, char**argv){
  int input[9]={0};
  int i, j;
  for (i=1; i<argc; ++i){
    input[i-1] = atoi(argv[i]);
  };
  for (i=0;i<3;++i){
    printf("%1i  %1i  %1i\n",input[3*i+0],input[3*i+1],input[3*i+2]);
  };
  if (i = T(input)){
    printf("%c wins!\n",(i==1)?'X':'O');
  } else {
    printf("No winner.\n");
  }
  return 0;
}

Answer 25

也许可以做得更好，但我现在感觉不是特别聪明。这只是为了确保 Haskell 得到代表......

假设 b 已经存在，这会将结果放入 w 中。

import List
a l=2*minimum l-maximum l
z=take 3$unfoldr(Just .splitAt 3)b
w=maximum$0:map a(z++transpose z++[map(b!!)[0,4,8],map(b!!)[2,4,6]])

假设输入来自 stdin 并输出到 stdout，

import List
a l=2*minimum l-maximum l
w b=maximum$0:map a(z++transpose z++[map(b!!)[0,4,8],map(b!!)[2,4,6]])where
 z=take 3$unfoldr(Just .splitAt 3)b
main=interact$show.w.read

Answer 26

C#，180 个字符：

var s=new[]{0,0,0,1,2,2,3,6};
var t=new[]{1,3,4,3,2,3,1,1};
return(s.Select((p,i)=>new[]{g[p],g[p+t[i]],g[p+2*t[i]]}).FirstOrDefault(l=>l.Distinct().Count()==1)??new[]{0}).First();

（g 是网格）

可能需要改进...我仍在努力；）

Answer 27

Python，140 个字符

我的第一个高尔夫代码，重达 140 个字符（导入声明，我否认你！）：

import operator as o

def c(t):return({1:1,8:2}.get(reduce(o.mul,t[:3]),0))
def g(t):return max([c(t[x::y]) for x,y in zip((0,0,0,1,2,2,3,6),(1,3,4,3,3,2,1,1))])

稍微不那么晦涩 g：

def g(t):return max([c(t[x::y]) for x,y in [[0,1],[0,3],[0,4],[1,3],[2,3],[2,2],[3,1],[6,1]]])

Answer 28

C# 解决方案。

将每行、列和列中的值相乘对角线。如果结果 == 1，则 X 获胜。如果结果 == 8，O 获胜。

int v(int[] b)
{
    var i = new[] { new[]{0,1,2}, new[]{3,4,5}, new[]{6,7,8}, new[]{0,3,6}, new[]{1,4,7}, new[]{2,5,8}, new[]{0,4,8}, new[]{2,4,6} };
    foreach(var a in i)
    {
        var n = b[a[0]] * b[a[1]] * b[a[2]];
        if(n==1) return 1;
        if(n==8) return 2;
    }
    return 0;
}

Answer 29

C#，154 163 170 177 个字符

借鉴其他提交的一些技术。
（不知道 C# 可以让你这样初始化数组）

static int V(int[] b)
{
   int[] a={0,1,3,1,6,1,0,3,1,3,2,3,0,4,2,2};
   int r=0,i=-2;
   while((i+=2)<16&&(r|=b[a[i]]&b[a[i]+a[i+1]]&b[a[i]+a[i+1]*2])==0){}
   return r;
}

Answer 30

C、113个字符

f(int*b){char*s="012345678036147258048264\0";int r=0;while(!r&&*s){int q=r=3;while(q--)r&=b[*s++-'0'];}return r;}

我觉得可行吗？我的第一个代码高尔夫，温柔点。

每 3 位数字编码 3 个需要匹配的单元格。内部 while 检查黑社会。外部 while 检查所有 8 个。