如何高效实现奇数完全平方数的螺旋坐标矩阵生成？求替代方案

给定一个奇数n，且n是完全平方数（如1、9、25、49、81……），生成包含n个(x,y)坐标的螺旋矩阵序列。

我的实现方案 #

// PasteCount - 满足√(PasteCount)² = PasteCount的奇数，例如1、9、25、49、81……
// Distance (d) - 任意正整数
function snailGeneration(pasteCount, distance) {
    let x = 0;
    let y = 0;

    console.log(x + " , " + y); // 第一步始终已完成

    let totalMoves = 1;
    let rightAndUpMoves = 1;
    let leftAndDownMoves = 2;


    while (true) {
        // 第一个循环 - 向右移动 - 1步、3步、5步、7步、9步
        // 此循环每次迭代都会检查计数器是否达到pasteCount
        // 向右移动 => 执行n次(x + d) - y保持上一循环的数值不变
        for (let i = 0; i < rightAndUpMoves; i++) {
            x += distance;
            totalMoves += 1;
            console.log(x + " , " + y);

            if (totalMoves == pasteCount) return;
        }

        // 第二个循环 - 向上移动 - 1步、3步、5步、7步、9步
        // 向上移动 => 执行n次(y + d) - x保持上一循环的数值不变
        for (let i = 0; i < rightAndUpMoves; i++) {
            y += distance;
            totalMoves += 1;
            console.log(x + " , " + y);
        }

        // 第三个循环 - 向左移动 - 2步、4步、6步、8步、10步
        // 向左移动 => 执行n次(x - d) - y保持上一循环的数值不变
        for (let i = 0; i < leftAndDownMoves; i++) {
            x -= distance;
            totalMoves += 1;
            console.log(x + " , " + y);
        }

        // 第四个循环 - 向下移动 - 2步、4步、6步、8步、10步
        // 向下移动 => 执行n次(y - d) - x保持上一循环的数值不变
        for (let i = 0; i < leftAndDownMoves; i++) {
            y -= distance;
            totalMoves += 1;
            console.log(x + " , " + y);
        }

        // 每个循环的递增模式为+2
        // 每次进入循环时，总迭代次数增加2
        // 在while循环结束时，增加循环的总迭代次数
        rightAndUpMoves += 2;
        leftAndDownMoves += 2;
    }
}

调用snailGeneration(9, 1)时的可视化效果：

提问 #

是否存在更高效的实现方式？能否提供一些替代解决方案？

优化与替代方案 #

1. 简化循环逻辑的优化版本 #

原方案的四个独立循环可以通过方向数组合并，减少重复代码，同时保留核心逻辑：

function snailOptimized(pasteCount, distance) {
    const result = [[0, 0]];
    if (pasteCount === 1) return result;

    let x = 0, y = 0;
    let stepCount = 1;
    // 方向顺序：右、上、左、下
    const directions = [[distance, 0], [0, distance], [-distance, 0], [0, -distance]];
    let dirIndex = 0;

    while (result.length < pasteCount) {
        // 每个方向走stepCount步
        for (let i = 0; i < stepCount; i++) {
            x += directions[dirIndex][0];
            y += directions[dirIndex][1];
            result.push([x, y]);
            if (result.length === pasteCount) return result;
        }
        dirIndex = (dirIndex + 1) % 4;
        // 每完成两个方向（右+上、左+下），步长加2
        if (dirIndex % 2 === 0) {
            stepCount += 2;
        }
    }
    return result;
}

这个版本用数组存储结果（而非直接打印），更灵活复用；通过方向数组统一处理移动逻辑，代码更简洁易维护。

2. 数学公式直接计算（最高效） #

利用螺旋的层状结构规律，直接推导每个位置的坐标，无需循环迭代判断：

function snailMath(pasteCount, distance) {
    const k = Math.sqrt(pasteCount);
    const result = [[0, 0]];

    // 每层处理一圈，共(k-1)/2层
    for (let layer = 1; layer <= (k - 1)/2; layer++) {
        const sideLength = 2 * layer;
        const currentX = layer * distance;
        const currentY = layer * distance;

        // 左移sideLength步（右上角→左上角）
        for (let i = 1; i <= sideLength; i++) {
            result.push([currentX - i * distance, currentY]);
        }
        // 下移sideLength步（左上角→左下角）
        for (let i = 1; i <= sideLength; i++) {
            result.push([currentX - sideLength * distance, currentY - i * distance]);
        }
        // 右移sideLength+1步（左下角→右下角）
        for (let i = 1; i <= sideLength + 1; i++) {
            result.push([currentX - sideLength * distance + i * distance, currentY - sideLength * distance]);
        }
        // 上移sideLength+1步（右下角→右上角）
        for (let i = 1; i <= sideLength + 1; i++) {
            result.push([currentX + distance, currentY - sideLength * distance + i * distance]);
        }
    }
    return result;
}

这种方式时间复杂度为O(n)，避免了循环中的条件判断，是效率最高的实现方式。

3. 迭代器模式（按需生成） #

如果不需要一次性生成所有坐标，可使用迭代器按需生成，节省内存：

function* snailIterator(pasteCount, distance) {
    yield [0, 0];
    if (pasteCount === 1) return;

    let x = 0, y = 0;
    let stepCount = 1;
    const directions = [[distance, 0], [0, distance], [-distance, 0], [0, -distance]];
    let dirIndex = 0;
    let count = 1;

    while (count < pasteCount) {
        for (let i = 0; i < stepCount; i++) {
            x += directions[dirIndex][0];
            y += directions[dirIndex][1];
            yield [x, y];
            count++;
            if (count === pasteCount) return;
        }
        dirIndex = (dirIndex + 1) % 4;
        if (dirIndex % 2 === 0) stepCount += 2;
    }
}

// 使用示例：
const iterator = snailIterator(9, 1);
for (const coord of iterator) {
    console.log(coord.join(' , '));
}

迭代器适合处理大n的场景，不会一次性生成所有坐标占用内存，而是每次调用生成下一个坐标。

内容的提问来源于stack exchange，提问作者matthewbolds