[已解决]如何只用C语言做这个题目？

彭尼玛

有一个喜欢装逼的学长，英语词汇量没到20个词还不会语法，却总想着拽两句英文，问个a+b都不会好好问，非用英文问。
这位学长特有的语法是，按位直接说英文，例如123他会念成one two three，123+456他会念one two three add four five six，结果是five seven nine
而1+2他会念one add two，结果是three
这位学长为了照顾英文不好的同学，他教大家学英语
0 zero
1 one
2 two
3 three
4 four
5 five
6 six
7 seven
8 eight
9 nine


输入
输入由1行字符串组成，形如题面描述（保证0<=a,b < 1000）


输出
按题面描述形式输出a+b的结果


样例输入
one two three add four five six
one add two
zero add one


样例输出
five seven nine
three
one


提示
能多组输入

原题网址：http://120.78.162.102/problem.php?cid=1412&pid=3

最佳答案

月排行榜 / 总排行榜

人造人

2018-12-9 22:41:18

彭尼玛 发表于 2018-12-9 17:47
是的……我那大妹子被要求必须用C语言…………
欸老哥，我临时这边有个问题想不通。。。
就是不明白， ...

1. #include <stdio.h>
   
2. #include <string.h>
   
3. 
   
4. static const char *g_table[] = {"zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine"};
   
5. static const size_t g_table_size = sizeof(g_table) / sizeof(g_table[0]);
   
6. 
   
7. static size_t WordToNumber(const char *word)
   
8. {
   
9.         for(size_t i = 0; i < g_table_size; ++i)
   
10.         {
    
11.                 if(!strcmp(word, g_table[i]))
    
12.                         return i;
    
13.         }
    
14.         return -1;
    
15. }
    
16. 
    
17. static const char *NumberToString(char *dest, size_t number)
    
18. {
    
19.         char buf[512];
    
20.         sprintf(buf, "%d", number);
    
21. 
    
22.         char *separator = "";
    
23.         dest[0] = '\0';
    
24.         for(size_t i = 0; buf[i]; ++i)
    
25.         {
    
26.                 strcat(dest, separator);
    
27.                 strcat(dest, g_table[buf[i] - '0']);
    
28.                 separator = " ";
    
29.         }
    
30.         return dest;
    
31. }
    
32. 
    
33. size_t GetWord(char *dest, const char *string)
    
34. {
    
35.         size_t count = 0;
    
36.         while(string[count] && string[count] != ' ')
    
37.                 ++count;
    
38. 
    
39.         strncpy(dest, string, count);
    
40.         dest[count] = '\0';
    
41.         return count;
    
42. }
    
43. 
    
44. const char *GetResult(char *dest, const char *expression)
    
45. {
    
46.         size_t a = 0, b = 0;
    
47.         char word[32];
    
48.         size_t offset = 0;
    
49.         size_t size;
    
50.         while((size = GetWord(word, expression + offset)) && (offset += size + 1) && strcmp(word, "add"))
    
51.         {
    
52.                 a = a * 10 + WordToNumber(word);
    
53.         }
    
54. 
    
55.         while((size = GetWord(word, expression + offset)) && (offset += size + 1))
    
56.         {
    
57.                 b = b * 10 + WordToNumber(word);
    
58.         }
    
59. 
    
60.         return NumberToString(dest, a + b);
    
61. }
    
62. 
    
63. int main()
    
64. {
    
65.         char expression[512][512];
    
66.         size_t size = 0;
    
67. 
    
68.         while(fgets(expression[size], 512, stdin))
    
69.         {
    
70.                 expression[size][strlen(expression[size]) - 1] = '\0';        // 去掉'\n'
    
71.                 ++size;
    
72.         }
    
73. 
    
74.         char dest[512];
    
75.         for(size_t i = 0; i < size; ++i)
    
76.         {
    
77.                 puts(GetResult(dest, expression[i]));
    
78.         }
    
79. 
    
80.         return 0;
    
81. }
    

复制代码

跳转到最佳答案楼层

人造人

必须是C语言？

1. #include <iostream>
   
2. #include <string>
   
3. #include <sstream>
   
4. #include <vector>
   
5. 
   
