一、单选题

1、用枚举算法求解"100以内既能被3整除又能被4整除的元素"时，在下列数值范围内，算法执行效率最高的是？（　）

A、1~101

B、4~100

C、12~100

D、12~96

解析：【喵呜刷题小喵解析】在枚举算法中，我们需要遍历指定的数值范围，检查每个元素是否满足条件。对于本题，我们需要找出100以内既能被3整除又能被4整除的元素。对于选项A，范围是1~101，需要检查的元素有101个。对于选项B，范围是4~100，需要检查的元素有97个。对于选项C，范围是12~100，需要检查的元素有89个。对于选项D，范围是12~96，需要检查的元素有85个。显然，在数值范围相同的情况下，元素个数越少，算法执行效率越高。因此，在选项D的范围内，算法执行效率最高。

2、下列有关函数的描述中，正确的是？（　）

A、函数中必须有return语句

B、在函数内部不能使用全局变量

C、函数能提高应用的模块化程度和代码的重复利用率

D、函数内容以大括号起始，并且缩进

解析：【喵呜刷题小喵解析】A选项：函数中必须有return语句。这是错误的。函数可以有return语句，也可以没有。没有return语句的函数通常用于执行某些操作，但并不返回任何值。B选项：在函数内部不能使用全局变量。这也是错误的。在函数内部，我们是可以使用全局变量的。但是，如果我们在函数内部修改了全局变量的值，那么这种修改在函数外部是可见的。C选项：函数能提高应用的模块化程度和代码的重复利用率。这是正确的。函数是一种将代码封装成独立实体的方式，可以独立地调用和重用。通过将代码组织成函数，我们可以提高代码的可读性、可维护性和可重用性。D选项：函数内容以大括号起始，并且缩进。这是不准确的。函数的内容确实通常用大括号包围，但这并不是函数定义的必要部分。函数定义通常包括函数名、参数列表和函数体（用大括号包围的代码块），但缩进不是函数定义的必要部分。缩进通常用于增加代码的可读性，但它不是函数定义的语法要求。因此，正确答案是C选项：函数能提高应用的模块化程度和代码的重复利用率。

3、下列哪个语句能够定义参数个数不确定的函数？（　）

A、hs(parameters)

B、hs(parameters[])

C、hs(parameters{})

D、hs(*parameters)

解析：【喵呜刷题小喵解析】在C++中，参数个数不确定的函数通常使用可变参数列表来实现。可变参数列表在函数定义中使用三个点（...）来表示。在给出的选项中，只有选项D使用了星号（*）而不是三个点，这不是C++中定义可变参数列表的正确方式。因此，选项D是不正确的。正确的定义方式应该是使用三个点，如`hs(parameters...)`。因此，正确答案是D，但这个选项并不是有效的C++代码。需要注意的是，选项A、B和C都不是有效的C++语法，因为参数列表不能直接使用`parameters`、`parameters[]`或`parameters{}`。正确的方式是使用类型名称后跟三个点，例如`int... parameters`，这表示函数接受可变数量的int类型参数。

4、执行如下Python代码的结果是？（　）

def area(r,pi=3.14):
return r*r*pi
print(area(2,10))

A、40

B、200

C、400

D、20

解析：【喵呜刷题小喵解析】在这个Python代码中，定义了一个名为`area`的函数，它接受两个参数`r`和`pi`。默认情况下，`pi`的值是3.14。但在调用函数`area(2,10)`时，我们明确指定了`pi`的值为10，而不是使用默认值。因此，函数计算的是半径为2，π值为10的圆的面积，即2*2*10=40。所以，执行这段代码的结果是40，选项A正确。

5、执行如下Python代码，输出结果是？（　）

def hs(num):
num += 1
return num
n=10
s=hs(n)
print(s)

A、11

B、10

C、1

D、运行错误

解析：【喵呜刷题小喵解析】：在Python中，函数参数传递默认是值传递，即函数内部对参数的修改不会影响到函数外部。在函数hs中，num += 1只是将函数内部的num值加1，并不会影响到函数外部的n。因此，s=hs(n)执行后，s的值是函数hs返回的值，即num加1后的值，也就是11。所以，print(s)的输出结果是11，选项A正确。

6、有如下Python程序，输出的结果是？（　）
def whao(year = ‘2023’):
print(‘你好’ + year)
whao()

A、你好

B、你好2023

C、你好year

D、没有输出

解析：【喵呜刷题小喵解析】：在Python中，默认参数是在函数定义时指定的，并且在函数调用时如果没有提供该参数的值，那么会使用默认参数的值。在这个例子中，函数`whao`有一个默认参数`year`，其值为'2023'。当函数被调用时，没有提供`year`参数的值，所以Python会使用默认值'2023'。因此，输出会是'你好2023'，选项B是正确的。

7、编写计算正方体体积的匿名函数，下列哪一个语句是正确的？（　）

