find diagonal difference

diagonaldifference.c

#include <stdio.h>

int diagonalDifference(int arr[3][3]);

int main(int argc, char* argv[]){
  int arr[3][3] ={{1,2,3}, {4,5,6},{7,8,9}};
  printf("Resultado: %d\n", diagonalDifference(arr));
  return 0;
}
int diagonalDifference(int arr[3][3]){
  int diag1=0, diag2=0;
  for (int i=0; i < 3; i++) {
    if (i==0){
      diag1+=arr[i][i];
    }
    if (i==1){
      diag1+=arr[i][i];
    }
    if (i==2){
      diag1+=arr[i][i];
    }
  }
  for (int i=2; i >= 0; i--) {
    if (i==2){
      diag2+=arr[i][i-i];
    }
    if (i==1){
      diag2+=arr[i][i];
    }
    if (i==0){
      diag2+=arr[i][i+2];
    }
  }
  int result=diag1-diag2;
  return result;
}

Otro tipo de solución:

#include <stdio.h>
#define N 3
#define M 3

int diagonalDifference(int [][M]);

int main(void)
{
    int array[N][M] =
    {
        {1,2,3}, 
        {4,5,6},
        {7,8,9}
    };
    printf("Resultado: %d\n", diagonalDifference(array));
    return 0;
}

int diagonalDifference(int array[][M])
{
    int diag1=0, diag2=0;
    //Para recorrer la diagonal principal.
    for(int i = 0, j = 0; i < N; ++i)
        diag1 += array[i][j++];
    
    //Para recorrer la diagonal secundaria.
    for(int i = 0, j = N - 1; i < N; ++i)
        diag2 += array[i][j--];

    return diag1 - diag2;
}

Para recorrer la diagonal P. i incrementa y j incrementa, daría este resultado:

i = 0, j = 0
i = 1, j = 1
i = 2, j = 2

Para recorrer la 2do diagonal, i incrementa y j decrementa, daría este resultado:

;j = N-1
i = 0, j = 2
i = 1, j = 1
i = 2, j = 0

Para hacer todo dinámico, se lo puede hacer así:

#include <stdio.h>
#include <stdlib.h> /* malloc, free */

int diagonalDifference(int**, int);

int main(void)
{
    int n, m;
    printf("Ingrese el valor de N: ");
    scanf("%d", &n);

    printf("Ingrese el valor de M: ");
    scanf("%d", &m);

    //Reservamos memoria para un array de punteros.
    int** parray = malloc(sizeof(int*) * n);

    for(int i = 0; i < n; ++i)
        //Reservamos memoria para un array de enteros, cada puntero apunta a un array de enteros.
        parray[i] = malloc(sizeof(int) * m);

    /*
        Aquí podemos agregar un código para llenar la matriz...
    */

    printf("Resultado: %d\n", diagonalDifference(parray, n));

    //Liberamos la memoria 
    for(int i = 0; i < n; ++i)
        free(parray[i]);
    free(parray);
    return 0;
}

int diagonalDifference(int** parray, int n)
{
    int diag1=0, diag2=0;
    //Para recorrer la diagonal principal.
    for(int i = 0, j = 0; i < n; ++i)
        diag1 += parray[i][j++];
    
    //Para recorrer la diagonal secundaria.
    for(int i = 0, j = n - 1; i < n; ++i)
        diag2 += parray[i][j--];

    return diag1 - diag2;
}