Thread: 2Darray in 1Darray and sum elements

Hello and congratulations for the forum!
My problem: we have a 2D array[i][j] nxn . We put serial the rows of the 2D array in one 1D array[t].Next we have a function with this prototype:

PHP Code:

int myfunc(array[t] , n); 


The int that the function returns is 1 or 0.
1(one) if the sum of each row and column(like as we have a 2D array) in 1D array is the same returns 1,otherwise returns 0;So i am very confused with the loops that i must do.Can anyone give me an idea?
My thougt, as example we have a 3X3 array:
[img=http://img17.imagevenue.com/loc1116/th_11174_array_122_1116lo.jpg](the numbers are random)

for the sum of the the rows in array[t] we must make 3 loops and for each loop i must calcuate the sum each t/n=3 elements (from 0-2, 3-5, 6-8 )
for the rows i must sum example the array[0] + array[t/n] + array[2t/n]
Am i wrong? How can i do the loops?

Yes i know that, but we have a 1D array and we should use it like it was a 2D array.If you can't give me some code i want to give me some advices such as : should i calculate the sum of each column and row separately and after compare them or must i calculate the sum of the first row and the sum for the first column, compare them and after continue with the others?Thanks!

so, you have an array like this:

Code:

int arr[9];

but you want it to appear like:

Code:

int arr[3][3];

And then you call the function with myfunc(arr, 3).

Code:

int myfunc(int arr[], int n)
{
    int x, y;
    for(y = 0; y < n; y++)
    {
        for(x = 0; x < n; x++) 
        {
             int e = arr[y * n + y];
             // ...  use e to calculate your sums. 
        }
    }
}

--
Mats

Originally Posted by dwks

I realize that that's just an example; however, the OP never said that the elements were equal in size. In fact, [s]he said:

Presumably t=i*j . . . .

I took

My problem: we have a 2D array[i][j] nxn

the n x n to mean that it's a square layout. Otherwise the function will require an X and Y size of course.

--
Mats

To step around in such flat representations it's useful to precompute the step size along each dimension. Moving in a given dimensions means adding or subtracting some constant value from the current position.

In general, suppose you have a flat array which is conceptually layed out as:

array[Dim1][Dim2]...[DimN-1][DimN]

In other words, an N-dimensional array. The total size of the flat array is the produce of the dimensions Dim1*Dim2*...*DimN. You probably already understand this part.

To find the "step" to move along dimension N, you simply take the product of the dimension sizes of all dimensions which follow it in the layout. So take your example:

array[Dim1][Dim2].

Suppose you want to move along Dim2. The product of all the dimensions FOLLOWING Dim2 is 1 -- nothing follows Dim2. It's as if there was a silent [1] sitting there. So the step size along Dim2 is 1. Now consider moving along Dim1. The product of the following dimensions is Dim2, so the step size along Dim1 is Dim2.

To compute an absolute position in the array for a point <x1, x2, ..., xN>, you would find the sum x1*Step1 + x2*Step2 + ... + xN*StepN.

Yes, so my solution describes how to get to a certain element in that array.

You will have to write the code to figure out what column sums are and such.

--
Mats

Originally Posted by matsp

Yes, so my solution describes how to get to a certain element in that array.

You will have to write the code to figure out what column sums are and such.

--
Mats

No i don't think so or i didn't understand.If we have array[i][j] we say

PHP Code:

for i=0; i<n
   for j=0 j<n 


So in 1D array[t] i have only t for loop and thought that must do these(hope are correct)

for the sum of the the rows in array[t] we must make 3 loops and for each loop i must calcuate the sum each t/n=3 elements (from 0-2, 3-5, 6-8 )
for the rows i must sum example the array[0] + array[t/n] + array[2t/n]

So, if we take a 9-element array and "make it into a 2D array", it would have the following indices:

Code:

[0] = [0][0]   [1] = [0][1]   [2]=[0][2]
[3] = [1][0]   [4] = [1][1]   [5]=[1][2]
[6] = [2][0]   [7] = [2][1]   [8]=[2][2]

So to get to element [y][x], we use [y *n + x] - for example, x = 1, y = 1 -> 1*3 + 1 -> 4; x = 0, y = 2 -> 2*3 + 0 -> 6.

Does this make sense to you?

--
Mats

Yes thank you very much.Now i understand what you mean.