Cho một số nguyên N , đếm có bao nhiêu cách nó có thể được biểu thị dưới dạng tích của M số nguyên> 1.

Input chỉ đơn giản là N và M , và đầu ra là tổng số các biệt nhóm số nguyên. Có nghĩa là bạn có thể sử dụng một số nguyên nhiều lần, nhưng mỗi nhóm phải khác biệt ( 3 x 2 x 2sẽ không được tính nếu 2 x 2 x 3có).

Những ràng buộc

1 < N <2 ³¹
1 < M <30

Ví dụ

Đầu vào 30 2cho đầu ra 3, vì nó có thể được thể hiện theo 3 cách:

2 x 15
3 x 10
5 x 6

Đầu vào 16 3cho đầu ra 1, vì chỉ có một nhóm riêng biệt:

2 x 2 x 4

Đầu vào 2310 4cho đầu ra 10:

5 x 6 x 7 x 11
3 x 7 x 10 x 11
3 x 5 x 11 x 14
3 x 5 x 7 x 22
2 x 7 x 11 x 15
2 x 5 x 11 x 21
2 x 5 x 7 x 33
2 x 3 x 11 x 35
2 x 3 x 7 x 55
2 x 3 x 5 x 77

Đầu vào 15 4cho đầu ra 0, vì nó không thể được thực hiện.

Quy tắc

Các lỗ hổng golf mã tiêu chuẩn được áp dụng, cùng với các định nghĩa tiêu chuẩn cho đầu vào / đầu ra. Câu trả lời có thể là một chức năng hoặc chương trình đầy đủ. Các chức năng tích hợp cho nhân tố hóa và / hoặc phân vùng không được phép, nhưng các chức năng khác vẫn ổn. Mã được tính bằng byte.

Pyth - 24 23 22 21 byte

Không phải là một giải pháp phức tạp. Sẽ được chơi golf nhiều hơn. Chỉ cần có sản phẩm cartesian của danh sách và bộ lọc. Chiến lược tương tự như @optimizer (Tôi đoán là do nhận xét của anh ấy, thực tế không giải mã được rằng CJam) Cảm ơn @FryAmTheEggman cho 2 byte và lừa với M.

Ml{m`Sdfqu*GHT1G^r2GH

Xác định hàm gvới args GvàH

M                    function definition of g with args G and H
 l                   length of
  {                  set (eliminates duplicates)
   m                 map
    `Sd              repr of sorted factors so can run set (on bash escape ` as \`)
    f                filter
     q      G        equals first arg
      u*GHT1         reduce by multiplication
     ^     H         cartesian product by repeat second arg
       r2G           range 2 to first arg

Đã làm việc trên tất cả các đối số thử nghiệm ngoại trừ cuối cùng, quá chậm trên cái đó nhưng không có giới hạn thời gian nhất định.

Con trăn 3, 59

f=lambda N,M,i=2:i<=N and f(N/i,M-1,i)+f(N,M,i+1)or-~M==N<2

Chúng tôi đếm các ước số tiềm năng i. Với đối số bổ sung ilà ước số thấp nhất được phép, mối quan hệ đệ quy cốt lõi là

f(N,M,i)=f(N/i,M-1,i)+f(N,M,i+1)

Đối với mỗi i, chúng tôi hoặc chọn bao gồm nó (có thể là lặp lại), trong trường hợp đó chúng tôi chia sản phẩm cần thiết Ncho ivà giảm dần M. Nếu không, chúng tôi sẽ tăng thêm i1, nhưng chỉ khi i<N, vì không sử dụng kiểm tra ước số lớn hơn N.

Khi ước số tối thiểu ivượt quá N, sẽ không còn ước số tiềm năng nào nữa. Vì vậy, chúng tôi kiểm tra xem chúng tôi đã thành công hay chưa bằng cách xem M==0 and N==1, hoặc, tương đương, M+1==N==1hoặc M+1==N<2từ khi nào M+1==N, giá trị lẫn nhau được đảm bảo là một số nguyên dương (nhờ FryAmTheEggman cho tối ưu hóa này).

Mã này sẽ gây ra lỗi tràn ngăn xếp cho Nkhoảng 1000 trên hầu hết các hệ thống, nhưng bạn có thể chạy nó trong Stackless Python để tránh điều này. Hơn nữa, nó cực kỳ chậm vì phân nhánh đệ quy theo cấp số nhân của nó.

Ruby, 67

f=->n,m,s=2,r=0{m<2?1:s.upto(n**0.5){|d|n%d<1&&r+=f[n/d,m-1,d]}&&r}

Thực sự hợp lý hiệu quả cho một định nghĩa đệ quy. Đối với mỗi cặp số chia [d,q]của n, với dsố nhỏ hơn, chúng ta tổng hợp kết quả của f[q,m-1]. Phần khó khăn là trong các cuộc gọi bên trong, chúng tôi giới hạn các yếu tố với các yếu tố lớn hơn hoặc bằng d để chúng tôi không kết thúc việc tính hai lần.

1.9.3-p327 :002 > f[30,2]
 => 3 
1.9.3-p327 :003 > f[2310,4]
 => 10 
1.9.3-p327 :004 > f[15,4]
 => 0 
1.9.3-p327 :005 > f[9,2]
 => 1 

CJam, 48 byte

Điều này có thể ngắn hơn rất nhiều nhưng tôi đã thêm một số kiểm tra để làm cho nó hoạt động với số lượng khá Mtrên trình biên dịch trực tuyến.

q~\:N),2>{N\%!},a*{_,2/)<m*{(+$}%}*{1a+:*N=},_&,

Dùng thử trực tuyến tại đây

T-SQL 456 373

Tôi chắc chắn rằng điều này sẽ phá vỡ khi đầu vào thậm chí gần lớn.

Cảm ơn @MickyT đã giúp lưu rất nhiều ký tự với CONCAT và CHỌN thay vì nhiều BỘ.

CREATE PROC Q(@N INT,@M INT)AS
DECLARE @ INT=2,@C VARCHAR(MAX)='SELECT COUNT(*)FROM # A1',@D VARCHAR(MAX)=' WHERE A1.A',@E VARCHAR(MAX)=''CREATE TABLE #(A INT)WHILE @<@N
BEGIN
INSERT INTO # VALUES(@)SET @+=1
END
SET @=1
WHILE @<@M
BEGIN
SELECT @+=1,@C+=CONCAT(',# A',@),@D+=CONCAT('*A',@,'.A'),@E+=CONCAT(' AND A',@-1,'.A<=A',@,'.A')END
SET @C+=CONCAT(@D,'=',@N,@E)EXEC(@C)