eee

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
 #include <stdio.h>
#include <stdlib.h>

/* Проверки на правильность ввода int и double */
int myInput();
double myInputDouble();
void myInputPointer(int* a);
int compareString(char* a, char* b);
int isCharInt(char ch);
int isMyInputCorrect(int res);
int isMyInputDoubleCorrect(double res);

 /* Создание и ввод матриц */
int** resmat(int m, int n);
double **resmatDouble(int m, int n);
int** input(int m, int n, int* matrixCorrect);
double** inputDouble(int m, int n, int* matrixCorrect);

 /* Вывод матрицы */
// void output(int** matrix, int m, int n);
 void output(double** matrix, int m, int n) {
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (j == 0)
                printf("%lf", matrix[i][j]);
            else
                printf(" %lf", matrix[i][j]);
        }
        if (i != m - 1) printf("\n");
    }
}
 /* Определитель матрицы */
double determinant(double** mat, int n);

int main() {
  int n, i, j;

  n = myInput();
  if ( isMyInputCorrect(n) && n > 0) {
      int matrixCorrect = 1;
      double** mat = inputDouble(n,n,&matrixCorrect);

      printf("%.6lf\n", determinant(mat, n));
    //   output(mat,n,n);

      free(mat);

      return 0;
  }
}

double determinant(double** mat, int n) {
  double det = 0;
  int c, subi, i, j, subj;
  double** submat;

  if (n == 2) {
    return((mat[0][0] * mat[1][1]) - (mat[1][0] * mat[0][1]));
  }
  else {
    submat = resmatDouble(n,n);

    for (c = 0; c < n; c++) {
      subi = 0;
      for (i = 1; i < n; i++) {
        subj = 0;
        for (j = 0; j < n; j++) {
          if (j == c) {
            continue;
          }
          submat[subi][subj] = mat[i][j];
          subj++;
        }
        subi++;
      }
      det = det + (pow(-1, c) * mat[0][c] * determinant(submat, n - 1));
    }

    free(submat);
  }

  return det;
}


double **resmatDouble(int m, int n) {  // m -rows n -cols
    double **mat = (double **)malloc(m * n * sizeof(double) + m * sizeof(double *));
    double *ptr = (double *)(mat + m);
    for (int i = 0; i < m; i++) mat[i] = ptr + n * i;
    return mat;
}

int** input(int m, int n, int* matrixCorrect) {  // m -rows n -cols
    int** mat = (int**)malloc(m * n * sizeof(int) + m * sizeof(int*));
    int* ptr = (int*)(mat + m);
    int flag = 1;
    int temp;
    for (int i = 0; i < m; i++) mat[i] = ptr + n * i;
    for (int i = 0; i < m; i++)
        for (int j = 0; j < n; j++) {
            if (flag) {
                temp = myInput();
                if (!isMyInputCorrect(temp)) {
                    flag = 0;
                    *matrixCorrect = 0;
                } else {
                    mat[i][j] = temp;
                }
            }
        }
    return mat;
}

double** inputDouble(int m, int n, int* matrixCorrect) {  // m -rows n -cols
    double** mat = (double**)malloc(m * n * sizeof(double) + m * sizeof(double*));
    double* ptr = (double*)(mat + m);
    int flag = 1;
    int temp;
    for (int i = 0; i < m; i++) mat[i] = ptr + n * i;
    for (int i = 0; i < m; i++)
        for (int j = 0; j < n; j++) {
            if (flag) {
                // Сделать проверку на дабл

                temp = myInputDouble();
                // temp = myInputDouble();
                if (!isMyInputDoubleCorrect(temp)) {
                    flag = 0;
                    *matrixCorrect = 0;
                } else {
                    mat[i][j] = temp;
                }
            }
        }
    return mat;
}



/**************** Проверка на ввод инта **********
 * Концепция:
 *
 * Попытка проверить на инты без сторонних библиотек
 *
 * Так, моя идея создать функцию myInput() и там проверять через строки
 * Так как злые дяди и тети запретили мне использовать сторонние библиотеки
 * и я не могу использовать strcmp() я создал свой strcmp()
 * Более детальное объяснение снизу. Мы русские с нами бог...
 *************************************************/

/*************************************************
 * Функция myInput():
 * Какую же гадость я написал...
 *
 * У нас есть две строки checker
 * Изначально из консоли мы записываем в checker1
 * Переносим это все в int a
 * Потом int a преобразуем в строку и записываем в checker2
 * И по сути если мы ввели не int то здесь строки будут разные
 *
 * Проверка на одинаковость строк через другую непонятную функцию
 *************************************************/
int myInput() {
    int a;
    char checker1[256], checker2[256];
    if (1 != scanf("%s", checker1)) {
        a = -2147483647;
    } else {
        sscanf(checker1, "%d", &a);
        sprintf(checker2, "%d", a);
        if (compareString(checker1, checker2) != 0) {
            a = -2147483647;
        }
    }
    return a;
}
double myInputDouble() {
    double a, b;
    char checker1[256], checker2[256];
    if (1 != scanf("%lf", &a)) {
        a = -2147483647;
    } else {
        sprintf(checker1, "%lf", a);
        sscanf(checker1, "%lf", &b);
        sprintf(checker2, "%lf", b);
        if (compareString(checker1, checker2) != 0) {
            a = -2147483647;
        }
    }
    return a;
}

/*************************************************
 * Функция compareString():
 * Какую же гадость я написал x2...
 *
 * Концепция что мы проверяем посимвольно и если вдруг какой-то
 * символ другой возвращаем разницу этих символов по таблице ASCI
 *************************************************/
int compareString(char* a, char* b) {
    while ((*a == *b) && (*a != 0)) {
        // printf("%s. %d | ", a, *a);
        // printf("%s. %d\n", b, *b);
        a++;
        b++;
    }

    return *a - *b;
}

/*************************************************
 * Функция myInputPointer():
 * Жизнь меня заставляет использовать указатель...
 *
 * Концепция один в один как myInput() только вместо return используем указатель
 *************************************************/

void myInputPointer(int* a) {
    char checker1[256], checker2[256];
    if (1 != scanf("%s", checker1)) {
        *a = -2147483647;
    } else {
        sscanf(checker1, "%d", a);
        sprintf(checker2, "%d", *a);
        if (compareString(checker1, checker2) != 0) {
            *a = -2147483647;
        }
    }
}

/*************************************************
 * Функция isCharInt():
 * Жизнь странная штука. Теперь я добавляю еще одну странную функцию...
 *
 * Смысл украден с myInput()
 * Мы должны проверить является ли char числом [0-9]
 * Получаем char ch, значение заносим в char[] checker1, потом переносим
 * значение char[] checker1 в int a и потом в char[] checker2
 * По итогу сравниваем checker1 и checker2
 *
 * Возвращаемые значения: целая положительная цифра [0-9] or -10 if error
 *************************************************/

int isCharInt(char ch) {
    int a, res = 1;
    char checker1[256], checker2[256];
    sprintf(checker1, "%c", ch);
    sscanf(checker1, "%d", &a);
    sprintf(checker2, "%d", a);
    if (compareString(checker1, checker2) != 0) {
        res = -10;
    } else {
        res = a;
    }
    return res;
}

/*************************************************
 * Я устал делать проверки поетому пусть он за меня делает
 **************************************************/
int isMyInputCorrect(int res) {
    if (res != -2147483647) {
        return 1;
    } else {
        return 0;
    }
}
int isMyInputDoubleCorrect(double res) {
    if (res != -2147483647) {
        return 1;
    } else {
        return 0;
    }
}