【算法面试题】-05

news2024/12/26 15:12:04

智能成绩表

在这里插入图片描述
在这里插入图片描述


class Student:
    def __init__(self):
        self.name = ""  # 学生名字
        self.scores = []  # 每门课成绩

students = [Student() for _ in range(10004)]  # 存储学生信息的数组
key_index = 0  # 要排序的课程名的下标

# 自定义排序函数
def student_comparator(a, b):
    if a.scores[key_index] != b.scores[key_index]:
        return b.scores[key_index] - a.scores[key_index]
    return (a.name > b.name) - (a.name < b.name)

n, m = map(int, input().split())  # 学生数量和课程数量
course_names = input().split()  # 课程名数组

for i in range(1, n + 1):
    student_info = input().split()
    students[i].name = student_info[0]  # 读取学生名字
    total_score = 0
    students[i].scores = list(map(int, student_info[1:]))  # 读取每门课成绩
    total_score = sum(students[i].scores)  # 计算总分
    students[i].scores.append(total_score)  # 将总分放入成绩数组末尾

key = input()  # 要排序的课程名
key_index = m  # 若没找到，赋值为最后一个位置，也就是总分
for i in range(m):  # 寻找这个课程名的下标
    if course_names[i] == key:
        key_index = i
        break

students = students[1:n+1]  # 仅保留有效学生信息
students.sort(key=lambda x: (x.scores[key_index], -ord(x.name[0])), reverse=True)  # 排序

for i in range(n):
    print(students[i].name, end=" ")

在这里插入图片描述
在这里插入图片描述

最长合法表达式

在这里插入图片描述
在这里插入图片描述


s = input()  # 输入字符串

ans = 0  # 最终答案
mx = 0  # 最长的有效连续段长度

# 检查字符串是否满足条件
def check(s):
    for i in range(len(s)-2):
        if all([x in "*-+" for x in s[i:i+3]]):  # 判断是否有三个连续的符号
            return False
    return True

# 遍历所有可能的连续段
for i in range(len(s)):
    for j in range(i, len(s)):
        if j-i+1 > mx and check(s[i:j+1]):  # 如果当前段长度大于最长长度且满足条件
            try:
                ans = eval(s[i:j+1])  # 计算当前段的表达式值
                mx = j-i+1  # 更新最长长度
            except:
                continue

print(ans)  # 输出最终答案

在这里插入图片描述

最大N个数与最小N个数的和

在这里插入图片描述
在这里插入图片描述

def function():
    m = int(input())
    nums = list(set(input().split(" ")))
    n = int(input())

    nums = [int(num) for num in nums]
    nums.sort()

    if len(nums) < 2 * n:
        return -1

    ans = 0
    for i in range(0, n):
        ans += nums[i]
        ans += nums[len(nums) - i - 1]

    return ans


if __name__ == '__main__':
    ans = function()
    print(ans)

在这里插入图片描述

小朋友来自多少小区

在这里插入图片描述
在这里插入图片描述

def get_value(arr):
    friends = 0
    i = 0
    while i < len(arr):
        friends += arr[i]
        if i + 1 < len(arr) and arr[i] == arr[i + 1]:
            j = i
            while j < i + arr[i] and j < len(arr):
                if arr[i] != arr[j]:
                    break
                j += 1
            i = j - 1
        i += 1
    return friends
 
 
arr = [int(i)+1 for i in input().split()]
arr.sort()
print(get_value(arr))

在这里插入图片描述

停车场车辆统计

在这里插入图片描述
在这里插入图片描述

w=list(map(int,input().split(',')))
n=len(w)
l,r=0,0  #双指针
res=0  #最少停车数量
while l<n:
    if w[l]==0:
        l+=1
        continue
    r=l
    while r<n and w[r]:
        r+=1
    num=r-l  #连续1的个数(某一段可以停的车的数量)
   # print(num)
    for i in range(3,0,-1):  #从大到小枚举停卡车 货车 小车
        res+=num//i
        num=num%i
    l=r
print(res)

在这里插入图片描述

执行任务赚积分

题目描述
现有N个任务需要处理，同一时间只能处理一个任务，处理每个任务所需要的时间固定为1。

每个任务都有最晚处理时间限制和积分值，在最晚处理时间点之前处理完成任务才可获得对应的积分奖励。

