程序员笔试题集与答案python版（持续更新）

题目主要来自于平时的刷题，注释内为直觉解法，不体现算法功底和高效。对比使用算法思想的解法，从而不断进步。争取每天都更新几道，加油。

1.给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。

说明：

你的算法应该具有线性时间复杂度。你可以不使用额外空间来实现吗？

class Solution:
def singleNumber(self, nums: List[int]) -> int:
'''
temp = []
for a in nums:
if a not in temp:
temp.append(a)
else:
temp.remove(a)

return temp[0]
'''
#使用异或^ y 因为相同的异或都为0，对所有数字异或就剩下只有一个的那个数字对应二进制不为零，四行解决。
result = 0
for i in nums:
result ^= i

return result

2.给定一个大小为 n 的数组，找到其中的众数。众数是指在数组中出现次数大于 ⌊ n/2 ⌋ 的元素。

你可以假设数组是非空的，并且给定的数组总是存在众数。

class Solution:
def majorityElement(self, nums: List[int]) -> int:
'''
appear_times = int(len(nums)/2)
for i in set(nums):
t = nums.count(i)
print(t)
if t > appear_times:
return i
'''
#本题使用摩尔投票法会更好，真正做到了只遍历一次列表，但是这种做法建立在众数大于n/2的基础上，才会将其他值给 #count没，只有众数的count最后会不是0。
count = 0
current = nums[0]
for i in nums:
if current == i:
count+=1
else:
count-=1
if count == 0:
current = i
count+=1
return current

3.编写一个高效的算法来搜索 m x n 矩阵 matrix 中的一个目标值 target。该矩阵具有以下特性：

每行的元素从左到右升序排列。
每列的元素从上到下升序排列。

示例:

现有矩阵 matrix 如下：

[
  [1,   4,  7, 11, 15],
  [2,   5,  8, 12, 19],
  [3,   6,  9, 16, 22],
  [10, 13, 14, 17, 24],
  [18, 21, 23, 26, 30]
]

给定 target = 5，返回 true。

给定 target = 20，返回 false。

#广度优先或者深度优先

class Solution:
def searchMatrix(self, matrix, target):
"""
:type matrix: List[List[int]]
:type target: int
:rtype: bool
"""
if matrix == [] or matrix ==[[]]:
return False
width = len(matrix[0])
deepth = len(matrix)
if target < matrix[0][0] or target > matrix[deepth-1][width-1]:
return False
for i in range(deepth):
for j in range(width):
if target == matrix[i][j]:
return True
if target < matrix[i][j]:
print(matrix[i][j])
break
else:
continue
return False

给定两个有序整数数组 nums1 和 nums2，将 nums2 合并到 nums1 中，使得 num1 成为一个有序数组。

说明:

初始化 nums1 和 nums2 的元素数量分别为 m 和 n。
你可以假设 nums1 有足够的空间（空间大小大于或等于 m + n）来保存 nums2 中的元素。

示例:

输入:
nums1 = [1,2,3,0,0,0], m = 3
nums2 = [2,5,6],       n = 3

输出: [1,2,2,3,5,6]

class Solution:
def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:
"""
Do not return anything, modify nums1 in-place instead.
"""
#这道题可以选择从头比较然后移动nums1，但是太费劲了
#换个思路我们可以从后往前插入，两个列表中较大的元素,算是归并排序的变体吧
current = m + n - 1
m -= 1
n -= 1
while(m >= 0 and n >= 0):
if nums2[n] > nums1[m]:
nums1[current] = nums2[n]
n -= 1
current -= 1

else:
nums1[current] = nums1[m]
m -= 1
current -= 1
while(n >= 0):
nums1[current] = nums2[n]
current -= 1
n -= 1

5.你将获得 K 个鸡蛋，并可以使用一栋从 1 到 N 共有 N 层楼的建筑。

每个蛋的功能都是一样的，如果一个蛋碎了，你就不能再把它掉下去。

你知道存在楼层 F ，满足 0 <= F <= N 任何从高于 F 的楼层落下的鸡蛋都会碎，从 F 楼层或比它低的楼层落下的鸡蛋都不会破。

每次移动，你可以取一个鸡蛋（如果你有完整的鸡蛋）并把它从任一楼层 X 扔下（满足 1 <= X <= N）。

你的目标是确切地知道 F 的值是多少。

无论 F 的初始值如何，你确定 F 的值的最小移动次数是多少？

动态规划精讲转载，https://www.cnblogs.com/raichen/p/5772056.html，写得很详细很好。

示例 1：

输入：K = 1, N = 2
输出：2
解释：
鸡蛋从 1 楼掉落。如果它碎了，我们肯定知道 F = 0 。
否则，鸡蛋从 2 楼掉落。如果它碎了，我们肯定知道 F = 1 。
如果它没碎，那么我们肯定知道 F = 2 。
因此，在最坏的情况下我们需要移动 2 次以确定 F 是多少。

示例 2：

输入：K = 2, N = 6
输出：3

示例 3：

输入：K = 3, N = 14
输出：4