क्रमपरिवर्तन कबूतर-छेद सिद्धांत


25

सुडोकू के खेल में, कई खिलाड़ी "पेंसिल" को संभव संख्या में पसंद करते हैं जो प्रत्येक वर्ग में जा सकते हैं:

सुडोकू पंक्ति

उपरोक्त पंक्ति को एक सरणी के रूप में दर्शाया जा सकता है:

[[1,2,9], [6], [5], [7], [1,2,9], [1,2,9], [3], [1,2,4], [8]]

अब, ध्यान दें कि केवल 1 जगह है जहां कोई भी 4जा सकता है। यह प्रभावी रूप से हमें उपरोक्त सूची को सरल बनाने देता है:

[[1,2,9], [6], [5], [7], [1,2,9], [1,2,9], [3], [4], [8]]

इस चुनौती का लक्ष्य एक क्रमपरिवर्तन में संभावित संख्याओं की सूची लेना है, और यह सुनिश्चित करना है कि किन संभावनाओं को समाप्त किया जा सकता है

एक अन्य उदाहरण के रूप में, आपको यह बताने की संभावना है कि आपके पास निम्नलिखित संभावनाएँ हैं:

[[0,1,3], [0,2,3], [1,2], [1,2]]

अंतिम दो स्थानों को 1 और 2 से भरा जाना चाहिए। इसलिए, हम उन संभावनाओं को पहले दो तत्वों से हटा सकते हैं:

[[0,3], [0,3], [1,2], [1,2]]

एक अन्य उदाहरण के रूप में:

[[0,1,2,3], [0,2], [0,2], [0,2]]

इसके असंभव , ऊपर संभावनाओं से एक क्रमपरिवर्तन के निर्माण के लिए दोनों के लिए केवल 1 स्थान के रूप में 1और 3, और आप एक खाली सरणी वापस जाने के लिए चाहते हैं।

आपको संभावनाओं की एक सूची इनपुट करने की आवश्यकता है और अधिकतम संभावनाओं को समाप्त करने के बाद शेष संभावनाओं को आउटपुट करना है।

  • यदि कोई विशेष सरणी असंभव है, तो आपको या तो एक खाली सरणी वापस करने की आवश्यकता है, या एक सरणी जहां एक सबरेज़ खाली है।
  • आप मान सकते हैं कि सरणी अच्छी तरह से बनाई जाएगी, और इसमें कम से कम 1 तत्व होगा।
  • आकार की एक सरणी को देखते हुए N, आप मान सकते हैं कि सबर्रे में संख्या हमेशा सीमा में होगी [0:N), और वहN <= 10
  • आप कल्पना नहीं कर सकते हैं कि हर नंबर 0के लिए N-1उपस्थित रहेंगे
  • आप मान सकते हैं कि एक अकेले उप-क्षेत्र के भीतर की संख्याएँ अद्वितीय हैं।
  • यदि किसी सबर्रे में केवल एक ही संभावना होती है, तो आप या तो किसी सरणी में या संभावना का प्रतिनिधित्व कर सकते हैं। [[1],[2],[0]], [1,2,0], [[1,2],0,[1,2]]सभी मान्य हैं।
  • आप सरणी को या तो एक उचित स्ट्रिंग प्रारूप में या सूची / सरणी प्रारूप में स्वीकार कर सकते हैं।
  • सबरेज़ किसी भी क्रम में हो सकते हैं।
  • रैग्ड एरे से निपटने के बजाय, आप खाली जगहों को पैड कर सकते हैं -1

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

