एक ऐसा सरणी ढूंढें जो रकम का एक सेट फिट बैठता है

Question

Aलंबाई की एक सरणी पर विचार करें n। सरणी में केवल धनात्मक पूर्णांक होते हैं। उदाहरण के लिए A = (1,1,2,2)। आइए हम f(A)सभी गैर-रिक्त सन्निहित उपसमूह के योगों के समूह के रूप में परिभाषित करते हैं A। इस मामले में f(A) = {1,2,3,4,5,6}। उत्पादन के चरण f(A) इस प्रकार हैं:

की अधीनताएँ Aहैं (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, आपका कार्य कम से कम एक सरणी को Xऐसे आउटपुट करना है f(X) = S।

उदाहरण के लिए, यदि S = {1,2,3,5,6}और n = 3फिर एक वैध आउटपुट है X = (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लेकिन आप को साबित करना यह सब जानकारी के लिए काफी तेजी से किया जाएगा जरूरत नहीं है।

Comments

टिप्पणियाँ विस्तारित चर्चा के लिए नहीं हैं; इस वार्तालाप को बातचीत में स्थानांतरित कर दिया गया है ।

— डेनिस

शायद 2 अंकों की संख्या के साथ एक परीक्षण मामला होना चाहिए।

— मैजिक ऑक्टोपस Urn

Answer 1

भूसी , 20 बाइट्स

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

इसे ऑनलाइन आज़माएं!

यदि यह मौजूद नहीं है तो एक समाधान, या एक खाली सूची देता है। पिछले परीक्षण मामले ( n=15) टीआईओ पर 3.8 सेकंड में समाप्त होता है।

व्याख्या

कार्यक्रम के दो भाग हैं। पहले भाग में ( ¡और इसके दाईं ओर), हम एक अनंत सूची का निर्माण करते हैं, जिसका kवें तत्व एक ऐसी सूची है, जिसमें सभी लंबाई- kसूचियाँ होती हैं, जिनके स्लाइस में हैं S। हम इसे 1-तत्व के स्लाइस से शुरू करते हुए, सरलता से करते हैंS , और प्रत्येक चरण में 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दूसरे तर्क के लिए प्लग" का अर्थ है α। फ़ंक्शन यह ¦जाँचता है कि क्या इसके पहले तर्क में दूसरे (गिनती गुणकों) के सभी तत्व शामिल हैं, इसलिए Sइसका दूसरा तर्क होना चाहिए।

पहले भाग में, ¡उपयोग करने वाले फ़ंक्शन की व्याख्या की जा सकती है S(f~Λ€∫)(×:)¹। कॉम्बिनेटर Sऐसा व्यवहार करता है Sαβγ -> (αγ)(βγ), जिसका अर्थ है कि हम इसे सरल बना सकते हैं (f~Λ€∫¹)(×:¹)। दूसरा भाग, ×:¹" Sपूर्वसंध्या के साथ मिश्रण " है, और इसका परिणाम पहले भाग के लिए दिया गया है। पहला भाग, f~Λ€∫¹इस तरह काम करता है। फ़ंक्शन fएक सूची को एक शर्त से फ़िल्टर करता है, जो इस मामले में है ~Λ€∫¹। यह सूचियों की एक सूची प्राप्त करता है L, इसलिए हमारे पास है ~Λ€∫¹L। कॉम्बिनेटर ~ऐसा व्यवहार करता है ~αβγδε -> α(βδ)(γε): पहला तर्क पास हो जाता है β, दूसरा γऔर परिणाम संयुक्त हो जाता है α। इसका मतलब है कि हमारे पास है Λ(€¹)(∫L)। अंतिम भाग ∫L, का संचयी योग है L,€¹एक ऐसा कार्य है जो सदस्यता की जाँच करता है S, और Λएक शर्त (यहाँ €¹) और एक सूची (यहाँ लेता है∫L), और जाँच करता है कि सभी तत्व इसे संतुष्ट करते हैं। सीधे शब्दों में कहें, हम मिश्रण के परिणामों को फ़िल्टर करते हैं कि क्या उनके संचयी योग हैं S।

Comments

मैं स्पष्टीकरण की प्रतीक्षा कर रहा हूं!

— अनुश्

@ आयुष मैंने एक कोड ब्रेकडाउन जोड़ा।

— जरगब

मुझे वास्तव में यह समाधान पसंद है। यह सुंदर की तरह है।

— आशु

Answer 2

रूबी , 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 तत्वों के बीच अंतर है।
• दूसरा तत्व इनपुट सरणी के दूसरे और तीसरे या दूसरे और चौथे अंतिम तत्व के बीच अंतर हो सकता है।

जो हमें अगले अनुकूलन के लिए लाता है:

रूबी , 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}

इसे ऑनलाइन आज़माएं!

~ TIO पर 8.5 सेकंड। बुरा नहीं...

... और इतने पर (लागू किया जाना)

Comments

यह बहुत अच्छा लग रहा है!

— अनुष्का

मैं आपके नए गैर-ब्रूट बल एल्गोरिदम से उत्साहित हूं। यदि आप I पर परीक्षण करने के लिए अधिक उदाहरण चाहते हैं तो उन्हें प्रश्न के एक नए खंड में जोड़ सकते हैं।

— अनुष्का

@ आंसू वास्तव में यह अभी भी जानवर बल (घातीय समय) है, लेकिन कुछ (बहुपद कारक) अनुकूलन के साथ।

— 14:20 पर उपयोगकर्ता 202729

मेरे लिए आप भूल जाते हैं कि पहला तत्व (तत्व अधिक छोटा) यह हमेशा समाधान में होता है: इसलिए हमारे पास 1 और अंतिम (सभी का योग) है; और आप दूसरी बार कहते हैं, लेकिन यह मेरे लिए स्पष्ट नहीं है ... संभव है कि इस तरह से सभी को मिल जाए ...

— RosLuP

Answer 3

हास्केल, 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) पुनरावर्ती कॉल से आता है, इस शर्त (4) के तहत कि सभी नए योग हैं s। नए योगों की गणना (3) में की जाती है - ध्यान दें कि tएक एकल सूची से तैयार किया गया है, जो मुहावरेदार हास्केल में एक बदसूरत गोल्फ हैक होगा let t=y:map(y+)i। पुनरावर्ती कॉल (5) के रूप में नया हो जाता है rउन तत्वों के बिना पुराने सेट जो नए रकम के बीच दिखाई देते हैं t।

