Vamos definir uma sequência. Diremos que $a(n)$ é o menor número, , que possui as seguintes propriedades:$x$

• $x$ e são co-primos (eles não compartilham nenhum fator)$n$

• $x$ não aparece anteriormente na sequência

• $|n - x| > 1$

Ao contrário da maioria das seqüências, o domínio e o intervalo de nossa sequência são números inteiros maiores que 1.

Vamos calcular os primeiros dois termos.

$a(2)$ , deve ser pelo menos 4 , mas 4 e 2 compartilham um fator de 2, de modo que deve ser 5 .$a(2)$

$a(3)$ , deve ser pelo menos 5, mas 5 é obtido por , portanto, é pelo menos 6 , mas 6 compartilha um fator com 3, portanto deve ser pelo menos 7 , 7 atende a todos os três requisitos, portanto, .$a(2)$$a(3)=7$

$a(4)$

• 2 Compartilha um fator
• 3 Muito perto
• 4 Muito perto
• 5 Muito perto
• 6 Compartilha um fator
• 7 Tirada por um (3)
• 8 Compartilha um fator
• 9 é bom

$a(5)$

• 2 é bom

Tarefa

Neste desafio, você deve escrever um programa que pega um número maior que 1 e retorna .$a(n)$

Esta é uma questão de código-golfe, para que as respostas sejam pontuadas em bytes, com menos bytes sendo melhores.

Casos de teste

Aqui estão os primeiros dois termos da sequência (é claro que são 2 indexados):

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

Bonus fato Fun

Como provado por Robert Israel no Math.se ( link ), essa sequência é inversa, o que significa que para todos os n.$a(a(n)) = n$

OEIS

Depois de fazer esta pergunta, enviei esta sequência para o OEIS e após alguns dias ela foi adicionada.

OEIS A290151

Haskell , 61 bytes

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

Experimente online!

Eu sou bastante novo em Haskell, então qualquer dica de golfe é apreciada.

Graças ao Assistente de Trigo por 2 bytes e nimi por 4 bytes

Explicação:

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 bytes

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

Experimente online!

Explicação

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

Este é um modelo padrão para programas que recebem um número como entrada e emitem um número, modificado para colocar 1 na pilha abaixo do número de entrada.

A parte principal do programa coloca cada número kno slot a(k)da fita. O loop interno calcula a (k) e o loop externo itera sobre k até que a (n) seja computado.

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 bytes

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

Eu tive que lançar seu próprio GCD. Também não consegui descobrir como fazê-lo não ser uma função inteira.

O GCD é sempre> = 1, portanto, basta ignorar 1

Tirou um curto-circuito no golfe porque é mais curto

Sem golfe

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 bytes

(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]])&

Experimente online! 2..23 (modo de alcance)

Experimente online! ou 150 (valores distintos)

Japt , 33 bytes (não concorrente?) ^†

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

Experimente online!

_{^† Eu fixo um bug no Japt intérprete , enquanto trabalhava em esta solução. Esta meta post de um ano atrás considera esta resposta não competitiva, mas esta nova meta post está pressionando por mais liberdade nisso. Independentemente disso, gastei muito tempo nisso para descartá-lo.}

05AB1E , 26 bytes

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

Experimente on-line ou produza a primeira$n$termos como lista . (OBSERVAÇÃO: °obviamente é extremamente lento, substitua- T*o pelos links TIO ($10*n$ ao invés de $10^n$).)

Explicação:

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)