The New Sudoku Players' Forum

[ArkieTech]

Code: Select all

 *-----------*
 |...|..1|.4.|
 |..7|6..|.25|
 |...|2..|..6|
 |---+---+---|
 |.3.|.6.|4.8|
 |..5|8.2|7..|
 |7.8|.1.|.6.|
 |---+---+---|
 |1..|..3|...|
 |37.|..9|2..|
 |.9.|1..|...|
 *-----------*


Play/Print this puzzle online

[Leren]

Code: Select all

*----------------------------------*
| 6 2 39 | 57  357  1 | 8  4   79  |
| 4 1 7  | 6   9    8 | 3  2   5   |
| 5 8 39 | 2  b37   4 | 1 c79  6   |
|--------+------------+------------|
| 2 3 1  | 9   6    7 | 4  5   8   |
| 9 6 5  | 8   4    2 | 7  13  13  |
| 7 4 8  | 3   1    5 | 9  6   2   |
|--------+------------+------------|
| 1 5 24 | 47 e8-27 3 | 6 d789 479 |
| 3 7 6  | 45  58   9 | 2  18  14  |
| 8 9 24 | 1  a27   6 | 5  37  347 |
*----------------------------------*

(2=7) r9c5 - (7) r3c5 = (7-9) r3c8 = (9-8) r7c8 = (8) r7c5 => - 27 r7c5; stte

Leren

[Cenoman]

Code: Select all

 +-----------------+------------------+-------------------+
 |  6    2    39   |  57  a35+7  1    |  8    4     79    |
 |  4    1    7    |  6    9     8    |  3    2     5     |
 |  5    8    39   |  2    37    4    |  1    79    6     |
 +-----------------+------------------+-------------------+
 |  2    3    1    |  9    6     7    |  4    5     8     |
 |  9    6    5    |  8    4     2    |  7    13    13    |
 |  7    4    8    |  3    1     5    |  9    6     2     |
 +-----------------+------------------+-------------------+
 |  1    5    24   |  47   28+7  3    |  6    89+7  79(+4)|
 |  3    7    6    |  45   58    9    |  2    18    14    |
 |  8    9    24   |  1    27    6    |  5    37   a34+7  |
 +-----------------+------------------+-------------------+

BUG+5
(7)r1c5,r9c9 == (7)r7c58 - r7c4 = (7)r1c4
=> -7 r1c9; ste

(Note 7r9c9 -> 9r1c9 -> 4r7c9 and 4r7c9 -> 9r1c9 -> 7r9c9)

[Ngisa]

Code: Select all

+----------------+-------------------+--------------------+
| 6     2     39 |a57      357     1 | 8     4       a79  |
| 4     1     7  | 6       9       8 | 3     2        5   |
| 5     8     39 | 2       37      4 | 1     7-9      6   |
+----------------+-------------------+--------------------+
| 2     3     1  | 9       6       7 | 4     5        8   |
| 9     6     5  | 8       4       2 | 7     13       13  |
| 7     4     8  | 3       1       5 | 9     6        2   |
+----------------+-------------------+--------------------+
| 1     5    e24 |c47     d278     3 | 6    g789     f479 |
| 3     7     6  |b45     c58      9 | 2     18       14  |
| 8     9     24 | 1       27      6 | 5     37       347 |
+----------------+-------------------+--------------------+


(9=75)r1c49 - (5=4)r8c4 - (4)r7c4&(5-8)r8c5 = (8-2)r7c5 = (2-4)r7c3 = (4-9)r7c9 = (9)r7c8 => - 9r3c8; stte

Clement

[SteveG48]

Code: Select all

 *--------------------------------------------------*
 | 6    2    39   |a57   357  1    | 8    4    9-7  |
 | 4    1    7    | 6    9    8    | 3    2    5    |
 | 5    8    39   | 2    3-7  4    | 1   d79   6    |
 *----------------+----------------+----------------|
 | 2    3    1    | 9    6    7    | 4    5    8    |
 | 9    6    5    | 8    4    2    | 7    13   13   |
 | 7    4    8    | 3    1    5    | 9    6    2    |
 *----------------+----------------+----------------|
 | 1    5    24   |b47   278  3    | 6   c789  479  |
 | 3    7    6    |b45   58   9    | 2   c18  c14   |
 | 8    9    24   | 1    27   6    | 5    37   347  |
 *--------------------------------------------------*


7r1c4 = (47)r78c4 - (4|7=189)b9p256 - (9=7)r3c8 => -7 r1c9,r3c5 ; stte

[SpAce]

BUG+5
(7)r1c5,r9c9 == (7)r7c58 - r7c4 = (7)r1c4 => -7 r1c9; ste

(Note 7r9c9 -> 9r1c9 -> 4r7c9 and 4r7c9 -> 9r1c9 -> 7r9c9)

Well, that's not boring! However, if that style is used, then why not go all the way:

(7)r1c5 == (7)r7c58 - r7c4 = (7)r1c4 => -7 r1c9; stte ?

...or for example:

(4==7)r7c985 - r7c4 = (79)r1c59 => -9 r7c9; stte ?

It can be easily demonstrated that all three true guardians (7r1c5, 7r9c9, and 4r7c9) are equivalent, so you get the simplest AIC if you use only one of them. Or, we could write even a one-linker with a slightly different approach:

(4)r7c9 == (79)r1c45,r9c9 => -9 r7c9; stte (because 7r7c58 -> 7r1c4)

Of course any of those is feigned simplicity, because they just externalize important parts making the full logic harder to understand (than that of a stand-alone AIC accounting for all guardians). But, it's different and valid logic, so I'm not complaining! (I would have settled for a boring option of adding '|(94)r17c9' to your first node.)

