学进去

某奶茶店收到了n杯奶茶的订单，这n杯奶茶分别经过甲、乙两个工序加工，并且必须先在甲工序加工后才可以进行乙工序。为了使得总加工时间最短，我们可以将这n杯奶茶分为两类：
第一类：甲工序的加工时长少于乙工序的加工时长。
第二类：甲工序的加工时长不少于乙工序的加工时长。
第一类应将在甲工序花费时间少的产品排在前面，第二类应将在乙工序花费时间少的产品排在后面，然后先处理所有第一类产品，再处理第二类产品。可以证明，这样排序后所有奶茶加工完成花费的总时间最少。
如：有4杯奶茶的订单，它们在甲工序的加工时长分别为2、3、5、1，在乙工序的加工时长分别为3、1、2、5，将奶茶分类、排序、合并、计算时长的过程如图所示，最后得出总时长为12。(每杯奶茶在乙工序开始加工需同时满足它甲工序加工完并且乙工序已加工完上一个产品这两个条件)

编写程序模拟奶茶店对这n杯奶茶的处理过程，计算总加工时间。
请回答下列问题:
（1）由题意可知，若3杯奶茶在甲工序加工时长分别为3、1、3，乙工序加工时长分别为2、4、3，则总加工时长为_______。
（2）小李先编写了如下将第一类产品排序的函数:
def order1(a,b): #参数a、b的元素分别表示每杯奶茶在甲乙两道工序的加工时长。

ans=[0]*100

idx=[0]*100

tmp1=[];tmp2=[]

for i in range(len(a)):

                ①_______

          idx[a[i]]=b[i]   #原始序号排序后会跑到第b[i]位置上

for i in range(len(ans)):

            while ans[i]>0:

                            ②_________

                    tmp2.append(idx[i])

                    ans[i]-=1

return tmp1,tmp2

请在划线处填入合适的代码。
（3）小方编写了将第二类产品排序的函数:
def order2(a,b): #参数a、b的元素分别表示每杯奶茶在甲乙两道工序的加工时长。
            #代码略
小张结合前两位同学的程序，计算产品加工总时长。请在划线处填入合适的代码。读取n杯奶茶在甲乙两道工序加工的时间，根据题目要求分为两类，第一类在甲乙两道工序加工的时间分别存储在列表a1和列表b1中,并通过order1()函数排序，第二类在甲乙两道工序加工的时间分别存储在列表a2和列表b2中,并通过order2()函数排序，代码略。

‘’’#代码略

a=a1+a2

b=b1+b2

n= len(a)

ta,tb=0,0     #ta为甲加工时间，tb为乙加工时间

for i in range (n) :

ta+=a[i]

if       ①______ :

tb=ta

                     ②_______

print("总加工时长最短为:",tb)

“网上预约挂号系统”的就诊规则为：年龄大于等于80岁的患者优先就诊，其余患者按照顺序就诊，现系统根据预约顺序记录了某天某科室患者的就诊号、姓名和年龄，部分数据如图a所示。经系统处理后输出患者的就诊顺序，部分数据如图b所示，请回答下列问题。

图a                                                               图b

（1）创建output函数，输出患者就诊顺序，请在划线处填上合适代码。
def output（1st，p）：
       k=1
       print（"患者就诊顺序："）
       while p ！=-1：
             print（k，"号"，1st[p][1]）
             _______
             p=1st[p][3]
（2）实现按规则排出患者就诊顺序的Python程序如下，请在划线处填入合适代码。
#读取患者信息存入pat列表，列表的每个元素包含3个数据项，分别对应患者的就诊号、姓名和年龄，pat=[['021036'，'张*星'，32]，…]，代码略
①___
for i inrange（n）：
       pat[i].append（-1）             #pat[i]追加一个元素-1
head=0
for i inrange(1,n):
       if pat[i][2]>=80:
             if ②___:
                    pat[i][3]=head
                    head=i
             else:
                    p=head
                    while pat[pat[p][3]][2]>=80 and pat[p][3]!=-1:
                           p=pat[p][3]
                     ③___
                    pat[p][3]=i
       else:
             q=p=head
             while p!=-1:
                   ④___
                  p=pat[p][3]
             pat[q][3]=i
output(pat,head)

