Python列表·元组·集合·字典 中职专项练习题

题目描述：判断一个整数列表中，数字19恰好出现2次，且数字5至少出现3次。满足条件返回True，否则返回False。

def check_nineteen_and_five(num_list):
    return num_list.count(19) == 2 and num_list.count(5) >= 3

if __name__ == "__main__":
    print(check_nineteen_and_five([19, 19, 15, 5, 3, 5, 5, 2]))
    print(check_nineteen_and_five([19, 15, 15, 5, 3, 3, 5, 2]))
    print(check_nineteen_and_five([19, 19, 5, 5, 5, 5, 5]))

题目描述：接收一个整数列表，判断列表长度是否为8，且列表的第5个元素（下标4）在列表中至少出现3次。

def check_fifth_element(num_list):
    if len(num_list) != 8:
        return False
    fifth_item = num_list[4]
    return num_list.count(fifth_item) >= 3

if __name__ == "__main__":
    print(check_fifth_element([19, 19, 15, 5, 5, 5, 1, 2]))
    print(check_fifth_element([19, 15, 5, 7, 5, 5, 2]))
    print(check_fifth_element([11, 12, 14, 13, 14, 13, 15, 14]))

题目描述：接收一个整数，判断该数是否大于4的4次方（256），且该数对34取余的结果等于4。

def check_num_condition(num):
    return num > 4 ** 4 and num % 34 == 4

if __name__ == "__main__":
    print(check_num_condition(922))
    print(check_num_condition(914))
    print(check_num_condition(854))

题目描述：创建n堆石子：第一堆有n个石子，所有堆奇偶性一致，每堆比前一堆多2个（增量最小），返回每堆石子数量列表。

def stone_piles(n):
    return [n + 2 * i for i in range(n)]

if __name__ == "__main__":
    print(stone_piles(2))
    print(stone_piles(10))
    print(stone_piles(3))

题目描述：校验整数列表是否所有相邻元素之间的差值都为10。满足返回True，否则返回False。

def check_diff_ten(num_list):
    for i in range(1, len(num_list)):
        if abs(num_list[i] - num_list[i-1]) != 10:
            return False
    return True

if __name__ == "__main__":
    print(check_diff_ten([i * 10 for i in range(10)]))
    print(check_diff_ten([i * 20 for i in range(5)]))

题目描述：校验整数列表是否对于每一个下标i，前i个整数的和等于i。全部满足返回True，否则返回False。

def check_sum_equal_index(num_list):
    total = 0
    for idx, num in enumerate(num_list):
        total += num
        if total != idx:
            return False
    return True

if __name__ == "__main__":
    print(check_sum_equal_index([0, 1, 2, 3, 4, 5]))
    print(check_sum_equal_index([1, 1, 1, 1, 1, 1]))
    print(check_sum_equal_index([2, 2, 2, 2, 2]))

题目描述：生成一个由0到n（包含n）的非负整数组成的、空格分隔的字符串。

def generate_num_string(n):
    return " ".join(str(i) for i in range(n + 1))

if __name__ == "__main__":
    print(generate_num_string(4))
    print(generate_num_string(15))

题目描述：处理输入字符串：有空格按空格拆分；无空格有逗号按逗号拆分；都没有则返回奇数下标的小写字母列表。

def special_string_split(input_str):
    if " " in input_str:
        return input_str.split()
    elif "," in input_str:
        return input_str.split(",")
    else:
        return [input_str[i].lower() for i in range(1, len(input_str), 2)]

if __name__ == "__main__":
    print(special_string_split("a b c d"))
    print(special_string_split("a,b,c,d"))
    print(special_string_split("abcd"))

题目描述：不规则矩阵（每行元素个数不同），找出目标值在矩阵中所有出现位置的[行号, 列号]索引。

def find_target_in_ragged_matrix(matrix, target):
    index_list = []
    for row_idx, row in enumerate(matrix):
        for col_idx, value in enumerate(row):
            if value == target:
                index_list.append([row_idx, col_idx])
    return index_list

if __name__ == "__main__":
    print(find_target_in_ragged_matrix(([1, 3, 2, 32, 19], [19, 2, 48, 19], [], [9, 35, 4], [3, 19]), 19))
    print(find_target_in_ragged_matrix(([1, 2, 3, 2], [], [7, 9, 2, 1, 4]), 2))

题目描述：比较两个字符串列表，返回总字符数更少的那个列表。

def fewer_total_chars_list(list_group):
    list1, list2 = list_group
    total1 = sum(len(s) for s in list1)
    total2 = sum(len(s) for s in list2)
    return list1 if total1 < total2 else list2

