算法-求二进制数中1的个数

最新推荐文章于 2022-11-16 22:58:01 发布
最新推荐文章于 2022-11-16 22:58:01 发布
阅读量511 收藏
点赞数
分类专栏： 算法 文章标签： c 算法

http://www.cnblogs.com/graphics/archive/2010/06/21/1752421.html

问题描述

任意给定一个32位无符号整数n，求n的二进制表示中1的个数，比如n = 5（0101）时，返回2，n = 15（1111）时，返回4

这也是一道比较经典的题目了，相信不少人面试的时候可能遇到过这道题吧，下面介绍了几种方法来实现这道题，相信很多人可能见过下面的算法，但我相信很少有人见到本文中所有的算法。如果您上头上有更好的算法，或者本文没有提到的算法，请不要吝惜您的代码，分享的时候，也是学习和交流的时候。

普通法

我总是习惯叫普通法，因为我实在找不到一个合适的名字来描述它，其实就是最简单的方法，有点程序基础的人都能想得到，那就是移位+计数，很简单，不多说了，直接上代码，这种方法的运算次数与输入n最高位1的位置有关，最多循环32次。

复制代码 
  
  

   
   int
   
    BitCount(unsigned 
   
   int
   
    n)
{
    unsigned 
   
   int
   
    c 
   
   =
   
    
   
   0
   
    ; 
   
   //
   
    计数器
   
   

   
       
   
   while
   
    (n 
   
   >
   
    
   
   0
   
   )
    {
        
   
   if
   
   ((n 
   
   &
   
    
   
   1
   
   ) 
   
   ==
   
    
   
   1
   
   ) 
   
   //
   
    当前位是1
   
   

   
               
   
   ++
   
   c ; 
   
   //
   
    计数器加1
   
   

   
           n 
   
   >>=
   
    
   
   1
   
    ; 
   
   //
   
    移位
   
   

   
       }
    
   
   return
   
    c ;
}

一个更精简的版本如下

复制代码 
  
  

   
   int
   
    BitCount1(unsigned 
   
   int
   
    n)
{
    unsigned 
   
   int
   
    c 
   
   =
   
    
   
   0
   
    ; 
   
   //
   
    计数器
   
   

   
       
   
   for
   
    (c 
   
   =
   
    
   
   0
   
   ; n; n 
   
   >>=
   
    
   
   1
   
   ) 
   
   //
   
    循环移位
   
   

   
           c 
   
   +=
   
    n 
   
   &
   
    
   
   1
   
    ; 
   
   //
   
    如果当前位是1，则计数器加1
   
   

   
       
   
   return
   
    c ;
}
复制代码

快速法

这种方法速度比较快，其运算次数与输入n的大小无关，只与n中1的个数有关。如果n的二进制表示中有k个1，那么这个方法只需要循环k次即可。其原理是不断清除n的二进制表示中最右边的1，同时累加计数器，直至n为0，代码如下

复制代码 
  
  

   
   int
   
    BitCount2(unsigned 
   
   int
   
    n)
{
    unsigned 
   
   int
   
    c 
   
   =
   
    
   
   0
   
    ;
    
   
   for
   
    (c 
   
   =
   
    
   
   0
   
   ; n; 
   
   ++
   
   c)
    {
        n 
   
   &=
   
    (n 
   
   -
   
    
   
   1
   
   ) ; 
   
   //
   
    清除最低位的1
   
   

   
       }
    
   
   return
   
    c ;
}
复制代码

查表法

动态建表

由于表示在程序运行时动态创建的，所以速度上肯定会慢一些，把这个版本放在这里，有两个原因

1. 介绍填表的方法，因为这个方法的确很巧妙。

2. 类型转换，这里不能使用传统的强制转换，而是先取地址再转换成对应的指针类型。也是常用的类型转换方法。

