Introducción (puede ser ignorado)

Poner todos los enteros positivos en su orden regular (1, 2, 3, ...) es un poco aburrido, ¿no? Así que aquí hay una serie de desafíos en torno a las permutaciones (reorganizaciones) de todos los enteros positivos. Este es el sexto desafío de esta serie (enlaces al primero , segundo , tercero , cuarto y quinto desafío).

Este desafío tiene un tema suave de Pascua (porque es Pascua). Me inspiré en este huevo de ganso altamente decorado (y en mi opinión personal bastante feo).

Me recordó a la espiral de Ulam , donde todos los enteros positivos se colocan en una espiral en sentido antihorario. Esta espiral tiene algunas características interesantes relacionadas con los números primos, pero eso no es relevante para este desafío.

Llegamos a la permutación de enteros positivos de este desafío si tomamos los números en la espiral de Ulam y trazamos todos los enteros en una espiral que gira en sentido horario , comenzando en 1. De esta manera, obtenemos:

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

Si dibujara ambas espirales, obtendría una especie de malla infinita de espirales (cáscara de huevo) ( tenga en cuenta la referencia del Nuevo Orden allí ).

Esta secuencia está presente en el OEIS con el número A090861 . Como se trata de un desafío de "secuencia pura", la tarea es generar $a(n)$ para un $n$ dado como entrada, donde $a(n)$ es A090861 .

Tarea

Dada una entrada entera $n$ , salida $a(n)$ en formato entero, donde $a(n)$ es A090861 .

Nota: aquí se supone una indexación basada en 1; puede usar indexación basada en 0, entonces $a(0) = 1; a(1) = 6$ , etc. Mencione esto en su respuesta si elige usar esto.

Casos de prueba

Input | Output
---------------
1     |  1
5     |  3
20    |  10
50    |  72
78    |  76
123   |  155
1234  |  1324
3000  |  2996
9999  |  9903
29890 |  29796

Reglas

• La entrada y la salida son enteros.
• Su programa debería al menos admitir entradas en el rango de 1 hasta 32767).
• La entrada no válida (0, flotantes, cadenas, valores negativos, etc.) puede generar salidas imprevistas, errores o un comportamiento (no) definido.
• Se aplican las reglas de E / S predeterminadas .
• Las lagunas predeterminadas están prohibidas.
• Este es el código de golf , por lo que gana la respuesta más corta en bytes

Jalea ,  16 14 11 10 9  8 bytes

-1 gracias a Lynn (mod-2; NO lógico; añadir a sí mismo: Ḃ¬+-> OR bit a bit con 1: |1)

|1×r)ẎQi

A Enlace monádico aceptar un número entero, n, lo que da un número entero, a(n).

Pruébalo en línea!(muy ineficiente ya que sale a la capa $\lceil\frac n2\rceil$)

Una versión de 11 bytes ½‘|1×rƲ€ẎQicompleta todos los casos de prueba, excepto el más grande, en menores de 30 años. Pruébelo en TIO$\lceil\frac{\lfloor\sqrt n\rfloor+1}2\rceil$

¿Cómo?

La permutación es tomar los números naturales en segmentos de longitudes invertidas [1,5,3,11,5,17,7,23,9,29,11,35,13,...]: los enteros positivos impares intercalados con los enteros positivos congruentes con cinco módulo seis, es decir [1, 2*3-1, 3, 4*3-1, 5, 6*3-1, 7, 8*3-1, 9, ...].

Esto es lo mismo que concatenar y luego deduplicar rangos invertidos [1..x]de dónde xestán las sumas acumulativas de estas longitudes de corte (es decir, el máximo de cada corte) [1,6,9,20,25,42,49,72,81,110,121,156,169,...], que son los enteros impares al cuadrado intercalados con números pares multiplicados por ellos mismos incrementados, es decir [1*1, 2*3, 3*3, 4*5, 5*5, 6*7, 7*7,...].

Dado que todas las diferencias son mayores que 1, podemos guardar un byte (la inversión) construyendo rangos [x..k]directamente, donde kestá el índice indexado de 1 del segmento.

Debido a esta estructura, la permutación es una permutación auto-conjugada, es decir, sabemos que $P(n) = v \iff P(v) = n$ , por lo que en lugar de encontrar el valor en el índice (1 indexado)n(|1×r)ẎQị@) podemos obtener el índice (1 indexado) de la primera aparición den(|1×r)ẎQi).

