OEIS 在Golomb序列上有一个变体（A111439）。与Golomb的序列中一样，描述序列中出现的频率。但是此外，没有两个连续的数字可能是相同的。在建立序列时，始终选择不违反这两个属性的最小正整数。由于不允许连续的相同数字，该序列随着其增长而略微上下波动。以下是前100个字词：A(n)nA(n)

1, 2, 3, 2, 3, 4, 3, 4, 5, 6, 5, 6, 5, 6, 7, 6, 7, 8, 7, 8, 9, 8, 9, 8, 9, 
10, 9, 10, 9, 10, 11, 10, 11, 10, 11, 10, 11, 12, 11, 12, 13, 12, 13, 12, 
13, 12, 13, 12, 13, 14, 15, 14, 15, 14, 15, 14, 15, 14, 15, 14, 15, 16, 15, 
16, 17, 16, 17, 16, 17, 16, 17, 16, 17, 18, 17, 18, 17, 18, 19, 18, 19, 18, 
19, 18, 19, 18, 19, 18, 19, 20, 19, 20, 21, 20, 21, 20, 21, 20, 21, 20

可以在OEIS上找到前10,000个号码的完整列表。

挑战在于编写A(n)给定的计算程序或函数n。n是1基础的，以确保自我描述性质的作品。

规则

您可以编写程序或函数，并使用我们的任何标准方法来接收输入和提供输出。

您可以使用任何编程语言，但是请注意，默认情况下，这些漏洞是禁止的。

这是代码高尔夫球，因此以字节为单位的最短有效答案为准。

测试用例

n     A(n)
1     1
4     2
10    6
26    10
100   20
1000  86
1257  100
10000 358

Haskell，67个字节

f k|k<4=k|p<-k-1=[n|n<-[1..],n/=f p,sum[1|a<-[1..p],f a==n]<f n]!!0

定义一个函数f。在线尝试！它非常慢，f 15TIO上的计算超时。

说明

只需定义一下即可：在每个阶段，选择n满足约束条件的最小正数（不等于上一个条目，并且尚未出现f n）。

f k             -- Define f k:
 |k<4=k         -- If k < 4, it's k.
 |p<-k-1=       -- Otherwise, bind k-1 to p,
  [n|           -- compute the list of numbers n where
   n<-[1..],    -- n is drawn from [1,2,3,...],
   n/=f p,      -- n is not equal to f p, and
   sum[1|       -- the number of
    a<-[1..p],  -- those elements of [1,2,3,...,p]
    f a==n]     -- whose f-image equals n
   <f n]        -- is less than f n,
  !!0           -- and take the first element of that list.

Mathematica，69 68字节

感谢Martin Ender为我找到了额外的–1个字节！

