如何计算汉明距离(hamming distance)

最新推荐文章于 2022-08-08 19:39:04 发布
最新推荐文章于 2022-08-08 19:39:04 发布
阅读量6.7k 收藏 1
点赞数
分类专栏： coding 文章标签： hamming distance

            int diff = 0;

            for (int i = 0; i < dim / 64; i++)

            {

                unsigned__int64 x1 = ((unsigned__int64 *)px1)[i];

                unsigned__int64 x2 = ((unsigned__int64 *)px2)[i];

                unsigned__int64 x = x1 ^ x2;

                diff += (int)_mm_popcnt_u64(x);

            }

 

 

            int diff = 0;

            for (int i = 0; i < len; i++)

            {

                ulong t = a[i] ^ b[i];

                t -= ((t >> 1)& 0x5555555555555555UL);

                t = (t & 0x3333333333333333UL) + ((t >> 2) & 0x3333333333333333UL);

                t = ((t + (t >> 4) & 0x0F0F0F0F0F0F0F0FUL) * 0x0101010101010101UL) >> 56;

                diff += (int)t;

            }

 

 

 

#if !defined HAVE_BITCOUNT_H__
#define      HAVE_BITCOUNT_H__
// This file is part of the FXT library.
// Copyright (C) 2010, 2011, 2012 Joerg Arndt
// License: GNU General Public License version 3 or later,
// see the file COPYING.txt in the main directory.

#include "fxttypes.h"
#include "bits/bitsperlong.h"
#include "bits/bitasm.h"


static inline ulong bit_count(ulong x)
// Return number of set bits.
// The sequence of values returned for x = 0, 1, 2, 3, ... is
// 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4, 1, ...
// (OEIS sequence A000120).
{
#ifdef HAVE_AMD64_POPCNT  // currently not auto-detected

    return  asm_bit_count(x);

#else  // HAVE_AMD64_POPCNT


#if  BITS_PER_LONG == 32
//    // VERSION 1:
//    x = (0x55555555UL & x) + (0x55555555UL & (x>> 1));  // 0-2 in 2 bits
//    x = (0x33333333UL & x) + (0x33333333UL & (x>> 2));  // 0-4 in 4 bits
//    x = (0x0f0f0f0fUL & x) + (0x0f0f0f0fUL & (x>> 4));  // 0-8 in 8 bits
//    x = (0x00ff00ffUL & x) + (0x00ff00ffUL & (x>> 8));  // 0-16 in 16 bits
//    x = (0x0000ffffUL & x) + (0x0000ffffUL & (x>>16));  // 0-32 in 32 bits
//    return x;

//    // VERSION 2:
//    x  = ((x>>1) & 0x55555555UL) + (x & 0x55555555UL);  // 0-2 in 2 bits
//    x  = ((x>>2) & 0x33333333UL) + (x & 0x33333333UL);  // 0-4 in 4 bits
//    x  = ((x>>4) + x) & 0x0f0f0f0fUL;                   // 0-8 in 8 bits
//    x +=  x>> 8;                                        // 0-16 in 8 bits
//    x +=  x>>16;                                        // 0-32 in 8 bits
//    return  x & 0xff;

    // VERSION 3:
    x -=  (x>>1) & 0x55555555UL;                        // 0-2 in 2 bits
    x  = ((x>>2) & 0x33333333UL) + (x & 0x33333333UL);  // 0-4 in 4 bits
    x  = ((x>>4) + x) & 0x0f0f0f0fUL;                   // 0-8 in 8 bits
    x *= 0x01010101UL;
    return  x>>24;

#endif

#if  BITS_PER_LONG == 64
//    // VERSION 1:
//    x = (0x5555555555555555UL & x) + (0x5555555555555555UL & (x>> 1));  // 0-2 in 2 bits
//    x = (0x3333333333333333UL & x) + (0x3333333333333333UL & (x>> 2));  // 0-4 in 4 bits
//    x = (0x0f0f0f0f0f0f0f0fUL & x) + (0x0f0f0f0f0f0f0f0fUL & (x>> 4));  // 0-8 in 8 bits
//    x = (0x00ff00ff00ff00ffUL & x) + (0x00ff00ff00ff00ffUL & (x>> 8));  // 0-16 in 16 bits
//    x = (0x0000ffff0000ffffUL & x) + (0x0000ffff0000ffffUL & (x>>16));  // 0-32 in 32 bits
//    x = (0x00000000ffffffffUL & x) + (0x00000000ffffffffUL & (x>>32));  // 0-64 in 64 bits
//    return x;

//    // VERSION 2:
//    x = ((x>>1) & 0x5555555555555555UL) + (x & 0x5555555555555555UL);  // 0-2 in 2 bits
//    x = ((x>>2) & 0x3333333333333333UL) + (x & 0x3333333333333333UL);  // 0-4 in 4 bits
//    x = ((x>>4) + x) & 0x0f0f0f0f0f0f0f0fUL;                           // 0-8 in 8 bits
//    x +=  x>> 8;                                                       // 0-16 in 8 bits
//    x +=  x>>16;                                                       // 0-32 in 8 bits
//    x +=  x>>32;                                                       // 0-64 in 8 bits
//    return  x & 0xff;

    // VERSION 3:
    x -=  (x>>1) & 0x5555555555555555UL;                                // 0-2 in 2 bits
    x  = ((x>>2) & 0x3333333333333333UL) + (x & 0x3333333333333333UL);  // 0-4 in 4 bits
    x  = ((x>>4) + x) & 0x0f0f0f0f0f0f0f0fUL;                           // 0-8 in 8 bits
    x *= 0x0101010101010101UL;
    return  x>>56;

#endif
#endif  // HAVE_AMD64_POPCNT
}
// -------------------------

