양의 정수 n에 대해 함수 f (n) 을 다음과 같이 정의하십시오 .

• N / 2 , 만약 n이 짝수
• n 이 홀수 인 경우 3 * n + 1

이 함수를 0보다 큰 n에 반복해서 적용 하면 결과는 항상 1로 수렴하는 것으로 보입니다 (아직 아무도 그것을 증명할 수는 없었 음). 이 속성은 Collatz Conjecture라고 합니다.

정수의 정지 시간 을 Collatz 함수 f 가 1에 도달하기 전에 통과해야하는 횟수로 정의하십시오 . 처음 15 개의 정수의 정지 시간은 다음과 같습니다.

1  0
2  1
3  7
4  2
5  5
6  8
7  16
8  3
9  19
10 6
11 14
12 9
13 9
14 17
15 17

같은 중지 시간 Collatz 사촌 과 함께 숫자 세트를 호출합시다 . 예를 들어, 5와 32는 중지 시간이 5 인 Collatz 사촌입니다.

작업 : 음수가 아닌 정수를 사용하고 중지 시간이 해당 정수와 같은 Collatz 사촌 세트를 생성하는 프로그램 또는 함수를 작성하십시오.

입력

STDIN, ARGV 또는 함수 인수를 통해 제공되는 음이 아닌 정수 S.

산출

중지 시간이 S 인 모든 숫자의 목록은 오름차순으로 정렬 됩니다 . 리스트는 프로그램에 의해 출력되거나 함수에 의해 리턴되거나 출력 될 수 있습니다. 출력 형식은 유연합니다. 공백으로 구분하거나 줄 바꾸기로 구분하거나 언어의 표준 목록 형식을 사용하면 숫자를 쉽게 구분할 수 있습니다.

요구 사항

제출물은 S ≤ 30에 대해 정확한 결과를 제공해야합니다. 몇 시간 또는 며칠이 아니라 몇 초 또는 몇 분 안에 완료되어야합니다.

예

0  -> 1
1  -> 2
5  -> 5, 32
9  -> 12, 13, 80, 84, 85, 512
15 -> 22, 23, 136, 138, 140, 141, 150, 151, 768, 832, 848, 852, 853, 904, 906, 908, 909, 5120, 5376, 5440, 5456, 5460, 5461, 32768

다음은 S = 30 의 출력 요점입니다 .

이것은 코드 골프입니다 : 바이트 단위의 최단 프로그램이 이깁니다. 행운을 빕니다!

Pyth, 26 24 21 바이트

Su+yMG-/R3fq4%T6G1Q]1

이 코드는에 대해 즉시 실행됩니다 S=30. 직접 해보십시오 : 데모

5 바이트를 절약 한 @isaacg에게 감사합니다.

설명

내 코드 1는 Collatz 기능으로 시작 하고 실행 취소합니다. 단계 d의 모든 숫자 S-1를 2*d및에 매핑합니다 (d-1)/3. 그래도 마지막은 항상 유효하지는 않습니다.

                        implicit: Q = input number
                   ]1   start with G = [1]
 u                Q     apply the following function Q-times to G:
                          update G by
   yMG                      each number in G doubled
  +                       +
          fq4%T6G           filter G for numbers T, which satisfy 4==T%6
       /R3                  and divide them by 3
      -          1          and remove 1, if it is in the list
                            (to avoid jumping from 4 to 1)
S                       sort the result and print

Mathematica, 98 92 89 바이트

이 솔루션은 S = 30즉시 해결됩니다 .

