只是好奇心问题,格雷码是否定义为基数2以外的基数？
我试着计算基数3,写连续值,注意一次只改变一个trit.我已经能够枚举最多26(3**3-1)的所有值,它似乎工作.
000 122 200
001 121 201
002 120 202
012 110 212
011 111 211
010 112 210
020 102 220
021 101 221
022 100 222
我能看到的唯一问题是,当循环回零时,所有三个trits都会改变.但这只适用于奇数基数.当使用偶数基数循环回零时,只会改变一个数字,如二进制.
我甚至猜测它可以扩展到其他基数,甚至十进制.这可能导致在十点基数计数时的另一个排序...... :-)
0 1 2 3 4 5 6 7 8 9 19 18 17 16 15 14 13 12 11 10
20 21 22 23 24 25 26 27 28 29 39 38 37 36 35 34 33 32 31 30
现在的问题是,有没有人听说过它？有申请吗？或者它只是数学上的狂热？
据我所知,每个格雷码与前面的代码有一点不同,但我并不完全理解为什么它被称为反映.我遇到了这个网站https://www.pc-control.co.uk/gray_code.htm,其中说"灰色代码有时被称为反射二进制,因为前8个值与最后8个值相比较值,但按相反的顺序",但前8个格雷码不能与后8个格雷码相反,从网站上的格雷码表中可以看出.为了增加我的困惑,灰色代码表与我教科书上的灰色代码表不同,例如我的教科书上9 = 1000的格雷码,而在网站上则为9 = 1101.
我尝试用Python生成格雷码.此代码正常工作.问题是我正在初始化函数中的基本case(n=1,[0,1])main并将其传递给gray_code函数来计算其余部分.我想在函数本身内生成所有格雷码,包括基本案例.我怎么做？
def gray_code(g,n):
k=len(g)
if n<=0:
return
else:
for i in range (k-1,-1,-1):
char='1'+g[i]
g.append(char)
for i in range (k-1,-1,-1):
g[i]='0'+g[i]
gray_code(g,n-1)
def main():
n=int(raw_input())
g=['0','1']
gray_code(g,n-1)
if n>=1:
for i in range (len(g)):
print g[i],
main()
这个算法的递归关系是T(n)=T(n-1)+n什么？
关于遗传算法的书籍和教程解释说，使用格雷码在二进制基因组中编码整数通常比使用标准基数 2 更好。给出的原因是编码整数中 +1 或 -1 的变化，只需要一位翻转对于任何数字。换句话说，相邻整数在格雷码中也是相邻的，格雷编码中的优化问题至多具有与原始数值问题一样多的局部最优值。
与标准基数 2 相比，使用格雷码还有其他好处吗？
我写了一个通用函数来将二进制反射的格雷码转换为标准二进制.我使用了本页找到的算法.这是上述算法:
unsigned short grayToBinary(unsigned short num)
{
unsigned short temp = num ^ (num>>8);
temp ^= (temp>>4);
temp ^= (temp>>2);
temp ^= (temp>>1);
return temp;
}
然后我修改了代码,使其适用于任何标准unsigned类型.这是我写的:
template<typename Uint>
Uint grayToBinary(Uint value)
{
for (Uint mask = sizeof(Uint)*4 ; mask ; mask >>= 1)
{
value ^= value >> mask;
}
return value;
}
该算法似乎适用于每种unsigned标准类型.然而,在写它时,我本能地使用,sizeof(Uint)*4因为它有意义的结束条件将取决于类型大小,但事实是我不知道sizeof(Uint)*4实际代表什么.就目前而言,这是我本能地写的一个神奇的数字,但我无法解释为什么它适用*4而不是任何其他系数.
有人知道这个神奇数字实际上对应的是什么吗？
除了海明距离外,我得到了一切.我一直得到错误"int()无法使用显式基础转换非字符串"
这是我的代码:
def int2bin(n):
if n:
bits = []
while n:
n,remainder = divmod(n, 2)
bits.insert(0, remainder)
return bits
else: return [0]
def bin2gray(bits):
return bits[:1] + [i ^ ishift for i, ishift in zip(bits[:-1], bits[1:])]
def hamming(a,b):
assert len(a) == len(b)
count,z = 0,int(a,2)^int(b,2)
while z:
count += 1
z &= z-1
return count
def main():
a = int(input("Positive integer 1: "))
b = int(input("Positive integer 2: "))
print('int:%2i binary:%12r BRGC:%12r' %
( a,
int2bin(a),
bin2gray(int2bin(a))
))
print('int:%2i binary:%12r …我最近遇到了格雷码，我一直在试图围绕用于将格雷码转换回二进制（32 位或更少）的高效算法进行思考。
num = num ^ (num >> 16);
num = num ^ (num >> 8);
num = num ^ (num >> 4);
num = num ^ (num >> 2);
num = num ^ (num >> 1);
这是我正在谈论的代码。现在这是我的问题：
mask == 0）有什么区别？如果我们反过来做，有什么区别：
num = num ^ (num >> 1);
num = num ^ (num >> 2);
num = num ^ (num >> 4);
num = num ^ (num >> 8); …什么是"灰色代码连续"应该是什么意思？我的意思是10和11在十进制系统中是连续的,但什么是"灰色代码中的连续"含义？我只知道格雷码是一个二进制数字系统,其中两个连续值只有一位不同.
这是一个在线解决方案,但我无法理解这一点
private static int graycode(byte term1, byte term2) {
byte x = (byte)(term1^term2); // why use XOR?
int count = 0;
while(x!=0)
{
x = (byte)(x &(x-1)); // why use bitwise operator?
count++; // what is count?
}
return count == 1;
}
我试着理解花了一个小时,但我仍然没有线索.
计算二进制补码绝对值的最快方法是一种足够常见的操作，优化的实现已广泛使用。那么让我们考虑另一种情况。如果我们想使用 x86 汇编获取补码的绝对值怎么办？
我拥有的一个快速但可能不是最理想的无分支实现是通过与 10000.... 掩码和移位来获取符号位，将其与 11111... 掩码相乘，然后将其与原始数字进行异或。但有更好的方法吗？
出现这种情况的一个应用是格雷解码的最佳实现。64 位整数的格雷解码的常见实现使用六个异或运算和六个位移位。然而，数字与......1111110 的无进位乘法将给出格雷解码或其按位求反，并取其补码abs 值给出格雷解码。只要可以进行微优化，它就应该比最普遍的方法更快。出于该问题的目的，起始状态可以假定为任何标准 C 调用约定或 CLMUL 操作之后（采用非进位输出）。