6.
约瑟夫环问题：已知n个人（以编号1，2，3...n分别表示）围坐在一张圆桌周围。从编号为k的人开始报数，数到k的那个人被杀掉；他的下一个人又从1开始报数，数到k的那个人又被杀掉；依此规律重复下去，直到圆桌周围的人只剩最后一个。
def get_live(lens=10, k=1):
"""k is step"""
flag = 0
if k == 1:
return lens
else:
people = [ x for x in range(1, (lens + 1 )) ]
print(people)
while True:
if flag == 0:
mod = k % lens #deal with step > len(people)
flag = k
#print(people)
if mod == 0:
mod = lens
people.pop(mod-1)
lens = lens -1
if lens == 0:
break
flag = (flag + k - 1 ) % lens
mod = flag
print(people)
5. 生成140个随机数，在1到100范围内，然后统计重复的数字：
1 def gen_random_numbers(min=0, max=100, numbers=40):
2 """随机生成N个随机数"""
3 i = 0
4 li_random = []
5 li = [ random.randint(min,max) for x in range(0, numbers)]
6 return li
7
8 def get_de(l):
9 """显示l里面重复过的元素"""
10 set_ = set()
11 for i in l:
12 temp = l.pop(l.index(i))
13 if temp in l:
14 set_.add(temp)
15 return set_
16
17 def get_repeat(list_count):
18 """获取list里面重复的元素和次数"""
19 set_nums = set(list_count)
20 print('!',set_nums)
21 dict_re = {}
22 for i in set_nums:
23 count = list_count.count(i)
24 print('count {} > {}'.format(i,count))
25 if count >1:
26 dict_re[i] = count
27 return dict_re
28
29 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))
