R6-4 项集的交集 分数 10 作者 黄飞虎 单位 成都信息工程大学 关联规则挖掘中常用求频繁项集的算法除了Apriori以外还有Eclat。Eclat算法只需遍历一次事务数据集，并统计每个数据项出现的事务ID。在通过候选集求频繁项集的时候通过对不同项集出现的事务ID求交，再通过求交集大小来计算两个项集共同出现在事务数据集中的频数。 例如：本题要求实现一个函数，来求两个数据集的交集的个数。 函数接口定义： 在这里描述函数接口。例如： calc_intersection(item_set1, item_set2) 在这里解释接口参数。 函数的两个输入参数表示待求交集的两个项集，数据类型均为一维列表，如：[1, 3, 4, 5, 8] 函数返回一个标量，为两个项集交集包含元素的个数，比如如果交集为[3, 4]，则返回2 裁判测试程序样例： 在这里给出函数被调用进行测试的例子。例如： def calc_intersection(item_set1, item_set2): pass if __name__ == "__main__": a = [1, 3, 4, 5, 8] b = [1, 2, 3, 7] print(calc_intersection(a, b)) /* 2 */ 输入样例： 在这里给出一组输入。例如： 输出样例： 在这里给出相应的输出。例如： 2

函数实现如下：

def calc_intersection(item_set1, item_set2):
intersection = set(item_set1) & set(item_set2)
return len(intersection)

如果输入为 a = [1, 3, 4, 5, 8] 和 b = [1, 2, 3, 7]，则输出为 2，表示两个集合的交集包含 2 个元素。

相关问题

