华为OD机试 - 九宫格游戏（Python/JS/C/C++ 2024 E卷 100分）

于 2024-10-07 09:33:29 发布
阅读量347 收藏 8
点赞数 7
分类专栏： 搬砖工逆袭Java架构师 文章标签： 华为od python javascript
本文为博主原创文章，未经博主允许不得转载。
本文链接：https://blog.csdn.net/guorui_java/article/details/142713987
版权

在这里插入图片描述

华为OD机试 2024E卷题库疯狂收录中，刷题点这里

专栏导读

本专栏收录于《华为OD机试真题（Python/JS/C/C++）》。

刷的越多，抽中的概率越大，私信哪吒，备注华为OD，加入华为OD刷题交流群，每一题都有详细的答题思路、详细的代码注释、3个测试用例、为什么这道题采用XX算法、XX算法的适用场景，发现新题目，随时更新，全天CSDN在线答疑。

一、题目描述

九宫格是一款广为流传的游戏，起源于河图洛书。

游戏规则 Q 是：1到9的九个数字放在3×3的格子中，要求每行、每列以及两个对角线上的三数之和都等于15。

在金庸名著《射雕英雄传》中黄蓉曾给 九宫格 Q 的一种解法，口诀：戴九履一，左三右七，二四肩背，八六为足，五居中央。解法如图所示。

在这里插入图片描述

现在有一种新的玩法，给九个 不同的 Q 数字，将这九个数字放在3×3的格子中，要求每行、每列以及两个对角线上的三数之积相等（三阶积幻方）。其中一个三阶幻方如图：

在这里插入图片描述
解释：每行、每列以及两个对角线上的三数之积相等，其为216，该示例的每个三数积均为216，满足三阶积幻方的要求。排列后的九个数字中：第1-3个数字为方格的第一行，第4-6个数字为方格的第二行，第7-9个数字为方格的第三行。

二、输入描述

九个不同的数字，每个数字之间用空格分开。

0 < 数字 < 107。

0 排列后满足要求的每行，每列以及两个对角线上的三数之积 < 2^31-1。

三、输出描述

九个数字所有满足要求的排列，每个数字之间用空格分开。

每行输出一个满足要求的排列。

要求输出的排列升序排列，即：对于排列 A(A1,A2,A3…A9) 和排列 B(B1,B2,B3…B9)，从排列的第 1 个数字开始，遇到 Ai < Bi，则排列 A < 排列 B (1 <= i <= 9)。

说明：用例保证至少有一种排列组合满足条件。

四、测试用例

测试用例1：

1、输入

75 36 10 4 30 225 90 25 12

2、输出

10 36 75 225 30 4 12 25 90
10 225 12 36 30 25 75 4 90
12 25 90 225 30 4 10 36 75
12 225 10 25 30 36 90 4 75
75 4 90 36 30 25 10 225 12
75 36 10 4 30 225 90 25 12
90 4 75 25 30 36 12 225 10
90 25 12 4 30 225 75 36 10

3、说明

五、解题思路

为了求解这个问题，我们需要生成输入的九个不同数字的所有排列组合，并检查每个排列是否满足三阶积幻方的条件。具体步骤如下：

  1. 读取输入：使用 Scanner 读取九个不同的数字，并存储在一个数组中。
  2. 生成排列：通过回溯算法生成所有可能的九个数字的排列组合。由于九个数字的全排列数量为 9! = 362,880，因此在时间允许的范围内，这种方法是可行的。
  3. 验证幻方条件：
    • 将排列的前九个数字放入 3×3 的格子中。
    • 计算每一行、每一列以及两条对角线的三个数字的乘积。
    • 检查这些乘积是否都相等。如果相等，则该排列满足三阶积幻方的条件。
  4. 收集有效排列：将所有满足条件的排列存储在一个列表中。
  5. 排序：根据题目要求，对所有有效排列按升序进行排序。排序的规则是从第一个数字开始，依次比较各个位置的数字大小。
  6. 输出结果：按排序后的顺序输出每个有效排列，数字之间用空格分隔。

通过这种方法，我们可以确保找到所有满足条件的排列，并按照要求进行输出。

六、Python算法源码

import sys
from itertools import permutations

