Introduzione (potrebbe essere ignorata)

Mettere tutti gli interi positivi nel suo ordine regolare (1, 2, 3, ...) è un po 'noioso, no? Quindi ecco una serie di sfide intorno alle permutazioni (rimpasto) di tutti gli interi positivi. Questa è la sesta sfida in questa serie (collegamenti al primo , secondo , terzo , quarto e quinto sfida).

Questa sfida ha un tema pasquale delicato (perché è Pasqua). Mi sono ispirato a questo uovo d'oca altamente decorato (e secondo la mia opinione piuttosto brutto).

Uovo d'oca decorato

Mi ha ricordato la spirale di Ulam , dove tutti gli interi positivi sono posti in una spirale in senso antiorario. Questa spirale ha alcune caratteristiche interessanti legate ai numeri primi, ma non è rilevante per questa sfida.

Arriviamo a questa permutazione di numeri interi positivi se prendiamo i numeri nella spirale di Ulam e tracciamo tutti i numeri interi in una spirale che gira in senso orario , iniziando da 1. In questo modo, otteniamo:

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 disegnassi entrambe le spirali, otterresti una sorta di maglia infinita di spirali (guscio d'uovo) ( nota qui il riferimento al Nuovo Ordine ).

Questa sequenza è presente nell'OEIS con il numero A090861 . Poiché si tratta di una sfida "sequenza pura", il compito è quello di produrre $a(n)$ per un dato $n$ come input, dove $a(n)$ è A090861 .

Compito

Dato un input intero $n$ , output $a(n)$ in formato intero, dove $a(n)$ è A090861 .

Nota: qui si assume l'indicizzazione basata su 1; puoi utilizzare l'indicizzazione basata su 0, quindi $a(0) = 1; a(1) = 6$ , ecc. Indicare questo nella risposta se si sceglie di utilizzarlo.

Casi test

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

Regole

Input e output sono numeri interi.
Il tuo programma dovrebbe almeno supportare input nell'intervallo da 1 a 32767).
Input non validi (0, float, stringhe, valori negativi, ecc.) Possono causare output non previsti, errori o comportamenti (non) definiti.
Si applicano le regole I / O predefinite .
Sono vietate le scappatoie predefinite .
Questo è code-golf , quindi vince la risposta più breve in byte

code-golf sequence

— agtoever
fonte

12

Gelatina , 16 14 11 10 9 8 byte

-1 grazie a Lynn (mod-2; NOT logico, metti in auto: Ḃ¬+-> OR bit a bit con 1: |1)

|1×r)ẎQi

Un collegamento monadica accettare un numero intero, nche produce un numero intero, a(n).

$\lceil\frac n2\rceil$

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

Come?

La permutazione è quella di prendere i numeri naturali in segmenti di lunghezza invertiti [1,5,3,11,5,17,7,23,9,29,11,35,13,...]- gli interi positivi dispari intervallati dagli interi positivi congruenti a cinque moduli sei, vale a dire [1, 2*3-1, 3, 4*3-1, 5, 6*3-1, 7, 8*3-1, 9, ...].

Ciò equivale a concatenare e quindi a deduplicare intervalli inversi [1..x]di dove xsono le somme cumulative di queste lunghezze di sezione (ovvero il massimo di ogni sezione) - [1,6,9,20,25,42,49,72,81,110,121,156,169,...], ovvero gli interi dispari al quadrato intervallati da numeri pari moltiplicati per essi stessi incrementati, ovvero[1*1, 2*3, 3*3, 4*5, 5*5, 6*7, 7*7,...] .

Poiché le differenze sono tutte maggiori di 1, possiamo salvare un byte (l'inversione) costruendo [x..k]direttamente gli intervalli , dove si ktrova l'indice 1-indexato della sezione.

$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

Molto bella. E hai superato la risposta MATL!

— agtoever,

1

Legato ora ... :-)

— Luis Mendo,

@LuisMendo Mi sono appena reso conto che posso fare qualcosa di subdolo qui e salvare un byte :)

— Jonathan Allan

1

@JonathanAllan Aww. Questo merita un voto :-)

— Luis Mendo il

1

@Lynn In realtà sto solo aggiornando un altro 9 byte. Probabilmente ne farai 8!

— Jonathan Allan,

6

JavaScript (ES7), 46 45 41 byte

0-indicizzati.

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

Provalo online!

Come?

Questo si basa sulla formula 1 indicizzata utilizzata nei programmi di esempio di A090861 .

$x_n$ $0$

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

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

Provalo online!

$k_n$ $6$ $-2$

