Basics of POM (Pattern Overlay Method)

Advanced methods and approaches for solving Sudoku puzzles

Basics of POM (Pattern Overlay Method)

Postby MythJellies » Sun Dec 18, 2016 8:00 pm

The Pattern Overlay Method (or POM) is a different way of solving sudoku puzzles. It is often referred to as a technique of last resort, which is fair considering how difficult it is to initiate, especially in the early stages of a puzzle. What is not fair is calling it a trial and error type of method, since these overlaid patterns can be arrived at without any unwarranted presumptions. Instead of breaking the puzzle up into candidate components for each digit and working to eliminate them until only the solution remains, POM breaks the puzzle up into labeled solution patterns, or rasters, for each digit and eliminates them until only the correct solutions remain. Each solution pattern for a digit has its own unique label. Each label is placed in every cell in which it occurs. In the following tables, an asterisk means that a digit can assume all of its possible values, while a bracket means that all of the numbers within could be used for that digit. As an example, lets consider a case where the solution has been given for the number 9 in cells r1c1, r6c2, r7c3, r8c4, and r9c9. Thus the unsolved cells for 9 are in r2345c5678. There are 16 different solution patterns or rasters for that number that could still possibly be part of the final solution. The labels for the 16 remaining rasters are shown below using two digits that range from 1 to 4. If a digit is replaced with an asterisk then that digit can be any number from 1 to its max. Thus, cell r2c5 contains the rasters labeled 11, 12, 13, and 14. If a digit is replaced with some numbers in brackets, then that digit can be any of those numbers. Thus, r2c8 contains the rasters labeled 31, 33, 41, and 43. The solution pattern labeled 11 shows up in all of its cells, in this case that is r2c5, r3c8, r5c6, and r4c7.

Code: Select all
---------+-------------------------------+------------------------
         |                               |
9  X  X  |  X        X         X         |  X         X         X         
         |                               |
X  X  X  |  X        1*        2*        |  [34][24]  [34][13]  X
         |                               |
X  X  X  |  X        3*        4*        |  [12][24]  [12][13]  X
         |                               |
---------+-------------------------------+------------------------
         |                               |
X  X  X  |  X        [24][34]  [13][34]  |  *1        *2        X
         |                               |
X  X  X  |  X        [24][12]  [13][12]  |  *3        *4        X     
         |                               |
X  9  X  |  X        X         X         |  X         X         X         
         |                               |
---------+-------------------------------+------------------------
         |                               |
X  X  9  |  X        X         X         |  X         X         X         
         |                               |
X  X  X  |  9        X         X         |  X         X         X         
         |                               |
X  X  X  |  X        X         X         |  X         X         9         
         |                               |
---------+-------------------------------+------------------------

Of course, once you've reduced the number of possible solutions to something manageable, you could substitute these digit labels for letters or any other unique symbols, giving the more familiar...
Code: Select all
9abcd  9efgh  |  9jlnp  9ikmo
              |
9ijkl  9mnop  |  9bdfh  9aceg
--------------+------------------
9ghop  9cdkl  |  9aeim  9bfjn
              |
9efmn  9abij  |  9cgko  9dhlp

Now lets expand this to a 6-cell pattern. You would get something like this if you solved for a digit in boxes 1, 5, and 9. Now you have 64 different ways to finish up the solution for that digit, which is nicely represented by a label containing 3 digits that can range from 1 to 4. Lets say the solved cells were in r1c1, r4c4, and r7c7. In that case, pattern 111 would be in r2c5, r3c9, r5c8, r6c3, r8c2, and r9c6. Cell r2c5 contains all sixteen patterns that have a 1 as the first digit.
Code: Select all
-----------------------+------------------------+------------------------
                       |                        |
                       |                        |
                       | 1**         2**        | [34][24]*   [34][13]*
                       |                        |
                       | 3**         4**        | [12][24]*   [12][13]*
                       |                        |
-----------------------+------------------------+------------------------
                       |                        |
                       |                        |
*[34][24]   *[34][13]  |                        | *1*         *2*
                       |                        |
