TweetFollow Us on Twitter

May 99 Challenge

Volume Number: 15 (1999)
Issue Number: 5
Column Tag: Programmer's Challenge

May 99 Challenge

by Bob Boonstra, Westford, MA

Piper

Every once in a while, good fortune not only comes your way, but actually reaches out of your computer monitor, and grabs you by the throat. I felt a little like that while reading a recent issue of TidBITS. In it was a column by Rick Holzgrafe reflecting on the increasing speed of computers, in which Rick described a program he wrote for a PDP-11/60 to solve a word puzzle. The idea behind the puzzle was to take a phrase and map it onto a rectangular grid, with the objective being to map the phrase into a rectangle of the smallest possible area. The word puzzle looked like a good idea for a Challenge, and Rick and TidBITS agreed to let me use it.

In more detail, the puzzle works like this. To start, you are given a null-terminated string consisting of printable characters. You process the characters in order, ignoring any non-alphabetic characters and ignoring case. The first alphabetic character can be mapped to any square in the grid. The next letter can be mapped to any adjacent square, where adjacent is any of the eight neighboring squares in a horizontal, vertical, or diagonal direction. You may reuse a square if it is adjacent and already has the letter you are mapping. If the same letter occurs twice in a row in the input string, the letters must still be mapped to adjacent (but distinct) squares.

The prototype for the code you should write is:

#if defined(__cplusplus)
extern "C" {
#endif

typedef struct GridPoint {
   long x;
   long y;
} GridPoint;

void Piper (
   char *s,
   GridPoint pt[]
);

#if defined(__cplusplus)
}
#endif

For example, your Piper routine might be provided with the string:

            How much wood would a woodchuck chuck if a woodchuck 
            could chuck wood?

You might place the letters of that string into a 4x14 rectangle like:

                  ULD  ADLU
               HDOAIUCOHWUHOD
               UCOWFKHDOMCWOW
                K   WO

Or, you might compact them into an 4x4 rectangle:

               HWMU
               OOCH
               UDWK
               LAFI

You must return the GridPoint coordinates of where each character is mapped, with pt[i] containing the coordinates of input character s[i]. The origin of your coordinate system should be the cell where the first character is placed. The winner will be the solution that stores the input string in a rectangle of minimal area. Note that you are minimizing rectangle area, not the number of occupied squares. A time penalty of 1% for each second of execution time will be added

This will be a native PowerPC Challenge, using the latest CodeWarrior environment. Solutions may be coded in C, C++, or Pascal.

Three Months Ago Winner

The February Challenge invited readers to write a player for the game of Chinese Checkers. Played on a hexagonal board with six appended triangles, Chinese Checkers pits between 2 and 6 players against one another, with the objective being to move one's pieces from the home triangle to the opposite triangle. In the traditional game, the home triangles are usually 3 or 4 positions on a side; the Challenge extended the game to triangles of up to 64 positions. Pieces can either be moved to an immediately adjacent position or jumped over an adjacent piece. A single piece is permitted to make a sequence of jumps in a single move.

As simple as the game sounds, readers found it to be very difficult, so difficult that no solutions were submitted for the Chinese Checkers Challenge. Which left Yours Truly in something of a difficult spot. I could stop the column at this point, which wouldn't be very interesting for readers, not to mention not very satisfying for the magazine. Or I could write a solution for the Challenge myself, something I haven't done since I retired from Competition four plus years ago. Somewhat against my better judgement, I selected the latter option.

The first thing I noticed in solving the Challenge was that the board coordinate system specified in the problem wasn't very useful in generating a solution. I needed a coordinate system that could be easily rotated in 60-degree increments, enabling my solution to play any of the six possible player positions. After some thought, I came up with a more symmetric coordinate system, called CanonPosition in the code, along with conversion routines ConvertPositionToCanonPosition and ConvertCanonPositionToPosition. The commentary in the code illustrates the coordinate system for a board of size 4. Then I needed a way to evaluate board positions. I decided on a simple metric that summed the distances of all pieces from the apex of their goal triangle. That metric could be improved upon by taking possible jump moves into account. The solution starts by computing all possible moves for our player. It then tries each of those moves, and then recursively calls MakeNextMove to process the next player. It computes and tries all moves for that player, and recurses for the next player. Recursion terminates when kMaxPlys turns have been taken for all players. Positions are evaluated using a min-max technique, where each player selects the position that maximizes his position relative to the best position of the other players.

