Números intocáveis ^α

Um número intocável é um número inteiro positivo que não pode ser expresso como a soma de todos os divisores adequados de qualquer número inteiro positivo (incluindo o próprio número intocável).

Por exemplo, o número 4 não é intocável, pois é igual à soma dos divisores adequados de 9: 1 + 3 = 4. O número 5 é intocável, pois não é a soma dos divisores adequados de qualquer número inteiro positivo. 5 = 1 + 4 é a única maneira de escrever 5 como a soma de números inteiros positivos distintos, incluindo 1, mas se 4 divide um número, 2 também, então 1 + 4 não pode ser a soma de todos os divisores adequados de qualquer número (uma vez que a lista de fatores teria que conter 4 e 2).

Acredita-se que o número 5 seja o único número ímpar e intocável, mas isso não foi comprovado: seguiria uma versão um pouco mais forte da conjectura de Goldbach. ^β

Existem infinitos números intocáveis, fato comprovado por Paul Erdős.

Algumas propriedades de intocáveis:

• Intocável é 1 maior que um primo
• Nenhum intocável é 3 maior que um primo, exceto 5
• Nenhum intocável é um número perfeito
• Até agora, todos os intocáveis, além de 2 e 5, são compostos.

Objetivo

Crie um programa ou função que obtenha um número natural npor meio de parâmetros de entrada ou função padrão e imprima os primeiros nnúmeros intocáveis.

A saída deve ter separação entre os números, mas isso pode ser qualquer coisa (por exemplo, novas linhas, vírgulas, espaços, etc.).

Isso deve poder funcionar pelo menos 1 <= n <= 8153. Isso se baseia no fato de o arquivo b fornecido para a entrada OEIS ^γ subir n = 8153.

As brechas padrão não são permitidas, como de costume.

Exemplo de E / S

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

Isso é código-golfe , portanto, o menor número de bytes vence.

^{α - Wikipedia , β - MathWorld , γ - OEIS}

^{Por alguma razão, isso foi marcado como duplicado para a pergunta 'encontrar números semiperfeitos', no entanto, as tarefas são completamente diferentes. Nesse caso, você deve verificar se nenhuma soma dos divisores perfeitos de qualquer número natural pode ser igual a um determinado número.}

Pitão, 21 bytes

.f!fqZsf!%TYStTSh^Z2Q

Aviso: incrivelmente lento. Teste a execução e o tempo abaixo.

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

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

É basicamente a força bruta possível, testa as fatorações até o número solitário em potencial ao quadrado mais um.

C, 104 bytes

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));}

Levará alguns minutos para y > 20, mas tanto faz.

Java, 310 bytes

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;}}

Joguei o melhor que pude, mas estava mais interessado em garantir que funcionasse em tempo razoável. A versão não blindada é provavelmente mais interessante

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++;
            }
        }
    }
}

Go, 396 bytes

Não é realmente um jogador de golfe, mas pode fazer todo o intervalo necessário. É executado em aproximadamente 20min e precisa de aproximadamente 7GB (independente de n). Cria uma matriz gigante para calcular a soma dos divisores para todos os números de até 59997 ao quadrado.

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--
        }
    }
}