复制代码 
  
  

   
   int
   
    BitCount3(unsigned 
   
   int
   
    n) 
{ 
    
   
   //
   
    建表
   
   

   
       unsigned 
   
   char
   
    BitsSetTable256[
   
   256
   
   ] 
   
   =
   
    {
   
   0
   
   } ; 

    
   
   //
   
    初始化表 
   
   

   
       
   
   for
   
    (
   
   int
   
    i 
   
   =
   
    
   
   0
   
   ; i 
   
   <
   
    
   
   256
   
   ; i
   
   ++
   
   ) 
    { 
        BitsSetTable256[i] 
   
   =
   
    (i 
   
   &
   
    
   
   1
   
   ) 
   
   +
   
    BitsSetTable256[i 
   
   /
   
    
   
   2
   
   ]; 
    } 

    unsigned 
   
   int
   
    c 
   
   =
   
    
   
   0
   
    ; 

    
   
   //
   
    查表
   
   

   
       unsigned 
   
   char
   
    
   
   *
   
    p 
   
   =
   
    (unsigned 
   
   char
   
    
   
   *
   
   ) 
   
   &
   
   n ; 

    c 
   
   =
   
    BitsSetTable256[p[
   
   0
   
   ]] 
   
   +
   
     
        BitsSetTable256[p[
   
   1
   
   ]] 
   
   +
   
     
        BitsSetTable256[p[
   
   2
   
   ]] 
   
   +
   
     
        BitsSetTable256[p[
   
   3
   
   ]]; 

    
   
   return
   
    c ; 
}
复制代码

静态表-4bit

原理和8-bit表相同，详见8-bit表的解释

复制代码 
  
  

   
   int
   
    BitCount4(unsigned 
   
   int
   
    n)
{
    unsigned 
   
   int
   
    table[
   
   16
   
   ] 
   
   =
   
    
    {
        
   
   0
   
   , 
   
   1
   
   , 
   
   1
   
   , 
   
   2
   
   , 
        
   
   1
   
   , 
   
   2
   
   , 
   
   2
   
   , 
   
   3
   
   , 
        
   
   1
   
   , 
   
   2
   
   , 
   
   2
   
   , 
   
   3
   
   , 
        
   
   2
   
   , 
   
   3
   
   , 
   
   3
   
   , 
   
   4
   
   
    } ;

    unsigned 
   
   int
   
    count 
   
   =
   
    
   
   0
   
    ;
    
   
   while
   
    (n)
    {
        count 
   
   +=
   
    table[n 
   
   &
   
    
   
   0xf
   
   ] ;
        n 
   
   >>=
   
    
   
   4
   
    ;
    }
    
   
   return
   
    count ;
}
复制代码

静态表-8bit

首先构造一个包含256个元素的表table，table[i]即i中1的个数，这里的i是[0-255]之间任意一个值。然后对于任意一个32bit无符号整数n，我们将其拆分成四个8bit，然后分别求出每个8bit中1的个数，再累加求和即可，这里用移位的方法，每次右移8位，并与0xff相与，取得最低位的8bit，累加后继续移位，如此往复，直到n为0。所以对于任意一个32位整数，需要查表4次。以十进制数2882400018为例，其对应的二进制数为10101011110011011110111100010010，对应的四次查表过程如下：红色表示当前8bit，绿色表示右移后高位补零。

第一次（n & 0xff）             10101011110011011110111100010010

第二次（(n >> 8) & 0xff）  00000000101010111100110111101111

第三次（(n >> 16) & 0xff）00000000000000001010101111001101

第四次（(n >> 24) & 0xff）00000000000000000000000010101011

