दोहराने तक परिवर्तनों की संख्या

Question

पूर्णांकों के अनुक्रम को देखते हुए या 0..N निम्नलिखित के रूप में इस क्रम को रूपांतरित करने के लिए अधिक विशिष्ट होना

• आउटपुट [x] = रिवर्स (इनपुट [इनपुट [x]])
• दोहराना

उदाहरण के लिए: [2,1,0]बन जाता है [0,1,2]और उलट हो जाता है [2,1,0]। [0,2,1]बन जाता है [0,1,2]और उलट हो जाता है [2,1,0]।

उदाहरण 1

In:   0 1 2
S#1:  2 1 0
S#2:  2 1 0
Output: 1

उदाहरण 2

In:   2 1 0
S#1:  2 1 0
Output: 0

उदाहरण 3

In:   3 0 1 2
S#1:  1 0 3 2
S#2:  3 2 1 0
S#3:  3 2 1 0
Output: 2

उदाहरण 4

In:   3 0 2 1
S#1:  0 2 3 1
S#2:  2 1 3 0
S#3:  2 0 1 3
S#4:  3 0 2 1
Output: 3

आपका कार्य एक फ़ंक्शन (या प्रोग्राम) को परिभाषित करना है जो पूर्णांक 0..Nऔर रिटर्न (या आउटपुट) के क्रमपरिवर्तन को लेता है जब तक कि एक क्रमचय उत्पन्न नहीं हुआ है तब तक चरणों की संख्या। यदि Xरूपांतरण करने के लिए Xतो उत्पादन शून्य है, होना चाहिए, तो Xकरने के लिए रूपांतरण Yऔर Yकरने के लिए X(या Y) तो उत्पादन 1 होना चाहिए।

Y -> Y: 0 steps
Y -> X -> X: 1 step
Y -> X -> Y: 1 step
A -> B -> C -> D -> C: 3 steps
A -> B -> C -> D -> A: 3 steps
A -> B -> C -> A: 2 steps
A -> B -> C -> C: 2 steps
A -> B -> C -> B: also 2 steps

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

4 3 0 1 2 -> 0 3 4 1 2 -> 4 3 2 1 0 -> 4 3 2 1 0: 2 steps 
4 3 2 1 0 -> 4 3 2 1 0: 0 steps
4 3 1 2 0 -> 4 1 3 2 0 -> 4 3 2 1 0 -> 4 3 2 1 0: 2 steps
1 2 3 0 4 -> 4 1 0 3 2 -> 0 3 4 1 2 -> 4 3 2 1 0 -> 4 3 2 1 0: 3 steps
5 1 2 3 0 4 -> 0 5 3 2 1 4 -> 1 5 3 2 4 0 -> 1 4 3 2 0 5 -> 
  5 1 3 2 0 4 -> 0 5 3 2 1 4: 4 steps

यदि आपकी भाषा "फ़ंक्शंस" का समर्थन नहीं करती है, तो आप मान सकते हैं कि अनुक्रम पूर्णांक की पूर्ण सूची के रूप में दिया गया है जैसे कि एकल लाइन पर 0 1 2या 3 1 0 2।

मजेदार तथ्य:

• अनुक्रम 0,1,2,3, .., एन हमेशा एन, ..., 3,2,1,0 में बदल जाएगा
• अनुक्रम एन, .., 3,2,1,0 हमेशा एन, .., 3,2,1,0 में बदल जाएगा
• अनुक्रम 0,1,3,2, ..., एन + 1, एन हमेशा एन, ..., 3,2,1,0 में बदल जाएगा

बोनस कार्य : एक गणितीय सूत्र का चित्र।

वैकल्पिक नियम :

• यदि आपकी भाषा का पहला सूचकांक 0 के बजाय 1 है, तो आप क्रमपरिवर्तन का उपयोग कर सकते हैं 1..N(आप उदाहरण और टेस्टकेस में प्रत्येक पूर्णांक में एक जोड़ सकते हैं)।

Comments

मेरा मतलब था "बंद सूत्र" जैसे $ f (a_ {0}, a_ {1}, a _ {...}} = a_ {0} ^ a_ {1} + ... $ जहां $ a_ { i} $ दिए गए अनुक्रम में i-th तत्व है।

— mroman

क्या आप सुनिश्चित हैं कि ऐसा "बंद सूत्र" मौजूद है?

— टोड सेवेल

" रिटर्न (या आउटपुट) कदम की संख्या जब तक कि एक क्रमचय होता है जो पहले से ही ठीक हो गया है। " यह सब कुछ है कि इसके बारे में बस के साथ असंगत है। एक शुरुआत के लिए, यह 0 के असंभव रिटर्न रिटर्न बनाता है ...

— पीटर टेलर