मुख्य कार्य &सहायक फ़ंक्शन को यह कहते हुए बुलाता है कि हमें अभी भी सभी मूल्य ( r=s) देखने हैं और अभी तक कोई रकम नहीं है (i=[] )।

सात और बाइट्स के लिए, हम केवल पहले परिणाम (यदि कोई हो) देने के लिए गणना को प्रतिबंधित कर सकते हैं, जो बहुत तेज़ है और 2 सेकंड से कम समय में सभी परीक्षण मामलों को संभालता है।

इसे ऑनलाइन आज़माएं! (यह पुराने संस्करण का केवल पहला परिणाम है)

Comments

यह आश्चर्यजनक रूप से तेज है। यदि आप एल्गोरिथ्म की व्याख्या कर सकते हैं जो बहुत अच्छा होगा।

— अनुष

111 बाइट्स

— nimi

मैं इस समस्या का सबसे तेज़ कोड संस्करण प्रस्तुत करने के बारे में सोच रहा हूं। क्या आपको लगता है कि पॉली टाइम सॉल्यूशन हो सकता है?

— आयुष

@ नमि धन्यवाद! आह, अच्छा बूढ़ा map, मैंने केवल कोशिश की, <$>लेकिन इसके लिए अतिरिक्त पैरेन्स की जरूरत थी ... @ अशुभ मेरे पास एक बहुपद समय समाधान के लिए कोई विचार नहीं है

— क्रिश्चियन

Answer 4

साफ , 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]]

इसे ऑनलाइन आज़माएं!

n=15परीक्षण मशीन के लिए मेरी मशीन पर लगभग 40 सेकंड लगते हैं, लेकिन यह 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]]

इसे ऑनलाइन आज़माएं!

इसमें जीबी द्वारा किए गए कुछ अनुकूलन शामिल हैं साथ-साथ कुछ मेरे अपने भी शामिल हैं। मुझे लगता है कि उनमें से कुछ को अधिक सामान्य बनाया जा सकता है, इसलिए मैं एक बार एक स्पष्टीकरण जोड़ूंगा।

मेरी मशीन पर लगभग 10 सेकंड, टीआईओ पर 40 सेकंड लगते हैं।

Comments

क्या आप अपने द्वारा उपयोग किए गए अनुकूलन को समाप्त कर सकते हैं? मैं बहुत इच्छुक हूँ।

— अनुष

@ आयुष मैं उनके साथ उत्तर संपादित करूंगा और @mentionकल जब वे उठेंगे तो दुर्भाग्य से आज उनके पास समय नहीं होगा।

— Οसुरेश

Answer 5

पायथन 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)

इसे ऑनलाइन आज़माएं!

(पाठकों को कोड स्क्रॉल करने से बचने के लिए जोड़े गए कुछ नए लिंक / स्पेस)

मेरे जेली उत्तर का एक सीधा पोर्ट (कुछ संशोधनों के साथ, नीचे "नोट" अनुभाग देखें)

स्थानीय रन परिणाम:

[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क्रिया है, लेकिन मेरा सबसे अच्छा combinationsकार्यान्वयन और भी अधिक क्रिया है:

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एक पुनरावृति लौटने के लिए धन्यवाद , यह अधिक मेमोरी-फ्रेंडली है।

Answer 6

जेली , 35 बाइट्स

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

इसे ऑनलाइन आज़माएं!

स्थानीय रूप से चलाएं: (n = 15 1 GB से अधिक RAM)

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$subarrays, योग की गणना, अद्वितीय। सबरेज़ की कुल लंबाई लगभग है$n^3 \over 6$)

---

अनटाइटेड (लेकिन समान प्रदर्शन होना चाहिए)

जेली , 32 बाइट्स

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

इसे ऑनलाइन आज़माएं!

---

अधिक अक्षम संस्करण (शॉर्ट सर्किट के बिना):

जेली , 27 बाइट्स

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

इसे ऑनलाइन आज़माएं!

N = 15 परीक्षण के लिए, यह 2GB रैम तक ले जाता है और ~ 37 मिनट के बाद समाप्त नहीं होता है।

---

नोट : के Ẇ§साथ प्रतिस्थापित किया जा सकता है ÄÐƤẎ। यह अधिक कुशल हो सकता है।

Answer 7

एपीएल (एनएआरएस), चार्ट्स 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 के सभी क्रमपरिवर्तन खोजेगा। यदि x सरणी एक बूलियन मान लौटाता है, तो x x में फ़ंक्शन d को ढूँढता है। फ़ंक्शन F in x F y, लंबाई x की सरणी r लौटाएगा, जैसे कि 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