พิจารณาอาร์เรย์ของความยาวA nอาร์เรย์มีจำนวนเต็มบวกเท่านั้น A = (1,1,2,2)เช่น ให้เรากำหนดf(A)เป็นชุดของผลรวมของทุกคนที่ไม่ว่างเปล่า subarrays Aต่อเนื่องกันของ ในกรณีf(A) = {1,2,3,4,5,6}นี้ ขั้นตอนในการผลิตf(A) มีดังนี้:

subarrays ของAreA จำนวนเงินของตนมี(1), (1), (2), (2), (1,1), (1,2), (2,2), (1,1,2), (1,2,2), (1,1,2,2) ชุดที่คุณได้รับจากรายการนี้จึงเป็น1,1,2,2,2,3,4,4,5,6{1,2,3,4,5,6}

งาน

รับชุดของเงินก้อนSได้รับในการเรียงลำดับที่มีจำนวนเต็มบวกเท่านั้นและระยะเวลาในอาร์เรย์nงานของคุณคือการส่งออกอย่างน้อยหนึ่งอาร์เรย์ดังกล่าวว่าXf(X) = S

ตัวอย่างเช่นถ้าS = {1,2,3,5,6}และแล้วการส่งออกที่ถูกต้องn = 3X = (1,2,3)

หากไม่มีอาเรย์ดังกล่าวXรหัสของคุณควรส่งออกค่าคงที่ใด ๆ

ตัวอย่าง

อินพุต: n=4, S = (1, 3, 4, 5, 6, 8, 9, 10, 13)เอาต์พุตที่เป็นไปได้:X = (3, 5, 1, 4)

อินพุต: n=6, S = (2, 3, 4, 5, 7, 8, 9, 10, 12, 14, 17, 22)เอาต์พุตที่เป็นไปได้:X = (5, 3, 2, 2, 5, 5)

อินพุต: n=6, S = (2, 4, 6, 8, 10, 12, 16)เอาต์พุตที่เป็นไปได้:X = (4, 2, 2, 2, 2, 4)

อินพุต: n=6, S = (1, 2, 3, 4, 6, 7, 8, 10, 14)เอาต์พุตที่เป็นไปได้:X = (4, 2, 1, 1, 2, 4)

อินพุต: n=10, S = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 14, 15, 16, 17, 18, 19, 20, 23, 24, 25)เอาต์พุตที่เป็นไปได้: X = (1, 1, 3, 1, 2, 1, 2, 5, 4, 5).

อินพุต: n=15, S = (1, 2, 3, 4, 6, 7, 8, 9, 10, 11, 13, 14, 15, 16, 17, 18, 20, 21, 22, 23, 24, 25, 26, 27, 28, 30, 31)เอาต์พุตที่เป็นไปได้: X = (1, 2, 1, 3, 3, 1, 3, 3, 1, 3, 3, 1, 2, 1, 3).

รูปแบบอินพุตและเอาต์พุต

รหัสของคุณสามารถรับอินพุตและให้เอาต์พุตในรูปแบบที่มนุษย์อ่านได้ง่ายที่คุณสะดวก อย่างไรก็ตามโปรดแสดงผลลัพธ์ของการทดสอบกับตัวอย่างในคำถาม

เวลาเล่น

คุณจะต้องสามารถเรียกใช้รหัสเพื่อให้สมบูรณ์สำหรับตัวอย่างทั้งหมดในคำถาม โดยหลักการแล้วควรถูกต้องnจนถึงสูงสุด15แต่คุณไม่จำเป็นต้องพิสูจน์ว่ามันเร็วพอสำหรับอินพุตทั้งหมด

Husk , 20 ไบต์

ḟȯ⁰¦ṁ∫ṫ!¡Sof~Λ€∫×:¹g

ลองออนไลน์!

ส่งคืนโซลูชันหนึ่งรายการหรือรายการว่างเปล่าหากไม่มีอยู่ กรณีทดสอบสุดท้าย ( n=15) เสร็จสิ้นภายใน 3.8 วินาทีสำหรับ TIO

