Sudoku Programmers Forum Index

 
 FAQFAQ   SearchSearch   MemberlistMemberlist   UsergroupsUsergroups   RegisterRegister   ProfileProfile   Log inLog in          Games  Calendar

Log in to check your private messagesLog in to check your private messages   

NEWS:
how to code BUG-Lite

 
Post new topic   Reply to topic    Sudoku Programmers Forum Index -> Solving sudoku
View previous topic :: View next topic  
Author Message
surbier

Joined: 30 Jan 2010
Posts: 22
:

Items
PostPosted: Tue Apr 05, 2011 2:15 pm    Post subject: how to code BUG-Lite Reply with quote

Hi,

I'm currently programming BUG-Lite
BUG-Lite

First, I understood rather late that BUG-Lite covers BUG+n, unique loops
and UR deadly pattern, hence part of my coding work will be insane in
case I succeed in coding BUG-Lite.

What I'm doing for BUG-Lite is the following.
- I retrieve tuple cells (a subset of all unsolved cells) in a house
- candidates that occur exactly 2 times in the tuple are flagged as BUG candidates
- candidates that occur 1 time are flagges as non-BUG candidates

With this definition of BUG-Lite composite in a house, I use a loop
over all 9 rows and a loop over all tuples of cells of sizes (2..6)
which give me a number of starting point tuples for the
recursive build up of the final BUG-Lite grid.

