ddidderr/sudk
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Compare commits

base: ddidderr:main
Branches Tags
ddidderr:main
ddidderr:old-method
ddidderr:bitsets
ddidderr:size4_measurements_loops_per_sec
ddidderr:row_col_block_datastructures
ddidderr:v0.1.1
..
compare: ddidderr:row_col_block_datastructures
Branches Tags
ddidderr:main
ddidderr:old-method
ddidderr:bitsets
ddidderr:size4_measurements_loops_per_sec
ddidderr:row_col_block_datastructures
ddidderr:v0.1.1

1 Commits
main ... row_col_bl

Author SHA1 Message Date
ddidderr
3ccc6b4659
row col block as different datasets. 
unexpectedly this seems to be slower for now... :(
 2022-07-18 16:07:07 +02:00
11 changed files with 433 additions and 1500 deletions
Show Stats Expand all files Collapse all files

1
.gitignore vendored
View File

@ -1,2 +1 @@
/target /target
/c_version/sudk_c

2
Cargo.lock generated
View File

@ -4,4 +4,4 @@ version = 3
[[package]] [[package]]
name = "sudk" name = "sudk"
version = "0.1.1" version = "0.1.0"

10
Cargo.toml
View File

@ -1,19 +1,13 @@
[package] [package]
name = "sudk" name = "sudk"
version = "0.1.1" version = "0.1.0"
authors = ["ddidderr <ddidderr@paul.network>"] authors = ["ddidderr <ddidderr@paul.network>"]
edition = "2021" edition = "2021"
[lints.clippy]
pedantic = { level = "warn", priority = -1 }
todo = "warn"
unwrap_used = "warn"
[dependencies] [dependencies]
[profile.release] [profile.release]
lto = true lto = true
debug = false debug = false
strip = true
panic = "abort"
codegen-units = 1 codegen-units = 1
panic = "abort"

6
c_version/clangtest
View File

@ -1,6 +0,0 @@
#!/bin/bash
set -e
clang -Weverything -Wno-unsafe-buffer-usage -Werror -O3 -march=native -flto -std=c17 -fstack-protector-all -s -o sudk_c "$1"
time ./sudk_c

7
c_version/gcctest
View File

@ -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

287
c_version/sudk_lots_of_allocs_for_tmp_rows_cols_blocks.c
View File

@ -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);*/
}

278
c_version/sudk_no_alloc_instead_use_global_mut_mem_once_initialized_on_start.c
View File

@ -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);
}

266
c_version/sudk_stack.c
View File

