Sudoku solver

Data Structures
struct	sudoku
	Structure to hold the matrix and dimensions. More...

Functions
bool	OKrow (const struct sudoku *a, int x, int y, int v)
	Check if x^th row is valid.
bool	OKcol (const struct sudoku *a, int x, int y, int v)
	Check if y^th column is valid.
bool	OKbox (const struct sudoku *a, int x, int y, int v)
	Check if a 3x3 box is valid.
bool	OK (const struct sudoku *a, int x, int y, int v)
	Check if element v is valid to place at (x,y) location.
void	print (const struct sudoku *a)
	Print the matrix to stdout.
bool	get_next_unknown (const struct sudoku *a, int *x, int *y)
	Find and get the location for next empty cell.
bool	solve (struct sudoku *a)
	Function to solve a partially filled sudoku matrix.

Detailed Description

Function Documentation

get_next_unknown()

bool get_next_unknown	(	const struct sudoku *	a,
		int *	x,
		int *	y
	)

Find and get the location for next empty cell.

Parameters

[in]	a	pointer to sudoku instance
[out]	x	pointer to row index of next unknown
[out]	y	pointer to column index of next unknown

Returns

true if an empty location was found

false if no more empty locations found

{
    for (int i = 0; i < a->N; i++)
    {
        for (int j = 0; j < a->N; j++)
        {
            if (a->a[i * a->N + j] == 0)
            {
                *x = i;
                *y = j;
                return true;
            }
        }
    }
 
    /* no unknown locations found */
    return false;
}

OK()

bool OK	(	const struct sudoku *	a,
		int	x,
		int	y,
		int	v
	)

Check if element v is valid to place at (x,y) location.

Parameters

a	sudoku to check
x	row to place value
y	column to place value
v	value to check if it is valid

Returns

true if valid

false if in-valid

{
    bool result = OKrow(a, x, y, v);
    if (result)
        result = OKcol(a, x, y, v);
    if (result)
        result = OKbox(a, x, y, v);
 
    return result;
}

Here is the call graph for this function:

OKbox()

bool OKbox	(	const struct sudoku *	a,
		int	x,
		int	y,
		int	v
	)

Check if a 3x3 box is valid.

Parameters

a	matrix to check
x	row index of the element to check
y	column index of the element to check
v	value to check if it repeats

Returns

true if valid

false if in-valid

{
    /* get start indices of the box that the current (x,y) lies in
       remember that in C/C++, division operation always rounds towards
       -infinity for signed integers and towards 0 for unsigned integers
    */
    int bi = x - x % a->N2, bj = y - y % a->N2;
    // printf("Checking box: (%d,%d)\n", bi, bj);
 
    for (int i = bi; i < (bi + a->N2); i++)
        for (int j = bj; j < (bj + a->N2); j++)
            if (a->a[i * a->N + j] == v)
                // if the value is found in the box
                return false;
    return true;
}

OKcol()

bool OKcol	(	const struct sudoku *	a,
		int	x,
		int	y,
		int	v
	)

Check if y^th column is valid.

Parameters

a	sudoku to check
x	ignored row
y	column to check
v	value to check if it repeats

Returns

true if valid

false if in-valid

{
    for (int i = 0; i < a->N; i++)
        if (a->a[i * a->N + y] == v)
            // if the value is found in the column
            return false;
    return true;
}

OKrow()

bool OKrow	(	const struct sudoku *	a,
		int	x,
		int	y,
		int	v
	)

Check if x^th row is valid.

Parameters

a	sudoku to check
x	row to check
y	ignored column
v	value to check if it repeats

Returns

true if valid

false if in-valid

{
    int offset = x * a->N;
    for (int j = 0; j < a->N; j++)
        if (a->a[offset + j] == v)
            // if the value is found in the row
            return false;
    return true;
}

print()

void print

(

const struct sudoku *

a

)

Print the matrix to stdout.

Parameters

[in]

a

array to print

{
    int i, j;
    for (i = 0; i < a->N; i++)
        for (j = 0; j < a->N; j++)
            printf("%" SCNu8 "%c", a->a[i * a->N + j],
                   (j == a->N - 1 ? '\n' : ' '));
}

solve()

bool solve

(

struct sudoku *

a

)

Function to solve a partially filled sudoku matrix.

For each unknown value (0), the function fills a possible value and calls the function again to check forvalid solution.

Parameters

[in,out]

a

sudoku matrix to solve

Returns

true if solution found

false if no solution found

{
    static uint32_t counter = 0;
    int i, j;
    static char prefix[100] = "";  // enough memory
 
    if (!get_next_unknown(a, &i, &j))
    {
        /* no more empty location found
           implies all good in the matrix
         */
        return true;
    }
 
    /* try all possible values for the unknown */
    for (uint8_t v = 1; v <= a->N; v++)
    { /* try all possible values 1 thru N */
        printf("%sTry (%d,%d) = %" SCNu8 "... ", prefix, i, j, v);
        counter++;
        if (OK(a, i, j, v))
        {
            /* if assignment checks satisfy, set the value and
             continue with remaining elements */
            printf("passed (counter=%" SCNu32 ")\n", counter);
            a->a[i * a->N + j] = v;
            strcat(prefix, "  ");
            if (solve(a))
            {
                /* solution found */
                return true;
            }
 
            printf("%sBacktrack (%d,%d) <- %" SCNu8 " (counter=%" SCNu32 ")\n",
                   prefix, i, j, a->a[i * a->N + j], counter);
 
            prefix[strlen(prefix) - 2] = '\0';  // truncate the prefix
            a->a[i * a->N + j] = 0;
        }
        else
        {
            printf("\r");
        }
    }
 
    return false;
}

Here is the call graph for this function: