Introdução (pode ser ignorado)

Colocar todos os números inteiros positivos em sua ordem regular (1, 2, 3, ...) é um pouco chato, não é? Então, aqui está uma série de desafios em torno de permutações (reorganizações) de todos os números inteiros positivos. Este é o sexto desafio desta série (links para o primeiro , segundo , terceiro , quarto e quinto desafio).

Esse desafio tem um tema leve de Páscoa (porque é Páscoa). Eu me inspirei neste ovo de ganso altamente decorado (e na minha opinião pessoal bastante feio).

Ovo de ganso decorado

Isso me lembrou a espiral de Ulam , onde todos os números inteiros positivos são colocados em uma espiral no sentido anti-horário. Essa espiral tem alguns recursos interessantes relacionados aos números primos, mas isso não é relevante para este desafio.

Chegamos à permutação deste desafio de números inteiros positivos se pegarmos os números na espiral de Ulam e rastrearmos todos os números inteiros em uma espiral de rotação no sentido horário , começando em 1. Dessa forma, obtemos:

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

Se você desenhar as duas espirais, obterá uma espécie de malha infinita de espirais (casca de ovo) ( observe a referência da Nova Ordem ali ).

Esta sequência está presente no OEIS sob o número A090861 . Como esse é um desafio de "sequência pura", a tarefa é gerar $a(n)$ para um dado $n$ como entrada, onde $a(n)$ é A090861 .

Tarefa

Dada uma entrada inteira $n$ , imprima $a(n)$ no formato inteiro, onde $a(n)$ é A090861 .

Nota: a indexação baseada em 1 é assumida aqui; você pode usar a indexação baseada em 0; portanto, $a(0) = 1; a(1) = 6$ , etc. Por favor mencione isso na sua resposta se você optar por usá-lo.

Casos de teste

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

Regras

Entrada e saída são números inteiros.
Seu programa deve, no mínimo, suportar entrada no intervalo de 1 a 32767).
Entrada inválida (0, valores flutuantes, seqüências de caracteres, valores negativos etc.) pode levar a resultados imprevisíveis, erros ou comportamento (não) definido.
Aplicam- se as regras de E / S padrão .
As brechas padrão são proibidas.
Isso é código-golfe , então as respostas mais curtas em bytes ganham

code-golf sequence

— de qualquer maneira
fonte

12

Gelatina , 16 14 11 10 9 8 bytes

-1 graças ao Lynn (mod-2; NÃO lógico; add to self: Ḃ¬+-> OR bit a bit com 1: |1)

|1×r)ẎQi

Um link monádico que aceita um número inteiro n, que gera um número inteiro a(n),.

$\lceil\frac n2\rceil$

½‘|1×rƲ€ẎQi $\lceil\frac{\lfloor\sqrt n\rfloor+1}2\rceil$

Quão?

A permutação é pegar os números naturais em fatias invertidas [1,5,3,11,5,17,7,23,9,29,11,35,13,...]- os inteiros positivos ímpares intercalados com os inteiros positivos congruentes a cinco módulos seis, ie [1, 2*3-1, 3, 4*3-1, 5, 6*3-1, 7, 8*3-1, 9, ...].

Isso é o mesmo que concatenar e desduplicar intervalos reversos [1..x]de onde xestão as somas cumulativas desses comprimentos de fatia (ou seja, o máximo de cada fatia) - [1,6,9,20,25,42,49,72,81,110,121,156,169,...]que são os números inteiros ímpares ao quadrado intercalados com números pares multiplicados por eles mesmos incrementados, ou seja [1*1, 2*3, 3*3, 4*5, 5*5, 6*7, 7*7,...].

Como as diferenças são maiores que 1, podemos salvar um byte (a reversão) construindo intervalos [x..k]diretamente, onde ké o índice indexado a 1 da fatia.

$P(n) = v \iff P(v) = n$ n|1×r)ẎQị@n|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

— Jonathan Allan
fonte

2

Muito agradável. E você superou a resposta MATL!

— agtoever

1

Amarrado agora ... :-)

— Luis Mendo

@LuisMendo Eu só percebi que eu posso fazer alguma coisa sorrateira aqui e salvar um byte :)

— Jonathan Allan

1

@JonathanAllan Aww. Isso merece um upvote :-)

— Luis Mendo

1

@ Lynn Na verdade, estou apenas atualizando para um 9 byter diferente. O seu provavelmente fará 8!

— Jonathan Allan

6

JavaScript (ES7), 46 45 41 bytes

Indexado a 0.

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

Experimente online!

Quão?

Isso é baseado na fórmula indexada em 1 usada nos programas de exemplo de A090861 .

$x_n$ $0$

x_{n} = ⌊ \frac{\sqrt{n - 1} + 1}{2} ⌋

$x_n=\left\lfloor\frac{\sqrt{n-1}+1}{2}\right\rfloor$

