大家有好的二进制算法吗?这个是想当然的做法,不理想.都来看看吧,欢迎指导

howzyao

1. #include <iostream>
   
2. #include <math.h>
   
3. #include <stdio.h>
   
4. #include <conio.h>
   
5. using namespace std;
   
6. const int max_bit = 15;
   
7. void input_num(int);
   
8. void process_single(int*,int*,int);
   
9. void process_double(int*,int*,int);
   
10. 
    
11. int main()
    
12. {
    
13.     cout << "Hello world!" << endl;
    
14.     int x=0;
    
15. 
    
16.     while(1)
    
17.     {
    
18.         cout<<"-----------------------------------begin"<<endl;
    
19.     cout << "( x<=32767 ) 输入正数 x:   ";
    
20.     cin>>x;
    
21.     input_num(x);//max 32767
    
22. 
    
23.     }
    
24. 
    
25.     return 0;
    
26. }
    
27. 
    
28. void input_num(int x)
    
29. {
    
30.     int bits_value[ max_bit ];
    
31.     int num_bit_save[max_bit];
    
32.     for(int i=0;i<max_bit;i++)
    
33.     {
    
34.         num_bit_save[i]=0;
    
35.         bits_value[i] = pow(2,i);
    
36.     }
    
37.     int max_num=0;
    
38.     for(int i=0;i<max_bit;i++)
    
39.     {
    
40.         max_num += bits_value[i];
    
41.     }
    
42. 
    
43.     int tempx=0;
    
44. 
    
45.     if(x<max_num+1)
    
46.     {
    
47.         tempx=x;
    
48.         cout<<"输入的是: "<<tempx <<" (最大数: 32767)"<<endl;
    
49.     }
    
50.     else
    
51.     {
    
52.         cout<<"输入的是: "<<x<<" (最大数: 32767) 超过取值上限"<<endl;
    
53.     }
    
54. 
    
55.     int sum=0;
    
56.     for(int i=0;i<max_bit;i++)
    
57.     {
    
58.         if(tempx==0)
    
59.         {
    
60.             break;
    
61.         }
    
62.         else if(tempx==bits_value[max_bit])
    
63.         {
    
64.             tempx -= bits_value[ max_bit ];
    
65.             num_bit_save[max_bit-1]=1;
    
66.             break;
    
67.         }
    
68.         else if(tempx >0 && tempx <bits_value[max_bit])// 处理1~32766
    
69.         {
    
70.             if(tempx%2==0)
    
71.             {
    
72.                 for(int j=0;j<max_bit; j++)
    
73.                 {
    
74.                     process_double(bits_value,num_bit_save,tempx);
    
75.                     break; //跳出所有if 偶数 总是少1 未解决
    
76.                 }
    
77.             }
    
78.             else if(tempx%2==1)
    
79.             {
    
80.                 for(int j=0;j<max_bit; j++)
    
81.                 {
    
82.                     process_single(bits_value,num_bit_save,tempx);
    
83.                     break; //跳出所有if 奇数 done by 20220924
    
84.                 }
    
85.             }
    
86.         }
    
87.         break;//跳出for
    
88. 
    
89.     }
    
90. 
    
91.     int save=0;
    
92.     cout<<"2进制数 == ";
    
93.     for(int i=max_bit;i>-1;i--)
    
94.     {
    
95.         num_bit_save[max_bit]=0;
    
96.         cout<<num_bit_save[i];
    
97.         if(i%2==0)
    
98.             cout<<" ";
    
99. 
    
100.     }
     
101.     cout<<"\n-----------------------------------end\n\n"<<endl;
     
102. 
     
103.     delete bits_value,num_bit_save;
     
104. }
     
105. void process_double(int*bitsv,int*bsv,int n)
     
106. {
     
107.     int t=n;
     
108.     int i=max_bit;
     
109. 
     
110.     int record_bit=0; //记录少1时,2进制数的最高位位数
     
111.     int switchs=1;
     
112. 
     
113. 
     
114.     while(t>-1)  //2~32766 必然是偶数
     
115.     {
     
116.         if(t>bitsv[i] && switchs)
     
117.         {
     
118.             record_bit=i; //记录需要进1时,二进制所处的最高位 位置
     
119.             switchs=0;
     
120.         }
     
121. 
     
122. 
     
123.         if(t>bitsv[i])
     
124.         {
     
125. 
     
126.             t -= bitsv[i]; //2~32766 必然是偶数
     
127. 
     
128.             bsv[i]=1;
     
129. 
     
130.         }
     
131. 
     
132. 
     
133.         if( t<2 )
     
134.         {
     
135.             //bsv[0]=0;   //2进制 第0位 设为0 因为 2~32766 必然是偶数
     
136.             //bsv[0]=0;
     
137.             t=-1;        //结束处理
     
138.         }
     
139. 
     
140.         if( t==2 )
     
141.         {
     
142.             //t=-1;
     
143.             //bsv[0]=0;
     
144.             //bsv[1]=1;
     
145.             //最高位进位怎么办
     
146.             //最高位记录是record_bit
     
147.         }
     
148. 
     
149.         i--; //从15位到1位倒序遍历
     
150.     }
     
151. 
     
152.     //总是少一个
     
153.     int choice=0;
     
154.     for(int j=0;j<max_bit;j++)
     
155.     {
     
156.         if(bsv[j]==1)
     
157.         choice += bitsv[j];
     
158.     }
     
159.     cout<<"偶数算少了1 x-1 == "<<choice<<"    最高位="<<record_bit+1
     
160.     <<" ***偶数进位算法未解决*** "<<endl;
     
161. }
     