The code could be improved in many ways. Instead of trying all possible positions, it could prune some obviously bad moves in the backward direction. This is complicated by the fact that some good jump multi-moves can include individual jumps that appear to be moving backward. The code might also be improved by evaluating moves by progressive deepening, rather than the depth-first search currently used, and by ordering move evaluation based on the scores at the prior depth. This technique is used in chess programs to prune the move tree to a manageable size. These and other optimizations are left to the reader. :-)

Remember, you can't win if you don't play. To ensure that you have as much time as possible to solve the Challenge, subscribe to the Programmer's Challenge mailing list. To subscribe, see the Challenge web page at <http://www.mactech.com/mactech/progchallenge/>. The Challenge is sent to the list around the 12th of the month before the solutions are due, often in advance of when the physical magazine is delivered.

Here is our sample Chinese Checkers solution:

Chinese Checkers.c
Copyright © 1999 J. Robert Boonstra

/*
*  Example solution for the February 1999 Programmer's Challenge
 *
 *  This solution is provided because no solutions were submitted
 *  for the ChineseCheckers Challenge.  This solution leaves a 
 *  great deal to be desired: it is not optimized, it does not 
 *  prune prospective moves efficiently, and it does not employ
 *  any of the classic alpha-beta techniques for efficiently
 *  selecting a move.
 */

#include <stdio.h>
#include <stdlib.h>
#include <Quickdraw.h>
 
#include "ChineseCheckers.h"

/* Position coordinates specified in problem (size==4)

  0:                           0
  1:                         0   1 
  2:                      -1   0   1 
  3:                    -1   0   1   2
  4:  -6  -5  -4  -3  -2  -1   0   1   2   3   4   5   6 
  5:    -5  -4  -3  -2  -1   0   1   2   3   4   5   6
  6:      -5  -4  -3  -2  -1   0   1   2   3   4   5  
  7:        -4  -3  -2  -1   0   1   2   3   4   5
  8:          -4  -3  -2  -1   0   1   2   3   4  
  9:        -4  -3  -2  -1   0   1   2   3   4   5
 10:      -5  -4  -3  -2  -1   0   1   2   3   4   5  
 11:    -5  -4  -3  -2  -1   0   1   2   3   4   5   6
 12:  -6  -5  -4  -3  -2  -1   0   1   2   3   4   5   6 
 13:                    -1   0   1   2
 14:                      -1   0   1 
 15:                         0   1 
 16:                           0
*/

#define kMaxPlys 1
#define kEmpty -1

/* CanonPosition uses units with (0,0) at the middle of the board */
typedef struct CanonPosition {
   long row;
   long col;
} CanonPosition;

/* Canonical position coordinates (size==4)

 -8:                           0
 -7:                        -1   1 
 -6:                      -2   0   2 
 -5:                    -3  -1   1   3
 -4: -12 -10  -8  -6  -4  -2   0   2   4   6   8  10  12 
 -3:   -11  -9  -7  -5  -3  -1   1   3   5   7   9  11
 -2:     -10  -8  -6  -4  -2   0   2   4   6   8  10  
 -1:        -9  -7  -5  -3  -1   1   3   5   7   9
  0:          -8  -6  -4  -2   0   2   4   6   8  
  1:        -9  -7  -5  -3  -1   1   3   5   7   9
  2:     -10  -8  -6  -4  -2   0   2   4   6   8  10  
  3:   -11  -9  -7  -5  -3  -1   1   3   5   7   9  11
  4: -12 -10  -8  -6  -4  -2   0   2   4   6   8  10  12 
  5:                    -3  -1   1   3
  6:                      -2   0   2 
  7:                        -1   1 
  8:                           0
*/

/* PlayerPos is used to store the location of each of a players pieces */
typedef struct PlayerPos {
   CanonPosition pos;
} PlayerPos;

typedef char *CanonBoard;

static long myNumPlayers,myNumPieces,myIndex,myGameSize,
   myPlayerPosition[6],myMinDist;
static PlayerPos *myPositions;

/* global board */
static CanonBoard myBoard;

/* moveIncrement is added to a CanonPosition to find the adjacent square in the
 * six possible directions 0..6, with 0==horizontal right, 1==down right, ...
 * 5==up right
 */
static CanonPosition moveIncrement[6] = 
   { { 0, 2}, { 1, 1}, { 1,-1}, { 0,-2}, {-1,-1}, {-1, 1} };

/* macros to access the board */
#define CanonRowSize(size) (6*(size)+1)
#define CanonBoardPos(row,col) (3*(myGameSize) +    \
         (2*(myGameSize)+(row))*(CanonRowSize(myGameSize)) + (col))
#define CanonBoardVal(board,row,col)          \
         board[CanonBoardPos(row,col)]
#define IsEmpty(board,row,col)             \
         (kEmpty == board[CanonBoardPos(row,col)])

