华为0510 实习笔试

最新推荐文章于 2025-04-23 17:18:45 发布

原创最新推荐文章于 2025-04-23 17:18:45 发布 · 1k 阅读

6 ·

CC 4.0 BY-SA版权

文章标签：

#算法

1、栈数据合并

向一个空栈压入正整数，每当压入一个整数时，执行以下规则(设: 栈顶至栈底整数依次编号为n1、n2...nx， n1为最新压入的整数)

1.如果n1=n2，则n1、n2全部出栈，压入新数据m(m=2*n1)

2.如果n1=n2+...+ny(y的范围为[3,x]) ，则n1、n2...ny全部出栈，压入新数据m(m=2*n1)。

3.如果上述规则都不满足，则不做操作

如: 依次向栈压入6、1、2、3，当压入2时，栈顶至栈底依次为[2、1.6];当压入3时，3=2+1，3、2、1全部出栈，重新入栈整数6，此时栈顶至栈底依次为[6、6]; 6=6，两个6全部出栈，压入12，最终栈中只剩个元素12。

向栈中输入一串数字，请输出应用此规则后栈中最终存留的数字。

解答要求

时间限制: C/C++ 1000ms,其他语言: 2000ms

内存限制: C/C++ 256MB,其他语言: 512MB

输入

使用单个空格隔开的正整数的字符串，如"5 6 7 8”，左边的数字先入栈。

正整数大小为[1,2^31-1]。

正整数个数为[1,1000]。

输出

最终栈中存留的元素值，元素值使用单个空格隔开，如”8 7 6 5”，从左至右依次为栈顶至栈底的数字。

输入: 10 20 50 80 1 1
输出: 2 160
解释: 向栈压入80时，10+20+50=80，数据合并后入栈160，压入两个1时，合并为2，最终栈顶至栈底的数字为2和160。

//处理输入
arr = [int(c) for c in input().split(" ")]

//最终的结果栈
st = []

//主函数
def solve():
    //1，处理第一个逻辑，当栈最后两个数相等时，出栈之后求和进栈。
    if len(st) > 1 and st[-1] == st[-2]:
        num = st.pop()
        st.pop()
        st.append(2 * num)
        //由于可能处理完进栈跟前面相等，需重复处理。如1 1 1 1
        solve()

    //2，处理第二个逻辑，使用sum_记录前面栈的和
    elif len(st) >= 3:
        sum_ = 0
        for i in range(len(st) - 1):
            sum_ += st[len(st) - i - 2]
            if sum_ >= st[-1]:
                //等于将前面全部出栈
                if sum_ == st[-1]:
                    for _ in range(i+2): st.pop()
                    st.append(2 * sum_)
                    //如7 2 3 1 5 6
                    solve()
                //跳出循环
                break

for i in arr:
    st.append(i)
    solve()


while st:
    if len(st) > 1: print(st.pop(), end=" ")
    else: print(st.pop())

2、寻找密码串

1.截取M中的某一段数字x，和数字N进行k运算 (x k N)，如果结果是一个所有位数相同的数，则这段数字有可能就是所找密码，例如x为222，N为3，k为"，则计算结果是222*3=666，满足要求，x是所寻目标彩码串之一。

2.如果存在满足第1点的多种情况，则以计算结果最大的为准;

3.如果没有找到符合条件的密码串，则输出-1，表示密码串不存在

3.M的长度<100，N为正整数，且N<=9999999999，3<=所找密码长度<=12。k为+或-或中的一种，不考虑除法。为避免数据过于庞大，约定在乘法场景下，乘数最大为3位数。

解答要求

时间限制: C/C++ 1000ms,其他语言: 2000ms

内存限制: C/C++ 256MB,其他语言: 512MB

输入

提供加密后字符串M，秘钥数字N和运算符k，例如：

(加密字符串M) 748443217098

(秘钥数字N) 123

(运算符k) +

输出

满足计算结果所有位数相同，且计算结果最大的值。

例如:上述例子截取44321，和123相加，则为44321+123=44444，结果所有位的数字字符相同，包括个位数、十位数、百位数、千位数和万位数都是同一个数字字符4，且其值最大。

输入:

6833023887793076998810418710
2211
-
输出: 9988
解释: 通过计算，8877-2211=6666，而9988-2211=7777，因为7777>6666，则目标密码串为9988。

//三行输入
a = input()
b = int(input())
c = input()

size = len(a)

#使用一个set来判断子字符串的数字是否都是一样的，都是一样的才进行之后的判断
def is_valid(s:str):
    return len(set(s)) == 1