“抢单”是外卖骑手的日常，当外卖平台上一个新的订单出现时，骑手需要在短时间内考虑是否抢单。平台根据骑手的实际信息，给出是否抢单的建议，若建议抢单则给出到达各个取送点的顺序。平台判断是否抢单的算法设计如下：
1）在不改变已有订单各取送点顺序的前提下，将新订单按先取餐后送餐的顺序分别插入原来的路线中，枚举所有新路线；
2）计算新路线路程，并进行判断：每个取送点都有一个系统指定时间，若骑手到达该位置时，时间晚于系统指定时间，则该方案无效；
3）对新路线进行计算和判断后，删除此次枚举的两个插入位置，还原为初始状态，再继续进行下一次枚举；
4）在所有有效方案中，输出总路程最小的方案，若无有效方案，则输出不接单的建议。如果骑手目前无订单在派送中，则插入订单A的方案只有1种，骑手→取餐点A→送餐点A；如果骑手订单中已有1个送餐点A和1个送餐点B，则新订单C有6种插入方案：
方案I：骑手→取餐点C→送餐点C→送餐点A→送餐点B
方案Ⅱ；骑手→取餐点C→送餐点A→送餐点C→送餐点B
方案Ⅲ：骑手→取餐点C→送餐点A→送餐点B→送餐点C
方案IV：骑手→送餐点A→取餐点C→送餐点C→送餐点B
方案V：骑手→送餐点A→取餐点C→送餐点B→送餐点C
方案VI：骑手→送餐点A→送餐点B→取餐点C→送餐点C
请回答下列问题：
（1）若骑手仅剩1份餐未送（已取餐），路线为：骑手→送餐点A，新的订单出现后，有________（填数字）种插入方案。
（2）定义如下con（tim）函数进行时间格式转换，将24小时制的“时：分”转换为分，如02：30转换为150，请在划线处填上合适代码。
def con（tim）：
     t=________+int（tim[3：]）
     return t
（3）定义totd（riderlist，h）函数，其功能为从头指针h进入链表riderlist，按节点先后顺序计算总路程，并判断能否在系统指定时间内到达各取送点，若到达某一取送点时超时返回-1。若链表riderlist如下，
riderlist=［［“u1001”，“119．906033”，“31．014597”，“11：30”，2］，
[“s”，“119．921439”，“31．023022”，“11：55”，3]，
[“t”，“119．887850”，“31．022861”，“11：40”，1]，
[“s”，“119．953836”，“31．021122”，“12：10”，-1]]
第1个元素中“u1001”为骑手编号，“119．906033”和“31．014597”，表示骑手实时位置，“11：30”为实时时间，2为下一节点指针，第2个元素开始，第1项若为“t”表示此元素为取餐点信息，若为“s”表示此元素为送餐点信息．调用函数totd（riderlist，h），risderlist的值如上，h为0，则加框处语句将被执行________次，若将此条件语句改为riderlist[pre][4]!=-1，________（选填：影响/不影响）程序执行。
def   totd（riderlist，h）：
     speed=0.3 #speed为骑手每分钟公里数
     total=0
     pre=h
     cur=riderlist[pre][4]
while ：
          #计算pre与cur两个节点所在位置间的路程，存储在变量d中
          total+=d
          if total/speed>con（riderlist[cur][3]）-con（riderlist[h][3]）：
               return-1
          else：
               pre=cur
               cur=riderlist[pre][4]
     return round（total，2）
（4）实现是否接单判断的Python部分程序如下，请在划线处填入合适的代码。
def add（oldlist，x，c）：#在x所指节点后插入新节点c
     c[4]=oldlist[x][4]
     oldlist.append（c）
     oldlist[x][4]=len（oldlist）-1
     return oldlist
#读取骑手信息，存储在lit中，代码略
tc=[“t”，“119．936506”，“31．008933”，“12：05”，-1]#新订单取餐信息
sc=[“s”，“119．919839”，“31．020183”，“12：22”，-1]#新订单送餐信息
ans=[-1，-1，10000]
head=0
p=head
while p!=-1：
     lit=add（lit，p，tc）
       ①____
     while q!=-1：
          lit=add（lit，q，sc）
          tot=totd（lit，head）
          if tot!=-1 and ②____：
               ans=[p，q，tot]
          lit[q][4]=lit[lit[q][4]][4]
          q=lit[q][4]
     lit[p][4]=lit[lit[p][4]][4]
     p=lit[p][4]
     if ans[2]==10000
          print（“不建议接单，不能在系统指定时间内送达。”）
     else：
          print（“可以接单，建议各取送点到达顺序依次为：”）
