让我们定义一个序列。我们将说$a(n)$是最小的$x$，它具有以下属性：

• $x$和$n$是互质的（它们不共享因子）

• $x$没有出现在序列的前面

• $|n - x| > 1$

与大多数序列不同，我们序列的域和范围是大于 1 的整数。

让我们计算前几个术语。

$a(2)$必须至少为4，但是4和2的因子为2，因此$a(2)$必须为5。

$a(3)$，必须是至少5但5采取的是$a(2)$，所以它是至少6，但6股因子与3所以它必须是至少7，7个满足所有三个条件从而$a(3)=7$。

$a(4)$

• 2分享一个因素
• 3太近了
• 4太近了
• 5太近了
• 6股因素
• 7由a（3）拍摄
• 8股因素
• 9好

$a(5)$

• 2好

任务

在这个挑战中，您将编写一个程序，该程序接受大于1的数字并返回$a(n)$。

这是一个代码问题，因此答案将以字节计分，而字节数越少越好。

测试用例

这是序列的前几个术语（它们当然是2索引的）：

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

奖励有趣的事实

由于对Math.se（证明由罗伯特·以色列链接）这个序列是其自身的逆，这意味着$a(a(n)) = n$对于所有的n。

信息系统

提出这个问题后，我将此序列提交给OEIS，并在几天后将其添加。

OEIS A290151

Haskell，61个字节

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

在线尝试！

我是Haskell的新手，因此可以了解任何高尔夫技巧。

多亏了Wheat Wizard为2个字节和nimi为4个字节

说明：

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

爱丽丝，42字节

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

在线尝试！

说明

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

这是用于程序的标准模板，这些程序采用数字作为输入，然后输出数字，并对其进行了修改，以将1放置在输入数字下方的堆栈中。

该程序的主要部分将每个数字放在磁带上的k插槽中a(k)。内循环计算a（k），外循环遍历k直到计算出a（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字节

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

我不得不推出自己的GCD。我也想不出如何使其不成为一个完整的功能。

GCD始终> = 1，因此只需忽略1

消除了高尔夫球中的短路，因为它更短

未打高尔夫球

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个字节

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

在线尝试！ 2..23（范围模式）

在线尝试！或150（不同的值）

Japt，33个字节（不竞争？）^†

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

在线尝试！

_{^†在解决此问题时，我修复了Japt解释器中的错误。 一年前的这篇meta帖子认为此答案没有竞争性，但是这篇较新的meta帖子正在为此寻求更多的自由。无论如何，我花了太多时间在此上将其废弃。}

05AB1E，26 个字节

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

在线尝试或输出第一个$n$列表中的术语。（注意：°速度显然非常慢，因此请T*在TIO链接中替换为（$10*n$ 代替 $10^n$）。

说明：

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)