c++- Please helmp me with making a "Moles and Mazes" program

I just started to learn arrays in my Computer Science class. Well now I have to write a game called "Moles and Mazes." The mole is in a grid with 8 rows and 8 columns. The mole starts his adventure at row 3, column 2. The escape route is at row 3, column nine.

The program will generate a random number between 1 and 4(I know how to do that). Number 1=right, 2=up, 3=left, 4=down. (I know how to do this, I think. I was going to try and use a case statement, or an if statement.

I do not know how to begin the program though, and here is why. The program is supposed to play 500 games and print out each escape path using a coordinate system (3, 2) (3,4) (4,4)..... (3,9)

The next part says to store the game paths in two separate one dimensional arrays named row and column.

So basically I don't know how to make it play a max of 500 games and display how many games were won and how the mole achieved to win(show the coordinates). I also don't know how to score the escape path into the two arrays. Can someone please help me get started with this? I usually post my code when I have a question but this one has me stuck. Thank you!

Have you covered Classes in your course yet? If so, you could create a Path class which consists of Xs and Ys, and create an array which stores Path objects. You'd probably have to use a vector, though, to avoid wasting mass amounts of memory, unless you maybe only stored a single path before printing it to file. Have you learned file I/O yet? I think that would be the most sensible way to attack this problem.

But I mean, if you were to use ONLY straight-up arrays, one for keeping track of all Xs and one for all Ys, I really have no clue how to come up with a practical solution. If you haven't covered dynamic memory, vectors, printing to file yet, you've got some serious issues to grapple with. How could you account for the fact that any one run through the maze has the potential to last an infinite (theoretically, IRL at least a large) number of turns?

I'm thinking we're misunderstanding the specifics of the question. Could you post it exactly as your prof has it worded?

PS: Don't forget to create a wall. You won't get through one round if you don't have a wall.

Thanks for the reply, we have not covered classes or vectors or pointers. I forgot to mention that if you go behind column 1, beyond column 8, above row 1, or below row 8, the mole falls of the "grid" and the game is over. So the only way the mole wins is if he ends up in row 3, column 9. But like I said if he ends up in column 9 but in anything other than row 3, he falls off the grid. so basically row 0, row 9, column 0, and column 9(other than column 9, row 3) the game is over and a new one starts.

So right now I'm trying to start writing the program. I can't even figure out how to declare the starting position. How do I declare a starting position of row 3 AND column 2? Thanks

Oh I re-read your post and I get it... ya.. did you learn ofstream yet?

Quote:

---

Originally Posted by IKnew

Oh I re-read your post and I get it... ya.. did you learn ofstream yet?

---

No, were basically supposed to do this with some if's and some arrays.

Why not start off with a simplified version, whereby the number of moves per game is restricted to say 100, else failed attempt. Then you can easily get started with one-dimensional arrays.

Create your main loop zero to 499.
Initialize arrays to zero.
Start position row[0] = 3, col[0] = 2.
Create an inner loop one to 99.
Test direction.
Move accordingly, col[j] = col[j-1] + 1;
Test for boundary.
Test for successful attempt.
Print out number of failed attempts and successful sequence.

Thanks. Can you tell me what initializing the array to zero is actually doing? Isn't that saying that I'm reserving 0 spots to store data into the array?

Start position: row[0] = 3, col[0] = 2 index 0 of row array contains value 3
Move right: row[1] = 3, col[1] = 3
Move right: row[2] = 3, col[2] = 4
move down: row[3] = 4, col[3] = 4
Move right: row[4] = 4, col[4] = 5
Move right: row[5] = 4, col[5] = 6
Move right: row[6] = 4, col[6] = 7
Move up: row[7] = 3, col[7] = 7
Move left: row[8] = 3, col[8] = 6
Move right: row[9] = 3, col[9] = 7
Move right: row[10] = 3, col[10] = 8 successful attempt.

Attempt number 1 of 500 might last 25 moves and then fail, so the array will hold 25 values. If the second run is successful in 12 moves and you didn’t clean out the array before hand, then you will print out the 12 successful moves followed by the last 13 failed attempts.

So all those values need to reset to zero.

Just declare your arrays after the main loop and before the shorter loop is the simplest way.

Here is my attempt so far. I am wondering if someone can look this over and just let me know if i'm even on the right track. I have a few concerns;

1; My random number generator I believe is flawed because it just goes from one to 4 in order and it displays like a hundred of each, I believe I can fix that pretty easily but I'm wondering if it's in the right spot at ;east.

2. I don't know how to allow the column to go into row 9 and make it win only if it's at row three.

3. How am I going to make it print only the winning games coordinates to the screen?

Thank you guys for your help!

Code:

---

#include<iostream>
#include<ctime>
using namespace std;
int main()
{

        int row[8] = {1, 2, 3, 4, 5, 6, 7, 8};
        int column[9] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
        int rowstart = 3;
        int columnstart = 2;
        int r, k, c, e;
       
       
        for(int i = 0; i < 500; i++)
        {
                r = rowstart;
                c = columnstart;
               
               

                while(r < 8 || c < 8)
                {
                srand(time(NULL));
                k = rand() % 5;
               
                switch(k)
                  {
                case 1:
                column[c+1];
                case 2:
                row[r - 1];
                case 3:
                column[c - 1];
                case 4:
                row[r + 1];

                cout << k << endl;
                  }
                }
        }
       
                system("pause");
                return 0;
        }

---

You should be including <cstdlib> to use srand() and rand().

First thing, decide whether your grid is 8X8 or 9X9, you keep changing.

Now on a piece of paper, draw a grid like a chessboard, 8x8.

Now number the squares along the top from 1 to 8 going from left to right.
Now number the squares on the left side from 1 to 8 going from top to bottom.

We can reference the top left square with the coordinate (1,1).
We can reference the top right square with the coordinate (1,8).
We can reference the bottom left square with the coordinate (8,1), etc.

We can reference the starting position of your mole with the coordinates (3,2).

I’m assuming you are going to keep this simple to start off, and not dynamically allocating memory for your arrays, and you are restricting the number of moves per game to say 100.

Code:

---

int row[100] = {0};
int col[100] = {0};

row[0] = 3;
col[0] = 2;

---

The first occurrence of your row array, index 0, holds the start position 3.
The first occurrence of your col array, index 0, holds the start position 2.

Put a mark on your diagram at position (3,2).

Now if we get a random number 1 then we will move 1 square to the right.
So mark the new position on your diagram as (3,3).
So now the second occurrence of your array row[1] = 3 and col[1] = 3.

Now if we get a random number 2 then we will move 1 square up.
So mark the new position on your diagram as (2,3).
So now the second occurrence of your array row[2] = 2 and col[2] = 3.

So in a loop, if j = 0, then row[j] = 3 and col[j] = 2.
So in a loop, if j = 1, then row[j] = 3 and col[j] = 3.
So in a loop, if j = 2, then row[j] = 2 and col[j] = 3 etc.

So we can plot the movement as (3,2) (3,3) (2,3) etc.

Now if we now get a random number 1 then we will move 1 square to the right.

Put a mark on your diagram at new position (2,4)

So now j = 3 in loop, and value in row[3] stays the same as value in row[2], so row[j] = row[j-1].
And value in col[3] = value in col[2] incremented by 1, so co[j] = col[j-1] + 1.

So your inner loop might look like this if you used a for loop:

Code:

---

for (int j = 1; j < 100; j++)
{
    move = rand() % 4 + 1;
    if (move == 1)  //move right
    {
        row[j] = row[j-1];
        col[j] = col[j-1] + 1;
        if (col[j] > 8 )
        {
            break; // outside right boundary
        }
    }

---

Michael, I cannot thank you enough for all your help. I took your advice and came up with some code. It compiles and everything, but when I print the random numbers to the screen, it displays like a hundred of each number before moving to the next number, I'm pretty sure it does this because it can only generate one new random number per second, so for one second it prints that one random number a bunch of times. Is there anyway to fix that? Below is my code, can you please tell me if I'm on the right track so far? Thank you guys again!!

P.S. When I loop it and the row does not change, why is it row[j] = row[j - 1]. Where does the -1 come from? Is it because the spot in the array is one less than j because the array starts at zero and not one?

Code:

---

#include<iostream>
#include<ctime>
using namespace std;
int main()
{

        int row[100] = {0};
        int column[100] = {0};
        int rowstart = 3;
        int columnstart = 2;
        int k;
       
       
        for(int i = 0; i < 500; i++)
        {
                row[0] = 3;
                column[0] = 2;
               
               

                for(int j = 0; j < 100; j++)
                {
                        srand(time(NULL));
                        k = rand() % 4 + 1;
                        cout << k << endl;
                        if (k ==1 ) // Move Right
                        {
                                row[j] = row[j-1];
                                column[j] = column[j-1] + 1;
                        }
                        else if(k==2) //Move Up
                        {
                                row[j] = row[j-1] - 1;
                                column[j] = column[j-1];
                        }

                        else if(k==3) // Move Left
                        {
                                row[j]= row[j-1];
                                column[j]= column[j-1] - 1;
                        }

                        else { // move down
                                        row[j] = row[j - 1] + 1;
                                        column[j] = column[j - 1];
                        }

                }
        }
                system("pause");
                return 0;
        }

---

Call to srand() goes at start of program before the loops.

Make sure you understand what the rand statement is doing.

I noticed you coded rand() % 5.

When rand() returns a value of 10, then 10 divided by 5 = 2, remainder = 0.
When rand() returns a value of 14, then 14 divided by 5 = 2, remainder = 4.

0 to 4 = 5 possibilities but we only want 4 possibilities.

Whilst rand() % 4 + 1:

When rand() returns a value of 11, then 11 divided by 4 = 2, remainder = 3. and 3 + 1 = 4
When rand() returns a value of 8, then 8 divided by 4 = 2, remainder = 0, and 0 + 1 = 1.

1 to 4 = 4 possibilities.

Call to srand() goes at start of program before the loops.
Call to rand() goes within the inside loop.

*

How to print out winning sequences?

If ( move == 4)
Do move down stuff
if (row[j] == 3 && col[j] == 8)
loop to print out array from row[0], col[0] to row[max], col[max] where max = J + 1. (J+1 because we assigned start position 3,2 before the j loop)

Here’s a winning sequence of 6 moves:

(3,2), and (3,3) (3,4) (3,5) (3,6) (3,7) (3,8)

We store these values in our array thus:

Row[0] = 3, col[0] = 2
Row[1] = 3, col[1] = 3
Row[2] = 3, col[2] = 4
Row[3] = 3, col[3] = 5
Row[4] = 3, col[4] = 6
Row[5] = 3, col[5] = 7
Row[6] = 3, col[6] = 8
Row[7] = 0, col[7] = 0 etc etc

Row[99] = 0, col[99] = 0

And print out successful sequence using loop 0 to 6


*

row[j] = row[j - 1] because row[j], which is initialized to 0, now holds the same value as the move before, row[j-1].

*

Don’t forget to check for boundary’s if (row[j] < 1)

I’m happy to be of help, but I want you to understand it.

I'm sorry for sounding so ignorant about all this, but I really do not understand much of what you are saying. I still cannot figure out where the j-1 comes from.
I also don't know why row[7] = 0, column[7] = 0. I also tried to make a loop to loop and print all of the winning games but that didn't go well either. Here is what I'm trying

Code:

---

if(row[j] == 3 && column[j] == 9)
                        {
                        for (j = 0; j < 100 + 1; j++)
                                cout << row[j] << "," << column[j] << endl;
                    }

---

I also don't know why it wins if row[j] = 3 and column[j] = 8. Isn't the column supposed to be column[j] = 9? Again thank you for your help!

Quote:

---

Originally Posted by nick753

I also don't know why it wins if row[j] = 3 and column[j] = 8. Isn't the column supposed to be column[j] = 9? Again thank you for your help!

---

He misunderstood your set-up. He is treating the whole grid like a perfect square, where one of the gridspaces on the outside edge is the exit point, rather than having one extra square "hanging loose". You need to give the grid 9 columns, but remember to treat all but one of the gridsquares in that column as off the map. You could account for this with something to the effect of:

Code:

---

if (COLUMN == 9 && ( ROW < 3 || ROW > 3) ) { Fail; }

---

Here is my most up to date code. It runs but it doesn't give me any winning output. Right now I have it set to just display 3,9 every time it wins because I don't know how to make it display the whole path. Also, I still don't know what row[j] = row[j-1] means. Again, any help is appreciated! Please help me find errors:

Code:

---

#include<iostream>
#include<ctime>
using namespace std;
int main()
{

        int row[100] = {0};
        int column[100] = {0};
        int rowstart = 3;
        int columnstart = 2;
        int k;
       
       
        for(int i = 0; i < 500; i++)
        {
                row[0] = 3;
                column[0] = 2;
               
               

                for(int j = 0; j < 100; j++)
                {
                        srand(time(NULL));
                        k = rand() % 4 + 1;
                       
                        if (k ==1 ) // Move Right
                        {
                                row[j] = row[j-1];
                                column[j] = column[j-1] + 1;
                        }
                        else if(k==2) //Move Up
                        {
                                row[j] = row[j-1] - 1;
                                column[j] = column[j-1];
                        }

                        else if(k==3) // Move Left
                        {
                                row[j]= row[j-1];
                                column[j]= column[j-1] - 1;
                        }

                        else { // move down
                                        row[j] = row[j - 1] + 1;
                                        column[j] = column[j - 1];
                        }
                       
                        if(row[j] < 1 || row[j] > 8)
                        {
                      row[0] = 3;
                      column[0] = 2;
            }
           
            else if ( column[j] > 8 && row[j] != 3)
                {
                    row[0] = 3;
                    column[0] = 2;
                    }
                   
            else if(column[j] == 9 && row[j] == 3)
            {
                cout << row[j] << column[j];
            }
           
            else if(column[j] < 1)
            {
            row[0] = 3;
            column[0] = 2;
            }
                }
        }
                system("pause");
                return 0;
        }

---

Quote:

---

Originally Posted by nick753

Here is my most up to date code. It runs but it doesn't give me any winning output. Right now I have it set to just display 3,9 every time it wins because I don't know how to make it display the whole path. Also, I still don't know what row[j] = row[j-1] means.

---

Every gridspace has two coordinates, ROW and COLUMN. The moves are stored in corresponding slots of both ROW and COLUMN arrays, namely slot J, where J is the number of completed iterations. By referring to slot [J - 1], you are calling on the coordinates of the previous move. This is useful because it allows you to calculate the present location relatively, instead of being forced to use absolute values. Here is a brief illustration:

Move #0: J = 0: Coordinates are (3,2).
Move #1: J = 1: (let's say the mole moves to the right.) Relative coordinates are (+1,0) We take the coordinates from J-1 (which is 0), and add to them the new relative coordinates, you get (4,2).
Move #2: J = 2: (mole moves up). Relative coordinates are (0,+1). Take coordinates from J-1 and add to them the relative coordinates. You get (4,3).

Hopefully that's cleared up! Now, to print the whole path, you just have to create a for() loop that runs indefinitely until the coordinates of slot [ i ] are the winning coordinates.

Code:

---

for (int i = 0; /*blank*/ ; i++) {
cout << row[i] << "," << column[i] << endl;
if (row[i] == 3 && column[i] == 9)
    break;
}

---

Thank you, Frog! I do understand now why j-1 makes sense! By looking at my code, can you tell me if I had the right idea about resetting the starting points if it goes outside the boundaries? I'm thinking that may be my program doesn't work properly? Thank you!

You’re doing fine, keep going, I’m not very good at explaining things, lol.

Ok, so it’s an 8*8 grid and if the mole is at position (3,8) and the next move is to the right, then he reaches the escape square 3,9.

Thanks frog.

Here’s some code that works. I’ve tried to keep it simple by checking for a successful attempt at the end rather than in the check move right code, and no else statements.

Ignore the counters, cnt_fr (failed right) etc.

Understanding j-1 is the most important part, so keep asking until you really get it.

Code:

---

srand((unsigned)time(0));

for (int i = 0; i < 500; i++)
{
    int row[100] = {0};
    int col[100] = {0};
    row[0] = 3;
    col[0] = 2;

    for (int j = 1; j < 100; j++) //
    {
        move = rand() % 4 + 1;
        if (move == 1)  //move right
        {
            row[j] = row[j-1];
            col[j] = col[j-1] + 1;
            //if (col[j] > 8 )
            if ((col[j] > 8) && (row[j] != 3))
            {
                cnt_fr = cnt_fr + 1;
                break; // outside right boundary
            }
        }
        if (move == 2) // move up
        {
            row[j] = row[j-1] - 1;
            col[j] = col[j-1];
            if (row[j] < 1)
            {
                cnt_fu = cnt_fu + 1;
                break;
            }
        }
        if (move == 3) // move left
        {
            row[j] = row[j-1];
            col[j] = col[j-1] - 1;
            if (col[j] < 1)
            {
                cnt_fl = cnt_fl + 1;
                break;
            }
        }
        if (move == 4) // move down
        {
            row[j] = row[j-1] + 1;
            col[j] = col[j-1];
            if (row[j] > 8)
            {
                cnt_fd = cnt_fd + 1;
                break;
            }
        }
        //if (row[j] == 3 && col[j] == 8)
        if (row[j] == 3 && col[j] == 9)

---

Michael, I see after the mole crosses a boundary you have a break statement. Will the break statement reset the mole at the beginning coordinates then make the mole start a new game?

Yes.

But, the break statement simply breaks out of the current loop.

In the above code the next statement to be executed would be the main for loop with i incremented by 1, and off we go again.

Not that I am anything beyond a beginner here, but shouldn't he be using a 10x10 grid. With 0 and 9 being out of bounds and 1-8 being the grid itself?

I think the problem is a silly one as well, since as someone pointed out right away you could infinately move around within the grid without either falling out or exiting... Your teacher should clarify this.

Quote:

---

Originally Posted by Michael432000

Yes.

But, the break statement simply breaks out of the current loop.

In the above code the next statement to be executed would be the main for loop with i incremented by 1, and off we go again.

---

So would it be better for me to put in break statements instead of the method I'm using?

Here is my latest code guys. While looking through it I noticed something. Where in the heck in my program is it saying what size the grid needs to be? I would have thought to put it inside the brackets of row[] and column[], but someone said to put 100 in there to make that the number of moves it makes. So where/how would I go about setting up my grid size?? My program as of now seems like it makes sense, but it never prints out when it escapes, but that's probably because no grid is set up? Please take a look at tell me what you think. Thanks for the help!

Code:

---

#include<iostream>
#include<ctime>
using namespace std;
int main()
{

    int row[100] = {0};
    int column[100] = {0};
    int rowstart = 3;
    int columnstart = 2;
    int k;
   
   
    for(int i = 0; i < 500; i++)
    {
        row[0] = 3;
        column[0] = 2;
       
       

        for(int j = 0; j < 100; j++)
        {
            srand(time(NULL));
            k = rand() % 4 + 1;
           
            if (k ==1 ) // Move Right
            {
                row[j] = row[j-1];
                column[j] = column[j-1] + 1;
                if(column[j] > 8 && row[j] != 3) { break; }
            }
            else if(k==2) //Move Up
            {
                row[j] = row[j-1] - 1;
                column[j] = column[j-1];
                if(row[j] < 1) { break; }
            }

            else if(k==3) // Move Left
            {
                row[j]= row[j-1];
                column[j]= column[j-1] - 1;
                if(column[j] < 1) { break;}
            }

            else { // move down
                    row[j] = row[j - 1] + 1;
                    column[j] = column[j - 1];
                    if(row[j] > 8) { break; }
                }
           
           
                   
            if(column[j] == 9 && row[j] == 3)
            {
                cout << row[j] << column[j];
            }
           
           
        }
    }
        system("pause");
        return 0;
    }

---

Quote:

---

Originally Posted by nick753

Here is my latest code guys. While looking through it I noticed something. Where in the heck in my program is it saying what size the grid needs to be? I would have thought to put it inside the brackets of row[] and column[], but someone said to put 100 in there to make that the number of moves it makes. So where/how would I go about setting up my grid size?? My program as of now seems like it makes sense, but it never prints out when it escapes, but that's probably because no grid is set up? Please take a look at tell me what you think. Thanks for the help!

---

Well, I can answer one question: Look at your own code. The grid is set up with the series of if...than checks you have when you parse the random value. For example, in the block:

Code:

---

if (k ==1 ) // Move Right
            {
                row[j] = row[j-1];
                column[j] = column[j-1] + 1;
                if(column[j] > 8 && row[j] != 3) { break; }
            }

---

The line, if (column[j] > 8 && row[j] != 3) is your boundary check. That's essentially saying, "If the mole is outside of the grid on the right hand side, and is not in the third row down, then the mole has fallen off the grid and fails."

As for why it's not printing, that's because you break out of the loop you're in before the call to print ever happens. Remember, a break statement is saying, "Short-circut the rest of the loop and exit now." So in your code, since your block:

Code:

---

if(column[j] == 9 && row[j] == 3)
            {
                cout << row[j] << column[j];
            }

---

is inside of the loop you just broke out of, it'll never get called. Think about where you could place it where it will be called once you break out of the inner loop. (Although I can also see that you aren't checking for both a win condition or a loss condition and handling them - you need to look into doing that.)

There's quite a few bugs that you have lurking around there, to be honest. Maybe you should take a step back and write everything out in psuedocode so that you can more clearly see where you're heading in your program.

I have moved the statement to print the result inside the 'move right' statement. But, it still will not print anything. I'm not sure if there is a better spot or not, but it seems pretty logical to put it there?

Code:

---

[if (k ==1 ) // Move Right
                        {
                                row[j] = row[j-1];
                                column[j] = column[j-1] + 1;
                 
                                  if(column[j] > 8 && row[j] != 3) { break; }
                                  else if(column[j] == 9 && row[j] == 3)
                  cout << row[j] << column[j];

---

Don’t worry; when you get it working and the results are printed out it will make more sense to you.

Don’t forget, you are only printing out the results for successful attempts, so if the mole crosses a boundary you just ignore it (break) and restart the j loop.

I put the successful attempt check at the end of the loop simply to make it easier for you to understand. You are now putting it in the correct place but you need a separate loop to print out the whole successful sequence from the beginning, then you need to break out of the j loop.

Using a function just keeps the code tidier but it’s ok to write the loop where you do your check.

Code:

---

        if (row[j] == 3 && col[j] == 9) // successful attempt
            {
              successful_attempt(row, 100, col, 100, j + 1);
              cnt_sa = cnt_sa + 1;
              break;
            }
         




void successful_attempt(int arg1[], int len1, int arg2[], int len2, int max)
{
    cout << "*** Successful Attempt ***" << endl;
    for (int j= 0; j < max; j++)
    {
    if (j % 13 == 0 ) // display 13 coordinates per line
        cout << "(" << arg1[j] << "," << arg2[j] << ") " << endl;
    else
        cout << "(" << arg1[j] << "," << arg2[j] << ") ";
    }
    cout << endl << endl;

}

---

Note1: srand(time(NULL)); goes at the start of the program before the loops.

Thank you Michael. The reason I'm not printing out the results yet is because I can't even get it to print the coordinates when it wins(which in my program, is never). So obviously I'm doing something wrong to where my program never can win. Maybe because it only does 100 moves? I don't know but here is my code.

Code:

---

#include<iostream>
#include<ctime>
using namespace std;
int main()
{

        int row[100] = {0};
        int column[100] = {0};
        int rowstart = 3;
        int columnstart = 2;
        int k;
        srand(time(NULL));
       
        for(int i = 0; i < 500; i++)
        {
                row[0] = 3;
                column[0] = 2;
               
               

                for(int j = 0; j < 100; j++)
                {
                       
                        k = rand() % 4 + 1;
                       
                        if (k ==1 ) // Move Right
                        {
                                row[j] = row[j-1];
                                column[j] = column[j-1] + 1;
                 
                                  if(column[j] > 8 && row[j] != 3) { break; }
                                  else if(column[j] == 9 && row[j] == 3)
                  cout << row[j] << column[j];
                        }
                        else if(k==2) //Move Up
                        {
                                row[j] = row[j-1] - 1;
                                column[j] = column[j-1];
                                if(row[j] < 1) { break; }
                        }

                        else if(k==3) // Move Left
                        {
                                row[j]= row[j-1];
                                column[j]= column[j-1] - 1;
                                if(column[j] < 1) { break;}
                        }

                        else { // move down
                                        row[j] = row[j - 1] + 1;
                                        column[j] = column[j - 1];
                                        if(row[j] > 8) { break; }
                            }
                       
                       
                   
           
           
           
                }
        }
                system("pause");
                return 0;
        }

---

This should get something printing out for you, which will hopefully make it more clear.

Code:

---

int main()
{

        ////////////int row[100] = {0};
        ////////////int column[100] = {0};
        ////////////int rowstart = 3;
        ////////////int columnstart = 2;
        int k;
        srand(time(NULL));

        for(int i = 0; i < 500; i++)
        {
        int row[100] = {0};        ////////
        int column[100] = {0};      ////////
                row[0] = 3;
                column[0] = 2;



                //////////////for(int j = 0; j < 100; j++)
                for(int j =1; j < 100; j++)
                {

                        k = rand() % 4 + 1;

                        if (k ==1 ) // Move Right
                        {
                                row[j] = row[j-1];
                                column[j] = column[j-1] + 1;

                                  if(column[j] > 8 && row[j] != 3) { break; }
                                  else if(column[j] == 9 && row[j] == 3)
                  ////////////////////////////cout << row[j] << column[j];


                                    //Add this here
                                    {
                                        cout << "*** Successful Attempt ***" << endl;
                                        for (int n = 0; n < (j+1); n++)
                                        {
                                            if (n % 13 == 0 ) // display 13 coordinates per line
                                                cout << "(" << row[n] << "," << column[n] << ") " << endl;
                                            else
                                                cout << "(" << row[n] << "," << column[n] << ") ";
                                        }
                                        cout << endl << endl;
                                        break;
                                    }





                        }
                        else if(k==2) //Move Up
                        {
                                row[j] = row[j-1] - 1;
                                column[j] = column[j-1];
                                if(row[j] < 1) { break; }
                        }

                        else if(k==3) // Move Left
                        {
                                row[j]= row[j-1];
                                column[j]= column[j-1] - 1;
                                if(column[j] < 1) { break;}
                        }

                        else { // move down
                                        row[j] = row[j - 1] + 1;
                                        column[j] = column[j - 1];
                                        if(row[j] > 8) { break; }
                            }






                }
        }
                system("pause");
                return 0;
        }

---

Michael, I cannot tell you how much I appreciate the help you have given me! It truly means a lot for you to take the time out of your day to help a beginning programmer out! Again, thank you! I looked at your code and understand it and have modified it just a little to display the amount of times the mole won and the percentage of it's chances of his escape.

Now send me a PM with your address so I can send you a gift card to a restaurant of your choice! :)

Thank you nick. But you don’t owe me anything, its been a pleasure to share the little bit of c++ knowledge I’ve learnt. And lots of very nice people on this forum have helped me too, so we all move forward a little bit.

Make sure you understand that you used a fixed length array of 100 elements and this restricted the mole to a maximum of 100 moves. Comment this at the top of your program.

When you come to do vectors you will see how it can be done more efficiently by dynamically allocating memory.

Here’s a typical sample of my output for comparison.

Good luck with your studies.

***Statistics ***
Number of attempts : 500
Successful attempts : 6
Success rate : 1.2%
Failed attempts : 494
Failed left : 265
Failed right : 31
Failed top : 146
Failed bottom : 51
Failed > 100 moves : 1
Total moves made : 7469
Ave moves per attempt : 14.94