2022.9.7华为笔试

已于 2022-09-22 15:37:09 修改
阅读量866 收藏 7
点赞数
分类专栏： 笔试面试整理 文章标签： 华为
于 2022-09-13 21:43:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51211461/article/details/126834267
版权

第一题:

 

public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()) {
            //输入
            int n = scanner.nextInt();
            scanner.nextLine();
            int row = scanner.nextInt();
            scanner.nextLine();
            //用于存储亲属关系的map<son-father>
            HashMap<Integer, Integer> relation = new HashMap<>();
            for (int i = 0; i < row; i++) {
                String s = scanner.nextLine();
                String[] split = s.split("\\s+");
                int father = Integer.parseInt(split[0]);
                for (int j = 1; j < split.length; j++) {
                    int son = Integer.parseInt(split[j]);
                    relation.put(son, father);
                }
            }
            int m1 = scanner.nextInt();
            int m2 = scanner.nextInt();
            List<Integer> m1List, m2List;
            m1List = new ArrayList<>();
            m2List = new ArrayList<>();
            getList(m1, relation, m1List);
            getList(m2, relation, m2List);
            int res = calculateDis(m1List, m2List);
            System.out.println(res);
        }
    }

    private static int calculateDis(List<Integer> m1List, List<Integer> m2List) {
        for (int i = 0; i < m1List.size(); i++) {
            Integer num1 = m1List.get(i);
            for (int j = 0; j < m2List.size(); j++) {
                Integer num2 = m2List.get(j);
                if(num1.equals(num2)){
                    return i+j;
                }
            }
        }
        return -1;
    }

    private static void getList(int m, HashMap<Integer, Integer> relation, List<Integer> list) {
        list.add(m);
        if (relation.containsKey(m)) {
            getList(relation.get(m), relation, list);
        }
    }

 第二题:

 

 

   static int[] dx = {0, -1, 0, 1};
    static int[] dy = {1, 0, -1, 0};
    static boolean[] direction = {false, true, false, true};//上下定义为true,横向定义为false

    private static int getShortDis(char[][] grid, int[] start, int[] end) {
        int m = grid.length, n = grid[0].length;
        boolean[][] visited = new boolean[m][n];
        //按照距离升序排列
        PriorityQueue<Node> nodes = new PriorityQueue<>((a, b) -> {
            return a.dis - b.dis;
        });
        //添加初始节点
        nodes.add(new Node(start[0], start[1], 0, null));
        while (!nodes.isEmpty()) {
            Node poll = nodes.poll();
            //已经遍历过则跳过
            if (visited[poll.x][poll.y]) continue;
            visited[poll.x][poll.y] = true;
            //如果途中找到了结果直接返回
            if (poll.x == end[0] && poll.y == end[1]) return poll.dis;
            for (int i = 0; i < 4; i++) {
                int numSteps = 0;
                int x = poll.x+dx[i], y = poll.y+dy[i];
                //如果发生方向的转变需要额外增加1步
                if (poll.isUpDown != null && poll.isUpDown != direction[i]) {
                    numSteps++;
                }
                //搜索目标结果
                while (x >= 0 && x  < m && y  >= 0 && y  < n && (grid[x ][y ] == 'B' || grid[x][y ] == 'E')) {
                    numSteps++;
                    //如果已访问则不参与排序
                    if (!visited[x][y]) nodes.add(new Node(x, y, poll.dis + numSteps, i == 1 || i == 3));
                    x+=dx[i];
                    y+=dy[i];
                }
            }
        }
        return -1;
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()) {
            int row = scanner.nextInt();
            int col = scanner.nextInt();
            scanner.nextLine();
            char[][] grid = new char[row][col];
            int[] start = new int[2];
            int[] end = new int[2];
            for (int i = 0; i < row; i++) {
                String s = scanner.nextLine();
                for (int j = 0; j < col; j++) {
                    grid[i][j] = s.charAt(j);
                    if (grid[i][j] == 'S') {
                        start[0] = i;
                        start[1] = j;
                    } else if (grid[i][j] == 'E') {
                        end[0] = i;
                        end[1] = j;
                    }
                }
            }
            System.out.println(getShortDis(grid, start, end));

        }
    }

    static class Node {
        int x, y, dis;
        Boolean isUpDown;

        public Node(int x, int y, int dis, Boolean isUpDown) {
            this.x = x;
            this.y = y;
            this.dis = dis;
            this.isUpDown = isUpDown;
        }
    }

