自学内容网 自学内容网

华为OD机试 - 箱子之字形摆放(Python/JS/C/C++ 2024 E卷 100分)

在这里插入图片描述

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

专栏导读

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

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

一、题目描述

有一批箱子(形式为字符串 Q,设为str),要求将这批箱子按从上到下以下Z字形顺序摆放在宽度为 n 的空地,请输出箱子的摆放位置。

例如:箱子ABCDEF, 空地宽度为3,摆放结果如图:

在这里插入图片描述
则输出结果为:

AFG
BE
CD

二、输入描述

输入一行字符串,通过空格分隔,前面部分为字母或数字组成的字符串str,表示箱子;后面部分为数字n,表示空地的宽度。

例如:ABCDEFG 3

三、输出描述

箱子摆放结果,如题目示例所示

AFG
BE
CD

四、测试用例

测试用例1:

1、输入

ABCDEFGHIJK 4

2、输出

AHI
BGJ
CFK
DE

3、说明

测试用例2:

1、输入

123456789 4

2、输出

189
27
36
45

3、说明

五、解题思路

  1. 输入处理:
    • 读取输入字符串str和宽度n。
  2. 初始化数据结构:
    • 创建一个包含n个列表的列表(matrixLists),每个子列表对应空地的一列,用于存放摆放的箱子。
  3. 摆放箱子:
    • 遍历字符串中的每个字符,根据当前位置i和宽度n计算当前应该放置到哪一列。
    • 使用一个布尔变量reverse来控制当前行的摆放方向(从左到右或从右到左)。每当到达新的一行(即i % n == 0)时,切换reverse的值。
    • 如果reverse为true,则调整列索引为n - 1 - k,实现反向摆放。
    • 将当前字符添加到对应的列列表中。
  4. 输出结果:
    • 遍历matrixLists中的每个子列表,将其中的字符连接成字符串,并逐行输出,得到最终的摆放结果。

六、Python算法源码

# 导入所需的模块
import sys

def main():
    # 读取输入,假设输入通过标准输入提供
    input_line = sys.stdin.read().strip()
    if not input_line:
        return
    
    # 分割输入,前面是字符串,后面是数字n
    parts = input_line.split()
    if len(parts) != 2:
        return
    
    s = parts[0]  # 字符串
    n = int(parts[1])  # 空地宽度
    
    # 初始化一个包含n个空列表的列表,用于存放每一列的字符
    matrix_lists = [[] for _ in range(n)]
    
    reverse = True  # 初始方向为反向
    for i in range(len(s)):
        k = i % n  # 计算当前字符应该放在哪一列
        
        if k == 0:
            reverse = not reverse  # 每到新的一行,切换方向
        
        if reverse:
            k = n - 1 - k  # 如果是反向,调整列索引
        
        matrix_lists[k].append(s[i])  # 将字符添加到对应的列列表中
    
    # 输出结果,每个子列表的字符连接成一个字符串
    for lst in matrix_lists:
        print(''.join(lst))

if __name__ == "__main__":
    main()

七、JavaScript算法源码

// 使用Node.js环境
function main() {
    const fs = require('fs');
    const input = fs.readFileSync(0, 'utf-8').trim(); // 读取标准输入并去除首尾空白字符
    if (!input) return;
    
    const parts = input.split(' '); // 分割输入
    if (parts.length !== 2) return;
    
    const s = parts[0]; // 字符串
    const n = parseInt(parts[1]); // 空地宽度
    
    // 初始化一个包含n个空数组的数组,用于存放每一列的字符
    const matrixLists = Array.from({length: n}, () => []);
    
    let reverse = true; // 初始方向为反向
    for (let i = 0; i < s.length; i++) {
        let k = i % n; // 计算当前字符应该放在哪一列
        
        if (k === 0) {
            reverse = !reverse; // 每到新的一行,切换方向
        }
        
        if (reverse) {
            k = n - 1 - k; // 如果是反向,调整列索引
        }
        
        matrixLists[k].push(s[i]); // 将字符添加到对应的列列表中
    }
    
    // 输出结果,每个子数组的字符连接成一个字符串
    for (const lst of matrixLists) {
        console.log(lst.join(''));
    }
}

main();

八、C算法源码

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

// 定义最大输入长度
#define MAX_LEN 1000

int main() {
    char s[MAX_LEN];
    int n;
    
    // 读取字符串和数字n
    if (scanf("%s %d", s, &n) != 2) {
        return 0;
    }
    
    // 动态分配二维数组,每列用一个动态字符串存储
    char **matrixLists = (char **)malloc(n * sizeof(char *));
    for (int i = 0; i < n; i++) {
        matrixLists[i] = (char *)malloc(MAX_LEN * sizeof(char));
        matrixLists[i][0] = '\0'; // 初始化为空字符串
    }
    
    int reverse = 1; // 初始方向为反向(1表示反向,0表示正向)
    int len = strlen(s);
    for (int i = 0; i < len; i++) {
        int k = i % n; // 计算当前字符应该放在哪一列
        
        if (k == 0) {
            reverse = !reverse; // 每到新的一行,切换方向
        }
        
        if (reverse) {
            k = n - 1 - k; // 如果是反向,调整列索引
        }
        
        // 将当前字符添加到对应的列字符串中
        int current_len = strlen(matrixLists[k]);
        matrixLists[k][current_len] = s[i];
        matrixLists[k][current_len + 1] = '\0';
    }
    
    // 输出结果,每个列字符串作为一行
    for (int i = 0; i < n; i++) {
        printf("%s\n", matrixLists[i]);
    }
    
    // 释放动态分配的内存
    for (int i = 0; i < n; i++) {
        free(matrixLists[i]);
    }
    free(matrixLists);
    
    return 0;
}

九、C++算法源码

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>

using namespace std;

int main(){
    string s;
    int n;
    
    // 读取字符串和数字n
    cin >> s >> n;
    
    // 初始化一个包含n个空字符串的向量,用于存放每一列的字符
    vector<string> matrixLists(n, "");
    
    bool reverse_flag = true; // 初始方向为反向
    int len = s.length();
    for(int i = 0; i < len; i++){
        int k = i % n; // 计算当前字符应该放在哪一列
        
        if(k == 0){
            reverse_flag = !reverse_flag; // 每到新的一行,切换方向
        }
        
        if(reverse_flag){
            k = n - 1 - k; // 如果是反向,调整列索引
        }
        
        matrixLists[k] += s[i]; // 将字符添加到对应的列字符串中
    }
    
    // 输出结果,每个列字符串作为一行
    for(auto &str : matrixLists){
        cout << str << endl;
    }
    
    return 0;
}


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

🏆本文收录于,华为OD机试真题(Python/JS/C/C++)

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

在这里插入图片描述


原文地址:https://blog.csdn.net/guorui_java/article/details/142632471

免责声明:本站文章内容转载自网络资源,如本站内容侵犯了原著者的合法权益,可联系本站删除。更多内容请关注自学内容网(zxcms.com)!