A、rst = lambda a : a * 3

B、lambda a : a * 3

C、rst = lambda a : a ** 3

D、lambda a : a ** 3

解析：【喵呜刷题小喵解析】计算正方体体积的公式是 V = a^3，其中a是正方体的边长。在给出的选项中，只有C选项的语句“rst = lambda a : a ** 3”符合这个公式，它表示了一个匿名函数，接受一个参数a，并返回a的三次方，即正方体的体积。其他选项中的公式都与正方体体积的计算不符。因此，正确答案是C。

8、执行如下Python程序，运行的结果是？（ ）

def zfzh(s):
c = ''
for ch in s:
if “9”>=ch>= “0”:
c+=str(int(ch)+1)
elif “z”>=ch>= “a”:
c+= chr(ord(ch)- ord(“a”)+ord(“A”))
return c
s = ‘hzag-21-8’
print(zfzh(s))

A、HZAG329

B、923HZAG

C、GAZH329

D、923GAZH

解析：【喵呜刷题小喵解析】首先，我们分析给定的Python程序。该程序定义了一个名为`zfzh`的函数，该函数接受一个字符串`s`作为输入。函数内部有一个空字符串`c`，用于存储处理后的字符。接下来，程序遍历输入字符串`s`中的每个字符`ch`。对于每个字符，程序执行以下操作：1. 如果字符`ch`在`'0'`到`'9'`之间（包括`'0'`和`'9'`），程序将字符的ASCII值加1，并将结果转换为字符串，然后追加到`c`字符串中。2. 如果字符`ch`在`'z'`到`'a'`之间（包括`'z'`和`'a'`），程序将字符的ASCII值减去`'a'`的ASCII值，然后加上`'A'`的ASCII值，从而得到对应的大写字母，并将该大写字母追加到`c`字符串中。最后，函数返回处理后的字符串`c`。现在，我们分析给定的输入字符串`s = 'hzag-21-8'`。程序将遍历该字符串中的每个字符，并应用上述规则进行处理。* 对于字符`'h'`，它不在`'0'`到`'9'`或`'z'`到`'a'`的范围内，所以不会被修改，直接追加到`c`字符串中。* 对于字符`'z'`，它满足条件`'z' >= ch >= 'a'`，因此会被转换为对应的大写字母`'Z'`，并追加到`c`字符串中。* 对于字符`'a'`，它满足条件`'z' >= ch >= 'a'`，因此会被转换为对应的大写字母`'A'`，并追加到`c`字符串中。* 对于字符`'g'`，它不在`'0'`到`'9'`或`'z'`到`'a'`的范围内，所以不会被修改，直接追加到`c`字符串中。* 对于字符`'-'`，它既不是数字也不是字母，所以不会被修改，直接追加到`c`字符串中。* 对于字符`'2'`，它满足条件`'9' >= ch >= '0'`，因此会被加1转换为`'3'`，并追加到`c`字符串中。* 对于字符`'1'`，同样地，会被加1转换为`'2'`，并追加到`c`字符串中。* 对于字符`'8'`，会被加1转换为`'9'`，并追加到`c`字符串中。因此，程序将返回字符串`'hZaG329'`。在给定的选项中，只有选项A与这个结果匹配，所以答案是A。

9、在Python中，以下哪个代码是安装numpy模块的方法？（　）

A、pip install numpy

B、pip uninstall numpy

C、install numpy

D、setup numpy

解析：【喵呜刷题小喵解析】：在Python中，安装numpy模块的方法是使用pip工具，命令为"pip install numpy"。选项A是正确的，选项B是卸载numpy模块，选项C的语法错误，选项D的命令格式不正确。因此，正确答案是A。

10、

A、from

B、import

C、pip

D、install

解析：【喵呜刷题小喵解析】：在Python中，导入第三方库的关键字是`import`，而不是`from`、`pip`或`install`。`from`用于从特定模块中导入特定的函数、类或变量，`pip`和`install`是命令行工具，用于安装Python包，而不是导入库的关键字。因此，正确答案是B，即`import`。

11、《阅微草堂笔记》里描述了槐树果实"响豆"，在夜里爆响，这种豆一棵树只有一粒，难以辨认出。所以古人就等槐树开花结果后，用许多布囊分别贮存豆荚，用来当枕头。夜里如果没有听到声音，便扔掉。如果有爆响声。然后把这一囊的豆荚又分成几个小囊装好，夜里再枕着听……如此这么分下去直到找到响豆。以上故事体现的算法是？（　）

A、顺序查找

B、枚举算法

C、解析算法

D、分治算法

解析：【喵呜刷题小喵解析】：《阅微草堂笔记》中描述的槐树果实“响豆”的故事，体现了分治算法的思想。故事中，古人将豆荚分成许多小囊，然后逐个检查，直到找到响豆。这种方法通过不断将问题分解为更小的子问题，然后分别解决这些子问题，最终找到答案。因此，这种算法是分治算法。