6. static const std::vector<std::string>g_table = {"zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine"};
   
7. 
   
8. static size_t WordToNumber(const std::string &word)
   
9. {
   
10.         for(auto iter = g_table.begin(); iter != g_table.end(); ++iter)
    
11.         {
    
12.                 if(*iter == word)
    
13.                         return iter - g_table.begin();
    
14.         }
    
15. 
    
16.         return -1;
    
17. }
    
18. 
    
19. static const std::string NumberToString(size_t number)
    
20. {
    
21.         std::stringstream ss;
    
22.         ss << number;
    
23. 
    
24.         char ch;
    
25.         std::string result;
    
26.         std::string separator;
    
27.         while(ss >> ch)
    
28.         {
    
29.                 result += separator + g_table[ch - '0'];
    
30.                 separator = " ";
    
31.         }
    
32. 
    
33.         return result;
    
34. }
    
35. 
    
36. const std::string GetResult(const std::string &expression)
    
37. {
    
38.         std::stringstream ss;
    
39.         ss << expression;
    
40. 
    
41.         size_t a = 0, b = 0;
    
42.         std::string word;
    
43.         while(ss >> word && word != "add")
    
44.         {
    
45.                 a = a * 10 + WordToNumber(word);
    
46.         }
    
47. 
    
48.         while(ss >> word)
    
49.         {
    
50.                 b = b * 10 + WordToNumber(word);
    
51.         }
    
52. 
    
53.         return NumberToString(a + b);
    
54. }
    
55. 
    
56. int main()
    
57. {
    
58.         std::vector<std::string> expression;
    
59. 
    
60.         std::string line;
    
61.         while(std::getline(std::cin, line))
    
62.                 expression.push_back(line);
    
63. 
    
64.         for(auto const &i: expression)
    
65.                 std::cout << GetResult(i) << std::endl;
    
66. 
    
67.         return 0;
    
68. }
    

复制代码

1. one two three add four five six
   
2. one add two
   
3. zero add one
   
4. ^Z
   
5. five seven nine
   
6. three
   
7. one
   
8. 请按任意键继续. . .
   

复制代码

彭尼玛

人造人 发表于 2018-12-9 14:16
必须是C语言？

是的……我那大妹子被要求必须用C语言…………
欸老哥，我临时这边有个问题想不通。。。
就是不明白，为什么IEEE 754标准里的 阶码的偏移量是127。。。我看计算机组成原理的时候，前面说的是 移码=补码的符号位取反   或者用  真值+2^n次方 来表示
为什么一到IEEE 754这里就变成了  真值+2^n次方-1   这个-1是哪里来的？？
还有就是
隐含位的问题，这是IEEE754规定的是吧，是为了让尾数的精度能提高一些吗？

我百度了很多，但是没有看到什么特别好的回答QAQ
求大佬帮帮孩子吧

人造人

彭尼玛 发表于 2018-12-9 17:47
是的……我那大妹子被要求必须用C语言…………
欸老哥，我临时这边有个问题想不通。。。
就是不明白， ...

1. #include <stdio.h>
   
2. #include <string.h>
   
3. 
   
4. static const char *g_table[] = {"zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine"};
   
5. static const size_t g_table_size = sizeof(g_table) / sizeof(g_table[0]);
   
6. 
   
7. static size_t WordToNumber(const char *word)
   
8. {
   
9.         for(size_t i = 0; i < g_table_size; ++i)
   
10.         {
    
11.                 if(!strcmp(word, g_table[i]))
    
12.                         return i;
    
13.         }
    
14.         return -1;
    
15. }
    
16. 
    
17. static const char *NumberToString(char *dest, size_t number)
    
18. {
    
19.         char buf[512];
    
20.         sprintf(buf, "%d", number);
    
21. 
    
22.         char *separator = "";
    
23.         dest[0] = '\0';
    
24.         for(size_t i = 0; buf[i]; ++i)
    
25.         {
    
26.                 strcat(dest, separator);
    
27.                 strcat(dest, g_table[buf[i] - '0']);
    
28.                 separator = " ";
    
29.         }
    
30.         return dest;
    
31. }
    
32. 
    
33. size_t GetWord(char *dest, const char *string)
    