क्या तीसरा उदाहरण सही है? मुझे देखना 3,0,1,2चाहिए2,3,0,1

— फायरक्यूबेज़

यह एक दोहराने से पहले परिवर्तनों की संख्या है।

— मरमैन

Answer 1

जावास्क्रिप्ट (ईएस 6), 54 बाइट्स

a=>~(g=a=>g[a]||~-g(g[a]=a.map(i=>a[i]).reverse()))(a)

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

Comments

[]एक समारोह में क्या करता है?

— मरमैन

एक कार्य एक वस्तु है। इसलिए, g[a]संपत्ति का उपयोग करने के लिए इसका उपयोग किया जा सकता है a।

— अरनौलद

ओह समझा। आप gराज्य को स्टोर करने के लिए उपयोग कर रहे हैं ।

— मैरोमान

Answer 2

पायथन 2 , 67 बाइट्स

f=lambda l,*h:len(h)-1if l in h else f([l[i]for i in l][::-1],l,*h)

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

Answer 3

अजगर, 10 9 8 बाइट्स

tl.u@LN_

स्पष्टीकरण:

t               One less than
 l              the number of values achieved by
  .u            repeating the following lambda N until already seen value:
    @LN_N         composing permutation N with its reverse
         Q      starting with the input.

टेस्ट सूट ।

Answer 4

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

([]#)
a#x|elem x a= -1|n<-x:a=1+n#reverse(map(x!!)x)

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

a # x                -- function '#' takes a list of all permutations
                     -- seen so far (-> 'a') and the current p. (-> 'x')
  | elem x a = -1    -- if x has been seen before, return -1 
  | n<-x:a =         -- else let 'n' be the new list of seen p.s and return
    1 +              -- 1 plus
       n #           -- a recursive call of '#' with the 'n' and
        reverse ...  -- the new p.

([]#)                -- start with an empty list of seen p.s 

Answer 5

पर्ल 6 , 44 35 बाइट्स

-9 बाइट्स nwellnhof के लिए धन्यवाद

{($_,{.[[R,] |$_]}...{%.{$_}++})-2}

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

स्पष्टीकरण:

{                              }  # Anonymous code block
                  ...    # Create a sequence where:
  $_,  # The first element is the input list
     {.[[R,] |$_]} # Subsequent elements are the previous element reverse indexed into itself
                     {        }    # Until
                      %.{$_}       # The index of the listt in an anonymous hash is non-zero
                            ++     # Then post increment it
 (                            )-2  # Return the length of the sequence minus 2

Answer 6

जे, 33 27 26 बाइट्स

-7 बबलर का शुक्रिया

_1(+~:i.0:)|.@C.~^:(<@!@#)

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

किस तरह

मूल व्याख्या। मेरा अंतिम सुधार केवल उस टुकड़े को बदलता है जो "पहले से हमने देखा है कि पहले तत्व का सूचकांक" पाता है। अब यह "बब छलनी" का उपयोग कम बाइट्स में करने के लिए करता है।

1 <:@i.~ [: ({: e. }:)\ |.@C.~^:(<@!@#)
                        |.@C.~          NB. self-apply permutation and reverse
                              ^:        NB. this many times:
                                (<@!@#) NB. the box of the factorial of the
                                        NB. the list len.  this guarantees
                                        NB. we terminate, and the box means
                                        NB. we collect all the results
         [: ({: e. }:)\                 NB. apply this to those results:
                      \                 NB. for each prefix
             {: e. }:                   NB. is the last item contained in 
                                        NB. the list of previous items?
1 <:@i.~                                NB. in that result find:
1    i.~                                NB. the index of the first 1
  <:@                                   NB. and subtract 1

ध्यान दें पूरा अंतिम वाक्यांश 1<:@i.~[:({:e.}:)\"पहले तत्व के सूचकांक को खोजने के लिए समर्पित है जो पहले ही देखा जा चुका है।" ऐसा लगता है कि यह प्राप्त करने के लिए बहुत लंबा है, लेकिन मैं इसे और अधिक गोल्फ करने में सक्षम नहीं था। सुझावों का स्वागत करते हैं।

Answer 7

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

Ṛị$ƬL’

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

1 अनुक्रमित।

Answer 8

दिल्लोग एपीएल, 29 28 27 बाइट्स

¯2∘+∘≢{⍵,⍨⊂⌽(⍋⍳⊢)⊃⍵}⍣{⍺≢∪⍺}

बॉक्सेड सरणियाँ लेता है। बाद में प्रशिक्षित करेंगे और समझाएंगे।

इसे यहां एक परीक्षण सूट के रूप में आज़माएं ।

Answer 9

साफ , 90 बाइट्स

import StdEnv
$l=length(until(\[h:t]=any((==)h)t)(\[h:t]=[reverse(map((!!)h)h),h:t])[l])-2

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