static inline ulong bit_count_15(ulong x)
// Return number of set bits, must have at most 15 set bits.
{
#if  BITS_PER_LONG == 32
    x -=  (x>>1) & 0x55555555UL;                        // 0-2 in 2 bits
    x  = ((x>>2) & 0x33333333UL) + (x & 0x33333333UL);  // 0-4 in 4 bits
    x *= 0x11111111UL;
    return  x>>28;
#endif

#if  BITS_PER_LONG == 64
    x -=  (x>>1) & 0x5555555555555555UL;                                // 0-2 in 2 bits
    x  = ((x>>2) & 0x3333333333333333UL) + (x & 0x3333333333333333UL);  // 0-4 in 4 bits
    x *= 0x1111111111111111UL;
    return  x>>60;
#endif
}
// -------------------------

static inline ulong bit_count_3(ulong x)
// Return number of set bits, must have at most 3 set bits.
{
#if  BITS_PER_LONG == 32
    x -=  (x>>1) & 0x55555555UL;  // 0-2 in 2 bits
    x *= 0x55555555UL;
    return  x>>30;
#endif

#if  BITS_PER_LONG == 64
    x -=  (x>>1) & 0x5555555555555555UL;  // 0-2 in 2 bits
    x *= 0x5555555555555555UL;
    return  x>>62;
#endif
}
// -------------------------


static inline int bit_count_cmp(const ulong &a, const ulong &b)
// Compare bit counts of a and b.
{
    ulong ca = bit_count(a);
    ulong cb = bit_count(b);
    return  ( ca==cb ? 0 : (ca>cb ? +1 : -1) );
}
// -------------------------


static inline ulong bit_count_sparse(ulong x)
// Return number of bits set.
{
#if 0
    // The loop will execute once for each bit of x set:
    ulong n = 0;
    while ( x )  { ++n;  x &= (x-1); }
    return  n;

#else
    // The loop will execute ceil(c/4) if c bits of x are set:
    ulong n = 0;
    do
    {
        n += (x!=0);  x &= (x-1);
        n += (x!=0);  x &= (x-1);
        n += (x!=0);  x &= (x-1);
        n += (x!=0);  x &= (x-1);
    }
    while ( x );
    return  n;

#endif
}
// -------------------------

static inline ulong bit_count_dense(ulong x)
// Return number of bits set.
// The loop (of bit_count_sparse()) will execute once for
//   each unset bit (i.e. zero) of x.
{
    return  BITS_PER_LONG - bit_count_sparse( ~x );
}
// -------------------------


