充值活动已开启,快来参与吧 关闭充值活动
当前位置:手动组卷 /高中信息技术 /按知识点
选择知识点
最新上传 最多使用
  • 1. (2023·嘉兴模拟) 最短路径问题。以 m*n 个边长为 1 的正方形组成的矩形,各顶点按行优先从 0 开始编号,如图 a 所示为 3*2 的矩形及顶点编号。从顶点 x(起点)经由各正方形的边移动到顶点 y(终点)有多种移动 路径,编程求解所有的最短路径。

    图 a

    图 b

    1. (1) 分析问题,将矩形转换为计算机可处理的数据。可采用列表存储矩形中各顶点的相邻关系,如图 b所示。

      编写函数init,根据横向和纵向的正方形数量,返回所有顶点及其所有的相邻顶点数据。完善程序,在划线处填入合适的代码。

      def init(m,n):

          tot=(m+1)*(n+1)    #顶点总数

          lst=[[] for i in range(tot)]

          for i in range(tot):

              if i>m:

                  lst[i].append(i-m- 1)

              if i<(m+1)*n:

                  lst[i].append(i+m+1)

              if i%(m+1) != 0:

                  lst[i].append(i- 1)

              if i%(m+1) != m:

                 

          return lst

    2. (2) 分析问题,查找所有从起点到终点的最短路径。例如:查找从起点1到终点10的所有最短路径,可先查找终点10的所有相邻顶点(6,9,11),然后再逐个查找顶点6、9、11的相邻顶点,直到查找到起点1,获得所有最短路径,如图c所示,共有3条长度为3的最短路径,分别为1→2→6→10,1→5→6→10,1→5→9→10。若从起点4到终点11,共有 (填数字)条最短路径。

      图 c

    3. (3) 分析问题,存储查询到的路径。可采用链表结构保存路径数据,例如:查找从起点1到终点10的所有最短路径,首先将终点10的数据[10,0,-1]保存在path[0]中,然后将其相邻顶点6、9、11的数据保存到path中,path[i][0]保存顶点的编号,path[i][1]保存当前顶点到终点的距离,path[i][2]保存下一顶点在path中的位置,其值为-1表示当前顶点为终点。

      编写函数print_path,输出所有的最短路径。完善程序,在划线处填入合适的代码。

      def print_path(x,path,length):    #为起点编号,length为Path中有效元素个数。

          cnt=0

          for i in range(length):

              if path[i][0] == x:

                  cnt+= 1

              s="最短路径"+str(cnt)+":"

              v=path[i]

              while  :

                  s=s+str(v[0])+","

                  v=path[v[2]]

              s=s+str(v[0])+" 。"

              print(s)

    4. (4) 实现上述功能的 Python程序如下,运行结果如图 d 所示。请在划线处填入合适的代码。

      m=3           #横向正方形数量

      n=2              #纵向正方形数量

      mtx=init(m,n)

      x=int(input("请输入起点:"))

      y=int(input("请输入终点:"))

      path=[[] for i in range(30)]

      passed=[False]*len(mtx)    #保存顶点是否已途经

      dis=0

      head=0

      tail=0

      path[tail]=[y,0,- 1]

      tail+= 1

      passed[y]=True

      while not found:

          dis+= 1

          pass_dis=[False]*len(mtx)

          tmp=tail

          for i in range(head,tail):

              v=path[i]

              for d in mtx[v[0]]:

                  if not passed[d]:

                      path[tail]=

                      tail+= 1

                      pass_dis[d]=True

                  if d == x:

                      found=True

              head=tmp

          for i in range(len(mtx)):    #标记已途经的顶点

              if  :

                  passed[i]=True

      #输出结果

      print_path(x,path,tail)

  • 1. (2023·嘉兴模拟) 某地高中的技术选考数据,保存在“jsxk.xls”文件中,如图a所示。

    图 a

    图 b

    请回答下列问题:

    1. (1) 统计各学校技术选考人数占本校总人数的比例,找出占比最高的前 5 所学校并绘制柱形图,如图 b 所示。部分 Python程序如下,请在划线处填写合适的代码。

      import pandas as pd

      import matplotlib.pyplot as plt

      #图表支持中文字体显示,代码略

      df= pd.read_excel("jsxk.xls",dtype={'学校代码':'string'})           #学校代码列为字符串

      df1 = df.groupby("  ", as_index=False).count()        #按学校统计人数

      df1 = df1.rename(columns={'姓名':'学生总数'})#重命名列

      df1['技术比例'] = round(/df1['学生总数']* 100,2)

      df1 = df1.sort_values('技术比例',ascending=False).head(5)

      plt.title('技术选考比例前 5 的学校')

      plt.bar( )

      plt.show()

    2. (2) 在本问题的解决中,为了探究函数 groupby() ,某同学编写了自定义函数zdygroupby() ,其功能为统 计各校技术选考总人数,并以字典的形式返回。函数代码如下,请在划线处填写合适的代码。(注:代码中 lst 为二维列表,列表中每个元素包含3个数据项,格式如[['201901','顾筱扬',NaN],['201901','  俞凯睿', 1.0],['201901',' 陈丹祺', 1.0] … …])

      def zdygroupby(1st):

          dic = {}

          for row in lst:

              if row[2] == 1:

                  if  :

                      dic[row[0]]=1

                  else:

                      dic[row[0]]+= 1

         

  • 1. (2023·嘉兴模拟) 待入栈的序列 a 有多种出栈序列, 以下函数用于判断序列 b 是否是 a 的出栈序列,代码如下:

    def judge(a, b):

        n=len(a) ;st=[- 1]*n

        top-= 1; i=j=0

        while i<n:

            top+= 1

               ①    

            i+= 1

            while top> - 1 and      ②     :  

                top-= 1

                j+= 1

            return top==- 1

    from random import shuffle

    a=[1,2,3,4, 5]

    b=[1,2, 3, 4, 5]

    shuffle (b)                  #将序列 b 的元素随机排序

    if judge(a, b):

        print (b,'是' ,a,' 的出栈序列')

    else:

        print (b,'不是' ,a,' 的出栈序列')

    程序运行结果如图所示。划线处应填写的语句是(   )

    A . ①st[top]=a[i]               ②st [top]==b[j] B . ①st[top]=a[i]                ②st[- 1]==b[j] C . ①st [top]=b[i]              ②st[top]=a[j] D . ①st[top]=b[i]              ②st[- 1]= =a[j]
  • 1. (2023·浙江模拟) 某咖啡店,店里共有4种咖啡,类型编号为0到3,每次只能制作一种类型的咖啡,咖啡都是批量现做(制作过程中不能更改数量或类型)。店员需按照订单的先后顺序完成订单(即当前订单完成之前不能换订单),已经接到的订单中的同一类型咖啡可以一起制作(假设咖啡机能同时制作的数量上限足够高),且不需要额外增加时间(即只需制作一杯的时间)。如图1为每个订单的咖啡数量,初始“订单0”中[6, 0, 2, 4]表示0到3号咖啡的购买数量。此时店员先做数量最多的6份0号咖啡,1分钟后接到新订单[1, 18, 0, 2],之后每分钟都会接到1个新订单,这些订单都计入每种咖啡的待做数量。3分钟后这6份0号咖啡制作完成,程序会在“订单0”中选择还没制作的且待做数量最多的(数量相同时先后不作要求)咖啡作为下一次要制作的咖啡。编写python程序,每次制作完一种咖啡,输出接下来要制作的咖啡,运行界面如图2:

    图 1

    图  2

    1. (1) 由图1的订单信息,3 分钟后" 咖啡 0"制作完成,那么图2 中(1)处店员接下来要做的咖啡是咖啡
    2. (2) 根据待制作的咖啡数量,对链表初始化,生成降序链表 lnk,则代码运行后 y的值为

      def sort():

          for i in range(3):

              for j in range(3,i,- 1):

                  if waitlist[index[j]][1] > waitlist[index[j - 1]][1]:

                      index[j], index[j - 1] = index[j - 1], index[j]

              if waitlist[index[j]][1]==0:

                  return j

          return 4

      waitlist=[[3,6],[4,0],[1,2],[2,4]]    # "咖啡 0" 的批量制作时间为 3 分钟,目前待做量为 6,以此类推

      q=[[6, 0, 2, 4], [1, 18, 0, 2], [2, 1, 2, 1], [0, 1, 0, 5],…… #如图 1,代码略

      #q 保存订单流,第一个订单[6,0,2,4]作为初始订单已计入 waitlist

      index=[0,1,2,3]

      y=sort()

      lnk=[- 1]*4

      for i in range(y- 1):                  #创建降序链表

          lnk[index[i]]=index[i+1]

      p=lnk_h=index[0]

      print("请制作咖啡"+str(p))

      waitlist[p][1]=0      #咖啡 p 进入制作,待做数量回 0

    3. (3) 请在划线处填入合适的代码。

      defenqueue(order):      #order 是一个订单,例如[1,2,0,3]

          global lnk_h

          flag.append([0,0,0,0])      #新订单 4 种咖啡未完成

          for i in range(4): f = True

              if waitlist[i][1]==0: f=False

                  if order[i]==0: continue

                      waitlist[i][1]+=order[i]    #将订单 order 中的咖啡 i 累加到待制作数量中

                      cur=lnk_h

                      while cur!=- 1 and waitlist[i][1]<waitlist[cur][1]:

                          pr,cur=cur,lnk[cur]

                      if cur!=i:

                          tmp = lnk[i]

                          lnk[i]=cur

                          if cur==lnk_h:

                              lnk_h=i

                          else:

                              lnk[pr]=i

                          if f:

                              while cur!=i:

                                  pr,cur=cur, lnk[cur]

                                 

      def nextfood(qhead,qtail):        #找到下一次要做的咖啡

          global lnk_h

          cur=lnk_h

          while  :

              pr,cur=cur,lnk[cur]

              if cur==lnk_h:

                  lnk_h=lnk[lnk_h]

              elif cur==- 1:

                  return – 1

              else:

                  lnk[pr]=lnk[cur]

              waitlist[cur][1]=0

              for i in range(  ):

                  if q[i][cur]!=0: flag[i][cur] = 1

                      return cur 

      qhead,qtail=0,1

      order=q[qhead]

      flag=[[1,0,0,0]]            #flag[i][j]=1 标记"订单 i" 中的"咖啡j" 已经在做或已经做完。 lnk_h, time =lnk[lnk_h],0

      while True:

          time=(time+1)%waitlist[p][0]

          if qtail<len(q):

              enqueue(q[qtail])   #接新订单

              qtail+=1

          if time==0:

              while qhead<qtail- 1 and sum(flag[qhead])+q[qhead].count(0)==4:        #订单完成时

                  qhead+=1

                  order=q[qhead]

              p=nextfood(qhead,qtail)

              if p == - 1 : break

              print("请制作咖啡"+str(p))

  • 1. (2023·浙江模拟) 有如下程序段:

    def fun(k):

        if k==1 :

            return "1"

        elifk%2==0:

            return fun(k- 1)+str(k%2)

        else:

            returnstr(k%2)+fun(k- 1)

    执行语句 s=fun(5) ,则 s 的值为(         )

    A . "00111" B . " 11010" C . " 11100" D . " 10110"
  • 1. (2023·浙江模拟) 某工厂将送达的各批次物品按品种打包。小李将各批次物品信息按送达时间顺序合并,得到如图 a-2 所示数据 data。同一个包裹只能装入同一品种任意批次的物品,当某一个品种物品 A 送达使得已送达的该品种物品总重量超过 m 时,则将在该物品之前送达的物品按重量由大到小依次 装入包裹,其余重量不足 m 的品种,按各品种依次装入包裹。编写程序,读取物品合并更新后的信 息,按送达时间顺序打包,输出各包裹中的物品序号,运行结果如图 b 所示。

    请回答下列问题:

    1. (1) 送达物品信息合并后如图 a-2 所示,若包裹装入物品重量不能超过 8 千克,则首先打包 完成的包裹中装入品种为 0,各物品的序号依次是
    2. (2) 定义 data_sort(lst)函数。先将数据(如图 a-1 中所示)合并得到 lst 列表(如图 a-1 中所示),函数 data_sort(lst)的功能是对 lst 列表按送达时间升序排列,并对序号进行更新。

      def data_sort(lst):

          for i in range(n- 1):

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

                  if lst [j][2]< lst [j- 1][2]:

                      lst [j], lst [j- 1]= lst [j- 1], lst [j]

              lst[i][0]=i+1

          return lst

      执行上述代码后, (填写:能/不能)正确得到如图 a-2 中的数据。

    3. (3) 实现上述功能的部分Python程序如下,请在划线处填入合适的代码。

      def pack(k):      #对品种 k已送达待打包的物品按重量由大到小输出

          #部分代码略

          p=b[k][1]

          num+= 1

          print("第"+str(num)+"个包裹中品种为"+str(k)+" ,各物品的序号依次是:",end=" ")

           while p!=- 1:

              print(data[p][0],end=",")

              p=x[p]

          print()

      '''

      合并后排序得到 n 件物品的数据存储在数组 data 中并输出,包裹最大承受最大重量为 m 千克。 物品品种的数量是 sn ,代码略

      '''

      b=[[0,- 1] for i in range(sn)]

      x=[- 1 for i in range(n)]

      num=0

      for i in range(n):

          k=data[i][1]

          if b[k][0]+data[i][4]>m :

              pack(k)

              b[k]=[0,- 1]

          p=

          if p==- 1:

              b[k][1]=i

          else:

              if data[i][4]>data[p][4]:

                  b[k][1]=i

                 

          else:

              q=- 1

              while   :

                  q=p

                  p=x[p]

              x[q]=i

              x[i]=p

          b[k][0]+=data[i][4]

      #重量不足 m 的品种,按各品种依次装入包裹

      for i in range(sn):

          if b[i][1]!=- 1:

              pack(i)

  • 1. (2023·浙江模拟) 某酒店共有A、B、C三种房间型号,A、B、C型房间的住宿团队价分别为500元/晚、300元/晚、200元/晚。因房型和房间数量原因,酒店规定A型房间只能订1-9个,而B型和C型房间都必须订10-99个。每两个团队的订房信息共同组成一个订单码,该订单码以第一个团队编号“g1”和字符“-”开头,后面由房间型号及其数量组成,两个团队的信息编号以逗号分隔。例如,订单码“g1-A2B15C27,g2-A6B11C22”,表示团队g1所订A、B、C型房间的数量分别为2个、15个、27个,团队g2所订A、B、C型房间的数量分别为6个、11个、22个。请回答下列问题:
    1. (1) 若某订单码为“g1-A2B11C17,g2-A8B19C23”,则该订单一天住宿的总金额为 元。
    2. (2) 实现上述功能的部分 Python 程序如下,请在划线处填入合适的代码。

      def fi(s,b,e):

          income=0

          i=b

          while i<=e:

              if s[i]=="A":

                  income+=

                  i+=2

              elif s[i]=="B":

                  income+=int(s[i+1:i+3])*300

                  i+=3

              elif s[i]=="C":

                  income+=int(s[i+1:i+3])*200

                  i+=3

          return income

      s=input("请输入订单码:")

      flag=False

      for i in range(len(s)):

          if s[i]=="-" and not flag:

             

              flag=True

          elif s[i]=="-":

              q=i

          elif s[i]==",":

              e=i

              total=fi(s,p+1,e- 1)

      total+=fi(s,  ,len(s)- 1)

      print(total)

  • 1. (2023·浙江模拟) 有如下 Python  程序段:

    deff(x):

        if x==1:

            return 2

        else:

            return f(x- 1)**2

    y=f(3)

    print(y)

    执行该程序段后,输出的结果是(  )

    A . 4 B . 8 C . 16 D . 32
  • 1. (2023高二上·湖州月考) 若一个字符串从左往右读和从右往左读均相同,称为回文字符串,例如“volov”。以下函数实现判断字符串s是否为回文字符串,若是返回True,否则返回False。

    方法1:设置左右两个索引,从两边往中间逐次判断。补充完整代码。

    def fun_1(s):

    L=0

    R=

        while :

            if s[L]!=s[R]:

                return False        #函数返回False并退出

            L=L+1

           

        return True                 #函数返回True并退出

    方法2:只设置左边一个索引,利用对应关系获取右边索引位置。按提示要求补充完整代码。

    def fun_2(s):

        n=len(s)

        for i in range():    #请写出最小的遍历区间值,即不可写n

            if :

                return False

    return True

  • 1. (2023高一上·霍城月考) 自定义函数一般包括四部分。
上一页 2 3 4 5 6 下一页 共55页