111_编程挑战基础：从FizzBuzz到逻辑算法的系统化学习指南

安全风信子

发布于 2025-11-16 15:21:16

910

文章被收录于专栏：AI SPPECHAI SPPECH

一、编程挑战概述与重要性

编程挑战是提升编程技能、算法思维和问题解决能力的重要途径，尤其在信息安全领域，良好的编程基础是理解漏洞原理、开发利用工具和构建安全系统的关键。从简单的FizzBuzz到复杂的算法实现，每一个编程挑战都在锻炼我们的逻辑思维和代码表达能力。

在CTF（Capture The Flag）竞赛中，编程挑战类题目（又称Misc类）通常作为基础部分出现，虽然难度较低，但对于参赛者的代码能力和问题分析能力有较高要求。掌握这些基础编程挑战不仅能帮助你在比赛中获得初步分数，更为解决更复杂的安全问题奠定基础。

编程挑战学习路径：
基础语法 → 简单算法 → 数据结构应用 → 高级算法 → 安全应用

1.1 学习目标

完成本章节学习后，你将能够：

熟练掌握Python基础语法和控制结构
理解并实现常见的简单算法问题
培养系统化的问题分析和解决能力
掌握编写高效、可读代码的技巧
为后续更复杂的编程挑战打下坚实基础

1.2 工具准备

在开始编程挑战前，我们需要准备以下工具和环境：

工具/环境	版本要求	用途
Python	3.6+	主要编程语言
Visual Studio Code	最新版	代码编辑器
Git	最新版	代码管理
Jupyter Notebook	最新版	交互式编程环境

二、编程基础回顾

在开始挑战前，让我们快速回顾一下Python编程的基础知识，包括变量、数据类型、控制流和函数等核心概念。

2.1 基本数据类型

Python支持多种数据类型，包括整数、浮点数、字符串、布尔值、列表、元组、字典和集合等。

# 基本数据类型示例
integer_value = 42               # 整数
float_value = 3.14159           # 浮点数
string_value = "Hello, World!"  # 字符串
bool_value = True              # 布尔值
list_value = [1, 2, 3, 4, 5]    # 列表
tuple_value = (1, 2, 3)         # 元组
dict_value = {"name": "Python", "version": 3.8}  # 字典
set_value = {1, 2, 3, 4}        # 集合

2.2 控制流语句

Python提供了if-elif-else条件语句和for、while循环语句来控制程序流程。

# 条件语句示例
x = 10
if x > 0:
    print("x是正数")
elif x < 0:
    print("x是负数")
else:
    print("x等于零")

# for循环示例
for i in range(5):
    print(f"当前数字: {i}")

# while循环示例
count = 0
while count < 5:
    print(f"计数: {count}")
    count += 1

2.3 函数定义与调用

函数是组织代码的基本单位，通过def关键字定义。

# 函数定义示例
def greet(name):
    """向指定名称的人打招呼"""
    return f"Hello, {name}!"

# 函数调用
message = greet("Python")
print(message)  # 输出: Hello, Python!

# 带默认参数的函数
def calculate_area(radius, pi=3.14159):
    """计算圆的面积"""
    return pi * radius ** 2

# 调用带默认参数的函数
area1 = calculate_area(5)       # 使用默认pi值
area2 = calculate_area(5, 3.14)  # 指定pi值

三、经典编程挑战解析：FizzBuzz

FizzBuzz是一个经典的编程挑战，虽然简单，但能很好地测试基础编程能力和逻辑思维。让我们深入分析并实现这个问题。

3.1 问题描述

编写一个程序，输出从1到100的所有数字，但有以下规则：

如果数字能被3整除，输出"Fizz"
如果数字能被5整除，输出"Buzz"
如果数字既能被3整除又能被5整除，输出"FizzBuzz"
其他情况下，输出数字本身

3.2 问题分析

这个问题主要考察条件语句的嵌套和组合使用。解决思路如下：

遍历从1到100的所有数字
对每个数字，检查是否满足特定条件
根据条件输出相应的结果

FizzBuzz逻辑流程图：
开始 → 取数字n → 检查n%3==0且n%5==0? → 是→输出"FizzBuzz"
                             ↓否
                  检查n%3==0? → 是→输出"Fizz"
                            ↓否
                  检查n%5==0? → 是→输出"Buzz"
                            ↓否
                           输出n
                             ↓
                           结束