Last@Nest[{##&@@#,1//.x_/;x==Last@#||#~Count~x==#[[x]]->x+1}&,{},#]&

未命名函数采用正整数 n作为输入并返回正整数的。我们构造n此序列的第一个元素的整个列表，然后采用该Last元素。该列表是通过从空列表开始{}并以一个函数n时间（通过Nest）连续对其进行操作来构造的。

所讨论的函数是{##&@@#,1//.x_/;x==Last@#||#~Count~x==#[[x]]->x+1}&，它需要部分序列值列表（本质上是##&@@#），并向其附加下一个值。下一个值通过以开头x=1，然后在满足条件的情况下重复替换x以替换，换句话说，如果一个是前一个元素，或者已经在列表中正确次数了。这个函数会吐出一些错误，因为（例如）我们不应该调用初始列表的th元素；但是，这些值都是正确的。x+1x==Last@#||#~Count~x==#[[x]]xxx{}

Python 2 2，99 86字节

感谢@Dennis总共进行了13个字节的改进！

s=0,1,2,3
exec't=1\nwhile t==s[-1]or s.count(t)/s[t]:t+=1\ns+=t,;'*input()
print s[-4]

该程序非常幼稚地进行：它跟踪到目前为止确定的值列表，并希望追加下一个值。它尝试附加一个1如果可以，到列表的末尾；如果没有，则尝试2依此类推，直到允许某些操作为止。

现在，我们从播种结果为1,2,3开始1,2,3。这样做是为了避免与已计算出的值过短的列表中的任何问题：我猜想，如果n是至少4再a(n)严格小于n。（在此程序中，s[n]等于a(n)。我们的列表实际上被初始化为，[0,1,2,3]因为列表0在Python 中被索引了。因此，例如a(1)=s[1]=1和a(2)=s[2]=2。）

因此，假设我们正在尝试确定s[m]，这意味着我们的列表已包含s[0], s[1], ..., s[m-1]。我们将开始t=1尝试设置s[m]=1。如果这不起作用，我们转到t=2尝试设置s[m]=2。每次增加时t，我们都会检查是否s.count(t)==s[t]...但是只要我们不必一直高到，右侧就不会产生错误t=m。这个猜想说我们永远不必这样做，因为我们计算的第一个值实际上是s[4]。

此实现计算的序列值比需要的多3个。例如，如果n是8，它将s[11]在返回值之前先进行计算s[8]。

我很高兴看到这一猜想的证明。我相信可以（强烈吗？）归纳证明。

编辑：这是一个猜想的证明。实际上，我们证明了该声明的形式稍强一些，因为它不需要任何额外的工作。

定理：对于所有n大于或等于4的项，该项a(n)小于或等于(n-2)。

证明（通过强归纳法）：（基数n=4）：该语句对于成立n=4，因为a(4) = 2 = 4-2。

现在假定a(k)是小于或等于k-2对于所有k从4通过n，包括（和假设n至少是4）。特别地，这意味着该序列的所有先前项最多为(n-2)。我们需要证明a(n+1)最多(n-1)。现在，根据定义，a(n)它是不违反任何条件的最小正整数，因此我们只需要证明该值(n-1)将不违反任何条件即可。

该值(n-1)不会违反“无连续重复”条件，因为根据归纳假设，先前的输入最多为(n-2)。除非已经达到次数，否则它不会违反“ 出现a(m)次数m”条件。但受强归纳假设，先前已经达到次，不等于，因为是积极的所有(n-1)a(n-1)(n-1)0a(n-1)0a(m)m。

因此，根据需要a(n+1)小于或等于n-1 = (n+1)-2。QED。

果冻，17个字节

Ṭ€S<;1Tḟ®Ḣ©ṭ
⁸Ç¡Ṫ

对于TIO，最后三个测试用例太多了。我已经在本地验证了1000和1257。

在线尝试！或验证前100个字词。

怎么运行的

⁸Ç¡Ṫ          Main link. No arguments.

⁸             Yield [].
 Ç¡           Execute the helper link n times (where n is an integer read from
              STDIN), initially with argument [], then with the previous return
              value as argument. Yield the last return value.
              Tail; yield the last element of the result.


Ṭ€S<;1Tḟ®Ḣ©ṭ  Helper link. Argument: A (array)

Ṭ€            Untruth each convert each k into an array of k-1 zeroes and one 1.
  S           Sum; column-wise reduce by +, counting the occurrences of all
              between 1 and max(A).
   <          Compare the count of k with A[k] (1-indexed), yielding 1 for all
              integers that still have to appear once or more times.
    ;1        Append a 1 (needed in case the previous result is all zeroes).
      T       Truth; find all indices of ones.
       ḟ®     Filter-false register; remove the value of the register (initially 0)
              from the previous result.
         Ḣ©   Head copy; yield the first (smallest) value of the result and save
              it in the register.
           ṭ  Tack; append the result to A.

Python 2中，77 74个字节

f=lambda n,k=1:n*(n<4)or map(f,range(n)+k*[n-1]).count(k)<f(k)or-~f(n,k+1)

这是@mathmandan算法的递归实现。

实现为O（insane）：本地输入9花费2秒，输入10 52秒，输入11 17分28秒。但是，如果声明为常规函数而不是lambda，则可以使用备注来验证测试用例。

在线尝试！

请注意，即使有了备忘录，TIO也无法计算f（1257）或f（10000）（均在本地验证）。

05AB1E，32 31字节

XˆXˆG[N¯2(è<›¯¤NÊsN¢¯Nè‹&&#]N.ˆ

在线尝试！

说明

XˆXˆ                             # initialize global list as [1,1]
    G                            # input-1 times do:
     [                    #]     # loop until expression is true     
      N¯2(è<›                    # n > list[-2]-1
             ¯¤NÊ                # list[-1] != N
                 sN¢¯Nè‹         # count(list, N) < list[N]
                        &&       # logical AND of the 3 expressions
                            N.ˆ  # add N to global list 
                                   and output last value in list and end of program

从技术上讲，G将N添加到全局列表时处于循环中，但是05AB1E中的所有循环都使用相同的变量N作为索引，因此内部循环[...]覆盖了N的G含义，可以将其添加到循环之外。

嵌套循环和条件语句的问题使我们无法在循环内部执行此操作。

Befunge，141个 136字节

<v9\0:p8\2:*2:-1<9
v>p1+:3\8p0\9p:#^_&
>1-:#v_1.@>$8g.@
*+2%\>1-:!|>$!:::9g!\!9g!*\:8g\!8g`
9\+1g9::< \|`g9\g8+2::p
g2+\8p2+^:<>:0\9p::8

在线尝试！

由于Befunge的内存限制，要跟踪序列中所有以前的条目并不现实，因此此解决方案使用内存占用量较小的算法来更直接地计算值。

也就是说，我们仍然受到单元格大小的限制，在Befunge-93参考解释器中，单元格大小是带符号的8位值，因此序列中A(1876) = 126支持的最高偶数为，而支持的最高奇数为A(1915) = 127。

如果要测试更大的值，则需要使用具有更大像元大小的解释器。这应该包括大多数Befunge-98实现（在线尝试！）。

Python 2，117字节

嗯 没那么短。简单的迭代解决方案。

L=[1,2,3]
n=input()
while len(L)<n:
 for i in range(2,n):
    if L.count(i)<L[i-1]and L[-1]!=i:L+=[i];break
print L[n-1]

在线尝试

这是一个非常糟糕的尝试递归解决方案（129字节）：

def f(n,L=[1,2,3]):
 if len(L)>=n:print L[n-1];exit(0)
 for i in range(2,n):
    if L.count(i)<L[i-1]and L[-1]!=i:f(n,L+[i])
 f(n,L)