4.24 (Knight’s tour) A program that will move the knight around a chessboard. Th
ID: 3832559 • Letter: 4
Question
4.24 (Knight’s tour)
A program that will move the knight around a chessboard. The board is represented by an 8-by-8 double-subscripted array board. Each of the squares is initialized to zero. We describe each of the eight possible moves in terms of both their horizontal and vertical components. For example, a move of type O, consists of moving two squares horizontally to the right and one square vertically upward. Move 2 consists of moving one square horizontally to the left and two squares vertically upward. Horizontal moves to the left and vertical moves upward are indicated with negative numbers. The eight moves may be described by two single-subscripted arrays, horizontal and vertical, as follows:
horizontal [0] = 2
horizontal [1] = 1
horizontal [2] = -1
horizontal [3] = -2
horizontal [4] = -2
horizontal [5] = -1
horizontal [6] = 1
horizontal [7] = 2
Vertical [0] = -1
Vertical [1] = -2
Vertical [2] = -2
Vertical [3] = -1
Vertical [4] = 1
Vertical [5] = 2
Vertical [6] = 2
Vertical [7] = 1
Let the variables currentRow and currentCoIumn indicate the row and column of the knight's current position. To make a move of type moveNumber, where moveNumber is between O and 7, your program uses the statements,
currentRow += vertical [ moveNumber ];
currentCoIumn horizontal [ moveNumber ];
Keep a counter that varies from 1 to 64. Record the latest count in each square the knight moves to. Remember to test each potential move to see if the knight has already visited that square, and, of course, test every potential move to make sure that the knight does not land off the chessboard.
After attempting to write and run the knight’s tour program, next develop accessibility heuristic by classifying each of the squares according to how accessible they are and then always moving the knight to the square that is most inaccessible.Label a double-subscripted array accessibility with numbers indicating from how many squares each particular square is accessible. On the blank chessboard, each center square is rated 8, each corner square is rated 2 and the other squares have accessibility numbers of 3, 4 and 6 as follows:
23444432
34666643
46888864
46888864
46888864
46888864
34666643
23444432
Modify the program to run 64 tours.
Please do not use define 8!! Please write C++
Explanation / Answer
Program Plan:
1.Include header files
2.Declare variables
3.Ceate functions()
4.Initialise main() function
5.Display all moves moved by the night
Description
First of all,you need to have certain variables in c++ like int chess_Board[8][8];//chessboard 8 by 8 square board which gives 64 squares
In the question , they said that all the squares must be initialised to 0(zero),let us take a flg value
for moves as 1,to know that we have visited that square.
Next variable be
int currentRow;//as you know that it is a variable for a row
int currentColumn;//as you know that it is a variable for a column
we must take to count the moves a variable as moveCount=0;//to count the number of moves
Initiallly,we take that the knight is at 0th row &0th column
So,currentRow=0;
currentColumn=0;
chess_Board[0][0]=1;//Since,it is visited by knight
Now,we will make the moves as follows.We can take any moves
For Simplicity,let us take from initial
for(int moveNumber=0;moveNumber<8;moveNumber++)//this makes a loop that will perform an operation for the 8 by 8 squares
let us make every move to find that it is a valid move or not
if ( (currentRow+vertical[moveNumber]>=0)&&(currentRow+vertical[moveNumber]<=7)&&
(currentColumn+horizontal[moveNumber]>=0)&&(currentColumn+horizontal[moveNumber]<=7) )
We must check that the moves must not not be out of bound(i.e, must not be greater than eight(>8))
Now,we must ensure a statement that the square move we are moving is not visited
for that,
if(chess_Board[ currentRow+vertical [ moveNumber ] ] [ currentColumn+horizontal[ moveNumber ] ] !=1)
If the above conditions are true,then changing the currentRow and currentColumn and then restart(re-initialize)
moveNumber from 0 and increment moveCount as moveCount++.Then we will be certainly on a new square and then check all the eight moves
Finally,if no move exists(none of the 8 moves worked and the for loop ended that means there are no more unvisited moves(valid moves).
Output moveCount and find the number of moves you have made.
Program:
#include <iostream>
#include <iomanip>
#include <time.h>
#include "function.h";
using namespace std;
int main(void){
initialize();
int biggestCoverage = 0;
//initializing horizontal move of knight
horizontal[0] = 2;
horizontal[1] = 1;
horizontal[2] = -1;
horizontal[3] = -2;
horizontal[4] = -2;
horizontal[5] = -1;
horizontal[6] = 1;
horizontal[7] = 2;
//intializing vertical move of the knight
vertical[0] = -1;
vertical[1] = -2;
vertical[2] = -2;
vertical[3] = -1;
vertical[4] = 1;
vertical[5] = 2;
vertical[6] = 2;
vertical[7] = 1;
srand(time(NULL));
printf(" ");
while (biggestCoverage <= 55)//total number of coverages
{
initialize();
moveNumber = randomiseMovement();//taking random move
printf("Move randomised to: %d ", moveNumber);
printf(" );
printf("Initial position is: [%d][%d] ", currentRow, currentColumn);
do {
//First check if moveNumber position is valid or not
//Then move the knight accordingly
if (validOrNot(moveNumber))
moveKnight(moveNumber);
else if (isThereEmptyLocationAround())
{
moveNumber = randomiseMovement();
}
else
{
flag = -1;
}
} while (flag != -1);
m = printBoard();
printf(" Total move = %d",m);
printf(" Total Game Board = %d", totalGame);
if (m>biggestCoverage){
biggestCoverage = m;
copyRecordArray(chessBoard);
}
printf(" Best Move: %d ", biggestCoverage);
printRecordArray(recordHolder);
}
printf(" ");
cin.get();
}
Functions:
int totalGame=0;
int counter = 0;
//the array which holds the square
int recordHolder[8][8] = { 0 };
int flag = 0;//flag values
int moveNumber = 0;// moveNumberB1=0, moveNumberB2=0, moveNumberB3=0;
int m = 1;
//These two single subscript arrays will be used to move the knight as L shape according to array subscript
int horizontal[8];
int vertical[8];
//Knight's valid movement
//declare currrent position
int currentRow;//current row of knight
int currentColumn;//current column of knight
//8x8 Chessboard
int chessBoard[8][8] = { 0 };
#include "header.h"
void clearChessBoard(void){
int i, j;
for (i = 0; i < 8; i++)
{
for (j = 0; j < 8; j++)
{
chessBoard[i][j] = 0;
}
}
}
void initialize(){
flag = 0;
clearChessBoard();
currentColumn = rand() % 8;
currentRow = rand() % 8;
chessBoard[currentRow][currentColumn] = 1;
counter = 1, m = 0;
}
int randomiseMovement(void){
return rand() % 8;
}
int validOrNot(int mn){
return (
chessBoard[currentRow + vertical[mn]][currentColumn + horizontal[mn]] == 0
&&
(currentRow + vertical[mn]) >= 0
&&
(currentRow + vertical[mn])<8
&&
(currentColumn + horizontal[mn]) >= 0
&&
(currentColumn + horizontal[mn]) <8);
}
void moveKnight(int moveno){
currentRow += vertical[moveno];
currentColumn += horizontal[moveno];
//printf("Knight has moved to chessBoard[%d][%d]. ", currentRow, currentColumn);
counter++;
//printf("Move count is %d. ", counter);
chessBoard[currentRow][currentColumn] = counter;
}
int isThereEmptyLocationAround(){
int i;
for (i = 0; i < 8; i++)
{
if (validOrNot(i))
return 1;
}
return 0;
}
void printRecordArray(int b[][8]){
int i, j;
printf(" Biggest record array is: ");
printf(" ");
for (i = 0; i < 8; i++)
{
printf(" ");
for (j = 0; j < 8; j++)
{
printf("%2d ", b[i][j]);
}
}
printf(" ");
}
void copyRecordArray(int b[][8]){
int i, j;
for (i = 0; i < 8; i++)
{
for (j = 0; j < 8; j++)
{
recordHolder[i][j] = b[i][j];
}
}
}
int printBoard(void){
totalGame++;
int i, j,> printf(" ");
for (i = 0; i < 8; i++)
{
printf(" ");
for (j = 0; j < 8; j++)
{
printf("%2d ", chessBoard[i][j]);
if (chessBoard[i][j]>0)
onesCount++;
}
}
return onesCount;
}
Program in another way:
#include<iostream>
#include <iomanip>
#include<conio.h>
using namespace std;
int nextmove(int chess [][8],int table[][8],int hmoves[],int vmoves[],
int frow, int fcol);//horizontal moves,vertical moves,front row,front column
void knightmove(int chess[][8],int hmoves[],int vmoves[],int choice,
int knight,int *frow,int *fcol);
void printboard(int chess[][8]);
int main()
{
int choice;
int firstrow=1;
int firstcol=6;
int board[8][8]={0};
int accboard[8][8] ={
{2,3,4,4,4,4,3,2},
{3,4,6,6,6,6,4,3},
{4,6,8,8,8,8,6,4},
{4,6,8,8,8,8,6,4},
{4,6,8,8,8,8,6,4},
{4,6,8,8,8,8,6,4},
{3,4,6,6,6,6,4,3},
{2,3,4,4,4,4,3,2},
};
int moves =0;
int horizontal[8]={2,1,-1,-2,-2,-1,1,2};
int vertical[8]={-1,-2,-2,-1,1,2,2,1};
for(int i =0; i<63; i++){
choice=nextmove(board,accboard,horizontal,vertical
,firstrow,firstcol);
moves++;
knightmove(board,horizontal,vertical,choice
,moves,&firstrow,&firstcol);}
printboard(board);
return 0;
}
int nextmove(int chess [][8],int table[][8],int hmoves[],int vmoves[],
int frow,int fcol)
{
int startval=100;
int choice=-1;
int row,col;
for(int i=0;i<8;i++){
row = frow;
col = fcol;
row +=hmoves[i];
col +=vmoves[i];
if(row >=0 && row < 8 && col>=0 && col<8 && chess[row][col]==0)
{
if(table[row][col] < startval && table[row][col]!=0)
{
startval=table[row][col];
choice=i;
}
}
}return choice;
}
void knightmove(int chess[][8],int hmoves[],int vmoves[],int choice,
int knight,int *frow,int *fcol)
{
if(choice !=-1)
{
chess[*frow][*fcol]=+knight;
*frow +=hmoves[choice];
*fcol +=vmoves[choice];
if(knight==63)
{
knight++;
chess[*frow][*fcol]=64;
}
}
}
void printboard(int chess[][8])
{
for(int i=0;i<8;i++){
cout <<endl;
for(int j=0;j<8;j++)
cout <<setw(6)<< chess[i][j]; }
cout << endl;
}
Another way of approach:
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
//functions
int randomiseMovement(void);
int printBoard(void);
void clearChessBoard(void);
void copyRecordArray(int c[][8]);
void printRecordArray(int b[][8]);
int validOrNot(int mn);
void moveKnight(int moveno);
void initialize(void);
int isThereEmptyLocationAround();
int determineLowestAccessNumberedMove(int p, int s);
//these are declared here for each function to reach!
//These two single subscript arrays will be used to move the knight as L shape according to array subscript
int horizontal[8];
int vertical[8];
int iteration=0;
//declare currrent position
int currentRow;
int currentColumn;
//Movement counter
int count=0;
//chessboard
int chessBoard[8][8]={0};
//the array which holds the biggest record
int recordHolder[8][8]={0};
int flag=0;
int moveNumber=0;// moveNumberB1=0, moveNumberB2=0, moveNumberB3=0;
int m=1;
//access array must be declared globally so that everyfunction can access it!
int access[8][8]={
2, 3, 4, 4, 4, 4, 3, 2,
3, 4, 6, 6, 6, 6, 4, 3,
4, 6, 8, 8, 8, 8, 6, 4,
4, 6, 8, 8, 8, 8, 6, 4,
4, 6, 8, 8, 8, 8, 6, 4,
4, 6, 8, 8, 8, 8, 6, 4,
3, 4, 6, 6, 6, 6, 4, 3,
2, 3, 4, 4, 4, 4, 3, 2 };
//declare lookahead storage variable
int smlAccessNoEquals;
int main(void){
int biggestCoverage=0;
//initialize horizontal move of knight
horizontal[ 0 ] = 2;
horizontal[ 1 ] = 1;
horizontal[ 2 ] = -1;
horizontal[ 3 ] = -2;
horizontal[ 4 ] = -2;
horizontal[ 5 ] = -1;
horizontal[ 6 ] = 1;
horizontal[ 7 ] = 2;
//intialize vertical move of the knight
vertical[ 0 ] = -1;
vertical[ 1 ] = -2;
vertical[ 2 ] = -2;
vertical[ 3 ] = -1;
vertical[ 4 ] = 1;
vertical[ 5 ] = 2;
vertical[ 6 ] = 2;
vertical[ 7 ] = 1;
srand(time(NULL));
printf(" ");
while (biggestCoverage<64){
initialize();
moveNumber=randomiseMovement();
while(!validOrNot(moveNumber)){
moveNumber=randomiseMovement();
}
printf("Move randomised to: %d ", moveNumber);
printf(" ");
printf("Starting position is: [%d][%d] ", currentRow, currentColumn);
do {
//First check if moveNumber position is available
//Then move the knight accordingly
moveNumber=randomiseMovement();
while(!validOrNot(moveNumber)&&isThereEmptyLocationAround()){ //You have to check if there is empty location left!!!!
moveNumber=randomiseMovement();
}
moveNumber=determineLowestAccessNumberedMove(currentRow, currentColumn);
if(validOrNot(moveNumber))
moveKnight(moveNumber);
else if (isThereEmptyLocationAround())
{
moveNumber=randomiseMovement();
}
else
{
flag=-1;
}
//printBoard();
}
while (flag!=-1);
m=printBoard();
if(m>biggestCoverage){
biggestCoverage=m;
copyRecordArray(chessBoard);
}
printf(" Biggest Coverage: %d ", biggestCoverage);
printRecordArray(recordHolder);
}
printf(" ");
getch();
return 0;
}
int randomiseMovement(void){
return rand()%8;
}
void copyRecordArray(int b[][8]){
int i,j;
for (i = 0; i < 8; i++)
{
for (j = 0; j < 8; j++)
{
recordHolder[i][j]=b[i][j];
}
}
}
//is the move valid?
int validOrNot(int mn){
return (
chessBoard[currentRow+vertical[mn]][currentColumn+horizontal[mn]]==0
&&
( currentRow+vertical[mn] )>=0
&&
( currentRow+vertical[mn] )<8
&&
( currentColumn+horizontal[mn] ) >=0
&&
( currentColumn+horizontal[mn] ) <8
);
}
//move the knight
void moveKnight(int moveno){
printf("Subscript is %d ",moveno);
currentRow+=vertical[moveno];
currentColumn+=horizontal[moveno];
printf("Knight has moved to chessBoard[%d][%d]. ",currentRow,currentColumn);
count++;
printf("Move count is %d. ",count);
chessBoard[currentRow][currentColumn]=count;
}
//check if it exists empty location
int isThereEmptyLocationAround(){
int i;
for (i = 0; i < 8; i++)
{
if(validOrNot(i))
return 1;
}
return 0;
}
//print board
int printBoard(void){
int i,j,onesCount=0;
printf(" ");
for (i = 0; i < 8; i++)
{
printf(" ");
for (j = 0; j < 8; j++)
{
printf("%2d ", chessBoard[i][j]);
if(chessBoard[i][j]>0)
onesCount++;
}
}
return onesCount;
}
void printRecordArray(int b[][8]){
int i,j;
printf(" Biggest recorded array is: ");
printf(" ");
for (i = 0; i < 8; i++)
{
printf(" ");
for (j = 0; j < 8; j++)
{
printf("%2d ", b[i][j]);
}
}
printf(" ");
}
//clears the board before each iteration
void clearChessBoard(void){
int i,j;
for (i = 0; i < 8; i++)
{
for (j = 0; j < 8; j++)
{
chessBoard[i][j]=0;
}
}
}
//resets the board
void initialize(void){
iteration++;
printf("%d th ITERATION",iteration);
flag=0;
clearChessBoard();
currentColumn=randomiseMovement();
currentRow=randomiseMovement();
printf("Current Row, Current Column is: [%d][%d] ",currentRow, currentColumn);
chessBoard[currentRow][currentColumn]=1;
count=1,m=0;
}
//without equality checking the lowest move
int determineLowestAccessNumberedMove(int cRow, int cCol){
int i;
int smlAccessNo=moveNumber;
smlAccessNoEquals=-1;
for (i = 0; i < 8; i++)
{ //determine the smallest subscript
if(validOrNot(i) && ((access[cRow+vertical[i]][cCol+horizontal[i]])<(access[cRow+vertical[smlAccessNo]] [cCol+horizontal[smlAccessNo]])))
smlAccessNo=i;
}
//check if there is another move equal to smallest access value and check if it is valid and then store it in smlAccessNoEquals variable
for (i = 0; i < 8; i++)
{
if (access[cRow+vertical[i]][cCol+horizontal[i]]==access[cRow+vertical[smlAccessNo]][cCol+horizontal[smlAccessNo]] && (i!=smlAccessNo) && ( cRow+vertical[i] )>=0
&& ( cRow+vertical[i] )<8 && ( cCol+horizontal[i] ) >=0 && ( cCol+horizontal[i] ) <8 && chessBoard[cRow+vertical[i]][cCol+horizontal[i]] == 0)
{
smlAccessNoEquals=i;
}
}
if(smlAccessNoEquals!=-1 && lookAhead(smlAccessNoEquals)<lookAhead(smlAccessNo))
return smlAccessNoEquals;
else
return smlAccessNo;
}
//looks ahead one move and choses accordingly
int lookAhead(int number){
int i;
int temporaryLookAheadRow;
int temporaryLookAheadColumn;
int temp=number;
int lookAheadSmlAccessNo=-1;
temporaryLookAheadRow=currentRow+vertical[number];
temporaryLookAheadColumn=currentColumn+horizontal[number];
for (i = 0; i < 8; i++)
{
if ( chessBoard[temporaryLookAheadRow+vertical[i]][temporaryLookAheadColumn+horizontal[i]] == 0 && access[temporaryLookAheadRow+vertical[i]][temporaryLookAheadColumn+horizontal[i]] < access[temporaryLookAheadRow+vertical[number]][temporaryLookAheadColumn+horizontal[number]]
&& ( temporaryLookAheadRow+vertical[i] )>=0 //check if valid
&& ( temporaryLookAheadRow+vertical[i] )<8 && ( temporaryLookAheadColumn+horizontal[i] ) >=0 && ( temporaryLookAheadColumn+horizontal[i] ) <8)
{
number=i;
}
}
if(number!=temp)
return access[temporaryLookAheadRow+vertical[number]][temporaryLookAheadColumn+horizontal[number]] ;
else return access[temporaryLookAheadRow+vertical[temp]][temporaryLookAheadColumn+horizontal[temp]];
}
Sample Output:
0 0 0 19 8 0 0 37
Total move = 37
Total Game Board = 10
Best Move: 46
Biggest recorded array is:
0 29 34 0 26 31 0 0
0 4 27 30 33 0 25 12
28 35 0 3 38 13 32 0
5 0 37 14 0 2 11 24
36 15 6 39 18 23 0 1
0 42 17 22 7 10 45 0
16 21 40 0 44 19 8 0
41 0 43 20 9 0 0 46
Move randomised to: 3
Starting position is: [5][3]
0 0 43 26 47 6 21 0
44 25 46 0 0 27 48 7
0 42 0 24 5 20 0 22
14 45 0 0 28 23 8 33
41 2 13 4 19 34 29 0
0 15 18 1 12 9 32 37
17 40 3 0 35 38 11 30
0 0 16 39 10 31 36 0
Total move = 48
Total Game Board = 11
Best Move: 48
Biggest recorded array is:
0 0 43 26 47 6 21 0
44 25 46 0 0 27 48 7
0 42 0 24 5 20 0 22
14 45 0 0 28 23 8 33
41 2 13 4 19 34 29 0
0 15 18 1 12 9 32 37
17 40 3 0 35 38 11 30
0 0 16 39 10 31 36 0
Move randomised to: 3
Starting position is: [0][6]
0 0 0 10 0 0 1 32
0 11 0 0 2 29 0 0
0 0 3 12 9 0 31 0
4 0 22 0 30 13 28 0
23 0 5 0 0 8 0 14
18 0 24 21 6 15 0 27
0 0 19 16 25 0 7 0
0 17 0 0 20 0 26 0
Total move = 32
Total Game Board = 12
Best Move: 48
Biggest recorded array is:
0 0 43 26 47 6 21 0
44 25 46 0 0 27 48 7
0 42 0 24 5 20 0 22
14 45 0 0 28 23 8 33
41 2 13 4 19 34 29 0
0 15 18 1 12 9 32 37
17 40 3 0 35 38 11 30
0 0 16 39 10 31 36 0
Move randomised to: 2
---------------------------------------------------------
Starting position is: [4][1]
0 0 12 0 4 0 0 0
11 0 3 0 0 20 23 0
2 13 0 31 0 5 0 21
0 10 0 0 0 22 19 24
14 1 32 9 30 25 6 0
33 0 15 26 0 8 37 18
0 27 0 35 16 29 0 7
0 34 0 28 0 36 17 38
Total move = 38
Total Game Board = 13
Best Move: 48
Biggest recorded array is:
0 0 43 26 47 6 21 0
44 25 46 0 0 27 48 7
0 42 0 24 5 20 0 22
14 45 0 0 28 23 8 33
41 2 13 4 19 34 29 0
0 15 18 1 12 9 32 37
17 40 3 0 35 38 11 30
0 0 16 39 10 31 36 0
Move randomised to: 5
------------------------------------------------------------------
Starting position is: [0][5]
0 15 0 0 0 1 12 0
0 0 0 14 11 0 0 0
6 0 16 0 2 13 0 0
0 0 7 0 17 10 0 0
0 5 0 3 8 0 18 0
0 0 0 0 0 0 9 0
0 0 4 0 0 19 0 0
0 0 0 0 0 0 0 20
Total move = 20
Total Game Board = 14
Best Move: 48
Biggest recorded array is:
0 0 43 26 47 6 21 0
44 25 46 0 0 27 48 7
0 42 0 24 5 20 0 22
14 45 0 0 28 23 8 33
41 2 13 4 19 34 29 0
0 15 18 1 12 9 32 37
17 40 3 0 35 38 11 30
0 0 16 39 10 31 36 0
Move randomised to: 0
----------------------------------------------------------------------
Starting position is: [5][3]
0 6 15 0 0 0 0 32
0 0 0 5 14 31 22 0
7 0 0 16 23 4 13 0
0 0 24 0 12 21 30 3
25 8 11 0 17 2 0 0
10 0 26 1 0 0 20 29
0 0 9 0 27 18 0 0
0 0 0 0 0 0 28 19
Total move = 32
Total Game Board = 15
Best Move: 48
Biggest recorded array is:
0 0 43 26 47 6 21 0
44 25 46 0 0 27 48 7
0 42 0 24 5 20 0 22
14 45 0 0 28 23 8 33
41 2 13 4 19 34 29 0
0 15 18 1 12 9 32 37
17 40 3 0 35 38 11 30
0 0 16 39 10 31 36 0
Move randomised to: 2
-------------------------------------------------
Starting position is: [4][7]
42 0 0 0 0 3 32 0
0 0 41 4 33 0 9 18
0 5 34 0 8 17 2 31
35 0 7 40 0 10 19 16
6 39 0 0 26 15 30 1
23 36 0 14 11 20 27 0
38 13 22 25 0 0 0 29
0 24 37 12 21 28 0 0
Total move = 42
Total Game Board = 16
Best Move: 48
Biggest recorded array is:
0 0 43 26 47 6 21 0
44 25 46 0 0 27 48 7
0 42 0 24 5 20 0 22
14 45 0 0 28 23 8 33
41 2 13 4 19 34 29 0
0 15 18 1 12 9 32 37
17 40 3 0 35 38 11 30
0 0 16 39 10 31 36 0
Move randomised to: 3
------------------------------------------------------
Starting position is: [4][7]
0 0 14 0 24 11 0 0
15 4 25 12 0 0 0 10
26 13 16 3 32 23 0 0
37 0 5 0 17 2 9 22
0 27 36 31 0 33 18 1
0 30 0 6 35 8 21 0
0 0 28 0 0 0 34 19
29 0 0 0 7 20 0 0
Total move = 37
Total Game Board = 17
Best Move: 48
Biggest recorded array is:
0 0 43 26 47 6 21 0
44 25 46 0 0 27 48 7
0 42 0 24 5 20 0 22
14 45 0 0 28 23 8 33
41 2 13 4 19 34 29 0
0 15 18 1 12 9 32 37
17 40 3 0 35 38 11 30
0 0 16 39 10 31 36 0
Move randomised to: 2
-----------------------------------------------------------------
Starting position is: [5][0]
0 0 0 0 0 19 0 0
0 0 3 18 0 0 0 0
4 0 0 0 20 0 0 0
0 2 5 0 17 0 0 8
12 0 0 21 6 9 24 0
1 28 13 10 23 16 7 0
0 11 22 27 14 0 0 25
29 0 0 0 0 26 15 0
Total move = 29
Total Game Board = 18
Best Move: 48
Biggest recorded array is:
0 0 43 26 47 6 21 0
44 25 46 0 0 27 48 7
0 42 0 24 5 20 0 22
14 45 0 0 28 23 8 33
41 2 13 4 19 34 29 0
0 15 18 1 12 9 32 37
17 40 3 0 35 38 11 30
0 0 16 39 10 31 36 0
Move randomised to: 0
-----------------------------------------------------------------------------
Starting position is: [3][0]
36 33 0 0 14 55 4 0
0 0 35 32 3 24 15 56
34 37 2 25 16 13 54 5
1 26 17 50 31 6 23 44
18 49 38 7 42 45 12 53
27 8 19 46 51 30 43 22
48 39 28 9 20 41 52 11
0 0 47 40 29 10 21 0
Total move = 56
Total Game Board = 19
Best Move: 56
Biggest recorded array is:
36 33 0 0 14 55 4 0
0 0 35 32 3 24 15 56
34 37 2 25 16 13 54 5
1 26 17 50 31 6 23 44
18 49 38 7 42 45 12 53
27 8 19 46 51 30 43 22
48 39 28 9 20 41 52 11
0 0 47 40 29 10 21 0
Related Questions
drjack9650@gmail.com
Navigate
Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.