python实现简单算法

#冒泡排序
for i in range(len(n)):  # 0 6
    for ii in range(i+1,len(n)):
        if n[i]>n[ii]:
            t = n[ii]
            n[ii] = n[i]
            n[i] = t
            
print(n)





#插入排序
new_n = []
for i in range(len(n)):
    if i == 0 or i == 1:
        new_n = [1,100]
        continue
    for ii in range(len(new_n)-1,0,-1): # 1
        if n[i]>new_n[ii-1] and n[i]<new_n[ii]:
            new_n.insert(ii,n[i])
            break
        elif n[i]<new_n[0]:
            new_n.insert(0,n[i])
            break
        elif n[i]>new_n[len(new_n)-1]:
            new_n.insert(-1,n[i])
            break
print(new_n)





#选择排序
new_n = []
while len(n):
    new_n.append(min(n))
    n.remove(min(n))
print(new_n)






#斐波那契数列     1 1 2 3 5 8 13 21
def fibonaci(n):
    if n == 1 or n == 2:
        return 1
    else:
        return fibonaci(n-1)+fibonaci(n-2)
print(fibonaci(7))






#字符串压缩算法，如果压缩后的字符串没有变短，则返回原字符串
s = 'abbccdddddde555'
def yasuo(raw_s):
    n = 1
    new_s = ''      #abbccc
    raw_s_length = len(raw_s)
    for i in range(raw_s_length):
        if i == raw_s_length - 1:
            new_s = new_s + raw_s[i] + str(n)
        elif raw_s[i] == raw_s[i+1]:
            n += 1
        elif raw_s[i] != raw_s[i+1]:
            new_s = new_s + raw_s[i] + str(n)
            n = 1
    if raw_s_length <= len(new_s):
        return raw_s
    else:
        return new_s
        
print(yasuo(s))






#两串乱序同构
#思路：先判断两串长度是否相等，不等直接返回False；长度相等，则把s1元素放在列表中，循环s2的所有元素，s2的元素如果在列表中就从列表删去该元素，如果不在列表就返回False
s1 = 'This is nowcoder'
s2 = 'is This nowcoder'
def same(s1, s2):
    if len(s1) != len(s2):
        return False
    else:
        li = []
        for i in s1:
            li.append(i)
        for i in s2:
            if i not in li:
                return False
            else:
                li.remove(i)
        return True
        
print(same(s1, s2))






#像素顺时针旋转90度
# 1  2 3 
# 4  5 6
# 7  8 9
 
#7  4  1
#8  5  2
#9  6  3
li = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
def reverse_right_90(raw_li):
    li = []
    new_li = []
    for i in range(len(raw_li)):
        for ii in raw_li:
            li.insert(0, ii[i])
        new_li.append(li)
        li = []
    return new_li
print(reverse_right_90(li))






#清除行列
#当某个元素为0时，将其所在的行与列清零
# 1 2 3
# 0 1 2
# 0 0 1

# 0 0 3
# 0 0 0
# 0 0 0
#注意：1、在原列表修改，如果改为0后，可能对后面的判断是否为0造成干扰，导致整个列表为0；2、如果复制旧列表，要注意深浅拷贝的问题
import copy
li = [[1, 2, 3], [0, 1, 2], [0, 0, 1]]
def clear(raw_li):
    new_li = copy.deepcopy(raw_li)
    for i in range(len(raw_li)):
        for ii in range(len(raw_li[i])):
            if raw_li[i][ii] == 0:
                for x in range(len(raw_li[i])):
                    new_li[i][x] = 0
                for y in range(len(raw_li)):
                    new_li[y][ii] = 0
    return new_li
print(clear(li))





#翻转子串
#给定两个字符串s1和s2，请编写代码检查s2是否为s1旋转而成，要求只能调用一次检查子串的函数。
#思路：先判断s1和s2是否长度相同，相同则创建一个新字符串s = s1 + s1，如果s2是s的子串，那必然是s1的子串
def issubset(s1, s2):   #判断s2是否为s1的子集
    if s2 in s1:
        return True
    else:
        return False
        
s1 = 'Hello world'
s2 = 'worldHelo '
def reverse_set(s1, s2):
    if len(s1) != len(s2):
        return False
    s = s1 + s1
    if issubset(s, s2):
        return True
    else:
        return False
print(reverse_set(s1,s2))






#二进制插入
#将m的二进制数替换掉n的二进制的第j到第i位，其中二进制的位数从低位数到高位且以0开始
#注意：用bin把10进制数转换成二进制数后变成字符串格式，且该字符串以'0b'开头，用n = bin(n)[2:]来去除'0b'字符串
#int(a,b)中的a参数是待转换的数字字符串，b是该数的具体进制
def bin_insert(n, m, j, i):
    n = bin(n)[2:]
    m = bin(m)[2:]
    li = list(n)
    for b in m:
        li[len(li)-1-i] = b
        i -= 1
    return int(''.join(li), 2)
    
print(bin_insert(21, 5, 1, 3))