12、下列哪项不是分治算法所具有的特征？（　）

A、求解问题的规模缩小到一定的程度就能够容易地解决

B、求解题可以分解为若干个规模较小的不同问题

C、利用求解问题分解出的子问题的解可以合并为该问题的解

D、求解问题所分解出的各个子问题是相互独立的

解析：【喵呜刷题小喵解析】分治算法是一种将问题分解为规模更小的同类问题，然后递归地解决这些子问题，最后将子问题的解合并起来得到原问题的解的算法。根据这个定义，我们可以分析每个选项：A. 求解问题的规模缩小到一定的程度就能够容易地解决 - 这是分治算法的一个关键特征，当问题规模足够小，我们可以直接求解。B. 求解题可以分解为若干个规模较小的不同问题 - 这个选项描述的是问题可以分解为多个子问题，但并未明确这些子问题是同类问题，也不强调子问题的规模减小，因此，这并不是分治算法的核心特征。C. 利用求解问题分解出的子问题的解可以合并为该问题的解 - 这是分治算法的关键特征，通过合并子问题的解，我们可以得到原问题的解。D. 求解问题所分解出的各个子问题是相互独立的 - 分治算法中的子问题应该是相互独立的，这样才能并行处理或递归地解决它们。综上所述，选项B“求解题可以分解为若干个规模较小的不同问题”并不是分治算法所具有的特征，所以正确答案是B。

13、两位同学玩猜数字游戏，规则如下：一方在心里默想一个范围在1-100之间的数，如果另一方猜的数字比对方想的要大，就说大了；如果猜的数字比想的要小，就说小了，直到猜中数字。那么使用二分查找法最多需要猜测的次数是？（　）

A、10

B、8

C、7

D、6

解析：【喵呜刷题小喵解析】：在猜数字游戏中，使用二分查找法可以减少猜测次数。每次猜测后，根据反馈可以排除一半的数字范围。对于1到100之间的数字，第一次猜测可以将范围缩小到50以下或50以上，第二次猜测可以进一步缩小范围，以此类推。因此，最多需要猜测的次数是log2(100)向上取整，即7次。所以，正确答案是C。

14、用递推算法求解n个自然数的乘积，请问代码中横线上需要填入的正确代码是？（　）

def fact(n):

s=1

for i in range(1,n+1):

s=s*i

return ________

a=fact(5)

print(a)

A、s

B、i

C、fact(n-1)

D、fact(n)

解析：【喵呜刷题小喵解析】题目中给出的函数`fact(n)`是用于计算n个自然数的乘积，即n的阶乘。在给出的代码中，已经使用了一个循环来逐个乘以从1到n的整数，因此，循环结束后，变量`s`的值就是n的阶乘。因此，函数应该返回`s`的值，即`return s`。选项A中的`s`与题目要求一致，因此选择A。其他选项中的`i`、`fact(n-1)`和`fact(n)`都不符合题目要求，因此是错误的。

15、一球从100米高度自由落下，每次落地后反跳回原高度的一半；再落下，求它在第10次落地时，共经过多少米？第10次反弹多高？

可以用下列代码解决这个问题，请问这段代码是基于（ ）算法编写的？

high=100

s=0

sum=0

for i in range(10):

s,high=high+high/2,high/2

sum=sum+s

sum=sum-high

print(sum)

print(high)

A、递归

B、枚举

C、递推

D、二分

解析：【喵呜刷题小喵解析】：该代码通过循环计算了小球在第10次落地时，共经过的距离和第10次反弹的高度。在每次循环中，小球的下落距离是前一次反弹高度的一半，即`high/2`，反弹的高度也是前一次反弹高度的一半，即`high/2`。这个过程可以看作是递推的过程，即每次的结果都依赖于前一次的结果。因此，这段代码是基于递推算法编写的。

16、用递归算法求1~n个连续自然数的乘积的代码如下,请选择合适的代码补全程序？（ ）
def Chengji(n):
if n <=1:
return 1
else:
return ?_
print(Chengji(3))

A、n*Chengji(n)

B、n*Chengji(n-1)

C、n*Chengji(n+1)

D、n×Chengji(n-1)

解析：【喵呜刷题小喵解析】：题目要求用递归算法求1~n个连续自然数的乘积，根据乘法的分配律，我们可以将n个连续自然数的乘积表示为n乘以(n-1)乘以(n-2)乘以...乘以1，即n*(n-1)*(n-2)*...*1。在递归函数中，当n大于1时，我们需要计算n*(n-1)的乘积，即n*Chengji(n-1)。因此，正确答案是B选项，即n*Chengji(n-1)。

