python练习题（一）-526互联

算法题

1.计算1-100之间所有偶数的和

# 定义一个变量用来保存最后的累加和
total_even_sum = 0

# 从1到100的数
for num in range(1, 101):
    # 判断是否为偶数
    if num % 2 == 0:
        total_even_sum += num

print("偶数和是:", total_even_sum)

2.计算1-100的和

# 使用for循环求和
total_sum = 0

for i in range(1, 101):
    total_sum += i

print("和是:", total_sum)

3.计算斐波那契数列

def fibonacci_iterative(n):
    if n < 0:
        return "Input should be a non-negative integer"
    elif n == 0:
        return 0
    elif n == 1:
        return 1
    else:
        # 初始值
        fib_minus_2, fib_minus_1 = 0, 1
        for i in range(2, n + 1):
            fib_current = fib_minus_1 + fib_minus_2
            fib_minus_2, fib_minus_1 = fib_minus_1, fib_current
        return fib_minus_1


# 示例使用
num_terms = 10  # 要生成的斐波那契数列项数
for i in range(num_terms):
    print(fibonacci_iterative(i), end=" ")

4.计算平方根，编写一个程序，计算给定数的平方根。

import math


def calculate_square_root(num):
    """
    math 是 Python 内置的数学模块，提供了许多数学相关的函数和常数。
    sqrt 是 math 模块中的函数，用于计算平方根。
    math.sqrt(16) 表示对数字 16 计算平方根，即计算 √16，结果是 4.0
    :param num: 
    :return: 
    """
    if num < 0:
        return "输入的不能小于0"
    else:
        return math.sqrt(num)


result = calculate_square_root(16)
print("平方根是:", result)

5.冒泡排序

原理：

从第一个元素开始，依次比较相邻的两个元素，将较大（或较小）的元素交换至右侧。
在第一次遍历的过程中，最大（或最小）的元素会浮动到序列的末尾。
重复以上步骤，对剩下的未排序元素进行类似的操作，直到所有元素都排序完成。

def bubble_sort(arr):
    n = len(arr)
    # 外层循环控制遍历次数
    for i in range(n):
        # 内层循环遍历当前未排序部分
        # 并比较相邻的元素，将较大的元素向后移动
        for j in range(0, n-i-1):
            if arr[j] > arr[j+1]:
                arr[j], arr[j+1] = arr[j+1], arr[j]


# 示例使用
nums = [64, 34, 25, 12, 22, 11, 90]
print("排序之前:", nums)
bubble_sort(nums)
print("排序之后:", nums)

6.二分查找法

初始状态：在已排序的数组中选择一个区间 [left, right]，通常初始时选择整个数组作为搜索范围。
计算中间位置：计算中间元素的索引 mid = (left + right) // 2。
比较中间元素：将目标值与中间元素进行比较。

如果目标值等于中间元素，返回中间元素的索引，查找成功。
如果目标值小于中间元素，说明目标值可能在左半部分，更新搜索范围为 [left, mid - 1]。
如果目标值大于中间元素，说明目标值可能在右半部分，更新搜索范围为 [mid + 1, right]。

循环或递归查找：重复步骤2和步骤3，直到找到目标值或确定目标值不存在。
结束条件：当搜索范围为空 [left, right] 或目标值不存在于数组中时，结束查找。

def binary_search(arr, target):
    left, right = 0, len(arr) - 1
    while left <= right:
        mid = left + (right - left) // 2
        if arr[mid] == target:
            return mid
        elif arr[mid] < target:
            left = mid + 1
        else:
            right = mid - 1
    return -1  # 查找的目标不存在


nums = [10, 20, 30, 40, 50, 60]
target = 30
result = binary_search(nums, target)
print("Index of", target, ":", result)

7.选择排序

原理：通过不断选择剩余元素中的最小值（或最大值），然后将其放到已排序部分的末尾。具体步骤如下：

初始状态：将序列分为已排序部分和未排序部分，初始时已排序部分为空，整个序列都是未排序的。
选择最小值：从未排序部分选择最小的元素，与未排序部分的第一个元素交换位置，将该最小元素加入已排序部分。
递归过程：重复步骤2，每次在未排序部分选择最小的元素，与未排序部分的第一个元素交换位置，将该最小元素加入已排序部分。
结束条件：当所有元素都被加入已排序部分，排序完成。

def selection_sort(arr):
    n = len(arr)
    for i in range(n):
        # 找到未排序部分的最小元素的索引
        min_index = i
        for j in range(i + 1, n):
            if arr[j] < arr[min_index]:
                min_index = j

        # 将最小元素与当前位置交换
        arr[i], arr[min_index] = arr[min_index], arr[i]


# 示例使用
nums = [64, 34, 25, 12, 22, 11, 90]
print("排序前:", nums)
selection_sort(nums)
print("排序后:", nums)