校招笔试题集锦（持续更新）

仅作学习记录之用，以便日后复习回顾，侵删。

目录

华为

1、修改机票

2、旋转方阵

3、处理字符串

4、 IP地址匹配

5、寻找最大方阵

6、奥塔曼打怪兽

7、数组重排

8、一百以内计算器

拼多多

1、掷骰子

字节跳动

1、圆形花园的入口

2、2048的操作 

---

华为

1、修改机票

 

代码：

import sys
def reschedule(origins, changes):
    tickets = {}
    new_tickets = {}
    for origin in origins:
        airline, seat, name = origin.split(',')
        tickets[(airline, seat)] = name
        new_tickets[name] = (airline, seat)

    for change in changes:
        old_airline, old_seat, new_airline, new_seat = change.split(',')
        name2 = tickets[(old_airline, old_seat)]
        new_tickets.pop(name2)
        new_tickets[name2] = (new_airline, new_seat)
    print(new_tickets)

if __name__=="__main__":
    # input=
    '''
    3
    CZ7132,A1,ZHANGSAW
    CZ7132,A2,ZHAOSI
    CZ7156,A2,WANGWU
    2
    CZ7132,A1,CZ7156,A2
    CZ7156,A2,CZ7156,A3
    '''

    N = int(sys.stdin.readline().strip('\n'))
    origins = []
    changes = []
    for i in range(N):
        origins.append(sys.stdin.readline().strip('\n'))

    M = int(sys.stdin.readline().strip('\n'))
    for j in range(M):
        changes.append(sys.stdin.readline().strip('\n'))

    # origins = ['CZ7132,A1,ZHANGSAW', 'CZ7132,A2,ZHAOSI', 'CZ7156,A2,WANGWU']
    # changes = ['CZ7132,A1,CZ7156,A2', 'CZ7156,A2,CZ7156,A3']
    if not 0 <= N <= 100:
        print("The number of the tickets is error!")
    elif not 0 <= M <= N:
        print("The number of the revised tickets is error!")
    else:
        reschedule(origins, changes)

 

2、旋转方阵