คำอธิบาย

โปรแกรมมีสองส่วน ในส่วนแรก ( ¡และทางด้านขวาของมัน) เราสร้างรายการอนันต์kองค์ประกอบ TH เป็นรายการที่มี length- ทุกรายการที่มีชิ้นผลรวมอยู่ในk Sเราทำเช่นนี้ inductively เริ่มต้นจากชิ้น 1 องค์ประกอบของSและในแต่ละขั้นตอน prepending องค์ประกอบของแต่ละเพื่อแต่ละรายการและการรักษาผู้ที่มีคำนำหน้าผลรวมอยู่ในS Sในส่วนที่สอง ( !และทางด้านซ้ายของมัน) เราใช้nองค์ประกอบที่สามของรายการซึ่งมีnรายการความยาว Sของเหล่านี้เราเลือกเป็นคนแรกที่มีผลรวมชิ้นจริงมีองค์ประกอบของทุก

ในโค้ดก่อนอื่นให้แทนที่oและȯ(ซึ่งประกอบด้วยสองและสามฟังก์ชันเป็นหนึ่ง) โดยวงเล็บเพื่อความชัดเจน

¡S(f~Λ€∫)×:¹g  First part. Input is a list, say S=[1,2,3]
            g  Group equal adjacent elements: [[1],[2],[3]]