*[12][24]   *[12][13]  |                        | *3*         *4*
                       |                        |
-----------------------+------------------------+------------------------
                       |                        | 
                       |                        |
**1         **2        | [24]*[34]   [13]*[34]  |
                       |                        |
**3         **4        | [24]*[12]   [13]*[12]  |
                       |                        |
-----------------------+------------------------+------------------------

So this gives us an arrangement for any arbitrary solution given in boxes 1, 5, and 9. Now I am going to show how one can create a POM grid in a non-assumptive fashion by using a magic starting pattern for all nine cells of a standard sudoku grid. For the 9x9 grid, each solution pattern label has six digits. The first three digits range from 1 to 9 and correspond to the solution cell for the pattern in boxes 1, 5, and 9 respectively. The second three digits range from 1 to 4 and correspond to the solutions in boxes 2, 6, and 7 respectively; with a 1 representing the cell that is cyclically to right and below the intersection of the solutions from boxes 1, 5, and 9. The solutions in the remaining boxes, 3, 4, and 8, follow uniquely from the solutions in the other boxes, following a similar format to that of the 6-cell case. Just as with the other cases, you can tell from the label which cells contain that label. For example, pattern 138124 lies in cells r1c1, r4c6, r9c8, r2c4, r5c7, r8c3, r3c9, r6c2, and r7c5. I imagine this sounds a bit complex, but it might be easier to digest if you see the full set. The complete set of 46,656 solution patterns for an empty grid are shown below.

Code: Select all
Block 1:
----------------------+----------------------+---------------------
                      |                      |
1*****                |2*****                |3*****                   
                      |                      |
----------------------+----------------------+---------------------
                      |                      |
4*****                |5*****                |6*****                   
                      |                      |
----------------------+----------------------+---------------------
                      |                      |
7*****                |8*****                |9*****                   
                      |                      |
----------------------+----------------------+---------------------

Block 2:
----------------------+----------------------+---------------------
                      |                      |
[789][369]*1**+       |[789][147]*1**+       |[789][258]*1**+         
[789][258]*2**+       |[789][369]*2**+       |[789][147]*2**+             
[456][369]*3**+       |[456][147]*3**+       |[456][258]*3**+           
[456][258]*4**        |[456][369]*4**        |[456][147]*4**           
                      |                      |
----------------------+----------------------+---------------------
                      |                      |
[123][369]*1**+       |[123][147]*1**+       |[123][258]*1**+           
[123][258]*2**+       |[123][369]*2**+       |[123][147]*2**+           
[789][369]*3**+       |[789][147]*3**+       |[789][258]*3**+         
[789][258]*4**        |[789][369]*4**        |[789][147]*4**           
                      |                      |
----------------------+----------------------+---------------------
                      |                      |
[456][369]*1**+       |[456][147]*1**+       |[456][258]*1**+         
[456][258]*2**+       |[456][369]*2**+       |[456][147]*2**+             
[123][369]*3**+       |[123][147]*3**+       |[123][258]*3**+         
[123][258]*4**        |[123][369]*4**        |[123][147]*4**           
                      |                      |
----------------------+----------------------+---------------------

Block 3:
----------------------+----------------------+---------------------
                      |                      |
[789]*[369][34][24]*+ |[789]*[147][34][24]*+ |[789]*[258][34][24]*+
[789]*[258][34][13]*+ |[789]*[369][34][13]*+ |[789]*[147][34][13]*+
[456]*[369][12][24]*+ |[456]*[147][12][24]*+ |[456]*[258][12][24]*+
[456]*[258][12][13]*  |[456]*[369][12][13]*  |[456]*[147][12][13]*
                      |                      |
----------------------+----------------------+---------------------
                      |                      |
[123]*[369][34][24]*+ |[123]*[147][34][24]*+ |[123]*[258][34][24]*+
[123]*[258][34][13]*+ |[123]*[369][34][13]*+ |[123]*[147][34][13]*+
[789]*[369][12][24]*+ |[789]*[147][12][24]*+ |[789]*[258][12][24]*+
[789]*[258][12][13]*  |[789]*[369][12][13]*  |[789]*[147][12][13]*
                      |                      |
