1. C++编程比赛题目：编写一个程序，接受一组数字的输入，然后统计并输出不超过这组数字的平均值的数字的个数

#include <iostream>
using namespace std;

int main() {
    int n;
    cout << "请输入数字的数量: ";
    cin >> n;

    // 声明一个数组来存储输入的数字
    int numbers[n];
    int sum = 0;

    // 输入数字
    for (int i = 0; i < n; i++) {
        cout << "请输入第 " << i + 1 << " 个数字: ";
        cin >> numbers[i];
        sum += numbers[i];
    }

    // 计算平均值
    double average = static_cast<double>(sum) / n;

    // 统计不超过平均值的数字的个数
    int count = 0;
    for (int i = 0; i < n; i++) {
        if (numbers[i] <= average) {
            count++;
        }
    }

    // 输出结果
    cout << "平均值为: " << average << endl;
    cout << "不超过平均值的数字个数为: " << count << endl;

    return 0;
}

2. 输入一些数，求第二大的值

#include <iostream>
using namespace std;

int main() {
    int n;
    cout << "请输入数字的数量: ";
    cin >> n;

    if (n < 2) {
        cout << "至少需要输入两个数字才能找到第二大值。" << endl;
        return 1;
    }

    int first_max = INT_MIN;  // 初始最大值为负无穷
    int second_max = INT_MIN; // 初始第二大值为负无穷

    for (int i = 0; i < n; i++) {
        int num;
        cout << "请输入第 " << i + 1 << " 个数字: ";
        cin >> num;

        if (num > first_max) {
            second_max = first_max;
            first_max = num;
        } else if (num > second_max && num != first_max) {
            second_max = num;
        }
    }

    if (second_max == INT_MIN) {
        cout << "没有找到第二大值。" << endl;
    } else {
        cout << "第二大值为: " << second_max << endl;
    }

    return 0;
}

3. 输入一些数，哪两个数最接近

#include <iostream>
#include <vector>
#include <cmath>
using namespace std;

int main() {
    int n;
    cout << "请输入数字的数量: ";
    cin >> n;

    if (n < 2) {
        cout << "至少需要输入两个数字才能找到最接近的两个数字。" << endl;
        return 1;
    }

    vector<int> numbers;
    for (int i = 0; i < n; i++) {
        int num;
        cout << "请输入第 " << i + 1 << " 个数字: ";
        cin >> num;
        numbers.push_back(num);
    }

    int minDiff = abs(numbers[0] - numbers[1]);
    int closest1 = numbers[0];
    int closest2 = numbers[1];

    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            int diff = abs(numbers[i] - numbers[j]);
            if (diff < minDiff) {
                minDiff = diff;
                closest1 = numbers[i];
                closest2 = numbers[j];
            }
        }
    }

    cout << "最接近的两个数字是: " << closest1 << " 和 " << closest2 << endl;

    return 0;
}

效率更高一点算法？

#include <iostream>
#include <vector>
#include <algorithm>
#include <climits>
using namespace std;

int main() {
    int n;
    cout << "请输入数字的数量: ";
    cin >> n;

    if (n < 2) {
        cout << "至少需要输入两个数字才能找到最接近的两个数字。" << endl;
        return 1;
    }

    vector<int> numbers;
    for (int i = 0; i < n; i++) {
        int num;
        cout << "请输入第 " << i + 1 << " 个数字: ";
        cin >> num;
        numbers.push_back(num);
    }

    sort(numbers.begin(), numbers.end()); // 排序数组

    int minDiff = INT_MAX;
    int closest1, closest2;

    for (int i = 0; i < n - 1; i++) {
        int diff = numbers[i + 1] - numbers[i];
        if (diff < minDiff) {
            minDiff = diff;
            closest1 = numbers[i];
            closest2 = numbers[i + 1];
        }
    }

    cout << "最接近的两个数字是: " << closest1 << " 和 " << closest2 << endl;

    return 0;
}

4. 统计字符1的个数

#include <iostream>
#include <string>
using namespace std;

int main() {
    string input;
    cout << "请输入一个字符串: ";
    cin >> input;

    int count = 0;

    for (char c : input) {
        if (c == '1') {
            count++;
        }
    }

    cout << "字符 '1' 的个数是: " << count << endl;

    return 0;
}

5. 前n个整数顺序写在以其，数一数0～9的数字各出现多少次？

#include <iostream>
#include <vector>
using namespace std;

int main() {
    int n;
    cout << "请输入一个正整数 n: ";
    cin >> n;

    if (n <= 0) {
        cout << "请输入一个有效的正整数。" << endl;
        return 1;
    }

    vector<int> counts(10, 0); // 初始化一个长度为10，每个元素都为0的向量，用于统计0~9的出现次数

    for (int i = 1; i <= n; i++) {
        int num = i;
        while (num > 0) {
            int digit = num % 10; // 获取最低位的数字
            counts[digit]++; // 增加对应数字的计数
            num /= 10; // 去掉最低位
        }
    }

    // 输出各数字出现次数
    for (int i = 0; i < 10; i++) {
        cout << "数字 " << i << " 出现 " << counts[i] << " 次" << endl;
    }

    return 0;
}

编写一个程序，它将找到所有这些数字，可被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("请输入有效的整数。")