emmmm，吸取了之前华为笔试一道题花时间太长的教训，这次给自己限定了每题最多半小时的限制
。。。于是一题都没AC _(:з」∠)_
完结了后没看答案试着把刚才的补补全，但没测例不知道对不对就是了。。。

第一题：

输入一个int列表，问通过+1将该列表变为非重复数字总共需要多少步：
印象里之前在LeetCode做过，但是半小时没做出来，直接下一题 5%

boxNums = int(input())
boxs = list(map(int, input().split(" ")))[:boxNums]
boxs.sort()

last = boxs[0]
remant = 0 # 还没填充的重复数字
added = 0 
for i in range(1, len(boxs)):
    if(last== boxs[i]): #与前面重复，多余数值+1
        remant+= 1
    elif remant>0:
        dist = boxs[i]-last
        if dist > 1:
            fill = dist-1 # 有多少坑位
            if fill > remant :
                fill = remant
            remant-=fill
            step = 0 # 通过累加填充多余数值到坑里
            for j in range(1, fill+1):
                step+=j
            added+= step
            pass
        added+=remant*dist # 增加剩余多余数字到当前值
    last = boxs[i]
    pass
step = 0
for j in range(1, remant+1):
    step+=j
added +=step
print(added)

结束又看了眼想起是个累加。。早知道多分配10分钟

第二题：

问给定的一组火柴能否拼成正方形，直接把非4的倍数和有火柴长度大于1/4的情况过滤掉也有一定分数（貌似50%，忘了）

# 回溯法凑边,凑不出边就是不能正方形
def makeSide(batch_li, used_set, target, index = -1, value = 0):
    if value > target:
        return False
    elif value == target:
        return True
    if value<= target:
        for i in range(index+1,len(batch_li)):
            if i not in used_set:
                print(i)
                value += batch_li[i] # 当前值
                used_set.add(i) # 记录用了的火柴
                if makeSide(batch_li,used_set,target,i,value):
                    return True
                else:
                    used_set.remove(i) # 弹出当前火柴
                    value -= batch_li[i]
    return False

input_nums = int(input())
for i in range(0,input_nums):
    input_list = list(map(int, input().split(" ")))
    nums = [0]
    batchs = input_list[1:]
    batchs.reverse()
    sum_len = sum(batchs)
    print(sum_len)
    if(sum_len%4!=0):
        print("NO1")
    else:
        side = sum_len/4
        if batchs[0]> side:
            print("NO2")
        else:
            used_set = set()
            for s in range(0,4):
                if not makeSide(batchs,used_set,side):
                    print(s)
                    print("NO3")
                    break
            else:
                print("YES")
            pass

回溯法不是很熟，考完还是做了段时间。。。

第三题：

问斐波那契数列的第N项是否能被3整除,能则YES否则NO
强算先手拿了50%，然后观察了下前30个输出，发现其实有规律
为了观察规律测试了会，但最后不知道哪里规律没总结对，看看时间到了，下一题 50%
强算版：

input_nums = int(input())
for i in range(0,input_nums):
    a,b, n = map(int, input().split(" "))
    if a%3==0 and b%3==0:
        print("YES")
        continue
    for i in range(1,n):
        cur = a+b
        a = b
        b = cur
    if b%3==0:
        print("YES")
    else:
        print("NO")
    pass

找规律版：

input_nums = int(input())
for i in range(0,input_nums):
    a,b, n = map(int, input().split(" "))
    n+=3
    if a%3==0 and b%3==0:
        print("YES")
    elif a%3==0:
        if n%4==3:
            print("YES")
        else:
            print("NO")
    elif b%3==0:
        if n%4==0:
            print("YES")
        else:
            print("NO")
    else:
        if n%4==2:
            print("YES")
        else:
            print("NO")

最后发现是n的起始点和强算版不太一样，考试时没发现应该是憋尿一个小时后注意力涣散了

第四题：

输入一个int列表，问连续子序列最大的gcd与子序列长度的和，
遇到点bug但最后时间来不及了，赶紧处理了下输入 10%

def gcd(a,b):
    if((a==0 )or( b==0)): 
        return 0
    elif (a==1) or (b==1):
        return 1
    if b>a:
        a,b = b,a
    while(a!=b):
        a%=b
        if(a==1):
            return 1
        elif(a==0):
            return b
        if b>a:
            a,b = b,a
        pass
    return b

input_nums = int(input())
li = list(map(int, input().split(" ")))
if(len(li)==0):
    print(0)
elif(len(li)==1):
    print(li[0])
elif(len(li)==2):
    print(gcd(li[0],li[1]))
max_gcd = 0
g = li[0]
start = 0
for i in range(1, len(li)):
    g = gcd(g, li[i])
    if g==1:
        g = li[i]
        start = i
    length = i- start +1
    max_gcd = max(max_gcd, g*length)
    pass
print(max_gcd)

检查了下BUG是gcd写错了，BUG没修多久但时间来不及也没办法，而且修好了这也不一定过啦233