----------------------+----------------------+---------------------
                      |                      |
[456]*[369][34][24]*+ |[456]*[147][34][24]*+ |[456]*[258][34][24]*+
[456]*[258][34][13]*+ |[456]*[369][34][13]*+ |[456]*[147][34][13]*+
[123]*[369][12][24]*+ |[123]*[147][12][24]*+ |[123]*[258][12][24]*+
[123]*[258][12][13]*  |[123]*[369][12][13]*  |[123]*[147][12][13]*
                      |                      |
----------------------+----------------------+---------------------

Block 4:
----------------------+----------------------+---------------------
                      |                      |
[369][789]**[34][24]+ |[147][789]**[34][24]+ |[258][789]**[34][24]+     
[258][789]**[34][13]+ |[369][789]**[34][13]+ |[147][789]**[34][13]+                                                                             
[369][456]**[12][24]+ |[147][456]**[12][24]+ |[258][456]**[12][24]+                                                                             
[258][456]**[12][13]  |[369][456]**[12][13]  |[147][456]**[12][13]                                                                             
                      |                      |
----------------------+----------------------+---------------------
                      |                      |
[369][123]**[34][24]+ |[147][123]**[34][24]+ |[258][123]**[34][24]+     
[258][123]**[34][13]+ |[369][123]**[34][13]+ |[147][123]**[34][13]+                                                                             
[369][789]**[12][24]+ |[147][789]**[12][24]+ |[258][789]**[12][24]+                                                                           
[258][789]**[12][13]  |[369][789]**[12][13]  |[147][789]**[12][13]                                                                             
                      |                      |
----------------------+----------------------+---------------------
                      |                      |
[369][456]**[34][24]+ |[147][456]**[34][24]+ |[258][456]**[34][24]+     
[258][456]**[34][13]+ |[369][456]**[34][13]+ |[147][456]**[34][13]+                                                                             
[369][123]**[12][24]+ |[147][123]**[12][24]+ |[258][123]**[12][24]+                                                                             
[258][123]**[12][13]  |[369][123]**[12][13]  |[147][123]**[12][13]                                                                             
                      |                      |
----------------------+----------------------+---------------------

Block 5:
----------------------+----------------------+---------------------
                      |                      |
*1****                |*2****                |*3****                   
                      |                      |
----------------------+----------------------+---------------------
                      |                      |
*4****                |*5****                |*6****                   
                      |                      |
----------------------+----------------------+---------------------
                      |                      |
*7****                |*8****                |*9****                   
                      |                      |
----------------------+----------------------+---------------------

Block 6:
----------------------+----------------------+---------------------
                      |                      |
*[789][369]*1*+       |*[789][147]*1*+       |*[789][258]*1*+
*[789][258]*2*+       |*[789][369]*2*+       |*[789][147]*2*+
*[456][369]*3*+       |*[456][147]*3*+       |*[456][258]*3*+
*[456][258]*4*        |*[456][369]*4*        |*[456][147]*4*
                      |                      |
----------------------+----------------------+---------------------
                      |                      |
*[123][369]*1*+       |*[123][147]*1*+       |*[123][258]*1*+
*[123][258]*2*+       |*[123][369]*2*+       |*[123][147]*2*+
*[789][369]*3*+       |*[789][147]*3*+       |*[789][258]*3*+
*[789][258]*4*        |*[789][369]*4*        |*[789][147]*4*
                      |                      |
----------------------+----------------------+---------------------
                      |                      |
*[456][369]*1*+       |*[456][147]*1*+       |*[456][258]*1*+
*[456][258]*2*+       |*[456][369]*2*+       |*[456][147]*2*+
*[123][369]*3*+       |*[123][147]*3*+       |*[123][258]*3*+
*[123][258]*4*        |*[123][369]*4*        |*[123][147]*4*
                      |                      |
----------------------+----------------------+---------------------

Block 7:
----------------------+----------------------+---------------------
                      |                      |