3.3 基础实现

下面是FizzBuzz问题的基础实现：

def fizzbuzz():
    """实现基础的FizzBuzz逻辑"""
    for i in range(1, 101):
        if i % 3 == 0 and i % 5 == 0:
            print("FizzBuzz")
        elif i % 3 == 0:
            print("Fizz")
        elif i % 5 == 0:
            print("Buzz")
        else:
            print(i)

# 调用函数
fizzbuzz()

3.4 优化实现

我们可以通过字符串拼接的方式优化代码，使其更加简洁：

def fizzbuzz_optimized():
    """使用字符串拼接优化FizzBuzz实现"""
    for i in range(1, 101):
        result = ""
        if i % 3 == 0:
            result += "Fizz"
        if i % 5 == 0:
            result += "Buzz"
        print(result if result else i)

# 调用优化后的函数
fizzbuzz_optimized()

3.5 进阶变体

FizzBuzz问题可以有多种变体，例如：

扩展倍数规则：支持更多的倍数和对应输出
自定义范围：允许用户指定输出范围
返回列表：返回结果列表而不是直接打印

下面是一个支持自定义规则的FizzBuzz变体实现：

def custom_fizzbuzz(start=1, end=100, rules=None):
    """
    实现自定义规则的FizzBuzz
    
    参数：
        start: 起始数字
        end: 结束数字
        rules: 字典，键为除数，值为对应输出字符串
    """
    # 默认规则
    if rules is None:
        rules = {3: "Fizz", 5: "Buzz"}
    
    results = []
    for i in range(start, end + 1):
        result = ""
        for divisor, word in rules.items():
            if i % divisor == 0:
                result += word
        results.append(result if result else str(i))
    return results

# 使用自定义规则
custom_rules = {3: "Fizz", 5: "Buzz", 7: "Bang"}
results = custom_fizzbuzz(1, 100, custom_rules)
for result in results:
    print(result)

3.6 性能分析

虽然FizzBuzz问题简单，但我们也可以分析不同实现方式的性能差异：

import time

# 测试不同实现的性能
def test_performance():
    # 测试基础实现
    start_time = time.time()
    fizzbuzz()
    base_time = time.time() - start_time
    
    # 测试优化实现
    start_time = time.time()
    fizzbuzz_optimized()
    opt_time = time.time() - start_time
    
    print(f"\n性能对比:")
    print(f"基础实现耗时: {base_time:.6f}秒")
    print(f"优化实现耗时: {opt_time:.6f}秒")
    print(f"优化实现提速: {(base_time - opt_time) / base_time * 100:.2f}%")

# 运行性能测试
test_performance()

四、更多编程基础挑战

除了FizzBuzz，还有许多经典的基础编程挑战可以帮助我们提升编程能力。让我们逐一分析和实现。

4.1 回文数判断

问题描述：判断一个整数是否是回文数（从左到右读和从右到左读都是一样的）。

实现思路：

将整数转换为字符串，然后检查是否与反转后的字符串相同
或者使用数学方法，通过取模和除法操作反转整数

def is_palindrome_string(num):
    """使用字符串方法判断回文数"""
    # 负数不是回文数
    if num < 0:
        return False
    # 转换为字符串并检查
    return str(num) == str(num)[::-1]

def is_palindrome_math(num):
    """使用数学方法判断回文数"""
    # 负数不是回文数
    if num < 0:
        return False
    
    original = num
    reversed_num = 0
    
    while num > 0:
        # 取最后一位数字
        last_digit = num % 10
        # 构建反转数
        reversed_num = reversed_num * 10 + last_digit
        # 移除最后一位数字
        num = num // 10
    
    return original == reversed_num

# 测试
print(is_palindrome_string(121))  # 输出: True
print(is_palindrome_string(-121))  # 输出: False
print(is_palindrome_math(121))  # 输出: True
print(is_palindrome_math(-121))  # 输出: False

4.2 斐波那契数列

问题描述：生成斐波那契数列的第n项。斐波那契数列定义为：F(0) = 0, F(1) = 1, F(n) = F(n-1) + F(n-2)（n ≥ 2）。

实现思路：