def is_valid(grid):
    """
    检查当前排列是否满足三阶积幻方的条件
    """
    # 计算第一行的乘积作为基准
    target = grid[0] * grid[1] * grid[2]
    
    # 检查每一行的乘积
    for i in range(3):
        row_product = grid[3*i] * grid[3*i +1] * grid[3*i +2]
        if row_product != target:
            return False
    
    # 检查每一列的乘积
    for i in range(3):
        col_product = grid[i] * grid[i +3] * grid[i +6]
        if col_product != target:
            return False
    
    # 检查两条对角线的乘积
    diag1 = grid[0] * grid[4] * grid[8]
    diag2 = grid[2] * grid[4] * grid[6]
    if diag1 != target or diag2 != target:
        return False
    
    return True

def main():
    # 读取输入并转换为整数列表
    input_numbers = list(map(int, sys.stdin.read().strip().split()))
    
    # 检查输入是否有且仅有9个数字
    if len(input_numbers) != 9:
        print("输入必须包含九个不同的数字。")
        return
    
    # 使用集合检查数字是否互不相同
    if len(set(input_numbers)) != 9:
        print("输入的数字必须互不相同。")
        return
    
    valid_perms = []  # 用于存储所有有效的排列
    
    # 生成所有排列并检查每个排列是否有效
    for perm in permutations(input_numbers):
        if is_valid(perm):
            valid_perms.append(perm)
    
    # 对所有有效排列进行排序
    valid_perms.sort()
    
    # 输出所有有效的排列
    for perm in valid_perms:
        print(' '.join(map(str, perm)))

if __name__ == "__main__":
    main()

七、JavaScript算法源码

const readline = require('readline');

// 创建接口以读取标准输入
const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
});

// 读取输入
let input = '';

rl.on('line', (line) => {
    input += line;
}).on('close', () => {
    // 将输入转换为数字数组
    const numbers = input.trim().split(/\s+/).map(Number);
    
    // 检查输入是否有且仅有9个数字
    if (numbers.length !== 9) {
        console.log("输入必须包含九个不同的数字。");
        process.exit(0);
    }
    
    // 检查数字是否互不相同
    const uniqueNumbers = new Set(numbers);
    if (uniqueNumbers.size !== 9) {
        console.log("输入的数字必须互不相同。");
        process.exit(0);
    }
    
    const validPerms = []; // 用于存储所有有效的排列
    
    // 生成所有排列的函数
    function permute(arr, l, r) {
        if (l === r) {
            if (isValid(arr)) {
                validPerms.push([...arr]);
            }
            return;
        }
        for (let i = l; i <= r; i++) {
            [arr[l], arr[i]] = [arr[i], arr[l]]; // 交换
            permute(arr, l + 1, r);
            [arr[l], arr[i]] = [arr[i], arr[l]]; // 交换回来
        }
    }
    
    // 检查当前排列是否满足三阶积幻方的条件
    function isValid(grid) {
        // 计算第一行的乘积作为基准
        const target = grid[0] * grid[1] * grid[2];
        
        // 检查每一行的乘积
        for (let i = 0; i < 3; i++) {
            const rowProduct = grid[3*i] * grid[3*i +1] * grid[3*i +2];
            if (rowProduct !== target) return false;
        }
        
        // 检查每一列的乘积
        for (let i = 0; i < 3; i++) {
            const colProduct = grid[i] * grid[i +3] * grid[i +6];
            if (colProduct !== target) return false;
        }
        
        // 检查两条对角线的乘积
        const diag1 = grid[0] * grid[4] * grid[8];
        const diag2 = grid[2] * grid[4] * grid[6];
        if (diag1 !== target || diag2 !== target) return false;
        
        return true;
    }
    
    // 生成所有排列
    permute(numbers, 0, numbers.length -1);
    
    // 对所有有效排列进行排序
    validPerms.sort((a, b) => {
        for (let i = 0; i < 9; i++) {
            if (a[i] !== b[i]) return a[i] - b[i];
        }
        return 0;
    });
    
    // 输出所有有效的排列
    validPerms.forEach(perm => {
        console.log(perm.join(' '));
    });
});

八、C算法源码

#include <stdio.h>
#include <stdlib.h>

// 定义一个结构体用于存储排列
typedef struct {
    int arr[9];
} Permutation;

// 全局变量用于存储所有有效的排列
Permutation validPerms[362880];
int count = 0;

