6.
约瑟夫环问题：已知n个人（以编号1，2，3...n分别表示）围坐在一张圆桌周围。从编号为k的人开始报数，数到k的那个人被杀掉；他的下一个人又从1开始报数，数到k的那个人又被杀掉；依此规律重复下去，直到圆桌周围的人只剩最后一个。
def get_live(lens=, k=):
"""k is step"""
flag =
if k == :
return lens
else:
people = [ x for x in range(, (lens + )) ]
print(people)
while True:
if flag == :
mod = k % lens #deal with step > len(people)
flag = k
#print(people)
if mod == :
mod = lens
people.pop(mod-)
lens = lens -
if lens == :
break
flag = (flag + k - ) % lens mod = flag
print(people)
5. 生成140个随机数，在1到100范围内，然后统计重复的数字：
def gen_random_numbers(min=0, max=100, numbers=40):
"""随机生成N个随机数"""
i = 0
li_random = []
li = [ random.randint(min,max) for x in range(0, numbers)]
return li def get_de(l):
"""显示l里面重复过的元素"""
set_ = set()
for i in l:
temp = l.pop(l.index(i))
if temp in l:
set_.add(temp)
return set_ def get_repeat(list_count):
"""获取list里面重复的元素和次数"""
set_nums = set(list_count)
print('!',set_nums)
dict_re = {}
for i in set_nums:
count = list_count.count(i)
print('count {} > {}'.format(i,count))
if count >1:
dict_re[i] = count
return dict_re if __name__ == '__main__':
4. 快速排序：
一般选取low为第一次的基准值，先从右边往左边找，找到小于基准值的值，j停下，否则一直j -= 1, 然后从左往右找，找到大于基准值的值，i停下，此时交换i,j的位置的list中的值，然后继续寻找， 继续交换值，左边的都是比基准值小的，右边都是比基准值大的，知道当i==j值，交换基准值于list[i]的值，一轮查找结束/////////////第二轮的时候，基准值的左边和右边，分为两队，直接递归就行了，
def q_sort(listB, low, high):
i = low
j = high
if i> j:
return listB
pov = listB[low]
while i<j:
while i<j and listB[i] <= listB[j]:
j -= 1
while i<j and listB[i] <= listB[j]:
i += 1
if i<j:
listB[i], listB[j] = listB[j], listB[i]
elif i == j:
listB[low], listB[i] = listB[i], listB[low] q_sort(listB,low, i-1)
q_sort(listB,j+1,high)
return listB
3. 选择排序：
选择排序原理即：在选择排序中，不再只比较两个相邻的数据。因此需要记录下某一个数据的下标，进行选择排序就是把所有的数据扫描一遍，从中挑出（按从小到大排序）最小的一个数据，这个最小的数据和最左端下标为0的数据交换位置。之后再次扫描数据，从下标为1开始，还是挑出最小的然后和1号位置进行交换，这个过程一直持续到所有的数据都排定。而程序中需要有一个标识变量来标识每次挑出最小数据的下标。
选择排序减少了交换数值的次数，只记录下标，最后交换最小的下标。
选择排序改进了冒泡排序，将必要的交换次数从 O（N2）减少到 O（N）次。不幸的是比较次数仍然保持为 O（N2）。然而，选择排序仍然为大记录量的排序提出了一个非常重要的改进，因为这些大量的记录需要在内存中移动，这就使交换的时间和比较的时间相比起来，交换的时间更为重要
listA = [1123,11,3,1,222,33,76,1,12345] def select_sort(li):
for i in range(0, len(li)):
flag = i
for j in range(i+1, len(li)):
if li[i] > li[j]:
flag = j
li[i], li[flag] = li[flag], li[i] print(li) if __name__ == '__main__':
select_sort(listA)
2. 冒泡排序：
linum = [88,77,44,55,9,111,222,777,55,3,22] def bubu_order(unsorted):
for i in range(0, len(unsorted)):
for j in range(0, len(unsorted)-1):
if unsorted[j] > unsorted[j]:
unsorted[j],unsorted[j+1] = unsorted[j+1],unsorted[j]
return unsorted if __name__ == '__main__':
print(bubu_order(linum))
for i in list2:
i =33
//这样是不能修改list本身的~~~
//获取对应值的index:
listA.index('33')
//另外一种获取list序号的方法：
for i,j in enumerate(listA):
print(i,j)
//str转list
str1.split(）
//list转str
' '.join(listA)
1. 插入排序：
插入排序默认第一个为已经排好顺序的列表，后面的每一个都与之比较并排序，排好之后，所有的自然都已经排好， 第二种优化的算法，如果已经插入， 说明找对了位置，那么下面就break，如果不需要排序， 那么就说明已经是最大的了， 因为前面的已经排好了，排好之后，也不需要再排了，可以break了。
import time start = lambda : time.time()
list1 = [66,33,1,3,111,3,10,29,7,123,56,23] * 50 def busorted(unsorted):
l = len(unsorted)
for i in range(0,l):
key = unsorted[i]
for x in range(i,0,-1):
if unsorted[x] < unsorted[x-1]:
unsorted[x], unsorted[x-1] = unsorted[x-1], unsorted[x]
return unsorted def optimizesorted(unsorted):
l = len(unsorted)
for i in range(0,l):
key = unsorted[i]
for x in range(i,0,-1):
if unsorted[x] < unsorted[x-1]:
unsorted[x], unsorted[x-1] = unsorted[x-1], unsorted[x]
else :
break
return unsorted if __name__ == '__main__':
print(list1)
t1 = start()
print(busorted(list1))
t2 = start()
print('-----------Time is {}'.format(t2-t1))