Thread: Scramble Elements in Array

I may be wrong, but if memory serves me correctly, the rand() function may not be returning the type of values you think they are. I know I've found occasions where the value returned was a double value between 0.999999999 and 0.000000000, so to find a value between 0 - 3, you would first have to multiply by 100. Check your documentation for your particular compiler to see what the rand() function is returning.

here's a sample code I just whipped out to prove my range is indeed form 0 to 3:

Code:

#include <stdio.h>
#include <stdlib.h>

int main()
{
	int i;
	srand(time(NULL));
	for ( i = 0; i < 11; ++i)
	{
		char i = rand()%4;
		printf("%d\n", i);
	}
}

output:

$./a.out
2
3
1
2
0
0
2
1
0
1
2
~/Desktop $

Originally Posted by laserlight

I am not sure what find_Zero_In_Row() and find_Zero_In_Col() do, but going by their names perhaps the problem is that there are no zeroes in your 2D array.

yes the array i made manually and does have a zero, else it would be pointless. I guarantee they return a valid position where the ever existant zero appears in the array.

Originally Posted by laserlight

If you have come across such a standard library implementation, then you have found a major bug in that implementation. rand() must return an int, not a double.

Thanks, I did notice that as well and have changed it to an int type, yet my code it still not doing what I intend it to.
It prints out the original array I pass in with the '0' as a space as specified in my print_Board() funciton.

Did you ever fix this?

Code:

gameBoard[x][y] = gameBoard[x][y]-1;

so this is my newest version of that function. Now it just swaps one element in the array.
so if my original array is:
1 2 3 4
5 6 7 8
9 10 11 12
13 14 15

then my output looks like this:
1 2 3 4
5 6 7 8
9 10 11 12
13 14 15

Code:

void scramble(char gameBoard[][COLS], int w) // incomplete
{
	srand(time(NULL));
	
	while ( w < 50) 
	{
		
		// search for zero in array and store position in x (row) & y (col)
		char x = find_Zero_In_Row(gameBoard);
		char y = find_Zero_In_Col(gameBoard);
		
		int unsigned z = rand()%4; // random number between 0 and 3, 0 and 3 included
		
		if ( z == 0 &&  y+1 < COLS) // case 1
		{
			gameBoard[x][y] = gameBoard[x][y+1];
			gameBoard[x][y+1] = 0;
		}
		else if ( z == 1 && y-1 > COLS) // case 2
		{
			gameBoard[x][y] = gameBoard[x][y]-1;
			gameBoard[x][y-1] = 0;
		}
		else if ( z == 2 && x+1 < ROWS) // case 3
		{
			gameBoard[x][y] = gameBoard[x+1][y];
			gameBoard[x+1][y] = 0;
		}
		else if ( z== 3 &&  x-1 > ROWS) // case 4
		{
			gameBoard[x][y] = gameBoard[x-1][y];
			gameBoard[x-1][y] = 0;
		}
		w += 1;
	}
	
	print_Board(gameBoard);
	print_Instructions();
	
}

ok, this thread doens't let me show the spaces how they are displayed in the terminal, but take my word for it that the number 15 in the array is originally to the far right and then after scramble the 15 swaps with the original empty space to the left of it.

I'm thinking my logic is flawed in the actual swapping of array elements...anyone?

Originally Posted by tabstop

Did you ever fix this?

Code:

gameBoard[x][y] = gameBoard[x][y]-1;

oops...

Originally Posted by laserlight

Well, considering that what you are doing is just moving the empty space around in the 2D array (and performing relatively expensive operations to find it on each iteration instead of just keeping track of its location), I suspect that the array will never be scrambled no matter what you do.

Why not go with what I suggested?

EDIT:
Oh, but that is not right: moving the empty space around should result in an eventual scrambling of the array, but it is probably just slow since you are only swapping the empty space with adjacent elements, and there are times when the swap does not even happen.

I think the point is to make the slider puzzle and to actually do the moves so that you know the puzzle that you present is solvable. It would be easier to (a) not do recursion (b) keep track of the empty block (c) not call srand each time, as it would not surprise me if you got 50 of the same move each time.

Originally Posted by kcpilot

I may be wrong, but if memory serves me correctly, the rand() function may not be returning the type of values you think they are. I know I've found occasions where the value returned was a double value between 0.999999999 and 0.000000000, so to find a value between 0 - 3, you would first have to multiply by 100. Check your documentation for your particular compiler to see what the rand() function is returning.

rand() is a standardized function, it always returns an int, there is no room for alternate implementations, although a particular run-time may implement overloaded versions.

Originally Posted by tabstop

I think the point is to make the slider puzzle and to actually do the moves so that you know the puzzle that you present is solvable. It would be easier to (a) not do recursion (b) keep track of the empty block (c) not call srand each time, as it would not surprise me if you got 50 of the same move each time.

yes very good observations guys...i'll will work on a better method.