int main() { int mincount; double myl,length; while(1) { mincount=1; myl=0.0; scanf("%lf",&length); if(notzero(length))/*²»µÈÓÚ0*/ { while(myl < length) { myl+=(double)(1 / (double)(++mincount)); } printf("%d card(s)\n",--mincount); } else { break; } } return 0; }
void op(int what) { mnumber a, b, c, *spval; int tp = type[what]; if (errflag) return; if (sp < 0) { zerr("bad math expression: stack empty"); return; } if (tp & (OP_A2|OP_A2IR|OP_A2IO|OP_E2|OP_E2IO)) { /* Make sure anyone seeing this message reports it. */ DPUTS(sp < 1, "BUG: math: not enough wallabies in outback."); b = pop(0); a = pop(what == EQ); if (errflag) return; if (tp & (OP_A2IO|OP_E2IO)) { /* coerce to integers */ if (a.type & MN_FLOAT) { a.type = MN_INTEGER; a.u.l = (zlong)a.u.d; } if (b.type & MN_FLOAT) { b.type = MN_INTEGER; b.u.l = (zlong)b.u.d; } } else if (a.type != b.type && what != COMMA && (a.type != MN_UNSET || what != EQ)) { /* * Different types, so coerce to float. * It may happen during an assignment that the LHS * variable is actually an integer, but there's still * no harm in doing the arithmetic in floating point; * the assignment will do the correct conversion. * This way, if the parameter is actually a scalar, but * used to contain an integer, we can write a float into it. */ if (a.type & MN_INTEGER) { a.type = MN_FLOAT; a.u.d = (double)a.u.l; } if (b.type & MN_INTEGER) { b.type = MN_FLOAT; b.u.d = (double)b.u.l; } } if (noeval) { c.type = MN_INTEGER; c.u.l = 0; } else { /* * type for operation: usually same as operands, but e.g. * (a == b) returns int. */ c.type = (tp & OP_A2IR) ? MN_INTEGER : a.type; switch(what) { case AND: case ANDEQ: c.u.l = a.u.l & b.u.l; break; case XOR: case XOREQ: c.u.l = a.u.l ^ b.u.l; break; case OR: case OREQ: c.u.l = a.u.l | b.u.l; break; case MUL: case MULEQ: if (c.type == MN_FLOAT) c.u.d = a.u.d * b.u.d; else c.u.l = a.u.l * b.u.l; break; case DIV: case DIVEQ: if (!notzero(b)) return; if (c.type == MN_FLOAT) c.u.d = a.u.d / b.u.d; else { /* * Avoid exception when dividing the smallest * negative integer by -1. Always treat it the * same as multiplication. This still doesn't give * numerically the right answer in two's complement, * but treating both these in the same way seems * reasonable. */ if (b.u.l == -1) c.u.l = - a.u.l; else c.u.l = a.u.l / b.u.l; } break; case MOD: case MODEQ: if (!notzero(b)) return; /* * Avoid exception as above. * Any integer mod -1 is the same as any integer mod 1 * i.e. zero. */ if (c.type == MN_FLOAT) c.u.d = fmod(a.u.d, b.u.d); else if (b.u.l == -1) c.u.l = 0; else c.u.l = a.u.l % b.u.l; break; case PLUS: case PLUSEQ: if (c.type == MN_FLOAT) c.u.d = a.u.d + b.u.d; else c.u.l = a.u.l + b.u.l; break; case MINUS: case MINUSEQ: if (c.type == MN_FLOAT) c.u.d = a.u.d - b.u.d; else c.u.l = a.u.l - b.u.l; break; case SHLEFT: case SHLEFTEQ: c.u.l = a.u.l << b.u.l; break; case SHRIGHT: case SHRIGHTEQ: c.u.l = a.u.l >> b.u.l; break; case LES: c.u.l = (zlong) (a.type == MN_FLOAT ? (a.u.d < b.u.d) : (a.u.l < b.u.l)); break; case LEQ: c.u.l = (zlong) (a.type == MN_FLOAT ? (a.u.d <= b.u.d) : (a.u.l <= b.u.l)); break; case GRE: c.u.l = (zlong) (a.type == MN_FLOAT ? (a.u.d > b.u.d) : (a.u.l > b.u.l)); break; case GEQ: c.u.l = (zlong) (a.type == MN_FLOAT ? (a.u.d >= b.u.d) : (a.u.l >= b.u.l)); break; case DEQ: c.u.l = (zlong) (a.type == MN_FLOAT ? (a.u.d == b.u.d) : (a.u.l == b.u.l)); break; case NEQ: c.u.l = (zlong) (a.type == MN_FLOAT ? (a.u.d != b.u.d) : (a.u.l != b.u.l)); break; case DAND: case DANDEQ: c.u.l = (zlong)(a.u.l && b.u.l); break; case DOR: case DOREQ: c.u.l = (zlong)(a.u.l || b.u.l); break; case DXOR: case DXOREQ: c.u.l = (zlong)((a.u.l && !b.u.l) || (!a.u.l && b.u.l)); break; case COMMA: c = b; break; case POWER: case POWEREQ: if (c.type == MN_INTEGER && b.u.l < 0) { /* produces a real result, so cast to real. */ a.type = b.type = c.type = MN_FLOAT; a.u.d = (double) a.u.l; b.u.d = (double) b.u.l; } if (c.type == MN_INTEGER) { for (c.u.l = 1; b.u.l--; c.u.l *= a.u.l); } else { if (b.u.d <= 0 && !notzero(a)) return; if (a.u.d < 0) { /* Error if (-num ** b) and b is not an integer */ double tst = (double)(zlong)b.u.d; if (tst != b.u.d) { zerr("imaginary power"); return; } } c.u.d = pow(a.u.d, b.u.d); } break; case EQ: c = b; break; } } if (tp & (OP_E2|OP_E2IO)) { struct mathvalue *mvp = stack + sp + 1; c = setmathvar(mvp, c); push(c, mvp->lval, 0); } else push(c,NULL, 0); return; }