【算法面试题】-05

智能成绩表

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


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的每个元素的最后一个值

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

07 数据结构之图

07 数据结构之图

# Makefile CCgcc CFLAGS -g -Wall SRCStest.c graph.c link_queue.c OBJS$(SRCS:.c.o) #variable replace APPtestall:$(OBJS) #指定一个目标&#xff0c; 不然默认目标不会检查依赖文件的时间戳$(CC) $(SRCS) -o $(APP) .PH…
阅读更多...
协程库项目—协程类模块

协程库项目—协程类模块

ucontext_t结构体、非对称协程 协程类 ucontext_t结构体 头文件中定义的四个函数&#xff08;getcontext(), setcontext(), makecontext(), swapcontext()&#xff09;和两个结构类型&#xff08;mcontext_t, ucontext_t&#xff09;在一个进程中实现用户级的线程切换。 其中…
阅读更多...
NXP iMX8MM Cortex-M4 核心 GPT Capture 测试

NXP iMX8MM Cortex-M4 核心 GPT Capture 测试

By Toradex秦海 1). 简介 NXP i.MX8 系列处理器均为异构多核架构 SoC&#xff0c;除了可以运行 Linux 等复杂操作系统的 Cortax-A 核心&#xff0c;还包含了可以运行实时操作系统比如 FreeRTOS 的 Cortex-M 核心&#xff0c;本文就演示通过 NXP i.MX8MM 处理器集成的 Cortex-…
阅读更多...
brpc之Channel

brpc之Channel

简介 Channel是brpc的通信类&#xff0c;继承于RpcChannel&#xff0c;RpcChannel是protobuf中的类&#xff0c;用于服务通信 Channel #mermaid-svg-HdRl5ZFGKiLhYVuW {font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}#mermaid-s…
阅读更多...
Sqllab第一关通关笔记

Sqllab第一关通关笔记

知识点&#xff1a; 明白数值注入和字符注入的区别 数值注入&#xff1a;通过数字运算判断&#xff0c;1/0 1/1 字符注入&#xff1a;通过引号进行判断&#xff0c;奇数个和偶数个单引号进行识别 联合查询&#xff1a;union 或者 union all 需要满足字段数一致&…
阅读更多...
《领导的气场——8堂课讲透中国式领导智慧》读书笔记

《领导的气场——8堂课讲透中国式领导智慧》读书笔记

整体感悟 个人感觉书籍比较偏说教、理论&#xff0c;没有看完。 现仅仅摘录自己“心有戚戚焉”的内容。 经典摘录 管理的本质是通过别人完成任务。有一百件事情&#xff0c;一个人都做了&#xff0c;那只能叫勤劳&#xff1b;有一百件事情&#xff0c;主事的人自己一件也不做&…
阅读更多...
子类的继承性

子类的继承性

继承性 类有两种重要的成员&#xff1a; 成员变量和方法 子类的成员 ① 自己声明定义 ②从父类继承 ① 成员变量的继 把继承来的变量作为 自己的一个成员变量 &#xff08;如同在子类中直接声明一样&#xff09;&#xff1b; 可被子类中自定义的任何实例方法操作 。 ② 方法…
阅读更多...
虚拟机中安装Win98

虚拟机中安装Win98

文章目录 一、下载Win98二、制作可启动光盘三、VMware中安装Win98四、Qemu中安装Win981. Qemu的安装2. 安装Win98 Win98是微软于1998年发布的16位与32位混合的操作系统&#xff0c;也是一代经典的操作系统&#xff0c;期间出现了不少经典的软件与游戏&#xff0c;还是值得怀念的…
阅读更多...
【牛客】CM26 二进制插入 HJ60 查找组成一个偶数最接近的两个素数

【牛客】CM26 二进制插入 HJ60 查找组成一个偶数最接近的两个素数

目录 题目一&#xff1a;二进制插入 题目链接&#xff1a;二进制插入_牛客题霸_牛客网 (nowcoder.com) 解题思路&#xff1a; 代码实现&#xff1a; 题目二&#xff1a;查找组成一个偶数最接近的两个素数 题目链接&#xff1a;查找组成一个偶数最接近的两个素数_牛客题霸_…
阅读更多...
【sgPhotoPlayer】自定义组件：图片预览，支持点击放大、缩小、旋转图片

【sgPhotoPlayer】自定义组件：图片预览，支持点击放大、缩小、旋转图片

特性&#xff1a; 支持设置初始索引值支持显示标题、日期、大小、当前图片位置支持无限循环切换轮播支持鼠标滑轮滚动、左右键、上下键、PageUp、PageDown、Home、End操作切换图片支持Esc关闭窗口 sgPhotoPlayer源码 <template><div :class"$options.name"…
阅读更多...
线程和进程