17、有一根绳子，第一次剪去一半多2米，第二次剪去剩下的一半多2米，第三次剪去剩下的一半多2米，第四次剪去剩下的一半多2米，第五次剪去剩下的一半多2米，此时绳子还剩2米。这根绳子长几米？想解决这个问题的话，可以采用以下哪种算法？（　）

A、排序

B、递推

C、解析

D、枚举

解析：【喵呜刷题小喵解析】这个问题适合用递推算法解决。因为每次剪去的长度都是前一次剩余长度的一半再多2米，所以可以通过递推的方式逐步计算出每次剪去后的剩余长度，直到得到最初的绳子长度。具体来说，我们可以从最后一次剪去后的剩余长度2米开始，逆向计算出前一次剪去后的剩余长度，再逆向计算出前一次剪去后的剩余长度，以此类推，直到得到最初的绳子长度。因此，选项B“递推”是合适的算法。

18、小猴子第一天摘下若干桃子，当即吃掉一半，又多吃一个。第二天早上又将剩下的桃子吃一半，又多吃一个。以后每天早上吃前一天剩下的一半另加一个。到第5天早上猴子想再吃时，发现只剩下一个桃子了。问第一天猴子共摘多少个桃子？

这个问题可以用递归来解决，代码如下：

def peach(day):

if day==1:

return 1

return (peach(day-1) + 1)*2

s=peach(5)

print(‘一共有%d只桃子’%(s))

请问第2行的"if day == 1"代码起到的作用是？（ ）

A、结束递归的边界条件

B、开始递归的边界条件

C、调用自身

D、递归过程中的变化

解析：【喵呜刷题小喵解析】：“if day==1:”这一行代码表示的是递归的边界条件，也就是当天数为1时，函数直接返回1，不再进行递归调用。这是递归函数中的基础情况，用来结束递归，避免无限递归。在这个问题中，当猴子只剩下一个桃子的时候，也就是第5天早上，函数直接返回1，然后逆向计算出第一天摘下的桃子数量。因此，选项A“结束递归的边界条件”是正确的。

19、下列代码可以求两个数的最小公倍数。请认真阅读下列代码运用了什么算法？（　）

def lcm(s,m,n):

if s%n==0:

return s

else:

return lcm(s+m,m,n)

a=int(input(‘请输入第1个数：’))

b=int(input(‘请输入第2个数：’))

c=lcm(a,a,b)

print(‘{}和{}的最小公倍数是{}’.format(a,b,c))

A、枚举

B、解析

C、递归

D、二分

E、在定义一个函数或过程时，如果出现调用自身的成分，则称为递归。

解析：【喵呜刷题小喵解析】：该代码定义了一个名为lcm的函数，该函数在调用自身时，会根据不同的条件返回不同的结果。具体来说，如果s能被n整除，则直接返回s；否则，递归调用lcm函数，参数分别为s+m、m和n。这种调用自身的情况，正是递归算法的定义。因此，该代码运用了递归算法。所以正确答案为C，即递归。

20、关于函数，正确的描述是？（　）

A、规范的函数设计都应该带有返回值

B、函数体中，只要遇到break关键字,函数就结束

C、函数体中，只要遇到return关键字,函数就结束

D、函数的返回值只能是整型、浮点型、布尔型和字符串

解析：【喵呜刷题小喵解析】：在函数体中，只要遇到return关键字，函数就会结束，并返回指定的值。所以，选项C的描述是正确的。对于选项A，虽然许多函数确实带有返回值，但不是所有函数设计都必须带有返回值，例如void函数就没有返回值。因此，A的描述是不准确的。对于选项B，函数体中的break关键字通常用于结束循环（如for或while循环）。它并不会直接结束函数，而是结束特定的循环。所以，B的描述是不正确的。对于选项D，函数的返回值不仅仅限于整型、浮点型、布尔型和字符串。函数可以返回任何类型的数据，包括自定义的数据类型（如类或结构体）。因此，D的描述也是不准确的。

21、关于全局变量和局部变量，正确的描述是？（　）

A、通俗来说，无缩进的变量都是全局变量

B、函数体中，只能使用局部变量

C、Python程序中，全局变量与局部变量不允许重名

D、函数体中，只能通过实参传递的方式实现对全局变量数值的使用

解析：【喵呜刷题小喵解析】：全局变量是在整个程序中都可以访问的变量，而局部变量是在函数或代码块内部定义的变量，只能在函数或代码块内部访问。因此，无缩进的变量并不一定是全局变量，因为变量是否全局取决于其定义的位置，而不是缩进。所以选项A的描述是错误的。选项B描述“函数体中，只能使用局部变量”也是错误的。函数体中可以使用全局变量，但使用全局变量时需要注意作用域和可见性。选项C描述“Python程序中，全局变量与局部变量不允许重名”是正确的。在Python中，全局变量和局部变量不能重名，否则在函数内部会优先使用局部变量。选项D描述“函数体中，只能通过实参传递的方式实现对全局变量数值的使用”也是错误的。函数体中可以通过引用全局变量的方式使用全局变量，而不仅仅是通过实参传递。虽然可以通过实参传递全局变量，但这并不是唯一的方式。因此，正确答案是选项C。