#最接近的数
#有一个正整数，请找出其二进制表示中1的个数相同，且大小最接近的那两个数（一个略大，一个略小）
def approach(n):
    bin_n = bin(n)
    big = int(bin_n, 2) + 1
    bin_big = bin(big)
    while bin_big.count('1') != bin_n.count('1'):
        big += 1
        bin_big = bin(big)
    small = int(bin_n, 2) -1
    bin_small = bin(small)
    while bin_small.count('1') != bin_n.count('1'):
        small -= 1
        bin_small = bin(small)
    return int(bin_small, 2), int(bin_big, 2)
print(approach(5))





#整数转化
#编写一个函数，确定需要改变几个位，才能将整数a转变成整数b
#思路：先把a、b转换为二进制数，然后在位数较少的二进制数上补零，通过循环对比每个位置的数
def change(a,b):
    bin_a = bin(a)[2:]
    bin_b = bin(b)[2:]
    if len(bin_a) > len(bin_b):     #如果bin_a的位数比bin_b的位数多，则在b的左边补零到跟a的位数一样多
        bin_b = bin_b.rjust(len(bin_a), '0')
    else:
        bin_a = bin_a.rjust(len(bin_b), '0')
    n = 0
    for i in range(len(bin_a)):
        if bin_a[i] != bin_b[i]:
            n += 1
    return n
print(change(27,4))






#奇偶位交换
#交换一个数的二进制的奇数位和偶数位
#思路：先判断二进制数长度是奇数还是偶数，奇数则补零，然后通过循环（步长设置为2）进行交换
def change(n):
    bin_n = bin(n)[2:]
    if len(bin_n) % 2 != 0:
        bin_n = bin_n.rjust(len(bin_n)+1, '0')
    li = list(bin_n)
    for i in range(0, len(li), 2):
        li[i], li[i+1] = li[i+1], li[i]
    return int(''.join(li), 2)
print(change(42))





#在n个顶点的多边形上有n只蚂蚁，这些蚂蚁同时开始沿着多边形的边爬行，请求出这些蚂蚁相撞的概率。(这里的相撞是指
#存在任意两只蚂蚁会相撞)。给定一个int n(3<=n<=10000)，代表n边形和n只蚂蚁，请返回一个double，为相撞的概率。
#思路：每个蚂蚁爬行的方向都有两个，即围绕多边形顺时针爬和逆时针爬，因此n个蚂蚁爬行的方法有2^n种。只有当所有
#的蚂蚁按照同一个方向爬行才能保证所有的蚂蚁都不相撞，只有两种方法--都按逆时针或顺时针方向爬行。
def ants(n):
    return 1 - 2/(2**n)
print(ants(3))





#上楼梯
#n阶楼梯，一次可以上1阶、2阶、3阶。给定一个台阶数，计算有多少种上楼的方式
#思路：递归实现
def upstairs(n):
    if n == 1:  return 1
    elif n == 2:  return 2
    elif n == 3:  return 4
    else:
        return upstairs(n-1) + upstairs(n-2) + upstairs(n-3)
print(upstairs(5))






#机器人走方格（无障碍）
#有一个X*Y网格，一个机器人只能走格点且只能向右或向下走，要从左上角走到右下角。给定两正整数，返回机器人的走法数目
def path(x,y):
    if x == 1 or y == 1:
        return 1
    else:
        return path(x-1, y) + path(x, y-1)
print(path(2,3))






#棋盘覆盖问题
#在2^k * 2^k个方格组成的棋盘中，有一个方格被占用，用4种L型骨牌覆盖棋盘上的其余所有方格，不能重叠。
#思路：采用递归和分治的方法，先创建二维数组，全部数字置为-1，把棋盘平均分成4份，特殊格子必定在某个
#分棋盘中，则把剩余3个小棋盘靠近中间的格子设置为另一个数，然后把刚设置为另一个数的格子当作特殊方格，
#把小棋盘继续平均分成四份。
def chess(cx, cy, sx, sy, size):    #cx,cy:特殊格子的横纵坐标,sx,sy:小棋盘左上角和右上角坐标
    if size == 1:
        return
    global COUNT,table
    COUNT += 1
    l = COUNT
    half = size // 2
    if cx<half+sx and cy<half+sy:
        chess(cx, cy, sx, sy, half)
    else:
        table[sy+half-1][sx+half-1] = l
        chess(sx+half-1, sy+half-1, sx, sy, half)
    if cx<half+sx and cy>half+sy-1:
        chess(cx, cy, sx, sy+half, half)
    else:
        table[sy+half][sx+half-1] = l
        chess(sx+half-1, sy+half, sx, sy+half, half)
    if cx>half+sx-1 and cy<half+sy:
        chess(cx, cy, sx+half, sy, half)
    else:
        table[sy+half-1][sx+half] = l
        chess(sx+half, sy+half-1, sx+half, sy, half)
    if cx>half+sx-1 and cy>half+sy-1:
        chess(cx, cy, sx+half, sy+half, half)
    else:
        table[sy+half][sx+half] = l
        chess(sx+half, sy+half, sx+half, sy+half, half)

n = 4
COUNT = 0
table = [[-1 for i in range(n)] for ii in range(n)]
chess(1, 1, 0, 0, n)
for i in table:
    print(i)