당신의 임무는 정수 시퀀스 A130826 을 구현하는 것입니다 .

_n이 되는 작은 양의 정수와 같은 인 _N , n은 - 의 전체 배수 3 및 제수의 두 숫자 (a _N - N)에 / 3 제공 N ^번째 비우스에 의해 생성 된 시퀀스의 첫 번째 차이 용어 요세푸스 체.

아직 졌습니까? 글쎄, 실제로는 매우 쉽습니다.

비우스 세프 자체가 다음 정수 시퀀스를 정의한다.

1. 양의 정수 시퀀스로 시작하여 k = 2로 설정하십시오 .

2. 모든 분리 K에게 ^번째 부터 시작 시퀀스의 정수 (K)의 ^제 .

3. k를 증가 시키고 2 단계로 돌아갑니다.

f _n 은 제거되지 않는 n ^번째 정수 (1 색인)입니다.

평소 - - 경우 σ ₀ (k)는 정수의 양의 약수의 개수이다 (k)를 , 우리는 정의 할 수 _N 작은 양수 것과 같은 2σ ₀ ((a _N = F - N) / 3) _{N + 1} -f _n .

도전

양의 정수 얻어 프로그램이나 함수 작성 N 입력 및 지문 등 또는 반환 _N을 .

표준 코드 골프 규칙이 적용됩니다. 가장 짧은 코드가 이길 수 있습니다!

작동 예

양의 정수의 두 번째 요소를 모두 제거하면

 1  3  5  7  9 11 13 15 17 19 21 23 25 27 29 31 33 35 37 39 ...

나머지의 세 번째 요소를 모두 제거한 후에는

 1  3  7  9 13 15 19 21 25 27 31 33 37 39 ...

이제 4 번째, 5 번째, 6 번째 요소를 모두 제거하면

 1  3  7 13 15 19 25 27 31 37 39 ...
 1  3  7 13 19 25 27 31 39 ...
 1  3  7 13 19 27 31 39 ...
 1  3  7 13 19 27 39 ...

마지막 행에는 용어 f ₁ ~ f _{7이 표시} 됩니다.

이 용어의 연속 요소의 차이점은

 2  4  6  6  8 12

이러한 앞으로의 차이를 나누면 2 것은 , 우리가 얻을

 1  2  3  3  4  6 

이것들은 목표 제수입니다.

• 도 4는 제 정수이고 K 되도록 σ ₀ = 1 - (1) / 3 (k)는 . 실제로 σ ₀ (1) = 1 입니다.
• 도 8은 제 정수이고 K 되도록 σ ₀ = 2 - ((2)) / 3 (k)는 . 실제로, σ ₀ (2) = 2 입니다.
• 도 15는 제 정수이고 K 되도록 σ ₀ = 3 - (3) / 3 (k)는 . 실제로 σ ₀ (4) = 3 입니다.
• 16 은 첫 번째 정수 k 이므로 σ ₀ ((k-4) / 3) = 3 입니다. 실제로 σ ₀ (4) = 3 입니다.
• 도 23은 제 정수이고 K 되도록 σ ₀ (4) = - (5) / 3 (k)는 . 실제로 σ ₀ (6) = 4 입니다.
• 도 42는 제 정수이고 K 되도록 σ ₀ (6) = - (6) / (3) (k)는 . 실제로, σ ₀ (12) = 6 입니다.

테스트 사례

   n     a(n)

   1        4
   2        8
   3       15
   4       16
   5       23
   6       42
   7       55
   8      200
   9       81
  10       46
  11      119
  12      192
  13      205
  14   196622
  15    12303
  16       88
  17      449
  18      558
  19      127
  20     1748
  21   786453
  22       58
  23     2183
  24     3096
  25     1105
  26   786458
  27 12582939
  28      568
  29     2189
  30     2730

젤리, 30 29 27 25 바이트

@Dennis 덕분에 2 바이트를 절약 Æd하고 두 체인을 결합하기위한 2 바이트를 절약했습니다 .

RUð÷‘Ċ×µ/
‘Ç_ÇH0Æd=¥1#×3+

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

이것은 아마도 내가 젤리와 함께했던 가장 재미있을 것입니다. I는 계산 번째 행에서 시작 F _N 에서 N OEIS의 식을 사용하여, 아주 아름답다.

설명

RUð ÷ 'Ċ × µ / F n 을 계산하기위한 도우미 링크 . 인수 : n
R 숫자 얻기 [1..n]
 U 역
        / "다음 2 배까지 반올림":
   ÷ 다음 숫자로 나누기
    '여러 개 건너 뛰기 증가
     eil Ceil (라운드 업)
      × 다음 숫자로 곱하기

