पृष्ठभूमि

मैं 3Blue1Brown के हाल के वीडियो से हार के बंटवारे की समस्या (या जैसा कि वह इसे, चुरा हुआ हार समस्या कहता है) और बोरसुक-उलम प्रमेय के साथ इसके संबंध से प्रेरित था ।

इस समस्या में, दो चोरों ने एक मूल्यवान हार चुरा लिया है जिसमें कई अलग-अलग प्रकार के गहने हैं। प्रत्येक प्रकार के गहने की एक समान संख्या होती है और चोर प्रत्येक आभूषण के प्रकार को समान रूप से उन दोनों के बीच विभाजित करना चाहते हैं। पकड़ यह है कि उन्हें ऐसा करना चाहिए कि कुछ संख्या में सन्निहित खंडों में हार को विभाजित करके उन दोनों के बीच के खंडों को वितरित करें।

यहाँ चार गहना प्रकार निरूपित किया जाता के साथ एक उदाहरण है S, E, D, और R(नीलम, पन्ना, हीरा, और गहरे लाल रंग का, क्रमशः के लिए)। मान लीजिए कि हार इस प्रकार है:

[S,S,S,E,S,D,E,R,S,R,E,S,S,S,D,R,E,E,R,E,D,E,R,R,D,E,E,E]

हैं 8नीलम, 10पन्ने, 4हीरे, और 6माणिक। हम हार को इस प्रकार विभाजित कर सकते हैं:

[[S],[S],[S,E,S,D,E,R,S],[R,E,S,S,S,D,R,E,E,R,E,D,E],[R,R,D,E,E,E]]

फिर यदि हम एक चोर को पहला, तीसरा और पाँचवाँ खंड देते हैं और दूसरे चोर को दूसरा और चौथा खंड देते हैं, तो प्रत्येक 4नीलम, 5पन्ना, 2हीरे और 3माणिक के साथ समाप्त होगा :

[S],    [S,E,S,D,E,R,S],                            [R,R,D,E,E,E]
    [S],                [R,E,S,S,S,D,R,E,E,R,E,D,E],

0-Indexing का उपयोग करते हुए, ये कटौती सूचकांकों में होती हैं [1,2,9,22]।

लक्ष्य

यह पता चला है कि इस तरह के एक निष्पक्ष विभाजन हमेशा सबसे अधिक nकटौती का उपयोग करके किया जा सकता है , जहां nगहने प्रकारों की संख्या है। आपका कार्य एक संपूर्ण कार्यक्रम या फ़ंक्शन लिखना है जो इनपुट के रूप में एक हार लेता है और न्यूनतम ऐसे विभाजन (कट्स की सबसे कम संख्या) को आउटपुट करता है।

इनपुट

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

आप मान सकते हैं कि इनपुट हार वैध है। आपको उस मामले को संभालने की आवश्यकता नहीं है जहां किसी प्रकार के गहने की एक विषम संख्या है या हार खाली है।

उत्पादन

फिर से, उत्पादन किसी भी सुविधाजनक प्रारूप में हो सकता है; जैसे खंडों की एक सूची, कट पदों की एक सूची, दो चोरों का प्रतिनिधित्व करने वाली कुंजियों वाला एक शब्दकोश और खंडों की सूची के मूल्यों का प्रतिनिधित्व करते हैं, आदि खंडों को उनके शुरुआती सूचकांक, अंत सूचकांक, लगातार सूचकांकों की सूची, जवाहरात की सूची, द्वारा दर्शाया जा सकता है, उनकी लंबाई, आदि आप 0- या 1- अनुक्रमण कर सकते हैं। यदि ऑर्डरिंग आपके प्रारूप के लिए महत्वपूर्ण नहीं है, तो आपका आउटपुट किसी भी क्रम में हो सकता है। यहाँ कई अलग-अलग स्वरूपों में उपरोक्त आउटपुट है:

list of segments: [[S],[S],[S,E,S,D,E,R,S],[R,E,S,S,S,D,R,E,E,R,E,D,E],[R,R,D,E,E,E]]
list of cuts:     [1,2,9,22]
list of lengths:  [1,1,7,13,6]
dictionary:       {'thief1' : [(R,R,D,E,E,E),(S),(S,E,S,D,E,R,S)], 'thief2' : [(S),(R,E,S,S,S,D,R,E,E,R,E,D,E)]}

ध्यान दें कि खंडों की सूची में महत्वपूर्ण है (चोरों के बीच वैकल्पिक खंड) और लंबाई की सूची (खंडों की पहचान करने के लिए), लेकिन कटौती या शब्दकोश की सूची में नहीं। संपादित करें: ग्रेग मार्टिन ने कहा कि ये वैध आउटपुट नहीं होंगे क्योंकि एक निष्पक्ष विभाजन को दो कटौती में प्राप्त किया जा सकता है

परीक्षण के मामलों