ConvertPositionToCanonPosition
/* Convert coordinates from problem statement to canonical coordinates */
static CanonPosition ConvertPositionToCanonPosition (
            Position *pos, long size) {
   CanonPosition canon;
   canon.row = pos->row - 2 * size;
   if (pos->row == 2 * (int)(pos->row/2)) {
      canon.col = 2 * pos->col;
   } else {
      canon.col = 2 * pos->col - 1;
   }
   return canon;
}

ConvertCanonPositionToPosition
/* Convert canonical coordinates to coordinates from problem statement */
static Position ConvertCanonPositionToPosition (CanonPosition *canon, long size) {
   Position pos;
   pos.row = canon->row + 2 * size;
   if (canon->row == 2 * (int)(canon->row/2)) {
      pos.col = canon->col / 2;
   } else {
      pos.col = (canon->col + 1) / 2;
   }
   return pos;
}

RotateCanonPosition0ToN
/* rotate board by posNum increments of player positions (60 degrees) */
static CanonPosition RotateCanonPosition0ToN(
         CanonPosition oldPos, long posNum) {
   CanonPosition newPos;
   while (posNum<0) posNum+=6;   /* normalize to 0..5 */
   while (posNum>5) posNum-=6;
   switch (posNum) {
   case 0:
      newPos.row = oldPos.row;
      newPos.col = oldPos.col;
      break;
   case 1:
      newPos.row = (oldPos.row + oldPos.col)/2;
      newPos.col = (oldPos.col - 3*oldPos.row)/2;
      break;
   case 2:
      newPos.row =  (oldPos.col - oldPos.row)/2;
      newPos.col = -(oldPos.col + 3*oldPos.row)/2;
      break;
   case 3:
      newPos.row = -oldPos.row;
      newPos.col = -oldPos.col;
      break;
   case 4:
      newPos.row = -(oldPos.row + oldPos.col)/2;
      newPos.col = -(oldPos.col - 3*oldPos.row)/2;
      break;
   case 5:
      newPos.row = -(oldPos.col - oldPos.row)/2;
      newPos.col =  (oldPos.col + 3*oldPos.row)/2;
      break;
   }
   return newPos;
}

MaxColInRow
/* return the max column number in a given row */
static long MaxColInRow(long row, long size) {
   long maxCol;
   if (row<-size) {
      maxCol = row+2*size;
   } else if (row<0) {
      maxCol = 2*size-row;
   } else if (row<=size) {
      maxCol = row+2*size;
   } else /* if (row<=2*size) */ {
      maxCol = 2*size-row;
   }
   return maxCol;
}

IsLegalPosition
/* determine if a row,col coordinate represents a legal position */
static Boolean IsLegalPosition(CanonPosition *pos) {
   long maxCol;
   if ((pos->row<-2*myGameSize) || (pos->row>2*myGameSize)) 
         return false;
   if ((pos->row + pos->col) != 
               2 * (int)((pos->row + pos->col)/2)) 
      return false;
   maxCol = MaxColInRow(pos->row,myGameSize);
   if ((pos->col<-maxCol) || (pos->col>maxCol)) 
      return false;
   return true;
}

MoveFromTo
/* move a piece between positions from and to, does not check legality of move */
static void MoveFromTo(CanonBoard b,CanonPosition *from,CanonPosition *to,long newValue) {
   PlayerPos *p = &myPositions[newValue*myNumPieces];
   long oldValue = CanonBoardVal(b,from->row,from->col);
   int i;
   
   if (oldValue != newValue) {
      DebugStr("\p check err");
   }
   if ( IsLegalPosition(from) && IsLegalPosition(to) ) {
      CanonBoardVal(b,from->row,from->col) = kEmpty;
      CanonBoardVal(b,to->row,to->col) = (char)newValue;
      for (i=0; i<myNumPieces; i++) {
         if (    (p[i].pos.row == from->row) && 
                     (p[i].pos.col == from->col)) {
            p[i].pos.row = to->row;
            p[i].pos.col = to->col;
            break;
         }
      }
   }
}

PositionDistFromGoal
/* return the distance of a given position from a goal postion for player 0 */
static long PositionDistFromGoal (const CanonPosition *a, const CanonPosition *goal) {
   long rowDelta,colDelta;
   rowDelta = a->row - goal->row;
   if (rowDelta<0) rowDelta = -rowDelta;
   colDelta = a->col - goal->col;
   if (colDelta<0) colDelta = -colDelta;
   if (rowDelta>=colDelta) return rowDelta;
   else return rowDelta + (colDelta-rowDelta)/2;
}

