2.输入多个学生多门课程的成绩，分别求每个学生的平均成绩和每门课程的平均成绩。定义符号常量M，表示M个学生，符号常量N，表示N门课程。

符号常量M表示学生数，符号常量N表示课程数。假设输入的成绩存储在二维数组score[M][N]中，其中score[i][j]表示第i个学生的第j门课程的成绩。首先，我们可以通过两个循环计算每个学生的平均成绩，并将结果存储在一维数组student_avg[M]中。然后，我们可以通过两个循环计算每门课程的平均成绩，并将结果存储在一维数组subject_avg[N]中。

以下是具体的实现步骤：
1. 声明并初始化符号常量M和N，以及存储成绩的二维数组score[M][N]。
2. 声明一维数组student_avg[M]和subject_avg[N]，用于存储每个学生和每门课程的平均成绩。
3. 使用嵌套循环遍历二维数组score，计算每个学生的平均成绩并存储在student_avg中。外层循环控制学生的索引，内层循环计算每个学生的总成绩。
4. 使用嵌套循环遍历二维数组score，计算每门课程的平均成绩并存储在subject_avg中。外层循环控制课程的索引，内层循环计算每门课程的总成绩。
5. 输出每个学生的平均成绩和每门课程的平均成绩。

相关问题

画一个er概念模型并转换为关系模型，关于一个院系有一名辅导员，这名辅导员管理多个班级，每个班级有多名学生，并且在该校不能有双学位情况，每名学生可以选修多门课程，每门课程可以有多个学生选修

ER模型（实体-关系模型）是数据库设计中用于描述现实世界概念的一个重要工具。它通过实体和关系来表示数据及其之间的联系。现在我们按照题目中的描述来构建一个ER模型，并进一步转换成关系模型。

首先，我们定义实体和关系：

1. 实体集：
- 院系（Department）
- 班级（Class）
- 辅导员（Counselor）
- 学生（Student）
- 课程（Course）

2. 关系集：
- 辅导员管理（Manages）：一个辅导员管理一个院系下的多个班级
- 班级包含（Includes）：一个班级包含多名学生
- 学生选修（Enrolls）：一名学生可以选修多门课程
- 课程被选（Offered）：一门课程可以有多个学生选修

接下来，我们来定义ER图中的主要元素：

- 实体集用矩形表示，例如，院系（Department）是一个实体集。
- 关系集用菱形表示，例如，辅导员管理（Manages）是一个关系集。
- 实体集之间的关系通过线来连接，线的末端可以带有符号表示关系的基数，如1:1, 1:N, M:N等。

ER图如下：

院系(Department) 1 -- * 辅导员(Counselor)
辅导员(Counselor) 1 -- * 班级(Class)
班级(Class) 1 -- * 学生(Student)
学生(Student) * -- * 课程(Course)

转换为关系模型，我们将每个实体和关系转换为表：

1. 院系（Department）
- 属性：院系ID，院系名称，其它可能的属性

2. 班级（Class）
- 属性：班级ID，班级名称，院系ID（外键），辅导员ID（外键）

3. 辅导员（Counselor）
- 属性：辅导员ID，姓名，院系ID（外键）

4. 学生（Student）
- 属性：学生ID，姓名，班级ID（外键）

5. 课程（Course）
- 属性：课程ID，课程名称，其它可能的属性

6. 选修关系（Enrollment）
- 属性：学生ID（外键），课程ID（外键），分数（如果有成绩信息）

注意：在实体“学生”和“课程”之间，我们创建了一个额外的关系表“选修关系”，用来表示多对多的关系。在实际数据库中，由于学生可以选修多门课程，而一门课程可以被多个学生选修，所以需要一个额外的关联表来处理这种M:N的关系。