|1×r)ẎQi - Link: integer, n       e.g. 10
    )    - for each k in [1..n]:  vs = [ 1, 2, 3, 4, 5, 6, 7, 8, 9,10]
|1       -   bitwise-OR (k) with 1     [ 1, 3, 3, 5, 5, 7, 7, 9, 9,11]
  ×      -   multiply (by k)           [ 1, 6, 9,20,25,42,49,72,81,110]
   r     -   inclusive range (to k)    [[1],[6..2],[9..3],[20..4],...,[110..10]]
     Ẏ   - tighten                     [1,6,5,4,3,2,9,8,7,6,5,4,3,20,...,4,......,110,...,10]
      Q  - de-duplicate                [1,6,5,4,3,2,9,8,7,20,...,10,......,110,...82]
       i - first index with value (n)  20

JavaScript (ES7),  46 45  41 bytes

0 indexado.

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

Pruébalo en línea!

¿Cómo?

Esto se basa en la fórmula indexada 1 utilizada en los programas de ejemplo de A090861 .

$x_n$$0$

Pruébalo en línea!

$k_n$$6$$-2$

Pruébalo en línea!

$a_n$

Pruébalo en línea!

Que se puede traducir a:

n=>8*(x=(n-1)**.5+1>>1)*x+(n<=4*x*x+2*x?-2:6)*x+2-n

Hacerlo indexado en 0 ahorra 5 bytes de inmediato:

n=>8*(x=n**.5+1>>1)*x+(n<4*x*x+2*x?-2:6)*x+1-n

La fórmula se puede simplificar aún más mediante el uso de:

que se puede expresar como:

x=n**.5+1&~1

llevando a:

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

y finalmente:

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

Wolfram Language (Mathematica) , 60 bytes

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

Pruébalo en línea!

MATL , 12 11 bytes

Eq1YL!tPG=)

Pruébalo en línea!

Muy ineficiente de memoria. Prepending lo X^khace más eficiente .

C # (compilador interactivo de Visual C #) , 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;

Pruébalo en línea!

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

Editar: ¡Gracias a Johnathan Allan por obtenerlo de 74 a 57 bytes!

Esta solución utiliza indexación basada en 0.

Python 3.8 (prelanzamiento) , 53 bytes

Un puerto directo de la respuesta de JavaScript de Arnauld, vota a favor y / o la respuesta de Mathematica de J42161217 , y / o la respuesta de Python de Kapocsi :)

lambda n:((x:=int(n**.5+1)&-2)*2-(n<x*x+x)*4+3)*x+1-n

0 indexado.

Pruébalo en línea!

Befunge, 67 57 bytes

Esta solución supone una indexación basada en 0 para los valores de entrada.

p&v-*8p00:+1g00:<
0:<@.-\+1*g00+*<|`
0g6*\`!8*2+00g4^>$:0

Pruébalo en línea!

Explicación

Comenzamos calculando el "radio" en el que se encuentra la entrada n con un bucle:

radius = 0
while n > 0
  radius += 1
  n -= radius*8

Al final del ciclo, el valor anterior de n es el desplazamiento en la espiral en ese radio:

offset = n + radius*8

Luego podemos determinar si estamos en la sección superior o inferior de la espiral de la siguiente manera:

bottom = offset >= radius*6

Y una vez que tengamos todos estos detalles, el valor en espiral se calcula con:

value = ((bottom?10:2) + 4*radius)*radius + 1 - offset

El radio es el único valor que necesitamos almacenar como una "variable", limitándolo a un valor máximo de 127 en Befunge-93, por lo que este algoritmo puede manejar entradas de hasta 65024.

Japt , 15 bytes

Solución de gelatina del puerto de Jonathan. 1 indexado.

gUòȲ+X*v)õÃcÔâ

Intentalo

gUòȲ+X*v)õÃcÔâ     :Implicit input of integer U
g                   :Index into
 Uò                 :  Range [0,U]
   È                :  Map each X
    ²               :    Square X
     +X*            :    Add X multiplied by
        v           :    1 if X is divisible by 2, 0 otherwise
         )          :    Group result
          õ         :    Range [1,result]
           Ã        :  End map
            c       :  Flatten
             Ô      :    After reversing each
              â     :  Deduplicate

C ++ (gcc) , 88 bytes

#import<cmath>
int a(int n){int x=(sqrt(n-1)+1)/2;return x*(8*(x+(n>4*x*x+2*x))-2)+2-n;}

1 indexado; usa la fórmula en la página OEIS, pero manipulada para guardar algunos bytes.

Pruébalo en línea!