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

howzyao

#include <iostream>
#include <math.h>
#include <stdio.h>
#include <conio.h>
using namespace std;
const int max_bit = 15;
void input_num(int);
void process_single(int*,int*,int);
void process_double(int*,int*,int);

int main()
{
    cout << "Hello world!" << endl;
    int x=0;

    while(1)
    {
        cout<<"-----------------------------------begin"<<endl;
    cout << "( x<=32767 ) 输入正数 x:   ";
    cin>>x;
    input_num(x);//max 32767

    }

    return 0;
}

void input_num(int x)
{
    int bits_value[ max_bit ];
    int num_bit_save[max_bit];
    for(int i=0;i<max_bit;i++)
    {
        num_bit_save[i]=0;
        bits_value[i] = pow(2,i);
    }
    int max_num=0;
    for(int i=0;i<max_bit;i++)
    {
        max_num += bits_value[i];
    }

    int tempx=0;

    if(x<max_num+1)
    {
        tempx=x;
        cout<<"输入的是: "<<tempx <<" (最大数: 32767)"<<endl;
    }
    else
    {
        cout<<"输入的是: "<<x<<" (最大数: 32767) 超过取值上限"<<endl;
    }

    int sum=0;
    for(int i=0;i<max_bit;i++)
    {
        if(tempx==0)
        {
            break;
        }
        else if(tempx==bits_value[max_bit])
        {
            tempx -= bits_value[ max_bit ];
            num_bit_save[max_bit-1]=1;
            break;
        }
        else if(tempx >0 && tempx <bits_value[max_bit])// 处理1~32766
        {
            if(tempx%2==0)
            {
                for(int j=0;j<max_bit; j++)
                {
                    process_double(bits_value,num_bit_save,tempx);
                    break; //跳出所有if 偶数 总是少1 未解决
                }
            }
            else if(tempx%2==1)
            {
                for(int j=0;j<max_bit; j++)
                {
                    process_single(bits_value,num_bit_save,tempx);
                    break; //跳出所有if 奇数 done by 20220924
                }
            }
        }
        break;//跳出for

    }

    int save=0;
    cout<<"2进制数 == ";
    for(int i=max_bit;i>-1;i--)
    {
        num_bit_save[max_bit]=0;
        cout<<num_bit_save[i];
        if(i%2==0)
            cout<<" ";

    }
    cout<<"\n-----------------------------------end\n\n"<<endl;

    delete bits_value,num_bit_save;
}
void process_double(int*bitsv,int*bsv,int n)
{
    int t=n;
    int i=max_bit;

    int record_bit=0; //记录少1时,2进制数的最高位位数
    int switchs=1;


    while(t>-1)  //2~32766 必然是偶数
    {
        if(t>bitsv[i] && switchs)
        {
            record_bit=i; //记录需要进1时,二进制所处的最高位 位置
            switchs=0;
        }


        if(t>bitsv[i])
        {

            t -= bitsv[i]; //2~32766 必然是偶数

            bsv[i]=1;

        }


        if( t<2 )
        {
            //bsv[0]=0;   //2进制 第0位 设为0 因为 2~32766 必然是偶数
            //bsv[0]=0;
            t=-1;        //结束处理
        }

        if( t==2 )
        {
            //t=-1;
            //bsv[0]=0;
            //bsv[1]=1;
            //最高位进位怎么办
            //最高位记录是record_bit
        }

        i--; //从15位到1位倒序遍历
    }

    //总是少一个
    int choice=0;
    for(int j=0;j<max_bit;j++)
    {
        if(bsv[j]==1)
        choice += bitsv[j];
    }
    cout<<"偶数算少了1 x-1 == "<<choice<<"    最高位="<<record_bit+1
    <<" ***偶数进位算法未解决*** "<<endl;
}


void process_single(int*bitsv,int*bsv,int n)
{
    int t=n;
    int i=max_bit;
    while(t>0) // 1~32766 必然是奇数
    {
        if(t>bitsv[i]) //从最高位 开始 找
        {
            t -= bitsv[i]; //1~32766 必然是奇数 减去 当前位的值
                           //进入低1位的检查

            bsv[i]=1;     //设置2进制位
        }

        if(t==1) //到达 最低位 需要结束
        {
            bsv[0]=1;   //2进制 最低位 设为1 因为 1~32766 必然是奇数
            t=0;        //结束处理
        }

        i--; //从15位到1位倒序遍历
    }
}

人造人

一般我会这样写

#include <iostream>
#include <string>
#include <cstdint>

using std::cin, std::cout, std::endl;
using std::string;

const string binary(uint32_t value) {
    string result;
    for(uint32_t mask = 0x80000000; mask != 0; mask >>= 1) {
        result.append(value & mask ? "1" : "0");
    }
    return result;
}

int main() {
    cout << binary(100) << endl;
    return 0;
}

人造人

#include <iostream>
#include <string>
#include <cstdint>

using std::cin, std::cout, std::endl;
using std::string;

const string binary(uint32_t value) {
    string result;
    for(uint32_t mask = 0x80000000; mask != 0; mask >>= 1) {
        result.append(value & mask ? "1" : "0");
    }
    return result;
}

const string format(const string &s) {
    string result;
    bool flag = false;
    for(size_t i = 0; i < s.size(); ++i) {
        if(flag && i % 2 == 0) result += ' ';
        result += s[i];
        flag = true;
    }
    return result;
}

int main() {
    cout << format(binary(100)) << endl;
    return 0;
}

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