复制代码 
  
  

   
   int
   
    BitCount7(unsigned 
   
   int
   
    n)
{    
    unsigned 
   
   int
   
    table[
   
   256
   
   ] 
   
   =
   
        
    {        
        
   
   0
   
   , 
   
   1
   
   , 
   
   1
   
   , 
   
   2
   
   , 
   
   1
   
   , 
   
   2
   
   , 
   
   2
   
   , 
   
   3
   
   , 
   
   1
   
   , 
   
   2
   
   , 
   
   2
   
   , 
   
   3
   
   , 
   
   2
   
   , 
   
   3
   
   , 
   
   3
   
   , 
   
   4
   
   ,        
        
   
   1
   
   , 
   
   2
   
   , 
   
   2
   
   , 
   
   3
   
   , 
   
   2
   
   , 
   
   3
   
   , 
   
   3
   
   , 
   
   4
   
   , 
   
   2
   
   , 
   
   3
   
   , 
   
   3
   
   , 
   
   4
   
   , 
   
   3
   
   , 
   
   4
   
   , 
   
   4
   
   , 
   
   5
   
   ,        
        
   
   1
   
   , 
   
   2
   
   , 
   
   2
   
   , 
   
   3
   
   , 
   
   2
   
   , 
   
   3
   
   , 
   
   3
   
   , 
   
   4
   
   , 
   
   2
   
   , 
   
   3
   
   , 
   
   3
   
   , 
   
   4
   
   , 
   
   3
   
   , 
   
   4
   
   , 
   
   4
   
   , 
   
   5
   
   ,        
        
   
   2
   
   , 
   
   3
   
   , 
   
   3
   
   , 
   
   4
   
   , 
   
   3
   
   , 
   
   4
   
   , 
   
   4
   
   , 
   
   5
   
   , 
   
   3
   
   , 
   
   4
   
   , 
   
   4
   
   , 
   
   5
   
   , 
   
   4
   
   , 
   
   5
   
   , 
   
   5
   
   , 
   
   6
   
   ,        
        
   
   1
   
   , 
   
   2
   
   , 
   
   2
   
   , 
   
   3
   
   , 
   
   2
   
   , 
   
   3
   
   , 
   
   3
   
   , 
   
   4
   
   , 
   
   2
   
   , 
   
   3
   
   , 
   
   3
   
   , 
   
   4
   
   , 
   
   3
   
   , 
   
   4
   
   , 
   
   4
   
   , 
   
   5
   
   ,        
        
   
   2
   
   , 
   
   3
   
   , 
   
   3
   
   , 
   
   4
   
   , 
   
   3
   
   , 
   
   4
   
   , 
   
   4
   
   , 
   
   5
   
   , 
   
   3
   
   , 
   
   4
   
   , 
   
   4
   
   , 
   
   5
   
   , 
   
   4
   
   , 
   
   5
   
   , 
   
   5
   
   , 
   
   6
   
   ,        
        
   
   2
   
   , 
   
   3
   
   , 
   
   3
   
   , 
   
   4
   
   , 
   
   3
   
   , 
   
   4
   
   , 
   
   4
   
   , 
   
   5
   
   , 
   
   3
   
   , 
   
   4
   
   , 
   
   4
   
   , 
   
   5
   
   , 
   
   4
   
   , 
   
   5
   
   , 
   
   5
   
   , 
   
   6
   
   ,        
        
   
   3
   
   , 
   
   4
   
   , 
   
   4
   
   , 
   
   5
   
   , 
   
   4
   
   , 
   
   5
   
   , 
   
   5
   
   , 
   
   6
   
   , 
   
   4
   
   , 
   
   5
   
   , 
   
   5
   
   , 
   
   6
   
   , 
   
   5
   
   , 
   
   6
   
   , 
   
   6
   
   , 
   
   7
   
   ,       
        
   
   1
   
   , 
   
   2
   
   , 
   
   2
   
   , 
   
   3
   
   , 
   
   2
   
   , 
   
   3
   
   , 
   
   3
   
   , 
   
   4
   
   , 
   
   2
   
   , 
   
   3
   
   , 
   
   3
   
   , 
   
   4
   
   , 
   
   3
   
   , 
   
   4
   
   , 
   
   4
   
   , 
   
   5
   
   ,        
        
   
   2
   
   , 
   
   3
   
   , 
   
   3
   
   , 
   
   4
   
   , 
   
   3
   
   , 
   
   4
   
   , 
   
   4
   
   , 
   
   5
   
   , 
   
   3
   
   , 
   
   4
   
   , 
   
   4
   
   , 
   
   5
   
   , 
   
   4
   
   , 
   
   5
   
   , 
   
   5
   
   , 
   
   6
   
   ,        
        
   
   2
   
   , 
   
   3
   
   , 
   
   3
   
   , 
   
   4
   
   , 
   
   3
   
   , 
   
   4
   
   , 
   
   4
   
   , 
   
   5
   
   , 
   
   3
   
   , 
   
   4
   
   , 
   
   4
   
   , 
   
   5
   
   , 
   
   4
   
   , 
   
   5
   
   , 
   
   5
   
   , 
   
   6
   
   ,        
        
   
   3
   
   , 
   
   4
   
   , 
   
   4
   
   , 
   
   5
   
   , 
   
   4
   
   , 
   
   5
   
   , 
   
   5
   
   , 
   
   6
   
   , 
   
   4
   
   , 
   
   5
   
   , 
   
   5
   
   , 
   
   6
   
   , 
   
   5
   
   , 
   
   6
   
   , 
   
   6
   
   , 
   
   7
   
   ,        
        
   
   2
   
   , 
   
   3
   
   , 
   
   3
   
   , 
   
   4
   
   , 
   
   3
   
   , 
   
   4
   
   , 
   
   4
   
   , 
   
   5
   
   , 
   
   3
   
   , 
   
   4
   
   , 
   
   4
   
   , 
   
   5
   
   , 
   
   4
   
   , 
   
   5
   
   , 
   
   5
   
   , 
   
   6
   
   ,        
        
   
   3
   
   , 
   
   4
   
   , 
   
   4
   
   , 
   
   5
   
   , 
   
   4
   
   , 
   
   5
   
   , 
   
   5
   
   , 
   
   6
   
   , 
   
   4
   
   , 
   
   5
   
   , 
   
   5
   
   , 
   
   6
   
   , 
   
   5
   
   , 
   
   6
   
   , 
   
   6
   
   , 
   
   7
   
   ,        
        
   
   3
   
   , 
   
   4
   
   , 
   
   4
   
   , 
   
   5
   
   , 
   
   4
   
   , 
   
   5
   
   , 
   
   5
   
   , 
   
   6
   
   , 
   
   4
   
   , 
   
   5
   
   , 
   
   5
   
   , 
   
   6
   
   , 
   
   5
   
   , 
   
   6
   
   , 
   
   6
   
   , 
   
   7
   
   ,        
        
   
   4
   
   , 
   
   5
   
   , 
   
   5
   
   , 
   
   6
   
   , 
   
   5
   
   , 
   
   6
   
   , 
   
   6
   
   , 
   
   7
   
   , 
   
   5
   
   , 
   
   6
   
   , 
   
   6
   
   , 
   
   7
   
   , 
   
   6
   
   , 
   
   7
   
   , 
   
   7
   
   , 
   
   8
   
   ,    
    };    
    
    
   
   return
   
    table[n 
   
   &
   
    
   
   0xff
   
   ] 
   
   +
   
   
        table[(n 
   
   >>
   
    
   
   8
   
   ) 
   
   &
   
    
   
   0xff
   
   ] 
   
   +
   
   
        table[(n 
   
   >>
   
    
   
   16
   
   ) 
   
   &
   
    
   
   0xff
   
   ] 
   
   +
   
   
        table[(n 
   
   >>
   
    
   
   24
   
   ) 
   
   &
   
    
   
   0xff
   
   ] ;
}