递归方法：直接按照定义实现递归
迭代方法：使用循环计算，避免重复计算
动态规划：使用数组存储中间结果

def fibonacci_recursive(n):
    """使用递归实现斐波那契数列"""
    if n <= 0:
        return 0
    elif n == 1:
        return 1
    else:
        return fibonacci_recursive(n-1) + fibonacci_recursive(n-2)

def fibonacci_iterative(n):
    """使用迭代实现斐波那契数列"""
    if n <= 0:
        return 0
    elif n == 1:
        return 1
    
    a, b = 0, 1
    for _ in range(2, n+1):
        a, b = b, a + b
    return b

def fibonacci_dp(n):
    """使用动态规划实现斐波那契数列"""
    if n <= 0:
        return 0
    elif n == 1:
        return 1
    
    fib = [0] * (n + 1)
    fib[1] = 1
    
    for i in range(2, n + 1):
        fib[i] = fib[i-1] + fib[i-2]
    
    return fib[n]

# 测试
print(fibonacci_recursive(10))  # 输出: 55
print(fibonacci_iterative(10))  # 输出: 55
print(fibonacci_dp(10))  # 输出: 55

4.3 素数判断

问题描述：判断一个数是否为素数（只能被1和自身整除的大于1的整数）。

实现思路：

基本方法：检查从2到n-1的所有数字是否能整除n
优化方法：只需检查到√n即可
高级优化：排除偶数后再检查

def is_prime_basic(n):
    """基本素数判断方法"""
    if n <= 1:
        return False
    for i in range(2, n):
        if n % i == 0:
            return False
    return True

def is_prime_optimized(n):
    """优化的素数判断方法"""
    if n <= 1:
        return False
    elif n <= 3:
        return True
    elif n % 2 == 0 or n % 3 == 0:
        return False
    
    # 只需检查到sqrt(n)，且只检查6k±1形式的数
    i = 5
    while i * i <= n:
        if n % i == 0 or n % (i + 2) == 0:
            return False
        i += 6
    return True

# 测试
print(is_prime_basic(17))  # 输出: True
print(is_prime_basic(20))  # 输出: False
print(is_prime_optimized(997))  # 输出: True
print(is_prime_optimized(1000))  # 输出: False

4.4 最大公约数与最小公倍数

问题描述：计算两个数的最大公约数（GCD）和最小公倍数（LCM）。

实现思路：

最大公约数：使用欧几里得算法（辗转相除法）
最小公倍数：利用公式 LCM(a, b) = |a * b| / GCD(a, b)

def gcd(a, b):
    """使用欧几里得算法计算最大公约数"""
    while b:
        a, b = b, a % b
    return a

def lcm(a, b):
    """计算最小公倍数"""
    if a == 0 or b == 0:
        return 0
    return abs(a * b) // gcd(a, b)

# 测试
print(gcd(48, 18))  # 输出: 6
print(lcm(48, 18))  # 输出: 144

五、字符串处理挑战

字符串处理是编程中非常常见的任务，也是CTF竞赛中的重要内容。让我们学习一些基本的字符串处理技巧。

5.1 字符串反转

问题描述：将输入的字符串反转。

实现思路：

使用切片操作
使用循环或递归
使用栈结构

def reverse_string_slice(s):
    """使用切片操作反转字符串"""
    return s[::-1]

def reverse_string_loop(s):
    """使用循环反转字符串"""
    reversed_str = ""
    for char in s:
        reversed_str = char + reversed_str
    return reversed_str

def reverse_string_stack(s):
    """使用栈反转字符串"""
    stack = list(s)
    reversed_str = ""
    while stack:
        reversed_str += stack.pop()
    return reversed_str

# 测试
text = "Hello, World!"
print(reverse_string_slice(text))  # 输出: !dlroW ,olleH
print(reverse_string_loop(text))  # 输出: !dlroW ,olleH
print(reverse_string_stack(text))  # 输出: !dlroW ,olleH

5.2 字符计数

问题描述：统计字符串中每个字符出现的次数。

实现思路：

使用字典存储字符及其出现次数
使用Python的Counter类

def count_chars_manual(s):
    """手动实现字符计数"""
    char_count = {}
    for char in s:
        if char in char_count:
            char_count[char] += 1
        else:
            char_count[char] = 1
    return char_count

