UVa 11809 Floating-Point Numbers

Floating-point numbers are represented differently in computers than integers. That is why a 32-bit

floating-point number can represent values in the magnitude of 1038 while a 32-bit integer can only

represent values as high as 232 .

Although there are variations in the ways floating-point numbers are stored in Computers, in this

problem we will assume that floating-point numbers are stored in the following way:

Floating-point numbers have two parts mantissa and exponent. M -bits are allotted for mantissa

and E bits are allotted for exponent. There is also one bit that denotes the sign of number (If this

bit is 0 then the number is positive and if it is 1 then the number is negative) and another bit that

denotes the sign of exponent (If this bit is 0 then exponent is positive otherwise negative). The value of

mantissa and exponent together make the value of the floating-point number. If the value of mantissa

is m then it maintains the constraints 1 ≤ m < 1. The left most digit of mantissa must always be 1 to

2

maintain the constraint 1 ≤ m < 1. So this bit is not stored as it is always 1. So the bits in mantissa

2

actually denote the digits at the right side of decimal point of a binary number (Excluding the digit

just to the right of decimal point)

In the figure above we can see a floating-point number where M = 8 and E = 6. The largest value

this floating-point number can represent is (in binary) 0.1111111112 × 21111112 . The decimal equivalent

to this number is: 0.998046875 × 263 = 920535763834529382410 . Given the maximum possible value

represented by a certain floating point type, you will have to find how many bits are allotted for

mantissa (M ) and how many bits are allotted for exponent (E) in that certain type.

Input

The input file contains around 300 line of input. Each line contains a floating-point number F that

denotes the maximum value that can be represented by a certain floating-point type. The floating point

number is expressed in decimal exponent format. So a number AeB actually denotes the value A×10B .

A line containing ‘0e0’ terminates input. The value of A will satisfy the constraint 0 < A < 10 and

will have exactly 15 digits after the decimal point.

Output

For each line of input produce one line of output. This line contains the value of M and E. You can

assume that each of the inputs (except the last one) has a possible and unique solution. You can also

assume that inputs will be such that the value of M and E will follow the constraints: 9 ≥ M ≥ 0 and

30 ≥ E ≥ 1. Also there is no need to assume that (M + E + 2) will be a multiple of 8.

Sample Input

5.699141892149156e76

9.205357638345294e18

0e0

Sample Output

5 8
8 6

#include "stdio.h"
#include "string.h"
#include "math.h"
#include "stdlib.h"

double A[10][31];
long long int B[10][31];
char str[100];

int main()
{
memset(A, 0, sizeof(A));
memset(B, 0, sizeof(B));

for(int m = 0; m <= 9; m++)
{
for(int e = 1; e <= 30; e++)
{
double a = 1.0 - pow(2.0, -(m+1));
long long int b = pow(2.0, e) - 1;
double x = log10(a) + b * log10(2);
B[m][e] = floor(x);
A[m][e] = pow(10, x - B[m][e]);
}
}

memset(str, 0, sizeof(str));

while(scanf("%s", str) && strcmp(str, "0e0") != 0)
{
int len = strlen(str);
int i;
for(i = 0; i < len; i++)
{
if(str[i] == 'e')
break;
}

char str2[100];
memset(str2, 0, sizeof(str2));
strncpy(str2, &str[0], i);
// printf("str2: %s\n", str2);
double a = atof(str2);
memset(str2, 0, sizeof(str2));
strncpy(str2, &str[i+1], len-(i+1));
// printf("str2: %s\n", str2);
int b = atoi(str2);
/* str[17]=' ';
double a;
int b;
sscanf(str,"%lf %d",&a,&b);
*/ int flag = 0;
for(int m = 0; m <= 9; m++)
{
for(int e = 1; e <= 30; e++)
{
if(b == B[m][e] && fabs(a-A[m][e]) < 0.00001)
{
printf("%d %d\n", m, e);
flag = 1;
break;
}
}
if(flag)
break;
}
memset(str, 0, sizeof(str));
}
return 0;
}

这道题一直想不起来怎么做，最终参考了http://blog.csdn.net/xyqcl/article/details/40011009

将十进制和二进制表达式同时取对数，并求floor。感觉很巧妙