平行算法

网上都这么叫，我也这么叫吧，不过话说回来，的确有平行的意味在里面，先看代码，稍后解释

复制代码 
  
  

   
   int
   
    BitCount4(unsigned 
   
   int
   
    n) 
{ 
    n 
   
   =
   
    (n 
   
   &
   
    
   
   0x55555555
   
   ) 
   
   +
   
    ((n 
   
   >>
   
    
   
   1
   
   ) 
   
   &
   
    
   
   0x55555555
   
   ) ; 
    n 
   
   =
   
    (n 
   
   &
   
    
   
   0x33333333
   
   ) 
   
   +
   
    ((n 
   
   >>
   
    
   
   2
   
   ) 
   
   &
   
    
   
   0x33333333
   
   ) ; 
    n 
   
   =
   
    (n 
   
   &
   
    
   
   0x0f0f0f0f
   
   ) 
   
   +
   
    ((n 
   
   >>
   
    
   
   4
   
   ) 
   
   &
   
    
   
   0x0f0f0f0f
   
   ) ; 
    n 
   
   =
   
    (n 
   
   &
   
    
   
   0x00ff00ff
   
   ) 
   
   +
   
    ((n 
   
   >>
   
    
   
   8
   
   ) 
   
   &
   
    
   
   0x00ff00ff
   
   ) ; 
    n 
   
   =
   
    (n 
   
   &
   
    
   
   0x0000ffff
   
   ) 
   
   +
   
    ((n 
   
   >>
   
    
   
   16
   
   ) 
   
   &
   
    
   
   0x0000ffff
   
   ) ; 

    
   
   return
   
    n ; 
}
复制代码

