编写一个程序，它将找到所有这些数字，可被7整除，但不是5的倍数，1000至2021(包括在内)，输出这些数字并统计满足条件的数字的个数

count = 0  # 用于统计符合条件的数字的数量
result = []  # 存储符合条件的数字

for num in range(1000, 2022):
    if num % 7 == 0 and num % 5 != 0:
        result.append(num)
        count += 1

#print("1000到2021之间可被7整除但不是5的倍数的数字有:")
print(result)
print(f"{count}")

编写一个接受句子并计算字母和数字的程序

sentence = input("请输入一个句子: ")

# 初始化字母和数字的计数器
letter_count = 0
digit_count = 0

# 遍历句子中的每个字符

for char in sentence:
    if char.isalpha():  # 判断字符是否是字母
        letter_count += 1
    elif char.isdigit():  # 判断字符是否是数字
        digit_count += 1

print(f"字母 {letter_count}  数字{digit_count}")

输入一个正整数，输出这个正整数的的阶乘

def factorial(n):
    if n == 0:
        return 1
    else:
        result = 1
        for i in range(1, n + 1):
            result *= i
        return result

try:
    num = int(input("请输入一个正整数: "))
    if num < 0:
        print("请输入一个非负整数。")
    else:
        result = factorial(num)
        print(f"{num} 的阶乘是 {result}")
except ValueError:
    print("请输入一个有效的整数。")

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值的那两个整数,nums指定为：[2,7,11,15],target为用户手动输入。如果nums中找不到两个整数相加的和等于target,则输出不存在

def find_two_sum(nums, target):
    num_indices = {}  # 用于存储数字和它们的索引

    for index, num in enumerate(nums):
        complement = target - num  # 计算与当前数字配对的补数

        if complement in num_indices:
            # 如果补数在字典中，说明找到了一对配对的数字
            return [num_indices[complement], index]

        # 否则，将当前数字添加到字典中
        num_indices[num] = index

    return None  # 如果找不到配对的数字，返回None

# 用户输入目标值
try:
    target = int(input("请输入目标值: "))
    nums = [2, 7, 11, 15]  # 给定的数组
    result = find_two_sum(nums, target)

    if result is not None:
        print(f"和为目标值 {target} 的两个整数是: {nums[result[0]]} 和 {nums[result[1]]}")
    else:
        print("不存在两个整数的和等于目标值。")
except ValueError:
    print("请输入一个有效的整数作为目标值。")

卡拉兹(Callatz)猜想：对任何一个正整数 n，如果它是偶数，那么把它砍掉一半；如果它是奇数，那么把 (3n+1) 砍掉一半。这样一直反复砍下去，最后一定在某一步得到 n=1。
对给定的任一不超过 1000 的正整数 n，简单地数一下，需要多少步（砍几下）才能得到 n=1？

def collatz_steps(n):
    steps = 0  # 初始化步数

    while n != 1:
        if n % 2 == 0:
            n = n // 2
        else:
            n = 3 * n + 1
        steps += 1

    return steps

try:
    n = int(input("请输入一个不超过1000的正整数: "))
    if 1 <= n <= 1000:
        steps_needed = collatz_steps(n)
        print(f"需要 {steps_needed} 步才能得到 n=1。")
    else:
        print("请输入一个介于1和1000之间的正整数。")
except ValueError:
    print("请输入一个有效的整数。")

设计一个函数，输入为两个整数，输出为这两个数的最大公约数
比如，输入：5，15；输出：5

def find_gcd(a, b):
    while b:
        a, b = b, a % b
    return a

# 示例用法
num1 = int(input("请输入第一个整数: "))
num2 = int(input("请输入第二个整数: "))

gcd = find_gcd(num1, num2)
print(f"{num1} 和 {num2} 的最大公约数是 {gcd}")

定义一个函数，输入一个列表，并将列表中的头尾两个元素对调后返回
表，并将列表中的

def swap_first_and_last(lst):
    if len(lst) >= 2:
        lst[0], lst[-1] = lst[-1], lst[0]
    return lst

# 示例用法
input_list = [1, 2, 3, 4, 5]
result = swap_first_and_last(input_list)
print(result)

输入一个正整数n，输出从1到这个正整数n（包括n）的所有正整数的和

def sum_of_integers_up_to_n(n):
    if n < 1:
        return "请输入一个正整数。"
    
    total = 0
    for i in range(1, n + 1):
        total += i
    return total

try:
    n = int(input("请输入一个正整数 n: "))
    result = sum_of_integers_up_to_n(n)
    if type(result) == int:
        print(f"从1到{n}的所有正整数的和是: {result}")
    else:
        print(result)
except ValueError:
    print("请输入一个有效的整数。")

定义一个函数sort_list（），功能为将两个升序链表合并为一个新的升序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。即输入为两个升序列表，输出为合并后的升序列表

class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

def sort_list(l1, l2):
    # 创建一个哑结点作为新链表的头部
    dummy = ListNode()
    current = dummy  # 用于遍历新链表

    while l1 is not None and l2 is not None:
        if l1.val < l2.val:
            current.next = l1
            l1 = l1.next
        else:
            current.next = l2
            l2 = l2.next
        current = current.next

    # 将剩余的节点连接到新链表
    if l1 is not None:
        current.next = l1
    if l2 is not None:
        current.next = l2

    return dummy.next  # 返回新链表的头部

示例用法

创建两个升序链表

l1 = ListNode(1, ListNode(3, ListNode(5)))
l2 = ListNode(2, ListNode(4, ListNode(6)))

merged_list = sort_list(l1, l2)

# 打印合并后的升序链表
while merged_list:
    print(merged_list.val, end=" ")
    merged_list = merged_list.next

给你一个整数 x ，如果 x 是一个回文整数，输出 true ；否则，输出 false

def is_palindrome(x):
    if x < 0:
        return False

    x_str = str(x)
    return x_str == x_str[::-1]

# 示例用法
num = int(input("请输入一个整数: "))
result = is_palindrome(num)

if result:
    print("是回文整数")
else:
    print("不是回文整数")

猴子偷桃问题：有一只猴子摘了若干个桃子，第一天吃了一半，还不过瘾，又多吃了一个；第二天吃了剩下的一半，还不过瘾，又多吃了一个；以后每天都是吃剩下的一半加一个。编写程序，输入天数和剩下的桃子数，计算猴子摘了多少桃子。

def calculate_starting_peaches(days, peach_left):
    peaches = peach_left

    for day in range(days - 1, 0, -1):
        peaches = (peaches + 1) * 2

    return peaches

try:
    days = int(input("请输入天数: "))
    peach_left = int(input("请输入剩下的桃子数: "))
    
    if days <= 0 or peach_left <= 0:
        print("请输入正整数天数和桃子数。")
    else:
        starting_peaches = calculate_starting_peaches(days, peach_left)
        print(f"一开始有 {starting_peaches} 个桃子。")
except ValueError:
    print("请输入有效的整数。")