In solving a Sudoku puzzle a human often looks at more or less easily recognizable patterns in order to make progress: we call these patterns “Techniques”. Examples are naked pairs, triples, and quads; X-Wings, Swordfishes (and “higher” fishes”), and Unique Rectangles. Although harder to identify, a Nice Loop can also be considered a pattern: a combination of strong and/or weak links. However, there are puzzles whose hardness does not allow us to solve them using only the previously mentioned techniques. So, more advanced techniques were discovered in order to overcome that, and some of them use what can be viewed as “almost patterns”: for example, we now are aware of the usefulness of Almost X-Wings, Almost Swordfishes, Almost Locked Sets, and Almost Unique Rectangles. These techniques make use of patterns that are very closely related to first ones but still can be used to make deductions. Now, if we can consider that a Nice Loop is a pattern, then what might be his correspondent “almost pattern” technique? The answer of this question is a technique that I decided to call the “Almost Nice Loops”, that I will start to describe next.
Part 1. Almost Nice Loops: definition and examples
Let´s start by defining an Almost Nice Loop (which from now on I will
abreviate as ANL) in the following way:
Almost Nice Loop: a set C of cells that, if one (or more) of them does not have specific candidates “x”, “y”, …, then in the cells of C (or in the remaining cells of C) a nice loop sets up, which eliminates or includes a candidate “z” (z = x,y,… or z not = x,y,…) in a cell belonging to C.
Naturaly, such an ANL can be used “inside” another nice loop, typically a multiple implication nice loop, or inside a single implication network. The definition above might appear confusing, but instead of using a lot of words to explain it I will present some representative examples. Let’s begin with a simple example of this concept. Consider the following puzzle:
- Code: Select all
. . 2 | 6 . . | . . .
. 9 . | . . . | 4 . .
. 1 . | . . 9 | . . 7
-------+-------+-------
. . . | . 4 6 | . . 5
. . 4 | . 9 . | . 8 .
. . . | 7 1 . | 3 . 4
-------+-------+-------
8 . . | . 3 1 | . . .
3 . . | 9 8 . | . . .
. . . | 4 . . | . 3 2
and after the basic steps we get:
- Code: Select all
57 38 2 | 6 57 4 | 19 19 38
6 9 57 | 1 257 38 | 4 25 38
4 1 38 | 38 25 9 | 256 256 7
----------------+-------------+---------------
1279 378 1389 | 238 4 6 | 1279 1279 5
1257 3567 4 | 235 9 235 | 1267 8 16
259 568 89 | 7 1 258 | 3 269 4
----------------+-------------+---------------
8 24 567 | 25 3 1 | 567 4567 9
3 24 567 | 9 8 257 | 1567 14567 16
19 57 19 | 4 6 57 | 8 3 2
Just as a matter of comparision, Simple Sudoku continues with coloring, X-Wing, naked triple, locked candidates, coloring again and then gets stuck. However, please note that we have an Almost Turbot Fish (a simple example of a nice loop) in the set C of cells {r6c2|r6c3|r6c6|r4c4|r3c4|r3c3}, in the sense that, if r6c2 is not “8” then a Turbot Fish sets up in the remaining cells of C that eliminates a “8” from r3c3. This observation can be used in the following multiple implication loop:
[r9c6]=7=[r9c2]-7-[r1c2|r4c2]-8-[r6c2]-{Turbot Fish: [r3c3]-8-[r6c3]=8=
[r6c6]-8-[r4c4]=8=[r3c4]-8-[r3c3]}-8-[r3c3]-3-[r3c4]-8-[r2c6](-3-[r5c6])
=8=[r6c6]-8-[r6c3](-9-[r4c2|r4c3])-9-[r9c3]-1-[r4c2|r4c3]-3,8-[r4c4]-2-
[r5c6]-5-[r9c6],
which implies r9c6<>5 => r9c6=7 and that solve the puzzle.
Let’s see another example of an Almost Turbot Fish, this time in a considerably harder puzzle:
- Code: Select all
. . 3 | 4 . . | 6 . .
. 5 . | . . 9 | . . .
. . . | 2 . . | . . 5
-------+-------+-------
2 6 . | . 7 . | 1 3 .
. . . | 8 . . | . 6 7
9 . . | 3 . . | . . .
-------+-------+-------
5 . . | . . . | . . 8
. . 4 | . 2 . | . . .
. 1 . | . . 3 | 7 . .
(this is the puzzle posted by Gsf in the thread “Simple example of a POM
vulnerable pairs operation”) and let’s jump to here:
- Code: Select all
178 2789 3 | 4 158 1578 | 6 12789 129
14678 5 1267 | 167 1368 9 | 2348 12478 1234
14678 4789 1679 | 2 1368 1678 | 3489 14789 5
-----------------+----------------+-----------------
2 6 8 | 59 7 45 | 1 3 49
134 34 15 | 8 149 124 | 2459 6 7
9 47 157 | 3 146 1246 | 2458 2458 24
-----------------+----------------+-----------------
5 2379 2679 | 167 1469 1467 | 2349 1249 8
3678 3789 4 | 167 2 15678 | 359 159 1369
68 1 29 | 59 4589 3 | 7 2459 2469
Here we have an Almost Turbot Fish in cells {r1c8|r1c2|r7c2|r9c3|r9c8|r9c9}: if r9c9 is not “2” then a Turbot Fish emerges that eliminates a “2” from r1c8. This can be used in a loop to demonstrate that r1c2 must be “2”:
[r9c4]=9=[r4c4]-9-[r4c9]-4-[r6c9](-2-[r1c9])-2-[r9c9]-{Turbot Fish:
[r1c8]-2-[r1c2]=2=[r7c2]-2-[r9c3]=2=[r9c8]-2-[r1c8]}-2-[r1c8]=2=
[r1c2]=2=[r7c2]-2-[r9c3]-9-[r9c4], => r1c2=2.
I have not begun the notation from the node where the discontinuity arises in order for the reader appreciates better the Almost Turbot Fish in action.
Let’s see now a different example of an Almost Nice Loop. The initial grid:
- Code: Select all
. 2 . | . 4 8 | . . 3
4 6 8 | 3 . 1 | . 7 .
3 . . | 7 . . | . . .
-------+-------+-------
. 8 4 | 1 . . | 6 . .
2 1 6 | 8 . . | . . 9
. . . | . . . | . . .
-------+-------+-------
8 3 . | 6 . . | 5 9 .
. 7 . | . . . | . . .
6 . 9 | 2 8 . | 7 . .
and after the basic steps we get:
- Code: Select all
159 2 7 | 59 4 8 | 19 6 3
4 6 8 | 3 259 1 | 29 7 25
3 59 15 | 7 2569 269 | 12489 12458 2458
---------------+----------------+---------------------
579 8 4 | 1 2359 239 | 6 25 257
2 1 6 | 8 57 47 | 3 45 9
579 59 3 | 459 2569 269 | 1248 12458 24578
---------------+----------------+---------------------
8 3 12 | 6 17 47 | 5 9 24
15 7 125 | 49 139 39 | 248 248 6
6 4 9 | 2 8 5 | 7 3 1
In this case we have an Almost Nice Loop in the set of cells {r6c4|r6c2|r3c2|r1c1|r1c4}: please note that, if r6c4 is not “4” then we can write [r6c4]=9=[r6c2]=5=[r3c2]=9=[r1c1]=5=[r1c4]=9=[r6c4], => r6c4=9. We can use this information to prove that r5c5<>7:
[r5c5]-7-[r5c6](-4-[r6c2|r6c4]-5,9-[r6c5|r6c6])-4-[r6c4]={Nice Loop:
[r6c4]=9=[r6c2]=5=[r3c2]=9= [r1c1]=5=[r1c4]=9=[r6c4]}=9=[r6c4](-9-
[r6c2]-5-[r3c2])-9-[r1c4]-5-[r3c5]={Almost Unique Rectangle:
r6c5|r6c6|r3c5|r3c6}=5|9=[r3c5|r3c6]-9-[r3c2],
which means that, if r5c5=7 then r3c2 would be an empty cell. Hence, r5c5<>7 and that solves the puzzle.
Some Almost Unique Rectangles and Almost Almost Unique Rectangles allow some interesting aplications of Almost Nice Loops. Consider the following grid:
- Code: Select all
. 4 7 | . . 8 | 5 . 3
. 1 . | . . . | . . .
2 8 . | 3 . . | 9 . .
-------+-------+-------
. . 6 | 4 8 9 | . . .
. 9 . | . . . | 4 5 8
. . . | . . . | 6 . .
-------+-------+-------
. . . | . 2 4 | 7 . 5
. . . | 5 9 6 | . 3 .
. . . | 1 . . | . . .
After the basic steps and using Uniqueness to eliminate “2” from r8c9 we get:
- Code: Select all
69 4 7 | 269 16 8 | 5 126 3
369 1 39 | 2679 4567 257 | 28 24678 267
2 8 5 | 3 1467 17 | 9 1467 167
-----------------+---------------------+--------------------
157 257 6 | 4 8 9 | 3 127 127
137 9 123 | 267 1367 1237 | 4 5 8
48 237 48 | 27 1357 12357 | 6 1279 1279
-----------------+---------------------+--------------------
139 36 139 | 8 2 4 | 7 69 5
78 27 28 | 5 9 6 | 1 3 4
459 56 49 | 1 37 37 | 28 2689 269
In this grid we have an Almost Nice Loop in the set C of cells {r9c5|r9c6|r5c5|r5c6|r1c5|r3c6} that takes advantage of the Almost Almost Unique Rectangle present in cells {r9c5|r9c6|r5c5|r5c6}. Please note the following: if r5c5/r5c6 are not “1”, then an AUR sets up and we have now in C the nice loop [r5c6]=2|6=[r5c5]-6-[r1c5]-1-[r3c6](-7-
[r5c6])-7-[r9c6]-3-[r5c6], => r5c6<>3,7 => r5c6=2. Now, we can use this Almost Nice Loop in the following multiple implication chain:
[r7c2](=3=[r6c2]-3-[r5c1|r5c3])(-6-[r7c8]-9-[r7c3|r9c9])-6-[r9c2]-5-
[r4c2|r5c1|r5c3]-1-[r5c5|r5c6]={Nice Loop: [r5c6]=2|6=[r5c5]-6-[r1c5]-
-1-[r3c6](-7-[r5c6])-7-[r9c6]-3-[r5c6]}=2=[r5c6](-2-[r5c4|r6c4]-6,7-
[r2c4])-2-[r5c3](-1-[r5c1]-7-[r4c2]-2-[r4c9])-1-[r7c3]-3-[r2c3]-9-[r2c4](-
-2-[r2c9])-2-[r2c7]-8-[r9c7]-2-[r9c9](-6-[r3c9])-6-[r2c9](-7-
-[r3c9])-7-[r4c9]-1-[r3c9].
This chain means that, if r7c2=6 then r3c9 would be an empty cell. So we must have r7c2<>6 and that solves the puzzle.
Until now, we have seen examples where, for a nice loop to emerge in a set C of cells, a candidate “x” must be first “removed” from a cell (or two) of C. Now, let’s see an example where for a nice loop to emerge we have to “remove” first two different candidates “x” and “y” from two cells of a set C. Consider the following good looking grid
- Code: Select all
. . . | . . . | . . .
6 . 2 | . . . | 8 . 1
3 . . | 7 . 4 | . . 6
-------+-------+-------
. . 7 | 6 . 1 | 2 . .
. . . | 3 5 2 | . . .
. . 6 | 4 . 7 | 9 . .
-------+-------+-------
9 . . | 2 . 3 | . . 4
7 . 1 | . . . | 3 . 5
. . . | . . . | . . .
which after the basic steps becomes
- Code: Select all
15 1579 459 | 18 126 68 | 47 3 29
6 47 2 | 59 3 59 | 8 47 1
3 189 89 | 7 12 4 | 5 29 6
----------------+------------------+------------------
45 3 7 | 6 9 1 | 2 45 8
18 189 489 | 3 5 2 | 146 16 7
125 125 6 | 4 8 7 | 9 15 3
----------------+------------------+------------------
9 568 58 | 2 167 3 | 167 1678 4
7 2468 1 | 89 46 689 | 3 2689 5
248 2468 3 | 1589 1467 5689 | 167 126789 29
Here we have an AUR in cells {r3c2|r3c3|r5c2|r5c3} and, if the reader looks carefully, we also have an Almost Nice Loop in the set C of cells {r5c1|r5c2|r5c3|r9c1|r4c1|r3c2|r3c3}: if r3c2 is not “1” and r9c1 is not “2” then we could write [r5c3]=4|1=[r5c2]-1-[r5c1]-8-[r9c1]-4-[r4c1]
=4=[r5c3], => r5c3=4. But the two conditions {r3c2 not “1” and r9c1 not “2”} are precisely met with r3c5=1, and we have the following SIN:
[r3c5]{=2=[r3c8]-2-[r1c9]=2=[r9c9](-2-[r9c1])-2-[r8c8]}(-1-
[r1c4]-8-[r1c6]-6-[r8c4|r8c6]-8,9-[r8c8])-1-[r3c2]={Nice Loop:
[r5c3]=4|1=[r5c2]-1-[r5c1]-8-[r9c1]-4-[r4c1]=4=[r5c3]}=4=[r5c3](-4-
[r4c1]=4=[r4c8]-4-[r2c8]-7-[r7c8])=9=[r5c2]-9-[r3c2]-8-[r3c3]=8=
[r7c3]-8-[r5c8|r7c8]-6-[r8c8]
which means that, if r3c5=1 then r8c8 would be an empty cell. So, r3c5<>1 and it solves the puzzle.
Let’s now see another example of an Almost Turbot Fish and an example of an Almost Grouped Nice Loop. Consider the following puzzle:
- Code: Select all
6 . . | . 3 5 | . . .
. 8 9 | . . . | . . .
. 5 2 | 1 . . | . 8 .
-------+-------+-------
. . . | . . . | 7 . 3
. . . | 9 . . | 4 . .
4 1 . | . . . | . . 6
-------+-------+-------
. 9 8 | 3 . . | . . .
. . . | . 7 . | 9 . .
. . 3 | . 5 . | 1 . .
which can be advanced with basic steps to here:
- Code: Select all
6 47 14 | 8 3 5 | 2 17 9
137 8 9 | 2467 46 2467 | 356 14567 1457
37 5 2 | 1 9 467 | 36 8 47
---------------+-----------------+------------------
9 2 56 | 456 8 146 | 7 15 3
8 3 567 | 9 16 167 | 4 125 125
4 1 57 | 57 2 3 | 8 9 6
---------------+-----------------+------------------
257 9 8 | 3 146 1246 | 56 24567 2457
125 46 14 | 246 7 8 | 9 3 245
27 467 3 | 246 5 9 | 1 2467 8
Let’s start by noting that we have an Almost Turbot Fish in the set C of cells {r7c7|r3c7|r3c6|r2c5|r5c5|r7c5}. If r5c5 is not “6” then the following loop emerges in C: [r7c7]-6-[r3c7]=6=[r3c6]-6-[r2c5]=6=[r7c5]-6-
-[r7c7], => r7c7<>6 => r7c7=5. We could then use this observation in the following way:
-6-[r5c5](r5c5=1)-{Nice Loop: [r7c7]-6-[r3c7]=6=[r3c6]-6-[r2c5]=6=
[r7c5]-6-[r7c7]}-6-[r7c7]-5-[r7c1]=5=[r8c1]=1=[r8c3]-1-[r1c3]=1=
[r1c8]-1-[r4c8]=1=[r4c6]-1-[r5c5],
which means that r5c5=1 implies r4c6=1: a contradiction, and so r5c5<>1.
Let’s now look at the same puzzle, particularly to candidates “4” in column 6: it can be seen that, if “4” weren’t in r7c6 then we would be able to write the following grouped nice loop: [r4c6]=4=[r2c6|r3c6]-4-[r2c5]-6-
-[r5c5]-1-[r4c6], => r4c6<>1. Thus, we have an Almost Grouped Nice Loop in the set of cells {r7c6|r4c6|r3c6|r2c6|r2c5|r5c5}, which can be used in the following single implication network:
-4-[r7c6]-{Nice Loop: [r4c6]=4=[r2c6|r3c6]-4-[r2c5]-6-[r5c5]-1-[r4c6]}-
-1-[r4c6]=1=[r4c8]-1-[r1c8](-7-[r9c8])=1=[r1c3]=4=[r8c3]=1=
[r8c1]=5=[r7c1](=2=[r9c1]-2-[r9c8])-5-[r7c7](-6-[r9c8])-6-
[r3c7]=6=[r3c6]-6-[r2c5]-4-[r7c5]=4=[X-Wing between boxes 7/8]-4-
[r9c8]
which means that if r7c6 is not “4” then r9c8 would be an empty cell. So r7c6 must be “4” and it solves the puzzle.
Let’s now see an example of a longer ANL:
- Code: Select all
5 1 278 | 2678 678 3 | 9 678 4
279 4 278 | 2678 6789 5 | 268 3 1
6 279 3 | 1 4 2789 | 5 78 278
----------------+------------------+------------------
8 3 1 | 2567 67 267 | 4 569 69
24 25 9 | 3 1 46 | 7 568 68
47 57 6 | 58 89 489 | 1 2 3
----------------+------------------+------------------
3 679 4 | 678 2 1 | 68 6789 5
1 8 27 | 9 5 67 | 3 4 267
279 2679 5 | 4 3 678 | 268 1 26789
In this grid, let’s start by noting that in row 7 candidate “7” is present in the three cells r7c2/r7c4/r7c8: now, if “7” is not in r7c4 then we would have a strong link between r7c2 and r7c8 and we would be able to write [r5c9]=8=[r5c8]=5=[r4c8]-5-[r4c4]=5=[r6c4]-5-[r6c2]-7-[r7c2]=7=
[r7c8]=9=[r9c9]-9-[r4c9]-6-[r5c8|r5c9], => r5c8/r5c9<>6. This observation can be used in the following deduction (note the Almost Locked Set in cells r7c4/r7c7):
-7-[r7c4|r7c8]-6-[r7c2]=6=[r9c2]-{Nice Loop: [r5c9]=8=[r5c8]=5=
[r4c8]-5-[r4c4]=5=[r6c4]-5-[r6c2]-7-[r7c2]=7=[r7c8]=9=[r9c9]-9-
[r4c9]-6-[r5c8|r5c9]}-6-[r5c8|r5c9]-5-[r5c2]=5=[r6c2]-5-[r6c4]-8-
[r6c5]-9-[r2c5]=9=[r2c1]-9-[r9c1]=9=[r9c9]-9-[r4c9]-6-[r8c9]=6=[r8c6]-
6-[r5c6]-4-[r5c1]-2-[r5c2],
which means that, if r7c4 is not “7” then the nice that stes up implies that r5c2 would be an empty cell. So, r7c4 must be “7” and it solve the puzzle.
Let’s look at a final example. Consider the following puzzle:
- Code: Select all
. . . | . 7 . | 9 4 .
. . . | . 9 . | . . 5
3 . . | . . 5 | . 7 .
-------+-------+-------
. . 7 | 4 . . | 1 . .
4 6 3 | . . . | . . .
. . . | . . 7 | . 8 .
-------+-------+-------
8 . . | . . . | . . .
7 . . | . . . | . 2 8
. 5 . | 2 6 . | . . .
which was considered until recently as the toughest known puzzle. After some steps we arrive at the following grid:
- Code: Select all
1256 12 1258 | 1368 7 1236 | 9 4 1236
126 7 1248 | 1368 9 12346 | 2368 136 5
3 1249 12489 | 168 124 5 | 268 7 126
--------------------+-------------------+--------------------
259 8 7 | 4 235 2369 | 1 3569 2369
4 6 3 | 159 8 129 | 257 59 279
1259 129 1259 | 3569 235 7 | 23456 8 23469
--------------------+-------------------+--------------------
8 12349 12469 | 7 1345 1349 | 456 1569 1469
7 1349 146 | 1359 145 1349 | 456 2 8
19 5 149 | 2 6 8 | 347 139 13479
In this grid we have two ANLs that sets up with the same condition: r7c5 not “4”. First, we have an Almost Turbot Fish in the set of cells {r8c5|r7c5|r3c5|r2c6|r2c3|r8c3}: if r7c5 is not “4” then a new strong link emerges that allow us to write [r8c3]-4-[r8c5]=4=[r3c5]-4-[r2c6]=4=
[r2c3]-4-[r8c3], => r8c3<>4. Second, we have another ANL (an Almost Grouped X-Cycle) in the set of cells {r8c5|r7c5|r3c5|r2c6|r2c3|r9c3|r9c7|r9c9|r8c7}: again, if r7c5 is not “4” then we can write [r8c7]-4-[r8c5]=4=[r3c5]-4-[r2c6]=4=[r2c3]-4-[r9c3]
=4=[r9c7|r9c9]-4-[r8c7], => r8c7<>4. These two pieces of information can be put together in the following deduction:
[r7c5](-3-[r7c6])(-3-[r7c2]=3=[r8c2])-3-[r46c5](-2,5-[r5c46]){-5-
[r56c4]=5=[r8c4](-5-[r8c7])=9=[r8c6](-9-[r7c6])-9-[r5c6]-1-
[r7c6]}-{Nice Loop: [r8c3]-4-[r8c5]=4=[r3c5]-4-[r2c6]=4=[r2c3]-4-
[r8c3]}-4-[r8c3]-{Nice Loop: [r8c7]-4-[r8c5]=4=[r3c5]-4-[r2c6]=4=
[r2c3]-4-[r9c3]=4=[r9c79]-4-[r8c7]}-4-[r8c7]-6-[r8c3]-1-[r8c5]-4-
[r7c6],
which means that, if r7c5=3 then r7c6 would be an empty cell. So, r7c5<>3. This deduction might look completely useless, but in my solution of this puzzle it turns out to play an important role (in conjunction with the previous deduction r8c5<>3).
Part 2. The Two Incompatible Nice Loops Rule (TIL).
The techniques used to solve Sudoku puzzles are based in avoiding some contradiction situation: two candidates “x” in the same unit, no candidate “x” in a given unit, more than one solution for the puzzle, empty cell. However, there are also other contradictions situations that, although more complex and so harder to find, can be exploited in the solving process. One of such situations can be expressed by the following rule:
The Two Incompatible Nice Loops Rule (TIL). If we have a situation in which, considering a given candidate “x” and a certain cell “A”, we can construct a nice loop that proves that “A” cannot be “x” but, at the same time, we can also construct another nice loop that proves that “A” must be “x”, then these two nice loops are in conflict with each other and we have a contradiction situation: so, the hypothesis that originated this conflicting situation must be false.
The better known example of this rule is the Turbot Fish with five strong sides on ”x”: we can write two nice loops for any cell of it, one that forces “x” to be in that cell and another that eliminate “x” from the same cell, which is a contradiction (I call this contradiction – a Turbot Fish with five strong sides – a Deadly Turbot Fish). However, we can have more complex situations where this same rule applies, and it is in these situations where the ANLs can help. Consider the following puzzle:
- Code: Select all
*-----------------------*
| . . . | 2 . 3 | 9 . . |
| . 5 . | 4 . 7 | . 8 . |
| . . . | . 6 . | 4 . . |
|-------+-------+-------|
| 1 8 . | . . . | . . 6 |
| 4 . . | . 1 . | . . 8 |
| 3 . . | . . . | . 1 2 |
|-------+-------+-------|
| . . 8 | . 3 . | . . . |
| . 4 . | 6 . 9 | . 3 . |
| . . 3 | 5 . 2 | . . . |
*-----------------------*
which after some basic steps becomes:
- Code: Select all
*-------------------------------------------------*
| 8 167 4 | 2 5 3 | 9 67 17 |
| 26 5 126 | 4 9 7 | 126 8 3 |
| 279 3 279 | 18 6 18 | 4 25 57 |
|-------------------+--------------+--------------|
| 1 8 79 | 379 2 5 | 37 4 6 |
| 4 27 257 | 37 1 6 | 357 9 8 |
| 3 679 5679 | 789 47 48 | 57 1 2 |
|-------------------+--------------+--------------|
| 25679 2679 8 | 17 3 14 | 26 25 49 |
| 257 4 127 | 6 78 9 | 128 3 157 |
| 679 1679 3 | 5 478 2 | 168 67 49 |
*-------------------------------------------------*
From here, this grid can be easily solved with colors, locked candidates, and colors again (considering a type-1 Unique Rectangle as a trivial last step). However, I have decided to study this puzzle in order to find a just one step solution. So, I have noted the presence of an ANL in the set of cells {r1c2|r2c1|r2c3|r2c7|r9c1|r9c2|r9c7|r9c8}: if the three cells r2c7/r9c7/r9c8 are not “6” then we could write [r9c2]=6=[r9c1]-6-[r2c1]
=6=[r2c3]=1=[r1c2]-1-[r9c2], => r9c2<>1. But, at the same time, we could also write another nice loop that proves that r9c2 must be “1”. Also, the condition {r2c7/r9c7/r9c8 not “6”} is precisely met if we consider r7c7=6. So, we could write in chain notation:
[r7c7](-6-[r2c7])-6-[r9c7|r9c8]-{TILA: [r9c2]=6=[r9c1]-6-[r2c1]=6=
[r2c3]=1=[r1c2]-1-[r9c2], => r9c2<>1; [r9c2]=1=[r9c7]-1-[r8c9]=1=
[r1c9]-1-[r1c2]=1=[r9c2], => r9c2=1}.
and we have two loops at the same time, one that proves that r9c2 cannot be “1” and another that proves that r9c2 must be “1”. Here, the hypothesis that originated the conflicting situation is r7c7=6. So, we must have r7c7<>6 and after that we get
- Code: Select all
*------------------------------------------------*
| 8 6 4 | 2 5 3 | 9 7 1 |
| 2 5 1 | 4 9 7 | 6 8 3 |
| 79 3 79 | 18 6 18 | 4 2 5 |
|----------------+----------------+--------------|
| 1 8 79 | 379 2 5 | 37 4 6 |
| 4 2 5 | 37 1 6 | 37 9 8 |
| 3 79 6 | 789 47 48 | 5 1 2 |
|----------------+----------------+--------------|
| 6 79 8 | 17 3 14 | 2 5 49 |
| 5 4 2 | 6 8 9 | 1 3 7 |
| 79 1 3 | 5 47 2 | 8 6 49 |
*------------------------------------------------*
From here the puzzle is solved with the Type-1 Unique Rectangle. Alternatively, this grid can also be solved from here with an Almost Two Incompatible Loops Argument. The reader is invited to identify it as an exercise.
Part 3. How to identify Almost Nice Loops?
If nice loops are already hard to find, almost nice loops are naturally even harder to identify. However, there are some good starting points. For example, if we have an almost almost unique rectangle (or even an AUR) then there is a very good chance that we are able to construct an ANL with it. A simplified bilocation/bivalue plot is also a natural good start, where an important “pattern” plays a decisive role: units that contain a candidate “x” distributed by exactly three cells (or even four), which in turn can be distributed by two or three units. Obviously, by considering that one of those cells is not “x” we thus have a new strong link that, in conjunction with the already existing b/b plot, can be used in an ANL.
Carcul