if __name__ == "__main__":
    print(fewer_total_chars_list([['this', 'list', 'is', 'narrow'], ['I', 'am', 'shorter but wider']]))

题目描述：判断整数列表是否恰好包含4种不同的数值，且前20个元素中没有连续重复的整数。

def check_four_unique_no_consecutive(num_list):
    if len(set(num_list)) != 4:
        return False
    check_part = num_list[:20]
    for i in range(1, len(check_part)):
        if check_part[i] == check_part[i-1]:
            return False
    return True

if __name__ == "__main__":
    print(check_four_unique_no_consecutive([1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4]))
    print(check_four_unique_no_consecutive([1, 2, 3, 3, 1, 2, 3, 3, 1, 2, 3, 3, 1, 2, 3, 3]))
    print(check_four_unique_no_consecutive([1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3]))

题目描述：忽略字符串的大小写，找出其中所有不同的字符，返回字符列表。

def distinct_char_ignore_case(input_str):
    return list(set(input_str.lower()))

if __name__ == "__main__":
    print(distinct_char_ignore_case("HELLO"))
    print(distinct_char_ignore_case("HelLo"))

题目描述：从字符串序列中，筛选出所有以指定前缀开头的字符串。

def filter_by_prefix(prefix, str_sequence):
    return [s for s in str_sequence if s.startswith(prefix)]

if __name__ == "__main__":
    print(filter_by_prefix("ca", ('cat', 'car', 'fear', 'center')))
    print(filter_by_prefix("do", ('cat', 'dog', 'shatter', 'donut', 'at', 'todo')))

题目描述：接收一个非空字符串列表，返回每个字符串的长度组成的列表。

def get_string_lengths(str_list):
    return [len(s) for s in str_list]

if __name__ == "__main__":
    print(get_string_lengths(['cat', 'car', 'fear', 'center']))

题目描述：从字符串序列中，筛选出所有包含指定子串的字符串。

def filter_by_substring(sub_str, str_sequence):
    return [s for s in str_sequence if sub_str in s]

if __name__ == "__main__":
    print(filter_by_substring("ca", ('cat', 'car', 'fear', 'center')))
    print(filter_by_substring("o", ('cat', 'dog', 'shatter', 'donut', 'at', 'todo', '')))

题目描述：找出字典中大小写格式与其他所有键不同的那个键。

def find_odd_case_key(dict_data):
    keys = list(dict_data.keys())
    lower_count = 0
    upper_count = 0
    lower_key = ""
    upper_key = ""
    for key in keys:
        if key.islower():
            lower_count += 1
            lower_key = key
        elif key.isupper():
            upper_count += 1
            upper_key = key
    if lower_count == 1:
        return lower_key
    elif upper_count == 1:
        return upper_key
    else:
        return None

if __name__ == "__main__":
    print(find_odd_case_key({'red': '', 'GREEN': '', 'blue': 'orange'}))
    print(find_odd_case_key({'RED': '', 'GREEN': '', 'orange': '#125GD'}))

题目描述：批量判断字符串列表是否为回文字符串，返回一一对应的布尔值列表。

def check_palindrome_list(str_list):
    return [s == s[::-1] for s in str_list]

if __name__ == "__main__":
    print(check_palindrome_list(['palindrome', 'madamimadam', '', 'foo', 'eyes']))

题目描述：找出字符串列表中长度最长的字符串。

def get_longest_string(str_list):
    if not str_list:
        return ""
    return max(str_list, key=lambda x: len(x))

if __name__ == "__main__":
    print(get_longest_string(['cat', 'car', 'fear', 'center']))

题目描述：计算给定字符串中所有大写字母的ASCII码值之和。

def sum_uppercase_ascii(input_str):
    total = 0
    for char in input_str:
        if char.isupper():
            total += ord(char)
    return total

if __name__ == "__main__":
    print(sum_uppercase_ascii("PytHon ExerciSEs"))
    print(sum_uppercase_ascii("JavaScript"))

题目描述：找出列表中数值发生下降的位置的索引（当前元素小于前一个元素的下标）。

def get_drop_indices(num_list):
    drop_idx = []
    for i in range(1, len(num_list)):
        if num_list[i] < num_list[i-1]:
            drop_idx.append(i)
    return drop_idx

if __name__ == "__main__":
    print(get_drop_indices([6, 5, 4, 3, 2, 1]))

题目描述：生成一个新列表，第i个元素是输入列表前i个元素中的最大值。

def running_max_list(num_list):
    if not num_list:
        return []
    result = []
    current_max = num_list[0]
    for num in num_list:
        current_max = max(current_max, num)
        result.append(current_max)
    return result

if __name__ == "__main__":
    print(running_max_list([6, 5, 4, 3, 2, 1]))

