【编程之美】2.6精确表达浮点数

最新推荐文章于 2019-02-01 10:34:53 发布
最新推荐文章于 2019-02-01 10:34:53 发布
阅读量593 收藏
点赞数
分类专栏： 编程之美 文章标签： 面试题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a45872055555/article/details/34861551
版权


【问题描述】：

       在计算机中，使用float或者double来存储小数是不能得到精确值的。如果你希望得到精确计算结果，最好是用分数形式来表示小数。有限小数或者无限循环小数都可以转化为分数。比如：
0.9 = 9/10
0.333（3）= 1/3（括号中的数字表示是循环节）
当然一个小数可以用好几种分数形式来表示。如：
0.333（3）= 1/3 = 3/9
       给定一个有限小数或者无限循环小数，你能否以分母最小的分数形式来返回这个小数呢？如果输入为循环小数，循环节用括号标记出来。下面是一些可能的输入数据，如0.3、0.30、0.3（000）、0.3333（3333）、……


解法：

        拿到这样一个问题，我们往往会从最简单的情况入手，因为所有的小数都可以分解成一个整数和一个纯小数之和，不妨只考虑大于0，小于1的纯小数，且暂时不考虑分子和分母的约分，先设法将其表示为分数形式，然后再进行约分。题目中输入的小数，要么为有限小数X=0.a1a2…an，要么为无限循环小数X=0.a1a2…an（b1b2…bm），X表示式中的字母a1a2…an，b1b2…bm都是0~9的数字，括号部分（b1b2…bm）表示循环节，我们需要处理的就是以上两种情况。

        对于有限小数X=0.a1a2…an来说，这个问题比较简单，X就等于（a1a2…an）/10n。

       对于无限循环小数X=0.a1a2…an（b1b2…bm）来说，其复杂部分在于小数点后同时有非循环部分和循环部分，我们可以做如下的转换：

X= 0.a1a2…an（b1b2…bm）

10n* X= a1a2…an.（b1b2…bm）

10n* X= a1a2…an+0.（b1b2…bm）

X =（a1a2…an+0.（b1b2…bm））/10n

        对于整数部分a1a2…an，不需要做额外处理，只需要把小数部分转化为分数形式再加上这个整数即可。对于后面的无限循环部分，可以采用如下方式进行处理：

令Y=0. b1b2…bm，那么

10m *Y=b1b2…bm.（b1b2…bm）

10m *Y=b1b2…bm+0.（b1b2…bm）

10m *Y-Y=b1b2…bm

Y= b1b2…bm/（10m-1）

将Y代入前面的X的等式可得：

X=（a1a2…an+Y）/10n

=（a1a2…an+ b1b2…bm/（10m-1））/10n

=（（a1a2…an）*（10m-1）+（b1b2…bm））/（（10m-1）*10n）

         至此，便可以得到任意一个有限小数或无限循环小数的分数表示，但是此时分母未必是最简的，接下来的任务就是让分母最小，即对分子和分母进行约分，这个相对比较简单。对于任意一个分数A/B，可以简化为（A/Gcd（A,B））/（B/Gcd（A,B）），其中Gcd函数为求A和B的最大公约数，这就涉及本书中的算法（2.7节“最大公约数问题”），其中有很巧妙的解法，请读者阅读具体的章节，这里就不再赘述。

         综上所述，先求得小数的分数表示方式，再对其分子分母进行约分，便能够得到分母最小的分数表现形式。

例如，对于小数0.3（33），根据上述方法，可以转化为分数：

0.3（33）

=（3 *（102-1）+ 33）/（（102-1）*10）

=（3*99+33）/990

= 1 / 3

对于小数0. 285714（285714），我们也可以算出：

0. 285714（285714）

= （285714 *（106-1）+ 285714）/ （（106-1）*106）

= （285714*999999 +285714）/ 999999000000

= 285714 / 999999

= 2/7


以下给出代码，简单实现：

