精华内容
下载资源
问答
  • 华为OD机试真题.pdf

    2021-04-15 16:31:36
    华为机试真题(非牛客网试练题)OD考试真题,不定期更新,文档含代码解答
  • 华为OD笔试202010OD笔试华为OD考勤全勤奖 前言:题目纯靠记忆。这些题目基本不涉及算法,而且能暴力就暴力。 考勤题(任意的连续7次考勤中,缺勤、迟到、早退的次数不超过3次)有点滑动窗口双端队列的意思,but我太...

    华为OD笔试202010OD笔试华为OD考勤全勤奖

    前言:题目纯靠记忆。这些题目基本不涉及算法,而且能暴力就暴力。
    考勤题(任意的连续7次考勤中,缺勤、迟到、早退的次数不超过3次)有点滑动窗口双端队列的意思,but我太菜了
    在这里插入图片描述

    1、考勤全勤奖
    absent 缺勤
    late 迟到
    leaveearly 早退
    present 正常上班

    能获得全勤奖的条件:
    缺勤次数不超过1次
    不能连续迟到/早退
    任意的连续7次考勤中,缺勤、迟到、早退的次数不超过3次。

    案例1输入:
    第一行代表输入一个数字n,代表接下来要输入n行字符串,
    每行字符串都要输出一个结果,获得全勤奖输出true ,否则false
    所有的结果是一行输出的,空格连接。

    2
    present
    present absent present present leaveearly present absent
    

    输出:

    true false
    

    案例2输入:

    1
    present absent present present leaveearly present absent 
    

    输出:

    false
    

    当时AC了的

    import java.util.Scanner;
    public class MyTest {
        public static void main(String[] args) {
            Scanner sc = new Scanner(System.in);
            //int cnt = sc.nextInt();
            int cnt;
            cnt = Integer.parseInt(sc.nextLine());
            String[] arr = new String[cnt];
            for (int i = 0; i < cnt; i++) {
                String s = sc.nextLine();
                arr[i] = s;
            }
            MyTest myTest = new MyTest();
    
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < cnt; i++) {
                if (arr[i] == null || arr[i].length() == 0)
                    break;
                String[] split = arr[i].split(" ");
                int absentCnt = 0;
                //上次迟到早退位置
                int lastLastOrEarly = -1;
                boolean flag = false;
                for (int j = 0; j < split.length; j++) {
                    //缺勤
                    if ("absent".equalsIgnoreCase(split[j])) {
                        absentCnt++;
                        if (absentCnt >= 2) {
                            sb.append("false ");
                            flag = true;
                            break;
                        }
                        //迟到、早退
                    } else if ("late".equalsIgnoreCase(split[j]) || "leaveearly".equalsIgnoreCase(split[j])) {
                        if (lastLastOrEarly == -1) {
                            lastLastOrEarly = j;
                        } else {
                            if (j - lastLastOrEarly == 1) {
                                sb.append("false ");
                                flag = true;
                                break;
                            } else
                                lastLastOrEarly = j;
                        }
                    }
                    //连续7次能获奖true
                    boolean b = myTest.judge7C(split, j);
                    if (!b) {
                        sb.append("false ");
                        flag = true;
                        break;
                    }
                }
                if (!flag)
                    sb.append("true ");
            }
            System.out.println(sb.toString().trim());
        }
    
        private boolean judge7C(String[] split, int now) {
            int cnt = 0;
            if (now < 7) {
                for (int i = 0; i <= now; i++) {
                    String s = split[i];
                    if ("absent".equals(s) || "late".equals(s) || "leaveearly".equals(s)) {
                        cnt++;
                    }
                }
            } else {
                for (int i = now - 6; i <= now; i++) {
                    String s = split[i];
                    if ("absent".equals(s) || "late".equals(s) || "leaveearly".equals(s)) {
                        cnt++;
                    }
                }
            }
            return cnt <= 3;
        }
    }
    

    第一题传送门:华为OD笔试202010OD笔试华为OD第一题考勤全勤奖

    第二题传送门:华为OD笔试202010OD笔试华为OD第二题最长的非递减连续子序列的长度

    第三题传送门:华为OD笔试202010OD笔试华为OD第三题入栈操作

    展开全文
  • 华为OD笔试202010OD笔试华为OD第三题入栈操作 输入 5 10 20 50 85 1 输出 1 170 输入 6 7 8 13 9 输出 9 13 8 7 6 解释 输入入栈 6 1 2 3 5 按顺序入栈 6 1 2 3 = 2 + 1 然后把 2 1 出栈,再把2*3=6入栈,此时 6=6...

    华为OD笔试202010OD笔试华为OD第三题入栈操作

    输入
    5 10 20 50 85 1
    输出
    1 170
    
    输入
    6 7 8 13 9
    输出
    9 13 8 7 6
    

    解释

    输入入栈
    6 1 2 3 5
    按顺序入栈
    6
    1
    2
    3 = 2 + 1
    然后把 2 1 出栈,再把2*3=6入栈,此时
    6=66 6 出栈,再把2*6=12入栈,
    5
    
    输出:
    5 12
    
    import java.util.Scanner;
    public class Main{
        public static void main(String[] args) {
            Scanner sc = new Scanner(System.in);
            int len = 0;
            String[] split = sc.nextLine().split(" ");
            int[] nums = new int[split.length];
            for (int i = 0; i < split.length; i++) {
                int num = Integer.parseInt(split[i]);
                nums[len] = num;
                len = pushStack(nums, len);
            }
            for (int i = len - 1; i >= 0; i--) {
                System.out.print(nums[i] + " ");
            }
        }
    
        private static int pushStack(int[] nums, int len) {
            int tmpNum = nums[len];
            int tmpLen = len - 1;
            while (tmpNum > 0 && tmpLen >= 0) {
                tmpNum = tmpNum - nums[tmpLen];
                if (0 == tmpNum) {
                    // 2*num
                    nums[tmpLen] = 2 * nums[len];
                    len = tmpLen;
                    int i = pushStack(nums, len);
                    return i;
                }
                tmpLen--;
            }
            len++;
            return len;
        }
    }
    

    第一题传送门:华为OD笔试202010OD笔试华为OD第一题考勤全勤奖

    第二题传送门:华为OD笔试202010OD笔试华为OD第二题最长的非递减连续子序列的长度

    展开全文
  • 华为od热乎的机考真题,研发岗

    今天是12.5

    前言

    第一次投华为:
    很早之前就有个华为的人联系我投递,去华为系统投递的,然后说要给我发笔试。不过现在我的投递档案还在华为的系统里挂着。后续就把我鸽了(跟我说是因为政策原因不招了,反正我是不太信,在那沐浴更衣干等了一天,有时候实在是不要报太大的期望)。
    第二次投华为:
    然后又过了一两周在牛客上hr看了我的简历就跟我说周三给我发笔试链接,结果说忘记了还是咋的,周五给我发,因为被鸽过一次了我就没有什么期待。到下午了邮件发到了:
    在这里插入图片描述下面的正文有个确认参加,有效时间是7天内。然后我今天做了这个题跟大家一起分享一下。

    (个人感觉第一次是华为招的正式员工把我简历刷了,第二个是华为od,不懂的同学可以去查一查有啥区别,不过od一般也能给到20k+起步)

    以下是题目正文(个人回忆的,尽量贴近题目意思):
    总分:400分

    第一题:(100分) 求数组

    给两个数字,第一个是总数n,第二个是划成多少分k,也就是把一个正整数分割成一个递增1的数组。如果划分不了就输出-1。

    输入样例1:15 5
        输出:1 2 3 4 5
    
    输入样例2:  3 5
    	输出: -1
    

    我对于这个题目的解法大概就是分组讨论,先把n<k的情况拿掉。奇数偶数分开处理。

    1. 奇数直接拿n/k能得到中间的数字,然后推出来一个式子:(要满足着个式子大于0才能找到目标数组)

      n/k - k/2 + i
      

      就可以输出目标数组(i从0开始到k-1)

    2. 对偶数的处理复杂一点,我是用了一个变量temp来存n(浮点数)的值。如果temp/k == n/k+0.5 那么认为这个数是可以划分为这么多组的,同时还要满足以下的递推式>0。

      n/k - k/2 + i
      

      就可以输出目标数组(i从1开始到k)

    然后第一题还有坑,我第一次只过了95%。后来写了个样例 1 1居然输出个-1,特判一下就A了。

    第二题 (100分)设计流水线

    模拟短进程优先算法,题目会给出拥有的线程数n,任务数m, 以及每个任务需要的时间,要求模拟短进程优先算法求最后的运行时间。

    输入: 3 5
    	  3 2 4 1 5
    输出: 7
    说明:先把耗时1 2 3的进程分别分配给1 2 3号线程,然后一个单位时间之后线程1闲置,把当前最短的
    任务4放入1号线程运行,然后又一个单位时间过去,把当前最短的任务耗时5的进程给线程2运行。最终耗
    时取的是2号线程的总运行时间。
    

    在这里插入图片描述
    解题思路:。。。。。。。。。。。。很无语的事情,sort不能用,然后我自己手写了个快排,因为数据量不大所以比较放肆。然后就开了个数组模拟了一下各个线程的运行时间,从小到达排列任务需要的时间,依次取,找到已运行时间最短的进程就把当前进程的时间加上去。
    but 我只过了85%的测试点。

    第三题:网络广播 (200分)

    给出一个NXN的矩阵(网络中各个路由器的链接关系)求通知到该网络的所有路由器需要多少次广播。

    输入:1 0 0
    	 0 1 0
    	 0 0 1
    输出:3
    
    输入:1 1
         1 1
    输出:1
    

    这个题输入输出的处理就很烦人,我是用getline把第一行直接取了,分奇偶讨论出N,后面用的cin来取的每一个元素。说白了这就是个并查集的问题。最后因为自己很久没碰过并查集了,写的很复杂。只拿了65%的测试点。

    以上是我整理出来的刷题经验,如有纰漏还请大家指正。

    展开全文
  • 上海华为OD--JAVA面试总结

    千次阅读 2021-07-28 10:23:34
    我是2021年6月21日收到华为OD的机试邀请,华为OD机试第一次做很难,我在2019年的时候第一次接触这个机试,三道题一题不会,要想通过,前期不去LeetCode上刷题那是不可能的,好在这次面试有个华为的人事全程对接,...

    我是2021年6月21日收到华为OD的机试邀请,华为OD机试第一次做很难,我在2019年的时候第一次接触这个机试,三道题一题不会,要想通过,前期不去LeetCode上刷题那是不可能的,好在这次面试有个华为的人事全程对接,可能是od那边真的很缺人,他们急迫想招人进去,然后给了一份常考机试题的答案给我了,一百多道,我大概花了5天时间,全部敲了一遍,机考链接给下来,有7天有效期,如果准备准备不充分的千万不要尝试去做,没过有6个月的封禁期,实在是得不偿失。想去OD的同学下面这个链接的机试题务必请务必掌握都是高频考题:

    华为OD机试高频考题

    下面重点讲一下本次7轮面试的面试题以及注意点:

    第一轮 机试  2021年6月27日

    说明机试第一和第二题一般对应LeetCode上的中等题,第三题为困难模式,总分400分,通过180分,也即是2道中等题搞出来基本就过了

    第一题:

    查找众数及中位数
    1.众数是指一组数据中出现次数量多的那个数,众数可以是多个
    2.中位数是指把一组数据从小到大排列,最中间的那个数,如果这组数据的个数是奇数,那最中间那个就是中位数,如果这组数据的个数为偶数,那就把中间的两个数之和除以2,所得的结果就是中位数
    3.查找整型数组中元素的众数并组成一个新的数组,求新数组的中位数
    
    输入描述:
    输入一个一维整型数组,数组大小取值范围 0<N<1000,数组中每个元素取值范围 0<E<1000
    输出描述:
    输出众数组成的新数组的中位数
    
    示例1:
    输入
    10 11 21 19 21 17 21 16 21 18 15
    输出
    21
    示例2:
    输入
    2 1 5 4 3 3 9 2 7 4 6 2 15 4 2 4
    输出
    3
    示例3:
    输入
    5 1 5 3 5 2 5 5 7 6 7 3 7 11 7 55 7 9 98 9 17 9 15 9 9 1 39
    输出
    7
    

    答案(测试用例通过100%),【注:最终得分=用例通过率*本题总分数】

    import java.util.*;
    public class Main {
        public static void main(String[] args) {
            // 输入
            Scanner scanner = new Scanner(System.in);
            String input = scanner.nextLine();
            String[] s = input.split(" ");
            int[] nums = new int[s.length];
            for (int i = 0; i < nums.length; i++) {
                nums[i] = Integer.parseInt(s[i]);
            }
            scanner.close();
            // 获取众数数组和中位数
            Integer[] manyNums = getManyArr(nums);
            int medium = 0;
            int len = manyNums.length;
            if (len % 2 == 0) {
                medium = (manyNums[len / 2 - 1] + manyNums[len / 2]) / 2;
            } else {
                medium = manyNums[len / 2];
            }
            System.out.println(medium);
        }
    
        private static Integer[] getManyArr(int[] arr) {
            if (arr == null) {
                return new Integer[0];
            }
            // 将数组元素和出现的次数转换为key-value
            Map<Integer, Integer> countMap = new HashMap<>();
            for (int i = 0; i < arr.length; i++) {
                int current = arr[i];
                if (countMap.containsKey(current)) {
                    Integer count = countMap.get(current);
                    countMap.put(current, ++count);
                } else {
                    countMap.put(current, 1);
                }
            }
            // 获取出现最多的次数
            int countMax = 0;
            for (int value : countMap.values()) {
                if (value > countMax) {
                    countMax = value;
                }
            }
            // 获取众数,并排序
            List<Integer> list = new ArrayList<>();
            for (int key : countMap.keySet()) {
                if (countMap.get(key) == countMax) {
                    list.add(key);
                }
            }
            list.sort(new Comparator<Integer>() {
                @Override
                public int compare(Integer o1, Integer o2) {
                    return o1 - o2;
                }
            });
            Integer[] newArr = new Integer[list.size()];
            return list.toArray(newArr);
        }
    }
    

     第二题:LeetCode第152题

    152. 乘积最大子数组
    给你一个整数数组 nums ,请你找出数组中乘积最大的连续子数组(该子数组中至少包含一个数字),并返回该子数组所对应的乘积。
    
     
    
    示例 1:
    
    输入: [2,3,-2,4]
    输出: 6
    解释: 子数组 [2,3] 有最大乘积 6。
    示例 2:
    
    输入: [-2,0,-1]
    输出: 0
    解释: 结果不能为 2, 因为 [-2,-1] 不是子数组。
    
    

    用例通过100%答案:

    public class Solution {
        public int maxProduct(int[] nums) {
            int length = nums.length;
            int[] maxF = new int[length];
            int[] minF = new int[length];
            System.arraycopy(nums, 0, maxF, 0, length);
            System.arraycopy(nums, 0, minF, 0, length);
            for (int i = 1; i < length; ++i) {
                maxF[i] = Math.max(maxF[i - 1] * nums[i], Math.max(nums[i], minF[i - 1] * nums[i]));
                minF[i] = Math.min(minF[i - 1] * nums[i], Math.min(nums[i], maxF[i - 1] * nums[i]));
            }
            int ans = maxF[0];
            for (int i = 1; i < length; ++i) {
                ans = Math.max(ans, maxF[i]);
            }
            return ans;
        }
    }
    

    第三题LeetCode第65题:

    有效数字(按顺序)可以分成以下几个部分:
    
    一个 小数 或者 整数
    (可选)一个 'e' 或 'E' ,后面跟着一个 整数
    小数(按顺序)可以分成以下几个部分:
    
    (可选)一个符号字符('+' 或 '-')
    下述格式之一:
    至少一位数字,后面跟着一个点 '.'
    至少一位数字,后面跟着一个点 '.' ,后面再跟着至少一位数字
    一个点 '.' ,后面跟着至少一位数字
    整数(按顺序)可以分成以下几个部分:
    
    (可选)一个符号字符('+' 或 '-')
    至少一位数字
    部分有效数字列举如下:
    
    ["2", "0089", "-0.1", "+3.14", "4.", "-.9", "2e10", "-90E3", "3e+7", "+6e-1", "53.5e93", "-123.456e789"]
    部分无效数字列举如下:
    
    ["abc", "1a", "1e", "e3", "99e2.5", "--6", "-+3", "95a54e53"]
    给你一个字符串 s ,如果 s 是一个 有效数字 ,请返回 true 。
    
     
    
    示例 1:
    
    输入:s = "0"
    输出:true
    示例 2:
    
    输入:s = "e"
    输出:false
    示例 3:
    
    输入:s = "."
    输出:false
    示例 4:
    
    输入:s = ".1"
    输出:true
    

    答案(这道题参考标准答案太难了):

    public class Solution {
        public boolean isNumber(String s) {
            Map<State, Map<CharType, State>> transfer = new HashMap<State, Map<CharType, State>>();
            Map<CharType, State> initialMap = new HashMap<CharType, State>() {{
                put(CharType.CHAR_NUMBER, State.STATE_INTEGER);
                put(CharType.CHAR_POINT, State.STATE_POINT_WITHOUT_INT);
                put(CharType.CHAR_SIGN, State.STATE_INT_SIGN);
            }};
            transfer.put(State.STATE_INITIAL, initialMap);
            Map<CharType, State> intSignMap = new HashMap<CharType, State>() {{
                put(CharType.CHAR_NUMBER, State.STATE_INTEGER);
                put(CharType.CHAR_POINT, State.STATE_POINT_WITHOUT_INT);
            }};
            transfer.put(State.STATE_INT_SIGN, intSignMap);
            Map<CharType, State> integerMap = new HashMap<CharType, State>() {{
                put(CharType.CHAR_NUMBER, State.STATE_INTEGER);
                put(CharType.CHAR_EXP, State.STATE_EXP);
                put(CharType.CHAR_POINT, State.STATE_POINT);
            }};
            transfer.put(State.STATE_INTEGER, integerMap);
            Map<CharType, State> pointMap = new HashMap<CharType, State>() {{
                put(CharType.CHAR_NUMBER, State.STATE_FRACTION);
                put(CharType.CHAR_EXP, State.STATE_EXP);
            }};
            transfer.put(State.STATE_POINT, pointMap);
            Map<CharType, State> pointWithoutIntMap = new HashMap<CharType, State>() {{
                put(CharType.CHAR_NUMBER, State.STATE_FRACTION);
            }};
            transfer.put(State.STATE_POINT_WITHOUT_INT, pointWithoutIntMap);
            Map<CharType, State> fractionMap = new HashMap<CharType, State>() {{
                put(CharType.CHAR_NUMBER, State.STATE_FRACTION);
                put(CharType.CHAR_EXP, State.STATE_EXP);
            }};
            transfer.put(State.STATE_FRACTION, fractionMap);
            Map<CharType, State> expMap = new HashMap<CharType, State>() {{
                put(CharType.CHAR_NUMBER, State.STATE_EXP_NUMBER);
                put(CharType.CHAR_SIGN, State.STATE_EXP_SIGN);
            }};
            transfer.put(State.STATE_EXP, expMap);
            Map<CharType, State> expSignMap = new HashMap<CharType, State>() {{
                put(CharType.CHAR_NUMBER, State.STATE_EXP_NUMBER);
            }};
            transfer.put(State.STATE_EXP_SIGN, expSignMap);
            Map<CharType, State> expNumberMap = new HashMap<CharType, State>() {{
                put(CharType.CHAR_NUMBER, State.STATE_EXP_NUMBER);
            }};
            transfer.put(State.STATE_EXP_NUMBER, expNumberMap);
    
            int length = s.length();
            State state = State.STATE_INITIAL;
    
            for (int i = 0; i < length; i++) {
                CharType type = toCharType(s.charAt(i));
                if (!transfer.get(state).containsKey(type)) {
                    return false;
                } else {
                    state = transfer.get(state).get(type);
                }
            }
            return state == State.STATE_INTEGER || state == State.STATE_POINT || state == State.STATE_FRACTION || state == State.STATE_EXP_NUMBER || state == State.STATE_END;
        }
    
        public CharType toCharType(char ch) {
            if (ch >= '0' && ch <= '9') {
                return CharType.CHAR_NUMBER;
            } else if (ch == 'e' || ch == 'E') {
                return CharType.CHAR_EXP;
            } else if (ch == '.') {
                return CharType.CHAR_POINT;
            } else if (ch == '+' || ch == '-') {
                return CharType.CHAR_SIGN;
            } else {
                return CharType.CHAR_ILLEGAL;
            }
        }
    
        enum State {
            STATE_INITIAL,
            STATE_INT_SIGN,
            STATE_INTEGER,
            STATE_POINT,
            STATE_POINT_WITHOUT_INT,
            STATE_FRACTION,
            STATE_EXP,
            STATE_EXP_SIGN,
            STATE_EXP_NUMBER,
            STATE_END
        }
    
        enum CharType {
            CHAR_NUMBER,
            CHAR_EXP,
            CHAR_POINT,
            CHAR_SIGN,
            CHAR_ILLEGAL
        }
    }
    

    第一轮三道机试,我最终应该拿到280,测试的时候 第一道100%通过,第二道测试100%通过,第三道40%,那么总分就是280分,这样机试第一轮就过了。

    第二轮 性格测试 时间2021年7月2日

    性格测试也是机试,可不要小看性格测试,我有个同事机试过了挂在性格测试上面,为什么这么说呢,性格测试,是在测试你是否和华为的价值观相符,测试之前请好好了解一下华为的企业价值观,无非就是华为是数字型企业,你将从事数字化工作,华为奉承奋斗者文化、狼性文化、奉献文化,你将吃苦耐劳,能在重压之下成长,明确自己在公司的定位,做技术就专心做技术,不要朝三暮四的,等等吧,一共102道选择题,每组2道,一共51组,每组选出一个最符合你的描述,选出一个最不符合你的描述,时间是30分钟内做完,非常难选,你稍微选错了,就无缘了,反正你选的是要尽量要仔细,把自己的价值观往华为公司的价值观上靠拢,这样被淘汰。我选完手心冒汗,因为太难做出选择,不过最后还是通过的。

    第三轮 技术面试第一轮 时间2021年7月7日

    性格测试通过以后才是真正的技术面试了,面试事宜视频面试举行的,面试时候保持环境安静,不要太吵了,影响面试体感,穿着上正式一点,上身穿件带领的寸衫吧,面试前提前15分钟进入房间测试语音和摄像头,电脑视频面试的,所以保证你的电脑是带摄像头的,因为面试官要共享你的电脑屏幕,让你手撕一道算法题,我第一轮那个面试官人很话不多,上来就是,你先写一道算法题吧。题目如下:

    注:此题是LeetCode第三题
    给定一个字符串,请你找出其中不含有重复字符的 最长子串 的长度
     * 输入: s = "abcabcbb"
     * 输出: 3
     * 解释: 因为无重复字符的最长子串是 "abc",所以其长度为 3。
     * 输入: s = "bbbbb"
     * 输出: 1
     * 解释: 因为无重复字符的最长子串是 "b",所以其长度为 1。
     * 输入: s = "pwwkew"
     * 输出: 3
     * 解释: 因为无重复字符的最长子串是"wke",所以其长度为 3。
     * 请注意,你的答案必须是 子串 的长度,"pwke"是一个子序列,不是子串。
     * 输入: s = ""
     * 输出: 0

    我当时的答案:

    package leetcode;
    
    /**
     * @author:
     * @description 无重复字符的最长子串
     * @create 2021-07-07 13:56
     * @Copyright (C), 2006-2021, 
     */
    
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.util.HashSet;
    import java.util.Set;
    
    /**
     * 给定一个字符串,请你找出其中不含有重复字符的 最长子串 的长度
     * 输入: s = "abcabcbb"
     * 输出: 3
     * 解释: 因为无重复字符的最长子串是 "abc",所以其长度为 3。
     * 输入: s = "bbbbb"
     * 输出: 1
     * 解释: 因为无重复字符的最长子串是 "b",所以其长度为 1。
     * 输入: s = "pwwkew"
     * 输出: 3
     * 解释: 因为无重复字符的最长子串是"wke",所以其长度为 3。
     * 请注意,你的答案必须是 子串 的长度,"pwke"是一个子序列,不是子串。
     * 输入: s = ""
     * 输出: 0
     */
    public class Test_3 {
        public static void main(String[] args) throws IOException {
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
            String str = bufferedReader.readLine();
            System.out.println(solve(str));
            //System.out.println(solve(new Scanner(System.in).nextLine()));
        }
    
        static int solve(String str) {
            int ans = 0, n = str.length(), rk = -1;
            Set<Character> occ = new HashSet<>();
            for (int i = 0; i < n; i++) {
                if (i != 0) {
                    occ.remove(str.charAt(i - 1));
                }
                while (rk + 1 < n && !occ.contains(str.charAt(rk + 1))) {
                    occ.add(str.charAt(rk + 1));
                    ++rk;
                }
                ans = Math.max(ans, rk - i + 1);
            }
            return ans;
        }
    }

    手撕算法有时间限制的,一般在15分钟就要写完,超时直接挂

    写完以后,就开始正式进入提问环节了,首先进行自我介绍

    自我介绍无非自己受教育经历、工作经历,其中你说的时候要注意你的项目描述,一般建议这样描述,项目背景是什么、项目主要解决了什么问题、项目的主要介绍架构、项目前、后端、运维分布使用了什么技术栈、项目的人员规模、你在项目里担任的角色(一般就说核心开发人员,核心二字请务必加上)、最后描述下你在项目里遇到重难点技术问题你是怎么解决的,我一般会说前后端跨域怎么解决的、分布式系统全局session怎么解决的、第三方登录、单点登录、分布式事务怎么控制的、事务一致性怎么保证的、缓存穿透、击穿、雪崩分别怎样保证的、mysql的分库分表怎样设计的等等,最好有这块的经验,不然很难,推荐去尚硅谷和黑马找对应的视频看看。

    我介绍完大概10分钟吧,你说完,请补充一句,我的个人学习和工作情况就是这样的,请问您还有什么需要了解的吗?这样就平滑过渡到面试官的发文环节了

    第一轮技术问题如下:

    1.说下java集合,以及他们之间的区别(很多,详细说)

    2.说下get和post的请求之间的区别

    3.熟下MVC模式设计原则和好处

    4.说下servlet是不是线程安全的

    5.说下SpringMVC的主要组件以及请求流程(6个组件,11个流程,务必牢记)

    6.讲一下mysql的优化原则,已经索引失效的场景,以及为什么会失效

    7.讲一下spirng 的IOC和AOP的原理

    8.讲一下redis的数据结构,以及你在项目中的使用场景有哪些

    9.讲一下Sringboot自动注解的原理,已经他的启动原理

    10.讲下数据库的隔离级别,脏库、幻读、不可重复读,分别是什么概念

    11.讲下hashMap和hashTable的底层实现以及底层的扩容机制

    12.讲下你项目中遇到的困难,以及你怎样解决的

    然后面试官向你发问,你有什么问题想问他,精心准备几个吧

    你可准备的问题如下:

    1.如果顺利入职,公司这边对我的安排是怎样的?
    2.公司这边做的项目主要是什么,技术栈是什么?
    3.公司这边有没有一些知识分享的平台?
    4.面的好就问,你觉得我在这次面试中表现的怎么样,我们还有机会再见吗?
    

    第一轮面试持续时间70分钟

    第四轮  技术面试第二轮 时间 2021年7月12日

    本轮技术面试是一位中年面试官,很严肃,这一轮不是先手撕代码,还是先自我介绍,说辞如上,这里不再赘述。直接到发问环节

    1.说下双亲委派原则以及类加载机制,双亲委派有何好处

    2.你说你做过架构设计,那你的输入是什么,输出是什么,UML设计原则讲一下(卧槽,这种题我哪儿会,我都听蒙了,输入输出,UML,完全没搞过呀,不知道就说自己不知道,输入就说需求文档,输出就说prd文档,UML设计干脆说自己没搞过,就说自己架构图是简单的png图片)

    3.讲一下你项目怎样进行单元测试的,输入输出又是什么?(这边我又听蒙了,可能这就是小厂和大厂的区别吧,规范都没有,我傻乎乎的说,我们用postman进行整个模块测试,单元测试很少,业务场景用不上)

    4.说下hashMap的底层实现,以及扩容机制

    5.你们项目里怎样对代码进行质量把控,又是输入输出,我说我们用sonar代码检测质量工具进行分析的,然后针对需要的优化的代码会尽心提示,然后他又问,你这个检测工具界面是什么样的,你看什么指标,我的天,追到这里就看你有无实际的项目经验,然后他又说你这里的异常代码,有哪些,你项目中的异常都有哪些,说5个,并说出出现场景、我说了5个 数组越界异常、空指针异常、算术异常、类转换异常、类找不到异常等等

    6.你刚才说sonar检测代码,那为什么在编辑CICD的时候不单独拉取一个流水线进行检测呢,我的理由就是一条jenkinsfile文件集成多个步骤,主要为了节省共工作量,然后后面,他针对我的K8S集群和CICD流水线部署做了一些建议,你虚心接收就行了

    7.好了,咱们来写一道算法题,题目如下,15分钟内完成

     * * 示例 1:
     * * 输入: "(()"
     * * 输出: 2
     * * 解释: 最长有效括号子串为 "()"
     * * 示例 2:
     * * 输入: ")()())"
     * * 输出: 4
     * * 解释: 最长有效括号子串为 "()()"
     * * 示例 3:
     * * 输入: "(())(()"
     * * 输出: 6
     * * 解释: 最长有效括号子串为 "(())()"

    标准答案:

    package test;
    
    /**
     * @author:
     * @description
     * @create 2021-07-12 20:01
     * @Copyright (C), 2006-2021, 
     */
    
    import java.util.Scanner;
    import java.util.Stack;
    
    /**
     * * 示例 1:
     * * 输入: "(()"
     * * 输出: 2
     * * 解释: 最长有效括号子串为 "()"
     * * 示例 2:
     * * 输入: ")()())"
     * * 输出: 4
     * * 解释: 最长有效括号子串为 "()()"
     * * 示例 3:
     * * 输入: "(())(()"
     * * 输出: 6
     * * 解释: 最长有效括号子串为 "(())()"
     * *
     * * class Solution {
     * *     public int longestValidParentheses(String s) {
     * *     }
     * * }
     */
    public class OdTest_02 {
        public static void main(String[] args) {
            System.out.println(solve(new Scanner(System.in).nextLine()));
        }
    
        static int solve(String str) {
            int max = 0;
            if (str == null) {
                return 0;
            }
            Stack<Character> stack = new Stack<>();
            for (int i = 0; i < str.length(); i++) {
                if (str.charAt(i) == '(') {
                    stack.push('(');
                    continue;
                } else {
                    if (stack.isEmpty()) {
                        continue;
                    } else {
                        stack.pop();
                        max += 2;
                    }
                }
            }
            return max;
        }
    }

    写完后,让我问他几个问题,我还是问了技术一轮面试问的问题

    总结,这一轮面试明显吃力很多,面试时间持续60分钟,这一轮面试侧重点在于对你简历上的项目进行深度发掘,深追你项目问题,算法题,我自己写的时候测试用例三,不满足,面试官提示了很多,最后才写出上面的答案,主要是自己算法太菜了,也太难了,不过后来他还是当面说,这一轮放你过,此时我终于松了一口气。

    第五轮 华为HRBP 人力资源官面试 时间2021年7月13日

    经历技术一轮和二轮面试 也是华为那边的对接人事为了缓解氛围,来一轮HR面试,面试形式也就是视频面试,这一轮面试,首先是自我介绍,因为人事面试,所以呢,会重点关心你为什么离职的原因,就照实说吧,第一次因为疫情公司倒闭,第二次因为想去华为公司,无奈学历不够,经验来凑,只能社招进华为OD,然后就疯狂舔华为公司,想过,你懂得,就说他是技术创新高低,中国高科技公司的一面旗帜,从新闻得知华为公司多牛逼,以一个公司的力量对抗超级大国美国的制裁,依然业绩坚挺,等等反正就是往好的方向说,我说完,面试官心里乐滋滋的,然后说我这种人特别适合来华为OD干,最后呢他简单聊了一下OD和自营的区别,整体上无非就是,自营有股票,OD没有股票,工牌和华为一样,在一起办公,技术氛围好,成长快,压力大,工资不低,然后就问我期望多少薪资了,整体而言,整个过程都在一种轻松的环境里度过的,面试持续时间30分钟

    第六轮  部门技术主管面试  时间2021年7月14日

    这一轮面试时间很仓促,因为要协调面试官的面试时间,形式也是视频面试,这一轮部门主管面试,延续技术二轮面试一样,氛围紧张,上来也是手撕一道算法题,LeetCode第64题,如下,

    package leetcode;
    
    /**
     * @author:
     * @description 动态规划-最小路径之和
     * @create 2021-07-14 10:09
     * @Copyright (C), 2006-2021, 
     */
    
    /**
     * 给定一个包含非负整数的 m x n 网格 grid ,请找出一条从左上角到右下角的路径,使得路径上的数字总和为最小。
     * 说明:每次只能向下或者向右移动一步。
     */
    public class Test_64 {
        public static void main(String[] args) {
            int[][] arr = new int[][]{
                    {1, 0, 0, 0},
                    {1, 2, 2, 0},
                    {1, 3, 7, 0},
                    {0, 3, 0, 0}
            };
            System.out.println(solve(arr));
        }
    
        static int solve(int[][] arr) {
            if (arr == null || arr.length == 0 || arr[0].length == 0) {
                return 0;
            }
            int rows = arr.length, columns = arr[0].length;
            int[][] dp = new int[rows][columns];
            dp[0][0] = arr[0][0];
            for (int i = 1; i < rows; i++) {
                dp[i][0] = dp[i - 1][0] + arr[i][0];
            }
            for (int j = 1; j < columns; j++) {
                dp[0][j] = dp[0][j - 1] + arr[0][j];
            }
            for (int i = 1; i < rows; i++) {
                for (int j = 1; j < columns; j++) {
                    dp[i][j] = Math.min(dp[i - 1][j], dp[i][j - 1]) + arr[i][j];
                }
            }
            return dp[rows - 1][columns - 1];
        }
    }

    做完后面展开发问:

    1.介绍项目,不再赘述

    2.讲一下常用的springcloud组件

    3.讲一下,soringboot的自动配置原理

    4.Mybaties的一二级缓存有什么区别、原理、怎么开启,画一下你项目里的mybaties的一二级原理图

    5.JVM内存模型说下,分别存放什么

    6.GC的整个流程讲一下

    7.monitor gc 、Major GC 、Full GC的区别,以及常用参数

    8.Spring Bean 的生命周期

    9.HashMap 和 hashTable 区别?

    10.线上服务 CPU 很高该怎么做?有哪些措施可以找到问题

    11.JDK 中有哪几个线程池?顺带把线程池讲了个遍

    12.线程池的异步编排使用场景,以及线程池的参数

    13.Concurrenthashmap 是怎么做到线程安全的?

    总结:部门主管面试持续时间75分钟,重点也是聊了项目,至于后续的常见问题和二轮面试并无区别

    第七轮 综合面试 时间2021年7月24日

    这一轮面试持续时间大约为35分钟,一共提问了8个问题

    1.项目架构设计你的输入输出是什么,UML设计原则是什么?

    2.技术选型你是怎么考虑的,有哪些因素,我的回答,技术成本、技术开源社区活跃度,讲一下这些场景你的实际应用

    3.你认为你最大的优势是什么

    4.你对华为公司有哪些了解

    5.你未来的工作方向

    6.你在杭州为什么选择来上海

    7.你认为你自己有没有被不公平对待过,说一下你的真实想法

    8.你有家人或者朋友在华为上班吗?

    总结

            整个面试走完大概花了5周时间,昨天通知我提交审核材料,如果审核通过,offer就会下来,如果offer能下来,我在补充od的福利待遇吧。

            面试是综合性的,面试官问你的问题,没有标准答案,面试的过程看中的是你的表述能力以及是否自信,总体上有个积极乐观、开放自信、衣冠得体、基础扎实、心态健康的人能容易面试成功,自信非常重要,我在面试第一轮的时候,让我手撕代码,我差点放弃,有时候面试坚持住了,可能就成功,总之,IT行业不是养老行业,技术迭代太快,唯一能顺应时代发展的唯有努力学习,不断提升。最后说下,简单聊下工作岗位的问题,现在的趋势是,在工作岗位整体不变的情况下,每年仍有1000多万应届毕业生加入进来,争抢好的工作岗位,如果自身学历、专业并不占优的情况下,请看清形式,深度了解自己在这个竞争潮流中的所处的地位,如果你没有合适的大厂offer,华为OD是你比较好的选择之一,工作无非就是为了挣钱养家,所以有时候别放不开你的面子,能挣钱的工作就是好工作,先让自己活下来,再去讨论自己要过得更好的话题,好了,我的面试经验就写到这里吧。

    展开全文
  • 2021华为OD面试经历

    千次阅读 2021-08-14 13:13:31
    笔者三非本科,毕业一年整,下为华为OD流程的简单复盘,学校好的人基本不会考虑OD,看脉脉甚至连华为正编都懒得考虑(羡慕 :D),可咱学校差又想进大厂,体验大厂的生活与核心项目,仅有这一条出路~ 小厂子去两家过...
  • 华为OD笔试202010OD笔试华为OD第二题最长的非递减连续子序列的长度要连续的数字序列的最长的长度 直接看输入输出 输入 abc2234019A334bc 输出 4 解释:输入一个字符串,只包含字母和数字, 长度也不长,数字也全...
  • 华为OD机考题

    2021-12-12 21:56:06
    凉凉夜色为我思念成河 第一行输入后面每个分隔字符串的长度,第二,行输要处理的字符串,然后这个字符串处理的情况是-分开第一个不变,之后的每一个字符串中大写字母大于小写字母则全部转为大写小写字母大于大写...
  • 华为OD的五轮面试总结

    万次阅读 多人点赞 2020-10-30 00:43:43
    华为OD的五轮面试 简述 在今年疫情期间,通过BOSS直聘,受邀华为OD的Java工程师面试;整整一个月(3月中-4月初)的时间,经过了5轮的筛选,现在对这次面试进行概括性复盘,给大家分享下我所收集到的各种信息和相关...
  • 华为机试题OD考试题,不定期更新,文档含代码解答
  • 2021年华为OD面试流程

    千次阅读 2021-04-03 13:47:06
    前面有一篇《华为OD的五轮面试总结》 实际发生是在2020年疫情期间;据我了解,2021年的华为OD面试流程,似乎有了那么一些许改动;也有可能是因为部门不同而流程有区别,但不管怎样,在此把注意点分享给大家,希望对...
  • 华为OD机试记录

    千次阅读 热门讨论 2021-03-10 14:42:20
    上周参加了华为OD的机试,两个半小时三道题目,现进行复盘和记录。 第一题: 给你一个m*n(0< m,n < 1024,)的数组array,成员初始全为0,给你两个坐标{x1,y2},{x2,y2},且使得array[x1][y1] = 1array[x2][y2] = 1...
  • 华为OD机试

    千次阅读 2020-12-20 09:21:12
    题目描述编写一个函数,传入一个int型数组,返回该数组能否分成两组,使得两组中各元素加...输入描述:第一行是数据个数,第二行是输入的数据输出描述:返回true或者falsepackage Face.huawei;import java.util.Arra...
  • 华为OD机考

    千次阅读 2021-04-02 20:35:46
    老生常谈。
  • 华为od社招一面凉经

    千次阅读 2021-03-15 00:56:26
    毕业于985院校,工作9年,1年半 c++,5年移动运营商java,2年海口某500强企业java,想去深圳发展。一面已挂,面试体验非常差。6.2 开始说要去深圳,后来说在家视频面试也可以,然后饭也没吃在家等着面试,一直等到10...
  • 华为OD机试题整理

    千次阅读 2021-08-02 22:53:47
    华为OD机试题整理TOC 声明:本文章只收集网络公开讨论的编程题目,仅用于学习交流。如有侵权,请联系删除,谢谢。 标记Leetcode,可以在leetcode网站根据题号找到相应题目。 标记牛客,可以根据题号在牛课网找到响应...
  • 华为od机考

    千次阅读 2021-04-13 21:38:18
    两道一星+一道二星(限时150min) 机考parseInt还是没搞懂,姑且就按记录一下自己平时的实现方法做了一下,可能与标准答案有出入,欢迎指正。 1、停车场停车的最少数量 function cars(arr) { if (arr[arr.length - ...
  • 华为OD笔试题

    千次阅读 2021-06-04 01:44:14
    冒泡排序解决 import java.util.Scanner; public class TestOne{ public static void main(String[] args) { Scanner scanner = new Scanner(System.in); int height = 0;... height = scanner.nextInt..
  • 四、总结 一、华为OD简介 首先来解释一下什么是华为OD面试,OD一般是指的是华为的“外包”公司,比如像德科这种。网上其实有很多人都吐槽过这个招聘模式,因为招进去的人不直接是华为内部的人,挂在德科名下或其他,...
  • 亲身经历从软通外包到华为OD,两者有什么区别? 声明:本人所有言论仅限2021-04当前真实所在的部门情况。 序言 ​ 坐标南京,本人2014年毕业于211本科院校,16年底加入软通动力,20年初转入华为OD。到如今算是经历了...
  • 华为OD面试 华为OD岗位: OD岗位就是那种外包性质的岗位,不过我面的这个岗位上说是 同工同酬,编制在德科,所以如果面过了就只算半个华为人吧。 为什么不直接去面正式员工的岗位?没机会! 面试流程是很规范的,...
  • 算法题 todo 面试题 1.python程序的执行过程 2.python深拷贝 浅拷贝的区别 3.列表和元组的区别 4.列表和元组执行效率 5.python的多线程机制?和其他语言的多线程区别?真正意义上的多线程 ...Python字符串反转的几种...
  • 华为OD面试——机试算法

    千次阅读 2020-11-09 17:24:51
    简述 给定两个非常大的正整数A和B,位数在50至100之间。求C=A+B; 题目类别: 字符串 难度: 中级 运行时间限制: 10Sec 内存限制: 128MByte ...因为A和B很大,从高位到低位,以字符串的形式输入两行数字A和B。...
  • 华为OD机试题-java-华为机试题及答案

    千次阅读 2021-07-25 13:55:56
    1. 通过键盘输入任意一个字符串序列,字符串可能包含多个子串,子串以空格 分隔。请编写一个程序,自动分离出各个子串,并使用 ’,’ 将其分隔,并且在最后 也补充一个 ’,’ 并将子串存储 测试:输入: ...
  • 备注:OD类型的岗位,是新的招聘模式,和德科签署合同; 与华为同工、薪酬、同福利;华为培养管理、华为办公、华为工卡(划定工号段)、华为考评。优秀员工每年20%转华为正式员工 以上内容仅为本站快照,最新信息请...
  • 华为OD社招前端面试复盘

    千次阅读 2021-05-11 11:39:22
    华为OD社招前端面试复盘 这是二面了,前面一轮笔试,一轮面试,说是第一轮面试表现不够好,所以本来走流程的二面现在就变成正式面了。下面复盘一下,由于记性不好,顺序并不一定是对的。 自我介绍 聊项目 编程环境...
  • 华为OD机试一二题

    2021-07-29 20:34:47
    每一个任务有三种策略 resA、resB、resC,每一种策略都对应一个完成该任务的时间,现在输入人数和每一个人的任务所用的三种策略的时间。 1.从第一个人依次选择三个策略中耗时最少的策略 2.相邻人不能选用同一种策略 ...
  • 华为OD面试即兴笔试算法(一)

    千次阅读 2020-10-30 23:45:56
    该题目为华为OD面试第四轮,一位技术主管视频面试时,最后即兴出的一道算法题;当时是使用电脑端的zoom进行视频面试,算法题可以使用电脑的IDE,需要进行屏幕共享;难度中下,更倾向于考验临场发挥能力。 题目描述 ...
  • 华为OD流程走完了

    万次阅读 热门讨论 2021-03-18 09:57:02
    机试过了后,华为上海部HR一面 耗时30分钟左右,问了些家庭,个人工作经历. 包括结婚否,为什么辞职之类的 技术二面 同样,自我介绍结束后,问了些项目相关的细节 该环节完后,面试官共享其试题.限时完成. 试题难度,简单上....

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,132
精华内容 452
关键字:

华为od

友情链接: 实例13.rar