The code can find in the following example the UR+2D ( (89)[r19c78] ) without
eliminations, and BUG-Lite (# marks) with r1c8<>8.


Code:

000000007003080400408007000010006020069005010020100039000000142000092070006000005
152463987673289451498517263714936528369825714825174639937658142541392876286741395


+--------------+-----------------+---------------+
| 1  #59    2  |  34 #56    34   | 89  #69+8  7  |
| 6   7     3  |  2   8     9    |  4   5    1   |
| 4  #59    8  | #56  1     7    |  2  #69   3   |
+--------------+-----------------+---------------+
| 37    1   4  |  9   37    6    |  5   2     8  |
| 38    6   9  |  38  2     5    |  7   1     4  |
| 78    2   5  |  1   47    48   |  6   3     9  |
+--------------+-----------------+---------------+
| 9   38    7  | #56 #56    38   |  1    4    2  |
| 5   348   1  |  348 9     2    |  38   7    6  |
| 2   348   6  |  7   34    1    | 893   89   5  |
+--------------+-----------------+---------------+

+--------------+-----------------+---------------+
| 1   59    2  | *34  56   *34   | 89  968   7   |
| 6   7     3  |  2   8     9    |  4   5    1   |
| 4   59    8  |  56  1     7    |  2   69   3   |
+--------------+-----------------+---------------+
|*37    1   4  |  9  *37    6    |  5   2     8  |
|*38    6   9  | *38  2     5    |  7   1     4  |
|*78    2   5  |  1  *47   *48   |  6   3     9  |
+--------------+-----------------+---------------+
| 9  *38    7  |  56  56   *38   |  1    4    2  |
| 5  *34+8  1  | *48+3 9     2   | *38   7    6  |
| 2  *48+3  6  |  7  *34    1    | *83+9 89   5  |
+--------------+-----------------+---------------+


However the third one (* marks) cannot be found. This is not because of the more than
one non-BUG candidates, it is more the situation in row 8: there are two
valid but different interpretations within one tuple (here tuple size =
3 cells)

Code:

r8c2(34+8)   r8c4(48+3)  r8c7(38)
r8c2(48+3)   r8c4(34+8)  r8c7(38)


So I modified my program to allowed for candidates with more than 2
occurences within the tuple, which might then become a BUG or a non-BUG
candidate dependent on how the candidates are intepreted. (the 8 occurs
three times, hence it must occur one time as non-BUG candidate and two
times as a BUG candidate; but there are two possibilities/cells in which
the 8 occurs as a non-BUG candidate) As there is no unique rule to decide
in which cell those candidates, (which occur more than two times) have to
be flagged as non-BUG or BUG, and in order to catch all these cases I
have to consider permutations between candidates within a BUG-Lite cell
according to if the candidate is flagged as BUG or non-BUG candidate. I
have already implemented permutations and have started same basic test,
but I still see the large amount of programming efforts to get the code
work in the generic manner I want.

On the otther side the properties of the final grid looks simple:
each BUG candidate must occur twice in each house of the BUG-Lite grid.

This post is to request some feedback if I'm still on the right
path (I'm confident, since my simple version is able to find the
example marked with #) or if I maybe have overlooked
a more elegant way to find BUG-Lite grids.

Thanks in advance
Back to top
View user's profile Send private message
ronk

Joined: 15 Apr 2010
Posts: 143
:
Location: Southeastern USA

Items
PostPosted: Tue Apr 05, 2011 2:44 pm    Post subject: Reply with quote

surbier, in your example, wouldn't the limited possibilities in box 8 dictate which of the the two possibilities in row 8 applied?
Back to top
View user's profile Send private message
dpbobelisk

Joined: 27 Apr 2006
Posts: 143
:
Location: Middle England

Items
PostPosted: Tue Apr 05, 2011 3:07 pm    Post subject: Reply with quote

In your problem row r8 you have 4 as a BUG candidate and 3 & 8 in the same tuple occurring 3 times or more generally an even number of digits occurring an odd number of times (but I don't know where that will lead). This makes the difference between 3 & 8 indistinguishable in r8c2 & r8c4.

For a hit, the other houses containing these cells must also hold the two BUG digits twice though. For r8c2 this is no help as they are also indistinguishable for both c2 and b7, but for r8c4 in c4 and b8 8 is bilocal and 3 trilocal which will distinguish one from the other.

So it might be good enough to keep your row checking procedure the same and when you hit an ambiguous row do a secondary check on the boxes and columns containing the problem cells.

I see that while I was writing this Ron made the same point more cocisely.
Back to top
View user's profile Send private message
surbier

Joined: 30 Jan 2010
Posts: 22
:

Items
PostPosted: Tue Apr 05, 2011 3:41 pm    Post subject: Reply with quote

I have three basic equivalent procedures to identify BUG-Lite composites in a row in a column and in a block. They don't know of each other.

Building up the grid is done in a recursive manner :
For a found valid row tuple (in the example both are valid in itself)
for each of the cells a block tuple and a col tuple is searched for.
So, one level deeper, in the block check routine, no block tuple is found
that includes cell r8c4 and that matches the candidate flags of r8c4.
In this case, this branch in the search tree is declared a dead-end road
and the search continues with other branches/possibilities.

The knowledge, if the current BUG-Lite composite in the recursive
search tree matches the next building block BUG-Lite composite
is only available in the next recursive level.
I think for the current BUG-Lite composite
all candidate flag permutations must be tested.

So the secondoary check you mention is done anyway as part of
finding and attaching the next component to the grid.
Back to top
View user's profile Send private message
daj95376

Joined: 05 Feb 2006
Posts: 431
:

Items
PostPosted: Tue Apr 05, 2011 4:22 pm    Post subject: Re: how to code BUG-Lite Reply with quote

surbier wrote:
The code can find in the following example the UR+2D ( (89)[r19c78] ) without eliminations, ...

Hmmmm. I don't know about your BUG issues, but the above statement has me confused.

First, there isn't a cell with <36> to support a UR+2D pattern.

Quote:
--- UR+2D: two cells with extra candidates diagonal to each other such that "X+Y"="xy" and a naked "xy" common the "abX" and "abY" => eliminate "xy" from the cell common to all three (given "abX" and the rightmost "ab" share a box then at the "*")

Code:
ab   |  abX
abY  |  ab  xy *


Second, there are eliminations from a UR+2D/1SL, which you didn't indicate.

Quote:
--- UR+2D/1SL: cells with extra candidates diagonal to each other => strong link on "a" removes "a" from "abY" - repeat for each strong link

Code:
 ab     abY
 |
 |a
 |
abX     ab


Code:
 after basics
 +-----------------------------------------------------+
 |  1    59   2    |  34   56   34   |  89   89+6 7    |
 |  6    7    3    |  2    8    9    |  4    5    1    |
 |  4    59   8    |  56   1    7    |  2    69   3    |
 |-----------------+-----------------+-----------------|
 |  37   1    4    |  9    37   6    |  5    2    8    |
 |  38   6    9    |  38   2    5    |  7    1    4    |
 |  78   2    5    |  1    47   48   |  6    3    9    |
 |-----------------+-----------------+-----------------|
 |  9    38   7    |  56   56   38   |  1    4    2    |
 |  5    348  1    |  348  9    2    |  38   7    6    |
 |  2    348  6    |  7    34   1    |  89+3 89   5    |
 +-----------------------------------------------------+
 # 32 eliminations remain

 r19c78  <89> UR via s-link  9c7         <> 9    r1c8
 r19c78  <89> UR via s-link  8c8         <> 8    r9c7
Back to top
View user's profile Send private message
ronk

Joined: 15 Apr 2010
Posts: 143
:
Location: Southeastern USA

Items
PostPosted: Tue Apr 05, 2011 4:48 pm    Post subject: Re: how to code BUG-Lite Reply with quote

surbier wrote:
there are two
valid but different interpretations within one tuple (here tuple size =
3 cells)

Code:

r8c2(34+8)   r8c4(48+3)  r8c7(38)
r8c2(48+3)   r8c4(34+8)  r8c7(38)

Perhaps the following should be considered valid interpretations as well.

Code:

r8c2(38+4)   r8c4(4+38)  r8c7(38)
r8c2(4+38)   r8c4(38+4)  r8c7(38)
Back to top
View user's profile Send private message
surbier

Joined: 30 Jan 2010
Posts: 22
:

Items
PostPosted: Tue Apr 05, 2011 4:49 pm    Post subject: Reply with quote

daj95376 wrote:
First, there isn't a cell with <36> to support a UR+2D pattern.


Yes, I should have been more precise. There is no elimiantion, as there is no
supporting xy cell to build up the full UR+2D.

daj95376 wrote:
Second, there are eliminations from a UR+2D/1SL, which you didn't indicate.


I used the example for the purpose it shows the smallest deadly pattern (UR),
a small grid BUG-Lite (+1) and the more complex BUG-Lite (+4).
So I didn't investigate the UR elimination (I switched off the UR methods for this purpose)
Back to top
View user's profile Send private message
dpbobelisk

Joined: 27 Apr 2006
Posts: 143
:
Location: Middle England

Items
PostPosted: Tue Apr 05, 2011 10:39 pm    Post subject: Reply with quote

Surbier, from your descriptions I can't understand exactly how you are selecting candidate tuples for each house as there are often multiple choices. I can only suppose that you are looping through all the possibilities.

As you are asking for alternative methods here's one you might not have considered: rather than flagging digits in each house flag the cells that are non-BUG.

Using a looping order of r123, b123, c123, b47, r456, b56, c456, r789, b89, c789 would eliminate the non-contenders the quickest. This is because as soon as an un-flagged cell in an earlier house X is eliminated, the search is abandoned and restarted from the next tuple option for house X.

I think this approach could find any type of BUG pattern, but at the moment I can't see how to refine it just to look for BUG-lites.
Back to top
View user's profile Send private message
surbier

Joined: 30 Jan 2010
Posts: 22
:

Items
PostPosted: Wed Apr 06, 2011 1:23 pm    Post subject: Reply with quote

ronk, thanks for for the two additional interpretations

but wouldn't they be equivalent to a tuple of two cells ?
Code:

r8c2(38+4)   r8c4(4+38)  r8c7(38)   =  r8c2(38+4)  r8c7(38)
r8c2(4+38)   r8c4(38+4)  r8c7(38)   =  r8c4(38+4)  r8c7(38)



Let me add some pseudocode.
I hope it it not too pseudo.

Code:

get_most_suitable_house:
# each cell has three flags r/c/b representing
# its partition in the grid as a member in a row/col/blk
# the most suitable new house is a house, that
# completes the involved cells instead of introducing
# new cells into the grid.
# example
#  1/1/1     1/1/1   1/1/0
#  0/1/1     0/1/1   0/1/0
# a row house composite of tuple_size 3 in the second column and/or
# a block house composite of tuple_size=2 in the most right block are the most
# suitable houses to towards completion of the BUG-Lite , to get something like:
#  1/1/1     1/1/1   1/1/1
#  1/1/1     1/1/1   1/1/1
# without this mechanism, the BUG-Lite grid with the most number of cells is prefered,
# but I prefer the smallest size BUG-Lite.


search_new:
house=get_the_most_suitable_house

    for (tuple size = 1 to 6)
        for any combination of tuple_size cells out of all unsolved cells the house
            # permute all candidate non-BUG/BUG flags and test interpretation
            # cells shared between the grid and the new house
            # must match in candidate flags (what is BUG and what is non-BUG)
            if (interpretation==valid and flags match in shared cells)
               {
               append_to_grid();
               if (grid == complete) analyse_eliminations(); else search_new();
               delete_again_from_grid() 
               }

starter:
for (house = row1; house <= row9; house++)
    for (tuple_size = 2 ; tuple_size<=6; tuple_size++)
        for any combination of tuple_size cells out of all unsolved cells within the house
            # permute all candidate flags and test interpretation
            if (interpretation==valid)
               {
               append_to_grid();
               search_new();
               delete_again_from_grid(); 
               }



dpbobelisk wrote:
Using a looping order of r123, b123, c123, b47, r456, b56, c456, r789, b89, c789 would eliminate the non-contenders the quickest. This is because as soon as an un-flagged cell in an earlier house X is eliminated, the search is abandoned and restarted from the next tuple option for house X.


If I understand you right, I think I use something equivalent
within the 'most_suitable_house' part.
Back to top
View user's profile Send private message
ronk

Joined: 15 Apr 2010
Posts: 143
:
Location: Southeastern USA

Items
PostPosted: Wed Apr 06, 2011 2:12 pm    Post subject: Reply with quote

surbier wrote:
wouldn't they be equivalent to a tuple of two cells ?
Code:

r8c2(38+4)   r8c4(4+38)  r8c7(38)   =  r8c2(38+4)  r8c7(38)
r8c2(4+38)   r8c4(38+4)  r8c7(38)   =  r8c4(38+4)  r8c7(38)

Maybe, but you would have to consider the (38) in (4+38) as non-BUG candidates. Moreover, all 4s that see this cell would also be non-BUG candidates. Not a pretty picture, but I've seen a few BUGs like this. Probably only a small percentage of puzzles would need such an interpretation, so little is lost by ignoring them (I think).

Thanks for sharing your pseudo-code, will see if the light brightens.
Back to top
View user's profile Send private message
dpbobelisk

Joined: 27 Apr 2006
Posts: 143
:
Location: Middle England

Items
PostPosted: Thu Apr 07, 2011 6:49 am    Post subject: Reply with quote

Surbier, my point about flagging potential bug cells rather than candidates is that it wouldn't be affected by the ambiguous tuples that cause you trouble.

Eg. this tuple (abc) (abc) (bc) passes two basic tests.
1 The set of candidates that appears more than once in the set is greater or equal to the number of cells.
2 Each cell contains at least two candidates from that set.

Only once a qualifying cell pattern has been found would it be necessary to identify the BUG and non-BUG candidates in each cell.

Surbier wrote:
If I understand you right, I think I use something equivalent within the 'most_suitable_house' part.

Yes I see that and it looks superior to my brute force fixed loop order. The only reservation it gives me is ensuring that every possibility has been covered by the end of the procedure call.
Back to top
View user's profile Send private message
surbier

Joined: 30 Jan 2010
Posts: 22
:

Items
PostPosted: Fri Apr 08, 2011 6:01 am    Post subject: Reply with quote

dpbobelisk, I agree.

I found the basic test #2 further downstream in my code and I have copied it
further upstream and do it from now on together with test #1.
With this test one can exclude cases like (abc) (abc) (ad), which pass test #1 but not test #2

Good Hint!

Nevertheless test #2 must be repeated per permutation:
Given your example, that would pass both tests before nonBUG/BUG
flagging has been applied:

Code:
abc  abc bc 


( excluding the exotic cases of single BUG candidates in a cell)
The full set of permutations for the tuple 3 three cells would be:

Code:
ab+c  ab+c  bc
ab+c  bc+a  bc
ab+c  ac+b  bc (valid)

ac+b  ab+c  bc (valid)
ac+b  bc+a  bc
ac+b  ac+b  bc

bc+a  ab+c  bc
bc+a  bc+a  bc
bc+a  ac+b  bc


The seven invalid permutations, not excluded by test #2 applied to unflagged candidates, can be identified via test #2 on (flagged) BUG candidates.
Back to top
View user's profile Send private message
dpbobelisk

Joined: 27 Apr 2006
Posts: 143
:
Location: Middle England

Items
PostPosted: Fri Apr 08, 2011 1:14 pm    Post subject: Reply with quote

Surbier, I hadn't considered screening the tuples that pass both the basic tests further until a qualifying BUG cell pattern had been found just by considering cell sets because by that time there wouldn't be many remaining.

If there are more than 3 cells involved the number of permutations will rise dramatically, and testing each of them may take more time than it would save it might be worth trying out both options.

However, if permutation testing is required, then there are some short-cuts that may be available by considering the candidates in bivalue cells and any that are bilocal in the tuple.

Good Luck!
Back to top
View user's profile Send private message
surbier

Joined: 30 Jan 2010
Posts: 22
:

Items
PostPosted: Mon Apr 11, 2011 7:52 am    Post subject: Reply with quote

surbier wrote:
daj95376 wrote:
First, there isn't a cell with <36> to support a UR+2D pattern.


Yes, I should have been more precise. There is no elimiantion, as there is no
supporting xy cell to build up the full UR+2D.

daj95376 wrote:
Second, there are eliminations from a UR+2D/1SL, which you didn't indicate.


I used the example for the purpose it shows the smallest deadly pattern (UR),
a small grid BUG-Lite (+1) and the more complex BUG-Lite (+4).
So I didn't investigate the UR elimination (I switched off the UR methods for this purpose)


I checked this again. The UR methods were activated for this run to look for BUG-Lite examples, that do not show any UR with elimination. However my code
did not found any UR elimination.
I misidentified the UR+2D/1SL with the classical UR6 and hence did not code
UR+2D/1SL as I coded the six classical URs before I found the MB thread.
Secondly, some more complex URs were not found by the code. The reason is, that for the
URs with Z in the lower right corner of the UR, the requested that Z must consist of at least one candidate (in the code). As Z is not part of a supporting bi-location strong link in the
MikeBarker examples, I relaxed the conditions allowing for Z={} (empty set).
Beside the UR+2D/1SL you found, my code finds now the following UR eliminations at variance

Code:
UR+3X/2SL (89)[17|98], [18]<>9
UR+3X/2SL (89)[17|98], [97]<>8


thanks for the heads up
Back to top
View user's profile Send private message
surbier

Joined: 30 Jan 2010
Posts: 22
:

Items
PostPosted: Thu May 05, 2011 5:10 pm    Post subject: Reply with quote

Hi,

Thanks to your motivating comments, I managed to get this run. I give
here the complete set of BUG-Lite deadly pattern, found by the code.
As you can see there are 4 distinct BUG-Lite grids of small size and
some BUG-Lite grids which can be considered as a combination of the
four basic ones ones. The largest one (the last one listed) is a BUG
with 5 non-BUG values.



1) basic pattern 1, UR+2D1SL 4 cells with 2 non-BUG candidates
Code:

+--------------------+--------------------+--------------------+
|  1    59     2     | 34    56    34     | #89   #89+6  7     |
|  6     7     3     |  2     8     9     |  4     5     1     |
|  4    59     8     | 56     1     7     |  2    69     3     |
+--------------------+--------------------+--------------------+
| 37     1     4     |  9    37     6     |  5     2     8     |
| 38     6     9     | 38     2     5     |  7     1     4     |
| 78     2     5     |  1    47    48     |  6     3     9     |
+--------------------+--------------------+--------------------+
|  9    38     7     | 56    56    38     |  1     4     2     |
|  5    348    1     | 348    9     2     | 38     7     6     |
|  2    348    6     |  7    34     1     | #89+3 #89    5     |
+--------------------+--------------------+--------------------+



2) basic pattern 2, 8 cells with 1 non-BUG candidates r1c8=8
Code:

+--------------------+--------------------+--------------------+
|  1    #59    2     | 34    #56   34     | 89    #69+8  7     |
|  6     7     3     |  2     8     9     |  4     5     1     |
|  4    #59    8     | #56    1     7     |  2    #69    3     |
+--------------------+--------------------+--------------------+
| 37     1     4     |  9    37     6     |  5     2     8     |
| 38     6     9     | 38     2     5     |  7     1     4     |
| 78     2     5     |  1    47    48     |  6     3     9     |
+--------------------+--------------------+--------------------+
|  9    38     7     | #56   #56   38     |  1     4     2     |
|  5    348    1     | 348    9     2     | 38     7     6     |
|  2    348    6     |  7    34     1     | 389   89     5     |
+--------------------+--------------------+--------------------+


3) basic pattern 3a, 15 cells with 3 non-BUG candidates, r8c7=8
Code:

+--------------------+--------------------+--------------------+
|  1    59     2     | #34   56    #34    | 89    689    7     |
|  6     7     3     |  2     8     9     |  4     5     1     |
|  4    59     8     | 56     1     7     |  2    69     3     |
+--------------------+--------------------+--------------------+
| #37    1     4     |  9    #37    6     |  5     2     8     |
| #38    6     9     | #38    2     5     |  7     1     4     |
| #78    2     5     |  1    #47   #48    |  6     3     9     |
+--------------------+--------------------+--------------------+
|  9    #38    7     | 56    56    #38    |  1     4     2     |
|  5    #48+3  1     | #48+3  9     2     | 38     7     6     |
|  2    #34+8  6     |  7    #34    1     | 389   89     5     |
+--------------------+--------------------+--------------------+


4) basic pattern 3b, 17 cells with 3 non-BUG candidates
Code:

+--------------------+--------------------+--------------------+
|  1    59     2     | #34   56    #34    | 89    689    7     |
|  6     7     3     |  2     8     9     |  4     5     1     |
|  4    59     8     | 56     1     7     |  2    69     3     |
+--------------------+--------------------+--------------------+
| #37    1     4     |  9    #37    6     |  5     2     8     |
| #38    6     9     | #38    2     5     |  7     1     4     |
| #78    2     5     |  1    #47   #48    |  6     3     9     |
+--------------------+--------------------+--------------------+
|  9    #38    7     | 56    56    #38    |  1     4     2     |
|  5    #34+8  1     | #48+3  9     2     | #38    7     6     |
|  2    #48+3  6     |  7    #34    1     | #38+9 89     5     |
+--------------------+--------------------+--------------------+



