एक पुन: व्यवस्थित सबसेट के आधार पर एक मास्टर सूची को फिर से व्यवस्थित करें

Question

मुझे हाल ही में काम पर हल करने की समस्या थी, जहां मेरे पास दो सूचियां थीं: एक मास्टर सूची, और एक छोटी सूची जिसमें मास्टर सूची में आइटम का एक सबसेट होता है जो संभावित रूप से एक अलग क्रम में होता है। मुझे मास्टर सूची को इस तरह से पुन: क्रमबद्ध करने की आवश्यकता थी कि जब भी संभव हो सूची में नहीं मिली वस्तुओं के क्रम को बदले और उसी स्थान पर आइटम रखने के बिना सबसेट में आइटम उसी क्रम में दिखाई देंगे। ठीक है, शायद यह भ्रामक लगता है, इसलिए मैं इसे तोड़ दूंगा:

• मास्टर सूची वस्तुओं के डिफ़ॉल्ट क्रम को परिभाषित करती है।
• सबसेट सूची कुछ वस्तुओं के सापेक्ष क्रम को परिभाषित करती है।
• जहाँ मास्टर सूची में सब्मिट सूची के अनुसार दो तत्व हैं, जो आइटम पहले मास्टर सूची में है, उसे जल्द से जल्द सूचकांक में ले जाया जाना चाहिए, जहाँ वह सबसेट सूची के भीतर अन्य वस्तुओं के सापेक्ष सही स्थान पर है। (बाद में आइटम के तुरंत बाद)

आपका कार्य इस पुन: व्यवस्थित एल्गोरिथ्म को लागू करना है।

उदाहरण परीक्षण मामले

Master: [1, 2, 3]
Subset: []
Result: [1, 2, 3]

---

Master: [9001, 42, 69, 1337, 420]
Subset: [69]
Result: [9001, 42, 69, 1337, 420]

---

Master: [9001, 42, 69, 1337, 420, 99, 255]
Subset: [69, 9001, 1337]
Result: [42, 69, 9001, 1337, 420, 99, 255]

---

Master: [1, 2, 3, 4, 5]
Subset: [2, 5]
Result: [1, 2, 3, 4, 5]

---

Master: [apple, banana, carrot, duck, elephant]
Subset: [duck, apple]
Result: [banana, carrot, duck, apple, elephant]

---

Master: [Alice, Betty, Carol, Debbie, Elaine, Felicia, Georgia, Helen, Ilene, Julia]
Subset: [Betty, Felicia, Carol, Julia]
Result: [Alice, Betty, Debbie, Elaine, Felicia, Carol, Georgia, Helen, Ilene, Julia]

---

Master: [snake, lizard, frog, werewolf, vulture, dog, human]
Subset: [snake, werewolf, lizard, human, dog]
Result: [snake, frog, werewolf, lizard, vulture, human, dog]

---

Master: [Pete, Rob, Jeff, Stan, Chris, Doug, Reggie, Paul, Alex]
Subset: [Jeff, Stan, Pete, Paul]
Result: [Rob, Jeff, Stan, Pete, Chris, Doug, Reggie, Paul, Alex]

---

Master: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
Subset: [8, 1, 2, 12, 11, 10]
Result: [3, 4, 5, 6, 7, 8, 1, 2, 9, 12, 11, 10]

---

Master: [lol, rofl, lmao, roflmao, lqtm, smh, jk, wat]
Subset: [wat, lmao, rofl]
Result: [lol, roflmao, lqtm, smh, jk, wat, lmao, rofl]

नियम

• मानक खामियां, याददा यदा, सुविधाजनक I / O, blah blah।
• भले ही उदाहरण संख्याओं और तारों का उपयोग करते हैं, आपको केवल एक तत्व प्रकार का समर्थन करने की आवश्यकता है, चाहे वह पूर्णांक, तार, या अच्छी तरह से परिभाषित समानता शब्दार्थ के साथ कुछ और हो, जिसमें विषम सूची भी शामिल हो अगर आपकी भाषा सुविधाजनक हो।
• आप मान सकते हैं कि दोनों मास्टर सूची और सबसेट सूची में कोई डुप्लिकेट नहीं है
• आप मान सकते हैं कि सबसेट सूची में पाए गए सभी आइटम मास्टर सूची में पाए जाते हैं
• या तो सूची खाली हो सकती है
• आपको कम से कम, 100 तत्वों तक लंबे अरैज़ का समर्थन करना चाहिए।
• पुन: व्यवस्थित करना एक नई सूची / सरणी के निर्माण में या जगह के माध्यम से लागू किया जा सकता है।

