sudoku/sudoku.h at 090f72df98cd1d062b2886f71e45fb2e37c952d6

 #ifndef SUDOKU_H
 #define SUDOKU_H
 #include "rlib.h"
 #include "rsolve.h"
 #include <stdio.h>
 #include <stdbool.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 #define ANSII_BLUE_BG "\033[34m"
 #define ANSII_RED_BG "\033[31m"
 #define ANSII_GREEN_BG "\033[32m"
 #define ANSII_CLEAR "\033[0m"
 #define N 9
 void draw_cell(int c)
 {
     if (c > 0 && c <= 3)
     {
         printf("%s", ANSII_BLUE_BG);
     }
     else if (c > 0 && c <= 6)
     {
         printf("%s", ANSII_GREEN_BG);
     }
     else if (c > 0 && c <= 9)
     {
         printf("%s", ANSII_RED_BG);
     }
     if(c){
         printf("%s%d ", c > 9 ? "" :" ", c );
     }else{
         printf(" 0 ");
     }
     printf("%s", ANSII_CLEAR);
 }
 char * grid_to_string(int grid[N][N]){
 	static char result[1024];
 	result[0] = 0;
 	for (int row = 0; row < N; row++) {
         for (int col = 0; col < N; col++) {
         	char chunk[4];
 	    	chunk[0] = 0;
 	        sprintf(chunk,"%d ",grid[row][col]);
 	        strcat(result,chunk);
         }
         strcat(result,"\n");
     }
     return result;
 }
 void print_grid(int grid[N][N],bool clear) {
     if(clear)
         printf("\033[2J\033[H");
     for (int row = 0; row < N; row++) {
         for (int col = 0; col < N; col++) {
             draw_cell(grid[row][col]);
             ///printf("%d ", grid[row][col]);
         }
         printf("\n");
     }
 }
 int count_neighbors2(int grid[N][N],int row, int col){
 	// Check row
     int num = -1;
      int neighbors = 0;
     for (int x = 0; x < N; x++) {
         if(grid[row][x])
 		neighbors++;
 	if (grid[row][x] == num) {
             return 0;
         }
     }
     // Check column
     for (int x = 0; x < N; x++) {
         if(grid[x][col])
 		neighbors++;
 	if (grid[x][col] == num) {
             return 0;
         }
     }
     // Check box
     int startRow = row - row % (N / 3), startCol = col - col % (N / 3);
     for (int i = 0; i < N / 3; i++) {
         for (int j = 0; j < N / 3; j++) {
 	    if(grid[i + startRow][j + startCol])
 		neighbors++;
             if (grid[i + startRow][j + startCol] == num) {
                 return 0;
             }
         }
     }
     return neighbors;
 }
 int is_safe(int grid[N][N], int row, int col, int num) {
     //if(count_neighbors(grid, row,col) < 4)
 	  //  return false;
 	// Check row
     for (int x = 0; x < N; x++) {
         if (grid[row][x] == num) {
             return false;
         }
     }
     // Check column
     for (int x = 0; x < N; x++) {
         if (grid[x][col] == num) {
             return false;
         }
     }
     // Check box
     int startRow = row - row % (N / 3), startCol = col - col % (N / 3);
     for (int i = 0; i < N / 3; i++) {
         for (int j = 0; j < N / 3; j++) {
             if (grid[i + startRow][j + startCol] == num) {
                 return false;
             }
         }
     }
     return true;
 }
 void grid_reset(int * grid){
     memset(grid,0,N*N*sizeof(int));
 }
 int * grid_copy(int * grid){
     int * new_grid = malloc(N*N*sizeof(int));
     memcpy(new_grid,grid,N*N*sizeof(int));
     return new_grid;
 }
 int * grid_new(){
     return (int *)calloc(sizeof(int),N*N);
 }
 bool empty_spot_is_available(int grid[N][N]){
     for (unsigned int row = 0; row < N; row++) {
         for (unsigned int col = 0; col < N; col++) {
             if (grid[row][col] == 0) {
                 return true;
             }
         }
     }
     return false;
 }
 unsigned long long _solve(int grid[N][N], unsigned long long *attempts, bool draw){
     (*attempts)++;
     unsigned int row, col;
     if(!get_easiest_cell(grid,&row,&col)){
         //print_grid(grid, false);
         return *attempts;
     }
     for(int num = 1; num < N + 1; num++){
         if(is_safe(grid,row,col,num)){
             grid[row][col] = num;
             //print_grid(grid,true);
             if(_solve(grid,attempts,draw))
             {
                 return *attempts;
             }
             grid[row][col] = 0;
         }
     }
     return 0;
 }
 unsigned int _solve2(int grid[N][N], unsigned long long * attempts, bool draw) {
     (*attempts)++;
     unsigned int row, col;
     bool emptySpot = false;
     for (row = 0; row < N; row++) {
         for (col = 0; col < N; col++) {
             if (grid[row][col] == 0) {
                // if(count_neighbors(grid,row,col) == 8){
                 //    print_grid(grid,true);
                 //    printf("Found neighbors\n");
                 //    exit(0);
                 //}
                 emptySpot = true;
                 break;
             }
         }
         if (emptySpot) {
             break;
         }
     }
     if(!emptySpot)
         return true;
     /*
     if (!empty_spot_is_available(grid)) {
         return true;
     }*/
     for (int num = 1; num <= 9; num++) {
         //unsigned int * easy_row = calloc(sizeof(int),1);
         //unsigned int * easy_col = calloc(sizeof(int), 1);
         //if(get_easiest_cell(grid,easy_row,easy_col)){
         //     row = *easy_row;
         //     free(easy_row);
         //     col = *easy_col;
         //     free(easy_col);
         //}
         if (is_safe(grid, row, col, num)) {
             grid[row][col] = num;
             if(draw)
                 print_grid(grid,true);
             if (_solve2(grid,attempts,draw)) {
                 return *attempts;
             }
             grid[row][col] = 0;
         }
     }
     return 0;
 }
 unsigned int solve2(int grid[N][N], bool draw){
     unsigned long long attempts = 0;
     return _solve(grid,&attempts, draw);
 }
 unsigned int solve(int grid[N][N],bool draw) {
     unsigned long long attempts = 0;
     return _solve2(grid,&attempts, draw);
 }
 #endif