22、定义以下函数:

def func(x,y,z=2):

print(x+y+z)

分别以func(1,2,3)和func(1,2)语句调用该函数，运行后的结果分别是？（ ）

A、6;出错

B、5;出错

C、5;5

D、6;5

解析：【喵呜刷题小喵解析】根据题目中给出的函数定义，函数`func`有三个参数，其中`z`有默认值2。当调用`func(1,2,3)`时，`x`的值为1，`y`的值为2，`z`的值为3，因此`x+y+z`的值为1+2+3=6。当调用`func(1,2)`时，`x`的值为1，`y`的值为2，`z`的值为默认值2，因此`x+y+z`的值为1+2+2=5。所以，分别以`func(1,2,3)`和`func(1,2)`语句调用该函数，运行后的结果分别是6和5，因此答案是D选项。

23、在嵌套函数中，也就是一个函数里面还有一个函数，如果内部函数需要修改外部变量的值，处理的方法是？（　）

A、只能通过不定长参数传递来实现

B、使用local关键字

C、使用nonlocal关键字

D、使用global关键字

解析：【喵呜刷题小喵解析】：在嵌套函数中，如果内部函数需要修改外部变量的值，需要使用global关键字。这是因为默认情况下，内部函数只能访问其自己的局部变量和全局变量，而不能直接修改外部函数的变量。使用global关键字可以声明内部函数需要访问和修改的是全局变量，这样就可以修改外部函数的变量值了。其他选项如不定长参数传递、local关键字和nonlocal关键字都不适用于这种情况。

24、在自定义函数中，如果发现局部变量与全局变量同名，则？（　）

A、程序会出现语法错，不能运行

B、程序可以运行，局部变量与全局变量互不干扰

C、可能会出现局部变量修改全局变量的值的情况，需要检查程序设计是否合理

D、不允许出现这种情况，应该采用参数传递的方法去解决问题

解析：【喵呜刷题小喵解析】在自定义函数中，如果发现局部变量与全局变量同名，程序可以运行，但局部变量会“屏蔽”全局变量。当在函数内部引用该变量时，使用的是局部变量而不是全局变量。如果函数内部修改了局部变量的值，这个修改不会影响到全局变量。但如果函数内部不小心修改了全局变量的值，那么全局变量的值就会被改变。因此，为了避免这种情况，需要仔细检查程序设计，确保不会误修改全局变量。选项A、B、D的说法都不准确。

25、考察以下函数定义代码：

def func(x:int,y:str)->str:

z=x*y

return z

以下陈述正确的是？（　）

A、Python是一种动态类型语言，不强制要求指定参数类型，上述代码行是不符合Python语法的

B、为提高程序的可靠性，Python函数定义时允许为形参指定数据类型，也允许为返回值指定类型

C、由于为函数指定了返回值类型，变量z一定要做类型转换后，才能用于上述return语句中

D、由于为形参指定了不同的数据类型，变量x和y也需要先做类型转换后才能进行上述运算

解析：【喵呜刷题小喵解析】：在Python中，虽然类型注解是可选的，但它可以用于为函数参数和返回值指定预期的类型。这种类型注解不会强制进行类型检查，但可以为程序员提供有关预期输入和输出的信息。在这个例子中，函数`func`的类型注解表明它期望`x`是一个整数，`y`是一个字符串，并返回一个字符串。然而，Python不会强制进行类型检查，所以即使`x`不是整数或`y`不是字符串，函数仍然可以运行，只是可能不会按照预期的方式工作。因此，选项A是不正确的。选项B是正确的，因为Python允许为形参和返回值指定类型。选项C和D都是不正确的，因为Python的类型注解不会强制进行类型检查，所以不需要进行类型转换。

二、判断题

26、函数是将实现相同功能的代码封装在一起，实现代码复用。（　）

A 正确

B 错误

解析：【喵呜刷题小喵解析】：函数是一种将实现相同功能的代码封装在一起，实现代码复用的编程结构。函数允许我们将一段代码封装成一个独立的实体，可以在程序的不同部分多次调用，而无需重复编写相同的代码。这种封装和复用性提高了代码的可读性和可维护性，并减少了代码的冗余。因此，题目的陈述是正确的。

27、函数是将实现相同功能的代码封装在一起，实现代码复用。

A 正确

B 错误

解析：【喵呜刷题小喵解析】：函数是一种将实现相同功能的代码封装在一起的结构，它的主要目的是实现代码复用。通过使用函数，可以将一段代码组织成一个独立的单元，然后在需要的地方调用这个函数，而不是每次都重复编写相同的代码。这种机制不仅提高了代码的可读性和可维护性，还大大减少了代码冗余，提高了程序的效率和可扩展性。因此，题目的陈述“函数是将实现相同功能的代码封装在一起，实现代码复用”是正确的。

