shithub: puzzles

--- a/unfinished/numgame.c

+++ b/unfinished/numgame.c

@@ -131,6 +131,7 @@

 #define OPFLAG_KEEPS_CONCAT 2

 #define OPFLAG_UNARY        4

 #define OPFLAG_UNARYPREFIX  8

+#define OPFLAG_FN           16

 struct operation {

/*

@@ -511,6 +512,43 @@

     return res;

+static int perform_perc(int *a, int *b, int *output)

+{

+    if (a[0] == 0) return FALSE; /* 0% = 0, uninteresting. */

+    if (a[1] > (INT_MAX/100)) return FALSE;

+    OUT(output, a[0], a[1]*100);

+    return TRUE;

+}

+static int perform_gamma(int *a, int *b, int *output)

+{

+    int asub1[2];

+    /*

+     * gamma(a) = (a-1)!

+     *

+     * special case not caught by perform_fact: gamma(1) is 1 so

+     * don't bother.

+     */

+    if (a[0] == 1 && a[1] == 1) return FALSE;

+    OUT(asub1, a[0]-a[1], a[1]);

+    return perform_factorial(asub1, b, output);

+}

+static int perform_sqrt(int *a, int *b, int *output)

+{

+    int half[2] = { 1, 2 };

+    /*

+     * sqrt(1) == 1: don't perform unary noops.

+     */

+    if (a[0] == 1 && a[1] == 1) return FALSE;

+    return perform_exp(a, half, output);

+}

 const static struct operation op_add = {

     TRUE, "+", "+", 0, 10, 0, TRUE, perform_add

};

@@ -545,6 +583,15 @@

 const static struct operation op_root = {

     TRUE, "v~", "root", 0, 30, 1, FALSE, perform_root

};

+const static struct operation op_perc = {

+    TRUE, "%", "%", OPFLAG_UNARY | OPFLAG_NEEDS_CONCAT, 45, 1, FALSE, perform_perc

+};

+const static struct operation op_gamma = {

+    TRUE, "gamma", "gamma", OPFLAG_UNARY | OPFLAG_UNARYPREFIX | OPFLAG_FN, 1, 3, FALSE, perform_gamma

+};

+const static struct operation op_sqrt = {

+    TRUE, "v~", "sqrt", OPFLAG_UNARY | OPFLAG_UNARYPREFIX, 30, 1, FALSE, perform_sqrt

+};

/*

  * In Countdown, divisions resulting in fractions are disallowed.

@@ -586,7 +633,7 @@

*/

 const static struct operation *const ops_anythinggoes[] = {

     &op_add, &op_mul, &op_sub, &op_div, &op_concat, &op_exp, &op_factorial,

-    &op_decimal, &op_recur, &op_root, NULL

+    &op_decimal, &op_recur, &op_root, &op_perc, &op_gamma, &op_sqrt, NULL

};

 const static struct rules rules_anythinggoes = {

     ops_anythinggoes, TRUE

@@ -860,7 +907,7 @@

 	    for (i = 0; i < ss->nnumbers; i++) {

 		int jlimit = (ops[k]->flags & OPFLAG_UNARY ? 1 : ss->nnumbers);

 		for (j = 0; j < jlimit; j++) {

-		    int n[2];

+		    int n[2], newnn = ss->nnumbers;

 		    int pa, po, pb, pr;

 		    if (!(ops[k]->flags & OPFLAG_UNARY)) {

@@ -868,11 +915,12 @@

 			    continue;  /* can't combine a number with itself */

 			if (i > j && ops[k]->commutes)

 			    continue;  /* no need to do this both ways round */

+                        newnn--;

 		    if (!ops[k]->perform(ss->numbers+2*i, ss->numbers+2*j, n))

 			continue;      /* operation failed */

-		    sn = newset(s, ss->nnumbers-1, ss->flags);

+		    sn = newset(s, newnn, ss->flags);

 		    if (!(ops[k]->flags & OPFLAG_KEEPS_CONCAT))

 			sn->flags &= ~SETFLAG_CONCAT;

@@ -990,8 +1038,14 @@

 	    for (op = s->ops[a->po]->text; *op; op++)

 		putchar(*op);

+        if (s->ops[a->po]->flags & OPFLAG_FN)

+            putchar('(');

 	print_recurse(s, a->prev, pathindex, a->pa, thispri, thisassoc, 1);

+        if (s->ops[a->po]->flags & OPFLAG_FN)

+            putchar(')');

 	if (!(s->ops[a->po]->flags & OPFLAG_UNARYPREFIX))

 	    for (op = s->ops[a->po]->text; *op; op++)

 		putchar(*op);

@@ -1050,6 +1104,7 @@

     int pathcounts = FALSE;

     int multiple = FALSE;

     int debug_bfs = FALSE;

+    int got_range = FALSE, rangemin = 0, rangemax = 0;

     struct output *o;

     struct sets *s;

@@ -1073,7 +1128,7 @@

 		    fprintf(stderr, "%s: option '--%s' not recognised\n",

 			    pname, p);

-	    } else while (*p) switch (c = *p++) {

+	    } else while (p && *p) switch (c = *p++) {

 	      case 'C':

 		rules = &rules_countdown;

 		break;

@@ -1096,6 +1151,7 @@

 		multiple = TRUE;

 		break;

 	      case 't':

+              case 'r':

 		    char *v;

 		    if (*p) {

@@ -1113,6 +1169,19 @@

 			got_target = TRUE;

 			target = atoi(v);

 			break;

+                      case 'r':

+                        {

+                             char *sep = strchr(v, '-');

+                             got_range = TRUE;

+                             if (sep) {

+                                 rangemin = atoi(v);

+                                 rangemax = atoi(sep+1);

+                             } else {

+                                 rangemin = 0;

+                                 rangemax = atoi(v);

+                             }

+                        }

+                        break;

 		break;

@@ -1142,6 +1211,17 @@

 	return 1;

+    if (got_range) {

+        if (got_target) {

+            fprintf(stderr, "%s: only one of -t and -r may be specified\n", pname);

+            return 1;

+        }

+        if (rangemin >= rangemax) {

+            fprintf(stderr, "%s: range not sensible (%d - %d)\n", pname, rangemin, rangemax);

+            return 1;

+        }

+    }

     s = do_search(nnumbers, numbers, rules, (got_target ? &target : NULL),

 		  debug_bfs, multiple);

@@ -1160,6 +1240,15 @@

 	else if (limit == -1)

 	    limit = start;

 	limit++;

+    } else if (got_range) {

+        if (!findrelpos234(s->outputtree, &rangemin, outputfindcmp,

+                           REL234_GE, &start) ||

+            !findrelpos234(s->outputtree, &rangemax, outputfindcmp,

+                           REL234_LE, &limit)) {

+            printf("No solutions available in specified range %d-%d\n", rangemin, rangemax);

+            return 1;

+        }

+        limit++;

     } else {

 	start = 0;

 	limit = count234(s->outputtree);

@@ -1197,3 +1286,5 @@

     return 0;

+/* vim: set shiftwidth=4 tabstop=8: */