Arrays 检查两个阵列是否相似

给定两个数组，检查它们是否相似（即具有相同的整数，每个整数出现的次数相同）

例如：

int arr1[5] = { 3, 5, 2, 5, 2}
int arr2[5] = { 2, 3, 5, 5, 2}

我不允许使用排序和哈希表。它应该是O（n），不应该使用任何额外的空间

这是一个面试问题

尝试了以下规则：

两个数组中的整数之和应相同

两个数组中整数的乘积应该相同

所有整数的XOR应为零

---

但面试官还是不高兴。也许我遗漏了一些关键案例。

用JavaScript试试这个算法：

var arr11=[3,5,2,5,2]
var arr22=[2,3,5,5,2]
控制台日志（arraySimilar（arr11，arr22））；
函数数组相似（arr1，arr2）{
var-tempArr=arr2；
//检查两个数组是否相等的长度
if（arr1.length==arr2.length）{
//为第一个数组运行For循环
对于（i=0；i请在JavaScript中尝试此算法：


var arr11=[3,5,2,5,2]
var arr22=[2,3,5,5,2]
控制台日志（arraySimilar（arr11，arr22））；
函数数组相似（arr1，arr2）{
var-tempArr=arr2；
//检查两个数组是否相等的长度
if（arr1.length==arr2.length）{
//为第一个数组运行For循环
对于（i=0；i第一个数组，无论它是否包含非重复元素，都有两种可能的方法。为了简单起见，假设第一个数组不包含重复元素，那么这个想法非常简单，就像我下面的代码中那样跟踪总数

#include <iostream>

int  main()
{ 
    int arr1[5] = { 1, 2, 3, 4, 5};
    int arr2[5] = { 5, 1, 3, 4, 2};

    int total(0);

    for (unsigned int i(0); i < 5; ++i)
    {
        for (unsigned int j(0); j < 5; ++j)
        {
            if ( arr1[i] == arr2[j] )
            {
                total += 1;
            }
        }
    }
    if ( total == 5 ) 
        std::cout << "Same " << std::endl;
    else 
        std::cout << "not Same " << std::endl;

    std::cin.get();
    return 0;
}

#包括
int main（）
{ 
int arr1[5]={1,2,3,4,5}；
int arr2[5]={5,1,3,4,2}；
整数合计（0）；
for（无符号整数i（0）；i<5；++i）
{
for（无符号整数j（0）；j<5；++j）
{
if（arr1[i]==arr2[j]）
{
总数+=1；
}
}
}
如果（总数=5）
std:：cout对于第一个数组，无论它是否包含非重复元素，都有两种可能的方法。为了简单起见，假设第一个数组不包含重复元素，那么这个想法非常简单，就像我下面的代码中那样跟踪总数

#include <iostream>

int  main()
{ 
    int arr1[5] = { 1, 2, 3, 4, 5};
    int arr2[5] = { 5, 1, 3, 4, 2};

    int total(0);

    for (unsigned int i(0); i < 5; ++i)
    {
        for (unsigned int j(0); j < 5; ++j)
        {
            if ( arr1[i] == arr2[j] )
            {
                total += 1;
            }
        }
    }
    if ( total == 5 ) 
        std::cout << "Same " << std::endl;
    else 
        std::cout << "not Same " << std::endl;

    std::cin.get();
    return 0;
}

#包括
int main（）
{ 
int arr1[5]={1,2,3,4,5}；
int arr2[5]={5,1,3,4,2}；
整数合计（0）；
for（无符号整数i（0）；i<5；++i）
{
for（无符号整数j（0）；j<5；++j）
{
if（arr1[i]==arr2[j]）
{
总数+=1；
}
}
}
如果（总数=5）
std：：cout可能他的意思是你应该比较f（x[i]）和f（y[i]）的和，其中x和y是数组，f是散列函数。
可能他的意思是你应该比较f（x[i]）和f（y[i]）的和，其中x和y是数组，f是散列函数。
我可以想出一种执行此任务的方法，如果元素值是整数并且以
n
为界（
1…n
），其中
n
是数组的大小（这适用于您的示例）：

在每个数组中，对于每个元素
x
，我们执行
arr[x%（n+1）-1]+=n+1
。我们使用mod，因为元素在整个过程中可能会发生变化，通过使用mod，我们可以得到原始数组中出现的元素

我们所做的是通过添加
n+1
来计算
arr[v]
中一个值
v
的出现次数，然后我们可以通过执行
arr[v]%（n+1）
来获得原始值，因为该值以
n
为边界，并且通过执行
arr[v]/（n+1）
来获得出现次数

最后，我们比较
A
和
B
中每个值的出现次数，如果任何值不同，我们返回
false
。如果所有值的计数相同，我们返回
true

这是一个
O（n）
时间解决方案，需要
O（1）
内存

以下是算法：

bool checkIfArraysAreSimilar(int[] A, int[] B)
{
    n = A.length; // = B.length
    int i;

    for (i = 0; i < n; i++)
    {
        A[(A[i]%(n+1))-1] += n+1;
        B[(B[i]%(n+1))-1] += n+1;
    }

    for (i = 0; i < n; i++)
    {
        if (A[i] / n+1 != B[i] / n+1)
            return false;
    }

    return true;
}

bool CHECKIFARRAYSALISIMILAR（int[]A，int[]B）
{
n=A.长度；//=B.长度
int i；
对于（i=0；i
我可以想出一种执行此任务的方法，如果元素值是整数并且以
n
（
1…n
）为边界，其中
n
是数组的大小（这适用于您的示例）：

在每个数组中，对于每个元素
x
，我们执行
arr[x%（n+1）-1]+=n+1
。我们使用mod，因为元素在整个过程中可能会发生变化，通过使用mod，我们可以得到原始数组中出现的元素

我们所做的是通过添加
n+1
来计算
arr[v]
中一个值
v
的出现次数，然后我们可以通过执行
arr[v]%（n+1）
来获得原始值，因为该值以
n
为边界，并且通过执行
arr[v]/（n+1）
来获得出现次数

最后，我们比较
A
和
B
中每个值的出现次数，如果任何值不同，我们返回
false
。如果所有值的计数相同，我们返回
true

这是一个
O（n）
时间解决方案，需要
O（1）
内存

以下是算法：

bool checkIfArraysAreSimilar(int[] A, int[] B)
{
    n = A.length; // = B.length
    int i;

    for (i = 0; i < n; i++)
    {
        A[(A[i]%(n+1))-1] += n+1;
        B[(B[i]%(n+1))-1] += n+1;
    }

    for (i = 0; i < n; i++)
    {
        if (A[i] / n+1 != B[i] / n+1)
            return false;
    }

    return true;
}

bool CHECKIFARRAYSALISIMILAR（int[]A，int[]B）
{
n=A.长度；//=B.长度
int i；
对于（i=0；i
这是你被问到的问题的逐字副本吗？如果是的话，它非常模糊，我不确定问的是什么。基本上，如果一个数组是其他数组的排列
bool checkIfArraysAreSimilar(int[] A, int[] B)
{
    n = A.length; // = B.length
    int i;

    for (i = 0; i < n; i++)
    {
        A[(A[i]%(n+1))-1] += n+1;
        B[(B[i]%(n+1))-1] += n+1;
    }

    for (i = 0; i < n; i++)
    {
        if (A[i] / n+1 != B[i] / n+1)
            return false;
    }

    return true;
}