from collections import Counter
def count_chars_counter(s):
    """使用Counter实现字符计数"""
    return dict(Counter(s))

# 测试
text = "programming challenge"
print(count_chars_manual(text))
print(count_chars_counter(text))

5.3 最长公共前缀

问题描述：找出一组字符串的最长公共前缀。

实现思路：

水平扫描：从第一个字符串开始，逐步比较
垂直扫描：比较每个字符串的第i个字符

def longest_common_prefix_horizontal(strs):
    """水平扫描法查找最长公共前缀"""
    if not strs:
        return ""
    
    prefix = strs[0]
    for i in range(1, len(strs)):
        while strs[i].find(prefix) != 0:
            prefix = prefix[:-1]
            if not prefix:
                return ""
    return prefix

def longest_common_prefix_vertical(strs):
    """垂直扫描法查找最长公共前缀"""
    if not strs:
        return ""
    
    for i in range(len(strs[0])):
        char = strs[0][i]
        for j in range(1, len(strs)):
            if i == len(strs[j]) or strs[j][i] != char:
                return strs[0][:i]
    return strs[0]

# 测试
words = ["flower", "flow", "flight"]
print(longest_common_prefix_horizontal(words))  # 输出: "fl"
print(longest_common_prefix_vertical(words))  # 输出: "fl"

六、数组和列表处理

数组和列表是编程中最常用的数据结构之一，掌握它们的操作对于解决编程挑战至关重要。

6.1 数组反转

问题描述：反转一个数组或列表。

实现思路：

使用切片操作
使用双指针技术
使用辅助数组

def reverse_array_slice(arr):
    """使用切片操作反转数组"""
    return arr[::-1]

def reverse_array_inplace(arr):
    """原地反转数组"""
    left, right = 0, len(arr) - 1
    while left < right:
        # 交换元素
        arr[left], arr[right] = arr[right], arr[left]
        left += 1
        right -= 1
    return arr

# 测试
numbers = [1, 2, 3, 4, 5]
print(reverse_array_slice(numbers))  # 输出: [5, 4, 3, 2, 1]
print(reverse_array_inplace(numbers.copy()))  # 输出: [5, 4, 3, 2, 1]

6.2 找出数组中的重复元素

问题描述：找出数组中所有重复出现的元素。

实现思路：

使用集合记录已见过的元素
使用字典统计元素出现次数
使用排序后比较相邻元素

def find_duplicates_set(arr):
    """使用集合找出重复元素"""
    seen = set()
    duplicates = set()
    
    for num in arr:
        if num in seen:
            duplicates.add(num)
        else:
            seen.add(num)
    
    return list(duplicates)

def find_duplicates_dict(arr):
    """使用字典找出重复元素"""
    count = {}
    for num in arr:
        count[num] = count.get(num, 0) + 1
    
    return [num for num, freq in count.items() if freq > 1]

def find_duplicates_sorted(arr):
    """排序后找出重复元素"""
    if not arr:
        return []
    
    arr.sort()
    duplicates = []
    for i in range(1, len(arr)):
        if arr[i] == arr[i-1] and (i == 1 or arr[i] != arr[i-2]):
            duplicates.append(arr[i])
    
    return duplicates

# 测试
numbers = [4, 3, 2, 7, 8, 2, 3, 1]
print(find_duplicates_set(numbers))  # 输出: [2, 3]
print(find_duplicates_dict(numbers))  # 输出: [2, 3]
print(find_duplicates_sorted(numbers))  # 输出: [2, 3]

6.3 两个数组的交集

问题描述：找出两个数组的交集，每个元素在结果中出现的次数应与在两个数组中出现的次数的最小值一致。

实现思路：

使用字典统计第一个数组中元素的出现次数
遍历第二个数组，检查元素是否在字典中，并减少计数
使用集合快速查找

def intersect_dict(nums1, nums2):
    """使用字典实现数组交集"""
    # 确保nums1是较小的数组，优化空间复杂度
    if len(nums1) > len(nums2):
        nums1, nums2 = nums2, nums1
    
    # 统计第一个数组中元素的出现次数
    count = {}
    for num in nums1:
        count[num] = count.get(num, 0) + 1
    
    # 查找交集
    result = []
    for num in nums2:
        if num in count and count[num] > 0:
            result.append(num)
            count[num] -= 1
    
    return result