हैप्पी गोल्फिंग!

Comments

एक अच्छी, मांसल समस्या।

— योना

क्या 8 1 3 4 5 6 7 2 9 12 11 10दूसरा-से-अंतिम एक वैध समाधान है?

— Ven

@ वी नं। भले ही वह सबटेट आइटम को एक ही रिश्तेदार क्रम में रखने की बाधाओं के भीतर फिट बैठता है, मैं यह सुनिश्चित करना चाहता था कि केवल एक सही उत्तर था, इसलिए पहले के आउट-ऑफ-ऑर्डर आइटम को बाद में स्थानांतरित किया जाना चाहिए बाद में आउट-ऑफ-ऑर्डर आइटम।

— बीफस्टर

यह क्यों मायने रखता है कि एक से अधिक सही उत्तर हैं? कृपया चुनौती के नियमों में बाधा जोड़ें।

— 14:14

Answer 1

रेटिना 0.8.2 , 51 बाइट्स

+`(\b(\w+),(\w+)\b.*¶.*\b)\3,(.*\b\2\b)
$1$4,$3
1A`

इसे ऑनलाइन आज़माएं! पहली पंक्ति पर सब-पासवर्ड की अल्पविराम से अलग सूची के रूप में इनपुट लेता है और दूसरी पंक्ति पर एक अल्पविराम से अलग शब्दों की मास्टर सूची। स्पष्टीकरण:

(\b(\w+),(\w+)\b.*¶.*\b)\3,(.*\b\2\b)

दो आसन्न उप-शब्द ढूँढें जहाँ दूसरा शब्द मास्टर सूची में पहला स्थान रखता है।

$1$4,$3

मास्टर सूची में पहले शब्द के बाद प्रकट होने के लिए दूसरे शब्द को स्थानांतरित करें।

+`

तब तक दोहराएं जब तक कोई शब्द क्रम से बाहर न दिखाई दे।

1A`

उपशब्द हटाएं।

Answer 2

जावास्क्रिप्ट (ईएस 6),  96 89 74  71 बाइट्स

यह एक भारी गड़बड़ी के रूप में शुरू हुआ और अंततः एक संक्षिप्त और सुरुचिपूर्ण रूप में सिकुड़ गया। मैं उस पर इसके उपयोगी सहयोग के लिए .splice () विधि का शुक्रिया अदा करना चाहता हूं । ;)

के रूप में इनपुट लेता है (master)(subset)। मास्टर सूची को अपडेट करके आउटपुट।

m=>s=>s.map(p=x=>m.splice(p,0,...m.splice(i=m.indexOf(x),p>i||!(p=i))))

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

कैसे?

$i$$p$

m.splice(p, 0, ...m.splice(i, condition))

$1$

• $i$$[element]$
• प्रसार सिंटैक्स के लिए धन्यवाद , इस तत्व को बाहरी .splice () के लिए एक 3 तर्क के रूप में विस्तारित किया जाता है , जो इसे स्थिति पर वापस डालने का कारण बनता है$p$

$0$

• भीतरी .plice () कुछ भी नहीं निकालता है और एक खाली सरणी देता है
• नतीजतन, बाहरी .splice () अपने 3 तर्क के रूप में अपरिभाषित प्राप्त करता है और कुछ भी नहीं डाला जाता है

टिप्पणी की गई

