当时正在从事编程工作,并且一直在寻找正确的算法。这是问题所在:
给出一个十进制数字,如果提供了十进制数字,将其转换为零则需要多少个最小可能的步骤:
- 如果下一个i + 1位为“ 1”,则更改第i位,其余所有其他i + 2位,之后为0。
- 无限制地更改最后一位
例如:
如果输入为(8)Base10 =(1000)Base2,则采取的步骤为:
1000→1001→1011→1010→1110→1111→1101→1100→0100→0101→0111→0110→0010→0011→0001→0000
总共需要15个步骤。
完成以下定义:
int minStepsRequired(long number)
可以获取伪代码或仅获取算法。这不是作业或作业。
答案 0 :(得分:7)
这是递归的PHP函数,用于计算所需的步骤数。通过注意以下两个可能的要求来进行操作:
0
s(总体要求);和1
,然后转换为0
s字符串(以允许翻转前一位)第二个要求显然是第一个要求的扩展,因此可以编写一个兼有这两个要求的递归函数。对于单位长度的字符串,它有一种特殊情况,只需检查是否需要翻转即可。
function reduce($bits, $value = '0') {
if (strlen($bits) == 1) {
// a single bit can be flipped as needed
return ($bits[0] == $value) ? 0 : 1;
}
if ($bits[0] == $value) {
// nothing to do with this bit, flip the remainder
return reduce(substr($bits, 1));
}
// need to convert balance of string to 1 followed by 0's
// then we can flip this bit, and then reduce the new string to 0
return reduce(substr($bits, 1), '1') + 1 + reduce(str_pad('1', strlen($bits) - 1, '0'));
}
此函数可以适合于存储实际执行的步骤,然后步骤数仅是该数组的计数(-1,因为我们也将原始值也放入了数组中)。要存储步骤,我们需要跟踪字符串的第一部分(以下代码中的$prefix
)以及我们要减少的部分:
function reduce($bits, $prefix, $value = '0') {
if (strlen($bits) == 1) {
// a single bit can be flipped as needed
return array($prefix . ($bits[0] == '0' ? '1' : '0'));
}
if ($bits[0] == $value) {
// nothing to do with this bit, flip the remainder
$prefix .= $bits[0];
return reduce(substr($bits, 1), $prefix);
}
// need to convert balance of string to 1 followed by 0's
$prefix .= $bits[0];
$steps = reduce(substr($bits, 1), $prefix, '1');
// now we can flip this bit
$prefix = substr($prefix, 0, -1) . ($bits[0] == '0' ? '1' : '0');
$steps[] = $prefix . str_pad('1', strlen($bits) - 1, '0');
// now reduce the new string to 0
$steps = array_merge($steps, reduce(str_pad('1', strlen($bits) - 1, '0'), $prefix));
return $steps;
}
您可以这样运行:
$bin = decbin($i);
$steps = array_merge(array($bin), reduce($bin, ''));
echo "$i ($bin) takes " . (count($steps) - 1) . " steps\n";
print_r($steps);
输入为8的输出:
8 (1000) takes 15 steps
Array
(
[0] => 1000
[1] => 1001
[2] => 1011
[3] => 1010
[4] => 1110
[5] => 1111
[6] => 1101
[7] => 1100
[8] => 0100
[9] => 0101
[10] => 0111
[11] => 0110
[12] => 0010
[13] => 0011
[14] => 0001
[15] => 0000
)
灰色代码
通过查看这些步骤,我们可以看到这实际上是一个Gray code(反射二进制代码),从原始值向下计数到0。因此,如果我们生成足以覆盖起始值的代码列表,可以简单地在该列表中查找起始值的二进制表示形式,这将使我们获得返回到0所需的步骤数:
function gray_code($bits) {
if ($bits == 1) {
return array('0', '1');
}
else {
$codes = gray_code($bits - 1);
return array_merge(array_map(function ($v) { return '0' . $v; }, $codes),
array_map(function ($v) { return '1' . $v; }, array_reverse($codes))
);
}
}
$value = 8;
$bin = decbin($value);
// get sufficient gray codes to cover the input
$gray_codes = gray_code(strlen($bin));
$codes = array_flip($gray_codes);
echo "$bin takes {$codes[$bin]} steps to reduce to 0\n";
// echo the steps
for ($i = $codes[$bin]; $i >= 0; $i--) {
echo $gray_codes[$i] . PHP_EOL;
}
如果不需要单独的步骤,则可以使用格雷代码二进制转换器来查找步骤数。这是超快的:
function gray_to_binary($value) {
$dec = $value;
for ($i = 1; $i < strlen($value); $i++) {
$dec[$i] = (int)$dec[$i-1] ^ (int)$value[$i];
}
return $dec;
}
echo bindec(gray_to_binary(decbin(115)));
输出:
93
格雷码生成器
我们可以使用迭代格雷代码生成器从原始代码开始倒数。这样做的好处是它不占用任何内存来存储代码,因此可以处理非常大的数目。此版本使用格雷码二进制转换器,该整数转换器适用于整数而不是字符串,如上面的操作:
function gray_to_binary($value) {
$dec = 0;
$bits = floor(log($value, 2));
for ($i = $bits; $i >= 0; $i--) {
$dec = $dec | (((($dec >> ($i + 1)) ^ ($value >> $i)) & 1) << $i);
}
return $dec;
}
function iterate_gray($value) {
// get the equivalent starting binary value
$code = decbin($value);
yield $code;
$len = strlen($code);
$count = gray_to_binary($value);
while ($count > 0) {
// flip the bit which corresponds to the least significant 1 bit in $count
$xor = 1;
while (($count & $xor) == 0) $xor <<= 1;
$value ^= $xor;
yield sprintf("%0{$len}b", $value);
$count--;
}
}
foreach (iterate_gray(8) as $code) {
echo $code . PHP_EOL;
}
输出:
1000
1001
1011
1010
1110
1111
1101
1100
0100
0101
0111
0110
0010
0011
0001
0000
答案 1 :(得分:4)
对于递归算法,这是一个很棒的问题。
如果二进制表示的长度为0,则您已经知道答案了。或者,如果不允许长度为0,那么如果长度为1,则根据该位是0还是1来告诉答案。
如果长度大于1:
该算法可能需要很长时间。它实际上是在计算步数,因此所花费的时间与步数成正比,我认为这大致与输入数成正比。您的方法使用一个long
参数,但是对于大的long
值,如果使用我的算法,它可能不会在正在运行的计算机的生命周期内终止。同样,步数可能会使int
甚至long
溢出(如果输入为负long
值)。
编码愉快。如果那是我,我将实际进行编码并运行它以验证我是否正确。
以下解决方案不需要递归并且可以持续运行。我无法正确解释它是如何工作的,如果我们想将其用于某些方面,这是一个严重的问题。我玩了一些示例,看到了一个模式并对其进行了概括。相比之下,恕我直言,上述递归解决方案的某些优点在于它易于理解(如果您了解递归的话)。
示例:输入8或1000
二进制。结果15或1111
二进制。模式是:结果的每个位是结果的前一个位与输入中相同位置的位的异或。因此,可以从1000
复制前一位1。下一位是1 XOR 0 = 1,其中1是结果的前一位,并且从输入中获取0。其余两位的计算方法相同。
更长的示例,因此您可以检查自己是否理解:
Input: 115 = 1110011
Result: 1011101 = 93
或在代码中
static BigInteger calculateStepsRequired(long number) {
// Take sign bit
int bit = number < 0 ? 1 : 0;
BigInteger result = BigInteger.valueOf(bit);
for (int i = 0; i < 63; i++) {
number = number << 1;
int sign = number < 0 ? 1 : 0;
bit = (bit + sign) % 2;
result = result.shiftLeft(1).add(BigInteger.valueOf(bit));
}
return result;
}
我已经根据我自己对上面第一个算法的实现(使用多达1亿个输入)进行了检查,他们一直都同意,因此我相信快速方法也是正确的。
答案 2 :(得分:2)
这是Ole的“快速方法”算法的PHP实现。想法是一样的:
function getBit($number, $i)
{
// Extracts bit i from number
return ($number & (1<<$i)) == 0 ? 0 : 1;
}
function minStepsRequired($number)
{
$i = 30; // Enough to handle all positive 32-bit integers
$bit = getBit($number, $i); // First bit
$res = $bit;
do
{
$i--;
$bit ^= getBit($number, $i); // Computes XOR between previous bit of the result and current bit of the number
$res = ($res<<1) + $bit; // Shifts the result to the left by 1 position and adds the new bit
}
while($i>0);
return $res;
}
var_dump(minStepsRequired(8)); // Outputs 15
var_dump(minStepsRequired(115)); // Outputs 93
答案 3 :(得分:2)
重要的是要注意,可以保留原先的零个k位,而您只从第(k + 1)个位开始,而我们忽略了所有起始位,其值为零并始终致力于增加他们的人数。这是我们的主要目标,因此,我们总是将问题空间缩小为相似但较小的问题空间。现在,假设您的电话号码是
1 b1b2b3 ... bn
您需要确保b1为1且b2,b3,...,bn为0,以便能够将b1之前的位修改为0。在那之后,您知道b2为1并且所有后续位均为0,那么新的目标是在知道所有后续位均为0的情况下将b2更改为0。
您可以使用堆栈来跟踪进度,堆栈可以包含与所处理的位数一样多的元素,始终以其顶部表示您当前的目标。
因此,当您想将第一位清零,然后实现正确的后续位序列时,将为您分配子任务,然后才能更改位,一旦成功,则需要类似地进行操作,但忽略第一位。您可以为步骤编号。
假设有多个
1 ... 0000000
可以以2 ^ n-1的步长归零,要做的总步数等于2 ^ n-1 +达到我们在上面看到的组合所需的步数。我没有检查它是否为2 ^ n-1
答案 4 :(得分:1)
起初,我尝试使用递归深度优先功能(在NodeJS中)解决该问题,但它仅适用于小数-由于10^5
之类的输入值会由于堆栈中的递归调用。
因此,我然后尝试查看如何将问题减少为较小的问题的总和,并发现N的步骤数(N为2的幂)是
N * 2-1-
(例如:2的步数是3,32的步数是63,256的步数是511,依此类推)。
然后我找到了与其他任何数字(不是2的幂)的关系,并且由于任何整数是2的不同幂的和(因此为二进制表示),所以我只需要查看该数字是否的步骤也将加起来……但是事实并非如此。但是,我确实发现,我不仅需要将每2次幂的步数相加,还应将
从最高位开始,以另一种方式减去并添加步骤
给出数字 42 (二进制为101010
首先应用第1条规则
1 0 1 0 1 0
^ ^ ^ ^ ^ ^
| | | | | |_ 0 steps
| | | | |___ 2*2-1 = 3 steps
| | | |_____ 0 steps
| | |_______ 2*8-1 = 15 steps
| |_________ 0 steps
|___________ 2*32-1 = 63 steps
然后,应用第2条规则:
63 - 15 + 3 = 51
步骤总数为 51