void Cal(char* str)
{
	char *p=str;
	char *q=str,*q1=str;//q和q1分别存储(和)的指针
	while(*p!='\0')
	{
		if(*p=='(')
		{
			q=p;
		}
		if(*p==')')
		{
			q1=p;
		}
		p++;
	}
	if(q==q1)
	{
		cout<<"有限小数"<<endl;
		p=str+2;
		char *t=(char*)malloc(sizeof(char)*(strlen(str)-1));
		memset(t,0,sizeof(char)*(strlen(str)-1));
		int i=0;
		while(i<strlen(str)-1)
		{
			*(t+i++)=*p++;
		}
		cout<<atoi(t)<<"/"<<pow((float)10,(float)i)<<endl;
		delete t;
		return;
	}
	else//有循环小数
	{
		int len1=q1-q-1;
		int len2=q-str-2;
		char *str1=(char*)malloc(sizeof(char)*(len1+1));//循环小数
		char *str2=(char*)malloc(sizeof(char)*(len2+1));//非循环小数
		memset(str1,0,len1+1);
		memset(str2,0,len2+1);
		int i=0;
		while(i<len1)
		{
			*(str1+i)=*(q+i+1);
			i++;
		}
		i=0;
		while(i<len2)
		{
			*(str2+i)=*(str+2+i++);
		}
		int t1=atoi(str1);//循环小数
		int t2=atoi(str2);//非循环小数
		int m=len1;
		int n=len2;
		cout<<t1+t2*(pow((float)10,(float)m)-1)<<"/"<<((pow((float)10,(float)m)-1)*pow((float)10,(float)n))<<endl;
		delete str1;
		delete str2;
	}
}

int main()
{
	char str[]="0.333(3)";
	Cal(str);
	return 0;
}


为了更完善，分两种情况：

1、对于小数的情况，不用定义数组形式：

#include <iostream>

using namespace std;

long long gcd(long long a, long long b)
{
	if (a < b)
	{
		long long tmp = a;
		a = b;
		b = tmp;
	}
	int i, k=0;
	while (b!=0)
	{
		if ((a&1) == 0)
		{
			if ((b&1) == 0)
			{
				// a,b均是偶数，f(a,b)=2*f(a>>1,b>>1)
				a >>= 1;
				b >>= 1;
				k++;
			}
			else
				// a为偶数，b为奇数，f(a,b)=f(a>>1,b)
				a >>= 1;
		}
		else
		{
			if ((b&1) == 0)
				// a为奇数，b为偶数，f(a,b)=f(a,b>>1)
				b >>= 1;
			else
				// a,b均是奇数，f(a,b)=f(a-b,b)
				a = a-b;
		}
		if (a < b)
		{
			long long tmp = a;
			a = b;
			b = tmp;
		}
	}
	return a << k;
}

int main()
{
	long long a=0, b=0, c=0;
	// 整数部分c，非循环小数a，循环小数b
	scanf("%d.%d(%d)",&c, &a, &b);
	if (a==0 && b==0)
		cout << c;
	else
	{
		// 分子up，分母down
		long long up = c;
		long long down = 1;
		long long ta = a;
		while (ta)
		{
			down *= 10;
			ta /= 10;
		}
		up = c*down+a;
		if (b!=0)
		{
			long long wb = 1;
			long long tb = b;
			while (tb)
			{
				wb *= 10;
				tb /= 10;
			}
			up = up*(wb-1)+b;
			down = down*(wb-1);
		}
		long long fac = gcd(up, down);
		cout << up/fac << "/" << down/fac << endl;
	}
}


2、用于大整数，定义了大整数类型，以及对应的加减乘除、比较移位运算

#include <iostream>
#include <cstring>
#include <string>
using namespace std;

// 大整数类型
#define MAXLEN 1000
struct HP {int len, s[MAXLEN];};

void PrintHP(HP x) 
{
	for (int i=x.len; i>=1; i--)
		cout << x.s[i];
}

// 字符串转大整数
void Str2HP(const char *s, HP &x)
{
	x.len = strlen(s);
	for (int i=1; i<=x.len; i++)
		x.s[i] = s[x.len-i] - '0';
	if (x.len == 0)
	{
		x.len = 1;
		x.s[1] = 0;
	}
}

// 大整数的加法
void Plus(const HP a, const HP b, HP &c)
{
	int i; c.s[1] = 0;
	// 大整数a,b的加法操作和结果c的进位操作
	for (i=1; i<=a.len || i<=b.len || c.s[i]; i++)
	{
		if (i <= a.len) c.s[i] += a.s[i];
		if (i <= b.len) c.s[i] += b.s[i];
		c.s[i+1] = c.s[i]/10; c.s[i] %= 10;
	}
	// 退出循环到原因是c.s[i]==0，所以取前一位
	c.len = i-1; 
	if (c.len == 0) c.len = 1;
}