34. {
    
35.         size_t count = 0;
    
36.         while(string[count] && string[count] != ' ')
    
37.                 ++count;
    
38. 
    
39.         strncpy(dest, string, count);
    
40.         dest[count] = '\0';
    
41.         return count;
    
42. }
    
43. 
    
44. const char *GetResult(char *dest, const char *expression)
    
45. {
    
46.         size_t a = 0, b = 0;
    
47.         char word[32];
    
48.         size_t offset = 0;
    
49.         size_t size;
    
50.         while((size = GetWord(word, expression + offset)) && (offset += size + 1) && strcmp(word, "add"))
    
51.         {
    
52.                 a = a * 10 + WordToNumber(word);
    
53.         }
    
54. 
    
55.         while((size = GetWord(word, expression + offset)) && (offset += size + 1))
    
56.         {
    
57.                 b = b * 10 + WordToNumber(word);
    
58.         }
    
59. 
    
60.         return NumberToString(dest, a + b);
    
61. }
    
62. 
    
63. int main()
    
64. {
    
65.         char expression[512][512];
    
66.         size_t size = 0;
    
67. 
    
68.         while(fgets(expression[size], 512, stdin))
    
69.         {
    
70.                 expression[size][strlen(expression[size]) - 1] = '\0';        // 去掉'\n'
    
71.                 ++size;
    
72.         }
    
73. 
    
74.         char dest[512];
    
75.         for(size_t i = 0; i < size; ++i)
    
76.         {
    
77.                 puts(GetResult(dest, expression[i]));
    
78.         }
    
79. 
    
80.         return 0;
    
81. }
    

复制代码

人造人

彭尼玛 发表于 2018-12-9 17:47
是的……我那大妹子被要求必须用C语言…………
欸老哥，我临时这边有个问题想不通。。。
就是不明白， ...

浮点数部分我需要研究研究

彭尼玛

人造人 发表于 2018-12-9 22:41

感动，谢谢，替我大妹子感谢你QAQ

人造人

彭尼玛 发表于 2018-12-9 17:47
是的……我那大妹子被要求必须用C语言…………
欸老哥，我临时这边有个问题想不通。。。
就是不明白， ...

目前我已经研究了差不多一半了，我还需要一些时间研究另外差不多一半的内容

彭尼玛

人造人 发表于 2018-12-15 15:03
目前我已经研究了差不多一半了，我还需要一些时间研究另外差不多一半的内容

计算机组成原理，好多看得不是很懂的，现在开始学数据结构和算法QAQ

人造人

彭尼玛 发表于 2018-12-16 11:04
计算机组成原理，好多看得不是很懂的，现在开始学数据结构和算法QAQ

C语言学完了是吧？
建议先学汇编语言
有了C语言和汇编语言之后，你就可以任意选择了
如果愿意，再加上C++
^_^

彭尼玛

人造人 发表于 2018-12-16 12:41
C语言学完了是吧？
建议先学汇编语言
有了C语言和汇编语言之后，你就可以任意选择了

看完了C和C++ ，汇编准备先学完数据结构在那个

人造人

彭尼玛 发表于 2018-12-9 17:47
是的……我那大妹子被要求必须用C语言…………
欸老哥，我临时这边有个问题想不通。。。
就是不明白， ...

两个星期了，我已经失去耐心了，估计下面这两个程序再也不会被完善了，最多就是重写这两个程序了^_^
这两个程序的设计上面的问题限制了继续对其完善，也许还有办法，但是我选择放弃这两个程序

人造人

解析单精度浮点数的存储格式

1. #include <iostream>
   
2. #include <string>
   
3. #include <sstream>
   
4. #include <iomanip>
   
5. 
   
6. #define BOOST_CONFIG_SUPPRESS_OUTDATED_MESSAGE
   
7. #include <boost/multiprecision/cpp_int.hpp>
   
8. 
   
9. static const std::string NumberToDecimalString(uint64_t num)
   
10. {
    
11.         std::stringstream ss;
    
12.         ss << std::setprecision(0) << std::fixed << num;
    
13.         return ss.str();
    
14. }
    
15. 
    
16. static size_t DecimalStringToNumber(const std::string &string)
    