完美法

复制代码 
  
  

   
   int
   
    BitCount5(unsigned 
   
   int
   
    n) 
{

   
   

    unsigned int tmp 
   
   =
   
    n 
   
   -
   
    ((n 
   
   >>
   
    
   
   1
   
   ) 
   
   &
   
    
   
   033333333333
   
   ) 
   
   -
   
    ((n 
   
   >>
   
    
   
   2
   
   ) 
   
   &
   
    
   
   011111111111
   
   );
    
   
   return
   
    ((tmp 
   
   +
   
    (tmp 
   
   >>
   
    
   
   3
   
   )) 
   
   &
   
    
   
   030707070707
   
   ) 
   
   %
   
    
   
   63
   
   ;
}

位标志法

感谢网友 gussing提供

复制代码 
  
  

   
   struct
   
    _byte  
{  
    unsigned a:
   
   1
   
   ;  
    unsigned b:
   
   1
   
   ;  
    unsigned c:
   
   1
   
   ;  
    unsigned d:
   
   1
   
   ;  
    unsigned e:
   
   1
   
   ;  
    unsigned f:
   
   1
   
   ;  
    unsigned g:
   
   1
   
   ;  
    unsigned h:
   
   1
   
   ;  
};  


   
   long
   
    get_bit_count( unsigned 
   
   char
   
    b )  
{
    
   
   struct
   
    _byte 
   
   *
   
   by 
   
   =
   
    (
   
   struct
   
    _byte
   
   *
   
   )
   
   &
   
   b;  
    
   
   return
   
    (by
   
   ->
   
   a
   
   +
   
   by
   
   ->
   
   b
   
   +
   
   by
   
   ->
   
   c
   
   +
   
   by
   
   ->
   
   d
   
   +
   
   by
   
   ->
   
   e
   
   +
   
   by
   
   ->
   
   f
   
   +
   
   by
   
   ->
   
   g
   
   +
   
   by
   
   ->
   
   h);  
}
复制代码

指令法

感谢网友 Milo Yip提供

使用微软提供的指令，首先要确保你的CPU支持SSE4指令，用Everest和CPU-Z可以查看是否支持。

  
  

   
   unsigned 
   
   int
   
    n 
   
   =
   
    
   
   127
   
    ;
unsigned 
   
   int
   
    bitCount 
   
   =
   
    _mm_popcnt_u32(n) ;

