8

Dado un número de entrada positivo n, construya una espiral de números desde 1hasta n^2, con 1en la parte superior izquierda, girando hacia adentro en sentido horario. Tome la suma de las diagonales (si nes impar, el número del medio n^2se cuenta dos veces) y escriba ese número.

Ejemplo para n = 1:

1

(1) + (1) = 2

Ejemplo para n = 2:

1 2
4 3

(1+3) + (4+2) = 4 + 6 = 10

Ejemplo para n = 4:

 1  2  3 4
12 13 14 5
11 16 15 6
10  9  8 7

(1+13+15+7) + (10+16+14+4) = 36 + 44 = 80

Ejemplo de n = 5:

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

(1+17+25+21+9) + (13+23+25+19+5) = 73 + 85 = 158

Más reglas y aclaraciones

Este es OEIS A059924 y hay algunas soluciones de forma cerrada en esa página.
Se puede suponer que la entrada y la salida encajan en el tipo entero nativo de su idioma.
La entrada y la salida se pueden dar en cualquier formato conveniente .
Puede optar por 0-index o 1-index, como estoy aquí en mis ejemplos, para su envío. Por favor, indique lo que está haciendo.
Un programa completo o una función son aceptables. Si es una función, puede devolver el resultado en lugar de imprimirlo.
Si es posible, incluya un enlace a un entorno de prueba en línea para que otras personas puedan probar su código.
Las lagunas estándar están prohibidas.
Este es el código de golf, por lo que se aplican todas las reglas habituales de golf, y gana el código más corto (en bytes).

— AdmBorkBork
fuente

21

R , 43 34 bytes

function(n)(8*n^3-3*n^2+4*n+3)%/%6

Pruébalo en línea!

La página OEIS enumera la siguiente fórmula para a(n):

(16*n^3 - 6*n^2 + 8*n + 3 - 3*(-1)^n)/12

Sin embargo, pasé por alto eso para llegar a la sección PROG donde se encuentra el siguiente código PARI:

floor((16*n^3 - 6*n^2 + 8*n + 3 - 3*(-1^n))/12))

Naturalmente, +3-3*(-1^n)es lo mismo +6que podemos simplificar la fórmula vinculada, primero reduciéndola a

(16*n^3-6*n^2+8*n+6)/12 -> (8*n^3-3*n^2+4*n+3)/6

y usar %/%, división entera, en lugar de /eliminar la necesidad de floor.

— Giuseppe
fuente

1

+3-3*(-1)^nno es realmente lo mismo 6, aunque la diferencia se pierde en la división de enteros.

— fergusq

@fergusq tienes razón, pero la fórmula dada como la expresión en PARI (en la que baso mi solución) tiene +3-3*(-1^n)la misma que +6. Actualizaré mi respuesta para hacerlo más obvio.

— Giuseppe

Es @Giuseppe +6si nes raro, pero +0cuando nes aún

— Bergi

3

@Bergi 3-3*(-1^n)es siempre 6pero 3-3*(-1)^ntiene ese comportamiento alternativo. La fórmula original tiene el último, lo que hace innecesario el uso de la división de enteros, ya que siempre es divisible por 12

— Giuseppe

1

Ah bien. Sin embargo, es extraño que el autor original haya pasado por alto esto, ¿no?

— Bergi

5

Python 2 , 30 bytes

Ahorró algunos bytes al portar el enfoque de Giuseppe .

lambda n:((8*n-3)*n*n+4*n+3)/6

Pruébalo en línea!

Python 2 , 36 34 bytes

Ahorré algunos bytes más gracias a @LeakyNun .

lambda n:((8*n-3)*n*n+4*n+n%2*3)/6

Pruébalo en línea!

— Sr. Xcoder
fuente

1

36 bytes

— Leaky Nun

34 bytes

— Leaky Nun

@LeakyNun Gracias y gracias.

— Sr. Xcoder

2

Créditos de 30 bytes a Giuseppe para el acercamiento

— Leaky Nun

@LeakyNun Yo también estaba actualizando eso

— Sr. Xcoder

3

Mathematica, 19 bytes