PlayerDistFromGoal
/* return the cumulative distance of a player from his goal postion */
static long PlayerDistFromGoal(long player) {
   long cumDist;
   int i;
   CanonPosition goal;
   PlayerPos *p = &myPositions[player*myNumPieces];
   goal.row = -2*myGameSize;
   goal.col = 0;
   goal = 
      RotateCanonPosition0ToN(goal,(myPlayerPosition[player]+3)%6);
   for (i=0, cumDist=0; i<myNumPieces; i++) {
      CanonPosition *cp = &p[i].pos;
      long dist = PositionDistFromGoal(cp,&goal);
      cumDist += dist;
   }
   return cumDist;
}

InitPlayer
/* initialize the positions for a player at a given position */
static void InitPlayer(char *b,PlayerPos *piecePositions, long player, long position,long size) {
   CanonPosition pos,newPos;
   int col,maxCol,pieceCount;
   PlayerPos *piecePos;
   
   pieceCount = 0;
   for (maxCol=0; maxCol<size; maxCol++) {
      pos.row = -2*size+maxCol;
      maxCol = maxCol;
      for (col=-maxCol; col<=maxCol; col+=2) {
         pos.col = col;
         newPos = RotateCanonPosition0ToN(pos,position);
         CanonBoardVal(b,newPos.row,newPos.col) = (char)player;
   piecePos = &piecePositions[myNumPieces*player + pieceCount];
         piecePos->pos = newPos;
         ++pieceCount;
      }
   }
}

/* some variables to record the history of multi-jump moves, to
   prevent them from repeating infinitely */
static CanonPosition gMoveHistoryPos[6*64];
static long gMoveHistoryDirection[6*64];
static long gMoveHistoryCtr = -1;

CalcMove
/* Calculate a move for a given piece for a given player in a given moveDir.
 * Return true there is a legal move.
 * Return doneWithThisDirection==true if there are no more moves in this direction.
 */
static Boolean CalcMove(
         CanonBoard b, long player, long pieceNum, long moveDir, 
         CanonPosition *p1, CanonPosition *p2, 
         Boolean *doneWithThisDirection, long iterationLimit) {
   Boolean legalMove = true;
   if (gMoveHistoryCtr<0) {
      PlayerPos *p = &myPositions[player*myNumPieces];
      *p2 = *p1 = p[pieceNum].pos;
      p2->row += moveIncrement[moveDir].row;
      p2->col += moveIncrement[moveDir].col;
      if (!IsLegalPosition(p2)) legalMove = false;
      else if (IsEmpty(b,p2->row,p2->col)) {
      } else {
         long oldVal = CanonBoardVal(b,p2->row,p2->col);
         p2->row += moveIncrement[moveDir].row;
         p2->col += moveIncrement[moveDir].col;
         if (!IsLegalPosition(p2)) legalMove = false;
         else if (IsEmpty(b,p2->row,p2->col)) {
            if (gMoveHistoryCtr>iterationLimit) 
                        DebugStr("\p limit exceeded");
            gMoveHistoryPos[++gMoveHistoryCtr] = *p1;
            gMoveHistoryDirection[gMoveHistoryCtr] = 6;
            gMoveHistoryPos[++gMoveHistoryCtr] = *p2;
            gMoveHistoryDirection[gMoveHistoryCtr] = -1;
         } else {
            legalMove = false;
         }
      }
   } else {
      CanonPosition pStart,pTemp;
      long newDir;
      ++gMoveHistoryDirection[gMoveHistoryCtr];
      pStart = pTemp = gMoveHistoryPos[gMoveHistoryCtr];
      while (   (gMoveHistoryCtr>=0) && 
                     (gMoveHistoryDirection[gMoveHistoryCtr]>=6) ) {
         gMoveHistoryCtr-;
      }
      if (gMoveHistoryCtr>0) {
         newDir = gMoveHistoryDirection[gMoveHistoryCtr];
         pTemp.row += moveIncrement[newDir].row;
         pTemp.col += moveIncrement[newDir].col;
         if (!IsLegalPosition(&pTemp)) legalMove=false;
         else if (IsEmpty(b,pTemp.row,pTemp.col)) legalMove=false;
         else {
            pTemp.row += moveIncrement[newDir].row;
            pTemp.col += moveIncrement[newDir].col;
            if (!IsLegalPosition(&pTemp)) legalMove=false;
            else if (!IsEmpty(b,pTemp.row,pTemp.col)) legalMove=false;
            else {
               int i;
               for (i=0; i<=gMoveHistoryCtr; i++)
                  if (   (pTemp.row == gMoveHistoryPos[i].row) && 
                           (pTemp.col == gMoveHistoryPos[i].col) )
                      legalMove=false;
               if (legalMove) {
                  gMoveHistoryDirection[++gMoveHistoryCtr] = -1;
                  gMoveHistoryPos[gMoveHistoryCtr] = pTemp;
                  *p1 = gMoveHistoryPos[0];
                  *p2 = pTemp;
               }
            }
         }
      } else {
         legalMove=false;
      }
      
   }
   *doneWithThisDirection = (gMoveHistoryCtr<0);
   return legalMove;
}

