Formula Challenge: The most efficient way to generate a Number Spiral (Ulam spiral) ?

This is my rendition for 2024 with  no Lambda helper functions.

//Patrick2788   11/21/2024

//Create a Ulam Spiral by supplying cartesian coordinates.
//Parameters:
//rings -   Create a spiral with this many rings from the center starting value
//[start_at] -  Specify a starting number. Defaults to 1 if omitted.

Spiralλ = LAMBDA(rings,[start_at],
        LET(
            start_at,IF(ISOMITTED(start_at),1,start_at),
        //Create cartesian coordindates
            i, SEQUENCE(rings * 2 + 1, , rings, -1),
            j, SEQUENCE(, rings * 2 + 1, -rings, 1),
        //Broadcast cartesian coordinates to matrices
            x, j * SEQUENCE(rings * 2 + 1, , 1, 0),
            y, i * SEQUENCE(, rings * 2 + 1, 1, 0),
        //Four scenarios for Four quadrants:
        //a_ - right    b_ -    left    c_ - top    d_ - bottom
            a_, (ABS(x) > ABS(y)) * (x > 0),
            b_, (ABS(x) > ABS(y)) * (x <= 0),
            c_, (ABS(x) <= ABS(y)) * (y > 0),
            d_, (ABS(x) <= ABS(y)) * (y <= 0),
        //Calculations for each quadrant:
            a, 4 * x ^ 2 - 3 * x + y,
            b, 4 * x ^ 2 - x - y,
            c, 4 * y ^ 2 - y - x,
            d, 4 * y ^ 2 - 3 * y + x,
        //Check cartesian coordinates, apply calculations
            result, start_at+IF(a_, a, IF(b_, b, IF(c_,c, d))),
            result
        )
    );

Patrick2788 Interesting challenge. I took a slightly different approach, starting from the center of the spiral and working my way outwards, offsetting the row or column number by either 1 or -1 at each step. I used TOCOL / IF / SEQUENCE as the primary method of array manipulation, then SORTBY to sort the numeric sequence by row and column number, and WRAPROWS to output the final results. Due to the row limitations of the SEQUENCE function, the maximum output size is 1023 rows by 1023 columns (1,046,529 numbers), but it only takes 3 seconds to process.

The complete definition of the LAMBDA function is:

ULAMSPIRAL:
=LAMBDA(rows,
    LET(
        n, rows + ISEVEN(rows),
        adj, DROP(TOCOL(IF({1,1}, SEQUENCE(n))), -1),
        row, DROP(TOCOL(IF(SEQUENCE(n), {0,1})), -1),
        off, DROP(DROP(TOCOL(IF(SEQUENCE(n), {1,1,-1,-1})), 1), -2),
        rId, DROP(TOCOL(IFS(adj >= SEQUENCE(, MAX(adj)), SEQUENCE(ROWS(adj))), 2), -1),
        r, INDEX(row, rId),
        k, INDEX(off, rId),
        s, ROUNDUP(n/2, 0),
        POS, LAMBDA(int,arr, VSTACK(int, SCAN(int, arr, LAMBDA(a,v, a+v)))),
        spiral, WRAPROWS(SORTBY(SEQUENCE(n^2), POS(s, r*k), 1, POS(s, NOT(r)*k), 1), n),
        DROP(spiral, rows-n, n-rows)
    )
)

It's set up a little different, in that you enter the total number of rows to be generated (n=rows^2). Entering an odd number of rows will generate a perfect spiral, whereas an even number of rows will be truncated (the last row and first column will be dropped)...

I found it best to avoid any iteration in order to not reach the calculation limit so quickly. This formula can return an 1120x1120 in less than 30 seconds. I must admit, I'm using Google Sheets, but I believe there's no compatibility issues with this formula. I'm not really sure what it's limit is in Sheets or Excel yet.

=let(n,1120,i,sequence(n),j,sequence(1,n),
index(n^2-
if(i<j+1,
  if(j<=n-i+1,
    4*n*i-4*i^2+7*i-4*n+j-4,
    4*n*j-4*j^2+3*j+i-2*n-2),
  if(j<n-i+1,
    4*n*j-4*j^2+j-i,
    4*n*i-4*i^2-2*n-j+5*i-2))))

 Patrick2788 

interesting. I already did something like this for that Fibonacci sequence challenge. I will have to pull out that file and see how I did it then

Ok so I used an approach inside out and here it is modified for this solution:

=IF(n > 1,
    LET(turns, 2 * INT(SQRT(n)) - 1,
        s, SEQUENCE(turns),
        all, REDUCE({1, 2},s,LAMBDA(p, q,
                CHOOSE(
                    MOD(q, 4) + 1,
                    HSTACK(p, SEQUENCE(ROWS(p), 1, MAX(p) + ROWS(p) + 1, -1)),
                    VSTACK(SEQUENCE(1, COLUMNS(p), COLUMNS(p) + MAX(p), -1), p),
                    HSTACK(SEQUENCE(ROWS(p), 1, MAX(p) + 1), p),
                    VSTACK(p, SEQUENCE(1, COLUMNS(p), MAX(p) + 1))
                )
            )
        ),
        final, IF(all > n, "", all),
        final
    ),
    "Parameter 'n' must be >=1"
)

it is far from optimized as excel has to find the MAX each loop when I could potentially add some parameters to the accumulator to pass the max and # rows/columns and even the next position

regardless it works relatively well and can do significant numbers (just how long you want to wait).