确定胜出力


19

让我们打一些代码高尔夫!

给定井字游戏板状态(示例:)

|x|x|o|
|x|o|x|
|o|o|x|

确定游戏是wina lose还是cat。给定状态,您的代码应输出所有这些选项。上面的游戏应该输出lose

需要明确指出的是:获胜定义为x连续3 秒(对角线,水平线,垂直线)。失败是o连续3 秒,而cat游戏却是连续3 秒。

为了使事情变得有趣,您需要确定状态的输入结构,然后必须对其进行解释。例如,xxoxoxoox如上所示是一个有效状态,其中从左到右,从上到下读取每个字符。[['x','x','o'],['x','o','x'],['o','o','x']]是以类似方式读取多维数组中的游戏。虽然0x1a9这是十六进制为110101001可能的工作作为一个适当的压缩,其中1可以针对被操纵xS和0可以被操纵o

但这只是一些想法,我相信您可能会有很多想法。

基本原则:

  1. 您的程序必须能够接受任何可行的状态。
  2. 输入形式必须能够表示任何状态。
  3. “获胜状态必须从董事会中确定”
  4. 假设一个完整的董事会
  5. Win之前,lose例如在的情况下“xxxoooxxx”

最低字符数获胜


1
我喜欢这种输入结构:(win|lose|cat) [xo]{9},其中第一个单词表示玩家x的游戏是胜利,失败还是猫(?)。能够代表任何状态。
Runer112

2
我是否可以建议诸如“必须从棋盘上确定获胜状态”或“输入内容必须包含棋盘状态之类的信息”之类的规则?
地下

3
我们是否仅假设玩合法游戏?如果是这样,则某些状态将是不可能的,即XXX OOO XXX,但其他一些全盘状态将其作为第四个不可能的结果,其中X获胜而O也获胜。
暴乱

10
为什么“猫”失去兴趣?
克里斯

7
@DylanMadisetti:之前从未听过,googlign提出“输掉猫”的想法一无所获。我本来可以打领带,也可以亲自画画。或者在这种游戏的情况下可能是“必然性”。;-)不过我对比赛并不介意。字符串是字符串。;-)
克里斯

Answers:


11

Ruby 2.0,85个字符

这是Ruby中基于位掩码的简单解决方案:

d=gets.hex
$><<[292,146,73,448,56,7,273,84].map{|m|d&m<1?:lose:d&m<m ?:cat: :win}.max

木板用十六进制数表示,由对应于九个正方形的九位组成。1是X,0是O。就像问题中的0x1a9示例一样,尽管0x是可选的!

比起硬编码一个大列表,可能有更好的方法来做位掩码。我会很乐意接受建议。

在这里看到它在Ideone上运行。


1
您的列表包含273两次。我真的很喜欢这个max主意!
Ventero 2014年

1
哦,@ Ventero,总是带有晦涩的优化(谢谢)
Paul Prestidge 2014年

板上可能有空白空间。您的输入格式不能解决这个问题,因此不能代表任何可行的游戏状态。
Stephen Ostermiller 2014年

2
@StephenOstermiller规则4:假设一个完整的董事会。您是正确的,该规则可能与规则1和2相抵触,但是,如果您阅读有关该问题的所有评论,我认为这是本问题的精神(不包括不完整的委员会,而完整的委员会则属于非法委员会。)但是我认为八进制比十六进制将是一种更加用户友好的输入格式。
级圣河

1
知道了,我认为完成意味着不同。
斯蒂芬·奥斯特米勒

10

Mathematica,84个字符

a=Input[];Which[Max@#>2,win,Min@#<1,lose,1>0,cat]&@{Tr@a,Tr@Reverse@a,Tr/@a,Total@a}

输入格式: {{1, 1, 0}, {1, 0, 1}, {0, 0, 1}}


这里发生了什么事?
seequ 2014年

3
@TheRare从右边开始。Tr@a是场(超过对角线之和)的痕迹,Tr@Reverse@a是翻转场的痕迹(一些过度的反对角线),Tr/@aTr应用到每一行,它给你的总和在每一行,Total@a给你的总和超过每列。基本上,您已经检查了所有8行。然后将Which事物应用于该事物(基本上是一条if/elseif/else语句),其中#代表了8个值的列表。if有一个3你赢了,else if有一个0你输了,else if 1>0(true)cat
Martin Ender 2014年

6

击:283 262 258

具有相对友好的界面。

t(){ sed 's/X/true/g;s/O/false/g'<<<$@;}
y(){ t $(sed 's/X/Q/g;s/O/X/g;s/Q/O/g'<<<$@);}
f(){($1&&$2&&$3)||($1&&$5&&$9)||($1&&$4&&$7)||($2&&$5&&$8)||($3&&$5&&$7)||($3&&$6&&$9)||($4&&$5&&$6)||($7&&$8&&$9)}
f $(t $@)&&echo win||(f $(y $@)&&echo lose)||echo cat

执行 bash tictactoe.sh O X O X O X X O X

注意:9个位置的列表是标准矩阵表示形式。董事会代表列专业还是行专业,从左到右或从上到下阅读都没关系-零食和交叉游戏(如果要坚持,则是井字游戏)是对称的,因此输入顺序应该无关紧要只要输入是线性的,就可以正确执行每个结果。

编辑:感谢hjk为较短的函数语法建议。


考虑t() { ... }代替function t?可以在其中保存一些字符。:)
hjk 2014年

