按职级顺序结队（华为od机考题）

于 2024-08-03 13:07:25 发布
阅读量720 收藏 26
点赞数 21
分类专栏： 华为od机考 文章标签： java 前端 javascript 华为od 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_57223586/article/details/140876781
版权

一、题目

1.原题

某部门计划通过结队编程来进行项目开发，
已知该部门有N名员工，
每个员工有独一无二的职级，每三个员工形成一个小组进行结队编程，结队分组规则如下：
从部门中选出序号分别为 i、j、k 的 3 名员工，
他们的职级分别为 level[i]、level [j]、level [k]
结队小组需满足： level [i] < level [j] < level [k] 
或者 level [i] > level [j] > level [k] ，
其中  0 <= i < j < k < n
请你按上述条件计算可能组合的小组数量。
同一员工可以参加多个小组。


二、思路与代码过程


1.思路

建一个数据类型Indexdata，含有数据域data和Index指针（固定值），对得到的职级数组level（Indexdata类）直接排序，对排序后的数进行全排列（for i；for k；for j），对满足索引顺序的进行输出。


2.代码过程


①main函数

public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入员工数量N：");
        int N = sc.nextInt();
        System.out.println("请依次输入N名员工的职级");
        ArrayList<Indexdata> levels = new ArrayList<>();
        int data =0;
        for (int i = 0; i < N; i++) {
            data = sc.nextInt();
            levels.add(new Indexdata(i,data));
        }
        System.out.println("员工序号和职级分别为：");
        for(Indexdata i : levels) {
            System.out.println(i);
        }

        //按职级排序
        Collections.sort(levels,new Comparator<Indexdata>() {
            public int compare(Indexdata o1, Indexdata o2) {
                return Integer.compare(o1.data, o2.data);
            }
        });

        //调用组合函数
        CombinationCalc(levels,N);
    }

②CombinationCalc函数

private static void CombinationCalc(ArrayList<Indexdata> levels,int N) {
        int[][]combinations = new int[3][2];
        ArrayList<String> Workcombination = new ArrayList<>();
        String workcombination = "";
        //全排列
        for (int i = 0; i < N; i++) {
            combinations[0][0] = levels.get(i).index;
            combinations[0][1] = levels.get(i).data;
            for (int j = 0; j < N; j++) {
                combinations[1][0] = levels.get(j).index;
                combinations[1][1] = levels.get(j).data;
                for (int k = 0; k < N; k++) {
                    combinations[2][0] = levels.get(k).index;
                    combinations[2][1] = levels.get(k).data;
                    //同一个人不能进一个组多次
                    if(levels.get(i).index != levels.get(j).index&&
                            levels.get(j).index != levels.get(k).index&&
                            levels.get(i).index!=levels.get(k).index) {
                        //序号从小到大
                        if(levels.get(i).index<levels.get(j).index&&
                                levels.get(j).index<levels.get(k).index) {
                            //职级从小到大
                            if (levels.get(i).data<levels.get(j).data&&
                                    levels.get(j).data<levels.get(k).data) {
                                workcombination = "\n职级从小到大可行工作组合: " +
                                        "序号"+combinations[0][0]+" 职级"+combinations[0][1]
                                +"；序号"+combinations[1][0]+" 职级"+combinations[1][1]
                                +"；序号"+combinations[2][0]+" 职级"+combinations[2][1]
                                ;
                                Workcombination.add(workcombination);
                            }//职级从大到小
                            else if (levels.get(i).data>levels.get(j).data&&
                                    levels.get(j).data>levels.get(k).data) {
                                workcombination = "\n职级从大到小可行工作组合: " +
                                        "序号"+combinations[0][0]+" 职级"+combinations[0][1]
                                        +"；序号"+combinations[1][0]+" 职级"+combinations[1][1]
                                        +"；序号"+combinations[2][0]+" 职级"+combinations[2][1]
                                ;
                                Workcombination.add(workcombination);
                            }
                        }
                    }
                }
            }
        }
        System.out.println("\n可能组合的小组数量为："+Workcombination.size());
        System.out.println("详情如下："+Workcombination);
    }


