精华内容
下载资源
问答
  •   在计算机中,补码可谓是十分神奇而又重要存在,我们知道整数在计算机内部机器一般都是补码表示的,这里给出几个这样表示的好处: 符号可以和数值为一起参加运算,比如俩个负数相加,只要结果在范围内...

    为什么计算机中的整数要用补码表示?补码表示有什么好处?

      在计算机中,补码可谓是十分神奇而又重要的存在,我们知道整数在计算机内部的机器数一般都是补码表示的,这里给出几个这样表示的好处:

    • 符号位可以和数值为一起参加运算,比如俩个负数相加,只要结果在范围内,则可直接按位相加,这是原码做不到的(原码符号位相加会出错)。
    • 由于其模运算的特性,补码可以直接利用加法的形式计算整数间的减法,既省时又省力。
    • 在原码中,-0和+0都存在,而补码的表示则确保了0的唯一值,即00000…00。
    • 既然0唯一确定了,那么我们便多出了一个10000…00,以此表示最小负数,这样就比原码多了一个负数。
    展开全文
  • X进制就是没有以X为进位之所以难理解是,因为我们下意识的什么数字都往10进制转。转换找一个规律就简单:10进制转2进制1、比如10进制是以10倍数来记忆数字,看到一个数字自然而然就用10倍数来区分数字。10-》...

    刚刚开始理解进制确实有些困难。 因为自我们打小起一切思维就是以10进制为基础思考的。

    但是,理解了原理,搞起来是很容易的。   X进制就是没有以X为进位

    之所以难理解是,因为我们下意识的什么数字都往10进制转。

    转换找一个规律就简单:

    10进制转2进制

    1、比如10进制是以10的倍数来记忆数字的,看到一个数字自然而然就用10的倍数来区分数字。10-》100-》1000-》10000

    2、2进制是以2的倍数来记忆数字,2,4,8,16,32,64,128,256,512,1024.....

    3、看到一个10进制的数字,就是看看比第二条所提的数字是否最大。比如300转2进制,显然,256是小于300的。1个256,剩下44比32大,那就是1个32,剩下12,比8大,1个8,剩下4恰好剩下一个4. 对照下表填写数字

    256 |  128 | 64 | 32 | 16 | 8 | 4 | 2 | 1

    1       0     0     1      0   1   1   0    0

    这就是结果。

    2进制转10进制

    类同上表,倒过来计算:

    256 |  128 | 64 | 32 | 16 | 8 | 4 | 2 | 1

    0       1     0     1      1   1   0   1    0

    2+8+16 + 32 + 128 = 186

    就这么简单

    展开全文
  • f表示的满足条件电话号码,定义状态7维f[ff][i][j][f1][f2][f3][l] //是否比n小 当前是第几 几个连续 是否3个连续 是否有8 是否有4 当前选择数字是什么状态转移十分复杂(写着复杂),但是思维

    题目描述

    这里写图片描述

    分析

    这题的要求的是组成该数的数字满足一些条件的数,并且看数据范围,果断锁定数位DP。
    考场上我写记忆化搜索的把自己搞晕了,然后果断改写递推版。
    f表示<=n的满足条件的电话号码,定义状态7维

    f[ff][i][j][f1][f2][f3][l]  //是否比n小  当前是第几位  几个连续  是否3个连续   是否有8  是否有4 当前选择的数字是什么

    状态转移十分复杂(写着复杂),但是思维难度不大,只要有耐心就能写对。
    具体方程看我的代码。

    ans=cal(r)cal(l1)

    代码

    #include<cstdio>
    #include<algorithm>
    #include<cstring>
    using namespace std;
    typedef long long LL;
    LL f[2][20][5][2][2][2][10];  //第几位  几个连续  是否3个连续   8  4
    LL l,r;
    int d[20],len;
    template<class T>
    void Read(T &x){
        char c;
        while(c=getchar(),c!=EOF)
            if(c>='0'&&c<='9'){
                x=c-'0';
                while(c=getchar(),c>='0'&&c<='9')
                    x=x*10+c-'0';
                ungetc(c,stdin);
                return;
            }
    }/*
    LL dfs(int i,int j,bool tr,bool et,bool fu,int d,bool ff){
        if(et&&fu)
            return 0;
        if(!i){
        }
        if(!ff&&~f[i][j][tr][et][fu])
            return f[i][j][tr][et][fu];
        LL ret=0;
        int j,mx=ff?d[i-1]:9;
        if(d==8)
            if(j==2){
                ret=dfs(i-1,j-1,tr,et,fu,8,0);
            }
    }*/
    void dp(){
        int i,j,k,l;
        for(i=0;i<=9;i++){
            if(i==8)
                f[0][0][0][0][1][0][i]=f[1][0][0][0][1][0][i]=1;
            else if(i==4)
                f[0][0][0][0][0][1][i]=f[1][0][0][0][0][1][i]=1;
            else
                f[0][0][0][0][0][0][i]=f[1][0][0][0][0][0][i]=1;
        }     //第几位  几个连续  是否3个连续   8  4
        for(i=1;i<=len;i++){
            for(j=0;j<=9;j++){
                for(k=0;k<=9;k++)
                    if(j!=k){
                        if(j==8){
                            for(l=1;l<=2;l++)
                                f[0][i][1][0][1][0][j]+=f[0][i-1][l][0][0][0][k]+f[0][i-1][l][0][1][0][k];
                            f[0][i][0][1][1][0][j]+=f[0][i-1][0][1][1][0][k]+f[0][i-1][0][1][0][0][k];
                        }
                        else if(j==4){
                            for(l=1;l<=2;l++)
                                f[0][i][1][0][0][1][j]+=f[0][i-1][l][0][0][1][k]+f[0][i-1][l][0][0][0][k];
                            f[0][i][0][1][0][1][j]+=f[0][i-1][0][1][0][1][k]+f[0][i-1][0][1][0][0][k];  
                        }
                        else{
                            for(l=1;l<=2;l++){
                                f[0][i][1][0][1][0][j]+=f[0][i-1][l][0][1][0][k];
                                f[0][i][1][0][0][1][j]+=f[0][i-1][l][0][0][1][k];
                                f[0][i][1][0][0][0][j]+=f[0][i-1][l][0][0][0][k];
                            }
                            f[0][i][0][1][1][0][j]+=f[0][i-1][0][1][1][0][k];
                            f[0][i][0][1][0][1][j]+=f[0][i-1][0][1][0][1][k];
                            f[0][i][0][1][0][0][j]+=f[0][i-1][0][1][0][0][k];
                        }
                    }
                    else{
                        if(j==8){
                            for(l=1;l<=2;l++)
                                f[0][i][l][0][1][0][j]+=f[0][i-1][l-1][0][1][0][j];
                            f[0][i][0][1][1][0][j]+=f[0][i-1][0][1][1][0][j]+f[0][i-1][2][0][1][0][j];
                        }
                        else if(j==4){
                            for(l=1;l<=2;l++)
                                f[0][i][l][0][0][1][j]+=f[0][i-1][l-1][0][0][1][j];
                            f[0][i][0][1][0][1][j]+=f[0][i-1][0][1][0][1][j]+f[0][i-1][2][0][0][1][j];
                        }
                        else{
                            for(l=1;l<=2;l++){
                                f[0][i][l][0][1][0][j]+=f[0][i-1][l-1][0][1][0][j];
                                f[0][i][l][0][0][1][j]+=f[0][i-1][l-1][0][0][1][j];
                                f[0][i][l][0][0][0][j]+=f[0][i-1][l-1][0][0][0][j];
                            }
                            f[0][i][0][1][1][0][j]+=f[0][i-1][0][1][1][0][j]+f[0][i-1][2][0][1][0][j];
                            f[0][i][0][1][0][1][j]+=f[0][i-1][0][1][0][1][j]+f[0][i-1][2][0][0][1][j];
                            f[0][i][0][1][0][0][j]+=f[0][i-1][0][1][0][0][j]+f[0][i-1][2][0][0][0][j];
                        }
                    }
            }
            j=d[i];
            for(k=0;k<d[i-1];k++){
                if(d[i]!=k){
                    if(d[i]==8){
                        for(l=1;l<=2;l++)
                            f[1][i][1][0][1][0][d[i]]+=f[0][i-1][l][0][1][0][k]+f[0][i-1][l][0][0][0][k];
                        f[1][i][0][1][1][0][d[i]]+=f[0][i-1][0][1][1][0][k]+f[0][i-1][0][1][0][0][k];
                    }
                    else if(d[i]==4){
                        for(l=1;l<=2;l++)
                            f[1][i][1][0][0][1][d[i]]+=f[0][i-1][l][0][0][1][k]+f[0][i-1][l][0][0][0][k];
                        f[1][i][0][1][0][1][d[i]]+=f[0][i-1][0][1][0][1][k]+f[0][i-1][0][1][0][0][k];
                    }
                    else{
                        for(l=1;l<=2;l++){
                            f[1][i][1][0][0][1][d[i]]+=f[0][i-1][l][0][0][1][k];
                            f[1][i][1][0][1][0][d[i]]+=f[0][i-1][l][0][1][0][k];
                            f[1][i][1][0][0][0][d[i]]+=f[0][i-1][l][0][0][0][k];
                        }
                        f[1][i][0][1][0][1][d[i]]+=f[0][i-1][0][1][0][1][k];
                        f[1][i][0][1][1][0][d[i]]+=f[0][i-1][0][1][1][0][k];
                        f[1][i][0][1][0][0][d[i]]+=f[0][i-1][0][1][0][0][k];
                    }
                }
                else{
                    if(d[i]==8){
                        for(l=1;l<=2;l++)
                            f[1][i][l][0][1][0][j]+=f[0][i-1][l-1][0][1][0][j];
                        f[1][i][0][1][1][0][j]+=f[0][i-1][0][1][1][0][d[i]]+f[0][i-1][2][0][1][0][d[i]];
                    }
                    else if(d[i]==4){
                        for(l=1;l<=2;l++)
                            f[1][i][l][0][0][1][j]+=f[0][i-1][l-1][0][0][1][j];
                        f[1][i][0][1][0][1][j]+=f[0][i-1][0][1][0][1][d[i]]+f[0][i-1][2][0][0][1][d[i]];
                    }
                    else{
                        for(l=1;l<=2;l++){
                            f[1][i][l][0][1][0][j]+=f[0][i-1][l-1][0][1][0][j];
                            f[1][i][l][0][0][1][j]+=f[0][i-1][l-1][0][0][1][j];
                            f[1][i][l][0][0][0][j]+=f[0][i-1][l-1][0][0][0][j];
                        }
                        f[1][i][0][1][1][0][j]+=f[0][i-1][0][1][1][0][d[i]]+f[0][i-1][2][0][1][0][d[i]];
                        f[1][i][0][1][0][1][j]+=f[0][i-1][0][1][0][1][d[i]]+f[0][i-1][2][0][0][1][d[i]];
                        f[1][i][0][1][0][0][j]+=f[0][i-1][0][1][0][0][d[i]]+f[0][i-1][2][0][0][0][d[i]];
                    }
                }
            }
            if(d[i]!=k){
                if(d[i]==8){
                    for(l=1;l<=2;l++)
                        f[1][i][1][0][1][0][d[i]]+=f[1][i-1][l][0][1][0][k]+f[1][i-1][l][0][0][0][k];
                    f[1][i][0][1][1][0][d[i]]+=f[1][i-1][0][1][1][0][k]+f[1][i-1][0][1][0][0][k];
                }
                else if(d[i]==4){
                    for(l=1;l<=2;l++)
                        f[1][i][1][0][0][1][d[i]]+=f[1][i-1][l][0][0][1][k]+f[1][i-1][l][0][0][0][k];
                    f[1][i][0][1][0][1][d[i]]+=f[1][i-1][0][1][0][1][k]+f[1][i-1][0][1][0][0][k];
                }
                else{
                    for(l=1;l<=2;l++){
                        f[1][i][1][0][0][1][d[i]]+=f[1][i-1][l][0][0][1][k];
                        f[1][i][1][0][1][0][d[i]]+=f[1][i-1][l][0][1][0][k];
                        f[1][i][1][0][0][0][d[i]]+=f[1][i-1][l][0][0][0][k];
                    }
                    f[1][i][0][1][0][1][d[i]]+=f[1][i-1][0][1][0][1][k];
                    f[1][i][0][1][1][0][d[i]]+=f[1][i-1][0][1][1][0][k];
                    f[1][i][0][1][0][0][d[i]]+=f[1][i-1][0][1][0][0][k];
                }
            }
            else{
                if(d[i]==8){
                    for(l=1;l<=2;l++)
                        f[1][i][l][0][1][0][d[i]]+=f[1][i-1][l-1][0][1][0][d[i]];
                    f[1][i][0][1][1][0][d[i]]+=f[1][i-1][0][1][1][0][d[i]]+f[1][i-1][2][0][1][0][d[i]];
                }
                else if(d[i]==4){
                    for(l=1;l<=2;l++)
                            f[1][i][l][0][0][1][d[i]]+=f[1][i-1][l-1][0][0][1][d[i]];
                    f[1][i][0][1][0][1][d[i]]+=f[1][i-1][0][1][0][1][d[i]]+f[1][i-1][2][0][0][1][d[i]];
                }
                else{
                    for(l=1;l<=2;l++){
                        f[1][i][l][0][1][0][d[i]]+=f[1][i-1][l-1][0][1][0][d[i]];
                        f[1][i][l][0][0][1][d[i]]+=f[1][i-1][l-1][0][0][1][d[i]];
                        f[1][i][l][0][0][0][d[i]]+=f[1][i-1][l-1][0][0][0][d[i]];
                    }
                    f[1][i][0][1][1][0][d[i]]+=f[1][i-1][0][1][1][0][d[i]]+f[1][i-1][2][0][1][0][d[i]];
                    f[1][i][0][1][0][1][d[i]]+=f[1][i-1][0][1][0][1][d[i]]+f[1][i-1][2][0][0][1][d[i]];
                    f[1][i][0][1][0][0][d[i]]+=f[1][i-1][0][1][0][0][d[i]]+f[1][i-1][2][0][0][0][d[i]];
                }
            }
        }
    }
    LL cal(LL n){
        len=0;
        LL ret=0;
        while(n){
            d[++len]=n%10;
            n/=10;
        }
        d[0]=9;
        if(len<11)
            d[++len]=0;
        memset(f,0,sizeof f);
        dp();
        for(int i=0;i<d[len];i++)
            ret+=f[0][len][0][1][0][0][i]+f[0][len][0][1][0][1][i]+f[0][len][0][1][1][0][i];
        ret+=f[1][len][0][1][0][0][d[len]]+f[1][len][0][1][0][1][d[len]]+f[1][len][0][1][1][0][d[len]];
        return ret;
    //  for(i=0;i<=mx;i++)
        //  return dfs(len,0,1,0,1,1)+dfs(len,0,1,1,0,1);
    }
    int main()
    {
        Read(l),Read(r);
        printf("%lld\n",cal(r)-cal(l-1));
    }
    展开全文
  • 它和ArrayList十分类似,可以动态调整大小,可以在需要时候添加二进制而不用担心数组越界问题。(所以本质它也是集合里套一个数组,可能是线性数组)什么集合?----集合是可以用来有效表示Boolean值集合...

    BitArray类用来处理位集合。

    它和ArrayList十分类似,可以动态调整大小,可以在需要的时候添加二进制位而不用担心数组越界的问题。(所以本质它也是集合里套一个数组,可能是线性数组)

    什么是位集合?

    ----位集合是可以用来有效表示Boolean值的集合。注意:表示True/False的集合,不是0、1集合。

    另:

    对常规数的二进制的显示或存储(如1):

    0 0 0 0 0 0 0 1

    而对于在BitArray里的存储,它是如下格式:

    True False False False False False False False

    它的顺序是相反的,而且用布尔值很难便捷读懂,但实际上,我们应当把数值当作1和0这样直观的显示出来,并且顺序也要进行处理!

    解决方法:

    BitArray里显示的格式是逆序的,并且每一位都用布尔值显示,我们无法改变BitArray类所用的内部代码,但我们可以编写外部代码,使它能够更加友好的便于理解的常规的方式显示出来。

    举例

    使用BitArray的其中一种构造方法:

    初始化 BitArray 的新实例,该实例包含从指定的字节数组复制的位值。位格式

    下面创建一个字节数组,里面包含5个字节型的数值:1和2和3和4和5

    1 usingSystem;2 usingSystem.Collections;3 usingSystem.Collections.Generic;4 usingSystem.Linq;5 usingSystem.Text;6 usingSystem.Threading.Tasks;7

    8 namespace二进制数9 {10 classBinNumber11 {12 static void Main(string[] args)13 {14 intbits;15 string[] binNumber = new string[8];//16 intbinary;17 byte[] ByteSet = new byte[] { 1, 2, 3, 4, 5 };//定义一个字节型数组,存5个字节型数值:1,2,3,4,5,6

    18 BitArray BitSet = new BitArray(ByteSet);//这里一定要注意,这里的每一个字节型数值是以位的形式、每一位用Boolean值、逆序存储在BitArray(1字节对应8位)19 bits = 0;//bits是计数器,到8了就又归为初始值0;为的是方便知道操作完了一个字节型数值(1字节正好占8位)

    20 binary = 7;//binary是二进制数组下标索引;初始值为7,这是因为BitArray里存储的数据和常规二进制数据的顺序是相反的

    21 Console.WriteLine("BitSet里包含的元素数"+BitSet.Count);//40,因为数据在BitArray里是以位的形式存储的,5个字节型数值,一个字节占8位,所以共占40位!!!不是5!!!22 for (int i = 0; i <= BitSet.Count - 1; i++)//遍历40个位,每个位存boolean值True/False

    23 {24 Console.WriteLine("BitSet.Get("+i+")" +BitSet.Get(i));25 if (BitSet.Get(i) == true)26 binNumber[binary] = "1";//如果该位存储的true值,则转成1;27 else

    28 binNumber[binary] = "0";//如果该位存储的false值,则转成0;29 bits++;      //计数+130 binary--;    //eg.第8位(下标7)存好,则将下标向左移1位存下一轮将位布尔值转成的二进制0/131

    32 if ((bits % 8) == 0)//当计数器为8时,表示一个字节型的数值已经表示完全了33 {34 binary = 7;//将存储字节型数值的二进制形式的String型数组的下标归初始35 bits = 0;36 for(int j=0;j<=7;j++)37 Console.Write(binNumber[j]);38 Console.WriteLine();39 }40 }41 Console.ReadKey();42 }43 }44 }

    利用Get方法 可以获取到存储在BitArray里的每一位的位值(True/False)。

    获取 BitArray 中特定位置处的位值。

    BitSet.Get(i):i是整型参数,该方法的返回值是该位所存储的True或False的位值!!!

    所以在获取到该位的位值时需要判断True or False,对True值就写入1,False值就写入0;这样就可以转换成常规的二进制形式0,1形式。

    上面代码的执行结果图

    29fbee66758d87b067069f3c3f1f3414.png

    其实用BitArray它已经把常规的数值按照二进制的位数存储,只是存的内容不是二进制的0,1;而是True ,False.要做的就是把顺序理好,把每一位的Boolean值改成0,1。

    ===========================================================================================================

    另:取整型数组来试一试,整型数组是4字节,32位

    usingSystem;usingSystem.Collections;usingSystem.Collections.Generic;usingSystem.Linq;usingSystem.Text;usingSystem.Threading.Tasks;namespaceConsoleApplication2

    {classProgram

    {static void Main(string[] args)

    {int bits = 0;int index = 31;string[] s = new string[32];int[] a = new int[] {2,3,2,7, 2147483647};

    BitArray BA= newBitArray(a);

    Console.WriteLine("BA的大小:" +BA.Count);for(int i=0;i

    {

    Boolean b=BA.Get(i);if (b == true)

    s[index]= "1";elses[index]= "0";

    bits++;

    index--;if (bits % 32 == 0)

    {

    bits= 0;

    index= 31;for (int j = 0; j <=31; j++)

    Console.Write(s[j]);

    Console.WriteLine();

    }

    }

    Console.ReadKey();

    }

    }

    }

    d1b48184a8f7c456f5b74d18e6f97de4.png

    附:BitArray相关API

    https://msdn.microsoft.com/zh-cn/library/system.collections.bitarray.aspx

    展开全文
  • 我们希望快速地找出链表位数节点mid。 为什么要设定「左闭右开」关系? 由于题目中给定链表为单向链表,访问后继元素十分容易,但无法直接访问前驱元素。因此在找出链表位数节点mid 之后,如果设定「...
  • 莱布尼茨(W.Leibniz)(1646~1716)是他那个时代...上帝从虚无中创造出所有实物,恰如在他的数学系统中用1和0表示了所有的数。”    上面这段话,摘自《什么是数学:对思想和方法的基本研究(增订版)》第一章中...
  • 什么是计算机存储单元?

    万次阅读 2007-11-07 12:19:00
    计算机信息存储单元的结构 数据必须首先在计算机内被...一"位"只能表示0和1中的一个,即一个二进制位,或存储一个二进制数位的单位。 (2)"字节"(Byte):是由相连8个位组成的信息存储单位。 字节是目前计算机最基本
  • 十进制:由 0~9 十个数字组成二进制:由 0和1 两个数字组成1、整数转换十进制转二进制的原理:十进制的数除以2,直到商为0,最后反向取余数。比如下图中的例子,十进制的13转为二进制表示,则为1101。十进制转二进制...
  • 十进制:由 0~9 十个数字组成二进制:由 0和1 两个数字组成1、整数转换十进制转二进制的原理:十进制的数除以2,直到商为0,最后反向取余数。比如下图中的例子,十进制的13转为二进制表示,则为1101。十进制转二进制...
  • 二进制补码和反码和...两个正数相加计算机来十分方便,但是如果是一个减去一个会有正负之分,此时要比较出绝对值最大那个,然后加上符号。这样子做也太麻烦了,会让计算机硬件消耗更多处理。 如果...
  • 首先我们得知道什么是摘要,摘要是指采用单向Hash函数对数据进行计算生成的固定长度的Hash值,摘要算法有Md5,Sha1等,Md5生成的Hash值是128位的数字,即16个字节,用十六进制表示是32个字符,Sha1生成的Hash值是160...
  • 什么是VLAN

    2013-10-23 09:59:12
    MAC地址由1216进制数表示,前6为网卡厂商标识(OUI),后6为网卡标识(NIC)。网络管理员可按MAC地址把一些站点划分为一个逻辑子网。 基于路由  路由协议工作在网络层,相应工作设备有路由器和路由交换机...
  • 一、概念 ❄ 什么是雪花算法 SnowFlake算法是Twitter公司出品的开源的分布式id生成算法 其特点为 使用一个64 bit的long型的...41位的长度可以表示2^41-1个毫秒值 也就是说可以使用69年 时间戳还有一个很重要的作用 可以
  • 什么又要用四二进制来表示呢? 一、BCD码 1.由来 计算机使用二进制来处理信息,但是如果二进制形式输入和输出数据,就十分不方便了。一般来说,输入输出时采用十进制。 举例: 明明二进制 0110 (B)代表...
  • 想一个问题:1/3+1/3+1/3=1.00.3+0.3+0.3 =0.9想一想在小数世界里要什么表示1/3呢!它办法就是取一个与1/3十分接近小数来代替;如上面例子中0.3来代替1/3;这样问题就来了存进去是3个1/3取出时就只有0.9。...
  • 我们都学过一个n二进制可以有2n2^n2n中可能的表示。 8bit是指声音每一个采样由8bit组成,也就是每个采样值有256种可能。 小时候老爸带我玩过一些游戏,比如我最喜欢魂斗罗、赤色要塞(KONAMI牛逼!!!) ...
  • 想一个问题: 1/3+1/3+1/3=1.0 0.3+0.3+0.3 =0.9 想一想在小数的世界里要什么表示1/3呢!它的办法就是取一个与1/3十分接近的小数来代替;如上面例子中的0.3来代替...在二进制的世界里0.1这样的数也不是可以精确的...
  • 你必须知道495个C语言问题

    千次下载 热门讨论 2015-05-08 11:09:25
    1.4 新64机上64类型是什么? 指针声明 1.5 这样声明有什么问题?char*p1,p2;我在使用p2时候报错了。 1.6 我想声明一个指针,并为它分配一些空间,但却不行。这样代码有什么问题?char*p;*p=...
  • 《你必须知道495个C语言问题》

    热门讨论 2010-03-20 16:41:18
    1.4 新64机上64类型是什么? 3 指针声明 3 1.5 这样声明有什么问题?char *p1, p2; 我在使用p2时候报错了。 3 1.6 我想声明一个指针,并为它分配一些空间,但却不行。这样代码有什么问题?...

空空如也

空空如也

1 2 3 4 5 ... 8
收藏数 149
精华内容 59
关键字:

十分位的数表示什么