我完全忘记了替代函数语法-谢谢!
暴乱

不需要空格<<<来保存另外四个字符。
Michael Mior

4

Befunge 93-375

将二进制字符串作为输入。

99>~\1-:!!|>v  
>0v>v>v   >^$>v
^+ + +    0<:p:
>#+#+#+    ^246
^+ + +    0<265
>#+#+#+    ^pp6
^+ + +    0<2++
 #+#+#+     55p
   0 0      552
  >^>^>0v   +46
v+ + +  <   ppp
>0 + + + v  444
   v!!-3:<< 246
  v_"ni"v   ppp
  0v" w"<   :+:
  \>,,,,@   266
  ->,,,@    555
  !^"cat"_^ 645
  !>:9-! ^  +:+
  >|        p:p
   >"eso"v  6p6
 @,,,,"l"<  246
            p2p
            >^ 
  v       <^  <

读取字符串。Bruteforce将其(最右边的垂直条)作为矩阵写入

^+ + + 
>#+#+#+
^+ + + 
>#+#+#+
^+ + + 
 #+#+#+

添加晶格(idk)。确定列,行和两个诊断值的总和。将这些值与3(“胜利”)或0(“损失”)进行比较,否则,如果所有值等于1或2,则进行绘制(“ cat”)。


4

GolfScript,27个字符

70&.{~"win""lose"if}"cat"if

输入格式是一个由八个八进制数字组成的字符串,每个(冗余)编码三个连续的木板正方形:

  • 前三个数字分别从上到下,从左到右编码一块木板。
  • 以下三位数字分别从左至右,自上而下编码电路板的一列。
  • 最后两位数字分别编码一个对角线(首先从左上角到右下角,然后从左下角到右上角)。

要将三个正方形的序列(行/列/对角线)编码为八进制数字,请将x序列中的每个替换为1,并将每个o为0,然后将所得的1和0序列解释为0到7之间的二进制数包括的。

此输入格式非常冗余(所有板位置至少编码两次,中心位置编码四次),但是它确实表示完全填充井字游戏板的任何可能状态,并且不直接编码赢家投入。

输入可以选择在数字之间包含空格或其他定界符。实际上,程序真正关心的就是输入字符串是否包含数字70

例如,示例板:

|x|x|o|
|x|o|x|
|o|o|x|

可以由输入表示:

651 643 50

为了方便起见,这是一个GolfScript程序,用于将ASCII艺术画板布局转换为适合该程序的输入字符串,如上面的挑战所示:

."XOxo"--[{1&!}/]:a[3/.zip"048642"{15&a=}%3/]{{2base""+}%}%" "*

在任何一种情况下,此转换器在输入中都忽略x和以外的任何字符o。它会产生一个单个数字的字符串(如上所示,带有空格分隔符),该字符串适合馈入上述获胜确定程序,因此,这两个程序的串联可用于直接从ASCII艺术委员会确定获胜者。

另外,这是一个反向转换器,只是为了证明输入确实确实代表了电路板:

.56,48>-- 3<{2base-3>{"ox"=}%n}%"|".@@*+);

附言 这是此解决方案的在线演示。


2
输入格式似乎有点作弊,因为在生成输入时需要进行很多工作。
Arkku 2014年

@Arkku:是的,是的,但是问题明确地表明:“您可以确定状态的输入结构-然后必须进行解释。” 它甚至显示了以位压缩的十六进制字符串作为有效输入格式的示例。那和我的输入格式之间的唯一区别是我重新排序并复制了一些位。
Ilmari Karonen 2014年

6
完全是重复,似乎是作弊。(例如,它会将输入的获胜者直接编码为7或0)
Arkku 2014年

仍然这是一个聪明的编码,它是多余的,但是使寻找解决方案比任何非冗余编码都更加有效!
ARRG 2014年

3

Python 2-214字节