可用于处理任务的时间有限，请问在有限的时间内，可获得的最多积分。

输入描述
第一行为一个数 N，表示有 N 个任务

1 ≤ N ≤ 100

第二行为一个数 T，表示可用于处理任务的时间

1 ≤ T ≤ 100

接下来 N 行，每行两个空格分隔的整数（SLA 和 V），SLA 表示任务的最晚处理时间，V 表示任务对应的积分。

1 ≤ SLA ≤ 100

0 ≤ V ≤ 100000

输出描述
可获得的最多积分

用例1
输入

4
3
1 2
1 3
1 4
1 5

输出

5

说明

虽然有3个单位的时间用于处理任务，可是所有任务在时刻1之后都无效。 所以在第1个时间单位内，选择处理有5个积分的任务。1-3时无任务处理。

用例2
输入

4
3
1 2
1 3
1 4
3 5

输出

9

说明

第1个时间单位内，处理任务3，获得4个积分
第2个时间单位内，处理任务4，获得5个积分
第3个时间单位内，无任务可处理
共获得9个积分
解题思路
首先，我们将所有任务按照截止时间进行分类，并在每个截止时间内按照积分从高到低进行排序。这样做的目的是为了在每个截止时间内优先处理积分最高的任务。

然后，我们从最大的截止时间开始，逆序遍历每一个截止时间。这样做的目的是为了优先处理截止时间最晚的任务，因为这些任务有更大的灵活性。

对于每个截止时间，我们将所有的任务添加到剩余的任务列表中，。

如果剩余的任务列表不为空，我们就处理积分最高的任务，并将其积分添加到总积分中并对其进行排序，以便优先处理积分最高的任务。这是贪心选择，我们总是选择当前可用的积分最高的任务。
在这里插入图片描述

import heapq

# 输入任务数量和时刻上限
n = int(input())
T = int(input())

# 使用列表存储任务，每个任务用一个元组表示
v = []

# 输入每个任务的开始时间和价值
for _ in range(n):
    a, b = map(int, input().split())
    v.append((a, b))

# 按照处理事件先后顺序从小到大排序
v.sort()  

# 创建小根堆，用于存储当前时刻的任务价值
heap = []  

# 处理任务
for i in range(n):
    # 如果当前任务在当前时刻没有过期
    if v[i][0] > len(heap):  
        # 如果堆的大小小于上限 T，则直接添加任务价值
        if len(heap) < T:
            heapq.heappush(heap, v[i][1])
        # 如果堆已满，比较堆顶任务价值与当前任务价值
        # 如果当前任务价值大于堆顶任务价值，则替换堆顶任务价值
        elif heap[0] < v[i][1]:
            heapq.heappop(heap)
            heapq.heappush(heap, v[i][1])
    # 如果当前任务在当前时刻已过期，比较堆顶任务价值与当前任务价值
    # 如果当前任务价值大于堆顶任务价值，则替换堆顶任务价值
    else:
        if v[i][1] > heap[0]:
            heapq.heappop(heap)
            heapq.heappush(heap, v[i][1])

# 计算总任务价值
res = sum(heap)
print(res)

在这里插入图片描述

最多购买宝石数目

题目描述
橱窗里有一排宝石，不同的宝石对应不同的价格，宝石的价格标记为 gems[i] 0 ≤ i < n n = gems.length 宝石可同时出售0个或多个，如果同时出售多个，则要求出售的宝石编号连续；

例如客户最大购买宝石个数为m，购买的宝石编号必须为：gems[i]，gems[i+1]，…，gems[i+m-1] 0 ≤ i < n m ≤ n 假设你当前拥有总面值为 value 的钱，请问最多能购买到多少个宝石，如无法购买宝石，则返回0。

输入描述
第一行输入n，参数类型为int，取值范围：[0,10^6]，表示橱窗中宝石的总数量。

之后 n 行分别表示从第0个到第n-1个宝石的价格，即 gems[0] 到 gems[n-1] 的价格，类型为int，取值范围：(0,1000]。

之后一行输入v，类型为int，取值范围：[0,10^9]，表示你拥有的钱。

输出描述
输出int类型的返回值，表示最大可购买的宝石数量。

用例1
输入