static inline ulong bit_block_count(ulong x)
// Return number of bit blocks.
// E.g.:
// ..1..11111...111.  -> 3
// ...1..11111...111  -> 3
// ......1.....1.1..  -> 3
// .........111.1111  -> 2
{
//    return  bit_count(gray_code(x))/2 + (x & 1);
    return  (x & 1) + bit_count( (x^(x>>1)) ) / 2;
}
// -------------------------


static inline ulong bit_block_ge2_count(ulong x)
// Return number of bit blocks with at least 2 bits.
// E.g.:
// ..1..11111...111.  -> 2
// ...1..11111...111  -> 2
// ......1.....1.1..  -> 0
// .........111.1111  -> 2
{
    // return bit_block_count( interior_ones(x) );
    return  bit_block_count( x & ( (x<<1) & (x>>1) ) );
}
// -------------------------


static inline ulong bit_count_01(ulong x)
// Return number of bits in a word
// for words of the special form 00...0001...11
{
#if defined  BITS_USE_ASM
    if ( 1>=x )  return x;
    x = asm_bsr(x);
    return  x + 1;
#else  // BITS_USE_ASM

    ulong ct = 0;
    ulong a;

#if  BITS_PER_LONG == 64
    a = (x & (1UL<<32)) >> (32-5);  // test bit 32
    x >>= a;  ct += a;
#endif
    a = (x & (1UL<<16)) >> (16-4);  // test bit 16
    x >>= a;  ct += a;

    a = (x & (1UL<<8)) >> (8-3);  // test bit 8
    x >>= a;  ct += a;

    a = (x & (1UL<<4)) >> (4-2);  // test bit 4
    x >>= a;  ct += a;

    a = (x & (1UL<<2)) >> (2-1);  // test bit 2
    x >>= a;  ct += a;

    a = (x & (1UL<<1)) >> (1-0);  // test bit 1
    x >>= a;  ct += a;

    ct += x & 1;  // test bit 0

    return ct;

#endif  // BITS_USE_ASM
}
// -------------------------

// bits/bitcount-v.cc:
ulong bit_count_v(const ulong *x, ulong n);


#endif  // !defined HAVE_BITCOUNT_H__

 

