2020 八月秋招笔试准备汇总

最新推荐文章于 2024-10-30 17:17:38 发布

HanhahnaH

最新推荐文章于 2024-10-30 17:17:38 发布

阅读量408

点赞数

分类专栏：笔试/面试准备文章标签：面试

本文链接：https://blog.csdn.net/Hanhahahahah/article/details/108427761

版权

笔试/面试准备专栏收录该内容

4 篇文章 0 订阅

订阅专栏

小红书测试开发&后端

https://blog.csdn.net/xuliwei950318/article/details/106954495

输入一串字符，请编写一个字符串压缩程序，将字符串中连续出现的重复字母进行压缩，并输出压缩后的字符串。

例如：
aac 压缩为 1ac
xxxxyyyyyyzbbb 压缩为 3x5yz2b

def getzip(string):
    count = 0
    res = ''
    if len(string) > 0:
        one = string[0]
        for i in range(1, len(string)):
            if string[i] == one:
                count += 1
            else:
                if count != 0:
                    res = res + str(count)
                res = res + one
                one = string[i]
                count = 0

        res = res + str(count)  # 最后一组相同的数
        res = res + one
        print(res)

getzip("xxuxxyyyyuyyzbbb")

K个一组翻转链表 leetcode 25（hard）

class Solution:
    def reverseKGroup(self, head: ListNode, k: int) -> ListNode:
        l = 0
        node = head
        while node: # 从node开始的链表长度
            l += 1
            node = node.next
        
        if k <= 1 or l < k: #无需分割，只有一个group：直接返回
            return head
        
        node, curr = None, head
        for _ in range(k):  # 每次对前后两个node进行交换
            nxt = curr.next
            curr.next = node
            node = curr
            curr = nxt
        # 交换到curr，然后recursion继续交换
        head.next = self.reverseKGroup(curr, k)
        return node

求n!后面有多少连续的0 172. Factorial Trailing Zeroes

在这里插入图片描述
看n！可以分解成多少个5的相乘，因为又大量的2存在，所以每一个5都会变成一个10.
trailing 0的数量 = n！的5的因子的数量

def trailingZeroes(self, n: int) -> int:
        number5 = 0
        while n >= 5:
            number5 += int(n/5)
            n = int(n/5)    # 一直除到小于5，无法找出因子5
        
        return number5

商汤-开发大类

7进制求和

输入描述：输入为空格分开的两个字符串，按字符串拆分即得到两个参数，如输入为“361 512”，拆分后为“361”和“512”，此输入合法。如果输入为“abc def”则不合法。
输出描述：输出按7进制相加的结果字符串。如果输入不合法，返回“NA”。
如：输入：361 512
输出：1203
说明：输入输出均按照字符串处理。

def to10(num, base = 7):
    if num = ' ':
        return 0
    for i, ele in enumerate(reversed(num)):
        res += int(ele) * pow(base, i)
    return res

def to7(num, base = 7):
    if num == 0:
        return '0'
    while num:
        res += str(num % base)
        num //= base
    return res[::-1]


while True:
    try:
        nums = list(map(int, input().split()))
        a = nums[0]
        b = nums[1]
        a10 = to10(a)
        b10 = to10(b)
        res = to7(a10 + b10)

华为笔试

输入输出

try except

输入描述:
输入包括两个正整数a,b(1 <= a, b <= 10^9),输入数据包括多组。
输出描述:
输出a+b的结果

while True:
    try:
        nums = input().split()
        print(int(nums[0]) + int(nums[1]))
    except:
        break

try except 在持续不断读取的时候，必不可少

input & sys.stdin.readline()

import sys
try:
 while True:
  print('Please input a number:')
  n = int(sys.stdin.readline().strip('\n')) #strip('\n')表示以\n分隔，否则输出是“字符串+\n”的形式
  print('Please input some numbers:')
  sn = sys.stdin.readline().strip()#若是多输入，strip()默认是以空格分隔，返回一个包含多个字符串的list。
  if sn == '':
   break
  sn = list(map(int,sn.split())) #如果要强制转换成int等类型，可以调用map()函数。
  print(n)
  print(sn,'\n')
except:
 pass

input输入很简单，就是获得用户的输入，一般是在控制台界面。
word=input(‘please input one or more word\n’)
print (word)
运行之后就可以等待用户输入了，最终系统会认为回车键是输入的结束，接下来对输入做任何处理就是你自己的事情啦。

while True:
 n = int(input('Please input a number:\n'))
 sn = list(map(int,input('Please input some numbers:\n').split()))
 print(n)
 print(sn,'\n')

sum(nums[1:])

List 求和，不用再遍历了。

sort()

list.sort(reverse=True|False, key=myFunc)

# A function that returns the 'year' value:
def myFunc(e):
  return e['year']

cars = [
  {'car': 'Ford', 'year': 2005},
  {'car': 'Mitsubishi', 'year': 2000},
  {'car': 'BMW', 'year': 2019},
  {'car': 'VW', 'year': 2011}
]

cars.sort(key=myFunc)

strip()

