L1xL2 array on 8x8 blocks - c

Question

Given an array of size L1xL2 divide the array by blocks of 4x4. For example the size of the array is 8x8 so there will be four blocks of 4x4.
Here is an example:
1 1 1 1 2 2 2 2 3 3 3 3 4 4 4 4 5 5 5 5 6 6 6 6 7 7 7 7 8 8 8 8
...............
First block 4x4 will be:
1 1 1 1 3 3 3 3 5 5 5 5 7 7 7 7
The second block will be:
2 2 2 2 4 4 4 4 6 6 6 6 8 8 8 8
I wrote this code (I have a matrix that is stored as an array and it's size is 8*8):
for (p = 0; p < nr_blocks; p ++) {
for (i = p*4; i < p*4 + 4; i++) {
for (j = 0; j < 4; j++) {
printf(" %d ", array[i*4 + j]);
}
}
}
But this code take the first block like this:
1 1 1 1 2 2 2 2 3 3 3 3 4 4 4 4
I want to divide in all the blocks and print them => 4 blocks.
What it is wrong?

Answer 1

When your array stores the 8x8 matrix you need access it with the dimension 8.
for(p = 0; p < nr_blocks; p ++){
for(i = p*nr_blocks; i < p*nr_blocks + 4; i++) { // please note the change
for(j = 0; j < 4; j++){
printf(" %d ", array[i*4 + j]);
}
printf("\n");
}
}

Answer 2

You seem to be storing what you call a matrix as one array, that is not a matrix. A matrix is
an array of arrays, thats what is making this difficult for you.
for (p = 0; p < nr_blocks; p ++) {
for (i = p*4; i < p*4 + 8; i=i+2) {
for (j = 0; j < 4; j++) {
printf(" %d ", array[i*4 + j]);
}
}
}

Answer 3

First
You are describing a 2 dimensional array, but using a 1 dimensional array in your code.
Second
Keep in mind C arrays are row major order. The order you extract elements must obey that construct.
For example, given this 3X4 array: (3 rows, 4 columns)
|1 1 1 1|
|2 2 2 2|
|3 3 3 3|
A C variable to contain such a matrix could be defined as:
int array[3][4]={{1,1,1,1},{2,2,2,2},{3,3,3,3}};
In memory, although it is a 2 dimensional array the elements are stored contiguously (Starting from array[0][0]) like this:
1 1 1 1 2 2 2 2 3 3 3 3
The offset from the beginning of the array to any one element is given by:
offset = row * (number_of_columns) + column;
Working in the opposite way, if you have an element's linear offset, you can get the row or column as follows:
row = offset/(number_of_columns);
column = offset%(number_of_columns);
In the example data you have shown (before you edited your original post), row 1 contains 4 1s, & 4 2s, then row 2: 4 3s & 4 4s, and so on. In extracting, you would have to set your for loop indexes to go from 0 to 3 for each of the 4 rows as you traverse the columns to get the first block. Then use 4 to 7 to traverse the columns again on the same 4 rows to get the second block.
For an 8x8, the same procedure would be used. Just keep in mind the row major order of the array.
Getting the first blocks for 8x8:
int i, j, r=8, c=8;
//first row 2nd 3rd and so on
int array[8][8]={{1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4},{...},{...}, (8 blocks total)...};
for(i=0;i<r/2;i++) //traverse 4 of 8 rows
for(j=0;c/2<j++) //traverse 4 of 8 columns
printf(" %d ", array[i][j]); //note this array is a two dimensional array,
//while you are showing a 1 dimensional array in your example
//(this is only 1 dimensional: array[i*4 + j])
Change indexes accordingly for remaining blocks