wfafa
关注
专栏目录
R语言计算汉明距离（Hamming Distance）实战
data+scenario+science+insight
04-18 609
R语言计算汉明距离（Hamming Distance）实战 目录 R语言计算汉明距离（Hamming Distance）实战 #汉明距离（Hamming Distance） #二值向量的汉明距离计算 #数值向量的汉明距离计算 #字符串的汉明距离 #汉明距离（Hamming Distance） 汉明距离是使用在数据传输差错控制编码里面的，汉明距离是一个概念，它表示两个（相同长度）字对应位不同的数量，我们以d（x,y）表示两个字x,y之间的汉明距离。对两个字符串进行异或运算，并统计结果为
C/C++ hamming distance汉明距离算法详解及源码
最新发布
希望我的博客，能帮上你解决学习中工作中所遇到的问题
06-21 2412
汉明距离（Hamming Distance）是衡量两个等长字符串之间的差异度量。在信息论和计算机科学中，汉明距离可以用来检测错误、纠错编码、密码学等领域。汉明距离的定义是对应位置上两个字符串不同字符的个数。例如，字符串 A = “1011101” 和字符串 B = “1001011”，它们的汉明距离是 3。因为在第 2、4、7 位置上，两个字符串的字符不同。
计算线性分组码和最小汉明距离（原创java）
06-02
利用本原多项式结果，计算线性分组码，并求出这组码的最小汉明距离，可以随意输入本原多项式和信息源位数。例如(7,4)码，本原多项式系数为（从高次到低次）为1011，产生编码如下：0001011 0010110 0011101 0100111 0101100 0110001 0111010 1000101 1001110 1010011 1011000 1100010 1101001 1110100 1111111 这组编码的最小汉明距离为：3
计算快速汉明距离
AdrianHust的专栏
03-17 1万+
汉明距离，作为一种衡量特征距离的计算方法，在很多场合都有应用，其主要思想是找到两个特征之间的差异大小，也可以说是相似性。 我是在图像处理中用到的，项目中需要计算图像梯度方向，我选择了四个方向，这样就可以用二位二进制说表示，分别为 0,1,2,3，也就是 00,01,10,11，这四种情况。这样，我就可以可以把，例如四个临近点，对应梯度特征合并为一个特征向量，如图 只需要一个字节的大小空
算法实现之汉明距离
handy周
04-13 1186
两个整数之间的汉明距离指的是这两个数字对应二进制位不同的位置的数目。 给出两个整数 x 和 y，计算它们之间的汉明距离。 注意： 0 ≤ x, y &lt; 2^31 示例: 输入: x = 1, y = 4 输出: 2 解释: 1 (0 0 0 1) 4 (0 1 0 0) C++实现 class Solution { public: ...
【算法】汉明距离
weixin_30849591的博客
04-19 592
汉明距离是以理查德·卫斯里·汉明的名字命名的。在信息论中，两个等长字符串之间的汉明距离是两个字符串对应位置的不同字符的个数。换句话说，它就是将一个字符串变换成另外一个字符串所需要替换的字符个数。例如： 1011101 与 1001001 之间的汉明距离是 2。 2143896 与 2233796 之间的汉明距离是 3。 "toned" 与 "roses" 之间的汉明距离是 3。 ...
汉明距离及其高效计算方式
schnauzers的博客
04-29 4687
什么是汉明距离 下面引用自维基百科： 在信息论中，两个等长字符串之间的汉明距离（英语：Hamming distance）是两个字符串对应位置的不同字符的个数。换句话说，它就是将一个字符串变换成另外一个字符串所需要替换的字符个数。 对于两个数字来说，汉明距离就是转成二进制后，对应的位置值不相同的个数。例如，假设有两个十进制数a=93和b=73，如果将这两个数用二进制表示的话，有a=1011101、b=1001001，可以看出，二者的从右往左数的第3位、第5位不同（从1开始数），因此，a和b的汉明距离是2。
leetcode — 461. 汉明距离 Hamming Distance
柚子
07-24 580
两个整数之间的汉明距离指的是这两个数字对应二进制位不同的位置的数目。 给定两个整数x和y，计算并返回它们之间的汉明距离。 示例 1： 输入：x = 1, y = 4 输出：2 解释： 1 (0 0 0 1) 4 (0 1 0 0) ↑ ↑ 上面的箭头指出了对应二进制位不同的位置。 示例 2： 输入：x = 3, y = 1 输出：1 提示： 0 <=x, y <= 2^31...
Python的二进制数位运算，计算汉明距离（Hamming Distance）为例
u010403272的博客
01-18 9933
Python的二进制数操作，计算汉明距离（Hamming Distance）为例 最近发现了LeetCode这个好网站，做了几道题，今后刷LeetCode学习到的新知识我都尽量抽时间记录下来，同时分享给大家。 今天就从LC上一道题说起： Given two integers x and y, calculate the Hamming distance. Hamming dis
Python:实现hamming distance汉明距离算法(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
08-08 751
Python:实现hamming distance汉明距离算法(附完整源码)
汉明距离理解与计算
weixin_42270074的博客
02-24 2761
**汉明距离**是求两个等长字符串之间对应位置的不同字符的个数。 也就是求将一个字符串变换成另一个字符串所需要替换字符的个数。 1. 有如下两个字符串 “abcde” “abbdc” 则这两个字符串的汉明距离为2，因为两个字符串的第三个和第五个位置的字符不同 2. “12345” “54321” 同理这两个字符串的汉明距离为4，除了第三个字符，其他四个字符都不同 两个整数之间的汉明距离...
距离度量 —— 汉明距离（Hamming Distance）
繁依Fanyi的博客
07-01 6531
汉明距离（Hamming Distance），就是将一个字符串变成另一个字符串所需要的替换次数。举个例子，只要将 式1 中标红的部分换一下即可。只要将 式1 中标红的部分换一下即可。只要将 式1 中标红的字母换一下即可。汉明重量 就是字符串相对于相同长度的零字符串的汉明距离；也就是说，它是字符串中非零的元素个数：对于二进制字符串来说，就是 1 的个数，所以 的汉明重量是 4。因此，如果向量空间中的元素 a 和 b 之间的汉明距离等于它们汉明重量的差 。...
图像分类-KNN算法
weixin_42394925的博客
12-21 243
import matplotlib.pyplot as plt import numpy as np def CreateDataset(): group = np.array([[1.0,2.0],[1.2,0.1],[0.1,1.4],[3.2,2.1],[0.3,3.5],[5.2,3.1],[1.0,1.1],[0.5,1.5]]) labels =np.array(['B','A','B','A','B','A','B','B']) return group,labels d
gym102823 H. Hamming Distance（贪心，字符串）
zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz
01-31 253
题意：
汉明距离之算法和实现总结
Zuocheng_Liu的专栏
08-29 2760
内容简介 汉明距离，通过比较向量每一位是否相同，求出不同位的个数。用来表示两个向量之间的相似度。 汉明距离计算的步骤，即对两个向量首先进行异或操作，然后对异或的结果的每一位bit进行统计，最后合计出有多少bit的值为1。 本文主要内容为，列举出9种计算汉明距离的算法及其C++代码的实现，并使用本文的测试方法测试得出不同算法的性能。再对不同的算法进行分析比较。 计算机在进行异或操作中，CPU的指令集可以提供多种实现。比如cpu固有指令 xor 和 SSE指令集 、AVX指令集。后两种指令集都是为了提升
【猿知识】汉明距离(Hamming Distance)
热门推荐
在这里你大概率会有所收获，欢迎指错||纠正||建议||水评+点赞&&评论&&关注&&转发
03-08 2万+
汉明距离是以理查德·卫斯里·汉明的名字命名的，汉明在误差检测与校正码的基础性论文中首次引入这个概念。在通信中累计定长二进制字中发生翻转的错误数据位，所以它也被称为信号距离。
Leetcode-Algorithms Hamming Distance(汉明距离）
oOCrowOo的学习日志
02-19 479
从今天开始每天用python做几道leetcode的题目练手，从easy到hard递进。The Hamming distance between two integers is the number of positions at which the corresponding bits are different.Given two integers x and y, calculate the
CCPC2018桂林站H. Hamming Distance —— 思维 + 贪心*
Strezia的博客
11-01 189
链接 题意： 构造一个字典序最小的字符串同时满足长度与串AB相等，并且与A的汉明距离等于与B的汉明距离，具体见题目。 思路： 贪心地构造前缀a尽可能多的字符串 一开始写复杂了，实际上有很简单的写法，即代码 check函数不要忘记给z加绝对值！ #include <iostream> // #include <bits/stdc++.h> using namespace std; const int maxn = 1e5 + 10; #define pb push_ba
Hamming Distance ccpc2018 桂林
1999
05-06 551
问题 H: Hamming Distance 时间限制:1 Sec内存限制:128 MB 提交:246解决:41 [提交] [状态] [命题人:admin] 题目描述 In information theory, the Hamming distance between two strings of equal length is the number of position...
matlab计算汉明距离
04-10
汉明距离是衡量两个等长字符串之间的差异度量。在MATLAB中，可以使用以下方法计算汉明距离： 1. 使用bitxor函数计算两个二进制字符串的异或结果。 2. 使用dec2bin函数将十进制数转换为二进制字符串。 3. 使用sum函数计算异或结果中1的个数，即为汉明距离。 下面是一个示例代码： ```matlab function hamming_distance = calculate_hamming_distance(str1, str2) % 将两个字符串转换为二进制表示 binary_str1 = dec2bin(str1); binary_str2 = dec2bin(str2); % 计算异或结果 xor_result = bitxor(binary_str1, binary_str2); % 计算汉明距离 hamming_distance = sum(xor_result == '1'); end ``` 使用示例： ```matlab str1 = 10; str2 = 7; distance = calculate_hamming_distance(str1, str2); disp(distance); ``` 这段代码将输出汉明距离的值。请注意，输入的字符串应该是等长的二进制字符串或者十进制数。如果输入的是十进制数，会自动转换为二进制字符串进行计算。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值