Now some BUG-Lites, based on combinations of the 4 basic BUG-Lite grids:

5) 11 cells with 2 non-BUG candidates (1 and 2 combined)
Code:

+--------------------+--------------------+--------------------+
|  1    #59    2     | 34    #56   34     | #89   #68+9  7     |
|  6     7     3     |  2     8     9     |  4     5     1     |
|  4    #59    8     | #56    1     7     |  2    #69    3     |
+--------------------+--------------------+--------------------+
| 37     1     4     |  9    37     6     |  5     2     8     |
| 38     6     9     | 38     2     5     |  7     1     4     |
| 78     2     5     |  1    47    48     |  6     3     9     |
+--------------------+--------------------+--------------------+
|  9    38     7     | #56   #56   38     |  1     4     2     |
|  5    348    1     | 348    9     2     | 38     7     6     |
|  2    348    6     |  7    34     1     | #89+3 #89    5     |
+--------------------+--------------------+--------------------+


6) 19 cells with 5 non-BUG candidates (3a with 1)
Code:

+--------------------+--------------------+--------------------+
|  1    59     2     | #34   56    #34    | #89   #89+6  7     |
|  6     7     3     |  2     8     9     |  4     5     1     |
|  4    59     8     | 56     1     7     |  2    69     3     |
+--------------------+--------------------+--------------------+
| #37    1     4     |  9    #37    6     |  5     2     8     |
| #38    6     9     | #38    2     5     |  7     1     4     |
| #78    2     5     |  1    #47   #48    |  6     3     9     |
+--------------------+--------------------+--------------------+
|  9    #38    7     | 56    56    #38    |  1     4     2     |
|  5    #48+3  1     | #48+3  9     2     | 38     7     6     |
|  2    #34+8  6     |  7    #34    1     | #89+3 #89    5     |
+--------------------+--------------------+--------------------+