[369]*[789]**1+       |[147]*[789]**1+       |[258]*[789]**1+               
[258]*[789]**2+       |[369]*[789]**2+       |[147]*[789]**2+         
[369]*[456]**3+       |[147]*[456]**3+       |[258]*[456]**3+           
[258]*[456]**4        |[369]*[456]**4        |[147]*[456]**4           
                      |                      |
----------------------+----------------------+---------------------
                      |                      |
[369]*[123]**1+       |[147]*[123]**1+       |[258]*[123]**1+               
[258]*[123]**2+       |[369]*[123]**2+       |[147]*[123]**2+           
[369]*[789]**3+       |[147]*[789]**3+       |[258]*[789]**3+           
[258]*[789]**4        |[369]*[789]**4        |[147]*[789]**4           
                      |                      |
----------------------+----------------------+---------------------
                      |                      |
[369]*[456]**1+       |[147]*[456]**1+       |[258]*[456]**1+               
[258]*[456]**2+       |[369]*[456]**2+       |[147]*[456]**2+           
[369]*[123]**3+       |[147]*[123]**3+       |[258]*[123]**3+           
[258]*[123]**4        |[369]*[123]**4        |[147]*[123]**4           
                      |                      |
----------------------+----------------------+---------------------

Block 8:
----------------------+----------------------+---------------------
                      |                      |
*[369][789][24]*[34]+ |*[147][789][24]*[34]+ |*[258][789][24]*[34]+
*[258][789][13]*[34]+ |*[369][789][13]*[34]+ |*[147][789][13]*[34]+
*[369][456][24]*[12]+ |*[147][456][24]*[12]+ |*[258][456][24]*[12]+
*[258][456][13]*[12]  |*[369][456][13]*[12]  |*[147][456][13]*[12]
                      |                      |
----------------------+----------------------+---------------------
                      |                      |
*[369][123][24]*[34]+ |*[147][123][24]*[34]+ |*[258][123][24]*[34]+     
*[258][123][13]*[34]+ |*[369][123][13]*[34]+ |*[147][123][13]*[34]+
*[369][789][24]*[12]+ |*[147][789][24]*[12]+ |*[258][789][24]*[12]+
*[258][789][13]*[12]  |*[369][789][13]*[12]  |*[147][789][13]*[12]
                      |                      |
----------------------+----------------------+---------------------
                      |                      |
*[369][456][24]*[34]+ |*[147][456][24]*[34]+ |*[258][456][24]*[34]+     
*[258][456][13]*[34]+ |*[369][456][13]*[34]+ |*[147][456][13]*[34]+
*[369][123][24]*[12]+ |*[147][123][24]*[12]+ |*[258][123][24]*[12]+
*[258][123][13]*[12]  |*[369][123][13]*[12]  |*[147][123][13]*[12]     
                      |                      |
----------------------+----------------------+---------------------

Block 9:
----------------------+----------------------+---------------------
                      |                      |
**1***                |**2***                |**3***
                      |                      |
----------------------+----------------------+---------------------
                      |                      |
**4***                |**5***                |**6***
                      |                      |
----------------------+----------------------+---------------------
                      |                      |
**7***                |**8***                |**9***
                      |                      |
----------------------+----------------------+---------------------


Conceptually, POM works in a similar fashion to working with candidates, allbeit with 46,656 pattern labels per cell instead of 9 candidates. In both cases you can begin with an empty grid starting constant and then, as you place your givens, you can follow some very simple rules to eliminate either candidates or solution patterns. With POM, the initial rules are even simpler than they are with candidates. When you place a given digit in a cell then you can eliminate all patterns for that digit that are not contained in that cell. At the same time, you can eliminate the patterns that do occur in that cell for every other digit. All these eliminations can be made wherever the label occurs in the puzzle. If you eliminate pattern "111111" for nine in r1c1, then you eliminate it in the other 8 cells that it occurs as well. These methods can also work together. If a candidate is eliminated from a cell using typical means then the patterns for that eliminated candidate that exist in that cell can be eliminated as well.

Once the number of patterns is reduced to something manageable, then one can always substitute letters or other symbology for the remaining digit labels.

