返回目录

疫情期间，小明隔离在家，百无聊赖，在纸上写数字玩。他发明了一种写法：

题目描述

给出数字个数 n （0 < n ≤ 999）和行数 m（0 < m ≤ 999），从左上角的 1 开始，按照顺时针螺旋向内写方式，依次写出2,3,....,n，最终形成一个 m 行矩阵。

小明对这个矩阵有些要求：

1. 每行数字的个数一样多
2. 列的数量尽可能少
3. 填充数字时优先填充外部
4. 数字不够时，使用单个 * 号占位

输入描述

两个整数，空格隔开，依次表示 n、m

输出描述

符合要求的唯一矩阵

示例：

题目解析

本题需要我们将1\~n数字按照螺旋顺序填入矩阵。

本题只给出了矩阵的行数m，没有给列数，需要我们求解一个最少的列数来满足矩阵能够填入n个数字，因此列数 k = ceil(n / m)，这里的除法不是整除，并且要对除法的结果向上取整。

将数字1\~n按照螺旋顺序，从矩阵matrix左上角开始填入，比较考察思维能力，具体实现如下：

• 定义变量step，初始step=1，表示当前要填入的数字，因此step ≤ n
• 定义变量x，y，初始x=0, y=0，表示要填值得矩阵位置，即初始时从矩阵左上角开始填入

然后按照顺序循环进行下面四个填值操作：

1. 正序填入第X行
2. 正序填入第Y列
3. 倒序填入第X行
4. 倒序填入第Y列

C算法源码

``

#include <stdio.h>
#include <math.h>

int main() {
    // num_elements 表示需要在螺旋矩阵中填入 1 ~ num_elements 数字的总数
    // rows 表示螺旋矩阵的行数
    int num_elements, rows;
    scanf("%d %d", &num_elements, &rows);
    // columns 表示螺旋矩阵的列数
    int columns = (int) ceil(num_elements * 1.0 / rows);

    // 螺旋矩阵
    int spiral_matrix[rows][columns];
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < columns; j++) {
            spiral_matrix[i][j] = 0; // 由于需要填入1~num_elements数字，因此这里未填值的位置值默认初始化为0
        }
    }

    // 当前要填入的值
    int current_value = 1;

    // 当前要填入的值的位置
    int x_pos = 0;
    int y_pos = 0;

    // 如果填入的值 > num_elements，则停止填值，否则继续填
    while (current_value <= num_elements) {
        // 正序填入第x行，即：行号不变，列号增加，注意：添值过程不能发生覆盖，也不能填入超过num_elements的值
        while (y_pos < columns && spiral_matrix[x_pos][y_pos] == 0 && current_value <= num_elements) {
            spiral_matrix[x_pos][y_pos++] = current_value++;
        }
        y_pos -= 1;
        x_pos += 1;

        // 正序填完第x行后，y处于末尾越界位置，因此y需要退一步
        // 按照螺旋矩阵顺序，应该从第x+1行开始正序填值第y列
        // 正序填入第y列，即：列号不变，行号增加，注意：添值过程不能发生覆盖，也不能填入超过num_elements的值
        while (x_pos < rows && spiral_matrix[x_pos][y_pos] == 0 && current_value <= num_elements) {
            spiral_matrix[x_pos++][y_pos] = current_value++;
        }
        x_pos -= 1;
        y_pos -= 1;

        // 倒序填入第x行，即：行号不变，列号减少，注意：添值过程不能发生覆盖，也不能填入超过num_elements的值
        while (y_pos >= 0 && spiral_matrix[x_pos][y_pos] == 0 && current_value <= num_elements) {
            spiral_matrix[x_pos][y_pos--] = current_value++;
        }
        y_pos += 1;
        x_pos -= 1;

        // 倒序填入第y列，即：列号不变，行号减少，注意：添值过程不能发生覆盖，也不能填入超过num_elements的值
        while (x_pos >= 0 && spiral_matrix[x_pos][y_pos] == 0 && current_value <= num_elements) {
            spiral_matrix[x_pos--][y_pos] = current_value++;
        }
        x_pos += 1;
        y_pos += 1;
    }

    // 打印螺旋矩阵字符串
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < columns; j++) {
            if (spiral_matrix[i][j] == 0) {
                printf("*");
            } else {
                printf("%d", spiral_matrix[i][j]);
            }

            if (j < columns - 1) {
                printf(" ");
            }
        }
        puts("");
    }

    return 0;
}

}`

Java算法源码

`