Experimente online!

$k_n$ $6$ $-2$

k_{n} = {\begin{cases} - 2 & E se n \leq 4 {x_{n}}^{2} + 2 x_{n} \\ 6 & de outra forma \end{cases}

$k_n=\begin{cases} -2&\text{if }n\le 4{x_n}^2+2x_n\\ 6&\text{otherwise} \end{cases}$

Experimente online!

$a_n$

{uma}_{n} = 8 {x_{n}}^{2} + k_{n} x_{n} + 2 - n

$a_n=8{x_n}^2+k_nx_n+2-n$

Experimente online!

Que pode ser traduzido em:

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

Ao indexá-lo, você economiza 5 bytes imediatamente:

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

A fórmula pode ser ainda mais simplificada usando:

{x^{'}}_{n} = 2 \times ⌊ \frac{\sqrt{n} + 1}{2} ⌋

${x'}_n=2\times\left\lfloor\frac{\sqrt{n}+1}{2}\right\rfloor$

que pode ser expresso como:

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

levando a:

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

e finalmente:

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

— Arnauld
fonte

5

Wolfram Language (Mathematica) , 60 bytes

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

Experimente online!

— J42161217
fonte

5

MATL , 12 11 bytes

Eq1YL!tPG=)

Experimente online!

Muito ineficiente em memória. Anexar X^ktorna mais eficiente .

— Luis Mendo
fonte

3

C # (compilador interativo do 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;

Experimente online!

— Modalidade de ignorância
fonte

3

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: Obrigado a Johnathan Allan por obtê-lo de 74 a 57 bytes!

Esta solução usa indexação baseada em 0.

— Kapocsi
fonte

1

Guardar 39 evitando as importações, removendo alguns parênteses redundantes, e usar >no lugar do <=e x*xno lugar de x**2... como assim: def f(n):x=((n-1)**.5+1)//2;return 8*x**2+(-2,6)[n>4*x*x+2*x]*x+2-n... TIO

— Jonathan Allan

Impressionante! Vou incorporar as edições. Fiz algumas alterações antes de ver o seu comentário e o reduzi para 74 bytes. Importa que o seu retorno flutue? Eu não supor ...

— Kapocsi

Representações flutuantes de números inteiros devem ser boas. Salvar um pouco mais usando o Python 3.8 atribuição ... EDIT: torná-lo ponto zero indexados

— Jonathan Allan

Muito legal. Sinta-se à vontade para fazer outras edições diretamente!

— precisa saber é o seguinte

3

Python 3.8 (pré-lançamento) , 53 bytes

Uma porta direta da resposta JavaScript de Arnauld , faça voto positivo e / ou a resposta Mathematica de J42161217 e / ou a resposta Python de Kapocsi :)

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

Indexado a 0.

Experimente online!

— Jonathan Allan
fonte

2

Befunge, 67 57 bytes

Esta solução assume a indexação baseada em 0 para os valores de entrada.

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

Experimente online!

Explicação

Começamos calculando o "raio" no qual a entrada n é encontrada com um loop:

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

No final do loop, o valor anterior de n é o deslocamento na espiral naquele raio:

offset = n + radius*8

Podemos então determinar se estamos na seção superior ou inferior da espiral da seguinte maneira:

bottom = offset >= radius*6

E quando tivermos todos esses detalhes, o valor espiral será calculado com:

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

O raio é o único valor que precisamos armazenar como uma "variável", limitando-o a um valor máximo de 127 no Befunge-93, para que esse algoritmo possa manipular entradas de até 65024.

— James Holderness
fonte

1

Japonês , 15 bytes

Solução de porto de geléia de Jonathan. 1 indexado.

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

Tente

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

— Shaggy
fonte

Eu acabei de dizer ao Jonathan que x+(1-x%2)está x|1(economizando um byte no Jelly), do qual essa resposta também pode se beneficiar, aposto.

— 21419 Lynn

0

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;}

Indexado 1; usa a fórmula na página OEIS, mas manipulada para salvar alguns bytes.

Experimente online!

— Neil A.
fonte

Sugerir em sqrt(n-1)/2+.5vez de(sqrt(n-1)+1)/2

— tetocat 22/04/19

Nova encomenda # 6: Ovo de Páscoa

Introdução (pode ser ignorado)

Tarefa

Casos de teste

Regras

Gelatina , 16 14 11 10 9 8 bytes

Quão?

JavaScript (ES7), 46 45 41 bytes

Quão?

Wolfram Language (Mathematica) , 60 bytes

MATL , 12 11 bytes

C # (compilador interativo do Visual C #) , 67 bytes

Python 3.8, 104 74 65 60 57 bytes

Python 3.8 (pré-lançamento) , 53 bytes

Befunge, 67 57 bytes

Japonês , 15 bytes

C ++ (gcc) , 88 bytes