¡              Iterate function:
                Argument is a list of lists, say [[1,1],[1,2],[2,1]]
         ×      Mix (combine two lists in all possible ways)
          :     by prepending
           ¹    with the list S: [[1,1,1],[1,1,2],[2,1,1],[1,2,1],[2,1,2],[3,1,1],[2,2,1],[3,1,2],[3,2,1]]
   f            Filter by condition:
        ∫        Cumulative sums: [[1,2,3],[1,2,4],[2,3,4],[1,3,4],[2,3,5],[3,4,5],[2,4,5],[3,4,6],[3,5,6]]
     ~Λ          All of the numbers
 S     €         are elements of S: [[1,1,1]]
                 Only this list remains, since the other cumulative sums contain numbers not from S.
               Result of iteration: [[[1],[2],[3]],[[1,1],[1,2],[2,1]],[[1,1,1]],[],[],[]...

ḟ(⁰¦ṁ∫ṫ)!      Second part. Implicit input, say n=2.
        !      Take nth element of above list: [[1,1],[1,2],[2,1]]
ḟ              Find first element that satisfies this:
                Argument is a list, say [1,2]
      ṫ         Tails: [[1,2],[2]]
    ṁ           Map and concatenate
     ∫          cumulative sums: [1,3,2]
 ȯ ¦            Does it contain all elements of
  ⁰             S? Yes.
               Result is [1,2], print implicitly.

มีบางส่วนที่ต้องการคำอธิบายเพิ่มเติม ในโปรแกรมนี้ตัวยกทั้งอ้างถึงอาร์กิวเมนต์แรก⁰¹ Sอย่างไรก็ตามถ้าαเป็นฟังก์ชั่นα¹แปลว่า "นำαไปใช้กับS" ในขณะที่⁰αหมายถึง "เสียบSเข้ากับอาร์กิวเมนต์ที่สองของα" ฟังก์ชั่น¦ตรวจสอบว่าอาร์กิวเมนต์แรกของมันมีองค์ประกอบทั้งหมดของที่สอง (นับ multiplicities) ดังนั้นSควรเป็นอาร์กิวเมนต์ที่สอง

ในส่วนแรก, ฟังก์ชั่นที่ใช้งานสามารถตีความได้ว่า¡ S(f~Λ€∫)(×:)¹Combinator Sพฤติกรรมเช่นซึ่งหมายความว่าเราสามารถลดความซับซ้อนของมันSαβγ -> (αγ)(βγ) (f~Λ€∫¹)(×:¹)ส่วนที่สอง×:¹คือ "ผสมกับการรวมS" และผลลัพธ์จะถูกส่งไปยังส่วนแรก ส่วนแรกf~Λ€∫¹ทำงานเช่นนี้ ฟังก์ชั่นกรองรายการโดยสภาพซึ่งในกรณีนี้คือf ~Λ€∫¹ได้รับรายการแสดงรายการเพื่อให้เรามีL ~Λ€∫¹Lผู้ประสาน~จะทำงานเช่น~αβγδε -> α(βδ)(γε): อาร์กิวเมนต์แรกถูกส่งไปβยังอันดับที่สองγและผลลัพธ์จะถูกรวมเข้าด้วยαกัน Λ(€¹)(∫L)ซึ่งหมายความว่าเรามี ส่วนสุดท้าย∫Lเป็นเพียงจำนวนเงินสะสมของL,€¹เป็นฟังก์ชั่นที่ตรวจสอบการเป็นสมาชิกSและΛรับเงื่อนไข (ที่นี่€¹) และรายการ (ที่นี่∫L) และตรวจสอบว่าองค์ประกอบทั้งหมดเป็นไปตามนั้น กล่าวง่ายๆคือเรากรองผลลัพธ์ของการผสมโดยระบุว่าผลรวมสะสมของพวกเขาทั้งหมดSหรือไม่

ทับทิมขนาด 135 ไบต์

->a,n{r=w=1;r+=1until w=(s=a[0,r]).product(*[s]*~-n).find{|x|x.sum==a.max&&a==[]|(1..n).flat_map{|r|x.each_cons(r).map(&:sum)}.sort};w}

ลองออนไลน์!

ใช้การค้นหาความกว้างก่อน n = 10 ทำงานกับ TIO, n = 15 ใช้เวลานานกว่าหนึ่งนาที แต่ทำงานบนเครื่องของฉัน

ทับทิม , 147 ไบต์

->a,n{r=w=1;r+=1until w=([a[-1]-a[-2]]).product(*[s=a[0,r]]*~-n).find{|x|x.sum==a.max&&a==[]|(1..n).flat_map{|r|x.each_cons(r).map(&:sum)}.sort};w}

ลองออนไลน์!

เวอร์ชันที่ปรับให้เหมาะสมทำงานบน TIO สำหรับ n = 15 (~ 20 วินาที)

ที่จริงแล้วนี่คือจุดเริ่มต้นของวิธีการที่ไม่ใช้กำลังดุร้าย ฉันหวังว่าใครบางคนจะทำงานกับมันและหาทางออกที่สมบูรณ์

ความคิดแรก:

• ผลรวมของอาร์เรย์เอาต์พุตคือองค์ประกอบสุดท้าย (สูงสุด) ของอินพุตอาร์เรย์
• ผลรวมของอาร์เรย์ผลลัพธ์ลบองค์ประกอบแรก (หรือสุดท้าย) เป็นองค์ประกอบสุดท้ายที่สองของอาร์เรย์อินพุต
• หากอาเรย์เป็นวิธีการแก้ปัญหาดังนั้นอาเรย์ย้อนกลับก็เป็นวิธีแก้ปัญหาด้วยดังนั้นเราจึงสามารถสันนิษฐานได้ว่าองค์ประกอบแรกคือความแตกต่างระหว่าง 2 องค์ประกอบสุดท้ายของอาเรย์อินพุต
• องค์ประกอบที่สองสามารถเป็นความแตกต่างระหว่างองค์ประกอบสุดท้ายที่สองและสามหรือสองและสี่ของอาร์เรย์

ซึ่งนำเราไปสู่การเพิ่มประสิทธิภาพต่อไป:

Ruby , 175 ไบต์

->a,n{r=w=1;r+=1until w=([a[-1]-a[-2]]).product([a[-2]-a[-3],a[-2]-a[-4]],*[s=a[0,r]]*(n-2)).find{|x|x.sum==a.max&&a==[]|(1..n).flat_map{|r|x.each_cons(r).map(&:sum)}.sort};w}

ลองออนไลน์!

ประมาณ 8.5 วินาทีใน TIO ไม่เลว...

... และอื่น ๆ (ที่จะดำเนินการ)

Haskell, 117 111 ไบต์

บันทึกไปแล้ว 6 ไบต์ด้วย @nimi!

f r i n s|n<1=[r|r==[]]|1<2=[y:z|y<-s,t<-[y:map(y+)i],all(`elem`s)t,z<-f[a|a<-r,all(a/=)t]t(n-1)s]
n&s=f s[]n s

ลองออนไลน์!

fr$S$ins

เมื่อnใดที่รายการศูนย์n<1ต้องพร้อมแล้วเราจะตรวจสอบว่ามีการเห็นค่าทั้งหมดหรือไม่ หากไม่มีเราจะส่งคืนรายการว่างเพื่อระบุว่าไม่มีวิธีแก้ปัญหามิฉะนั้นเราจะส่งคืนรายการเดี่ยวที่มีรายการว่างซึ่งองค์ประกอบที่เลือกจะถูกนำมารวมไว้ กรณีนี้อาจถูกจัดการด้วยสมการเพิ่มเติม

f [] _ 0 _=[[]]
f _ _ 0 _=[]

ถ้าnไม่ใช่ศูนย์เรากลับมา

[y:z|y<-s,t<-[y:map(y+)i],all(`elem`s)t,z<-f[a|a<-r,all(a/=)t]t(n-1)s]
 ^1^ ^2^^ ^......3......^ ^.....4.....^ ^.............5.............^

นี่คือรายการของ (1) รายการที่องค์ประกอบแรก (2) มาจากsและส่วนที่เหลือ (5) มาจากโทร recursive ภายใต้เงื่อนไข (4) sว่าเงินก้อนใหม่ทั้งหมดที่อยู่ใน เงินก้อนใหม่จะคำนวณใน (3) - ทราบว่าtจะถูกดึงจากรายการเดี่ยว, สับเล่นกอล์ฟที่น่าเกลียดสำหรับสิ่งที่อยู่ในสำนวน Haskell let t=y:map(y+)iจะเป็น โทร recursive (5) ได้รับใหม่ชุดเดิมโดยไม่ต้ององค์ประกอบเหล่านั้นที่ปรากฏในผลรวมใหม่rt

ฟังก์ชั่นหลัก&เรียกใช้ฟังก์ชันตัวช่วยซึ่งบอกว่าเรายังต้องดูค่าทั้งหมด ( r=s) และยังไม่มีผลรวม ( i=[])

สำหรับอีกเจ็ดไบต์เราสามารถ จำกัด การคำนวณเพื่อให้ผลลัพธ์แรกเท่านั้น (ถ้ามี) ซึ่งเร็วกว่ามากและจัดการกรณีทดสอบทั้งหมดในเวลาน้อยกว่า 2 วินาที

ลองออนไลน์! (นี่เป็นผลลัพธ์แรกที่เปลี่ยนแปลงรุ่นเก่าเท่านั้น)

ทำความสะอาด , 177 ไบต์

import StdEnv,Data.List
$s n=find(\a=sort(nub[sum t\\i<-inits a,t<-tails i|t>[]])==s)(?{#u\\u<-s|u<=(last s)-n}(last s)n)
?e s n|n>1=[[h:t]\\h<-:e|h<=s-n,t<- ?e(s-h)(n-1)]=[[s]]

ลองออนไลน์!

ใช้เวลาประมาณ 40 วินาทีบนเครื่องของฉันสำหรับn=15เคสทดสอบ แต่หมดเวลากับ TIO

ทำความสะอาด , 297 ไบต์

import StdEnv,Data.List
$s n=find(\a=sort(nub[sum t\\i<-inits a,t<-tails i|t>[]])==s)(~[u\\u<-s|u<=(last s)-n](last s)n(reverse s))
~e s n a|n>4=let u=a!!0-a!!1 in[[u,h:t]\\h<-[a!!1-a!!2,a!!1-a!!3],t<- ?e(s-u-h)(n-2)]= ?e s n
?e s n|n>1=[[h:t]\\h<-e,t<- ?(takeWhile((>=)(s-n-h))e)(s-h)(n-1)]=[[s]]

ลองออนไลน์!

อันนี้รวมถึงการเพิ่มประสิทธิภาพบางอย่างที่ทำโดยGBเช่นเดียวกับของฉันเอง ฉันคิดว่าพวกเขาบางคนสามารถทำให้เป็นเรื่องทั่วไปมากขึ้นดังนั้นฉันจะเพิ่มคำอธิบายเมื่อเสร็จแล้ว

ใช้เวลาประมาณ 10 วินาทีบนเครื่องของฉัน 40 วินาทีสำหรับ TIO

Python 3 , 177 ไบต์

from itertools import*
s,n=eval(input())
for[*t]in combinations(s[:-2],n-2):
  a=[*map(int.__sub__,t+s[-2:],[0,*t,s[-2]])];
  {sum(a[p//n:p%n+1])for p in range(n*n)}^{0,*s}or-print(a)

ลองออนไลน์!

(เพิ่มบรรทัดใหม่ / ช่องว่างบางส่วนเพื่อหลีกเลี่ยงผู้อ่านที่ต้องเลื่อนโค้ด)

พอร์ตโดยตรงของคำตอบ Jelly ของฉัน (ด้วยการแก้ไขบางอย่างดู "หมายเหตุ" ส่วนด้านล่าง)

ผลการเรียกใช้ในท้องถิ่น:

[user202729@archlinux golf]$ printf '%s' "from itertools import*
s,n=eval(input())
for[*t]in combinations(s[:-2],n-2):a=[*map(int.__sub__,t+s[-2:],[0,*t,s[-2]])];{sum(a[p//n:p%n+1])for p in range(n*n)}^{0,*s}or-print(a)" > a.py
[user202729@archlinux golf]$ wc -c a.py
177 a.py
[user202729@archlinux golf]$ time python a.py<<<'([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 14, 15, 16, 17, 18, 19, 20, 23, 24, 25], 10)' 2>/dev/null
[1, 4, 1, 1, 1, 1, 1, 7, 7, 1]

real    0m3.125s
user    0m3.119s
sys     0m0.004s
[user202729@archlinux golf]$ time python a.py<<<'([1, 2, 3, 4, 6, 7, 8, 9, 10, 11, 13, 14, 15, 16, 17, 18, 20, 21, 22, 23, 24, 25, 26, 27, 28, 30, 31], 15)' 2>/dev/null
[3, 1, 2, 1, 3, 3, 1, 3, 3, 1, 3, 3, 1, 2, 1]

real    11m36.093s
user    11m33.941s
sys     0m0.387s
[user202729@archlinux golf]$ 

ฉันได้ยินมาว่าitertoolsเป็น verbose แต่combinationsการนำไปใช้ที่ดีที่สุดของฉันคือ verbose มากยิ่งขึ้น:

c=lambda s,n,p:s and c(s[1:],n-1,p+s[:1])+c(s[1:],n,p)or[]if n else[p]

หมายเหตุ

• การใช้การหาร / โมดูโลa[p//n:p%n+1]จะใช้เวลาประมาณ 2x อีกต่อไป แต่จะบันทึกบางไบต์
• สิ่งนี้แตกต่างจากคำตอบของเยลลี่เล็กน้อย - คำตอบของเยลลี่จะวนซ้ำไปข้างหลัง
• ขอบคุณที่combinationsคืนค่าตัววนซ้ำนี่เป็นมิตรกับหน่วยความจำมากขึ้น

เยลลี่ 35 ไบต์

Ẇ§QṢ⁼³
;³ṫ-¤0;I
ṖṖœcƓ_2¤¹Ṫ©ÇѬƲ¿ṛ®Ç

ลองออนไลน์!

เรียกใช้ในเครื่อง: (n = 15 ใช้ RAM มากกว่า 1 GB)

aaa@DESKTOP-F0NL48D MINGW64 ~/jellylanguage (master)
$ time python scripts/jelly fu z '[1,2,3,4,5,6,7,8,9,10,11,12,14,15,16,17,18,19,20,23,24,25]'<<<10
[8, 6, 2, 1, 1, 1, 1, 3, 1, 1]
real    0m1.177s
user    0m0.000s
sys     0m0.015s

aaa@DESKTOP-F0NL48D MINGW64 ~/jellylanguage (master)
$ time python scripts/jelly fu z '[1, 2, 3, 4, 6, 7, 8, 9, 10, 11, 13, 14, 15, 16, 17, 18, 20, 21, 22, 23, 24, 25, 2
6, 27, 28, 30, 31]'<<<15
[3, 1, 2, 1, 3, 3, 1, 3, 3, 1, 3, 3, 1, 2, 1]
real    12m24.488s
user    0m0.000s
sys     0m0.015s

(อันที่จริงฉันรันรุ่นเข้ารหัส UTF8 ซึ่งใช้เวลามากกว่า 35 ไบต์ แต่ผลลัพธ์จะเหมือนกันอยู่ดี)

วิธีแก้ปัญหานี้ใช้ไฟฟ้าลัดวงจรเพื่อลดเวลาทำงาน

$\binom {|S|-2}{n-2} \times \left( \frac {n^3}6 + n^2\log{n^2} \right)$$\binom {26-2}{15-2} \times \left( \frac {15^3}6 + 15^2\log{15^2} \right) \approx 5.79 \times 10^9$

คำอธิบาย

เราทราบว่าจำนวนเงินของคำนำหน้าไม่ว่างทั้งหมดอยู่ในอินพุตและเพิ่มขึ้นอย่างเคร่งครัด เราสามารถสันนิษฐานได้ว่าองค์ประกอบที่ใหญ่ที่สุดและใหญ่เป็นอันดับสองคือผลรวมคำนำหน้า

$n-2$$|S|-2$$\binom {|S|-2}{n-2}$$n^2$$n^3 \over 6$

ยังไม่ทดลอง (แต่ควรมีประสิทธิภาพเหมือนกัน)

เยลลี่ 32 ไบต์

Ṫ©ÑẆ§QṢ⁻³
;³ṫ-¤ŻI
ṖṖœcƓ_2¤¹Ñ¿ṛ®Ç

ลองออนไลน์!

รุ่นที่ไม่มีประสิทธิภาพมากขึ้น (ไม่มีการลัดวงจร):

เยลลี่ , 27 ไบต์

Ẇ§QṢ⁼³
ṖṖœcƓ_2¤µ;³ṫ-¤0;I)ÑƇ

ลองออนไลน์!

สำหรับการทดสอบ n = 15 จะใช้ RAM สูงสุด 2GB และไม่ยุติหลังจาก ~ 37 นาที

หมายเหตุ : อาจถูกแทนที่ด้วยẆ§ ÄÐƤẎมันอาจจะมีประสิทธิภาพมากขึ้น

APL (NARS), ตัวอักษร 758, ไบต์ 1516

r←H w;i;k;a;m;j
   r←⊂,w⋄→0×⍳1≥k←↑⍴w⋄a←⍳k⋄j←i←1⋄r←⍬⋄→C
A: m←i⊃w⋄→B×⍳(i≠1)∧j=m⋄r←r,m,¨∇w[a∼i]⋄j←m
B: i+←1
C: →A×⍳i≤k

G←{H⍵[⍋⍵]}

r←a d w;i;j;k;b;c
   k←↑⍴w ⋄b←⍬⋄r←0 ⋄j←¯1
A: i←1⋄j+←1⋄→V×⍳(i+j)>k
B: →A×⍳(i+j)>k⋄c←+/w[i..(i+j)]⋄→0×⍳∼c∊a⋄→C×⍳c∊b⋄b←b,c
C: i+←1⋄→B
V: →0×⍳∼a⊆b
   r←1

r←a F w;k;j;b;m;i;q;x;y;c;ii;kk;v;l;l1;i1;v1
   w←w[⍋w]⋄r←a⍴w[1]⋄l←↑⍴w⋄k←w[l]⋄m←8⌊a-2⋄b←¯1+(11 1‼m)⋄j←2⋄i←1⋄x←↑⍴b⋄i1←0⋄v1←⍬
I: i1+←1⋄l1←w[l]-w[l-i1]⋄v1←v1,w[1+l-i1]-w[l-i1]⋄→I×⍳(l1=i1)∧l>i1⋄→B
E: r←,¯1⋄→0
F: i←1⋄q←((1+(a-2)-m)⍴0),(m⍴1),0⋄r+←q
A:   i+←1⋄j+←1⋄→E×⍳j>4000
B:   →F×⍳i>x⋄q←((1+(a-2)-m)⍴0),b[i;],0⋄q+←r⋄v←q[1..(a-1)]⋄→A×⍳0>k-y←+/v
   q[a]←k-y⋄→A×⍳l1<q[a]⋄→A×⍳∼q⊆w⋄→A×⍳∼l1∊q⋄→A×⍳∼v1⊆⍦q⋄c←G q∼⍦v1⋄ii←1⋄kk←↑⍴c⋄→D
C:   →Z×⍳w d v1,ii⊃c⋄ii+←1
D:   →C×⍳ii≤kk
   →A
Z: r←v1,ii⊃c

ฟังก์ชั่น G ใน G x (ด้วยความช่วยเหลือของฟังก์ชั่น H) จะพบการเรียงสับเปลี่ยนทั้งหมดของ x ฟังก์ชัน d ใน xdy ค้นหาว่าอาร์เรย์ y สร้างขึ้นหลังจากการออกกำลังกายอาร์เรย์ x คืนค่าบูลีนหรือไม่ ฟังก์ชั่น F ใน x F y จะคืนค่าอาเรย์ของความยาว x เช่น ydr เป็นจริง (= 1) การใช้งานเพียงเล็กน้อย แต่มันเป็นอันนี้ที่คำนวณทุกกรณีในการทดสอบเวลาที่น้อยลง ... กรณีสุดท้าย สำหรับ n = 15 มันใช้เวลา 20 วินาทีเท่านั้น ... ฉันต้องบอกว่าไม่พบวิธีแก้ปัญหามากมายให้ส่งคืนหนึ่งโซลูชัน (ในที่สุดดูเหมือนว่าจะเป็นเช่นนั้น) ในเวลาที่น้อยกว่า (ไม่ได้ทดสอบการสำรวจสำหรับอินพุตที่แตกต่างกัน ... ) 16 + 39 + 42 + 8 + 11 + 11 + 18 + 24 + 24 + 54 + 11 + 12 + 7 + 45 + 79 + 69 + 12 + 38 + 26 + 72 + 79 + 27 + 15 + 6 + 13 (758)

  6 F (2, 3, 4, 5, 7, 8, 9, 10, 12, 14, 17, 22)
5 3 2 2 5 5 
  6 F (2, 4, 6, 8, 10, 12, 16)
4 2 2 2 2 4 
  6 F (1, 2, 3, 4, 6, 7, 8, 10, 14)
4 2 1 1 2 4 
  10 F (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 14, 15, 16, 17, 18, 19, 20, 23, 24, 25)
1 1 3 1 2 3 5 1 3 5 
  15 F (1, 2, 3, 4, 6, 7, 8, 9, 10, 11, 13, 14, 15, 16, 17, 18, 20, 21, 22, 23, 24, 25, 26, 27, 28, 30, 31)
1 2 1 3 3 1 3 3 1 3 3 1 2 1 3 
  ww←(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 14, 15, 16, 17, 18, 19, 20, 23, 24, 25)
  ww≡dx 1 1 3 1 2 3 5 1 3 5 
1