Compare Arrays

Hi Everyone,

I'm trying to compare two 9 element arrays. Their contents have to be identical but not necessarily in order.

For example:

Code:

---

Array1 = 000123000
Array2 = 010020030

---

These would return as identical.

I guess i could spend some time doing it manually but i think theres an easier way?

I'd have 2 loops, 1 nested in the other. I dunno, someone's probably got a better idea ;)

So, you are saying that all elements of one array has to occur in the other array exactly the same number of times, or would

Code:

---

Array1 = 000123001
Array2 = 111020030

---

also be equal?

--
Mats

Ah, sorry matsp, should have been more specific.

The elements have to occur the same number of times. Just their position can change.

I know how to do it if the positions are the same but its this point which is confusing me.

Thanks.

Keep track of if each element has occurred, eg:

Code:

---

int element[10] = {0};  /* 10 digits, [0,9] */

---

Then go through each array with the loops like I said, setting element[digit] to 1 every time you find a unique digit.

I guess one way would be to sort both arrays and compare them in sorted order...

--
Mats

Or that... which would greatly help if you had to compare n arrays.

Tis a good idea! Once sorted is there a way to compare both arrays in one go. Since they will both now be identical in position and value?

Yes, if the arrays are sorted, you should be able to just compare the corresponding elements until you either find a difference or reach the end of the array. Pretty basic comparison really.

--
Mats

what about when the number of arrays are unknown?

i can do it for an unknown number of elements but if there is more than one array i'm not sure how to do it.

You could use a counter. Use a map to store a value and increment that value the number of times that specific character or number occours in the array.
Then iterate your map for both arrays and compare all the character occourances. If all characters have the same count, they're equal.

Quote:

---

Originally Posted by AmbliKai

what about when the number of arrays are unknown?

i can do it for an unknown number of elements but if there is more than one array i'm not sure how to do it.

---

Again, not sure what you want to do, is it one array that you need to find a match for, or multiple arrays, any of which could possibly be equal to any other?

Although, really, it makes little difference - you only compare one array to one other array at any time.

Obviously, if you have an unound number of arrays, you either have to not store any "old" arrays, or you have to use some dynamic allocation method or such.

--
Mats

sort and then strcmp

Ok, i've finished the part of my program which generates the arrays.

They end up in a 2 dimensional array:
for example:

Code:

---

disjoint_subset_row_array =
002040009
002045000
000045600
002040009

---

Notice the top row and bottom row are identical.

My problem is this:
I want to compare the ROWS in the array and find how many of them are identical and to return that row.

So for the example above:

Code:

---

Rows : 0, 3.
002040009

---

Its just that the number of rows changes each time. As does the number which are identical (if any)
I'm a bit stuck on this!!
Any help would be very greatly appreciated.
Thank you.

So, I guess you get these in a file or some such, right?

--
Mats

No i sort of generate them from a couple of other matrices. Some source code:

Code:

---

#include <stdio.h>

int main()
{
int smallsquarefinal[9][9][9];
int x, y, z;
int a, b;
int possarray[9][9];
int i;
int size_of_disjoint_subset, count_disjoint_subset_row;
int location[9] = {0};
int row = 0;
int col = 0;
int secondary_x, secondary_y, location_count;

FILE *disjointsubsetoutput;
FILE *possarrayoutput;

if ((disjointsubsetoutput = fopen("disjointsubsetoutput", "w")) == NULL)
          fprintf(stderr, "Cannot open %s\n", "disjointsubsetoutput");
         
for (x = 0; x < 9; x++)
{
        for (y = 0; y < 9; y++)
        {
        fprintf(disjointsubsetoutput, "\n[%d][%d] ", x, y);
                for (z = 0; z < 9; z++)
                {
                smallsquarefinal[x][y][z] = z + 1;
                fprintf(disjointsubsetoutput, "%d", smallsquarefinal[x][y][z]);
                }
        }
}

if ((possarrayoutput = fopen("possarrayoutput", "r")) == NULL)
          fprintf(stderr, "Cannot open %s\n", "possarrayoutput");

for (x = 0; x <= 8; x++)
{
        char buf[10];
        fscanf(possarrayoutput, "%s", buf);
        for (y = 0; y <= 8; y++)
        {
        possarray[x][y] = buf[y]-'0';
        printf("%d ", possarray[x][y]);
        }
printf("\n");
}
fclose(possarrayoutput);

fprintf(disjointsubsetoutput, "\nThese are the arrays to be compared (seperated by newlines):");
for (size_of_disjoint_subset = 2; size_of_disjoint_subset < 9; size_of_disjoint_subset++)
{
        for (row = 0; row < 9; row++)
        {
        count_disjoint_subset_row = 0;
                for (col = 0; col < 9; col++)
                {
                location[col] = 0;
                        if (possarray[row][col] != 0)
                        {
                                if(possarray[row][col] == size_of_disjoint_subset)
                                {
                                count_disjoint_subset_row++;
                                location[col] = col + 1;
                                }
                        }
                }
               
                if (count_disjoint_subset_row != 0)
                {
                printf("\nsubset = %d, count = %d, row = %d, location = ", size_of_disjoint_subset, count_disjoint_subset_row, row);
                        for (secondary_y = 0; secondary_y < 9; secondary_y++)
                        {
                                if(location[secondary_y] != 0)
                                {
                                printf("%d", location[secondary_y]);
                                }
                        }
               
                        if (count_disjoint_subset_row >= size_of_disjoint_subset)
                        {
                        int disjoint_subset_row_array[count_disjoint_subset_row][9];
                        int no_of_rows_count = 0;
                        printf(" *");
                        // At this point we have the following information:
                        // The size of the subset "size_of_disjoint_subset"
                        // How many occurences of the subset there are in said row "coint_disjoint_subset_row"
                                // (This is greater than or equal to the subset size)
                        // The corresponding row "row"
                        // The locations of each of the possibility sets equal to the subset size "location[]"
                                //fprintf(disjointsubsetoutput, "\n");
                                for (y = 0; y < 9; y++)
                                {
                                        for (location_count = 0; location_count < 9; location_count++)
                                        {
                                                if(location[location_count] != 0 && location[location_count] - 1 == y)
                                                {
                                                printf("%d", no_of_rows_count);
                                                printf("[%d][%d] = ", row, y);
                                                        for (z = 0; z < 9; z++)
                                                        {
                                                        disjoint_subset_row_array[no_of_rows_count][z] = smallsquarefinal[row][y][z];
                                                        }
                                                no_of_rows_count++;
                                                }
                                        }
                                }
                               
                                for (a = 0; a < count_disjoint_subset_row; a++)
                                {
                                fprintf(disjointsubsetoutput, "\n");
                                        for (b = 0; b < 9; b++)
                                        {
                                        fprintf(disjointsubsetoutput, "%d", disjoint_subset_row_array[a][b]);
                                        }
                                }
                        }
                }
        fprintf(disjointsubsetoutput, "\n");
        }
}


printf("\n");
fclose(disjointsubsetoutput);
}

---

That file is self sufficient and is just to test my code. Part of the out put from the program looks like this:

Code:

---

123456789
123456789


123456789
123456789
123456789
123456789

123456789
123456789
123456789

123456789
123456789
123456789



123456789
123456789
123456789

123456789
123456789
123456789
123456789


123456789
123456789
123456789
123456789

---

And its these arrays which need to be compared. (Obviously they are all equal as i set them all for testing purposes)

Oh sorry, except that it reads this file in called "possarrayoutput"

Code:

---

430430544
003343346
200503303
540302330
534000424
044200033
403304003
343030300
444020032

---