Return to arithmetic.c CVS log

Up to [Research Unix] / researchv10no / games

Annotation of researchv10no/games/arithmetic.c, revision 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.