小雪狼
关注
专栏目录
Python《剑指offer》算法实现-二进制中1的个数
12-25
1. 初级程序员注重算法和数据结构 2. 事先做好准备,对工作有热情 3. 面试过程放松。不要急于写代码,了解清楚所要解决的问题,多和面试官沟通,然后开始做一些整体的设计和规划。不要急于提交,自己测试几个用例避免错误...
Java数据结构及算法实例：快速计算二进制数中1的个数(Fast Bit Counting)
09-03
总结来说，Java数据结构及算法实例：快速计算二进制数中1的个数，通过使用Brian Kernighan的位操作技巧，可以高效地计算出整数的二进制表示中1的个数，这对于理解和优化计算密集型代码非常重要。
位运算算法---求二进制中1的个数
zyp_zl的博客
06-09 834
位运算算法---求二进制中1的个数
算法---求二进制中1的个数
Mister5ive的专栏
09-10 3937
学习的地址：原文地址 问题描述 　　任意给定一个32位无符号整数n，求n的二进制表示中1的个数，比如n = 5（0101）时，返回2，n = 15（1111）时，返回4。 1.普通法 　　我总是习惯叫普通法，因为我实在找不到一个合适的名字来描述它，其实就是最简单的方法，有点程序基础的人都能想得到，那就是移位+计数，很简单，不多说了，直接上代码，这种方法的运算次数与输
位运算-求二进制中1的个数
六月二十七的博客
03-13 299
//求二进制中1的个数 public int countOne(int n){ int count=0; while(n&gt;0){ if(n&amp;1==1){ count++; } n&gt;&gt;=1; } return count; }
算法刷题-求二进制序列中1的个数
chuxinchangcun的博客
09-24 553
目录 一.题目要求 二.方法1 二.方法2 三.方法3 四.总结 一.题目要求 二.方法1 size_t count_bit_one(int n) { size_t count = 0; while(n) { if(n%2 == 1) { count++; } n = n/2; } return count; } 改进： size_t count_.
java---位运算运用Lowbit算法--二进制中1的个数（每日一道算法2022.7.29）
SRestia的博客
07-29 567
声明算法思路来源为y总，详细请见https//www.acwing.com/给定一个长度为n的数列，请你求出数列中每个数的二进制表示中1的个数。（今天的题解法非常精彩，别看没几行代码，理论可不少）本文仅用作学习记录和交流。......
bitCount-计算数字二进制中1的个数
dopamine_joker的博客
10-29 5282
这里写自定义目录标题1. 题目描述2. 解决方法3. bitcount解法分析4. 参考 主要介绍bitcount位运算实现，思路和java中bitcount的实现一样。 1. 题目描述 编写一个函数，输入是一个无符号整数（以二进制串的形式），返回其二进制表达式中数字位数为 ‘1’ 的个数（也被称为 汉明重量).）。 LeetCode 2. 解决方法 解法1 第一反应就是直接暴力，代码如下: int hammingWeight(uint32_t n) { int ret = 0; for
求二进制中1的个数的三种方法
m0_72940975的博客
11-16 1348
求二进制中1的个数
C语言 --统计二进制位中1的个数(通俗易懂)
qq_61688804的博客
03-09 4185
嗨，当你看到这篇文章，并且点了进来，那是我的荣幸，也没什么好感谢你的，那么就祝福屏幕前的你，未来offer拿到手软！！！ 好了，一波吹嘘完，我们开始干正事。 目录 题目主题：统计一个数二进制位中1的个数 一，方法一 1.1，代码 1.2，原理解析 二，方法二 2.1，代码 2.2，原理解析 2.3，代码优化 三，方法三 3.1，代码 3.2，原理解释 题目主题：统计一个数二进制位中1的个数 注意：这里的二进制位指的是二进制补码，因为数在计算机中存储都是以二进...
求二进制中1的个数（python）
qq_43211230的博客
03-29 2711
解法 1 利用整数除法的特点，通过相除和判断余数的值来分析。 def count_1(v): num = 0 while v: if v%2 == 1: num += 1 v = v // 2 return num 解法 2 利用二进制移位的方法 def count_2(v): num = 0 while v: num += v&1 v >>=
C++计算一个数字的二进制中0或1的个数原理及代码
07-02
printf("\n数字%d的二进制数中，0的个数为%d个，1的个数为%d个\n", nData, nSum_Zero, nSum_One); return 1; } ``` **代码解析：** - **主函数**：`main()`函数首先定义了一个整数变量`nData`并赋值为300，然后...
求二进制数中1的个数.pdf
12-03
### 求二进制数中1的个数 #### 背景介绍 在计算机科学领域，理解和操作二进制数是非常基础且重要的技能之一。对于一个字节（8位）的变量，求其二进制表示中“1”的个数是一个常见的问题。这一问题不仅出现在计算机...
算法-权势二进制（51Nod-1413）.rar
09-16
3. 巧妙的数学技巧：有时，可以通过观察二进制数的特性来简化计算，例如，对于任何正整数n，n&(n-1)总是去掉n的最右边的一个1，通过反复应用这个操作，可以快速得到n的1的个数。 由于没有提供具体的题目详情，以上...
梦幻西游手游多开与自动化的详细教程
最新发布
09-23
本文档提供了梦幻西游手游多开以及自动化的完整指南。主要内容涵盖了所需软硬件的具体配置流程，其中包括Windows 10操作系统的要求限制、使用沙盒工具进行多账号安全操作的方法以及借助Python和AirTest实现游戏脚本自动化的技巧。对于希望实现游戏账号多开并运用自动化来减轻任务负担的手游玩家而言，它给出了详细的解决方案，帮助玩家完成诸如批量任务操作、窗口管理和自动化脚本编写等功能。 适用人群：喜欢《梦幻西游》并有兴趣提升日常任务效率的玩家和初学者级别的Python爱好者。 使用场景及目标：用于解决《梦幻西游》多账号管理过程中所遇到的问题，提高任务的自动化程度以节省时间。 阅读建议：文档不仅限于代码展示，还涉及了很多配置和调试的操作指引。因此，读者应该按照文档内的步骤逐一操作实践才能真正掌握多开与自动化应用的技术要点。
辽宁对外经贸学院在湖南2021-2024各专业最低录取分数及位次表.pdf
09-23
全国各大学在湖南2021-2024年各专业最低录取分数及录取位次数据，高考志愿必备参考数据
变压器变频器配电柜电路控制原理图CAD施工图纸设备控制图星三角启动11
09-23
变压器变频器配电柜电路控制原理图CAD施工图纸设备控制图星三角启动11
【数字信号去噪】基于matlab粒子群算法PSO-ICEEMDAN信号去躁【含Matlab源码 7616期】.zip
09-23
CSDN海神之光上传的代码均可运行，亲测可用，直接替换数据即可，适合小白； 1、代码压缩包内容 主函数：main.m； 调用函数：其他m文件；无需运行 运行结果效果图； 2、代码运行版本 Matlab 2019b或2023b；若运行有误，根据提示修改；若不会，私信博主； 3、运行操作步骤 步骤一：将所有文件放到Matlab的当前文件夹中； 步骤二：双击打开main.m文件； 步骤三：点击运行，等程序运行完得到结果； 4、仿真咨询 如需其他服务，可私信博主或扫描博客文章底部QQ名片； 4.1 博客或资源的完整代码提供 4.2 期刊或参考文献复现 4.3 Matlab程序定制 4.4 科研合作 功率谱估计： 故障诊断分析： 雷达通信：雷达LFM、MIMO、成像、定位、干扰、检测、信号分析、脉冲压缩 滤波估计：SOC估计 目标定位：WSN定位、滤波跟踪、目标定位 生物电信号：肌电信号EMG、脑电信号EEG、心电信号ECG 通信系统：DOA估计、编码译码、变分模态分解、管道泄漏、滤波器、数字信号处理+传输+分析+去噪（CEEMDAN）、数字信号调制、误码率、信号估计、DTMF、信号检测识别融合、LEACH协议、信号检测、水声通信
优化算法：高效计算二进制中1的个数
"这篇文档主要讨论了如何高效地计算一个字节（8bit）二进制数中1的个数，提供了三种不同的解决方案，并强调了在不同应用场景中对算法效率和空间需求的不同要求。" 在计算机科学中，尤其是在算法设计和优化领域，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值