28、函数的定义代码不需要在主程序调用函数之前。（　）

A 正确

B 错误

解析：【喵呜刷题小喵解析】：函数的定义代码通常需要在主程序调用函数之前，这是因为在调用函数之前，函数的定义必须已经被编译和链接到程序中。如果函数的定义在调用之后，那么程序在尝试调用该函数时就会报错，因为它不知道这个函数的存在。因此，函数的定义代码需要在主程序调用函数之前。

29、命令pip download <第三方库>表示下载并安装指定的第三方库。（　）

A 正确

B 错误

解析：【喵呜刷题小喵解析】：题目中的说法是错误的。`pip download` 命令用于下载指定的Python包，但不安装它们。如果你想安装第三方库，应该使用 `pip install` 命令。因此，答案是B，即题目中的说法是错误的。

30、二分查找又称对折半查找，例如：在数列34、17、25、9、10、3中查找3，适合采用二分查找法。（　）

A 正确

B 错误

解析：【喵呜刷题小喵解析】：二分查找法是一种在有序数组中查找某一特定元素的搜索算法。算法比较当前元素与目标值，如果当前元素等于目标值，则查找成功；如果目标值小于或大于当前元素，则在数组的左半部分或右半部分继续查找。题目中的数列34、17、25、9、10、3是无序的，因此不能采用二分查找法。因此，题目中的说法是错误的。

31、递归算法不涉及高深的数学知识，使得很多比较复杂的问题，也可以用简洁的代码解决，代码的执行效率比较高，所以即使有其他算法可行，也应该首选递归算法解决问题。（　）

A 正确

B 错误

解析：【喵呜刷题小喵解析】：虽然递归算法在一些问题上有简洁的代码和高效性，但它并不是万能的。在某些情况下，递归算法可能并不是首选的解决方案，因为递归可能会导致栈溢出或执行效率低下。此外，递归算法通常需要更多的内存空间，因为每次递归调用都会在栈上创建一个新的帧。因此，是否使用递归算法取决于具体的问题和场景，不能一概而论。所以，题目中的说法“即使有其他算法可行，也应该首选递归算法解决问题”是不准确的，因此答案是B。

32、递归算法中，必然存在函数体内调用自身的情况，可以在最后调用，也可以在中间调用。（　）

A 正确

B 错误

解析：【喵呜刷题小喵解析】：在递归算法中，函数体内调用自身的情况确实是存在的，这种调用可以在最后发生，也可以在中间发生。这种特性使得递归算法能够解决一些复杂问题，例如阶乘计算、树遍历等。因此，题目的说法是正确的。

33、Python程序中，自定义函数可以放在整个程序的开头，也可以放在主程序之后，比较自由。（　）

A 正确

B 错误

解析：【喵呜刷题小喵解析】：在Python程序中，自定义函数的定义位置是有讲究的。通常，我们会将函数的定义放在主程序之前，这样在主程序中调用该函数时，Python解释器可以正确地找到并执行该函数。如果将函数定义放在主程序之后，那么在主程序执行到该函数调用时，Python解释器将无法找到该函数，从而导致NameError错误。因此，自定义函数不能随意放在整个程序的开头或主程序之后，而是应该放在主程序之前。所以，题目的说法是错误的。

34、通过把某些特定功能语句设计成自定义函数，可以简化主程序的编写。（　）

A 正确

B 错误

解析：【喵呜刷题小喵解析】：在编程中，把某些特定功能语句设计成自定义函数，可以简化主程序的编写。通过创建自定义函数，可以将重复的代码块封装成一个独立的、可重复使用的模块。这样，主程序只需调用该函数即可实现相应的功能，从而避免了代码重复和混乱，使程序更加清晰、简洁。因此，这个题目的说法是正确的。

35、下面代码的时间复杂度为O(n*n)。（ ）arr = [ 2, 3, 4, 10, 40 ] n = len(arr)for i in range(n):    for j in range(0, n-i-1):         if arr[j] > arr[j+1] :            arr[j], arr[j+1] = arr[j+1], arr[j]

A 正确

B 错误

解析：【喵呜刷题小喵解析】：该代码实现的是冒泡排序算法，其时间复杂度为O(n^2)。在冒泡排序中，外层循环和内层循环分别遍历数组，比较相邻元素并交换它们的位置，直到整个数组排序完成。由于外层循环和内层循环都需要遍历数组，所以时间复杂度为O(n^2)。因此，该代码的时间复杂度为O(n^2)，答案为A。

三、编程题

36、从键盘上分别输入要查找和替换的字符串，对文本文件进行查找与替换，替换后保存到新的文本文件中。

