一、单选题
1、下面流程图在yr输入2024时，可以判定yr代表闰年，并输出 2月是29天 ，则图中菱形框中应该填入（ ）。
A (yr % 400 == 0) or (yr % 4 == 0)
B ( yr % 400 == 0) or (yr % 4 == 0 and yr %100 != 0)
C ( yr % 400 == 0) and ( yr % 4 == 0)
D (yr % 400 == 0) and (yr % 4 == 0 and yr % 100 != 0)
解析：【喵呜刷题小喵解析】：根据闰年的判断规则，如果一个年份能被400整除，那么这一年就是闰年；如果年份能被4整除但不能被100整除，那么这一年也是闰年。因此，菱形框中应该填入“(yr % 400 == 0) or (yr % 4 == 0 and yr % 100 != 0)”，即选项B。这样当输入2024时，就能正确判断2024是闰年，并输出“2月是29天”。
2、在TCP协议中，完成连接建立需要通过（ ）握手。
A 一次
B 二次
C 三次
D 四次
解析：【喵呜刷题小喵解析】：TCP协议是一种面向连接的协议，它使用三次握手来建立连接。这三次握手包括：客户端发送SYN包到服务器，服务器回应SYN-ACK包，客户端再发送ACK包确认服务器的SYN-ACK包。因此，正确答案是三次握手。选项A、B、D都是错误的。
3、下面有关排序算法的说法，正确的是（ ）
A 快速排序是稳定排序
B Python中list类型的sort()是稳定排序
C 冒泡排序是不稳定排序
D 归并排序是不稳定排序
解析：【喵呜刷题小喵解析】：
A选项：快速排序是不稳定排序。在快速排序中，当两个元素相等时，它们的相对位置可能会改变，因此快速排序是不稳定的。
B选项：Python中list类型的sort()是稳定排序。Python的list.sort()方法默认使用的是Timsort排序算法，Timsort是一种稳定的排序算法，因此B选项是正确的。但题目中并没有明确指出这一点，所以我们不能确定B选项是正确的。
C选项：冒泡排序是不稳定排序。在冒泡排序中，当两个元素相等时，它们的相对位置可能会改变，因此冒泡排序是不稳定的。
D选项：归并排序是稳定排序。在归并排序中，当两个元素相等时，它们的相对位置不会改变，因此归并排序是稳定的。
因此，正确答案是C选项，冒泡排序是不稳定排序。
4、不同的排序算法，其空间复杂度也不同。与冒泡法排序空间复杂度相同的是（ ）
A 归并排序
B 快速排序
C 计数排序
D 插入排序
解析：【喵呜刷题小喵解析】：冒泡排序的空间复杂度为O(1)，这是因为冒泡排序只需要用到常数级别的额外空间来存储临时变量。归并排序的空间复杂度为O(n)，因为它需要额外的空间来存储临时数组。快速排序的空间复杂度取决于实现方式，如果是使用原地快速排序，其空间复杂度为O(log n)或O(n)，如果是使用递归方式，其空间复杂度可能接近O(n)。计数排序的空间复杂度为O(k)，其中k为待排序数的范围。插入排序的空间复杂度为O(1)，因为插入排序只需要用到常数级别的额外空间来存储临时变量。因此，与冒泡排序空间复杂度相同的是插入排序。
5、下面Python代码中，aFactorial()和bFactorial()用于求正整数的阶乘。有关说法，错误的是( )。
A aFactorial( )用循环方式，bFactorial()递归方式
B bFactorial( )更加符合数学定义，直观易于理解，而aFactorial()需要将数学定义转换为计算机程序实现
C 当N值较大时，aFactorial( )执行效率更高，而bFactorial()因为有多次函数调用，效率将降低，且N如果较大，将可能导致不能使用
D bFactorial( )因为代码量较少，没有循环，因此其执行效率更高
解析：【喵呜刷题小喵解析】aFactorial()用循环方式计算阶乘，bFactorial()用递归方式计算阶乘。当N值较大时，由于循环结构避免了多次函数调用带来的开销，因此aFactorial()执行效率更高，而bFactorial()因为有多次函数调用，效率会降低，且当N值较大时，递归深度过深可能导致栈溢出，无法使用。因此，选项C的说法是错误的。选项A描述了两种计算阶乘的方式，是正确的；选项B描述了两种方式的优缺点，也是正确的；选项D说bFactorial()因为代码量较少，执行效率更高，但实际上两种方式的执行效率与代码量无关，是错误的。
6、有关下面Python代码的说法，正确的是( )。
A、
代码中qSort()函数不是稳定排序
B、
代码中qSort()函数空间复杂度为O(1)
C、 代码中qSort()函数是就地排序
D、
代码中qSort()函数是外排序，因为排序后的结果保存在新的内存空间即外空间
解析：【喵呜刷题小喵解析】：
根据提供的图片，我们无法直接看到代码，但我们可以根据题目给出的选项进行分析。
A选项提到qSort()函数不是稳定排序，这需要我们分析该函数的稳定性。qSort()函数通常指的是C++ STL库中的快速排序函数，而快速排序在一般情况下并不是稳定排序。然而，根据提供的代码和图片，我们不能确定这是C++的qSort()还是其他语言或自定义实现，所以无法确切判断。
B选项提到qSort()函数空间复杂度为O(1)，这通常意味着排序算法在排序过程中需要使用的额外空间是常数。然而，快速排序的空间复杂度通常为O(log n)或O(n)，因为它需要递归调用，并使用栈来保存递归状态。所以，B选项不正确。
C选项提到qSort()函数是就地排序，这意味着排序算法在排序过程中不需要额外的存储空间，而是在原始数据上进行排序。对于快速排序来说，如果它是原地实现（不使用递归或堆栈），那么它的空间复杂度确实为O(1)。但是，快速排序通常使用递归，所以其空间复杂度通常不是O(1)。然而，从选项的描述来看，我们无法确定这是否是原地实现，所以C选项可能是正确的。
D选项提到qSort()函数是外排序，因为排序后的结果保存在新的内存空间即外空间。外排序通常指的是当待排序数据的大小超过内存大小时，需要在磁盘或其他外部存储设备进行排序的算法。但是，从图片和选项中，我们并不能看出这个排序过程涉及外存。所以，D选项不正确。
由于我们不能确定qSort()的具体实现，所以我们无法确切判断这些选项的正确性。但是，根据常见的排序算法和选项的描述，C选项可能是正确的。它提到qSort()是就地排序，虽然快速排序通常不是原地实现，但也不能排除这种可能性。因此，在没有更多信息的情况下，我们可以选择C选项。
7、上题不能支持其他常见类型的排序，如实现该支持，横线处分别应填写代码是( )。
A isinstance(iterData, list) == False ， st == [x for x in iterData]
B type(iterData) == list ， lst = [x for x in iterData]
C isinstance(iterData, list) ， lst = list(iterData)
D type(iterData) != list ， lst = list(iterData)
解析：【喵呜刷题小喵解析】：题目中给出的图片似乎是一个伪代码或流程图，但无法直接识别。从题目描述来看，似乎是在判断`iterData`是否为列表类型，并根据判断结果执行不同的操作。
选项A中，`isinstance(iterData, list) == False`这部分代码是检查`iterData`是否不是列表类型，但后面的`st == [x for x in iterData]`似乎与前面的判断没有直接关系，且`st`未在此处定义，因此A选项不符合题意。
选项B中，`type(iterData) == list`是检查`iterData`是否为列表类型，但后面的`lst = [x for x in iterData]`同样与前面的判断没有直接关系，且`lst`未在此处定义，因此B选项也不符合题意。
选项C中，`isinstance(iterData, list)`是检查`iterData`是否为列表类型，如果是，则执行`lst = list(iterData)`，将`iterData`转换为列表并赋值给`lst`。这符合题目的描述，因此C选项是正确的。
选项D中，`type(iterData) != list`是检查`iterData`是否不是列表类型，但后面的`lst = list(iterData)`似乎与前面的判断没有直接关系，且`lst`未在此处定义，因此D选项不符合题意。
因此，正确答案是C。
8、上上题qSort()函数不支持排序规则函数，形如sorted()函数的key参数，为实现类似目标，横线处分别应填入代码是( )。
A fx == None ， fx(x) >= fx(Pivot) ， fx(x) < fx(Pivot)
B fx == None ， fx(x) >= Pivot ， fx(x) < Pivot
C fx != None ， fx(x) >= fx(Pivot) ， fx(x) < fx(Pivot)
D fx != None ， fx(x) >= Pivot ， fx(x) < Pivot
解析：【喵呜刷题小喵解析】：题目中提到要实现类似sorted()函数的key参数的功能，而qSort()函数不支持排序规则函数。这意味着我们需要自己实现一个排序规则。在快速排序中，我们需要一个pivot（基准值）来将数组分为两部分，一部分的元素都小于pivot，另一部分的元素都大于pivot。为了实现类似sorted()函数的key参数，我们需要一个函数fx，用于确定元素x的排序规则。
在选项A和B中，fx被设置为None，这意味着没有排序规则，与题目要求不符。在选项C和D中，fx被设置为一个函数，可以用于确定元素的排序规则。
在选项C中，fx(x) >= fx(Pivot)表示元素x的排序规则大于或等于pivot的排序规则，而fx(x) < fx(Pivot)表示元素x的排序规则小于pivot的排序规则，这符合快速排序的要求。
在选项D中，fx(x) >= Pivot表示元素x的排序规则大于或等于pivot，而fx(x) < Pivot表示元素x的排序规则小于pivot，这实际上并不符合快速排序的要求，因为这里的Pivot并不是一个函数，而是一个具体的值。
因此，选项C是正确答案。
9、下面的Python代码中merge()函数的两个参数均为list类型，且是已按相同规则排序的数据。下面有关说法中，正确的是（ ）。
A 第3-7行代码将导致死循环，因为没有循环变量及其改变
B 第5行和第7行代码执行后，result的成员值为None
C 第9行和第11行是否被执行，与arr1和arr2的成员值有关，如果值转换为False，将不会被执行
merge()函数的代码没有错
D 误，执行后参数arr1和arr2将合并成新的list保存到result之中，且有序
解析：【喵呜刷题小喵解析】：从给出的代码来看，`merge()`函数的作用是合并两个已排序的列表`arr1`和`arr2`，并将合并后的结果保存在`result`中。根据代码的逻辑，如果`arr1`和`arr2`都已经排好序，那么`merge()`函数将会按照升序将两个列表合并。
对于选项A，代码中的`while`循环是有循环变量的，即`i`和`j`，它们分别表示`arr1`和`arr2`的索引。
对于选项B，第5行和第7行代码执行后，`result`将不会为`None`，而是会保存合并后的列表。
对于选项C，第9行和第11行是否执行与`arr1`和`arr2`的成员值无关，而是与`i`和`j`的索引有关。
因此，选项D是正确的，`merge()`函数没有错，执行后参数`arr1`和`arr2`将合并成新的列表保存到`result`之中，且有序。
10、阅读下面Python代码，横线处应填入（ ）。
A isOdd ， isEven
B isOdd ， isEven(10)
C isOdd(10) ， isEven
D isOdd(10) ， isEven(10)
解析：【喵呜刷题小喵解析】：
根据题目给出的Python代码，我们可以看出，代码中有一个函数定义`def isOdd(n):`，它用于判断一个数是否为奇数。同时，代码中还有一个变量`n`，它的值为10。在代码下方，有两个函数调用，一个为`isOdd(10)`，另一个为`isEven`。由于`isEven`前面没有参数，我们可以推测它应该是一个已经定义好的函数，用于判断一个数是否为偶数。因此，根据代码的逻辑，第一个函数调用`isOdd(10)`应该是判断10是否为奇数，而第二个函数调用`isEven`应该是判断某个数是否为偶数。所以，选项C“isOdd(10) ， isEven”是正确的。
11、下面Python代码的平均时间复杂度是（ ）。
A O(N)
B O(logN)
C O(NlogN)
D O(N2)
解析：【喵呜刷题小喵解析】：
题目中的Python代码是一个嵌套循环，外层循环和内层循环分别遍历两个列表。外层循环遍历列表a，内层循环遍历列表b。在每次外层循环中，内层循环都会遍历列表b中的所有元素，所以时间复杂度是O(N)。但是，外层循环需要执行N次，内层循环需要执行N次，因此整体的时间复杂度是O(N^2)。
所以，答案是O(N^2)，选项D正确。选项A、B、C均不正确。
12、有关下面Python代码的说法，正确的是（ ）。
A 代码采用二分法查找，仅对有序list有效，不适用于set、dict等
B 在函数内定义函数，存在多次调用多次定义，因此存在错误
C 第16行代码__bSearch()最后一个参数val应为queryVal
D 第16行代码应为return __bSearch
解析：【喵呜刷题小喵解析】：
首先，我们观察给出的Python代码，它定义了一个名为`binarySearch`的函数，该函数用于在有序列表中查找指定的值。
A选项提到代码采用二分法查找，仅对有序list有效，不适用于set、dict等。这个说法是正确的，因为代码中的`binarySearch`函数是针对有序列表设计的，不适用于set和dict，因为set和dict的排序不是确定的。
B选项说在函数内定义函数，存在多次调用多次定义，因此存在错误。这个说法是错误的，Python允许在函数内部定义函数，这被称为嵌套函数或局部函数。这种定义方式并不会导致多次定义的问题。
C选项说第16行代码`__bSearch()`最后一个参数val应为`queryVal`。这个说法也是正确的，因为函数`binarySearch`的第16行代码调用了`__bSearch()`函数，并且应该传入`queryVal`作为最后一个参数，而不是`val`。
D选项说第16行代码应为`return __bSearch`。这个说法是错误的，因为第16行代码实际上应该调用`__bSearch()`函数，而不是返回它。正确的调用方式应该是`return __bSearch(list, left, right, queryVal)`。
综上所述，正确的选项是C。
13、在上题的算法中，其时间复杂度是（ ）。
A O(N)
B O(logN)
C O(NlogN)
D O(N2)
解析：【喵呜刷题小喵解析】：
由于题目没有给出具体的算法，我们无法直接计算其时间复杂度。但是，从选项来看，我们可以根据常见的时间复杂度形式进行推测。
选项A，O(N)表示算法的时间复杂度与输入规模N成正比，即随着输入规模的增大，算法所需时间也线性增长。这是最简单、最常见的时间复杂度形式，通常对应于线性扫描、顺序访问等操作。
选项B，O(logN)表示算法的时间复杂度与输入规模N的对数成正比，即随着输入规模的增大，算法所需时间以对数速度增长。这种时间复杂度通常对应于二分查找、分治算法等。
选项C，O(NlogN)表示算法的时间复杂度与输入规模N的对数成正比，同时还有一个与N成正比的项。这种时间复杂度通常对应于排序算法（如归并排序、快速排序）和一些特殊问题的解决方案。
选项D，O(N^2)表示算法的时间复杂度与输入规模N的平方成正比，即随着输入规模的增大，算法所需时间以平方速度增长。这种时间复杂度通常对应于嵌套循环、动态规划等问题。
由于题目没有给出具体的算法，我们无法确定其确切的时间复杂度。但是，从选项来看，只有选项A是线性时间复杂度，而其他选项都高于线性时间复杂度。因此，我们可以推测，除非算法非常复杂，否则其时间复杂度很可能是O(N)。因此，最合理的答案是选项A。当然，这只是一种推测，具体答案还需要根据算法的具体实现来确定。
14、有关下面Python代码的说法错误的是（ ）。
A 代码中第17行执行后，firstNode(第一个节点)的下一个节点指向第3个节点，即secondNode(第2个节点)的下一个
B 代码中第18行执行后，第3个节点的Previous(前向)指向第1个节点（firstNode）
C 仅仅通过firstNode节点，不能访问第2个节点，第2个节点已不在内存中存在，自动释放所占内存
D 在第18行后，执行del secondNode后，第2个节点所占内存才会被释放。仅仅执行先有第16-18行，第2个节点内存不会被释放。
解析：【喵呜刷题小喵解析】：
首先，我们需要理解这段代码。从给出的图片中，我们可以看到这是一个双向链表的节点删除操作。
A选项：代码中第17行执行后，firstNode（第一个节点）的下一个节点指向第3个节点，即secondNode（第2个节点）的下一个。这是正确的，因为第17行的代码`firstNode.next = firstNode.next.next`意味着`firstNode`的`next`指针直接指向了`secondNode`的`next`，即第3个节点。
B选项：代码中第18行执行后，第3个节点的Previous（前向）指向第1个节点（firstNode）。这也是正确的，因为第18行的代码`thirdNode.previous = firstNode`将`thirdNode`的`previous`指针指向了`firstNode`。
C选项：仅仅通过firstNode节点，不能访问第2个节点，第2个节点已不在内存中存在，自动释放所占内存。这是错误的。从给出的代码中，我们可以看到`secondNode`仍然存在于内存中，只是它的引用被断开了，但它本身并没有被删除或释放。
D选项：在第18行后，执行del secondNode后，第2个节点所占内存才会被释放。仅仅执行先有第16-18行，第2个节点内存不会被释放。这是正确的。在Python中，当一个对象没有任何引用指向它时，它的内存才会被释放。在这里，`secondNode`的引用被断开了，但`secondNode`对象本身仍然存在，直到显式地删除它。
因此，C选项是错误的。
15、下面的Python代码中，idList变量为list类型，保存有大量身份编码，倒数第二位如为偶数，则为女性，奇数为男性，从第7位开始连续8位为出生年月日，年为4位数月和日均为两位数。编码统计每天有几位男生生日女生生日。横线处应填入代码是（ ）。
A (1, 0) if gender == 1 else (1, 0) ， (0, 1)
B (0, 1) if gender == 1 else (1, 0) ， (0, 0)
C 0, 1 if gender == 1 else 1, 0 ，0, 0
D (0, 1) if gender == 1 else (1, 0) ，0, 0
解析：【喵呜刷题小喵解析】：根据题目描述，身份编码的倒数第二位为性别标识，偶数为女性，奇数为男性。因此，在判断性别后，需要根据性别结果来统计男生和女生的数量。如果性别为1（奇数），则男生数量加1，女生数量不变；如果性别为0（偶数），则女生数量加1，男生数量不变。因此，应该使用条件表达式 `(1, 0) if gender == 1 else (0, 1)` 来判断性别并统计数量。选项A中的代码 `(1, 0) if gender == 1 else (1, 0)` 中第二个元素应为 `0`，因此选项A不正确。选项B中的代码 `(0, 1) if gender == 1 else (1, 0)` 符合题目要求，因此选项B正确。选项C和D中的代码均不符合题目要求，因此选项C和D不正确。
二、判断题
16、一个算法设计合理的话是可以没有输出的，比如冒泡排序就不输出任何信息（ ）。
A 正确
B 错误
解析：【喵呜刷题小喵解析】：算法通常是为了解决特定问题而设计的一系列步骤。虽然某些算法可能不直接产生可见的输出，但它们通常会有某种形式的输出，例如排序算法会对输入数据进行排序并返回排序后的结果。冒泡排序作为一种排序算法，其目的就是对输入数据进行排序，因此它会有输出。因此，说一个算法设计合理的话是可以没有输出的，这个观点是错误的。
17、流程图描述算法的能力是有限的，比如它无法对能够提前终止的循环给出等价描述 ( ) 。
A 正确
B 错误
解析：【喵呜刷题小喵解析】：虽然流程图可以描述大部分算法，但它确实有一些局限性。其中一点是，流程图无法直接表示出能够提前终止的循环。例如，在某些编程语言中，我们可以使用条件语句在循环的某个点上提前退出循环，这在流程图中很难直观地表示出来。因此，选项A“正确”是正确的。
18、归并排序的空间复杂度是 。( )
A 正确
B 错误
解析：【喵呜刷题小喵解析】：归并排序的空间复杂度是O(n)，其中n是待排序序列的长度。这是因为归并排序在排序过程中需要开辟一个与待排序序列长度相等的新数组来存放排序过程中的临时结果，所以空间复杂度为O(n)。因此，选项A“正确”是正确的。
19、在Python中，当对dict类型进行in运算查找元素是否存在时，其时间复杂度为 O(1) ，set类型也如此。（ ）
A 正确
B 错误
解析：【喵呜刷题小喵解析】：在Python中，字典（dict）和集合（set）都是哈希表结构，它们提供了O(1)的查找时间复杂度。但是，当使用“in”运算符对字典进行元素查找时，其时间复杂度实际上是O(1)，因为字典内部会首先通过哈希函数计算键的哈希值，然后快速定位到相应的桶（bucket），再进一步查找元素。然而，当哈希冲突发生时，Python可能会使用链地址法或其他解决策略来处理，这可能导致查找过程稍微复杂一些，但仍然保持O(1)的平均时间复杂度。但对于集合（set），使用“in”运算符查找元素的时间复杂度也是O(1)，因为集合也是基于哈希表实现的。因此，该题目中的说法不完全准确，因为它忽略了哈希冲突的可能性，所以答案为B，错误。
20、在以下Python代码中，执行后输出是 5=>4=>3=>2=>1=>2=>3=>2=>1=>5 。( )
A 正确
B 错误
解析：【喵呜刷题小喵解析】：根据题目给出的图片，该Python代码似乎是一个递归函数，但无法直接看到完整的代码，因此无法确定其确切的输出。然而，从图片中可以看到，该函数似乎接受一个参数，并在每次递归调用时减少该参数的值，直到达到1，然后再次增加该参数的值，直到达到5。因此，输出可能类似于“5=>4=>3=>2=>1=>2=>3=>2=>1=>5”，但这取决于具体的代码实现。然而，题目中给出的输出“5=>4=>3=>2=>1=>2=>3=>2=>1=>5”似乎是一个循环，而不是递归，因为递归通常会导致栈溢出或类似的错误，而不是重复相同的序列。因此，该输出不太可能由给定的代码产生。所以，选择B选项，即“错误”。要得到准确的答案，需要看到完整的代码。
21、贪心算法虽然可能不是局部最优，但可达到全局最优。 ( )
A 正确
B 错误
解析：【喵呜刷题小喵解析】：贪心算法并不一定能达到全局最优。贪心算法总是基于当前的最优选择，但这并不保证最后得到的结果是最优的。它只能保证每一步都是当前状态下的最优选择，但不能保证最终全局最优。在某些情况下，贪心算法可能只能得到局部最优解，而无法得到全局最优解。因此，题目中的说法是错误的。
22、Python内置函数sorted()可对支持for-in循环的数据类型排序。（ ）
A 正确
B 错误
解析：【喵呜刷题小喵解析】：Python内置的sorted()函数可以对支持for-in循环的数据类型进行排序。这是因为sorted()函数的基本工作原理是通过遍历输入的数据，并比较每个元素来确定它们的顺序，这与for-in循环的工作方式是一致的。因此，这个陈述是正确的。
23、冒泡排序是就地排序，空间复杂度为 O(1) 。（ ）
A 正确
B 错误
解析：【喵呜刷题小喵解析】：冒泡排序是一种简单的排序算法，它确实是一种就地排序，即不需要额外的存储空间。然而，空间复杂度通常用于描述算法所需的额外空间，而不是用于描述其用于排序的空间。对于冒泡排序，虽然它不需要额外的存储空间，但空间复杂度通常不描述为O(1)，而是描述为O(log n)或O(n)，这取决于具体实现。因此，该题目的说法是错误的。
24、下面的Python代码能实现N的质因数分解，类似埃氏筛法。（ ）
A 正确
B 错误
解析：【喵呜刷题小喵解析】：从题目中给出的图片可以看出，提供的Python代码是一个埃氏筛法的示例，用于找出小于N的所有素数。然而，题目要求的是实现N的质因数分解，与埃氏筛法的功能不符。质因数分解是将一个正整数表示为几个质数的乘积，而埃氏筛法只能找出素数，并不能直接得到质因数分解的结果。因此，这个Python代码不能实现N的质因数分解，选项B是正确的。
25、Python代码print(sorted(list(range(10,20)), key = hex))执行后将输出[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]。（ ）
A 正确
B 错误
解析：【喵呜刷题小喵解析】：题目中的Python代码`print(sorted(list(range(10,20)), key = hex))`试图对数字10到19进行排序，排序的key是`hex`函数。但是，`hex`函数会将整数转换为十六进制字符串，而不是用于比较整数的函数。因此，这段代码会抛出一个TypeError，因为它试图将字符串（十六进制表示）用于排序整数。所以，代码不会输出`[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]`，而是会抛出一个错误。因此，题目的陈述是错误的。
三、实操题
26、成绩排序
问题描述
有N名同学，每名同学有语文、数学、英语三科成绩。你需要按如下规则对所有同学的成绩从高到低排序：
1. 比较总分，高者靠前；
2. 如果总分相同，则比较语文和数学两科总分，高者靠前；
3. 如果仍相同，则比较语文和数学两科的最高分，高者靠前；
4. 如果仍相同，则二人并列。
你需要输出每位同学的排名，如遇x人并列，则他们排名相同，并留空后面的x-1个名次。例如，有3名同学并列第1，则后一名同学自动成为第4名。
输入描述
第一行一个整数N，表示同学的人数。
接下来N行，每行三个非负整数ci,mi,ei分别表示该名同学的语文、数学、英语成绩。
保证0≤ci,mi,ei≤150。
输出描述
输出N行，按输入同学的顺序，输出他们的排名。
注意：请不要按排名输出同学的序号，而是按同学的顺序输出他们各自的排名
特别提醒
在常规程序中，输入、输出时提供提示是好习惯。但在本场考试中，由于系统限定，请不要在输入、输出中附带任何提示信息。
样例输入
6 140 140 150 140 149 140 148 141 140 141 148 140 145 145 139 0 0 0
样例输出
1 3 4 4 2 6
数据规模
对于30的测试点，保证N≤100，且所有同学的总分各不相同。
对于所有测试点，保证2≤N≤104。
参考答案：对于给定的输入，首先计算每位同学的总分，然后按照题目中的排序规则进行排序。1. 计算总分：* 同学1的总分 = 140 + 140 + 150 = 430* 同学2的总分 = 140 + 149 + 140 = 429* 同学3的总分 = 148 + 141 + 140 = 429* 同学4的总分 = 141 + 148 + 140 = 429* 同学5的总分 = 145 + 145 + 139 = 429* 同学6的总分 = 0 + 0 + 0 = 02. 按照题目中的排序规则进行排序：* 同学1的总分最高，为430，所以同学1排名为1。* 同学2、3、4、5的总分均为429，所以同学2、3、4、5并列排名为3。* 同学6的总分为0，所以同学6排名为6。因此，输出结果为：```134426```
解析：【喵呜刷题小喵解析】：
首先，根据题目要求，我们需要计算每位同学的总分，并按照总分从高到低进行排序。如果总分相同，则继续比较语文和数学两科的总分，如果仍然相同，则比较语文和数学两科的最高分。
在这个样例中，同学1的总分最高，为430，所以同学1排名为1。同学2、3、4、5的总分均为429，所以同学2、3、4、5并列排名为3。同学6的总分为0，所以同学6排名为6。
在输出时，我们按照输入同学的顺序输出他们的排名。由于同学2、3、4、5并列排名为3，所以他们的排名都是3，并且空出后面的两个名次。同样，同学6的排名为6，也空出后面的所有名次。
需要注意的是，题目中要求按照同学的顺序输出排名，而不是按照排名输出同学的序号。因此，在输出时，我们需要按照输入的顺序输出排名，而不是按照排名顺序输出同学的序号。
27、B-smooth数（python）
题面描述
小杨同学想寻找一种名为B-smooth数的正整数。
如果一个正整数的最大质因子不超过B，则该正整数为B-smooth数。
小杨同学想知道，对于给定的n和B，有多少个不超过n的B-smooth数。
输入格式
第一行包含两个正整数n,B，含义如题面所示。
输出格式
输出一个非负整数，表示不超过n的B-smooth数的数量。
样例输入
10 3
样例输出
7
样例解释
在不超过10的正整数中，3-smooth 数有{1,2,3,4,6,8,9}，共7个。
数据范围
对于全部数据，保证有1≤n≤106，1≤B≤106。
参考答案：对于输入的n和B，我们可以遍历从1到n的所有整数，并检查每个整数的最大质因子是否不超过B。如果是，则该整数是一个B-smooth数，我们将其计数。最后，输出计数的结果。
解析：【喵呜刷题小喵解析】：
本题要求计算不超过n的B-smooth数的数量。B-smooth数是指最大质因子不超过B的正整数。对于每个正整数，我们可以检查其最大质因子是否不超过B，如果是，则将其计数。这种方法的时间复杂度为O(n)，对于较小的n和B，这种方法是可行的。
然而，对于较大的n和B，这种方法的时间复杂度过高，需要优化。一种优化方法是使用筛法，通过预处理出每个数的最大质因子，然后遍历每个数，检查其最大质因子是否不超过B。这种方法的时间复杂度可以降低到O(nloglogn)，但仍然不够高效。
另一种优化方法是使用数论分块的思想。我们可以将n分成若干个区间，每个区间的长度不超过B，然后分别计算每个区间内B-smooth数的数量。这种方法的时间复杂度可以降低到O(n/B + B)，当B取n的平方根时，时间复杂度最优，为O(sqrt(n))。
在本题中，由于n和B的取值范围较小，我们可以直接使用暴力方法，遍历每个数并检查其最大质因子是否不超过B。虽然这种方法的时间复杂度较高，但对于本题的数据范围，仍然可以在较短时间内得到正确答案。
喵呜刷题：让学习像火箭一样快速，快来微信扫码，体验免费刷题服务，开启你的学习加速器！