③Indexdata类

static class Indexdata {
        int index;
        int data;
        public Indexdata(int index, int data) {
            this.index = index;
            this.data = data;
        }
        public String toString() {
            return "员工序号："+index+"，职级："+data;
        }
    }


三、运行结果


1.运行截图

2.带数据分析运行结果

请输入员工数量N：
5
请依次输入N名员工的职级
2 3 4 1 5
员工序号和职级分别为：
员工序号：0，职级：2
员工序号：1，职级：3
员工序号：2，职级：4
员工序号：3，职级：1
员工序号：4，职级：5
排序后员工职级和索引分别为：
员工序号：3，职级：1
员工序号：0，职级：2
员工序号：1，职级：3
员工序号：2，职级：4
员工序号：4，职级：5
{ [3,1], [3,1],[3,1] }
{ [3,1], [3,1],[0,2] }
{ [3,1], [3,1],[1,3] }
{ [3,1], [3,1],[2,4] }
{ [3,1], [3,1],[4,5] }
{ [3,1], [0,2],[3,1] }
{ [3,1], [0,2],[0,2] }
{ [3,1], [0,2],[1,3] }
{ [3,1], [0,2],[2,4] }
{ [3,1], [0,2],[4,5] }
{ [3,1], [1,3],[3,1] }
{ [3,1], [1,3],[0,2] }
{ [3,1], [1,3],[1,3] }
{ [3,1], [1,3],[2,4] }
{ [3,1], [1,3],[4,5] }
{ [3,1], [2,4],[3,1] }
{ [3,1], [2,4],[0,2] }
{ [3,1], [2,4],[1,3] }
{ [3,1], [2,4],[2,4] }
{ [3,1], [2,4],[4,5] }
{ [3,1], [4,5],[3,1] }
{ [3,1], [4,5],[0,2] }
{ [3,1], [4,5],[1,3] }
{ [3,1], [4,5],[2,4] }
{ [3,1], [4,5],[4,5] }
{ [0,2], [3,1],[3,1] }
{ [0,2], [3,1],[0,2] }
{ [0,2], [3,1],[1,3] }
{ [0,2], [3,1],[2,4] }
{ [0,2], [3,1],[4,5] }
{ [0,2], [0,2],[3,1] }
{ [0,2], [0,2],[0,2] }
{ [0,2], [0,2],[1,3] }
{ [0,2], [0,2],[2,4] }
{ [0,2], [0,2],[4,5] }
{ [0,2], [1,3],[3,1] }
{ [0,2], [1,3],[0,2] }
{ [0,2], [1,3],[1,3] }
{ [0,2], [1,3],[2,4] }

职级从小到大可行工作组合: 序号0 职级2；序号1 职级3；序号2 职级4
{ [0,2], [1,3],[4,5] }

职级从小到大可行工作组合: 序号0 职级2；序号1 职级3；序号4 职级5
{ [0,2], [2,4],[3,1] }
{ [0,2], [2,4],[0,2] }
{ [0,2], [2,4],[1,3] }
{ [0,2], [2,4],[2,4] }
{ [0,2], [2,4],[4,5] }

职级从小到大可行工作组合: 序号0 职级2；序号2 职级4；序号4 职级5
{ [0,2], [4,5],[3,1] }
{ [0,2], [4,5],[0,2] }
{ [0,2], [4,5],[1,3] }
{ [0,2], [4,5],[2,4] }
{ [0,2], [4,5],[4,5] }
{ [1,3], [3,1],[3,1] }
{ [1,3], [3,1],[0,2] }
{ [1,3], [3,1],[1,3] }
{ [1,3], [3,1],[2,4] }
{ [1,3], [3,1],[4,5] }
{ [1,3], [0,2],[3,1] }
{ [1,3], [0,2],[0,2] }
{ [1,3], [0,2],[1,3] }
{ [1,3], [0,2],[2,4] }
{ [1,3], [0,2],[4,5] }
{ [1,3], [1,3],[3,1] }
{ [1,3], [1,3],[0,2] }
{ [1,3], [1,3],[1,3] }
{ [1,3], [1,3],[2,4] }
{ [1,3], [1,3],[4,5] }
{ [1,3], [2,4],[3,1] }
{ [1,3], [2,4],[0,2] }
{ [1,3], [2,4],[1,3] }
{ [1,3], [2,4],[2,4] }
{ [1,3], [2,4],[4,5] }