/* multiplier to determine how much storage to reserves for moves for each piece */
#define kMemAllocFudge 12

EnumerateMoves
static long EnumerateMoves(CanonBoard b, long player, CanonPosition moveFrom[], CanonPosition moveTo[]) {
   long numMoves = 0;
   int piece,moveDir;
   Boolean legalMove,doneWithThisDirection;
   for (piece=0; piece<myNumPieces; piece++) {
      int pieceCounter=0;
      int firstPieceMoveIndex = numMoves;
      moveDir = 0;
      do {
         legalMove = CalcMove(b,player,piece,moveDir,
               &moveFrom[numMoves],&moveTo[numMoves],
               &doneWithThisDirection,6*myGameSize);
         if (doneWithThisDirection)
            ++moveDir;
         if (!legalMove) continue;
         if (numMoves>=kMemAllocFudge*myNumPieces-1) {
            DebugStr("\pnumMoves limit exceeded");
            break;
         } else {
            int i;
            for (i=firstPieceMoveIndex; i<numMoves; i++)
               if ( (moveTo[i].row==moveTo[numMoves].row) && 
                   (moveTo[i].col==moveTo[numMoves].col) )
                     legalMove = false;
            if (!legalMove) continue;
            ++numMoves;
         }
      } while (moveDir<6);
   }
   return numMoves;
}

MakeNextMove
/* 
 * Recursive routine to explore move tree.
 * MakeNextMove iterates over all possible moves for a player.
 * If ply limit is not yet reached, it recurses by calling for the next player.
 * Ply limit is decreased by 1 when the "me" player is called.
 * Recursion terminates when ply limit is reached.
 * Score is assigned on return based on the perspective of the player making the move.
 * Simple-minded score algorithm is used: 
 *   difference between player score and the best other player score, where
 *   a player's score is the number of spaces he is away from the final state
 * No alpha-beta pruning is employed - search is exhaustive.
 */

static long MakeNextMove(CanonBoard b, long me, long player, long playerDistances[6], long numPlys,
   Boolean firstTime, CanonPosition *from, CanonPosition *to) {
   long theMove,nextPlayer,numMoves,
               bestScore=0x7FFFFFFF, myBestDistance=0x7FFFFFFF;
   CanonPosition pFrom,pTo,bestFrom,bestTo;
   int newPlys;
   CanonPosition *moveFrom,*moveTo;

   /* allocate storage for possible moves */
   moveFrom = (CanonPosition *)
      malloc(kMemAllocFudge*myNumPieces*sizeof(CanonPosition));
   if (0==moveFrom) 
         DebugStr("\pproblem allocation moveFrom memory");
   moveTo = (CanonPosition *)
      malloc(kMemAllocFudge*myNumPieces*sizeof(CanonPosition));
   if (0==moveTo) 
         DebugStr("\pproblem allocation moveTo memory");
   
   /* prime best move with starting move */
   bestFrom = *from;
   bestTo = *to;
   /* enumerate all legal moves for this player */
   numMoves = EnumerateMoves(b,player,moveFrom,moveTo);
   /* examine all of the enumerated moves */
   for (theMove=0; theMove<numMoves; theMove++) {
      long opponent,scoreDifference,minOpponentDistance,
               myDistance,returnedDistances[6];
      int thePlayer;
      pFrom = moveFrom[theMove];
      pTo = moveTo[theMove];
      if (firstTime) {
         *from = pFrom;
         *to = pTo;
      }
      nextPlayer = (player+1)%myNumPlayers;
      newPlys = (player==me) ? numPlys-1 : numPlys;
      
      /* record move in the simulated board */
      MoveFromTo(b,&pFrom,&pTo,player);
      
      myDistance = PlayerDistFromGoal(player);
      
      /* recurse if ply limit not reached */
      if ( (newPlys>=0) && (myDistance>myMinDist) ){
         /* MakeNextMove returns each player's distance from the goal in 
            returnedDistances, and the score from nextPlayer's perspective in 
            returnScore.
            returnScore is ignored except by nonrecursive callers to MakeNextMove 
          */
         long returnScore;
         returnScore = 
               MakeNextMove(b, me, nextPlayer, returnedDistances, 
                           newPlys, false, from, to);
      } else /*if (player==me)*/ {
         /* terminating recursion, calculate position values for each player */
         /* compute distances for all players */
         for (thePlayer=0; thePlayer<myNumPlayers; thePlayer++)
            returnedDistances[thePlayer] = 
                     PlayerDistFromGoal(thePlayer);
      }
      /* compute best opponent score from this player perspective */
      for (thePlayer=0,minOpponentDistance=0x7fffffff; 
                     thePlayer<myNumPlayers; thePlayer++) {
         if (   (thePlayer != player) && 
            (returnedDistances[thePlayer]<minOpponentDistance) ) 
            minOpponentDistance = returnedDistances[thePlayer];
      }
      scoreDifference = 
            returnedDistances[player]-minOpponentDistance;
      /* Save score if it is the best for this player.
         This move is best if
         (1) our distance from goal minus best opponents distance is smallest, or
         (2) goal distance difference is equal, but our absolute distance is smallest, or
         (3) goal distance difference is equal, and coin flip says pick this move 
                                          (commented out) */
      if ( (scoreDifference < bestScore) ||
          ((scoreDifference==bestScore) && 
                  (returnedDistances[player]<myBestDistance)) /*||
((scoreDifference==bestScore) && ((rand()&0x0080)==1))*/ ) {
         bestScore = scoreDifference;
         myBestDistance = returnedDistances[player];
         for (opponent=0; opponent<myNumPlayers; opponent++)
      playerDistances[opponent] = returnedDistances[opponent];
         bestFrom = pFrom;
         bestTo = pTo;
      }
      /* reverse move to clear board for mext move */
      MoveFromTo(b,&pTo,&pFrom,player);
   }
   /* free dynamically allocated move storage */
   free(moveTo);
   free(moveFrom);
   
   /* return best move */
   *from = bestFrom;
   *to = bestTo;

   return bestScore;
}