b=eval(raw_input())
s=map(sum,b)
w,l='win','lose'
e="if min(s)<1:print l;a\nif max(s)>2:print w;a"
exec e+'\ns=map(sum,zip(*b))\n'+e
m=b[1][1]
for i in 0,2:
 if m==b[0][i]==b[2][abs(i-2)]:print[l,w][m];a
print'cat'

我确定有待改进。

跑步:

python2 tictactoe.py <<< '[[1,1,1],[1,0,1],[0,1,0]]'

代表此板:

X|X|X
-----
X|O|X
-----
0|X|0

NameError除以外的所有情况均异常退出cat


哇,我从来不知道<<<!为此+1。
Greg Hewgill 2014年

@GregHewgill非常方便。./whatever <<< 'blah blah blah'与相同echo -n 'blah blah blah' | ./whatever但没有一个完整的分离过程echo
Undergroundmonorail

@undergroundmonorail echoin bash实际上是内置的,因此不会分叉新过程
Bob

@GregHewgill,它被称为herestring

3

Haskell,146个字符

为了使事情变得有趣,您需要确定状态的输入结构,然后必须对其进行解释。

好 :)。我代表董事会是这126个字符中的一个

ĻŃŇʼnŊœŗřŚşšŢťŦŨųŷŹźſƁƂƅƆƈƏƑƒƕƖƘƝƞƠƤƳƷƹƺƿǁǂDždžLjǏǑǒǕǖǘǝǞǠǤǯDZDzǵǶǸǽǾȀȄȍȎȐȔȜȳȷȹȺȿɁɂɅɆɈɏɑɒɕɖɘɝɞɠɤɯɱɲɵɶɸɽɾʀʄʍʎʐʔʜʯʱʲʵʶʸʽʾˀ˄ˍˎː˔〜˭ˮ˰˴˼̌

这是146个字符的解决方案:

main=interact$(\x->case(head x)of h|elem h "ĻŃœťŦŨųŷŹƁƂƅƈƕƠƤƳƿǂdžǞǤǵǾȀȳȿɁɅɑɒɘɝɠɤɵɽʀʐʽʾː˭ˮ˰˴˼̌"->"lose";h|elem h "ƏƝƞƹǁLjǑǝȍȺɆɈɶɾʎʸ"->"cat";h->"win")

这是它的工作方式,作为haskell脚本:

import Data.List (subsequences, (\\))
import Data.Char (chr)

-- A set of indexes [0-8] describing where on the board pieces of a single color have been played
-- For example the board "OxO;Oxx;xxO" is indexes [0,2,3,8]
type Play = [Int]

-- There are 126 filled tic tac toe boards when X plays first.
--      (This is a combination of 4 OHs among 9 places : binomial(9 4) = 126)
-- perms returns a list of all such possible boards (represented by the index of their OHs).
perms = filter (\x -> 4 == length x) $ subsequences [0..8]

-- We now create an encoding for plays that brings them down to a single char.
-- The index list can be seen as an 9 bit binary word [0,2,3,8] -> '100001101'
-- This, in turn is the integer 269. The possible boards give integers between 15 and 480.
-- Let's call those PlayInts
type PlayInt = Int

permToInt [] = 0
permToInt (x:xs) = (2 ^ x) + permToInt xs 

-- Since the characters in the range 15-480 are not all printable. We offset the chars by 300, this gives the range 
-- ĻŃŇʼnŊœŗřŚşšŢťŦŨųŷŹźſƁƂƅƆƈƏƑƒƕƖƘƝƞƠƤƳƷƹƺƿǁǂDždžLjǏǑǒǕǖǘǝǞǠǤǯDZDzǵǶǸǽǾȀȄȍȎȐȔȜȳȷȹȺȿɁɂɅɆɈɏɑɒɕɖɘɝɞɠɤɯɱɲɵɶɸɽɾʀʄʍʎʐʔʜʯʱʲʵʶʸʽʾˀ˄ˍˎː˔˜˭ˮ˰˴˼̌
-- Of all distinct, printable characters
uOffset = 300

-- Transform a PlayInt to its Char representation
pIntToUnicode i = chr $ i + uOffset

-- Helper function to convert a board in a more user friendly representation to its Char
-- This accepts a representation in the form "xooxxxoxo"
convertBoard s = let play = map snd $ filter (\(c, i) -> c == 'o') $ (zip s [0..]) :: Play 
    in pIntToUnicode $ permToInt play

--
-- Now let's cook some data for our final result
--  

-- All boards as chars
allUnicode = let allInts = map permToInt perms 
    in map pIntToUnicode allInts

-- Now let's determine which boards give which outcome.