线程和进程

参考链接&#xff1a; 1.基本概念 进程&#xff1a;Windows系统中&#xff0c;一个运行的xx.exe就是一个进程。例如打开浏览器就是一个进程 线程&#xff1a;进程中的一个执行任务&#xff08;控制单元&#xff09;&#xff0c;负责当前进程中程序的执行。一个进程至少有一个…
阅读更多...
无人机|LQR控制算法及其无人机控制中的应用仿真

无人机|LQR控制算法及其无人机控制中的应用仿真

前言 LQR全称Linear Quadratic Regulator&#xff08;线性二次调节器&#xff09;&#xff0c;顾名思义用于解决形如 x ˙ A x B u y C x D u \begin{aligned}\dot{x}&AxBu\\y&CxDu\end{aligned} x˙y​AxBuCxDu​ 线性时不变系统的一种线性控制方法&#xff0c;…
阅读更多...
初识REDHAWK

初识REDHAWK

文章目录 前言一、什么是 REDHAWK?1、概述2、REDHAWK 的应用 二、REDHAWK 的流程管理和交互方法1、流程管理2、数据传输 三、入门1、安装 REDHAWK2、IDE 快速入门①、启动 REDHAWK IDE②、打开 Chalkboard③、创建信号发生器④、测试组件的输入/输出响应 前言 REDHAWK 是一个…
阅读更多...
Opencv 绘制线段、矩形、圆形、多边形操作

Opencv 绘制线段、矩形、圆形、多边形操作

1、前言 OpenCV提供了许多用于绘制图形的方法 包括绘制线段的line()方法、绘制矩形的 rectangle()方法、绘制圆形的 circle()方法、绘制多边形的 polylines()方法和绘制文字的 putText()方法 本章将依次对上述各个方法进行讲解&#xff0c;并作出相应实验。 因为 OpenCV 中的…
阅读更多...
简洁的链式思维（CCoT）提示

简洁的链式思维（CCoT）提示

原文地址&#xff1a;Concise Chain-of-Thought (CCoT) Prompting 传统的CoT导致了输出令牌使用的增加&#xff0c;而CCoT提示是一种旨在减少LLM响应的冗长性和推理时间的提示工程技术。 2024 年 1 月 24 日 Areas where Chain-Of-Thought-like methodology has been introd…
阅读更多...
【C/C++ 学习笔记】函数

【C/C++ 学习笔记】函数

【C/C 学习笔记】函数 视频地址: Bilibili 函数结构 返回值类型函数名参数列表函数体语句return 表达式 返回值类型 函数名 (参数列表) {函数体语句;return 表达式; }声明 在函数定义之前声明函数&#xff0c;可以声明多次&#xff0c;但是只能定义依次 返回值类型 函数名…
阅读更多...
计算机考研｜保姆级择校+资料+全年规划

计算机考研｜保姆级择校+资料+全年规划

本科211&#xff0c;研究生上岸某985 计算机考研备考过程中走了不少弯路&#xff0c;希望我的经验能够帮助大家少走弯路 大家决定考研之前&#xff0c;一定要认真思考自己考研的目的是什么&#xff0c;有的人是随大流&#xff0c;别人考研&#xff0c;就跟风考研&#xff0c;有…
阅读更多...
JDK 17：Java生态系统的最新巨擘

JDK 17：Java生态系统的最新巨擘

JDK 17&#xff1a;Java生态系统的最新巨擘 &#x1f680; JDK 17&#xff1a;Java生态系统的最新巨擘 &#x1f680;摘要 &#x1f31f;引言 &#x1f308;模块一&#xff1a;性能优化与提升 &#x1f527;垃圾回收器的改进&#xff1a;JIT编译器的优化&#xff1a;其他性能优…
阅读更多...
Visual Basic6.0零基础教学(2)—vb中类的介绍和基本控件的属性

Visual Basic6.0零基础教学(2)—vb中类的介绍和基本控件的属性

Visual Basic 6.0中类的介绍和基本控件的属性 文章目录 Visual Basic 6.0中类的介绍和基本控件的属性前言一、对象的有关概念1.类2.对象3.对象的三要素4.5. VB程序的执行步骤 二、基本控件属性1.修改控件属性的练习案例 总结 前言 大家好&#xff0c;昨天我们学习了vb的简单介…
阅读更多...
python实现生成树

python实现生成树

生成树 生成树&#xff08;Spanning Tree&#xff09;是一个连通图的生成树是图的极小连通子图&#xff0c;它包含图中的所有顶点&#xff0c;并且只含尽可能少的边。这意味着对于生成树来说&#xff0c;若砍去它的一条边&#xff0c;则会使生成树变成非连通图&#xff1b;若给…
阅读更多...
最新文章

Copyright @ 2022~2023