精华内容
下载资源
问答
  • 颠倒二进制位数

    千次阅读 2019-08-10 17:37:22
    颠倒给定的 32 位无符号整数的二进制位。 示例 1: 输入: 00000010100101000001111010011100 输出: 00111001011110000010100101000000 解释: 输入的二进制串 00000010100101000001111010011100 表示无符号整数 ...

    颠倒给定的 32 位无符号整数的二进制位。

    示例 1:
    输入: 00000010100101000001111010011100
    输出: 00111001011110000010100101000000
    解释: 输入的二进制串 00000010100101000001111010011100 表示无符号整数 43261596,
    因此返回 964176192,其二进制表示形式为 00111001011110000010100101000000。

    示例 2:
    输入:11111111111111111111111111111101
    输出:10111111111111111111111111111111
    解释:输入的二进制串 11111111111111111111111111111101 表示无符号整数 4294967293,
    因此返回 3221225471 其二进制表示形式为 10101111110010110010011101101001。

    代码片.

    public class Solution {
        // you need treat n as an unsigned value
        public int reverseBits(int n) {
            //方法一:
            int sum=0;
            for(int i=0;i<32;i++){
               int num=n>>i;        //将第i位上的数放到最后一位,例如:110001向右位移一位得到011000;向右位移四位得到000011
               
               
               num &=1;             //得到最后一位的数,例如:0110000                     000011
                                                      //  & 0000001                   & 000001  //&按与运算
                                                      //    0000000//最后一位为0         000001//最后一位为1
    
    
               num<<=(31-i);        //左移31-i位,将数放到要求的位置, 例如:上面向右位移四位最后一位是1,它应该在翻转后数                                     //100011的倒数第二位
               
               
               sum|=num;             //将数累加,如:100010
                                               // |      1 //按或运算
                                               //   100011
                                          
           }
            return sum;
            
    //-----------------------------------------------------------------------------------------------------------------
             //方法2:此方法有错误
        /*    int end=0;
            int sum=0;
          
            for(int i=31;i>=0;i--){
                end=n%2;
                sum+=end*Math.pow(2,i);  
                n=n>>1;
            }
           return sum;
           */
    //-----------------------------------------------------------------------------------------------------------------
        
        }
    
    }
    
    展开全文
  • 最近在开发一个业务规则的项目,遇到一个问题,就是要判断一个无符号整数的有效二进制位数是多少。例如,5的二进制形式为101b,有3个二进制位,17的二进制形式为1 0001b,有5个二进制位。问题:已知n∈[0, pow(2, 31...

    (声明:此为原创,首发于http://blog.csdn.net,转载请注明 “作者:究竟实相,邮箱:LmjLmj8@163.com”。本文所给代码可未经本人允许而做任何使用,但是本人不承担因此造成的任何后果)

    最近在开发一个业务规则的项目,遇到一个问题,就是要判断一个无符号整数的有效二进制位数是多少。例如,5的二进制形式为101b,有3个二进制位,17的二进制形式为1 0001b,有5个二进制位。问题:已知n∈[0, pow(2, 31) ),求n的二进制位数。笔者这里给出这个问题的解决过程。所有代码在Visual Studio 2013 Express测试通过。由于编辑器出了问题,无法用中文来表示代码注释,请原谅。限于笔者水平有限,这里给出的代码可能还有一些不足,请大家指正。


    拿到问题后,我在纸上列举了一些例子,以观察规律。例子如下:

    二进制位数举例
    无符号整数二进制位数
    0~11
    2~32
    4~73
    8~154
    16~315
    32~636
    64~1277

    显然这是一个多对一的映射。观察后,可发现,从数学角度来说,可使用函数floor(log2(n)) + 1来求取任意无符号整数的二进制位数,其中floor()表示向下取整,log2(n)表示以2为底数n的对数。


    由于对数运算涉及到小数运算,有可能导致精度损失和性能偏低的问题,因此,我决定另找路子。


    思路1:设n为32位无符号整数,shift表示移位数,初始值为16,使用折半法。第一步:如果n的高16位大于0,则result增加16,将n的高16位赋值给n;否则result不变,将n的低16位赋值给n。第二步:如果n的高8位大于0,则result增加8,将n的高8位赋值给n;否则result不变,将n的低8位赋值给n。以此类推,五六步就解决了问题。刚想到这个思路时,觉得它的效率比较高,因为折半法。不过折半法有个困难,就是需要很长时间的调试才能保证其实现代码的正确性。

    下面给出实现代码:

    /** 使用折半法求取无符号整数的有效二进制位数

     *  @param[in] n 无符号整数

     *  @return  无符号整数的有效二进制位数

    */

    unsigned int getCountOfNeededBits(unsigned int n)
    {  
      unsigned int result = 0;


      if (n > 1)
      {
        unsigned int shift = 16;
        result = 1;


        while (shift > 0)
        {
          if ((n >> shift) > 0)
          {
            result += shift;
            n = n >> shift;
          }
          else
          {
            /* shift the low (32 - shift) bits of n to left in order to clear the high shift bits of n*/
            n = n << (32 - shift);


            /* shift the high (32 - shift) bits of n to right in order to get correct value */
            n = n >> (32 - shift);
          }


          shift = shift >> 1;
        }
      }
      else
      {
        result = n;
      }


      return result;
    }


    花了一个小时调试上述函数,才算正确,但不排除还有未测试出的bug。


    思路2:昨晚上床准备睡觉,突然觉得思路1有点过于复杂。它的效率可能比较高(此点尚待证实),但是思路的复杂性有点过了。有没有更简洁的办法呢?再仔细思考了一些具体的数字例子,发现无符号整数的二进制位数就等于最高位1所在的下标(最低位的下标为0)加上1。例如,6的二进制形式110b,0的下标为0,最高位1的下标为2,而6的二进制位数等于2 + 1 = 3;23的二进制形式为1 0111b,最低位1的下标为0,最高位1的下标为4,而23的二进制位数为4 + 1 = 5。在脑海里反复证实这个关系的正确性和普遍性之后,思考了其时间复杂度。由于这个思路需要从最高位开始遍历n的每个二进制位,因此是线性复杂度算法。从理论上来说,它比起前面的折半算法要慢。不过,由于n总共只有32位,因此线性算法的平均步数为16,最差为32,最好为1。代码实现如下:

    /** 使用折半法求取无符号整数的有效二进制位数

     *  @param[in] n 无符号整数

     *  @return  无符号整数的有效二进制位数

    */


    unsigned int getCountOfValidBits(unsigned int n)
    {
      unsigned int i = 0;
      unsigned int mask = 0;
      unsigned int count = 1;


      for (i = 0; i < 32; i++)
      {
        /* to get the i-th bit of n. It has two values, 0 or 1 */
        mask = 1 << (31 - i);
        mask = mask & n;
        mask = mask >> (31 - i);


        if (0 != mask)
        {
          count = 32 - i;
          break;
        }
      }


      return count;
    }


    花了5分钟写出上述代码,一次性通过。


    评述:折半算法和线性算法各有千秋,前者速度快,但难以理解,正确性难以保证,后者速度慢,但是容易理解,正确性容易保证。由于本问题本身的计算量不大,加之现代计算机很快,因此线性算法的32步与折半算法的五六步在时间上可能没什么差别。至于大批数据的测试,这里就不做了。


    下面给出相关函数、测试代码以及测试结果。

    /** my function to print integers in the form of binary
    *  @param[in] n the integer to print
    *  @param[in] separator the separator to group binary bits. Each group has four bits. The common separators are ',' and ' '. If no need, set it 0
    *  @param[in] needPrefixZeros if true (any nonzero value), then prefix zeros will be printed out, else not
    *  @return void

    */

    void printBinary(unsigned int n, unsigned char separator, unsigned char needPrefixZeros)
    {
      unsigned int i = 0;
      unsigned int mask = 0;    /* the mask code to get each bit of n */
      unsigned char data[40];   /* the buffer to store the bits of n in the form of characters */
      unsigned int index = 0;   /* used to access data[] */
      unsigned int start = 0;   /* to point out where and when to store bits of n */
      
      data[39] = '\0';


      if (n > 1)
      { /* when n == 1 or n == 0, it will be dealt with specially */


        if (needPrefixZeros)
        {
          start = 1;
        }


        /* n has 32 bits. The left bit (with index i = 0) is the highest bit */
        for (i = 0; i < 32; i++)
        {
          /* to get the i-th bit of n. It has two values, 0 or 1 */
          mask = 1 << (31 - i);
          mask = mask & n;
          mask = mask >> (31 - i);


          /* if needPrefixZeros is false, then, only when and after the first bit 1 is found, the bits of n are stored in data[] */
          if ((0 != mask) && (0 == start))
          {
            start = 1;
          }


          if (1 == start)
          {
            data[index++] = mask + '0';


            if ('\0' != separator && (i + 1) % 4 == 0)
            {
              data[index++] = separator;
            }
          }      
        }


        if ('\0' != separator)
        {
          data[index - 1] = '\0';
        }
        else
        {
          data[index] = '\0';
        }
      }
      else
      {
        data[0] = n + '0';
        data[1] = '\0';
      }


      printf("%sb\n", data);
    }


    void TestCountOfValidBits(void)
    {
      unsigned int i = 0;
      unsigned int n = 0;
      unsigned int numbers[10] = { 0xFFFFFFFF, 0xEABCDEF0, 0x81234567, 0x7100AB01, 0x456789, 0x100, 0x3, 0x2, 0x1, 0x0 };


      printf("=============test with special integers==============\n");


      for (i = 0; i < 10; i++)
      {
        printf("0X%X\n", numbers[i]);


        /* use my function to print binary bits of numbers[i] with separator ' ' bu no prefix zeros */
        printBinary(numbers[i], ' ', 0);


        printf("count of valid bits: %u\n", getCountOfValidBits(numbers[i]));
        printf("count of valid bits: %u\n", getCountOfNeededBits(numbers[i]));
        printf("\n");
      }


      printf("=============test with random integers==============\n");


      srand((unsigned int)time(NULL));


      for (i = 0; i < 10; i++)
      {
        rand_s(&n);


        printf("0X%X\n", n);


        /* use my function to print binary bits of numbers[i] with separator ' ' bu no prefix zeros */
        printBinary(n, ' ', 0);


        printf("count of valid bits: %u\n", getCountOfValidBits(n));
        printf("count of valid bits: %u\n", getCountOfNeededBits(n));
        printf("\n");
      }
    }


    int main(void)
    {
      unsigned int n = 0;


      TestCountOfValidBits();


      scanf_s("%u", &n);
      return 0;
    }


    /** 测试结果 */

    =============test with special integers==============
    0XFFFFFFFF
    1111 1111 1111 1111 1111 1111 1111 1111b
    count of valid bits: 32
    count of valid bits: 32


    0XEABCDEF0
    1110 1010 1011 1100 1101 1110 1111 0000b
    count of valid bits: 32
    count of valid bits: 32


    0X81234567
    1000 0001 0010 0011 0100 0101 0110 0111b
    count of valid bits: 32
    count of valid bits: 32


    0X7100AB01
    111 0001 0000 0000 1010 1011 0000 0001b
    count of valid bits: 31
    count of valid bits: 31


    0X456789
    100 0101 0110 0111 1000 1001b
    count of valid bits: 23
    count of valid bits: 23


    0X100
    1 0000 0000b
    count of valid bits: 9
    count of valid bits: 9


    0X3
    11b
    count of valid bits: 2
    count of valid bits: 2


    0X2
    10b
    count of valid bits: 2
    count of valid bits: 2


    0X1
    1b
    count of valid bits: 1
    count of valid bits: 1


    0X0
    0b
    count of valid bits: 1
    count of valid bits: 0


    =============test with random integers==============
    0X1951A3F7
    1 1001 0101 0001 1010 0011 1111 0111b
    count of valid bits: 29
    count of valid bits: 29


    0XB44E9BEB
    1011 0100 0100 1110 1001 1011 1110 1011b
    count of valid bits: 32
    count of valid bits: 32


    0XD2B60E39
    1101 0010 1011 0110 0000 1110 0011 1001b
    count of valid bits: 32
    count of valid bits: 32


    0XF3D1B0BE
    1111 0011 1101 0001 1011 0000 1011 1110b
    count of valid bits: 32
    count of valid bits: 32


    0XA9925C7C
    1010 1001 1001 0010 0101 1100 0111 1100b
    count of valid bits: 32
    count of valid bits: 32


    0X58E4EA77
    101 1000 1110 0100 1110 1010 0111 0111b
    count of valid bits: 31
    count of valid bits: 31


    0X9B126103
    1001 1011 0001 0010 0110 0001 0000 0011b
    count of valid bits: 32
    count of valid bits: 32


    0XEB6CF3BB
    1110 1011 0110 1100 1111 0011 1011 1011b
    count of valid bits: 32
    count of valid bits: 32


    0XAA3D6AF7
    1010 1010 0011 1101 0110 1010 1111 0111b
    count of valid bits: 32
    count of valid bits: 32


    0X7714C758
    111 0111 0001 0100 1100 0111 0101 1000b
    count of valid bits: 31
    count of valid bits: 31

    注:函数void printBinary(unsigned int n, unsigned char separator, unsigned char needPrefixZeros)的详细信息,请参考笔者的另一篇文章http://blog.csdn.net/jiujingshixiang/article/details/39134791

    展开全文
  • 子网计算 掩码 二进制位数 换算 192.168.0.0/30 192.168.0.0/24 192.168.0.0/22 192.168.0.0/20 192.168.0.0/18 之类的范围计算
  • Redis提供了SETBIT,GETBIT,BITCOUNT,BITOP四个命令用于处理二进制位数组(bit array,又称"位数组"). 位数组的表示 使用SDS结构保存位数组,使用SDS的操作函数处理位数组。但是,为了简化SETBIT的实现,保存位数组的...

    Redis提供了SETBIT,GETBIT,BITCOUNT,BITOP四个命令用于处理二进制位数组(bit array,又称"位数组").

    位数组的表示

    使用SDS结构保存位数组,使用SDS的操作函数处理位数组。但是,为了简化SETBIT的实现,保存位数组的顺序和我们平时书写位数组的顺序是相反的,如设置0000 1010,保存在SDS中是0101 0000。

    位数组:1111 0000 1100 0011 1010 0101 在SDS中保存为 1010 0101 1100 0011 0000 1111

    GETBIT命令的实现

    GETBIT <bitarray> <offset>

    过程如下:

    -1、计算byte = [offset / 8],byte记录了offset偏移量指定的二进制位保存在位数组的哪个字节;
    -2、计算bit = (offset mod 8) + 1,bit记录了offset偏移量指定的二进制位是byte字节的第几个二进制位;
    -3、根据byte和bit的值,在位数组中定位偏移量指定的二进制位,并返回这个位的值。
    复杂度O(1).

     

    SETBIT命令的实现

    SETBIT <bitarray> <offset> <value>

    1、计算len=[offset / 8] + 1,len记录了保存offset偏移量指定的二进制位至少需要多少字节
    2、检查bitarray键保存的位数组长度是否小于len,如果是,扩展SDS长度为len字节,并将所有扩展的长度值置为0
    3、计算byte = [offset / 8],byte记录了offset偏移量指定的位保存在哪个字节;
    4、计算bit = (offset mod 8) + 1,bit记录了offset偏移量指定的二进制位是byte字节的第几个二进制位
    5、根据byte值和bit值,在bitarray键保存的位数组中定位offset指定的二进制位,先记录指定二进制位保存的值到oldvalue,然后将新值设置为这个二进制位的值;
    6、向客户端返回oldvalue。
    复杂度(O)1;

    BITCOUNT命令的实现

    BITCOUNT <bitarray>

    统计给定位数组中,值为1的二进制位的数量。

    二进制位统计算法:


    1、遍历算法:,遍历每个二进制位,在遇到值为1的位时,计数器+1;
    效率太低,每次循环正检查一个二进制位的值是否为1,检查操作执行的次数与位数组包含的二进制位数量成正比。
    2、查表算法:
    对于一个有限集合来说,集合元素的排列方式是有限的;
    对于一个有限长度的位数组来说,它能表示的二进制位排列也是有限的。
    创建一个数字对应位为1个数的表,通过一次读取一个(或多个,需要建更大的映射表)字节,对比数字,就可以知道这个字节有几个位为1。键为数字,值为位上1的个数,查表。
    初看起来,只要我们创建一个足够大的表,那么统计工作就可以轻易地完成,但查表法的实际效果会受到内存和缓存两方面因素的限制:

    • 因为查表法是典型的空间换时间策略,节约的时间越多,花费的内存越大。
    • 查表法的效果会受到CPU缓存的限制:对于固定大小的CPU缓存,创建的表越大,CPU缓存所能保存的内容相比整个表越少,那么查表时出现缓存不命中的情况就会越多,缓存换入和换出操作就会越频繁,最终影响查表法的效率。

    3、variable-precision SWAR算法
    BITCOUNT命令要解决的问题:统计一个位数组中非0二进制位的数量,在数学上被称为“计算韩明重量”。汉明重量经常被用于信息论,编码理论和密码学,所以研究人员开发了多种不同的算法,一些处理器甚至直接带有计算汉明重量的指令,对于不具备这种特殊指令的处理器来说,variable-precision SWAR算法是效率最好的,该算法通过一系列位移和位运算,可以在常数时间内计算多个字节的汉明重量,并且不需要额外的内存。

    以下是一个处理32位长度位数组的算法实现:

    uint32_t swar(uint32_t i){
     //步骤1
     i = (i & 0x55555555) + ((i >> 1) & 0x55555555);
     //步骤2
     i = (i & 0x33333333) + ((i >> 2) & 0x33333333);
     //步骤3
     i = (i & 0x0f0f0f0f) + ((i >> 4) & 0x0f0f0f0f);
     //步骤4
     it = (i * (0x01010101) >> 24);
     return i
    }
    

    执行步骤:

    1、计算出值i的二进制标志可以按每两个二进制位为一组进行分组,各组的十进制表示就是改组的汉明重量;

    2、计算出的值i的二进制表示可以按每四个二进制位为一组进行分组,各组的十进制表示就是改组的汉明重量;

    3、计算出的值i的二进制表示可以按每八个二进制位为一组进行分组,各组的十进制表示就是该组的汉明重量。

    4、i*0x01010101计算出bitarray的汉明重量并记录在二进制位的最高八位,而>>24通过右移运算,将bitarray的汉明重量移动到最低八位,得出的结果就是汉明重量。

    因为swar函数是单纯的计算操作,所以它无需像查表法那样,使用额外的内存。而且swar函数是一个常数复杂度的操作,所以我们可以按照自己的需要,在一次循环中多次执行swar,从而按倍数提升计算汉明重量的效率。

    我们可以按照自己的需要,再一次循环中多次执行swar,从而按倍数提升计算汉明重量的效率:例如,我们在一次循环中调用两次swar函数,那么计算汉明重量的效率就从之前的一次循环计算32位提升到了一次循环计算64位。如果在一次循环中调用四次swar函数,那么一次循环级就可以计算128个二进制的汉明重量,这笔每次循环只调用一次swar函数块4倍。

    当然,一次循环执行多个swar调用这种优化方式是有极限的:一旦循环中处理数组的大小超过了缓存大小,这种优化的效果就会降低并最终消失。

     

    variable-precision SWAR逐行解释:

    第一行

    i = i - ((i >> 1) & 0x55555555);

    0x55555555二进制的标识方式如下:

    0x55555555 = 0b01010101010101010101010101010101

    可以看到的规律是,奇数位为1,偶数位为0。
    表达式((i >> 1) & 0x55555555),将i右移一位,并将所有偶数位设置为0.(等效的,我们也可以通过& 0xAAAAAAAA将所有奇数位设置成0,然后再将结果右移1位)为了方便起见,我们将这个中间值命名为j。
    当我们将中间值j从原始值i中减去会发生什么?那让我们来看看如果i只有两位是什么情况。

        i           j (右移一位)        i - j
    ----------------------------------
    0 = 0b00    0 = 0b00    0 = 0b00
    1 = 0b01    0 = 0b00    1 = 0b01
    2 = 0b10    1 = 0b01    1 = 0b01
    3 = 0b11    1 = 0b01    2 = 0b10

    最后的结论就是i-j的十进制结果就是位数组中1出现的次数。
    那么如果i不只是两位数组呢?实际上,很容易发现i-j的最低两位仍然如上表所示,三四位,五六位也是一个道理,等等。需要注意的是:

    • 由于& 0x55555555的巧妙用法,尽管>> 1,i-j的最低两位不会被i的第三位或者更高的位影响
    • 由于j的最低两位永远不可能在比i的最低两位大。这个减法永远不会向i的第三位借位,因此:对于i-j来说,i的最低两位不会影响i的第三位或者更高位。

    实际上这一行就是将32位数组分为16个两位为单位的组,每组分别计算1出现的次数。
    第二行:

    i = (i & 0x33333333) + ((i >> 2) & 0x33333333);

    与第一行对比,这一行非常的简单。首先,来看一下0x33333333的二进制表示:

    0x33333333 = 0b00110011001100110011001100110011

    i & 0x33333333的目的是以4位为分组取四位中的后两位。而(i >> 2) & 0x33333333在把i右移两位后做同样的工作。然后把它们结果加起来。
    因此,实际上,这行做的工作就是将最低的两位1出现的次数和最低三四位的1出现的次数相加,得到最低四位的1出现的次数。同样的对于输入的8个四位分组(=16进制数)都是一样的。
    第三行:

    return (((i + (i >> 4)) & 0x0F0F0F0F) * 0x01010101) >> 24;

    (i + (i >> 4)) & 0x0F0F0F0F除了这次是用临近的4位1出现的次数系相加,得到8位为一组的1出现的次数,以外原理跟前一行一样。(和上一行有所不同的是,我们可以把&去掉,因为我们知道原始输入8位不可能出现超过8个1因此二进制值不会超过4位。)
    现在我们有一个三十二位数,由四个字节组成,每个字节保存着原始输入中为1的位的数量。(我们把它们称作A,B,C和D。)那么为什么我们用0x01010101乘以这个值(命名为k)?

    由于:

    0x01010101 = (1 << 24) + (1 << 16) + (1 << 8) + 1

    可得:

    k * 0x01010101 = (k << 24) + (k << 16) + (k << 8) + k

    k * 0x01010101最高位就是原始输入的1出现次数的最终结果。>> 24只是简单的将最高位的值移到最低位。


    Redis实现

    BITCOUNT命令的实现用到了查表和variable-precisionSWAR两种算法:

    • 查表算法使用键长为8位的表,表中记录了从0000 0000 到1111 1111在内的所有二进制位的汉明重量。
    • variable-precisionSWAR算法,BITCOUNT命令在每次循环中载入128个二进制位,然后调用四次32位variable-precision算法来计算这128个二进制位的汉明重量。

    程序会根据未处理的二进制位的数量来决定使用哪种算法:
    如果未处理的二进制位数量小于128位,那么程序使用查表法来计算二进制位的汉明重量。否则使用variable-precisionSWAR算法来计算二进制位的汉明重量。

    BITTOP

    因为C语言直接支持对字节执行逻辑与,或,异或,非的操作,所以BITOP的四个操作都是直接基于这些逻辑操作来实现的。
    执行过程:
    1、创建一个空白的位数组value,用于保存逻辑操作的结果;
    2、对两个位数组的每个字节执行逻辑操作,并将结果保存到value[i]字节;
    3、经过前面的逻辑操作,程序得到了计算结果,并将它保存在result上。

    BITTOP AND <result > <operand-1>  [operand-2]

    BITTOP OR <result > <operand-1>  [operand-2]

    BITTOP NOT <result > <operand-1>  [operand-2]

    BITTOP XOR <result > <operand-1>  [operand-2]


     

     

     

    展开全文
  • Redis二进制位数组BitMap

    千次阅读 2018-11-18 09:56:23
    Redis提供了setbit、getbit、bitcount、bitop四个命令用于处理二进制位数组。 # setbit key pos [0/1] 设置key的第pos位置为0或者1 &amp;amp;amp;amp;gt; setbit bit 0 1 # 设置第0位为1 0000000...

    (1) 统计活跃用户

    1. 1亿个用户,用户有频繁登陆的,也有不频繁登陆的
    2. 如何记录用户的登陆信息
    3. 如何查询活跃用户,如一周内登陆3次的

    (2) 一段时间内,曾经登陆过某网站的会员人数

    Redis提供了setbit、getbit、bitcount、bitop、BITPOS 5个命令用于处理二进制位数组。

    # SETBIT key pos [0/1]  设置key的第pos位置为0或者1
    > setbit bit 0 1 # 设置第0位为1   00000001
    > setbit bit 0 1 # 设置第2位为1   00000101
    > setbit bit 0 0 # 设置第0位为0   00000100
    
    # GETBIT bit 3   # 获取第3位的值
    (integer) 1
    
    # BITCOUNT key [start end]
    > 获取bitmap指定范围[start end],位值为1的总个数
    
    # BITOP operation destkey key [key ...]  # 对一个或多个bitmap 进行位元操作,并将结果保存到 destkey 上。
      operation 可以是 AND 、 OR 、 NOT 、 XOR 这四种操作中的任意一种:
       - AND:并
       - OR:或
       - XOR:异或
       - NOT:非
    
    # BITPOS key targetBit [start] [end]
    计算bitmap指定范围[start end],第一个偏移量对应的值等于targetBit的位置
    
    展开全文
  • mathtype的公式竟然无法转存上来,只能截图啦。
  • //如十进制数字1,转化为8位二进制 int a=1; string b=Convert.ToString(1,2); //但是得到的字符串是"1"而不是"00000001" //这就需要补齐位数了 string b=Convert.ToString(1,2).PadLeft(8,'0');//PadLeft(int a,cha...
  • 二进制不同位数

    2017-03-11 08:54:02
    世界上有10种人,一种懂二进制,一种不懂。 那么你知道两个int32整数m和n的二进制表达,有多少个位(bit)不同么?  对于这道题目,我的想法是首先把对应的十进制整数转换为二进制,然后对比两个二进制,得出结果。 ...
  • #define _CRT_SECURE_NO_WARNINGS #include int bitcount(unsigned x) { int i; printf("bitcout"); for (i = 0;x > 0;x &= x - 1) i++; return i; } int bitcount1(unsigned x) ... printf("bitcount1
  • 计算机在处置惩罚数据时,一次能直接处置惩罚的二进制数据的位数称为:字长。字长是指计算机一次能直接处置惩罚的二进制数据的位数,字长越长,计算机的团体机能越强。 计算机采纳二进制编码体式格局示意数、字符、...
  • 获得一个整数的二进制位数

    千次阅读 2014-05-06 22:17:31
     获得一个整数的二进制位数。 #include void main(){  int i=0,j;  int m;  scanf("%d",&j);  m=j; while((j>>i)>0){  i++;  j=m;  } printf("%d\n",i); }
  • 10 求二进制表示位数

    2020-04-28 11:51:17
    10 求二进制表示位数 作者: zwz时间限制: 1S章节: 基本练习(循环) 问题描述 : 给定一个十进制整数,返回其对应的二进制数的位数。例如,输入十进制数9,其对应的二进制数是1001,因此位数是4。 输入说明 : 输入一...
  • 今天小编就为大家分享一篇Python的bit_length函数来二进制位数方法,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • Java实现 蓝桥杯VIP 算法训练 递归求二进制表示位数

    万次阅读 多人点赞 2019-06-17 07:57:07
    给定一个十进制整数,返回其对应的二进制数的位数。例如,输入十进制数9,其对应的二进制数是1001,因此位数是4。 样例输入 一个满足题目要求的输入范例。 9 样例输出 与上面的样例输入对应的输出。 数据规模和约定 ...
  • 二进制位数,字节、字符

    万次阅读 2016-08-11 21:23:02
    二进制位数,也就是表达一个其他类型的数所需要的二进制数有几个,确定整数二进制表示中第一个1 的出现位置。 例如:  2的二进制为 10,占用2个二进制位  3的二进制为 11,占用2个二进制位  4的二进制为 100...
  • 递归求二进制表示位数问题描述 给定一个十进制整数,返回其对应的二进制数的位数。例如,输入十进制数9,其对应的二进制数是1001,因此位数是4。样例输入一个满足题目要求的输入范例。9样例输出与上面的样例输入...
  • #include using namespace std; #define N 4 int *x=new int[N]; void backtrack(int t) { int i=0; if(t>N-1) { for(i=0; i; i++) cout[i]; cout; } else ... {
  • 问题描述  给定一个十进制整数,返回其对应的二进制数的位数。例如,输入十进制数9,其对应的二进制数是1001,因此位数是4。 样例输入 一个满足题目要求的输入范例...n大于2时,二进制的位数是n / 2的二进制位数加1...
  • 世界上有10种人,一种懂二进制,一种不懂。那么你知道两个int32整数m和n的二进制表达,有多少个位(bit)不同么?
  • Python的bit_length函数来二进制位数

    万次阅读 2018-10-01 16:37:28
    自Python3.1中,整数bit_length方法允许查询二进制位数或长度。 常规做法: &gt;&gt;&gt; bin(256) '0b100000000' &gt;&gt;&gt; len(bin(256)) - 2 9 &gt;&gt;&gt; 使用...
  • 二进制 二进制就是计算机常用的进制,即逢二进一。例如:1010 八进制 八进制即逢八进一。例如:626 十进制 十进制就是我们在计算中常用的进制,所以就不再举例(即逢十进一) 十六进制 十六进制与其它进制...
  • 简单的输出十进制数输出其对应二进制数的位数,很简单 很实用
  • oracle如何判断十进制数对应二进制指定位数是否为1,挺起来比较绕口,需求大致为 我们报警分为 1、A类报警,对应二进制第一位数字为1,如00001,10001 2、B类报警,对应二进制第二位数字为1,如00010,10010,11011...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 178,656
精华内容 71,462
关键字:

二进制的位数叫什么