@ -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(void) { 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(void) {
Sudoku *s = Sudoku_New(3);
Sudoku_Print(s);
Sudoku_SolveBacktracking(s);
Sudoku_Free(s);
}

491
flamegraph.svg
View File

File diff suppressed because one or more lines are too long
Side by Side

Before

Width:  |  Height:  |  Size: 31 KiB

3
rustfmt.toml
View File

@ -1,3 +0,0 @@
group_imports = "StdExternalCrate"
imports_granularity = "Crate"
imports_layout = "HorizontalVertical"

582
src/main.rs
View File

@ -1,39 +1,52 @@
use std::time::Instant; use std::time::Instant;
const BLOCK_SIZE: usize = 3;
const SIZE: usize = BLOCK_SIZE * BLOCK_SIZE;
const NUM_FIELDS: usize = SIZE * SIZE;
fn print_gray() {
print!("\x1b\x5b\x31\x3b\x33\x30\x6d");
}
fn print_green() {
print!("\x1b\x5b\x31\x3b\x33\x32\x6d");
}
fn print_neutral() {
print!("\x1b\x5b\x31\x3b\x30\x6d");
}
fn print_clear() {
print!("\x1b\x5b\x48\x1b\x5b\x32\x4a");
}
struct SField { struct SField {
field: Vec<u8>, field: Vec<usize>,
skip_forward: Vec<u8>, rows: Vec<Vec<usize>>,
skip_backward: Vec<u8>, cols: Vec<Vec<usize>>,
blocks: Vec<Vec<usize>>,
fixed: Vec<usize>,
size: usize,
block_size: usize,
pos: usize, pos: usize,
possible_values: Vec<Vec<u8>>, pos_last_placed: usize,
num_fields: usize,
possible_values: Vec<Vec<usize>>,
} }
impl SField { 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] #[rustfmt::skip]
let field = vec![ let field = vec![
0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,9,
0,0,0,0,8,9,0,0,0, 0,0,0,0,8,9,0,2,0,
0,0,0,0,2,0,4,0,0, 0,0,0,0,2,0,4,0,0,
0,0,4,0,6,0,0,0,8, 0,0,4,0,6,0,0,0,8,
0,0,0,5,0,0,0,0,0, 0,0,0,5,0,0,0,0,0,
@ -43,72 +56,116 @@ impl SField {
0,0,8,2,0,0,0,6,0, 0,0,8,2,0,0,0,6,0,
]; ];
let mut sudoku = SField { // 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(0);
} else {
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, field,
skip_forward: vec![0; NUM_FIELDS + 1], rows,
skip_backward: vec![0; NUM_FIELDS + 1], cols,
blocks,
fixed,
size,
block_size,
pos: 0, pos: 0,
possible_values: vec![vec![]; NUM_FIELDS], pos_last_placed: 0,
}; num_fields: size * size,
possible_values: vec![vec![]; size * size],
sudoku.build_possible_values_db(); }
sudoku.build_skip_dbs();
sudoku
} }
fn build_skip_dbs(&mut self) { fn rows_from_plain_field(field: &[usize]) -> Vec<Vec<usize>> {
fn find_fixed_streak_forward(mut idx: usize, field: &[u8]) -> u8 { let mut rows = vec![vec![0; 9]; 9];
let mut fixed_count = 1; for row in 0..9 {
idx += 1; for col in 0..9 {
rows[row][col] = field[row * 9 + col];
while idx < NUM_FIELDS && field[idx] > 0 {
fixed_count += 1;
idx += 1;
}
fixed_count
}
fn find_fixed_streak_backward(mut idx: usize, field: &[u8]) -> u8 {
let mut fixed_count = 1;
idx -= 1;
while idx < NUM_FIELDS && field[idx] > 0 {
fixed_count += 1;
idx -= 1;
}
fixed_count
}
let fwd = &mut self.skip_forward;
for (idx, nr) in self.field.iter().enumerate() {
match nr {
0 => fwd[idx] = *nr,
_ => fwd[idx] = find_fixed_streak_forward(idx, &self.field),
} }
} }
rows
}
let bwd = &mut self.skip_backward; fn cols_from_plain_field(field: &[usize]) -> Vec<Vec<usize>> {
for (idx, nr) in self.field.iter().enumerate().rev() { let mut cols = vec![vec![0; 9]; 9];
match nr { for row in 0..9 {
0 => bwd[idx + 1] = *nr, for col in 0..9 {
_ => bwd[idx + 1] = find_fixed_streak_backward(idx, &self.field), 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) { fn build_possible_values_db(&mut self) {
for idx in 0..NUM_FIELDS { for idx in 0..self.num_fields {
if self.field[idx] != 0 { if self.fixed[idx] == 1 {
continue; continue;
} }
self.pos = idx; self.pos = idx;
// try all values between 1 and =self.size and remember the good ones // try all values between 1 and =self.size and remember the good ones
let mut good_ones = Vec::with_capacity(SIZE); let mut good_ones = Vec::with_capacity(self.size);
for nr in 1..=(u8::try_from(SIZE).expect("SIZE is too big")) { for nr in 1..=self.size {
if self.ok(nr) { if self.ok(nr) {
good_ones.push(nr); good_ones.push(nr);
} }
@ -119,70 +176,166 @@ impl SField {
} }
pub fn solve_backtracking(&mut self) -> bool { pub fn solve_backtracking(&mut self) -> bool {
let mut found_solution = false;
let mut num_solutions = 0; let mut num_solutions = 0;
//let mut loop_count = 0;
loop { loop {
if !self.put_valid_nr() { //std::thread::sleep_ms(30);
self.clear_current_field(); //self.print_clear();
if !self.prev() { //self.print();
print_clear(); //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(); self.print();
println!("Number of solutions: {num_solutions}");
break;
} }
if self.is_fixed() {
continue;
}
self.clear_current_field();
self.prev();
self.goto_prev_free_field();
}
if self.is_fixed() {
self.next();
continue; continue;
} }
if !self.next() { if self.goto_next_free_field() {
num_solutions += 1; if self.put_valid_nr() {
if num_solutions % 10_000 == 0 { self.next();
print_clear(); continue;
self.print(); } else {
println!("Number of solutions: {num_solutions}"); //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);
break;
}
if !self.goto_prev_free_field() {
println!("Number of solutions: {}", num_solutions);
break;
}
} }
self.clear_current_field();
self.prev();
} }
} }
num_solutions > 0 found_solution
} }
#[inline(always)]
fn print_gray(&self) {
print!("\x1b\x5b\x31\x3b\x33\x30\x6d");
}
#[inline(always)]
fn print_green(&self) {
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");
}
#[inline(always)]
fn print_clear(&self) {
print!("\x1b\x5b\x48\x1b\x5b\x32\x4a");
}
#[inline(always)]
fn print(&self) { fn print(&self) {
for i in 0..NUM_FIELDS { for i in 0..self.num_fields {
if i != 0 && i % SIZE == 0 { if i != 0 && i % self.size == 0 {
println!(); println!();
} }
if i == self.pos { if i == self.pos_last_placed {
print_green(); self.print_red();
} else if i == self.pos {
self.print_green();
} else if self.get_field_at_pos(i) == 0 { } else if self.get_field_at_pos(i) == 0 {
print_gray(); self.print_gray();
} }
print!("{:2} ", self.get_field_at_pos(i)); 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 {
print_neutral(); self.print_neutral();
} }
} }
println!(); println!();
} }
#[inline(always)]
fn clear_current_field(&mut self) { fn clear_current_field(&mut self) {
self.set(0); self.set(0);
} }
#[inline(always)]
fn goto_prev_free_field(&mut self) -> bool {
while {
if !self.is_fixed() {
return true;
}
self.prev()
} {}
false
}
#[inline(always)]
fn goto_next_free_field(&mut self) -> bool {
while {
if !self.is_fixed() {
return true;
}
self.next()
} {}
false
}
#[inline(always)]
fn _put_valid_nr(&mut self) -> bool {
let current_nr = self.get_field_at_pos(self.pos);
for nr in current_nr..self.size + 1 {
if self.ok(nr) {
self.set(nr);
return true;
}
}
false
}
#[inline(always)]
fn put_valid_nr(&mut self) -> bool { fn put_valid_nr(&mut self) -> bool {
let current_nr = self.get_field_at_pos(self.pos); let current_nr = self.get_field_at_pos(self.pos);
// safety: // safety:
// self.possible_vals is initialized with self.size * self.size // self.possible_vals is initialized with self.size * self.size
// so self.pos can safely be used to index here // so self.pos can safely be used to index here
let possible_vals = &self.possible_values[self.pos]; let possible_vals = unsafe { self.possible_values.get_unchecked(self.pos) };
for nr in possible_vals { for nr in possible_vals.iter() {
if *nr <= current_nr { if *nr <= current_nr {
continue; continue;
} }
@ -195,11 +348,33 @@ impl SField {
false false
} }
fn ok(&self, nr: u8) -> bool { #[inline(always)]
fn is_end(&self) -> bool {
!self.field.contains(&0)
}
#[inline(always)]
fn ok(&self, nr: usize) -> bool {
self.block_ok(nr) && self.row_ok(nr) && self.col_ok(nr) self.block_ok(nr) && self.row_ok(nr) && self.col_ok(nr)
} }
fn get_field_at_pos(&self, pos: usize) -> u8 { #[inline(always)]
fn _pos_to_xy(&self) -> (usize, usize) {
let y = self.pos / self.size;
let x = self.pos % self.size;
(x + 1, y + 1)
}
#[inline(always)]
fn is_fixed(&self) -> bool {
// 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) == 1 }
}
#[inline(always)]
fn get_field_at_pos(&self, pos: usize) -> usize {
// safety: // safety:
// TODO // TODO
// would need to mathematically explain that the calculations in // would need to mathematically explain that the calculations in
@ -207,84 +382,187 @@ impl SField {
unsafe { *self.field.get_unchecked(pos) } unsafe { *self.field.get_unchecked(pos) }
} }
fn set(&mut self, nr: u8) { #[inline(always)]
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.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());
} }
fn get_row(&self, row: &mut [u8; SIZE]) { #[inline(always)]
for (idx, row_elem) in row.iter_mut().enumerate() { fn block_ok(&self, nr: usize) -> bool {
*row_elem = self.get_field_at_pos((self.pos / SIZE) * SIZE + idx); // 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)
} }
fn get_col(&self, col: &mut [u8; SIZE]) { #[inline(always)]
for (idx, col_elem) in col.iter_mut().enumerate() { fn row_ok(&self, nr: usize) -> bool {
*col_elem = self.get_field_at_pos(idx * SIZE + self.pos % SIZE); let row_nr = self.pos / self.size;
} //println!("{:?}", self.rows[row_nr]);
!unsafe { self.rows.get_unchecked(row_nr) }.contains(&nr)
} }
fn get_block(&self, block: &mut [u8; SIZE]) { #[inline(always)]
let block_start_row = self.pos / SIZE / BLOCK_SIZE * BLOCK_SIZE; fn col_ok(&self, nr: usize) -> bool {
let block_start_col = self.pos % SIZE / BLOCK_SIZE * BLOCK_SIZE; let col_nr = self.pos % self.size;
//println!("{:?}", self.cols[col_nr]);
for r in 0..BLOCK_SIZE { !unsafe { self.cols.get_unchecked(col_nr) }.contains(&nr)
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);
}
}
}
fn block_ok(&self, nr: u8) -> bool {
let mut block = [0; SIZE];
self.get_block(&mut block);
!block.contains(&nr)
}
fn row_ok(&self, nr: u8) -> bool {
let mut row = [0; SIZE];
self.get_row(&mut row);
!row.contains(&nr)
}
fn col_ok(&self, nr: u8) -> bool {
let mut col = [0; SIZE];
self.get_col(&mut col);
!col.contains(&nr)
} }
#[inline(always)]
fn next(&mut self) -> bool { fn next(&mut self) -> bool {
let new_pos = self.pos + 1 + self.skip_forward[self.pos + 1] as usize; if self.pos == self.num_fields - 1 {
if new_pos >= NUM_FIELDS {
return false; return false;
} }
self.pos = new_pos; self.pos += 1;
true true
} }
#[inline(always)]
fn prev(&mut self) -> bool { fn prev(&mut self) -> bool {
let new_pos = self.pos - 1 - self.skip_backward[self.pos] as usize; if self.pos == 0 {
if new_pos >= NUM_FIELDS {
return false; return false;
} }
self.pos = new_pos; self.pos -= 1;
true true
} }
#[inline(always)]
fn solve(&mut self) { fn solve(&mut self) {
let now = Instant::now(); let now = Instant::now();
if !self.solve_backtracking() { if !self.solve_backtracking() {
println!("there is no solution."); 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(3);
field.build_possible_values_db();
field.solve();
Ok(())
} }
fn main() { fn main() {
let mut field = SField::new(); if let Err(e) = run() {
field.solve(); println!("{}", e)
}
} }