// 交换函数
void swap(int *a, int *b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

// 检查当前排列是否满足三阶积幻方的条件
int isValid(int grid[]) {
    // 计算第一行的乘积作为基准
    long long target = (long long)grid[0] * grid[1] * grid[2];
    
    // 检查每一行的乘积
    for(int i = 0; i < 3; i++) {
        long long rowProduct = (long long)grid[3*i] * grid[3*i +1] * grid[3*i +2];
        if(rowProduct != target) return 0;
    }
    
    // 检查每一列的乘积
    for(int i = 0; i < 3; i++) {
        long long colProduct = (long long)grid[i] * grid[i +3] * grid[i +6];
        if(colProduct != target) return 0;
    }
    
    // 检查两条对角线的乘积
    long long diag1 = (long long)grid[0] * grid[4] * grid[8];
    long long diag2 = (long long)grid[2] * grid[4] * grid[6];
    if(diag1 != target || diag2 != target) return 0;
    
    return 1;
}

// 生成所有排列并检查有效性
void permute(int *arr, int l, int r) {
    if(l == r) {
        if(isValid(arr)) {
            // 将当前有效的排列添加到validPerms中
            for(int i = 0; i < 9; i++) {
                validPerms[count].arr[i] = arr[i];
            }
            count++;
        }
        return;
    }
    for(int i = l; i <= r; i++) {
        swap(&arr[l], &arr[i]);          // 交换
        permute(arr, l +1, r);           // 递归
        swap(&arr[l], &arr[i]);          // 交换回来
    }
}

// 比较两个排列，用于排序
int compare(const void *a, const void *b) {
    Permutation *pa = (Permutation *)a;
    Permutation *pb = (Permutation *)b;
    for(int i = 0; i < 9; i++) {
        if(pa->arr[i] != pb->arr[i]) {
            return pa->arr[i] - pb->arr[i];
        }
    }
    return 0;
}

int main(){
    int numbers[9];
    
    // 读取九个不同的数字
    for(int i = 0; i < 9; i++) {
        if(scanf("%d", &numbers[i]) != 1){
            printf("输入必须包含九个不同的数字。\n");
            return 0;
        }
    }
    
    // 检查数字是否互不相同
    for(int i = 0; i < 9; i++) {
        for(int j = i +1; j < 9; j++) {
            if(numbers[i] == numbers[j]){
                printf("输入的数字必须互不相同。\n");
                return 0;
            }
        }
    }
    
    // 生成所有排列并检查有效性
    permute(numbers, 0, 8);
    
    // 使用快速排序对所有有效排列进行排序
    qsort(validPerms, count, sizeof(Permutation), compare);
    
    // 输出所有有效的排列
    for(int i = 0; i < count; i++) {
        for(int j = 0; j < 9; j++) {
            printf("%d", validPerms[i].arr[j]);
            if(j != 8) printf(" ");
        }
        printf("\n");
    }
    
    return 0;
}

九、C++算法源码

#include <bits/stdc++.h>
using namespace std;

// 定义一个类型用于存储排列
typedef vector<int> Permutation;

// 全局变量用于存储所有有效的排列
vector<Permutation> validPerms;

// 交换函数（C++内置swap已足够，无需自定义）

// 检查当前排列是否满足三阶积幻方的条件
bool isValid(const Permutation &grid) {
    // 计算第一行的乘积作为基准
    long long target = (long long)grid[0] * grid[1] * grid[2];
    
    // 检查每一行的乘积
    for(int i = 0; i < 3; i++) {
        long long rowProduct = (long long)grid[3*i] * grid[3*i +1] * grid[3*i +2];
        if(rowProduct != target) return false;
    }
    
    // 检查每一列的乘积
    for(int i = 0; i < 3; i++) {
        long long colProduct = (long long)grid[i] * grid[i +3] * grid[i +6];
        if(colProduct != target) return false;
    }
    
    // 检查两条对角线的乘积
    long long diag1 = (long long)grid[0] * grid[4] * grid[8];
    long long diag2 = (long long)grid[2] * grid[4] * grid[6];
    if(diag1 != target || diag2 != target) return false;
    
    return true;
}

int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    
    Permutation numbers(9);
    
    // 读取九个不同的数字
    for(int i = 0; i < 9; i++) {
        cin >> numbers[i];
    }
    
    // 检查数字是否互不相同
    unordered_set<int> uniqueNumbers(numbers.begin(), numbers.end());
    if(uniqueNumbers.size() != 9){
        // 输入的数字不互不相同，退出
        return 0;
    }
    
    // 生成所有排列并检查有效性
    sort(numbers.begin(), numbers.end());
    do {
        if(isValid(numbers)) {
            validPerms.push_back(numbers);
        }
    } while(next_permutation(numbers.begin(), numbers.end()));
    
    // 对所有有效排列进行排序（已按字典序排列，无需再次排序）
    // 但为了确保，进行一次排序
    sort(validPerms.begin(), validPerms.end());
    
    // 输出所有有效的排列
    for(auto &perm : validPerms) {
        for(int i = 0; i < 9; i++) {
            cout << perm[i];
            if(i != 8) cout << ' ';
        }
        cout << '\n';
    }
    
    return 0;
}

