华为机试3题

第一题

  思路就是吧 ab 串放set里，来判断是否包含，并且判断是否完全匹配上

package baidutest;

import java.util.HashSet;
import java.util.Set;

public class test {
    public static void main(String[] args) {

        String content = "qweebaewqd";
        String word = "qwe";

        char[] chars = content.toCharArray();
        char[] charWord= word.toCharArray();
        int count = 0;
        Set<String> setWord = new HashSet<String>();
        for (int i = 0; i < charWord.length; i++) {
            setWord.add(String.valueOf(charWord[i]));
        }

        for (int i = 0; i < chars.length; i++) {
            Set<String> setWordBox = new HashSet<String>();
            setWordBox.addAll(setWord);
            int k = i;
            //顶多循环这么多次找
            for (int j = 0; j < setWord.size(); j++) {
                //移除
                if(k<chars.length){
                    setWordBox.remove(String.valueOf(chars[k]));
                }
                k++;
                if(setWordBox.size()!=setWord.size()-(j+1)){
                    break;
                }
            }
            if (setWordBox.size() == 0) {
                count ++;
            }
        }
        System.out.println(count);

    }
}

第二题

 第一行数据是数据条数

后面是用户id  谁给谁发了短信

最后一个是判定人

要求输出 是否是垃圾短信发送者 ，并且输出L 和M

package baidutest;

import java.util.*;

public class test03 {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);

        int i =  in.nextInt();
        // 1 获取数据
        //用户关系
        HashMap<String,Set<Integer>> userMap = new HashMap<String, Set<Integer>>();
        //A用户给B用户发的调数量
        HashMap<String,Integer> userNumberMap = new HashMap<String, Integer>();
        //用户A发送的条数、
        int[] fs = new int[101];
        int[] js = new int[101];
        //用户A接收的条数
        for (int j = 0; j < i; j++) {
            int a = in.nextInt();
            int b = in.nextInt();
            //记录发送和接收
            fs[a] = fs[a]+1;
            js[b] = js[b]+1;
            String aStr = a+"->"+b;
            if(userNumberMap.containsKey(aStr)){
                userNumberMap.put(aStr,userNumberMap.get(aStr)+1) ;
            }else {
                userNumberMap.put(aStr,1) ;
            }
            if(userMap.containsKey(String.valueOf(a))){
                userMap.get(String.valueOf(a)).add(b) ;
            }else {
                Set<Integer> set = new HashSet<Integer>();
                set.add(b);
                userMap.put(String.valueOf(a),set) ;
            }
        }
        int user =  in.nextInt();

        // 2 生成 L M N
        int L = 0;
        int M = 0;
        int N = 0;
        String rt = "false";
        Set<Integer> s = userMap.get(String.valueOf(user));
        for (Integer buser: s) {
            String aStr = buser+"->"+user;
            if (!userNumberMap.containsKey(aStr)){
                L++;
            }
        }
        if(L>5){
            rt = "true";
        }
        M = fs[user]-js[user];
        if(M>10){
            rt = "true";
        }
        for (Integer x: s) {
            String af = user+"->"+x;
            String as = x+"->"+user;
            int afint =0;
            int asint =0;
            if (userNumberMap.containsKey(af)){
                afint = userNumberMap.get(af);
            }
            if (userNumberMap.containsKey(as)){
                afint = userNumberMap.get(as);
            }
            N = afint-asint;
        }
        if(N>5){
            rt = "true";
        }
        // 3 返回结果
        System.out.println(rt);
        System.out.println(L);
        System.out.println(N);
    }
}

第三题

找不到题目了大概是这个意思

一个人工作  有工作时间T和工作次数N

给你一堆任务 任务数据有两个内容 一个是耗费的时间 另一个是 收益，求 给T和N 和一些任务给最大收益

模拟数据   时间 40 可工作次数2

任务列表

时间   收益

20     10

20   20

20     5

package baidutest;

import sun.awt.SunHints;

import java.util.ArrayList;
import java.util.List;

public class test02 {
    public static void main(String[] args) {

        //把数据转换成list<date>
        List<Integer[]> list = new ArrayList<Integer[]>();

        list.add(new Integer[]{20,10});
        list.add(new Integer[]{20,20});
        list.add(new Integer[]{20,5});

        //通过动态规划暴力解开
        int ans = returnAns(40, 2, list, 0,0);
        // 返回最优解法
        System.out.println(ans);
    }
    // 1 剩余工作时间 2 剩余工作次数 3 工作任务列表
    private static int returnAns(int workTime, int workNumber, List< Integer[]> list,
                                 int i,int w) {
        if(i>=list.size()||workNumber==0){
            return w;
        }
        int you =0;
        int wu = 0;
        //当前任务 耗费时间与报仇
        int nowWorkerTime =list.get(i)[0];
        int nowM =list.get(i)[1];
        // System.out.println("当前workTime"+workTime+"workNumber"+workNumber);

        //如果当前还能干
        if(workTime>nowWorkerTime&&workNumber>1){
            you = returnAns(workTime-nowWorkerTime,workNumber-1,list,i+1,w+nowM);
        }
        wu = returnAns(workTime,workNumber,list,i+1,w);
        if (you>wu){
            return you;
        }
        return wu;
    }
}