python每日经典算法题5(基础题)+1(中难题)

　　现在，越来越多的公司面试以及考验面试对算法要求都提高了一个层次，从现在，我讲每日抽出时间进行5+1算法题讲解，5是指基础题，1是指1道中等偏难。希望能够让大家熟练掌握python的语法结构已经一些高级函数的应用。这些题目是在某些刷题的网站上登记的有水平的题目。这里如果有需要input的简单题，就略去了输出结果。如果时间充裕，则就会增加每日更多习题。

一：基础算法题5道

1.判断用户输入的年份是否为闰年

题目解析:

(1)问题分析：能被4整除但不能被100整除的年份为普通闰年，能被400整除的年份为世纪闰年，判断是否满足上述情况。

(2)算法分析：输入一个数，先判断如果是400的倍数，则满足；如果不是400的倍数，再判断如果该数能够被4整除，却不能被100整除，则满足。

(3)用到的python语法：input()标准输入函数，if判断语句，or，and逻辑运算符。

(4)博主答题代码：

n = int(input('请输入年份:'))
if n % 400 == 0 or n % 4 == 0 and n % 100 != 0:
    print('{0}是闰年'.format(n))
else:
     print('{0}不是闰年'.format(n))

(5)高效方法：
python 的 calendar 库中已经封装好了一个方法 isleap() 来实现这个判断是否为闰年：

import calendar

n = int(input("请输入年份："))
year = calendar.isleap(n)
if year == True:
    print ("{0}是闰年".format(n))
else:
    print ("{0}不是闰年".format(n))

2.判断一个数是否是质数

题目解析:

(1)问题分析：除了1和它本身以外不再有其他的因数的数就是质数。

(2)算法分析：输入一个数，如果该数大于1，则从2开始循环到该数并一一整除该数，如果余数为0，则该数不是质数；否则该数是质数。

(3)用到的python语法：input()标准输入函数，for循环，if判断语句。

(4)博主答题代码：

n = int(input(''))
if n > 1:
    for i in range(2,n):
        if n % i == 0:
            print('{0}不是质数'.format(n))
            print('{n}={a}*{b}'.format(n=n,a=i,b=int(n/i)))    # 这里也可为b=n//i
            break
        else:
            print('{0}是质数'.format(n))
            break

这时如果想把非质数的所有非1与自己的因数输出，则可以改为如下代码：

n = int(input(''))
if n > 1:
    m1 = 0;m2 = 0
    for i in range(2,n):
        if n % i == 0:
            str = '{0}不是质数'.format(n)
            print('{n}={a}*{b}'.format(n=n,a=i,b=int(n/i)))    # 这里也可为b=n//i
            m1 = 1;m2 = 1
        elif m1==0:
            print('{0}是质数'.format(n))
            break
    if [m1,m2].count(1) == 2:
        print('{0}不是质数'.format(n))

(5)高效方法：

num = int(input(""))
i = 2
while i < num:
    s = num % i
    if s == 0:
        break
    else:
        i += 1
if num == i:
    print("{0}是质数".format(num))
else:
    print("{0}不是质数".format(num))

3.输出指定范围内的素数

(1)题目分析：素数就是质，上一题已经介绍了如何求质数，这里我们需要加一个范围。
(2)算法分析：把上一题判断的内容放在一个for循环选择范围里进行分析。

(3)用到的python语法：input()标准输入函数，map函数，for循环，if判断语句。
(4)博主答题代码：

my_index1,my_index2 = map(int,input('请选择一个范围:').split(','))
result = []

for num in range(my_index1,my_index2+1):
    if num > 1:
        for i in range(2,num):
            if (num % i) == 0:
                break
        else:
            result.append(num)
print('{a}到{b}所有的质数有:{c}'.format(a = my_index1,b = my_index2,c = result))

这里的if和else是就近匹配，和上面的不同，这就避免了重复，这是要注意的一点。

展示这是最简单的方法，如果大家有好的方法，请评论。

4.约瑟夫生者死者小游戏

30 个人在一条船上，超载，需要 15 人下船。

于是人们排成一队，排队的位置即为他们的编号。

报数，从 1 开始，数到 9 的人下船。

如此循环，直到船上仅剩 15 人为止，问都有哪些编号的人下船了呢？

这一题可以扩展为：

m个人在一条船上，超载，需要n人下船。

于是人们排成一队，排队的位置即为他们的编号。

报数，从 1 开始，数到 k 的人下船。

如此循环，直到船上仅剩 m - n人为止，问都有哪些编号的人下船了呢？

(1)题目分析：

(2)算法分析：这里设置编号从1开始，先给出从1到m的所有编号，用一个列表表示，需要n个人下船，则船上就生了m-n个人。以此循环递归，其实也可以转化为递归问题。但这里每次递归，当找到数到编号k，就把编号k所在的序号，就是编号删除。这里可以设置一个外部变量，从第一个编号index开始，当index=k时，把编号重新置为1，每次都这样，直到循环完毕，直到所有最后剩余元素个数为m-n。

(3)用到的python语法：for循环，函数，列表操作，列表切片。

(4)博主答题代码：

def yueSeFu(m,n,k):
    serial_num = list(range(1,m +1))    # 创建从1到m的序号
    index = 0                            # 设置外部变量index
    while len(serial_num) > m - n:        # 当最后剩余人数为m - n之前，一直进行下面的程序
        for i in serial_num:            # 遍历每个编号
            index += 1                     # 把外部变量index进行真实遍历
            if index == k:                # 当外部变量index找到k时，进行下面代码块的操作
                serial_num.remove(i)    # 移除需要下船的人的编号
                index = 1                # 这时候index已经找到序号k了，就要重新遍历
                print('{0}号人下船了'.format(i))

