面试代码题

日萌社

 

人工智能AI：Keras PyTorch MXNet TensorFlow PaddlePaddle 深度学习实战（不定时更新）

---

面试题

面试代码题

---

给定两个数组表示的整数, 返回最接近第二个整数, 并且大于第二个整数的值。

# coding=utf-8
import numpy as np

def getclosenumber(x, y):
    sorted_x = sorted(x)
    length = len(x)
    result = []
    used = [False] * length
    for i in range(length):
        j = 0
        while j < length and (used[j] or sorted_x[j] < y[i]):
            j += 1

        used[j] = True
        result.append(sorted_x[j])

        if j == length:
            break

        if sorted_x[j] > y[i]:
            for k in range(length):
                if not used[k]:
                    result.append(sorted_x[k])
            break

    return result
    
def main():
    x = [4, 6, 2, 0, 3, 5]
    y = [5, 3, 2, 4, 1, 0]
    res = getclosenumber(x, y)
    print("res=%s" % res)


if __name__ == '__main__':
    main()

---

在一维数组中，找出一个点，使得其所有左边的数字均小于等于它，所有右边的数字都大于等于它。返回这个点所在的下标，要求你的算法时间复杂度为O(n)

def get_point_number(a):
	length = len(a)
	result = []
	flag = [0] * length
	first_max = a[0]
	for i in range(0, length):
		if a[i] >= first_max:
			first_max = a[i]
				flag[i] = 1
	second_min = a[-1]
	for i in range(length - 1, -1, -1):
		if a[i] <= second_min:
			second_min = a[i]
			if flag[i] == 1:
				result.append(i)
	return result

def main():
	a = [1, 0, 1, 0, 1, 2, 3]
	res = get_point_number(a)
	print(res)
if __name__ == '__main__':
	main()

---

蛙跳，给出一维非负元素的数组，每个元素代表该元素位置能够跳的最远距离。假设初始位置在第一个元素，请根据输入数组判断是否能跳到数组的末尾。

def frog_jump(a):
    i = 0
    length = len(a)
    current_max = 0
    while i < length - 1:
        if a[i] == 0 and current_max < i + 1:
            return False
        if a[i] + i > current_max and a[i] > 0:
            current_max = a[i] + i
            if current_max >= length - 1:
                return True
        i += 1

    return False


def main():
    a = [2, 1, 3, 1, 1]
    b = [3, 2, 1, 0, 1]
    res = frog_jump(b)
    print(res)
    res = frog_jump(a)
    print(res)


if __name__ == '__main__':
    main()

---

神经网络的训练中如何判断过拟合?如果防止过拟合, 都有哪些办法?请详细说明

训练集上的指标在提升, 同时验证集上的指标在下降是过拟合最直观的表现。使用Relu, dropout, batchnormalization, 降低网络参数量, 层数, 复杂度等等都可以。

---

给定一个整形数组, 找出最大下标距离 j - i , 当且仅当 A[i] < A[j] 和 i < j

算法思路: 记录从数组第⼀个元素开始的下降序列descent_seq, 然后使⽤指针从尾部开始逆向扫
描, 求出满⾜要求的下标的最⼤距离。
反证法: 假设存在最⼤下标距离的两个下标i和j, 满⾜i<j, A[i]<A[j], 并且A[i]不在
descent_seq中。
 如果上述假设情况发⽣, 那么我们⼀定还能找到⼀个k, 满⾜k<i, A[k]<A[i], 那么此
时最⼤下标距离应该是j-k, ⽽不是j-i, ⽭盾! 因此假设不成⽴!
 得出结论: 满⾜要求的A[i]⼀定在descent_seq中, 也就是⼀定在从数组第⼀个元素开
始的下降序列中。

# coding=utf-8

def maxDistance(array):
    descent_array = []
    max_number = array[0]
    for i in range(len(array)):
        if i == 0:
            descent_array.append('O')
        else:
            if array[i] < max_number:
                descent_array.append('O')
                max_number = array[i]
            else:
                descent_array.append('X')

    print(descent_array)

    i = j = len(descent_array) - 1
    max_distance = 0
    max_i = -1
    max_j = -1
    while i >= 0:
        if descent_array[i] == 'X':
            i -= 1
            continue

        while array[j] <= array[i] and i < j:
            j -= 1

        if i < j and j - i > max_distance:
            max_distance = j - i
            max_i = i
            max_j = j

        i -= 1

    return max_distance, max_i, max_j


