Hàm của bạn lấy một số tự nhiên và trả về số tự nhiên nhỏ nhất có chính xác số lượng ước đó, bao gồm cả chính nó.

Ví dụ:

f(1) =  1 [1]
f(2) =  2 [1, 2]
f(3) =  4 [1, 2, 4]
f(4) =  6 [1, 2, 3, 6]
f(5) = 16 [1, 2, 4, 8, 16]
f(6) = 12 [1, 2, 3, 4, 6, 12]
 ...

Hàm không phải trả về danh sách các ước, chúng chỉ ở đây để lấy ví dụ.

APL, 25 24 23 ký tự

f←{({+/⍵=⍵∧⍳⍵}¨⍳2*⍵)⍳⍵}

Xác định một hàm fmà sau đó có thể được sử dụng để tính các số:

> f 13
4096

> f 14
192

Giải pháp sử dụng thực tế là LCM (n, x) == n iff x chia n . Do đó, khối {+/⍵=⍵∧⍳⍵}chỉ đơn giản là tính toán số lượng ước. Hàm này được áp dụng cho tất cả các số từ 1 đến 2 ^ d ¨⍳2*⍵ . Sau đó, danh sách kết quả được tìm kiếm cho chính d ( ⍳⍵) là hàm mong muốn f (d) .

GolfScript, 29 28 ký tự

{.{\.,{)1$\%},,-=}+2@?,?}:f;

Chỉnh sửa: Một char duy nhất có thể được lưu nếu chúng tôi giới hạn tìm kiếm ở <2 ^ n, nhờ Peter Taylor cho ý tưởng này.

Phiên bản trước:

{.{\)..,{)1$\%},,-@=!}+do}:f;

Một nỗ lực trong GolfScript, chạy trực tuyến .

Ví dụ:

13 f p  # => 4096
14 f p  # => 192
15 f p  # => 144

Mã này về cơ bản chứa ba khối được giải thích chi tiết trong các dòng sau.

# Calculate numbers of divisors
#         .,{)1$\%},,-    
# Input stack: n
# After application: D(n)

.,          # push array [0 .. n-1] to stack
{           # filter array by function
  )         #   take array element and increase by one
  1$\%      #   test division of n ($1) by this value
},          # -> List of numbers x where n is NOT divisible by x+1
,           # count these numbers. Stack now is n xd(n)
-           # subtracting from n yields the result



# Test if number of divisors D(n) is equal to d
#         {\D=}+   , for D see above
# Input stack: n d
# After application: D(n)==d

{
  \         # swap stack -> d n
  D         # calculate D(n) -> d D(n)
  =         # compare
}+          # consumes d from stack and prepends it to code block         



# Search for the first number which D(n) is equal to d
#         .T2@?,?    , for T see above
# Input stack: d
# After application: f(d)

.           # duplicate -> d d
T           # push code block (!) for T(n,d) -> d T(n,d)
2@?         # swap and calculate 2^d -> T(n,d) 2^d
,           # make array -> T(n,d) [0 .. 2^d-1]
?           # search first element in array where T(n,d) is true -> f(d)

Con trăn: 64

Sửa đổi giải pháp của Bakuriu và kết hợp đề xuất của grc cũng như mẹo từ giải pháp R của plannapus, chúng tôi nhận được:

f=lambda n,k=1:n-sum(k%i<1for i in range(1,k+1))and f(n,k+1)or k

Con trăn: 66

f=lambda n,k=1:n==sum(k%i<1for i in range(1,k+1))and k or f(n,k+1)

Ở trên sẽ đưa ra một RuntimeError: maximum recursion depth exceededđầu vào nhỏ trong CPython, và thậm chí đặt giới hạn cho một số lượng lớn, nó có thể sẽ đưa ra một số vấn đề. Trên các triển khai python tối ưu hóa đệ quy đuôi, nó sẽ hoạt động tốt.

Một phiên bản dài hơn, không nên có những hạn chế như vậy, là giải pháp 79 byte sau đây :

def f(n,k=1):
    while 1:
        if sum(k%i<1for i in range(1,k+1))==n:return k
        k+=1

Toán học 38 36