7) 20 cells with 5 non-BUG candidates (3b with 1)
Code:

+--------------------+--------------------+--------------------+
|  1    59     2     | #34   56    #34    | #89   #89+6  7     |
|  6     7     3     |  2     8     9     |  4     5     1     |
|  4    59     8     | 56     1     7     |  2    69     3     |
+--------------------+--------------------+--------------------+
| #37    1     4     |  9    #37    6     |  5     2     8     |
| #38    6     9     | #38    2     5     |  7     1     4     |
| #78    2     5     |  1    #47   #48    |  6     3     9     |
+--------------------+--------------------+--------------------+
|  9    #38    7     | 56    56    #38    |  1     4     2     |
|  5    #34+8  1     | #48+3  9     2     | #38    7     6     |
|  2    #48+3  6     |  7    #34    1     | #39+8 #89    5     |
+--------------------+--------------------+--------------------+


8) 23 cells with 4 non-BUG candidates (2 and 3a combined)
Code:

+--------------------+--------------------+--------------------+
|  1    #59    2     | #34   #56   #34    | 89    #69+8  7     |
|  6     7     3     |  2     8     9     |  4     5     1     |
|  4    #59    8     | #56    1     7     |  2    #69    3     |
+--------------------+--------------------+--------------------+
| #37    1     4     |  9    #37    6     |  5     2     8     |
| #38    6     9     | #38    2     5     |  7     1     4     |
| #78    2     5     |  1    #47   #48    |  6     3     9     |
+--------------------+--------------------+--------------------+
|  9    #38    7     | #56   #56   #38    |  1     4     2     |
|  5    #48+3  1     | #48+3  9     2     | 38     7     6     |
|  2    #34+8  6     |  7    #34    1     | 389   89     5     |
+--------------------+--------------------+--------------------+