ans = 0

#这个循环结果是各个子字符串
for i in range(size):
    for len in range(13):
        now = int(a[i:i + len + 1])
        #如果是加法将子字符串和b进行相加
        if c == '+':
            if is_valid(str(now + b)):
                ans = max(ans, now)
        #如果是减法将子字符串和b进行相加
        elif c == '-':
            if is_valid(str(now - b)):
                ans = max(ans, now)
        #如果是乘法
        else:
            if is_valid(str(now * b)):
                ans = max(ans, now)

#输出有点问题
print(ans)

3、微服务调用链路染色最短时间

在微服务架构中，一个请求可能会经过若干个服务节点，其所经过的路径，我们称之为请求调用链路。通常，我们会把一些服务治理相关的字段(例traceld)，通过请求头的方式在整个链路中透传。当我们把有特定含义的请求头透传到整个链路，然后链路中每个服务会针对这个请求头做一些特殊的处理，我们把这种行为称之为链路染色。现给出在某一请求下其经过所有微服务节点的响应时长列表rsTimes，其中rsTimes[i]=(srcSerivce,dstService,rsTime)，其中srcSerivce为调用方服务,dstService为被调用方服务，所有服务名称由一个1到n范围内的整数表示，rsTime为接口调用响应耗时。如果srcSerivce与dstService相同，则表示系统自身计算耗时。所以如果服务srcService到dstService的染色总时长为srcService到dstService响应时长+dstService计算耗时，现给出一个调用源头服务名称service，请给出以这个服务作为源头服务发起调用，最终可实现染色的服务个数，并给出这些服务全部完成染色的最短时间。

解答要求

时间限制: C/C++ 1000ms,其他语言: 2000ms

内存限制: C/C++ 256MB,其他语言: 512MB

输入

第一行表示服务节点总数m

第二行表示服务间调用响应耗时或者服务自身计算耗时rsTmes的长度n

接下来n行表示具体的服务间调用响应耗时或者服务自身计算耗时

rsTmes[i]，每个数字间用空格隔开，比如 10 20 3，则表示10号服务调用20号服务的耗时为3秒

最后一行表示调用方源服务名称

提示:

1<=rsTimes.lenath<=5000 1<=srcSerivce<=100 1<=dstService<=100 1<=rsTime<=100

输出

输出分为两行，第一行输出最终可实现染色的微服务个数，第二行输出这些服务全部完成染色的最短时间

输入:

5

9

1 1 3
1 2 6
1 3 10
3 3 8
2 2 7
2 4 12
2 5 20
5 5 5
4 4 9
1
输出:

5

38
解释: 以服务1为起点计算最长耗时链路，分析可能会存在三条最大耗时链路，分别为1->3以及1->2->5以及1-2-4
第一条路径1->3路径下，总耗时为10(1->3耗时)+8(3自身耗时)=18秒
第二条路径1->2->5路径下，总耗时为6(1->2耗时)+7(2自身耗时)+20(2-5耗时)+5(5自身耗时)=38秒
第三条路径1->2->4路径下，总耗时为6(1->2耗时)+7(2自身耗时)+12(2->4耗时)+9(4自身耗时)=34秒
所以在此场景下，服务5完成染色的最短时间为38秒，为可以染色的所有服务节点的最长时间
最终输出结果分两行输出，最终1 2 3 4 5四个服务节点都可以实现染色，所以最终输出结果如下
5
38

输入:

5
1 2 5
2 3 10
1 3 3
3 1 2
3 2 9
3

输出:

3

7

解释：以服务3为起点计算最长耗时，3->1

import heapq
from collections import defaultdict
from math import inf

n = int(input())
m = int(input())

sysTime = defaultdict(int)
nxs = defaultdict(list)

for _ in range(m):
    s,d,t = map(int, input().split(" "))
    if s != d: nxs[s].append((d,t))
    else:
        sysTime[s] = t

start = int(input())

h = []
heapq.heappush(h, (0, start)) # 距离 节点
dis = [inf for _ in range(n+1)]
dis[start] = 0

while h:
    time, node = heapq.heappop(h)
    for nx, nxtime in nxs[node]:
        if dis[nx] > time + sysTime[nx]+ nxtime:
            heapq.heappush(h, (time + sysTime[nx]+ nxtime, nx))
            dis[nx] = min(dis[nx], time + sysTime[nx]+ nxtime)


cnt, res = 0, 0
for d in dis:
    if d != inf:
        cnt+=1
        res = max(res, d)

print(cnt)
print(res)

文章参考：万诺coding