def intersect_sorted(nums1, nums2):
    """先排序再找交集"""
    nums1.sort()
    nums2.sort()
    
    i = j = 0
    result = []
    
    while i < len(nums1) and j < len(nums2):
        if nums1[i] < nums2[j]:
            i += 1
        elif nums1[i] > nums2[j]:
            j += 1
        else:
            result.append(nums1[i])
            i += 1
            j += 1
    
    return result

# 测试
nums1 = [1, 2, 2, 1]
nums2 = [2, 2]
print(intersect_dict(nums1, nums2))  # 输出: [2, 2]
print(intersect_sorted(nums1, nums2))  # 输出: [2, 2]

七、算法复杂度分析

在编程挑战中，理解算法复杂度对于编写高效的解决方案至关重要。让我们学习如何分析常见算法的时间复杂度和空间复杂度。

7.1 时间复杂度

时间复杂度表示算法执行时间与输入规模之间的关系，通常使用大O符号表示。常见的时间复杂度包括：

O(1)：常数时间复杂度
O(log n)：对数时间复杂度
O(n)：线性时间复杂度
O(n log n)：线性对数时间复杂度
O(n²)：平方时间复杂度
O(2ⁿ)：指数时间复杂度

时间复杂度比较：
O(1) < O(log n) < O(n) < O(n log n) < O(n²) < O(2ⁿ)

7.2 空间复杂度

空间复杂度表示算法所需的额外空间与输入规模之间的关系。

# 示例：不同算法的时间和空间复杂度

def constant_example(arr):
    # 时间复杂度: O(1)
    # 空间复杂度: O(1)
    return arr[0] if arr else None

def linear_example(arr):
    # 时间复杂度: O(n)
    # 空间复杂度: O(1)
    sum_result = 0
    for num in arr:
        sum_result += num
    return sum_result

def quadratic_example(arr):
    # 时间复杂度: O(n²)
    # 空间复杂度: O(1)
    n = len(arr)
    for i in range(n):
        for j in range(i+1, n):
            if arr[i] > arr[j]:
                arr[i], arr[j] = arr[j], arr[i]
    return arr

def logn_example(nums, target):
    # 二分查找示例
    # 时间复杂度: O(log n)
    # 空间复杂度: O(1)
    left, right = 0, len(nums) - 1
    while left <= right:
        mid = (left + right) // 2
        if nums[mid] == target:
            return mid
        elif nums[mid] < target:
            left = mid + 1
        else:
            right = mid - 1
    return -1

7.3 复杂度优化技巧

在编程挑战中，我们通常需要优化算法的时间或空间复杂度。以下是一些常见的优化技巧：

使用哈希表（字典/集合）：将查找操作从O(n)优化到O(1)
二分查找：将搜索操作从O(n)优化到O(log n)
双指针技术：减少遍历次数，优化空间使用
动态规划：避免重复计算，优化递归算法
贪心算法：在某些问题上提供更高效的解决方案

八、编程挑战实战案例

让我们通过一些实际的编程挑战案例来巩固所学知识，并学习如何系统化地解决问题。

8.1 案例一：两数之和

问题描述：给定一个整数数组和一个目标值，找出数组中和为目标值的两个数的索引。

实现思路：

暴力解法：双层循环，时间复杂度O(n²)
哈希表解法：一次遍历，时间复杂度O(n)

def two_sum_brute(nums, target):
    """暴力解法：双层循环"""
    n = len(nums)
    for i in range(n):
        for j in range(i+1, n):
            if nums[i] + nums[j] == target:
                return [i, j]
    return []

def two_sum_hash(nums, target):
    """哈希表解法"""
    num_map = {}
    for i, num in enumerate(nums):
        complement = target - num
        if complement in num_map:
            return [num_map[complement], i]
        num_map[num] = i
    return []

# 测试
nums = [2, 7, 11, 15]
target = 9
print(two_sum_brute(nums, target))  # 输出: [0, 1]
print(two_sum_hash(nums, target))  # 输出: [0, 1]

8.2 案例二：有效的括号

问题描述：给定一个只包含括号字符的字符串，判断字符串是否有效。有效字符串必须满足：

左括号必须用相同类型的右括号闭合
左括号必须以正确的顺序闭合

