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

news2024/10/7 12:10:31

在这里插入图片描述

华为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在线答疑。

在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2194116.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

麒麟 操作系统介绍| 银河麒麟和中标麒麟操作系统| Kylin 麒麟iso 镜像下载地址 银河麒麟操作系统v10 |

麒麟 操作系统介绍| 银河麒麟和中标麒麟操作系统| Kylin 麒麟iso 镜像下载地址 银河麒麟操作系统v10 |

目录 #申请试用小技巧&#xff0c; 所有麒麟系列的版本如下 详细介绍如下&#xff1a; 银河麒麟高级服务器操作系统 V10 1. 龙芯-MIPS64el 版 2. 申威版 3. 兆芯版 4. 海光版 5. 飞腾版 6. 鲲鹏版 7. AMD64版 8. 龙芯-LoongArch64 版 9. ARM64版 银河麒麟桌面操作…
阅读更多...
BGP路由原理详解

BGP路由原理详解

&#x1f423;个人主页 可惜已不在 &#x1f424;这篇在这个专栏 华为_可惜已不在的博客-CSDN博客 &#x1f425;有用的话就留下一个三连吧&#x1f63c; 目录 一. BGP简介: 二. BGP报文中的角色 BGP的报文 BGP处理过程 BGP有限状态机 BGP属性 三. BGP作用 四. BGP选路 ​…
阅读更多...
120页PPT企业对标管理指导：对标具有全球竞争力的世界一流企业

120页PPT企业对标管理指导：对标具有全球竞争力的世界一流企业

国有企业管理提升与对标管理是提升企业竞争力、实现可持续发展的重要途径。以下是对国有企业管理提升路线与对标管理的详细分析&#xff1a; 一、国有企业管理提升路线 明确战略定位&#xff1a; 根据市场需求和资源状况&#xff0c;确定企业的核心业务和发展方向。制定科学…
阅读更多...
使用 docker-compose 启动 es 集群 + kibana

使用 docker-compose 启动 es 集群 + kibana

编写 docker-compose yaml version: v3 services:elasticsearch-node1:image: elasticsearch:7.17.24container_name: elasticsearch-node1ports:- "9200:9200"- "9300:9300"environment:- node.nameelasticsearch-node1- cluster.namemy-es-cluster- dis…
阅读更多...
【Linux 】文件描述符fd、重定向、缓冲区（超详解）

【Linux 】文件描述符fd、重定向、缓冲区（超详解）

目录 ​编辑 系统接口进行文件访问 open 接口介绍 文件描述符fd 重定向 缓冲区 1、缓冲区是什么&#xff1f; 2、为什么要有缓冲区&#xff1f; 3、怎么办&#xff1f; 我们先来复习一下&#xff0c;c语言对文件的操作&#xff1a; C默认会打开三个输入输出流&#xf…
阅读更多...
SpringBoot 集成 Ehcache 实现本地缓存

SpringBoot 集成 Ehcache 实现本地缓存

目录 1、Ehcache 简介2、Ehcache 集群方式3、工作原理3.1、缓存写入3.2、缓存查找3.3、缓存过期和驱逐3.4、缓存持久化 4、入门案例 —— Ehcache 2.x 版本4.1、单独使用 Ehcache4.1.1、引入依赖4.1.2、配置 Ehcache4.1.2.1、XML 配置方式4.1.2.1.1、新建 ehcache.xml4.1.2.1.2…
阅读更多...
字节放大招：无需LORA训练，小红书写真轻松搞定，Pulid-Flux换脸方案来了

字节放大招：无需LORA训练，小红书写真轻松搞定，Pulid-Flux换脸方案来了

前言 在这之前&#xff0c;SD常用的换脸节点还不支持Flux模型&#xff0c;使用Flux 做虚拟模特最好的方法是炼制人脸lora&#xff0c;但是炼丹是个有技术门槛的活。 之前文章有提过字节跳动的 Pulid团队&#xff0c;率先推出了Pulid-Flux模型&#xff0c;但是之前只能在线上使用…
阅读更多...
vivo/iqoo原子笔记 拍试卷去手写或者叫还原试卷。

vivo/iqoo原子笔记 拍试卷去手写或者叫还原试卷。

1、如果我们经常做试卷的时候&#xff0c;发现有错的&#xff0c;想重新做一下。那就要去掉原来的手写的答案。 2、网上的App或软件多的就是&#xff0c;但大多是要收费的&#xff0c;那么我们如何利用手机里的功能&#xff0c;来基本达到这一效果呢&#xff1f; 3、手机自动…
阅读更多...
Spring Boot实现的医院资源优化工具

Spring Boot实现的医院资源优化工具

1系统概述 1.1 研究背景 如今互联网高速发展&#xff0c;网络遍布全球&#xff0c;通过互联网发布的消息能快而方便的传播到世界每个角落&#xff0c;并且互联网上能传播的信息也很广&#xff0c;比如文字、图片、声音、视频等。从而&#xff0c;这种种好处使得互联网成了信息传…
阅读更多...
ASCII码、Unicode编码和UTF-8编码介绍

ASCII码、Unicode编码和UTF-8编码介绍

