만질 수없는 숫자 ^α

건드리지 않는 숫자는 양의 정수 (터치 할 수없는 숫자 자체 포함)의 모든 적절한 제수의 합으로 표현할 수없는 양의 정수입니다.

예를 들어, 숫자 4는 9 : 1 + 3 = 4의 적절한 제수의 합과 같으므로 건드리지 않습니다. 숫자 5는 양의 정수의 적절한 제수의 합이 아니므로 만질 수 없습니다. 5 = 1 + 4는 1을 포함하여 구별되는 양의 정수의 합으로 5를 쓰는 유일한 방법이지만, 4가 숫자를 나누면 2도 마찬가지이므로 1 + 4는 모든 숫자의 적절한 제수의 합계가 될 수 없습니다. 요인 목록에는 4와 2가 모두 포함되어야합니다.

숫자 5는 만질 수없는 유일한 홀수 인 것으로 여겨지지만 이것은 입증되지 않았습니다. 약간 더 강한 버전의 Goldbach 추측에서 나옵니다. ^β

Paul Erdős에 의해 입증 된 사실은 만질 수없는 수많은 숫자가 있습니다.

언터처블의 몇 가지 속성 :

• 만질 수없는 것은 소수보다 1이 크다
• 만질 수없는 것은 소수보다 3이 크지 않습니다.
• 만질 수없는 것은 완벽한 숫자입니다
• 지금까지 2와 5를 제외한 모든 손길이 닿지 않는 것은 합성입니다.

객관적인

표준 입력 또는 기능 매개 변수 를 통해 자연수 를 사용 하고 만질 수없는 첫 번째 숫자를 인쇄 하는 프로그램 또는 기능 을 작성하십시오 .nn

출력은 숫자 사이에 분리가 있어야하지만 이것은 개행, 쉼표, 공백 등일 수 있습니다.

이것은 적어도 작동 할 수 있어야합니다 1 <= n <= 8153. 이것은 B-파일이 OEIS 항목에 대해 제공한다는 사실을 기반으로 ^γ 까지 간다 n = 8153.

평상시와 같이 표준 허점은 허용되지 않습니다.

예제 I / O

1    -> 2
2    -> 2, 5
4    -> 2, 5, 52, 88
10   -> 2, 5, 52, 88, 96, 120, 124, 146, 162, 188
8153 -> 2, 5, 52, 88, 96, 120, ..., ..., ..., 59996

이것은 코드 골프따라서 바이트 수가 가장 적습니다.

^{α- 위키 백과 , β- MathWorld , γ- OEIS}

^{어떤 이유로 이것은 '완벽 준결승 찾기'질문과 중복되는 것으로 표시되었지만 과제는 완전히 다릅니다. 이 경우, 자연수의 완벽한 제수의 합이 특정 숫자와 같지 않아야합니다.}

Pyth, 21 바이트

.f!fqZsf!%TYStTSh^Z2Q

경고 : 매우 느립니다. 아래의 테스트 실행 및 타이밍.

$ time pyth -c '.f!fqZsf!%TYStTSh^Z2Q' <<< 3
[2, 5, 52]

real    2m46.463s
user    2m46.579s
sys 0m0.004s

그것은 기본적으로 가능한 한 무차별적인 힘이며, 가능한 외로운 수의 제곱에 1을 더한 인수 분해를 테스트합니다.

C, 104 바이트

j,i,z,w;u(y){for(z=2;y;z++)for(w=0;(++w<z*z||0&printf("%i ",z)+y--)&&j^z;)for(i=j=0;++i<w;j+=i*!(w%i));}

y > 20의 경우 몇 분이 걸리지 만 무엇이든됩니다.

자바, 310 바이트

class U{int[] p;U(int e){p=new int[(int)4e9];for(int i=1,c=0;c<e;i++)if(u(i)>0){System.out.println(i);c++;}}int p(int n){if(p[n]!=0)return p[n];int i,s=1;for(i=2;i<=n-1;i++)s+=n%i==0?i+(n/i!=i?n/i:0):0;return(p[n]=s);}int u(int n){if(n==1)return 0;for(int i=2;i<=(n-1)*(n-1);i++)if(p(i)==n)return 0;return 1;}}

골프는 물론 할 수 있었지만 합리적인 시간에 달리는 데 더 관심이있었습니다. 언 글로벌 버전은 아마도 더 흥미로울 것입니다

public class Untouchable {
    int[] properDivisorSumMap;


    public Untouchable(int estimatedMaxium){
        properDivisorSumMap = new int[(estimatedMaxium-1)*(estimatedMaxium-1)];
    }


    public int properDivisorSum(int n){
        if(properDivisorSumMap[n] != 0){
            return properDivisorSumMap[n];
        }

        int sum = 1;
        for(int i=2;i<=(int)Math.sqrt(n);i++){
            if(n%i==0){
                sum+=i;
                if(n/i != i){
                    sum+=n/i;
                }
            }
        }
        properDivisorSumMap[n] = sum;
        return sum;
    }


    public boolean untouchable(int n){
        if(n==1){
            return false;
        }
        for(int i=2;i<=(n-1)*(n-1);i++){
            if(properDivisorSum(i) == n){
                return false;
            }
        } 
        return true;
    }


    public static void main(String[] args){
        Untouchable test = new Untouchable(8480);

        int elements = Integer.parseInt(args[0]);

        for(int i=1,count=0;count < elements;i++){
            if(test.untouchable(i)){
                System.out.printf("%4d: %4d%n",count,i);
                count++;
            }
        }
    }
}

396 바이트

실제로 골프는 아니지만 필요한 모든 범위를 수행 할 수 있습니다. 약 20 분 안에 실행되며 ~ 7GB가 필요합니다 (n과 상관 없음). 최대 59997 제곱까지의 모든 수에 대한 제수의 합을 계산하는 거대한 배열을 만듭니다.

func untouchable(n int) {
    const C = 59997
    const N = C * C
    s := make([]uint16, N)
    for d := 1; d < N; d++ {
        for i := 2 * d; i < N; i += d {
            v := int(s[i]) + d
            if v > C {
                v = C + 1 // saturate at C+1
            }
            s[i] = uint16(v)
        }
    }
    var m [C]bool
    for i := 2; i < N; i++ {
        if s[i] < C {
            m[s[i]] = true
        }
    }
    for i := 2; n > 0; i++ {
        if !m[i] {
            println(i)
            n--
        }
    }
}