Các định nghĩa

Hãy để mvà nlà số nguyên dương. Chúng tôi nói rằng đó mlà một sự chia rẽ của nnếu có tồn tại các số nguyên 1 < a ≤ bnhư vậy n = a*bvà m = (a - 1)*(b + 1) + 1. Nếu mcó thể thu được từ nbằng cách áp dụng số 0 hoặc nhiều số chia cho nó, thì đó mlà hậu duệ của n. Lưu ý rằng mỗi số là con cháu riêng của nó.

Ví dụ, xem xét n = 16. Chúng ta có thể chọn a = 2và b = 8, kể từ đó 2*8 = 16. Sau đó

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

trong đó cho thấy đó 10là một sự chia rẽ của 16. Với a = 2và b = 5, sau đó chúng ta thấy đó 7là một sự chia rẽ của 10. Như vậy 7là một hậu duệ của 16.

Nhiệm vụ

Cho một số nguyên dương n, tính toán con cháu của n, được liệt kê theo thứ tự tăng dần, không trùng lặp.

Quy tắc

Bạn không được phép sử dụng các thao tác tích hợp để tính các ước của một số.

Cả hai chương trình và hàm đầy đủ đều được chấp nhận và trả về kiểu dữ liệu bộ sưu tập (như một bộ loại nào đó) được cho phép, miễn là nó được sắp xếp và không trùng lặp. Số byte thấp nhất sẽ thắng và các sơ hở tiêu chuẩn không được phép.

Các trường hợp thử nghiệm

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 byte

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

Vì (a-1)*(b+1)+1 == a*b-(b-a)và b >= a, con cháu luôn nhỏ hơn hoặc bằng số gốc. Vì vậy, chúng ta chỉ có thể bắt đầu với số ban đầu và tiếp tục tạo ra các hậu duệ nhỏ hơn cho đến khi không còn lại.

Điều kiện (n<x*x)>n%xkiểm tra hai điều trong một - đó n<x*xvà n%x == 0.

(Cảm ơn @xnor vì đã lấy 3 byte khỏi trường hợp cơ sở)

Bình thường, 32 byte

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

Bản dịch trực tiếp ở trên, ngoại trừ thực tế là Pyth dường như bị nghẹt thở khi cố gắng tổng hợp ( s) trong một danh sách trống.

Điều này xác định một chức năng ycó thể được gọi bằng cách nối thêm y<number>vào cuối, như vậy ( thử trực tuyến ):

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

CJam, 47 45 byte

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

Cũng sử dụng cùng một phương pháp, với một vài sửa đổi. Tôi muốn thử dùng CJam để so sánh, nhưng thật không may, tôi kém hơn ở CJam so với tôi ở Pyth / Python, vì vậy có lẽ có rất nhiều chỗ để cải thiện.

Trên đây là một khối (về cơ bản là phiên bản của các hàm không tên của CJam) nhận một int và trả về một danh sách. Bạn có thể kiểm tra nó như vậy ( thử trực tuyến ):

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

Java, 148 146 104 byte

Phiên bản chơi gôn:

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

Phiên bản dài:

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

Vì vậy, tôi sẽ ra mắt trên PPCG với chương trình này, sử dụng một TreeSet(tự động sắp xếp các số, rất may) và đệ quy tương tự như chương trình của Geobits, nhưng theo một cách khác, kiểm tra bội số của n và sau đó sử dụng chúng trong chức năng tiếp theo. Tôi muốn nói rằng đây là một số điểm khá công bằng cho lần đầu tiên (đặc biệt là với Java, dường như không phải là ngôn ngữ lý tưởng nhất cho loại điều này và sự giúp đỡ của Geobits).

Java, 157 121

Đây là một hàm đệ quy có được hậu duệ của mỗi hậu duệ n. Nó trả về một TreeSet, được sắp xếp theo mặc định.

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

Với một số ngắt dòng:

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

Tháng Mười, 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

In đẹp

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 byte

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]

Cách sử dụng: p 16đầu ra nào[7,10,16]

Hàm dtính toán đệ quy tất cả các hậu duệ, nhưng không kiểm tra trùng lặp, vì vậy nhiều xuất hiện nhiều lần, ví dụ d [4]trả về một danh sách vô hạn của 4s. Các hàm plấy các nphần tử đầu tiên từ danh sách này, loại bỏ trùng lặp và sắp xếp danh sách. Võngà.

CJam - 36

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

Dùng thử trực tuyến

Hoặc, phương pháp khác nhau:

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

Tôi đã viết chúng gần 2 ngày trước, bị kẹt ở tuổi 36, thất vọng và đi ngủ mà không đăng bài.