#按顺序输出各取送点代码略

某工厂有若干种货物存储在仓库，仓库有m（编号为0~m-1）个货柜，每个货柜存放一件货物。管理员可以入库、出库等操作，每次操作对象有货物名称和数量，入库时从0号到m-1号找到空的货柜放入仓库，出库时一样按序取出。
如仓库有m=10个货柜，依次进行以下3次操作：
入库：[ ['A'，3]，[B'，1] ]，表示把货物A入库3件，货物B入库1件；
出库：[ ['A'，1]]，表示把货物A出库1件；
入库：[['C'，2]，['A'，1]]，表示把货物C入库2件，货物A入库1件
操作结束后，仓库的存储模拟视图如图所示：

0	1	2	3	4	5	6	7	8	9
C	A	A	B	C	A

（1）在上图所示的基础上，再进行出库操作[ ['C'，1]]，入库操作[['B'，2] ]，操作结束后0号货柜存放的货物是_______。
（2）函数finde() 可以在仓库中查找空货柜的位置，加框处代码应改为________。
def finde():

j = 0

while:

j += 1

             if j == m:

                      return   -1

             c[j] = -1
        return j
（3）函数putin实现将列表a中的货物入库，如a=[['A'，3]，['B'，1]]。
def putin():

for i in range(len(a)):

p=finde()

if p==-1:

#仓库已满，后续操作代码略

return

if a[i][0] not in info:       #当前货物没出现过

info[a[i] [0]] =[p, p]

else：

c[info[a[i][0]][1]]=p

for j in range(a[i][1] -1):

       ________

p=c[p]

info[a[i][0]][1] =p

（4）函数getout实现将列表a中的货物出库操作。
def getout():

for i in range(len(a)):

if a[i][0] not in info:

print("提示:该货物已无存量! ")

continue

p=info[a[i][0]][0] ; r= 0

while p! =-1 and r<a[i][1]:

t=c[p] ; c[p]=-2 ; p=t

                    ①_______

if p==-1:

info.pop(a[i][0]) #删除字典中指定的键值对

else:

                    ②_______

print("提示:该货物已出库"+str(r) +"件")

m=500#货柜个数
c=[-2] *m ; info={}       #c[i]=-2，表示i号货柜为空
while True：

print("仓库管理系统操作菜单:1.入库2.出库3.查询4.存储现状图5.退出"）

t=int(input("请输入操作步骤:(选择数字1~5) "))

#读入货物数据到列表a，调用相应函数，代码略

某办事处每天都有客户来办理业务，每位客户信息包括客户编号、到达时间、办理业务所需时 长和客户等级(1 代表是 VIP ，0 代表不是 VIP) ，如图 a 所示。已将当天所有客户信息， 按照到达时间的先后顺序存储在文件中。该办事处共有 2 个窗 口，初始时仅开通 1 个窗 口，当 排队人数到达 m 时，增开 1 个窗 口，增开窗 口后，不再关闭。所有客户按照到达时间排成一队办理业务，VIP 客户优先。

客户 编号		到达 时间		办理业务所 需时长 (分)		客户 等级
1		07:53		8		0
2		07:54		6		0
3		07:57		7		0
4		08:02		8		1
5		08:12		10		1
.		.		.			.

图 a

图b

从文件中读取当天客户信息，根据上述规则，按办理业务顺序输出办理结果，如图 b 所示。
       (1) 以图 a 为例，若只开 1 个窗口，第 4 个办理业务的客户编号为______________。
       (2) 实现上述功能的 Python 程序段如下，请在划线处填入合适的代码。
'''从文件中读取客户信息存入 data 中 (到达时间已转换为分钟，如 07:53 转换为 473) ，其 中 data[0]存储第 1 个客户信息，data[0][0] 、data[0][1] 、data[0][2] 、data[0][3]为分别表示第 1 个客户的客户编号、到达时间、办理业务所需时长 (分) 和客户等级，代码略。'''                 
def mt(x) :
#将分钟转换为时间格式，如 473 转换为 07:53,代码略
def gs(x):
#格式化输出，代码略
t=[[9999,9999],[9999,9999]]#t[0]代表第一个窗口的开始时间和结束时间，t[1]代表第二个窗
口的开始时间和结束时间
m=int(input("请输入 m 的值："))
n=len(data)
t[0][0]=data[0][1]
t[0][1]=data[0][1]+data[0][2]
print("办理序号","客户编号","开始时间","结束时间","窗口编号")
print(gs(1),gs(data[0][0]),gs(mt(t[0][0])),gs(mt(t[0][1])),gs(0))
full=False                  #full 为 True 表示 2 个窗口办理业务
waitnum=0
openwin=False       #openwin 为 True 表示增开 1 个窗口
i=1;q=1;head=1;tail=1          #第一个人已经在办理业务， 队伍为空
while         ①_______ :
     while i < n and data [i][1] < min(t[0][1],t[1][1]):
          tail+=1
          waitnum+=1
          tmp=data[tail-1]
          j=tail-2
          while           ②_______ :               #根据优先级调整排队次序
               data [j+1]=data [j]
               j-= 1
          data[j+1]=tmp
          i+=1
          if waitnum==m and not full:
               full=True
               openwin=True
               break
     x=0 #办理业务的窗口编号
     if openwin or full and t[1][1] < t[0][1]:
          x= 1
          if openwin==True:            #新开一个窗口
               t[x][1]=        ③________
               openwin=False
     if waitnum>0:
          t[x][0]=t[x][1]
          t[x][1]=t[x][1]+data[head][2]
          waitnum-= 1
          q+=1
          print(gs(q),gs(data[head][0]),gs(mt(t[x][0])),gs(mt(t[x][1])),gs(x))
④_______
     else:
          t[x][0]=data[i][1]
          t[x][1]=data[i][1]+data[i][2]
          q+=1
          print(gs(q),gs(data[i][0]),gs(mt(t[x][0])),gs(mt(t[x][1])),gs(x))
          i+=1
          head=tail=i

某工厂有一批类型不同、数量不等的货物需要运输，要求尽量把相同类型的货物装在同一辆车中，当任意一种类型的货物不能装满一车时，则不同类型的货物可以合并装车。小王设计了一种装车方案，从载货量最大的车开始，优先从数量最多的货物开始装车，装完一车后继续从剩余数量最多的货物中取货装车。他编写了一个Python程序，模拟货物装车过程。程序运行时从文件中读取货物数据及车辆信息，并按车辆最大载货量的大小依次输出每辆车装载的货物类型，以及剩余货物情况。请回答下列问题。
（1）若货物数据及车辆信息如下表所示

货物类型	A	B	C	D	E		车辆编号	C1	C2	C3
货物数量（件）	15	50	28	20	25		最大载货量（件）	25	35	40

则车辆C1装载的货物类型依次为______（填货物类型，用逗号分隔）
（2）货物由2个数据项组成：第1个数据项为货物类型，第2个数据项为货物数量，读入到列表a中的数据格式形如：[[“A”，40][“B”，50]，[“A”，30]，[“C”，20]，①…]．首先对货物数据进行预处理，将类型相同的货物进行合并，如a=[[“A”，40]，[“B”，50]，[“A”，30]，[“C”，20]]，则合并后的数据为[[“A”，70]，[“B”，50]，[“C”，20]]。编写自定义函数merge（1st），参数1st为货物列表，
Python程序代码如下：

def merge（1st）：

i=0；n=len（lst）-l

while i<n：

j=i+1

while j<=n：

if lst[i][0]==lst[j][0]：

lst[i][l]+=lst[j][1]

①__

j-=1；n-=1

j+=1

i+=l

return 1st[：n+1]

①请将划线处代码补充完整。
②若1st的值为[[“A”，40]，[“B”，50]，[“A”，30]，[“C”，20]]，则程序中1st[i][0]与1st[j][0]比较了______次。
（3）实现模拟货物装车的Python程序代码如下，请在划线处填入合适的代码。
’’’读取货物数据和运输车辆数据，分别存入列表a和列表b中。列表b的每个元素包含2个数据项，分别为车辆编号和最大载货量。列表b数据格式形如：b=[[“Cl”，25]，[“C2”，35]，[“C3”，40]]，代码略’’’
data=merge（a）
#对列表变量data按数量降序排序，对列表b按最大载货量降序排序，代码略
m=len（b）
for i in range（len（data））：

data[i]．append（i+1）#为data[i]增加一个元素

data[i][2]=-1
head=0
for i in range（m）：

num=0；s=“”

q=head

while q!= -l and num<b[i][1]：

num+=data[q][1]

data[q][1]=0

s+=data[q][0]+”，”

p=q；q=data[q][2]

print（”编号为”，b[i][0]，”的车辆装载的货物为：”，s）

if num>b[i][1]：

①__

head=p

else：

head=q

q=head

if q!=-l：

while data[q][2]!= -l and ②__；

q=data[q][2]

if q!=head：

tmp=data[head][2]

data[head][2]=data[q][2]

data[q][2]=head

③__

else：

break

if head!=-l：

print（”剩余货物及数量：”）

p=head

while p!=-1：

print（data[p][0]，”货物：”，data[p][1]）

p=data[p][2]

else：

print（”货物已全部装完！”）

有n位用户需要办理事务，每位用户的信息包含到达时间及办理时长。共有m条通道可以进行办理。每位用户均选择完成事务时间最早的通道入队，若存在多条相同完成时间的通道，则选择编号靠前的通道入队（在某条通道入队，则表示该条通道中前一位用户出队）。每条通道每办理5个用户的事务后，将休息10分钟。
编写程序模拟办理过程，先按到达时间加工数据，然后计算所有用户的平均等待时长，其中每位用户的等待时长为其开始办理的时间与其到达时间的时间差。（时间单位为分钟）
请回答下列问题：
（1）结合题意，若有3条通道可以办理事务，则用户D的等待时长为______（填数字）分钟。

	到达时间	办理时长
A	09：01	7
B	09：01	13
C	09：02	5
D	09：04	9
	……	……

（2）定义如下procl（rawdata）函数，参数rawdata的每个元素由到达时间及办理时长构成，并已按到达时间升序排列，形如[[’09:01’,7]，[’09:01’,13]，[’09:02’,5]，[’09:04’,9]······]。函数功能是计算到达时间与9点整相差的分钟数，并将其追加至rawdata的每个元素中。
def procl（rawdata）：

for i in range（len（rawdata））：

h=int（rawdata[i][0][:2]）-9

m=int（______）

x=h﹡60+m

rawdata[i].append（x）                           #rawdata[i]追加一个元素x

return rawdata

下列选项中，符合划线处功能要求的是______（多选，填字母）。
A．rawdata[i][0][3:]       B．rawdata[i][0][-2:]       C．rawdata[i][0][:-3:-1]                    D．rawdata[i][0][-2::-1]
（3）计算所有用户平均等待时长的部分Python程序如下，请在划线处填入合适的代码。
def proc2（data,m）：

n=len（data）

head=[0]*m

tail=[0]*m

que=[[0 for i in range(n)] for j in range(m)]

i=0

total=0

while i<n:

x=0

for y in range(1,m)：

if que[y][head[y]]<que[x][head[x]]:

x=y

if head[x]==tail[x]：

que[x][tail[x]]=data[i][2]+data[i][1]

tail[x]+=1

else：

if data[i][2]<que[x][head[x]]:

total+= ①___．

que[x][tail[x]]=que[x][head[x]]+data[i][1]

else：

que[x][tai1[x]]= ②___

tail[x]+=1

head[x]+=1

if ③___:

que[x][head[x]]+=10

i+=1

return total/n

．．．
读取原始数据。存入列表rawdata中，该列表的每个元素包含2个数据项，分别对应用户的到达时间及办理时长，rawdata中的数据已按到达时间升序排列，代码略
读取可办理事务的通道数存入变量m中，代码略
．．．
data=procl（rawdata）
print（proc2（data，m））

餐厅叫号系统是现代化餐厅常用的信息管理系统，小明设计了一款模拟餐厅叫号系统的程序。该程序在读取当天就餐信息（数据格式如1图所示）后，可以模拟餐厅叫号的顺序，并计算出当天所有客人的等待时间。餐厅共有3种不同类型座位，数量分别是30、10、10。客人到达餐厅后，若对应类型的座位有空位，则直接安排客人点餐；若对应类型的座位没有空余，则需要排队等待其他客人离开后才能安排点餐。小明将原始数据读取后将时间格式“HH: MM”换算成分钟，然后按分钟数升序排列，再依次模拟餐厅叫号的过程，同时计算客人的等待时间，程序运行结果如2图所示。
     

1图                                                    2图

（1）“data. csv”中的原始数据需要进行换算和排序后才能进一步处理，读取与排序的程序如下。
a=[]
def read_data (): #读取数据并排序

df=pd.read_csv ("data.csv")

for row in df.values:       #逐行读取数据到列表row

s=row[1]       #将时间数据赋值到s

b，c=map (int，s.split (’：’))       #以“：”分割小时到b，分钟到c

s=b*60+c       #将b小时、c分钟换算成s分钟

a. append ([row[0]，s，row [2]])       #a追加一个元素[row[0]，s，row[2]]

n=len (a)

for i in range(n-1):

for j in range (n-1，i，-1):

if a[j][1]<a[j-1][1]:

a[j]，a[j-1]=a[j-1]，a[j]

①若“data.csv”文件中有10条记录，则上述程序中语句“if a[j][1]<a[j-1][1]”的运行次数为______。
②若将上述程序中的语句“s=b*60+c”删除，仅以第15-1图可见的6条数据运行上述程序后，列表a中元素依次为(        )
A．B．C．D．
（2）实现模拟叫号程序并统计所有客人等待时间部分代码如下，请在划线处填入合适的代码：
read_data ()       #调用read_data ()函数完成数据读取及排序
n=len (a)
b=[0，30，10，10]       #初始3种类型的座位数分别是30，10，10
h=[]；q=[]
for i in range(4):

h.append ([-1，-1])       #h末尾追加一个元素[-1，-1]

c=0
①___
for i in range(n):

m=a[i][0]

if a[i][2]=="OUT":

b[m]+=1

if h[m][0]!=-1:

total+= ②___

h[m][0]=q[h[m][0]][2]

b[m]-=1

print ("类别为"，m，"的客人在"，a[i][1]，"分点餐")

else:

if b[m]>0:

b[m]-=1

print ("类别为"，m，"的客人在"，a[i][1]，"分点餐")

else:

q.append ([m，a[i][1]，-1])

if h[m][0]==-1:

h[m][0]=c

if h[m][1]!=-1:

③___

h[m][1]=c

c+=1

print ("所有客人等待时间："，total，"分钟"）

请根据第二段程序回答下题。
   
●判断题
（1）上述代码中，若将第13行修改为INF = 1 << 40；则输出结果一定不变。(     )
（2）将第23行修改为break或continue这两种情况后，有相同输入时，在这两种情况下，在不考虑运行时间下，输出结果也一定相同。(     )
（3）代码中将第23行修改为break后，有相同的输入，变量c的值和未修改前一定相同。(     )
（3） (此题3分)代码中将第23行修改为break后，有相同的输入，输出结果也一定相同。(     )
●单选题
（5）若输入8，输出(     )。
A. 17       B. 19回车over       C.19       D.23 \nover
（6）代码中将第6行的i < n修改为(     )后功能不变，效率更高。
A.i*i<=n              B.i<n/2                    C.i<n/3             D.i<n/4

如果一个字符串T既是字符串S的前缀，也是S的后缀，那么称T是S的Border。给定S，求出S除自身之外的最长Border。
   
（1）①处应填(     )。
A. int i=n；i>0；i--          B. int i=1；i<=n；i++        C. int i=n-1；i>0；i--       D. int i=1；i<n；i++
（2）②处应填(     )。
A. int j=0；j<=i；j++        B. int j=1；j<=i；j++       C. int j=1；j<i；j++          D. int j=0；j<i；j++
（3）③处应填(     )。
A. int j=0；j<i；j++        B. int j=n-i；j<n；j++        C. int j=0；j<=i；j++       D. int j=n-i；j<=n；j++
（4）④处应填(     )。
A. T[j-n+i]==S[j]        B. T[n-i-j]!=S[j]          C. T[j-n+i]!=S[j]          D.T[n-i-j]==S[j]
（5）⑤处应填(     )。
A. flag     B. ans. size() < T. size()          C. ! flag       D. ans. size()> T. size()