python-简单的算法题

一、冒泡排序

'''

冒泡算法

冒泡排序原理就是循环遍历数组，比较相邻两个数的大小，重复比较直到排序完成

N个数字要排序完成，总共要进行N-1趟排序，第i趟的排序次数为(N-i) 次

'''

def bubbleSort(arr):
    n = len(arr)
    # 遍历所有元组元素
    for i in range(n):
        # 每一趟循环最后一位数都会确定，所以需要去掉最后一个数
        for j in range(0,n-i-1):
            if arr[j] > arr[j+1]:     # 升序大于号，降序小于号
                arr[j],arr[j+1] = arr[j+1],arr[j]
    return arr

arr = [23,10,32,67,43,52]
bubbleSort(arr)
print("排序后的数组为：")
for i in range(len(arr)):
    print("%d"%arr[i])

二、字符串和列表排序

'''
编写一个函数，实现对字符串的排序
大多数排序操作是针对列表的，所以需要先将字符串转换成列表，进行排序，然后再合并成字符串
运用list的sort()函数，sort()函数对原列表进行排序，没有返回值
或者通过sorted()函数，sorted()函数对列表可迭代的对象进行排序操作，返回一个新的list
sort 缺省为升序，降序排列增加reverse=True参数
'''

# 方法一  sort()
def  sort(s):
    ls = list(s)
    ls.sort()
    s1 = "".join(ls)
    return  s1

s = "3649208"
print(sort(s))


# 方法二 sorted()
def sort(s):
    ls = sorted(s)
    s1 = "".join(ls)
    return s1

s = "345110"
print(sort(s))

三、字符串反转

'''
实现输入一个字符串，并将该字符串反转输出
方法一：字符串切片 a[i:j:s] 当s<0时，i缺省时，默认为-1；j缺省时，默认为-len(a) -1
a[::-1] 相当于a[-1:-len(a)-1:-1]，也就是从最后一个元素到第一个元素复制一遍，即倒序
方法二：将字符串转换为列表，用列表的reverse()方法
'''

# 方法一  字符串切片法
a  = input("please input str:")
print(a[::-1])


# 方法二 转换成列表，用列表的reverse()方法
a = input("please input str:")
l = list(a)
l.reverse()
print("".join(l))

四、字符串计数

'''

列出1-1000中包含1的数字

'''

for i in range(1001):
    if str(i).find("1") == 0:
        print(i)

 

'''
生成包含1000个0-100之间的随机整数，并统计每个元素出现的次数
'''

import random
ls = [random.randint(0,100) for i in range(1000)]
st = set(ls)    # set()函数创建一个无序不重复元素集
for i in st:
    print(i, "出现的次数：", ls.count(i))

 

'''
统计字符串中各字符的个数
'''

str = input("请输出字符串：")
dt = {}
for i in str:
    dt[i] = str.count(i)
print(dt)

 五、列表左移、右移

'''
列表左移
运用列表的A.pop()方法，去除最后一位并返回值，将最后一位插入到第一位
'''

A = [12,34,56,23,10]
a = 2
for i in range(a):
    A.insert(0,A.pop())
print(A)

'''
列表右移
将第一个元素插到最后一位（len(A)）,再去除第一个元素
'''

A = [12,34,56,23,10]
a = 2
for i in range(a):
    A.insert(len(A),A[0])
    A.remove(A[0])
print(A)

 六、约瑟夫环

'''
问题描述:N个人围成一圈，从第一个人开始报数，报到k的人出圈，剩下的人继续从1开始报数，报到k的人出圈；如此往复，直到所有人出圈。（模拟此过程，输出出圈的人的序号）
解决方案:这道题涉及到的算法叫做约瑟夫算法，需要将列表内所有数类似排列成一个圈来解决，需要将前一次删除后剩下的元素的索引不变，但是位置镶嵌提，无限循环这个圈，直到删除到只剩一个
这道题的关键在于如何将每个数的索引数字固定，在删除前一个数字后，后面的数字都应该在排序中加一。所以我们需要创建一个列表，从1开始含有位数的数字，代表每个数字的索引列表
'''

def josephus(n,k):
    # n代表总人数，K代表报数的数字
    List = list(range(1,n+1))
    index = 0
    while List:
        temp = List.pop(0)
        index += 1
        if index == k:
            index = 0
            continue
        List.append(temp)
        if len(List) == 1:
            print(List)
            break
if __name__ == '__main__':
    josephus(10,3)