[[0]]                                         -> [[0]]
[[1],[0]]                                     -> [[1],[0]]
[[1],[1]]                                     -> []
[[1],[0,1]]                                   -> [[1],[0]]
[[0,1,2],[1,2],[1,2]]                         -> [[0],[1,2],[1,2]]
[[0,1],[1,2],[0,2]]                           -> [[0,1],[1,2],[0,2]]
[[2,1],[1,2],[1,2]]                           -> []
[[0,3],[2,1],[3,0],[3,2]]                     -> [[0,3],[1],[0,3],[2]]
[[0,1],[0,1],[2,3],[2,3,0]]                   -> [[0,1],[0,1],[2,3],[2,3]]
[[0,1],[0,3],[3,2],[0]]                       -> [[1],[3],[2],[0]]
[[3,5,2],[0,2,4],[4,0],[0,1,3,5],[2,1],[2,4]] -> [[3,5],[0,2,4],[4,0],[3,5],[1],[2,4]]
[[6,9,8,4],[4,5],[5,3,6],[3,8,6,1,4],[3,1,9,6],[3,7,0,2,4,5],[9,5,6,8],[6,5,8,1,3,7],[8],[8,0,6,2,5,6,3]] -> [[6,9,4],[4,5],[5,3,6],[3,6,1,4],[3,1,9,6],[0,2],[9,5,6],[7],[8],[0,2]]
[[3,5,0],[5,7],[5,1,2],[1,3,0],[5,3],[5,0],[5,3,7,8,0,6],[7,5,0,1,8],[1,0,8],[0,6]] -> []
[[9,0,2,3,7],[0,7,6,5],[6,9,4,7],[9,1,2,3,0,5],[2,8,5,7,4,6],[6,5,7,1],[5,9,4],[5,9,3,8,1],[5,0,6,4],[0,7,2,1,3,4,8]] -> [[9,0,2,3,7],[0,7,6,5],[6,9,4,7],[9,1,2,3,0,5],[2,8,5,7,4,6],[6,5,7,1],[5,9,4],[5,9,3,8,1],[5,0,6,4],[0,7,2,1,3,4,8]]
[[2,6,0],[0,4,3],[0,6,2],[0,7],[0,9,2,3,6,1,4],[1,7,2],[2,7,8],[8,6,7],[6,5,2,8,0],[5,8,1,4]] -> [[2,6,0],[3],[0,6,2],[0,7],[9],[1],[2,7,8],[8,6,7],[5],[4]]
[[8],[8,0,6,5,7,2,4,1],[8,6,9,3,5,0,7],[3,9,1,0],[9],[9,2,6],[2,8,3],[3,1,6,8,2],[6],[6,4,5,3,0,7]] -> [[8],[5,7,4],[5,7],[0],[9],[2],[3],[1],[6],[4,5,7]]
[[8,1,0],[5,8,7,6,2,0],[6,8,2],[2,4,0,9],[4,1,7,3,6,8],[8,1],[8,0,3],[0,8,2],[0,8,3],[1,8,0]] -> []

यह एक इसलिए अपने उत्तरों को यथासंभव छोटा करें!


9 से अधिक कोई संख्या?
लीक

आपको 9. से अधिक संख्या का समर्थन करने की आवश्यकता नहीं है
नाथन मेरिल

क्या मैं उपशीर्षकों में डुप्लिकेट के साथ वापस आ सकता हूं?
लीक नून

@LeakyNun सं। सबरेज़ में केवल अनन्य तत्व हो सकते हैं।
नाथन मेरिल

मुझे लगता है कि आपको अपने चौथे परीक्षण मामले में कुछ गलतियाँ मिली हैं; सब्लिस्ट्स में से एक डबल-ब्रैकेटेड है।
TheBikingViking

जवाबों:


17

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

:1fz:da|,[]
:2a#d
:Am

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

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

विधेय 0 (मुख्य विधेय)

:1fz:da|,[]
:1f            Find all solutions of Predicate 1 using Input as Input.
   z           Transpose
    :da        Deduplicate each.
       |,[]    If there is no solution, return [] instead.

विधेय 1 (सहायक विधेय 1)

:2a#d
:2a     Each element of Output satisfies Predicate 2 with each element of Input as Input
   #d   Each element is different

विधेय 2 (सहायक विधेय 2)

:Am     Output is member of Input

8

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

Œp⁼Q$ÐfZQ€

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

