【机试题总结】

乐鑫科技

牛客网
一个城区的绿化问题，每条街道原本绿化水平和居民数不同。n个街道、每条街道都能绿化水平改到m、可以改善k个街道绿化水平；

问：最大居民满意度；

题目意思其实就是每个街道能得到的居民满意度是这个街道的居民数 乘以 绿化增加水平（绿化到m 减去原来绿化水平）；

比如一共6个街道、要绿化的都能绿化到10、最多可以绿化3条街。

就是求top k然后加和

#n:接到数量 m:可以绿化到的程度 k:可以绿化k个
#arr[i][0]:第i条街道的居民数 arr[i][1]:第i条街道的原有绿化程度
#居民的最大满意数=sumk（arr[i][0]*(m-arr[i][1])）
def quickSort(res,l,r,k):
	li,ri=l,r
	while li<ri:
		while li<ri and res[ri]<res[l]:ri-=1
		while li<ri and res[li]>=res[l]:li+=1
		res[li],res[ri]=res[ri],res[li]
	res[li],res[l]=res[l],res[li]
	if li==k:return res[:k]
	elif li>k:return quickSort(res,l,li-1,k)
	else: return quickSort(res,li+1,r,k)
def maxsurprise(arr,m,k):
	n=len(arr)
	res2=[]
	for i in range(n):
		res2.append(arr[i][0]*(m-arr[i][1]))
	#对res快速排序 取最大的前k个
	print(res2)
	print('-----------')
	maxk=quickSort(res2,0,n-1,k)
	print(maxk)
	result=1
	for num in maxk:
		result+=num
	return result
arr=[[3,5],[1,4],[4,6],[4,7],[5,5],[3,7]]
m,k=10,3
print(maxsurprise(arr,m,k))

---

2022.07.26
机试题

尽可能留下面试成绩最好的人

面试官每天面试一个人，决定推不推荐入职，每个人会出一个成绩，以及他的最晚几天后通知的时间，即在通知他之前，还可以面试几个人，面试官想留下成绩最好的人，在某个人的最后通知日期，如果已经出现了成绩比他还好的人，那么通知他不推荐。如果没有出现，那么通知他推荐。如果有成绩相等的人，那么截止日期最后的占优势。给一组数据。问推荐谁

6
10 1
11 2 
9 3
13 1
10 5
15 5

输出

4

persons=[[10,1],[11,2],[9,3],[13,1],[10,5],[15,5]]
persons=[[10,1],[11,2],[13,1],[13,1],[10,5],[15,5]]
persons=[[10,1],[11,2],[9,3],[13,2],[10,5],[15,5]]
maxs=[0,persons[0][0],persons[0][1]]
#[第几个人，最大值，第几天必须通知]
flag=True
for i in range(len(persons)):
	cur=persons[i]
	#比最大值大，说明前边的都不用推荐，更新最大值
	if cur[0]>=maxs[1]:
		maxs=[i,cur[0],cur[1]+i]
	else:
	#比最大值小，判断最大值是否今天到期，到期就推荐，否则还可以等
		if maxs[2]==i:
			print(maxs[0]+1)
			flag=False
			break
if flag:#面试完了所有人，取最大的
	print(maxs[0]+1)

写入内存

内存写入的时候以二进制写，比如将4写入内存，写的是00…0100一共32比特，四字节。
但是写的时候只能把二进制的1变成0，不能把0变成1，即本来某位置存的A，接下来该位置写入B，得到的该位置内容应该为C=A&B。把0变成1需要擦除操作，浪费时间。初始情况已经全部擦除，即全是1，给一串数，能正确写入则写，不能争取写入则重新开辟一个地址，问存入这串数字需要几字节。
另外，如果最后一次写入的是0xffffffff，则不算内存空间

输入第一行为数字个数，第二行为数字

4
7 5 1 5

输出

8

第一个位置，存入7（111），接下来如果写入5（101），5&7=5，因此可以写入，同样1（001）&5=1，也可以写入第一个位置，当5（101）进入，5&1=1！=5，因此需要另起一个位置。每个位置四个字节，所以为8字节
代码实现

n=4
nums=[7,5,1,5]
nums=[7,5,1,0xffffffff]
cur=0xffffffff
count=1
print(cur)
for num in nums:
	if num&cur==num:
		cur=num
	else:
		count+=1
		cur=num
if cur==0xffffffff:
	print((count-1)*4) 