17. {
    
18.         std::stringstream ss;
    
19.         ss << string;
    
20. 
    
21.         size_t result;
    
22.         ss >> result;
    
23.         return result;
    
24. }
    
25. 
    
26. static const std::string NumberToBinaryString(uint32_t num)
    
27. {
    
28.         std::string result;
    
29.         for(uint32_t mask = 0x80000000; mask; mask >>= 1)
    
30.         {
    
31.                 if(mask & num)
    
32.                         result += "1";
    
33.                 else
    
34.                         result += "0";
    
35.         }
    
36.         return result;
    
37. }
    
38. 
    
39. static size_t BinaryStringToNumber(std::string string)
    
40. {
    
41.         size_t result = 0;
    
42.         size_t size = string.size();
    
43.         for(auto iter = string.begin(); iter != string.end(); ++iter)
    
44.         {
    
45.                 if(*iter == '1')
    
46.                 {
    
47.                         size_t index = size - (iter - string.begin()) - 1;
    
48.                         result += size_t(pow(2, index));
    
49.                 }
    
50.         }
    
51.         return result;
    
52. }
    
53. 
    
54. static const std::string GetIntegerPart(const std::string binary_string)
    
55. {
    
56.         return NumberToDecimalString(BinaryStringToNumber(binary_string));
    
57. }
    
58. 
    
59. static const std::string GetDecimalPart(const std::string binary_string)
    
60. {
    
61.         using bigint = boost::multiprecision::number<boost::multiprecision::cpp_int_backend<>>;
    
62. 
    
63.         bigint value = 1;        // 随便一个数字，这里使用数字1；为了最后的字符串前面有0，例如0625
    
64.         for(auto iter = binary_string.begin(); iter != binary_string.end(); ++iter)
    
65.         {
    
66.                 value *= 10;
    
67.                 if(*iter == '1')
    
68.                 {
    
69.                         int index = iter - binary_string.begin();
    
70.                         value += uint64_t(pow(2, -(index + 1)) * pow(10, index + 1));
    
71.                 }
    
72.         }
    
73. 
    
74.         std::string num = value.str();
    
75.         num.erase(num.begin());                // 去掉上面的那个'1'
    
76.         while(!num.empty() && (*(num.end() - 1) == '0'))        // 删除末尾的'0'
    
77.                 num.erase(num.end() - 1);
    
78. 
    
79.         if(num == "")                // 不能全删掉
    
80.                 num = "00";
    
81. 
    
82.         return num;
    
83. }
    
84. 
    
85. const std::string ParseFloat(float num)
    
86. {
    
87.         std::string binary_string = NumberToBinaryString(*(uint32_t *)&num);
    
88.         char sign = binary_string[0];
    
89.         std::string exponent = std::string(binary_string.begin() + 1, binary_string.begin() + 9);
    
90.         std::string fraction = std::string(binary_string.begin() + 9, binary_string.end());
    
91. 
    
92. 
    
93.         int32_t e = BinaryStringToNumber(exponent);
    
94.         if(e == 0xFF)        // INF or NaN
    
95.         {
    
96.                 if(BinaryStringToNumber(fraction))
    
97.                         return "NaN";
    
98.                 return "INF";
    
99.         }
    
100.         if(e == 0)        // 非正规化
     
101.         {
     
102.                 fraction.insert(fraction.begin(), '0');
     
103.         }
     
104.         else
     
105.         {
     
106.                 fraction.insert(fraction.begin(), '1');
     
107.                 e -= 127;
     
108.         }
     
109. 
     
110.         size_t pos;
     
111.         if(e >= 0)
     
112.         {
     
113.                 pos = e + 1;
     
114.         }
     
115.         else
     
116.         {
     
117.                 while(e++ < 0)
     
118.                         fraction.insert(fraction.begin(), '0');
     
119.                 pos = 1;
     
120.         }
     
121. 
     
122.         return GetIntegerPart(std::string(fraction.begin(), fraction.begin() + pos))
     
123.                 + "." + GetDecimalPart(std::string(fraction.begin() + pos, fraction.end()));
     
124. }
     
125. 
     
126. int main()
     