There are some ancient threads, some of them lost, that explained some of the interesting solving options available to a POM grid.

(0) Just the creation of the POM grid finds all single-digit eliminations from hidden singles to single-digit chains to any manner of frankenfish. Candidates in a cell that has no viable patterns for that candidate can be eliminated

(1) For any set of N cells that contains all of the patterns for a particular digit; if any pattern occupies all of those cells, that pattern must be false

(2) POM gives you a convenient "NOT". NOT a particular set of patterns for a digit equals the remaining patterns for that digit. Every cell contains multiple equations where NOT the set of patterns for one of the digits in the cell equals the patterns of all the other digits in the cell. One can use these equations to substitute into other cells--and if any pattern then gets repeated in a cell, it must be false since the cell can only hold one truth at a time and two would be required for that pattern to be true

(3) Given P patterns that exist in N cells that share a house (box, row, or column); if there exists another set of exactly N other cells that contain all of the P patterns plus extras, then the extras must be false and also any patterns which exist in more that one of the second set of cells must also be false. The N=1 case does happen. The N=2 case is interesting as it shows how the exocet presents itself using a POM grid

(...) There are many other ways you can compare equations to either get further refined equations or show that a particular pattern is false.
MythJellies
 
Posts: 1
Joined: 18 December 2016

Re: Basics of POM (Pattern Overlay Method)

Postby tarek » Sat Feb 11, 2017 5:31 pm

Good to see familiar names again!!!
User avatar
tarek
 
Posts: 2574
Joined: 05 January 2006

Re: Basics of POM (Pattern Overlay Method)

Postby StrmCkr » Sun Feb 12, 2017 4:28 am

Long time no see myth jellies

Looking forward to advancementa with this, as I've also considered it a trial and error method.
Intresting read that it's alot more in depth explanation on eliminations as massive/simplistic a subset pattern restriction.

I've been tempted to attempt to implement this but I don't see an easy way with limitations of bit set size to 256 characters in pascal.

I'd have to set up each cell as an expanding array representing each 1 possible solution.

For quicker initiation on a loaded grid is it easier to set up the pencil mark grid first:
per-generated all inclusive list of solutions id's : 46,656 of them
Then generate the list of potential solution id's by comparing all active N digits on a grid to the full list of id's saving any active hits.

excluding the id's solutions where a cell in the id is active but it isn't valid in the grids pencil marks
exclude the id's that have cells active but the Grid cell contains a solved digit <> N


edit: added all 46,656 combinations, each line represent a potential Id and listing the active cells that make up that id
{cells listed as 0..80 format =>> left to right =>>top down }
Some do, some teach, the rest look it up.
User avatar
StrmCkr
 
Posts: 601
Joined: 05 September 2006

Re: Basics of POM (Pattern Overlay Method)

Postby StrmCkr » Tue Feb 14, 2017 7:01 am

test puzzle:
6.23.915..3.2....6954.16.3.26.5.43.141..235..5.31.....3..4.2.1584..3.6...2....4.3

pm updated based on above string:
Code: Select all
.----------------.-------------------.---------------------.
| 6   78   2     | 3     478    9    | 1     5       478   |
| 17  3    178   | 2     4578   578  | 789   4789    6     |
| 9   5    4     | 78    1      6    | 278   3       278   |
:----------------+-------------------+---------------------:
| 2   6    789   | 5     789    4    | 3     789     1     |
| 4   1    789   | 6789  2      3    | 5     6789    789   |
| 5   789  3     | 1     6789   78   | 2789  246789  24789 |
:----------------+-------------------+---------------------:
| 3   79   679   | 4     6789   2    | 789   1       5     |
| 8   4    1579  | 79    3      157  | 6     279     279   |
| 17  2    15679 | 6789  56789  1578 | 4     789     3     |
'----------------'-------------------'---------------------'


template generation:
"Locked ": Save a list of Cell for each N grid givens
"Delete" save a list Cells of each Grid Given that is not N and Cells that do not have N in pencil-marks