string.strip([chars])
chars (optional) - a string specifying the set of characters to be removed from the left and right part of the string.
If the chars argument is not provided, all leading and trailing whitespaces are removed from the string.
lstrip() / rstrip(): remove left / right

华为题库

a.count(b) a中有多少个b

字符串分割

连续输入字符串，请按长度为8拆分每个字符串后输出到新的字符串数组；
长度不是8整数倍的字符串请在后面补数字0，空字符串不处理。
输入：
abc
123456789
输出：
abc00000
12345678
90000000

while True:
    try:
        str1 = input()
        str2 = input()
        def ss(s):
            while len(s) > 8:	# 一直拆分直到长度小于等于8
                print(s[:8])
                s = s[8:]
            if 0 < len(s) <= 8:
                print(s + "0" * (8 - len(s)))
        ss(str1)
        ss(str2)
    except:
        break

进制转换

其他进制转十进制

>>> int('1101',2)  
13
>>> int('0o226',8)   #00226 0：阿拉伯数字零   o：小写英文字母 o    226：八进制数
150
>>> int('0x96',16)
150

十进制转二进制

>>> bin(13)
'0b1101'

八进制转二进制

>>> bin(0x33)
'0b110011'

二进制转八进制

>>> oct(0b10110011111)
'0o2637'

二进制转十六进制

hex(0b10110011111)
'0x59f'

0o：八进制表示；0b：二进制表示；0x：十六进制表示。后面跟各自进制的表示。

质数因子

功能:输入一个正整数，按照从小到大的顺序输出它的所有质因子（重复的也要列举）（如180的质因子为2 2 3 3 5 ）。最后一个数后面也要有空格

num = int(input())
def factor(x):
    isFac = 1
    for i in range(2, int(x**0.5 + 2)):
        if x % i == 0:
            isFac = 0    # num有因数，自己本身不是质数
            print(i, end = ' ')
            factor(x // i)
            break
    if isFac == 1: # num本身就是一个质数
        print(x, end = ' ')

factor(num)

合并表记录

输入描述:
先输入键值对的个数
然后输入成对的index和value值，以空格隔开
输出描述:
输出合并后的键值对（多行）
示例1
输入
4
0 1
0 2
1 2
3 4
输出
0 3
1 2
3 4
dictionary

Get the value of the “model” key:

x = thisdict["model"]
or
x = thisdict.get("model")

Print all key names in the dictionary, one by one:
x in dic: x 是 key 的值！

for x in thisdict:
  print(x)

Print all values in the dictionary, one by one:

for x in thisdict:
  print(thisdict[x])

Loop through both keys and values, by using the items() method:

for x, y in thisdict.items():
  print(x, y)

remove item

The pop() method removes the item with the specified key name:

thisdict = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
thisdict.pop("model")

The popitem() method removes the last inserted item

thisdict.popitem()

The del keyword removes the item with the specified key name:

del thisdict["model"]

The clear() method empties the dictionary:

thisdict.clear()

Copy dict:

mydict = thisdict.copy()

mydict = dict(thisdict)

Update:

  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}

car.update({"color": "White"})

get()
dictionary.get(keyname, value)
keyname: Required. The keyname of the item you want to return the value from
value: Optional. A value to return if the specified key does not exist. Default value None

n = int(input())
dic = {}
for i in range(n):
    nums = list(map(int, input().split(" ")))
    key = nums[0]
    value = nums[1]
    dic[key] = dic.get(key, 0) + value
for i in dic:
    print(i, dic[i])

倒序

input() [::-1]
reversed(input())

input()
读取的输入转化成了str !!!!

字符个数统计

编写一个函数，计算字符串中含有的不同字符的个数。字符在ACSII码范围内(0~127)，换行表示结束符，不算在字符里。不在范围内的不作统计。多个相同的字符只计算一次
输入
abaca
输出
3

string = input()
s = set()
count = 0
for i in string:
    if 0 < ord(i) < 127 and i not in s:
        count += 1
        s.add(i)
print(count)

ord( c) : 输入字符c，返回该字符在ASCII中对应的十进制码值（十进制整数）。
chr( i ): 输入十进制数字，返回该数字在ASCII中对应的字符。ord() 的对称函数。

背包问题

n,m=map(int,input().split())
f=[0]*n    #购物单总价值
#分组背包，每组有四种情况，a.主件 b.主件+附件1 c.主件+附件2 d.主件+附件1+附件2
v=[[0 for i in range(4)] for j in range(m+1)] #每组的价格
w=[[0 for i in range(4)] for j in range(m+1)] #每组的价格x重要度（权重）
n=n//10#价格为10的整数倍，节省时间
for i in range(1,m+1):    # 正在购买第i件物品
    x,y,z=map(int,input().split())
    x=x//10    # 单价
    # 主件。买第i个物品，对其四种组合方式赋值为主件的单价、权重
    if z==0:    # z=0：主件；z=1：附件
        for t in range(4):    
            v[i][t], w[i][t] = v[i][t]+x, w[i][t]+x* y
            
    # 附件。且a==b，意味着附件1没加入，这时候累加b跟d情况
    elif v[z][1]==v[z][0]:#如果a==b，添加附件1(如果a=b=c=d说明没有附件)
        v[z][1],w[z][1] = v[z][1] + x, w[z][1] + x* y    # b
        v[z][3],w[z][3] = v[z][3] + x, w[z][3] + x* y    # d
        
    #附件且a!=b，意味着附件1加入了附件2没加入，这时候累加c跟d情况
    else:
        v[z][2], w[z][2] = v[z][2] + x, w[z][2] + x* y
        v[z][3], w[z][3] = v[z][3] + x, w[z][3] + x* y
