오늘 은 Collatz 함수 f 와 관련된 시퀀스 a를 살펴 보겠습니다 .

우리는 폼의 호출 시퀀스 (F (z)) ... F (Z), F (Z) Collatz 시퀀스 .

첫 번째 숫자 우리의 서열은, A (1) 이며, 0 . f를 반복 적용 하면 사이클 0 → 0 →…

우리가 아직 보지 못한 가장 작은 숫자는 1이므로 a (2) = 1 입니다. f를 반복해서 적용 하면 1 → 4 → 2 → 1 →…

이제 숫자 보이면서 2 다음에 작은 번호가되도록, 상기주기에서 A (3) = 3 사이클에 떨어지는 3 → 10 → 5 → 16 → 8 → 4 → 2 → 1 → 4 → 2 → 1 →…

위의 모든 사이클에서 우리는 4 와 5를 이미 보았 으므로 다음 숫자는 a (4) = 6 입니다.

이제 아이디어를 얻어야합니다. a (n) 은 모든 a (1),…, a (n-1) 에 대해 Collatz 시퀀스의 일부가 아닌 가장 작은 수입니다 .

양의 정수 n이 주어지면 a (n)을 반환 하는 프로그램이나 함수를 작성하십시오 . 바이트 단위의 최단 코드가 이깁니다.

테스트 케이스 :

1  -> 0
2  -> 1
3  -> 3
4  -> 6
5  -> 7
6  -> 9
7  -> 12
8  -> 15
9  -> 18
10 -> 19
50 -> 114

( OEIS 시퀀스 A061641 입니다.)

젤리 , 20 19 바이트

ḟ@JḢ×3‘$HḂ?ÐĿ;Ṛ
Ç¡Ṫ

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오 .

작동 원리

Ç¡Ṫ              Main link. No explicit arguments. Default argument: 0
 ¡               Read an integer n from STDIN and do the following n times.
Ç                  Call the helper link.
  Ṫ              Tail; extract the last element of the resulting array.


ḟ@JḢ×3‘$HḂ?ÐĿ;Ṛ  Helper link. Argument: A (array)

  J              Yield all 1-based indices of A, i.e., [1, ..., len(A)]. Since 0
                 belongs to A, there is at least one index that does belong to A.
ḟ@               Filter-false swapped; remove all indices that belong to A.
   Ḣ             Head; extract the first index (i) that hasn't been removed.
           ÐĿ    Call the quicklink to the left on i, then until the results are no
                 longer unique. Collect all unique results in an array.
         Ḃ?      If the last bit of the return value (r) is 1:
       $           Apply the monadic 3-link chain to the left to r.
    ×3‘              Yield 3r + 1.
        H        Else, halve r.
              Ṛ  Yield A, reversed.
             ;   Concatenate the results array with reversed A.

n 반복 후 , a (n + 1) 의 값은 배열의 시작 부분에 있습니다. 새 배열을 이전 배열의 뒤집힌 사본과 연결하므로 a (n) 이 끝날 것입니다.

하스켈, 93 92 바이트

c x|x<2=[[0,2]!!x]|odd x=x:c(3*x+1)|1<2=x:c(div x 2)
([y|y<-[-1..],all(/=y)$c=<<[0..y-1]]!!)

사용 예 : ([y|y<-[-1..],all(/=y)$c=<<[0..y-1]]!!) 10-> 19.

c x에 대한 x약간의 부정 행위와 Collatz주기 입니다 x == 1. 주요 기능은 모든 정수를 순환과에없는 것들 유지 c x를 위해 x의를 [0..y-1]. 정의의 직접적인 구현. Haskell 인덱스 연산자 !!는 0 기반이므로 -1인덱스를 고정시키기 위해 (그렇지 않으면 쓸모없는) 숫자를 앞에 추가합니다.

MATL , 46 40 바이트

Oiq:"tX>Q:yX-X<`t0)to?3*Q}2/]h5M1>]Pv]0)

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

설명