// 大整数的减法
void Subtract(const HP a, const HP b, HP &c)
{
	int i, j;
	for (i=1,j=0; i<=a.len; i++)
	{
		// j表示是否要对高位进行借位
		c.s[i] = a.s[i] - j;
		if (i <= b.len) c.s[i] -= b.s[i];
		if (c.s[i] < 0) 
		{
			// 向高位借位，补10
			j = 1;
			c.s[i] += 10;
		}
		else j = 0;
	}
	c.len = a.len;
	while (c.len > 1 && !c.s[c.len]) c.len--;
}

// 大整数的比较
int HPCompare(const HP &x, const HP &y)
{
	if (x.len > y.len) return 1;
	if (x.len < y.len) return -1;
	int i = x.len;
	while (i>1 && (x.s[i]==y.s[i])) i--;
	return x.s[i] - y.s[i];
}

// 大整数的乘法
void Multi(const HP a, const HP b, HP &c)
{
	int i, j;
	// 对乘法结果赋初值，以方便之后的+=运算
	c.len = a.len + b.len;
	for (i=1; i<=c.len; i++) c.s[i] = 0;
	for (i=1; i<=a.len; i++)
		for (j=1; j<=b.len; j++)
			c.s[i+j-1] += a.s[i]*b.s[j];
	// 运算结果进位
	for (i=1; i<c.len; i++) {c.s[i+1] += c.s[i]/10; c.s[i] %= 10;}
	// 最高位继续进位
	while (c.s[i]) {c.s[i+1] = c.s[i]/10; c.s[i] %= 10; i++;}
	// 确保最高位不为0
	while (i>1 && !c.s[i]) i--;
	c.len = i;
}

// 大整数的除法
void Divide(const HP a, const HP b, HP &c, HP &d)
{
	int i, j;
	// 用余数d存被除数a的前i位数据，用来多次减去除数b，以得到商c
	d.len = 1; d.s[1] = 0;
	for (i=a.len; i>0; i--)
	{
		if (!(d.len == 1 && d.s[1] == 0))
		{
			// i没移一位，余数d也移位
			for (j=d.len; j>0; j--)
				d.s[j+1] = d.s[j];
			d.len++;
		}
		d.s[1] = a.s[i];
		c.s[i] = 0;
		// 余数d大于除数b时，才可以进行减操作
		while ((j=HPCompare(d,b)) >= 0)
		{
			Subtract(d, b, d);
			c.s[i]++;
			if (j == 0) break;
		}
	}
	c.len = a.len;
	while (c.len > 1 && c.s[c.len] == 0)
		c.len--;
}
// 十进位右移
void RightShift(HP &x, int k)
{
	for (int i=1; i<=x.len-k; i++)
		x.s[i] = x.s[i+k];
	x.len -= k;
	if(x.len <= 0)
	{
		x.len = 1;
		x.s[1] = 0;
	}
}
// 十进位左移
void LeftShift(HP &x, int k)
{
	int i;
	for (i=x.len; i>=1; i--)
		x.s[i+k] = x.s[i];
	for (i=k; i>=1; i--)
		x.s[i] = 0;
	x.len += k;
}
// 求大整数的最大公约数
void GCD(HP a, HP b, HP &c)
{
	if (b.len == 1 && b.s[1] == 0)
	{
		c.len = a.len;
		memcpy(c.s, a.s, (a.len+1)*sizeof(int));
	}
	else
	{
		HP m, n;
		Divide(a, b, m, n);
		GCD(b, n, c);
	}
}

int main()
{
	string str;
	string strc, stra, strb;
	cin >> str;
	int posc = str.find('.');
	int posa = str.find('(');
	int posb = str.find(')');
	strc = str.substr(0, posc);
	if (posc < 0)
		cout << strc;
	else
	{	
		HP a, b, c;
		HP tmp; tmp.len = 1; tmp.s[1] = 1;
		// 整数部分
		Str2HP(strc.c_str(), c);
		stra = str.substr(posc+1, posa-posc-1);
		// 非循环部分
		Str2HP(stra.c_str(), a);
		// up分子，down分母
		HP up = c, down = tmp;
		// 乘以10^|a|
		LeftShift(down, stra.size());
		LeftShift(up, stra.size());
		Plus(up, a, up);
		if (posa >= 0)
		{
			strb = str.substr(posa+1, posb-posa-1);
			// 循环部分
			Str2HP(strb.c_str(), b);
			HP m = tmp;
			LeftShift(m, strb.size());
			Subtract(m, tmp, m);
			// 乘以10^(|b|-1)
			Multi(up, m, up);
			Plus(up, b, up);
			Multi(down, m, down);
		}
		// 求分子分母的最大公约数
		GCD(down, up, tmp);
		HP h;
		Divide(down, tmp, down, h);
		Divide(up, tmp, up, h);
		PrintHP(up); cout << "/";
		PrintHP(down); cout << endl;
	}
}



