Introduction (may be ignored)

Putting all positive integers in its regular order (1, 2, 3, ...) is a bit boring, isn't it? So here is a series of challenges around permutations (reshuffelings) of all positive integers. This is the sixth challenge in this series (links to the first, second, third, fourth and fifth challenge).

This challenge has a mild Easter theme (because it's Easter). I took my inspiration from this highly decorated (and in my personal opinion rather ugly) goose egg.

It reminded me of the Ulam spiral, where all positive integers are placed in a counter-clockwise spiral. This spiral has some interesting features related to prime numbers, but that's not relevant for this challenge.

We get to this challenge's permutation of positive integers if we take the numbers in the Ulam spiral and trace all integers in a clockwise turning spiral, starting at 1. This way, we get:

1, 6, 5, 4, 3, 2, 9, 8, 7, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 25, 24, 23, etc.

If you would draw both of the spirals, you'd get some sort of an infinite mesh of (egg shell) spirals (note the New Order reference there).

This sequence is present in the OEIS under number A090861. Since this is a "pure sequence" challenge, the task is to output $a(n)$ for a given $n$ as input, where $a(n)$ is A090861.

Task

Given an integer input $n$, output $a(n)$ in integer format, where $a(n)$ is A090861.

Note: 1-based indexing is assumed here; you may use 0-based indexing, so $a(0) = 1; a(1) = 6$, etc. Please mention this in your answer if you choose to use this.

Test cases

Input | Output

---------------

1     |  1

5     |  3

20    |  10

50    |  72

78    |  76

123   |  155

1234  |  1324

3000  |  2996

9999  |  9903

29890 |  29796

Rules

• Input and output are integers.


• Your program should at least support input in the range of 1 up to 32767).


• Invalid input (0, floats, strings, negative values, etc.) may lead to unpredicted output, errors or (un)defined behaviour.


• Default I/O rules apply.


• 
  Default loopholes are forbidden.


• This is code-golf, so the shortest answers in bytes wins

Wolfram Language (Mathematica), 60 bytes

8(s=⌊(⌊Sqrt[#-1]⌋+1)/2⌋)^2-#+2+If[#<=4s^2+2s,-2,6]s&

Try it online!

JavaScript (ES7),  46 45  41 bytes

0-indexed.

n=>((x=n**.5+1&~1)*2-(n<x*x+x)*4+3)*x+1-n

Try it online!

Jelly,  16 14  11 bytes

Ḃ¬+×)RUẎQị@

A monadic Link accepting an integer, n, which yields an integer, a(n).

Try it online! (very inefficient since it goes out to layer $lceilfrac n2rceil$)

A 14-byte version, ½‘Ḃ¬+×Ʋ€RUẎQị@, completes all but the largest test case in under 30s - Try it at TIO - this limits the layers used to $lceilfrac{lfloorsqrt nrfloor+1}2rceil$.

How?

The permutation is to take the natural numbers in reversed slices of lengths [1,5,3,11,5,17,7,23,9,29,11,35,13,...] - the odd positive integers interspersed with the positive integers congruent to five modulo six, i.e [1, 2*3-1, 3, 4*3-1, 5, 6*3-1, 7, 8*3-1, 9, ...].

This is the same as concatenating and then deduplicating reversed ranges [1..x] of where x is the cumulative sums of these slice lengths (i.e. the maximum of each slice) - [1,6,9,20,25,42,49,72,81,110,121,156,169,...], which is the odd integers squared interspersed with even numbers multiplied by themselves incremented, i.e. [1*1, 2*3, 3*3, 4*5, 5*5, 6*7, 7*7,...].

Ḃ¬+×)RUẎQị@ - Link: integer, n       e.g. 10

    )       - for each v in [1..n]:  vs = [ 1, 2, 3, 4, 5, 6, 7, 8, 9,10]

Ḃ           -   modulo 2                  [ 1, 0, 1, 0, 1, 0, 1, 0, 1, 0]

 ¬          -   logical NOT               [ 0, 1, 0, 1, 0, 1, 0, 1, 0, 1]

  +         -   add (v)                   [ 1, 3, 3, 5, 5, 7, 7, 9, 9,11]

   ×        -   multiply (by v)           [ 1, 6, 9,20,25,42,49,72,81,110]

     R      - range (vectorises)          [[1],[1..6],[1..9],[1..20],...,[1..110]]

      U     - upend                       [[1],[6..1],[9..1],[20..1],...,[110..1]]

       Ẏ    - tighten                     [1,6,5,4,3,2,1,9,8,7,6,5,4,3,2,1,20,...,1,...,110,...,1]

        Q   - de-duplicate                [1,6,5,4,3,2,9,8,7,20,...,110,...82]

          @ - with swapped arguments:

         ị  -   (n) index into            20

C# (Visual C# Interactive Compiler), 67 bytes

n=>8*(x=(int)Math.Sqrt(--n)+1>>1)*x+(n<4*x*x+2*x?-2:6)*x+1-n;int x;

Try it online!

MATL, 12 bytes

Eq1YL!tPwG=)

Try it online!

Very memory-inefficient. Prepending X^k makes it more efficient.

Python 3.8, 104 74 65 60 57 bytes

lambda n:(-2,6)[n>4*(x:=(n**.5+1)//2)*x+2*x]*x+2+~n+8*x*x

Edit: Thanks to Johnathan Allan for getting it from 74 to 57 bytes!

This solution uses 0-based indexing.