第三题

 

   static int[] dx = {1, -1, 0, 0};
    static int[] dy = {0, 0, 1, -1};

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()) {
            int m = scanner.nextInt();
            int n = scanner.nextInt();
            int begin_x = scanner.nextInt() - 1;
            int begin_y = scanner.nextInt() - 1;
            int[][] grid = new int[m][n];
            for (int i = 0; i < m; i++) {
                scanner.nextLine();
                for (int j = 0; j < n; j++) {
                    grid[i][j] = scanner.nextInt();
                }
            }
            PriorityQueue<Node> queue = new PriorityQueue<>((a, b) -> {
                if (a.dis == b.dis) {
                    if (a.x == b.x) {
                        return a.y - b.y;
                    }
                    return a.x - b.x;
                }
                return a.dis - b.dis;
            });
            Node begin = new Node(begin_x, begin_y, 0);
            queue.add(begin);
            boolean[][] visited = new boolean[m][n];
            Direction[][] direction = new Direction[m][n];//记录方向的数组 0123分别表示上左右下
            while (!queue.isEmpty()) {
                Node poll = queue.poll();
                if (visited[poll.x][poll.y]) continue;
                if (grid[poll.x][poll.y] == 1 && (direction[poll.x][poll.y].y == poll.y)) {//只能从竖直方向进入
                    Deque<Integer> path = getPath(direction, begin_x, begin_y, poll.x, poll.y);
                    System.out.println(path.toString());
                    return;
                }
                visited[poll.x][poll.y] = true;
                for (int i = 0; i < 4; i++) {
                    //计算步数
                    int numSteps = 0;
                    int x = poll.x + dx[i], y = poll.y + dy[i];
                    while (x >= 0 && y >= 0 && x < m && y < n && (grid[x][y] == 0 || grid[x][y] == 1)) {
                        numSteps++;
                        if(!visited[x][y]){
                            direction[x][y] = new Direction(poll.x, poll.y);
                            Node node = new Node(x, y, numSteps + poll.dis);
                            queue.add(node);
                        }
                        x += dx[i];
                        y += dy[i];
                    }
                }
            }
            System.out.println(-1 + " " + -1);
        }
    }

    private static Deque<Integer> getPath(Direction[][] direction, int begin_x, int begin_y, int end_x, int end_y) {
        Deque<Integer> res = new LinkedList<>();
        int x = end_x, y = end_y;
        res.push(end_y + 1);
        res.push(end_x + 1);
        while (x != begin_x || y != begin_y) {
            Direction dir = direction[x][y];
            int cur_x = dir.x, cur_y = dir.y;
            while (x != cur_x || y != cur_y) {
                if (x < cur_x) {
                    x++;
                } else if (y < cur_y) {
                    y++;
                } else if (x > cur_x) {
                    x--;
                } else {
                    y--;
                }
                res.push(y + 1);
                res.push(x + 1);
            }
            x = dir.x;
            y = dir.y;
        }

        return res;
    }

    static class Node {
        int x, y, dis;

        public Node(int x, int y, int dis) {
            this.x = x;
            this.y = y;
            this.dis = dis;
        }
    }

    static class Direction {
        int x;
        int y;
        public Direction(int x, int y) {
            this.x = x;
            this.y = y;
        }
    }

9.21华为笔试第二题

 X代表不能走,S代表驿站,可以切换为马或者兵(需要耗费1步),驿站代表可以切换为兵或者马,马走日字,兵走上下左右,.代表正常道路,问从0,0到(m-1,n-1)所使用的最小步数

