Return to arithmetic.c CVS log

Up to [Research Unix] / researchv10no / games

Annotation of researchv10no/games/arithmetic.c, revision 1.1.1.1

1.1       root        1: #include <signal.h>
                      2: 
                      3: #define        MAX     100
                      4: 
                      5: char   types[10];
                      6: int    right[MAX];
                      7: int    left[MAX];
                      8: int    rights;
                      9: int    wrongs;
                     10: long   stvec;
                     11: long   etvec;
                     12: long   dtvec;
                     13: 
                     14: main(argc,argv)
                     15: char   *argv[];
                     16: {
                     17:        int range, k, dif, l;
                     18:        char line[100];
                     19:        int ans,pans,i,j,t;
                     20:        extern  delete();
                     21: 
                     22:        signal(SIGINT, delete);
                     23: 
                     24:        range = 11;
                     25:        dif = 0;
                     26:        while(argc > 1) {
                     27:                switch(*argv[1]) {
                     28:                case '+':
                     29:                case '-':
                     30:                case 'x':
                     31:                case '/':
                     32:                        while(types[dif] = argv[1][dif])
                     33:                                dif++;
                     34:                        break;
                     35: 
                     36:                default:
                     37:                        range = getnum(argv[1]) + 1;
                     38:                }
                     39:                argv++;
                     40:                argc--;
                     41:        }
                     42:        if(range > MAX) {
                     43:                printf("Range is too large.\n");
                     44:                exit(0);
                     45:        }
                     46: 
                     47:        if(dif == 0) {
                     48:                types[0] = '+';
                     49:                types[1] = '-';
                     50:                dif = 2;
                     51:        }
                     52: 
                     53:        for(i = 0; i < range; i++) {
                     54:                left[i] = right[i] = i;
                     55:        }
                     56:        time(&stvec);
                     57:        k = stvec;
                     58:        srand(k);
                     59:        k = 0;
                     60:        l = 0;
                     61:        goto start;
                     62: 
                     63: loop:
                     64:        if(++k%20 == 0)
                     65:                score();
                     66: 
                     67: start:
                     68:        i = skrand(range);
                     69:        j = skrand(range);
                     70:        if(dif > 1)
                     71:                l = random(dif);
                     72: 
                     73:        switch(types[l]) {
                     74:                case '+':
                     75:                default:
                     76:                        ans = left[i] + right[j];
                     77:                        printf("%d + %d =   ", left[i], right[j]);
                     78:                        break;
                     79: 
                     80:                case '-':
                     81:                        t = left[i] + right[j];
                     82:                        ans = left[i];
                     83:                        printf("%d - %d =   ", t, right[j]);
                     84:                        break;
                     85: 
                     86:                case 'x':
                     87:                        ans = left[i] * right[j];
                     88:                        printf("%d x %d =   ", left[i], right[j]);
                     89:                        break;
                     90: 
                     91:                case '/':
                     92:                        while(right[j] == 0)
                     93:                                j = random(range);
                     94:                        t = left[i] * right[j] + random(right[j]);
                     95:                        ans = left[i];
                     96:                        printf("%d / %d =   ", t, right[j]);
                     97:                        break;
                     98:        }
                     99: 
                    100: 
                    101: loop1:
                    102:        getline(line);
                    103:        dtvec += etvec - stvec;
                    104:        if(line[0]=='\n') goto loop1;
                    105:        pans = getnum(line);
                    106:        if(pans == ans) {
                    107:                printf("Right!\n");
                    108:                rights++;
                    109:                goto loop;
                    110:        }
                    111:        else {
                    112:                printf("What?\n");
                    113:                wrongs++;
                    114:                if(range >= MAX)        goto loop1;
                    115:                left[range] = left[i];
                    116:                right[range++] = right[j];
                    117:                goto loop1;
                    118:        }
                    119: }
                    120: 
                    121: getline(s)
                    122: char *s;
                    123: {
                    124:        register char   *rs;
                    125: 
                    126:        rs = s;
                    127: 
                    128:        while((*rs = getchar()) == ' ');
                    129:        while(*rs != '\n')
                    130:                if(*rs == 0)
                    131:                        exit(0);
                    132:                else if(rs >= &s[99]) {
                    133:                        while((*rs = getchar()) != '\n')
                    134:                                if(*rs == '\0') exit(0);
                    135:                }
                    136:                else
                    137:                        *++rs = getchar();
                    138:        while(*--rs == ' ')
                    139:                *rs = '\n';
                    140: }
                    141: 
                    142: getnum(s)
                    143: char *s;
                    144: {
                    145:        int     a;
                    146:        char    c;
                    147: 
                    148:        a = 0;
                    149:        while((c = *s++) >= '0' && c <= '9') {
                    150:                a = a*10 + c - '0';
                    151:        }
                    152:        return(a);
                    153: }
                    154: 
                    155: 
                    156: random(range)
                    157: {
                    158:        return(rand()%range);
                    159: }
                    160: 
                    161: skrand(range){
                    162: int temp;
                    163:        temp = random(range) + random(range);
                    164:        if(temp > range - 1) temp = 2*range - 1 - temp;
                    165:        return(temp);
                    166:        }
                    167: 
                    168: score()
                    169: {
                    170:        time(&etvec);
                    171: 
                    172:        printf("\n\nRights %d; Wrongs %d; Score %d%%\n", rights, wrongs,
                    173:                (rights * 100)/(rights + wrongs));
                    174: 
                    175:        if(rights == 0) return;
                    176:        printf("Total time %ld seconds; %.1f seconds per problem\n\n\n",
                    177:                etvec - stvec,
                    178:                (etvec - stvec) / (rights + 0.));
                    179: 
                    180:        sleep(3);
                    181:        time(&dtvec);
                    182:        stvec += dtvec - etvec;
                    183: }
                    184: 
                    185: delete()
                    186: {
                    187:        if(rights + wrongs == 0.) {
                    188:                printf("\n");
                    189:                exit(0);
                    190:        }
                    191:        score();
                    192:        exit(0);
                    193: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.