for each "set" of potential id;s in the 46,656 file in previous post.
run the following state check
Code: Select all
(( Set - deleted ) * locked = locked )
 and
( deleted * set = [] )

save any set that hits true

here is my list:
{note my code eliminates listing the Grid Givens from the set}
Code: Select all
Digit 1
9 65 77
9 68 74
11 68 72

Code: Select all
Digit 2
24 52 71
24 53 70
26 51 70
 

Code: Select all
Digit 3

Code: Select all
Digit 4
4 16 53
8 13 52
 

Code: Select all
Digit 5
13 65 77
14 65 76
13 68 74

Code: Select all
Digit 6
39 52 56 76
43 49 56 75
39 52 58 74

Code: Select all
Digit 7
4 9 24 29 39 53 55 68 79
4 9 26 29 39 51 55 68 79
8 9 21 31 38 51 55 68 79
4 9 24 29 44 50 55 66 79
4 9 24 34 39 46 56 71 77
4 9 24 29 39 52 55 71 77
4 9 24 29 39 53 55 70 77
4 9 26 29 39 51 55 70 77
8 9 21 31 38 51 55 70 77
8 9 21 31 43 46 60 65 77
4 9 26 34 39 46 60 65 77
4 9 24 29 43 50 55 71 75
4 9 24 34 38 50 55 71 75
4 9 24 29 44 50 55 70 75
8 9 21 31 43 46 60 68 74
4 9 26 34 39 46 60 68 74
1 14 24 29 39 52 58 71 72
1 15 21 29 43 50 58 71 72
1 15 21 34 38 50 58 71 72
1 14 24 29 39 53 58 70 72
1 14 26 29 39 51 58 70 72
1 15 21 29 44 50 58 70 72
1 16 21 31 38 53 60 68 72
1 13 26 29 39 52 60 68 72
1 16 21 29 44 49 60 68 72
8 11 21 31 43 46 60 68 72
4 11 26 34 39 46 60 68 72
1 14 26 31 38 52 60 66 72
1 13 26 29 43 50 60 66 72
1 13 26 34 38 50 60 66 72
1 14 26 29 43 49 60 66 72
1 14 26 34 38 49 60 66 72

Code: Select all
Digit 8
1 14 24 29 39 53 58 79
1 14 26 29 39 51 58 79
1 15 21 29 44 50 58 79
1 16 21 31 38 53 60 77
1 13 26 29 39 52 60 77
1 16 21 29 44 49 60 77
8 11 21 31 43 46 60 77
4 11 26 34 39 46 60 77
1 14 26 29 39 52 60 76
1 16 21 29 44 50 60 76
1 14 26 31 38 52 60 75
1 13 26 29 43 50 60 75
1 13 26 34 38 50 60 75
1 14 26 29 43 49 60 75
1 14 26 34 38 49 60 75

Code: Select all
Digit 9
15 31 44 46 56 66 79
15 31 38 53 55 66 79
15 29 44 49 55 66 79
15 34 39 46 56 71 76
15 29 39 52 55 71 76
16 29 39 51 55 71 76
15 29 39 53 55 70 76
15 31 43 46 56 71 75
15 31 38 52 55 71 75
16 31 38 51 55 71 75
15 29 43 49 55 71 75
15 34 38 49 55 71 75
15 31 44 46 56 70 75
15 31 38 53 55 70 75
15 29 44 49 55 70 75
16 31 44 46 60 65 75
15 34 39 46 58 71 74
16 31 44 46 60 66 74


elimination steps 1:
for each N digit "sum" all cells used in all of the potential id
(
Code: Select all
 [0..80] - locked - deleted  ) - sum


if any digit is left in the initial set of [0..80] cells then that number may be excluded as it is never used in any of the potential solutions.

elimination:
digit 7 @ cell 76
...

Naked Triple: Cells 66, 70,71 on digits 2,7,9
step 1:
in each digit 2,7,9 mark "x" each potential solution that contains cells 65,70,71
all unmarked solutions may be deleted.
Code: Select all
Digit 2
24 52 71 x
24 53 70 x
26 51 70 x