127. {
     
128.         float num;
     
129. 
     
130.         num = 3.1415926F;
     
131.         std::cout << "0x" << std::hex << std::uppercase << *(uint32_t *)&num << ": " << ParseFloat(num) << std::endl;
     
132. 
     
133.         num = 0.0F;
     
134.         std::cout << "0x" << std::hex << std::uppercase << *(uint32_t *)&num << ": " << ParseFloat(num) << std::endl;
     
135. 
     
136.         num = 0.005F;
     
137.         std::cout << "0x" << std::hex << std::uppercase << *(uint32_t *)&num << ": " << ParseFloat(num) << std::endl;
     
138. 
     
139.         num = 1234;
     
140.         std::cout << "0x" << std::hex << std::uppercase << *(uint32_t *)&num << ": " << ParseFloat(num) << std::endl;
     
141. 
     
142.         return 0;
     
143. }
     

复制代码

人造人

构造单精度浮点数的存储格式，这个代码还有问题，我知道为什么，但是却没办法修改它，这个代码太乱了，我实在是不想继续在其上面完善了

1. #include <iostream>
   
2. #include <string>
   
3. #include <sstream>
   
4. #include <iomanip>
   
5. #include <cmath>
   
6. 
   
7. #define BOOST_CONFIG_SUPPRESS_OUTDATED_MESSAGE
   
8. #include <boost/multiprecision/cpp_int.hpp>
   
9. 
   
10. using BigInteger = boost::multiprecision::number<boost::multiprecision::cpp_int_backend<>>;
    
11. 
    
12. static const std::string IntegerPartToBinaryString(const std::string &string, size_t bits)
    
13. {
    
14.         BigInteger num(string);
    
15.         std::string result;
    
16. 
    
17.         while(num)
    
18.         {
    
19.                 if(num % 2)
    
20.                         result += "1";
    
21.                 else
    
22.                         result += "0";
    
23.                 num /= 2;
    
24.         }
    
25. 
    
26.         std::reverse(result.begin(), result.end());
    
27.         if(bits)
    
28.         {
    
29.                 while(result.size() != bits)
    
30.                         result.insert(result.begin(), '0');
    
31.         }
    
32.         if(result.size() == 0)
    
33.                 result += "0";
    
34.         return result;
    
35. }
    
36. 
    
37. static const std::string RemovePrefixZero(const std::string &string)
    
38. {
    
39.         auto iter = string.begin();
    
40.         for(; iter != string.end(); ++iter)
    
41.         {
    
42.                 if(*iter != '0')
    
43.                         break;
    
44.         }
    
45.         if(iter == string.end())
    
46.                 return std::string("0");
    
47.         return std::string(iter, string.end());
    
48. }
    
49. 
    
50. static void BinaryCarry(std::string &string)
    
51. {
    
52.         for(auto iter = string.rbegin(); iter != string.rend(); ++iter)
    
53.         {
    
54.                 if(*iter == '0')
    
55.                 {
    
56.                         *iter = '1';
    
57.                         break;
    
58.                 }
    
59.                 *iter = '0';
    
60.         }
    
61. }
    
62. 
    
63. static const std::string DecimalPartToBinaryString(const std::string &string, size_t bits)
    
64. {
    
65.         BigInteger num = BigInteger(pow(10, string.size()));
    
66.         num += BigInteger(RemovePrefixZero(string));
    
67. 
    
68.         std::string result;
    
69.         for(size_t i = 0; i < bits + 1; ++i)
    
70.         {
    
71.                 num *= 2;
    
72.                 num -= BigInteger(pow(10, string.size()));
    
73. 
    
74.                 BigInteger remainder = (num / BigInteger(pow(10, string.size()))) % 10;
    
75.                 if(remainder > 1)
    
76.                 {
    
77.                         num -= BigInteger(pow(10, string.size()));
    
78.                         result += "1";
    
79.                 }
    
80.                 else
    
81.                 {
    
82.                         result += "0";
    
83.                 }
    
84.         }
    
85. 
    
86.         char ch = *(result.end() - 1);
    
87.         result.erase(result.end() - 1);
    
88.         if(ch == '1')
    
89.         {
    
90.                 BinaryCarry(result);
    
91.         }
    
92. 
    
93.         return result;
    
94. }
    