思路：输入待查找字符串s，需查找子字符串key和替换字符串new，通过调用自定义函数replace实现替换。完善划线处代码。

s = input(“请输入待查找的字符串：”)

key = input(“请输入需查找的子字符串：”)

new = input(“请输入要替换的字符串：”)

def findstr(key, s, begin):

for i in range(begin,len(s) - len(key) + 1):

if s[i: ① ]== key:

return i

return -1

def replace(key, new, s):

begin = 0

while begin < ② :

pos = findstr(key,s, begin)

if pos ==-1:

break

else:

s = s[0:pos]+ new + s[pos + len(key): ③ ]

begin = pos + len(key)

return s

rst = ④ #调用函数替换字符

print(rst)

参考答案：

s = input(“请输入待查找的字符串：”)

key = input(“请输入需查找的子字符串：”)

new = input(“请输入要替换的字符串：”)

def findstr(key, s, begin):

for i in range(begin,len(s) - len(key) + 1):

if s[i:i+len(key)]== key:

return i

return -1

def replace(key, new, s):

begin = 0

while begin < len(s)-len(key)+ 1:

pos = findstr(key,s, begin)

if pos ==-1:

break

else:

s = s[0:pos]+ new + s[pos + len(key):len(s)]

begin = pos + len(key)

return s

rst = replace(key,new,s) #调用函数替换字符

print(rst)

解析：【喵呜刷题小喵解析】本题要求从键盘上分别输入要查找和替换的字符串，对文本文件进行查找与替换，替换后保存到新的文本文件中。首先，从键盘输入待查找的字符串`s`，需查找的子字符串`key`和替换字符串`new`。然后，定义两个函数：1. `findstr(key, s, begin)`：在字符串`s`中从位置`begin`开始查找子字符串`key`，返回其位置，如果未找到则返回-1。2. `replace(key, new, s)`：在字符串`s`中查找所有子字符串`key`，并将其替换为`new`，返回替换后的字符串。在`replace`函数中，使用`while`循环和`findstr`函数来查找并替换所有子字符串`key`。如果未找到，则退出循环。最后，调用`replace`函数进行替换，并打印结果。注意，在`findstr`函数中，使用`s[i:i+len(key)]`来截取子字符串，而不是`s[i: ① ]`。在`replace`函数中，使用`s[0:pos]+ new + s[pos + len(key):len(s)]`来拼接字符串，而不是`s[0:pos]+ new + s[pos + len(key): ③ ]`。同时，将`rst = ④`修改为`rst = replace(key, new, s)`来调用函数进行替换。

37、一个列表中存在n个数据，可以用分治算法来找到其中的最小值。具体过程如下：如果列表元素的个数小于等于2的时候，经过一个判断就找到其中的最小值，所以可以先把数据从中间划分为左右两部分，然后通过递归把每一部分再划分为左右两部分，直到数据规模小于等于2的时候，返回结果，然后通过递归到最后为两个数据对比，我们就可以找到最小值。

请根据以上算法过程，补全代码。

求列表中小于两个元素的最小值

def get_min(number):

if len(number) == 1:

return ①

else:

if number[1] > number[0]:

return number[0]

else:

return number[1]

def solve(number):

n = len(number)

if n <= 2:

return get_min(number)

else:

将整个列表分为左右两部分