m => s =>                 // m[] = master list, s[] = subset list
  s.map(                  //
    p =                   // p = position in the master list of the last element from
                          //     the subset list (initialized to a non-numeric value)
    x =>                  // for each element x in the subset list:
    m.splice(             //   insert in the master list:
      p,                  //     at position p
      0,                  //     without removing any element
      ...m.splice(        //     remove from the master list and flatten:
        i = m.indexOf(x), //       i = position of x in the master list
        p > i             //       if p is greater than i, remove x from its current
                          //       position and insert it at position p
        || !(p = i)       //       otherwise, set p to i and don't remove/insert anything
      )                   //     end of inner splice()
    )                     //   end of outer splice()
  )                       // end of map()

Comments

"मैं शुक्रिया अदा करना चाहूंगा। (पीपीएलजी) ... के लिए विधि ..." क्यूसी पीपीसीजी ऑस्कर का संगीत ... :)

— चास ब्राउन

अधिक सही ढंग से, बाहरी ब्याह कॉल को क्रमशः 3 या 2 तर्क मिलते हैं, जो इसे सही काम करता है।

— नील

Answer 3

हास्केल, 79 बाइट्स

(m:n)#u@(s:t)|m==s=m:n#t|all(/=m)u=m:n#u|(x,_:z)<-span(/=s)n=(x++s:m:z)#u
m#_=m

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

(m:n)#u@(s:t)                 -- m: head of master list
                              -- n: tail of master list
                              -- s: head of subset
                              -- t: tail of subset
                              -- u: whole subset
   |m==s                      -- if m==s
        =m:n#t                -- return 'm' and append a recursive call with 'n' and 't'
   |all(/=m)u                 -- if 'm' is not in 'u'
             =m:n#u           -- return 'm' and append a recursive call with 'n' and 'u'
   |                          -- else (note: 's' is element of 'n')
    (x,_:z)<-span(/=s)n       -- split 'n' into a list 'x' before element 's' and
                              -- a list 'z' after element 's' and
       = (x++s:m:z)#u         -- make a recursive call with
                              -- x++s:m:z as the new master list (i.e. 'm' inserted into 'n' after 's') 
                              -- and 'u'
m # _ = m                     -- if either list is emtpy, return the master list

Answer 4

रूबी , 73 68 बाइट्स

->a,b{0while b.zip(a&b).find{|m,n|m!=n&&a=a[0..a.index(m)]-[n]|a};a}

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

कैसे?

• के बीच के चौराहे aऔर के bसभी तत्व शामिल हैं b, लेकिन उसी क्रम में जैसे हम उन्हें अंदर पाएंगेa
• इसलिए, यदि हम bसमानांतर में चौराहे पर और उस पर पुनरावृति करते हैं, जैसे ही हमें एक अंतर पता चलता है, हम एक तत्व को स्थानांतरित कर सकते हैं।
• हमारे द्वारा aपाए गए तत्व की स्थिति में कटौती करके स्थानांतरण किया जाता है b, फिर हम चौराहे में पाए गए तत्व को हटाते हैं, और फिर शेष को जोड़ते हैं।
• शुरुआत से दोहराएं, जब तक कि सभी तत्व bसही क्रम में न होंa

Comments

0 क्या कर रहा है 0while?

— योना

यह सिर्फ एक एनओपी है।

— जीबी

इसकी आवश्यकता क्यों है?

— योना

क्योंकि लूप शुरू करने से पहले एक चर घोषित करने से बचने के लिए तुलना और हेरफेर एक ही ब्लॉक में किया जाता है। इसका अर्थ है: "ऑपरेशन के सही होने पर कुछ भी न करें।", कोड "ऑपरेशन सही है, जबकि परिणाम सही है" से कम है

— GB

Answer 5

पायथन 2 , 124 109 106 99 96 बाइट्स

def f(a,b,i=0):
 while b[i+1:]:x,y=map(a.index,b)[i:i+2];i+=1;x>y>a.insert(x,a.pop(y))
 return a

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

Answer 6

पर्ल 6 , 40 बाइट्स

{*.permutations.first(*.grep(.any)eq$_)}

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

