Ogni linea è composta da tre caselle; indichiamo ogni casella con un numero (ai fini della valutazione non ha alcuna importanza la disposizione delle tre caselle):

1. a sinistra la mossa da valutare: vale 1 o 2 secondo chi deve muovere (Who)
2. al centro la casella adiacente: vale 0 se vuota, 1 o 2 se occupata da una pedina.
3. a destra l'altra casella: vale 0 se vuota, 1 o 2 se occupata da una pedina.

Indicando in binario i tre numeri (due bit ciascuno) e concatenando i bit, avremo che ogni configurazione è rappresentata da un numero a 6 bit, che può essere usato come indice per l'accesso alla tabella dei punteggi relativi.
Sia, ad esempio, 1=01 la pedina gialla e 2=10 la pedina blu:

Configurazione	Who		Punti
16 = 01 00 00			1	apre il gioco
17 = 01 00 01			7	tenta il tris
18 = 01 00 10			3	ostacola il tris
20 = 01 01 00			7	tenta il tris
21 = 01 01 01			31	vince !
22 = 01 01 10			0	mossa inutile
24 = 01 10 00			3	ostacola il tris
25 = 01 10 01			0	mossa inutile
26 = 01 10 10			15	blocca un tris
32 = 10 00 00			1	apre il gioco
33 = 10 00 01			3	ostacola il tris
34 = 10 00 10			7	tenta il tris
36 = 10 01 00			3	ostacola il tris
37 = 10 01 01			15	blocca un tris
38 = 10 01 10			0	mossa inutile
40 = 10 10 00			7	tenta il tris
41 = 10 10 01			0	mossa inutile
42 = 10 10 10			31	vince !

I punteggi sono scelti in modo che due configurazioni di una categoria valgano meno di una di categoria superiore. Costruiamo ora un array di interi con l'elenco dei punteggi corrispondenti a ciascuna configurazione:

int PuntiMossa[ ] = { 0, 0, 0, 0, 0,  0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0,
                               1, 7, 3, 0, 7, 31, 0, 0, 3, 0, 15, 0, 0, 0, 0, 0,
                               1, 3, 7, 0, 3, 15, 0, 0, 7, 0, 31, 0, 0, 0, 0, 0  };

Ad esempio, per valutare la bontà di una mossa per Who nella casella 0, si usano le configurazioni delle coppie di caselle 1-2  e 9-21

Punteggio = PuntiMossa [(Who<<4)+(Tavola[ 1]<<2)+Tavola[ 2] ] +
                 PuntiMossa [(Who<<4)+(Tavola[ 9]<<2)+Tavola[21] ]  ;

Nel programma, scritto in C, costruiamo 24 funzioni, una per ciascuna casella, e inseriamo gli indirizzi in un array di puntatori a funzione:

int (*ValoreCasa[ ])( int ) = { Casa00, Casa01, . . . ., Casa23};