Scrivi un programma per giocare a Connect 4 . Ti viene dato lo stato del tabellone come input e devi decidere in quale colonna posizionare il tuo pezzo per ottenere 4 di fila (orizzontalmente, verticalmente o diagonalmente) o impedire al tuo avversario di fare lo stesso.

Il tabellone è un array 6x7, dove ogni cella può essere vuota (''), contenere il tuo pezzo ('X') o il pezzo del tuo avversario ('O'). Una scheda di esempio:

O      
XX    X
XOX  OO
XOO OXO
OXXOXXO
XOXOXOX

Ti piacerebbe giocare nella colonna 3 (le colonne sono 0-6, numerate da sinistra) per la vittoria diagonale. Quindi hai prodotto:

3

Il codice deve generare un numero di colonna e deve soddisfare i seguenti criteri:

1. Non puoi giocare in una colonna che contiene già 6 pezzi.
2. Se c'è almeno una mossa vincente, devi giocarne una.
3. Se riesci a impedire al tuo avversario di vincere alla sua prossima mossa, devi farlo.

Nota che il gioco ottimale non è necessario, solo che ottieni una vittoria immediata o impedisci la vittoria immediata dell'avversario. Se il tuo avversario ha più di un modo per vincere, non è necessario bloccarne uno.

Ti viene data la scheda sull'input standard e devi stampare un numero di colonna in cui vuoi giocare sull'output standard. Il tabellone è garantito per essere ben formato (niente buche, almeno una mossa possibile) e non avere già una vittoria per nessuno dei due giocatori.

Il codice più corto vince.

Esempio 1

      X
      O
      X
      O
 OOO  X
 XXX  O

Devi giocare la colonna 0 o 4 per la vittoria.

Esempio 2

      X
X     X
O     O
XOX  XO
XXO XOX
XXO XXO

Devi giocare alla colonna 3 per bloccare la vittoria immediata del tuo avversario.

Esempio 3

X      
XO     
OX    O
XO   XX
XXO OOO
OOO XXO

Non puoi vincere o fermare la vittoria del tuo avversario, quindi puoi giocare qualsiasi colonna 1-6 (0 è pieno).

Esempio 4

X      
O      
X      
OOO    
XOX    
OXOX   

Non puoi giocare nella colonna 3, in quanto consente al tuo avversario di vincere immediatamente. Puoi giocare nelle colonne 1-2 o 4-6.

C, 234 286 256 caratteri

Risolto per risolvere correttamente il problema, controllando le mosse vincenti dell'avversario dopo ogni mossa tentata.

Questo codice è molto sensibile al formato del file di input: ogni riga deve contenere 7 caratteri + newline.
La scheda è trattata come una matrice 8x8, piuttosto che 7x6. L'ottava colonna contiene le nuove righe e le 2 righe extra contengono zeri, quindi non interferiscono con la soluzione. In realtà aiutano: quando ci si sposta a destra dalla colonna più a destra, si preme sulla colonna di nuova riga, che funge da controllo del limite.

wcontrolla una posizione per avere l'opportunità di vincere o bloccare. qdovrebbe essere la cella da controllare. Usa la ricorsione per scorrere in 4 direzioni (inizia con 9,8,7, quindi più volte 1).
Ccontrolla una sequenza di caratteri identici che iniziano qnella direzione d, sia avanti che indietro. Restituisce la somma di entrambe le sequenze (senza contare la posizione iniziale), quindi se restituisce 3, c'è una riga di 4.

char B[99],q;
C(i,d){
    return B[d*i+++q]-B[q]?d>0?C(1,-d):0:1+C(i,d);
}
w(x){
    return x&&C(1,x>6?x:1)>2|w(x-1);
}
t(l,c,r,v){
    for(;c--;)B[q=c]&32&B[c+8]-32?r=w(9,B[c]=l)?v=c:v||r*t(79,l,0,1)?r:c,B[c]=32:0;
    return r;
}
main(){
    putchar(48+t(88,16+read(0,B+16,48),0,0)%8);
}

Python 2.x - 594 591 576 557 523 459 458 433 byte

Questo è il migliore che ho raggiunto finora. Immagino sia difficile battere C. Sfida fantastica, devo dire.

r=range
f=[]
exec'f+=list(raw_input());'*6
def n(p):
 o,b,a,k=[],1,'O',lambda q:any([o[i:i+4]==list(q)*4for o in(f[x-x%7:],f[x%7::7])for i in r(3)]+[all(q==f[7*(y+u*i)+z+i]for i in r(4))for u,z,v,c in((1,0,3,4),(-1,3,6,3))for y in r(z,v)for z in r(c)])
 for x in r(42):
    if x>34<a>f[x]or x<35and f[x+7]>'0'>f[x]:f[x]=p;z=k(p)*b;o=z*[x]+o+[x]*(a==p or n(a)[1]);b-=z;f[x]=' '
 return o[0]%7,b
a,b,c,d=n('X')+n('O')
print(a,(c,a)[d])[b]

L'if-line (riga 7) ha un rientro di una scheda. A SE non piacciono le schede.