Primeira espiral, depois diagonal

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 é portanto todas as regras usuais de golfe se aplicam e o código mais curto (em bytes) vence.
AdmBorkBork
fonte

Respostas:

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

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

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

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