如何递归地制定二元微分问题？

问题描述

我的头撞墙有一段时间了...

问题要我制定这个微分规则，应用于字节数组（源应该被覆盖），递归地，从数组的末尾（derive.length - 1）开始，向 i=0 移动。不应使用第二个数组，应覆盖输入数组。以下是迭代版本。

public static void derivative(byte[] derive) {
        
        for (int i = derive.length - 1; i > 0; i--) {
            
            if (i == 0 && derive[0] == 0) {
                derive[0] = 0;
            }
            
            if (i > 0 && derive[i] == derive[i-1]) {
                derive[i] = 0;
            }
            
            else {
                derive[i] = 1;
            }   
}

所讨论的算法将以下规则集应用于二进制数数组，例如 [1,1,1]： a[i]（输出版本）应该等于：

• 0 如果 i=0 且 a[i]=0
• 0 如果 i>0 且 a[i]=a[i-1]
• 1 其他

例如： {1,0} 变为： {1,0} 和 {0,0} 变为： {0,1}

如何递归地表达这个？

解决方法

public static byte derivative(byte[] derive,int index) {
    byte curr = derive[index];
    
    if (index == 0) {
        derive[index] = 0;
        return curr;
    } elif (derive[index] == derivative(derive,index - 1)) {
        derive[index] = 0;
        return curr;
    }

    derive[index] = 1;
    return curr;
}

编辑：修改返回类型

,

您的代码实际上是这样做的：

public static void derivative(byte[] derive) {       
    for (int i = derive.length - 1; i > 0; i--) {
         derive[i] = derive[i] == derive[i-1] ? 0 : 1;
    }   
}

我会请你检查一下。

哪个更有趣，因为它很简单。

更好的方法是使用位、每字节 8 位或长。

public static void derivative(byte[] derive) {
    long num = toBits(derive);
    num = (num >>> 1)^num;
    fromBits(bits,derive);
}

private static long bits(byte[] derive) {  
    long bits = 0;
    for (byte b : derive) {
        bits = (bits << 1) | (b == 0 ? 0 : 1);
    }
    return bits;
}

使用以下算法

{1,1,0} becomes:
{1,0}

10100

10100
 1010 shift right
----- xor
11110

顶部简化函数的递归是微不足道的。

public static void derivative(byte[] derive) {       
    derivativeRecursively(derive,derive.length - 1);
}

private static void derivativeRecursively(byte[] derive,int i) {       
    ...   
}