95. 
    
96. static const std::string GetFraction(const std::string &binary_integer_part, const std::string &binary_decimal_part)
    
97. {
    
98.         std::string fraction = binary_integer_part + binary_decimal_part;
    
99.         fraction.erase(fraction.begin());
    
100.         return fraction;
     
101. }
     
102. 
     
103. static const std::string GetExponent(size_t exponent, bool normalization)
     
104. {
     
105.         if(!normalization)
     
106.                 return std::string("00000000");
     
107.         BigInteger num = exponent + 127;
     
108.         return IntegerPartToBinaryString(num.str(), 8);
     
109. }
     
110. 
     
111. static void SetBit(uint32_t &data, bool bit, size_t pos)
     
112. {
     
113.         data &= ~(1 << pos);
     
114.         data |= bit << pos;
     
115. }
     
116. 
     
117. 
     
118. static uint32_t MakeFloat(bool sign, const std::string &exponent, const std::string &fraction)
     
119. {
     
120.         uint32_t num = 0;
     
121.         SetBit(num, sign, 31);
     
122.         for(int i = 30; i != 22; --i)
     
123.                 SetBit(num, exponent[30 - i] == '1', i);
     
124.         for(int i = 22; i >= 0; --i)
     
125.                 SetBit(num, fraction[22 - i] == '1', i);
     
126.         return num;
     
127. }
     
128. 
     
129. size_t ParseFloat(std::string num)
     
130. {
     
131.         std::string integer_part;
     
132.         std::string decimal_part;
     
133. 
     
134.         size_t pos = num.find('.');
     
135.         if(pos == std::string::npos)
     
136.         {
     
137.                 integer_part = num;
     
138.                 decimal_part = "0";
     
139.         }
     
140.         else
     
141.         {
     
142.                 integer_part = std::string(num.begin(), num.begin() + pos);
     
143.                 decimal_part = std::string(num.begin() + pos + 1, num.end());
     
144.         }
     
145. 
     
146.         std::string binary_integer_part = IntegerPartToBinaryString(integer_part, 0);
     
147.         std::string binary_decimal_part = DecimalPartToBinaryString(decimal_part, 23 - (binary_integer_part.size() - 1));
     
148. 
     
149.         std::string exponent;
     
150.         if(binary_integer_part == "0")
     
151.                 exponent = GetExponent(binary_integer_part.size() - 1, false);        // 非正规化
     
152.         else
     
153.                 exponent = GetExponent(binary_integer_part.size() - 1, true);        // 正规化
     
154.         std::string fraction = GetFraction(binary_integer_part, binary_decimal_part);
     
155.         return MakeFloat(num[0] == '-', exponent, fraction);
     
156. }
     
157. 
     
158. int main()
     
159. {
     
160.         float num;
     
161. 
     
162.         std::cout << std::hex << std::uppercase;
     
163. 
     
164.         num = 3.14F;
     
165.         std::cout << *(uint32_t *)&num << " -> " << ParseFloat("3.14") << std::endl;
     
166. 
     
167.         num = 1234.0F;
     
168.         std::cout << *(uint32_t *)&num << " -> " << ParseFloat("1234") << std::endl;
     
169. 
     
170.         num = 3.1415926F;
     
171.         std::cout << *(uint32_t *)&num << " -> " << ParseFloat("3.1415926") << std::endl;
     
172. 
     
173.         num = 0.0F;
     
174.         std::cout << *(uint32_t *)&num << " -> " << ParseFloat("0") << std::endl;
     
175. 
     
176.         num = 0.005F;
     
177.         std::cout << *(uint32_t *)&num << " -> " << ParseFloat("0.005") << std::endl;
     
178. 
     
179.         return 0;
     
180. }
     

复制代码

人造人

https://www.jianshu.com/p/e5d72d764f2f
为什么一到IEEE 754这里就变成了  真值+2^n次方-1   这个-1是哪里来的？？
因为要把 0000 0000 和 1111 1111 留出来给 “非正规化”
加127正好把这个数（正数）向上偏移了 “一半”，如果是负数，那就向下偏移
从中间向两边偏移，把两个极限值 0000 0000 和 1111 1111 留出来用于“非正规化”表示