-- These are all lines, columns, and diags that give a win when filled
wins = [
        [0,1,2],[3,4,5],[6,7,8], -- lines
        [0,3,6],[1,4,7],[2,5,8], -- columns
        [0,4,8],[2,4,6] -- diagonals
    ]

isWin :: Play -> Bool   
isWin ps = let triplets = filter (\x -> 3 == length x) $ subsequences ps -- extract all triplets in the 4 or 5 moves played
    in any (\t -> t `elem` wins) triplets -- And check if any is a win line

-- These are OH wins
oWins = filter isWin perms
-- EX wins when the complement board wins
xWins = filter (isWin . complement) perms
    where complement ps = [0..9] \\ ps
-- And it's stalemate otherwise
cWins = (perms \\ oWins) \\ xWins

-- Write the cooked data to files
cookData = let toString = map (pIntToUnicode . permToInt) in do
  writeFile "all.txt" allUnicode
  writeFile "cWins.txt" $ toString cWins
  writeFile "oWins.txt" $ toString oWins
  writeFile "xWins.txt" $ toString xWins

-- Now we know that there are 48 OH-wins, 16 stalemates, and 62 EX wins (they have more because they play 5 times instead of 4).
-- Finding the solution is just checking to which set an input board belongs to (ungolfed :)
main = interact $ \x -> case (head x) of -- Only consider the first input char
    h | elem h "ĻŃœťŦŨųŷŹƁƂƅƈƕƠƤƳƿǂdžǞǤǵǾȀȳȿɁɅɑɒɘɝɠɤɵɽʀʐʽʾː˭ˮ˰˴˼̌" -> "lose" -- This string is == oWins
    h | elem h "ƏƝƞƹǁLjǑǝȍȺɆɈɶɾʎʸ" -> "cat" -- And this one == cWins
    h -> "win"

3

JavaScript,420个字符

if((s&0x3F000)==0x3F000||(s&0x00FC0)==0x00FC0||(s&0x0003F)==0x0003F||(s&0x030C3)==0x030C3||(s&0x0C30C)==0x0C30C||(s&0x30C30)==0x30C30||(s&0x03330)==0x03330||(s&0x30303)==0x30303)return 'win'
if((s&0x3F000)==0x2A000||(s&0x00FC0)==0x00A80||(s&0x0003F)==0x0002A||(s&0x030C3)==0x02082||(s&0x0C30C)==0x08208||(s&0x30C30)==0x20820||(s&0x03330)==0x02220||(s&0x30303)==0x20202)return 'lose'
if((s&0x2AAAA)==0x2AAAA)return 'cat'

在此版本中,s包含一个表示游戏板状态的整数。它是一个值的位数组,其中两位代表板上的每个正方形:

  • 10 - X
  • 11 -O
  • 00 -空的正方形

该解决方案使用位操作来测试八个可能的“连续三个”配置中的每个配置(它分别对它们进行两次测试,一次用于X,一次用于O)。

我从我的Tic-Tac-Toe网站上以较小的尺寸展示了该detectWin功能,该功能已在真正的Tic-Tac-Toe游戏中使用。


6
好吧,这可以称为蛮力逼迫。
seequ 2014年

2

Ruby,84个字符

$><<(gets.tr("01","10")[r=/0..(0|.0.)..0|000(...)*$|^..0.0.0/]?:win:~r ?:lose: :cat)

基于RegExp的简单解决方案。输入格式为9位二进制字符串,例如110101001问题中给出的示例板。

Ruby,78个字符

$><<(gets.tr("ox","xo")[r=/o...(o|.o.)...o|ooo|o_.o._o/]?:win:~r ?:lose: :cat)

输入格式: xxo_xox_oox


1

哈斯克尔(169)

main=interact$(\x->last$"cat":[b|(a,b)<-[("ooo","lose"),("xxx","win")],any(==a)x]).(\x->x++(foldr(zipWith(:))(repeat[])x)++map(zipWith(!!)x)[[0..],[2,1,0]]).take 3.lines

输入格式:“ X”仅由表示x,“ O”仅由表示o。在每一行中,字符是同时出现的,没有空格等。行之间用换行符分隔。

生成所有可能的行/列/对角线,然后[("ooo","lose"),("xxx","win")]按其在板上的存在进行过滤,然后选择元组中的第二个单词,这样我们就知道哪个玩家赢了。我们以开头为准,"cat"以便我们可以将列表的最后一个元素作为赢家。如果两个玩家都赢了,"win"将是最后一个(列表理解保持顺序)。由于"cat"始终是第一位,如果存在获胜者,则将选择该获胜者,否则最后一个元素仍然存在,因为前置"cat"保证非空性。

编辑:通过将最后一个列表理解更改为,剃了3个字符map