FindBestMove
/* find best move for player me from this position on the board */
static long FindBestMove(CanonBoard b, long me, long numPlys, CanonPosition *from, CanonPosition *to) {
   long playerDistances[6];

   return MakeNextMove(b,me,me,playerDistances,numPlys,true,from,to);
}

InitChineseCheckers
void InitChineseCheckers(
   long numPlayers,      /* 2..6  */
   long gameSize, /* base of home triangle, 3..63, you have size*(size+1)/2 pieces */
   long playerPosition[6],   /* 0..5, entries 0..numPlayers-1 are valid */
   long yourIndex /* 0..numPlayers-1, your position is playerPosition[yourIndex] */
) {
   int i,numPositions;
   /* allocate memory for board */
   numPositions = 6*(1+gameSize)*4*(1+gameSize);
   myBoard = (char *)malloc(numPositions*sizeof(char));
   if (myBoard==0) DebugStr("\p could not allocate board");
   myNumPieces = gameSize*(gameSize+1)/2;
   myPositions = (PlayerPos *)
               malloc(6*myNumPieces*sizeof(PlayerPos));
   if (myPositions==0) 
               DebugStr("\p could not allocate myPositions");

   /* copy parameters */
   for (i=0;i<6; i++) myPlayerPosition[i] = playerPosition[i];
   myIndex = yourIndex;
   myNumPlayers = numPlayers;
   myGameSize = gameSize;
   /* initialize board */
   for (i=0; i<numPositions; i++) myBoard[i] = kEmpty;
   for (i=0; i<numPlayers; i++) {
      InitPlayer(myBoard,myPositions,i,playerPosition[i],gameSize);
   }
   
   /* calculate distance metric at goal position */
   for (i=1, myMinDist=0; i<gameSize; i++) myMinDist += i*(i+1);
}

YourMove
void YourMove(
   Position *fromPos,   /* originating position */
   Position *toPos   /* destination position */
) {
   CanonPosition from,to;
   long numPlys = kMaxPlys;
   FindBestMove(myBoard,myIndex,numPlys,&from,&to);
   MoveFromTo(myBoard,&from,&to,myIndex);
   *fromPos = ConvertCanonPositionToPosition(&from,myGameSize);
   *toPos = ConvertCanonPositionToPosition(&to,myGameSize);
}

OpponentMove
void OpponentMove(
   long opponent,   /* index in playerPosition[] of the player making move */
   Position fromPos,   /* originating position */
   Position toPos      /* destination position */
) {
   CanonPosition from,to;
   from = ConvertPositionToCanonPosition(&fromPos,myGameSize);
   to =   ConvertPositionToCanonPosition(&toPos,myGameSize);
   MoveFromTo(myBoard,&from,&to,opponent);
}

