코드 골프를하자!

틱택 토 보드 상태 (예 :)

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

게임이 있는지 여부를 확인 나 . 코드는 상태에 따라 이러한 옵션을 출력해야합니다. 위의 게임은 출력해야합니다winlosecatlose

분명히 : 승리는 x연속으로 3 s (대각선, 수평, 수직)로 정의됩니다. 패배는 o연속으로 3 초이고, 연속으로 cat경기는 없습니다.

흥미로운 것들을 만들기 위해 설명해야 할 상태에 대한 입력 구조를 결정하게됩니다. 예를 들어 xxoxoxoox위와 같이 각 문자를 왼쪽에서 오른쪽으로, 위에서 아래로 읽는 유효한 상태입니다. [['x','x','o'],['x','o','x'],['o','o','x']]다차원 배열의 게임도 비슷한 방식으로 읽습니다. 하지만 0x1a9이는 16 진수입니다 110101001적절한 압축과 같은 힘 작업 1을 위해 조작 할 수 x의 및 0위해 조작 할 수는 o.

하지만 이것들은 단지 몇 가지 아이디어 일뿐입니다. 많은 아이디어가있을 것입니다.

기본 규칙 :

1. 프로그램은 실행 가능한 상태를 수용 할 수 있어야합니다.
2. 입력 형식은 모든 상태를 나타낼 수 있어야합니다.
3. "승리 상태는 보드에서 결정해야합니다"
4. 완전한 보드를 가정
5. Win이전 lose의 경우 'xxxoooxxx'의 예를 들어

가장 적은 문자 수의 승리

루비 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

보드는 16 진수로 표시되며 9 개의 사각형에 해당하는 9 비트로 구성됩니다. 1은입니다 X, 0은입니다 O. 이것은 선택 0x1a9의 여지가 있지만 질문 의 예 와 같습니다 0x!

비트 마스크를 수행하고 큰 목록을 하드 코딩하는 더 좋은 방법이있을 것입니다. 나는 행복하게 제안을 할 것이다.

여기 Ideone에서 실행 되는 것을 참조 하십시오 .

매스 매 티카, 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}}

강타 : 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 덕분입니다.

빌 펀지 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) 추가. 열, 행 및 두 개의 diagnals의 합계를 결정합니다. 해당 값을 3 ( "win") 또는 0 ( "lose")과 비교합니다. 그렇지 않으면 모든 값이 1 또는 2 인 경우 그립니다 ( "cat").

GolfScript, 27 자

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

입력 형식은 8 개의 8 진수로 구성된 문자열이며, 각각 3 개의 연속 보드 사각형을 (중복) 인코딩합니다.

• 처음 세 자리 숫자는 각각 보드의 단일 행을 위에서 아래로, 왼쪽에서 오른쪽으로 인코딩합니다.
• 다음 3 자리 숫자는 각각 왼쪽에서 오른쪽으로, 위에서 아래로 보드의 단일 열을 인코딩합니다.
• 마지막 두 자리는 각각 대각선 중 하나를 인코딩합니다 (먼저 왼쪽에서 오른쪽 아래, 왼쪽에서 오른쪽 아래).

3 개의 제곱의 시퀀스 (행 / 열 / 대각선)를 8 진수로 인코딩하려면 시퀀스의 모든 항목 x을 1과 o0으로 바꾸고 1과 0의 결과 시퀀스를 0과 7 사이의 이진수로 해석하십시오. 포함한.

이 입력 형식 (전체 기판의 위치가 중심 위치가 네 번 인코딩하여 두번 적어도 부호화) 상당히 중복되지만 않는 명백하게 완전히 채워 틱택 토 기판의 가능한 상태를 나타내고, 않는 직접 인코딩 입력에 승자.

입력은 선택적으로 숫자 사이에 공백이나 다른 구분 기호를 포함 할 수 있습니다. 사실, 모든 프로그램은 정말 에 대한 관심이 입력 문자열이 숫자가 포함되어 있는지 여부입니다 7또는 0.

예를 들어, 보드 예 :

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

입력으로 나타낼 수 있습니다.

651 643 50

편의상, 위의 도전과 같이 ASCII 아트 보드 레이아웃을이 프로그램에 적합한 입력 문자열로 변환하는 GolfScript 프로그램이 있습니다.

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

이 변환기는 입력에서 x및 이외의 문자를 무시합니다 o. 위의 승리 결정 프로그램에 공급하기에 적합한 단일 숫자 문자열 (위의 공백 구분 기호로 완성 됨)을 생성하므로이 두 프로그램의 연결을 사용하여 ASCII 아트 보드에서 우승자를 직접 결정할 수 있습니다.

또한 입력이 실제로 보드를 명확하게 나타내는 것을 보여주기 위해 리버스 컨버터가 있습니다.

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

추신. 다음은이 솔루션의 온라인 데모입니다.

파이썬 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.

하스켈, 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"

자바 스크립트, 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 -오
• 00 -빈 광장

이 솔루션은 비트 조작을 사용하여 8 개의 가능한 "3 개의 행"구성을 각각 테스트합니다 (X에 대해 한 번, O에 대해 한 번씩 두 번 테스트 함).

이 기능이 실제 Tic-Tac-Toe 게임의 일부로 사용 되는 Tic-Tac-Toe 웹 사이트 에서 약간의 축소를 제공 detectWin합니다.

루비, 84 자

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

간단한 RegExp 기반 솔루션. 입력 형식은 9 자리 이진 문자열입니다 (예 : 110101001질문에 제공된 예제 보드의 경우).

루비, 78 자

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

입력 형식 : xxo_xox_oox

하스켈, 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.

C, 150 약

자정이었고 테스트를 수행 하지는 않았지만 어쨌든 개념을 게시 할 것입니다. 나는 내일 다시 올 것이다.

사용자는 두 개의 8 진수를 입력합니다 (바이너리를 사용하고 싶었지만 C가 8 진수 만 지원한다는 것을 알았습니다) :

a 중심 사각형, X의 경우 1, O의 경우 0

b 하나의 모서리에서 시작하여 같은 모서리 (마침이 반복 될 때만 해당)에서 끝나는 보드 주위를 돌고, X의 경우 1, O의 경우 0 인 경계 사각형을 나타내는 9 자리 숫자입니다.

이기는 방법에는 두 가지가 있습니다.

1. 가운데 정사각형은 X ( a= 1)이고 반대쪽 두 정사각형도 X (b&b*4096 0이 아님).

2. 인접한 3 개의 주변 사각형은 X ( b/8 & b & b*80이 아님)입니다. 중간 사각형이 모서리 사각형이 아닌 가장자리 사각형 인 경우에만 유효한 승리입니다. 따라서 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"));
}

세게 때리다, 107 103

sed 스크립트를 생성하고 실행합니다.

I / O 형식 : oxo-oox-xoo출력 lose(a -를 사용하여 행 분리). stdin에 입력하십시오. c명령에 GNU sed가 필요합니다 .

나는 규칙 5를 "승리와 패가 모두 가능하다면 승리를 선택하십시오"라고 해석했습니다.

주요 코드

이것이 실제 답변입니다.

정말 흥미로운 것은 없습니다. 그것은 정의 $b로 /cwin문자를 저장하려면, 다음 스크립트의 승리 조건 부분을 정의 한 후, 사용 sed y/x/o/\;s$b/close/변환 x에 o와 cwin에 close(함으로써 잃게 조건을 생성). 그런 다음 두 가지를 보내고 sed에 win / lose 조건이 일치하지 않으면 ccat출력 cat됩니다.

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정규식이 일치하는 경우 텍스트를 출력하고 종료.

독립형 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

파이썬 3, 45

Input is in 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]

다트-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 문자는 구분 기호로 사용할 수 있습니다.

문자를 계산하기 전에 선행 공백과 줄 바꿈을 생략해야하지만 가능한 경우 내부 공백을 잘라냅니다. 하위 문자열을 만드는 더 작은 방법이 있었으면 좋겠다.