162. 
     
163. 
     
164. void process_single(int*bitsv,int*bsv,int n)
     
165. {
     
166.     int t=n;
     
167.     int i=max_bit;
     
168.     while(t>0) // 1~32766 必然是奇数
     
169.     {
     
170.         if(t>bitsv[i]) //从最高位 开始 找
     
171.         {
     
172.             t -= bitsv[i]; //1~32766 必然是奇数 减去 当前位的值
     
173.                            //进入低1位的检查
     
174. 
     
175.             bsv[i]=1;     //设置2进制位
     
176.         }
     
177. 
     
178.         if(t==1) //到达 最低位 需要结束
     
179.         {
     
180.             bsv[0]=1;   //2进制 最低位 设为1 因为 1~32766 必然是奇数
     
181.             t=0;        //结束处理
     
182.         }
     
183. 
     
184.         i--; //从15位到1位倒序遍历
     
185.     }
     
186. }
     
187. 
     

复制代码

人造人

一般我会这样写

1. #include <iostream>
   
2. #include <string>
   
3. #include <cstdint>
   
4. 
   
5. using std::cin, std::cout, std::endl;
   
6. using std::string;
   
7. 
   
8. const string binary(uint32_t value) {
   
9.     string result;
   
10.     for(uint32_t mask = 0x80000000; mask != 0; mask >>= 1) {
    
11.         result.append(value & mask ? "1" : "0");
    
12.     }
    
13.     return result;
    
14. }
    
15. 
    
16. int main() {
    
17.     cout << binary(100) << endl;
    
18.     return 0;
    
19. }
    

复制代码

人造人

1. #include <iostream>
   
2. #include <string>
   
3. #include <cstdint>
   
4. 
   
5. using std::cin, std::cout, std::endl;
   
6. using std::string;
   
7. 
   
8. const string binary(uint32_t value) {
   
9.     string result;
   
10.     for(uint32_t mask = 0x80000000; mask != 0; mask >>= 1) {
    
11.         result.append(value & mask ? "1" : "0");
    
12.     }
    
13.     return result;
    
14. }
    
15. 
    
16. const string format(const string &s) {
    
17.     string result;
    
18.     bool flag = false;
    
19.     for(size_t i = 0; i < s.size(); ++i) {
    
20.         if(flag && i % 2 == 0) result += ' ';
    
21.         result += s[i];
    
22.         flag = true;
    
23.     }
    
24.     return result;
    
25. }
    
26. 
    
27. int main() {
    
28.     cout << format(binary(100)) << endl;
    
29.     return 0;
    
30. }
    

复制代码

howzyao

uint32_t mask = 0x80000000;
mask != 0;
mask >>= 1
这个for，是我孤陋寡闻了。
猜测是定义一个变量，
还能直接赋值地址，
也许是立即数的那种概念的数吧，
变量还能使用操作数，
也许这是一个对象吧？
const string binary(uint32_t value)
这个函数，也是超出了想象，
value类型也是这个32的吗？
32怎能如此牛叉？

size_t i = 0; i < s.size(); ++i
这个t类型的i是什么i
二进制返回字符串。
s提供size方法。
单个字符来
＋等
还能赋值空格。。。。
感觉完全需要补课，
你这吗容易，行数少，
但需要的前提估计也不少。

谢谢回复，使我再教育，感谢感谢。

howzyao

result.append(value & mask ? "1" : "0");
这像声明，却是实参。
第一次看到这个string的方法，
而且参数操作符的使用也是第一次看到，
我得一段时间去查资料了，谢谢啊

howzyao

string::append
查了，原来是字符串后面能连续追加另一个字符串

howzyao

str3="print 10 and then 5 more";

str.append(str3.begin()+8,
这里的开始，是不是指字符p，算0个，然后
从r数成1
+8个到
10后面的空字符，正好8？

howzyao

参数1 字符串对象使用迭代器指定开始的位置，
参数2 也是对象使用迭代器指定结束的位置。
这让我想起了vector

howzyao

明天上机，实验一把append，看来很好玩的样子
只是，明明是处理字符的，怎么联系起来处理了数字呢？
楼上朋友能指点一二吗。

howzyao

result.append(value & mask ? "1" : "0");
这个是不是实际就使用了1个参数
这个参数是字符，追加到结果里面，再返回这个结果

howzyao

uint32_t mask = 0x80000000;
mask != 0;
mask >>= 1
这个，有80%的可能性正是我考虑如何解决
2进制进位难题的方法。。。

howzyao

掩码不为0，这个32类型的“掩码”向右移动1位。。。
这个掩码，做何解呢？

howzyao

100，作为了32类型的参数，
这里是不是有什么玄学？
100的2进制立即数，作为字符，
拿进去遍历，转换吗？

howzyao

看了专业的32类型的使用，我决定，
明天去搞清楚这个类型到底是怎么一回事。
我为我的写法感到内疚。原谅我的技术，我还以为我很有想法，结果做了一个臃肿的半成品。