C语言中的置乱数组

我是C的新手！所以我得到两个等长整数数组作为输入和一个len，它总是等于两个数组的len。我应该验证数组A中的整数是否等于数组B中的整数，顺序无关紧要

例如，以下是确定的：

A[:)] = {1,2,3}
B[:(] = {3,2,1}

但以下几点并不好：

A[:)] = {1,1,1}
B[:(] = {1,2,3}

下面是我的代码，我在main.c中添加了一个示例测试。但是，我的代码无法生成正确的答案。但我不知道为什么，我想知道是否有人能帮我指出哪里出了问题。提前谢谢

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

//flag = 1 means the two arrays are equal, or empty
//flag = 0 means that the two arrays are not equal

int scrambled( int a[], int b[], int len)
{
    int i = 0;
    int j = 0;
    int flag = 0;

    if (len == 0)
    {
        return 1;
    }

    for(i = 0; i < len; i++)
    {   
        flag = 0;

        for( j = 0; j < len; j++)
        {
            if( a[i] == b[j])
            {
                flag = 1;
            }
        }

        if(flag == 0)
        {
            printf("Number not found\n");
            return flag;
        }

    }

    printf("Here is flag: %d\n", flag);
    return flag;
}

int main()
{
    int array[100] = {1,1,1};
    int array2[100] = {1,2,3} ;

    int len = 3;

    scrambled(array,array2,len);
}

#包括
#包括
#包括
//flag=1表示两个数组相等或为空
//flag=0表示两个数组不相等
整数加扰（整数a[]，整数b[]，整数len）
{
int i=0；
int j=0；
int标志=0；
如果（len==0）
{
返回1；
}
对于（i=0；i

您的代码只检查a[]中的每个数字是否都存在于b[]中，而不是相反。 []只包含1的-->{1,1,1}。它根据b[]检查所有三个1，每次在b[]中找到1

---

代码还应检查b[]中的每个数字是否都存在于a[]中。如果您添加了它，那么您的代码就完成了

这很有效。。（请注意，对于大型阵列，气泡排序速度较慢！）

#包括
静态无效气泡\排序\整数（整数a[]，整数len）
{
inti，j，t；
对于（i=0；ia[j]）{
t=a[i]；
a[i]=a[j]；
a[j]=t；
}
}
}
}
静态整数加扰（整数a[]，整数b[]，整数len）
{
气泡排序（a，len）；
气泡排序整数（b，len）；
int i；
对于（i=0；i

您的代码只检查a[]中的每个数字是否都存在于b[]中，而不是相反。 []只包含1的-->{1,1,1}。它根据b[]检查所有三个1，每次在b[]中找到1

---

代码还应检查b[]中的每个数字是否都存在于a[]中。如果您添加了它，那么您的代码就完成了

这很有效。。（请注意，对于大型阵列，气泡排序速度较慢！）

#包括
静态无效气泡\排序\整数（整数a[]，整数len）
{
inti，j，t；
对于（i=0；ia[j]）{
t=a[i]；
a[i]=a[j]；
a[j]=t；
}
}
}
}
静态整数加扰（整数a[]，整数b[]，整数len）
{
气泡排序（a，len）；
气泡排序整数（b，len）；
int i；
对于（i=0；i

您的代码实际上是在告诉您第一个数组中的每个值是否都可以在第二个数组中找到。 我建议您通过交换所述阵列来运行函数2次，并比较结果：

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

//flag = 1 means the two arrays are equal, or empty
//flag = 0 means that the two arrays are not equal

int scrambled( int a[], int b[], int len)
{
    int i = 0;
    int j = 0;
    int flag = 0;

    if (len == 0)
    {
        return 1;
    }

    for(i = 0; i < len; i++)
    {
        flag = 0;

        for( j = 0; j < len; j++)
        {
            if( a[i] == b[j])
            {
                flag = 1;
            }
        }

        if (flag == 0)
            return flag;

    }
    return flag;
}

int main()
{
    int array[100] = {1,1,1};
    int array2[100] = {1,2,3} ;

    int len = 3;

    if (scrambled(array,array2,len) && scrambled(array2,array,len))
        printf("Equal\n");
    else
        printf("Not equal\n");
}

#包括
#包括
#包括
//flag=1表示两个数组相等或为空
//flag=0表示两个数组不相等
整数加扰（整数a[]，整数b[]，整数len）
{
int i=0；
int j=0；
int标志=0；
如果（len==0）
{
返回1；
}
对于（i=0；i

---

对于

{1,3,2}，输出是
相等的
；{1,2,3}

和

不等于
{1,1,1}；{1,2,3}
您的代码实际上在告诉您第一个数组中的每个值是否都可以在第二个数组中找到。
我建议您通过交换所述阵列来运行函数2次，并比较结果：

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

//flag = 1 means the two arrays are equal, or empty
//flag = 0 means that the two arrays are not equal

int scrambled( int a[], int b[], int len)
{
    int i = 0;
    int j = 0;
    int flag = 0;

    if (len == 0)
    {
        return 1;
    }

    for(i = 0; i < len; i++)
    {
        flag = 0;

        for( j = 0; j < len; j++)
        {
            if( a[i] == b[j])
            {
                flag = 1;
            }
        }

        if (flag == 0)
            return flag;

    }
    return flag;
}

int main()
{
    int array[100] = {1,1,1};
    int array2[100] = {1,2,3} ;

    int len = 3;

    if (scrambled(array,array2,len) && scrambled(array2,array,len))
        printf("Equal\n");
    else
        printf("Not equal\n");
}

#包括
#包括
#包括
//flag=1表示两个数组相等或为空
//flag=0表示两个数组不相等
整数加扰（整数a[]，整数b[]，整数len）
{
int i=0；
int j=0；
int标志=0；
如果（len==0）
{
返回1；
}
对于（i=0；i

对于
{1,3,2}，输出是
相等的
；{1,2,3}
和
不等于
{1,1,1}；{1,2,3}
您的代码不正确。您的代码检测数组1的所有元素是否都在数组2中，而不是相反。试着打电话

scrambled(array2,array,len);

你会看到的
 您的代码不正确。你的代码检测
int scrambled( int a[], int b[], int len){
    int i, j, flag;
    char flags[len];

    if (len == 0) return 1;
    memset(flags, 0, len);
    for(i = 0; i < len; ++i){
        flag = 0;
        for( j = 0; j < len; ++j){
            if( a[i] == b[j] && flags[j]==0){
                flags[j] = flag = 1;
                break;
            }
        }

        if(flag == 0)
            return 0;
    }
    return 1;
}

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

//flag = 1 means the two arrays are equal, or empty
//flag = 0 means that the two arrays are not equal

int scrambled(int a[], int b[], int len)
{
    int i;
    int j;
    int flag;


    if (len == 0)
    {
        return 1;
    }

    for(i = 0; i < len; i++)
    {
        flag = 0;

        for(j = i; j < len; j++)  // start with j = i
        {
            if(a[i] == b[j])
            {
                // we got a match, hence forget about b[j]
                b[j] = b[i];

                // one match is enough for the current iteration
                flag = 1;
                break;
            }
        }


        if(flag == 0)
        {
            printf("Number not found\n");
            return flag;
        }

    }

    printf("Here is flag: %d\n", flag);
    return flag;
}

int main()
{
    int array[100] = {1,1,1};
    int array2[100] = {1,2,3} ;

    int len = 3;

    scrambled(array,array2,len);
}

#include <stdbool.h>
#include <string.h>
#include <stdio.h>

bool match_scrambled( int a[], int b[], int len)
{
    if (len == 0) return true;

    int bx[len], nbx = len;
    memcpy(bx, b, sizeof bx);

    for (int i = 0; i < len; ++i)
        for (int j = 0;; ++j)
        {
            if (j == nbx)
                return false;

            if( a[i] == bx[j])
            {
                bx[j] = bx[--nbx];
                break;
            }
        }

    return true;
}

int main()
{
    int array[] = {1,1,1};
    int array2[] = {1,2,3};

    if (!match_scrambled(array, array2, sizeof array / sizeof *array))
        printf("no ");
    printf("match\n");
    return 0;
}