9) 25 cells with 5 non-BUG candidates (2 and 3b combined)
Code:

+--------------------+--------------------+--------------------+
|  1    #59    2     | #34   #56   #34    | 89    #69+8  7     |
|  6     7     3     |  2     8     9     |  4     5     1     |
|  4    #59    8     | #56    1     7     |  2    #69    3     |
+--------------------+--------------------+--------------------+
| #37    1     4     |  9    #37    6     |  5     2     8     |
| #38    6     9     | #38    2     5     |  7     1     4     |
| #78    2     5     |  1    #47   #48    |  6     3     9     |
+--------------------+--------------------+--------------------+
|  9    #38    7     | #56   #56   #38    |  1     4     2     |
|  5    #34+8  1     | #48+3  9     2     | #38    7     6     |
|  2    #48+3  6     |  7    #34    1     | #38+9 89     5     |
+--------------------+--------------------+--------------------+


10) 26 cells with 5 non-BUG candidates (1 2 and 3a combined)
Code:
 
+--------------------+--------------------+--------------------+
|  1    #59    2     | #34   #56   #34    | #89   #68+9  7     |
|  6     7     3     |  2     8     9     |  4     5     1     |
|  4    #59    8     | #56    1     7     |  2    #69    3     |
+--------------------+--------------------+--------------------+
| #37    1     4     |  9    #37    6     |  5     2     8     |
| #38    6     9     | #38    2     5     |  7     1     4     |
| #78    2     5     |  1    #47   #48    |  6     3     9     |
+--------------------+--------------------+--------------------+
|  9    #38    7     | #56   #56   #38    |  1     4     2     |
|  5    #48+3  1     | #48+3  9     2     | 38     7     6     |
|  2    #34+8  6     |  7    #34    1     | #89+3 #89    5     |
+--------------------+--------------------+--------------------+