left_list, right_list = ② , number[n//2:]

递归（树），分治

left_min, right_min = solve(left_list), ③

return get_min([left_min, right_min])

test_list = [5, 11, 3, 2, 7, 9]

print(solve(test_list))

参考答案：

参考程序：

求列表中小于两个元素的最小值

def get_min(number):

if len(number) == 1:

return number[0]

else:

if number[1] > number[0]:

return number[0]

else:

return number[1]

def solve(number):

n = len(number)

if n <= 2:

return get_min(number)

else:

将整个列表分为左右两部分

left_list, right_list = number[:n//2], number[n//2:]

递归（树），分治

left_min, right_min = solve(left_list), solve(right_list)

return get_min([left_min, right_min])

test_list = [5, 11, 3, 2, 7, 9]

print(solve(test_list))

解析：【喵呜刷题小喵解析】：首先，我们定义了一个函数`get_min`，用于获取列表中小于两个元素的最小值。当列表只有一个元素时，直接返回该元素；当列表有两个元素时，比较这两个元素，返回较小的那个。然后，我们定义了另一个函数`solve`，用于找到列表中的最小值。首先，判断列表的长度，如果小于等于2，直接调用`get_min`函数获取最小值。否则，将列表分为左右两部分，递归调用`solve`函数获取左右两部分的最小值，然后再比较这两个最小值，返回最小的那个。在题目给出的测试列表中，元素按照从小到大的顺序排列为[2, 3, 5, 7, 9, 11]。在第一次递归调用时，列表被分为[2, 3, 5]和[7, 9, 11]。在第二次递归调用时，列表[2, 3, 5]被分为[2, 3]和[5]，列表[7, 9, 11]被分为[7]和[9, 11]。在第三次递归调用时，列表[2, 3]被分为[2]和[3]，列表[7]保持不变。在第四次递归调用时，列表[2]和[3]都只有一个元素，直接返回元素值。在第三次递归调用中，比较[2]和[3]，返回2；比较[7]和[9, 11]，返回7。在第二次递归调用中，比较[2]和[7]，返回2；比较[3]和[9, 11]，返回3。在第一次递归调用中，比较[2]和[3]，返回2。最终，输出结果为2，即列表中的最小值。

38、未来居民社区设计有一个机器人服务中心，假如某社区有若干栋住宅楼，每栋楼的位置可以由坐标(x,y)表示，其中x坐标表示居民楼的东西向位置，y坐标表示居民楼的南北向位置。这里约定，社区中任意2点(x1,y1)和(x2,y2)的之间的距离使用数值|x1-x2|+|y1-y2|来度量。要求为社区选择建立机器人服务中心的最佳位置，使各个居民点到机器人服务中心的距离总和最小。以下是机器人服务中心的选址程序，采用取各坐标中位数的方法来确定中心位置，请补充完成该程序。

注：中位数的含义：一组按大小顺序排列起来的数据中处于中间位置的数。当有奇数个数据时,中位数就是中间那个数；当有偶数个数据时,中位数就是中间那两个数的平均数。

n=int(input(“请输入居民楼总数：”))

hx=[]

hy=[]

for i in range(n):

x,y = map(int,input(“请输入居民楼的x和y坐标：”).split(“,”))

hx. append(x)

hy. append(y)

hx = sorted( ① )

hy = sorted( ② )

if n%2 == 0: #偶数情况，求中位数

sn = int(n/2)

x0 = int((hx[sn]+hx[sn-1])/2)

y0 = int((hy[sn]+hy[sn-1])/2)

else: #奇数情况，求中位数

sn = int((n-1)/2)

x0 = ③

y0 = ④

sumx=0

sumy=0

for j in hx:

dx =abs(x0-j)

sumx += dx

for k in hy:

dy = abs(y0-k)

sumy += dy

print(“选址点的坐标是：(%d,%d)”%(x0,y0))

print(“选址到各楼的累计距离是：”,sumx+sumy)

参考答案：

参考程序：

n=int(input(“请输入居民楼总数：”))

hx=[]

hy=[]

x,y = input(“请输入居民楼的x和y坐标：”).split(“,”)

for i in range(n):

x,y = map(int,input(“请输入居民楼的x和y坐标：”).split(“,”))

hx.append(x)

hy.append(y)

hx=sorted(hx) #对输入坐标进行排序

hy=sorted(hy)

if n%2 == 0: #偶数情况，求中位数

sn = int(n/2)

x0 = int((hx[sn]+hx[sn-1])/2)

y0 = int((hy[sn]+hy[sn-1])/2)

else: #奇数情况，求中位数

sn = int((n-1)/2)

x0 = hx[sn]

y0 = hy[sn]

sumx=0

sumy=0

for j in hx:

dx =abs(x0-j)

sumx += dx

for k in hy:

dy = abs(y0-k)

sumy += dy

print(“选址点的坐标是：(%d,%d)”%(x0,y0))

print(“选址到各楼的累计距离是：”,sumx+sumy)

解析：【喵呜刷题小喵解析】：该程序的目标是为社区选择一个机器人服务中心的最佳位置，使各个居民点到机器人服务中心的距离总和最小。程序首先通过用户输入获取居民楼的数量和每栋楼的坐标。然后，程序对输入的坐标进行排序，以便找到中位数。如果居民楼的数量是偶数，程序计算中间两个坐标的平均值作为中位数；如果居民楼的数量是奇数，程序直接取中间的坐标作为中位数。最后，程序计算机器人服务中心到每个居民楼的距离总和，并输出结果。程序首先获取用户输入的居民楼数量，然后创建一个空列表来存储x坐标和y坐标。接着，程序循环n次，每次从用户输入中获取一个居民楼的x和y坐标，并将它们添加到对应的列表中。然后，程序对x坐标和y坐标列表进行排序，以便找到中位数。如果居民楼的数量是偶数，程序计算中间两个坐标的平均值作为中位数；如果居民楼的数量是奇数，程序直接取中间的坐标作为中位数。最后，程序计算机器人服务中心到每个居民楼的距离总和，并输出结果。程序使用`abs(x0-j)`和`abs(y0-k)`计算机器人服务中心到每个居民楼的距离，并将它们累加到`sumx`和`sumy`中。最后，程序输出机器人服务中心的坐标和到各居民楼的距离总和。

喵呜刷题：让学习像火箭一样快速，快来微信扫码，体验免费刷题服务，开启你的学习加速器！