7
8
4
6
3
1
6
7
10

输出

3

说明

gems = [8,4,6,3,1,6,7], value = 10

最多购买的宝石为gems[2]至gems[4]或者gems[3]至gems[5]

用例2
输入

0
1

输出

0

说明

gems = [], value = 1 因为没有宝石，所以返回0

用例3
输入

9
6
1
3
1
8
9
3
2
4
15

输出

4

说明

gems = [6, 1, 3, 1, 8, 9, 3, 2, 4], value = 15 最多购买的宝石为gems[0]至gems[3]

用例4
输入

9
1
1
1
1
1
1
1
1
1
10

输出

9

说明

gems = [1, 1, 1, 1, 1, 1, 1, 1, 1], value = 10 最多购买的宝石为gems[0]至gems[8]，即全部购买

解题思路
以下是详细的解题思路：

首先，代码从控制台读取宝石的数量，每颗宝石的价格，以及你拥有的钱的总面值。

然后，初始化滑动窗口的左右边界（left和right）为0，窗口内宝石的总价（sum），以及最大可购买的宝石数量（max）。

在while循环中，首先将右边界的宝石价格加到总价中。如果总价超过你拥有的钱，那么就将左边界的宝石价格从总价中减去，并将左边界向右移动，直到总价不超过你拥有的钱。

然后，更新最大可购买的宝石数量。这是通过比较当前最大可购买的宝石数量和滑动窗口内的宝石数量（right - left + 1）来实现的。

最后，将右边界向右移动，扩大滑动窗口。当滑动窗口的右边界超过宝石数量时，结束循环。

在while循环结束后，输出最大可购买的宝石数量。

通过这种方式，代码能够找出在给定预算下，最多可以购买的宝石数量。

以例3中的宝石数量是9，宝石的价格分别是6、1、3、1、8、9、3、2、4，你拥有的钱的总面值是15。

以下是详细的计算步骤：

初始化：left=0，right=0，sum=0，max=0。

第一步：将右边界的宝石价格加到总价中，sum=6，right=1，left=0，max=1。

第二步：将右边界的宝石价格加到总价中，sum=7，right=2，left=0，max=2。

第三步：将右边界的宝石价格加到总价中，sum=10，right=3，left=0，max=3。

第四步：将右边界的宝石价格加到总价中，sum=11，right=4，left=0，max=4。

第五步：将右边界的宝石价格加到总价中，sum=19，总价超过了你拥有的钱，所以将左边界的宝石价格从总价中减去，并将左边界向右移动，sum=13，right=4，left=1，max=4。

第六步：将右边界的宝石价格加到总价中，sum=22，总价超过了你拥有的钱，所以将左边界的宝石价格从总价中减去，并将左边界向右移动，sum=21，right=5，left=2，max=4。

第七步：继续将左边界的宝石价格从总价中减去，并将左边界向右移动，sum=18，right=5，left=3，max=4。

第八步：继续将左边界的宝石价格从总价中减去，并将左边界向右移动，sum=17，right=5，left=4，max=4。

第九步：继续将左边界的宝石价格从总价中减去，并将左边界向右移动，sum=9，right=5，left=5，max=4。

第十步：将右边界的宝石价格加到总价中，sum=12，right=6，left=5，max=4。

第十一步：将右边界的宝石价格加到总价中，sum=14，right=7，left=6，max=4。

第十一步：将右边界的宝石价格加到总价中，sum=18，总价超过了你拥有的钱，所以将左边界的宝石价格从总价中减去，并将左边界向右移动，sum=9，right=8，left=7，max=4。

第十四步：滑动窗口的右边界已经超过了宝石数量，结束循环。

因此，最大可购买的宝石数量是4。

在这里插入图片描述
在这里插入图片描述

n=int(input())
w=[0]*n
for i in range(n):
    w[i]=int(input())
value=int(input())  
ans,sum=0,0  #最大子数组长度/区间和初始化
l,r=0,0  #双指针起始位置
while r<n:
    sum+=w[r]
    while sum>value:  #当区间不满足条件时,l指针右移
        sum-=w[l]
        l+=1
    ans=max(ans,r-l+1)  #更新最大值
    r+=1
print(ans)

在这里插入图片描述

求字符串中所有整数的最小和

在这里插入图片描述
在这里插入图片描述