[1,2,1,2,1,3,1,3,3,2,2,3] -> [[1,2,1],[2,1,3,1],[3,3,2],[2,3]]
[1,1,1,1,2,2,3,3,3,3,3,3] -> [[1,1],[1,1,2],[2,3,3,3],[3,3,3]]
[1,1,1,1,1,1,1,1,1,1,1,1] -> [[1,1,1,1,1,1],[1,1,1,1,1,1]]
[1,1,1,1,2,3,4,2,3,4,2,2] -> [[1,1],[1,1,2,3,4,2],[3,4,2,2]]

यदि खंडों के क्रम को नहीं बदला गया है, तो टुकड़ों को एआईएफ और एआईएफ बी के बीच वैकल्पिक किया जाता है, जैसे कि आउटपुट में उस जानकारी को शामिल करना अनुप्रेषित है। अगर जवाब गहनों के क्रम को नहीं बदलता है तो क्या हम if संकेत को छोड़ सकते हैं? क्या आपके पास कुछ परीक्षण मामले हैं?

— ल्यूक

2

आपके उदाहरण के लिए [S,S,S,E,S,D,E,R,S,R,E,S,S,S,D,R,E,E,R,E,D,E,R,R,D,E,E,E], ऐसा लगता है कि आउटपुट होना चाहिए [[S,S,S,E,S,D,E,R],[S,R,E,S,S,S,D,R,E,E,R,E,D,E],[R,R,D,E,E,E]], क्योंकि इसमें कटौती की तुलना में कम है [[S],[S],[S,E,S,D,E,R,S],[R,E,S,S,S,D,R,E,E,R,E,D,E],[R,R,D,E,E,E]]। क्या मैं युक्ति को सही ढंग से समझ रहा हूँ?

— ग्रेग मार्टिन

3

ब्रेकीलॉग , 13 बाइट्स

~c.ġ₂z₁Ċcᵐoᵛ∧

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

नोट: ᵛइस चुनौती की तुलना में रूपक बहुत नया है।

व्याख्या

~c.ġ₂z₁Ċcᵐoᵛ∧  Input is a list, say L = [1,2,2,2,1,2,3,3]
~c.            Output is a partition of the input: [[1,2,2],[2,1,2],[3],[3]]
  .ġ₂          Split the output into chunks of length 2: [[[1,2,2],[2,1,2]],[[3],[3]]]
     z₁        Zip (transpose) the chunks: [[[1,2,2],[3]],[[2,1,2],[3]]]
       Ċ       This is a 2-element list (forbid the trivial partition).
        cᵐ     Concatenate both: [[1,2,2,3],[2,1,2,3]]
          oᵛ   If you sort both lists, they are equal.
            ∧  Don't unify with the output.

विभाजन की संख्या के बढ़ते क्रम में विभाजन की गणना की जाती है, इसलिए परिणाम में यथासंभव कुछ ब्लॉक होंगे।

— Zgarb
स्रोत

3

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

s2ZFṢ$€E¬,L
ŒṖṖÇÞḢ

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

कुशल नहीं है - उदाहरण में 28 गहने हैं जो इस संसाधन के पहले कदम के बाद से विशाल संसाधनों के बिना काम नहीं करेंगे, 2 ²⁷ संभावित विभाजन की सूची बनाना होगा ।

सूची की सूची लौटाता है - वैकल्पिक चोरों के बीच उन्हें बाहर करने के क्रम में खंड। (पुनः TIO आउटपुट: जब एक सूची में केवल एक ही आइटम होता है तो निहित प्रिंट कोष्ठक से परेशान नहीं होता है [])

कैसे?

