定义

根据OEIS A006345的描述：

要查找a(n)，请考虑a 1或a 2。对于每个a(n)=1,2序列，找到最长的重复后缀，即对于每个序列，找到s具有序列a(1),...,a(n)结尾的最长序列ss。使用导致后缀较短的数字。a(1) = 1。

解决的例子

a(1)=1。

如果是a(2)=1，我们将得到1 1从末尾最长的一倍子串是的序列1。如果a(2)=2不是，那么它将是空的子字符串。因此a(2)=2。

什么时候n=6，我们在1 2 1 1 2 1和之间选择1 2 1 1 2 2。在首选中，1 2 1从末尾开始连续翻倍。在第二选择中，它是2。因此，a(6)=2。

什么时候n=9，我们在1 2 1 1 2 2 1 2 1 和之间选择1 2 1 1 2 2 1 2 2。在第一种选择中，最长的双倍连续子字符串是2 1，而在第二种选择1 2 2中，最后连续地双倍连续。因此a(9)=1。

任务

给定n，退货a(n)。

眼镜

• n 将是积极的。
• 您可以使用0索引而不是1索引。在这种情况下，请在您的答案中注明。同样，在这种情况下，n也可以0。

测试用例

测试用例是1索引的。但是，您可以使用0索引。

n  a(n)
1  1
2  2
3  1
4  1
5  2
6  2
7  1
8  2
9  1
10 1
11 2
12 1
13 2
14 2
15 1
16 1
17 2
18 1
19 1
20 1

参考文献

• Wolfram数学世界
• 强制性OEIS A006345

Haskell，146 140 137 133 118字节

s!l|take l s==take l(drop l s)=l|1<2=s!(l-1)
g[w,x]|w<x=1|1<2=2
a 1=1
a n=g$(\s x->(x:s)!n)(a<$>[n-1,n-2..1])<$>[1,2]

Python，137个字节

def a(n,s=[0],r=lambda l:max([0]+filter(lambda i:l[-i:]==l[-i*2:-i],range(len(l))))):
 for _ in[0]*n:s+=[r(s+[0])>r(s+[1])]
 return-~s[n]

该解决方案使用基于0的索引。

果冻，25 24 22 20 字节

2个字节感谢Dennis。

2;€µḣJf;`€$ṪLµÞḢ
Ç¡Ḣ

在线尝试！

我在Pyth中的回答的一部分。

Ç¡Ḣ   Main chain

 ¡    Repeat for (input) times:
Ç         the helper chain
  Ḣ   Then take the first element



2;€µḣJf;`€$ṪLµÞḢ  Helper chain, argument: z

2;€               append z to 1 and 2, creating two possibilities
   µ         µÞ   sort the possibilities by the following:
    ḣJ                generate all prefixes from shortest to longest
       ;`€            append the prefixes to themselves
      f   $           intersect with the original set of prefixes
           Ṫ          take the last prefix in the intersection
            L         find its length
                 Ḣ   take the first (minimum)

Mathematica，84个字节

a@n_:=a@n=First@MinimalBy[{1,2},Array[a,n-1]~Append~#/.{___,b___,b___}:>Length@{b}&]

果冻，30 29 28 27 24 字节

;€¬;\€Z;/f;`€$ṪḢ;
1Ç¡o2Ḣ

在线尝试！或验证所有测试用例。

MATL，34个字节

vXKi:"2:"K@h'(.+)\1$'XXgn]>QhXK]0)

在线尝试！或验证所有测试用例。

说明

