Ajò Dimonios wrote:7r8c6=r4c6-r4c4=r2c4-(7=8)r1c5-(8=6)r1c8-6r1c2=r2c1-r5c1=(6-4*5) r5c9=(5-48)r6c9=48r4c789-(48=7)r4c4=>-7r4c6=>stte
I like the logic and have no problem understanding your chain, but it could be improved. (In general, I would suggest adding white space to make your chains more readable. Marking the chains in the grid would be nice too, to make them easier to follow.)
1. You could cut a few nodes from the start and the end. While this is not my main point, I start with it so we can deal with a bit shorter chain:
- Code: Select all
7r4c4 = r2c4 - (7=8)r1c5 - (8=6)r1c8 - 6r1c2 = r2c1 - r5c1 = (6-4*5)r5c9 = (5-48)r6c9 = 48r4c789 => -48r4c4; stte
2. Related to the discussion about eleven's chain and the correct use of '|', your chain would also need it in a couple of places to make it Boolean-correct:
- Code: Select all
7r4c4 = r2c4 - (7=8)r1c5 - (8=6)r1c8 - 6r1c2 = r2c1 - r5c1 = (6-4*|5)r5c9 = (5-4|8)r6c9 = 48r4c789 => -48r4c4
(The original needs it in one more place at the end: 48r4c789 - (4|8=7)r4c4 => -7r4c6)
3. It's good that you marked the stored memory, but it should be marked also where it's used. In this case it enables the last strong link, so it's connected to the last node:
- Code: Select all
7r4c4 = r2c4 - (7=8)r1c5 - (8=6)r1c8 - 6r1c2 = r2c1 - r5c1 = (6-4*|5)r5c9 = (5-4|8)r6c9 = *48r4c789 => -48r4c4
Otherwise the last strong link looks invalid. That practice also makes it possible to read the chain backwards, as long as it's Boolean-correct (see 2). The most readable style is to mark stored memories to the right of the stored item (like you did) and recalled memories to the left of the affected item (like I did), so the same symbols are facing each other. If more than one memory is used, they should have different symbols.
4. In general, "negative memories" should be avoided, because they make strong links harder to verify and backwards reading more awkward. Your chain stores the "elimination" of 4r5c9 (when read from the left) which later enables the strong link to 48r4c789. It works, but it's generally preferable to store "placements" and then use their weak links remotely. In this particular case the latter style is actually a bit uglier, so I don't mind the negative memory so much. Here's the other option, storing the "placement" of 6r5c9:
- Code: Select all
7r4c4 = r2c4 - (7=8)r1c5 - (8=6)r1c8 - 6r1c2 = r2c1 - r5c1 = (6*-5)r5c9 = 5r6c9 - (4|8)r6*5c9 = 48r4c789 => -48 r4c4
(This latter style corresponds with the t-candidates in Denis' chains. He claims to have invented memory chains. Perhaps it's actually better to use negative memories to avoid the risk of having to pay royalties. Just kidding.)
5. There's no need to use a memory chain at all. The simpler and the more elegant option is to use the hidden pair (56)r56c9 to do the job:
- Code: Select all
.------------------.-------------------.----------------------.
| 5 e26 3 | 1 c78 9 | 4 d68 2678 |
| f26 1 478 | b478 3478 5 | 278 9 23678 |
| 478 79 4789 | 2 3478 6 | 5 18 1378 |
:------------------+-------------------+----------------------:
| 9 3 5 | a7-48 14678 127 | i128 i1468 i12468 |
| g1246 8 14 | 45 9 3 | 12 7 h12456 |
| 12467 26 147 | 458 1468 12 | 9 3 h124568 |
:------------------+-------------------+----------------------:
| 17 59 2 | 3 17 8 | 6 45 49 |
| 3 4 1789 | 6 5 17 | 178 2 1789 |
| 178 57 6 | 9 2 4 | 3 158 178 |
'------------------'-------------------'----------------------'
- Code: Select all
7r4c4 = r2c4 - (7=8)r1c5 - (8=6)r1c8 - r1c2 = r2c1 - r5c1 = (65-4|8)r56c9 = 48r4c789 => -48r4c4
It could also be written (6,5-4|8)r56c9 if you want to make the preceding strong link easier to understand. The link is valid either way.
I really like the ending of that chain. My improvements only make it shine more brightly, if I may say so, but the logic is yours. Nice job.