Code: Select all
Digit 7
4 9 24 29 39 53 55 68 79
4 9 26 29 39 51 55 68 79
8 9 21 31 38 51 55 68 79
4 9 24 29 44 50 55 66 79 x
4 9 24 34 39 46 56 71 77 x
4 9 24 29 39 52 55 71 77 x
4 9 24 29 39 53 55 70 77 x
4 9 26 29 39 51 55 70 77 x
8 9 21 31 38 51 55 70 77 x
8 9 21 31 43 46 60 65 77
4 9 26 34 39 46 60 65 77
4 9 24 29 43 50 55 71 75 x
4 9 24 34 38 50 55 71 75 x
4 9 24 29 44 50 55 70 75 x
8 9 21 31 43 46 60 68 74
4 9 26 34 39 46 60 68 74
1 14 24 29 39 52 58 71 72 x
1 15 21 29 43 50 58 71 72 x
1 15 21 34 38 50 58 71 72 x
1 14 24 29 39 53 58 70 72 x
1 14 26 29 39 51 58 70 72 x
1 15 21 29 44 50 58 70 72 x
1 16 21 31 38 53 60 68 72
1 13 26 29 39 52 60 68 72
1 16 21 29 44 49 60 68 72
8 11 21 31 43 46 60 68 72
4 11 26 34 39 46 60 68 72
1 14 26 31 38 52 60 66 72 x
1 13 26 29 43 50 60 66 72 x
1 13 26 34 38 50 60 66 72 x
1 14 26 29 43 49 60 66 72 x
1 14 26 34 38 49 60 66 72 x

Code: Select all
Digit 9
15 31 44 46 56 66 79 x
15 31 38 53 55 66 79 x
15 29 44 49 55 66 79 x
15 34 39 46 56 71 76 x
15 29 39 52 55 71 76 x
16 29 39 51 55 71 76 x
15 29 39 53 55 70 76 x
15 31 43 46 56 71 75 x
15 31 38 52 55 71 75 x
16 31 38 51 55 71 75 x
15 29 43 49 55 71 75 x
15 34 38 49 55 71 75 x
15 31 44 46 56 70 75 x
15 31 38 53 55 70 75 x
15 29 44 49 55 70 75 x
16 31 44 46 60 65 75
15 34 39 46 58 71 74 x
16 31 44 46 60 66 74 x


apply step1.
eliminations:
Digit 7 @ 11,65,68,74
Digit 9 @ 65

Hidden Pair:
Cells 65,68 digits 1,5
delete all potential solutions that contain cells 65,68 in all other numbers
{direct inverse of above step all non x cells are deleted}
apply step 1
eliminations:
Digit 7 @ 11,65,68,74
Digit 9 @ 65


more complicated:
Almost Locked Set XY-Wing: A=r8c4689 {12579}, B=r7c2,r9c1 {179}, C=r269c6 {1578}, X,Y=1,5, Z=7,9 => r8c3<>7, r8c3<>9

for each Cell on each digit used in the als-xy, mark every rasters that has that cell.
delete all unmarked rasters for each digit

apply step 1:
eliminations:
Digit 7 @ 65,
Digit 9 @ 65
Last edited by StrmCkr on Tue Feb 14, 2017 7:57 am, edited 3 times in total.
Some do, some teach, the rest look it up.
User avatar
StrmCkr
 
Posts: 601
Joined: 05 September 2006

Postby StrmCkr » Tue Feb 14, 2017 7:18 am

i know this one is off topic to this but it is directly related:

a brute force method based off templates lists raster .

for each N digit there is z potential "raster". {index's}

an engine could cycle each z{1..9} for each N digit
starting with the shortest list size and increasing

1[z], 2[z2],3[z3],4[z4],5[z5],6[z6],7[z7].8[z8].9[z9] = [0..80];

updating subset list of id's per z placed in previous step
if it leaves no id's for next subset back to previous state and select a different id

this could be able to identify if its muti,single or zero solution grid.
Some do, some teach, the rest look it up.
User avatar
StrmCkr
 
Posts: 601
Joined: 05 September 2006


Return to Advanced solving techniques