कितने फेरबदल किए

Question

एक राइफल फेरबदल एक प्रकार का फेरबदल है जहां डेक को दो भागों में विभाजित किया जाता है और विभाजन फिर से एक नया फेरबदल डेक बनाने के लिए एक साथ spliced ​​होते हैं।

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

प्रत्येक राइफल फेरबदल को तब कार्ड के मूल डेक के क्रमचय के रूप में देखा जा सकता है। उदाहरण के लिए क्रमपरिवर्तन

1,2,3 -> 1,3,2

एक व्याकुल फेरबदल है। यदि आप डेक को ऐसे ही विभाजित करते हैं

1, 2 | 3

हम देखते हैं कि हर कार्ड में 1,3,2विभाजन के हर दूसरे कार्ड के सापेक्ष समान क्रम है। 2अभी भी है 1।

दूसरी ओर निम्नलिखित क्रमपरिवर्तन एक राइफल फेरबदल नहीं है।

1,2,3 -> 3,2,1

हम इसे सभी दो (गैर-तुच्छ) विभाजनों के लिए देख सकते हैं

1, 2 | 3
1 | 2, 3 

कार्ड की एक जोड़ी है जो उनके सापेक्ष आदेशों को बनाए नहीं रखते हैं। पहले विभाजन में 1और 2उनके क्रम को बदलते हैं, जबकि दूसरे विभाजन में 2और 3उनके क्रम को बदलते हैं।

हालांकि हम देखते हैं कि 3, 2, 1दो राइफल के फेरबदल की रचना की जा सकती है,

1, 3, 2 + 2, 3, 1 = 3, 2, 1

वास्तव में सिद्ध होने के लिए एक बहुत ही सरल तथ्य यह है कि किसी भी क्रमपरिवर्तन को कुछ संख्या में राइफल फेरबदल क्रमपरिवर्तन के संयोजन से बनाया जा सकता है।

कार्य

आपका कार्य एक प्रोग्राम या फ़ंक्शन करना है जो इनपुट के रूप में एक क्रमचय (आकार एन ) लेता है और छोटी संख्या में राइफल फेरबदल क्रमपरिवर्तन (आकार एन ) का उत्पादन करता है जिसे इनपुट क्रमचय बनाने के लिए संयोजित किया जा सकता है। आपको राइफल को खुद से फेरबदल करने की आवश्यकता नहीं है कि कितने हैं।

यह कोड-गोल्फ है इसलिए उत्तर बाइट्स में कम बाइट के साथ बेहतर स्कोर किए जाएंगे।

आप एक पहचान क्रमचय के लिए या तो 1 या 0 आउटपुट कर सकते हैं।

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

1,3,2 -> 1
3,2,1 -> 2
3,1,2,4 -> 1
2,3,4,1 -> 1
4,3,2,1 -> 2

Comments

तो, क्या हम RiffleSort एल्गोरिदम जल्द ही देख पाएंगे?

— mbomb007

नहीं 4,3,2,1होना चाहिए 2? पहले हम मध्य और लाभ 3,1,4,2में विभाजित होते हैं और फिर हम बीच में फिर से विभाजित हो जाते हैं और उसी क्रमांकन का उपयोग करते हैं

— Halvardamm

@HalvardHummel यह सही है। मुझे अपने संदर्भ कार्यान्वयन के साथ समस्या का पता लगाना होगा।

— पोस्ट रॉक गार्फ हंटर

Answer 1

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

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

lambda x:f(range(1,len(x)+1),x)
f=lambda x,y,i=0:x==y and i or i<len(x)and min(f(q,y,i+1)for a in range(1,len(x))for q in g(x[:a],x[a:]))or i
g=lambda x,y:(x or y)and[[v]+q for v in x[:1]for q in g(x[1:],y)]+[[v]+q for v in y[:1]for q in g(x,y[1:])]or[[]]

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

Answer 2

क्लीन , 206 ... 185 बाइट्स

import StdEnv
f=flatten
$a b#[c:d]=b
|a>[]#[u:v]=a
=[a++b,b++a:f[[[u,c:e],[c,u:e]]\\e<- $v d]]=[b]
@l#i=length l
=hd[n\\n<-[0..],e<-iter n(f o map(uncurry$o splitAt(i/2)))[[1..i]]|l==e]

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

फेरबदल के हर संभव परिणाम उत्पन्न करता है n, और जाँचता है कि सूची सदस्य है या नहीं।
हालांकि यह समस्या को हल करने के लिए एक बहुत ही अक्षम तरीका है, यह कोड विशेष रूप से धीमा है रचना के बजाय सूची बोध के उपयोग के कारण , जो कि किसी भी प्राथमिक ग्राफ में कमी को सीमित करता है, और स्वच्छ कचरा संग्रहकर्ता के शानदार प्रदर्शन के परिणामस्वरूप होता है।

Ungolfed:

import StdEnv
shuffle [] l
    = [l]
shuffle [a: b] [c: d]
    = [[a: b]++[c: d], [c: d]++[a: b]: flatten [
        [[a, c: e], [c, a: e]]
        \\ e <- shuffle b d
        ]]
numReq l
    = until cond ((+)1) 0
where
    cond n 
        = let
            mapper
                = map (uncurry shuffle o splitAt (length l/2))
            options
                = iter n (removeDup o flatten o mapper) [[1..length l]]
        in isMember l options

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