'Ç_ÇH0Æd = ¥ 1 # × 3 + 메인 링크. 인수 : n
'증가 n
 Ç F n + 1 
   계산 Ç F n 계산
  _ 빼기
    H를 2로 나누기
     0 1 # 0에서 시작하여 (a n -n) / 3 의 첫 번째 후보를 찾습니다.
                   만족합니다 ...
      Æd σ 0 ((a n -n) / 3)
        = = (F n + 1 -F n ) / 2
            × 3 3을 곱하여 (a n -n) / 3을 n -n으로 바꿉니다.
              + 회전하려면 n 추가 n 개의 에 -n을 N

파이썬 (2) , 121 (119) 118 바이트

n=input();r=range(1,4**n);d=s,=r*1,
for k in r:del s[k::k+1];d+=sum(k%j<1for j in r)*2,
print d.index(s[n]-s[n-1])*3+n

런타임 은 O (4 ⁿ ) 메모리 사용량 과 함께 대략 O (16 ⁿ ) 여야 합니다. 교체 로 - 내가하는 생각은 충분하다 - 극적이 개선 것입니다,하지만 난 그게의 임의의 큰 값에 대해 작동하는지 확신 아니에요 N .4**n5<<n

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

점근 적 행동과 _n의 상한

정의 b를 _N 으로서 (a _N / 3 - N) 즉, 작은 양의 정수 K 되도록 σ ₀ (K) = ½ (F _{N + 1} - F _N ) .

OEIS 페이지에 명시된 바와 같이, f _n ~ ¼πn ² 이므로 f _{n + 1} -f _n ~ ¼π (n + 1) ² -¼πn ² = ¼π (2n + 1) ~ ½πn 입니다.

이런 식으로 ½ (f _{n + 1} -f _n ) ~ ¼πn 입니다. 실제 숫자가 소수 p 인 경우 p 제수를 갖는 가장 작은 양의 정수 는 2 ^p-1 이므로 b _n 은 2 ^{c _n} 으로 근사 할 수 있습니다 . 여기서 c _n ~ ¼πn 입니다.

따라서 b _n <4 ⁿ 은 충분히 큰 n을 유지 하고 2 ^¼πn <2 ⁿ << (2 ⁿ ) ² = 4 ⁿ 이면, 반례가 없다고 확신합니다.

작동 원리

n=input();r=range(1,4**n);d=s,=r*1,

반복 프로세스에 대한 몇 가지 참조를 설정합니다.

• n 은 사용자 입력 : 양의 정수입니다.

• r 은리스트 [1, ..., 4 ⁿ -1] 입니다.

• s 는 r 의 사본입니다 .

  를 사용하여 목록을 한 번 반복하면 r*1얕은 사본 이 생성되므로 s 를 수정하면 r이 수정되지 않습니다 .

• D는 튜플로 초기화한다 (S) .

  이 첫 번째 가치는 중요하지 않습니다. 다른 모든 것에는 양수의 제수를 보유합니다.

for k in r:del s[k::k+1];d+=sum(k%j<1for j in r)*2,

1 에서 4 ⁿ -1 까지의 각 정수 k에 대해 다음을 수행합니다.

• del s[k::k+1]각 소요 (K + 1) ^번째 의 정수 들 으로 시작 - (K + 1) ^번째 - 및 삭제로부터 그 조각 들 .

  이것은 Flavius ​​Josephus sieve의 초기 간격을 s 에 저장하는 간단한 방법입니다 . 필요한 n + 1 초기 항 보다 훨씬 많은 양을 계산 하지만 단일 for루프를 사용하여 s 와 d를 모두 업데이트 하면 일부 바이트가 절약됩니다.

• d+=sum(k%j<1for j in r)*2,r이 k를 균등하게 나누는 요소 수를 계산 하고 d 에 2σ ₀ (k) 를 추가 합니다.

  이후 D는 싱글 튜플로 초기화하고, 2σ ₀ (k)는 인덱스에 저장되어있는 K .

print d.index(s[n]-s[n-1])*3+n

이 처음 발견 지수 F _{N + 1} - F _N 에서 D , 가장 작은 K에게 되도록 2σ ₀ (K) = F _{, N + 1} - F를 _N 다음 계산, _N 등 3K + 1을 하고 그 결과를 출력한다.

자바 8, 336 , 305 , 303 , 287 , 283 279 바이트

Kritixi Lithos로 인해 57 바이트 제거

골프

class f{static int g(int s,int N){return s<1?N+1:g(s-1,N+N/s);}static int h(int k){int u=0,t=1,i;for(;u!=(g(k,k)-g(k,k-1))/2;t++)for(i=1,u=0;i<=t;)if(t%i++<1)u++;return 3*t-3+k;}public static void main(String[]a){System.out.print(h(new java.util.Scanner(System.in).nextInt()));}}

