此处定义了吸血鬼号码https://en.wikipedia.org/wiki/Vampire_number。数字V是吸血鬼号码，如果：
我想出了一个解决方案，
strV = sort(toString(V))
for factor <- pow(10, N/2) to sqrt(V)
if factor divides V
X <- factor
Y <- V/factor
if X and Y have trailing zeros
continue
checkStr = sort(toString(X) + toString(Y))
if checkStr equals strV return true
另一种可能的解决方案是置换由V表示的字符串并将其分成两半并检查它是否为吸血鬼号码。哪一个是最佳方式？
答案 0 :(得分：15)
我在这里提出的算法不会经历所有数字排列。它将尽可能快地消除可能性，以便实际上只测试一小部分排列。
以下是基于示例编号125460的工作原理。如果你可以直接阅读代码，那么你可以跳过这个（长篇）部分：
起初，两个尖牙（即吸血鬼因素）显然未知，问题可以表示如下：
?**
X ?**
-------
=125460
对于第一个因子的最左边数字（标有?），我们可以选择任何数字0,1,2,5,4或6.但仔细分析0不会是可行的可能性，因为产品永远不会超过5位数。因此，通过以零开头的所有数字排列将是浪费时间。
对于第二个因子的最左边的数字（也标有?），情况也是如此。但是，在查看组合时，我们可以再次筛选出一些无法有助于达到目标产品的对。例如，应该放弃这种组合：
1**
X 2**
-------
=125460
这些数字可以达到的最大数字是199x299 = 59501（忽略了我们甚至没有9的事实），这甚至不是所需数字的一半。所以我们应该拒绝组合（1,2）。出于同样的原因，可以丢弃对（1,5）以获取这些位置。类似地，也可以拒绝对（4,5），（4,6）和（5,6），因为它们产生太大的产物（> = 200000）。我将这种测试称为一种测试 - 确定目标数量是否在某个选定数字对的范围内，＆＃34;范围测试＆＃34;。
在这个阶段，第一个和第二个牙齿没有区别，所以我们也不必研究第二个数字小于第一个数字的对，因为它们反映了一对已经被调查的对（或者拒绝）。
所有可能占据第一个位置的可能对（从一组6个数字中取出2个数字有30种可能性），只需要调查以下4个：
(1, 6), (2, 4), (2, 5), (2, 6)
在更详细的符号中，这意味着我们将搜索限制为这些数字模式：
1** 2** 2** 2**
X 6** X 4** X 5** X 6**
------- ------- ------- -------
=125460 =125460 =125460 =125460
A B C D
很明显，即使查看其他位置，这种可能性的减少也会大大减少搜索树。
算法将按顺序采用这4种可能性中的每一种，并且每种可能性将检查下一个数字位置的可能性。因此，首先分析配置A：
1?*
X 6?*
-------
=125460
可用于?标记位置的对是这12个：
(0, 2), (0, 4), (0, 5)
(2, 0), (2, 4), (2, 5)
(4, 0), (4, 2), (4, 5)
(5, 0), (5, 2), (5, 4)
同样，我们可以通过应用范围测试来消除对。让我们来看一对（5,4）。这意味着我们有因子15 *和64 *（其中*是此时的未知数字）。这两者的乘积将最大化为159 * 649，即103191（再次忽略我们甚至没有9可用的事实）：这对于到达目标来说太低了，所以可以忽略这一对。通过进一步应用范围测试，可以丢弃所有这12对，因此配置A中的搜索在此处停止：那里没有解决方案。
然后算法移动到配置B：
2?*
X 4?*
-------
=125460
同样，范围测试应用于第二个位置的可能对，并且再次证明这些对中没有一个通过测试：例如（5,6）永远不能代表比259 * 469更大的产品= 121471，（只是）太小了。
然后算法转到选项C：
2?*
X 5?*
-------
=125460
在所有12个可能的对中，只有以下在范围测试中存活：（4,0），（4,1），（6,0），（6,1）。所以现在我们有以下第二级配置：
24* 24* 26* 26*
X 50* X 51* X 50* X 51*
------- ------- ------- -------
=125460 =125460 =125460 =125460
Ca Cb Cc Cd
在配置Ca中，没有通过范围测试的对。
在配置Cb中，对（6,0）通过，并导致解决方案：
246
X 510
-------
=125460
此时算法停止搜索。结果很清楚。总的来说，与蛮力置换检查算法相比，所看到的配置的数量非常少。以下是搜索树的可视化：
*-+-- (1, 6)
|
+-- (2, 4)
|
+-- (2, 5) -+-- (4, 0)
| |
| +-- (4, 1) ---- (6, 0) = success: 246 * 510
/ /
| +-- (6, 0)
| |
| +-- (6, 1)
|
+-- (2, 6) ---- (0, 1) ---- (4, 5) = success: 204 * 615
/下面的变体仅用于显示算法可能做的其他内容，如果没有找到解决方案的话。但在这个实际案例中，搜索树的那部分实际上从未被跟踪过。
我不清楚时间复杂度，但对于较大的数字似乎运行良好，表明在早期阶段消除数字会使搜索树的宽度变窄。
这是一个实时的JavaScript实现，它在激活时也会运行一些测试用例（并且还有一些其他的优化 - 请参阅代码注释）。
/*
Function: vampireFangs
Arguments:
vampire: number to factorise into two fangs, if possible.
Return value:
Array with two fangs if indeed the argument is a vampire number.
Otherwise false (not a vampire number) or null (argument too large to
compute)
*/
function vampireFangs(vampire) {
/* Function recurse: for the recursive part of the algorithm.
prevA, prevB: partial, potential fangs based on left-most digits of the given
number
counts: array of ten numbers representing the occurrence of still
available digits
divider: power of 100, is divided by 100 each next level in the search tree.
Determines the number of right-most digits of the given number that
are ignored at first in the algorithm. They will be considered in
deeper levels of recursion.
*/
function recurse(vampire, prevA, prevB, counts, divider) {
if (divider < 1) { // end of recursion
// Product of fangs must equal original number and fangs must not both
// end with a 0.
return prevA * prevB === vampire && (prevA % 10 + prevB % 10 > 0)
? [prevA, prevB] // Solution found
: false; // It's not a solution
}
// Get left-most digits (multiple of 2) of potential vampire number
var v = Math.floor(vampire/divider);
// Shift decimal digits of partial fangs to the left to make room for
// the next digits
prevA *= 10;
prevB *= 10;
// Calculate the min/max A digit that can potentially contribute to a
// solution
var minDigA = Math.floor(v / (prevB + 10)) - prevA;
var maxDigA = prevB ? Math.floor((v + 1) / prevB) - prevA : 9;
if (maxDigA > 9) maxDigA = 9;
for (var digA = minDigA; digA <= maxDigA; digA++) {
if (!counts[digA]) continue; // this digit is not available
var fangA = prevA + digA;
counts[digA]--;
// Calculate the min/max B digit that can potentially contribute to
// a solution
var minDigB = Math.floor(v / (fangA + 1)) - prevB;
var maxDigB = fangA ? (v + 1) / fangA - prevB : 9;
// Don't search mirrored A-B digits when both fangs are equal until now.
if (prevA === prevB && digA > minDigB) minDigB = digA;
if (maxDigB > 9) maxDigB = 9;
for (var digB = minDigB; digB <= Math.min(maxDigB, 9); digB++) {
if (!counts[digB]) continue; // this digit is not available
var fangB = prevB + digB;
counts[digB]--;
// Recurse by considering the next two digits of the potential
// vampire number, for finding the next digits to append to
// both partial fangs.
var result = recurse(vampire, fangA, fangB, counts, divider / 100);
// When one solution is found: stop searching & exit search tree.
if (result) return result; // solution found
// Restore counts
counts[digB]++;
}
counts[digA]++;
}
}
// Validate argument
if (typeof vampire !== 'number') return false;
if (vampire < 0 || vampire % 1 !== 0) return false; // not positive and integer
if (vampire > 9007199254740991) return null; // beyond JavaScript precision
var digits = vampire.toString(10).split('').map(Number);
// A vampire number has an even number of digits
if (!digits.length || digits.length % 2 > 0) return false;
// Register per digit (0..9) the frequency of that digit in the argument
var counts = [0,0,0,0,0,0,0,0,0,0];
for (var i = 0; i < digits.length; i++) {
counts[digits[i]]++;
}
return recurse(vampire, 0, 0, counts, Math.pow(10, digits.length - 2));
}
function Timer() {
function now() { // try performance object, else use Date
return performance ? performance.now() : new Date().getTime();
}
var start = now();
this.spent = function () { return Math.round(now() - start); }
}
// I/O
var button = document.querySelector('button');
var input = document.querySelector('input');
var output = document.querySelector('pre');
button.onclick = function () {
var str = input.value;
// Convert to number
var vampire = parseInt(str);
// Measure performance
var timer = new Timer();
// Input must be valid number
var result = vampire.toString(10) !== str ? null
: vampireFangs(vampire);
output.textContent = (result
? 'Vampire number. Fangs are: ' + result.join(', ')
: result === null
? 'Input is not an integer or too large for JavaScript'
: 'Not a vampire number')
+ '\nTime spent: ' + timer.spent() + 'ms';
}
// Tests (numbers taken from wiki page)
var tests = [
// Negative test cases:
[1, 999, 126000, 1023],
// Positive test cases:
[1260, 1395, 1435, 1530, 1827, 2187, 6880,
102510, 104260, 105210, 105264, 105750, 108135,
110758, 115672, 116725, 117067, 118440,
120600, 123354, 124483, 125248, 125433, 125460, 125500,
13078260,
16758243290880,
24959017348650]
];
tests.forEach(function (vampires, shouldBeVampire) {
vampires.forEach(function (vampire) {
var isVampire = vampireFangs(vampire);
if (!isVampire !== !shouldBeVampire) {
output.textContent = 'Unexpected: vampireFangs('
+ vampire + ') returns ' + JSON.stringify(isVampire);
throw 'Test failed';
}
});
});
output.textContent = 'All tests passed.';N: <input value="1047527295416280"><button>Vampire Check</button>
<pre></pre>
由于JavaScript使用64位浮点表示，因此上述代码段仅接受最多2 53 -1的数字。超过该限制将导致精度损失，从而导致不可靠的结果。
由于Python没有这样的限制，我还在eval.in上放了一个Python实现。该网站对执行时间有限制，因此如果成为问题，您必须在其他地方运行它。
答案 1 :(得分：3)
在伪代码中：
if digitcount is odd return false
if digitcount is 2 return false
for A = each permutation of length digitcount/2 selected from all the digits,
for B = each permutation of the remaining digits,
if either A or B starts with a zero, continue
if both A and B end in a zero, continue
if A*B == the number, return true
这里仍然可以执行许多优化，主要是确保每个可能的因子对只尝试一次。换句话说，如何在选择排列时最好地检查重复数字？
但这是我要使用的算法的要点。
P.S。：你不是在寻找素数，为什么要使用素数测验？你只关心这些是否是 vampire 号码;只有极少数可能的因素。无需检查所有数字，直至sqrt（数字）。
答案 2 :(得分：2)
以下是一些建议：
首先是一个简单的改进：如果位数是＆lt; 4或奇数返回false（或者如果v也是负数）。
您不需要对v进行排序，只需计算每个数字出现的次数O（n）。
您不必检查每个数字，只检查数字可能的组合。这可以通过回溯来完成，并显着减少必须检查的数字量。
检查是否使用了所有数字的最终排序也是不需要的，只需将两个数字的已用数字相加，然后与v中的出现进行比较。
以下是类似JS的语言的代码，其中整数从不溢出，V参数是一个不带前导0的整数字符串：
编辑：事实证明，代码不仅是JS- ，而且是，但有效的JS代码并没有问题可以确定1047527295416280确实是吸血鬼号码（jsfiddle）。
var V, v, isVmp, digits, len;
function isVampire(numberString) {
V = numberString;
if (V.length < 4 || V.length % 2 == 1 )
return false;
v = parseInt(V);
if (v < 0)
return false;
digits = countDigits(V);
len = V.length / 2;
isVmp = false;
checkNumbers();
return isVmp;
}
function countDigits(s) {
var offset = "0".charCodeAt(0);
var ret = [0,0,0,0,0,0,0,0,0,0];
for (var i = 0; i < s.length; i++)
ret[s.charCodeAt(i) - offset]++;
return ret;
}
function checkNumbers(number, depth) {
if (isVmp)
return;
if (typeof number == 'undefined') {
for (var i = 1; i < 10; i++) {
if (digits[i] > 0) {
digits[i]--;
checkNumbers(i, len - 1);
digits[i]++;
}
}
} else if (depth == 0) {
if (v % number == 0) {
var b = v / number;
if (number % 10 != 0 || b % 10 != 0) {
var d = countDigits('' + b);
if (d[0] == digits[0] && d[1] == digits[1] && d[2] == digits[2] &&
d[3] == digits[3] && d[4] == digits[4] && d[5] == digits[5] &&
d[6] == digits[6] && d[7] == digits[7] && d[8] == digits[8] &&
d[9] == digits[9])
isVmp = true;
}
}
} else {
for (var i = 0; i < 10; i++) {
if (digits[i] > 0) {
digits[i]--;
checkNumbers(number * 10 + i, depth - 1);
digits[i]++;
}
}
}
}