python_case_2_30个人在一条穿上,超载,需要15人下船

• 约瑟夫生者死者小游戏。30人在一条船上，现在由于超载需要15人下船。给30人编号，从1开始报数，数到9的人下船，如此反复，直到15人全部下船。问有哪些编号的人下船了。

people = {}    # 集合
i=1    # 每人的编号
j=0    # 计数下船的人
check=0    # 当前1-9人的计数
 
for i in range(1,31):
    people[i] = 1    
 
while i<=31:
    if i == 31:
        i = 1
    elif j ==15:
        break
    else:
        if people[i] == 0:    # 过滤掉前面已经下船的人
            i += 1
        else:
            check += 1
            if check == 9:
                print("{}号下船了".format(i))
                j += 1
                people[i] == 0    # 标记此人已下船
                check = 0    # 重新计数1-9
            else:
                i += 1

•  五人分鱼。第一个人把鱼扔掉一条并且五等分，拿走自己的部分；第二个人把第一个人剩下的鱼扔掉一条并且五等分，拿走自己的部分...五个人都同样的操作，问至少有多少条鱼。

def main():
    fish = 1    # 当前fish的数量
    while True:
        total = fish    # for loop中会改变fish的数量，需要total变量记录同一loop中的fish的数量
        enough = True
        for i in range(5):
            if((total-1)%5 == 0):
                total = (total-1)//5*4  # 当前剩余fish的数量
            else:
                enough = False
                break        # 善用break以避免不必要的loop
        if enough:
            print("至少捕到了{}条鱼".format(fish))
            break   # 第一次满足条件
        fish += 1
 
if __name__ == "__main__":  # 只有当前文件单独执行时，执行此函数。作为模块被其他文件引用时，不执行。
    main()

• 秒表 

import time
 
print('按下回车开始计时，按下 Ctrl + C 停止计时。')
input("")
 
starttime=time.time()   # 当前时间戳
try:
    while True:
        print("计时",round(time.time()-starttime, 0),"秒",end="\r")     # round() 方法返回浮点数 x 的四舍五入值     # \r表示将光标的位置回退到本行的开头位置   
        time.sleep(1)       # 表示进程挂起的时间
except KeyboardInterrupt:   # Ctrl + C
    print("\n结束")
    print("共计",round(time.time()-starttime,2),"秒")

• 计算数组元素之和

def sumof_array(array):     # 封装成一个函数    # 内置函数sum()
    return sum(array)
 
array = {}      # 初始化数组
array = {1,2,3}
n=len(array)    # 计算数组的长度 len()
print(sumof_array(array),n)    

• 数组翻转指定个数的元素

def reverse_one(array,n):       # list的元素向前推一格
    temp=array[0]
    for k in range(n-1):
        array[k]=array[k+1]
    array[n-1]=temp
 
def reverse_d(array,d,n):   
    for j in range(d):      # 重复d次，list的元素向前推d格
        reverse_one(array,n)
 
def print_array(array,n):
    for i in range(n):
        print(array[i],end=" ")
 
array=[1,2,3,4,5,6,7]
reverse_d(array,2,7)
print_array(array,7)

def reverse_array(array,start,end):
    while(start<end):
        temp=array[start]
        array[start]=array[end]
        array[end]=temp
        start+=1
        end-=1
 
def reverse_d(array,d):
    n=len(array)
    reverse_array(array,0,d-1)
    reverse_array(array,d,n-1)
    reverse_array(array,0,n-1)
 
def print_array(array):
    for i in range(len(array)):   # 节省变量n的使用
        print(array[i],end=" ")
 
array=[1,2,3,4,5,6,7]
reverse_d(array,2)
print(array)

• 将列表中指定位置的元素对调

def reverse(array,i,j):
    array[i-1],array[j-1]=array[j-1],array[i-1]        # 对调两元素
    return array
 
array=[1,2,3,4,5,6,7]
print(reverse(array,1,3) )

def reverse(array,i,j):
    first=array.pop(i)          # 删除指定位置的元素
    second=array.pop=(j-1)
    array.insert(i,second)      # 在指定位置插入指定元素
    array.insert(j,first)
    return array
 
array=[1,2,3,4,5,6,7]
print(reverse(array,1,3) )

•  判断元素是否在列表中存在

list=[1,2,3,4,5,6,7]
print("判断4是否在list中.")
 
for i in len(list):         # 循环
    if i==4:    
        print("存在")
 
if 4 in list:           # in关键字
    print("存在")
 
if list.count(4)>0:         # count(). 返回子字符串在字符串中出现的次数   
    print("存在")
 
list_new=set(list)          # set()和in关键字. set()用于创建一个无序不重复元素集.
if 4 in list_new:
    print("存在")

• 清空列表

list=[1,2,3,4,5]
print(list)
list.clear()        # 清空列表
print(list)

