cdo/sudoku-solver
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Use uint16_t instead of struct for cell state

Browse Source 
- Bits 0-8 are the possible values
- Bits 9-12 is the concrete value
- Bit 15 is 1 if the cell is determined
This commit is contained in:
Camden Dixie O'Brien 2022-11-24 00:37:48 +00:00
parent 4a2cfb392f
commit f51e9a06b0
3 changed files with 49 additions and 41 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
solve.c
View File

@ -24,6 +24,7 @@ int solve(struct sudoku *sud)
{ {
unsigned r, c, n, i, j, val, np, pr, pc; unsigned r, c, n, i, j, val, np, pr, pc;
bool match; bool match;
uint16_t valmask;
for (n = 0;; ++n) { for (n = 0;; ++n) {
match = false; match = false;
@ -31,9 +32,12 @@ int solve(struct sudoku *sud)
/* Check if only one place a value can go on each row. */ /* Check if only one place a value can go on each row. */
for (r = 0; r < NDIGITS; ++r) { for (r = 0; r < NDIGITS; ++r) {
for (val = 0; val < NDIGITS; ++val) { for (val = 0; val < NDIGITS; ++val) {
valmask = 1 << val;
np = 0; np = 0;
for (c = 0; c < NDIGITS; ++c) { for (c = 0; c < NDIGITS; ++c) {
if (!sud->cells[r][c].det && sud->cells[r][c].pvals[val]) { if (!(sud->cells[r][c] & DETMASK)
&& sud->cells[r][c] & valmask) {
pr = r; pr = r;
pc = c; pc = c;
++np; ++np;
@ -52,9 +56,12 @@ int solve(struct sudoku *sud)
/* Check if only one place a value can go on each column. */ /* Check if only one place a value can go on each column. */
for (c = 0; c < NDIGITS; ++c) { for (c = 0; c < NDIGITS; ++c) {
for (val = 0; val < NDIGITS; ++val) { for (val = 0; val < NDIGITS; ++val) {
valmask = 1 << val;
np = 0; np = 0;
for (r = 0; r < NDIGITS; ++r) { for (r = 0; r < NDIGITS; ++r) {
if (!sud->cells[r][c].det && sud->cells[r][c].pvals[val]) { if (!(sud->cells[r][c] & DETMASK)
&& sud->cells[r][c] & valmask) {
pr = r; pr = r;
pc = c; pc = c;
++np; ++np;
@ -73,11 +80,14 @@ int solve(struct sudoku *sud)
/* Check if only one place a value can go in each segment. */ /* Check if only one place a value can go in each segment. */
for (i = 0; i < NDIGITS; ++i) { for (i = 0; i < NDIGITS; ++i) {
for (val = 0; val < NDIGITS; ++val) { for (val = 0; val < NDIGITS; ++val) {
valmask = 1 << val;
np = 0; np = 0;
for (j = 0; j < NDIGITS; ++j) { for (j = 0; j < NDIGITS; ++j) {
r = SEGLEN * (i / SEGLEN) + j / SEGLEN; r = SEGLEN * (i / SEGLEN) + j / SEGLEN;
c = SEGLEN * (i % SEGLEN) + j % SEGLEN; c = SEGLEN * (i % SEGLEN) + j % SEGLEN;
if (!sud->cells[r][c].det && sud->cells[r][c].pvals[val]) { if (!(sud->cells[r][c] & DETMASK)
&& sud->cells[r][c] & valmask) {
pr = r; pr = r;
pc = c; pc = c;
++np; ++np;

48
sud.c
View File

@ -24,20 +24,22 @@
#define MAX_FILL_ATTEMPTS 32 #define MAX_FILL_ATTEMPTS 32
static void initposs(struct sudoku *sud) #define CELLINIT 0x01ff
static void init(struct sudoku *sud)
{ {
for (unsigned r = 0; r < NDIGITS; ++r) { for (unsigned r = 0; r < NDIGITS; ++r) {
for (unsigned c = 0; c < NDIGITS; ++c) { for (unsigned c = 0; c < NDIGITS; ++c) {
sud->cells[r][c].det = false; sud->cells[r][c] = CELLINIT;
for (unsigned i = 0; i < NDIGITS; ++i)
sud->cells[r][c].pvals[i] = true;
} }
} }
} }
bool load(struct sudoku *sud, const char *ptr) bool load(struct sudoku *sud, const char *ptr)
{ {
initposs(sud);
init(sud);
for (unsigned i = 0; i < NCELLS; ++i) { for (unsigned i = 0; i < NCELLS; ++i) {
if (ptr[i] == '0') if (ptr[i] == '0')
continue; continue;
@ -53,18 +55,20 @@ enum update_res update(struct sudoku *sud, unsigned r, unsigned c, unsigned val)
unsigned tr, tc; unsigned tr, tc;
assert(val < NDIGITS); assert(val < NDIGITS);
const uint16_t clearmask = ~(1 << val);
/* Update possible values of cells in same column. */ /* Update possible values of cells in same column. */
for (tr = 0; tr < NDIGITS; ++tr) { for (tr = 0; tr < NDIGITS; ++tr) {
if (tr == r || sud->cells[tr][c].det) if (tr == r || DET(sud->cells[tr][c]))
continue; continue;
sud->cells[tr][c].pvals[val] = false; sud->cells[tr][c] &= clearmask;
} }
/* Update possible values of cells in same row. */ /* Update possible values of cells in same row. */
for (tc = 0; tc < NDIGITS; ++tc) { for (tc = 0; tc < NDIGITS; ++tc) {
if (tc == c || sud->cells[r][tc].det) if (tc == c || DET(sud->cells[r][tc]))
continue; continue;
sud->cells[r][tc].pvals[val] = false; sud->cells[r][tc] &= clearmask;
} }
/* Update possible values of cells in same segment. */ /* Update possible values of cells in same segment. */
@ -72,15 +76,15 @@ enum update_res update(struct sudoku *sud, unsigned r, unsigned c, unsigned val)
const unsigned segc0 = SEGLEN * (c / SEGLEN); const unsigned segc0 = SEGLEN * (c / SEGLEN);
for (tr = segr0; tr < segr0 + SEGLEN; ++tr) { for (tr = segr0; tr < segr0 + SEGLEN; ++tr) {
for (tc = segc0; tc < segc0 + SEGLEN; ++tc) { for (tc = segc0; tc < segc0 + SEGLEN; ++tc) {
if ((tr == r && tc == c) || sud->cells[tr][tc].det) if ((tr == r && tc == c) || DET(sud->cells[tr][tc]))
continue; continue;
sud->cells[tr][tc].pvals[val] = false; sud->cells[tr][tc] &= clearmask;
} }
} }
/* Set the cell's value. */ /* Set the cell's value. */
sud->cells[r][c].det = true; sud->cells[r][c] |= DETMASK;
sud->cells[r][c].val = val; sud->cells[r][c] |= val << VALSHIFT;
return OK; return OK;
} }
@ -103,8 +107,8 @@ void print(const struct sudoku *sud)
if (c != 0 && c % SEGLEN == 0) if (c != 0 && c % SEGLEN == 0)
fputs("| ", stdout); fputs("| ", stdout);
if (sud->cells[r][c].det) if (DET(sud->cells[r][c]))
printf("%u ", sud->cells[r][c].val + 1); printf("%u ", VAL(sud->cells[r][c]) + 1);
else else
fputs(" ", stdout); fputs(" ", stdout);
} }
@ -135,9 +139,9 @@ enum check_res check(const struct sudoku *sud)
for (r = 0; r < NDIGITS; ++r) { for (r = 0; r < NDIGITS; ++r) {
zerocounts(digitcounts); zerocounts(digitcounts);
for (c = 0; c < NDIGITS; ++c) { for (c = 0; c < NDIGITS; ++c) {
if (!sud->cells[r][c].det) if (!DET(sud->cells[r][c]))
return INCOMPLETE; return INCOMPLETE;
++digitcounts[sud->cells[r][c].val]; ++digitcounts[VAL(sud->cells[r][c])];
} }
if (!checkcounts(digitcounts)) if (!checkcounts(digitcounts))
return INCORRECT; return INCORRECT;
@ -147,9 +151,9 @@ enum check_res check(const struct sudoku *sud)
for (c = 0; c < NDIGITS; ++c) { for (c = 0; c < NDIGITS; ++c) {
zerocounts(digitcounts); zerocounts(digitcounts);
for (r = 0; r < NDIGITS; ++r) { for (r = 0; r < NDIGITS; ++r) {
if (!sud->cells[r][c].det) if (!DET(sud->cells[r][c]))
return INCOMPLETE; return INCOMPLETE;
++digitcounts[sud->cells[r][c].val]; ++digitcounts[VAL(sud->cells[r][c])];
} }
if (!checkcounts(digitcounts)) if (!checkcounts(digitcounts))
return INCORRECT; return INCORRECT;
@ -161,9 +165,9 @@ enum check_res check(const struct sudoku *sud)
for (j = 0; j < NDIGITS; ++j) { for (j = 0; j < NDIGITS; ++j) {
r = 3 * (i / 3) + j / 3; r = 3 * (i / 3) + j / 3;
c = 3 * (i % 3) + j % 3; c = 3 * (i % 3) + j % 3;
if (!sud->cells[r][c].det) if (!DET(sud->cells[r][c]))
return INCOMPLETE; return INCOMPLETE;
++digitcounts[sud->cells[r][c].val]; ++digitcounts[VAL(sud->cells[r][c])];
} }
if (!checkcounts(digitcounts)) if (!checkcounts(digitcounts))
return INCORRECT; return INCORRECT;
@ -177,7 +181,7 @@ bool filled(const struct sudoku *sud)
{ {
for (unsigned r = 0; r < NDIGITS; ++r) { for (unsigned r = 0; r < NDIGITS; ++r) {
for (unsigned c = 0; c < NDIGITS; ++c) { for (unsigned c = 0; c < NDIGITS; ++c) {
if (!sud->cells[r][c].det) if (!(DET(sud->cells[r][c])))
return false; return false;
} }
} }

26
sud.h
View File

@ -20,21 +20,21 @@
#define SUD_H #define SUD_H
#include <stdbool.h> #include <stdbool.h>
#include <stdint.h>
#define SEGLEN 3 #define SEGLEN 3
#define NDIGITS (SEGLEN * SEGLEN) #define NDIGITS 9
#define NCELLS (NDIGITS * NDIGITS) #define NCELLS 81
struct cellstate { #define DETMASK 0x8000
bool det; #define VALSHIFT 9
union { #define VALMASK 0x1e00
unsigned val;
bool pvals[NDIGITS]; #define DET(x) (x & DETMASK)
}; #define VAL(x) ((x & VALMASK) >> VALSHIFT)
};
struct sudoku { struct sudoku {
struct cellstate cells[NDIGITS][NDIGITS]; uint16_t cells[NDIGITS][NDIGITS];
}; };
enum update_res { NOT_ALLOWED, ALREADY_DET, OK }; enum update_res { NOT_ALLOWED, ALREADY_DET, OK };
@ -47,12 +47,6 @@ enum check_res { INCOMPLETE, INCORRECT, SOLVED };
*/ */
bool load(struct sudoku *sud, const char *ptr); bool load(struct sudoku *sud, const char *ptr);
/**
* Populate the sudoku with some random values. The proportion of
* cells that are filled will be approximately `fill_prop`.
*/
void gen(struct sudoku *sud, double fill_prop);
/** /**
* Attempt to update the cell at row `r`, column `c` to have the value * Attempt to update the cell at row `r`, column `c` to have the value
* `val`. Returns `OK` on success, `ALREADY_DET` if the cell is * `val`. Returns `OK` on success, `ALREADY_DET` if the cell is