코드 골프:틱 전술 발가락

StackOverflow https://stackoverflow.com/questions/2245801

문제

게시의 짧은 코드에 의하여,문자,계산 확인하려면 플레이어가지 않고,만약 그렇다면,어떤.

이 있다고 가정 정수 배열 변수 b (보드)를 보유하는 틱 전술 발가락이 보드,고의 움직임을 플레이어:

  • 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 을 나타내는 player1 했다.지 않은 경우-하나는 출력할 수 있습니다 0 나 false.

내 자신이(루비)솔루션입니다.

편집:죄송하는 것을 잊었으로 표시 커뮤니티 wiki.가정할 수 있는 입력이 잘 형성되어야 하지 않 오류가 확인됩니다.

업데이트:게시하시기 바랍 솔루션의 형태로 기능입니다.대부분의 사람들이 이것을 이미하지만,일부지지 않는 전적으로 공정하다.보드에 제공되는 기능으로 매개 변수입니다.결과에 의해 반환되는 기능입니다.기능할 수 있는 이름이 있습니다.

도움이 되었습니까?

해결책

C, 77 (83) 문자

이것은 변형입니다 DMCKEE소형 코딩의 각 숫자 쌍이 이제 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;
}

다른 팁

미친 파이썬 솔루션 -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 자 및 신형.

업데이트: 비트와 트릭을 사용하여 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])

파이썬 80 (69) 숯

가장 짧은 파이썬 솔루션은 아니지만 Tic-Tac-Toe 게임에 "주사위"를 소개하는 방법이 마음에 듭니다.

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

Perl, 87 85 캐릭터

정규 표현식을 사용하여 0, 1 또는 2를 반환하는 함수 (물론 Newline은 스크롤 바를 피하기 위해만) :

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

그것은 다음과 같이 호출 할 수 있습니다 V(@b), 예를 들어.

J, 50 숯

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

나는 나 자신을 반복하는 것에 만족하지 않지만 (수평/수직, 대각선), 나는 그것이 공정한 시작이라고 생각합니다.

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 끝에 모두 함께.

루비, 115 숯

죄송합니다 : 어떻게 든 나는 많은 것을 잘못 입증했다. 이것은 실제로 79가 아닌 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

교육 목적으로 확장 된 코드 :

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

나는 이것이 단축 될 수 있다고 확신합니다. 특히 큰 배열과 아마도 3 원 버그가 나오는 플레이어의 움직임에 비트 마스크를 얻기위한 코드 일 것입니다. 그러나 지금은 이것이 꽤 좋다고 생각합니다.

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

중간 열을 읽고 마법 번호를 얻으십시오.

옥타브/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)

만약 우리가 사양을 변경하고 전달 b3x3 매트릭스에서 시작,제거할 수 있습을 바꿀 라인,그것을 받고 내려 80 문자입니다.

올바르게 플레이 할 때 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

루비, 85 숯

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입니다.

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]

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
}

(철) 파이썬, 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입니다.

행에 세 가지 동일한 값이 포함되어 있는지 확인하고 연산자를 사용하여 수행됩니다. (동일하지 않은 경우 0이됩니다). Max는 가능한 승자를 찾는 데 사용됩니다.

C (162 자)의 솔루션 :

이것은 플레이어 1 값 (1)과 플레이어 2 값 (2)이 독립 비트 세트를 가지고 있다는 사실을 사용합니다. 따라서 비트와 3 개의 테스트 상자의 값을 함께 할 수 있습니다. 값이 0이 아닌 경우 세 값은 모두 동일해야합니다. 또한 결과 값 == 승리 한 플레이어입니다.

지금까지 가장 짧은 솔루션은 아니지만 내가 할 수있는 최선입니다.

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

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

루아, 130 자

130자는 기능 크기입니다. 일치가없는 경우 함수는 아무것도 반환하지 않습니다. LUA에서는 거짓 리턴과 유사합니다.

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)

시각적 기본 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

JavaScript -Function "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>

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)의 목록을 작성한 다음 각 플레이어가 가지고있는 사각형의 파워 세트를 만들고 두 목록을 교차시킵니다. 경기가 있다면 그것이 승자입니다.

파이썬 -75 숯 (64)

나는 각각 64 차의 2 개의 표현을 생각해 냈습니다.

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 크기를 만듭니다. 지금까지 가장 짧은 파이썬?

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

... 아, 이것은 당신이 "코드 골프 : Tic Tac Toe"라고 말했을 때의 의미가 아니 었습니까? ;) (X 또는 O를 배치하려면 Numpad 번호를 입력하고, 즉 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

이 작업을 수행하는 방법이 짧지 만 ... 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;}

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

두 수익률 모두 카운트 (하나는 필요하고 다른 하나는 공간으로 교체해야합니다).

배열은 짝수 위치에서 시작하여 Mod 16을 가져가는 트리플렛에서 승리하는 8 가지 방법을 코딩합니다.

비트와 트릭에서 도난당했습니다 에릭 피.

더 읽기 쉬운 양식 :

#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;
}

아마 더 나아질 수는 있지만 지금은 특히 영리하지 않습니다. 이것은 단지 확인하기위한 것입니다 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

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 그리드가되기)

아마 개선 될 수있을 것입니다 ... 나는 아직도 그것에 대해 노력하고 있습니다;)

파이썬, 140 숯

내 첫 번째 코드 골프, 무거운 140 숯으로 무게를두고 있습니다 (Import Statement, 나는 당신을 거부합니다!) :

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

C# 솔루션.

각 행의 값을 Col & Diagonal에 곱하십시오. 결과 == 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;
}

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

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 개의 셀을 인코딩합니다. 내부는 트라이어드를 점검합니다. 외부는 8을 모두 점검합니다.

라이센스 : CC-BY-SA ~와 함께 속성
제휴하지 않습니다 StackOverflow
scroll top