s = input()
res = 0
i = 0
while i < len(s):
    if not s[i].isdigit() and s[i] != '-':
        i += 1
        continue
    if s[i] == '-':
        j = i + 1
        num = 0
        while j < len(s) and s[j].isdigit():
            num = num * 10 + int(s[j])
            j += 1
        res -= num
        i = j
    else:
        res += int(s[i])
        i += 1

print(res)

在这里插入图片描述

堆内存申请

在这里插入图片描述
在这里插入图片描述

n = int(input())
arr = []
while True:#不定行输入
    try:
        l,r=map(int,input().split())
        arr.append([l,l+r-1])
    except:
        break
arr.sort()  #按照左端点进行排序
m=len(arr)
def check(arr):  #判断是否有不合法输入
    for i in range(m):
        x,y=arr[i][0],arr[i][1]
        if x<0 or y<0 or x>=100 or y>=100 or x>y:  #输入数据不合法
            print(x,y)
            return False
        if i and x<=arr[i-1][1]:  #区间有重叠
            return False
    return True
if not check(arr):
    print(-1)
else:
    pos,diff=-1,10**9
    for i in range(m):
        if i==0:
            if arr[i][0]>=n and abs(arr[i][0]-n)<diff:
                pos=0
                diff=abs(arr[i][0]-n)
        elif arr[i][0]-arr[i-1][1]>n and abs(arr[i][0]-arr[i-1][1]-n)<diff:
            pos=arr[i-1][1]+1
            diff=abs(arr[i][0]-arr[i-1][1]-n)
            break
    if 99-arr[m-1][1]>=n and abs(99-arr[m-1][1]-n)<diff:
        pos=arr[m-1][1]+1
    print(pos)

在这里插入图片描述

测试用例执行计划

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

n, m = map(int, input().split())  # 读取输入的整数n和m
w = [0] * (n + 1)  # 创建长度为n+1的整数列表w，初始值为0
for i in range(1, n + 1):
    w[i] = int(input())  # 读取n个整数并存入列表w
lists = [[] for _ in range(m)]  # 创建m个空列表的列表

for i in range(m):
    arr = [w[int(x)] for x in input().split()]  # 读取一行输入，将其按空格分割并转为整数列表arr
    _sum = sum(arr)  # 计算arr的和
    lists[i].append(_sum)  # 将和添加到lists的第i个元素中
    lists[i].append(i + 1)  # 将i+1添加到lists的第i个元素中

lists.sort(key=lambda x: (-x[0], x[1]))  # 对lists进行排序，首先按照第一个元素降序排序，然后按照第二个元素升序排序

for l in lists:
    print(l[-1])  # 输出lists的每个元素的最后一个值

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1507657.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

中间件 | Redis - [基本信息]

中间件 | Redis - [基本信息]

INDEX 1 常规用法2 QPS3 pipeline 1 常规用法 分布式锁 最常见用法&#xff0c;需要注意分布式锁的redis需要单点 分布式事务 分布式事务中&#xff0c;核心的技术难点其实是分布式事务这个事本身作为数据的持久化 2PC&#xff0c;比如 seata 的 AT 模式下&#xff0c;将 un…
阅读更多...
低功耗控制器结合Node-RED革新电力系统监控方式

低功耗控制器结合Node-RED革新电力系统监控方式

现代电力行业的不断发展与技术进步&#xff0c;微电网ARM低功耗控制器与Node-RED的深度融合&#xff0c;为电力系统的智能化运维提供了崭新的解决方案。这一集成方案将硬件控制的高效稳定与软件逻辑处理的强大灵活性相结合&#xff0c;实现了对变电站设备、输电线路状态以及智能…
阅读更多...
Importing ArkTS files to JS and TS files is not allowed. ＜etsLint＞ 解决方法

Importing ArkTS files to JS and TS files is not allowed. ＜etsLint＞ 解决方法

这个问题是 harmonyos 项目中 因为在ts中导入了 ets文件造成的 系统不需要在ts文件中 直接导入 ets文件 一般来讲 ts能写的代码 ets也可以 最简单的方式 就是直接将 ts 改为ets 右键文件 如下图选择 将后缀的ts改为 ets 就OK了
阅读更多...
GEE：计算一个遥感影像的空像素占比