s2ZFṢ$€E¬,L - Link 1, get (isUnfair, Slices): A possible partition
s2          - split into slices of length 2 (any odd one on it's own at the end)
  Z         - transpose (first item is one thief's slices, second is the others)
     $€     - last two links as a monad for €ach
   F        -     flatten
    Ṣ       -     sort
       E    - equal? (theif1's jewels == theif2's jewels)
        ¬   - not
          L - length (number of slices in the partition)
         ,  - pair

ŒṖṖÇÞḢ - Main link: necklace
ŒṖ     - all partitions
  Ṗ    - pop, we must remove the rightmost one...
              because Link 1 will say it is fair, and it will have length 1!
              (a list of one thing has all entries equal)
    Þ  - sort by
   Ç   -     last link (1) as a monad
     Ḣ - head (get the first one, i.e. minimal isUnfair, then minimal length)

— जोनाथन एलन
स्रोत

3

गणितज्ञ, ११hem बाइट्स

लगभग जेली को हरा दिया ... सिर्फ 1 बंद;)

SelectFirst[l_±c_:=Append[-#±Most@c,#2]&@@l~TakeDrop~Last@c;l_±{}:={l};i=#;(i±#)&/@Range@#2~Subsets~#3,Tr[Tr/@#]==0&]&

तीन तर्कों को लेते हुए शुद्ध कार्य: हार, जैसे कि टोकन की सूची {A, A, A, A, B, C, D, B, C, D, B, B}; हार की लंबाई; और विशिष्ट गहना समय की संख्या। यह फॉर्म में मौजूद उदात्त लोगों की सूची देता है {{A, A}, {-A, -A, -B, -C, -D, -B}, {C, D, B, B}}, जहां बिना नकारात्मक संकेतों के टोकन एक चोर के पास जाते हैं और नकारात्मक संकेतों वाले टोकन दूसरे चोर के पास जाते हैं। (हालांकि यह निरर्थक जानकारी है, एल्गोरिथ्म इस प्रतिनिधित्व की ओर जाता है, और नकारात्मक संकेतों को हटाने से कई बाइट्स खर्च होंगे।)

पहले हमें एक फ़ंक्शन को लागू करना होगा जो एक सूची और nकट-स्थानों का एक सेट लेता है और n+1उन nकट-स्थानों पर इनपुट सूची को काटकर प्राप्त उप- सूची की सूची देता है ; बाइनरी इन्फिक्स ऑपरेटर ±का उपयोग इस उद्देश्य के लिए किया जाता है, और पुनरावर्ती रूप से परिभाषित किया जाता है l_±c_:=Append[-#±Most@c,#2]&@@l~TakeDrop~Last@c;l_±{}:={l};। नकारात्मक संकेत सही होने के कारण Append, इसका परिणाम यह है कि सब्लिस्ट बारी-बारी से करते हैं और प्रत्येक टोकन से जुड़े नकारात्मक संकेत नहीं होते हैं।

फिर हम सभी संभव कट-जगह सेट जिसकी लंबाई गहना प्रकारों का उपयोग करने की संख्या अधिक से अधिक है उत्पन्न Range@#2~Subsets~#3, और उपयोग i=#;(i±#)&/@को लागू करने के ±बदले में इन कट-जगह सेटों में से प्रत्येक के लिए (जवाहरात के इनपुट सूची के साथ) ऑपरेटर।

अंत में, SelectFirst[...,Tr[Tr/@#]==0&]&परिणामी हार डिवीजनों में से पहला उठाता है जो उचित है। यह शाब्दिक रूप से सभी उपशाखाओं में सभी तत्वों को जोड़कर करता है; गणितज्ञ स्पष्ट रूप से प्रत्येक टोकन की सकारात्मक और नकारात्मक प्रतियों को रद्द करने के लिए पर्याप्त बुद्धिमान है।

— ग्रेग मार्टिन
स्रोत

3

पायथ, 16 बाइट्स

hfqFSMsM.TcT2t./

इसे ऑनलाइन आज़माएँ: प्रदर्शन या टेस्ट सूट

स्पष्टीकरण:

hfqFSMsM.TcT2t./Q   implicit Q (=input) at the end
              ./Q   create all partitions of the input list 
                    (they are already sorted by number of cuts)
             t      remove the partition with zero splits
 f                  filter for partitions T, which satisfy:
          cT2          chop into pieces of length 2
        .T             transpose to get the pieces of each thieve
    SMsM               combine all pieces for each thieve and sort the results
  qF                   check if they got the same jewels
h                   print the first such partition

— Jakube
स्रोत

1

05AB1E , 14 बाइट्स

.œ¨ʒ2ôζε˜{}Ë}¤

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

.œ                # All partitions of the (implicit) input
                  #  i.e. [2,3,2,1,3,1]
                  #   → [[[2],[3],[2],[1],[3],[1]],[[2],[3],[2],[1],[3,1]],
                  #      ...,[[2,3,2,1,3,1]]]
  ¨               # Remove the last one
   ʒ        }     # Filter this list by:
    2ô            # Split it into parts of 2
                  #  i.e. [[2,3],[2],[1],[3,1]] → [[[2,3],[2]],[[1],[3,1]]]
                  #  i.e. [[2,3,2],[1,3],[1]] → [[[2,3,2],[1,3]],[[1]]]
      ζ           # Swap rows and columns (using space as filler if necessary)
                  #  i.e. [[[2,3],[2]],[[1],[3,1]]] → [[[2,3],[1]],[[2],[3,1]]]
                  #  i.e. [[[2,3,2],[1,3]],[[1]]] → [[[2,3,2],[1]],[[1,3]," "]]
       ε  }       # Map each inner list to:
        ˜         # Flatten the list
                  #  i.e. [[2,3],[1]] → [2,3,1]
                  #  i.e. [[1,3]," "] → [1,3," "]
         {        # Sort the list
                  #  i.e. [2,3,1] → [1,2,3]
                  #  i.e. [1,3," "] → [1,3," "]
           Ë      # Check if both sorted lists are equal
                  # (if not, remove them from the partitions)
             ¤    # After filtering, take the last one as result (and output implicitly)
                  #  i.e. [[[2],[3,2],[1,3],[1]],[[2,3],[2],[1],[3,1]]]
                  #   → [[2,3],[2],[1],[3,1]]

— केविन क्रूज़सेन
स्रोत

हार बंटवारे की समस्या