गुप्त सांता - पर दोबारा गौर किया

Question

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

मेरे जीवन को आसान बनाने के लिए, आपका कार्य एक फ़ंक्शन (या आपकी भाषा में निकटतम विकल्प) लिखना है, जब किसी सरणी (या आपकी चुनी हुई भाषा में निकटतम विकल्प) दिया जाता है, तो रिटर्न (या आउटपुट) 'उपहार देने वालों' की एक जोड़ी बनती है बाइट्स में कम से कम संभव कोड में 'giftees', जैसे कि निम्न स्थितियां पूरी होती हैं:

• प्रत्येक नाम को दूसरे के साथ जोड़ा जाता है, बेतरतीब ढंग से चयनित, इनपुट डेटा से नाम (ध्यान दें कि यह हमेशा उपलब्ध स्थितियों के आधार पर आउटपुट को यादृच्छिक करने के लिए संभव नहीं हो सकता है)
• नामों को फ़्लैग की एक सूची के साथ प्रदान किया जाएगा जो क्रमबद्ध सुसंगतता के साथ एक आसन्न मैट्रिक्स का प्रतिनिधित्व करते हैं , ताकि स्तंभ nपंक्ति के समान व्यक्ति को संदर्भित करता है n।
• यदि शर्तों को पूरा नहीं किया जा सकता है, तो अपनी भाषा में कुछ मिथ्या लौटें।
• यदि कई समाधान हैं, तो आपका प्रोग्राम कई बार चलने पर उन सभी को उत्पन्न करने में सक्षम होना चाहिए।

आप यह मान सकते हैं कि आप नकली नाम के साथ प्रस्तुत किया कभी नहीं होगा के रूप में हम बताते हैं कि किस परिवार के सदस्य जो है में सक्षम होना चाहिए, लेकिन आप डेटा है कि अंतर करने के लिए रिक्त स्थान शामिल किए जा सकते हैं Bob Seniorसे Bob Junior! यह बहुत बड़े परिवारों के लिए एक घंटे के भीतर सभी आपूर्ति किए गए परीक्षण मामलों को पूरा करना चाहिए, जैसे कि स्रोत डेटा में 100 अद्वितीय नाम (कृपया नीचे दिए गए उदाहरण डेटा सेट देखें, आपको आवंटित समय के भीतर इन सभी को पार्स करने में सक्षम होना चाहिए)।

उदाहरण इनपुट:

santa([
    ["Alice", 0, 0, 1, 1, 1, 1, 1],
    ["Bob",   0, 0, 0, 0, 0, 1, 0],
    ["Carla", 1, 1, 0, 0, 0, 1, 1],
    ["Dan",   1, 1, 0, 0, 0, 1, 1],
    ["Erin",  1, 1, 0, 0, 0, 1, 1],
    ["Frank", 1, 1, 1, 1, 1, 0, 1],
    ["Gary",  1, 1, 1, 1, 1, 1, 0]
]);
// might return something like:
[
    ["Alice", "Erin"],
    ["Bob", "Frank"],
    ["Carla", "Alice"],
    ["Dan", "Gary"],
    ["Erin", "Bob"],
    ["Frank", "Dan"],
    ["Gary", "Carla"]
]

santa([
    ["Alice", 0, 1, 1, 1, 0, 1],
    ["Bob",   0, 0, 1, 1, 0, 1],
    ["Carla", 0, 1, 0, 1, 0, 1],
    ["Dan",   0, 1, 1, 0, 0, 0],
    ["Erin",  0, 0, 1, 0, 0, 1],
    ["Frank", 1, 1, 1, 1, 1, 0]
]);
false

santa([
    ["Alice", 0, 1, 1],
    ["Bob",   1, 0, 1],
    ["Carla", 1, 1, 0]
]);
[
    ["Alice", "Bob"],
    ["Bob", "Carla"],
    ["Carla", "Alice"]
]

भाषा के आधार पर, इनपुट अन्य स्वरूपों में हो सकता है, उदाहरण के लिए विवरण STDIN इस प्रकार प्रदान किया जा सकता है:

script <<< 'Alice,0,0,1,1,1,1,1
Bob,0,0,0,0,0,1,0
Carla,1,1,0,0,0,1,1
Dan,1,1,0,0,0,1,1
Erin,1,1,0,0,0,1,1
Frank,1,1,1,1,1,0,1
Gary,1,1,1,1,1,1,0'

आउटपुट किसी भी समझदार प्रारूप में प्रदान किया जा सकता है, जो भी आपकी भाषा के लिए सबसे आसान है। स्वीकार्य स्वरूपों में सरणियों का एक सरणी शामिल है (ऊपर के रूप में) या शायद एक हैश / Object/ साहचर्य सरणी या यहां तक ​​कि सिर्फ पैरिंग्स को प्रिंट करना STDOUT:

Alice:Dan
Bob:Erin
Carla:Bob
Dan:Alice
Erin:Frank
Frank:Carla

यदि संदेह है, तो कृपया अपने जवाब के साथ आवश्यक इनपुट प्रारूप और अपेक्षित आउटपुट प्रारूप के उदाहरण पूछें और प्रदान करें।

संदर्भ जावास्क्रिप्ट कार्यान्वयन ।

बड़े डेटा सेट: 100 , 100 , 200 , 200 - कई समाधान , 200 - केवल एक समाधान ।

संदर्भ कार्यान्वयन मेरी मशीन पर <4s में इन सभी को पूरा करता है।

ऊपर इस स्क्रिप्ट के साथ उत्पन्न सेट ।

Comments

क्या हम यह मान सकते हैं कि अभिभावकों के तत्व मूल क्रम के समान ही हैं? और यह कि 1kth सबरेरे में (n + 1) वें तत्व का अर्थ है कि kth व्यक्ति nth व्यक्ति को दे सकता है?

— msh210

@ msh210 वास्तव में, क्रिया नहीं होने के लिए माफी, मैं पुष्टि करने के लिए प्रश्न को अपडेट करूंगा।

— डोम हेस्टिंग्स 10

पहले उदाहरण में, यह कहां से मानचित्रण प्रदान करता Bobहै Erin? मैं बस से एक को देखने Erinके लिए Bob।

— लीजनमोनमल 978 12

@ LegionMammal978 आह, यह एक उत्कृष्ट प्रश्न है और केवल एक संपादन द्वारा उत्तर दिया जा सकता है ... क्षमा याचना! फिक्स्ड!

— डोम हेस्टिंग्स

N0! यह क्रिसमस के लिए जल्दी रास्ता है! यह गुप्त तुर्की होना चाहिए जो प्रस्तुत करता है।

— ग्रांट डेविस

Answer 1

जावास्क्रिप्ट ईएस 6, 191

यह समाधान जोड़े की सूची की सूची के रूप में सभी संभावित जोड़ देता है:

f=l=>(h=l=>l.length,n=l.map(i=>i.shift()),o=[],(r=s=>(g=h(s))<h(n)?l[g].map((e,x)=>e&&r([...s,x])):o.push([...s]))([]),o.filter(i=>h([...new Set(i)])==h(n)).map(l=>l.map((t,f)=>[n[f],n[t]])))

उदाहरण रन:

>> example = f([
    ["Alice", 0, 0, 1, 1, 1, 1, 1],
    ["Bob",   0, 0, 0, 0, 0, 1, 0],
    ["Carla", 1, 1, 0, 0, 0, 1, 1],
    ["Dan",   1, 1, 0, 0, 0, 1, 1],
    ["Erin",  1, 1, 0, 0, 0, 1, 1],
    ["Frank", 1, 1, 1, 1, 1, 0, 1],
    ["Gary",  1, 1, 1, 1, 1, 1, 0]])

<< Array [ Array[7], Array[7], Array[7], Array[7], Array[7], Array[7], Array[7], Array[7], Array[7], Array[7], 26 more… ]

>> example[0]

<< Array [ "Alice:Carla", "Bob:Frank", "Carla:Alice", "Dan:Bob", "Erin:Gary", "Frank:Dan", "Gary:Erin" ]

Comments

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

— डोम हेस्टिंग्स