def main():
    array = [5, 3, 4, 0 ,1, 4, 1]
    dis, a, b = maxDistance(array)
    print("dis=%d, start=%d, end=%d" % (dis, a, b))


if __name__ == '__main__':
    main()

---

给定一个一维数组，里面只有一个数字出现了一次，其他数字都出现了2次，请将这个唯一出现了一次的数字找出来。

采用将整个数组元素依次执行异或操作，最终的结果值C就是那个唯一出现了一次的数字。

---

相比于RNN处理序列数据, 我们可以用CNN处理同样的文本吗?如何实施? 有哪些需要特殊处理的地方?请尽可能详细的给出说明或图示

- - 关于采用CNN来处理文本, 需要考虑的是卷积核的大小设置, 只能设为[conv_length, sequence_length], 第一个维度为卷积尺寸, 可以是2, 3, 4这样的值, 但是第二个维度必须和数字化张量的第二个维度匹配, 即等于sequence_length。其他的处理步骤和RNN基本一致。

---

给定一个只含数字的字符串，返回所有合法的IP地址。

# coding=utf-8
import numpy as np

def get_all_ip(s, start, part, ip, result):
    length_s = len(s)
    if length_s - start > (4 - part) * 3:
        return

    if length_s - start < (4 - part):
        return

    if start == length_s and part == 4:
        result.append(ip[:-1])
        return

    num = 0
    max_i = np.minimum(start+3, length_s)
    for i in range(start, max_i):
        num = num * 10 + int(s[i])
        if num < 256:
            ip += s[i]
            get_all_ip(s, i+1, part+1, ip+'.', result)
        if num == 0:
            break


def get_ip(s):
    result = []
    ip = ''
    get_all_ip(s, 0, 0, ip, result)
    return result


def main():
    s = '10112'
    res = get_ip(s)
    for i in res:
        print(i)


if __name__ == '__main__':
    main()

---

在之前基础上实现股票买卖2.0，给定一个数组，第i个元素代表第i天的股价。假设最多允许进行2次买卖，求可能的最大利润是多少? ​​​​​​​

# coding=utf-8
import numpy as np

def get_max_profit(price):
    length = len(price)
    current_profit = [0] * length
    future_profit = [0] * length
    low = price[0]
    for i in range(1, length):
        low = np.minimum(low, price[i])
        current_profit[i] = np.maximum(current_profit[i - 1], price[i] - low)

    high = price[length - 1]
    for i in range(length - 2, -1, -1):
        high = np.maximum(high, price[i])
        future_profit[i] = np.maximum(future_profit[i + 1], high - price[i])

    max_profit = 0
    for i in range(0, length):
        max_profit = np.maximum(max_profit, current_profit[i] + future_profit[i])

    return max_profit
    
def main():
    price = [68, 72, 59, 73, 66, 63, 59, 72, 65, 70, 64, 75, 71, 70, 67, 70, 72, 66, 63, 59, 68, 73, 74]
    result = get_max_profit(price)
    print(result)


if __name__ == '__main__':
    main()

---

在之前基础上实现蛙跳2.0，给出一维非负元素的数组，每个元素代表该元素位置能够跳的最远距离。假设初始位置在第一个元素，并假设输入数组能满足到达数组末尾，求最少的跳数是多少?

def frog_jump(a):
    result = 0
    last = current = 0
    length = len(a)
    for i in range(length):
        if i > last:
            last = current
            result += 1
        current = max(current, i + a[i])
    
    return result


def main():
    a = [2, 1, 3, 1, 1]
    res = frog_jump(a)
    print(res)

if __name__ == '__main__':
    main()

---

输入一个递增有序数组的一个旋转，输出旋转数组的最小值

def get_min_value(a):
    left = 0
    right = len(a) - 1
    min_value = a[left]
    while left < right:
        mid = int(left + (right - left) / 2)
        min_value = min(a[left], min_value)
        if (a[mid] == a[left]) and (a[mid] == a[right]):
            left += 1
        elif a[mid] >= a[left]:
            left = mid + 1
            min_value = min(a[left], min_value)
        else:
            min_value = min(a[mid], min_value)
            right = mid - 1

    return min_value


def main():
    a = [3, 4, 5, 6, 1, 2]
    res = get_min_value(a)
    print('res=%d' % res)


if __name__ == '__main__':
    main()