1

约C,150

现在是午夜,我没有做任何测试,但是我还是会发布这个概念。我明天再说。

用户输入两个八进制数(我想使用二进制,但据我所知C仅支持八进制):

a 代表中心正方形,X代表1,O代表0

b 是一个代表外围正方形的九位数,从一个角开始一直到同一角(仅重复该角)在木板上盘旋,1代表X,0代表O。

有两种可能的取胜方法:

  1. 中心正方形是X(a = 1),两个相反的正方形也是X(b&b*4096非零)

  2. 三个相邻的周长正方形为X(b/8 & b & b*8非零)。如果中间正方形是边角正方形,而不是边角正方形,则这仅是有效的获胜,因此有必要应用蒙版m,以避免出现角正方形的情况。

使用变量c(它是b的倒数)检测到丢失。

int a,b,c,m=010101010;
main(){
    scanf("%o%o",a,b);c=b^0111111111;
    printf("%s",(a&&b&b*4096)|(b/8&b&b*8&m)?"win":((!a&&c&c*4096)|(c/8&c&c*8)?"lose":"cat"));
}

您忘记m在“丢失”检测中应用该蒙版- c/8&c&c*8。我已重新查询您的代码(未测试其操作),如下所示:int a,b;t(v){return a&&v&v<<12||v/8&v&v*8&0x208208;}main(){scanf("%o%o",a,b);printf("%s",t(b)?"win":t(b^0x1249249)?"lose":"cat");}(130个字符)。重复测试的时间足够长,足以提取到测试函数中t(); 这消除了对c和的需要m;将常量转换为十六进制以每个节省一个字符。
Toby Speight 2015年

刚刚发现,printf不需要格式字符串-只需提供结果字符串作为格式-否则puts,因为问题不要求在输出后输入换行符!(另节省7个字符)。
Toby Speight 2015年

1

重击 107 103

生成并运行sed脚本。

I / O格式:oxo-oox-xoo输出lose(使用a -分隔行)。在标准输入上输入。该c命令需要GNU sed 。

我已经将规则5解释为“如果可能同时有输赢,则选择获胜”。

主要代号

这是实际答案。

真的没什么有趣的。它定义$b/cwin保存字符,然后定义脚本的获胜条件部分,然后使用sed y/x/o/\;s$b/close/转换xocwinclose(从而生成失落条件)。然后ccat,它将这两件事发送cat给sed (如果不匹配获胜/失败条件,则将输出)。

b=/cwin
v="/xxx$b
/x...x...x$b
/x..-.x.-..x$b
/x-.x.-x$b"
sed "$v
`sed y/x/o/\;s$b/close/<<<"$v"`
ccat"

生成的代码

这是由Bash脚本生成并运行的sed脚本。

在正则表达式中,.匹配任何字符,并在它们之后cTEXT输出TEXT并在匹配正则表达式时退出。

这可以作为独立的sed脚本运行。它的长度为125个字符,您可以将其视为另一个解决方案。

/xxx/cwin
/x...x...x/cwin
/x..-.x.-..x/cwin
/x-.x.-x/cwin
/ooo/close
/o...o...o/close
/o..-.o.-..o/close
/o-.o.-o/close
ccat

1

Python 3、45

输入在 i,这是代表游戏板的每一行,每一列和对角线的数字的列表,例如:

X X O
O X O
O O X

由表示[6, 2, 1, 4, 6, 1, 7, 4]

代码('cat','lose','win')[2 if 7 in i else 0 in i]


1

飞镖-119

(请参见dartlang.org)。

使用RegExp的原始版本:151个字符。

main(b,{w:"cat",i,p,z}){
 for(p in["olose","xwin"])
   for(i in[0,2,3,4])
     if(b[0].contains(new RegExp('${z=p[0]}(${'.'*i}$z){2}')))
       w=p.substring(1);
  print(w);
}

在命令行上输入的是11个字符,例如“ xxx | ooo | xxx”。任何非xo字符都可以用作分隔符。

在对字符进行计数之前,应省略前导空格和换行符,但在可能的情况下,我会切掉内部空格。我希望有一个较小的方法来创建子字符串。

可恢复的基于位的版本:119个字符。输入必须是一个9位数字,其中1代表“ x”,0代表“ o”。

main(n){
  n=int.parse(n[0]);
  z(b,r)=>b>0?b&n==b&511?"win":z(b>>9,n&b==0?"lose":r):r;
  print(z(0x9224893c01c01e2254,"cat"));
}

1

果酱 39 38 36个字符

"ᔔꉚ굌궽渒䗠脯뗠㰍㔚귇籾〳㎪䬔⹴쪳儏⃒ꈯ琉"2G#b129b:c~

