华为OD机考E卷100分题 - VLAN资源池_vlan资源池[e卷,100-优快云博客

本文链接：https://blog.youkuaiyun.com/left_freckle/article/details/143837889

题目描述

VLAN是一种对局域网设备进行逻辑划分的技术，为了标识不同的VLAN，引入VLAN ID(1-4094之间的整数)的概念。

定义一个VLAN ID的资源池(下称VLAN资源池)，资源池中连续的VLAN用开始VLAN-结束VLAN表示，不连续的用单个整数表示，所有的VLAN用英文逗号连接起来。

现在有一个VLAN资源池，业务需要从资源池中申请一个VLAN，需要你输出从VLAN资源池中移除申请的VLAN后的资源池。

输入描述

第一行为字符串格式的VLAN资源池，第二行为业务要申请的VLAN，VLAN的取值范围为[1,4094]之间的整数。

输出描述

从输入VLAN资源池中移除申请的VLAN后字符串格式的VLAN资源池，输出要求满足题目描述中的格式，并且按照VLAN从小到大升序输出。
如果申请的VLAN不在原VLAN资源池内，输出原VLAN资源池升序排序后的字符串即可。

示例1

输入

1-5
2
12

输出

1,3-5
1

说明

原VLAN资源池中有VLAN 1、2、3、4、5，从资源池中移除2后，剩下VLAN 1、3、4、5，按照题目描述格式并升序后的结果为1,3-5

示例2

输入

20-21,15,18,30,5-10
15
12

输出

5-10,18,20-21,30
1

说明

原VLAN资源池中有VLAN 5、6、7、8、9、10、15、18、20、21、30，从资源池中移除15后，资源池中剩下的VLAN为 5、6、7、8、9、10、18、20、21、30，按照题目描述格式并升序后的结果为5-10,18,20-21,30。

示例3

输入

5,1-3
10
12

输出

1-3,5
1

说明

原VLAN资源池中有VLAN 1、2、3，5，申请的VLAN 10不在原资源池中，将原资源池按照题目描述格式并按升序排序后输出的结果为1-3,5。

解题思路

VLAN（虚拟局域网）是一种网络技术，用来对局域网中的设备进行逻辑划分。每个VLAN通过一个 VLAN ID 来标识，取值范围是 1 到 4094 的整数。题目中的任务是处理一个字符串格式的 VLAN 资源池，模拟从资源池中申请并移除某个 VLAN，然后返回剩余的资源池。

任务：
1. 输入
  
  包含两个部分：
  - VLAN资源池：用字符串表示，可能是单个 VLAN ID，或者是多个 VLAN ID 或 VLAN ID 范围（用"-"连接），各个 VLAN 或范围之间用逗号连接。
  - 要申请的 VLAN：一个需要移除的 VLAN ID。
2. 输出
  
  ：
  - 从资源池中移除申请的 VLAN 后，输出剩余的 VLAN 资源池，按从小到大的顺序排列，且格式必须符合题目的描述。
输出格式：
- 连续的 VLAN ID 应该用范围的方式表示，如 1-5 表示 VLAN 1, 2, 3, 4, 5。
- 不连续的 VLAN ID 用逗号分隔，如 1,3-5。
示例分析：

示例 1：

输入：
```
1-5
2
12
```
解释：
- 原始资源池有 VLAN 1, 2, 3, 4, 5。
- 申请的 VLAN 是 2，所以移除 2 后，剩下的 VLAN 是 1, 3, 4, 5。
- 格式化输出为：1,3-5。
示例 2：

输入：
```
20-21,15,18,30,5-10
15
12
```
解释：
- 原始资源池有 VLAN 5, 6, 7, 8, 9, 10, 15, 18, 20, 21, 30。
- 申请的 VLAN 是 15，移除 15 后，剩下的 VLAN 是 5, 6, 7, 8, 9, 10, 18, 20, 21, 30。
- 格式化输出为：5-10,18,20-21,30。
示例 3：

输入：
```
5,1-3
10
12
```
解释：
- 原始资源池有 VLAN 1, 2, 3, 5。
- 申请的 VLAN 是 10，不在资源池中，所以资源池保持不变。
- 格式化输出为：1-3,5。

Java

import java.util.*;

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

        // 输入VLAN资源池
        String input = sc.nextLine();
        // 输入业务要申请的VLAN
        Integer destVlan = Integer.parseInt(sc.nextLine());

        // 解析VLAN资源池
        List<Integer> vlanPool = parseVlanPool(input);

        // 对VLAN资源池进行升序排序
        Collections.sort(vlanPool);

        // 从VLAN资源池中移除申请的VLAN
        vlanPool.remove(destVlan);

        // 格式化VLAN资源池
        String result = formatVlanPool(vlanPool);
        System.out.println(result);
    }

    // 解析VLAN资源池
    private static List<Integer> parseVlanPool(String input) {
   
   
        List<Integer> vlanPool = new ArrayList<Integer>();
        // 根据逗号分割VLAN资源池中的VLAN
        String[] vlanGroup = input.split(",");
        for (String vlanItem : vlanGroup) {
   
   
            if (vlanItem.contains("-")) {
   
   
                // 如果VLAN是连续的，根据连字符分割开始VLAN和结束VLAN
                String[] vlanItems = vlanItem.split("-");
                Integer start = Integer.parseInt(vlanItems[0]);
                Integer end = Integer.parseInt(vlanItems[1]);
                // 将连续的VLAN添加到VLAN资源池中
                for (int j = start; j <= end; j++) {
   
   
                    vlanPool.add(j);
                }
            } else {
   
   
                // 如果VLAN是单个的，直接添加到VLAN资源池中
                vlanPool.add(Integer.parseInt(vlanItem));
            }
        }
        return vlanPool;
    }

    // 格式化VLAN资源池
    private static String formatVlanPool(List<Integer> vlanPool) {
   
   
        StringBuilder result = new StringBuilder();
        Integer last = null;
        for (int index = 0; index < vlanPool.size(); index++) {
   
   
            if (last == null) {
   
   
                // 如果是第一个VLAN，直接添加到结果中
                result.append(vlanPool.get(index));
                last = vlanPool.get(index);
            } else {
   
   
                if (vlanPool.get(index) - last == 1) {
   
   
                    // 如果与上一个VLAN相差1，表示是连续的VLAN
                    if (result.toString().endsWith("-" + last)) {
   
   
                        // 如果结果中最后一个VLAN已经是连续的VLAN的结束VLAN，替换为当前VLAN
                        result.replace(result.lastIndexOf(last.toString())