else:
	print(count*4)

华为

2022.07.27帮人作答

统计表达式的计算时间

±:1 *:2 /:4

九宫格

给一串数，一共有九个，按顺序填入九宫格，使得三行三列两对角线一共8个积相等，输出按字典序

就是一个找满足某种条件的排列问题，先用回溯暴力定排列，后判断

# -*- coding: UTF-8 -*-
# Write Python 2 code in this online editor and run it.
def jude(nums):
	target =nums[0]*nums[1]*nums[2]
	return nums[3]*nums[4]*nums[5]==target\
and nums[6] *nums[7]*nums[8]==target \
and nums[0]*nums[3]*nums[6]==target \
and nums[1]*nums[4]*nums[7]==target \
and nums[2]*nums[5]*nums[8]==target \
and nums[0]*nums[4]*nums[8]==target \
and nums[2]*nums[4]*nums[6]==target
def backtracking():
	if len(path)==9:
		#print(path)
		if jude(path) :
			res.append(path[:])			
		return 
	for i in range(9) :
		if flag[i]:continue
		
		if i>0 and nums[i]==nums[i-1] and not flag[i-1]:
			continue
		flag[i]=True
		path.append(nums[i])#str(nums[i])
		backtracking()
		flag[i]=False
		path.pop()
nums=[1,2,4,5,10,20,25,50,100]
nums.sort()
flag=[False]*9
path=[]
res=[]
backtracking()
print(res)

剪枝
因为需要8条线乘积相同，所以把nums排序后，nums[4]应该放在res[4]的位置，而应该满足res[0]*res[8]=res[1]*res[7]=res[2]*res[6]=res[3]*res[5]，所以只要确定res[0]到res[3]的值，res[5]到res[8]自然也就确定了。res[0]的可选范围为nums[0]到nums[8]（nums[4]除外）。因此变成了Ω=[0,1,2,3,5,6,7,8]，n=4的全排序问题。

def jude(nums,target):
	return nums[0]*nums[1]*nums[2]==target\
and nums[6] *nums[7]*nums[8]==target \
and nums[0]*nums[3]*nums[6]==target \
and nums[2]*nums[5]*nums[8]==target 
def backtracking():
	if len(index)==4:
		#print(index)
		path=[]
		for i in range(4):
			path.append(nums[index[i]])
		path.append(nums[4])
		for i in range(5,9):
			path.append(nums[8-index[8-i]])
		#print(index,path)
		if jude(path,target) :
			res.append(path[:])			
		return 
	for i in [0,1,2,3,5,6,7,8]:
		if flag[i]:continue
		if i==5 and nums[5]==nums[3] and not flag[3]:continue 
		if i>0 and nums[i]==nums[i-1] and not flag[i-1]:
			continue
		flag[i]=True
		index.append(i)
		#path.append(nums[i])#str(nums[i])
		backtracking()
		flag[i]=False
		index.pop()
		#path.pop()
nums=[1,2,4,5,10,20,25,50,100]
nums.sort()
target=nums[0]*nums[8]*nums[4]
flag=[False]*9
path=[]
index=[]				
res=[]
backtracking()
print(res)

5个数 6次比较求中值 7次排序

比较a0 a1，将较小者存入a0

比较a2 a3，将较小者存入a2

比较a0 a2，将较小者存入a0，如果a0和a2发生了交换，则同时交换a1,a3，目的是使a0,a1和a2,a3仍保持原来的大小关系。进行这三次比较后，a0比a1,a2,a3都小，不可能是中位数，故排除a0,（5个数的中位数不可能比三个数都小）

比较a1 a4，将较小者存入a1

比较a1 a2，将较小者存入a1，如果a1和a2发生了交换，则同时交换a3,a4，使a1 a4和a2 a3的大小关系保持不变。进行这三次比较后，a1比a2,a3,a4都小，可以排除a1。

比较a2 a4，将较小者存入a2。这个时候a2就是中位数。

7次比较排序算法
1、任取四个数比较，如a>b,c>d。（两次）
2、a，c比较求出大者，假设为a，此时有a>c>d，a>b。（1次）
3、e与c比较，此时分为两种情况。（1次）
4、e>c时，b与c比较，得到两种情况，自己画图即可看出再两次即可排好序。
5、e<c时，e与d比较，此时有四个数已排好序，且最大数已求出，此时再两次同样可排好序（b与c，d，e中的中间值先比较即可）。