Count the value of 2d Matrix - c++

Question

I need to count the value of the matrix. Let's see the example, because its bit hard to explain.
There is a 2d quadratic matrix ( rows == columns ) let's called it int n and it must be odd ( 3x3, 5x5, 7x7,.. ) and we have int x. We need to find the sum of the value based on x. The value of x is start from 0 and less than n/2.
Example:
Matrix 3x3
1 1 1
2 2 2
3 3 3
if x is 0, we need to sum 1 + 1 + 1 + 2 + 2 + 3 + 3 + 3 = 16.
if x is 1, output is 2.
x cant be more than 1, because 2 > n/2.
Matrix 5x5
1 1 1 1 1
2 2 2 2 2
3 3 3 3 3
2 2 2 2 2
1 1 1 1 1
if x is 0, then output will be 24 ( 1 + 1 + 1 + 1 + 1 + 2 + 2 + 3 + 3 + 2 + 2 + 1 + 1 + 1 + 1 + 1 )
if x is 1, then output will be 18 ( 2 + 2 + 2 + 3 + 3 + 2 + 2 + 2 )
if x is 2, then output will be 3.
as you can see, the bold number is if x is 0, and the italic number is if x is 1.
Then, i came up with this code
int test( int A[100][100], int n, int x){
if( x == ( n - 1 ) / 2 )
return A[((n-1)/2)][((n-1)/2)];
if(x >= 0 && x < ( n - 1 )/2 )
return A[((n-1)/2)-x-1][((n-1)/2)-x-1] + A[((n-1)/2)-x-1][((n-1)/2)] + A[((n-1)/2)-x-1][((n-1)/2)+x+1] + A[((n-1)/2)][((n-1)/2)-x-1] + A[((n-1)/2)][((n-1)/2)+x+1]
+ A[((n-1)/2)+x+1][((n-1)/2)-x-1] + A[((n-1)/2)+x+1][((n-1)/2)] + A[((n-1)/2)+x+1][((n-1)/2)+x+1];
}
The problem is, if the matrix is only 3x3, its ok. but if the matrix is greater than 3x3 will come up with wrong output.
Also, I tried with loop. but didn't work.
int test(int A[100][100], int n, int x ) {
for ( int i = 0; i < n; i ++ ) {
for ( int j = 0; j < n; j ++ ) {
int count = 0;
if ( i < n - 1 ) // bottom
count = count + A[((n-1)/2)+1+x][(n-1)/2];
if ( j < n - 1 ) // right
count = count + A[(n-1)/2][((n-1)/2)+1+x];
if ( j >= 1 ) // left
count = count + A[(n-1)/2][((n-1)/2)-1-x];
if ( i >= 1 ) // top
count = count + A[((n-1)/2)-1-x][(n-1)/2];
if ( j >= 1 && i >= 1 ) // left top
count = count + A[((n-1)/2)-1-x][((n-1)/2)-1-x];
if ( j < n - 1 && i >= 1 ) // right top
count = count + A[((n-1)/2)-1-x][((n-1)/2)+1+x];
if ( j >= 1 && i < n - 1 ) // left bottom
count = count + A[((n-1)/2)+1+x][((n-1)/2)-1-x];
if ( j < n - 1 && i < n - 1 ) // right bottom
count = count + A[((n-1)/2)+1+x][((n-1)/2)+1+x];
return count;
}
}
}

Answer 1

You want to sum up a ring. You only need one loop, not two nested loops:
It doesn't make sense to unconditionally return in a loop. It will break out of the loop in the first iteration. You should return after the loop.
It doesn't make sense to initialize count in the loop. It will reset it in each iteration. You should initialize count before the loop.
You don't use the loop variables in your calculation. You should access different elements using i and j.
You can make your life easier if you set the loop to
int test(int A[100][100], int n, int x) {
int count = 0;
for (int i = x; i < n - x - 1; ++i) {
count += A[i][x];
count += A[i + 1][n - x - 1];
count += A[x][i];
count += A[n - x - 1][i + 1];
}
return count;
}
or use std::accumulate
int test(int A[100][100], int n, int x) {
return std::accumulate(A[x] + x, A[x] + n - x - 1, 0)
+ std::accumulate(A[n - x - 1] + x + 1, A[n - x - 1] + n - x, 0)
+ std::accumulate(A + x + 1, A + n - x, 0, [x, n](auto acc, auto el) {
return acc + el[x];
})
+ std::accumulate(A + x, A + n - x - 1, 0, [x, n](auto acc, auto el) {
return acc + el[n - x - 1];
});
}
It's unclear for me why you need parameter n. A has a fixed size 100x100. n has to be 100. You could rewrite both codes to
constexpr int n = 100;
int test(int A[n][n], int x) {
int count = 0;
for (int i = x; i < n - x - 1; ++i) {
count += A[i][x];
count += A[i + 1][n - x - 1];
count += A[x][i];
count += A[n - x - 1][i + 1];
}
return count;
}
resp.
constexpr int n = 100;
int test(int A[n][n], int x) {
return std::accumulate(A[x] + x, A[x] + n - x - 1, 0)
+ std::accumulate(A[n - x - 1] + x + 1, A[n - x - 1] + n - x, 0)
+ std::accumulate(A + x + 1, A + n - x, 0, [x](auto acc, auto el) {
return acc + el[x];
})
+ std::accumulate(A + x, A + n - x - 1, 0, [x](auto acc, auto el) {
return acc + el[n - x - 1];
});
}
or using templates
template<int n>
int test(int A[n][n], int x) {
int count = 0;
for (int i = x; i < n - x - 1; ++i) {
count += A[i][x];
count += A[i + 1][n - x - 1];
count += A[x][i];
count += A[n - x - 1][i + 1];
}
return count;
}
resp.
template<int n>
int test(int A[n][n], int x) {
return std::accumulate(A[x] + x, A[x] + n - x - 1, 0)
+ std::accumulate(A[n - x - 1] + x + 1, A[n - x - 1] + n - x, 0)
+ std::accumulate(A + x + 1, A + n - x, 0, [x](auto acc, auto el) {
return acc + el[x];
})
+ std::accumulate(A + x, A + n - x - 1, 0, [x](auto acc, auto el) {
return acc + el[n - x - 1];
});
}

Answer 2

template <int N>
int SumRing (const int A[N][N], const int x)
{
// x represents the lower end, XX the upper:
const int XX = N - x - 1;
// special case: no "ring", only middle element:
if (x == XX)
return A[x][x];
// edges of the ring:
const int r_top = x;
const int c_left = x;
const int r_bottom = XX;
const int c_right = XX;
// We add clockwise around the ring,
// each time leaving out the last element
// to avoid its double-count:
int sum = 0;
// top row:
for (int c = c_left; c < c_right; ++c)
sum += A[r_top][c];
// right column:
for (int r = r_top; r < r_bottom; ++r)
sum += A[r][c_right];
// bottom row:
for (int c = c_right; c > c_left; --c)
sum += A[r_bottom][c];
// left column:
for (int r = r_bottom; r > r_top; --r)
sum += A[r][c_left];
return sum;
}
If you don't know the array size before run-time, then you may want to consider a matrix wrapper class around std::vector.