OEIS 는 Golomb의 시퀀스 에 변형 (A111439)이 있습니다. Golomb의 시퀀스에서와 A(n)같이 시퀀스에 얼마나 자주 n나타나는지 설명합니다 . 그러나 두 개의 연속 된 숫자가 동일하지 않을 수도 있습니다. 시퀀스를 구축하는 동안 A(n)항상이 두 속성을 위반하지 않는 가장 작은 양의 정수로 선택됩니다. 연속 된 동일한 숫자가 허용되지 않기 때문에 시리즈는 자라면서 약간 위아래로 흔들립니다. 처음 100 개의 용어는 다음과 같습니다.

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

처음 10,000 개 숫자의 전체 목록은 OEIS에서 찾을 수 있습니다 .

과제는 A(n)주어진 계산하는 프로그램이나 함수를 작성하는 것 n입니다. n되는 1자체 설명 속성이 작동하는지 확인하기 위해 기반.

규칙

당신은 쓸 수 있습니다 프로그램이나 기능을 하고, 우리의 사용 표준 방법 입력을 수신하고 출력을 제공합니다.

모든 프로그래밍 언어를 사용할 수 있지만 이러한 허점 은 기본적으로 금지되어 있습니다.

이것은 code-golf 이므로 바이트 단위로 측정 된 가장 짧은 유효한 답변이 이깁니다.

테스트 사례

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

하스켈 , 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.

매스 매 티카, 69 68 바이트

여분의 –1 바이트를 찾아 주신 Martin Ender에게 감사드립니다!

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

익명 함수를 n입력 으로 양의 정수 를 가져와 양의 정수를 반환합니다. n이 시퀀스 의 첫 번째 요소의 전체 목록을 구성한 다음 Last요소 를 가져옵니다 . 리스트는 빈리스트로 시작 {}하여 함수 n시간으로 행을 통해 (via를 통해 Nest) 구성됩니다.

문제의 함수는 {##&@@#,1//.x_/;x==Last@#||#~Count~x==#[[x]]->x+1}&(순서대로) 시퀀스 값의 부분 목록을 가져 와서 ##&@@#다음 값을 추가합니다. 다음 값은로 시작 하여 조건 이 충족되는 한 (즉, 이전 요소 중 하나 이거나 이미 목록에 올바른 횟수 인 경우) x=1반복해서 대체 x하여 계산됩니다 . 이 함수는 (예를 들어) 초기 목록 의 th 요소를 호출해서는 안되기 때문에 약간의 오류가 발생 합니다 . 그러나 값이 모두 맞습니다.x+1x==Last@#||#~Count~x==#[[x]]xxx{}

파이썬 2, 99 86 바이트

총 13 바이트의 여러 개선 사항에 대한 @Dennis에 감사드립니다!

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경우 목록 끝에 a를 추가하려고 시도합니다 . 그렇지 않은 경우 2무언가가 허용 될 때까지 계속 시도합니다 .

이제에 대한 결과를 시드하는 것으로 시작 1,2,3합니다 1,2,3. I : 이것은 너무 짧은 것을 이미 계산 된 값 목록에 문제되지 않도록하기위한 것입니다 추측 경우 것이 n적어도입니다 4후 a(n)엄격 미만입니다 n. (이 프로그램에서는 s[n]입니다 a(n).리스트는 실제로 파이썬에서 인덱스 [0,1,2,3]되기 때문에리스트는 실제로 초기화됩니다 0. 예를 들어 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 개의 시퀀스 값을 더 계산합니다. 예를 들어 nis 8인 경우 s[11]값을 반환하기 전에 계산됩니다 s[8].

추측의 증거를 보게되어 기쁩니다. 나는 그것이 (강한?) 유도에 의해 입증 될 수 있다고 생각합니다.

편집 : 다음은 추측 의 증거입니다 . 우리는 실제로 추가 작업이 필요하지 않기 때문에 약간 더 강한 형태의 진술을 증명합니다.

정리 : 모두 n크거나 같은 4경우 항 a(n)은보다 작거나 같습니다 (n-2).

(강한 유도로) 증명 : (자료 n=4) : 명령문에 대한 사실 n=4때문에 a(4) = 2 = 4-2.

이제 부터부터부터 까지의 모든 a(k)것보다 작거나 같다고 가정합니다 ( 적어도 같다고 가정 ). 특히, 이는 시퀀스의 모든 이전 항이 최대가되었음을 의미합니다 . 우리 는 최대가 될 것임을 보여줄 필요 가 있습니다 . 이제 정의상 조건을 위반하지 않는 가장 작은 양의 정수이므로 값 이 조건을 위반하지 않음 을 보여 주면 됩니다.k-2k4nn4(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.

파이썬 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 (inane)입니다 . 입력 9 는 로컬에서 2 초, 입력 10 52 초, 11 17 분 28 초를 입력 합니다. 그러나 람다가 아닌 일반 함수로 선언 된 경우 메모를 사용하여 테스트 사례를 확인할 수 있습니다.

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

메모를 사용하더라도 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 루프 외부에 추가 할 수 있습니다.

중첩 루프 및 조건부 문제로 인해 루프 내부에서이 작업을 수행 할 수 없습니다.

비 펀지, 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 구현이 포함되어야합니다 ( 온라인 시도 ).

파이썬 2, 117 바이트

Meh. 그렇게 짧지 않습니다. 간단한 반복 솔루션.

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)