home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Source Code 1993 July / THE_SOURCE_CODE_CD_ROM.iso / bsd_srcs / games / arithmetic / arithmetic.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-04-08  |  10.9 KB  |  376 lines
  1. /*
  2.  * Copyright (c) 1989 The Regents of the University of California.
  3.  * All rights reserved.
  4.  *
  5.  * This code is derived from software contributed to Berkeley by
  6.  * Eamonn McManus of Trinity College Dublin.
  7.  *
  8.  * Redistribution and use in source and binary forms, with or without
  9.  * modification, are permitted provided that the following conditions
  10.  * are met:
  11.  * 1. Redistributions of source code must retain the above copyright
  12.  *    notice, this list of conditions and the following disclaimer.
  13.  * 2. Redistributions in binary form must reproduce the above copyright
  14.  *    notice, this list of conditions and the following disclaimer in the
  15.  *    documentation and/or other materials provided with the distribution.
  16.  * 3. All advertising materials mentioning features or use of this software
  17.  *    must display the following acknowledgement:
  18.  *    This product includes software developed by the University of
  19.  *    California, Berkeley and its contributors.
  20.  * 4. Neither the name of the University nor the names of its contributors
  21.  *    may be used to endorse or promote products derived from this software
  22.  *    without specific prior written permission.
  23.  *
  24.  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  25.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  26.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  27.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  28.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  29.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  30.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  31.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  32.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  33.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  34.  * SUCH DAMAGE.
  35.  */
  36.  
  37. #ifndef lint
  38. char copyright[] =
  39. "@(#) Copyright (c) 1989 The Regents of the University of California.\n\
  40.  All rights reserved.\n";
  41. #endif /* not lint */
  42.  
  43. #ifndef lint
  44. static char sccsid[] = "@(#)arithmetic.c    5.5 (Berkeley) 2/27/91";
  45. #endif /* not lint */
  46.  
  47. /*
  48.  * By Eamonn McManus, Trinity College Dublin <emcmanus@cs.tcd.ie>.
  49.  *
  50.  * The operation of this program mimics that of the standard Unix game
  51.  * `arithmetic'.  I've made it as close as I could manage without examining
  52.  * the source code.  The principal differences are:
  53.  *
  54.  * The method of biasing towards numbers that had wrong answers in the past
  55.  * is different; original `arithmetic' seems to retain the bias forever,
  56.  * whereas this program lets the bias gradually decay as it is used.
  57.  *
  58.  * Original `arithmetic' delays for some period (3 seconds?) after printing
  59.  * the score.  I saw no reason for this delay, so I scrapped it.
  60.  *
  61.  * There is no longer a limitation on the maximum range that can be supplied
  62.  * to the program.  The original program required it to be less than 100.
  63.  * Anomalous results may occur with this program if ranges big enough to
  64.  * allow overflow are given.
  65.  *
  66.  * I have obviously not attempted to duplicate bugs in the original.  It
  67.  * would go into an infinite loop if invoked as `arithmetic / 0'.  It also
  68.  * did not recognise an EOF in its input, and would continue trying to read
  69.  * after it.  It did not check that the input was a valid number, treating any
  70.  * garbage as 0.  Finally, it did not flush stdout after printing its prompt,
  71.  * so in the unlikely event that stdout was not a terminal, it would not work
  72.  * properly.
  73.  */
  74.  
  75. #include <sys/types.h>
  76. #include <sys/signal.h>
  77. #include <ctype.h>
  78. #include <stdio.h>
  79. #include <string.h>
  80.  
  81. char keylist[] = "+-x/";
  82. char defaultkeys[] = "+-";
  83. char *keys = defaultkeys;
  84. int nkeys = sizeof(defaultkeys) - 1;
  85. int rangemax = 10;
  86. int nright, nwrong;
  87. time_t qtime;
  88. #define    NQUESTS    20
  89.  
  90. /*
  91.  * Select keys from +-x/ to be asked addition, subtraction, multiplication,
  92.  * and division problems.  More than one key may be given.  The default is
  93.  * +-.  Specify a range to confine the operands to 0 - range.  Default upper
  94.  * bound is 10.  After every NQUESTS questions, statistics on the performance
  95.  * so far are printed.
  96.  */
  97. void
  98. main(argc, argv)
  99.     int argc;
  100.     char **argv;
  101. {
  102.     extern char *optarg;
  103.     extern int optind;
  104.     int ch, cnt;
  105.     time_t time();
  106.     void intr();
  107.  
  108.     while ((ch = getopt(argc, argv, "r:o:")) != EOF)
  109.         switch(ch) {
  110.         case 'o': {
  111.             register char *p;
  112.  
  113.             for (p = keys = optarg; *p; ++p)
  114.                 if (!index(keylist, *p)) {
  115.                     (void)fprintf(stderr,
  116.                         "arithmetic: unknown key.\n");
  117.                     exit(1);
  118.                 }
  119.             nkeys = p - optarg;
  120.             break;
  121.         }
  122.         case 'r':
  123.             if ((rangemax = atoi(optarg)) <= 0) {
  124.                 (void)fprintf(stderr,
  125.                     "arithmetic: invalid range.\n");
  126.                 exit(1);
  127.             }
  128.             break;
  129.         case '?':
  130.         default:
  131.             usage();
  132.         }
  133.     if (argc -= optind)
  134.         usage();
  135.  
  136.     /* Seed the random-number generator. */
  137.     srandom((int)time((time_t *)NULL));
  138.  
  139.     (void)signal(SIGINT, intr);
  140.  
  141.     /* Now ask the questions. */
  142.     for (;;) {
  143.         for (cnt = NQUESTS; cnt--;)
  144.             if (problem() == EOF)
  145.                 exit(0);
  146.         showstats();
  147.     }
  148.     /* NOTREACHED */
  149. }
  150.  
  151. /* Handle interrupt character.  Print score and exit. */
  152. void
  153. intr()
  154. {
  155.     showstats();
  156.     exit(0);
  157. }
  158.  
  159. /* Print score.  Original `arithmetic' had a delay after printing it. */
  160. showstats()
  161. {
  162.     if (nright + nwrong > 0) {
  163.         (void)printf("\n\nRights %d; Wrongs %d; Score %d%%",
  164.             nright, nwrong, (int)(100L * nright / (nright + nwrong)));
  165.         if (nright > 0)
  166.     (void)printf("\nTotal time %ld seconds; %.1f seconds per problem\n\n",
  167.                 (long)qtime, (float)qtime / nright);
  168.     }
  169.     (void)printf("\n");
  170. }
  171.  
  172. /*
  173.  * Pick a problem and ask it.  Keeps asking the same problem until supplied
  174.  * with the correct answer, or until EOF or interrupt is typed.  Problems are
  175.  * selected such that the right operand and either the left operand (for +, x)
  176.  * or the correct result (for -, /) are in the range 0 to rangemax.  Each wrong
  177.  * answer causes the numbers in the problem to be penalised, so that they are
  178.  * more likely to appear in subsequent problems.
  179.  */
  180. problem()
  181. {
  182.     register char *p;
  183.     time_t start, finish;
  184.     int left, op, right, result;
  185.     char line[80];
  186.  
  187.     op = keys[random() % nkeys];
  188.     if (op != '/')
  189.         right = getrandom(rangemax + 1, op, 1);
  190. retry:
  191.     /* Get the operands. */
  192.     switch (op) {
  193.     case '+':
  194.         left = getrandom(rangemax + 1, op, 0);
  195.         result = left + right;
  196.         break;
  197.     case '-':
  198.         result = getrandom(rangemax + 1, op, 0);
  199.         left = right + result;
  200.         break;
  201.     case 'x':
  202.         left = getrandom(rangemax + 1, op, 0);
  203.         result = left * right;
  204.         break;
  205.     case '/':
  206.         right = getrandom(rangemax, op, 1) + 1;
  207.         result = getrandom(rangemax + 1, op, 0);
  208.         left = right * result + random() % right;
  209.         break;
  210.     }
  211.  
  212.     /*
  213.      * A very big maxrange could cause negative values to pop
  214.      * up, owing to overflow.
  215.      */
  216.     if (result < 0 || left < 0)
  217.         goto retry;
  218.  
  219.     (void)printf("%d %c %d =   ", left, op, right);
  220.     (void)fflush(stdout);
  221.     (void)time(&start);
  222.  
  223.     /*
  224.      * Keep looping until the correct answer is given, or until EOF or
  225.      * interrupt is typed.
  226.      */
  227.     for (;;) {
  228.         if (!fgets(line, sizeof(line), stdin)) {
  229.             (void)printf("\n");
  230.             return(EOF);
  231.         }
  232.         for (p = line; *p && isspace(*p); ++p);
  233.         if (!isdigit(*p)) {
  234.             (void)printf("Please type a number.\n");
  235.             continue;
  236.         }
  237.         if (atoi(p) == result) {
  238.             (void)printf("Right!\n");
  239.             ++nright;
  240.             break;
  241.         }
  242.         /* Wrong answer; penalise and ask again. */
  243.         (void)printf("What?\n");
  244.         ++nwrong;
  245.         penalise(right, op, 1);
  246.         if (op == 'x' || op == '+')
  247.             penalise(left, op, 0);
  248.         else
  249.             penalise(result, op, 0);
  250.     }
  251.  
  252.     /*
  253.      * Accumulate the time taken.  Obviously rounding errors happen here;
  254.      * however they should cancel out, because some of the time you are
  255.      * charged for a partially elapsed second at the start, and some of
  256.      * the time you are not charged for a partially elapsed second at the
  257.      * end.
  258.      */
  259.     (void)time(&finish);
  260.     qtime += finish - start;
  261.     return(0);
  262. }
  263.  
  264. /*
  265.  * Here is the code for accumulating penalties against the numbers for which
  266.  * a wrong answer was given.  The right operand and either the left operand
  267.  * (for +, x) or the result (for -, /) are stored in a list for the particular
  268.  * operation, and each becomes more likely to appear again in that operation.
  269.  * Initially, each number is charged a penalty of WRONGPENALTY, giving it that
  270.  * many extra chances of appearing.  Each time it is selected because of this,
  271.  * its penalty is decreased by one; it is removed when it reaches 0.
  272.  *
  273.  * The penalty[] array gives the sum of all penalties in the list for
  274.  * each operation and each operand.  The penlist[] array has the lists of
  275.  * penalties themselves.
  276.  */
  277.  
  278. int penalty[sizeof(keylist) - 1][2];
  279. struct penalty {
  280.     int value, penalty;    /* Penalised value and its penalty. */
  281.     struct penalty *next;
  282. } *penlist[sizeof(keylist) - 1][2];
  283.  
  284. #define    WRONGPENALTY    5    /* Perhaps this should depend on maxrange. */
  285.  
  286. /*
  287.  * Add a penalty for the number `value' to the list for operation `op',
  288.  * operand number `operand' (0 or 1).  If we run out of memory, we just
  289.  * forget about the penalty (how likely is this, anyway?).
  290.  */
  291. penalise(value, op, operand)
  292.     int value, op, operand;
  293. {
  294.     struct penalty *p;
  295.     char *malloc();
  296.  
  297.     op = opnum(op);
  298.     if ((p = (struct penalty *)malloc((u_int)sizeof(*p))) == NULL)
  299.         return;
  300.     p->next = penlist[op][operand];
  301.     penlist[op][operand] = p;
  302.     penalty[op][operand] += p->penalty = WRONGPENALTY;
  303.     p->value = value;
  304. }
  305.  
  306. /*
  307.  * Select a random value from 0 to maxval - 1 for operand `operand' (0 or 1)
  308.  * of operation `op'.  The random number we generate is either used directly
  309.  * as a value, or represents a position in the penalty list.  If the latter,
  310.  * we find the corresponding value and return that, decreasing its penalty.
  311.  */
  312. getrandom(maxval, op, operand)
  313.     int maxval, op, operand;
  314. {
  315.     int value;
  316.     register struct penalty **pp, *p;
  317.  
  318.     op = opnum(op);
  319.     value = random() % (maxval + penalty[op][operand]);
  320.  
  321.     /*
  322.      * 0 to maxval - 1 is a number to be used directly; bigger values
  323.      * are positions to be located in the penalty list.
  324.      */
  325.     if (value < maxval)
  326.         return(value);
  327.     value -= maxval;
  328.  
  329.     /*
  330.      * Find the penalty at position `value'; decrement its penalty and
  331.      * delete it if it reaches 0; return the corresponding value.
  332.      */
  333.     for (pp = &penlist[op][operand]; (p = *pp) != NULL; pp = &p->next) {
  334.         if (p->penalty > value) {
  335.             value = p->value;
  336.             penalty[op][operand]--;
  337.             if (--(p->penalty) <= 0) {
  338.                 p = p->next;
  339.                 (void)free((char *)*pp);
  340.                 *pp = p;
  341.             }
  342.             return(value);
  343.         }
  344.         value -= p->penalty;
  345.     }
  346.     /*
  347.      * We can only get here if the value from the penalty[] array doesn't
  348.      * correspond to the actual sum of penalties in the list.  Provide an
  349.      * obscure message.
  350.      */
  351.     (void)fprintf(stderr, "arithmetic: bug: inconsistent penalties\n");
  352.     exit(1);
  353.     /* NOTREACHED */
  354. }
  355.  
  356. /* Return an index for the character op, which is one of [+-x/]. */
  357. opnum(op)
  358.     int op;
  359. {
  360.     char *p;
  361.  
  362.     if (op == 0 || (p = index(keylist, op)) == NULL) {
  363.         (void)fprintf(stderr,
  364.             "arithmetic: bug: op %c not in keylist %s\n", op, keylist);
  365.         exit(1);
  366.     }
  367.     return(p - keylist);
  368. }
  369.  
  370. /* Print usage message and quit. */
  371. usage()
  372. {
  373.     (void)fprintf(stderr, "usage: arithmetic [-o +-x/] [-r range]\n");
  374.     exit(1);
  375. }
  376.