题目描述: 
-- 输入一个N阶方阵(0 -- 旋转举例：（如下四个三阶方阵从上到下为数字围绕中心顺时针旋转
1 2 3
4 5 6
7 8 9

7 4 1
8 5 2
9 6 3

9 8 7
6 5 4
3 2 1

3 6 9
2 5 8
1 4 7
输入描述：
(1) 输入第一行一个正整数N (0 (2) 接下来N行每行N个整数用空格分开，为方阵的数据
(3) 接下来一行一个正整数M (0<=M<=10000)
说明：不用考虑异常输入，所有输入都是正常的，严格遵从取值范围
输出描述：
(1) N行，每行N个整数，用空格分开，为旋转后的数据
示例1: 
-- 输入
3
1 2 3
4 5 6
7 8 9
2
-- 输出
9 8 7
6 5 4
3 2 1

import sys

# 升级版，封装为函数，递归实现
def rotate_matrix(handled_array, order):
    rotate = [([0] * order) for _ in range(order)]  # 初始化rotate矩阵
    for row_index in range(order):
        for col_index in range(order):
            # 原矩阵逐列赋值给旋转矩阵的每一行
            rotate[row_index][col_index] = handled_array[order-1-col_index][row_index]
    return rotate

# 输入
square_array = []
N = sys.stdin.readline().rstrip("\n")
for i in range(0, int(N)):
    row = []
    line = sys.stdin.readline().rstrip("\n")
    temp_str = line.split(" ")
    for str_ in temp_str:
        row.append(int(str_))
    square_array.append(row)
M = sys.stdin.readline().rstrip("\n")

# 旋转处理
L = int(N)
M = int(M) % 4
for i in range(M):
    square_array = rotate_matrix(square_array, L)

# 输出
for row in square_array:
    row_str = ""
    for item in row:
        row_str += str(item) + " "
    print(row_str)

3、处理字符串

此题略长，慢慢看才能看懂。
题目描述：
--  对输入字符串检查是否存在非法字符，输出合法字符串（去重）和非法字符串（不去重）
--  对合法字符串循环左移10次，在进行排序输出。（举例：比如字符串"abc"，循环左移一次的结果为"bca"）
输入描述：
(1) 字符串中的字符集合为 '0'-'9'，'a'-'z'，'A'-'Z'，其余为非法字符串（空字符串作为定界符），
    有非法字符的字符串被视为非法输入；
(2) 作为输入的字符串个数不超过100，每个字符串长度不超过64；
(3) 作为输入的连续空字符串（空格/制表符/回车/换行符）作为一个空格处理（作为定界符，字符串起始字符不能为空）；
(4) 输入每行只有一个字符串
(5) 输入以空行结束
输出描述：
(1) 输出合法字符串并去重
(2) 输出所有非法字符串
(3) 对结果1的去重合法字符串循环左移10次
(4) 对结果3合法字符串字符串排序，按ASCII表字符从小到大顺序排序
注意事项：
--  每输入一个字符后用空格跟下一个字符串隔离，作为输出的所有字符串之间只能有一个空格（作为定界符）；
示例1:
-- 输入
abc
def
==
acd123
44234tjg
aga'-=
ad--s
abd
123
abcdef
1234567890123456789012345678901234567890123
45678901234567890123
EDFG
SDFG
ABC
DEF
cccc
a*b=1
dd
87&&^
asdfas
234abc35
765rgfh4sd
1231
123
==
EDFG

-- 输出
abc def acd123 44234tjg abd 123 abcdef 1234
5678901234567890123456789012345678901234567
8901234567890123 EDFG SDFG ABC DEF cccc dd
asdfas 234abc35 765rgfh4sd 1231
== aga'-= as--s a*b=1 87&&^ ==
bca efd 23acd1 234tjg44 bda 231 efabcd 1234
5678901234567890123456789012345678901234567
8901231234567890 FGED FGSD BCA EFD cccc dd
asasdf 4abc3523 765rgfh4sd 3112
1234567890123456789012345678901234567890123
45678901231234567890 231 234tjg44 23acd1 31
12 4abc3523 765rgfh4sd BCA EFD FGED FGSD as
asdf bca bda cccc dd efabcd efd
 

import sys


# 初始化输入
def input_init():
    string_list = []
    while True:
        line = sys.stdin.readline().rstrip('\n')        # 逐行读入，并去除行末的换行符
        if 0 == len(line):                              # 输入以空行结束,break语句较强应放在 continue语句前，不然会陷入死循环
            break
        if len(line) > 64:                              # 每个字符串长度不超过64
            continue
        if len(string_list) > 100-1:                    # 输入字符串个数不超过100
            continue
        if (line.startswith(' ')) & (0 != len(line)):   # 输入字符串不能以空格开始
            continue
        temp_str = line.split()                         # split()，默认分割(删除)所有的空字符,包括空格、换行(\n)、制表符(\t)等
        string_list.append(' '.join(temp_str))          # 输入的连续空字符串（空格/制表符/回车/换行符）作为一个空格处理
    return string_list


# 保存合法字符串
def get_legal_string(string_list: list):
    number_ls = list("0123456789")
    letter_ls = list("abcdefghijklmnopqrstuvwxyz")
    up_letter_ls = []
    for letter in letter_ls:
        up_letter_ls.append(letter.upper())

    flag = int(0)
    legal_str = []

    for index in range(0, len(string_list)):
        temp_str = string_list[index]
        for ix in range(0, len(temp_str)):
            x = temp_str[ix]
            if (x in number_ls) | (x in letter_ls) | (x in up_letter_ls):
                # 合法字符串
                flag = 1
            else:
                flag = 0
                break
        if flag:
            legal_str.append(temp_str)
    return legal_str


# 去除列表中重复的字符串
def remove_repeat_string(string_list: list):
    remove_repeated_str = string_list.copy()
    ix = 0
    while True:
        temp_str = remove_repeated_str[ix]
        count = remove_repeated_str.count(temp_str)             # 统计重复字符串个数
        if ix == len(remove_repeated_str)-1:
            break
        if count == 1:
            ix = ix + 1
            continue
        while count > 1:                                        # for循环不能动态改变数组长度，因此用while
            count = count - 1
            j = 1
            while True:
                need_remove = remove_repeated_str[-j]           # 反序遍历
                if temp_str == need_remove:
                    #remove_repeated_str.remove(need_remove)    # 因为remove()只能移除列表中第一个匹配的元素
                    pop_index = len(remove_repeated_str) - j
                    remove_repeated_str.pop(pop_index)          # 删除指定索引位置元素(反序)
                    break
                else:
                    j = j + 1
    return remove_repeated_str


# 保存非法字符串
def get_non_legal_string(raw_string_list: list, legal_string: list):
    non_legal_str = []
    for i in raw_string_list:
        if i in legal_string:
            continue
        non_legal_str.append(i)
    return non_legal_str


# 左移10次字符 10%len(str)
def shift_string(string_list: list):
    shift_string = []
    for shift_str in string_list:
        start = 10 % len(shift_str)
        shift_temp = ""
        shift_temp += shift_str[start:]
        shift_temp += shift_str[:start]
        shift_string.append(shift_temp)
    return shift_string


# 输出字符串结果
def output_string(string_list: list):
    output = ""
    for str_ in string_list:
        output += str_ + " "
    print(output)


def main():
    # 原始输入
    str_list = input_init()
    # 保存合法字符串
    legal_str = get_legal_string(str_list)
    # 保存非法字符串
    non_legal_str = get_non_legal_string(raw_string_list=str_list, legal_string=legal_str)
    # 保存合法字符串_去重
    remove_repeated_string = remove_repeat_string(legal_str)
    # 1.输出去重合法字符串
    output_string(remove_repeated_string)
    # 2.输出未去重的非法字符串
    output_string(non_legal_str)
    # 3.输出去重合法字符串左移10次后的结果
    shift_legal_str = shift_string(remove_repeated_string)
    output_string(shift_legal_str)
    # 4.输出对合法字符串字符串左移后排序，按ASCII表字符从小到大顺序排序
    shift_legal_str = sorted(shift_legal_str)
    output_string(shift_legal_str)


if __name__ == '__main__':
    main()
 

#####################################################################################################
#####################################################################################################
'''
NOTE:
# 注意输入时strip()、split()用法
# extend() 函数用于在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
# ord('a') 返回字符a的ASCII码
# index = [m.start() for m in re.finditer(' ',x)] 返回输入字符串中空格所在索引位置
# 字符串去重时，由于需要删除列表新加入的元素，而remove()只能移除列表中第一个匹配的元素，因此需要找到需去重的字符串索引
# 用pop(index)，从后往前的弹出。由于在此期间存储字符串的列表长度在动态改变，而for循环不能动态改变数组长度，因此用while

# split(str="",num=string.count(str)) 函数
# str_test = 'This\t\t is    a\t\t\t test for   split()'
# 输入：str_test.split()           # 默认分割(删除)所有的空字符，包括空格、换行(\n)、制表符(\t)等
# 输出：['This', 'is', 'a', 'test', 'for', 'split()']
# 输入：str_test.split('s')        # 分割所有的字符s
# 输出：['Thi', '\t\t i', '    a\t\t\t te', 't for   ', 'plit()']
# 输入：str_test.split('s',2)      # 分割前2个字符s
# 输出：['Thi', '\t\t i', '    a\t\t\t test for   split()']
'''

4、 IP地址匹配

这道题对输入做切分（调用split()方法）后，进行反复的10-2进制转换即可。 

import sys
ip1, ip2, maskip = sys.stdin.readline().split()

ip1 = ip1.split('.')
ip2 = ip2.split('.')
maskip = maskip.split('.')

new_ip1 = []
new_ip2 = []

for i in range(len(ip1)):
    new_ip1.append(str(int(ip1[i]) & int(maskip[i])))
    new_ip2.append(str(int(ip2[i]) & int(maskip[i])))

res = 1
for i in range(len(ip1)):
    if new_ip1[i] != new_ip2[i]:
        res = 0
        break
print(res, '.'.join(new_ip1))

5、寻找最大方阵

 

这道题可以参考LeetCode85：https://blog.csdn.net/u014626513/article/details/81381948

这种思路是比较清晰的：遍历每一行的每个元素，进行向下（列方向）和向右（行方向）的搜索并计数，从而得到以每个元素为左上角顶点的最大正方形。此处还可以优化一下减少运算量，即遍历元素时，若该元素右边或下边的元素个数已经少于目前得到的最大正方形的边长，那么就直接停止遍历搜索。高级一点的思路：采用动态规划，用计数矩阵记录个数，运算量更少。

以下代码，细思极妙。

def calMAX1(matrix):
    res = 0
    hang = len(matrix)  # 矩阵的行
    lie = len(matrix[0])  # 矩阵的列
    countMatrix = [[0 for i in range(lie)] for i in range(hang)]  # 生成0矩阵

    for i in range(hang):
        for j in range(lie):
            # 遍历
            if i == 0 or j == 0:
                countMatrix[i][j] = int(matrix[i][j])
            else:
                if matrix[i][j] != '0':
                    countMatrix[i][j] = min(countMatrix[i - 1][j], countMatrix[i][j - 1], countMatrix[i - 1][j - 1]) + 1  # 查询周边元素并累加
                else:
                    countMatrix[i][j] = 0
            res = max(res, countMatrix[i][j])
    return res ** 2

matrix = []
n = int(input())  # 有几行
for i in range(n):  # 输入每一行，str形式
    matrix.append(list(input()))

if len(matrix[0]) == 0:
    print(0)
else:
    print(calMAX1(matrix))

6、奥塔曼打怪兽

此题尚未有答案，做出来的大佬欢迎在评论区贴出自己的答案，感激不尽。

7、数组重排

输入为n行数字，第一行为数字a，第2到n行均为数组，每行数据形式例如2,3,4,5，每行数据长度不定，n也不定。

数据输出为从第二行数据开始截取前a个数据放在新数组中，并将这a个数据从第二行删除，接着转到第三行，进行同样操作，数据依次放在新数组中，依次操作直到第n行。再转到第2行开始重复操作。若是某行数据长度小于等于a，则将整行数据放在新数组中，直到所有数据放在新数组中为止。

输出一行新数组，输出格式类似于 2,3,4,5,6,7。即数字之间用逗号分隔。

eg:
输入：

3

1,2,3,4,5

2,3,4,5,6,7,8,9,0

输出：

1,2,3,2,3,4,4,5,5,6,7,8,9,0
 

import sys

if __name__ == "__main__":
    # 读取步长
    step = int(sys.stdin.readline().strip())
    ans, length, lines = [], [], []

    for linees in sys.stdin:
        if linees:
            linee = list(map(int, linees.split(",")))
            lines.append(linee)
        else:
            break

    length = [len(line) for line in lines]

    for i in range(max(length)):
        for line in lines:
            if len(line) >= step:
                ans.extend(line[0:step])  # extend()函数用于在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）。
                del line[0:step]  # del删除的是变量，而不是数据。
            else:
                ans.extend(line)
                del line[0:len(line)]

    aans = ''
    for i in ans:
        aans = aans + str(i)
    print(",".join(aans))  # 要求输出格式是 2,3,4,5,6 类型

8、一百以内计算器

aStr = ''
while True:
    tmp = input()
    if tmp != '=':
        aStr += tmp
    else:
        break
index = 0
jiaList = []
jianList = []
flagList = []

for i in aStr:
    if i == '+':
        jiaList.append(index)
        flagList.append(index)
    if i == '-':
        jianList.append(index)
        flagList.append(index)
    index += 1

res = int(aStr[0:flagList[0]])  # 初始化结果
for i in range(len(flagList)):

    if flagList[i] in jiaList:
        if i + 1 < len(flagList):
            res += int(aStr[flagList[i] + 1:flagList[i + 1]])
        else:
            res += int(aStr[flagList[i] + 1:])

    elif flagList[i] in jianList:
        if i + 1 < len(flagList):
            res -= int(aStr[flagList[i] + 1:flagList[i + 1]])
        else:
            res -= int(aStr[flagList[i] + 1:])
print(res)

9.https://blog.csdn.net/Jeff_Winger/article/details/81778329

 

拼多多

1、掷骰子

掷n个不同面数的骰子，以最大点数为结果，求点数的期望。一共有n个骰子，第i个骰子面数为ni，点数为[1,ni]，每个面的概率相同，同时掷这n个骰子，所有骰子中的最大点数为最终点数求骰子投出的期望值。

examlple1

输入

22 2

输出

1.75

examlple2

输入

41 2 3 4

输出

2.875

分析：

这道题目主要考察的知识点为动态规划。动态规划主要就是要找准它的转移方程和base case以及目标

首先把所有骰子的输入放入xi数组中并且进行排序（倒序 从大到小），然后建立两个列表

一个是res 存放最终的结果

一个是current 存放遍历到当前骰子的结果

1.先拿出第一个骰子 计算第一个骰子中发生每一个可能点数的概率并存入res和current中 【规定起始状态】

2.开始遍历每一个骰子 我们把当前的骰子记作P

   首先先是计算P这个骰子每一面会发生的概率 就是1/P

    P这个骰子在转的时候  假设最后所有骰子的点数为Q

A .之前的骰子都是＜Q * P这个骰子投出了Q

B .之前的骰子刚好出现Q * P这个骰子没投注Q

C .之前的骰子出现Q * 这个骰子投出了Q

3.最后把每个点数 * 概率 求出期望值

举个例子,，方便大家理解

假设现在有三个骰子，分别为2 3 4 存入X中，先将X排倒序 X=【4，3，2】，说明最多有四种情况 1，2，3，4

然后一开始初始化的时候是选择骰子面数最多的4

此时res=[0,1/4,1/4,1/4,1/4]，current=[0,1/4,1/4,1/4,1/4]

然后从第二个骰子开始遍历到第N个骰子，现在第二个骰子是3 ，投出1，2，3的概率都是1/3，基于第一个骰子的基础上 投出第二个骰子，那么最后结果为X的可能性由以下三个方面组成

1.之前的骰子投出的结果

      a=sum(res[:j])*(1/xi[i])

（之前出现1，2，3，...,X-1的概率 * 当前出现X的概率）

2.之前骰子投出结果=X的概率 乘以 当前骰子投出

       b=res[j]*((j-1)/xi[i]

  (之前恰好是X * 当前出现1，2，3，...,X-1的概率)

3.之前骰子投出X  乘以 当前骰子投出X的概率

        c=res[j]*(1/xi[i])

 （之前恰好是X 且当前也是X）

把三种情况的概率相加a+b+c赋值给current[i] 然后用current更新res即可

n = int(input())
xi = list(map(int, input().split()))
xi.sort(reverse=True)
res = [0]
current = [0]
for i in range(xi[0]):
    res.append(1/xi[0])
    current.append(1/xi[0])

for i in range(1,n):
    for j in range(1,xi[i]+1):
        print(res)
        a = sum(res[:j])*(1/xi[i])  # 之前的骰子投出的结果字节跳动 
  
1、圆形花园的入口
 
  
 小区花园里有n个入口，现在要修一些路，要求每个入口只能有一条路，且每条路之间互不相交，求输入为n的时候有几条路
 
  
examlple:
 
  
 
  
分析：
 
  
这道题目主要考察的知识点为动态规划.动态规划主要就是要找准它的转移方程和base case以及目标
 
  
题目中提到，N是一个输入为2-1000的偶数
 
  
先找base case：
 
  
N=2 dp[2]=1 只有一条路 那么只有一种情况 这个好理解
 
  
N=4 dp[4]=2
 
  
N=6 dp[6]=5
 
  
当N=8的时候，怎么分析？
 
  
 
  
现在把每个门都标上了号码牌，我们假设我们从1开始看。
 
  
1一开始可以和 2或者 8 相连，那么剩下了6个门，那么剩下六个门连通的可能总数为dp[6]（前面已经计算了）
 
  
1可以和7相连吗？不可以，因为这样8无论如何都会使得他们相交
 
  
所以我们必须隔两个门取。
 
  
1接下来和 2+2=4 或者 8-2=6 相连 当1和4相连的时候 剩下的六个门组合为dp[2]*dp[4]
 
  
此时 1 再和 4+2=6 或者 6-2=4 相连 此时已经发生了重复计算的情况，设置好跳出条件即可
 
  
思路：先锁定一个门（假设为1），从两端开始 先和距离为1的门相连，然后距离为3 距离为5直至发生重复计算跳出循环
 
  
或者从一端开始直至绕了一圈回到1这个门的时候跳出循环
 
  
 
 
  
a=int(input())
dp=[0 for i in range(a+1)]
dp[0]=0
dp[2]=1
dp[4]=2
dp[6]=5
for i in range(8,a+2,2):
    for j in range(i-2,0,-2):
        if j
 
  
2、2048的操作 
 
  
2048游戏是一个44的矩阵,用户可以按上下左右4个方向键让所有的方块向同个方向运动,两个相同数字方块撞一起之后合并成为他们的和,每次操作之后随机生成个2或者4合并规则:相邻会撞的两个数字合并且一个位置只会触发一次合并,且优先合并移动方向顶部的位置
 
  
比如【2，2，2，2】合并后【0，0，4，4】
 
  
【0，2，2，2】合并后【0，0，2，4】
 
  
  输入第一行是用户按下的方向键,1代表上,2代表下,3代表左,4代表右接下来是一个44的矩阵,空格分割,0代表该位置没有数字
 
  
| 分析：这个题目其实就是考察对边界条件的判定和对两数之间的值是否相等的判定
 
  
com = int(input())
l=[]
for _ in range(4):
    l.append(list(map(int,input().split())))

if com == 1:
    for i in range(3, 0, -1):
        for j in range(4):
            if l[i-1][j] == l[i][j]:
                l[i][j] = 0
                l[i-1][j] *= 2
            for k in range(3, 0, -1):
                if l[k-1][j] == 0 and l[k][j] != 0:
                    l[k-1][j] = l[k][j]
                    l[k][j] = 0
                if l[k-1][j] == l[k][j]:
                    l[k-1][j] *= 2
                    l[k][j] = 0

elif com == 2:
    for i in range(0, 3, 1):
        for j in range(4):
            if l[i + 1][j] == l[i][j]:
                l[i][j] = 0
                l[i + 1][j] *= 2
            for k in range(0, 3, 1):
                if l[k + 1][j] == 0 and l[k][j] != 0:
                    l[k + 1][j] = l[k][j]
                    l[k][j] = 0
                if l[k + 1][j] == l[k][j]:
                    l[k + 1][j] *= 2
                    l[k][j] = 0
elif com == 3:
    for i in range(4):
        for j in range(3, 0, -1):
            if l[i][j - 1] == l[i][j]:
                l[i][j] = 0
                l[i][j - 1] *= 2
            for k in range(3, 0, -1):
                if l[i][k - 1] == 0 and l[i][k] != 0:
                    l[i][k - 1] = l[i][k]
                    l[i][k] = 0
                if l[i][k - 1] == l[i][k]:
                    l[i][k - 1] *= 2
                    l[i][k] = 0

elif com == 4:
    for i in range(4):
        for j in range(0, 3, 1):
            if l[i][j + 1] == l[i][j]:
                l[i][j] = 0
                l[i][j + 1] *= 2
            for k in range(0, 3, 1):
                if l[i][k + 1] == 0 and l[i][k] != 0:
                    l[i][k + 1] = l[i][k]
                    l[i][k] = 0
                if l[i][k + 1] == l[i][k]:
                    l[i][k + 1] *= 2
                    l[i][k] = 0

for i in range(4):
    print(" ".join(map(str, l[i])))
 
  
 un
 
  
1.统计字母
 
  
 
  
 
  
str_list=input().strip()
dict={}
str_list=sorted(str_list)
for ch in str_list:
    if ch not in dict:
        dict[ch]=0
    dict[ch]+=1
tmp=''
for i in dict.keys():
    tmp=tmp+i+str(dict[i])
print(tmp)
 
  
结果：