亿豪的python学习 day09

今天的学习内容

上午

2048游戏算法的六个练习

"""
2048 游戏核心算法
"""
#全局变量
list_merge = [0,0,2,0]#2 2 0 0


#1.定义函数，零元素移动到末尾
#输入：[2,0,2,0]
#输出：[2,2,0,0](不用返回值)
def move_zero_to_end():
    for i in range(len(list_merge)-1):
        if 0 in list_merge:
            list_merge.remove(0)
            list_merge.append(0)
# move_zero_to_end()
# print(list_merge)


#2.定义函数，合并相同元素（非零）
#输入：[2,2,0,0]
#输出：[4,0,0,0]
#输入：[2,0,0,2] - ->[2,2,0,0]
#输出：[4,0,0,0]
#输入：[2,0,2,2] - ->[2,2,2,0]
#输出：[4,2,0,0]
#输入：[8,8,8,8]
#输出：[16,16,0,0]
def merge():
    move_zero_to_end()
    for i in range(3):
        if list_merge[i] == list_merge[i+1]:
            list_merge[i] *= 2
            del list_merge[i+1]
            list_merge.append(0)

# sum_same_num()
# print(list_merge)

map =[
    [2,0,2,0],
    [2,0,2,0],
    [2,0,2,0],
    [2,0,2,0]
]
#3.定义函数，向左移动
#提示：每行交给list—_merge，在调用练习2
def move_to_left():
    global list_merge
    for line in map:
        list_merge = line
        merge()

# move_to_left()
# print(map)



#4.定义函数，向右移动
#提示：将每行反向切片交给list_merge
def move_to_right():
    global list_merge
    for line in map:
        list_merge = line[::-1]
        merge()
        line[::-1] = list_merge

#5.定义函数，向上移动
#提示：方阵转置，向左移动,调用练习3
def transposition_matrix(list):
    for i in range(len(list)):
        for j in range(i + 1, len(list[i])):
            list[i][j], list[j][i] = list[j][i], list[i][j]
def move_to_up():
    transposition_matrix(map)
    move_to_left()
    transposition_matrix(map)

# move_to_up()
# print(map)

#6.定义函数，向下移动
#提示：方阵转置，向右移动,调用练习4
def move_to_lower():
    transposition_matrix(map)
    move_to_right()
    transposition_matrix(map)
# move_to_lower()
# print(map)

下午的七个练习

"""
    定义函数，返回列表中不重复的元素(顺序不重要)。
    输入：[4,35,7,64,7,35]
    输出：[4, 35, 7, 64]
"""
def get_not_repeating(target):
    """
     获取不重复的元素
    :param target: list类型，表示具有重复元素的数据
    :return:
    """
    # return list(set(target))
    return list(dict().fromkeys(target).keys())

list01 = [4, 35, 7, 64, 7, 35]
print(get_not_repeating(list01))

"""
    定义函数，判断二维数字列表中是否存在某个数字
    输入：二维列表、11
    输出：True
"""
list01 = [
    [1, 2, 3, 4],
    [5, 6, 7, 8],
    [9, 10, 11, 12],
    [13, 14, 15, 16],
]
def is_exists(double_list, target):
    """
        判断二维列表中是否存在指定元素
    :param double_list:list类型，表示二维列表
    :param target:需要判断的元素
    :return:bool类型，是否存在。
    """
    for line in double_list:
        if target in line:
            return True
    return False

print(is_exists(list01, 18))

"""
    定义函数，返回字符串中第一个不重复的字符。
    输入：ABCACDBEFD
    输出：E
"""


def get_repeating_info(target):
    dict_repeat_info = {}
    for char in target:
        dict_repeat_info[char] = target.count(char)
    # if char not in dict_repeat_info:
    #     dict_repeat_info[char] = 1
    # else:
    #     dict_repeat_info[char] += 1
    return dict_repeat_info

def get_key_for_value(target, value):
    for k, v in target.items():
        if v == value:
            return k
            
def first_not_repeating_char(target):
    dict_info = get_repeating_info(target)
    return get_key_for_value(dict_info, 1)

print(first_not_repeating_char("ABCACDBEFD"))

