Compare commits
1 Commits
old-method
...
row_col_bl
| Author | SHA1 | Date | |
|---|---|---|---|
3ccc6b4659
|
@ -1,2 +0,0 @@
|
||||
[build]
|
||||
rustflags = ["-C", "target-cpu=native", "-C", "target-feature=+crt-static"]
|
||||
1
.gitignore
vendored
1
.gitignore
vendored
@ -1,2 +1 @@
|
||||
/target
|
||||
/c_version/sudk_c
|
||||
|
||||
@ -9,6 +9,5 @@ edition = "2021"
|
||||
[profile.release]
|
||||
lto = true
|
||||
debug = false
|
||||
strip = true
|
||||
panic = "abort"
|
||||
codegen-units = 1
|
||||
panic = "abort"
|
||||
|
||||
@ -1,6 +0,0 @@
|
||||
#!/bin/bash
|
||||
set -e
|
||||
|
||||
clang -Wall -Wextra -Weverything -Werror -O3 -march=native -flto -std=c17 -fstack-protector-all -s -o sudk_c "$1"
|
||||
|
||||
time ./sudk_c
|
||||
@ -1,7 +0,0 @@
|
||||
#!/bin/bash
|
||||
|
||||
set -e
|
||||
|
||||
gcc -Wall -Wextra -Werror --std=c17 -march=native -O3 -fstack-protector-all -flto -s -o sudk_c "$1"
|
||||
|
||||
time ./sudk_c
|
||||
@ -1,287 +0,0 @@
|
||||
#include <stdbool.h>
|
||||
#include <stddef.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <sys/types.h>
|
||||
|
||||
#define PFSALLOC(bytes) malloc(bytes)
|
||||
|
||||
static inline void Print_Clear() { printf("\x1b\x5b\x48\x1b\x5b\x32\x4a"); }
|
||||
|
||||
typedef struct Sudoku {
|
||||
size_t *field;
|
||||
size_t *fixed;
|
||||
size_t *known;
|
||||
size_t size;
|
||||
size_t block_size;
|
||||
size_t pos;
|
||||
size_t pos_last_placed;
|
||||
size_t num_fields;
|
||||
} Sudoku;
|
||||
|
||||
static Sudoku *Sudoku_New(size_t block_size) {
|
||||
|
||||
Sudoku *s = calloc(1, sizeof(Sudoku));
|
||||
|
||||
size_t many_solutions_field[81] = {
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 8, 9, 0, 2, 0, 0, 0, 0,
|
||||
0, 2, 0, 4, 0, 0, 0, 0, 4, 0, 6, 0, 0, 0, 8, 0, 0, 0, 5, 0, 0,
|
||||
0, 0, 0, 0, 6, 5, 0, 0, 2, 0, 7, 4, 0, 3, 0, 0, 0, 5, 0, 4, 0,
|
||||
0, 0, 1, 8, 0, 0, 0, 0, 0, 0, 0, 8, 2, 0, 0, 0, 6, 0,
|
||||
};
|
||||
|
||||
size_t size = block_size * block_size;
|
||||
size_t *field = calloc(size * size, sizeof(size_t));
|
||||
size_t *fixed = calloc(size * size, sizeof(size_t));
|
||||
size_t *known = calloc(size * size, sizeof(size_t));
|
||||
|
||||
printf("num_fields: %zu\n", size * size);
|
||||
|
||||
s->field = field;
|
||||
s->fixed = fixed;
|
||||
s->known = known;
|
||||
|
||||
for (size_t idx = 0; idx < 81; idx++) {
|
||||
s->field[idx] = many_solutions_field[idx];
|
||||
}
|
||||
|
||||
for (size_t idx = 0; idx < 81; idx++) {
|
||||
if (s->field[idx] != 0) {
|
||||
s->fixed[idx] = 1;
|
||||
s->known[idx] = 1;
|
||||
}
|
||||
}
|
||||
|
||||
s->size = size;
|
||||
s->block_size = block_size;
|
||||
s->pos = 0;
|
||||
s->pos_last_placed = 0;
|
||||
s->num_fields = size * size;
|
||||
|
||||
return s;
|
||||
}
|
||||
|
||||
static void Sudoku_Print(Sudoku *s) {
|
||||
for (size_t idx = 0; idx < s->size * s->size; idx++) {
|
||||
|
||||
// newline
|
||||
if (idx != 0 && idx % s->size == 0)
|
||||
printf("\n");
|
||||
|
||||
// nr
|
||||
printf("%zu", s->field[idx]);
|
||||
|
||||
// space
|
||||
if ((idx + 1) % s->size != 0)
|
||||
printf(" ");
|
||||
}
|
||||
printf("\n");
|
||||
}
|
||||
|
||||
static inline bool Sudoku_Next(Sudoku *s) {
|
||||
if (s->pos == s->num_fields - 1) {
|
||||
/*printf("there is no next\n");*/
|
||||
return false;
|
||||
}
|
||||
|
||||
s->pos++;
|
||||
return true;
|
||||
}
|
||||
|
||||
static inline bool Sudoku_Prev(Sudoku *s) {
|
||||
if (s->pos == 0)
|
||||
return false;
|
||||
|
||||
s->pos--;
|
||||
return true;
|
||||
}
|
||||
|
||||
static inline bool Sudoku_IsFixed(Sudoku *s) { return s->fixed[s->pos] == 1; }
|
||||
|
||||
static inline size_t Sudoku_GetFieldAtPos(Sudoku *s, size_t pos) {
|
||||
return s->field[pos];
|
||||
}
|
||||
|
||||
static inline void Sudoku_Set(Sudoku *s, size_t nr) {
|
||||
s->field[s->pos] = nr;
|
||||
s->pos_last_placed = s->pos;
|
||||
}
|
||||
|
||||
static inline void Sudoku_ClearCurrentField(Sudoku *s) { Sudoku_Set(s, 0); }
|
||||
|
||||
/*static void Array_Print(char *name, size_t *arr, size_t len) {*/
|
||||
/*printf("%s: ", name);*/
|
||||
/*for (size_t idx = 0; idx < len; idx++) {*/
|
||||
/*if (idx < len - 1)*/
|
||||
/*printf("%zu ", arr[idx]);*/
|
||||
/*else*/
|
||||
/*printf("%zu", arr[idx]);*/
|
||||
/*}*/
|
||||
/*printf("\n");*/
|
||||
/*}*/
|
||||
|
||||
static inline bool Array_Contains(size_t *arr, size_t len, size_t nr) {
|
||||
/*printf("ARRAY_CONTAINS_LEN: %zu\n", len);*/
|
||||
for (size_t idx = 0; idx < len; idx++) {
|
||||
if (arr[idx] == nr) {
|
||||
/*printf("SEARCH FOR %zu --- ", nr);*/
|
||||
/*Array_Print("ARRAY_CONTAINS_TRUE", arr, len);*/
|
||||
return true;
|
||||
}
|
||||
}
|
||||
/*printf("SEARCH FOR %zu --- ", nr);*/
|
||||
/*Array_Print("ARRAY_CONTAINS_FALSE", arr, len);*/
|
||||
return false;
|
||||
}
|
||||
|
||||
static inline bool Sudoku_IsEnd(Sudoku *s) {
|
||||
return !Array_Contains(s->field, s->num_fields, 0);
|
||||
}
|
||||
|
||||
static inline bool Sudoku_GotoPrevFreeField(Sudoku *s) {
|
||||
do {
|
||||
if (!Sudoku_IsFixed(s))
|
||||
return true;
|
||||
} while (Sudoku_Prev(s));
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
static inline bool Sudoku_GotoNextFreeField(Sudoku *s) {
|
||||
/*printf("Sudoku_GotoNextFreeField\n");*/
|
||||
do {
|
||||
if (!Sudoku_IsFixed(s))
|
||||
return true;
|
||||
} while (Sudoku_Next(s));
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
static inline size_t *Sudoku_GetRow(Sudoku *s) {
|
||||
size_t *tmp = PFSALLOC(s->size * sizeof(size_t));
|
||||
for (size_t pos = 0; pos < s->size; pos++) {
|
||||
tmp[pos] = Sudoku_GetFieldAtPos(s, (s->pos / s->size) * s->size + pos);
|
||||
}
|
||||
return tmp;
|
||||
}
|
||||
|
||||
static inline size_t *Sudoku_GetCol(Sudoku *s) {
|
||||
size_t *tmp = PFSALLOC(s->size * sizeof(size_t));
|
||||
for (size_t pos = 0; pos < s->size; pos++) {
|
||||
tmp[pos] = Sudoku_GetFieldAtPos(s, pos * s->size + s->pos % s->size);
|
||||
}
|
||||
return tmp;
|
||||
}
|
||||
|
||||
static inline size_t *Sudoku_GetBlock(Sudoku *s) {
|
||||
size_t *tmp = PFSALLOC(s->size * sizeof(size_t));
|
||||
|
||||
size_t block_start_row = s->pos / s->size / s->block_size * s->block_size;
|
||||
size_t block_start_col = s->pos % s->size / s->block_size * s->block_size;
|
||||
|
||||
for (size_t r = 0; r < s->block_size; r++) {
|
||||
for (size_t c = 0; c < s->block_size; c++) {
|
||||
tmp[r * s->block_size + c] = Sudoku_GetFieldAtPos(
|
||||
s, s->size * (block_start_row + r) + block_start_col + c);
|
||||
}
|
||||
}
|
||||
return tmp;
|
||||
}
|
||||
|
||||
static inline bool Sudoku_BlockOk(Sudoku *s, size_t nr) {
|
||||
size_t *block = Sudoku_GetBlock(s);
|
||||
/*Array_Print("BLOCK", block, s->size);*/
|
||||
bool ok = !Array_Contains(block, s->size, nr);
|
||||
return ok;
|
||||
}
|
||||
|
||||
static inline bool Sudoku_RowOk(Sudoku *s, size_t nr) {
|
||||
size_t *row = Sudoku_GetRow(s);
|
||||
bool ok = !Array_Contains(row, s->size, nr);
|
||||
return ok;
|
||||
}
|
||||
|
||||
static inline bool Sudoku_ColOk(Sudoku *s, size_t nr) {
|
||||
size_t *col = Sudoku_GetCol(s);
|
||||
bool ok = !Array_Contains(col, s->size, nr);
|
||||
return ok;
|
||||
}
|
||||
|
||||
static inline bool Sudoku_Ok(Sudoku *s, size_t nr) {
|
||||
return Sudoku_BlockOk(s, nr) && Sudoku_ColOk(s, nr) && Sudoku_RowOk(s, nr);
|
||||
}
|
||||
|
||||
static inline bool Sudoku_PutValidNr(Sudoku *s) {
|
||||
size_t current_nr = Sudoku_GetFieldAtPos(s, s->pos);
|
||||
|
||||
/*printf("%s() pos=%zu current_nr=%zu\n", __func__, s->pos, current_nr);*/
|
||||
|
||||
for (size_t nr = current_nr; nr < s->size + 1; nr++) {
|
||||
if (Sudoku_Ok(s, nr)) {
|
||||
/*printf("%s() pos=%zu current_nr=%zu nr=%zu\n", __func__, s->pos,*/
|
||||
/*current_nr, nr);*/
|
||||
Sudoku_Set(s, nr);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
static bool Sudoku_SolveBacktracking(Sudoku *s) {
|
||||
bool found_solution = false;
|
||||
size_t num_solutions = 0;
|
||||
while (1) {
|
||||
/*printf("LOOP: pos=%zu\n", s->pos);*/
|
||||
/*Sudoku_Print(s);*/
|
||||
if (Sudoku_IsEnd(s)) {
|
||||
/*printf("END\n");*/
|
||||
found_solution = true;
|
||||
num_solutions++;
|
||||
if (num_solutions % 100 == 0) {
|
||||
Print_Clear();
|
||||
printf("Solutions: %zu\n", num_solutions);
|
||||
Sudoku_Print(s);
|
||||
}
|
||||
|
||||
if (Sudoku_IsFixed(s)) {
|
||||
/*printf("fixed\n");*/
|
||||
continue;
|
||||
}
|
||||
Sudoku_ClearCurrentField(s);
|
||||
Sudoku_Prev(s);
|
||||
Sudoku_GotoPrevFreeField(s);
|
||||
}
|
||||
|
||||
if (Sudoku_IsFixed(s)) {
|
||||
/*printf("fixed -> goto next\n");*/
|
||||
Sudoku_Next(s);
|
||||
continue;
|
||||
}
|
||||
|
||||
if (Sudoku_GotoNextFreeField(s)) {
|
||||
if (Sudoku_PutValidNr(s)) {
|
||||
Sudoku_Next(s);
|
||||
continue;
|
||||
} else {
|
||||
Sudoku_ClearCurrentField(s);
|
||||
if (!Sudoku_Prev(s)) {
|
||||
printf("Number of solutions: %zu\n", num_solutions);
|
||||
break;
|
||||
}
|
||||
if (!Sudoku_GotoPrevFreeField(s)) {
|
||||
printf("Number of solutions: %zu\n", num_solutions);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return found_solution;
|
||||
}
|
||||
|
||||
int main() {
|
||||
Sudoku *s = Sudoku_New(3);
|
||||
Sudoku_Print(s);
|
||||
Sudoku_SolveBacktracking(s);
|
||||
/*Sudoku_Print(s);*/
|
||||
}
|
||||
@ -1,278 +0,0 @@
|
||||
#include <stdbool.h>
|
||||
#include <stddef.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <sys/types.h>
|
||||
|
||||
static size_t *tmpArr;
|
||||
|
||||
static inline void Print_Clear() { printf("\x1b\x5b\x48\x1b\x5b\x32\x4a"); }
|
||||
|
||||
typedef struct Sudoku {
|
||||
size_t *field;
|
||||
size_t *fixed;
|
||||
size_t size;
|
||||
size_t block_size;
|
||||
size_t pos;
|
||||
size_t pos_last_placed;
|
||||
size_t num_fields;
|
||||
} Sudoku;
|
||||
|
||||
static Sudoku *Sudoku_New(size_t block_size) {
|
||||
|
||||
Sudoku *s = calloc(1, sizeof(Sudoku));
|
||||
|
||||
size_t many_solutions_field[81] = {
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 8, 9, 0, 2, 0, 0, 0, 0,
|
||||
0, 2, 0, 4, 0, 0, 0, 0, 4, 0, 6, 0, 0, 0, 8, 0, 0, 0, 5, 0, 0,
|
||||
0, 0, 0, 0, 6, 5, 0, 0, 2, 0, 7, 4, 0, 3, 0, 0, 0, 5, 0, 4, 0,
|
||||
0, 0, 1, 8, 0, 0, 0, 0, 0, 0, 0, 8, 2, 0, 0, 0, 6, 0,
|
||||
};
|
||||
|
||||
size_t size = block_size * block_size;
|
||||
size_t *field = calloc(size * size, sizeof(size_t));
|
||||
size_t *fixed = calloc(size * size, sizeof(size_t));
|
||||
|
||||
printf("num_fields: %zu\n", size * size);
|
||||
|
||||
s->field = field;
|
||||
s->fixed = fixed;
|
||||
|
||||
for (size_t idx = 0; idx < 81; idx++) {
|
||||
s->field[idx] = many_solutions_field[idx];
|
||||
}
|
||||
|
||||
for (size_t idx = 0; idx < 81; idx++) {
|
||||
if (s->field[idx] != 0) {
|
||||
s->fixed[idx] = 1;
|
||||
}
|
||||
}
|
||||
|
||||
s->size = size;
|
||||
s->block_size = block_size;
|
||||
s->pos = 0;
|
||||
s->pos_last_placed = 0;
|
||||
s->num_fields = size * size;
|
||||
|
||||
tmpArr = calloc(s->size, sizeof(size_t));
|
||||
|
||||
return s;
|
||||
}
|
||||
|
||||
static void Sudoku_Print(Sudoku *s) {
|
||||
for (size_t idx = 0; idx < s->size * s->size; idx++) {
|
||||
|
||||
// newline
|
||||
if (idx != 0 && idx % s->size == 0)
|
||||
printf("\n");
|
||||
|
||||
// nr
|
||||
printf("%zu", s->field[idx]);
|
||||
|
||||
// space
|
||||
if ((idx + 1) % s->size != 0)
|
||||
printf(" ");
|
||||
}
|
||||
printf("\n");
|
||||
}
|
||||
|
||||
static inline bool Sudoku_Next(Sudoku *s) {
|
||||
if (s->pos == s->num_fields - 1) {
|
||||
/*printf("there is no next\n");*/
|
||||
return false;
|
||||
}
|
||||
|
||||
s->pos++;
|
||||
return true;
|
||||
}
|
||||
|
||||
static inline bool Sudoku_Prev(Sudoku *s) {
|
||||
if (s->pos == 0)
|
||||
return false;
|
||||
|
||||
s->pos--;
|
||||
return true;
|
||||
}
|
||||
|
||||
static inline bool Sudoku_IsFixed(Sudoku *s) { return s->fixed[s->pos] == 1; }
|
||||
|
||||
static inline size_t Sudoku_GetFieldAtPos(Sudoku *s, size_t pos) {
|
||||
return s->field[pos];
|
||||
}
|
||||
|
||||
static inline void Sudoku_Set(Sudoku *s, size_t nr) {
|
||||
s->field[s->pos] = nr;
|
||||
s->pos_last_placed = s->pos;
|
||||
}
|
||||
|
||||
static inline void Sudoku_ClearCurrentField(Sudoku *s) { Sudoku_Set(s, 0); }
|
||||
|
||||
static inline bool Array_Contains(size_t *arr, size_t len, size_t nr) {
|
||||
/*printf("ARRAY_CONTAINS_LEN: %zu\n", len);*/
|
||||
for (size_t idx = 0; idx < len; idx++) {
|
||||
if (arr[idx] == nr) {
|
||||
/*printf("SEARCH FOR %zu --- ", nr);*/
|
||||
/*Array_Print("ARRAY_CONTAINS_TRUE", arr, len);*/
|
||||
return true;
|
||||
}
|
||||
}
|
||||
/*printf("SEARCH FOR %zu --- ", nr);*/
|
||||
/*Array_Print("ARRAY_CONTAINS_FALSE", arr, len);*/
|
||||
return false;
|
||||
}
|
||||
|
||||
static inline bool Sudoku_IsEnd(Sudoku *s) {
|
||||
return !Array_Contains(s->field, s->num_fields, 0);
|
||||
}
|
||||
|
||||
static inline bool Sudoku_GotoPrevFreeField(Sudoku *s) {
|
||||
do {
|
||||
if (!Sudoku_IsFixed(s))
|
||||
return true;
|
||||
} while (Sudoku_Prev(s));
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
static inline bool Sudoku_GotoNextFreeField(Sudoku *s) {
|
||||
/*printf("Sudoku_GotoNextFreeField\n");*/
|
||||
do {
|
||||
if (!Sudoku_IsFixed(s))
|
||||
return true;
|
||||
} while (Sudoku_Next(s));
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
static inline size_t *Sudoku_GetRow(Sudoku *s) {
|
||||
for (size_t pos = 0; pos < s->size; pos++) {
|
||||
tmpArr[pos] = Sudoku_GetFieldAtPos(s, (s->pos / s->size) * s->size + pos);
|
||||
}
|
||||
return tmpArr;
|
||||
}
|
||||
|
||||
static inline size_t *Sudoku_GetCol(Sudoku *s) {
|
||||
for (size_t pos = 0; pos < s->size; pos++) {
|
||||
tmpArr[pos] = Sudoku_GetFieldAtPos(s, pos * s->size + s->pos % s->size);
|
||||
}
|
||||
return tmpArr;
|
||||
}
|
||||
|
||||
static inline size_t *Sudoku_GetBlock(Sudoku *s) {
|
||||
size_t block_start_row = s->pos / s->size / s->block_size * s->block_size;
|
||||
size_t block_start_col = s->pos % s->size / s->block_size * s->block_size;
|
||||
|
||||
for (size_t r = 0; r < s->block_size; r++) {
|
||||
for (size_t c = 0; c < s->block_size; c++) {
|
||||
tmpArr[r * s->block_size + c] = Sudoku_GetFieldAtPos(
|
||||
s, s->size * (block_start_row + r) + block_start_col + c);
|
||||
}
|
||||
}
|
||||
return tmpArr;
|
||||
}
|
||||
|
||||
static inline bool Sudoku_BlockOk(Sudoku *s, size_t nr) {
|
||||
size_t *block = Sudoku_GetBlock(s);
|
||||
/*Array_Print("BLOCK", block, s->size);*/
|
||||
bool ok = !Array_Contains(block, s->size, nr);
|
||||
return ok;
|
||||
}
|
||||
|
||||
static inline bool Sudoku_RowOk(Sudoku *s, size_t nr) {
|
||||
size_t *row = Sudoku_GetRow(s);
|
||||
bool ok = !Array_Contains(row, s->size, nr);
|
||||
return ok;
|
||||
}
|
||||
|
||||
static inline bool Sudoku_ColOk(Sudoku *s, size_t nr) {
|
||||
size_t *col = Sudoku_GetCol(s);
|
||||
bool ok = !Array_Contains(col, s->size, nr);
|
||||
return ok;
|
||||
}
|
||||
|
||||
static inline bool Sudoku_Ok(Sudoku *s, size_t nr) {
|
||||
return Sudoku_BlockOk(s, nr) && Sudoku_ColOk(s, nr) && Sudoku_RowOk(s, nr);
|
||||
}
|
||||
|
||||
static inline bool Sudoku_PutValidNr(Sudoku *s) {
|
||||
size_t current_nr = Sudoku_GetFieldAtPos(s, s->pos);
|
||||
|
||||
/*printf("%s() pos=%zu current_nr=%zu\n", __func__, s->pos, current_nr);*/
|
||||
|
||||
for (size_t nr = current_nr; nr < s->size + 1; nr++) {
|
||||
if (Sudoku_Ok(s, nr)) {
|
||||
/*printf("%s() pos=%zu current_nr=%zu nr=%zu\n", __func__, s->pos,*/
|
||||
/*current_nr, nr);*/
|
||||
Sudoku_Set(s, nr);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
static bool Sudoku_SolveBacktracking(Sudoku *s) {
|
||||
bool found_solution = false;
|
||||
size_t num_solutions = 0;
|
||||
while (1) {
|
||||
/*printf("LOOP: pos=%zu\n", s->pos);*/
|
||||
/*Sudoku_Print(s);*/
|
||||
if (Sudoku_IsEnd(s)) {
|
||||
/*printf("END\n");*/
|
||||
found_solution = true;
|
||||
num_solutions++;
|
||||
if (num_solutions % 100 == 0) {
|
||||
Print_Clear();
|
||||
printf("Solutions: %zu\n", num_solutions);
|
||||
Sudoku_Print(s);
|
||||
}
|
||||
|
||||
if (Sudoku_IsFixed(s)) {
|
||||
/*printf("fixed\n");*/
|
||||
continue;
|
||||
}
|
||||
Sudoku_ClearCurrentField(s);
|
||||
Sudoku_Prev(s);
|
||||
Sudoku_GotoPrevFreeField(s);
|
||||
}
|
||||
|
||||
if (Sudoku_IsFixed(s)) {
|
||||
/*printf("fixed -> goto next\n");*/
|
||||
Sudoku_Next(s);
|
||||
continue;
|
||||
}
|
||||
|
||||
if (Sudoku_GotoNextFreeField(s)) {
|
||||
if (Sudoku_PutValidNr(s)) {
|
||||
Sudoku_Next(s);
|
||||
continue;
|
||||
} else {
|
||||
Sudoku_ClearCurrentField(s);
|
||||
if (!Sudoku_Prev(s)) {
|
||||
printf("Number of solutions: %zu\n", num_solutions);
|
||||
break;
|
||||
}
|
||||
if (!Sudoku_GotoPrevFreeField(s)) {
|
||||
printf("Number of solutions: %zu\n", num_solutions);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return found_solution;
|
||||
}
|
||||
|
||||
static void Sudoku_Free(Sudoku *s) {
|
||||
free(s->field);
|
||||
free(s->fixed);
|
||||
free(s);
|
||||
s = NULL;
|
||||
}
|
||||
|
||||
int main() {
|
||||
Sudoku *s = Sudoku_New(3);
|
||||
Sudoku_Print(s);
|
||||
Sudoku_SolveBacktracking(s);
|
||||
Sudoku_Free(s);
|
||||
free(tmpArr);
|
||||
}
|
||||
@ -1,266 +0,0 @@
|
||||
#include <stdbool.h>
|
||||
#include <stddef.h>
|
||||
#include <stdint.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <sys/types.h>
|
||||
|
||||
static inline void Print_Clear() { printf("\x1b\x5b\x48\x1b\x5b\x32\x4a"); }
|
||||
|
||||
typedef struct Sudoku {
|
||||
uint8_t *field;
|
||||
bool *fixed;
|
||||
size_t size;
|
||||
size_t block_size;
|
||||
size_t pos;
|
||||
size_t pos_last_placed;
|
||||
size_t num_fields;
|
||||
} Sudoku;
|
||||
|
||||
static Sudoku *Sudoku_New(size_t block_size) {
|
||||
|
||||
Sudoku *s = calloc(1, sizeof(Sudoku));
|
||||
|
||||
// clang-format off
|
||||
uint8_t many_solutions_field[81] = {
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 9,
|
||||
0, 0, 0, 0, 8, 9, 0, 2, 0,
|
||||
0, 0, 0, 0, 2, 0, 4, 0, 0,
|
||||
0, 0, 4, 0, 6, 0, 0, 0, 8,
|
||||
0, 0, 0, 5, 0, 0, 0, 0, 0,
|
||||
0, 6, 5, 0, 0, 2, 0, 7, 4,
|
||||
0, 3, 0, 0, 0, 5, 0, 4, 0,
|
||||
0, 0, 1, 8, 0, 0, 0, 0, 0,
|
||||
0, 0, 8, 2, 0, 0, 0, 6, 0,
|
||||
};
|
||||
// clang-format on
|
||||
|
||||
size_t size = block_size * block_size;
|
||||
uint8_t *field = calloc(size * size, sizeof(uint8_t));
|
||||
bool *fixed = calloc(size * size, sizeof(bool));
|
||||
|
||||
printf("num_fields: %zu\n", size * size);
|
||||
|
||||
s->field = field;
|
||||
s->fixed = fixed;
|
||||
|
||||
for (size_t idx = 0; idx < 81; idx++) {
|
||||
s->field[idx] = many_solutions_field[idx];
|
||||
}
|
||||
|
||||
for (size_t idx = 0; idx < 81; idx++) {
|
||||
if (s->field[idx] != 0) {
|
||||
s->fixed[idx] = true;
|
||||
}
|
||||
}
|
||||
|
||||
s->size = size;
|
||||
s->block_size = block_size;
|
||||
s->pos = 0;
|
||||
s->pos_last_placed = 0;
|
||||
s->num_fields = size * size;
|
||||
|
||||
return s;
|
||||
}
|
||||
|
||||
static inline void Sudoku_Print(Sudoku *s) {
|
||||
for (size_t idx = 0; idx < s->num_fields; idx++) {
|
||||
|
||||
// newline
|
||||
if (idx != 0 && idx % s->size == 0)
|
||||
printf("\n");
|
||||
|
||||
// nr
|
||||
printf("%hhu", s->field[idx]);
|
||||
|
||||
// space
|
||||
if ((idx + 1) % s->size != 0)
|
||||
printf(" ");
|
||||
}
|
||||
printf("\n");
|
||||
}
|
||||
|
||||
static inline bool Sudoku_Next(Sudoku *s) {
|
||||
if (s->pos == s->num_fields - 1) {
|
||||
return false;
|
||||
}
|
||||
|
||||
s->pos++;
|
||||
return true;
|
||||
}
|
||||
|
||||
static inline bool Sudoku_Prev(Sudoku *s) {
|
||||
if (s->pos == 0)
|
||||
return false;
|
||||
|
||||
s->pos--;
|
||||
return true;
|
||||
}
|
||||
|
||||
static inline bool Sudoku_IsFixed(Sudoku *s) { return s->fixed[s->pos]; }
|
||||
|
||||
static inline uint8_t Sudoku_GetFieldAtPos(Sudoku *s, size_t pos) {
|
||||
return s->field[pos];
|
||||
}
|
||||
|
||||
static inline void Sudoku_Set(Sudoku *s, uint8_t nr) {
|
||||
s->field[s->pos] = nr;
|
||||
s->pos_last_placed = s->pos;
|
||||
}
|
||||
|
||||
static inline void Sudoku_ClearCurrentField(Sudoku *s) { Sudoku_Set(s, 0); }
|
||||
|
||||
static inline bool Array_Contains(uint8_t *arr, size_t len, uint8_t nr) {
|
||||
for (size_t idx = 0; idx < len; idx++) {
|
||||
if (arr[idx] == nr) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
static inline bool Sudoku_IsEnd(Sudoku *s) {
|
||||
return !Array_Contains(s->field, s->num_fields, 0);
|
||||
}
|
||||
|
||||
static inline bool Sudoku_GotoPrevFreeField(Sudoku *s) {
|
||||
do {
|
||||
if (!Sudoku_IsFixed(s))
|
||||
return true;
|
||||
} while (Sudoku_Prev(s));
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
static inline bool Sudoku_GotoNextFreeField(Sudoku *s) {
|
||||
do {
|
||||
if (!Sudoku_IsFixed(s))
|
||||
return true;
|
||||
} while (Sudoku_Next(s));
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
static inline void Sudoku_GetRow(Sudoku *s, uint8_t *row) {
|
||||
for (size_t pos = 0; pos < s->size; pos++) {
|
||||
row[pos] = Sudoku_GetFieldAtPos(s, (s->pos / s->size) * s->size + pos);
|
||||
}
|
||||
}
|
||||
|
||||
static inline void Sudoku_GetCol(Sudoku *s, uint8_t *col) {
|
||||
for (size_t pos = 0; pos < s->size; pos++) {
|
||||
col[pos] = Sudoku_GetFieldAtPos(s, pos * s->size + s->pos % s->size);
|
||||
}
|
||||
}
|
||||
|
||||
static inline void Sudoku_GetBlock(Sudoku *s, uint8_t *block) {
|
||||
size_t block_start_row = s->pos / s->size / s->block_size * s->block_size;
|
||||
size_t block_start_col = s->pos % s->size / s->block_size * s->block_size;
|
||||
|
||||
for (size_t r = 0; r < s->block_size; r++) {
|
||||
for (size_t c = 0; c < s->block_size; c++) {
|
||||
block[r * s->block_size + c] = Sudoku_GetFieldAtPos(
|
||||
s, s->size * (block_start_row + r) + block_start_col + c);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static inline bool Sudoku_BlockOk(Sudoku *s, uint8_t nr) {
|
||||
bool ok;
|
||||
uint8_t block[9] = {0};
|
||||
Sudoku_GetBlock(s, block);
|
||||
ok = !Array_Contains(block, s->size, nr);
|
||||
return ok;
|
||||
}
|
||||
|
||||
static inline bool Sudoku_RowOk(Sudoku *s, uint8_t nr) {
|
||||
bool ok;
|
||||
uint8_t row[9] = {0};
|
||||
Sudoku_GetRow(s, row);
|
||||
ok = !Array_Contains(row, s->size, nr);
|
||||
return ok;
|
||||
}
|
||||
|
||||
static inline bool Sudoku_ColOk(Sudoku *s, uint8_t nr) {
|
||||
bool ok;
|
||||
uint8_t col[9] = {0};
|
||||
Sudoku_GetCol(s, col);
|
||||
ok = !Array_Contains(col, s->size, nr);
|
||||
return ok;
|
||||
}
|
||||
|
||||
static inline bool Sudoku_Ok(Sudoku *s, uint8_t nr) {
|
||||
return Sudoku_BlockOk(s, nr) && Sudoku_ColOk(s, nr) && Sudoku_RowOk(s, nr);
|
||||
}
|
||||
|
||||
static inline bool Sudoku_PutValidNr(Sudoku *s) {
|
||||
uint8_t current_nr = Sudoku_GetFieldAtPos(s, s->pos);
|
||||
for (uint8_t nr = current_nr; nr < s->size + 1; nr++) {
|
||||
if (Sudoku_Ok(s, nr)) {
|
||||
Sudoku_Set(s, nr);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
static bool Sudoku_SolveBacktracking(Sudoku *s) {
|
||||
bool found_solution = false;
|
||||
size_t num_solutions = 0;
|
||||
while (1) {
|
||||
if (Sudoku_IsEnd(s)) {
|
||||
found_solution = true;
|
||||
num_solutions++;
|
||||
if (num_solutions % 100 == 0) {
|
||||
Print_Clear();
|
||||
printf("Solutions: %zu\n", num_solutions);
|
||||
Sudoku_Print(s);
|
||||
}
|
||||
|
||||
if (Sudoku_IsFixed(s)) {
|
||||
continue;
|
||||
}
|
||||
Sudoku_ClearCurrentField(s);
|
||||
Sudoku_Prev(s);
|
||||
Sudoku_GotoPrevFreeField(s);
|
||||
}
|
||||
|
||||
if (Sudoku_IsFixed(s)) {
|
||||
Sudoku_Next(s);
|
||||
continue;
|
||||
}
|
||||
|
||||
if (Sudoku_GotoNextFreeField(s)) {
|
||||
if (Sudoku_PutValidNr(s)) {
|
||||
Sudoku_Next(s);
|
||||
continue;
|
||||
} else {
|
||||
Sudoku_ClearCurrentField(s);
|
||||
if (!Sudoku_Prev(s)) {
|
||||
printf("Number of solutions: %zu\n", num_solutions);
|
||||
break;
|
||||
}
|
||||
if (!Sudoku_GotoPrevFreeField(s)) {
|
||||
printf("Number of solutions: %zu\n", num_solutions);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return found_solution;
|
||||
}
|
||||
|
||||
static void Sudoku_Free(Sudoku *s) {
|
||||
free(s->field);
|
||||
free(s->fixed);
|
||||
free(s);
|
||||
s = NULL;
|
||||
}
|
||||
|
||||
int main() {
|
||||
Sudoku *s = Sudoku_New(3);
|
||||
Sudoku_Print(s);
|
||||
Sudoku_SolveBacktracking(s);
|
||||
Sudoku_Free(s);
|
||||
}
|
||||
375
src/main.rs
375
src/main.rs
@ -1,22 +1,52 @@
|
||||
use std::time::Instant;
|
||||
|
||||
const BLOCK_SIZE: usize = 3;
|
||||
const SIZE: usize = BLOCK_SIZE * BLOCK_SIZE;
|
||||
const NUM_FIELDS: usize = SIZE * SIZE;
|
||||
|
||||
struct SField {
|
||||
field: Vec<u8>,
|
||||
fixed: Vec<bool>,
|
||||
field: Vec<usize>,
|
||||
rows: Vec<Vec<usize>>,
|
||||
cols: Vec<Vec<usize>>,
|
||||
blocks: Vec<Vec<usize>>,
|
||||
fixed: Vec<usize>,
|
||||
size: usize,
|
||||
block_size: usize,
|
||||
pos: usize,
|
||||
possible_values: Vec<Vec<u8>>,
|
||||
pos_last_placed: usize,
|
||||
num_fields: usize,
|
||||
possible_values: Vec<Vec<usize>>,
|
||||
}
|
||||
|
||||
impl SField {
|
||||
pub fn new() -> SField {
|
||||
pub fn new(block_size: usize) -> SField {
|
||||
let size = block_size * block_size;
|
||||
|
||||
// EMPTY FIELD
|
||||
// let field = vec![0; size * size];
|
||||
|
||||
// BLOCK_SIZE 4
|
||||
// #[rustfmt::skip]
|
||||
// let field = vec![
|
||||
// 0,15,0,0,0,0,11,4,0,5,0,0,0,0,12,8,
|
||||
// 12,0,0,9,0,1,0,5,0,0,8,15,0,0,0,13,
|
||||
// 0,0,3,0,0,10,13,0,0,11,4,0,15,0,6,0,
|
||||
// 13,10,0,11,0,0,0,14,0,3,2,0,0,9,0,0,
|
||||
// 0,0,15,10,8,0,0,0,0,0,14,0,0,6,2,0,
|
||||
// 0,0,14,0,0,0,6,0,0,0,0,0,1,0,0,0,
|
||||
// 0,11,0,8,3,0,15,1,6,0,0,0,0,0,0,7,
|
||||
// 0,6,0,7,0,0,0,0,8,13,0,0,10,0,0,0,
|
||||
// 0,14,0,2,0,0,0,0,3,0,5,0,11,15,9,0,
|
||||
// 0,0,0,12,11,0,2,0,0,0,0,0,0,0,0,0,
|
||||
// 0,8,0,0,6,14,1,0,13,15,0,0,0,0,0,10,
|
||||
// 10,0,0,3,9,0,7,0,0,1,0,0,13,12,8,0,
|
||||
// 7,0,0,0,0,0,14,0,0,0,0,0,0,0,0,9,
|
||||
// 0,3,0,14,0,0,9,6,0,0,0,0,0,4,0,0,
|
||||
// 0,4,6,0,0,7,0,0,0,0,0,0,0,0,0,0,
|
||||
// 5,2,0,0,0,4,10,15,1,0,3,0,0,0,7,0,
|
||||
// ];
|
||||
|
||||
// MANY SOLUTIONS
|
||||
#[rustfmt::skip]
|
||||
let field = vec![
|
||||
0,0,0,0,0,0,0,0,0,
|
||||
0,0,0,0,8,9,0,0,0,
|
||||
0,0,0,0,0,0,0,0,9,
|
||||
0,0,0,0,8,9,0,2,0,
|
||||
0,0,0,0,2,0,4,0,0,
|
||||
0,0,4,0,6,0,0,0,8,
|
||||
0,0,0,5,0,0,0,0,0,
|
||||
@ -26,32 +56,116 @@ impl SField {
|
||||
0,0,8,2,0,0,0,6,0,
|
||||
];
|
||||
|
||||
let mut fixed = Vec::with_capacity(SIZE * SIZE);
|
||||
// HARD
|
||||
// #[rustfmt::skip]
|
||||
// let field = vec![
|
||||
// 8,4,0,0,6,0,5,0,1,
|
||||
// 0,0,0,0,0,3,0,4,0,
|
||||
// 0,0,6,9,0,0,0,0,7,
|
||||
// 0,2,0,7,1,0,0,0,6,
|
||||
// 0,0,0,6,3,0,0,0,0,
|
||||
// 9,0,0,0,0,0,0,5,0,
|
||||
// 0,0,0,0,4,0,0,6,0,
|
||||
// 2,0,0,0,0,0,1,8,0,
|
||||
// 0,0,5,0,0,0,3,0,0,
|
||||
// ];
|
||||
|
||||
// EASY
|
||||
// #[rustfmt::skip]
|
||||
// let field = vec![
|
||||
// 5,9,0,6,1,3,0,0,0,
|
||||
// 0,0,0,9,0,0,5,0,0,
|
||||
// 8,0,3,0,5,7,6,4,0,
|
||||
// 0,7,5,0,0,0,4,0,6,
|
||||
// 0,6,0,7,4,0,2,0,8,
|
||||
// 2,0,8,0,0,0,7,5,3,
|
||||
// 0,0,0,5,6,1,0,7,0,
|
||||
// 0,0,1,0,7,0,9,0,0,
|
||||
// 7,3,6,0,2,0,0,0,0,
|
||||
// ];
|
||||
|
||||
let mut fixed = Vec::with_capacity(size * size);
|
||||
field.iter().for_each(|e| {
|
||||
if *e == 0 {
|
||||
fixed.push(false);
|
||||
fixed.push(0);
|
||||
} else {
|
||||
fixed.push(true);
|
||||
fixed.push(1);
|
||||
}
|
||||
});
|
||||
|
||||
let rows = SField::rows_from_plain_field(&field);
|
||||
let cols = SField::cols_from_plain_field(&field);
|
||||
let blocks = SField::blocks_from_plain_field(&field);
|
||||
|
||||
SField {
|
||||
field,
|
||||
rows,
|
||||
cols,
|
||||
blocks,
|
||||
fixed,
|
||||
size,
|
||||
block_size,
|
||||
pos: 0,
|
||||
possible_values: vec![vec![]; SIZE * SIZE],
|
||||
pos_last_placed: 0,
|
||||
num_fields: size * size,
|
||||
possible_values: vec![vec![]; size * size],
|
||||
}
|
||||
}
|
||||
|
||||
fn rows_from_plain_field(field: &[usize]) -> Vec<Vec<usize>> {
|
||||
let mut rows = vec![vec![0; 9]; 9];
|
||||
for row in 0..9 {
|
||||
for col in 0..9 {
|
||||
rows[row][col] = field[row * 9 + col];
|
||||
}
|
||||
}
|
||||
rows
|
||||
}
|
||||
|
||||
fn cols_from_plain_field(field: &[usize]) -> Vec<Vec<usize>> {
|
||||
let mut cols = vec![vec![0; 9]; 9];
|
||||
for row in 0..9 {
|
||||
for col in 0..9 {
|
||||
cols[col][row] = field[row * 9 + col];
|
||||
}
|
||||
}
|
||||
cols
|
||||
}
|
||||
|
||||
fn blocks_from_plain_field(field: &[usize]) -> Vec<Vec<usize>> {
|
||||
fn get_block_with_pos(field: &[usize], pos: usize) -> Vec<usize> {
|
||||
let block_start_row = pos / 9 / 3 * 3;
|
||||
let block_start_col = pos % 9 / 3 * 3;
|
||||
|
||||
let mut block = vec![];
|
||||
|
||||
for r in 0..3 {
|
||||
for c in 0..3 {
|
||||
block.push(field[9 * (block_start_row + r) + block_start_col + c])
|
||||
}
|
||||
}
|
||||
|
||||
block
|
||||
}
|
||||
|
||||
let mut blocks = vec![];
|
||||
let block_start_positions = [0, 3, 6, 27, 30, 33, 54, 57, 60];
|
||||
for pos in block_start_positions {
|
||||
blocks.push(get_block_with_pos(field, pos));
|
||||
}
|
||||
|
||||
blocks
|
||||
}
|
||||
|
||||
fn build_possible_values_db(&mut self) {
|
||||
for idx in 0..NUM_FIELDS {
|
||||
if self.fixed[idx] {
|
||||
for idx in 0..self.num_fields {
|
||||
if self.fixed[idx] == 1 {
|
||||
continue;
|
||||
}
|
||||
self.pos = idx;
|
||||
// try all values between 1 and =self.size and remember the good ones
|
||||
let mut good_ones = Vec::with_capacity(SIZE);
|
||||
for nr in 1..=(SIZE as u8) {
|
||||
let mut good_ones = Vec::with_capacity(self.size);
|
||||
for nr in 1..=self.size {
|
||||
if self.ok(nr) {
|
||||
good_ones.push(nr);
|
||||
}
|
||||
@ -62,15 +176,26 @@ impl SField {
|
||||
}
|
||||
|
||||
pub fn solve_backtracking(&mut self) -> bool {
|
||||
let mut found_solution = false;
|
||||
let mut num_solutions = 0;
|
||||
loop {
|
||||
if self.is_end() {
|
||||
num_solutions += 1;
|
||||
|
||||
if num_solutions % 10_000 == 0 {
|
||||
//let mut loop_count = 0;
|
||||
loop {
|
||||
//std::thread::sleep_ms(30);
|
||||
//self.print_clear();
|
||||
//self.print();
|
||||
//loop_count += 1;
|
||||
//if loop_count % 1000000 == 0 {
|
||||
//self.print_clear();
|
||||
//self.print();
|
||||
//}
|
||||
if self.is_end() {
|
||||
found_solution = true;
|
||||
num_solutions += 1;
|
||||
if num_solutions % 100 == 0 {
|
||||
self.print_clear();
|
||||
println!("Solutions: {}", num_solutions);
|
||||
self.print();
|
||||
println!("Number of solutions: {}", num_solutions);
|
||||
}
|
||||
|
||||
if self.is_fixed() {
|
||||
@ -91,6 +216,8 @@ impl SField {
|
||||
self.next();
|
||||
continue;
|
||||
} else {
|
||||
//println!("put_valid_nr failed for pos {}", self.pos);
|
||||
//std::thread::sleep_ms(300);
|
||||
self.clear_current_field();
|
||||
if !self.prev() {
|
||||
println!("Number of solutions: {}", num_solutions);
|
||||
@ -104,7 +231,7 @@ impl SField {
|
||||
}
|
||||
}
|
||||
|
||||
num_solutions > 0
|
||||
found_solution
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
@ -117,6 +244,11 @@ impl SField {
|
||||
print!("\x1b\x5b\x31\x3b\x33\x32\x6d");
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
fn print_red(&self) {
|
||||
print!("\x1b\x5b\x31\x3b\x33\x31\x6d");
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
fn print_neutral(&self) {
|
||||
print!("\x1b\x5b\x31\x3b\x30\x6d");
|
||||
@ -129,12 +261,14 @@ impl SField {
|
||||
|
||||
#[inline(always)]
|
||||
fn print(&self) {
|
||||
for i in 0..NUM_FIELDS {
|
||||
if i != 0 && i % SIZE == 0 {
|
||||
for i in 0..self.num_fields {
|
||||
if i != 0 && i % self.size == 0 {
|
||||
println!();
|
||||
}
|
||||
|
||||
if i == self.pos {
|
||||
if i == self.pos_last_placed {
|
||||
self.print_red();
|
||||
} else if i == self.pos {
|
||||
self.print_green();
|
||||
} else if self.get_field_at_pos(i) == 0 {
|
||||
self.print_gray();
|
||||
@ -142,7 +276,7 @@ impl SField {
|
||||
|
||||
print!("{:2} ", self.get_field_at_pos(i));
|
||||
|
||||
if i == self.pos || self.get_field_at_pos(i) == 0 {
|
||||
if i == self.pos || i == self.pos_last_placed || self.get_field_at_pos(i) == 0 {
|
||||
self.print_neutral();
|
||||
}
|
||||
}
|
||||
@ -182,7 +316,7 @@ impl SField {
|
||||
fn _put_valid_nr(&mut self) -> bool {
|
||||
let current_nr = self.get_field_at_pos(self.pos);
|
||||
|
||||
for nr in current_nr..(SIZE + 1) as u8 {
|
||||
for nr in current_nr..self.size + 1 {
|
||||
if self.ok(nr) {
|
||||
self.set(nr);
|
||||
return true;
|
||||
@ -220,14 +354,14 @@ impl SField {
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
fn ok(&self, nr: u8) -> bool {
|
||||
fn ok(&self, nr: usize) -> bool {
|
||||
self.block_ok(nr) && self.row_ok(nr) && self.col_ok(nr)
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
fn _pos_to_xy(&self) -> (usize, usize) {
|
||||
let y = self.pos / SIZE;
|
||||
let x = self.pos % SIZE;
|
||||
let y = self.pos / self.size;
|
||||
let x = self.pos % self.size;
|
||||
(x + 1, y + 1)
|
||||
}
|
||||
|
||||
@ -236,11 +370,11 @@ impl SField {
|
||||
// safety: self.pos can be used to index the field unchecked
|
||||
// since the only methods modifying self.pos are
|
||||
// `next()` and `prev()` and they do bounds checking
|
||||
unsafe { *self.fixed.get_unchecked(self.pos) }
|
||||
unsafe { *self.fixed.get_unchecked(self.pos) == 1 }
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
fn get_field_at_pos(&self, pos: usize) -> u8 {
|
||||
fn get_field_at_pos(&self, pos: usize) -> usize {
|
||||
// safety:
|
||||
// TODO
|
||||
// would need to mathematically explain that the calculations in
|
||||
@ -249,61 +383,107 @@ impl SField {
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
fn set(&mut self, nr: u8) {
|
||||
fn get_x_y_block_blockoffset(&self) -> (usize, usize, usize, usize) {
|
||||
// TODO:
|
||||
// this only works for 3x3 sudoku
|
||||
#[rustfmt::skip]
|
||||
let block_nrs = [
|
||||
0, 1, 2, 9,10,11,18,19,20,
|
||||
3, 4, 5,12,13,14,21,22,23,
|
||||
6, 7, 8,15,16,17,24,25,26,
|
||||
27,28,29,36,37,38,45,46,47,
|
||||
30,31,32,39,40,41,48,49,50,
|
||||
33,34,35,42,43,44,51,52,53,
|
||||
54,55,56,63,64,65,72,73,74,
|
||||
57,58,59,66,67,68,75,76,77,
|
||||
60,61,62,69,70,71,78,79,80,
|
||||
];
|
||||
|
||||
let y = self.pos / self.size;
|
||||
let x = self.pos % self.size;
|
||||
|
||||
let block_field = unsafe { block_nrs.get_unchecked(self.pos) };
|
||||
|
||||
let block_nr = block_field / self.size;
|
||||
let block_offset = block_field - (block_nr * self.size);
|
||||
|
||||
(x, y, block_nr, block_offset)
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
fn set(&mut self, nr: usize) {
|
||||
//assert_eq!(self.field, self.flatten_rows());
|
||||
//assert_eq!(self.field, self.flatten_cols());
|
||||
//assert_eq!(self.field, self.flatten_blocks());
|
||||
|
||||
self.field[self.pos] = nr;
|
||||
self.pos_last_placed = self.pos;
|
||||
|
||||
// update rows, cols and blocks
|
||||
// this is more expensive than only updating field but should be outweight
|
||||
// by the fact that row_ok(), col_ok() and block_ok() just need to do simple
|
||||
// lookups now
|
||||
|
||||
let (x, y, block_nr, block_offset) = self.get_x_y_block_blockoffset();
|
||||
|
||||
//println!("[{},{}] setting {}", y, x, nr);
|
||||
|
||||
let row = unsafe { self.rows.get_unchecked_mut(y) };
|
||||
let value = unsafe { row.get_unchecked_mut(x) };
|
||||
*value = nr;
|
||||
|
||||
let col = unsafe { self.cols.get_unchecked_mut(x) };
|
||||
let value = unsafe { col.get_unchecked_mut(y) };
|
||||
*value = nr;
|
||||
|
||||
let block = unsafe { self.blocks.get_unchecked_mut(block_nr) };
|
||||
let value = unsafe { block.get_unchecked_mut(block_offset) };
|
||||
*value = nr;
|
||||
|
||||
//assert_eq!(self.field, self.flatten_rows());
|
||||
//assert_eq!(self.field, self.flatten_cols());
|
||||
//assert_eq!(self.field, self.flatten_blocks());
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
fn get_row(&self, row: &mut [u8; SIZE]) {
|
||||
for (idx, row_elem) in row.iter_mut().enumerate() {
|
||||
*row_elem = self.get_field_at_pos((self.pos / SIZE) * SIZE + idx);
|
||||
}
|
||||
fn block_ok(&self, nr: usize) -> bool {
|
||||
// TODO
|
||||
// works only on 3x3 sudoku
|
||||
#[rustfmt::skip]
|
||||
let block_nrs = [
|
||||
0,0,0,1,1,1,2,2,2,
|
||||
0,0,0,1,1,1,2,2,2,
|
||||
0,0,0,1,1,1,2,2,2,
|
||||
3,3,3,4,4,4,5,5,5,
|
||||
3,3,3,4,4,4,5,5,5,
|
||||
3,3,3,4,4,4,5,5,5,
|
||||
6,6,6,7,7,7,8,8,8,
|
||||
6,6,6,7,7,7,8,8,8,
|
||||
6,6,6,7,7,7,8,8,8,
|
||||
];
|
||||
|
||||
let block_nr = unsafe { block_nrs.get_unchecked(self.pos) };
|
||||
//println!("Block {}: {:?}", block_nr, self.blocks[*block_nr]);
|
||||
!unsafe { self.blocks.get_unchecked(*block_nr) }.contains(&nr)
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
fn get_col(&self, col: &mut [u8; SIZE]) {
|
||||
for (idx, col_elem) in col.iter_mut().enumerate() {
|
||||
*col_elem = self.get_field_at_pos(idx * SIZE + self.pos % SIZE);
|
||||
}
|
||||
fn row_ok(&self, nr: usize) -> bool {
|
||||
let row_nr = self.pos / self.size;
|
||||
//println!("{:?}", self.rows[row_nr]);
|
||||
!unsafe { self.rows.get_unchecked(row_nr) }.contains(&nr)
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
fn get_block(&self, block: &mut [u8; SIZE]) {
|
||||
let block_start_row = self.pos / SIZE / BLOCK_SIZE * BLOCK_SIZE;
|
||||
let block_start_col = self.pos % SIZE / BLOCK_SIZE * BLOCK_SIZE;
|
||||
|
||||
for r in 0..BLOCK_SIZE {
|
||||
for c in 0..BLOCK_SIZE {
|
||||
block[r * BLOCK_SIZE + c] =
|
||||
self.get_field_at_pos(SIZE * (block_start_row + r) + block_start_col + c);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
fn block_ok(&self, nr: u8) -> bool {
|
||||
let mut block = [0; SIZE];
|
||||
self.get_block(&mut block);
|
||||
!block.contains(&nr)
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
fn row_ok(&self, nr: u8) -> bool {
|
||||
let mut row = [0; SIZE];
|
||||
self.get_row(&mut row);
|
||||
!row.contains(&nr)
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
fn col_ok(&self, nr: u8) -> bool {
|
||||
let mut col = [0; SIZE];
|
||||
self.get_col(&mut col);
|
||||
!col.contains(&nr)
|
||||
fn col_ok(&self, nr: usize) -> bool {
|
||||
let col_nr = self.pos % self.size;
|
||||
//println!("{:?}", self.cols[col_nr]);
|
||||
!unsafe { self.cols.get_unchecked(col_nr) }.contains(&nr)
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
fn next(&mut self) -> bool {
|
||||
if self.pos == NUM_FIELDS - 1 {
|
||||
if self.pos == self.num_fields - 1 {
|
||||
return false;
|
||||
}
|
||||
|
||||
@ -327,12 +507,53 @@ impl SField {
|
||||
if !self.solve_backtracking() {
|
||||
println!("there is no solution.");
|
||||
}
|
||||
eprintln!("took {:.3}s", now.elapsed().as_secs_f64());
|
||||
println!("took {:.3} seconds", now.elapsed().as_secs_f64());
|
||||
}
|
||||
|
||||
//fn flatten_blocks(&self) -> Vec<usize> {
|
||||
//#[rustfmt::skip]
|
||||
//let block_nrs = [
|
||||
//0, 1, 2, 9,10,11,18,19,20,
|
||||
//3, 4, 5,12,13,14,21,22,23,
|
||||
//6, 7, 8,15,16,17,24,25,26,
|
||||
//27,28,29,36,37,38,45,46,47,
|
||||
//30,31,32,39,40,41,48,49,50,
|
||||
//33,34,35,42,43,44,51,52,53,
|
||||
//54,55,56,63,64,65,72,73,74,
|
||||
//57,58,59,66,67,68,75,76,77,
|
||||
//60,61,62,69,70,71,78,79,80,
|
||||
//];
|
||||
|
||||
//let mut flattened = Vec::with_capacity(self.num_fields);
|
||||
//for (idx, nr) in block_nrs.iter().enumerate() {
|
||||
//let block_nr = nr / self.size;
|
||||
//let block_offset = nr - (block_nr * self.size);
|
||||
//flattened.push(self.blocks[block_nr][block_offset]);
|
||||
//}
|
||||
//flattened
|
||||
//}
|
||||
|
||||
//fn flatten_rows(&self) -> Vec<usize> {
|
||||
//let mut flattened = Vec::with_capacity(self.num_fields);
|
||||
//for row in self.rows.iter() {
|
||||
//for val in row {
|
||||
//flattened.push(*val);
|
||||
//}
|
||||
//}
|
||||
//flattened
|
||||
//}
|
||||
|
||||
//fn flatten_cols(&self) -> Vec<usize> {
|
||||
//let mut flattened = Vec::with_capacity(self.num_fields);
|
||||
//for idx in 0..self.num_fields {
|
||||
//flattened.push(self.cols[idx % self.size][idx / self.size]);
|
||||
//}
|
||||
//flattened
|
||||
//}
|
||||
}
|
||||
|
||||
fn run() -> Result<(), String> {
|
||||
let mut field = SField::new();
|
||||
let mut field = SField::new(3);
|
||||
|
||||
field.build_possible_values_db();
|
||||
|
||||
|
||||
Reference in New Issue
Block a user