अनाम कोड ब्लॉक जो इनपुट f(subList)(masterList)को घुमाने ले जाता है (जैसे , और मास्टर सूची के अनुक्रमित का पहला लेक्सोग्राफ़िक क्रमांकन पाता है, जहां उप सूची के तत्व सही क्रम में हैं।

सहज रूप से, पहले संतोषजनक क्रमपरिवर्तन मूल क्रम में सही रूप से क्रमबद्ध तत्वों को छोड़ देगा, जबकि गलत तरीके से रखे गए लोगों को सही क्रम में आगे ले जाने के लिए न्यूनतम आवश्यक दूरी को आगे बढ़ाता है, जो उन्हें उपसमुच्चय में पिछले तत्व के बाद सीधे रखता है।

स्पष्टीकरण:

{*                                     } # Anonymous code block that returns a lambda
  .permutations                          # In all permutations of the master list
               .first(                )  # Find the first permutation
                     (*.grep(.any)       # Where the order of the subset
                                  eq$_   # Is the same as the given order

Answer 7

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

Œ!iⱮṢƑ¥ƇḢ

इसे ऑनलाइन आज़माएं! या टेस्ट सूट

अक्षम, विशेष रूप से बड़े मास्टर सूचियों के साथ। हर संभव क्रमपरिवर्तन उत्पन्न करता है, उन्हें फ़िल्टर करता है जहां सबसेट गलत क्रम में है, और फिर पहले रिटर्न देता है।

व्याख्या

Œ!        | Generate all permutations of the master list
      ¥Ƈ  | Filter including only those where...
  iⱮ      |   the index of each sublist item in this permutation...
     Ƒ    |   is...
    Ṣ     |   in order. 
        Ḣ | Finally take the first item

Comments

ऐसा नहीं लगता है कि यह नियम के अनुरूप होगा "जहां उप-सूची के अनुसार मास्टर सूची में दो तत्व हैं, जो आइटम पहले मास्टर सूची में है, उसे जल्द से जल्द सूचकांक में स्थानांतरित किया जाना चाहिए जहां यह है उप-सूची के भीतर अन्य मदों के सापेक्ष सही स्थान। (यानी बाद में तुरंत आइटम के बाद) "

— बीफ़स्टर

@Beefster यह उन लोगों पर काम करता है जो मैंने अब तक कोशिश की है। मुझे लगता है कि क्रमपरिवर्तन का क्रम ऐसा है कि यह सही परिणाम है। अगर कोई प्रतिघात हुआ तो गलत साबित होने में खुशी होगी।

— निक केनेडी

@Beefster मैंने अब महिला नामों और 1..12 को छोड़कर आपके सभी उदाहरणों की कोशिश की है और परिणाम का क्रम सही है।

— निक केनेडी

@Beefster मेरे जवाब में यह काम करने के लिए एक आंशिक स्पष्टीकरण है

— जो किंग

Answer 8

जे , 49 बाइट्स

[:(<@({:+i.@>:@-/)@i.~C.])^:(>/@i.~)&.>/]|.@;2<\[

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

व्याख्या

हम सब्मिट को लेफ्ट एर्ग के रूप में लेते हैं और फुल इनपुट को राइट के रूप में।

हम स्पष्टता के लिए एक विशिष्ट उदाहरण के साथ कोड के माध्यम से काम करेंगे:

5 2 4 f 1 2 3 4 5

सब्मिट के आकार के बॉक्सिंग वाले इनफ़िक्स लें:

2 <\ [

उत्पादन:

┌───┬───┐
│5 2│2 4│
└───┴───┘

उन्हें मूल इनपुट में जोड़ें, और पूरी चीज़ को उलट दें:

] |.@;

हमें मिला:

┌───┬───┬─────────┐
│2 4│5 2│1 2 3 4 5│
└───┴───┴─────────┘

समस्या को हल करने से ऊपर की तरफ दाएं से बाएं कमी हो जाती है। हमें केवल /वस्तुओं के बीच डालने के लिए सही क्रिया खोजने की आवश्यकता है ।

कटौती का प्रत्येक पुनरावृत्ति सही बॉक्स (पूर्ण इनपुट, जिसे हम परिवर्तित कर रहे हैं) को अपडेट करेगा, इसलिए यह जोड़ी द्वारा उसके बाईं ओर दिए गए क्रमबद्ध अवरोध के अनुरूप है। जब कमी समाप्त हो जाती है, तो इनपुट पूर्ण उप-क्रम का सम्मान करेगा।

यदि जोड़ी का क्रम इनपुट में आदेश देने के समान है, तो निम्नलिखित 0 का मूल्यांकन करेगा और हम कुछ नहीं करेंगे:

^:(>/@i.~)

अन्यथा यह 1 का मूल्यांकन करेगा और हम क्रिया को बाईं ओर लागू करेंगे ^:

   {: + i.@>:@-/)@i.~ C. ]

जो बाएँ आइटम को दाएँ आइटम के दाईं ओर ले जाता है। यह आन्दोलन दोनों तत्वों के बीच (और शामिल) सभी तत्वों का एक चक्रीय क्रमांकन है।

जम्मू में इस तरह के चक्रीय क्रमपरिवर्तन को लागू करने के लिए आदिम है:

<cyclic permutation definition> C. ]

और क्रिया के शेष कुछ भी नहीं है, लेकिन हमें उन अनुक्रमों को चुनना चाहिए जिन्हें हमें चक्र करने की आवश्यकता है:

{: + i.@>:@-/)@i.~

जो लगता है कि यह होना चाहिए की तुलना में लंबा है, लेकिन मैं उस वाक्यांश को आगे गोल्फ में सक्षम नहीं था।

अंत में हम परिणाम <@को फिर से जारी करते हैं और हम कर रहे हैं।

Answer 9

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

i@€MƤFṬœṗƲḊ;JḟF}W€ʋ@¥ṢFị