GEE：计算一个遥感影像的空像素占比

作者：CSDN @ _养乐多_ 本文将介绍，如何在 Google Earth Engine (GEE) 平台计算一个遥感影像的空像素占比，其中，包含获取研究区内所有像素的总数的代码，以及获取非空像素的总数的代码。 结果如下图所示， 文章目录 一、核心函数1.1 获取研究区内所有像素的总数1.2 获取非…
阅读更多...
LeetCode刷题日志-46.全排列

LeetCode刷题日志-46.全排列

跟77题组合一样&#xff0c;在这里又遇到同样的问题&#xff0c;如果使用暴力解法&#xff0c;nums大小不同&#xff0c;使用的循环嵌套的层数也不同。那么这时候我们就需要使用暴力的解法。 我们看以下代码&#xff0c;如果nums [1,2,3]会输出什么&#xff1f; class Soluti…
阅读更多...
openssl3.2 - 官方demo学习 - encode - ec_encode.c

openssl3.2 - 官方demo学习 - encode - ec_encode.c

文章目录 openssl3.2 - 官方demo学习 - encode - ec_encode.c概述笔记产生ecc私钥产生ecc公钥测试工程END openssl3.2 - 官方demo学习 - encode - ec_encode.c 概述 官方demos/encode 目录中给了2个例子工程 功能是载入(RSA/ECC)公钥, 然后自己就可以拿内存中的公钥对象干活了…
阅读更多...
Uber/Google Golang编码标准深度分析

Uber/Google Golang编码标准深度分析

良好的代码风格对于开发优秀的产品至关重要&#xff0c;本文通过分析比较三部流传甚广的Golang代码风格指南&#xff0c;介绍了Go代码风格要点&#xff0c;并介绍了通过工具实现代码检查的方式。原文: Mastering Go: In-Depth Analysis of Uber and Google’s Coding Standards…
阅读更多...
算法50：动态规划专练(力扣514题：自由之路-----4种写法)

算法50：动态规划专练(力扣514题：自由之路-----4种写法)

题目: 力扣514 &#xff1a; 自由之路 . - 力扣&#xff08;LeetCode&#xff09; 题目的详细描述&#xff0c;直接打开力扣看就是了&#xff0c;下面说一下我对题目的理解: 事例1&#xff1a; 输入: ring "godding", key "gd" 输出: 4. 1. ring的第…
阅读更多...
【网络原理】TCP 协议中比较重要的一些特性（一）

【网络原理】TCP 协议中比较重要的一些特性（一）

目录 1、TCP 协议 2、确认应答 2.1、确认序号 3、超时重传 4、连接管理 4.1、建立连接&#xff08;三次握手&#xff09; 4.2、断开连接&#xff08;四次挥手&#xff09; 1、TCP 协议 TCP 是工作中最常用到的协议&#xff0c;也是面试中最常考的协议&#xff0c;具有面…
阅读更多...
spring-data-elasticsearch官方文档解读（部分）

spring-data-elasticsearch官方文档解读（部分）

Spring Data Elasticsearch 这里主要学习的是4.4.16版本的文档 1. 版本 下表显示了 Spring Data 发行版系列使用的 Elasticsearch 版本和其中包含的 Spring Data Elasticsearch 版本&#xff0c;以及引用该特定 Spring Data 发行版系列的 Spring Boot 版本。给出的 Elastics…
阅读更多...
关于yolov8的DFL模块(pytorch以及tensorrt)

关于yolov8的DFL模块(pytorch以及tensorrt)

可以参考我改的项目&#xff0c;不过目前推理结果不对&#xff0c;还在修复&#xff1a; https://github.com/lindsayshuo/yolov8-cls-tensorrtx先看代码 class DFL(nn.Module):"""Integral module of Distribution Focal Loss (DFL).Proposed in Generalized…
阅读更多...
视频占用内存太大了怎么办 如何快速又无损的压缩视频 快来学习吧

视频占用内存太大了怎么办 如何快速又无损的压缩视频 快来学习吧