`import java.util.Scanner;
import java.util.StringJoiner;

public class Main {

    // 新增无关变量
    static String message = "This is a new variable.";

    // 新增函数
    static void someFunction() {
        System.out.println("This is a new function.");
    }

    // 新增类
    static class SomeClass {
        int[][] data;

        SomeClass(int size) {
            this.data = new int[size][size];
        }

        void addData(int x, int y, int value) {
            this.data[x][y] = value;
        }
    }

    // 修改后的函数入参类型和个数，适当更改注释
    static void getResult(int n, int m) {
        int k = (int) Math.ceil(n * 1.0 / m);
        SomeClass someObj = new SomeClass(m);

        int step = 1;
        int x = 0;
        int y = 0;

        while (step <= n) {
            while (y < k && someObj.data[x][y] == 0 && step <= n)
                someObj.addData(x, y++, step++);
            y -= 1;
            x += 1;

            while (x < m && someObj.data[x][y] == 0 && step <= n)
                someObj.addData(x++, y, step++);
            x -= 1;
            y -= 1;

            while (y >= 0 && someObj.data[x][y] == 0 && step <= n)
                someObj.addData(x, y--, step++);
            y += 1;
            x -= 1;

            while (x >= 0 && someObj.data[x][y] == 0 && step <= n)
                someObj.addData(x--, y, step++);
            x += 1;
            y += 1;
        }

        for (int i = 0; i < m; i++) {
            StringJoiner row = new StringJoiner(" ");
            for (int j = 0; j < k; j++) {
                if (someObj.data[i][j] == 0) {
                    row.add("*");
                } else {
                    row.add(String.valueOf(someObj.data[i][j]));
                }
            }
            System.out.println(row);
        }

        System.out.println("\n" + message);
        someFunction();
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        // 修改后的函数入参类型和个数，适当更改注释
        int n = sc.nextInt();
        int m = sc.nextInt();

        // 调用修改后的函数
        getResult(n, m);
    }
}

Python算法源码

import math

# 定义一个新的变量
message = "This is a new variable."

# 定义一个新的函数
def some_function():
    print("This is a new function.")

# 定义一个类
class SomeClass:
    def __init__(self, size):
        self.data = [['*'] * size for _ in range(size)]

    def add_data(self, x, y, value):
        self.data[x][y] = value

# 修改后的函数入参类型和个数，适当更改注释
def get_result(n, m):
    k = int(math.ceil(n / m))
    some_obj = SomeClass(m)

    step = 1
    x, y = 0, 0

    while step <= n:
        while y < k and some_obj.data[x][y] == '*' and step <= n:
            some_obj.add_data(x, y, str(step))
            step += 1
            y += 1

        y -= 1
        x += 1

        while x < m and some_obj.data[x][y] == '*' and step <= n:
            some_obj.add_data(x, y, str(step))
            step += 1
            x += 1

        x -= 1
        y -= 1

        while y >= 0 and some_obj.data[x][y] == '*' and step <= n:
            some_obj.add_data(x, y, str(step))
            step += 1
            y -= 1

        y += 1
        x -= 1

        while x >= 0 and some_obj.data[x][y] == '*' and step <= n:
            some_obj.add_data(x, y, str(step))
            step += 1
            x -= 1

        x += 1
        y += 1

    # 打印结果
    for i in range(m):
        print(" ".join(some_obj.data[i]))

    # 打印额外的消息
    print("\n" + message)
    some_function()

# 输入获取
n, m = map(int, input().split())

# 算法调用
get_result(n, m)