Œp⁼Q$ÐfZQ€   Main chain, argument: z

Œp           Cartesian product
  ⁼Q$Ðf      Filter for those that remain unchanged when uniquified
       Z     Transpose
        Q€   Uniquify each subarray

यह 10 बाइट्स का दावा करने के लिए थोड़ा विवादास्पद लगता है जब जेली लैटिन 1 के बाहर के पात्रों का उपयोग करती है। UTF-8 के रूप में प्रस्तुत किए गए उपरोक्त अनुक्रम में 16 बाइट्स की आवश्यकता है।
क्रिस बेके

1
@ क्रिसबेक जेली का अपना खुद का
चरित्र है

और फिर भी - अगर मैं इसे ऑनलाइन कोशिश करता हूं! - मुझे 16 बाइट भेजने की आवश्यकता है।
क्रिस बेक

@ChrisBecke हाँ, लेकिन अगर आप जेली डाउनलोड करते हैं तो आपको केवल 10-बाइट प्रोग्राम लिखना होगा।
लीक नन

और इसे एक टेक्स्ट फाइल में सेव करें जिसे मैं जेली के अलावा और किसी चीज के साथ एडिट नहीं कर सकता हूं? उस तर्क से अगर जेली ने अपने कार्यक्रम को संकुचित कर दिया तो हमें केवल संकुचित बाइट्स की गणना करनी चाहिए?
बजे क्रिस बेके




2

पायथन 3, 101 99 बाइट्स

-2 बाइट्स के लिए @ टीएलडब्ल्यू को धन्यवाद

from itertools import*
lambda x:list(map(set,zip(*[i for i in product(*x)if len(i)==len(set(i))])))

एक अनाम फ़ंक्शन जो सूची की सूची के तर्क के माध्यम से इनपुट लेता है और सेट की एक सूची देता है।

यह काम किस प्रकार करता है

from itertools import*        Import Python's library for iterator generation
lambda x                      Anonymous function with input possibilities x as a
                              list of lists
...for i in product(*x)...    For i in the Cartesian product of x, ie all candidate
                              arrangements:
[...if len(i)==len(set(i))]    Filter into list by non-duplicity (set removes
                               duplicates, so there are no duplicates if the length
                               of i is the same as the length of the set of
                               the elements of i)
zip(*...)                     Unpack and take the transpose, leaving the modified
                              possibilities with duplicates
map(set,...)                  Remove duplicates
:list(...)                    Return the modified possibilities as a list of sets

Ideone पर इसे आज़माएं


list(map(set,छोटा है, मुझे लगता है
TLW

2

मैथेमेटिका, 46 बाइट्स

Union/@Thread@Select[Tuples@#,DuplicateFreeQ]&

0

PHP, 245 231 बाइट्स

कार्टेजियन उत्पाद फ़ंक्शन के लिए 131 117, अन्य सामान के लिए 114

function c($a){if ($a){if($u=array_pop($a))foreach(c($a)as$p)foreach($u as$v)yield $p+[count($p)=>$v];}else yield[];}
function p($a){foreach(c($a)as$i)if(max(array_count_values($i))<2)foreach($i as$k=>$v)$r[$k][$v]=$v;return$r?:[];}

मैं कार्टेशियन उत्पाद के लिए एक पुनरावर्ती कार्य के साथ कुछ परीक्षण मामलों पर स्मृति मुद्दों में भाग गया। इस जनरेटर वर्ग और के साथ बेहतर काम किया function c($a){$b=[];foreach($a as$i)$b[]=new \ArrayIterator($i);return new CartesianProductIterator($b);}
लेकिन मेरे जेनरेटर छोटा है और वही काम करता है।

हालाँकि, बड़े उदाहरणों में मेरी मशीन पर थोड़ी देर बाद एक आंतरिक सर्वर त्रुटि (पुनरावृत्ति और जनरेटर दोनों के साथ) होती है। वर्तमान में सर्वर लॉग की जांच करने का कोई समय नहीं है, दुर्भाग्य से।

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.