((8#-3)#*#+4#+3)/6&

Puede ejecutarlo con la siguiente sintaxis:

((8#-3)#*#+4#+3)/6&[5]

Donde 5se puede sustituir con la entrada.

Puede probarlo en el Sandbox de Wolfram (Copiar-Pegar + Evaluar celdas)

— Sr. Xcoder
fuente

3

Mathematica, 19 bytes

((8#-3)#*#+4#+3)/6&

Pruébalo en línea!

Ahorró algunos bytes al portar el enfoque de Giuseppe.

Mathematica, 58 bytes

Siempre disfruto las preguntas con respuestas dadas gracias a los oeis (por la buena pregunta y respuesta)

LinearRecurrence[{3,-2,-2,3,-1},{0,2,10,34,80},2#][[#+1]]&

— J42161217
fuente

¿No sería más golfista usar la forma cerrada?

— Leaky Nun

1

muchas respuestas están utilizando mi simplificación, por lo que bien puede hacer lo mismo

— Giuseppe

2

Jalea , 11 10 bytes

1 byte gracias a Jonathan Allan.

⁽ø\DN2¦ḅ:6

Pruébalo en línea!

— Monja permeable
fuente

8,-3,4,3-> ⁽ø\DN2¦para guardar un byte

— Jonathan Allan

1

MATL , 21 bytes

tt2^Qw6Y3YL-wXytP+*ss

Pruébalo en línea!

— James
fuente

Puedes acortar un poco conUQG1YL-tP,wXds]+

— Luis Mendo

1

Cubix , 33 bytes

I:u8**.../\*3t3n*3t+u@O,6+3+t3*4p

Pruébalo en línea!

versión del cubo:

      I : u
      8 * *
      . . .
/ \ * 3 t 3 n * 3 t + u
@ O , 6 + 3 + t 3 * 4 p
. . . . . . . . . . . .
      . . .
      . . .
      . . .

Implementa el mismo algoritmo que mi R respuesta . Sospecho que esto se puede reducir.

— Giuseppe
fuente

1

SOGL V0.12 , 25 15 14 bytes

8*3-**4.*+3+6÷

Pruébalo aquí!

Traducción de la respuesta de Python de Mr.Xcoder que utiliza el enfoque de Giuseppe . SOGL no gana nada aquí: p

— dzaima
fuente

1

Java 8, 24 bytes

n->((8*n-3)*n*n+4*n+3)/6

Puerto de la respuesta R de @Giuseppe .
Tenga en cuenta que los /6pisos por defecto al calcular con enteros en Java.

Pruébalo aquí

— Kevin Cruijssen
fuente

1

Excel, 35 30 bytes

Guardado 5 bytes usando el enfoque de Giuseppe .

=INT((8*A1^3-3*A1^2+4*A1+3)/6)

Primer intento:

=(8*A1^3-3*A1^2+4*A1+3*MOD(A1,2))/6

Evolucionado de una implementación directa de fórmula de OEIS (37 bytes):

=(16*A1^3-6*A1^2+8*A1+3-3*(-1)^A1)/12

+3-3*(-1)^A1La lógica se puede cambiar a 6*MOD(A1,2).

=(16*A1^3-6*A1^2+8*A1+6*MOD(A1,2))/12

No guarda bytes, pero permite la eliminación de un factor común para 2 bytes.

— Wernisch
fuente

1

05AB1E , 13 12 bytes

Utiliza la misma técnica de conversión de base que la presentación Jelly de Leaky Nun

^{¿Quizás haya una forma más corta de crear la lista de coeficientes ?}

-1 byte gracias a Datboi (use espacios y ajuste para vencer la compresión (!))

8 3(4 3)¹β6÷

Pruébalo en línea!

¿Cómo?

8 3(4 3)¹β6÷               stack: []
8            - literal            ['8']
  3          - literal            ['8','3']
   (         - negate             ['8',-3]
    4        - literal            ['8',-3,'4']
      3      - literal            ['8',-3,'4','3']
       )     - wrap               [['8',-3,'4','3']]
        ¹    - 1st input (e.g. 4) [['8',-3,'4','3'], 4]
         β   - base conversion    [483]
          6  - literal six        [483,6]
           ÷ - integer division   [80]
             - print TOS           80

Mis 13 años ...

•VŠ•S3(1ǝ¹β6÷

•2ùë•₂в3-¹β6÷

•мå•12в3-¹β6÷

Todos usan compresiones para encontrar la lista de coeficientes.

— Jonathan Allan
fuente

8 3(4 3)¹β6÷a salvo 1 byte (aunque sin compresión elegante)

— Datboi

0

Pyth , 17 bytes

/+3+*^Q2-*8Q3*4Q6

Pruébalo aquí

— Sr. Xcoder
fuente

0

Pyke , 14 bytes

8*3-**Q4*+3+6f

Pruébalo aquí!

— Sr. Xcoder
fuente

0

05AB1E , 14 bytes

8*3-**4I*+3+6÷

Pruébalo en línea!

— Sr. Xcoder
fuente

0

MATL , 12 bytes

[DcKI]6/iZQk

¡Pruébalo en MATL Online!

Explicación

El mismo enfoque que la respuesta de Giuseppe .

[DcKI]   % Push array [8, -3, 4, 3]
6/       % Divide each entry by 6
i        % Push input
ZQ       % Evaluate polynomial
k        % Round down. Implicitly display

— Luis Mendo
fuente

0

Gaia , 14 bytes

8×3⁻××@4×+3+6/

Pruébalo en línea!

— Sr. Xcoder
fuente

Primero espiral, luego diagonal

Más reglas y aclaraciones

R , 43 34 bytes

Python 2 , 30 bytes

Python 2 , 36 34 bytes

Mathematica, 19 bytes

Mathematica, 19 bytes

Mathematica, 58 bytes

Jalea , 11 10 bytes

MATL , 21 bytes

Cubix , 33 bytes

SOGL V0.12 , 25 15 14 bytes

Java 8, 24 bytes

Excel, 35 30 bytes

05AB1E , 13 12 bytes

¿Cómo?

Pyth , 17 bytes

Pyke , 14 bytes

05AB1E , 14 bytes

MATL , 12 bytes

Explicación

Gaia , 14 bytes