k_{n} = {\begin{cases} - 2 & if n \leq 4 {x_{n}}^{2} + 2 x_{n} \\ 6 & otherwise \end{cases}

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

Provalo online!

$a_n$

a_{n} = 8 {x_{n}}^{2} + k_{n} x_{n} + 2 - n

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

Provalo online!

Che può essere tradotto in:

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

Rendendolo 0-indicizzato salva subito 5 byte:

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

La formula può essere ulteriormente semplificata utilizzando:

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

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

che può essere espresso come:

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

portando a:

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

e infine:

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

— Arnauld
fonte

5

Wolfram Language (Mathematica) , 60 byte

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

Provalo online!

— J42161217
fonte

5

MATL , 12 11 byte

Eq1YL!tPG=)

Provalo online!

Molto inefficiente dalla memoria. La preparazione X^krende più efficiente .

— Luis Mendo
fonte

3

C # (compilatore interattivo Visual C #) , 67 byte

n=>8*(x=(int)Math.Sqrt(--n)+1>>1)*x+(n<4*x*x+2*x?-2:6)*x+1-n;int x;

Provalo online!

— Incarnazione dell'ignoranza
fonte

3

Python 3.8, 104 74 65 60 57 byte

lambda n:(-2,6)[n>4*(x:=(n**.5+1)//2)*x+2*x]*x+2+~n+8*x*x

Modifica: grazie a Johnathan Allan per averlo ottenuto da 74 a 57 byte!

Questa soluzione utilizza l'indicizzazione basata su 0.

— Kapocsi
fonte

1

Salva 39 evitando le importazioni, rimuovendo alcune parentesi ridondanti e utilizzando >al posto <=e x*xal posto di x**2... in questo modo: 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

Eccezionale! Incorporerò le modifiche. Ho apportato alcune modifiche prima di vedere il tuo commento e farlo scendere a 74 byte. Importa che i tuoi resi galleggino? Suppongo di no ...

— Kapocsi,

Le rappresentazioni float degli interi dovrebbero andare bene. Risparmia ancora usando il compito di Python 3.8 ... MODIFICA: rendilo indicizzato zero

— Jonathan Allan

Molto bello. Sentiti libero di apportare ulteriori modifiche direttamente!

— Kapocsi,

3

Python 3.8 (pre-release) , 53 byte

Una porta diretta della risposta JavaScript di Arnauld , va votata a tale e / o la risposta Mathematica di J42161217 e / o la risposta Python di Kapocsi :)

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

0-indicizzati.

Provalo online!

— Jonathan Allan
fonte

2

Befunge, 67 57 byte

Questa soluzione presuppone l'indicizzazione basata su 0 per i valori di input.

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

Provalo online!

Spiegazione

Iniziamo calcolando il "raggio" in corrispondenza del quale si trova l'ingresso n con un loop:

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

Alla fine del ciclo, il valore precedente di n è l'offset nella spirale in quel raggio:

offset = n + radius*8

Possiamo quindi determinare se siamo nella sezione superiore o inferiore della spirale come segue:

bottom = offset >= radius*6

E una volta che abbiamo tutti questi dettagli, il valore della spirale viene calcolato con:

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

Il raggio è l'unico valore che dobbiamo memorizzare come "variabile", limitandolo a un valore massimo di 127 in Befunge-93, quindi questo algoritmo può gestire input fino a 65024.

— James Holderness
fonte

1

Japt , 15 byte

La soluzione Jelly di Port of Jonathan. 1-indicizzati.

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

Provalo

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

— ispido
fonte

Ho appena detto Jonathan che x+(1-x%2)è x|1(salvando un byte in gelatina), che questa risposta può anche beneficiare, scommetto.

— Lynn,

0

C ++ (gcc) , 88 byte

#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-indicizzati; utilizza la formula nella pagina OEIS, ma manipolata per salvare alcuni byte.

Provalo online!

— Neil A.
fonte

Suggerisci sqrt(n-1)/2+.5invece di(sqrt(n-1)+1)/2

— ceilingcat il

Nuovo ordine n. 6: Easter Egg

Introduzione (potrebbe essere ignorata)

Compito

Casi test

Regole

Gelatina , 16 14 11 10 9 8 byte

Come?

JavaScript (ES7), 46 45 41 byte

Come?

Wolfram Language (Mathematica) , 60 byte

MATL , 12 11 byte

C # (compilatore interattivo Visual C #) , 67 byte

Python 3.8, 104 74 65 60 57 byte

Python 3.8 (pre-release) , 53 byte

Befunge, 67 57 byte

Japt , 15 byte

C ++ (gcc) , 88 byte