Definiamo una sequenza. Diremo che $a(n)$ è il numero più piccolo, $x$ , che ha le seguenti proprietà:

• $x$ e$n$ sono co-primi (non condividono alcun fattore)

• $x$ non appare prima nella sequenza

• $|n - x| > 1$

A differenza della maggior parte delle sequenze, il dominio e l'intervallo della nostra sequenza sono numeri interi maggiori di 1.

Calcoliamo la prima coppia di termini.

$a(2)$ , deve essere almeno4, ma4e2condividono un fattore2,quindi$a(2)$ deve essere5.

$a(3)$ , deve essere almeno5ma5è preso da$a(2)$ , quindi è almeno6, ma6condivide un fattore con3,quindi deve essere almeno7,7soddisfa tutti e tre i requisiti quindi$a(3)=7$ .

$a(4)$

• 2 Condivide un fattore
• 3 Troppo vicino
• 4 Troppo vicino
• 5 Troppo vicino
• 6 Condivide un fattore
• 7 Tratto da un (3)
• 8 Condivide un fattore
• 9 è buono

$a(5)$

• 2 è buono

Compito

In questa sfida devi scrivere un programma che accetta un numero maggiore di 1 e restituisce $a(n)$ .

Questa è una domanda di code-golf, quindi le risposte verranno classificate in byte, con un numero minore di byte migliori.

Casi test

Ecco i primi due termini della sequenza (sono ovviamente 2 indicizzati):

5,7,9,2,11,3,13,4,17,6,19,8,23,22,21,10,25,12,27,16,15,14

Bonus Fatto divertente

Come dimostrato da Robert Israel su Math.se ( link ) questa sequenza è la sua inversa, ciò significa che $a(a(n)) = n$ per tutto n.

OEIS

Dopo aver posto questa domanda, ho inviato questa sequenza all'OEIS e dopo alcuni giorni è stata aggiunta.

OEIS A290151

Haskell , 61 byte

f n=[i|i<-[2..],gcd i n<2,all((/=i).f)[2..n-1],abs(n-i)>1]!!0

Provalo online!

Sono abbastanza nuovo su Haskell, quindi ogni consiglio sul golf è apprezzato.

Grazie a Wheat Wizard per 2 byte e nimi per 4 byte

Spiegazione:

f n=[i|i<-[2..],gcd i n<2,all((/=i).f)[2..n-1],abs(n-i)>1]!!0
f n=                                                          -- define a function f :: Int -> Int
    [i|i<-[2..],                                              -- out of positive integers greater than two
                gcd i n<2,                                    -- gcd of i and n is 1
                          all((/=i).f)[2..n-1],               -- i isn't already in the sequence
                                               abs(n-i)>1]    -- and |n-i| > 1
                                                          !!0 -- take the first element

Alice , 42 byte

/oi
\1@/2-&whq&[]w].q-H.t*n$K.qG?*h$KW.!kq

Provalo online!

Spiegazione

/oi
\1@/.........

Questo è un modello standard per i programmi che accettano un numero come input e producono un numero, modificato per posizionare un 1 nello stack sotto il numero di input.

La parte principale del programma posiziona ciascun numero knello slot a(k)sul nastro. Il ciclo interno calcola a (k) e il ciclo esterno scorre it k fino a quando non viene calcolato un (n).

1       push 1
i       take input
2-&w    repeat n-1 times (push return address n-2 times)
h       increment current value of k
q&[     return tape to position 0
]       move right to position 1
w       push return address to start inner loop
]       move to next tape position
.q-     subtract tape position from k
H       absolute value
.t*     multiply by this amount minus 1
n$K     if zero (i.e., |k-x| = 0 or 1), return to start of inner loop
.qG     GCD(k, x)
?       current value of tape at position: -1 if x is available, or something positive otherwise
*       multiply
h$K     if not -1, return to start of inner loop
W       pop return address without jumping (end inner loop)
.!      store k at position a(k)
k       end outer loop
q       get tape position, which is a(n)
o       output
@       terminate

VB.NET (.NET 4.5), 222 byte

Function A(n)
Dim s=New List(Of Long)
For i=2To n
Dim c=2
While Math.Abs(i-c)<2Or g(c,i)>1Or s.Contains(c)
c+=1
End While
s.Add(c)
Next
Return s.Last
End Function
Function g(a, b)
Return If(b=0,a,g(b,a Mod b))
End Function

Ho dovuto lanciare il tuo GCD. Inoltre non sono riuscito a capire come ottenerlo per non essere un'intera funzione.

GCD è sempre> = 1, quindi devi solo ignorare 1

Ha eliminato i cortocircuiti nel golf perché è più corto

Un-golfed

Function Answer(n As Integer) As Integer
    Dim seqeunce As New List(Of Integer)
    For i As Integer = 2 To n
        Dim counter As Integer = 2
        ' took out short-circuiting in the golf because it's shorter
        ' GCD is always >= 1, so only need to ignore 1
        While Math.Abs(i - counter) < 2 OrElse GCD(counter, i) > 1 OrElse seqeunce.Contains(counter)
            counter += 1
        End While
        seqeunce.Add(counter)
    Next
    Return seqeunce.Last
End Function

' roll your own GCD
Function GCD(a, b)
    Return If(b = 0, a, GCD(b, a Mod b))
End Function

Mathematica, 111 byte

(s={};Table[m=2;While[m<3#,If[CoprimeQ[i,m]&&FreeQ[s,m]&&Abs[i-m]>1,s~AppendTo~m;m=3#];m++],{i,2,#}];s[[#-1]])&

Provalo online! 2..23 (modalità intervallo)

Provalo online! o 150 (valori distinti)

Japt , 33 byte (non in competizione?) ^†

ò2 rÈc_aY >1«XøZ «Yk øZk}a+2}[] o

Provalo online!

_{^† Ho risolto un bug nell'interprete Japt mentre lavoravo su questa soluzione. Questo meta post di un anno fa considera questa risposta non competitiva, ma questo nuovo post post sta spingendo per una maggiore libertà in questo. Indipendentemente da ciò, ho speso troppo tempo su questo per scartarlo.}

05AB1E , 26 byte

2IŸεDU°2Ÿ¯KʒX¿}ʒXα1›}θDˆ}θ

$n$°T*$10*n$$10^n$

Spiegazione:

2IŸ               # Create a list in the range [2, input]
   ε              # Map each value `y` to:
    DU            #  Store a copy of `y` in variable `X`
    °2Ÿ           #  Create a list in the range [10**`y`,2]
       ¯K         #  Remove all values already in the global_array
       ʒX¿}       #  Only keep values with a greatest common divider of 1 with `X`
       ʒXα1›}     #  Only keep values with an absolute difference larger than 1 with `X`
             θ    #  After these filters: keep the last (the smallest) element
              Dˆ  #  And add a copy of it to the global_array
   }θ             # After the map: only leave the last value
                  # (and output the result implicitly)