8

Dado um número de entrada positivo n, construa uma espiral de números de 1para n^2, com 1no canto superior esquerdo, espiralando para dentro no sentido horário. Pegue a soma das diagonais (se nfor ímpar, o número do meio n^2é contado duas vezes) e produza esse número.

Exemplo para n = 1:

1

(1) + (1) = 2

Exemplo para n = 2:

1 2
4 3

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

Exemplo 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

Exemplo 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

Regras e esclarecimentos adicionais

Este é o OEIS A059924 e existem algumas soluções em formato fechado nessa página.
Pode-se presumir que a entrada e a saída se encaixam no tipo inteiro nativo do seu idioma.
A entrada e saída podem ser fornecidas em qualquer formato conveniente .
Você pode optar pelo índice 0 ou 1, como eu estou aqui nos meus exemplos, para sua apresentação. Por favor, indique o que você está fazendo.
Um programa completo ou uma função são aceitáveis. Se uma função, você pode retornar a saída em vez de imprimi-la.
Se possível, inclua um link para um ambiente de teste on-line para que outras pessoas possam experimentar seu código!
As brechas padrão são proibidas.
Isso é código-golfe, portanto todas as regras usuais de golfe se aplicam e o código mais curto (em bytes) vence.

— AdmBorkBork
fonte

21

R , 43 34 bytes

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

Experimente online!

A página OEIS lista a seguinte fórmula para a(n):

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

No entanto, pulei direto para chegar à seção PROG, onde o seguinte código PARI é encontrado:

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

Naturalmente, +3-3*(-1^n)é o mesmo +6para que possamos simplificar a fórmula vinculada, primeiro reduzindo-a para

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

e usando %/%, divisão inteira, em vez de /eliminar a necessidade floor.

— Giuseppe
fonte

1

+3-3*(-1)^nnão é realmente o mesmo que 6, embora a diferença seja perdida na divisão inteira.

— Fergusq

@fergusq você está certo, mas a fórmula dada como a expressão no PARI (na qual baseio minha solução) tem +3-3*(-1^n)a mesma +6. Vou atualizar minha resposta para tornar isso mais óbvio.

— Giuseppe

@Giuseppe É +6se né estranho, mas +0quando né mesmo

— Bergi

3

@ Bergi 3-3*(-1^n)é sempre, 6mas 3-3*(-1)^ntem esse comportamento alternado. A fórmula original tem o último, o que torna o uso de divisão inteira desnecessário, pois é sempre divisível por 12

— Giuseppe

1

Ah, certo. É estranho que o autor original tenha ignorado isso, não é?

— Bergi

5

Python 2 , 30 bytes

Economizou alguns bytes portando a abordagem de Giuseppe .

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

Experimente online!

Python 2 , 36 34 bytes

Economizei mais alguns bytes graças a @LeakyNun .

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

Experimente online!

— Mr. Xcoder
fonte

1

36 bytes

— Freira vazada

34 bytes

— Freira vazada

@LeakyNun Obrigado e obrigado.

— Xcoder

2

30 bytes créditos para Giuseppe para abordagem

— Leaky Nun

@LeakyNun eu estava atualizando com isso também

— Mr. Xcoder

3

Mathematica, 19 bytes

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

Você pode executá-lo com a seguinte sintaxe:

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

Onde 5pode ser substituído pela entrada.

Você pode experimentá-lo na caixa de areia Wolfram (copiar e colar + avaliar células)

— Mr. Xcoder
fonte

3

Mathematica, 19 bytes

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

Experimente online!

Economizou alguns bytes portando a abordagem de Giuseppe.

Mathematica, 58 bytes

Eu sempre gosto de perguntas com respostas dadas thanx to oeis (para a boa pergunta e resposta)

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

— J42161217
fonte

Não seria mais golfista usar o formulário fechado?

— Freira vazada

1

muitas respostas estão usando minha simplificação, de modo que você pode muito bem fazer o mesmo

— Giuseppe

2

Geléia , 11 10 bytes

1 byte graças a Jonathan Allan.

⁽ø\DN2¦ḅ:6

Experimente online!

— Freira Furada
fonte

8,-3,4,3-> ⁽ø\DN2¦para salvar um byte

— Jonathan Allan

1

MATL , 21 bytes

tt2^Qw6Y3YL-wXytP+*ss

Experimente online!

— James
fonte

Você pode diminuir um pouco comUQG1YL-tP,wXds]+

— Luis Mendo

1

Cubix , 33 bytes

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

Experimente online!

versão do cubo:

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

Implementa o mesmo algoritmo que minha resposta R . Suspeito que isso possa ser jogado para baixo.

— Giuseppe
fonte

1

SOGL V0.12 , 25 15 14 bytes

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

Experimente aqui!

Tradução da resposta Python do Sr.Xcoder, que está usando a abordagem de Giuseppe . SOGL não está ganhando nada aqui: p

— dzaima
fonte

1

Java 8, 24 bytes

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

Porto da resposta R de @Giuseppe .
Observe que /6, por padrão, o piso é calculado com números inteiros em Java.

Experimente aqui.

— Kevin Cruijssen
fonte

1

Excel, 35 30 bytes

Economizou 5 bytes usando a abordagem de Giuseppe .

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

Primeira tentativa:

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

Evoluiu de uma implementação direta da fórmula do OEIS (37 bytes):

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

+3-3*(-1)^A1lógica pode ser alterada para 6*MOD(A1,2).

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

Não salva bytes, mas permite a remoção de um fator comum por 2 bytes.

— Wernisch
fonte

1

05AB1E , 13 12 bytes

Usa a mesma técnica de conversão de base que a submissão de geléia de Leaky Nun

^{Talvez exista uma maneira mais curta de criar a lista de coeficientes ?}

-1 byte graças ao Datboi (use espaços e wrap para vencer a compactação (!))

8 3(4 3)¹β6÷

Experimente online!

Quão?

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

Meus 13 anos ...

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

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

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

Tudo usando compressões para encontrar a lista de coeficientes.

— Jonathan Allan
fonte

8 3(4 3)¹β6÷para 1 byte seguro (sem compressão sofisticada)

— Datboi 31/08

0

Pitão , 17 bytes

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

Experimente aqui.

— Mr. Xcoder
fonte

0

Pyke , 14 bytes

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

Experimente aqui!

— Mr. Xcoder
fonte

0

05AB1E , 14 bytes

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

Experimente online!

— Mr. Xcoder
fonte

0

MATL , 12 bytes

[DcKI]6/iZQk

Experimente no MATL Online!

Explicação

Mesma abordagem que a resposta 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
fonte

0

Gaia , 14 bytes

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

Experimente online!

— Mr. Xcoder
fonte

Primeira espiral, depois diagonal

Regras e esclarecimentos adicionais

R , 43 34 bytes

Python 2 , 30 bytes

Python 2 , 36 34 bytes

Mathematica, 19 bytes

Mathematica, 19 bytes

Mathematica, 58 bytes

Geléia , 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

Quão?

Pitão , 17 bytes

Pyke , 14 bytes

05AB1E , 14 bytes

MATL , 12 bytes

Explicação

Gaia , 14 bytes