(I'm already regretting that I broke my promise and looked )

[Cenoman]

(2=7) r9c5 - (7) r3c5 = (7-9) r3c8 = (9-8) r7c8 = (8) r7c5 => - 27 r7c5; stte

7r1c4 = (47)r78c4 - (4|7=189)b9p256 - (9=7)r3c8 => -7 r1c9,r3c5 ; stte

Both tricky and nice !

Two days ago, here

I do prefer an AIC [vs a kraken] if I can come up with one, just because it's more fun for me that way. In this particular case, I think the AIC is so simple that it's just not an issue.

I didn't react on July 3, but of course, I agree. I start doubting whether a krakenless solution is preferable, when the kraken is replaced with just an additional level of brackets (which is not your practise).

why not ...
(7)r1c5 == (7)r7c58 - r7c4 = (7)r1c4 => -7 r1c9; stte ?

Honestly, I didn't see the equivalence 7r1c5 ≈ 7r9c9 (not so easy to demonstrate, though), as I was not searching the simplest AIC, but just a single AIC. The logic encompasses a redundant term, but not false. So what ?

[SpAce]

I start doubting whether a krakenless solution is preferable, when the kraken is replaced with just an additional level of brackets (which is not your practise).

If you mean replacing a kraken with a nested (almost) AIC, I fully agree with that line in the sand. That practice doesn't usually make the solution a bit more interesting unless it's a named almost-pattern. It does, however, reduce clarity a lot because it just turns a kraken into a less readable shape.

why not ...
(7)r1c5 == (7)r7c58 - r7c4 = (7)r1c4 => -7 r1c9; stte ?

Honestly, I didn't see the equivalence 7r1c5 ≈ 7r9c9 (not so easy to demonstrate, though), as I was not searching the simplest AIC, but just a single AIC. The logic encompasses a redundant term, but not false. So what ?

Ok. I presumed you saw that it could be written as a single AIC pretty easily with all guardians accounted for, so I thought you just considered that option ugly (with a bloated node) and preferred a simpler AIC with some externalized logic. Either way, I'm not saying it's wrong, but my implicit question was: where do we draw the line in the sand there?

As I tried to demonstrate (see the added "one-linker"), externalized logic can be abused pretty easily. I didn't imply you abused it, and maybe not everyone thinks it's abuse at all. I don't try to be a judge. Personally I prefer pretty self-contained pieces of logic, if possible, but I don't want it to be a requirement of any kind (because it might leave out truly elegant solutions that I'd never imagine myself).

Bottom line: I think your idea was quite valid and I'm glad you demonstrated it. In this particular case it just seemed a bit of an overkill because (imho) simpler options existed.

[SpAce]

(9=75)r1c49 - (5=4)r8c4 - (4)r7c4&(5-8)r8c5 = (8-2)r7c5 = (2-4)r7c3 = (4-9)r7c9 = (9)r7c8 => - 9r3c8; stte

Hi Clement. I hope you don't mind if I use your solution as a case study related to the recent AIC vs Kraken discussion. It happens to be a perfect example where a kraken (or a matrix) would be a much simpler and more readable choice than an AIC. In fact, writing a correct AIC is not trivial (though doable) here, and it would look very different from the above. A kraken is the natural choice here, because the three 4s in row 7 form the heart of the logic. That's very easy to write:

Code: Select all

Kraken Row (4R7):


(4-2)r7c3 = (2-8)r7c5 = (8-5)r8c5 = r8c4 - (5=7)r1c4 - (7=9)r1c9
||
(4)r7c4 - (4=5)r8c4 - (5=7)r1c4 - (7=9)r1c9
||
(4-9)r7c9 = (9)r7c8


=> -9 r3c8,r7c9; stte


8x8 TM: Show

Code: Select all

   9r1c9    7r1c9
            7r1c4 5r1c4
                  5r8c4 5r8c5
                        8r8c5 8r7c5
                              2r7c5 2r7c3
                  5r8c4                   4r8c4
                                    4r7c3 4r7c4 4r7c9
   9r7c8                                        9r7c9
-----------------------------------------------------
-9r3c8,r7c9

That's without any modifications to the logic, except for the missed elimination 9r7c9 added, but it's already much easier to understand. If we look at it more closely, we can notice that the last branch could also end with (9)r1c9 proving +9r1c9, which implies that it could be simplified with a different elimination. Two easy options for that: -9 r7c9 or -7 r1c9.

Either:

Code: Select all

(4-2)r7c3 = (2-8)r7c5 = (8-5)r8c5 = r8c4 - (5=7)r1c4 - (7=9)r1c9
||
(4)r7c4 - (4=5)r8c4 - (5=7)r1c4 - (7=9)r1c9
||
(4)r7c9

=> -9 r7c9; stte


Or:

Code: Select all

(4-2)r7c3 = (2-8)r7c5 = (8-5)r8c5 = r8c4 - (5=7)r1c4
||
(4)r7c4 - (4=5)r8c4 - (5=7)r1c4
||
(4-9)r7c9 = (9)r1c9

=> -7 r1c9; stte


The latter seems more balanced, so it'd be my choice. None of them are exactly straight-forward to turn into AICs (except nested AICs, of course, but those don't count). The closest to the original pseudo-AIC I can come up with is:

(9=75)r1c94 - r8c4 = (58)r87c5 - (2|5)b8p24 = (24)r7c3,r8c4 - (4)r7c34 = (49)r7c98 => -9 r3c8,r7c9; stte

I'd probably twist it into something like:

(7)r1c4 = (7,24)r7c4,r9c53 - (4)r7c43 = (49)r71c9 => -7 r1c9; stte

For most people I'd recommend sticking to the kraken option. It's much easier to get correct and readable.