이 코드에는 반복마다 하나씩 Collatz 시퀀스 for를 생성 하는 외부 루프가 n있습니다. 각 시퀀스 내에서 생성되는 do...while(A)에 새로운 값을 계산하여 저장 루프 시퀀스 벡터 까지 1또는 0얻는다. 시퀀스를 완료하면 벡터가 반전되고 모든 이전 시퀀스의 값이 포함 된 전역 벡터로 연결됩니다 . 이 벡터에는 반복되는 값이 포함될 수 있습니다. 시퀀스 벡터의 반전은 외부 루프의 끝에서 원하는 결과 (마지막 시퀀스의 시작 값)가 글로벌 벡터의 끝이되도록합니다.

의사 코드 :

1  Initiallization
2  Generate n sequences (for loop):
3    Compute initial value for the k-th sequence
4    Generate the k-th sequence (do...while loop)
5      Starting from latest value so far, apply the Collatz algorithm to get next value
6      Update sequence with new value 
7      Check if we are done. If so, exit loop. We have the k-th sequence
8    Update vector of seen values
9  We now have the n sequences. Get final result

주석이 달린 코드 :

O           % Push 0                                                          1
iq:         % Input n. Generate [1 2 ... n-1]                                 ·
"           % For loop: repeat n-1 times. Let k denote each iteration         2
  t         %   Duplicate vector of all seen values                           · 3
  X>Q       %   Take maximum, add 1                                           · ·
  :         %   Range from 1 to that: these are potential initial values      · ·
  y         %   Duplicate vector of all seen values                           · ·
  X-X<      %   Set difference, minimum: first value not seen                 · ·
  `         %   Do...while: this generates the k-th Collatz sequence          · 4
    t0)     %     Duplicate, push last value of the sequence so far           · · 5
    to      %     Duplicate, parity: 1 if odd, 0 if even                      · · ·
    ?       %     If odd                                                      · · ·
      3*Q   %       Times 3, plus 1                                           · · ·
    }       %     Else                                                        · · ·
      2/    %       Half                                                      · · ·
    ]       %     End if                                                      · · ·
    h       %     Concatenate new value of the sequence                       · · 6
    5M      %     Push the new value again                                    · · 7
    1>      %     Does it exceed 1? This is the loop condition                · · ·
  ]         %   End do...while. The loops ends when we have reached 0 or 1    · ·
  P         %   Reverse the k-th Collatz sequence                             · 8
  v         %   Concatenate with vector of previously seen values             · ·
]           % End for                                                         ·
0)          % Take last value. Implicitly display.                            9

Brachylog , 70 67 65 63 62 바이트

,[]:?:1ih.
,0<=X=,?'eXg{t{:2/.*?|:3*+.}gB,(?.sB;?:Bc:2&.)}:?c.

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

파이썬 2, 97 96 바이트

r,=s={-1}
exec'n=r=min({r+1,r+2,r+3}-s)\nwhile{n}-s:s|={n};n=(n/2,3*n+1)[n%2]\n'*input()
print r

3의 배수가 모두 순수 하다는 사실을 이용합니다 . Ideone에서 테스트하십시오 .

작동 원리

첫번째 행에서, r,=s={-1}집합 S = {-1} (SET) 및 R = -1 .

다음으로 STDIN에서 정수를 읽고 특정 문자열을 여러 번 반복 한 다음 실행합니다. 이것은 다음 파이썬 코드와 동일합니다.

for _ in range(input())
    n=r=min({r+1,r+2,r+3}-s)
    while{n}-s:
        s|={n}
        n=(n/2,3*n+1)[n%2]

각 반복에서 s에 속하지 않는 가장 작은 {r + 1, r + 2, r + 3} 멤버를 찾는 것으로 시작합니다 . 첫 번째 반복에서는 r 을 0으로 초기화 합니다.

모든 후속 실행에서 들 (과 의지)의 일부 포함 할 수있다 R + 1 , R + 2 및 R + 3 의 모든 배수 때문에, 그러나 결코 그들 모두, 3은 순수하다. 이 문장을 검증하려면 3의 배수 m 이 3k + 1 형식이 아닌지 확인하십시오 . 그 잎 2m 을 유일한 사전 이미지로 3 의 배수이기도합니다 . 따라서, m은 보다 작은 개수의 Collatz 시퀀스에 나타나지 않을 수 m , 따라서 순수하다.

식별 한 후 R을 하고 초기화 N을 우리가 가진 Collatz 함수 적용 n=(n/2,3*n+1)[n%2]의 각각의 중간 값을 가산, N을 세트로 S 와s|={n} . 우리는 숫자가 발생하면 N 즉 이미 S , {n}-s빈 세트를 산출하고, 반복이 중지됩니다.

r 의 마지막 값 원하는 시퀀스 요소입니다.

Pyth , 32 바이트

VtQ=+Y.u?%N2h*3N/N2Z)=Zf!}TYhZ)Z

테스트 스위트.

자바, 148 바이트

int a(int n){if(n<2)return 0;int f=a(n-1),b,i,c;do{f++;for(b=1,i=1;i<n;i++)for(c=i==2?4:a(i);c>1;c=c%2>0?c*3+1:c/2)b=c==f?0:b;}while(b<1);return f;}

무시 했어!(경고 : 제로 최적화로 인한 지수 복잡성.)

do...while루프 에서 루프로 변환for 골퍼가 될 수 있지만 그렇게하는 데 문제가 있습니다.

골프 조언은 평소처럼 환영합니다.

펄 6, 96

my @s;my $a=0;map {while ($a=@s[$a]=$a%2??3*$a+1!!$a/2)>1 {};while @s[++$a] {}},2..slurp;$a.say;

Perl 5 답변을 기반으로합니다 . Perl6 구문이 Perl5 구문보다 덜 관대하기 때문에 조금 더 길지만 지금은 이것으로 해결하겠습니다.

PHP, 233124 바이트

<?$n=$argv[1];for($c=[];$n--;){for($v=0;in_array($v,$c);)$v++;for(;$n&&!in_array($v,$c);$v=$v&1?3*$v+1:$v/2)$c[]=$v;}echo$v;

기능 +4 :

function a($n){for($c=[];$n--;){for($v=0;in_array($v,$c);)$v++;for(;$n&&!in_array($v,$c);$v=$v&1?3*$v+1:$v/2)$c[]=$v;}return$v;}

펄 5-74 바이트

map{0 while 1<($a=$c[$a]=$a%2?$a*3+1:$a/2);0 while$c[++$a]}2..<>;print$a+0

이것은 매우 간단한 해결책입니다. Collatz 함수를 반복적으로 변수에 적용하고 값이 $a표시된 배열에 저장 @c한 다음 0 또는 1에 도달하면 $a아직 보이지 않는 숫자가 될 때까지 증가 합니다. 이것은 입력 마이너스 2와 같은 횟수로 반복되고, 최종적으로 그 값 $a이 출력된다.

수학, 134 바이트

f=If[EvenQ@#,#/2,3#+1]&;a@n_:=(b={i=c=0};While[i++<n-1,c=First[Range@Max[#+1]~Complement~#&@b];b=b~Union~NestWhileList[f,c,f@#>c&]];c)

더 읽기 쉬운 형식 :

f = If[EvenQ@#, #/2, 3#+1] &;                        Collatz function
a@n_ := (                                            defines a(n)
  b = {i = c = 0};                                   initializations
                                                       b is the growing sequence
                                                       of cycles already completed
  While[i++ < n - 1,                                 computes a(n) recursively
    c = First[Range@Max[# + 1]~Complement~# & @b];   smallest number not in b
    b = b~Union~NestWhileList[f, c, f@# > c &]       apply f to c repeatedly
                                                       until the answer is smaller
                                                       than c, then add this new
                                                       cycle to b
    ]
  ; c)                                                 output final value of c