华为笔试题2020(3月11日)

1. shell字符串替换

"""
题目描述：
    xxx=lyf/${ttt}/test 表示shell环境下的${yyy}，编译时转换为 xxx
    ttt=www,
    yyy=seeyou
    目标aa=/aaa/${xxx}/bbb/${yyy}/ccc 输出编译以后的结果

    解决思路：字符串分割 递归
    1. 将可替换部分找出来，如xxx=lyf/${ttt}/test  变成(${xxx},lyf/${ttt}/test) 左边是目标字符串中能够替换的部分，右边是替换后的结果
    2. 遍历目候选替换集，找出目标串中所有能匹配的部分，进行替换，因为替换后的结果可能还有待替换的部分，需要递归，结束条件是，没有可以换的部分了

    Python用到的内置函数：
    split字符串分割 str.split(sep=None, maxsplit=-1) 题中以"="进行分割
    replace() 字符串替换  str.replace(old, new, count=None)
    find() 匹配串是否出，string(sub, start=None, end=None) 返回idx 或者-1
"""

import sys

def replace_str(array,available):
    """

    :param array:
    :param avilables: 替换候选集
    :return:
    """
    aim_arr=array[-1] #目标串

    for key,sub in available:
        aim_arr=aim_arr.replace(key,sub)
        
    array.pop()
    array.append(aim_arr)

    flag=0
    for key1 ,sub1  in available:
        if aim_arr.find(key1)!=-1:
            flag=0
            break
        else:
            flag=1
    if flag==1:
        return array
    return replace_str(array,available)

def getAvailable(array):
    """
    分割部分
    :param array:
    :return:
    """
    available = []
    for i in range(len(array) - 1):
        key, sub = array[i].split('=')

        # print('key',key)
        # print('sub:',sub)

        arr2 = '${' + key + '}'
        tup = (arr2, sub)
        available.append(tup)
    print('可替换词：', available)
    return available


if __name__ == '__main__':
    # 读取第一行的n
    # n = int(sys.stdin.readline().strip())
    #
    # array=[]
    # for i in range(n):
    #     line=sys.stdin.readline().strip()
    #     array.append(line)
    #     # print(line)
    # print(array)
    
    array=['xxx=lyf/${ttt}/test',
    'ttt=www',
    'yyy=seeyou',
    'aa=/aaa/${xxx}/bbb/${yyy}/ccc']
    # print(array)
 
    available=getAvailable(array)

    arr=replace_str(array,available)
    result=arr[-1]
    zu,yu=result.split('=')
    print(yu)

2. 小蜜蜂

"""
题目大意是：
平原上一群蜜蜂开始采蜜，要连续采集5片花丛后才可以归巢。
已知5片花丛相对于蜂巢的坐标，请你帮助蜜蜂规划一下要访问的花丛的顺序，以使飞行的总距离最短。

输入描述：以蜂巢为平面原点的5片花丛A、B、C、D、E的坐标，值为整数。
输出：从出发到返回蜂巢的最短路径长度，取整数，即舍弃小数点后的值。

例如：
输入：200，0，200，10，200，50，200，30，200，25
输出：456

类型：图 最短路径 迪杰斯特拉 贪心算法 双重循环

解题思路：
路径path=[0]
候选点vertex=[1,2,3,4,5]
cost=0.0
从原点出发，从候选点中找到距离最近的点，将这两点的距离加入到cost，候选点集中删除这个点，路径中加上这个点，start起始点变为这个点，循环，直到path=6
"""
import math
def getGraph(array):
    """
    将数据存为图 邻接矩阵
    :param array:  [200，0，200，10，200，50，200，30，200，25]
    :return:  graph
    """
    #将原点插入到里面去
    array.insert(0,0)
    array.insert(0,0)

    print(array)
    length=len(array)
    graph=[]

    i=0
    while(i<length):
        vertex=[]
        start=array[i],array[i+1]

        j=0
        while(j<length):
            curent=array[j],array[j+1]
            dist=(math.sqrt((start[0]-curent[0])**2+(start[1]-curent[1])**2))
            vertex.append(dist)
            j=j+2
        graph.append(vertex)
        i=i+2
    print(graph)
    return graph
    
def dijkstar(graph):
    """
    寻找最短路径
    :param graph:
    :param start:

    求解各节点最短路径，获取path，和cost数组，
    path[i] 表示vi节点的前继节点索引，一直追溯到起点。
    cost[i] 表示vi节点的花费
    """
    start=0
    path=[start]
    cost=0.0
    vertex=[i for i in range(len(graph))]
    vertex.remove(start) #候选节点


    while True:
        print("path:",path,len(path))
        print("vertex:",vertex,len(vertex))

        if len(path)<len(graph):

            houxuan=[]
            for v in vertex:
                houxuan.append([v,graph[start][v]])

            print("候选长度：",houxuan)
            min_value = houxuan[0][1]
            min_idx=houxuan[0][0]
            for i in range(len(houxuan)):
                if houxuan[i][1]<min_value:
                    min_value=houxuan[i][1]
                    min_idx=houxuan[i][0]

            print("候选点：",min_idx)
            print("候选值：",min_value)

            path.append(min_idx)

            cost+=min_value
            start=min_idx

            vertex.remove(min_idx)

        else:
            break

    return path ,cost

if __name__ == '__main__':
    array = [200, 0, 200, 10, 200, 50, 200, 30, 200, 25]

    graph = getGraph(array)


    path, cost=dijkstar(graph)
    print("path:",path)
    print("cost:",cost)

    result=cost+graph[0][path[-1]]
    print(int(result))

4. Include

1. 字符串

计算字符串最后一个单词的长度，单词以空格隔开。
输入描述：一行字符串，非空，长度小于5000。
输出描述：整数N，最后一个单词的长度。
示例1
输入：hello world
输出：5

#include <iostream>
#include <string>

using namespace std;

int main()
{
    string s;
    int length=0;
    int num=0;

    getline(cin,s);
    length=s.length();
    
    for(int i=length-1;i>=0;i--){
        if(s[i]!=' '){
            num+=1;
        }
        if (num!=0 && s[i]==' '){
            break;
        }
    }
    cout<<num<<endl;

    return 0;
}

def countEnglish(array):
    """
    计算最后一个单词的个数
    :param array: list形式，从键盘输入的一串带空格的字符串
    :return:
    """
    length=len(array)
    num=0
    for i in range(length-1,-1,-1):
        if array[i]!=' ':
            num+=1
        if num!=0 and array[i]==' ':
            break
    return num
if __name__ == '__main__':
    import sys
    str=sys.stdin.readline().strip('\n')
    num=countEnglish(str)
    print(num)