solar一抹阳光
关注
专栏目录
校OJ 11076 浮点数的分数表达
Lin_disguiser的博客
12-20 1417
这是一道简单的水题，可是还是忍不住看题解了~~~ Description 在计算机中，用float或double来存储小数有时不能得到精确值，若要精确表达一个浮点数的计算结果， 最好用分数来表示小数，有限小数或无限循环小数都可以转化为分数，无限循环小数的循环节用括号标记出来。如： 0.9 = 9/10 0.(3) = 0.3(3) = 0.3(33) = 1/3 当然一个
[读书笔记]编程之美（二)
xy_cpp的博客
04-08 402
[读书笔记]编程之美（二)2.1求二进制数中1的个数 问题：对于一个字节（8bit）的无符号整形变量，求其二进制表示中“1”的个数，要求算法的执行效率尽可能高。 思路： n = n & (n-1);当然因为只有8bit所以直接定义一个256的int数组表，直接返回结果，时间复杂度是O（1）。2.2不要被阶乘吓到 问题：1.给定一个整数N，那么N的阶乘N！末尾有多少个0呢？例如：N=10，N！=362
【编程之美】精确表达浮点数
famousDT的专栏
03-22 615
转自hi，baidu 【问题描述】：        在计算机中，使用float或者double来存储小数是不能得到精确值的。如果你希望得到精确计算结果，最好是用分数形式来表示小数。有限小数或者无限循环小数都可以转化为分数。比如： 0.9 = 9/10 0.333（3）= 1/3（括号中的数字表示是循环节） 当然一个小数可以用好几种分数形式来表示。如： 0.333（3）= 1/3 = 3
《编程之美》学而思-精确表达浮点数
flyfish
08-20 2214
C++浮点数表示flyfish 2015-10-13《编程之美》精确表达浮点数 有限小数或者无限循环小数都可以转化为分数。 有限小数：0.9 = 9/10 无限循环小数：0.333（3）= 1/3（括号中的数字表示是循环节） 1）对于有限小数：0.a1a2…an=(a1a2…an)/10n0.a_1a_2…a_n=(a_1a_2…a_n)/10^n 2）对于无限循环小数
编程之美——精确表达浮点数
chenglinhust的专栏
12-06 1053
编程之美——精确表达浮点数       在计算机中，使用float或者double来存储小数是不能得到精确值的。如果你希望得到精确计算结果，最好是用分数形式来表示小数。有限小数或者无限循环小数都可以转化为分数。比如： 0.9 = 9/10 0.333（3）= 1/3（括号中的数字表示是循环节） 当然一个小数可以用好几种分数形式来表示。如： 0.333（3）= 1/3 = 3/9 给定一个
编程之美2.6 精确表达浮点数
richard_如风的专栏
03-15 1069
题：        在计算机中，使用float或者double来存储小数是不能得到精确值的。如果你希望得到精确计算结果，最好是用分数形式来表示小数。有限小数或者无限循环小数都可以转化为分数。比如： 0.9 = 9/10 0.333（3）= 1/3（括号中的数字表示是循环节） 当然一个小数可以用好几种分数形式来表示。如： 0.333（3）= 1/3 = 3/9        给定一个有限
commons-lang-2.6.zip
09-09
Apache Commons Lang 2.6 是Java开发者不可或缺的工具之一，它通过封装和优化许多常见的编程任务，提升了代码的可读性和可维护性，减少了重复的工作，提高了开发效率。虽然现在已经有更新的版本（如3.x），但2.6版本...
C&C++编程规范（超级实用）
最新发布
02-13
浮点数不精确，应使用一个很小的正数作为误差范围进行比较。 示例： ```cpp float f = 0.0f; if (fabs(f) ) { /* ... */ } ``` **4.3.4 指针变量与零值比较** 指针与NULL比较时应使用`== NULL`或`!= NULL`。 示例...
《JavaScript函数式编程思想》——类型系统
JavaScript
02-01 1032
第2章  类型系统 为什么在许多编程语言中整数和浮点数是两种类型？结构体、数组、列表、映射……这些类型有什么关系？用户自定义的各种类型与它们又有什么关系？函数也是类型吗？强类型和弱类型意味着什么？它们的区别和类型转换有关吗？静态类型语言中的变量为什么有固定类型而动态类型则没有？多态性就是后期绑定吗？鸭子类型是怎么回事？为什么要采用它？ 假如您对以上问题感兴趣，阅读完本章时就会有肯定的答案。有了...
Perl语言编程
10-15
### Perl语言编程知识点详解 #### 一、Perl概述 **1.1 从头开始** Perl是一种高级脚本语言，广泛应用于系统管理、Web开发、网络编程等领域。它结合了C语言的强大功能与Shell脚本的灵活性，拥有丰富的内置函数和...
11076 浮点数的分数表达
11-23
Description 在计算机中，用float或double来存储小数有时不能得到精确值，若要精确表达一个浮点数的计算结果， 最好用分数来表示小数，有限小数或无限循环小数都可以转化为分数，无限循环小数的循环节用括号标记出来。如： 0.9 = 9/10 0.(3) = 0.3(3) = 0.3(33) = 1/3 当然一个小数可以用好几种分数形式来表示，我们只感兴趣最简的分数形式(即分母最小)，如： 0.3(33) = 1/3 = 3/9 因为任何一个数都可以转化为一个整数和一个纯小数之和，整数部分较为简单无需做额外处理，只要将纯小数部分转化为分数形式，整数部分的分数部分就很简单了。 现在给定一个正的纯小数（这个纯小数为有限小数或无限循环小数），请你以最简分数形式来返回这个纯小数。 输入格式 给定一个纯小数，若是无限循环小数，用括号标记循环节，输入小数表达不超过100个字符。 输出格式 输出：化为最简分数形式，分子在前，分母在后，中间空格连接。 输入样例 0.3(33) 输出样例 1 3
浮点数的分数表达
01-02
计算机算法设计与分析实验：浮点数的分数表达，可运行源代码，c++
11076浮点数的分数表达
03-15
在计算机中，用float或double来存储小数有时不能得到精确值，若要精确表达一个浮点数的计算结果， 最好用分数来表示小数，有限小数或无限循环小数都可以转化为分数，无限循环小数的循环节用括号标记出来。如： 0.9 = 9/10 0.(3) = 0.3(3) = 0.3(33) = 1/3 当然一个小数可以用好几种分数形式来表示，我们只感兴趣最简的分数形式(即分母最小)，如： 0.3(33) = 1/3 = 3/9 因为任何一个数都可以转化为一个整数和一个纯小数之和，整数部分较为简单无需做额外处理，只要将纯小数部分转化为分数形式，整数部分的分数部分就很简单了。 现在给定一个正的纯小数（这个纯小数为有限小数或无限循环小数），请你以最简分数形式来返回这个纯小数。 Input 给定一个纯小数，若是无限循环小数，用括号标记循环节，输入小数表达不超过100个字符。 Output 输出：化为最简分数形式，分子在前，分母在后，中间空格连接。
编程之美--2.6 精确表达浮点数
u011387543的博客
06-04 306
/** * 本题目内容如下： * 在计算机中，有时使用float或double来存储小数是不能得到精确值的. 如果你需要得到精确计算结果，最好是用分数形式来表示小数。有限小数或者无限循环小数都可以转化为分数。 * eg： 0.9 = 9/10; * 0.33(3) = 1/3(括号里的数字表示的的是循环节) * 当然一个小数可以用好几种弄分数形式来表示. 如: * 0.33(3) = 1 / 3...
Java编程疑难解答：精确计算与浮点数表示
本文档主要针对Java编程中的一些易忽略问题进行了解答，旨在帮助开发者提升Java技术。首先，作者指出在判断数值是否为奇数时，应注意避免使用`i % 2 == 1`的方式，因为这种方法在处理负奇数时会出现不正确的情况。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值