정의

OEIS A006345 에 대한 설명에서 :

찾으려면 a(n)a 1또는 a를 고려 하십시오 2. 각각에 대해 가장 긴 반복 접미사를 찾으십시오. 즉, 각각에 대해 시퀀스가로 끝나는 속성을 가진 a(n)=1,2가장 긴 시퀀스 s를 찾으십시오 . 그러한 접미어가 더 짧은 숫자를 사용하십시오. .a(1),...,a(n)ssa(1) = 1

해결 된 예

a(1)=1.

그렇다면 끝에서 가장 긴 두 배로 된 부분 문자열 a(2)=1이있는 순서를 갖게됩니다 . 경우 대신, 그것은 빈 문자열이 될 것입니다. 따라서 .1 11a(2)=2a(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 긍정적입니다.
• 1- 인덱스 대신 0- 인덱스를 사용할 수 있습니다. 이 경우 답변에 기재하십시오. 또한,이 경우에, 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

참고 문헌

• WolframMathWorld
• 의무적 OEIS A006345

하스켈 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]

파이썬, 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 바이트

Dennis 덕분에 2 바이트.

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)

수학, 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

파이썬 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
!`.$

온라인으로 사용해보십시오!

이 답변 의 포트 .

펄, 40 바이트

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

코드 길이 는 39 바이트 이며 -p스위치 ( +1 바이트) 가 필요합니다 .

루프는 관련 OEIS 페이지 의 Perl 솔루션에서 영감을 얻었 지만 정규 표현식과 독립적으로 나왔습니다.

Ideone에서 테스트하십시오 .

자바 스크립트 (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))