Визначення

Нехай mі nбудуть натуральними числами. Ми говоримо , що mє дільником твіст з , nякщо існує цілих чисел , 1 < a ≤ bтаких , що n = a*bі m = (a - 1)*(b + 1) + 1. Якщо mможе бути отримана з nзастосовуючи нуль або більше подільники завихрення до нього, то mє нащадок з n. Зауважте, що кожне число - це власний нащадок.

Наприклад, розглянемо n = 16. Ми можемо вибрати a = 2і b = 8, так як 2*8 = 16. Потім

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

що показує, що 10це ділення повороту 16. З a = 2і b = 5, потім ми бачимо, що 7це перекрут дільника 10. Таким чином 7є нащадком Росії 16.

Завдання

Давши додатне ціле число n, обчисліть нащадків n, перелічених у порядку зростання, без дублів.

Правила

Вам заборонено використовувати вбудовані операції, які обчислюють дільники числа.

Приймаються як повні програми, так і функції, і повернення типу даних колекції (як-от набір певного типу) дозволено, якщо воно відсортовано і не дублює. Виграє найменший байт, а стандартні лазівки заборонені.

Випробування

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 байт

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])))

Оскільки (a-1)*(b+1)+1 == a*b-(b-a)і b >= aнащадки, завжди менше або дорівнює початковому числу. Тож ми можемо просто почати з початкового числа і продовжувати генерувати суворо менші нащадки, поки не залишиться жодного.

Умова (n<x*x)>n%xперевіряє дві речі в одному - те n<x*xі n%x == 0.

(Дякуємо @xnor за те, що він зняв 3 байти з базового корпусу)

Pyth, 32 байти

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

Прямий переклад вищезазначеного, за винятком того, що, здається, Pyth задихається, намагаючись підвести суму ( s) до порожнього списку.

Це визначає функцію, yяку можна викликати, додавши y<number>в кінці, як-от так ( спробуйте в Інтернеті ):

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

CJam, 47 45 байт

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

Також використовуючи той самий метод, з кількома модифікаціями. Я хотів спробувати CJam для порівняння, але, на жаль, у CJam я набагато гірший, ніж у Pyth / Python, тому, мабуть, є багато можливостей для вдосконалення.

Вищевказане - це блок (в основному версія неназваних функцій CJam), який приймає int і повертає список. Ви можете перевірити його так ( спробуйте в Інтернеті ):

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

Java, 148 146 104 байт

Версія для гольфу:

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

Довга версія:

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

Тож я дебютував на PPCG з цією програмою, яка використовує TreeSet(яка автоматично сортує числа, на щастя) та рекурсії, подібні до програми Geobits, але по-іншому, перевіряючи кратність n і потім використовуючи їх у наступна функція. Я б сказав, що це досить справедливий бал для першокласника (особливо для Java, який, здається, не є найбільш ідеальною мовою для подібних речей, і допомога Geobits).

Ява, 157 121

Ось рекурсивна функція, яку отримують нащадки кожного нащадка n. Він повертає a TreeSet, який сортується за замовчуванням.

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

З деякими перервами рядків:

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

Октава, 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

Симпатичний друк:

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 байт

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]

Використання: p 16які виходи[7,10,16]

Функція dрекурсивно обчислює всіх нащадків, але не перевіряє наявність дублікатів, тому багато хто з’являється не один раз, наприклад d [4]повертає нескінченний список 4s. Функції pприймають перші nелементи з цього списку, видаляє дублікати та сортує список. Voilà.

CJam - 36

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

Спробуйте в Інтернеті

Або інший метод:

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

Я написав їх майже 2 дні тому, застряг у 36, засмутився і лягав спати, не публікуючи повідомлення.