"""
    质数：大于1的整数，除了1和它本身以外不能再被其他数字整除。
    定义函数，获取指定范围内的所有质数。
    输入：2,20
    输出：[2, 3, 5, 7, 11, 13, 17, 19]
"""
def is_prime(number):
    for item in range(2, number):
        if number % item == 0:
            return False
    return True

def get_prime(begin, end):
    # list_result = []
    # for num in range(begin, end):
    #     if is_prime(num):
    #         list_result.append(num)
    # return list_result
    return [num for num in range(begin, end+1) if is_prime(num)]

print(get_prime(2,20))

"""
    创建函数，生成指定行数的杨辉三角。
    杨辉三角：
    每行端点与结尾的数为1，每个数是它左上方和右上方的数的和
    输入：6
    输出：
         [
                    [1],
                   [1, 1],
                  [1, 2, 1],
                 [1, 3, 3, 1],
               [1, 4, 6, 4, 1],
             [1, 5, 10, 10, 5, 1]
         ]
"""

def get_yang_hui_triangle(row_count):# 6
    """
        获取杨辉三角
    :param row_count: int类型,行数
    :return: list类型，杨辉三角
    """
    triangle = []
    for row_index in range(row_count):# 0 1 2 3 .. 5
        # 创建行
        row = [None] * (row_index + 1)
        # 设置首尾
        row[0], row[-1] = 1, 1
        # 设置中间(从第三行开始)
        for i in range(1, row_index):#1
            # 当前元素 = 上一行
            row[i] = triangle[row_index - 1][i - 1] + triangle[row_index - 1][i]
        triangle.append(row)
    return triangle

print(get_yang_hui_triangle(6))

"""
    "水仙花数":各位数字的位数和次方（1001就是1的4次方加0的4次方再乘以2）等于该数本身
    定义函数，根据位数计算水仙花数
    输入：3
    输出：[153, 370, 371, 407]
"""

def is_daffodil(number):
    """
        判断指定数字是否为水仙花数
    :param number: int 类型，表示需要判断的数字
    :return: bool 类型，表示是否为水仙花数。
    """
    str_number = str(number)
    power = len(str_number)
    sum_value = 0
    for item in str_number:
        sum_value += int(item) ** power
    return sum_value == number

def get_daffodil(n):
    """
        获取指定位数的水仙花数
    :param n:int类型，表示整数位数。
    :return:列表类型，水仙花数。
    """
    # list_list = []
    # for i in range(10 ** (n - 1), 10 ** n):
    #     if is_daffodil(i):
    #         list_list.append(i)
    # return list_list
    return [num for num in range(10 ** (n - 1), 10 ** n) if is_daffodil(num)]

print(get_daffodil(3))

"""
    二分查找
    定义函数，在有序数字列表中找到目标值，并返回其索引。
    如果目标值不在列表中，返回它可以按顺序插入的索引。
    输入：[1,2,6,8,9]  8
    输出：3
    输入：[1,2,6,8,9]  5
    输出：2
"""
def search_insert_index(list_number, target):
    left = 0
    right = len(list_number) - 1
    while left <= right:
        mid = (left + right) // 2
        if list_number[mid] == target:
            return mid
        elif list_number[mid] < target:
            left = mid + 1
        else:
            right = mid - 1
    return left

print(search_insert_index([1, 2, 6, 8, 9], 5))

昨天的复习

函数
内存图
参数
实际参数
位置实参:函数名称(数据1,数据2)
实参 -位置-> 形参
序列实参:函数名称(*序列) [拆]
关键字实参:函数名称(形参名1=数据1,形参名2=数据2)
实参 -名称-> 形参
优势:代码可读性高
配合默认参数可以随意传餐
字典实参:函数名称(**字典) [拆]
形式参数
默认参数:def 函数名称(形参名1=默认值,形参名2=默认值)
位置形参:必须传递
星号元组形参:def 函数名称(*args) [合]
位置实参数量无限
命名关键字形参:实参必须是关键字实参
def 函数名称(args,a,b)
def 函数名称(a,,b = “”,c = “”)
双星号字典形参:def 函数名称(**kwargs) [合]
关键字实参数量无限
传入可变对象+修改可变对象 --> 无需return返回结果