for i in range(1,m+1):
    # n:购物总资金上限，只能倒序遍历，因为背包的思维是可用空间从大到小，求当前每个子状态的最优
    for j in range(n,-1,-1):
        for k in range(4):
            if j>=v[i][k]:
                f[j]=max(f[j], f[j-v[i][k]] + w[i][k])
print(10*f[n])

坐标移动

A10;S20;W10;D30;X;A1A;B10A11;;A10;
处理过程：
起点（0,0）

A10 = （-10,0）
S20 = (-10,-20)
W10 = (-10,-10)
D30 = (20,-10)
x = 无效
A1A = 无效
B10A11 = 无效
一个空不影响
A10 = (10,-10)
结果（10， -10）

while True:
  try:
    x,y = 0,0
    a = input().split(';')
    for k in a:
      if k == '':
        continue
      if k[0] == 'A' and k[1:]>='1' and k[1:]<='99':
        x -= int(k[1:])
      if k[0] == 'D' and k[1:]>='1' and k[1:]<='99':
        x += int(k[1:])
      if k[0] == 'W' and k[1:]>='1' and k[1:]<='99':
        y += int(k[1:])       
      if k[0] == 'S' and k[1:]>='1' and k[1:]<='99':
        y -= int(k[1:]) 
    print(str(x)+','+str(y))
  except:
    break

判断IP地址和子网掩码

**IP地址**
在这里插入图片描述
A类地址第1个8位中的第1位始终为0 0-127.x.x.x 255.0.0.0/8
B类地址第1个8位中的第1、2位始终为10 128-191.x.x.x 255.255.0.0/16
C类地址第1个8位中的第1、2、3位始终为110 192-y.x.x.x 255.255.255.0/24
D类以1110开始用于组播
E类以11110开始用于科研保留
其中127.x.x.x段地址空间是被保留的回环地址

**子网掩码**
子网掩码只有一个作用，就是将某个IP地址划分成网络地址和主机地址两部分。
子网掩码连续全 1 的是网络地址，后面的 0 是主机地址。
IP地址和子网掩码进行与运算 and，结果是网络地址（即主机号全0是网络地址）
IP地址 and 子网掩码 = 网络地址

**广播地址**
主机地址段全部为 1
10.1.1.0 （255.255.255.0 ）网段，其广播地址为10.1.1.255 （255 即为2 进制的11111111 ）
当发出一个目的地址为10.1.1.255 的分组（封包）时，它将被分发给该网段上的所有计算机。

import sys
#判断子网掩码是否存在非连续的1，（以下是所有连续1的情况）
# 7,6,5,4,3,2,1,0 个 1
lll=['254','252','248','240','224','192','128','0']
A, B, C, D, E, err, pri = 0,0,0,0,0,0,0    # counter

def check_ip(ip):    #检测IP是否有效
    if len(ip) != 4 or " " in ip:
        return False
    else:
        for i in range(4):
            if int(ip[i]) < 0 or int(ip[i]) > 255:
                return False
        return True

def check_mask(ms):
    if len(ms) != 4:
        return False
    if ms[0] == '255':
        if ms[1] == '255':
            if ms[2] == '255':
                if ms[3] in lll:
                    return True
                else:
                    return False
            elif ms[2] in lll and ms[3] == '0':
                return True
            else:
                return False
        elif ms[1] in lll and ms[2] == ms[3] == '0':
            return True
        else:
            return False
    elif ms[0] in lll and ms[1] == ms[2] == ms[3] == '0':
        return True
    else:
        return False
    
while True:
    string = sys.stdin.readline().strip()
    if string == '':
        break
    iplist = string.split('~')[0]
    masklist = string.split('~')[1]
    ip = iplist.split('.')
    ms = masklist.split('.')
    if check_ip(ip) and check_mask(ms):
        if 1 <= int(ip[0]) <= 126:
            A += 1
        if 128 <= int(ip[0]) <= 191:
            B += 1
        if 192 <= int(ip[0]) <= 223:
            C += 1
        if 224 <= int(ip[0]) <= 239:
            D += 1
        if 240 <= int(ip[0]) <= 255:
            E += 1
        if (int(ip[0]) == 10 or (int(ip[0]) == 172 and 15 < int(ip[1]) < 32) or (int(ip[0])==192 and int(ip[1])==168):
            pri += 1
    else:
        err += 1
    
print('%s %s %s %s %s %s %s'%(A,B,C,D,E,err,pri))