11) 27 cells with 5 non-BUG candidates = BUG (1, 2 and 3b combined)
Code:

+--------------------+--------------------+--------------------+
|  1    #59    2     | #34   #56   #34    | #89   #68+9  7     |
|  6     7     3     |  2     8     9     |  4     5     1     |
|  4    #59    8     | #56    1     7     |  2    #69    3     |
+--------------------+--------------------+--------------------+
| #37    1     4     |  9    #37    6     |  5     2     8     |
| #38    6     9     | #38    2     5     |  7     1     4     |
| #78    2     5     |  1    #47   #48    |  6     3     9     |
+--------------------+--------------------+--------------------+
|  9    #38    7     | #56   #56   #38    |  1     4     2     |
|  5    #34+8  1     | #48+3  9     2     | #38    7     6     |
|  2    #48+3  6     |  7    #34    1     | #39+8 #89    5     |
+--------------------+--------------------+--------------------+
Back to top
View user's profile Send private message
Display posts from previous:   
Post new topic   Reply to topic    Sudoku Programmers Forum Index -> Solving sudoku All times are GMT
Page 1 of 1

 
Jump to:  
You cannot post new topics in this forum
You cannot reply to topics in this forum
You cannot edit your posts in this forum
You cannot delete your posts in this forum
You cannot vote in polls in this forum
Sudoku Programmers topic RSS feed 


Powered by phpBB © 2001, 2005 phpBB Group

Igloo Theme Version 1.0 :: Created By: Andrew Charron
FREE FORUM HOSTING by AtFreeForum. Terms of Service - Privacy Policy
FASHION ACCESSORIES - BLING BLING - LADIES WATCHES - KOREAN CHILDREN CLOTHING - ONLINE BARGAIN STORE - FASHION JEWELLERIES