性能不是很好，但是可以定义一个函数contained_in，检查一个数组中的所有内容是否都在另一个数组中。

int contained_in(int *arr1, size_t n1, int *arr2, size_t n2) {
    for (size_t i = 0; i < n1; i++) {
        int contained = 0;
        for (size_t j = 0; j < n2 && !contained; j++) {
            if (arr1[i] == arr2[j]) {
                contained = 1;
            }
        }

        if (!contained) return 0;
    }

    return 1;
}

如果选中contained_in(arrascii1, N, arrascii2, N) * 和 * contained_in(arrascii2, N, arrascii1, N)，则会知道两者包含相同的值。

与将数组arr1、arr2和arr3定义为单独的数组不同，定义数组的数组可能更容易，例如：

#define NUM_ARRAYS 3
#define N 6

int arrays[NUM_ARRAYS][N] = {
    {  3,  41, 315, 2 },
    {  5,  31, 315 },
    { 315, 41,   3, 2, 2, 41}
};

这样，你就可以在循环中使用两个维度的索引，这将使编码更容易：

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

#define NUM_ARRAYS 3
#define N 6

//This function returns true if the right array contains all
//elements of the left array, and vice versa. Otherwise it returns false.
bool compare_arrays( int left[], int right[] )
{
    //check whether right array contains all elements in the
    //left array
    for ( int i = 0; i < N; i++ )
    {
        for ( int j = 0; ; j++ )
        {
            if ( j == N )
                return false;

            if ( left[i] == right[j] )
                break;
        }
    }

    //check whether left array contains all elements in the
    //right array
    for ( int i = 0; i < N; i++ )
    {
        for ( int j = 0; ; j++ )
        {
            if ( j == N )
                return false;

            if ( right[i] == left[j] )
                break;
        }
    }

    return true;
}

int main( void )
{
    const char *map[] = {
        "First", "Second", "Third", "Fourth", "Fifth",
        "Sixth", "Sevent", "Eighth", "Ninth", "Tenth"
    };

    int arrays[NUM_ARRAYS][N] = {
        {   3, 41, 315, 2 },
        {   5, 31, 315 },
        { 315, 41,   3, 2, 2, 41 }
    };

    for ( int i = 0; i < NUM_ARRAYS; i++ )
    {
        for ( int j = i + 1; j < NUM_ARRAYS; j++ )
        {
            if ( compare_arrays( arrays[i], arrays[j] ) )
                printf( "%s %s\n", map[i], map[j] );
        }
    }
}

但是，这个程序没有输出，这是因为数组arr1的最后两个元素也包含值0，而arr3中不存在0，所以arr1和arr3的比较失败。
最后两个元素的值为0的原因是，如果数组中至少有一个元素被初始化，则所有未显式初始化的元素都被隐式初始化为0。
由于上述原因，为每个数组增加一个变量是合适的，该变量指定数组中有效元素的数量。与其使用单独的变量，不如将它们与数组一起分组在struct中：

struct array_with_length
{
    int length;
    int array[N];
};

这样，您就可以将循环限制为有效元素的数量：

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

#define NUM_ARRAYS 3
#define N 6

struct array_with_length
{
    int length;
    int array[N];
};

//This function returns true if the right array contains all
//elements of the left array, and vice versa. Otherwise it returns false.
bool compare_arrays(
    const struct array_with_length *left,
    const struct array_with_length *right
)
{
    //check whether right array contains all elements in the
    //left array
    for ( int i = 0; i < left->length; i++ )
    {
        for ( int j = 0; ; j++ )
        {
            if ( j == right->length )
                return false;

            if ( left->array[i] == right->array[j] )
                break;
        }
    }

    //check whether left array contains all elements in the
    //right array
    for ( int i = 0; i < right->length; i++ )
    {
        for ( int j = 0; ; j++ )
        {
            if ( j == left->length )
                return false;

            if ( right->array[i] == left->array[j] )
                break;
        }
    }

    return true;
}

int main( void )
{
    const char *map[] = {
        "First", "Second", "Third", "Fourth", "Fifth",
        "Sixth", "Sevent", "Eighth", "Ninth", "Tenth"
    };

    struct array_with_length arrays[NUM_ARRAYS] = {
        {
            4, //number of elements in array
            {   3, 41, 315, 2 }, //array content
        },

        {
            3, //number of elements in array
            {   5, 31, 315 }, //array content
        },

        {
            6, //number of elements in array
            { 315, 41, 3, 2, 2, 41 } //array content
        }
    };

    for ( int i = 0; i < NUM_ARRAYS; i++ )
    {
        for ( int j = i + 1; j < NUM_ARRAYS; j++ )
        {
            if ( compare_arrays( &arrays[i], &arrays[j] ) )
                printf( "%s %s\n", map[i], map[j] );
        }
    }
}

此程序具有以下输出：

First Third

这是你说你想要的输出。