职级从小到大可行工作组合: 序号1 职级3；序号2 职级4；序号4 职级5
{ [1,3], [4,5],[3,1] }
{ [1,3], [4,5],[0,2] }
{ [1,3], [4,5],[1,3] }
{ [1,3], [4,5],[2,4] }
{ [1,3], [4,5],[4,5] }
{ [2,4], [3,1],[3,1] }
{ [2,4], [3,1],[0,2] }
{ [2,4], [3,1],[1,3] }
{ [2,4], [3,1],[2,4] }
{ [2,4], [3,1],[4,5] }
{ [2,4], [0,2],[3,1] }
{ [2,4], [0,2],[0,2] }
{ [2,4], [0,2],[1,3] }
{ [2,4], [0,2],[2,4] }
{ [2,4], [0,2],[4,5] }
{ [2,4], [1,3],[3,1] }
{ [2,4], [1,3],[0,2] }
{ [2,4], [1,3],[1,3] }
{ [2,4], [1,3],[2,4] }
{ [2,4], [1,3],[4,5] }
{ [2,4], [2,4],[3,1] }
{ [2,4], [2,4],[0,2] }
{ [2,4], [2,4],[1,3] }
{ [2,4], [2,4],[2,4] }
{ [2,4], [2,4],[4,5] }
{ [2,4], [4,5],[3,1] }
{ [2,4], [4,5],[0,2] }
{ [2,4], [4,5],[1,3] }
{ [2,4], [4,5],[2,4] }
{ [2,4], [4,5],[4,5] }
{ [4,5], [3,1],[3,1] }
{ [4,5], [3,1],[0,2] }
{ [4,5], [3,1],[1,3] }
{ [4,5], [3,1],[2,4] }
{ [4,5], [3,1],[4,5] }
{ [4,5], [0,2],[3,1] }
{ [4,5], [0,2],[0,2] }
{ [4,5], [0,2],[1,3] }
{ [4,5], [0,2],[2,4] }
{ [4,5], [0,2],[4,5] }
{ [4,5], [1,3],[3,1] }
{ [4,5], [1,3],[0,2] }
{ [4,5], [1,3],[1,3] }
{ [4,5], [1,3],[2,4] }
{ [4,5], [1,3],[4,5] }
{ [4,5], [2,4],[3,1] }
{ [4,5], [2,4],[0,2] }
{ [4,5], [2,4],[1,3] }
{ [4,5], [2,4],[2,4] }
{ [4,5], [2,4],[4,5] }
{ [4,5], [4,5],[3,1] }
{ [4,5], [4,5],[0,2] }
{ [4,5], [4,5],[1,3] }
{ [4,5], [4,5],[2,4] }
{ [4,5], [4,5],[4,5] }

可能组合的小组数量为：4
详情如下：

[职级从小到大可行工作组合: 序号0 职级2；序号1 职级3；序号2 职级4, 
职级从小到大可行工作组合: 序号0 职级2；序号1 职级3；序号4 职级5, 
职级从小到大可行工作组合: 序号0 职级2；序号2 职级4；序号4 职级5, 
职级从小到大可行工作组合: 序号1 职级3；序号2 职级4；序号4 职级5]


3.带数据分析完整代码

import java.util.*;