v             % Concatenate stack vertically: produces empty array
XK            % Copy to clipboard K. This clipboard holds the current sequence
i:            % Take input n. Generate vector [1 2 ... n]
"             % For each k in [1 2 ... n]
  2:          %   Push [1 2]. These are the possible digits for extending the sequence
  "           %     For each j in [1 2]
    K         %       Push contents of clipboard K (current sequence)
    @         %       Push j (1 or 2)
    h         %       Concatenate horizontally: gives a possible extension of sequence
    '(.+)\1$' %       String to be used as regex pattern: maximal-length repeated suffix
    XX        %       Regex match
    gn        %       Convert to vector and push its length: gives length of match
  ]           %    End. We now have the suffix lengths of the two possible extensions
  >           %    Push 1 if extension with "1" has longer suffix than with "2"; else 0 
  Q           %    Add 1: gives 2 if extension with "1" produced a longer suffix, or 1
              %    otherwise. This is the digit to be appended to the sequence
  h           %    Concatenate horizontally
  XK          %    Update clipboard with extended sequence, for the next iteration
]             % End
0)            % Get last entry (1-based modular indexing). Implicitly display

Python 2，94个字节

import re
s='1'
exec"s+=`3-int(re.search(r'(.*)(.)\\1$',s).groups()[1])`;"*input()
print s[-1]

使用基于0的索引。在Ideone上进行测试。

Pyth，26个字节

huh.mleq#.<T/lT2._b+RGS2QY

测试套件。

说明

当时n = 6，我们在1 2 1 1 2 1和之间选择1 2 1 1 2 2。

我们生成这两种可能性，然后看一下它们的后缀。

对于第一个，后缀是：1，2 1，1 2 1，1 1 2 1，2 1 1 2 1，1 2 1 1 2 1。

我们通过他们是否旋转他们的长度除以2后的相同检查筛选出一倍后缀（事实证明，这种检查是不完美的，因为它证实了1和2也）。

我们取最后一个加倍的后缀，然后取其长度。

然后，我们选择与上面生成的最小长度相对应的可能性。

然后我们继续到的下一个值n。

出于此程序的目的，代替生成反向数组是一个高尔夫球手。

huh.mleq#.<T/lT2._b+RGS2QY
 u                      QY   repeat Q (input) times,
                             start with Y (empty array),
                             storing the temporary result in G:
                   +RGS2         prepend 1 and 2 to G,
                                 creating two possibilities
   .m             b              find the one that
                                 makes the following minimal:
                ._                   generate all prefixes
       q#                            filter for prefixes as T
                                     that equals:
         .<T/lT2                         T left-rotated
                                         by its length halved
      e                              take the last one
     l                               generate its length
  h                              take the first minimal one
h                                take the first one from the generated
                                 array and implicitly print it out

Pyth，46个 29字节

从@Leaky Nun出色的Pyth答案中获得了一些启发。尝试查看是否有使用字符串的更短方法。还有3个字节！

huh.melM+kf!x>blTT._bm+dGS2Qk

您可以在这里尝试。

视网膜，51 42字节

感谢Martin Ender提供9个字节。

.+
$*x
+`((.*)(^|2|(?<3>1))\2)x
$1$#3
!`.$

在线尝试！

这个答案的端口。

Perl，40个字节

$a.=/(.*)(.)\1$/^$2for($a)x$_;$_=$a%5+1

该代码长39字节，需要-p切换（+1字节）。

该循环的灵感来自相关OEIS页面上的Perl解决方案，尽管我确实独立提出了正则表达式。

在Ideone上进行测试。

JavaScript（ES6），84

索引基数0

n=>eval("s='1';for(r=d=>(s+d).match(/(.*)\\1$/)[0].length;n--;s+=c)c=r(1)>r(2)?2:1")

少打高尔夫球

n=>{
  r = d => (s+d).match(/(.*)\1$/)[0].length;
  c = '1';
  for(s = c; n--; s += c)
    c = r(1) > r(2) ? 2 : 1;
  return c;
}

测试

F=
n=>eval("s='1';for(r=d=>(s+d).match(/(.*)\\1$/)[0].length;n--;s+=c)c=r(1)>r(2)?2:1")

for(n=0;n<20;n++)console.log(n,F(n))