视频文件太大是很多人在使用电脑或移动设备时经常遇到的问题。如果视频文件过大&#xff0c;不仅会占用过多的存储空间&#xff0c;还会让播放和传输变得困难。为了解决这个问题&#xff0c;我们需要学会如何缩小视频文件大小。那么如何缩小储存视频的大小呢&#xff1f;下面给…
阅读更多...
【JAVA】CSS2：样式、选择器、伪类、颜色、字体、边框、列表、背景、盒子、布局、浮动

【JAVA】CSS2：样式、选择器、伪类、颜色、字体、边框、列表、背景、盒子、布局、浮动

本文介绍了CSS样式、选择器、伪类、像素、颜色、字体、边框、列表、表格属性、背景、盒子、布局与浮动 1.样式 1.1 行内样式 <h1 style"color: aqua;font-size: large;">123</h1> 1.2 内部样式 <style>h1{color: red;font: 100;}</style>…
阅读更多...
高速电路顶级会议DesignCon 2019年会议总结和论文资料分享

高速电路顶级会议DesignCon 2019年会议总结和论文资料分享

会议基本介绍 DesignCon 2019年是一场专注于电子设计和信号完整性的国际会议&#xff0c;于在美国加利福尼亚州举行。 主题丰富&#xff1a;DesignCon 2019年聚焦于电子设计和信号完整性的多个领域&#xff0c;包括高速串行链接、射频和微波设计、功率完整性、模拟设计、信号…
阅读更多...
Unity3d Shader篇（十三）— 透明度混合(AlphaBlend)

Unity3d Shader篇（十三）— 透明度混合(AlphaBlend)

文章目录 前言一、什么是透明度混合&#xff1f;1. 透明度混合原理2. 透明度混合优缺点优点&#xff1a;缺点&#xff1a; 3. 纹理图 二、使用步骤1. Shader 属性定义2. SubShader 设置3. 渲染 Pass4. 定义结构体和顶点着色器函数5. 片元着色器函数 三、效果四、总结 前言 在计…
阅读更多...
ArmSoM Rockchip系列产品 通用教程 之 PCIe 使用

ArmSoM Rockchip系列产品 通用教程 之 PCIe 使用

1. PCIe 简介​ PCIe&#xff08;Peripheral Component Interconnect Express&#xff09;是一种用于连接主板和外部设备的高速串行接口标准。它是 PCI 技术的后继者&#xff0c;旨在提供更高的带宽和更好的性能。 高速传输&#xff1a; PCIe接口提供了高速的数据传输通道&am…
阅读更多...
【STA】SRAM / DDR SDRAM 接口时序约束学习记录

【STA】SRAM / DDR SDRAM 接口时序约束学习记录

1. SRAM接口 相比于DDR SDRAM&#xff0c;SRAM接口数据与控制信号共享同一时钟。在用户逻辑&#xff08;这里记作DUA&#xff08;Design Under Analysis&#xff09;&#xff09;将数据写到SRAM中去的写周期中&#xff0c;数据和地址从DUA传送到SRAM中&#xff0c;并都在有效时…
阅读更多...
使用QEMU来模拟运行Linux系统

使用QEMU来模拟运行Linux系统

第一步&#xff1a;安装 执行命令 假设我们呢开发板需要arm64架构的Ubuntu 得通过apt-file去找&#xff0c;可以找到qemu-system-arm 所以直接按照qemu-system-arm就行了 apt-file list会列举这个软件包里所有的文件 这个命令可以列举出所有安装好的包名&#xff0c;有点像pip…
阅读更多...
什么是PLC远程控制模块？

什么是PLC远程控制模块？

随着工业自动化的不断发展&#xff0c;可编程逻辑控制器&#xff08;PLC&#xff09;已成为现代工业设备中不可或缺的核心组件。然而&#xff0c;传统的PLC管理方式往往受限于现场操作和维护&#xff0c;难以满足日益复杂的工业需求。在这一背景下&#xff0c;PLC远程控制模块应…
阅读更多...
【数据库系统概论】第2章：关系数据库

【数据库系统概论】第2章：关系数据库

文章目录 0. 前言2.1 关系数据结构及形式化定义2.1.1关系2.1.2 关系模式 2.2 关系操作2.3 关系的完整性2.4 关系代数 0. 前言 关系数据库系统是支持关系模型的数据库系统。第一章初步介绍了关系模型及其基本术语。本章将深入介绍关系模型。 按照数据模型的三个要素&#xff0c;…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023