รับจำนวนเต็มN , นับจำนวนวิธีที่สามารถแสดงเป็นผลคูณของMจำนวนเต็ม> 1

อินพุตเป็นเพียงNและMและเอาต์พุตคือจำนวนรวมของกลุ่มจำนวนเต็มที่แตกต่างกัน ความหมายคุณสามารถใช้จำนวนเต็มมากกว่าหนึ่งครั้ง แต่แต่ละกลุ่มจะต้องแตกต่างกัน ( 3 x 2 x 2จะไม่นับถ้า2 x 2 x 3มี)

ข้อ จำกัด

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

ตัวอย่าง

อินพุต30 2ให้เอาต์พุต3เนื่องจากสามารถแสดงได้ 3 วิธี:

2 x 15
3 x 10
5 x 6

อินพุต16 3ให้เอาต์พุต1เนื่องจากมีเพียงกลุ่มเดียวเท่านั้น:

2 x 2 x 4

อินพุต2310 4ให้เอาต์พุต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

อินพุต15 4ให้เอาต์พุต0เนื่องจากไม่สามารถทำได้

กฎระเบียบ

ใช้ช่องโหว่รหัสกอล์ฟมาตรฐานพร้อมกับคำจำกัดความมาตรฐานสำหรับอินพุต / เอาต์พุต รู้รอบอาจเป็นฟังก์ชั่นหรือโปรแกรมเต็มรูปแบบ ไม่อนุญาตให้ใช้ฟังก์ชันในตัวสำหรับการแยกตัวประกอบและ / หรือการแบ่งพาร์ติชัน แต่ฟังก์ชันอื่น ๆ ใช้งานได้ดี รหัสนับเป็นไบต์

Pyth - 24 23 22 21 ไบต์

ไม่ใช่ทางออกที่ซับซ้อน จะมีการตีกอล์ฟมากขึ้น เพียงใช้ผลิตภัณฑ์รายการและตัวกรองของคาร์ทีเซียน กลยุทธ์เดียวกับ @optimizer (ฉันเดาเพราะความเห็นของเขาไม่ได้ถอดรหัส CJam นั้น) ขอบคุณ @FryAmTheEggman เป็นเวลา 2 ไบต์และหลอกด้วย M

Ml{m`Sdfqu*GHT1G^r2GH

กำหนดฟังก์ชั่นgด้วย args Gและ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

ทำงานในการทดสอบทั้งหมดยกเว้นครั้งสุดท้ายช้าเกินไป แต่ไม่มีการ จำกัด เวลา

Python 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

iเรานับขึ้นหารที่มีศักยภาพ ด้วยอาร์กิวเมนต์เพิ่มเติมiเป็นตัวหารที่ได้รับอนุญาตต่ำสุดความสัมพันธ์แบบเรียกซ้ำหลักคือ

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

สำหรับแต่ละiเราเลือกที่จะรวมไว้ (เป็นไปได้เช่นการทำซ้ำ) ซึ่งในกรณีนี้เราแบ่งสินค้าที่จำเป็นNโดยและลดลงi Mถ้าเราทำไม่ได้เราเพิ่มขึ้นiโดยที่ 1 แต่ถ้าเนื่องจากไม่มีตัวหารใช้การตรวจสอบมากกว่าi<NN

เมื่อตัวหารขั้นต่ำiเกินกว่าNจะไม่มีตัวหารที่เป็นไปได้อีก ดังนั้นเราตรวจสอบว่าเราประสบความสำเร็จโดยการดูว่าM==0 and N==1หรือเทียบเท่าM+1==N==1หรือM+1==N<2ตั้งแต่เมื่อใดM+1==Nค่ารวมทั้งคู่จะรับประกันว่าเป็นจำนวนเต็มบวก (ขอบคุณ FryAmTheEggman สำหรับการเพิ่มประสิทธิภาพนี้)

รหัสนี้จะทำให้เกิดการล้นสแต็คNประมาณ 1,000 ในระบบส่วนใหญ่ แต่คุณสามารถเรียกใช้ในStackless Pythonเพื่อหลีกเลี่ยงปัญหานี้ ยิ่งกว่านั้นมันช้ามากเนื่องจากการแยกแบบซ้ำแบบเอกซ์โพเนนเชียล

ทับทิม, 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}

มีประสิทธิภาพพอสมควรจริง ๆ สำหรับนิยามแบบวนซ้ำ สำหรับแต่ละคู่หาร[d,q]ของ n ด้วยการเป็นหนึ่งที่มีขนาดเล็กเราสรุปผลมาจากการd f[q,m-1]ส่วนที่ยุ่งยากคือในการโทรภายในเราจะ จำกัด ปัจจัยให้มากกว่าหรือเท่ากับ d เพื่อที่เราจะได้ไม่ต้องนับซ้ำ

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 ไบต์

อาจสั้นกว่านี้มาก แต่ฉันได้เพิ่มการตรวจสอบบางอย่างเพื่อให้สามารถทำงานMกับคอมไพเลอร์ออนไลน์ได้อย่างเหมาะสม

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

ลองออนไลน์ได้ที่นี่

T-SQL 456 373

ฉันแน่ใจว่าสิ่งนี้จะพังเมื่ออินพุตใกล้เคียงกับขนาดใหญ่

ขอบคุณ @MickyT ที่ช่วยประหยัดอักขระจำนวนมากด้วย CONCAT และ SELECTing แทนที่จะเป็น SET หลายชุด

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)