这是用于的基本转换代码

q3/_z__Wf%s4%\s4%]`:Q3'o*#"win"{Q'x3*#"lose""cat"?}?

长度为52个字符。

输入只是从左上方开始,逐行进行的木板的字符串表示形式。例如:

oxooxooox

结果是win输出。要么

oxooxoxox

导致 cat输出等。

该代码仅执行以下三件事:

  • q3/_ -将字符串分成3个部分,即每行
  • _z -复制每个行数组并转置为每个列数组。
  • __Wf%s4%-反转每一行并获得从左到右的对角线。这是板的辅助对角线。
  • \s4% -获取板的主要对角线
  • ]` -将所有内容包装在数组中并进行数组化处理。

现在,董事会中所有可能的3人小组。我们只需检查是否存在“ ooo”和“ xxx”来确定结果。

在这里在线尝试


1

GNU sed,25个字节

如果输入是棋盘的冗余表示,并且在其他答案中也使用了分别用于列,行和对角线的视图,那么sed非常适合检查字节数最少的游戏的结束状态。

输入格式:( xxx ooo xxx xox xox xox xox xox从OP的问题中获取的棋盘状态)

/xxx/cwin
/ooo/close
ccat

如果输入格式为非冗余(xxx ooo xxx),则上面的sed代码仅在下一行作为前缀时才起作用,从而使程序长96个字节(r计算了所需的标志)。

s/(.)(.)(.) (.)(.)(.) (.)(.)(.)/& \1\4\7 \2\5\8 \3\6\9 \1\5\9 \3\5\7/

1

重击:208个字符

y(){ tr '01' '10'<<<$@;}
f(){ x=$[($1&$2&$3)|($1&$5&$9)|($1&$4&$7)|($2&$5&$8)|($3&$5&$7)|($3&$6&$9)|($4&$5&$6)|($7&$8&$9)]; }
f $@;w=$x
f $(y $@)
([ $x -eq 1 ]&&echo lose)||([ $w -eq 1 ]&&echo win)||echo cat

执行 bash tictactoe.sh 0 1 0 1 0 1 1 0 1

受到这个答案的启发。


0

VB.net

在示例中,provide编码为以下位模式

q  = &B_100101_100110_011010 ' 00 Empty, 01 = O, 10 = X

现在,我们可以通过以下操作确定结果(或获胜者)。

Dim g = {21, 1344, 86016, 66576, 16644, 4161, 65379, 4368}
Dim w = If(g.Any(Function(p)(q And p)=p),"Lose",If(g.Any(Function(p)(q And p*2)=p*2),"Win","Cat"))

0

J-97个字节

好吧,最简单的方法。输入为111222333,其中数字代表行。从左到右阅读。玩家是x敌人o。空方格可以是x或以外的任何值o

f=:(cat`lose>@{~'ooo'&c)`('win'"_)@.('xxx'&c=:+./@(r,(r|:),((r=:-:"1)(0 4 8&{,:2 4 6&{)@,))3 3&$)

示例:(注:是注释)

   f 'xoxxoxxox' NB. Victory from first and last column.
win
   f 'oxxxooxxx' NB. Victory from last row.
win
   f 'ooxxoxxxo' NB. The example case, lost to a diagonal.
lose
   f 'xxooxxxoo' NB. Nobody won.
cat
   f 'xoo xx ox' NB. Victory from diagonal.
win

非高尔夫代码说明

row   =: -:"1                        Checks if victory can be achieved from any row.
col   =: -:"1 |:                     Checks if victory can be achieved from any column.
diag  =: -:"1 (0 4 8&{ ,: 2 4 6&{)@, Checks if victory can be achieved from diagonals.
check =: +./@(row,col,diag) 3 3&$    Checks all of the above and OR's them.

