华为机试题202205

举办一场8小时的聚会，时间段从12：00到20：00点，让来访的客人事先填好到达的时间和离开的时间，为了掌握聚会期间的座位数目，需要先估计不同时间的最大客人数量。
1.到达和离开的时间，以整点计算，输入为整数，比如“12，18”表示客人到达的时间为12点后13点前，离开的时间是17点后18点前。
2.按小时区间统计客人的数量，需要统计[12，13),[13,14)….[19，20)共有8个时间段的最大客人数量。
3.假设邀请的客人最多100个。
假设输入：

12,15
16,17
12,20
-1,-1

程序要求的输出结果为：

[12,13):2
[13,14):2
[14,15):2
[15,16):1
[16,17):2
[17,18):1
[18,19):1
[19,20):1

Java程序

第一种方法：

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Hashtable;
import java.util.List;
public class Test {
    public static  List<String> list = new ArrayList<String>();
    public static void main(String[] args) {
        String[] str = {"12,15","16,17" ,"12,20"};
        for (int i = 0; i < str.length; i++) {
            reset(str[i]);
        }
        Hashtable<String, Integer>  wordCount = wordcount ();
        List<String> newlist = new ArrayList<String>();
        for (String key : wordcount ().keySet()) {
            newlist.add("[" + key + ")" + ":" + wordCount.get(key));
        }
        //重排
        Collections.sort(newlist, new Comparator() {  
            public int compare(Object o1, Object o2) {  
                String str1 = (String) o1;  
                String str2 = (String) o2;  
                if (str1.compareToIgnoreCase(str2)<0){    
                    return -1;    
                }    
                return 1;    
            }  
        });
        //输出结果
        for (int i = 0; i < newlist.size(); i++) {
            System.out.println(newlist.get(i));
        }
    }
    //字符串组合成制定格式，类似于16,17
    static void reset (String str) {
        String[] aa = str.split(",");
        int inter = Integer.parseInt(aa[1]) - Integer.parseInt(aa[0]);
        for (int i = 0; i < inter; i++) {
            int newString = Integer.parseInt(aa[0]) + i;
            list.add( newString + "," +(newString + 1) );
        }
    }  
    //统计次数
    static Hashtable<String, Integer> wordcount () {
        Hashtable<String, Integer>  wordCount = new Hashtable<String, Integer>();
        for (int i = 0; i < list.size(); i++) {
            String str = list.get(i);
            if (!wordCount.containsKey(str)) {
                wordCount.put(str, Integer.valueOf(1));
            } else {
                wordCount.put(str, Integer.valueOf(wordCount.get(str).intValue() + 1));
            }
        }
        return wordCount;
    }
}

对于一个没学过数据结构与算法的人，暂且用这种方法处理。处理逻辑是：首先将指定字符，如”12,15”处理成要求的字符串，如12,13；13,14；14,15。其次，每个制定字符串处理完成之后，使用map集合统计每个字符串(如12,13)出现的总次数。最后，由于map的key是乱序的，所以使用Collections.sort进行重排一下，最终得到输出结果。
参考：https://blog.csdn.net/qy20115549/article/details/81711910

第二种方法：

import java.io.IOException;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Scanner;
import java.util.stream.Collectors;

public class Demo {
    public static void main(String[] args) throws IOException {
        Map<String, Integer> result = new HashMap<>();
        Map<String,Integer> linkedMap = new LinkedHashMap<String,Integer>();
        Scanner in = new Scanner(System.in);
        String temp;
        while(in.hasNext()){
            temp = in.nextLine();
            String[] split = temp.split(",");

            int a = Integer.valueOf(split[0]);
            int b = Integer.valueOf(split[1]);
            if (a > b || a < 12 || b > 20) {
                break;
            }

            for (int i = a; i < b; i++) {
                String key = "[" + i + "," + (i + 1) + ")" + ":";
                if (result.containsKey(key))
                    result.put(key, result.get(key) + 1);
                else
                    result.put(key, 1);
            }
        }
        linkedMap = result.entrySet().stream().sorted(
                Map.Entry.<String, Integer>comparingByKey()).collect(
                Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (o1, o2) -> o1, LinkedHashMap::new));

        linkedMap.entrySet().forEach(e -> System.out.println(e.getKey() + e.getValue()));

    }
}