इसे ऑनलाइन आज़माएं! या टेस्ट सूट

व्याख्या

एक डाईएडिक लिंक जो उपसमूह को बाएं और मास्टर सूची को सही तर्क के रूप में लेता है। नीचे दिए गए उदाहरण में 9001, 42, 69, 1337, 420, 99, 255 को मास्टर के रूप में और 69, 9001, 1337 को सबसेट के रूप में उपयोग किया गया है।

i@€                      | Find the index of each subset item in the master list [3, 1, 4]
         Ʋ               | Previous 4 links as a monad
   MƤ                    | Find the index of the maximum for each prefix of this list [1, 1, 3]
     F                   | Flatten (because the previous result are actually each length one lists)
      Ṭ                  | Convert to a boolean list [1,0,1]
       œṗ                | Partition the [3, 1, 4] list before each 1 [[], [3, 1], [4]]
          Ḋ              | Remove the empty first list [[3, 1], [4]]
                    ¥    | Previous two links as a dyad
                  ʋ@     | Previous 4 links as a dyad with reversed arguments
            J            | Sequence along the master list [1, 2, 3, 4, 5, 6, 7]
             ḟF}         | Filter out items in the flattened [3, 1, 4] list
                W€       | Wrap each item as a list [[2], [5], [6], [7]]
           ;             | Concatenate rhis to the [[3, 1], [4]] list
                     Ṣ   | Sort (effectively by first item in each list) [[2], [3, 1], [4], [5], [6], [7]]
                      F  | Flatten
                       ị | Look up in original master list (and implicitly output)

Answer 10

C # (विजुअल C # इंटरएक्टिव कंपाइलर) , 118 बाइट्स

a=>b=>{for(int j;b.Any();)foreach(var e in b.Intersect(a.Take(j=a.IndexOf(b.Dequeue())))){a.Remove(e);a.Insert(j,e);}}

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

System.Collections.Genericनेमस्पेस में कुछ वर्गों का उत्थान। मास्टर एक है List<T>और सबसेट एक है Queue<T>।

// a: master
// b: subset
a=>b=>{
  // continue until b is empty
  for(int j;b.Any();)
    // iterate over values that are out of order in a
    // per the head of b using loop variable e
    foreach(var e in
      // the out of order values are determined by
      // intersecting remaining values in b with
      b.Intersect(
        // values in a occurring before the current head of b
        // save the position in a to variable j and remove the head of b
        a.Take(j=a.IndexOf(b.Dequeue()))
      )
    ){
      // push back the out of order element in a
      a.Remove(e);
      a.Insert(j,e);
    }
}