What happen if input values are changed. I mean couple of more negative values in matrix

For a more readable format:

int squareDiffHalf(vector<vector<int>> matrix, int n)
{
    int diff = 0;
    for (int i = 0; i < n/2; i++)
    {
        diff += (matrix[i][i] + matrix[n-i-1][n-i-1] - matrix[i][n-i-1] - matrix[n-i-1][i]);
    }
    return abs(diff);
}

Cannot read this. always go for a solutions others can read

could you explain?

Very good love you

Great

Yes, it is a good thinking .. If anyone has read Herbert Schildt or Deitel's Java books would have recognized it.. my solution is the same.. some one else should be able to read it quickly..

static int diagonalDifference(int[][] a) {
    int primeDi = 0, secondDi = 0;
    // could be improved to 
            // int sum = 0;
    for (int i = 0 , j = a[0].length-1; i < a[0].length ; i++, j--) {
        primeDi += a[i][i] ;
        secondDi += a[i][j] ;
                    // could be improved to 
                    // sum = a[i][i] - a[i][j] ;
    }

    return Math.abs(primeDi - secondDi);
            // could be improved to
            // return Math.abs(sum);
}

This is more efficient:

n--; for(int i = 0; i <= n; i++){ sum1 += a[i][i]; sum2 += a[n-i][i]; }

Like this is more efficient:

n--;

for(int i = 0; i <= n; i++){

sum1 += a[i][i];
sum2 += a[n-i][i];

}

I think this is the most elegant a clear solution. Well done

This is a fantastic solution.

Beautiful code

Did you try it?

doesn't matter , its abs diff

The positions of the elements in a matrix can be seen in terms of i and j and the values of i and j comes out to be as shown in the example below of a 3 x 3 matrix:

0,0  0,1  0,2

1,0  1,1  1,2

2,0  2,1  2,2

Here, the 1st digit represents the value of i and the 2nd digit represents value of j. There're two diagonals forming in the matrix given above. If we have to identify the diagonal elements in the matrix given above.

1st diagonal: 0,0 ;  1,1 ;  2,2.
2nd diagonal: 2,0  ;  1,1  ;   0,2.

Since the square matrix in the question/problem is represented by a Jagged Array (array of arrays). If you don't have an idea of what Jagged Array is, then you might need to first know about the Jagged Array at the following link: https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/arrays/jagged-arrays

Now we analyse the solution:

The solution is as follows:

static int diagonalDifference(int[][] arr) {
        int x = 0;
        int y = arr[0].Length - 1;
        int sum = 0;
        for(int index=0;  index<arr.Length;  index++){
            //sum -= arr[x][x] - arr[x++][y--]; can also be simplified as below:
	 sum = sum - ( arr[x][x] - arr[x++][y--] );
        }
        return Math.Abs(sum);
    }

Now, with the following test input:

11 2 4
4 5 6
10 8 -12

If we've to look at the approach via position wise: we've done it as:

Taking sum = 0
sum = sum - (position(0,0) - position(0,2))
then
sum = sum - (position(1,1) - position(1,1))
then
sum = sum - (position(2,2) - position(2,0))

We'll try to figure out how loop works on the test-input given above: We've initialized the value of x to be 0 and the value of y to be arr.Length -1. Note: arr.Length gives us the number of arrays in the Jagged Array, which in our case is 3. The Jagged array in question is as follows:

int[][] arr = new int[3][];
    arr[0] = new int[] {11, 2, 4};
    arr[1] = new int[]  {4, 5, 6};
    arr[2] = new int[]  {10, 8, -12};

So the size of Jagged Array: arr in question is 3 (which is arr.Length) where each array further contains a simple array of int as can be seen above.

Now let's analyse how loop works:

1st round of loop will run as follows:

the value of x = 0;
the value of y = 2; //came from arr.Length - 1 i.e. 3 - 1 = 2
arr[x][x] = arr[0][0] = 11
arr[x++][y--] = arr[0][2] = 4
sum = sum - (arr[x][x] - arr[x++][y--]) 
sum = sum - (arr[0][0] - arr[0][2])
sum= 0- (11-4)
sum = -7

After this operation the value of x++ will give 1 and y-- will give 1. The value of x and y for next loop operation becomes 1 and 1 respectively.

2nd round of loop will run as follows:

the value of x = 1
the value of y = 1
arr[x][x] = arr[1][1] = 5
arr[x++][y--] = arr[1][1] = 5
sum = sum - (arr[x][x] - arr[x++][y--]) 
sum = sum - (arr[1][1] - arr[1][1])
sum= -7 -(5 - 5)
sum = -7

After this operation the value of x++ will give 2 and y-- will give 0. The value of x and y for next loop operation becomes 2 and 0 respectively.

3rd round of loop will run as follows:

the value of x = 2
the value of y = 0
arr[x][x] = arr[2][2] = -12
arr[x++][y--] = arr[2][0] = 10
sum = sum - (arr[x][x] - arr[x++][y--]) 
sum = sum - (arr[2][2] - arr[2][0])
sum = -7 -(-12 - 10)
sum = - 7 -(-22)
sum = -7 + 22
sum = 15

After this operation the value of x++ will give 3 and y-- will give -1. The value of x and y for next loop operation becomes 3 and -1 respectively and this will fail the loop condition and the loop iteration will stop giving 15 as final result.