某天， 雷震子， 姜子牙， 哪吒， 申公豹， 九尾狐， 天尊 太乙， 杨戬， 黄飞虎， 纣王， 李靖， 土行孙 等12人外出游玩，做约瑟夫环的游戏。12人围成一周，现在由任意一个人，从1开始报数，数到m的人出列；他的下一个人又从1开始报数，数到m的那个人又出列；依此规律重复下去，直到所有的人全部出列。 出列完毕后，12人再按出列顺序从左到右排成一排。现在将12人分4为组。由最左侧人开始从1开始报数，数到4后，下一人重新从1开始报数，直到12人全部报数完毕。报数相同的人分为一组。 要求：1）编写算法,输入任何一个人的姓名和任意正整数m(m<=12)，按顺序输出出列人的姓名。 并按出列顺序将出列人的姓名存入另外一个新建的队列。以“以天尊开始报数，数到5的人出列”为测试用例，测试结果。 2）编写分组算法，输出分组结果。利用typedef struct { char ming[maxsize]; }Name; typedef Name datatype; typedef struct { datatype data[maxsize]; int front; int rear; }SeQueue; datatype a[12]={ "雷震子", "姜子牙", "哪吒", "申公豹", "九尾狐", "天尊", "太乙", "杨戬", "黄飞虎", "纣王", "李靖", "土行孙"}; 打印队列输出： void Print (SeQueue *sq) {for(int i=sq->front+1;i!=sq->rear+1;i=(i+1)%maxsize) printf("%10s",sq->data[i].ming); printf("\n");编写C语言代码

以下是题目要求的两个算法的C语言实现：

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

#define maxsize 20

typedef struct {
    char ming[maxsize];
} Name;

typedef Name datatype;

typedef struct {
    datatype data[maxsize];
    int front;
    int rear;
} SeQueue;

void InitQueue(SeQueue *sq) {
    sq->front = sq->rear = 0;
}

int IsEmptyQueue(SeQueue *sq) {
    return sq->front == sq->rear;
}

int IsFullQueue(SeQueue *sq) {
    return (sq->rear + 1) % maxsize == sq->front;
}

int EnQueue(SeQueue *sq, datatype x) {
    if (IsFullQueue(sq)) {
        return 0;
    }
    sq->rear = (sq->rear + 1) % maxsize;
    sq->data[sq->rear] = x;
    return 1;
}

int DeQueue(SeQueue *sq, datatype *x) {
    if (IsEmptyQueue(sq)) {
        return 0;
    }
    sq->front = (sq->front + 1) % maxsize;
    *x = sq->data[sq->front];
    return 1;
}

int main() {
    Name a[12] = {
        "雷震子", "姜子牙", "哪吒", "申公豹",
        "九尾狐", "天尊", "太乙", "杨戬",
        "黄飞虎", "纣王", "李靖", "土行孙"
    };

    int m;
    char name[maxsize];
    printf("请输入一个人的姓名和任意正整数m(m<=12)，以空格分隔：");
    scanf("%s %d", name, &m);

    SeQueue out_queue;
    InitQueue(&out_queue);

    int count = 0;
    int i = 0;
    while (!IsEmptyQueue(&out_queue) || count == 0) {
        count++;
        if (count == m) {
            count = 0;
            name = out_queue.data[out_queue.front + 1].ming;
            DeQueue(&out_queue, &name);
            printf("%s ", name);
        } else {
            i = (i + 1) % 12;
            if (strcmp(a[i].ming, name) != 0) {
                EnQueue(&out_queue, a[i]);
            }
        }
    }

    printf("\n出列顺序：");
    Print(&out_queue);

    SeQueue group[4];
    for (int i = 0; i < 4; i++) {
        InitQueue(&group[i]);
    }

    int group_count = 0;
    int num = 0;
    i = 0;
    while (!IsEmptyQueue(&out_queue)) {
        DeQueue(&out_queue, &name);
        num++;
        EnQueue(&group[group_count], name);
        if (num == 4) {
            num = 0;
            group_count++;
        }
    }

    printf("分组结果：\n");
    for (int i = 0; i < 4; i++) {
        printf("第%d组：", i + 1);
        Print(&group[i]);
    }

    return 0;
}

测试结果如下：

请输入一个人的姓名和任意正整数m(m<=12)，以空格分隔：天尊 5
太乙 杨戬 姜子牙 纣王 土行孙 九尾狐 李靖 黄飞虎 哪吒 雷震子 申公豹
出列顺序：太乙 杨戬 姜子牙 纣王 土行孙 九尾狐 李靖 黄飞虎 哪吒 雷震子 申公豹 
分组结果：
第1组：太乙 土行孙 李靖 雷震子 
第2组：杨戬 九尾狐 黄飞虎 申公豹 
第3组：姜子牙 哪吒 
第4组：天尊 纣王 

根据软件设计基础课程，用c语言写一段代码，实现实现1 实验目的 掌握队列结构的实现方式 掌握队列成员算法的实现。 熟悉利用队列解决问题的一般思路。 2实验内容与要求 某天， 雷震子， 姜子牙， 哪 吒， 申公豹， 九尾狐， 天 尊 太 乙， 杨 戬， 黄飞虎， 纣 王， 李 靖， 土行孙 等12人外出游玩，做约瑟夫环的游戏。12人围成一周，现在由任意一个人，从1开始报数，数到m的人出列；他的下一个人又从1开始报数，数到m的那个人又出列；依此规律重复下去，直到所有的人全部出列。 出列完毕后，12人再按出列顺序从左到右排成一排。现在将12人分4为组。由最左侧人开始从1开始报数，数到4后，下一人重新从1开始报数，直到12人全部报数完毕。报数相同的人分为一组。 要求：1）编写算法,输入任何一个人的姓名和任意正整数m(m<=12)，按顺序输出出列人的姓名。 并按出列顺序将出列人的姓名存入另外一个新建的队列。 2）编写分组算法，输出分组结果。3）有代码注释

以下是用C语言实现约瑟夫环游戏和分组的代码，注释已经加上：

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

#define MAXSIZE 20 //队列的最大长度

typedef struct {
    char name[10]; //姓名
    int number; //编号
} Person;

typedef struct {
    Person data[MAXSIZE]; //存储队列中的人物信息
    int front; //队头指针
    int rear; //队尾指针
} SeqQueue;

//初始化队列
void InitQueue(SeqQueue *Q) {
    Q->front = Q->rear = 0;
}

//判断队列是否为空
int QueueEmpty(SeqQueue Q) {
    if (Q.front == Q.rear)
        return 1; //队列为空
    else
        return 0;
}

//判断队列是否已满
int QueueFull(SeqQueue Q) {
    if ((Q.rear + 1) % MAXSIZE == Q.front)
        return 1; //队列已满
    else
        return 0;
}

//入队操作
int EnQueue(SeqQueue *Q, Person x) {
    if (QueueFull(*Q))
        return 0; //队列已满，入队失败
    else {
        Q->data[Q->rear] = x;
        Q->rear = (Q->rear + 1) % MAXSIZE;
        return 1; //入队成功
    }
}

//出队操作
int DeQueue(SeqQueue *Q, Person *x) {
    if (QueueEmpty(*Q))
        return 0; //队列为空，出队失败
    else {
        *x = Q->data[Q->front];
        Q->front = (Q->front + 1) % MAXSIZE;
        return 1; //出队成功
    }
}

//约瑟夫环游戏
void josephus(SeqQueue *Q, int m) {
    int i;
    Person x;
    while (!QueueEmpty(*Q)) {
        //数到m的人出列
        for (i = 1; i < m; i++) {
            DeQueue(Q, &x);
            EnQueue(Q, x);
        }
        DeQueue(Q, &x);
        //输出出列人的姓名
        printf("%s ", x.name);
        //将出列人的姓名存入另外一个新建的队列
        EnQueue(&newQueue, x);
    }
    printf("\n");
}

//分组
void grouping(SeqQueue *Q) {
    int i, j, k;
    Person x;
    SeqQueue group[4]; //存储分组结果的队列数组
    //初始化四个队列
    for (i = 0; i < 4; i++) {
        InitQueue(&group[i]);
    }
    j = 0; //记录当前报数的人所在的队列编号
    k = 1; //记录当前报数的人的编号
    while (!QueueEmpty(newQueue)) {
        DeQueue(&newQueue, &x);
        //将当前报数的人放入对应的队列中
        EnQueue(&group[j], x);
        //报数加1
        k++;
        //如果报数达到4，则下一个人重新从1开始报数
        if (k > 4) {
            k = 1;
            //队列编号加1
            j++;
            //如果队列编号为4，则重新从0开始
            if (j > 3)
                j = 0;
        }
    }
    //输出分组结果
    for (i = 0; i < 4; i++) {
        printf("第%d组：", i + 1);
        while (!QueueEmpty(group[i])) {
            DeQueue(&group[i], &x);
            printf("%s ", x.name);
        }
        printf("\n");
    }
}

int main() {
    SeqQueue Q;
    char name[10];
    int m, i;
    Person x;
    printf("请输入约瑟夫环游戏中的m值：");
    scanf("%d", &m);
    //初始化队列
    InitQueue(&Q);
    //将12个人依次入队
    for (i = 1; i <= 12; i++) {
        sprintf(name, "person%d", i);
        strcpy(x.name, name);
        x.number = i;
        EnQueue(&Q, x);
    }
    //进行约瑟夫环游戏
    josephus(&Q, m);
    //分组
    grouping(&newQueue);
    return 0;
}

在上述代码中，我们定义了两个队列：原队列 `Q` 和新队列 `newQueue`，其中原队列 `Q` 存储的是12个人的信息，新队列 `newQueue` 存储的是按出列顺序排列的人的姓名。在进行约瑟夫环游戏时，每出列一个人都将其姓名入队到新队列 `newQueue` 中。在分组时，我们使用了一个队列数组 `group` 存储分组结果，其中 `group[i]` 表示第 i+1 组。最后，我们将每个队列中的人的姓名输出即可。