题目描述：将两个二进制字符串按位异或，以0b开头的二进制格式输出。

def binary_string_xor(bin_str_list):
    num1 = int(bin_str_list[0], 2)
    num2 = int(bin_str_list[1], 2)
    return bin(num1 ^ num2)

if __name__ == "__main__":
    print(binary_string_xor(['0001', '1011']))

题目描述：将字符串中的逗号和句号都视为小数点，解析为数字，返回其中最大的数值。

def get_max_number_with_comma_dot(str_list):
    num_list = []
    for s in str_list:
        num = float(s.replace(",", "."))
        num_list.append(num)
    return max(num_list)

if __name__ == "__main__":
    print(get_max_number_with_comma_dot(['100', '102,1', '101.1']))

题目描述：找出字符串列表中，包含唯一字符数量最多的字符串。

def most_unique_char_string(str_list):
    if not str_list:
        return ""
    return max(str_list, key=lambda s: len(set(s)))

if __name__ == "__main__":
    print(most_unique_char_string(['Green', 'Red', 'Orange', 'Yellow', '', 'White']))

题目描述：判断数字序列的单调性，返回递增、递减或非单调序列。

def check_monotonic_direction(num_list):
    is_increasing = all(num_list[i] <= num_list[i+1] for i in range(len(num_list)-1))
    is_decreasing = all(num_list[i] >= num_list[i+1] for i in range(len(num_list)-1))
    if is_increasing:
        return "Increasing."
    elif is_decreasing:
        return "Decreasing."
    else:
        return "Not a monotonic sequence!"

if __name__ == "__main__":
    print(check_monotonic_direction([1, 2, 3, 4, 5, 6]))
    print(check_monotonic_direction([6, 5, 4, 3, 2, 1]))

题目描述：计算列表中所有数字的个位数字的乘积。

def product_of_units_digits(num_list):
    product = 1
    for num in num_list:
        unit_digit = abs(num) % 10
        product *= unit_digit
    return product

if __name__ == "__main__":
    print(product_of_units_digits([12, 23]))
    print(product_of_units_digits([12, 23, 43]))

题目描述：对整数列表去重，同时保留元素在原列表中的出现顺序。

def deduplicate_preserve_order(num_list):
    seen = set()
    result = []
    for num in num_list:
        if num not in seen:
            seen.add(num)
            result.append(num)
    return result

if __name__ == "__main__":
    print(deduplicate_preserve_order([1, 3, 4, 10, 4, 1, 43]))

题目描述：找出需要追加到列表末尾的数字，使得列表所有元素的总和为0。

def get_zero_sum_number(num_list):
    return -sum(num_list)

if __name__ == "__main__":
    print(get_zero_sum_number([1, 2, 3, 4, 5]))

题目描述：计算列表中位于奇数下标位置的偶数元素的总和。

def sum_even_at_odd_index(num_list):
    total = 0
    for idx, num in enumerate(num_list):
        if idx % 2 == 1 and num % 2 == 0:
            total += num
    return total

if __name__ == "__main__":
    print(sum_even_at_odd_index([1, 2, 3, 4, 5, 6, 7]))

题目描述：对每组[已吃数量、还需数量、库存数量]，计算总需求量和剩余库存。

def stock_appetite_calc(data_groups):
    result = []
    for eaten, need, stock in data_groups:
        total_appetite = eaten + need
        remaining = stock - total_appetite
        result.append([total_appetite, remaining])
    return result

if __name__ == "__main__":
    print(stock_appetite_calc([[2, 5, 6], [3, 9, 22]]))

题目描述：找出列表中所有数值小于指定阈值的元素的下标索引。

def get_index_below_threshold(num_list, threshold):
    return [idx for idx, num in enumerate(num_list) if num < threshold]

if __name__ == "__main__":
    print(get_index_below_threshold([0, 12, 45, 3, 4923, 322, 105, 29, 15, 39, 55], 100))

题目描述：找出小于等于n的所有偶数回文数。

def find_even_palindromes(n):
    result = []
    for num in range(0, n + 1, 2):
        num_str = str(num)
        if num_str == num_str[::-1]:
            result.append(num)
    return result

if __name__ == "__main__":
    print(find_even_palindromes(50))
    print(find_even_palindromes(100))

题目描述：找出数组中最小的偶数数值及其下标；多个相同最小值返回下标最小的；无偶数返回空列表。

def min_even_with_index(num_list):
    even_list = [(num, idx) for idx, num in enumerate(num_list) if num % 2 == 0]
    if not even_list:
        return []
    even_list.sort(key=lambda x: (x[0], x[1]))
    min_num, min_idx = even_list[0]
    return [min_num, min_idx]