更正：0000 0000用于“非正规化”，1111 1111用于Inf和NaN

人造人

隐含位的问题，这是IEEE754规定的是吧，是为了让尾数的精度能提高一些吗？
可以这么说，因为这个隐含位要么恒为1，要么恒为0，没有必要存储这一位，至于是恒为1，还是恒为0，取决于是“正规化”还是“非正规化”

人造人

差点忘了这个
这个是写上面那两个程序时的中间数据，也许有参考价值

1. 0.14 * 2 = 0.28                0
   
2. 0.28 * 2 = 0.56                0
   
3. 0.56 * 2 = 1.12                1
   
4. 0.12 * 2 = 0.24                0
   
5. 0.24 * 2 = 0.48                0
   
6. 0.48 * 2 = 0.96                0
   
7. 0.96 * 2 = 1.92                1
   
8. 0.92 * 2 = 1.84                1
   
9. 0.84 * 2 = 1.68                1
   
10. 0.68 * 2 = 1.36                1
    
11. 0.36 * 2 = 0.72                0
    
12. 0.72 * 2 = 1.44                1
    
13. 0.44 * 2 = 0.88                0
    
14. 0.88 * 2 = 1.76                1
    
15. 0.76 * 2 = 1.52                1
    
16. 0.52 * 2 = 1.04                1
    
17. 0.04 * 2 = 0.08                0
    
18. 0.08 * 2 = 0.16                0
    
19. 0.16 * 2 = 0.32                0
    
20. 
    
21. 
    
22. 
    
23. #include <stdio.h>
    
24. 
    
25. int main()
    
26. {
    
27.         double num = 0.14;
    
28. 
    
29.         for(size_t i = 0; i < 32; ++i)
    
30.         {
    
31.                 printf("%.4f * 2 = %.4f\t%d\n", num, num * 2, (num * 2 > 1) ? 1 : 0);
    
32.                 num *= 2;
    
33.                 if(num > 1)
    
34.                         num -= 1;
    
35.         }
    
36. 
    
37.         return 0;
    
38. }
    
39. 
    
40. 0.1400 * 2 = 0.2800     0
    
41. 0.2800 * 2 = 0.5600     0
    
42. 0.5600 * 2 = 1.1200     1
    
43. 0.1200 * 2 = 0.2400     0
    
44. 0.2400 * 2 = 0.4800     0
    
45. 0.4800 * 2 = 0.9600     0
    
46. 0.9600 * 2 = 1.9200     1
    
47. 0.9200 * 2 = 1.8400     1
    
48. 0.8400 * 2 = 1.6800     1
    
49. 0.6800 * 2 = 1.3600     1
    
50. 0.3600 * 2 = 0.7200     0
    
51. 0.7200 * 2 = 1.4400     1
    
52. 0.4400 * 2 = 0.8800     0
    
53. 0.8800 * 2 = 1.7600     1
    
54. 0.7600 * 2 = 1.5200     1
    
55. 0.5200 * 2 = 1.0400     1
    
56. 0.0400 * 2 = 0.0800     0
    
57. 0.0800 * 2 = 0.1600     0
    
58. 0.1600 * 2 = 0.3200     0
    
59. 0.3200 * 2 = 0.6400     0
    
60. 0.6400 * 2 = 1.2800     1
    
61. 0.2800 * 2 = 0.5600     0
    
62. 0.5600 * 2 = 1.1200     1
    
63. 0.1200 * 2 = 0.2400     0
    
64. 0.2400 * 2 = 0.4800     0
    
65. 0.4800 * 2 = 0.9600     0
    
66. 0.9600 * 2 = 1.9200     1
    
67. 0.9200 * 2 = 1.8400     1
    
68. 0.8400 * 2 = 1.6800     1
    
69. 0.6800 * 2 = 1.3600     1
    
70. 0.3600 * 2 = 0.7200     0
    
71. 0.7200 * 2 = 1.4400     1
    
72. 请按任意键继续. . .
    
73. 
    
74. 
    
75. 1 0 -1  -2  -3  -4  -5  -6  -7  -8  -9 -10 -11 -12 -13 -14 -15 -16 -17 -18 -19 -20 -21 -22
    
