一些题

1 有一个中国轨道拼图，随便给出两个城市之间的距离T和拼图盒里剩余的轨道C，你需要给出所有能连接上两个城市的轨道组合。
例：
input:C=[2,5,1,3,2],T=5
output:[[1,2,2],[5],[2,3]]

https://github.com/wenshijie/exercise/tree/master/orbital

c=[2,5,1,3,2]
c.sort(reverse=True)
t=5
n = len(c)
results=[]
def orbital(i,s_t,res=[]):
    j=i+1
    if s_t==t:
        results.append(res)
    if s_t<t and j<n:
        orbital(j,s_t+c[j],res+[c[j]])
        orbital(j,s_t,res)
orbital(-1,0,[])
print([list(re) for re in set(map(tuple,results))])

2 给出一段时间内小明在海里每秒游泳前进的距离，每秒可能前进，可能后退（后退为负）和一个时间段。要求小明大于等于k的时间范围内最快的平均前进速度。
例：
input: distance=[1,12,-5,-6,50,3], k=4
output:12.75

https://github.com/wenshijie/exercise/tree/master/fastest_speed

"""
distance=[1,12,-5,-6,50,3]
[1, 13, 8, 2, 52, 55] 前n项的和
0.5 2/4 
10.4 52/5
9.17 55/6
[1, 13, 8, 1, 51, 54] 从第k项每项减去distance的第一项
12.75 51/4
10.8 54/5
[1, 13, 8, 1, 39, 42] 从第k+1项每项减去distance的第二项
10.5 42/4
"""

distance=[1,12,-5,-6,50,3]
k = 4
distance = [1,5,7,10,-6,-8,7,6]
k = 3

def fast_speed(distance,k):
    n = len(distance)
    fs_max = 0
    sum_dis = [distance[0]]
    for i in range(1,n):
        sum_dis.append(sum_dis[-1]+distance[i])
    i = 0
    k = k-1
    while k<n:
        for j in range(k,n):
            fs = sum_dis[j]/(j-i+1)
            print(fs)
            if fs>fs_max:
                fs_max = fs 
            sum_dis[j] = sum_dis[j]-distance[i]
        k += 1
        i += 1
        
    return float('%.2f' % fs_max)

if __name__ == '__main__':
    print(fast_speed(distance,k))

3 你注册一个网站时输入一个英文字符串为用户名，如果这个字符串加上个字符串所有非空子集的数量作为你的密码，请你给出你的密码生成器：
例：
input：‘abc’
output:‘abc7’

https://github.com/wenshijie/exercise/tree/master/user_password

def user_password(s:str):
    n = len(set(s))
    return s+str(2**n-1)

if __name__ == '__main__':
    s = 'abc'
    print(user_password(s))

4 给定数n，二叉树的节点值分别为1,2，…,n.能组成多少种不同的二叉搜索树？
例：
input ：3
output：5

https://github.com/wenshijie/exercise/tree/master/search_bin_tree_num

"""
把n个数分解成根节点为1,2,...,n的数,则n个数的二叉搜索树的个数为
1为根节点则为后n-1个数组成的搜索树个数及dp[n-1]
2为根节点则为左树为1个数组成的,右子树为n-2个数组成的搜索树,dp[1]dp[n-2]
3为根节点左子树1,2,右子树4,5,...n,则为dp[2]*dp[n-3]
"""
# search_bin_tree
def search_bin_tree(n):
    dp=[0]*(n+1)
    dp[0],dp[1] = 1, 1
    for i in range(2,n+1):
        for j in range(i):
            dp[i] += dp[j]*dp[i-j-1]
    return dp[n]

if __name__=='__main__':
    result = search_bin_tree(4)

5 给定一个无序数组，包含正数、负数和0，要求从中找出3个数的乘积，使得乘积最大，要求时间复杂度：O(n)，空间复杂度：O(1)
输入描述:
输入共2行，第一行包括一个整数n，表示数组长度
第二行为n个以空格隔开的整数，分别为A1,A2, … ,An
输出描述:
满足条件的最大乘积
示例1
输入
4
3 4 1 2
输出
24

https://github.com/wenshijie/exercise/tree/master/largest_product

# 方法一
def pri(m,a):
    if m<3:
        return 0
    result_p = [0,0,0]  # 正数
    result_n = [0,0,0]  # 负数
    num_0 = 0
    for i in a:
        if i>result_p[0]:  # 正数前3或包括0的前三大
            result_p[0]=i
            result_p.sort()
        if i<0:  # 负数前3或包括0的前三小
            if result_n[-1]==0:
                result_n[-1]=i
                result_n.sort()
            elif i<result_n[-1]:
                result_n[-1]=i
                result_n.sort()
        if i==0:
            num_0 += 1
    while result_p[0]==0:  # 删除正数列表中的0项
        del result_p[0]
        if not result_p:  # 如果都是0，删除完了
            break
    while result_n[-1]==0:  # 删除负数列表中的0项
        del result_n[-1]
        if not result_n:  # 如果都是0，删除完了
            break
    if num_0>0:
        result_0 = [0,0,0]  # 如果0超级多不至于占内存，用一个0的话return中可能溢出指针
    else:
        result_0 = []
    result = result_n+result_0+result_p
    return max(result[0]*result[1]*result[-1],result[-3]*result[-2]*result[-1])
m = int(input())
a = list(map(int,input().split(' ')))
print(pri(m,a))

#方法二 分别求出max1，max2，max3，min2，min1
def pri(m,a):
    if m<3:
        return 0
    def get_max(b):
        max_ = b[0]
        max_index = 0
        for i in range(len(b)):
            if b[i]>max_:
                max_ = b[i]
                max_index = i
        return max_,max_index
    def get_min(b):
        min_ = b[0]
        min_index = 0
        for i in range(len(b)):
            if b[i]<min_:
                min_ = b[i]
                min_index = i
        return min_,min_index
    max1,max_index = get_max(a)
    del a[max_index]
    max2,max_index = get_max(a)
    del a[max_index]
    max3,max_index = get_max(a)
    a.extend([max1,max2])
    min1,min_index = get_min(a)
    del a[min_index]
    min2,min_index = get_min(a)
    return max(min1*min2*max1,max1*max2*max3)
m = int(input())
a = list(map(int,input().split(' ')))
print(pri(m,a))

6 画家小Q又开始他的艺术创作。小Q拿出了一块有NxM像素格的画板, 画板初始状态是空白的,用’X’表示。
小Q有他独特的绘画技巧,每次小Q会选择一条斜线, 如果斜线的方向形如’/’,即斜率为1,小Q会选择这条斜线中的一段格子,都涂画为蓝色,用’B’表示;如果对角线的方向形如’’,即斜率为-1,小Q会选择这条斜线中的一段格子,都涂画为黄色,用’Y’表示。
如果一个格子既被蓝色涂画过又被黄色涂画过,那么这个格子就会变成绿色,用’G’表示。
小Q已经有想画出的作品的样子, 请你帮他计算一下他最少需要多少次操作完成这幅画。
输入描述:

每个输入包含一个测试用例。
每个测试用例的第一行包含两个正整数N和M(1 <= N, M <= 50), 表示画板的长宽。
接下来的N行包含N个长度为M的字符串, 其中包含字符'B','Y','G','X',分别表示蓝色,黄色,绿色,空白。整个表示小Q要完成的作品。

输出描述:

输出一个正整数, 表示小Q最少需要多少次操作完成绘画。

示例1
输入

4 4
YXXB
XYGX
XBYY
BXXY

输出

3

https://github.com/wenshijie/exercise/tree/master/Q_draw

# 贪心
# n,m=6,5
# img=[list('XBGBX'),list('YBBYB'),list('BGGXX'),list('XYYBG'),
#      list('XYBGG'),list('YYXYX')]
n,m=tuple(map(int,input().split()))
img = []
for i in range(n):
    img.append(list(input()))
i=0
result=0
while i<n:
    j = 0
    while j<m:
        if img[i][j] == 'Y' or img[i][j]=='G':
            result+=1
            ki,kj=i,j
            while ki<n and kj<m:
                if img[ki][kj]=='Y':
                    img[ki][kj]='X'
                elif img[ki][kj]=='G':
                    img[ki][kj]='B'
                else:
                    break
                ki,kj=ki+1,kj+1
        if img[i][j] == 'B' or img[i][j]=='G':
            result+=1
            ki,kj=i,j
            while ki<n and kj>=0:
                if img[ki][kj]=='B':
                    img[ki][kj]='X'
                elif img[ki][kj]=='G':
                    img[ki][kj]='Y'
                else:
                    break
                ki,kj=ki+1,kj-1
        j+=1
    i+=1
print(result)

7 A 国的手机号码由且仅由 N 位十进制数字(0-9)组成。一个手机号码中有至少 K 位数字相同则被定义为靓号。A 国的手机号可以有前导零，比如 000123456 是一个合法的手机号。
小多想花钱将自己的手机号码修改为一个靓号。修改号码中的一个数字需要花费的金额为新数字与旧数字之间的差值。比如将 1 修改为 6 或 6 修改为 1 都需要花 5 块钱。
给出小多现在的手机号码，问将其修改成一个靓号，最少需要多少钱？

n, k = tuple(map(int,input().split()))
s = input()
d={}
inf = 9*k+1
ch = []
for i in s:
    d[int(i)]=d.get(int(i),0)+1
min_key,max_key,keys=min(d.keys()),max(d.keys()),d.keys()
for key in d.keys():
    ki= k-d[key]
    i = 1
    num = 0
    change={}
    while ki >0:
        if key+i<=max_key and (key+i) in keys:  # 保证key存在
            num += i*min(ki,d[key+i])
            change[key+i]=min(ki,d[key+i])
            ki=max(ki-d[key+i],0)
        if key-i>=min_key and (key-i) in keys and ki>0:
            num += i*min(ki,d[key-i])
            change[key-i]=min(ki,d[key-i])
            ki=max(ki-d[key-i],0)
        i+=1
    if num<inf:
        inf = num
        ch.clear()
        ch.append([key,change])
    elif num==inf:
        ch.append([key,change])
result=[]
for ch_s,ch_dict in ch:  # 可能有多种如'887766' k=3时
    s_l = list(s)
    for i in range(len(s_l)):
        if (int(s_l[i]) in ch_dict.keys() and ch_dict[int(s_l[i])]>0
            and int(s_l[i])>ch_s):  # 大变小从前开始
            ch_dict[int(s_l[i])]-=1
            s_l[i]=str(ch_s)
    for i in range(-1,-(n+1),-1):
        if (int(s_l[i]) in ch_dict.keys() and ch_dict[int(s_l[i])]>0
            and int(s_l[i])<ch_s):  # 小变大从后开始
            ch_dict[int(s_l[i])]-=1
            s_l[i]=str(ch_s)
    result.append(''.join(s_l))
result.sort()  # 可以优化不用排序去结果为'A'一次选最小令为最小的
print(inf)
print(result[0])