实现思路：

使用栈数据结构
遇到左括号入栈，遇到右括号则检查栈顶元素是否匹配

def is_valid_parentheses(s):
    """检查括号字符串是否有效"""
    # 定义括号匹配规则
    pairs = {
        ")": "(",
        "]": "[",
        "}": "{"
    }
    
    stack = []
    
    for char in s:
        # 如果是右括号，检查栈顶元素
        if char in pairs:
            # 如果栈为空或栈顶元素不匹配，返回False
            top_element = stack.pop() if stack else '#'
            if pairs[char] != top_element:
                return False
        # 如果是左括号，入栈
        else:
            stack.append(char)
    
    # 如果栈为空，说明所有括号都匹配
    return not stack

# 测试
print(is_valid_parentheses("()"))  # 输出: True
print(is_valid_parentheses("()[]{}"))  # 输出: True
print(is_valid_parentheses("(]"))  # 输出: False
print(is_valid_parentheses("([)]"))  # 输出: False
print(is_valid_parentheses("{[]}"))  # 输出: True

8.3 案例三：合并两个有序数组

问题描述：给定两个有序整数数组nums1和nums2，将nums2合并到nums1中，使得nums1成为一个有序数组。

实现思路：

双指针从后向前遍历，避免需要额外空间
使用辅助数组暂存结果

def merge_sorted_arrays(nums1, m, nums2, n):
    """合并两个有序数组，将结果存储在nums1中"""
    # 初始化三个指针
    p1 = m - 1  # nums1最后一个元素的位置
    p2 = n - 1  # nums2最后一个元素的位置
    p = m + n - 1  # 合并后数组最后一个位置
    
    # 从后向前合并
    while p1 >= 0 and p2 >= 0:
        if nums1[p1] > nums2[p2]:
            nums1[p] = nums1[p1]
            p1 -= 1
        else:
            nums1[p] = nums2[p2]
            p2 -= 1
        p -= 1
    
    # 如果nums2还有剩余元素，直接复制到nums1
    nums1[:p2+1] = nums2[:p2+1]
    
    return nums1

# 测试
nums1 = [1, 2, 3, 0, 0, 0]
m = 3
nums2 = [2, 5, 6]
n = 3
print(merge_sorted_arrays(nums1, m, nums2, n))  # 输出: [1, 2, 2, 3, 5, 6]

九、编程挑战解题方法论

面对编程挑战，拥有系统化的解题方法非常重要。以下是一个通用的解题方法论：

9.1 问题分析

理解问题：仔细阅读题目，确保完全理解要求
明确输入和输出：确定函数的参数和返回值
考虑边界情况：空输入、特殊值等
找出约束条件：时间限制、空间限制等

9.2 设计算法

思考可能的解决方案：先想出暴力解法，再思考优化方法
分析算法复杂度：计算时间和空间复杂度
选择最优算法：根据题目要求选择最合适的算法

9.3 编写代码

编写伪代码：先理清思路，再开始编码
实现算法：用Python编写代码，注意代码风格和可读性
添加注释：解释重要的逻辑和决策

9.4 测试和调试

编写测试用例：包括常规情况、边界情况和特殊情况
运行测试：检查代码是否按预期工作
调试问题：如果有错误，定位并修复

编程挑战解题流程：
理解问题 → 分析约束 → 设计算法 → 评估复杂度 → 编码实现 → 测试调试 → 优化改进

十、总结与展望

通过本章的学习，我们掌握了编程挑战的基础概念和方法，从简单的FizzBuzz到更复杂的数组和字符串处理问题。这些基础内容是解决更高级编程挑战和安全问题的基石。

在接下来的章节中，我们将学习更多高级的编程挑战技术，包括脚本自动化、网络协议分析、人工智能挑战等。这些内容将帮助你在CTF竞赛中更上一层楼，也能在实际的信息安全工作中发挥重要作用。

记住，编程能力的提升需要不断的练习和思考。遇到问题时，不要急于查找答案，而是尝试自己分析和解决，这样才能真正提高编程水平。

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2025-11-12，如有侵权请联系 cloudcommunity@tencent.com 删除

基础

本文分享自作者个人站点/博客前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体同步曝光计划，欢迎热爱写作的你一起参与！

登录后参与评论

0 条评论

热度