76. 1 1. 0   0   1   0   0   0   1   1   1   1   0   1   0   1   1   1   0   0   0   0   1   1
    
77. 
    
78. 2^-3 + 2^-7 + 2^-8 + 2^-9 + 2^-10 + 2^-12 + 2^-14 + 2^-15 + 2^-16 + 2^-21 + 2^-22
    
79. 
    
80. 2^-1 = 0.5
    
81. 2^-2 = 0.25
    
82. 2^-3 = 0.125
    
83. 2^-4 = 0.0625
    
84. 2^-5 = 0.03125
    
85. 2^-6 = 0.015625
    
86. 
    
87. 
    
88. 
    
89. #include <stdio.h>
    
90. #include <math.h>
    
91. 
    
92. int main()
    
93. {
    
94.         char format[64];
    
95.         for(int i = 1; i <= 32; ++i)
    
96.         {
    
97.                 sprintf(format, "2^-%d = %%.%dlf\n", i, i);
    
98.                 printf(format, pow(2, -i));
    
99.         }
    
100. 
     
101.         return 0;
     
102. }
     
103. 
     
104. 
     
105. 1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22
     
106. 0  0  1  0  0  0  1  1  1  1  0  1  0  1  1  1  0  0  0  0  1  1
     
107. 
     
108. 2^-1 = 0.5
     
109. 2^-2 = 0.25
     
110. 2^-3 = 0.125
     
111. 2^-4 = 0.0625
     
112. 2^-5 = 0.03125
     
113. 2^-6 = 0.015625
     
114. 2^-7 = 0.0078125
     
115. 2^-8 = 0.00390625
     
116. 2^-9 = 0.001953125
     
117. 2^-10 = 0.0009765625
     
118. 2^-11 = 0.00048828125
     
119. 2^-12 = 0.000244140625
     
120. 2^-13 = 0.0001220703125
     
121. 2^-14 = 0.00006103515625
     
122. 2^-15 = 0.000030517578125
     
123. 2^-16 = 0.0000152587890625
     
124. 2^-17 = 0.00000762939453125
     
125. 2^-18 = 0.000003814697265625
     
126. 2^-19 = 0.0000019073486328125
     
127. 2^-20 = 0.00000095367431640625
     
128. 2^-21 = 0.000000476837158203125
     
129. 2^-22 = 0.0000002384185791015625
     
130. 2^-23 = 0.00000011920928955078125
     
131. 2^-24 = 0.000000059604644775390625
     
132. 2^-25 = 0.0000000298023223876953125
     
133. 2^-26 = 0.00000001490116119384765625
     
134. 2^-27 = 0.000000007450580596923828125
     
135. 2^-28 = 0.0000000037252902984619140625
     
136. 2^-29 = 0.00000000186264514923095703125
     
137. 2^-30 = 0.000000000931322574615478515625
     
138. 2^-31 = 0.0000000004656612873077392578125
     
139. 2^-32 = 0.00000000023283064365386962890625
     
140. 请按任意键继续. . .
     
141. 
     
142. 
     
143. 
     
144. 
     
145. 
     
146. 
     
147. 
     
148. 
     
149. 0.0000000101000111101011100001010
     
150. 
     
151. 
     
152. 
     
153. 
     
154. 
     
155. *************************************************************
     
156. 
     
157. 
     
158. 0.005
     
159. 005
     
160. 
     
161. 1005
     
162. 
     
163. 
     
164. 
     
165. 
     

复制代码

彭尼玛

人造人 发表于 2018-12-22 12:47
https://www.jianshu.com/p/e5d72d764f2f
为什么一到IEEE 754这里就变成了  真值+2^n次方-1   这个-1是哪 ...

谢谢，超感动QAQ，没想到仁兄还记得这个QAQ，哇，最近比较少登入鱼C，一上来就好感动，QAQ

人造人

彭尼玛 发表于 2018-12-28 11:05
谢谢，超感动QAQ，没想到仁兄还记得这个QAQ，哇，最近比较少登入鱼C，一上来就好感动，QAQ

当然记得
^_^

千锦襄

刚入门中