if __name__ == "__main__":
    print(min_even_with_index([1, 9, 4, 6, 10, 11, 14, 8]))
    print(min_even_with_index([1, 7, 7, 5, 9]))

题目描述：筛选列表中大于10，且首位和末位数字均为奇数的数字。

def filter_odd_first_last(num_list):
    result = []
    for num in num_list:
        if num <= 10:
            continue
        num_str = str(abs(num))
        first_digit = int(num_str[0])
        last_digit = int(num_str[-1])
        if first_digit % 2 == 1 and last_digit % 2 == 1:
            result.append(num)
    return result

if __name__ == "__main__":
    print(filter_odd_first_last([1, 3, 79, 10, 4, 1, 39, 62]))

题目描述：从单词列表中找出长度为偶数的单词，并按单词长度升序排序。

def sort_even_length_words(word_list):
    even_words = [word for word in word_list if len(word) % 2 == 0]
    return sorted(even_words, key=lambda x: len(x))

if __name__ == "__main__":
    print(sort_even_length_words(['Red', 'Black', 'White', 'Green', 'Pink', 'Orange']))

题目描述：从数字列表中找出最大的k个数字。

def top_k_largest(num_list, k):
    return sorted(num_list, reverse=True)[:k]

if __name__ == "__main__":
    print(top_k_largest([1, 2, 3, 4, 5, 5, 3, 6, 2], 3))

题目描述：按照数字各位数之和的大小，对列表中的数字进行升序排序。

def sort_by_digit_sum(num_list):
    def digit_sum(num):
        return sum(int(char) for char in str(abs(num)))
    return sorted(num_list, key=digit_sum)

if __name__ == "__main__":
    print(sort_by_digit_sum([10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]))

题目描述：判断三元组列表中，每组三个数字之和是否为0，返回布尔值列表。

def check_zero_sum_triples(triple_list):
    return [sum(triple) == 0 for triple in triple_list]

if __name__ == "__main__":
    print(check_zero_sum_triples([[1, 2, -3], [-4, 0, 4], [0, 1, -5], [1, 1, 1]]))

题目描述：接收英文数字单词组成的字符串，按数值大小对单词升序排序。

def sort_number_words(input_str):
    num_map = {
        "zero": 0, "one": 1, "two": 2, "three": 3, "four": 4,
        "five": 5, "six": 6, "seven": 7, "eight": 8, "nine": 9
    }
    words = input_str.split()
    sorted_words = sorted(words, key=lambda w: num_map.get(w, 0))
    return " ".join(sorted_words)

if __name__ == "__main__":
    print(sort_number_words("six one four one two three"))

题目描述：找出列表中第一个破坏递增顺序的两个元素的下标；严格递增则返回空列表。

def first_non_increasing_indices(num_list):
    for i in range(1, len(num_list)):
        if num_list[i] < num_list[i-1]:
            return [i-1, i]
    return []

if __name__ == "__main__":
    print(first_non_increasing_indices([1, 2, 3, 0, 4, 5, 6]))
    print(first_non_increasing_indices([1, 2, 3, 4, 5, 6]))

题目描述：生成前n项斐波那契数列。

def fibonacci_sequence(n):
    if n <= 0:
        return []
    fib = [1, 1]
    if n == 1:
        return [1]
    for i in range(2, n):
        fib.append(fib[i-1] + fib[i-2])
    return fib

if __name__ == "__main__":
    print(fibonacci_sequence(10))

题目描述：字符串仅含字母则翻转大小写；不含字母则反转整个字符串。

def swap_case_or_reverse(str_list):
    result = []
    for s in str_list:
        if s.isalpha():
            result.append(s.swapcase())
        else:
            result.append(s[::-1])
    return result

if __name__ == "__main__":
    print(swap_case_or_reverse(['cat', '124259239185125', '!@#']))

题目描述：定义两个数字集合，分别计算交集、并集、A-B差集并输出。

set_a = {1,2,3,4,5}
set_b = {4,5,6,7}
print("交集：", set_a & set_b)
print("并集：", set_a | set_b)
print("A-B差集：", set_a - set_b)

题目描述：接收两个整数列表，找出共同元素，去重后升序输出。

def same_elements(list1, list2):
    common = set(list1) & set(list2)
    return sorted(list(common))

if __name__ == "__main__":
    print(same_elements([1,2,5,5], [4,5,2]))

题目描述：找出列表中与质数相邻的所有数字，去重后按升序返回。

def is_prime(num):
    if num < 2:
        return False
    for i in range(2, int(num**0.5) + 1):
        if num % i == 0:
            return False
    return True

def adjacent_to_prime(num_list):
    result = set()
    for idx, num in enumerate(num_list):
        if is_prime(num):
            if idx > 0:
                result.add(num_list[idx-1])
            if idx < len(num_list) - 1:
                result.add(num_list[idx+1])
    return sorted(list(result))

