检查两个数字是否相互排列？

Question

给定两个数字 a, b 使得 1

例如 - 123 是 312 的有效排列

我也不想对数字中的数字进行排序。

Answer 1

这是作业吗？

计算每个数字出现的次数并比较它们，如果它们相同，则可以使用置换将一个数字转换为另一个数字。

Answer 2

如果您指的是数字的字符（例如 1927 和 9721），则（至少）有几种方法。

如果允许您进行排序，一种方法是简单地将它们sprintf 分配到两个缓冲区，对缓冲区中的字符进行排序，然后查看字符串是否相等。

但是，鉴于您希望不对数字进行排序，另一种选择是设置一个十元素数组，所有元素最初都设置为零，然后处理第一个数字中的每个数字，递增相关元素。

然后对第二个数字做同样的事情，但要递减。

如果最后仍然全为零，则这些数字是彼此的排列。

这是一种高效的O(n) 算法，其中n 是两个数字中的位数。这种野兽的伪代码类似于：

def arePermutations (num1, num2):
    create array count, ten elements, all zero.
    for each digit in num1:
        increment count[digit]
    for each digit in num2:
        decrement count[digit]
    for each item in count:
        if item is non-zero:
            return false
    return true

在 C 语言中，下面的完整程序说明了如何做到这一点：

#include <stdio.h>
#include <stdlib.h>

#define FALSE (1==0)
#define TRUE  (1==1)

int hasSameDigits (long num1, long num2) {
    int digits[10];
    int i;

    for (i = 0; i < 10; i++)      // Init all counts to zero.
        digits[i] = 0;

    while (num1 != 0) {           // Process all digits.
        digits[num1%10]++;        // Increment for least significant digit.
        num1 /= 10;               // Get next digit in sequence.
    }

    while (num2 != 0) {           // Same for num2 except decrement.
        digits[num2%10]--;
        num2 /= 10;
    }

    for (i = 0; i < 10; i++)
        if (digits[i] != 0)       // Any count different, not a permutation.
            return FALSE;

    return TRUE;                  // All count identical, was a permutation.
}

 

int main (int c, char *v[]) {
    long v1, v2;

    if (c != 3) {
        printf ("Usage: %s <number1> <number2>\n", v[0]);
        return 1;
    }

    v1 = atol (v[1]);
    v2 = atol (v[2]);
    if (hasSameDigits (v1, v2)) {
        printf ("%d and %d are permutations\n", v1, v2);
    } else {
        printf ("%d and %d are not permutations\n", v1, v2);
    }

    return 0;
}

只需传递两个（正）数字，假设它们适合 long，它会告诉您它们是否具有相同的数字计数。

Answer 3

创建一个数组：

int digitOccurances[2][10];

在digitOccruances[X][N] 中存储数字N 在数字X 中出现的次数。因此，如果您将 8675309 与 9568733 进行比较，则数组最终会如下所示：

{ { 1, 0, 0, 1, 0, 1, 1, 1, 1, 1 } , { 0, 0, 0, 2, 0, 1, 1, 1, 1, 1 } }

如果两个数组相等，则数字是排列。

这是一个 O(n) 算法，所以渐近地说，这是最有效的（如果不检查所有数字至少一次，您将无法解决此问题。

如果数字的长度不同，您可以立即返回 false，因此假设两者的长度均为 n。填充数组需要 2n 次操作，然后恰好 10 次比较才能读取数组。 2n + 10 是 O(n)。

Answer 4

a 和 b 如果每个数字的数字相同，则它们是字谜。所以基本上最快的方法似乎是，计算 a 和 b 的数字：

int c[10]={0,0,0,0,0,0,0,0,0,0}

while (a) { c[a%10]++; a/=10; }
while (b) { c[b%10]--; b/=10; }

int res=1;
for (int i=0;i<10;i++) res &= c[i]==0;
printf(res?"yes":"no");

Answer 5

如果你能建立一个 80GB 的表，你总是可以做到的：

int64 table[10000000000] = {0, blah blah..., 9999999999};

if (table[a] == table[b]) ...

Answer 6

{已编辑以添加额外的测试）

假设你在数字领域，怎么样

if 
(
    ('1' ^ '2' ^ '3' == '3' ^ '1' ^ '2') &&
    ('1' + '2' + '3' == '3' + '1' + '2')
)
{
    cout << "Yes\n";
}
else
{
    cout << "No\n";
}

Answer 7

如果我从您的问题中正确理解，则排列是元素的组合，不会重复。因此，如果 123 是 312 的有效排列，那么

123,
213,
132,
321,
213, 

等等。

因此，基于此假设，假设您有两个整数 123456789 和 129837456。（为简单起见，我还假设两个数字的长度相同）。如果您理解了这一点，那么您也许还可以检查不同的排列和组合。

为此，您需要做的就是从给定数字中获取单位的整数，例如：

Number 123456789 is
1 * 100000000 + 
2 * 10000000  +
3 * 1000000   +
4 * 100000    +
5 * 10000     +
6 * 1000      +
7 * 100       +
8 * 10        +
9 

或

1 * power(10, 8) +
2 * power(10, 7) +
3 * power(10, 6) +
4 * power(10, 5) +
5 * power(10, 4) +
6 * power(10, 3) +
7 * power(10, 2) +
8 * power(10, 1) +
9 * power(10, 0) 

我已经从字面上给了你如何做到这一点的算法提示，所以这很容易做到。完成后，您将得到单独的整数（最好将这些值保存在数组中）

1, 2, 3, 4, 5, 6, 7, 8, 9

现在

对另一个给定的整数做同样的事情，这样你最终会得到另一个整数数组

1, 2, 9, 8, 3, 7, 4, 5, 6

所以现在你需要检查的是，如果第二个数组的所有整数都存在于第一个整数数组中，如果是，那么它们是第一个数组的整数或第一个数字的排列。

我希望这会有所帮助。

Answer 8

我在rossetacode.org 上找到了这个相当有效的解决方案。我希望你能原谅我用 Java 编写它（我对 C 不太习惯），但语法应该或多或少相同。

代码首先检查数字是否具有相同的位数，然后通过位移将这些数字相加为总数。除了移位距离乘以因子 6。这使得较小的数字不可能与较大的数字组成相同的值。例如，一个 '9' 需要 64 次 '8' 才能匹配它的值，这显然是不可能的。

此代码假定非负输入。

boolean haveSameDigits(long n1, long n2) {
    long nn1 = n1, nn2 = n2;
    while (nn1 > 0 && nn2 > 0) {
        nn1 /= 10;
        nn2 /= 10;
    }
    if (nn2 != nn1) // not the same length
        return false;

    long total1 = 0, total2 = 0;
    while (n1 != 0) {
        total1 += 1L << ((n1 % 10) * 6);
        total2 += 1L << ((n2 % 10) * 6);
        n1 /= 10;
        n2 /= 10;
    }
    return total1 == total2;
}

Answer 9

不确定您为什么不想排序，除非这是您的家庭作业的条件。对于任何偶然发现这个问题的人，他们只是在寻找最快（也是最 Pythonic！）的方法来测试两个整数是否是 Python 中的排列：

def arePermutations(a, b):
    return sorted([d for d in str(a)]) == sorted([d for d in str(b)])

这个解决方案在 Python 中运行得稍微快一些，当然，它依赖于被测试的数字是相对较小的整数。它对 Project Euler 问题 52 非常有效。

Answer 10

您可以简单地计算数字的平方和： 123 = (1 * 1) + (2 * 2) + (3 * 3) 并将它们一起比较。如果它们的平方和相同，则它们是彼此的有效排列。