work1

1.已知一个数字列表，求列表中心元素。

def get_mid(list1):
    """已知一个数字列表，求列表中心元素"""
    list_len = len(list1)
    if list_len & 1:
        return list1[list_len // 2]
    else:
        return list1[list_len // 2 - 1], list1[list_len // 2]

2.已知一个数字列表，求所有元素和。

def get_list_sum(list1):
    """已知一个数字列表，求所有元素和。"""
    sum1 = 0
    for num in list1:
        sum1 += num
    return sum1

3.已知一个数字列表，输出所有奇数下标元素。

def get_index_odd(list1):
    """已知一个数字列表，输出所有奇数下标元素。"""
    # return [list1[i] for i in range(len(list1)) if i & 1]
    # return list(list1[i] for i in range(1, len(list1), 2))
    # return list1[1::2]
    for i in range(len(list1)):
        if i & 1:
            print(list1[i], end=" ")

4.已知一个数字列表，输出所有元素中，值为奇数的元素。

def get_value_odd(list1):
    """已知一个数字列表，输出所有元素中，值为奇数的元素。"""
    # return [n for n in list1 if n & 1]
    for num in list1:
        if num & 1:
            print(num, end=" ")

5.已知一个数字列表，将所有元素乘二。

例如：nums = [1, 2, 3, 4] —> nums = [2, 4, 6, 8]

def set_value_double(list1):
    """已知一个数字列表，将所有元素乘二。"""
    # return [n * 2 for n in list1]
    for i in range(len(list1)):
        list1[i] *= 2
    return list1

6.有一个长度是10的列表，数组内有10个人名，要求去掉重复的

例如:names = ['张三', '李四', '大黄', '张三'] -> names = ['张三', '李四', '大黄']

def del_duplicate(list1):
    """有一个长度是10的列表，数组内有10个人名，要求去掉重复的"""
    names_dict = {}
    for name in list1[:]:
        if name not in names_dict:
            names_dict[name] = True
        else:
            list1.remove(name)
    return list1

    # i = 0
    # while i < len(list1):
    #   if list1[i] not in names:
    #       names[list1[i]] = True
    #   else:
    #       list1.pop(i)
    #       i -= 1
    #   i += 1
    # return list1


# 解2
def del_duplicate2(list1):
    new_list = list(dedupe(list1))
    return new_list


def dedupe(items, key=None):
    seen = set()
    for item in items:
        val = item if key is None else key(item)
        if val not in seen:
            yield item
            seen.add(val)

7.已经一个数字列表(数字大小在0~6535之间), 将列表转换成数字对应的字符列表

例如: list1 = [97, 98, 99] -> list1 = ['a', 'b', 'c']

def int_to_char(list1):
    """已经一个数字列表(数字大小在0~6535之间), 将列表转换成数字对应的字符列表"""
    for i in range(len(list1)):
        list1[i] = chr(list1[i])
    return list1

8.用一个列表来保存一个节目的所有分数，求平均分数(去掉一个最高分，去掉一个最低分，求最后得分)

def get_avg(list1):
    """用一个列表来保存一个节目的所有分数，求平均分数(去掉一个最高分，去掉一个最低分，求最后得分)"""
    list1.sort()
    sum1 = 0
    # first, *new_list, last = list1
    new_list = list1[1:len(list1) - 1]
    for num in new_list:
        sum1 += num
    return sum1 / len(new_list)

9.有两个列表A和B，使用列表C来获取两个列表中公共的元素

例如: A = [1, 'a', 4, 90] B = ['a', 8, 'j', 1] --> C = [1, 'a']

def public_elements(list1, list2):
    """有两个列表A和B，使用列表C来获取两个列表中公共的元素"""
    # 解1
    # return set(list1) & set(list2)

    # 解2
    pub_elements = {}
    new_list = []
    for num in list1:
        if num not in pub_elements:
            pub_elements[num] = True

    for num in list2:
        if num in pub_elements:
            new_list.append(num)
    return new_list

10.有一个数字列表，获取这个列表中的最大值.(注意: 不能使用max函数)

例如: nums = [19, 89, 90, 600, 1] —> 600

def get_max(list1):
    """有一个数字列表，获取这个列表中的最大值.(注意: 不能使用max函数)"""
    # import heapq
    # return heapq.nlargest(1, list1)
    max_num = list1[0]
    for num in list1[1:]:
        if max_num < num:
            max_num = num
    return max_num

11.获取列表中出现次数最多的元素

例如：nums = [1, 2, 3,1,4,2,1,3,7,3,3] —> 打印:3

def appear_most(list1):
    """获取列表中出现次数最多的元素"""
    # 1.
    # from collections import defaultdict
    # num_times = defaultdict(int)
    # for num in list1:
    #   num_times[num] += 1

    # 2.
    num_times = {}
    for num in list1:
        if num not in num_times:
            num_times[num] = 1
        else:
            num_times[num] += 1
    # print(max(zip(num_times.values(), num_times.keys())))
    return max(num_times, key=num_times.get)

work2

1.一张纸的厚度大约是0.08mm，对折多少次之后能达到珠穆朗玛峰的高度（8848.13米）？

def fold_paper():
    """一张纸的厚度大约是0.08mm，对折多少次之后能达到珠穆朗玛峰的高度（8848.13米）？"""
    paper_h = 8 * 10 ** -5
    count = 0
    while True:
        paper_h *= 2
        count += 1
        if paper_h > 8848.13:
            return count

2. 古典问题：有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问每个月的兔子总数为多少？

def count_rabbits(n):
    """古典问题：有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，
    假如兔子都不死，问每个月的兔子总数为多少？1,1,2,3,5,8,13,21"""
    if n < 3:
        return 1
    else:
        return count_rabbits(n - 2) + count_rabbits(n - 1)

3. 将一个正整数分解质因数。例如:输入90,打印出90=2x3x3x5。

def get_prime_factor(num):
    """将一个正整数分解质因数"""
    primes = []
    get_factor(num, primes)
    result = str(num) + "="
    for prime in primes:
        result += str(prime) + 'x'
    result = result[:len(result) - 1]
    print(result)
    return primes


def get_factor(num, primes_list):
    """获得质因数"""
    is_prime = True
    i = 2
    while i <= int(num ** 0.5) + 1:
        if not num % i:
            primes_list.append(i)
            is_prime = False
            get_factor(num // i, primes_list)
            break
        i += 1
    if is_prime:
        primes_list.append(num)

4. 输入两个正整数m和n，求其最大公约数和最小公倍数。 程序分析：利用辗除法。

def get_gcd_and_lcm(m, n):
    """输入两个正整数m和n，求其最大公约数和最小公倍数"""
    # 保证m为较大值
    if m < n:
        m, n = n, m
    # 欧几里得算法获得最大公约数
    tmp_m, tmp_n = m, n
    while True:
        gcd = tmp_m % tmp_n
        if not gcd:
            gcd = tmp_n
            break
        tmp_m = tmp_n
        tmp_n = gcd

    # 获得最小公倍数
    lcm = m * n // gcd
    return gcd, lcm

5. 一个数如果恰好等于它的因子之和，这个数就称为 "完数 "。例如6=1＋2＋3. 编程 找出1000以内的所有完数

def get_perfect_nums(n):
    """一个数如果恰好等于它的因子之和，这个数就称为 "完数 "。 编程 找出1000以内的所有完数"""
    nums = []
    for num in range(1, n + 1):
        count = 0
        for i in range(1, num):
            if not num % i:
                count += i
        if count == num:
            nums.append(num)
    return nums

6.输入某年某月某日，判断这一天是这一年的第几天？ 程序分析：以3月5日为例，应该先把前两个月的加起来，然后再加上5天即本年的第几天，特殊情况，闰年且输入月份大于3时需考虑多加一天。

def get_day_of_year(date):
    """输入某年某月某日，判断这一天是这一年的第几天？"""
    year, month = date.split('年')
    month, day = month.split('月')
    day = day.split('日')[0]
    year, month, day = int(year), int(month), int(day)
    if month == 1:
        return day

    for m in range(1, month + 1):
        if m - 1 == 2:
            if (year % 4 == 0 and year % 100 != 0) or year % 400 == 0:
                day += 29
            else:
                day += 28
        elif m - 1 in (1, 3, 5, 7, 8, 10):
            day += 31
        elif m - 1 in (4, 6, 9, 11):
            day += 30
    return day

7. 某个公司采用公用电话传递数据，数据是四位的整数，在传递过程中是加密的，加密规则如下：每位数字都加上5,然后用和除以10的余数代替该数字，再将第一位和第四位交换，第二位和第三位交换。求输入的四位整数加密后的值

def get_pwd(num):
    """某个公司采用公用电话传递数据，数据是四位的整数，在传递过程中是加密的,
    加密规则如下：每位数字都加上5,然后用和除以10的余数代替该数字，再将第一位和第四位交换，
    第二位和第三位交换。求输入的四位整数加密后的值"""
    # 1234
    num_list = []
    while True:
        num_list.append((num % 10 + 5) % 10)
        num //= 10
        if not num:
            num_list = num_list[::-1]
            num_list[0], num_list[3] = num_list[3], num_list[0]
            num_list[1], num_list[2] = num_list[2], num_list[1]
            break
    for i in range(len(num_list)):
        num += num_list[i] * 10 ** (len(num_list) - 1 - i)
    return num

8. 获取第n个丑数。 什么是丑数: 因子只包含2，3，5的数

6 =1* 2*3 -> 丑数

2 = 1*2 -> 丑数

7 = 1*7 -> 不是丑数

1, 2, 3, 4, 5, 6, 8,9,10, 12 ….

def get_ugly_num(n):
    """获取第n个丑数。 什么是丑数: 因子只包含2，3，5的数"""
    if n <= 0:
        return 0
    if n == 1:
        return 1
    # 存储丑数的列表
    numbers = [1]
    i_2, i_3, i_5 = 0, 0, 0
    ugly_num = 0
    # 找第n个丑数
    for _ in range(n - 1):
        # n_2, n_3, n_5的所有值均含有因子2或3或5，所以均为丑数
        n_2, n_3, n_5 = numbers[i_2] * 2, numbers[i_3] * 3, numbers[i_5] * 5
        # 因需按序输出，优先输出n_2, n_3, n_5中的最小值
        ugly_num = min(n_2, n_3, n_5)
        # 将本次循环的丑数加入列表
        numbers.append(ugly_num)
        # 本次丑数的因子系数加1
        i_2 += (ugly_num == n_2)
        i_3 += (ugly_num == n_3)
        i_5 += (ugly_num == n_5)
    return ugly_num