if __name__ == "__main__":
    print(adjacent_to_prime([2, 17, 16, 0, 6, 4, 5]))

题目描述：遍历列表，用字典统计每个元素出现的次数。

def count_frequency(lst):
    cnt = {}
    for n in lst:
        if n in cnt:
            cnt[n] += 1
        else:
            cnt[n] = 1
    return cnt

if __name__ == "__main__":
    print(count_frequency([1,2,2,3,3,3]))

题目描述：找出句子中包含指定个数辅音字母的所有单词。

def find_word_with_consonant_count(input_str, consonant_num):
    vowels = {"a", "e", "i", "o", "u"}
    words = input_str.split()
    result = []
    for word in words:
        count = 0
        for char in word.lower():
            if char.isalpha() and char not in vowels:
                count += 1
        if count == consonant_num:
            result.append(word)
    return result

if __name__ == "__main__":
    print(find_word_with_consonant_count("this is our time", 3))

题目描述：根据字典中字符和出现次数，生成空格分隔的字符串。

def char_count_to_string(count_dict):
    char_list = []
    for char, count in count_dict.items():
        char_list.extend([char] * count)
    return " ".join(char_list)

if __name__ == "__main__":
    print(char_count_to_string({'f': 1, 'o': 2}))

题目描述：先翻转所有字母大小写，再将元音字母替换为ASCII码+2的字符。

def flip_case_shift_vowel(input_str):
    vowels = {"a", "e", "i", "o", "u", "A", "E", "I", "O", "U"}
    swapped_str = input_str.swapcase()
    result = []
    for char in swapped_str:
        if char in vowels:
            result.append(chr(ord(char) + 2))
        else:
            result.append(char)
    return "".join(result)

if __name__ == "__main__":
    print(flip_case_shift_vowel("Python"))

题目描述：找出数字n的小于n的最大整数因数。