f     =: (cat`lose >@{~ 'ooo'&check)`('win'"_)@.('xxx'&check)
Check if you have won ........................@.('xxx'&check)
 If yes, return 'win' .............. ('win'"_)
 If not                   (cat`lose >@{~ 'ooo'&check)
  Check if enemy won ................... 'ooo'&check
   If yes, return 'lose'   ---`lose >@{~
   If not, return 'cat'    cat`---- >@{~

0

Python 2,120字节

b=0b101001110
l=[448,56,7,292,146,73,273,84]
print(['Win'for w in l if w&b==w]+['Lose'for w in l if w&~b==w]+['Cat'])[0]

Python,来自Python shell(2或3)的115个字节

b=0b101001110;l=[448,56,7,292,146,73,273,84];(['Win'for w in l if w&b==w]+['Lose'for w in l if w&~b==w]+['Cat'])[0]

board变量设置为问题中描述的二进制格式:1对于X,0对于O,从左到右,从上到下。在这种情况下,101001110代表

XOX
OOX
XXO

导致输出: Cat


输入格式是什么?
seequ 2014年

0

Python(73 62个字符)

输入是代表同一块板的四个不同视图的四个小写字符串,所有字符串都串联成一个字符串:按行,按列,右对角,左对角。

更新

感谢theRare提供了一个很好的反例! 电路板上的每个视图以及电路板上的每个段(行或列)都必须用一个既不是“ x”也不是“ o”的字符分隔开,以便即使在连接后也可以保留该电路板的结构。板的每个视图周围的边框将是方括号(“ [”和“]”),行/列之间的分隔符将是管道字符“ |”。

这使算法变得很简单-分别寻找赢或输的“ xxx”或“ ooo”。否则就是领带(猫)。

例如板子(从左到右,从上到下阅读)...

X | X | X X | O | X O | X | O

...表示为“ [xxx | xox | oxo]”(按行)+“ [xxo | xox | xxo]”(按列)+“ [xoo]”(右诊断)+ [xoo]”(左diag)=“ [xxx | xox | oxo] [xxo | xox | xxo] [xoo] [xoo]”。

该Python语句在给定变量s的情况下打印游戏结果作为输入的情况下,以下:

print 'win' if 'xxx' in s else 'lose' if 'ooo' in s else 'cat'

这对董事会OXX XOO XOX有效吗(应该是猫)?
seequ 2014年

不,不,不是。接得好!我想我的解决方案太简单了...糟糕!
鲍勃,2014年

我不能说这种解决方案没有引起我的注意。:)
seequ 2014年

0

Haskell(69个字符)

i x=take 4$(x>>=(\y->case y of{'7'->"win";'0'->"lose";_->""}))++"cat"

这采用与以下描述相同的输入 此答案。更具体地说,输入为8个八进制值,描述每个行,列和对角线的二进制值。该代码使每个实例7“ win”,每个实例0“ lose”,并删除所有其他内容。然后将“ cat”添加到末尾,并从结果中获取前4个字符。

将有4种可能的答案:“ lose”,“ cat”,“ win”后跟“ l”,以及“ win”后跟“ c”,但规则不禁止:)

用法示例:

i "65153806" --outputs "lose"

0

J:83

(;:'lose cat win'){::~>:*(-&(+/@:(*./"1)@;@(;((<0 1)&|:&.>@(;|.)(,<)|:)))-.)3 3$'x'=

用法:只需附加一串x和o即可观看魔术作品。例如。'xxxoooxxx'。

内部动词(+/@:(*./"1)@;@(;((<0 1)&|:&.>@(;|.)(,<)|:)))基本上将原始二进制矩阵装箱在一起,将转置和2个对角线装箱在一起。这些结果被夷为平地; 行总和用于确定获胜,然后求和。再说这个动词Inner

为了找到赢家,钩子获取了正常二进制矩阵与反向二进制矩阵之间的分数差(-&Inner -.)

其余代码只是简单地输出,然后选择正确的输出。


0

JavaScript,133,114个字符

r = '/(1){3}|(1.{3}){2}1|(1.{4}){2}1|(1\|.1.\|1)/';alert(i.match(r)?'WIN':i.match(r.replace(/1/g,0))?'LOSS':'CAT')

输入i是带有行分隔符的简单字符串,即100|001|100

编辑:更新了我的方法,用零替换正则表达式中的1以检查丢失情况。


您可以删除=正则表达式文字周围的空格和引号。另外,1...比短一个字符1.{3}
nyuszika7h 2014年

1
r.test(i)也比短一个字符i.match(r)
nyuszika7h 2014年

0

J-56(26?)字符

为输入提供了9个字符的3x3矩阵,因为J可以将其作为数据类型LOL支持。

(win`lose`cat{::~xxx`ooo<./@i.<"1,<"1@|:,2 7{</.,</.@|.)

例子:

   NB. 4 equivalent ways to input the example board
   (3 3 $ 'xxoxoxoox') ; (_3 ]\ 'xxoxoxoox') ; ('xxo','xox',:'oox') ; (];._1 '|xxo|xox|oox')
+---+---+---+---+
|xxo|xxo|xxo|xxo|
|xox|xox|xox|xox|
|oox|oox|oox|oox|
+---+---+---+---+
   (win`lose`cat{::~xxx`ooo<./@i.<"1,<"1@|:,2 7{</.,</.@|.) 3 3 $ 'xxoxoxoox'
lose
   wlc =: (win`lose`cat{::~xxx`ooo<./@i.<"1,<"1@|:,2 7{</.,</.@|.)
   wlc (3 3 $ 'xoxoxooxo')
cat
   wlc (3 3 $ 'xxxoooxxx')
win

如果允许我们用八进制数字的Golfscriptish编码冗余地表示每一行,每一列和对角线的状态,那么它只有26个字符:

   win`lose`cat{::~7 0<./@i.] 6 5 1 6 4 3 5 0
lose
   f=:win`lose`cat{::~7 0<./@i.]
   f  7 0 7 5 5 5 5 5
win

0

T-SQL(2012),110

select max(iif(@&m=0,'lose',iif(@&m=m,'win','cat')))from(VALUES(292),(146),(73),(448),(56),(7),(273),(84))z(m)

输入的是十六进制数字。这几乎是将ruby解决方案转换为T-SQL的一种很好的方式。


0

Javascript 1.6,71个字符

我假设输入为一个数组game,其中包含每一行,每一列和每个diag作为3个字符的字符串。与bob的答案相似,但它以数组形式而不是串联字符串形式出现。

alert(game.indexOf("xxx")>=0?"win":game.indexOf("ooo")>=0?"lose":"cat")

编辑@ nyuszika7h的评论(67个字符)

alert(~game.indexOf("xxx")?"win":~game.indexOf("ooo")?"lose":"cat")

您可以使用~game.indexOf("xxx")代替game.indexOf("xxx")>=0,对另一个相同。
nyuszika7h 2014年

0

Java 7,260字节

String c(int[]s){int a[]=new int[8],x=0,y;for(;x<3;x++){for(y=0;y<3;a[x]+=s[x*3+y++]);for(y=0;y<3;a[x+3]+=s[y++%3]);}for(x=0;x<9;y=s[x],a[6]+=x%4<1?y:0;a[7]+=x%2<1&x>0&x++<8?y:0);x=0;for(int i:a)if(i>2)return"win";for(int i:a)if(i<1)return"loose";return"cat";}

非高尔夫球和测试用例:

在这里尝试。

class M{
  static String c(int[] s){
    int a[] = new int[8],
        x = 0,
        y;
    for(; x < 3; x++){
      for(y = 0; y < 3; a[x] += s[x * 3 + y++]);
      for (y = 0; y < 3; a[x + 3] += s[y++ % 3]);
    }
    for(x = 0; x < 9; y = s[x],
                      a[6] += x % 4 < 1
                               ? y
                               : 0,
                      a[7] += x % 2 < 1 & x > 0 & x++ < 8
                               ? y
                               : 0);
    x = 0;
    for(int i : a){
      if(i > 2){
        return "win";
      }
    }
    for(int i : a){
      if(i < 1){
        return "loose";
      }
    }
    return "cat";
  }

  public static void main(String[] a){
    /*  xxo
        xox
        oox  */
    System.out.println(c(new int[]{ 1, 1, 0, 1, 0, 1, 0, 0, 1 }));
    /*  xxx
        ooo
        xxx  */
    System.out.println(c(new int[]{ 1, 1, 1, 0, 0, 0, 1, 1, 1 }));
    /*  xxo
        oox
        xox  */
    System.out.println(c(new int[]{ 1, 1, 0, 0, 0, 1, 1, 0, 1 }));
  }
}

输出:

loose
win
cat

0

APL(NARS),69个字符,138个字节

{w←3 3⍴⍵⋄x←(+/1 1⍉⊖w),(+/1 1⍉w),(+⌿w),+/w⋄3∊x:'win'⋄0∊x:'lose'⋄'cat'}

输入应该是一个3x3矩阵或一个9个元素的线性数组,该线性数组只能是1(对于X)和0(对于O),如果没有人获胜,则结果为“ cat”;如果O获胜,则结果为“ lose”;“ win”如果X获胜。不会检查一个无效的电路板或输入是一个数组的元素少于9个或更多,还是检查每个元素<2。

作为注释:它将在3x3矩阵中转换输入,并构建一个名为“ x”的数组,其中元素是每一行列和对角线的和。

一些测试请参见其他示例:

  f←{w←3 3⍴⍵⋄x←(+/1 1⍉⊖w),(+/1 1⍉w),(+⌿w),+/w⋄3∊x:'win'⋄0∊x:'lose'⋄'cat'}
  f 1 2 3
win
  f 0 0 0
lose
  f 1 0 1  1 0 1  1 0 1
win
  f 0 1 1  1 0 0  1 1 1
win
  f 0 0 1  1 0 1  1 1 0
lose
  f 1 1 0  0 1 1  1 0 0
cat
  f 1 1 0  0 1 0  0 0 1
win
  f 1 1 0  1 0 1  0 0 1
lose
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.