static char[][] grid;
    static int m, n;
    static boolean[][] usedHorse;
    static boolean[][] usedSoldier;
    static int[][] horseDirect = new int[][]{{1, 2}, {1, -2}, {-1, 2}, {-1, -2}, {-2, 1}, {-2, -1}, {2, 1}, {2, -1}};
    static int[][] soldierDirect = new int[][]{{0, 1}, {0, -1}, {-1, 0}, {1, 0}};

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()) {
            m = scanner.nextInt();
            n = scanner.nextInt();
            scanner.nextLine();
            grid = new char[m][n];
            for (int i = 0; i < m; i++) {
                String s = scanner.nextLine();
                for (int j = 0; j < n; j++) {
                    grid[i][j] = s.charAt(j);
                }
            }
            usedHorse = new boolean[m][n];
            usedSoldier = new boolean[m][n];
            PriorityQueue<Node> nodes = new PriorityQueue<>((a, b) -> {
                return a.dis - b.dis;
            });
            if (grid[0][0] == 'S') {
                nodes.add(new Node(0, 0, 0, true));
                nodes.add(new Node(0, 0, 1, false));
            } else if (grid[0][0] == '.') {
                nodes.add(new Node(0, 0, 0, true));
            } else {
                System.out.println(-1);
                return;
            }
            while (!nodes.isEmpty()) {
                Node poll = nodes.poll();
                int curX = poll.x, curY = poll.y;
                boolean curState = poll.isSoldier;
                if (usedSoldier[curX][curY] && curState||(usedHorse[curX][curY]&&!curState)) continue;
                System.out.println("<"+curX+","+curY+">-->"+curState+"-->"+poll.dis);
                if (curState) {
                    usedSoldier[curX][curY] = true;
                } else {
                    usedHorse[curX][curY] = true;
                }
                if (curX == m - 1 && curY == n - 1) {
                    System.out.println(poll.dis);
                    return;
                }
                if (curState) {
                    for (int[] dir : soldierDirect) {
                        int step = 0;
                        int x = dir[0] + curX, y = dir[1] + curY;
                        while (isValid(x, y) && grid[x][y] != 'X') {
                            step++;
                            if (grid[x][y] == 'S' && !usedHorse[x][y]) {
                                nodes.add(new Node(x, y, poll.dis + step + 1, false));
                            }
                            if (!usedSoldier[x][y]) nodes.add(new Node(x, y, poll.dis + step, true));
                            x += dir[0];
                            y += dir[1];
                        }
                    }
                } else {
                    for (int[] dir : horseDirect) {
                        int step = 0;
                        int x = dir[0] + curX, y = dir[1] + curY;
                        while (isValid(x, y) && grid[x][y] != 'X') {
                            step++;
                            if (grid[x][y] == 'S' && !usedSoldier[x][y]) {
                                nodes.add(new Node(x, y, poll.dis + step + 1, true));
                            }
                            if (!usedHorse[x][y]) nodes.add(new Node(x, y, poll.dis + step, false));
                            x += dir[0];
                            y += dir[1];
                        }
                    }
                }
            }
            System.out.println(-1);
        }
    }

    static boolean isValid(int x, int y) {
        return x >= 0 && y >= 0 && x < m && y < n;
    }

    static class Node {
        int x, y, dis;
        boolean isSoldier;

        public Node(int m, int n, int dis, boolean isSoldier) {
            this.x = m;
            this.y = n;
            this.dis = dis;
            this.isSoldier = isSoldier;
        }
    }

测试输入

9 9
.........
.....XXX.
.....X.X.
.....X.X.
.....X.XS
XXXXXX.XX
.........
.........
.........
<0,0>-->true-->0
<0,1>-->true-->1
<1,0>-->true-->1
<0,2>-->true-->2
<1,1>-->true-->2
<2,0>-->true-->2
<1,2>-->true-->3
<2,1>-->true-->3
<3,0>-->true-->3
<0,3>-->true-->3
<0,4>-->true-->4
<2,2>-->true-->4
<1,3>-->true-->4
<3,1>-->true-->4
<4,0>-->true-->4
<2,3>-->true-->5
<1,4>-->true-->5
<3,2>-->true-->5
<4,1>-->true-->5
<0,5>-->true-->5
<4,2>-->true-->6
<2,4>-->true-->6
<3,3>-->true-->6
<0,6>-->true-->6
<3,4>-->true-->7
<4,3>-->true-->7
<0,7>-->true-->7
<4,4>-->true-->8
<0,8>-->true-->8
<1,8>-->true-->9
<2,8>-->true-->10
<3,8>-->true-->11
<4,8>-->true-->12
<4,8>-->false-->13
<5,6>-->false-->14
<3,6>-->false-->14
<6,7>-->false-->14
<8,6>-->false-->15
<2,4>-->false-->15
<7,7>-->false-->15
<7,5>-->false-->15
<4,4>-->false-->15
<2,8>-->false-->15
<6,4>-->false-->15
<6,8>-->false-->15
<4,6>-->false-->15
<8,8>-->false-->15
15

