编程题

编程题

1. 编写一个函数，接受一个字符串，并返回该字符串中所有大写字母的数量。

def count_uppercase(string):
    return sum(1 for char in string if char.isupper())

2. 实现一个函数，接受一个整数列表，并返回其中所有奇数的平方和。

def sum_of_odd_squares(numbers):
    return sum(num**2 for num in numbers if num % 2 != 0)

3. 编写一个程序，计算给定整数的阶乘。

def factorial(n):
    if n == 0:
        return 1
    return n * factorial(n-1)

4. 实现一个函数，接受一个字符串，返回该字符串中每个单词的长度列表。

def word_lengths(string):
    return [len(word) for word in string.split()]

5. 编写一个程序，接受一个整数列表，返回其中的最大值和最小值。

def find_max_min(numbers):
    return max(numbers), min(numbers)

6. 实现一个函数，接受一个字符串，返回其中出现频率最高的字符。

def most_frequent_char(string):
    char_frequency = {char: string.count(char) for char in set(string)}
    return max(char_frequency, key=char_frequency.get)

7. 编写一个程序，将两个列表合并为一个字典，其中第一个列表中的元素作为键，第二个列表中的元素作为值。

def merge_lists_to_dict(keys, values):
    return dict(zip(keys, values))

8. 实现一个函数，接受一个整数列表，返回其中所有元素的乘积。

def product_of_numbers(numbers):
    product = 1
    for num in numbers:
        product *= num
    return product

9. 编写一个程序，找出一个字符串中的所有回文子串。

def all_palindromic_substrings(string):
    palindromes = []
    for i in range(len(string)):
        for j in range(i, len(string)):
            substring = string[i:j+1]
            if substring == substring[::-1] and len(substring) > 1:
                palindromes.append(substring)
    return palindromes

10. 实现一个函数，接受一个字符串和一个字符，返回该字符在字符串中的所有位置索引。

def find_char_positions(string, char):
    return [i for i, c in enumerate(string) if c == char]

11. 编写一个函数，接受一个整数列表，并返回其中所有偶数的和。

def sum_of_even_numbers(numbers):
    return sum(num for num in numbers if num % 2 == 0)

12. 实现一个函数，接受一个字符串，返回该字符串中第一个不重复的字符。

def first_unique_char(string):
    char_count = {}
    for char in string:
        char_count[char] = char_count.get(char, 0) + 1
    for char in string:
        if char_count[char] == 1:
            return char
    return None

13. 编写一个程序，将一个整数列表逆序排列。

def reverse_list(numbers):
    return numbers[::-1]

14. 实现一个函数，接受一个字符串，返回该字符串中所有元音字母的数量。

def count_vowels(string):
    vowels = 'aeiouAEIOU'
    return sum(1 for char in string if char in vowels)

15. 编写一个程序，判断一个字符串是否是有效的回文串（忽略大小写和非字母字符）。

def is_palindrome(s):
    s = ''.join(char.lower() for char in s if char.isalnum())
    return s == s[::-1]

16. 实现一个函数，接受一个整数列表和一个目标值，返回列表中两个数相加等于目标值的索引。

def two_sum(nums, target):
    num_indices = {}
    for i, num in enumerate(nums):
        complement = target - num
        if complement in num_indices:
            return [num_indices[complement], i]
        num_indices[num] = i
    return None

17. 编写一个程序，找出一个整数列表中缺失的数字。

def find_missing_number(nums):
    n = len(nums) + 1
    expected_sum = n * (n + 1) // 2
    actual_sum = sum(nums)
    return expected_sum - actual_sum

18. 实现一个函数，接受一个整数列表和一个目标值，返回列表中所有和为目标值的不重复三元组。

def three_sum(nums, target):
    nums.sort()
    res = []
    for i in range(len(nums)-2):
        if i > 0 and nums[i] == nums[i-1]:
            continue
        left, right = i+1, len(nums)-1
        while left < right:
            total = nums[i] + nums[left] + nums[right]
            if total < target:
                left += 1
            elif total > target:
                right -= 1
            else:
                res.append([nums[i], nums[left], nums[right]])
                while left < right and nums[left] == nums[left+1]:
                    left += 1
                while left < right and nums[right] == nums[right-1]:
                    right -= 1
                left += 1
                right -= 1
    return res

19. 实现一个函数，接受一个字符串，返回该字符串中出现次数最多的字符及其出现次数。

def most_frequent_char_count(string):
    char_count = {}
    for char in string:
        char_count[char] = char_count.get(char, 0) + 1
    max_char = max(char_count, key=char_count.get)
    return max_char, char_count[max_char]

20. 编写一个程序，实现插入排序算法对一个整数列表进行排序。

def insertion_sort(numbers):
    for i in range(1, len(numbers)):
        key = numbers[i]
        j = i - 1
        while j >= 0 and key < numbers[j]:
            numbers[j + 1] = numbers[j]
            j -= 1
        numbers[j + 1] = key
    return numbers