Definições

Let mE nSer inteiros positivos. Dizemos que mé uma torção divisora de nse existem números inteiros, 1 < a ≤ btais que n = a*be m = (a - 1)*(b + 1) + 1. Se mpode ser obtido naplicando zero ou mais torções divisórias a ele, então mé um descendente de n. Observe que todo número é seu próprio descendente.

Por exemplo, considere n = 16. Nós podemos escolher a = 2e b = 8, desde então 2*8 = 16. Então

(a - 1)*(b + 1) + 1 = 1*9 + 1 = 10

o que mostra que 10é uma torção divisória de 16. Com a = 2e b = 5, vemos então que 7é uma torção divisória de 10. Assim 7é um descendente de 16.

A tarefa

Dado um número inteiro positivo n, calcule os descendentes de n, listados em ordem crescente, sem duplicatas.

Regras

Você não tem permissão para usar operações internas que computam os divisores de um número.

Programas e funções completos são aceitos e o retorno de um tipo de dados de coleção (como um conjunto de algum tipo) é permitido, desde que seja classificado e sem duplicação. A contagem de bytes mais baixa vence e as brechas padrão não são permitidas.

Casos de teste

1 ->  [1]
2 ->  [2] (any prime number returns just itself)
4 ->  [4]
16 -> [7, 10, 16]
28 -> [7, 10, 16, 25, 28]
51 -> [37, 51]
60 -> [7, 10, 11, 13, 15, 16, 17, 18, 23, 25, 28, 29, 30, 32, 43, 46, 49, 53, 55, 56, 60]

Python 2, 109 98 85 82 bytes

f=lambda n:sorted(set(sum(map(f,{n-x+n/x for x in range(2,n)if(n<x*x)>n%x}),[n])))

Desde (a-1)*(b+1)+1 == a*b-(b-a)e b >= a, os descendentes são sempre menores ou iguais ao número original. Assim, podemos começar com o número inicial e continuar gerando descendentes estritamente menores até que não haja mais nenhum.

A condição (n<x*x)>n%xverifica duas coisas em uma - que n<x*xe n%x == 0.

(Agradecemos a @xnor por remover 3 bytes do gabinete base)

Pitão, 32 bytes

LS{s+]]bmydm+-bk/bkf><b*TT%bTr2b

Tradução direta do exposto acima, exceto pelo fato de Pyth parecer engasgar ao tentar somar ( s) em uma lista vazia.

Isso define uma função yque pode ser chamada anexando y<number>no final, assim ( tente online ):

LS{s+]]bmydm+-bk/bkf><b*TT%bTr2by60

CJam, 47 45 bytes

{{:X_,2>{__*X>X@%>},{_X\/\-X+}%{F}%~}:F~]_&$}

Também usando o mesmo método, com algumas modificações. Eu queria experimentar o CJam para comparação, mas infelizmente sou muito pior no CJam do que no Pyth / Python, então provavelmente há muito espaço para melhorias.

O acima é um bloco (basicamente a versão do CJam de funções sem nome) que recebe um int e retorna uma lista. Você pode testá-lo assim ( tente on-line ):

{{:X_,2>{__*X>X@%>},{_X\/\-X+}%{F}%~}:F~]_&$}:G; 60 Gp

Java, 148 146 104 bytes

Versão Golfed:

import java.util.*;Set s=new TreeSet();void f(int n){s.add(n);for(int a=1;++a*a<n;)if(n%a<1)f(n+a-n/a);}

Versão longa:

import java.util.*;
Set s = new TreeSet();
void f(int n) {
    s.add(n);
    for (int a = 1; ++a*a < n;)
        if (n%a < 1)
            f(n + a - n/a);
}

Então, eu estou fazendo minha estréia no PPCG com este programa, que usa a TreeSet(que classifica automaticamente os números, felizmente) e recursão semelhante ao programa do Geobits, mas de uma maneira diferente, verificando múltiplos de n e depois usá-los no próxima função. Eu diria que essa é uma pontuação bastante justa para quem está iniciando (especialmente com Java, que não parece ser a linguagem ideal para esse tipo de coisa, e a ajuda do Geobits).

Java, 157 121

Aqui está uma função recursiva que obtém descendentes de cada descendente de n. Retorna a TreeSet, que é classificado por padrão.

import java.util.*;Set t(int n){Set o=new TreeSet();for(int i=1;++i*i<n;)o.addAll(n%i<1?t(n+i-n/i):o);o.add(n);return o;}

Com algumas quebras de linha:

import java.util.*;
Set t(int n){
    Set o=new TreeSet();
    for(int i=1;++i*i<n;)
        o.addAll(n%i<1?t(n+i-n/i):o);
    o.add(n);
    return o;
}

Oitava, 107 96

function r=d(n)r=[n];a=find(!mod(n,2:sqrt(n-1)))+1;for(m=(a+n-n./a))r=unique([d(m) r]);end;end

Pretty-print:

function r=d(n)
  r=[n];                          # include N in our list
  a=find(!mod(n,2:sqrt(n-1)))+1;  # gets a list of factors of a, up to (not including) sqrt(N)
  for(m=(a+n-n./a))               # each element of m is a twist
    r=unique([d(m) r]);           # recurse, sort, and find unique values
  end;
end

Haskell, 102 100 bytes

import Data.List
d[]=[]
d(h:t)=h:d(t++[a*b-b+a|b<-[2..h],a<-[2..b],a*b==h])
p n=sort$nub$take n$d[n]

Uso: p 16quais saídas[7,10,16]

A função dcalcula recursivamente todos os descendentes, mas não verifica se há duplicatas; muitas aparecem mais de uma vez; por exemplo, d [4]retorna uma lista infinita de 4s. As funções pobtêm os primeiros nelementos dessa lista, remove duplicatas e classificam a lista. Voilà.

CJam - 36

ri_a\{_{:N,2>{NNImd!\I-z*-}fI}%|}*$p

Experimente online

Ou, método diferente:

ri_a\{_{_,2f#_2$4*f-&:mq:if-~}%|}*$p

Escrevi-os há quase 2 dias, fiquei preso aos 36 anos, fiquei frustrado e fui dormir sem postar.