• 复制列表

list=[1,2,3,4,5]
list_2=[]
list_2=list.copy()
list_2.extend(list)
print(list_2)

• 计算列表元素之积

from functools import reduce
# lamda函数，一个简单的函数，x y为输入参数，x*y为执行函数体并作为返回值
# reduce(function，literable list) 可对一整个数组进行同一种操作，例如相加、相减、相乘、相除
list=[1,2,3,4,5]
print(reduce(lambda x,y:x*y, list))

•   移除字符串中的指定字符

str="python3"
 
# 1st method
str_new=""
for i in range(len(str)):
    if i!=2:
        str_new=str_new+str[i]
print(str_new)
 
# 2nd method
# replace() 方法把字符串中的 old（旧字符串） 替换成 new(新字符串)，如果指定第三个参数max，则替换不超过 max 次。
str_new=str.replace(str[2],"",1)
print(str_new)

•  判断字符串中是否包含子字符串

str="hello world"
substr="world"
 
# 1st method
def sub_exist(str,substr):
    if substr in str:           # in关键字
        print("存在")
    else:
        print("不存在")
sub_exist(str,substr)
 
# 2nd method
# find() 方法检测字符串中是否包含子字符串。如果指定 beg（开始） 和 end（结束） 范围，则检查是否包含在指定范围内，如果指定范围内如果包含指定索引值，返回的是索引值在字符串中的起始位置。如果不包含索引值，返回-1。
if str.find(substr)==-1:
    print("不存在")
else:
    print("存在")

• 将字符串作为代码执行

def exec_code():
    LOC="""
def factorial(num):
    fact=1
    for i in range(1, num+1):
        fact=fact*i
    return fact 
print(factorial(5))
"""
    exec(LOC)       # exec 执行储存在字符串或文件中的 Python 语句.
 
exec_code()

• 字符串翻转

str="python3"
 
print(str[::-1])
# 内置函数，reversed 函数返回一个反转的迭代器。
# join() 方法用于将序列中的元素以指定的字符连接生成一个新的字符串
print("".join(reversed(str))) 

from functools import reduce
 
str="python3"
print(reduce(lambda x,y:y+x,str))

• 对字符串进行切片和翻转

def rotate(str,d):
    Lfirst=str[0:d]
    Lsecond=str[d:len(str)]
    Rfirst=str[0:len(str)-d]
    Rsecond=str[len(str)-d:len(str)]
    print("前2的翻转结果是："+ Lsecond + Lfirst)
    print("后2的翻转结果是："+ Rsecond + Rfirst)
 
str="python3"
d=2
# 取前2和后2翻转
rotate(str,d)

• 按key或者value对字典进行排序

def dictionary():
    dic={}
    dic[1]=9
    dic[2]=77
    dic[3]=56
    dic[4]=38
    dic[5]=67
    dic[6]=5
 
    # 字典(Dictionary) items() 函数以列表返回可遍历的(键, 值) 元组数组。
    # sorted() 函数对所有可迭代的对象进行排序操作。sorted(iterable, cmp=None, key=None, reverse=False). key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
    print(sorted(dic.items(),key=lambda x:x[0]))    # 以key升序排列
    print(sorted(dic.items(),key=lambda x:x[1]))       # 以value升序排列
    print(sorted(dic.items(),key=lambda x:(x[0],x[1])))     # 先以key升序排列，再以value升序排列
 
def main():
    dictionary()
 
if __name__=="__main__":
    main()

• 字典中的值之和

def dictionary(dic):
    sum=0
    for i in dic:
        sum+=dic[i]
    print(sum)
 
dic={"a":9,"b":7,"c":5,"d":3,"e":6,"f":5}
dictionary(dic)

•  移除字典中的键值对

dic={"a":9,"b":7,"c":5,"d":3,"e":6,"f":5}
 
print("原始字典："+str(dic))
 
removed_1=dic.pop("a")
print(removed_1)
removed_2=dic.pop("g","该键值不存在.")        # 字典 pop() 方法删除字典给定键 key 及对应的值，返回值为被删除的值。key 值必须给出。 否则，返回 default 值。
print(removed_2)
del dic["b"]            # 删除
# del dic["g"]        # 不能移除一个不存在的key
print("变化后的字典：" +str(dic))

• 合并两个字典

dic_1={"a":1,"b":2}
dic_2={"c":3,"d":4}
 
dic_2.update(dic_1)         # 字典 update() 函数把字典参数 dict1 的 key/value(键/值) 对更新到字典 dict2 里。
print(dic_2)
print({**dic_1,**dic_2})        # *args 和 **kwargs 都代表 1个 或 多个 参数的意思。*args 传入tuple 类型的无名参数，而 **kwargs 传入的参数是 dict 类型。

•