1.ASCII码 2.Unicode编码 3.UTF-8编码
阅读更多...
如何训练自己的大模型，答案就在这里。

如何训练自己的大模型，答案就在这里。

训练自己的AI大模型是一个复杂且资源密集型的任务&#xff0c;涉及多个详细步骤、数据集需求以及计算资源要求。以下是根据搜索结果提供的概述&#xff1a; 详细步骤 \1. 设定目标&#xff1a; - 首先需要明确模型的应用场景和目标&#xff0c;比如是进行分类、回归、生成文本…
阅读更多...
实现一个计算器的功能（一般形式、函数指针数组的形式、回调函数的形式）

实现一个计算器的功能（一般形式、函数指针数组的形式、回调函数的形式）

实现一个计算器的功能&#xff1a; 一般的形式&#xff1a; #include<stdio.h> int Add(int x, int y) {return x y; } int Sub(int x, int y) {return x - y; } int Mul(int x, int y) {return x * y; } int Div(int x, int y) {return x / y; } void menu() {printf…
阅读更多...
【Linux】Linux命令与操作详解（一）文件管理（文件命令）、用户与用户组管理（创建、删除用户/组）

【Linux】Linux命令与操作详解（一）文件管理（文件命令）、用户与用户组管理（创建、删除用户/组）

文章目录 一、前言1.1、Linux的文件结构是一颗从 根目录/ 开始的一个多叉树。1.2、绝对路径与相对路径1.3、命令的本质是可执行文件。1.4、家目录 二、文件管理2.1、文件操作1、pwd2、ls3、cd4、touch5、mkdir6、cp7、rm8、mv9、rmdir 2.2、查看文件1、cat2、more3、less4、hea…
阅读更多...
6.1K Star，简简单单的看直播

6.1K Star，简简单单的看直播

Hi&#xff0c;骚年&#xff0c;我是大 G&#xff0c;公众号「GitHub 指北」会推荐 GitHub 上有趣有用的项目&#xff0c;一分钟 get 一个优秀的开源项目&#xff0c;挖掘开源的价值&#xff0c;欢迎关注。 导语 在视频内容飞速发展的时代&#xff0c;实时推流和流媒体技术成…
阅读更多...
java并发之并发实践

java并发之并发实践

一、死锁 线程死锁 死锁是指两个或者两个以上的线程在执行的过程中&#xff0c;因争夺资源产生的一种互相等待现象。 假设线程 A 持有资源 1&#xff0c;线程 B 持有资源 2&#xff0c;它们同时都想申请对方的资源&#xff0c;那么这两个线程就会互相等待而进入死锁状态。 使用…
阅读更多...
多功能声学综合馆：流动会场的新标杆—轻空间

多功能声学综合馆：流动会场的新标杆—轻空间

随着现代会议、展览、演出和活动的多元化需求&#xff0c;场地的灵活性与适应性变得尤为重要。传统的固定场馆难以满足各类活动的复杂需求&#xff0c;而多功能声学综合馆凭借其灵活、便捷、专业的声学性能&#xff0c;成为了市场上一颗闪耀的新星。其“流动会场”的特性&#…
阅读更多...
计算机取证

计算机取证

文章目录 思维导图计算机取证数据固定FTK ImageDumpIt 数据分析——磁盘镜像仿真软件自动仿真手动仿真仿真后的取证分析 基本信息及用户痕迹1.名称、版本、build号、系统目录、位数、产品秘钥等2.安装时间3.最后一次关机时间4.USB使用记录5.WIFI信息6.近期访问过的文档、程序7.…
阅读更多...
动销方案：剑指市场份额扩张

动销方案：剑指市场份额扩张

在竞争激烈的市场中&#xff0c;企业如何扩大市场份额&#xff1f;动销&#xff0c;即拉动销售&#xff0c;乃是关键手段。 首先进行市场分析。行业现状方面&#xff0c;以快速消费品行业为例&#xff0c;市场规模大且持续增长&#xff0c;但竞争激烈&#xff0c;各大品牌不断推…
阅读更多...
深化理解：RAG应用搭建进阶指南

深化理解：RAG应用搭建进阶指南

大型语言模型&#xff08;LLM&#xff09;的文本推理能力&#xff0c;宛如一位博学的公民&#xff0c;其智慧之源来自于互联网上公开的文献宝库。想象一下&#xff0c;这位名为LLM的公民&#xff0c;如同一位勤奋的学者&#xff0c;借阅了图书馆中所有的书籍&#xff0c;并将这…
阅读更多...
杀疯了深度解析chatGPT和NLP底层技术——复旦大学新版《自然语言处理导论》

杀疯了深度解析chatGPT和NLP底层技术——复旦大学新版《自然语言处理导论》

在今年的2月28号&#xff0c;复旦张琦教授放出了自己的大招&#xff0c;发布了自己历时近三年之久&#xff0c;即自身对自然语言处理20年研究的著作 全文共 600页&#xff0c; 涉及了 787 篇参考文献&#xff0c; 全面且深度的解析了与NLP的底层知识。 内容介绍&#xff1a; …
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023