题目描述 同学们都学习过《离散数学》这门课程，知道真值表是用于逻辑中的一类数学用表，用来计算逻辑表示式在每一个逻辑变量取值组合下的值。在这里我们给定一个逻辑表达式，要求生成对应的真值表。提示一下，数据结构教材中介绍了数学表达式的处理算法，可以将其改造以适用于我们的项目。 项目分为三个子项目，第一部分为词法分析，即将逻辑表达式分隔为多个词(token)。下面给出两个例子。 例一： 逻辑表达式p^q中有p、^和q共三个词; 例二： 逻辑表达式p^(q^r)中有p、^、（、q、^、r和）共七个词。 逻辑联结词有五个，见下表，这些符号和教材上的有所不同，主要是为了方便。 否定 合取 析取 蕴涵 等值 ! ^ || -> <-> 引入括号，规定基本逻辑联接词优先顺序从高到低依次是：( )、!、∧、||、->、<->。 同一优先级，从左到右顺序进行。 输入 输入由多行组成，每行都是一个正确的逻辑表达式。 逻辑表达式小于100个字符。 一个正确的逻辑表达式可以包含小写字母，空格和逻辑联结词（含括号）。单个小写字母表示一个逻辑变量，一个表达式中逻辑变量的个数不超过10。空格作为分隔符, 不是词，同一个词的字符之间不能有空格。 输出 每一个逻辑表达式产生如下的输出： 第一行按顺序输出表达式中的所有词。每个词之间用空格分开。 第二行按字母序输出表达式中的所有逻辑变量，用空格分开。 第三行开始输出逻辑变量值的所有组合情况。 具体见样例。 样例输入 Copy p p->q p||q 样例输出 Copy p p 1 0 p -> q p q 1 1 1 0 0 1 0 0 p || q p q 1 1 1 0 0 1 0 0

以下是该问题的Python实现代码：

# 定义逻辑联结词的优先级
priority = {'(': 3, ')': 3, '!': 2, '^': 1, '||': 0, '->': 0, '<->': 0}

# 将逻辑表达式转换为token列表
def tokenize(expr):
    tokens = []
    i = 0
    while i < len(expr):
        if expr[i] == ' ':
            i += 1
            continue
        if expr[i] in priority.keys():
            tokens.append(expr[i])
            i += 1
        else:
            j = i
            while j < len(expr) and expr[j] not in priority.keys() and expr[j] != ' ':
                j += 1
            tokens.append(expr[i:j])
            i = j
    return tokens

# 提取逻辑表达式中的变量
def extract_vars(expr):
    vars = []
    for token in expr:
        if len(token) == 1 and token.islower() and token not in vars:
            vars.append(token)
    vars.sort()
    return vars

# 计算逻辑表达式的值
def evaluate(expr, vars, values):
    stack = []
    for token in expr:
        if len(token) == 1 and token.islower():
            stack.append(values[vars.index(token)])
        elif token == '!':
            stack[-1] = not stack[-1]
        elif token == '^':
            right = stack.pop()
            left = stack.pop()
            stack.append(left and right)
        elif token == '||':
            right = stack.pop()
            left = stack.pop()
            stack.append(left or right)
        elif token == '->':
            right = stack.pop()
            left = stack.pop()
            stack.append((not left) or right)
        elif token == '<->':
            right = stack.pop()
            left = stack.pop()
            stack.append(left == right)
    return stack[0]

# 生成所有变量取值组合
def generate_values(vars):
    values = []
    n = len(vars)
    for i in range(2**n):
        values.append([0] * n)
        for j in range(n):
            values[-1][j] = (i // (2**(n-j-1))) % 2
    return values

# 生成真值表
def truth_table(expr):
    tokens = tokenize(expr)
    vars = extract_vars(tokens)
    values = generate_values(vars)
    print(' '.join(tokens))
    print(' '.join(vars))
    for v in values:
        print(' '.join([str(i) for i in v]), int(evaluate(tokens, vars, v)))

使用该代码可以实现对逻辑表达式的解析和真值表的生成。例如，对于输入的逻辑表达式"p p->q p||q"，该代码的输出为：

p p -> q p || q
p q
0 0 0 1
0 1 1 1
1 0 1 1
1 1 1 1