华为OD机试-结队编程（Java/Python/C++）

一、题目描述

题目描述：

某部门计划通过结队编程来进行项目开发，已知该部门有 N 名员工，每个员工有独一无二的职级，每三个员工形成一个小组进行结队编程，结队分组规则如下:

从部门中选出序号分别为 i、j、k 的3名员工，他们的职级分别为 leve[i]，level[j]，level[k],结队小组满足 level[i] < level[j] < level[k] 或者 level[i] > level[j] > level[k],其中0<i<j<k<n。

请你按上述条件计算可能组合的小组数量。同一员工可以参加多个小组.

二、输入输出

输入描述：

第一行输入: 员工总数 n 
第二行输入: 按序号依次排列的员工的职级 level，中间用空格隔开 
备注: 
1≤n≤6000 1 ≤ level[i] ≤10^5
输出描述：
可能结队的小组数量

三、测试用例

示例1：
输入:
4
1 2 3 4
输出:
4
说明:可能结队成的组合(1,2,3)、(1,2,4)、(1,3,4)、(2,3,4)
示例2：
输入:
3
5 4 7
输出:
0
说明:根据结队条件，我们无法为该部门组建小组

四、考点内容

考察逻辑模拟

五、参考代码

JAVA代码

// import java.util.regex.Matcher;
// import java.util.stream.Collectors;
// import java.util.*;
// import java.util.HashMap;
// import java.util.regex.Pattern;
// import java.util.Scanner;
// import java.util.stream.Stream;

 
import java.util.Scanner;
 
public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
 
        System.out.println();
        int n = scanner.nextInt();
 
        System.out.println();
        int[] levels = new int[n];
        for (int i = 0; i < n; i++) {
            levels[i] = scanner.nextInt();
        }
 
        int count = calculateGroupCount(n, levels);
        System.out.println(count);
    }
 
    /**
     * 计算可能的结队小组数量
     *
     * @param n      员工总数
     * @param levels 员工的职级数组
     * @return 可能的结队小组数量
     */
    public static int calculateGroupCount(int n, int[] levels) {
        int count = 0;
 
        // 三重循环遍历所有可能的员工组合
        for (int i = 0; i < n - 2; i++) {
            for (int j = i + 1; j < n - 1; j++) {
                for (int k = j + 1; k < n; k++) {
                    // 判断职级是否满足条件
                    if ((levels[i] < levels[j] && levels[j] < levels[k]) ||
                            (levels[i] > levels[j] && levels[j] > levels[k])) {
                        count++;
                    }
                }
            }
        }
 
        return count;
    }
}

Python代码

# from collections import Counter, defaultdict
# from queue import Queue
# import os
# import math
# import functools
# import re
# import copy
# import sys

 
def get_poss_groups(n, levels):
    # 初始化小组数量为0
    count = 0
    
    # 遍历所有可能的组合
    for i in range(n - 2):
        for j in range(i + 1, n - 1):
            for k in range(j + 1, n):
                # 检查结队分组条件
                if (levels[i] < levels[j] < levels[k]) or (levels[i] > levels[j] > levels[k]):
                    count += 1
    
    return count
 
# 输入员工总数和员工的职级
n = int(input())
levels = list(map(int, input().split()))
 
# 调用函数计算可能结队的小组数量
possible_groups = get_poss_groups(n, levels)
 
# 输出结果
print(possible_groups)

C++代码

// #include<utility>
// #include<algorithm>
// #include<unordered_map>
// #include<set>
// #include<map>
// #include<list>
// #include<stdlib.h>
// #include<string.h>
// #include<iostream>
// #include<regex>
// #include<cmath>
// #include<queue>
// #include<exception> 
// #include<stack>
// #include<bitset>

 
#include <iostream>
#include <vector>
 
// 计算可能结队的小组数量
int countPossibleGroups(int n, std::vector<int>& levels) {
    int count = 0;
    
    // 遍历所有可能的组合
    for (int i = 0; i < n - 2; ++i) {
        for (int j = i + 1; j < n - 1; ++j) {
            for (int k = j + 1; k < n; ++k) {
                if ((levels[i] < levels[j] && levels[j] < levels[k]) || 
                    (levels[i] > levels[j] && levels[j] > levels[k])) {
                    count++;
                }
            }
        }
    }
    
    return count;
}
 
int main() {
    int n;
    std::cin >> n;
    
    std::vector<int> levels(n);
    for (int i = 0; i < n; ++i) {
        std::cin >> levels[i];
    }
    
    // 调用函数计算可能结队的小组数量
    int result = countPossibleGroups(n, levels);
    
    // 输出结果
    std::cout << result << std::endl;
 
    return 0;
}

 六、华为OD机试真题汇总目录

        【华为OD机试】真题汇总C卷（Java/Python/C++实现）