Fou Python solution - 79 caractères

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

cependant, cela suppose un ordre différent pour les positions de la Commission dans b:

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

Qui est, b[5] représente le coin supérieur gauche, et ainsi de suite.

afin De minimiser la ci-dessus:

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 caractères et une nouvelle ligne.

mise à Jour: à 79 caractères et une nouvelle ligne utilisant le bitwise et trick:

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

Python 80 (69) char

pas la solution Python la plus courte, mais j'aime comment il introduit "DICE" dans un jeu de 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 caractères pour l'expression la plus simple:

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 characters

une fonction qui renvoie 0, 1 ou 2, en utilisant une expression régulière, Bien sûr (la nouvelle ligne n'est là que pour éviter la barre de défilement):

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

on peut l'appeler V(@b) , par exemple.

J, 50 chars

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

Je ne suis pas content de me répéter (horizontal/vertical, et les diagonales), mais je pense que c'est un bon début.

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

stratégie: Bitwise AND chaque élément d'une rangée/colonne/diagonale avec les autres éléments (avec 3 comme une graine) pour obtenir un vainqueur pour ce sous-ensemble, et OR eux tous ensemble à la fin.

Ruby, 115 caractères

Oops: J'ai dû me tromper. C'est en fait 115 caractères, pas 79.

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

et le code élargi, à des fins éducatives:

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

je suis sûr que cela pourrait être raccourci, en particulier le grand tableau et peut-être le code pour obtenir un bitmask des mouvements des joueurs--ce ternary me dérange--mais je pense que c'est assez bon pour le moment.

Perl, 76 char

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

il y a trois façons de gagner horizontalement:

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

Une façon de gagner en diagonale du bas à gauche vers en haut à droite:

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

trois façons de gagner verticalement:

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

Une façon de gagner en diagonale du coin supérieur gauche au coin inférieur droit:

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

lisez les colonnes du milieu pour obtenir les nombres magiques.

Octave / Matlab, 97 caractères, y compris les espaces et les lignes. Sorties 0 si aucun gagnant, 1 si le Joueur 1 a gagné, 2 si le Joueur 2 a gagné, et 2.0801 si les deux joueurs "ont gagné":

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)

si nous changeons la spécification et passons en B comme matrice 3x3 dès le début, nous pouvons supprimer la ligne de remodelage, en la ramenant à 80 caractères.

parce que personne ne gagne au tictactoe quand bien joué je pense que c'est le code le plus court

echo 0; 

7 caractères

mise à jour: une meilleure entrée pour bash serait celle-ci:

86 caractères ou 81 excluant la définition de la fonction (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;}

mais, c'est le code de par programme tic-tac-toe dans bash donc il ne répond pas tout à fait aux spécifications.

# 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

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

si l'entrée a deux joueurs gagnants, p.ex.

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

alors la sortie est 3.

Haskell, en supposant les carrés magiques ci-dessus. 77 caractères

77 exclut les importations et définit 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]

Ou 82 en supposant que la normale de la commande:

{-# 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 caractères

pas un gagnant, mais peut-être qu'il y a de l'amélioration. N'a jamais fait cela avant. Concept Original, première ébauche.

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

merci à KennyTM pour quelques idées et le harnais d'essai.

La "version de développement":

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

(fer)python, 75 caractères

75 caractères pour une fonction complète

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 caractères si vous omettez la définition de la fonction comme d'autres l'ont fait

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

les 8 directions différentes sont représentées par valeur de départ + incrémenteur, comprimée en un seul nombre qui peut être extrait en utilisant la division et modula. Par exemple: 2,5,8 = 2*6 + 3 = 15.

contrôle qu'une rangée contienne trois valeurs égales est fait en utilisant l'opérateur&. (ce qui donne zéro s'ils ne sont pas égaux). max est utilisé pour trouver le possible vainqueur.

Une solution dans C (162 Caractères):

Cela fait usage du fait que le joueur une valeur (1) et le joueur deux valeurs (2) ont des bits indépendants définis. Par conséquent, vous pouvez bitwise et les valeurs des trois boîtes de test ensemble-- si la valeur est non nulle, alors les trois valeurs doivent être identiques. En outre, la valeur résultante == le joueur qui a gagné.

pas la solution la plus courte pour l'instant, mais le mieux que je puisse faire:

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

une version plus lisible:

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

Python, 102 caractères

puisque vous n'avez pas vraiment précisé comment obtenir les entrées et les sorties, c'est la version" brute " qui devrait peut-être être enveloppé dans une fonction. b est la liste des entrées; r est la sortie (0, 1 ou 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

Lua, 130 caractères

130 caractères est la taille de la fonction. La fonction ne renvoie rien si aucune correspondance n'est trouvée, ce qui dans Lua est similaire à retourner 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)

Visual Basic 275 254 (avec frappe libre) caractères

 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 - fonction" w "ci-dessous est de 114 caractères

<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 caractères.

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

j'avais prévu de poster une explication de comment cela fonctionne, mais c'était hier et maintenant je ne peux pas lire ce code.

l'idée est de créer une liste de tous les triplés gagnants possibles (048.246.012.345.678.036.147.258), puis de faire le powerset des carrés de chaque joueur a et puis de croiser les deux listes. S'il y a un match, c'est le gagnant.

Python - 75 caractères (64)

j'ai trouvé 2 expressions, chacune 64chars:

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

et

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

quand vous ajoutez "W=lambda b:" pour en faire une fonction, Cela fait 75chars. Le Python le plus court?

Python, 285 octets

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

...Oh, ce n'était pas ce que tu voulais dire quand tu as dit "Code Golf: Tic Tac Toe"? ;) (entrer les numéros de numpad pour placer des x ou des o, c.-à-d. 7 est nord-ouest)

Version Longue

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

je suis sûr qu'il y a un moyen plus court pour faire ça mais... Perl, 141 caractères (134 à l'intérieur de la fonction)

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 caractères

Minifiés:

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

les deux retours comptent (l'un nécessaire et l'autre à remplacer par un espace).

les codes de tableau pour les huit façons de gagner en triplets à partir de positions égales et pris mod 16.

bit à Bit et truc volé Eric Pi .

forme plus lisible:

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

échafaudage D'essai:

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

pourrait probablement être amélioré, mais je ne me sens pas particulièrement intelligent en ce moment. C'est juste pour s'assurer que Haskell soit représenté...

en supposant que b existe déjà, cela mettra le résultat dans w .

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

, en supposant une entrée de stdin et une sortie de stdout,

import List
a l=2*minimum l-maximum l
w b=maximum"151910920":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 caractères:

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 étant la grille)

pourrait probablement être amélioré... Je travaille toujours sur elle ;)

Python, 140 caractères

mon premier golf de code, pesant à 140 chars (déclaration d'importation, je vous nie!):

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

légèrement moins obscur 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# Solution.

multiplier les valeurs dans chaque ligne, col et diagonale. Si résultat == 1, X gagne. Si résultat = = 8, O gagne.

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 caractères

empruntant quelques techniques à d'autres soumissions. (il ne savait pas C# vous permettent d'initialisation des tableaux comme ça)

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 caractères

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

je pense que ça marche? Mon premier golf code, sois gentil.

tous les 3 chiffres encode 3 cellules qui doivent correspondre. L'intérieur contrôle une triade. L'extérieur tout en contrôlant tout 8.