华为OD机试 2024E卷题库疯狂收录中，刷题点这里
专栏导读
本专栏收录于《华为OD机试真题（Python/JS/C/C++）》。
刷的越多，抽中的概率越大，私信哪吒，备注华为OD，加入华为OD刷题交流群，每一题都有详细的答题思路、详细的代码注释、3个测试用例、为什么这道题采用XX算法、XX算法的适用场景，发现新题目，随时更新，全天CSDN在线答疑。
一、题目描述
给定两个只包含数字的数组a、b，调整数组b里面数字的排列顺序，使得尽可能多的a[i] > b[i]。数组a和b中的数字各不相同。
输出所有可以达到最优结果的a数组组数量
二、输入描述
输入的第一行是数组a中的数字，其中只包含数字，每两个数字之间相隔一个空格，a数组大小不超过10。
输入的第一行是数组b中的数字，其中只包含数字，每两个数字之间相隔一个空格，b数组大小不超过10。
三、输出描述
输出所有可以达到最优结果的a数组数量
四、测试用例
输入输出仅供调试，后台判题数据一般不包含示例
测试用例1
1、输入
11 8 20
10 13 7
2、输出
1
3、说明
最优结果只有一个，a = [11, 20, 8]，故输出1
测试用例2
1、输入
11 12 20
10 13 7
2、输出
2
3、说明
有两个a数组的排列可以达到最优结果，[12, 20, 11]和[11, 20, 12]，故输出2
五、解题思路
我们需要对数组 b 进行排列，使得尽可能多的 a[i] > b[i]。可以对数组 a 进行排序，然后对 b 的所有排列进行逐个比较，判断哪些排列能满足 a[i] > b[i]。
暴力解法：对数组 b 求所有排列，并与排序后的 a 逐一比较，统计能够满足条件的情况。
详细步骤：
- 将数组 a 升序排序。
- 求出数组 b 的所有可能排列。
- 对于每一种排列，统计满足 a[i] > b[i] 的情况。
- 返回满足 a[i] > b[i] 条件的最优数量排列的个数。
六、Python算法源码
import itertools
# 计算数组b的所有排列并返回所有排列结果
def permute(nums):
return list(itertools.permutations(nums))
def main():
# 输入a数组
a = list(map(int, input().split()))
# 输入b数组
b = list(map(int, input().split()))
# 将a数组升序排序
a.sort()
# 求b数组的所有排列
permutations = permute(b)
# 记录可以达到最优结果的个数
max_count = 0
optimal_count = 0
# 遍历每一个b的排列，和a数组进行比较
for perm in permutations:
count = 0
# 统计a[i] > b[i]的数量
for i in range(len(a)):
if a[i] > perm[i]:
count += 1
# 更新最优结果
if count > max_count:
max_count = count
optimal_count = 1 # 更新为新的最优情况
elif count == max_count:
optimal_count += 1 # 多个排列可以达到相同的最优结果
# 输出可以达到最优结果的排列个数
print(optimal_count)
# 调用主函数
if __name__ == '__main__':
main()
七、JavaScript算法源码
// 计算数组b的所有排列并返回所有的排列结果
function permute(nums) {
let results = [];
permuteHelper(nums, 0, results);
return results;
}
// 递归函数，求数组的全排列
function permuteHelper(nums, start, results) {
if (start === nums.length - 1) {
results.push([...nums]); // 深拷贝当前排列
return;
}
for (let i = start; i < nums.length; i++) {
[nums[start], nums[i]] = [nums[i], nums[start]]; // 交换
permuteHelper(nums, start + 1, results); // 递归调用
[nums[start], nums[i]] = [nums[i], nums[start]]; // 还原
}
}
// 主函数
function main() {
// 读取输入并将其转换为整数数组
const a = prompt("输入a数组:").split(" ").map(Number);
const b = prompt("输入b数组:").split(" ").map(Number);
// 将a数组升序排序
a.sort((x, y) => x - y);
// 求b数组的所有排列
const permutations = permute(b);
// 记录可以达到最优结果的个数
let maxCount = 0;
let optimalCount = 0;
// 遍历每一个b的排列，和a数组进行比较
permutations.forEach(perm => {
let count = 0;
// 统计a[i] > b[i]的数量
for (let i = 0; i < a.length; i++) {
if (a[i] > perm[i]) {
count++;
}
}
// 更新最优结果
if (count > maxCount) {
maxCount = count;
optimalCount = 1; // 更新为新的最优情况
} else if (count === maxCount) {
optimalCount++; // 多个排列可以达到相同的最优结果
}
});
// 输出可以达到最优结果的排列个数
console.log(optimalCount);
}
// 调用主函数
main();
八、C算法源码
#include <stdio.h>
#include <stdlib.h>
// 交换函数
void swap(int *a, int *b) {
int temp = *a;
*a = *b;
*b = temp;
}
// 递归函数，求数组的全排列
void permuteHelper(int *nums, int start, int size, int **results, int *resultCount) {
if (start == size - 1) {
results[*resultCount] = (int *)malloc(size * sizeof(int));
for (int i = 0; i < size; i++) {
results[*resultCount][i] = nums[i];
}
(*resultCount)++;
return;
}
for (int i = start; i < size; i++) {
swap(&nums[start], &nums[i]); // 交换
permuteHelper(nums, start + 1, size, results, resultCount); // 递归调用
swap(&nums[start], &nums[i]); // 还原
}
}
// 计算数组b的所有排列并返回所有排列结果
int **permute(int *nums, int size, int *resultCount) {
// 计算阶乘大小，确定结果数组的大小
int totalPermutations = 1;
for (int i = 1; i <= size; i++) {
totalPermutations *= i;
}
// 分配空间
int **results = (int **)malloc(totalPermutations * sizeof(int *));
*resultCount = 0;
permuteHelper(nums, 0, size, results, resultCount);
return results;
}
// 对数组进行升序排序的函数（使用简单的冒泡排序）
void bubbleSort(int *arr, int size) {
for (int i = 0; i < size - 1; i++) {
for (int j = 0; j < size - 1 - i; j++) {
if (arr[j] > arr[j + 1]) {
swap(&arr[j], &arr[j + 1]);
}
}
}
}
int main() {
int a[10], b[10];
int n, m; // 数组a和b的大小
// 输入a数组
printf("输入a数组的大小: ");
scanf("%d", &n);
printf("输入a数组: ");
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
// 输入b数组
printf("输入b数组的大小: ");
scanf("%d", &m);
printf("输入b数组: ");
for (int i = 0; i < m; i++) {
scanf("%d", &b[i]);
}
// 将a数组升序排序
bubbleSort(a, n);
// 求b数组的所有排列
int resultCount;
int **permutations = permute(b, m, &resultCount);
// 记录可以达到最优结果的个数
int maxCount = 0;
int optimalCount = 0;
// 遍历每一个b的排列，和a数组进行比较
for (int i = 0; i < resultCount; i++) {
int count = 0;
// 统计a[i] > b[i]的数量
for (int j = 0; j < n; j++) {
if (a[j] > permutations[i][j]) {
count++;
}
}
// 更新最优结果
if (count > maxCount) {
maxCount = count;
optimalCount = 1; // 更新为新的最优情况
} else if (count == maxCount) {
optimalCount++; // 多个排列可以达到相同的最优结果
}
}
// 输出可以达到最优结果的排列个数
printf("%d\n", optimalCount);
// 释放内存
for (int i = 0; i < resultCount; i++) {
free(permutations[i]);
}
free(permutations);
return 0;
}
九、C++算法源码
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
// 交换函数
void swap(int &a, int &b) {
int temp = a;
a = b;
b = temp;
}
// 递归函数，求数组的全排列
void permuteHelper(vector<int> &nums, int start, vector<vector<int>> &results) {
if (start == nums.size() - 1) {
results.push_back(nums);
return;
}
for (int i = start; i < nums.size(); i++) {
swap(nums[start], nums[i]); // 交换
permuteHelper(nums, start + 1, results); // 递归调用
swap(nums[start], nums[i]); // 还原
}
}
// 计算数组b的所有排列并返回所有排列结果
vector<vector<int>> permute(vector<int> &nums) {
vector<vector<int>> results;
permuteHelper(nums, 0, results);
return results;
}
int main() {
vector<int> a, b;
int n, m;
// 输入a数组
cout << "输入a数组的大小: ";
cin >> n;
cout << "输入a数组: ";
for (int i = 0; i < n; i++) {
int temp;
cin >> temp;
a.push_back(temp);
}
// 输入b数组
cout << "输入b数组的大小: ";
cin >> m;
cout << "输入b数组: ";
for (int i = 0; i < m; i++) {
int temp;
cin >> temp;
b.push_back(temp);
}
// 将a数组升序排序
sort(a.begin(), a.end());
// 求b数组的所有排列
vector<vector<int>> permutations = permute(b);
// 记录可以达到最优结果的个数
int maxCount = 0;
int optimalCount = 0;
// 遍历每一个b的排列，和a数组进行比较
for (const auto &perm : permutations) {
int count = 0;
// 统计a[i] > b[i]的数量
for (int i = 0; i < n; i++) {
if (a[i] > perm[i]) {
count++;
}
}
// 更新最优结果
if (count > maxCount) {
maxCount = count;
optimalCount = 1; // 更新为新的最优情况
} else if (count == maxCount) {
optimalCount++; // 多个排列可以达到相同的最优结果
}
}
// 输出可以达到最优结果的排列个数
cout << optimalCount << endl;
return 0;
}
🏆下一篇：华为OD机试真题 - 简易内存池（Python/JS/C/C++ 2024 E卷 200分）
🏆本文收录于，华为OD机试真题（Python/JS/C/C++）
刷的越多，抽中的概率越大，私信哪吒，备注华为OD，加入华为OD刷题交流群，每一题都有详细的答题思路、详细的代码注释、3个测试用例、为什么这道题采用XX算法、XX算法的适用场景，发现新题目，随时更新，全天CSDN在线答疑。
7万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