Recusive bit-base 버전 : 119 자 입력은 1은 'x'를 나타내고 0은 'o'를 나타내는 9 비트 숫자 여야합니다.

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"));
}

CJam, 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"가 있는지 확인하여 결과를 결정합니다.

여기에서 온라인으로 사용해보십시오

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/

배쉬 : 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

이 답변에서 영감을 얻었습니다 .

VB.net

이 예제에서 제공은 다음 비트 패턴으로 인코딩됩니다.

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"))

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&$)

예 : (NB.는 주석입니다)

   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

Ungolfed 코드 설명

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`---- >@{~

파이썬 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 쉘에서 115 바이트 (2 또는 3) :

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]

보드 변수는 질문에 설명 된 이진 형식으로 설정됩니다. 1X의 0경우 O, 왼쪽에서 오른쪽, 위에서 아래로. 이 경우101001110 대표

XOX
OOX
XXO

출력으로 이어지는 Cat

파이썬 ( 73 62 자)

입력은 동일한 보드의 4 가지 개별 뷰를 나타내는 4 개의 소문자 문자열이며, 모두 행, 열, 오른쪽 대각선, 왼쪽 대각선으로 단일 문자열로 연결됩니다.

최신 정보

좋은 반례로 이것을 지적 해준 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]".

이 파이썬 문장은 변수가 주어진 게임 결과를 인쇄합니다 s 를 입력으로 :

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

하스켈 (69 문자)

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

이것은 이 답변에서 설명한 것과 동일한 입력을받습니다. . 보다 구체적으로, 입력은 8 개의 8 진수 값으로 각 행, 열 및 대각선의 이진 값을 나타냅니다. 이 코드는 7 "win"의 모든 인스턴스, 0 "lose"의 모든 인스턴스를 만들고 다른 모든 것을 제거합니다. 그런 다음 끝에 "cat"을 추가하고 결과에서 처음 4자를 가져옵니다.

"lose", "cat", "win", "l", "win", "c"가 다음과 같이 4 가지 가능한 답변이 있습니다.

사용법 예 :

i "65153806" --outputs "lose"

J : 83

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

사용법 : x와 o의 문자열을 추가하고 마법의 일을보십시오. 예. 'xxxoooxxx'.

내 동사 (+/@:(*./"1)@;@(;((<0 1)&|:&.>@(;|.)(,<)|:))) 기본적으로 원래 이진 행렬을 묶고 조옮김은 2 개의 대각선으로 묶습니다. 이 결과는 함께 사라졌다; 행 합계는 승을 결정하기 위해 취한 다음 합산됩니다. 또한이 동사를 호출합니다 Inner.

승자를 찾기 위해 일반 이진 행렬과 역 이진 행렬의 점수 차이는 후크에서 가져옵니다. (-&Inner -.) .

나머지 코드는 단순히 출력을 만들고 올바른 것을 선택합니다.

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을 0으로 바꾸는 방법을 업데이트했습니다.

J-56 (26?) 숯

J는 데이터 유형으로 LOL을 지원할 수 있기 때문에 9 개의 문자로 구성된 3x3 행렬이 제공됩니다.

(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

각 행, 열 및 대각선의 상태를 중복 적으로 나타내는 8 진수의 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

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)

입력은 16 진수입니다. 이것은 루비 솔루션을 T-SQL로 변환 한 것입니다.

자바 스크립트 1.6, 71 자

game각 행, 각 열 및 각 진단을 3 문자 문자열로 포함 하는 배열로 입력을 가정 합니다. bob 's answer 와 유사 하지만 연결된 문자열이 아닌 배열로 제공됩니다.

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

편집 @ nyuszika7h 의 코멘트 (67 개 문자)

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

자바 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

APL (NARS), 69 자, 138 바이트

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

입력은 1 (X의 경우)과 0 (O의 경우) 만 될 수있는 3 개의 3x3 행렬 또는 9 개의 요소로 구성된 선형 배열이어야합니다. 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