return "Both dimensions must be at least 2";
if (params->c > ORDER_MAX || params->r > ORDER_MAX)
return "Dimensions greater than "STR(ORDER_MAX)" are not supported";
+ if ((params->c * params->r) > 36)
+ return "Unable to support more than 36 distinct symbols in a puzzle";
return NULL;
}
sfree(scratch);
}
-static int solver(int c, int r, digit *grid, random_state *rs, int maxdiff)
+static int solver(int c, int r, digit *grid, int maxdiff)
{
struct solver_usage *usage;
struct solver_scratch *scratch;
* possible.
*/
if (maxdiff >= DIFF_RECURSIVE) {
- int best, bestcount, bestnumber;
+ int best, bestcount;
best = -1;
bestcount = cr+1;
- bestnumber = 0;
for (y = 0; y < cr; y++)
for (x = 0; x < cr; x++)
if (count < bestcount) {
bestcount = count;
- bestnumber = 0;
- }
-
- if (count == bestcount) {
- bestnumber++;
- if (bestnumber == 1 ||
- (rs && random_upto(rs, bestnumber) == 0))
- best = y*cr+x;
+ best = y*cr+x;
}
}
}
#endif
- /* Now shuffle the list. */
- if (rs) {
- for (i = j; i > 1; i--) {
- int p = random_upto(rs, i);
- if (p != i-1) {
- int t = list[p];
- list[p] = list[i-1];
- list[i-1] = t;
- }
- }
- }
-
/*
* And step along the list, recursing back into the
* main solver at every stage.
solver_recurse_depth++;
#endif
- ret = solver(c, r, outgrid, rs, maxdiff);
+ ret = solver(c, r, outgrid, maxdiff);
#ifdef STANDALONE_SOLVER
solver_recurse_depth--;
digits[j++] = n+1;
}
- if (usage->rs) {
- /* shuffle */
- for (i = j; i > 1; i--) {
- int p = random_upto(usage->rs, i);
- if (p != i-1) {
- int t = digits[p];
- digits[p] = digits[i-1];
- digits[i-1] = t;
- }
- }
- }
+ if (usage->rs)
+ shuffle(digits, j, sizeof(*digits), usage->rs);
/* And finally, go through the digit list and actually recurse. */
ret = FALSE;
int nlocs;
char *desc;
int coords[16], ncoords;
- int *symmclasses, nsymmclasses;
- int maxdiff, recursing;
+ int maxdiff;
+ int x, y, i, j;
/*
* Adjust the maximum difficulty level to be consistent with
grid2 = snewn(area, digit);
/*
- * Find the set of equivalence classes of squares permitted
- * by the selected symmetry. We do this by enumerating all
- * the grid squares which have no symmetric companion
- * sorting lower than themselves.
- */
- nsymmclasses = 0;
- symmclasses = snewn(cr * cr, int);
- {
- int x, y;
-
- for (y = 0; y < cr; y++)
- for (x = 0; x < cr; x++) {
- int i = y*cr+x;
- int j;
-
- ncoords = symmetries(params, x, y, coords, params->symm);
- for (j = 0; j < ncoords; j++)
- if (coords[2*j+1]*cr+coords[2*j] < i)
- break;
- if (j == ncoords)
- symmclasses[nsymmclasses++] = i;
- }
- }
-
- /*
* Loop until we get a grid of the required difficulty. This is
* nasty, but it seems to be unpleasantly hard to generate
* difficult grids otherwise.
* Now we have a solved grid, start removing things from it
* while preserving solubility.
*/
- recursing = FALSE;
- while (1) {
- int x, y, i, j;
- /*
- * Iterate over the grid and enumerate all the filled
- * squares we could empty.
- */
- nlocs = 0;
+ /*
+ * Find the set of equivalence classes of squares permitted
+ * by the selected symmetry. We do this by enumerating all
+ * the grid squares which have no symmetric companion
+ * sorting lower than themselves.
+ */
+ nlocs = 0;
+ for (y = 0; y < cr; y++)
+ for (x = 0; x < cr; x++) {
+ int i = y*cr+x;
+ int j;
- for (i = 0; i < nsymmclasses; i++) {
- x = symmclasses[i] % cr;
- y = symmclasses[i] / cr;
- if (grid[y*cr+x]) {
+ ncoords = symmetries(params, x, y, coords, params->symm);
+ for (j = 0; j < ncoords; j++)
+ if (coords[2*j+1]*cr+coords[2*j] < i)
+ break;
+ if (j == ncoords) {
locs[nlocs].x = x;
locs[nlocs].y = y;
nlocs++;
}
}
- /*
- * Now shuffle that list.
- */
- for (i = nlocs; i > 1; i--) {
- int p = random_upto(rs, i);
- if (p != i-1) {
- struct xy t = locs[p];
- locs[p] = locs[i-1];
- locs[i-1] = t;
- }
- }
-
- /*
- * Now loop over the shuffled list and, for each element,
- * see whether removing that element (and its reflections)
- * from the grid will still leave the grid soluble by
- * solver.
- */
- for (i = 0; i < nlocs; i++) {
- int ret;
+ /*
+ * Now shuffle that list.
+ */
+ shuffle(locs, nlocs, sizeof(*locs), rs);
- x = locs[i].x;
- y = locs[i].y;
+ /*
+ * Now loop over the shuffled list and, for each element,
+ * see whether removing that element (and its reflections)
+ * from the grid will still leave the grid soluble.
+ */
+ for (i = 0; i < nlocs; i++) {
+ int ret;
- memcpy(grid2, grid, area);
- ncoords = symmetries(params, x, y, coords, params->symm);
- for (j = 0; j < ncoords; j++)
- grid2[coords[2*j+1]*cr+coords[2*j]] = 0;
+ x = locs[i].x;
+ y = locs[i].y;
- ret = solver(c, r, grid2, NULL, maxdiff);
- if (ret != DIFF_IMPOSSIBLE && ret != DIFF_AMBIGUOUS) {
- for (j = 0; j < ncoords; j++)
- grid[coords[2*j+1]*cr+coords[2*j]] = 0;
- break;
- }
- }
+ memcpy(grid2, grid, area);
+ ncoords = symmetries(params, x, y, coords, params->symm);
+ for (j = 0; j < ncoords; j++)
+ grid2[coords[2*j+1]*cr+coords[2*j]] = 0;
- if (i == nlocs) {
- /*
- * There was nothing we could remove without
- * destroying solvability. Give up.
- */
- break;
+ ret = solver(c, r, grid2, maxdiff);
+ if (ret != DIFF_IMPOSSIBLE && ret != DIFF_AMBIGUOUS) {
+ for (j = 0; j < ncoords; j++)
+ grid[coords[2*j+1]*cr+coords[2*j]] = 0;
}
}
memcpy(grid2, grid, area);
- } while (solver(c, r, grid2, NULL, maxdiff) < maxdiff);
+ } while (solver(c, r, grid2, maxdiff) < maxdiff);
sfree(grid2);
sfree(locs);
- sfree(symmclasses);
-
/*
* Now we have the grid as it will be presented to the user.
* Encode it in a game desc.
grid = snewn(cr*cr, digit);
memcpy(grid, state->grid, cr*cr);
- solve_ret = solver(c, r, grid, NULL, DIFF_RECURSIVE);
+ solve_ret = solver(c, r, grid, DIFF_RECURSIVE);
*error = NULL;
return FALSE;
}
-static int game_timing_state(game_state *state)
+static int game_timing_state(game_state *state, game_ui *ui)
{
return TRUE;
}
{ assert(!"Shouldn't get randomness"); return 0; }
unsigned long random_upto(random_state *state, unsigned long limit)
{ assert(!"Shouldn't get randomness"); return 0; }
+void shuffle(void *array, int nelts, int eltsize, random_state *rs)
+{ assert(!"Shouldn't get randomness"); }
void fatal(char *fmt, ...)
{
}
s = new_game(NULL, p, desc);
- ret = solver(p->c, p->r, s->grid, NULL, DIFF_RECURSIVE);
+ ret = solver(p->c, p->r, s->grid, DIFF_RECURSIVE);
if (grade) {
printf("Difficulty rating: %s\n",
ret==DIFF_BLOCK ? "Trivial (blockwise positional elimination only)":