def largest_proper_divisor(n):
    if n <= 1:
        return 0
    for i in range(n // 2, 0, -1):
        if n % i == 0:
            return i
    return 1

if __name__ == "__main__":
    print(largest_proper_divisor(18))
    print(largest_proper_divisor(100))

题目描述：计算数字中所有奇数位数字的乘积；没有奇数位数字返回0。

def product_of_odd_digits(num):
    num_str = str(abs(num))
    product = 1
    has_odd = False
    for char in num_str:
        digit = int(char)
        if digit % 2 == 1:
            product *= digit
            has_odd = True
    return product if has_odd else 0

if __name__ == "__main__":
    print(product_of_odd_digits(123456789))
    print(product_of_odd_digits(2468))

题目描述：计算列表前k个元素中，位数大于等于2的数字之和。

def sum_two_digit_in_first_k(num_list, k):
    check_part = num_list[:k]
    total = 0
    for num in check_part:
        if abs(num) >= 10:
            total += num
    return total

if __name__ == "__main__":
    print(sum_two_digit_in_first_k([4, 5, 17, 9, 14, 108, -9, 12, 76], 6))

题目描述：找出整数指数x，使得a的x次方等于n。

def find_integer_exponent(a, n):
    if a == 1:
        return 1 if n == 1 else None
    exponent = 0
    current = 1
    while current < n:
        current *= a
        exponent += 1
    return exponent if current == n else None

if __name__ == "__main__":
    print(find_integer_exponent(2, 1024))

题目描述：计算数组所有元素绝对值的和，结果符号与数组元素乘积的符号一致。

def signed_abs_sum(num_list):
    abs_total = sum(abs(num) for num in num_list)
    sign = 1
    for num in num_list:
        if num < 0:
            sign *= -1
        elif num == 0:
            sign = 0
            break
    return abs_total * sign

if __name__ == "__main__":
    print(signed_abs_sum([1, 3, -2]))

题目描述：找出两个数之间（包含两端）的最大偶数。

def max_even_in_range(m, n):
    start, end = sorted([m, n])
    for num in range(end, start - 1, -1):
        if num % 2 == 0:
            return num
    return None

if __name__ == "__main__":
    print(max_even_in_range(12, 51))

题目描述：校验文件名：必须以指定后缀结尾，文件名最多3个数字，最多一个句点。

def validate_filenames(filename_list):
    valid_suffix = {"txt", "exe", "jpg", "png", "dll"}
    result = []
    for filename in filename_list:
        if filename.count(".") != 1:
            result.append("No")
            continue
        main_name, suffix = filename.split(".")
        if suffix not in valid_suffix:
            result.append("No")
            continue
        digit_count = sum(1 for char in main_name if char.isdigit())
        if digit_count > 3:
            result.append("No")
            continue
        result.append("Yes")
    return result

if __name__ == "__main__":
    print(validate_filenames(['abc.txt', 'windows.dll', 'tiger.png', 'rose.jpg', 'test.py', 'win32.exe']))

题目描述：将数字的十进制位向左循环移动n位，超出的数字补到末尾。

def circular_left_shift(num, shift):
    num_str = str(num)
    digit_len = len(num_str)
    if shift > digit_len:
        return int(num_str[::-1])
    shifted_str = num_str[shift:] + num_str[:shift]
    return int(shifted_str)

if __name__ == "__main__":
    print(circular_left_shift(12345, 2))

题目描述：找出列表中数值最接近的一对元素的下标索引。

def closest_pair_indices(num_list):
    min_diff = float("inf")
    min_pair = []
    for i in range(len(num_list)):
        for j in range(i+1, len(num_list)):
            diff = abs(num_list[i] - num_list[j])
            if diff < min_diff:
                min_diff = diff
                min_pair = [i, j]
    return min_pair

if __name__ == "__main__":
    print(closest_pair_indices([1, 7, 9, 2, 10]))

题目描述：句子按单词拆分，每个单词内部字符按ASCII升序重排，再拼接成新字符串。

def sort_char_by_ascii(input_str):
    words = input_str.split()
    sorted_words = []
    for word in words:
        sorted_char = sorted(word)
        sorted_words.append("".join(sorted_char))
    return " ".join(sorted_words)

if __name__ == "__main__":
    print(sort_char_by_ascii("maltos won"))

题目描述：多组存取款记录，计算每组首次出现负余额时的余额；全程无负余额返回None。

def first_negative_balance(record_groups):
    result = []
    for records in record_groups:
        balance = 0
        negative_balance = None
        for num in records:
            balance += num
            if balance < 0 and negative_balance is None:
                negative_balance = balance
        result.append(negative_balance)
    return result

if __name__ == "__main__":
    print(first_negative_balance([[12, -7, 3, -89, 14, 88, -78], [-1, 2, 7]]))

题目描述：在数字列表每对相邻元素之间插入指定分隔数字，返回新列表。

def insert_separator_between(num_list, separator):
    result = []
    for i in range(len(num_list)):
        result.append(num_list[i])
        if i != len(num_list) - 1:
            result.append(separator)
    return result

if __name__ == "__main__":
    print(insert_separator_between([12, -7, 3, -89], 6))

题目描述：找出字符串中第一个「辅音+元音+辅音」结构的子串。

def find_cvc_substring(input_str):
    vowels = {"a", "e", "i", "o", "u"}
    for i in range(len(input_str) - 2):
        c1 = input_str[i].lower()
        c2 = input_str[i+1].lower()
        c3 = input_str[i+2].lower()
        if c1 not in vowels and c2 in vowels and c3 not in vowels:
            return input_str[i:i+3]
    return ""

if __name__ == "__main__":
    print(find_cvc_substring("Hello"))

题目描述：首元素+尾元素和为奇数则升序，和为偶数则降序。

def reorder_by_edge_sum(num_list):
    if not num_list:
        return []
    edge_sum = num_list[0] + num_list[-1]
    if edge_sum % 2 == 1:
        return sorted(num_list)
    else:
        return sorted(num_list, reverse=True)

if __name__ == "__main__":
    print(reorder_by_edge_sum([3, 7, 4]))
    print(reorder_by_edge_sum([2, 7, 4]))

题目描述：按照GPA区间规则，将分数转换为对应的字母等级。

def gpa_to_grade(gpa_list):
    grade_rules = [
        (4.0, "A+"), (3.7, "A"), (3.4, "A-"),
        (3.0, "B+"), (2.7, "B"), (2.4, "B-"),
        (2.0, "C+"), (1.7, "C"), (1.4, "C-"),
        (0, "F")
    ]
    result = []
    for gpa in gpa_list:
        for threshold, grade in grade_rules:
            if gpa >= threshold:
                result.append(grade)
                break
    return result

if __name__ == "__main__":
    print(gpa_to_grade([4.0, 3.5, 3.8]))

题目描述：找出列表中最大的负数和最小的正数；不存在则对应返回0。

def max_neg_min_pos(num_list):
    negatives = [num for num in num_list if num < 0]
    positives = [num for num in num_list if num > 0]
    max_negative = max(negatives) if negatives else 0
    min_positive = min(positives) if positives else 0
    return [max_negative, min_positive]

if __name__ == "__main__":
    print(max_neg_min_pos([-12, -6, 300, -40, 2, 2, 3]))

题目描述：输入姓名成绩字符串列表，用字典统计每位学生的总分和平均分并输出。

def score_statistics(score_list):
    data = {}
    for item in score_list:
        name, s = item.split(":")
        score = int(s)
        if name in data:
            data[name][0] += score
            data[name][1] += 1
        else:
            data[name] = [score, 1]
    for name, (total, num) in data.items():
        avg = total / num
        print(f"{name} 总分：{total}，平均分：{avg:.1f}")

if __name__ == "__main__":
    score_statistics(["张三:85","李四:92","张三:90","李四:88","王五:78"])

题目描述：实现简易购物车：添加商品、删除商品、统计总价，用集合保证商品编号唯一。

def shopping_cart_demo():
    cart = {}
    id_set = set()

    def add_goods(goods_id, name, price, num):
        if goods_id in id_set:
            cart[goods_id][2] += num
        else:
            cart[goods_id] = [name, price, num]
            id_set.add(goods_id)

    def del_goods(goods_id):
        if goods_id in id_set:
            del cart[goods_id]
            id_set.remove(goods_id)

    def calc_total():
        total = 0
        for info in cart.values():
            total += info[1] * info[2]
        return total

    # 测试流程
    add_goods("001", "笔记本", 50, 2)
    add_goods("002", "钢笔", 5, 10)
    print("总价：", calc_total())
    del_goods("002")
    print("删除后总价：", calc_total())

if __name__ == "__main__":
    shopping_cart_demo()

题目描述：从句子中筛选出长度为质数的单词，拼接成新字符串。

def is_prime(num):
    if num < 2:
        return False
    for i in range(2, int(num**0.5) + 1):
        if num % i == 0:
            return False
    return True

def concat_prime_length_words(sentence):
    words = sentence.split()
    result = []
    for word in words:
        if is_prime(len(word)):
            result.append(word)
    return " ".join(result)

if __name__ == "__main__":
    print(concat_prime_length_words("The quick brown fox jumps over the lazy dog."))

题目描述：将列表升序后，按「最小→剩余最大→剩余最小→剩余最大」交替生成新列表。

def min_max_alternate_sort(num_list):
    sorted_list = sorted(num_list)
    left = 0
    right = len(sorted_list) - 1
    result = []
    pick_min = True
    while left <= right:
        if pick_min:
            result.append(sorted_list[left])
            left += 1
        else:
            result.append(sorted_list[right])
            right -= 1
        pick_min = not pick_min
    return result

if __name__ == "__main__":
    print(min_max_alternate_sort([1, 3, 4, 5, 11]))

题目描述：找出列表中最大的质数，返回它的下标索引和各位数字之和。

def is_prime(num):
    if num < 2:
        return False
    for i in range(2, int(num**0.5) + 1):
        if num % i == 0:
            return False
    return True

def max_prime_index_and_digit_sum(num_list):
    prime_list = []
    for idx, num in enumerate(num_list):
        if is_prime(num):
            prime_list.append((num, idx))
    if not prime_list:
        return None
    max_prime, max_idx = max(prime_list, key=lambda x: x[0])
    digit_sum = sum(int(char) for char in str(max_prime))
    return [max_idx, digit_sum]

if __name__ == "__main__":
    print(max_prime_index_and_digit_sum([3, 11, 7, 17, 19, 4]))

题目描述：找出列表中两个数值最接近的不同数字。

def closest_distinct_pair(num_list):
    unique_nums = list(set(num_list))
    if len(unique_nums) < 2:
        return []
    unique_nums.sort()
    min_diff = float("inf")
    min_pair = []
    for i in range(1, len(unique_nums)):
        diff = unique_nums[i] - unique_nums[i-1]
        if diff < min_diff:
            min_diff = diff
            min_pair = [unique_nums[i-1], unique_nums[i]]
    return min_pair

if __name__ == "__main__":
    print(closest_distinct_pair([12.02, 20.3, 15.0, 19.0, 11.0, 14.99, 17.0]))

题目描述：对列表排序：奇数下标位置元素不动，偶数下标位置元素升序排序。

def sort_keep_odd_fixed(num_list):
    even_indices = [i for i in range(0, len(num_list), 2)]
    even_values = [num_list[i] for i in even_indices]
    even_values_sorted = sorted(even_values)
    new_list = num_list.copy()
    for idx, pos in enumerate(even_indices):
        new_list[pos] = even_values_sorted[idx]
    return new_list

if __name__ == "__main__":
    print(sort_keep_odd_fixed([2, 5, 6, 3, 1, 4, 34]))

题目描述：提取单词中的元音字母；如果y出现在单词末尾，也视为元音。

def extract_vowel_include_y_end(word_list):
    vowels = {"a", "e", "i", "o", "u"}
    result = []
    for word in word_list:
        word_lower = word.lower()
        vowel_chars = []
        for idx, char in enumerate(word_lower):
            if char in vowels:
                vowel_chars.append(char)
            elif char == "y" and idx == len(word_lower) - 1:
                vowel_chars.append(char)
        result.append("".join(vowel_chars))
    return result

if __name__ == "__main__":
    print(extract_vowel_include_y_end(['ably', 'abruptly', 'abecedary']))

题目描述：用输入字符串生成一个指定长度的回文字符串。

def generate_palindrome_by_length(input_str, length):
    if length <= 0:
        return ""
    half_length = (length + 1) // 2
    half = input_str[:half_length].ljust(half_length, input_str[0])
    if length % 2 == 0:
        return half + half[::-1]
    else:
        return half + half[:-1][::-1]

if __name__ == "__main__":
    print(generate_palindrome_by_length("madam", 7))

题目描述：提取列表中数字的个位数字，去重降序后转换为对应的英文数字单词。

def single_digit_to_english_reverse(num_list):
    digit_word_map = {
        0: "zero", 1: "one", 2: "two", 3: "three", 4: "four",
        5: "five", 6: "six", 7: "seven", 8: "eight", 9: "nine"
    }
    unit_digits = list(set(abs(num) % 10 for num in num_list))
    unit_digits_sorted = sorted(unit_digits, reverse=True)
    return [digit_word_map[d] for d in unit_digits_sorted if d != 0]

if __name__ == "__main__":
    print(single_digit_to_english_reverse([1, 3, 4, 5, 11]))

题目描述：从列表中筛选出所有数字位均为奇数的数字，升序排序后返回。

def all_odd_digit_sublist(num_list):
    def is_all_odd_digit(num):
        num_str = str(abs(num))
        for char in num_str:
            if int(char) % 2 == 0:
                return False
        return True
    result = [num for num in num_list if is_all_odd_digit(num)]
    return sorted(result)

if __name__ == "__main__":
    print(all_odd_digit_sublist([1, 3, 79, 10, 4, 2, 39]))

题目描述：判断字符串是否每三个连续字符都不相同；不是则返回首次连续三个相同字符的后两个下标。

def unhappy_string_indices(input_str):
    for i in range(len(input_str) - 2):
        if input_str[i] == input_str[i+1] == input_str[i+2]:
            return [i+1, i+2]
    return None

if __name__ == "__main__":
    print(unhappy_string_indices("Python"))
    print(unhappy_string_indices("Unhappy"))

题目描述：用原列表元素生成一个严格递增的序列（去重+升序）。

def increasing_sequence_from_list(num_list):
    return sorted(list(set(num_list)))

if __name__ == "__main__":
    print(increasing_sequence_from_list([1, 3, 79, 10, 4, 2, 39]))

题目描述：找出所有n位整数中，以2开头或以2结尾的数字。

def n_digit_start_end_with_two(n):
    if n == 1:
        return [2]
    start = 10 ** (n - 1)
    end = 10 ** n - 1
    result = []
    for num in range(start, end + 1):
        num_str = str(num)
        if num_str[0] == "2" or num_str[-1] == "2":
            result.append(num)
    return result

if __name__ == "__main__":
    print(n_digit_start_end_with_two(2))

题目描述：根据输入字符串生成最接近的回文字符串。

def closest_palindrome(input_str):
    n = len(input_str)
    if n == 1:
        return input_str
    half = input_str[:(n + 1) // 2]
    if n % 2 == 0:
        palindrome = half + half[::-1]
    else:
        palindrome = half + half[:-1][::-1]
    return palindrome

if __name__ == "__main__":
    print(closest_palindrome("madan"))

题目描述：计算a到b之间所有整数的平均值，四舍五入后以二进制格式返回。

def range_average_binary(a, b):
    if b <= a:
        return -1
    num_range = range(a, b)
    average = sum(num_range) / len(num_range)
    rounded_avg = round(average)
    return bin(rounded_avg)

if __name__ == "__main__":
    print(range_average_binary(4, 7))

题目描述：列表中每个浮点数向上取整，计算取整后整数的平方，返回累加和列表。

import math
def ceil_square_running_total(num_list):
    running_total = 0
    result = []
    for num in num_list:
        ceil_num = math.ceil(num)
        running_total += ceil_num ** 2
        result.append(running_total)
    return result

if __name__ == "__main__":
    print(ceil_square_running_total([2.6, 3.5, 6.7, 2.3, 5.6]))

题目描述：找出四个正偶数，使其和等于给定整数n。

def four_even_sum(n):
    if n < 8:
        return []
    return [n - 6, 2, 2, 2]

if __name__ == "__main__":
    print(four_even_sum(100))