兴趣使然的CV工程师
关注
  • 0
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
【2024-03-20】华为春招笔试三道编程题解
试问道几许
03-21 875
恭喜发现宝藏！搜索公众号【TechGuide】回复公司名，解锁更多新鲜好文和互联网大厂的笔经面经。作者@TechGuide【全网同名】
华为 2022_09_07 笔试题复盘
玛卡巴卡的博客
09-08 1893
华为笔试题复盘
华为机试 迷宫最短路径
仲翎逸仙
09-10 1782
闯迷宫   描述: sun所在学校每年都要举行电脑节，今年电脑节有一个新的趣味比赛项目叫做闯迷宫。 sun的室友在帮电脑节设计迷宫，所以室友就请sun帮忙计算下走出迷宫的最少步数。 知道了最少步数就可以辅助控制比赛难度以及去掉一些没有路径到达终点的map。 比赛规则是：从原点（0,0）开始走到终点（n-1,n-1），只能上下左右4个方向走，只能在给定的矩阵里走。
【笔试题汇总】华为春招笔试题解 2024-4-17
最新发布
fans2306的博客
04-27 2063
这里是paoxiaomo，一个现役ACMer，之后将会持续更新算法笔记系列以及笔试题题解系列本文章面向想打ICPC/蓝桥杯/天梯赛等程序设计竞赛，以及各个大厂笔试的选手有什么想看的算法专题可以私信博主（本文题面由收集）
华为笔试题目100及最佳答案,华为笔试题库与答案
chatgpt001的博客
10-07 801
华为OD机试是华为的笔试（因为是在电脑上做题，所以称为机试）。主要用于评估求职者是否适合所申请的职位。华为OD机试通常涵盖了多个测试领域，如算法构造、编程技巧以及错误修复等，其目标是全面评估求职者的基础知识实践技能和编程逻辑等能力。这是华为招聘过程中至关重要的一步。
华为机试（6.17笔试题解析）
yuhaomogui的博客
06-18 2万+
6.17号参加华为机试题的题目分享与解答，三题均通过。
huawei.rar_华为_华为笔试
09-24
【华为笔试知识点详解】 华为作为全球知名的电信设备与消费电子制造商，其招聘流程严谨且具有挑战性，尤其在笔试环节，考察的知识点广泛且深入。本资料“huawei.rar”包含了一份华为的经典笔试题和面试题，对于有意...
华为隐私保护治理白皮书（2022.11）共9页.pdf.z
11-20
【华为隐私保护治理白皮书（2022.11）共9页.pdf】 华为作为全球知名的电信设备和消费电子制造商，始终将用户隐私保护视为企业社会责任的重要组成部分。这份2022年11月发布的隐私保护治理白皮书详细阐述了华为在隐私...
华为射频岗笔试题.docx
04-25
在华为射频岗位的笔试中，涉及到的是一系列关于射频工程的基础知识，包括电磁波传播、射频器件性能、电路损耗、噪声系数、反射系数、电压驻波比（VSWR）以及功率增益等相关概念。 1. **电磁波与介质** - 波长与...
2020七月华为天线笔试.docx
06-12
在2020年华为天线工程师的笔试中，考生需要具备扎实的天线理论知识，这包括但不限于以下几个方面： 1. **天线基本原理**：天线是无线通信系统中的关键组件，负责电磁波的发射和接收。理解天线的工作原理，如辐射...
2021年7月华为射频笔试.docx
07-21
清晰度高
java写花束_AcWing 1101. 献给阿尔吉侬的花束-Java
weixin_39992831的博客
02-13 118
import java.util.*;import java.io.*;public class Main {static int[] dx = {-1, 0, 1, 0};static int[] dy = {0, 1, 0, -1};static int row;static int col;static char[][] arr;static int[][] visited;public s...
华为历届笔试面试题整理大全
热门推荐
wodwl的专栏
10-14 4万+
整理了一下华为往届笔试面试题，希望对大家有帮助： 超级有用的面试题：Java常见面试题    常见算法面试题   数据库常见面试题  操作系统常见面试题   C/C++常见面试题  大数据常见面试   python常见面试 来源：华为笔试面试圈&gt;&gt; 1、2018华为校招机试题目 2、2018华为届校园招聘软件开发岗笔试题 3、2017华为笔试题及答案 4、2017年华为笔试...
华为这么容易进吗？轻轻松松拿到25K的offer...
HUA1211的博客
06-20 1600
（1）简历深挖。（2）字符串中的某个字符出现的次数。（3）给定一个链表，将倒数第 n 个结点删除。（leetcode第19题）删除一个结点，无非是遍历链表找到那个结点前边的结点，然后改变下指向就好。先遍历一遍得到它的长度，之后用长度减去 n 就是要删除的结点的位置，然后遍历到结点的前一个位置就好了。（4）测试的流程。
2023年华为笔试面试机考真题100道（C/C++语言）
Gabriel.Tian的博客
07-07 3万+
华为面试 机考 C语言
2024年华为HCIE笔试题一（亲测800分以上）
lwljh134的博客
03-25 1905
A.使用PS功能，在某些情况下可以减轻网络环境的影响，如向服务器传输采集的信息时，Python脚本中可以实现当网络不通时，将执行结果暂存在设备，等网络恢复后再传输到服务器的功能。24、通过iMaster NCE-Campus部署的拟化园区网络场景中，创建VPN后，还需要配置VPN互通，以下关于配置互通的描述中，正确的是哪一项？23、网络切片技术可在网络中划分出独享的网络资源，用于承载高价值业务流量，以下关于网络切片的描述，错误的是哪一项？、如图所示是某位网络工程师在排查OSPF故障时的输出信息。
burpsuite2022.5.1安装教程
09-07
以下是安装Burp Suite 2022.5.1的教程： 1. 首先，确保你已经下载了Burp Suite 2022.5.1的安装文件。 2. 接下来，你可以选择使用以下两种方法之一进行激活和启动Burp Suite。 方法一：使用华为镜像进行激活和...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值