언 골프

class f {
    static int g(int s,int N){return s < 1 ? N + 1 : g(s - 1, N + N / s);}

    static int h(int k) {
        int u = 0, t = 1, i;
        // get the first number with v divisors
        while(u != (g(k, k) - g(k, k - 1))/2){
            u = 0;
            for (i = 1; i <= t; i++)
                if (t % i < 1) u++;
            t++;
        }
        // 3*(t-1)+k = 3*t+k-3
        return 3 * t + k - 3;
    }

    public static void main(String[] a) {
        System.out.print(h(new java.util.Scanner(System.in).nextInt()));
    }
}

매쓰, 130 116 106 103 바이트

3Catch@Do[f=#2⌈#/#2+1⌉&~Fold~Reverse@Range@#&;If[Tr[2+0Divisors@k]==f[#+1]-f@#,Throw@k],{k,∞}]+#&

또는

3Catch@Do[f=#2⌈#/#2+1⌉&~Fold~Reverse@Range@#&;If[2DivisorSum[k,1&]==f[#+1]-f@#,Throw@k],{k,∞}]+#&

@ Pietu1998의 Jelly 코드와 거의 동일하게 끝났습니다 ...

설명

Catch@

Catch무엇이든지 Throw-ed (thrown)입니다.

Do[ ... ,{k,∞}]

무한 루프; 매 반복마다 k시작하여 1증가합니다.

f= ...

할당 f:

Reverse@Range@#

찾기 {1, 2, ... , n}. 반대로 해

#2⌈#/#2+1⌉&

ceil (n1 / n2 + 1) * n2를 출력하는 기능

f= ... ~Fold~ ... &

f각 출력을 첫 번째 입력으로 사용하고 목록의 각 요소를 두 번째 입력으로 사용하여 위의 기능을 위의 두 단계에서 목록에 반복적으로 적용하는 기능을 지정 하십시오. 초기 "출력"(첫 번째 입력)은 목록의 첫 번째 요소입니다.

Tr[2+0Divisors@k]==f[#+1]-f@#

제수의 두 배가 kf (n + 1)-f (n)과 같은지 확인하십시오 .

If[ ... ,Throw@k]

조건이 True인 Throw경우 값은 k입니다. 그렇지 않으면 계속 반복하십시오.

3 ... +#&

출력에 3을 곱하고 n을 더합니다.

130 바이트 버전

Catch@Do[s=#+1;a=k-#;If[3∣a&&2DivisorSigma[0,a/3]==Differences[Nest[i=1;Drop[#,++i;;;;i]&,Range[s^2],s]][[#]],Throw@k],{k,∞}]&

펄 (6) , 154 (149) 136 107 바이트

->\n{n+3*first ->\o{([-] ->\m{m??&?BLOCK(m-1).rotor(m+0=>1).flat!!1..*}(n)[n,n-1])/2==grep o%%*,1..o},^Inf}

언 골프 드 :

-> \n {                    # Anonymous sub taking argument n
  n + 3 * first -> \o {    # n plus thrice the first integer satisfying:
    (                      #
      [-]                  #
      -> \m {              # Compute nth sieve iteration:
        m                  # If m is nonzero,
          ?? &?BLOCK(m-1).rotor(m+0=>1).flat # then recurse and remove every (m+1)-th element;
          !! 1..*          # the base case is all of the positive integers
      }                    #
      (n)                  # Get the nth sieve
      [n,n-1]              # Get the difference between the nth and (n-1)th elements (via the [-] reduction operator above)
    ) / 2                  # and divide by 2;
    ==                     # We want the number that equals
    grep o %% *, 1..o      # the number of divisors of o.
  }
  ,^Inf
}

05AB1E ,35 34 39 바이트

1Qi4ë[N3*¹+NÑg·¹D>‚vyy<LRvy/>îy*}}‚Æ(Q#

런타임 성능도 끔찍합니다. 작은 값을 산출하는 입력에는 몇 초가 걸립니다. 14와 같은 숫자를 시도하지 마십시오. 결국 결과를 찾을 수 있지만 시간이 오래 걸릴 것입니다.

설명

순차적으로 호출되는 2 개의 프로그램으로 작동합니다. 첫 번째 것은 F _{n + 1} -F _n을 계산 하고 두 번째 것은 무차별 접근 방식을 사용하여 정의에 따라 _n을 결정 합니다 .

F _{n + 1} -F _n 은 루프가 변하지 않더라도 각 반복에 대해 평가됩니다. 코드 시간이 비효율적이지만 코드가 짧아집니다.

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