(For[i=1,DivisorSum[++i,1&]!=#,];i)&

Sử dụng:

(For[i=1,DivisorSum[++i,1&]!=#,];i)&@200

Kết quả:

498960

Biên tập

Một số giải thích:

DivisorSum [n, mẫu] đại diện cho tổng mẫu [i] cho tất cả i chia n.

Khi form[i]tôi đang sử dụng hàm 1 &, nó luôn trả về 1, vì vậy tính toán hiệu quả tổng của các ước số một cách ngắn gọn.

J, 33 ký tự

Khá nhanh chóng, đi qua tất cả các số nhỏ hơn và tính toán số lượng ước tính dựa trên hệ số.

   f=.>:@]^:([~:[:*/[:>:_&q:@])^:_&1

   f 19
262144

Haskell 54

Giải pháp nhanh chóng và bẩn (rất dễ đọc và không khó khăn):

f k=head[x|x<-[k..],length[y|y<-[1..x],mod x y==0]==k]

K, 42

Giải pháp đệ quy không hiệu quả làm nổ tung stack khá dễ dàng

{{$[x=+/a=_a:y%!1+y;y;.z.s[x;1+y]]}[x;0]} 

.

k){{$[x=+/a=_a:y%!1+y;y;.z.s[x;1+y]]}[x;0]}14
192
k){{$[x=+/a=_a:y%!1+y;y;.z.s[x;1+y]]}[x;0]}13
'stack

APL 33

F n            
i←0              
l:i←i+1          
→(n≠+/0=(⍳i)|i)/l
i 

Thí dụ:

F 6
12           

APL (25)

{⍵{⍺=+/0=⍵|⍨⍳⍵:⍵⋄⍺∇⍵+1}1}

R - 47 ký tự

f=function(N){n=1;while(N-sum(!n%%1:n))n=n+1;n}

!n%%1:nđưa ra một vectơ booleans: TRUE khi một số nguyên từ 1 đến n là ước của n và FALSE nếu không. sum(!n%%1:n)ép booleans thành 0 nếu FALSE và 1 nếu TRUE và tính tổng của chúng, vì vậy đó N-sum(...)là 0 khi số lượng ước là N. 0 sau đó được hiểu là FALSE bởiwhile sau đó dừng lại.

Sử dụng:

f(6)
[1] 12
f(13)
[1] 4096

Javascript 70

function f(N){for(j=i=m=1;m-N||j-i;j>i?i+=m=j=1:m+=!(i%++j));return i}

Thực sự chỉ có 46 nhân vật có ý nghĩa:

for(j=i=m=1;m-N||j-i;j>i?i+=m=j=1:m+=!(i%++j))

Tôi có lẽ nên học một ngôn ngữ với cú pháp ngắn hơn :)

Haskell: 49 ký tự

Nó có thể được coi là một cải tiến của giải pháp Haskell trước đó, nhưng nó được hình thành theo đúng nghĩa của nó (cảnh báo: nó rất chậm):

f n=until(\i->n==sum[1|j<-[1..i],rem i j<1])(+1)1

Đây là một hàm khá thú vị, ví dụ lưu ý rằng f (p) = 2 ^ (p-1), trong đó p là số nguyên tố.

C: 66 64 ký tự

Một giải pháp gần như ngắn:

i;f(n){while(n-g(++i));return i;}g(j){return j?!(i%j)+g(j-1):0;}

Và giải pháp trước đây của tôi không tái diễn:

i;j;k;f(n){while(k-n&&++i)for(k=0,j=1;j<=i;k+=!(i%j++));return i;}

Các giải pháp ngắn hơn nhiều phải tồn tại.

Haskell (120C), một phương pháp rất hiệu quả

1<>p=[]
x<>p|mod x p>0=x<>(p+1)|1<2=(div x p<>p)++[p]
f k=product[p^(c-1)|(p,c)<-zip[r|r<-[2..k],2>length(r<>2)](k<>2)]

Mã kiểm tra:

main=do putStrLn$show$ f (100000::Integer)

Phương pháp này rất nhanh. Ý tưởng đầu tiên là tìm các thừa số nguyên tố của k=p1*p2*...*pm, trong đó p1 <= p2 <= ... <= pm. Sau đó, câu trả lời là n = 2^(pm-1) * 3^(p(m-1)-1) * 5^(p(m-2)-1) ....

Ví dụ: hệ số k = 18, ta được 18 = 2 * 3 * 3. 3 số nguyên tố đầu tiên là 2, 3, 5. Vì vậy, câu trả lời n = 2 ^ (3-1) * 3 ^ (3-1) * 5 ^ (2-1) = 4 * 9 * 5 = 180

Bạn có thể kiểm tra nó dưới ghci:

*Main> f 18
180
*Main> f 10000000
1740652905587144828469399739530000
*Main> f 1000000000
1302303070391975081724526582139502123033432810000
*Main> f 100000000000
25958180173643524088357042948368704203923121762667635047013610000
*Main> f 10000000000000
6558313786906640112489895663139340360110815128467528032775795115280724604138270000
*Main> f 1000000000000000
7348810968806203597063900192838925279090695601493714327649576583670128003853133061160889908724790000
*Main> f 100000000000000000
71188706857499485011467278407770542735616855123676504522039680180114830719677927305683781590828722891087523475746870000
*Main> f 10000000000000000000
2798178979166951451842528148175504903754628434958803670791683781551387366333345375422961774196997331643554372758635346791935929536819490000
*Main> f 10000000000000000000000
6628041919424064609742258499702994184911680129293140595567200404379028498804621325505764043845346230598649786731543414049417584746693323667614171464476224652223383190000

Brachylog , 2 byte

fl

Hãy thử trực tuyến!

Đưa đầu vào thông qua biến đầu ra và đầu ra thông qua biến đầu vào.

f     The list of factors of
      the input variable
 l    has length equal to
      the output variable.

Chính xác vị từ này, lấy đầu vào thông qua biến đầu vào của nó và xuất ra thông qua biến đầu ra của nó, thay vào đó giải quyết thách thức này .

C, 69 ký tự

Không phải là ngắn nhất, nhưng câu trả lời C đầu tiên:

f(n,s){return--s?f(n,s)+!(n%s):1;}
x;
g(d){return++x,f(x,x)-d&&g(d),x;}

f(n,s)đếm các ước của ntrong phạm vi 1..s. Vì vậy, f(n,n)tính các ước của n.
g(d)các vòng lặp (bằng cách đệ quy) cho đến khi f(x,x)==dtrả về x.

Toán học 38 36

(For[k=1,DivisorSigma[0, k]!= #,k++]; k)&

Sử dụng

   (For[k = 1, DivisorSigma[0, k] != #, k++]; k) &[7]

(* 64 *)

Mục đầu tiên (trước khi code-golfthẻ được thêm vào câu hỏi.)

Một vấn đề đơn giản, được đưa ra là Divisors[n]trả về các ước của n(bao gồm n) và Length[Divisors[n]]trả về số lượng các ước đó. **

smallestNumber[nDivisors_] :=
   Module[{k = 1},
   While[Length[Divisors[k]] != nDivisors, k++];k]

Ví dụ

Table[{i, nDivisors[i]}, {i, 1, 20}] // Grid

Jelly , 6 byte (không cạnh tranh)

2*RÆdi

Hãy thử trực tuyến!hoặc xác minh tất cả các trường hợp thử nghiệm .

Làm thế nào nó hoạt động

2*RÆdi  Main link. Argument: n (integer)

2*      Compute 2**n.
  R     Range; yield [1, ..., 2**n]. Note that 2**(n-1) has n divisors, so this
        range contains the number we are searching for.
   Æd   Divisor count; compute the number of divisors of each integer in the range.
     i  Index; return the first (1-based) index of n.

C ++, 87 ký tự

int a(int d){int k=0,r,i;for(;r!=d;k++)for(i=2,r=1;i<=k;i++)if(!(k%i))r++;return k-1;}

Python2, 95 ký tự, Không đệ quy

Một chút dài dòng hơn các giải pháp python khác nhưng nó không đệ quy nên nó không đạt giới hạn đệ quy của cpython:

from itertools import*
f=lambda n:next(i for i in count()if sum(1>i%(j+1)for j in range(i))==n)

Perl 6 , 39 ký tự

{my \a=$=0;a++while $_-[+] a X%%1..a;a}

Ví dụ sử dụng:

say (0..10).map: {my \a=$=0;a++while $_-[+] a X%%1..a;a}

(0 1 2 4 6 16 12 64 24 36 48)