🏆下一篇：华为OD机试真题 - 简易内存池（Python/JS/C/C++ 2024 E卷 200分）

🏆本文收录于，华为OD机试真题（Python/JS/C/C++）

刷的越多，抽中的概率越大，私信哪吒，备注华为OD，加入华为OD刷题交流群，每一题都有详细的答题思路、详细的代码注释、3个测试用例、为什么这道题采用XX算法、XX算法的适用场景，发现新题目，随时更新，全天CSDN在线答疑。

在这里插入图片描述

哪 吒
关注
专栏目录
2024华为OD机考机试E卷 +C卷 + D卷 + B卷 + A卷：真题目录 + 考点说明
算法大师！
03-18 38万+
OD，全称(Outsourcing Dispacth)模式，目前华为和德科联合招聘的简称。华为社招基本都是OD招聘，17级以下都是OD模式（13-17）。
华为OD机试 -九宫格游戏 / 三阶积幻方（C++ Java JavaScript Python）
算法大师！
03-04 4065
款广为流传的游戏，起源于河图洛书。 游戏规则是：1到9九个数字放在3×3的格子中，要求每行、每列以及两个对角线上的三数之和都等于15. 在金麻名著《射雕英雄传》中黃蓉曾给九宫格的一种解法，口诀：戴九恩一，左三右七，二四有肩，八六为足，五居中央。解法如图所示。
华为OD机试2024年真题题库（E卷+D卷+C卷+B卷+A卷）
面试高手的博客
11-25 12万+
我是一名软件培训老师，已经帮助上百名学生通过了华为OD机试，2024年8月开始考的都是OD统一考试（E卷），题库已经整理好了，命中率95%以上。
华为OD机试 - 三阶积幻方（Python/JS/C/C++ 2024 E卷 100分）
学Java，找哪吒
09-30 281
华为OD机试 2024E卷题库疯狂收录中，刷题。
【 华为OD机试 2023】 九宫格游戏 / 三阶积幻方（C++ Java JavaScript Python）
专注于图像领域，主要研究内容包括计算机视觉和深度学习，特别是在图像分类、目标检测和图像生成等方面有深入的研究和实践经验。
04-13 173
[九宫格]是一款广为流传的游戏，起源于河图洛书。 游戏规则是：1到9九个数字放在3×3的格子中，要求每行、每列以及两个对角线上的三数之和都等于15. 在金麻名著《射雕英雄传》中黃蓉曾给九宫格的一种解法，口诀：戴九恩一，左三右七，二四有肩，八六为足，五居中央。解法如图所示。
2024华为OD机试题库-(A卷+B卷+C卷+D卷+E)-(JAVA、Python、C++)
goldarmour的博客
03-28 4万+
博主是一名资深后端开发人员，精通C++，Python，Java，乐于分享面试经验，已帮助千余名同学通过OD机考！这些题目博主每一道都刷了至少两遍，每一行代码都蕴含了博主从业以来所积累的所有经验和技巧，可谓干货满满！
华为OD机试真题目录汇总（C语言）2024 B+C+D+E卷 （484道）
KJ.JK
08-09 8万+
本文是华为OD机试真题（C语言）专栏的目录贴（持续更新中…）华为OD是Outsourcing Dispacth模式，是华为和外企德科联合招聘的简称。目前华为大多数是OD招聘。OD模式也是华为提出的一种新的用工形式，每年都会从OD项目挑优秀员工转为正编。所有OD和正式员工一样对待，没有差别，部门平时开会、评审等活动都是一起参加的，是同薪同酬，都是由华为的HR直接定的薪资，看的是我们技术能力。华为是大企业，能到华为上班也是有能力的，每个部门都有好多职位，是金子，在哪都会发光。
2024华为OD机试真题目录 B+C+D+E卷，使用C语言进行解答（484道）
热门推荐
KJ.JK
04-15 14万+
本文是华为OD机试真题(C语言)专栏的目录贴（持续更新中…）定期更新华为OD各个时间阶段的机试真题，每日定时更新，本专栏将使用C语言进行更新解答，包含真题，思路分析，代码参考，欢迎大家订阅学习华为OD机试真题(C语言）定期更新华为OD各个时间阶段的机试真题，每日定时更新，本专栏将使用C语言进行更新解答，包含真题，思路分析，代码参考，欢迎大家订阅学习。
【华为OD】2024年华为OD机试C卷、D卷真题集：最新的真题集题库 C/C++/Java/python/JavaScript
十年以上编程经验的干货分享
04-01 2689
2024年华为OD机试C卷真题题集题库，有2种分数的题目列表分别是100分的列表、200分的列表从2023年11月开始，华为OD题目切换到C卷，基本上大概率会使用半年左右，要在2024年5月之前把这些题目都好好练习一下，可以得到很好的收获，基本上都是出的原题，提前恭喜大家都上岸。目前通过大大提供的真题练习，已经有上百人成功上岸了，而且大大还是一个老师，通过大大指导进入华为OD的学生已经有上千人了。 2024年5月之前，碰到原题的概率是98%以上。
【免费题库】华为OD机试 - 九宫格（Java & JS & Python & C & C++）.html
04-19
【免费题库】华为OD机试 - 九宫格（Java & JS & Python & C & C++）.html
编码能力提升计划 - 华为OD统一考试(E卷)
学习,你不是一个人在战斗 ～ 961302305（QQ,微信）
10-01 618
编码能力提升计划 - 华为OD统一考试(E卷) 为了提升软件编码能力，小王制定了刷题计划，他选了题库中的n道题，编号从0到n-1，并计划在m天内按照题目编号顺序刷完所有的题目(注意，小王不能用多天完成同一题)。 在小王刷题计划中，小王需要用 `time[i]` 的时间完成编号 `i`的题目。此外，小王还可以查看答案，可以省去该题的做题时间。为了真正达到刷题效果，小王每天最多直接看一次答案。 我们定义m天中做题时间最多的一天耗时为T(直接看答案的题目不计入做题总时间)。请你帮小王求出最小的T是多少。
（笔记）第三期书生·浦语大模型实战营（十一卷王场）--书生入门岛通关第2关Python 基础知识
haidizym的博客
10-02 483
学员闯关手册：https://aicarrier.feishu.cn/wiki/ZcgkwqteZi9s4ZkYr0Gcayg1n1g?课程视频：https://www.bilibili.com/video/BV1mS421X7h4/课程文档：https://github.com/InternLM/Tutorial/tree/camp3/docs/L0/Python。
遥感影像-实例分割数据集：iSAID 从切图到YOLO格式数据集制作详细介绍
GIS潮流
09-30 1288
开源数据集isaid标注包含实例分割，但是原始影像太大，很吃显存，一般显卡无法用原始影像直接训练，所以需要对影像进行裁剪，并生成对应的标签，因为想用yolo系列跑模型，所以将标签需要转为txt格式。
酷炫音乐盒: 使用Python和Tkinter配合Pygame打造自己的音乐播放器
宇宙第一小趴菜的博客
09-29 1241
Tkinter是一个功能强大且简单易用的库，适合构建轻量级的GUI应用程序。它在不同的操作系统上具有相同的外观和行为，因此可以实现跨平台的应用程序。当然，Tkinter还有更多的功能和细节，通过阅读官方文档和教程，你可以更深入地了解和学习如何运用Tkinter来创建各种GUI应用程序。
Python | Leetcode Python题解之第448题找到所有数组中消失的数字
Mopes__的博客
10-01 416
Python | Leetcode Python题解之第448题找到所有数组中消失的数字
Python编写的贪吃蛇小游戏
WwLK123的博客
10-03 450
Python编写贪吃蛇小游戏。
pytorch版本和cuda版本不匹配问题
最新发布
分享计算机视觉，C++，网络摄像头研发，音视频开发，嵌入式等知识。
10-06 272
发现cuda11.8支持pytorch2.0.0。
合并两个有序数组
Sudo_Wang的学习记录
09-30 440
我们可以使用双指针法从后向前遍历，避免将已经排序的数组打乱。这个方法的核心思路是从。的末尾开始填充较大的元素，因为末尾是用零填充的空闲区域，这样我们可以避免覆盖。这个方法能够高效地解决问题，并且符合进阶要求的 O(m + n) 复杂度。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

哪 吒

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值