if __name__ == '__main__':
    # 传入起始人数m，需要下船的人数n，数到多少下船的序号k,这里可自行设置
    yueSeFu(30,15,9)

(5)高效方法：

def yueSeFu(m,n,k):
    people = list(range(1, m+1))
    i = 0
    while len(people) > m - n:
        i += (k - 1)
        if i >= len(people):
            i -= len(people)
        print("{}号下船了".format(people[i]))
        del people[i]

if __name__ == '__main__':
    # 传入起始人数m，需要下船的人数n，数到多少下船的序号k
    yueSeFu(30,15,9)

5.二分查找，返回某个值在数组中的索引

(1)题目分析：二分搜索是一种在有序数组中查找某一特定元素的搜索算法。从数组的中间元素开始，正好是要查找的元素，则搜索过程结束；如果某一特定元素大于或者小于中间元素，则在数组大于或小于中间元素的那一半中查找，而且跟开始一样从中间元素开始比较。如果在某一步骤数组为空，则代表找不到。这种搜索算法每一次比较都使搜索范围缩小一半。

(2)算法分析：这里重复查找需要用到递归，用到一个一维数组，先判断数组查找的元素末尾下标是否大于等于1。如果是的话，就要先找到中间位置，如果大于中间位置，就只比较左边的元素重新递归；如果小于中间位置，则比较右边的元素重新递归。找不到就返回-1。
(3)用到的python语法：if判断语句，函数，递归算法。

(4)博主答题代码：

def twoSearch(x,arr,begin,end):    # x为要查询的元素,arr为数组,begin和and是每次查找的范围
    if end >= 1:
        mid = int(begin + (end-1)/2)    # 每次范围的元素中间位置
        if int(arr[mid]) == x:
            return mid
        elif int(arr[mid]) > x:        # 元素小于中间的元素，需要比较左边的元素
            return twoSearch(x,arr,begin,end - 1)
        else:                    # 元素大于中间的元素，需要比较右边的元素
            return twoSearch(x,arr,begin + 1,end)
    else:
        return -1

if __name__ == '__main__':
    my_arr = list(map(int,input('请输入数组:').split(',')))    # 返回可迭代对象
    my_x = int(input('请输入要查找的元素:'))
    result = twoSearch(my_x, my_arr, 0, len(my_arr) - 1)
    if result != -1:
        print('元素在数组中的索引为:{0}'.format(result))
    else:
        print('元素不在数组中')

二：中等算法题1道

1.两数之和

给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。

示例:

给定 nums = [2, 7, 11, 15], target = 9

因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

(1)算法解析：我们给出一个列表，进行两次循环，就可以得到结果。
(2)博主代码：

def twoSum(nums, target):
    for index1,i in enumerate(nums):
        for index2,j in enumerate(nums):
            if i+j == target and i != j:
                return index1,index2

a = list(map(int,input().split(',')))
b = int(input())
print(list(twoSum(a,b)))

主要代码为：

for index1,i in enumerate(nums):
        for index2,j in enumerate(nums):
            if i+j == target and i != j:
                return index1,index2

(3)代码问题

　　但是在运行很多个数字的列表中，需要两次循环遍历列表，如果列表的长度为n，则时间复杂度为O(n)，时间执行效率太差，最差为O(n^2)，故上面的代码实际上是不太可取的。

(4)高级算法

下面有一些改进的高级一点的算法：

列表生成式三行代码搞定：

for i in range(len(nums)):    # 循环遍历列表
        # 这里是用和减去列表中的某一元素，并且两个元素下标不同，就返回两个下标
        if(target-nums[i] in nums and i != nums.index(target-nums[i])):
                return [i,nums.index(target-nums[i])]

执行用时 :1284ms，内存消耗 :14.7MB左右，比上面的代码节省了一层循环遍历的过程。

字典查找，利用哈希表，不用遍历：

my_dict = {}                        # 创建一个字典
    for index, num1 in enumerate(nums):    # 利用函数enumerate输出列表或数组的下标和元素
        num2 = target - num1            # 另一个元素
        # 这里是判断，如果字典中有另一个元素值的话，返回下标，以及该元素下标
        # 这里由于字典是键值对，就避免了两个元素和符合，单元素是同一个元素的情况
        if num2 in my_dict:
            return [my_dict[num2], index]
        # 把字典中的元素对应于键
        my_dict[num1] = index
    return -1

执行用时 :68ms，内存消耗 :15 MB左右，时间效率更高。

利用集合进行操作，效率和字典差不多：

my_set = set(nums)
    for i, v in enumerate(nums):
        if (target - v) in my_set and i != nums.index(target - v):
            return [i, nums.index(target - v)]

执行用时 :80ms，内存消耗 :15 .2MB左右。

总结：

　　1.用python字典或集合的效率要高很多，不建议常用列表。

　　2.生成一个整数序列可以先生成一个可迭代对象

　　　　比如生成一个只有整数的可迭代对象：

　　　　map(int,input('请选择一个范围:').split(','))

　　3.calendar.isleap(n可以判断是否为闰年。

　　4.列表生成式常用可以减少代码量，当然是有必要用列表的时候。

　　5.enumerate对既需要元素和下标值的序列很有用。