TermChineseCheckers
void TermChineseCheckers(void) {
   free (myPositions);
   free (myBoard);
}
 
AAPL
$116.47
Apple Inc.
+0.00
MSFT
$47.98
Microsoft Corpora
+0.00
GOOG
$537.50
Google Inc.
+0.00

MacTech Search:
Community Search:

Software Updates via MacUpdate

Cobook 3.0.7 - Intelligent address book....
Cobook Contacts is an intuitive, engaging address book. Solve the problem of contact management with Cobook Contacts and its simple interface and powerful syncing and integration possibilities.... Read more
StatsBar 1.9 - Monitor system processes...
StatsBar gives you a comprehensive and detailed analysis of the following areas of your Mac: CPU usage Memory usage Disk usage Network and bandwidth usage Battery power and health (MacBooks only)... Read more
Cyberduck 4.6 - FTP and SFTP browser. (F...
Cyberduck is a robust FTP/FTP-TLS/SFTP browser for the Mac whose lack of visual clutter and cleverly intuitive features make it easy to use. Support for external editors and system technologies such... Read more
Maya 2015 - Professional 3D modeling and...
Maya is an award-winning software and powerful, integrated 3D modeling, animation, visual effects, and rendering solution. Because Maya is based on an open architecture, all your work can be scripted... Read more
Evernote 6.0.1 - Create searchable notes...
Evernote allows you to easily capture information in any environment using whatever device or platform you find most convenient, and makes this information accessible and searchable at anytime, from... Read more
calibre 2.11 - Complete e-library manage...
Calibre is a complete e-book library manager. Organize your collection, convert your books to multiple formats, and sync with all of your devices. Let Calibre be your multi-tasking digital... Read more
Herald 5.0.1 - Notification plugin for M...
Note: Versions 2.1.3 (for OS X 10.7), 3.0.6 (for OS X 10.8), and 4.0.8 (for OS X 10.9) are no longer supported by the developer. Herald is a notification plugin for Mail.app, Apple's Mac OS X email... Read more
Firetask 3.7 - Innovative task managemen...
Firetask uniquely combines the advantages of classical priority-and-due-date-based task management with GTD. Stay focused and on top of your commitments - Firetask's "Today" view shows all relevant... Read more
TechTool Pro 7.0.6 - Hard drive and syst...
TechTool Pro is now 7, and this is the most advanced version of the acclaimed Macintosh troubleshooting utility created in its 20-year history. Micromat has redeveloped TechTool Pro 7 to be fully 64... Read more
PhotoDesk 3.0.1 - Instagram client for p...
PhotoDesk lets you view, like, comment, and download Instagram pictures/videos! (NO Uploads! / Image Posting! Instagram forbids that! AND you *need* an *existing* Instagram account). But you can do... Read more

Latest Forum Discussions

See All

Space Expedition Review
Space Expedition Review By Jordan Minor on November 24th, 2014 Our Rating: :: ONE SMALL STEPUniversal App - Designed for iPhone and iPad The only thing boring about Space Expedition’s lonely journey is its title.   | Read more »
Ubisoft Gives Everyone Two New Ways to E...
Ubisoft Gives Everyone Two New Ways to Earn In-Game Stuff for Far Cry 4 Posted by Jessica Fisher on November 21st, 2014 [ permalink ] | Read more »
Golfinity – Tips, Tricks, Strategies, an...
Dig this: Would you like to know what we thought of being an infinite golfer? Check out our Golfinity review! Golfinity offers unlimited ways to test your skills at golf. Here are a few ways to make sure your score doesn’t get too high and your... | Read more »
Dark Hearts, The Sequel to Haunting Meli...
Dark Hearts, The Sequel to Haunting Melissa, is Available Now Posted by Jessica Fisher on November 21st, 2014 [ permalink ] Universal App - Designed for iPhone and iPad | Read more »
Meowza! Toyze Brings Talking Tom to Life...
Meowza! | Read more »
Square Enix Announces New Tactical RPG f...
Square Enix Announces New Tactical RPG for Mobile, Heavenstrike Rivals. Posted by Jessica Fisher on November 21st, 2014 [ permalink ] With their epic stories and gorgeous graphics, | Read more »
Quest for Revenge (Games)
Quest for Revenge 1.0.0 Device: iOS Universal Category: Games Price: $4.99, Version: 1.0.0 (iTunes) Description: The great Kingdom of the west has fallen. The gods ignore the prayers of the desperate. A dark warlord has extinguished... | Read more »
Threadz is a New Writing Adventure for Y...
Threadz is a New Writing Adventure for You and Your Friends Posted by Jessica Fisher on November 21st, 2014 [ permalink ] In the tradition of round-robin storytelling, | Read more »
SteelSeries Stratus XL Hardware Review
Made by: SteelSeries Price: $59.99 Hardware/iOS Integration Rating: 4 out of 5 stars Usability Rating: 4.5 out of 5 stars Reuse Value Rating: 4.25 out of 5 stars Build Quality Rating: 4.5 out of 5 stars Overall Rating: 4.31 out of 5 stars | Read more »
ACDSee (Photography)
ACDSee 1.0.0 Device: iOS iPhone Category: Photography Price: $1.99, Version: 1.0.0 (iTunes) Description: Capture, perfect, and share your photos with ACDSee. The ACDSee iPhone app combines an innovative camera, a powerful photo... | Read more »

Price Scanner via MacPrices.net

CEA Study Finds More People Recycling Electro...
A new study by the Consumer Electronics Association (CEA) finds that electronics recycling receives the continued and growing support of consumers. According to the CEA,s Recycling and Reuse Study,... Read more
15″ 2.2GHz Retina MacBook Pro on sale for $17...
 B&H Photo has the 2014 15″ 2.2GHz Retina MacBook Pro on sale today for $1749. Shipping is free, and B&H charges NY sales tax only. B&H will also include free copies of Parallels Desktop... Read more
27-inch 3.5GHz 5K iMac in stock today and on...
 B&H Photo has the new 27″ 3.5GHz 5K iMac in stock today and on sale for $2299 including free shipping plus NY sales tax only. Their price is $200 off MSRP, and it’s the lowest price available... Read more
21-inch 1.4GHz iMac on sale for $979, save $1...
B&H Photo has the new 21″ 1.4GHz iMac on sale for $979.99 including free shipping plus NY sales tax only. Their price is $120 off MSRP. B&H will also include free copies of Parallels Desktop... Read more
13-inch 1.4GHz/256GB MacBook Air on sale for...
B&H Photo has lowered their price on the 13″ 1.4GHz/256GB MacBook Air to $1059.99 including free shipping plus NY sales tax only. Their price is $140 off MSRP, and it’s the lowest price for this... Read more
Save up to $400 with Apple refurbished 2014 1...
The Apple Store has restocked Apple Certified Refurbished 2014 15″ Retina MacBook Pros for up to $400 off the cost of new models. An Apple one-year warranty is included with each model, and shipping... Read more
New 13-inch 1.4GHz MacBook Air on sale for $8...
 Adorama has the 2014 13″ 1.4GHz/128GB MacBook Air on sale for $899.99 including free shipping plus NY & NJ tax only. Their price is $100 off MSRP. B&H Photo has the 13″ 1.4GHz/128GB MacBook... Read more
Apple Expected to Reverse Nine-Month Tablet S...
Apple and Samsung combined accounted for 62 percent of the nearly 36 million branded tablets shipped in 3Q 2014, according to early vendor shipment share estimates from market intelligence firm ABI... Read more
Stratos: 30 Percent of US Smartphone Owners t...
Stratos, Inc., creator of the Bluetooth Connected Card Platform, has announced results from its 2014 Holiday Mobile Payments Survey. The consumer survey found that nearly one out of three (30 percent... Read more
2014 1.4GHz Mac mini on sale for $449, save $...
 B&H Photo has lowered their price on the new 1.4GHz Mac mini to $449.99 including free shipping plus NY tax only. Their price is $50 off MSRP, and it’s the lowest price available for this new... Read more

Jobs Board

*Apple* Solutions Consultant (ASC) - Apple (...
**Job Summary** The ASC is an Apple employee who serves as an Apple brand ambassador and influencer in a Reseller's store. The ASC's role is to grow Apple Read more
*Apple* Solutions Consultant (ASC)- Retail S...
**Job Summary** The ASC is an Apple employee who serves as an Apple brand ambassador and influencer in a Reseller's store. The ASC's role is to grow Apple Read more
Project Manager, *Apple* Financial Services...
**Job Summary** Apple Financial Services (AFS) offers consumers, businesses and educational institutions ways to finance Apple purchases. We work with national and Read more
*Apple* Store Leader Program - College Gradu...
Job Description: Job Summary As an Apple Store Leader Program agent, you can continue your education as you major in the art of leadership at the Apple Store. You'll Read more
*Apple* Retail - Multiple Positions (US) - A...
Sales Specialist - Retail Customer Service and Sales Transform Apple Store visitors into loyal Apple customers. When customers enter the store, you're also the Read more
All contents are Copyright 1984-2011 by Xplain Corporation. All rights reserved. Theme designed by Icreon.