public class test23 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入员工数量N：");
        int N = sc.nextInt();
        System.out.println("请依次输入N名员工的职级");
        ArrayList<Indexdata> levels = new ArrayList<>();
        int data =0;
        for (int i = 0; i < N; i++) {
            data = sc.nextInt();
            levels.add(new Indexdata(i,data));
        }
        System.out.println("员工序号和职级分别为：");
        for(Indexdata i : levels) {
            System.out.println(i);
        }

        //按职级排序
        Collections.sort(levels,new Comparator<Indexdata>() {
            public int compare(Indexdata o1, Indexdata o2) {
                return Integer.compare(o1.data, o2.data);
            }
        });


        System.out.println("排序后员工职级和索引分别为：");
        for(Indexdata i : levels) {
            System.out.println(i);
        }


        //调用组合函数
        CombinationCalc(levels,N);
    }

    private static void CombinationCalc(ArrayList<Indexdata> levels,int N) {
        int[][]combinations = new int[3][2];
        ArrayList<String> Workcombination = new ArrayList<>();
        String workcombination = "";
        //全排列
        for (int i = 0; i < N; i++) {
            combinations[0][0] = levels.get(i).index;
            combinations[0][1] = levels.get(i).data;
            for (int j = 0; j < N; j++) {
                combinations[1][0] = levels.get(j).index;
                combinations[1][1] = levels.get(j).data;
                for (int k = 0; k < N; k++) {
                    combinations[2][0] = levels.get(k).index;
                    combinations[2][1] = levels.get(k).data;
                    /*
                    System.out.println("全排列组合有：");
                    for (int[] row: combinations) {
                        for (int elem : row) {
                            System.out.print(elem+" ");
                        }
                        System.out.println();
                    }
                     */
                    System.out.println("{ ["+combinations[0][0]+","+combinations[0][1]+
                            "], ["+combinations[1][0]+","+combinations[1][1]+"],[" +
                            combinations[2][0]+","+combinations[2][1]+"] }");
                    //同一个人不能进一个组多次
                    if(levels.get(i).index != levels.get(j).index&&
                            levels.get(j).index != levels.get(k).index&&
                            levels.get(i).index!=levels.get(k).index) {
                        //序号从小到大
                        if(levels.get(i).index<levels.get(j).index&&
                                levels.get(j).index<levels.get(k).index) {
                            //职级从小到大
                            if (levels.get(i).data<levels.get(j).data&&
                                    levels.get(j).data<levels.get(k).data) {
                                /*
                                System.out.println("序号从小到大，职级从小到大的排序有：");
                                System.out.println(Arrays.deepToString(combinations));
                                */
                                workcombination = "\n职级从小到大可行工作组合: " +
                                        "序号"+combinations[0][0]+" 职级"+combinations[0][1]
                                +"；序号"+combinations[1][0]+" 职级"+combinations[1][1]
                                +"；序号"+combinations[2][0]+" 职级"+combinations[2][1]
                                ;
                                System.out.println(workcombination);
                                Workcombination.add(workcombination);
                            }//职级从大到小
                            else if (levels.get(i).data>levels.get(j).data&&
                                    levels.get(j).data>levels.get(k).data) {

                                System.out.println("序号从小到大，职级从大到小的排序有：");
                                System.out.println(Arrays.deepToString(combinations));

                                workcombination = "\n职级从大到小可行工作组合: " +
                                        "序号"+combinations[0][0]+" 职级"+combinations[0][1]
                                        +"；序号"+combinations[1][0]+" 职级"+combinations[1][1]
                                        +"；序号"+combinations[2][0]+" 职级"+combinations[2][1]
                                ;
                                System.out.println(workcombination);//
                                Workcombination.add(workcombination);
                            }
                        }
                    }
                }
            }
        }
        System.out.println("\n可能组合的小组数量为："+Workcombination.size());
        System.out.println("详情如下："+Workcombination);
    }

    static class Indexdata {
        int index;
        int data;
        public Indexdata(int index, int data) {
            this.index = index;
            this.data = data;
        }
        public String toString() {
            return "员工序号："+index+"，职级："+data;
        }
    }

}

鱼油吖
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值