ermm, i dont know what you are trying to do exactly, but to me this can be quite easy to do if you consider it as a string of numbers! Just fix all the digits except the last two, and rotate them, then release one more digit and rotate it! While you do this, keep pushing the numbers in a array, and if they already exist, just skip to next!
example: 0123
fix 01, rotate 23
0123
0132
fix 0, rotate 123
0123 --> skip this one
0312
0213
fix none, rotate all
0123 --> skip this one
3012
3201
3210
.....
....
so on
you can make a recursive function for this!
Thanks for the reply... I'd have to play with what you described. I spent the last couple of days coming up with this code that solves for all unique ways to move around on any sized matrix. This script works great, except it crashes when columns and rows are greater than 4; In other words, anything larger than a 4x4 matrix. AAAAAAAhhHHHHH
If you can help me figure out why flash freezes past this point, that'd be sweet!
Copy my code into a blank flash document and look at the output to see what's happening:
/////////////////////////////////////////////////////////////////////////////
///////////////Uniqe Matrix Number Generator By Walter Zelhofer//////////////
///////////////////////////////Created 2-17-2009/////////////////////////////
/////////////////////////////////////////////////////////////////////////////
///////////////WARNING: This script will run any matrix smaller//////////////
///////////////than a 4x4. Anything larger will make the flash //////////////
///////////////player unresponsive. Damn it! //////////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
/*------------------------------Settings------------------------------------*/
columns = 3;
rows = 2;
/*------------------------------Create Matrix--------------------------------*/
total_boxes = columns*rows;
// push numbers into the values array in single line array
values = new Array();
for (i=0; i<total_boxes; i++) {
values.push(i);
}
// create a new nested array from the values array based on the columns and rows
//the rest of the script depends on this nested array to find the possible_moves
//for each square. In other words, to find each square's neighbor(s), the put them
//into a nested array called values_nested.
values_nested = new Array();
counter = 0;
for (i=0; i<rows; i++) {
values_nested[i] = new Array();
for (j=0; j<columns; j++) {
values_nested[i][j] = values[counter];
counter += 1;
}
}
trace("single line values are:"+values);
trace("the nested values_nested now are:"+values_nested);
trace("NOTE: The two lists of values above should appear identical! One is a nested array the other isn't.")
for (i=0; i<values_nested.length; i++) {
trace("-------values_nested"+"["+i+"]"+values_nested[i]);
}
// Now we use this entire procedure to come up with the array: possible_moves.
possible_moves = new Array();
TempArray = new Array();
TempLength = new Array();
counter = 0;
for (i=0; i<values_nested.length; i++) {
for (j=0; j<values_nested[i].length; j++) {
//Starting with the first value in the first row
//Go left & right 1 spot to find immediate neighbors and store these values, IF POSSIBLE
//Check to my immediate left:
if ((j-1)>=0) {
TempArray.push(values_nested[i][j-1]);
counter += 1;
}
//Check to my immediate right:
if ((j+1)<values_nested[i].length) {
TempArray.push(values_nested[i][j+1]);
counter += 1;
}
//Go to row Above me, if there is one, and store the value I hit in this SAME index position, j
// This would be the square directly above me
if ((i-1)>=0) {
TempArray.push(values_nested[i-1][j]);
counter += 1;
//Now in this row above me, store the value to the LEFT of my Index, j, IF there is one:
if ((j-1)>=0) {
TempArray.push(values_nested[i-1][j-1]);
counter += 1;
}
//Now in this row above me, store the value to the RIGHT of my Index, j, IF there is one:
if ((j+1)<values_nested[i-1].length) {
TempArray.push(values_nested[i-1][j+1]);
counter += 1;
}
}
//Go row BELOW me, if there is one, and store the value I hit in the same index position, j
if ((i+1)<values_nested.length) {
TempArray.push(values_nested[i+1][j]);
counter += 1;
//Now in this row below me, store the value to the LEFT of my Index, j, IF there is one:
if ((j-1)>=0) {
TempArray.push(values_nested[i+1][j-1]);
counter += 1;
}
//Now in this row below me, store the value to the RIGHT of my index, j, IF there is one:
if ((j+1)<values_nested[i+1].length) {
TempArray.push(values_nested[i+1][j+1]);
counter += 1;
}
}
TempLength.push(counter);
counter = 0;
}
}
//trace("possible_moves:"+possible_moves);
//trace("TempLength:"+TempLength);
counter = 0;
for (i=0; i<total_boxes; i++) {
possible_moves[i] = new Array();
for (j=0; j<TempLength[i]; j++) {
possible_moves[i][j] = TempArray[counter];
counter += 1;
}
}
//trace("possible_moves:"+possible_moves);
for (i=0; i<possible_moves.length; i++) {
//trace("possible_moves"+"["+i+"]:"+possible_moves[i]);
}
//This function allows us to sort on an array of numbers
function sortByNumber(a, b) {
return (a>b);
}
for (i=0; i<possible_moves.length; i++) {
possible_moves[i].sort(sortByNumber);
//trace("ran the sort function");
}
//trace("possible_moves:"+possible_moves);
for (i=0; i<possible_moves.length; i++) {
trace("possible_moves"+"["+i+"]:"+possible_moves[i]);
}
/*---------------------------Functions----------------------------------------------*/
function arrayLastNumbers(arrayName:Array) {
TempArray = new Array();
for (i=0; i<arrayName.length; i++) {
TempString = arrayName[i];
TempString = TempString.split("");
TempLength = TempString.length;
TempArray[i] = TempString[TempString.length-1];
}
return arrayName;
}
function nestTempArray() {
counter = 0;
TempArray2 = new Array();// this will be the nested version of TempArray
for (i=0; i<TempLengths.length; i++) {
TempArray2[i] = new Array();
for (j=0; j<TempLengths[i]; j++) {
TempArray2[i][j] = TempArray[counter];
counter += 1;
}
}
return arrayName;
}
function arrayCombineResults(arrayNameOLD:Array, arrayNameNEW:Array) {
//Combine results
counter = 0;
for (i=0; i<arrayNameOLD.length; i++) {
for (j=0; j<TempArray2[i].length; j++) {
arrayNameNEW[counter] = arrayNameOLD[i]+""+TempArray2[i][j];
counter += 1;
}
}
}
function arrayFindPossibleMoves(arrayName:Array) {
counter = 0;
TempLengths = new Array();//This will be the temp array to hold the lengths of the
//groups of numbers that will come out. We need this to make our multidimensional array later
for (i=0; i<TempArray.length; i++) {
SearchPosition = TempArray[i];
TempLengths[i] = possible_moves[SearchPosition].length;
//store these lengths into another array temprorarily
for (j=0; j<possible_moves[SearchPosition].length; j++) {
arrayName[counter] = TempArray[i]+""+possible_moves[SearchPosition][j];
counter += 1;
}
}
return arrayName;
}
function arrayRemoveDuplicates(arrayName:Array) {
var arrayName:Array = arrayName.sort();
var i:Number = arrayName.length;
while (--i>0) {
while (arrayName[i] == arrayName[i-1]) {
arrayName.splice(i-1,1);
Duplicates = true;
}
}
return arrayName;
}
function arrayoverwriteWithNoDuplicates(arrayName:Array) {
TempArray = new Array();
for (i=0; i<arrayName.length; i++) {
Duplicates = false;
TempString = arrayName[i];
TempString2 = TempString;
TempString = TempString.split("");
_root.arrayRemoveDuplicates(TempString);
if (Duplicates == false) {
TempArray.push(TempString2);
}
}
_root.arrayName = TempArray;
return arrayName;
trace("End Duplicate Check");
}
TempArray = values;
for (i=1; i<values.length; i++) {
var solutions:Array = this["answer"+i]=new Array();
}
arrayFindPossibleMoves(answer1);
trace("answer1:"+answer1);
trace("total for answer1:"+answer1.length);
//This will be the temp array to hold the lengths of the
//groups of numbers that will come out. We need this to make our multidimensional array later
/*-----------------------Procedure for Calling the above functions--------------------*/
arrayLastNumbers(answer1);
arrayFindPossibleMoves(answer2);
arrayLastNumbers(answer2);
//trace("UnNested TempArray:"+TempArray);
nestTempArray();
//Combine results
arrayCombineResults(answer1,answer2);
//Check for duplicates process here
//trace("create nested array from answer2 with duplicates");
arrayoverwriteWithNoDuplicates(answer2);
answer2 = arrayName;
trace("answer2:"+answer2);
trace("total for answer2:"+answer2.length);
//Now Do the same thing for the other arrays. Since these are all the same, I throw them
//into a loop.
for (k=2; k<values.length-1; k++) {
l = k+1;
arrayLastNumbers(_root["answer"+k]);
arrayFindPossibleMoves(_root["answer"+l]);
//-------------------------------------------THIS NEEDS TO BE A NESTED ARRAY
arrayLastNumbers(_root["answer"+l]);
//trace("UnNested TempArray:"+TempArray);
nestTempArray();
//Combine results
arrayCombineResults(_root["answer"+k],_root["answer"+l]);
//trace("answer2 w Dups:"+answer2);
//Check for duplicates process here
//trace("create nested array from answer2 with duplicates");
arrayoverwriteWithNoDuplicates(_root["answer"+l]);
_root["answer"+l] = arrayName;
trace("answer"+l+":"+_root["answer"+l]);
trace("total for answer"+l+":"+_root["answer"+l].length);
}
/////////////////////////////////////////END///////////////////////////////////////////
trace("End Of Output");