Skip to content

Instantly share code, notes, and snippets.

@svagionitis

svagionitis/convertions.txt

Last active December 24, 2015 22:59
Show Gist options
  • Save svagionitis/6877110 to your computer and use it in GitHub Desktop.
Save svagionitis/6877110 to your computer and use it in GitHub Desktop.
Download ZIP
Raw
convertions.txt
0 1 2 3 4 5 6 7 8
--------------------------
{{4, 0, 0, 0, 0, 0, 8, 0, 5}, //0
{0, 3, 0, 0, 0, 0, 0, 0, 0}, //1
{0, 0, 0, 7, 0, 0, 0, 0, 0}, //2
{0, 2, 0, 0, 0, 0, 0, 6, 0}, //3
{0, 0, 0, 0, 8, 0, 4, 0, 0}, //4
{0, 0, 0, 0, 1, 0, 0, 0, 0}, //5
{0, 0, 0, 6, 0, 3, 0, 7, 0}, //6
{5, 0, 0, 2, 0, 0, 0, 0, 0}, //7
{1, 0, 4, 0, 0, 0, 0, 0, 0}};//8
i: 0, j: 0, sud: 4 bit: 3, idx: 0
i: 0, j: 6, sud: 8 bit: 61, idx: 3
i: 0, j: 8, sud: 5 bit: 76, idx: 4
i: 0, sudoku_sq_bit[0]: 0x1000, sudoku_sq_bit[1]: 0x0, sudoku_sq_bit[2]: 0x0 sudoku_sq_bit[3]: 0x4 sudoku_sq_bit[4]: 0x8 sudoku_sq_bit[i][5]: 0x0
1234567891234567
-->0: 0001000000000000
8912345678912345
-->1: 0000000000000000
6789123456789123
-->2: 0000000000000000
4567891234567891
-->3: 0000000000000100
2345678912345678
-->4: 0000000000001000
9
-->5: 0000000000000000
i: 1, j: 1, sud: 3 bit: 11, idx: 0
i: 1, sudoku_sq_bit[0]: 0x10, sudoku_sq_bit[1]: 0x0, sudoku_sq_bit[2]: 0x0 sudoku_sq_bit[3]: 0x0 sudoku_sq_bit[4]: 0x0 sudoku_sq_bit[i][5]: 0x0
-->0: 0000000000010000
-->1: 0000000000000000
-->2: 0000000000000000
-->3: 0000000000000000
-->4: 0000000000000000
-->5: 0000000000000000
i: 2, j: 3, sud: 7 bit: 33, idx: 2
i: 2, sudoku_sq_bit[0]: 0x0, sudoku_sq_bit[1]: 0x0, sudoku_sq_bit[2]: 0x4000 sudoku_sq_bit[3]: 0x0 sudoku_sq_bit[4]: 0x0 sudoku_sq_bit[i][5]: 0x0
-->0: 0000000000000000
-->1: 0000000000000000
-->2: 0100000000000000
-->3: 0000000000000000
-->4: 0000000000000000
-->5: 0000000000000000
i: 3, j: 1, sud: 2 bit: 10, idx: 0
i: 3, j: 7, sud: 6 bit: 68, idx: 4
i: 3, sudoku_sq_bit[0]: 0x20, sudoku_sq_bit[1]: 0x0, sudoku_sq_bit[2]: 0x0 sudoku_sq_bit[3]: 0x0 sudoku_sq_bit[4]: 0x800 sudoku_sq_bit[i][5]: 0x0
-->0: 0000000000100000
-->1: 0000000000000000
-->2: 0000000000000000
-->3: 0000000000000000
-->4: 0000100000000000
-->5: 0000000000000000
i: 4, j: 4, sud: 8 bit: 43, idx: 2
i: 4, j: 6, sud: 4 bit: 57, idx: 3
i: 4, sudoku_sq_bit[0]: 0x0, sudoku_sq_bit[1]: 0x0, sudoku_sq_bit[2]: 0x10 sudoku_sq_bit[3]: 0x40 sudoku_sq_bit[4]: 0x0 sudoku_sq_bit[i][5]: 0x0
-->0: 0000000000000000
-->1: 0000000000000000
-->2: 0000000000010000
-->3: 0000000001000000
-->4: 0000000000000000
-->5: 0000000000000000
i: 5, j: 4, sud: 1 bit: 36, idx: 2
i: 5, sudoku_sq_bit[0]: 0x0, sudoku_sq_bit[1]: 0x0, sudoku_sq_bit[2]: 0x800 sudoku_sq_bit[3]: 0x0 sudoku_sq_bit[4]: 0x0 sudoku_sq_bit[i][5]: 0x0
-->0: 0000000000000000
-->1: 0000000000000000
-->2: 0000100000000000
-->3: 0000000000000000
-->4: 0000000000000000
-->5: 0000000000000000
i: 6, j: 3, sud: 6 bit: 32, idx: 2
i: 6, j: 5, sud: 3 bit: 47, idx: 2
i: 6, j: 7, sud: 7 bit: 69, idx: 4
i: 6, sudoku_sq_bit[0]: 0x0, sudoku_sq_bit[1]: 0x0, sudoku_sq_bit[2]: 0x8001 sudoku_sq_bit[3]: 0x0 sudoku_sq_bit[4]: 0x400 sudoku_sq_bit[i][5]: 0x0
1234567891234567
-->0: 0000000000000000
8912345678912345
-->1: 0000000000000000
6789123456789123
-->2: 1000000000000001
4567891234567891
-->3: 0000000000000000
2345678912345678
-->4: 0000010000000000
9
-->5: 0000000000000000
i: 7, j: 0, sud: 5 bit: 4, idx: 0
i: 7, j: 3, sud: 2 bit: 28, idx: 1
i: 7, sudoku_sq_bit[0]: 0x800, sudoku_sq_bit[1]: 0x8, sudoku_sq_bit[2]: 0x0 sudoku_sq_bit[3]: 0x0 sudoku_sq_bit[4]: 0x0 sudoku_sq_bit[i][5]: 0x0
-->0: 0000100000000000
-->1: 0000000000001000
-->2: 0000000000000000
-->3: 0000000000000000
-->4: 0000000000000000
-->5: 0000000000000000
i: 8, j: 0, sud: 1 bit: 0, idx: 0
i: 8, j: 2, sud: 4 bit: 21, idx: 1
i: 8, sudoku_sq_bit[0]: 0x8000, sudoku_sq_bit[1]: 0x400, sudoku_sq_bit[2]: 0x0 sudoku_sq_bit[3]: 0x0 sudoku_sq_bit[4]: 0x0 sudoku_sq_bit[i][5]: 0x0
-->0: 1000000000000000
-->1: 0000010000000000
-->2: 0000000000000000
-->3: 0000000000000000
-->4: 0000000000000000
-->5: 0000000000000000
i: 0, j: 0, sud: 4 bit: 3, idx: 0
i: 0, j: 6, sud: 8 bit: 61, idx: 1
i: 0, j: 8, sud: 5 bit: 76, idx: 2
i: 0, sudoku_sq_bit[0]: 0x10000000, sudoku_sq_bit[1]: 0x4, sudoku_sq_bit[2]: 0x80000
12345678912345678912345678912345
-->0: 00010000000000000000000000000000
67891234567891234567891234567891
-->1: 00000000000000000000000000000100
23456789123456789
-->2: 00000000000010000000000000000000
i: 1, j: 1, sud: 3 bit: 11, idx: 0
i: 1, sudoku_sq_bit[0]: 0x100000, sudoku_sq_bit[1]: 0x0, sudoku_sq_bit[2]: 0x0
-->0: 00000000000100000000000000000000
-->1: 00000000000000000000000000000000
-->2: 00000000000000000000000000000000
i: 2, j: 3, sud: 7 bit: 33, idx: 1
i: 2, sudoku_sq_bit[0]: 0x0, sudoku_sq_bit[1]: 0x40000000, sudoku_sq_bit[2]: 0x0
-->0: 00000000000000000000000000000000
-->1: 01000000000000000000000000000000
-->2: 00000000000000000000000000000000
i: 3, j: 1, sud: 2 bit: 10, idx: 0
i: 3, j: 7, sud: 6 bit: 68, idx: 2
i: 3, sudoku_sq_bit[0]: 0x200000, sudoku_sq_bit[1]: 0x0, sudoku_sq_bit[2]: 0x8000000
-->0: 00000000001000000000000000000000
-->1: 00000000000000000000000000000000
-->2: 00001000000000000000000000000000
i: 4, j: 4, sud: 8 bit: 43, idx: 1
i: 4, j: 6, sud: 4 bit: 57, idx: 1
i: 4, sudoku_sq_bit[0]: 0x0, sudoku_sq_bit[1]: 0x100040, sudoku_sq_bit[2]: 0x0
-->0: 00000000000000000000000000000000
-->1: 00000000000100000000000001000000
-->2: 00000000000000000000000000000000
i: 5, j: 4, sud: 1 bit: 36, idx: 1
i: 5, sudoku_sq_bit[0]: 0x0, sudoku_sq_bit[1]: 0x8000000, sudoku_sq_bit[2]: 0x0
-->0: 00000000000000000000000000000000
-->1: 00001000000000000000000000000000
-->2: 00000000000000000000000000000000
i: 6, j: 3, sud: 6 bit: 32, idx: 1
i: 6, j: 5, sud: 3 bit: 47, idx: 1
i: 6, j: 7, sud: 7 bit: 69, idx: 2
i: 6, sudoku_sq_bit[0]: 0x0, sudoku_sq_bit[1]: 0x80010000, sudoku_sq_bit[2]: 0x4000000
12345678912345678912345678912345
-->0: 00000000000000000000000000000000
67891234567891234567891234567891
-->1: 10000000000000010000000000000000
23456789123456789
-->2: 00000100000000000000000000000000
i: 7, j: 0, sud: 5 bit: 4, idx: 0
i: 7, j: 3, sud: 2 bit: 28, idx: 0
i: 7, sudoku_sq_bit[0]: 0x8000008, sudoku_sq_bit[1]: 0x0, sudoku_sq_bit[2]: 0x0
-->0: 00001000000000000000000000001000
-->1: 00000000000000000000000000000000
-->2: 00000000000000000000000000000000
i: 8, j: 0, sud: 1 bit: 0, idx: 0
i: 8, j: 2, sud: 4 bit: 21, idx: 0
i: 8, sudoku_sq_bit[0]: 0x80000400, sudoku_sq_bit[1]: 0x0, sudoku_sq_bit[2]: 0x0
-->0: 10000000000000000000010000000000
-->1: 00000000000000000000000000000000
-->2: 00000000000000000000000000000000
i: 0, j: 0, sud: 4 bit: 3, idx: 0
i: 0, j: 6, sud: 8 bit: 61, idx: 0
i: 0, j: 8, sud: 5 bit: 76, idx: 1
i: 0 sudoku_sq_bit[0]: 0x1000000000000004, sudoku_sq_bit[1]: 0x8000000000000
1234567891234567891234567891234567891234567891234567891234567891
-->0: 0001000000000000000000000000000000000000000000000000000000000100
23456789123456789
-->1: 0000000000001000000000000000000000000000000000000000000000000000
i: 1, j: 1, sud: 3 bit: 11, idx: 0
i: 1 sudoku_sq_bit[0]: 0x10000000000000, sudoku_sq_bit[1]: 0x0
-->0: 0000000000010000000000000000000000000000000000000000000000000000
-->1: 0000000000000000000000000000000000000000000000000000000000000000
i: 2, j: 3, sud: 7 bit: 33, idx: 0
i: 2 sudoku_sq_bit[0]: 0x40000000, sudoku_sq_bit[1]: 0x0
-->0: 0000000000000000000000000000000001000000000000000000000000000000
-->1: 0000000000000000000000000000000000000000000000000000000000000000
i: 3, j: 1, sud: 2 bit: 10, idx: 0
i: 3, j: 7, sud: 6 bit: 68, idx: 1
i: 3 sudoku_sq_bit[0]: 0x20000000000000, sudoku_sq_bit[1]: 0x800000000000000
-->0: 0000000000100000000000000000000000000000000000000000000000000000
-->1: 0000100000000000000000000000000000000000000000000000000000000000
i: 4, j: 4, sud: 8 bit: 43, idx: 0
i: 4, j: 6, sud: 4 bit: 57, idx: 0
i: 4 sudoku_sq_bit[0]: 0x100040, sudoku_sq_bit[1]: 0x0
-->0: 0000000000000000000000000000000000000000000100000000000001000000
-->1: 0000000000000000000000000000000000000000000000000000000000000000
i: 5, j: 4, sud: 1 bit: 36, idx: 0
i: 5 sudoku_sq_bit[0]: 0x8000000, sudoku_sq_bit[1]: 0x0
-->0: 0000000000000000000000000000000000001000000000000000000000000000
-->1: 0000000000000000000000000000000000000000000000000000000000000000
i: 6, j: 3, sud: 6 bit: 32, idx: 0
i: 6, j: 5, sud: 3 bit: 47, idx: 0
i: 6, j: 7, sud: 7 bit: 69, idx: 1
i: 6 sudoku_sq_bit[0]: 0x80010000, sudoku_sq_bit[1]: 0x400000000000000
1234567891234567891234567891234567891234567891234567891234567891
-->0: 0000000000000000000000000000000010000000000000010000000000000000
23456789123456789
-->1: 0000010000000000000000000000000000000000000000000000000000000000
i: 7, j: 0, sud: 5 bit: 4, idx: 0
i: 7, j: 3, sud: 2 bit: 28, idx: 0
i: 7 sudoku_sq_bit[0]: 0x800000800000000, sudoku_sq_bit[1]: 0x0
-->0: 0000100000000000000000000000100000000000000000000000000000000000
-->1: 0000000000000000000000000000000000000000000000000000000000000000
i: 8, j: 0, sud: 1 bit: 0, idx: 0
i: 8, j: 2, sud: 4 bit: 21, idx: 0
i: 8 sudoku_sq_bit[0]: 0x8000040000000000, sudoku_sq_bit[1]: 0x0
-->0: 1000000000000000000001000000000000000000000000000000000000000000
-->1: 0000000000000000000000000000000000000000000000000000000000000000
i: 0 BitsNBytes: 0x19000000 00011001000000000000000000000000
horiz0: 0x19000000 00011001000000000000000000000000
horiz1: 0x0 00000000000000000000000000000000
horiz2: 0x0 00000000000000000000000000000000
i: 1 BitsNBytes: 0x20000000 00100000000000000000000000000000
horiz0: 0x19100000 00011001000100000000000000000000
horiz1: 0x0 00000000000000000000000000000000
horiz2: 0x0 00000000000000000000000000000000
i: 2 BitsNBytes: 0x2000000 00000010000000000000000000000000
horiz0: 0x19100080 00011001000100000000000010000000
horiz1: 0x0 00000000000000000000000000000000
horiz2: 0x0 00000000000000000000000000000000
i: 3 BitsNBytes: 0x44000000 01000100000000000000000000000000
horiz0: 0x19100088 00011001000100000000000010001000
horiz1: 0x80000000 10000000000000000000000000000000
horiz2: 0x0 00000000000000000000000000000000
i: 4 BitsNBytes: 0x11000000 00010001000000000000000000000000
horiz0: 0x19100088 00011001000100000000000010001000
horiz1: 0x81100000 10000001000100000000000000000000
horiz2: 0x0 00000000000000000000000000000000
i: 5 BitsNBytes: 0x80000000 10000000000000000000000000000000
horiz0: 0x19100088 00011001000100000000000010001000
horiz1: 0x81140000 10000001000101000000000000000000
horiz2: 0x0 00000000000000000000000000000000
i: 6 BitsNBytes: 0x26000000 00100110000000000000000000000000
horiz0: 0x19100088 00011001000100000000000010001000
horiz1: 0x81140098 10000001000101000000000010011000
horiz2: 0x0 00000000000000000000000000000000
i: 7 BitsNBytes: 0x48000000 01001000000000000000000000000000
horiz0: 0x19100088 00011001000100000000000010001000
horiz1: 0x81140098 10000001000101000000000010011000
horiz2: 0x90000000 10010000000000000000000000000000
i: 8 BitsNBytes: 0x90000000 10010000000000000000000000000000
horiz0: 0x19100088 00011001000100000000000010001000
horiz1: 0x81140098 10000001000101000000000010011000
horiz2: 0x90900000 10010000100100000000000000000000
i: 0 verti0: 0x10000000 verti1: 0x4 verti2: 0x80000
i: 1 verti0: 0x10100000 verti1: 0x4 verti2: 0x80000
i: 2 verti0: 0x10100000 verti1: 0x40000004 verti2: 0x80000
i: 3 verti0: 0x10300000 verti1: 0x40000004 verti2: 0x8080000
i: 4 verti0: 0x10300000 verti1: 0x40100044 verti2: 0x8080000
i: 5 verti0: 0x10300000 verti1: 0x48100044 verti2: 0x8080000
i: 6 verti0: 0x10300000 verti1: 0xc8110044 verti2: 0xc080000
i: 7 verti0: 0x18300008 verti1: 0xc8110044 verti2: 0xc080000
i: 8 verti0: 0x98300408 verti1: 0xc8110044 verti2: 0xc080000
Raw
sudoku.c
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <stdint.h>
/*
Initial idea: http://norvig.com/sudoku.html
1 2 3 4 5 6 7 8 9
A . . .| . . .| . . .
B . . .| . . .| . . .
C . . .| . . .| . . .
---------+--------+---------
D . . .| . . .| . . .
E . . .| . . .| . . .
F . . .| . . .| . . .
---------+--------+---------
G . . .| . . .| . . .
H . . .| . . .| . . .
I . . .| . . .| . . .
0 1 2 3 4 5 6 7 8
--------------------------
{{4, 0, 0, 0, 0, 0, 8, 0, 5}, //0
{0, 3, 0, 0, 0, 0, 0, 0, 0}, //1
{0, 0, 0, 7, 0, 0, 0, 0, 0}, //2
{0, 2, 0, 0, 0, 0, 0, 6, 0}, //3
{0, 0, 0, 0, 8, 0, 4, 0, 0}, //4
{0, 0, 0, 0, 1, 0, 0, 0, 0}, //5
{0, 0, 0, 6, 0, 3, 0, 7, 0}, //6
{5, 0, 0, 2, 0, 0, 0, 0, 0}, //7
{1, 0, 4, 0, 0, 0, 0, 0, 0}};//8
[0] | [1] | [2]
0 1 2 3 4 5 6 7 8
| | | | | | | | |
12345678 91234567 89123456 78912345 67891234 56789123 45678912 34567891 23456789 12345678 9
xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx
00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000
Example:
| | | | | | | | |
12345678 91234567 89123456 78912345 67891234 56789123 45678912 34567891 23456789 12345678 9
00010000 00000000 00000000 00000000 00000000 00000000 00000000 00000100 00000000 00001000 00000000 00000000
00000000 00010000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000
00000000 00000000 00000000 00000000 01000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000
00000000 00100000 00000000 00000000 00000000 00000000 00000000 00000000 00001000 00000000 00000000 00000000
00000000 00000000 00000000 00000000 00000000 00010000 00000000 01000000 00000000 00000000 00000000 00000000
00000000 00000000 00000000 00000000 00001000 00000000 00000000 00000000 00000000 00000000 00000000 00000000
00000000 00000000 00000000 00000000 10000000 00000001 00000000 00000000 00000100 00000000 00000000 00000000
00001000 00000000 00000000 00001000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000
10000000 00000000 00000100 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000
Horizontal Mask:
{4, 8, 5} {3} {7} {2, 6} {4, 8} {1} {3, 6, 7} {2, 5} {1, 4}
0 1 2 3 4 5 6 7 8
| | | | | | | | |
12345678 91234567 89123456 78912345 67891234 56789123 45678912 34567891 23456789 12345678 9
00011001 00010000 00000000 10001000 10000001 00010100 00000000 10011000 10010000 10010000 00000000 00000000
0x19100088 0x81140098 0x90900000
Vertical Mask:
{4, 5, 1} {3, 2} {4} {7, 6, 2} {8, 1} {3} {8, 4} {6, 7} {5}
0 1 2 3 4 5 6 7 8
| | | | | | | | |
12345678 91234567 89123456 78912345 67891234 56789123 45678912 34567891 23456789 12345678 9
10011000 00110000 00000100 00001000 11001000 00010001 00000000 01000100 00001100 00001000 00000000 00000000
0x98300408 0xC8110044 0xC0800000
Put Horizontal and Vertical Masks in one:
Verti
100110000 011000000 000100000 010001100 100000010 001000000 000100010 000001100 000010000
------------------------------------------------------------------------------------------
Horiz
000110010 | 100110010 011110010 000110010 010111110 100110010 001110010 000110010 000111110 000110010
001000000 | 101110000 011000000 001100000 011001100 101000010 001000000 001100010 001001100 001010000
000000100 | 100110100 011000100 000100100 010001100 100000110 001000100 000100110 000001100 000010100
010001000 | 110111000 011001000 010101000 010001100 110001010 011001000 010101010 010001100 010011000
000100010 | 100110010 011100010 000100010 010101110 100100010 001100010 000100010 000101110 000110010
100000000 | 100110000 111000000 100100000 110001100 100000010 101000000 100100010 100001100 100010000
001001100 | 101111100 011001100 001101100 011001100 101001110 001001100 001101110 001001100 001011100
010010000 | 110110000 011010000 010110000 010011100 110010010 011010000 010110010 010011100 010010000
100100000 | 100110000 111100000 100100000 110101100 100100010 101100000 100100010 100101100 100110000
0 1 2 3 4 5 6 7 8
| | | | | | | | |
10011001 00111100 10000110 01001011 11101001 10010001 11001000 01100100 00111110 00011001 00000000 00000000
10111000 00110000 00001100 00001100 11001010 00010001 00000000 11000100 01001100 00101000 00000000 00000000
10011010 00110001 00000100 10001000 11001000 00110001 00010000 01001100 00001100 00001010 00000000 00000000
11011100 00110010 00010101 00001000 11001100 01010011 00100001 01010100 10001100 01001100 00000000 00000000
10011001 00111000 10000100 01001010 11101001 00010001 10001000 01000100 00101110 00011001 00000000 00000000
10011000 01110000 00100100 00011000 11001000 00010101 00000010 01000101 00001100 10001000 00000000 00000000
10111110 00110011 00001101 10001100 11001010 01110001 00110000 11011100 01001100 00101110 00000000 00000000
11011000 00110100 00010110 00001001 11001100 10010011 01000001 01100100 10011100 01001000 00000000 00000000
10011000 01111000 00100100 00011010 11001001 00010101 10000010 01000101 00101100 10011000 00000000 00000000
00010000 00000000 00000000 00000000 00000000 00000000 00000000 00000100 00000000 00001000 00000000 00000000
00000000 00010000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000
00000000 00000000 00000000 00000000 01000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000
00000000 00100000 00000000 00000000 00000000 00000000 00000000 00000000 00001000 00000000 00000000 00000000
00000000 00000000 00000000 00000000 00000000 00010000 00000000 01000000 00000000 00000000 00000000 00000000
00000000 00000000 00000000 00000000 00001000 00000000 00000000 00000000 00000000 00000000 00000000 00000000
00000000 00000000 00000000 00000000 10000000 00000001 00000000 00000000 00000100 00000000 00000000 00000000
00001000 00000000 00000000 00001000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000
10000000 00000000 00000100 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000
Result:
In regions with one bit there are the final values. In the regions with more than one bits, the bits on represent the
numbers that are occupied and cannot be used.
0 1 2 3 4 5 6 7 8
| | | | | | | | |
i: 0 00010000 00111100 10000110 01001011 11101001 10010001 11001000 00000100 00111110 00001000 00000000 00000000
i: 1 10111000 00010000 00001100 00001100 11001010 00010001 00000000 11000100 01001100 00101000 00000000 00000000
i: 2 10011010 00110001 00000100 10000000 01001000 00110001 00010000 01001100 00001100 00001010 00000000 00000000
i: 3 11011100 00100000 00010101 00001000 11001100 01010011 00100001 01010100 00001000 01001100 00000000 00000000
i: 4 10011001 00111000 10000100 01001010 11100000 00010001 10001000 01000000 00101110 00011001 00000000 00000000
i: 5 10011000 01110000 00100100 00011000 11001000 00000101 00000010 01000101 00001100 10001000 00000000 00000000
i: 6 10111110 00110011 00001101 10000000 10001010 01110001 00000000 11011100 00000100 00101110 00000000 00000000
i: 7 00001000 00110100 00010110 00001000 00001100 10010011 01000001 01100100 10011100 01001000 00000000 00000000
i: 8 10000000 01111000 00000100 00011010 11001001 00010101 10000010 01000101 00101100 10011000 00000000 00000000
In regions with one bit there are the final values. In the regions with more than one bits, the bits on represent the
numbers that can be used.
0 1 2 3 4 5 6 7 8
| | | | | | | | |
i: 0 00010000 01000011 01111001 10110100 00010110 01101110 00110100 00000101 11000001 00001000 00000000 00000000
i: 1 01000111 10010000 00110011 11110011 00110101 11101110 11111111 00111011 10110011 11010111 10000000 00000000
i: 2 01100101 11001110 11111011 01100000 01000111 11001110 11101111 10110011 11110011 11110101 10000000 00000000
i: 3 00100011 10100000 00101010 11110111 00110011 10101100 11011110 10101010 00001000 10110011 10000000 00000000
i: 4 01100110 11000111 01111011 10110101 00010000 00010110 01110100 01000001 11010001 11100110 10000000 00000000
i: 5 01100111 10001111 11011011 11100111 00111000 00000010 11111101 10111010 11110011 01110111 10000000 00000000
i: 6 01000001 11001100 11110010 01100000 10000101 10001001 00000011 00100010 00000100 11010001 10000000 00000000
i: 7 00001000 01001011 11101001 11101000 00000011 01101100 10111110 10011011 01100011 10110111 10000000 00000000
i: 8 10000000 00000111 11000100 00000101 00110110 11101010 01111101 10111010 11010011 01100111 10000000 00000000
0 1 2 3 4 5 6 7 8
| | | | | | | | |
i: 0 000100000 100001101 111001101 101000001 011001101 110001101 000000010 111000001 0000100000 000000 00000000
i: 1 010001111 001000000 110011111 100110011 010111101 110111111 110011101 110110011 1101011110 000000 00000000
i: 2 011001011 100111011 111011011 000000100 011111001 110111011 111011001 111110011 1111010110 000000 00000000
i: 3 001000111 010000000 101010111 101110011 001110101 100110111 101010101 000001000 1011001110 000000 00000000
i: 4 011001101 100011101 111011101 101010001 000000010 110011101 000100000 111010001 1110011010 000000 00000000
i: 5 011001111 000111111 011011111 001110011 100000000 010111111 011011101 011110011 0111011110 000000 00000000
i: 6 010000011 100110011 110010011 000001000 010110001 001000000 110010001 000000100 1101000110 000000 00000000
i: 7 000010000 100101111 101001111 010000000 001101101 100101111 101001101 101100011 1011011110 000000 00000000
i: 8 100000000 000011111 000100000 001010011 011011101 010011111 011011101 011010011 0110011110 000000 00000000
*/
/**
* @brief Convert a bit array to integer.
* @param[in] b is the bit array to converted to integer.
*
* @return The integer which is the result of the conversion
* from the bit array.
*/
uint32_t bit2int(char *b)
{
uint32_t v;
v = 0;
while(*b)
v = 2*v + (*b++ - '0') ;
return(v);
}
/**
* @brief Convert an integer to bit array.
* @param[in] v is the number to be converted.
* @param[in] nb is the number of bits to be printed.
*
* @return A bit array of the input interger.
*/
char* int2bit(uint64_t v, uint32_t nb)
{
uint32_t i = 0;
static char out[sizeof(v)*8+1];
for(i=0;i<nb;i++)
out[i] = '0' + ( (v>>(nb-i-1)) & 1);
out[nb] = '\0';
return(out);
}
/**
* @brief Convert the numbers from sudoku to bits in 16 bit integers.
* @param[in] sudoku_sq is the numbers of the sudoku puzzle.
* @param[out] sudoku_sq_bit is the 16 bit numbers which have the bits.
*
* @return 1 if everything was ok, 0 otherwise.
*/
uint8_t convertTo16Bit(uint8_t sudoku_sq[9][9], uint16_t sudoku_sq_bit[9][6])
{
uint8_t i = 0, j = 0;
uint8_t idx = 0, bit = 0;
/*
0 1
|
12345678 91234567
[0]: xxxxxxxx xxxxxxxx
1 2 3
| |
[1]: 89123456 78912345
xxxxxxxx xxxxxxxx
3 4 5
| |
67891234 56789123
[2]: xxxxxxxx xxxxxxxx
5 6 7
| |
45678912 34567891
[3]: xxxxxxxx xxxxxxxx
7 8
|
23456789 12345678
[4]: xxxxxxxx xxxxxxxx
8
|
9
[5]: xxxxxxxx xxxxxxxx
*/
for(i = 0;i<9;i++)
{
for(j = 0;j<9;j++)
{
if (!sudoku_sq[i][j])//if 0 continue.
continue;
bit = j*9 + (sudoku_sq[i][j] - 1);
// 16 bits = (8 * sizeof(uint16_t)
idx = bit / 16;
printf("i: %u, j: %u, sud: %u bit: %u, idx: %u\n", i, j, sudoku_sq[i][j], bit, idx);
sudoku_sq_bit[i][idx] |= 0x8000 >> (bit % 16);
}
printf("i: %d, sudoku_sq_bit[0]: 0x%x, sudoku_sq_bit[1]: 0x%x, sudoku_sq_bit[2]: 0x%x sudoku_sq_bit[3]: 0x%x sudoku_sq_bit[4]: 0x%x sudoku_sq_bit[i][5]: 0x%x\n", i, sudoku_sq_bit[i][0], sudoku_sq_bit[i][1], sudoku_sq_bit[i][2], sudoku_sq_bit[i][3], sudoku_sq_bit[i][4], sudoku_sq_bit[i][5]);
printf("-->0: %s\n", int2bit(sudoku_sq_bit[i][0], 16));
printf("-->1: %s\n", int2bit(sudoku_sq_bit[i][1], 16));
printf("-->2: %s\n", int2bit(sudoku_sq_bit[i][2], 16));
printf("-->3: %s\n", int2bit(sudoku_sq_bit[i][3], 16));
printf("-->4: %s\n", int2bit(sudoku_sq_bit[i][4], 16));
printf("-->5: %s\n", int2bit(sudoku_sq_bit[i][5], 16));
}
return 1;
}
/**
* @brief Convert the numbers from sudoku to bits in 32 bit integers.
* @param[in] sudoku_sq is the numbers of the sudoku puzzle.
* @param[out] sudoku_sq_bit is the 32 bit numbers which have the bits.
*
* @return 1 if everything was ok, 0 otherwise.
*/
uint8_t convertTo32Bit(uint8_t sudoku_sq[9][9], uint32_t sudoku_sq_bit[9][3])
{
uint8_t i = 0, j = 0;
uint8_t idx = 0, bit = 0;
/*
0 1 2 3
| | |
12345678 91234567 89123456 78912345
[0]: xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx
3 4 5 6 7
| | | |
67891234 56789123 45678912 34567891
[1]: xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx
7 8
| |
23456789 12345678 9
[2]: xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx
*/
for(i = 0;i<9;i++)
{
for(j = 0;j<9;j++)
{
if (!sudoku_sq[i][j])//if 0 continue.
continue;
bit = j*9 + (sudoku_sq[i][j] - 1);
// 32 bits = (8 * sizeof(uint32_t))
idx = bit / 32;
printf("i: %u, j: %u, sud: %u bit: %u, idx: %u\n", i, j, sudoku_sq[i][j], bit, idx);
sudoku_sq_bit[i][idx] |= 0x80000000 >> (bit % 32);
}
printf("i: %d, sudoku_sq_bit[0]: 0x%x, sudoku_sq_bit[1]: 0x%x, sudoku_sq_bit[2]: 0x%x\n", i, sudoku_sq_bit[i][0], sudoku_sq_bit[i][1], sudoku_sq_bit[i][2]);
printf("-->0: %s\n", int2bit(sudoku_sq_bit[i][0], 32));
printf("-->1: %s\n", int2bit(sudoku_sq_bit[i][1], 32));
printf("-->2: %s\n", int2bit(sudoku_sq_bit[i][2], 32));
}
return 1;
}
/**
* @brief Convert the numbers from sudoku to bits in 64 bit integers.
* @param[in] sudoku_sq is the numbers of the sudoku puzzle.
* @param[out] sudoku_sq_bit is the 64 bit numbers which have the bits.
*
* @return 1 if everything was ok, 0 otherwise.
*/
uint8_t convertTo64Bit(uint8_t sudoku_sq[9][9], uint64_t sudoku_sq_bit[9][2])
{
uint8_t i = 0, j = 0;
uint8_t idx = 0, bit = 0;
/*
0 1 2 3 4 5 6 7
| | | | | | |
12345678 91234567 89123456 78912345 67891234 56789123 45678912 34567891
[0]: xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx
7 8
| |
23456789 12345678 9
[1]: xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx
*/
for(i = 0;i<9;i++)
{
for(j = 0;j<9;j++)
{
if (!sudoku_sq[i][j])//if 0 continue.
continue;
bit = j*9 + (sudoku_sq[i][j] - 1);
// 64 bits = (8 * sizeof(uint64_t))
idx = bit / 64;
printf("i: %u, j: %u, sud: %u bit: %u, idx: %u\n", i, j, sudoku_sq[i][j], bit, idx);
sudoku_sq_bit[i][idx] |= 0x8000000000000000 >> (bit % 64);
}
printf("i: %d sudoku_sq_bit[0]: 0x%llx, sudoku_sq_bit[1]: 0x%llx\n", i, sudoku_sq_bit[i][0], sudoku_sq_bit[i][1]);
printf("-->0: %s\n", int2bit(sudoku_sq_bit[i][0], 64));
printf("-->1: %s\n", int2bit(sudoku_sq_bit[i][1], 64));
}
return 1;
}
/**
* @brief Create horizontal and vertical masks from 32 bit convertion.
* @param[in] sudoku_sq_bit is the 32 bit convertion number of sudoku numbers.
* @param[out] sudoku_horiz is the horizntal mask.
* @param[out] sudoku_verti is the vertical mask.
*
* @return 1 if everything was ok, 0 otherwise.
*/
uint8_t createHorizVertiMasks32Bit(uint32_t sudoku_sq_bit[9][3], uint32_t sudoku_horiz[3], uint32_t sudoku_verti[3])
{
uint8_t i = 0, j = 0;
/*
Mask of nine most significant bits of uint32.
=============================================
12345678 9
Binary representation: 11111111 10000000 00000000 00000000
Hexadecimal representation: 0xFF800000
*/
uint32_t maskNineBits = 0xFF800000;
/*
Mask of nine bits right shift of the nine most significant bits.
================================================================
12345678 91234567 89
Binary representation: 00000000 01111111 11000000 00000000
Hexadecimal representation: 0x007FC000 = 0xFF800000 >> 9
*/
uint32_t maskNineBitsRightShift9Bits = 0x007FC000;
/*
Mask of eighteen bits right shift of the nine most significant bits.
====================================================================
12345678 91234567 89123456 789
Binary representation: 00000000 00000000 00111111 11100000
Hexadecimal representation: 0x00003FE0 = 0xFF800000 >> 18
*/
uint32_t maskNineBitsRightShift18Bits = 0x00003FE0;
/*
Mask of twenty-seven bits right shift of the nine most significant bits.
========================================================================
12345678 91234567 89123456 78912345
Binary representation: 00000000 00000000 00000000 00011111
Hexadecimal representation: 0x0000001F = 0xFF800000 >> 27
*/
uint32_t maskNineBitsRightShift27Bits = 0x0000001F;
uint32_t Bit32Mod9 = 32 % 9;
uint32_t Bit64Mod9 = 64 % 9;
/*
2*32 % 9 = 64 % 9 = 1
32 % (4*9 - (32 % 9)) =
32 % (36 - 5) =
32 % 31 =
1
*/
/*
Move the 9-bits mask to right by multiple of 9.
0xFF800000 >> 9 = 0x007FC000;
0xFF800000 >> 18 = 0x00003FE0;
0xFF800000 >> 27 = 0x0000001F;
sudoku_horiz[0] |= ((sudoku_sq_bit[i][0] & 0xFF800000) |
((sudoku_sq_bit[i][0] & (0xFF800000 >> 9)) << 9) |
((sudoku_sq_bit[i][0] & (0xFF800000 >> 18)) << 18) |
((sudoku_sq_bit[i][0] & (0xFF800000 >> 27)) << 27)) >> 9*i;
32 - 27 = 5
9 - 5 = 4
18 - 5 = 13
27 - 5 = 22
36 - 5 = 31
*/
for (i = 0;i<9;i++)
{
uint8_t iMod4 = (uint8_t)(i%4);
uint8_t idx = 0;
uint32_t row = 0;
for (idx = 0;idx<3;idx++)
{
uint32_t idxMod9 = idx*32 % 9;
row |= (sudoku_sq_bit[i][idx] & (0xFF800000 << idxMod9)) >> idxMod9;
printf("i: %d idx: %d row0: %s\n", i, idx, int2bit(row, 32));
row |= (sudoku_sq_bit[i][idx] & (0xFF800000 >> 9 - idxMod9)) << 9 - idxMod9;
printf("i: %d idx: %d row1: %s\n", i, idx, int2bit(row, 32));
/*if (idx == 2)
continue;*/
row |= (sudoku_sq_bit[i][idx] & (0xFF800000 >> 18 - idxMod9)) << 18 - idxMod9;
printf("i: %d idx: %d row2: %s\n", i, idx, int2bit(row, 32));
row |= (sudoku_sq_bit[i][idx] & (0xFF800000 >> 27 - idxMod9)) << 27 - idxMod9;
printf("i: %d idx: %d row3: %s\n", i, idx, int2bit(row, 32));
/*if (idx == 0)
continue;*/
row |= (sudoku_sq_bit[i][idx] & (0xFF800000 >> 36 - idxMod9)) << 36 - idxMod9;
printf("i: %d idx: %d RightShift: 0x%x row4: %s\n", i, idx, (0xFF800000 >> 36 - idxMod9), int2bit(row, 32));
}
//printf("i: %d row: 0x%x %s\n", i, row, int2bit(row, 32));
uint32_t bitsNBytes =
(sudoku_sq_bit[i][0] & 0xFF800000) |
((sudoku_sq_bit[i][0] & (0xFF800000 >> 9)) << 9) |
((sudoku_sq_bit[i][0] & (0xFF800000 >> 18)) << 18) |
((sudoku_sq_bit[i][0] & (0xFF800000 >> 27)) << 27) |
((sudoku_sq_bit[i][1] & (0xFF800000 << Bit32Mod9)) >> Bit32Mod9) |
((sudoku_sq_bit[i][1] & (0xFF800000 >> 9 - Bit32Mod9)) << 9 - Bit32Mod9) |
((sudoku_sq_bit[i][1] & (0xFF800000 >> 18 - Bit32Mod9)) << 18 - Bit32Mod9) |
((sudoku_sq_bit[i][1] & (0xFF800000 >> 27 - Bit32Mod9)) << 27 - Bit32Mod9) |
((sudoku_sq_bit[i][1] & (0xFF800000 >> 36 - Bit32Mod9)) << 36 - Bit32Mod9) |
((sudoku_sq_bit[i][2] & (0xFF800000 << Bit64Mod9)) >> Bit64Mod9) |
((sudoku_sq_bit[i][2] & (0xFF800000 >> 9 - Bit64Mod9)) << 9 - Bit64Mod9);
//printf("i: %d BitsNBytes: 0x%x %s\n", i, bitsNBytes, int2bit(bitsNBytes, 32));
if (i < 3)
sudoku_horiz[0] |= (bitsNBytes) >> 9*i;
else if (i == 3)
{
sudoku_horiz[0] |= (bitsNBytes) >> 9*i;
sudoku_horiz[1] |= (bitsNBytes) << 32 - 9*i;
}
else if (i < 7)
sudoku_horiz[1] |= (bitsNBytes) >> 9*(iMod4) + (9 - Bit32Mod9);
else if (i == 7)
{
sudoku_horiz[1] |= (bitsNBytes) >> 9*(iMod4) + (9 - Bit32Mod9);
sudoku_horiz[2] |= (bitsNBytes) << Bit64Mod9;
}
else
sudoku_horiz[2] |= (bitsNBytes) >> 9*(iMod4) + (9 - Bit64Mod9);
/*
printf("\thoriz0: 0x%x %s\n", sudoku_horiz[0], int2bit(sudoku_horiz[0], 32));
printf("\thoriz1: 0x%x %s\n", sudoku_horiz[1], int2bit(sudoku_horiz[1], 32));
printf("\thoriz2: 0x%x %s\n", sudoku_horiz[2], int2bit(sudoku_horiz[2], 32));
*/
}
for (i = 0;i<9;i++)
{
sudoku_verti[0] |= sudoku_sq_bit[i][0];
sudoku_verti[1] |= sudoku_sq_bit[i][1];
sudoku_verti[2] |= sudoku_sq_bit[i][2];
printf("i: %d verti0: 0x%x verti1: 0x%x verti2: 0x%x\n", i, sudoku_verti[0], sudoku_verti[1], sudoku_verti[2]);
}
return 1;
}
uint8_t solveSudoku(uint32_t sudoku_sq_bit[9][3], //in
uint32_t sudoku_horiz[3], //in
uint32_t sudoku_verti[3], //in
uint32_t sudoku_solution[9][3]){ //out
uint8_t i = 0, j = 0;
uint8_t byte = 0, bit = 0;
uint32_t sudoku_mask[9][3];
memset(sudoku_mask, 0, sizeof(sudoku_mask));
//horizontal
uint32_t horizBitsNBytes = 0;
//Put vertical and horizontal mask in solution
for (i=0;i<9;i++){
uint8_t iMod4 = (uint8_t)(i%4);
bit = 9*i;
byte = bit / 32;
//vertical
sudoku_mask[i][0] |= sudoku_verti[0];
sudoku_mask[i][1] |= sudoku_verti[1];
sudoku_mask[i][2] |= sudoku_verti[2];
printf("verti: i: %d msk0: 0x%x msk1: 0x%x msk2: 0x%x\n", i, sudoku_mask[i][0], sudoku_mask[i][1], sudoku_mask[i][2]);
if (i < 3)
horizBitsNBytes = (sudoku_horiz[0] & (0xFF800000 >> 9*i)) << 9*i;
else if (i == 3)
horizBitsNBytes = ((sudoku_horiz[0] & (0xFF800000 >> 9*i)) << 9*i) |
((sudoku_horiz[1] & (0xFF800000 << 32 - 9*i)) >> 32 - 9*i);
else if (i < 7)
horizBitsNBytes = (sudoku_horiz[1] & (0xFF800000 >> (9*(iMod4) + 4))) << (9*(iMod4) + 4);
else if (i == 7)
horizBitsNBytes = ((sudoku_horiz[1] & (0xFF800000 >> (9*(iMod4) + 4))) << (9*(iMod4) + 4)) |
((sudoku_horiz[2] & (0xFF800000 << 1)) >> 1);
else
horizBitsNBytes = (sudoku_horiz[2] & (0xFF800000 >> (9*(iMod4) + 8))) << (9*(iMod4) + 8);
sudoku_mask[i][0] |= (horizBitsNBytes);
sudoku_mask[i][0] |= (horizBitsNBytes >> 9);
sudoku_mask[i][0] |= (horizBitsNBytes >> 18);
sudoku_mask[i][0] |= (horizBitsNBytes >> 27);
sudoku_mask[i][1] |= (horizBitsNBytes << 5);
sudoku_mask[i][1] |= (horizBitsNBytes >> 4);
sudoku_mask[i][1] |= (horizBitsNBytes >> 13);
sudoku_mask[i][1] |= (horizBitsNBytes >> 22);
sudoku_mask[i][1] |= (horizBitsNBytes >> 31);
sudoku_mask[i][2] |= (horizBitsNBytes << 1);
sudoku_mask[i][2] |= (horizBitsNBytes >> 8);
printf("horiz: i: %d msk0: 0x%x msk1: 0x%x msk2: 0x%x\n", i, sudoku_mask[i][0], sudoku_mask[i][1], sudoku_mask[i][2]);
/*
printf("i: %d %s", i, int2bit(sudoku_mask[i][0], 32));
printf(" %s", int2bit(sudoku_mask[i][1], 32));
printf(" %s\n", int2bit(sudoku_mask[i][2], 32));
*/
}
for (i=0;i<9;i++){
printf("i: %d msk0: 0x%x msk1: 0x%x msk2: 0x%x\n", i, sudoku_mask[i][0], sudoku_mask[i][1], sudoku_mask[i][2]);
/*
printf("i: %d %s", i, int2bit(sudoku_mask[i][0], 32));
printf(" %s", int2bit(sudoku_mask[i][1], 32));
printf(" %s\n", int2bit(sudoku_mask[i][2], 32));
*/
}
for (i=0;i<9;i++){
sudoku_solution[i][0] |= (sudoku_sq_bit[i][0] & (0xFF800000)) ?
(sudoku_sq_bit[i][0] & (0xFF800000)) : (~sudoku_mask[i][0] & (0xFF800000));
sudoku_solution[i][0] |= (sudoku_sq_bit[i][0] & (0xFF800000 >> 9)) ?
(sudoku_sq_bit[i][0] & (0xFF800000 >> 9)) : (~sudoku_mask[i][0] & (0xFF800000 >> 9));
sudoku_solution[i][0] |= (sudoku_sq_bit[i][0] & (0xFF800000 >> 18)) ?
(sudoku_sq_bit[i][0] & (0xFF800000 >> 18)) : (~sudoku_mask[i][0] & (0xFF800000 >> 18));
sudoku_solution[i][0] |= ((sudoku_sq_bit[i][0] & (0xFF800000 >> 27)) && !(sudoku_sq_bit[i][1] & (0xFF800000 << 5))) ||
(!(sudoku_sq_bit[i][0] & (0xFF800000 >> 27)) && (sudoku_sq_bit[i][1] & (0xFF800000 << 5))) ?
(sudoku_sq_bit[i][0] & (0xFF800000 >> 27)) : (~sudoku_mask[i][0] & (0xFF800000 >> 27));
sudoku_solution[i][1] |= ((sudoku_sq_bit[i][1] & (0xFF800000 << 5)) && !(sudoku_sq_bit[i][0] & (0xFF800000 >> 27))) ||
(!(sudoku_sq_bit[i][1] & (0xFF800000 << 5)) && (sudoku_sq_bit[i][0] & (0xFF800000 >> 27))) ?
(sudoku_sq_bit[i][1] & (0xFF800000 << 5)) : (~sudoku_mask[i][1] & (0xFF800000 << 5));
sudoku_solution[i][1] |= (sudoku_sq_bit[i][1] & (0xFF800000 >> 4)) ?
(sudoku_sq_bit[i][1] & (0xFF800000 >> 4)) : (~sudoku_mask[i][1] & (0xFF800000 >> 4));
sudoku_solution[i][1] |= (sudoku_sq_bit[i][1] & (0xFF800000 >> 13)) ?
(sudoku_sq_bit[i][1] & (0xFF800000 >> 13)) : (~sudoku_mask[i][1] & (0xFF800000 >> 13));
sudoku_solution[i][1] |= (sudoku_sq_bit[i][1] & (0xFF800000 >> 22)) ?
(sudoku_sq_bit[i][1] & (0xFF800000 >> 22)) : (~sudoku_mask[i][1] & (0xFF800000 >> 22));
sudoku_solution[i][1] |= ((sudoku_sq_bit[i][1] & (0xFF800000 >> 31)) && !(sudoku_sq_bit[i][2] & (0xFF800000 << 1))) ||
((sudoku_sq_bit[i][2] & (0xFF800000 << 1)) && !(sudoku_sq_bit[i][1] & (0xFF800000 >> 31))) ?
(sudoku_sq_bit[i][1] & (0xFF800000 >> 31)) : (~sudoku_mask[i][1] & (0xFF800000 >> 31));
sudoku_solution[i][2] |= ((sudoku_sq_bit[i][2] & (0xFF800000 << 1)) && !(sudoku_sq_bit[i][1] & (0xFF800000 >> 31))) ||
((sudoku_sq_bit[i][1] & (0xFF800000 >> 31)) && !(sudoku_sq_bit[i][2] & (0xFF800000 << 1))) ?
(sudoku_sq_bit[i][2] & (0xFF800000 << 1)) : (~sudoku_mask[i][2] & (0xFF800000 << 1));
sudoku_solution[i][2] |= (sudoku_sq_bit[i][2] & (0xFF800000 >> 8)) ?
(sudoku_sq_bit[i][2] & (0xFF800000 >> 8)) : (~sudoku_mask[i][2] & (0xFF800000 >> 8));
//printf("i: %d sol0: 0x%x sol1: 0x%x sol2: 0x%x\n", i, sudoku_solution[i][0], sudoku_solution[i][1], sudoku_solution[i][2]);
printf("i: %d %s", i, int2bit(sudoku_solution[i][0], 32));
printf(" %s", int2bit(sudoku_solution[i][1], 32));
printf(" %s\n", int2bit(sudoku_solution[i][2], 32));
}
return 1;
}
int main(int argc, char *argv[]){
uint8_t sdk_sq[9][9] = {{4, 0, 0, 0, 0, 0, 8, 0, 5},//0
{0, 3, 0, 0, 0, 0, 0, 0, 0},//1
{0, 0, 0, 7, 0, 0, 0, 0, 0},//2
{0, 2, 0, 0, 0, 0, 0, 6, 0},//3
{0, 0, 0, 0, 8, 0, 4, 0, 0},//4
{0, 0, 0, 0, 1, 0, 0, 0, 0},//5
{0, 0, 0, 6, 0, 3, 0, 7, 0},//6
{5, 0, 0, 2, 0, 0, 0, 0, 0},//7
{1, 0, 4, 0, 0, 0, 0, 0, 0}};//8
uint16_t sdk_sq_16bit[9][6];/*Sudoku squares*/
uint32_t sdk_sq_32bit[9][3], sdk_sq_sol_32bit[9][3];
uint64_t sdk_sq_64bit[9][2];
uint32_t sdk_sq_32bit_horiz_masks[3], sdk_sq_32bit_verti_masks[3];
memset(sdk_sq_16bit, 0, sizeof(sdk_sq_16bit));
memset(sdk_sq_32bit, 0, sizeof(sdk_sq_32bit));
memset(sdk_sq_64bit, 0, sizeof(sdk_sq_64bit));
memset(sdk_sq_sol_32bit, 0, sizeof(sdk_sq_sol_32bit));//solution
memset(sdk_sq_32bit_horiz_masks, 0, sizeof(sdk_sq_32bit_horiz_masks));
memset(sdk_sq_32bit_verti_masks, 0, sizeof(sdk_sq_32bit_verti_masks));
//printf("9x9 ushort: %d 9x3 ulong: %d 9x2\n", sizeof(sdk_sq_16bit), sizeof(sdk_sq_32bit));
convertTo16Bit(sdk_sq, sdk_sq_16bit);
convertTo32Bit(sdk_sq, sdk_sq_32bit);
convertTo64Bit(sdk_sq, sdk_sq_64bit);
createHorizVertiMasks32Bit(sdk_sq_32bit, sdk_sq_32bit_horiz_masks, sdk_sq_32bit_verti_masks);
return 1;
solveSudoku(sdk_sq_32bit, sdk_sq_32bit_horiz_masks, sdk_sq_32bit_verti_masks, sdk_sq_sol_32bit);
printf("%d -> %d \n%d -> %d \n%d -> %d \n", sdk_sq[0][0], sdk_sq_16bit[0][0], sdk_sq[0][6], sdk_sq_16bit[0][6], sdk_sq[0][8], sdk_sq_16bit[0][8]);
return 1;
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment