网易2019秋季校园招聘编程题真题集合(python实现)

# 写在前面，题目来自牛客网：网易2019秋季校园招聘编程题真题集合

# 具体的输入输出的解释并没有截图，大家可以从上面的连接点进去到牛客网查看。

【解题tip】这题很简单，每次只要方块落在哪里，哪一例加1，最后输出各列高度中最小的值即可

n, m = list(map(int, input().split()))
lst = list(map(int, input().split()))
out = [0]*n
for i in range(len(lst)):
    out[lst[i]-1] += 1
print(min(out))

 【解题tip】 代码1能AC，但是时间复杂度为O(k*n)；可以修改方法2，时间复杂度为O(n)

# 代码1
n, k = list(map(int, input().split()))
score = list(map(int, input().split()))
awake = list(map(int, input().split()))
 
out = 0
MAX = 0
tmp = [0]*k
 
if k>=n:
    print(sum(score))
else:
    if k == 0:
        for i in range(n):
            if awake[i] == 1:
                out += score[i]
        print(out)
    else:
        for i in range(n):
            tmp.pop(0)
            if awake[i] == 1:
                out += score[i]
                tmp.append(0)
            else:
                tmp.append(score[i])
            if sum(tmp) > MAX:
                MAX = sum(tmp)
        print(out+MAX)

# 方法2 O(n)时间复杂度

n, k = list(map(int, input().split()))
score = list(map(int, input().split()))
awake = list(map(int, input().split()))

awake_score = 0
for i in range(n):
    if awake[i] == 1:
        awake_score += score[i]
        score[i] = 0

sleep_score = 0
for i in range(1, n):
    score[i] += score[i-1]
for i in range(k):
    sleep_score = max(sleep_score, score[i])
for i in range(k, n):
    sleep_score = max(sleep_score, score[i] - score[i-k])

print(awake_score+sleep_score)

【解题tip】 暴力解法是不能AC的，将各堆的苹果数量依次累加，构成一个递增数组，然后使用二分法确定位置

n = int(input())
app_num = list(map(int, input().split()))
m =int(input())
numl = list(map(int, input().split()))
 
result = []
for i in range(1, n):
    app_num[i] += app_num[i-1]
     
def get_place(data, left, right, target):
    i, j = left, right
    mid = i + (j-i)//2
    while left < right:
        if data[mid] >= target and data[mid-1]<target:
            return mid+1
        elif data[mid] >= target:
            right = mid-1
            return get_place(data, left, right, target)
        else:
            left = mid+1
            return get_place(data, left, right, target)
    return left+1
 
for j in range(m):
    result.append(get_place(app_num, 0, n-1, numl[j]))
     
for i in range(m):
    print(result[i])

 【解题tip】遍历 ？？？ 参考 biamgo 的代码

def change(i, x, y):
    # 返回逆时针旋转90度之后的坐标
    return [x+y-i[1], y-x+i[0]]

def dis(a, b):
    # 判断两个点的距离
    return (a[0] - b[0])**2 + (a[1] - b[1])**2

def square(a, b, c, d):
    # 判断4个点组成的结果中是不是可以组成一个正方形
    distances = [dis(a, b),  dis(a, c), dis(a, d), dis(b, c), dis(b, d), dis(c, d)]
    distances.sort()
    # 由勾股定理可知，两条对角线组成的边的平方是其他的边的长度的平方的两倍（注意点重合的情况）
    if distances[0]!=0 and distances[0] == distances[1] and distances[1] == distances[2] and distances[2] == distances[3]\
                and distances[3]*2 == distances[4] and distances[4] == distances[5]:
        return True
    return False

n = int(input())
result = []
for i in range(n):
    data = []
    best_t = float('inf')
    for j in range(4):
        a, b, x, y = list(map(int, input().split()))
        temp = [[a, b]]
        for k in range(3):
            temp.append(change(temp[-1], x, y))
        data.append(temp)
    
    # 遍历所有的可能性
    for i in range(4):
        for j in range(4):
            for k in range(4):
                for m in range(4):
                    if square(data[0][i], data[1][j], data[2][k], data[3][m]):
                        best_t = min(best_t, i+j+k+m)
    
    if best_t == float('inf'):
        print(-1)
    else:
        result.append(best_t)

for i in range(result):
    print(result[i])

扫描二维码关注公众号，回复： 3299500 查看本文章

【解题tip】1）直接遍历？？能AC，但不是滋味  2） 二分法比较（参考用户biamgo的思路）

# 只有6种情况 方法1
a,b,c = list(map(int, input().split()))
res = []
res.append(a+b+c)
res.append(a+b*c)
res.append((a+b)*c)
res.append(a*b+c)
res.append(a*(b+c))
res.append(a*b*c)
print(max(res))


# biamgo 思路  方法2 鲁棒性更好
a = map(int, raw_input().strip().split())
def search(l, r):
    if l == r:
        return a[l]
    ans = 0
    for i in range(l, r):
        lans = search(l, i)
        rans = search(i + 1, r)
        ans = max(ans, lans + rans)
        ans = max(ans, lans * rans)
    return ans
print(search(0, 2))

 【解题tip】每次将最大位置的高度减一，并且最小高度加一。直到k次操作结束或者最大高度差小于等于1。

n,k = list(map(int, input().split()))
high = list(map(int, input().split()))
 
result = []
for i in range(k):
    min_index = -1
    max_index = -1
    MIN = float('inf')
    MAX = -float('inf')
    for j in range(n):
        if high[j] > MAX:
            MAX = high[j]
            max_index = j
        if high[j] < MIN:
            MIN = high[j]
            min_index = j
    tmp = MAX - MIN
    if tmp <= 1:
        break
    else:
        result.append([max_index+1, min_index+1])
        high[max_index] = MAX - 1
        high[min_index] = MIN + 1
length = len(result)
print(str(max(high) - min(high))+' '+str(length))
for i in range(length):
    print(str(result[i][0])+' '+str(result[i][1]))

【解题tip】字符串问题很可能要转化为一个更小规模的问题。我们假设第一个字母是‘a’和第一个字母是‘z’，两种情况。分别讨论。 

# 字符串问题， 第7题
def cacl(num_a, num_z):
    # num_a 个 a, num_z 个 z ,组成不同字符串的个数
    ans = 1
    for i in range(1, num_a+num_z+1):
        ans *= i
    for i in range(1, num_a+1):
        ans //= i
    for i in range(1, num_z+1):
        ans //= i
    return ans

n, m, k = list(map(int, input().split()))
if cacl(n, m) < k:
    print(-1)
else:
    out = []
    while n>0 and m>0:
        tmp = cacl(n-1, m)
        if tmp >= k:
            out.append('a')
            n -= 1
        else:
            out.append('z')
            k = k - tmp
            m -= 1
    out.append('a'*n)
    out.append('z'*m)
    print(''.join(out))

# 参考资料  部分思路参考 牛客网用户 biamgo 的代码