如何实现从任意起点出发的(0,0)中心左旋螺旋坐标生成

需求 #

实现以(0,0)为中心的左旋螺旋坐标生成，可从螺旋内任意起点开始——螺旋形态与从(0,0)起始的完全一致，仅跳过起点之前的所有点。

现有代码问题 #

当前代码仅在initX和initY均为0时能正常生成螺旋坐标，任意起点下逻辑失效，代码如下：

void printSpiralCoords(int32_t initX, int32_t initY, uint32_t steps) {

    int8_t dx = 0;
    int8_t dy = 0;

    uint32_t stepsDone = 0;
    uint32_t length = 0;

    uint32_t absX = abs(initX);
    uint32_t absY = abs(initY);


    if (absX > absY) {
        if (initX >= 0) {
            dy = 1;
        }
        else {
            dy = -1;
        }
        stepsDone = absY;
        length = absX;
    }
    else {
        if (initY >= 0) {
            dx = 1;
        }
        else {
            dx = -1;
        }
        stepsDone = absX;
        length = absY;
    }

    if (length == 0) {
        length = 1;
    }


    for (uint32_t i = 0; i < steps; i++) {

        printf("x: %d, z: %d\n", initX, initY);

        initX += dx;
        initY += dy;

        stepsDone++;
        if (stepsDone >= length) {
            stepsDone = 0;
            if (dx == 0) {
                dx = -dy;
                dy = 0;
                length++;
            }
            else {
                dy = dx;
                dx = 0;
            }
        }
    }
}

约束规则 #

• 螺旋始终保持左旋转向
• 禁止先从(0,0)生成完整螺旋再跳过前置点的实现方式
• steps变量最大值可达2^32-1，不能使用查找表

示例说明 #

• 从(0,0)起始的螺旋：标准左旋螺旋，从原点出发逐层向外扩展
• 从(0,1)起始的螺旋：延续原点起始的螺旋形态，直接从(0,1)位置开始生成后续坐标

修正方案 #

要解决任意起点的问题，核心是准确计算起点所在的螺旋层级、当前段的剩余步数以及下一步的转向方向。

修正后的代码 #

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

void printSpiralCoords(int32_t initX, int32_t initY, uint32_t steps) {
    int8_t dx = 0;
    int8_t dy = 0;
    uint32_t stepsDone = 0;
    uint32_t currentLength = 0;

    // 计算当前点所在的螺旋层级（离原点的最大坐标绝对值）
    uint32_t layer = (uint32_t)abs((intmax_t)initX);
    uint32_t absY = (uint32_t)abs((intmax_t)initY);
    if (absY > layer) {
        layer = absY;
    }

    // 确定当前点所在的边以及初始方向、已走步数、当前段长度
    if (layer == 0) {
        // 起点是原点，初始化方向为右
        dx = 1;
        currentLength = 1;
        stepsDone = 0;
    } else {
        // 判断当前点属于哪一条边
        if (initX == (int32_t)layer && initY > -(int32_t)layer) {
            // 右边界：从(layer, -layer)到(layer, layer)，方向向上
            dy = 1;
            currentLength = 2 * layer;
            stepsDone = initY + layer;
        } else if (initY == (int32_t)layer && initX > -(int32_t)layer) {
            // 上边界：从(layer, layer)到(-layer, layer)，方向向左
            dx = -1;
            currentLength = 2 * layer;
            stepsDone = layer - initX;
        } else if (initX == -(int32_t)layer && initY < (int32_t)layer) {
            // 左边界：从(-layer, layer)到(-layer, -layer)，方向向下
            dy = -1;
            currentLength = 2 * layer;
            stepsDone = layer - initY;
        } else if (initY == -(int32_t)layer && initX < (int32_t)layer) {
            // 下边界：从(-layer, -layer)到(layer+1, -layer)，方向向右
            dx = 1;
            currentLength = 2 * layer + 1;
            stepsDone = initX + layer;
        }

        // 检查当前是否处于段末尾，提前完成转向
        if (stepsDone >= currentLength) {
            if (dx != 0) {
                dy = dx;
                dx = 0;
                currentLength++;
            } else {
                dx = -dy;
                dy = 0;
            }
            stepsDone = 0;
        }
    }

    // 生成指定步数的坐标
    for (uint32_t i = 0; i < steps; i++) {
        printf("x: %d, z: %d\n", initX, initY);

        initX += dx;
        initY += dy;

        stepsDone++;
        if (stepsDone >= currentLength) {
            stepsDone = 0;
            // 左旋转向逻辑：水平转垂直时方向不变并增加段长，垂直转水平时方向反转
            if (dx != 0) {
                dy = dx;
                dx = 0;
                currentLength++;
            } else {
                dx = -dy;
                dy = 0;
            }
        }
    }
}

代码说明 #

1. 层级计算：通过坐标的最大绝对值确定当前点所在的螺旋层级layer，层级直接决定当前边的长度。
2. 边的判断：根据坐标所在的右、上、左、下边界，确定初始移动方向、当前段总长度以及当前点在该段已走的步数。
3. 转向逻辑：严格遵循左旋规则，水平移动后切换为同方向的垂直移动并增加段长度；垂直移动后切换为反方向的水平移动。
4. 大数兼容：使用定宽整数类型处理坐标和步数，确保steps达到2^32-1时不会出现溢出问题。

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