(p={0};l={1};Do[l=Complement[##&@@{2#,Mod[a=#-1,2]#~Mod~3~Mod~2a/3}&/@l,p=p⋃l],{#}];l)&

이것은 S유일한 매개 변수로 사용하고 Collatz 사촌 목록을 반환 하는 명명되지 않은 함수 입니다.

이 알고리즘은 간단한 너비 우선 검색입니다. 주어진 SCollatz 사촌은 Collatz 사촌에서을 S-1통해 도달 할 수있는 모든 정수 2*n또는 을 통해 도달 할 수있는 홀수 (n-1)/3입니다. 또한 단계 후 처음으로 도달 한 정수만 생성 S하므로 이전의 모든 사촌을 추적 p하고 결과에서 제거합니다. 어쨌든 우리는 그렇게하고 있기 때문에 이전의 모든 사촌 ( 단계 뿐만 아니라 S-1) 의 단계를 계산하여 몇 바이트를 절약함으로써 몇 바이트를 절약 할 수 있습니다 (이는 약간 느리지 만 필요한 것은 눈에 띄지 않습니다 S).

약간 더 읽기 쉬운 버전이 있습니다 :

(
  p = {0};
  l = {1};
  Do[
    l = Complement[
      ## & @@ {2 #, Mod[a = # - 1, 2] #~Mod~3~Mod~2 a/3} & /@ l,
      p = p ⋃ l
    ]~Cases~_Integer,
    {#}
  ];
  l
) &

파이썬 2, 86 83 75 73 71 바이트

f=lambda n,k=1:sorted([k][n:]or(k>4==k%6and f(n-1,k/3)or[])+f(n-1,k*2))

처럼 전화하십시오 f(30). n = 30거의 즉각적입니다.

( k사촌 목록이 아닌 숫자와 몇 바이트로 되풀이되는 아이디어에 대해 @DLosc에게 감사합니다 ~-.

이 변형은 훨씬 짧지 만 불행히도 지수 분기로 인해 너무 오래 걸립니다.

f=lambda n,k=1:sorted([k][n:]or(k>4==k%6)*f(n-1,k/3)+f(n-1,k*2))

CJam, 29 26 바이트

Xari{{2*_Cmd8=*2*)}%1-}*$p

크레디트는 각 반복 후 1을 제거하려는 아이디어로 @isaacg로 이동하여 2 바이트를 직접 저장하고 다른 바이트는 간접적으로 저장했습니다.

CJam 통역사 에서 온라인으로 사용해보십시오 (1 초 이내에 완료해야 함).

작동 원리

Xa       e# Push A := [1].
ri{      e# Read an integer from STDIN and do the following that many times:
  {      e# For each N in A:
    2*   e#     Push I := (N * 2) twice.
    _Cmd e#     Push (I / 12) and (I % 12).
     8=  e#     Push K := (I % 12 == 8).

         e#     (K == 1) if and only if the division ((N - 1) / 3) is exact and
         e#     yields an odd integer. In this case we can compute the quotient 
         e#     as (I / 12) * 2 + 1.

    *2*) e#     Push J := (I / 12) * K * 2 + 1.

         e#     This yields ((N - 1) / 3) when appropriate and 1 otherwise.
  }%     e# Replace N with I and J.
  1-     e# Remove all 1's from A.

         e# This serves three purposes:

         e# 1. Ones have been added as dummy values for inappropriate quotients.

         e# 2. Not allowing 1's in A avoids integers that have already stopped
         e#    from beginning a new cycle. Since looping around has been prevented,
         e#    A now contains all integers of a fixed stopping time.

         e# 3. If A does not contain duplicates, since the maps N -> I and N -> J
         e#      are inyective (exluding image 1) and yield integers of different
         e#      parities, the updated A won't contain duplicates either.

}*       e#
$p       e# print(sort(C))

CJam, 35 바이트

1]ri{_"(Z/Y*"3/m*:s:~\L+:L-_&0-}*$p

곧 설명하겠습니다. 이것은 "꽤 직설적 인"접근 방식보다 훨씬 빠른 버전입니다 (편집 기록에서 확인).

온라인 여기 시도 에 대해 N = 30어느에 즉시 온라인 버전에 초 단위로 실행되며 자바 컴파일러

자바 8, 123

x->java.util.stream.LongStream.range(1,(1<<x)+1).filter(i->{int n=0;for(;i>1;n++)i=i%2<1?i/2:3*i+1;return n==x;}).toArray()

때 x30 프로그램 15 분 29 초 정도 걸립니다.

넓히는

class Collatz {
    static IntFunction<long[]> f =
            x -> java.util.stream.LongStream.range(1, (1 << x) + 1).filter(i -> {
                int n = 0;
                for (; i > 1; n++)
                    i = i % 2 < 1 ? i / 2 : 3 * i + 1;
                return n == x;
            }).toArray();

    public static void main(String[] args) {
        System.out.println(Arrays.toString(f.apply(15)));
    }
}

파이썬 2, 118 바이트

글쎄, @ Sp3000의 솔루션을 본 후 최고의 Python 점수에 도달하지 못할 것이라고 생각했습니다. 그러나 그것은 재미있는 작은 문제처럼 보였으므로 어쨌든 독립적 인 솔루션을 시도하고 싶었습니다.

s={1}
for k in range(input()):
 p,s=s,set()
 for t in p:s.add(2*t);t>4and(t-1)%6==3and s.add((t-1)/3)
print sorted(s)

공백을 제거하기 전에 같은 것 :

s={1}
for k in range(input()):
    p,s=s,set()
    for t in p:
        s.add(2 * t)
        t > 4 and (t - 1) % 6 == 3 and s.add((t - 1) / 3)
print sorted(s)

이것은 광범위한 첫 번째 검색을 매우 직접 구현 한 것입니다. 각 단계에서는, 정지 시간과의 세트를 가지고 k, 시간 정지하여 세트를 도출 k + 1각 값의 가능한 추가하여 선행 t단계에서 집합하여 k:

• 2 * t 항상 전임자입니다.
• 경우 t로서 기록 될 수있다 3 * u + 1여기서 u되지 홀수 1후 u뿐만 아니라 선행된다.

N = 30MacBook Pro 에서 실행하는 데 약 0.02 초가 걸립니다 .

PHP 5.4+, 178 바이트

함수

function c($s,$v=1,$p=[],&$r=[]){$p[]=$v;if(!$s--){return$r[$v][]=$p;}c($s,$v*2,$p,$r);is_int($b=($v-1)/3)&!in_array($b,$p)&$b%2?c($s,$b,$p,$r):0;ksort($r);return array_keys($r);}

테스트 및 출력

echo "0 - ".implode(',',c(0)).PHP_EOL;
// 0 - 1
echo "1 - ".implode(',',c(1)).PHP_EOL;
// 1 - 2
echo "5 - ".implode(',',c(5)).PHP_EOL;
// 5 - 5,32
echo "9 - ".implode(',',c(9)).PHP_EOL;
// 9 - 12,13,80,84,85,512
echo "15 - ".implode(',',c(15)).PHP_EOL;
// 15 - 22,23,136,138,140,141,150,151,768,832,848,852,853,904,906,908,909,5120,5376,5440,5456,5460,5461,32768

S (30)은 0.24 초 * 안에 실행되며 732 개의 요소를 반환합니다. 부부는

86,87,89,520,522,524,525,528, [ ... ] ,178956928,178956960,178956968,178956970,1073741824

* 나는 추가했다 바이트에 저장하려면 ksort및 array_keys모든 단계에서. 내가 가진 유일한 다른 선택의 여지는 전화 작은 래퍼 함수를 만드는 것이 었습니다 c()다음 통화 array_keys및 ksort결과에 한 번. 그러나 여전히 시간이 너무 짧아서 낮은 바이트 수에 대한 성능 적중을 결정했습니다. 적절한 분류 및 처리가 없으면 시간은 0.07 초입니다. S (30)의 평균 입니다.

너무 많은 추가 바이트없이 한 번만 적절한 처리를 얻는 영리한 방법이 있다면 알려주십시오! (I는, 배열 키로의 따라서 사용이 내 번호를 저장 array_keys하고 ksort)

C 언어

#include <stdio.h>
#include <limits.h>    
const int s = 30;

bool f(long i)
{
    int r = 0;
    for(;;)
        if (i < 0 || r > s) return false;
        else if (i == 1) break;
        else{r ++;i = i % 2 ? 3*i + 1 : i/2;}
    return (r==s);
}

void main(){
    for(long i = 1; i < LONG_MAX; i++) if (f(i)) printf("%ld ", i);
}