Hey if you want the mathematics method that we had in course then refer to any textbook with a chapter on matrices.But for coding part if you are

😕 then

Check this thing out
Inverse = Adjoint divided by the determinant of matrix

Now how to find the adjoint again if you are 😕 then

Adjoint = Transpose of the matrix of cofactors.

Now how to find the cofactors again if you are 😕 then

cofactor of element is minor of the element multiplied by (-1) raised to (i+j)

Now how to find the minor again if you are 😕 then

minor is the value of the determinant formed by skipping the ith row and jth column then taking remaining rows and columns.

I guess i have clarified it enough.
The hard task is to find the determinant in generalized manner.
You have two loops one inside the another and then again two loops inside them to find the determinant of remaining rows and columns.Can you do this??????????????I have a big doubt Try it out even if you get the code working then also it would be of the complexity n^4 which is not advisable I think i posted quite a big suggestion sorry for that but i am really 😁

thanx dude.... but i know the method wat u tld above... but i need to know how the inverse come for given matrix.......
i already tried ur method....but its not give the solution.......

I forgot to specify that this method works only for the matrices with non zero determinant
see if your input satisfies this criteria

Below is my sample code to determine inverse of a matrix of order n.

  #include "stdio.h"
  
  #define MAX_MATRIX_ORDER 10
  
  void print_matrix(int matrix[MAX_MATRIX_ORDER][MAX_MATRIX_ORDER], int order) {
    int i = 0, j = 0;
    for(i = 0; i < order; i++) {
      for(j = 0; j < order; j++) {
        printf("%d ", matrix[i][j]);
      }
      printf("\n");
    }
  }
  
  long calculate_determinant(int matrix[MAX_MATRIX_ORDER][MAX_MATRIX_ORDER], int order) {
    int submatrix[MAX_MATRIX_ORDER][MAX_MATRIX_ORDER] = { 0 };
    int determinant = 0;
    int sign = 1;
    int i = 0, j = 0, k = 0;
  
    if(order == 1) {
      determinant = matrix[0][0];
    } else {
      for(i = 0; i < order; i++) {
        for(j = 0; j < (order - 1); j++) {
          for(k = 0; k < (order - 1); k++) {
            if(k < i) {
              submatrix[j][k] = matrix[j + 1][k];
            } else {
              submatrix[j][k] = matrix[j + 1][k + 1];
            }
          }
        }
        determinant += sign*matrix[0][i]*calculate_determinant(submatrix, order -1);
        sign = -sign;
      }
    }
  
    return determinant;
  }
  
  void determine_cofactor_matrix(int matrix[MAX_MATRIX_ORDER][MAX_MATRIX_ORDER], int cofactor_matrix[MAX_MATRIX_ORDER][MAX_MATRIX_ORDER], int order) {
    int submatrix[MAX_MATRIX_ORDER][MAX_MATRIX_ORDER] = { 0 };
    int sign_x = 1, sign_y = 1;
    int index_x = 0, index_y = 0;
    int i = 0, j = 0, k = 0, l = 0;
  
    if(order == 1) {
      cofactor_matrix[0][0] = matrix[0][0];
    } else {
      for(i = 0; i < order; i++) {
        for(j = 0; j < order; j++) {
          index_x = 0;
          index_y = 0;
          for(k = 0; k < order; k++) {
            if(k != i) {
              for(l = 0; l < order; l++) {
                if(l != j) {
                  submatrix[index_x][index_y] = matrix[k][l];
                  index_y++;
                }
              }
              index_x++;
              index_y = 0;
            }
          }
          cofactor_matrix[i][j] = sign_x*sign_y*calculate_determinant(submatrix, order -1);
          sign_y = -sign_y;
        }
        sign_x = -sign_x;
        sign_y = 1;
      }
    }
  }
  
  void determine_transpose_matrix(int matrix[MAX_MATRIX_ORDER][MAX_MATRIX_ORDER], int order) {
    int i = 0, j = 0, temp = 0;
    for(i = 0; i < order; i++) {
      for(j = 0; j <= i; j++) {
        temp = matrix[i][j];
        matrix[i][j] = matrix[j][i];
        matrix[j][i] = temp;
      }
    }
  }
  
  int main() {
    int matrix[MAX_MATRIX_ORDER][MAX_MATRIX_ORDER] = { 0 };
    int order = 0;
    long determinant = 0;
    int inverse_matrix[MAX_MATRIX_ORDER][MAX_MATRIX_ORDER] = { 0 };
    int i = 0, j = 0;
  
    scanf("%d", &order);
    if(order > MAX_MATRIX_ORDER) {
      printf("Matrix order too high\n");
      return 0;
    } else if(order < 1) {
      printf("Invalid matrix order\n");
      return 0;
    }
  
    for(i = 0; i < order; i++) {
      for(j = 0; j < order; j++) {
        scanf("%d", &matrix[i][j]);
      }
    }
  
    determinant = calculate_determinant(matrix, order);
    printf("Matrix:\n");
    print_matrix(matrix, order);
    if(determinant == 0) {
      printf("Determinant of matrix is ), inverse can't be find.");
    } else {
      determine_cofactor_matrix(matrix, inverse_matrix, order);
      determine_transpose_matrix(inverse_matrix, order);
    }
    printf("Inverse matrix: [A]*(1/%d)\n[A] =\n", determinant);
    print_matrix(inverse_matrix, order);
  
    return 0;
  }

Compile the file with above code and run as:
a.exe < input.txt > output.txt [on windows]
a.out < input.txt > output.txt [on linux]

Here,
a.exe or a.out are the executables generated after compilation

input.txt is the file containing input, e.g., if the matrix of order 3 is:
1 2 3
0 4 5
1 0 6
Then input.txt will be
3
1 2 3
0 4 5
1 0 6

output.txt is the output file containing result, for given example output.txt will contain
Matrix:
1 2 3
0 4 5
1 0 6
Inverse matrix: [A]*(1/22)
[A] =
24 -12 -2
5 3 -5
-4 2 4

Please let me know if any clarification on the code is required.

-Pradeep

Awesome code Pradeep keep it up but i guess has he got his solution i dont know but your code is good i must say

Indeed 😀 Pradeep is one of the CS experts on CE. We are proud to have him on CE.