X-Git-Url: https://git.distorted.org.uk/~mdw/sgt/puzzles/blobdiff_plain/7c568a48f46bd88d9f298a1c29ac0f64a88266c0..f17b8728edad5051e1e9a858814ee114176f0b14:/solo.c

diff --git a/solo.c b/solo.c
index d991536..f6d28ec 100644
--- a/solo.c
+++ b/solo.c
@@ -3,20 +3,12 @@
  *
  * TODO:
  *
- *  - can we do anything about nasty centring of text in GTK? It
- *    seems to be taking ascenders/descenders into account when
- *    centring. Ick.
- *
  *  - it might still be nice to do some prioritisation on the
  *    removal of numbers from the grid
  *     + one possibility is to try to minimise the maximum number
  * 	 of filled squares in any block, which in particular ought
  * 	 to enforce never leaving a completely filled block in the
  * 	 puzzle as presented.
- *     + be careful of being too clever here, though, until after
- * 	 I've tried implementing difficulty levels. It's not
- * 	 impossible that those might impose much more important
- * 	 constraints on this process.
  *
  *  - alternative interface modes
  *     + sudoku.com's Windows program has a palette of possible
@@ -1124,7 +1116,7 @@ static int nsolve(int c, int r, digit *grid)
 #ifdef STANDALONE_SOLVER
                                           , "intersectional analysis,"
                                           " row %d vs block (%d,%d)",
-                                          1+YUNTRANS(y), 1+x, 1+y%r
+                                          1+YUNTRANS(y), 1+x/r, 1+y%r
 #endif
                                           ) ||
                          nsolve_intersect(usage, cubepos(x,y%r,n), r*cr,
@@ -1132,7 +1124,7 @@ static int nsolve(int c, int r, digit *grid)
 #ifdef STANDALONE_SOLVER
                                           , "intersectional analysis,"
                                           " block (%d,%d) vs row %d",
-                                          1+x, 1+y%r, 1+YUNTRANS(y)
+                                          1+x/r, 1+y%r, 1+YUNTRANS(y)
 #endif
                                           ))) {
                         diff = max(diff, DIFF_INTERSECT);
@@ -2031,14 +2023,14 @@ int main(int argc, char **argv)
                 else
                     ret = DIFF_AMBIGUOUS;
             }
-            printf("difficulty rating: %s\n",
-                   ret==DIFF_BLOCK ? "blockwise positional elimination only":
-                   ret==DIFF_SIMPLE ? "row/column/number elimination required":
-                   ret==DIFF_INTERSECT ? "intersectional analysis required":
-                   ret==DIFF_SET ? "set elimination required":
-                   ret==DIFF_RECURSIVE ? "guesswork and backtracking required":
-                   ret==DIFF_AMBIGUOUS ? "multiple solutions exist":
-                   ret==DIFF_IMPOSSIBLE ? "no solution exists":
+            printf("Difficulty rating: %s\n",
+                   ret==DIFF_BLOCK ? "Trivial (blockwise positional elimination only)":
+                   ret==DIFF_SIMPLE ? "Basic (row/column/number elimination required)":
+                   ret==DIFF_INTERSECT ? "Intermediate (intersectional analysis required)":
+                   ret==DIFF_SET ? "Advanced (set elimination required)":
+                   ret==DIFF_RECURSIVE ? "Unreasonable (guesswork and backtracking required)":
+                   ret==DIFF_AMBIGUOUS ? "Ambiguous (multiple solutions exist)":
+                   ret==DIFF_IMPOSSIBLE ? "Impossible (no solution exists)":
                    "INTERNAL ERROR: unrecognised difficulty code");
         }
     }
@@ -2054,18 +2046,18 @@ int main(int argc, char **argv)
                 c = 'a' + c-10;
             printf("%c", c);
             if (x+1 < p->c * p->r) {
-                if ((x+1) % p->c)
+                if ((x+1) % p->r)
                     printf(" ");
                 else
                     printf(" | ");
             }
         }
         printf("\n");
-        if (y+1 < p->c * p->r && (y+1) % p->r == 0) {
+        if (y+1 < p->c * p->r && (y+1) % p->c == 0) {
             for (x = 0; x < p->c * p->r; x++) {
                 printf("-");
                 if (x+1 < p->c * p->r) {
-                    if ((x+1) % p->c)
+                    if ((x+1) % p->r)
                         printf("-");
                     else
                         printf("-+-");