आप कृपया डेक फेरबदल बंद कर सकते हैं और पहले से ही खेल सकते हैं?

Question

चुनौती:

इनपुट: सीमा के भीतर अलग-अलग सकारात्मक पूर्णांक की एक सूची ।$[1, \text{list-size}]$

आउटपुट: एक पूर्णांक: सूची को बार -बार फेरबदल करने की मात्रा । एक सूची के लिए, इसका मतलब है कि सूची को दो हिस्सों में विभाजित किया गया है, और इन हिस्सों को बीच में विभाजित किया गया है (अर्थात सूची में फेरबदल करने के [1,2,3,4,5,6,7,8,9,10]बाद एक बार परिणाम आएगा [1,6,2,7,3,8,4,9,5,10], इसलिए इस चुनौती के लिए इनपुट [1,6,2,7,3,8,4,9,5,10]में परिणाम होगा 1)।

चुनौती नियम:

• आप मान सकते हैं कि सूची में केवल श्रेणी में सकारात्मक पूर्णांक होंगे (या यदि आप 0-अनुक्रमित इनपुट-सूची रखना चाहते हैं )।$[1, \text{list-size}]$$[0, \text{list-size}-1]$
• आप मान सकते हैं कि सभी इनपुट-सूचियाँ या तो एक मान्य रिफ़ल-शफ़ल्ड सूची होगी, या एक सॉर्ट की गई सूची, जिसे फेरबदल नहीं किया गया है (जिस स्थिति में आउटपुट है 0)।
• आप मान सकते हैं कि इनपुट-सूची में कम से कम तीन मूल्य होंगे।

चरण-दर-चरण उदाहरण:

इनपुट: [1,3,5,7,9,2,4,6,8]

एक बार इसे अनशफल करना: [1,5,9,4,8,3,7,2,6]क्योंकि हर 0-अनुक्रमित आइटम पहले आता है [1, ,5, ,9, ,4, ,8], और उसके बाद सभी विषम 0-अनुक्रमित आइटम [ ,3, ,7, ,2, ,6, ]।
सूची अभी तक ऑर्डर नहीं की गई है, इसलिए हम जारी रखते हैं:

सूची को अनशफल करना फिर से बन जाता है: [1,9,8,7,6,5,4,3,2]
फिर से बन जाता है: [1,8,6,4,2,9,7,5,3]
फिर: [1,6,2,7,3,8,4,9,5]
और अंत में:, [1,2,3,4,5,6,7,8,9]जो एक ऑर्डर की गई सूची है, इसलिए हम अनशफलिंग कर रहे हैं।

हमने मूल [1,3,5,7,9,2,4,6,8]पांच बार इसे प्राप्त करने के लिए अप्रकाशित किया [1,2,3,4,5,6,7,8,9], इसलिए 5इस मामले में आउटपुट है ।

सामान्य नियम:

• यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे छोटा जवाब है।
  कोड-गोल्फ भाषाओं को गैर-कोडगॉल्फिंग भाषाओं के साथ उत्तर पोस्ट करने से हतोत्साहित न करें। 'किसी भी' प्रोग्रामिंग भाषा के लिए यथासंभव संक्षिप्त उत्तर के साथ आने का प्रयास करें।
• डिफ़ॉल्ट I / O नियमों के साथ आपके जवाब के लिए मानक नियम लागू होते हैं , इसलिए आपको उचित पैरामीटर और रिटर्न-प्रकार, पूर्ण कार्यक्रमों के साथ STDIN / STDOUT, फ़ंक्शन / विधि का उपयोग करने की अनुमति है। तुम्हारा कॉल।
• डिफ़ॉल्ट लूपोल्स निषिद्ध हैं।
• यदि संभव हो, तो कृपया अपने कोड (यानी TIO ) के लिए एक परीक्षण के साथ एक लिंक जोड़ें ।
• साथ ही, आपके उत्तर के लिए स्पष्टीकरण जोड़ने की अत्यधिक अनुशंसा की जाती है।

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

Input                                                   Output

[1,2,3]                                                 0
[1,2,3,4,5]                                             0
[1,3,2]                                                 1
[1,6,2,7,3,8,4,9,5,10]                                  1
[1,3,5,7,2,4,6]                                         2
[1,8,6,4,2,9,7,5,3,10]                                  2
[1,9,8,7,6,5,4,3,2,10]                                  3
[1,5,9,4,8,3,7,2,6,10]                                  4
[1,3,5,7,9,2,4,6,8]                                     5
[1,6,11,5,10,4,9,3,8,2,7]                               6
[1,10,19,9,18,8,17,7,16,6,15,5,14,4,13,3,12,2,11,20]    10
[1,3,5,7,9,11,13,15,17,19,2,4,6,8,10,12,14,16,18,20]    17
[1,141,32,172,63,203,94,234,125,16,156,47,187,78,218,109,249,140,31,171,62,202,93,233,124,15,155,46,186,77,217,108,248,139,30,170,61,201,92,232,123,14,154,45,185,76,216,107,247,138,29,169,60,200,91,231,122,13,153,44,184,75,215,106,246,137,28,168,59,199,90,230,121,12,152,43,183,74,214,105,245,136,27,167,58,198,89,229,120,11,151,42,182,73,213,104,244,135,26,166,57,197,88,228,119,10,150,41,181,72,212,103,243,134,25,165,56,196,87,227,118,9,149,40,180,71,211,102,242,133,24,164,55,195,86,226,117,8,148,39,179,70,210,101,241,132,23,163,54,194,85,225,116,7,147,38,178,69,209,100,240,131,22,162,53,193,84,224,115,6,146,37,177,68,208,99,239,130,21,161,52,192,83,223,114,5,145,36,176,67,207,98,238,129,20,160,51,191,82,222,113,4,144,35,175,66,206,97,237,128,19,159,50,190,81,221,112,3,143,34,174,65,205,96,236,127,18,158,49,189,80,220,111,2,142,33,173,64,204,95,235,126,17,157,48,188,79,219,110,250]
                                                        45

Comments

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

— ओलिवियर ग्राएगोइरे

@ ओलिवियरग्रैगोयर [1,3,5,7,9,2,4,6,8]लंबाई 9 की है, लेकिन मैं शायद लंबाई 7 और 11 के लिए कुछ और जोड़ूंगा । संपादित करें: परीक्षण मामलों [1,3,5,7,2,4,6] = 2(लंबाई 7) और [1,6,11,5,10,4,9,3,8,2,7] = 6(लंबाई 11) को जोड़ा गया । उम्मीद है की वो मदद करदे।

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

मेरा बुरा: मुझे यकीन था कि आपके द्वारा उल्लिखित परीक्षण मामला आकार 8 का था। लेकिन अतिरिक्त परीक्षण मामलों के लिए धन्यवाद।

— ओलिवियर ग्रेगोइरे

जैसा कि वर्तमान में तैयार किया गया प्रश्न "गलत" लगता है ... एक एकल राइफल फेरबदल का परिणाम पहले और अंतिम कार्ड में बदलना चाहिए, जब तक कि आप किसी प्रकार की कॉन ट्रिक नहीं खींच रहे हों! 10 कार्ड के एकल फेरबदल के बाद [[6,1,7,2,8,3,9,4,10,5]।

— स्टीव

@ मुझे लगता है कि तुम थोड़े सही हो। सामान्य तौर पर राइफल में फेरबदल दो हिस्सों में बंट जाता है, इसलिए दोनों [1,6,2,7,3,8,4,9,5,10]या [6,1,7,2,8,3,9,4,10,5]संभव हैं। मेरी चुनौती में इसका मतलब यह है कि शीर्ष कार्ड हमेशा शीर्ष कार्ड रहेगा, इसलिए यह वास्तव में एक कॉन-ट्रिक है .. मैंने कभी किसी को केवल कार्डों के डेक को फेरने के लिए राइफल-शफल का उपयोग नहीं देखा है । आमतौर पर वे बीच-बीच में अन्य प्रकार के फेरबदल भी करते हैं। वैसे भी, अब चुनौती को बदलने में बहुत देर हो चुकी है, इसलिए इस चुनौती के लिए शीर्ष कार्ड हमेशा राइफल-फेरबदल के बाद शीर्ष कार्ड बना रहेगा।

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

Answer 1

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

ŒœẎ$ƬiṢ’

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

कैसे?

ŒœẎ$ƬiṢ’ - Link: list of integers A
    Ƭ    - collect up until results are no longer unique...
   $     -   last two links as a monad:
Œœ       -     odds & evens i.e. [a,b,c,d,...] -> [[a,c,...],[b,d,...]]
  Ẏ      -     tighten                         -> [a,c,...,b,d,...]
     Ṣ   - sort A
    i    - first (1-indexed) index of sorted A in collected shuffles
      ’  - decrement

Answer 2

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

@Nwellnhof द्वारा सुझाया गया छोटा संस्करण

इनपुट के रूप में 1-अनुक्रमित कार्ड के साथ एक डेक की अपेक्षा करता है।

f=(a,x=1)=>a[x]-2&&1+f(a,x*2%(a.length-1|1))

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

एक डेक को देखते हुए $[c_0,\ldots,c_{L-1}]$ की लंबाई $L$ , हम परिभाषित करते हैं:

$$x_n=\begin{cases} 2^n\bmod L&\text{if }L\text{ is odd}\\ 2^n\bmod (L-1)&\text{if }L\text{ is even}\\ \end{cases}$$

और हम $n$ तलाश करते हैं जैसे कि $c_{x_n}=2$ ।

---

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

इनपुट के रूप में 0-अनुक्रमित कार्ड के साथ एक डेक की अपेक्षा करता है।

f=(a,x=1,k=a.length-1|1)=>a[1]-x%k&&1+f(a,x*-~k/2)

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

कैसे?

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

लंबाई $L$ डेक को देखते हुए , यह कोड $n$ लिए दिखता है जैसे:

$$c_2\equiv\left(\frac{k+1}{2}\right)^n\pmod k$$

जहाँ दूसरा कार्ड है और को इस प्रकार परिभाषित किया गया है:$c_2$$k$

$$k=\begin{cases} L&\text{if }L\text{ is odd}\\ L-1&\text{if }L\text{ is even}\\ \end{cases}$$

Answer 3

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

f=lambda x:x[1]-2and-~f(x[::2]+x[1::2])

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

-4 जोनाथन एलन को धन्यवाद ।

Comments

चार बाइट्स बचाएंf=lambda x:2!=x[1]and-~f(x[::2]+x[1::2])

— जोनाथन एलन

@JonathanAllan ओह, बिल्कुल! खैर ... !=हो सकता है -। ;-)

— आउटगोल्फर

आह, हाँ कैवेट एम्प्टर: डी (या सिर्फ x[1]>2मुझे लगता है)

— योनातन एलन

Answer 4

आर , 58 55 45 बाइट्स

a=scan();while(a[2]>2)a=matrix(a,,2,F<-F+1);F

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

छँटाई प्रक्रिया को अनुकरण करता है। इनपुट 1-अनुक्रमित है, FALSE0 के लिए रिटर्न ।

Comments

बहुत अच्छा! मैं एक समान दृष्टिकोण पर काम कर रहा था लेकिन एक पुनरावर्ती फ़ंक्शन का उपयोग कर रहा था, जो कि गोल्फ के रूप में काम नहीं करता था।

— user2390246

Answer 5

पर्ल 6 , 34 32 बाइट्स

-2 बाइट्स जो किंग को धन्यवाद

{(.[(2 X**^$_)X%$_-1+|1]...2)-1}

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

अरनुलद के दृष्टिकोण के समान । N फेरबदल के बाद दूसरे कार्ड का सूचकांक 2**n % kk के साथ है जैसा कि अरनल्ड के उत्तर में परिभाषित किया गया है।

Answer 6

APL (Dyalog Unicode) , 35 26 23 22 बाइट्स ^SBCS

{⍵≡⍳≢⍵:0⋄1+∇⍵[⍒2|⍳⍴⍵]}

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

मदद के लिए Adám को धन्यवाद, -3 के लिए Outgolfer और -1 के लिए ngn।

TIO लिंक में दो परीक्षण मामले हैं।

स्पष्टीकरण:

{⍵≡⍳≢⍵:0⋄1+∇⍵[⍒2|⍳⍴⍵]}
{⍵≡⍳≢⍵:0⋄1+∇⍵[⍒2|⍳⍴⍵]} ⍝ function takes one argument: ⍵, the array
 ⍵≡⍳≢⍵                 ⍝ if the array is sorted:
 ⍵≡⍳≢⍵                 ⍝ array = 1..length(array)
      :0               ⍝ then return 0
        ⋄              ⍝ otherwise
         1+            ⍝ increment
           ∇           ⍝ the value of the recursive call with this argument:
            ⍵[      ]  ⍝ index into the argument with these indexes:
                 ⍳⍴⍵   ⍝ - generate a range from 1 up to the size of ⍵
               2|      ⍝ - %2: generate a binary mask like [1 0 1 0 1 0]
              ⍒        ⍝ - grade (sorts but returns indexes instead of values), so we have the indexes of all the 1s first, then the 0s.

¹

Comments

-3 के लिए पुनरावृत्ति की गहराई की गणना करें ।

— ११:२६ पर आउटगोल्फ

@EriktheOutgolfer बहुत बेहतर, धन्यवाद!

— शुक्र

∧/2≤/⍵->⍵≡⍳≢⍵

— ngn

@ng को इस बात का अहसास नहीं था कि इस सरणी में कोई छेद नहीं था। धन्यवाद!

— वेन

Answer 7

पर्ल 6 , 36 34 32 बाइट्स

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

$!={.[1]-2&&$!(.sort:{$++%2})+1}

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

सूची में क्रमबद्ध होने तक इंडेक्स मोडुलो 2 से छंटनी करके रिवर्स राइफल फेरबदल करें, फिर अनुक्रम की लंबाई लौटाता है।

यह मज़ेदार है, मैं आमतौर पर पर्ल 6 के लिए पुनरावर्ती दृष्टिकोण की कोशिश नहीं करता, लेकिन इस बार यह मूल की तुलना में कम हो गया।

स्पष्टीकरण:

$!={.[1]-2&&$!(.sort:{$++%2})+1}
$!={                           }   # Assign the anonymous code block to $!
    .[1]-2&&                       # While the list is not sorted
            $!(             )      # Recursively call the function on
               .sort:{$++%2}       # It sorted by the parity of each index
                             +1    # And return the number of shuffles

Answer 8

05AB1E (विरासत) , 9 बाइट्स

[DāQ#ι˜]N

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

व्याख्या

[   #  ]     # loop until
  ā          # the 1-indexed enumeration of the current list
 D Q         # equals a copy of the current list
     ι˜      # while false, uninterleave the current list and flatten
        N    # push the iteration index N as output

Comments

मैं यह भी नहीं जानता था कि विरासत के बाहर के सूचकांक को लूप में आउटपुट करना संभव था। मैंने सोचा कि यह उस बिंदु पर फिर से 0 होगा, नए 05AB1E संस्करण की तरह। अच्छा जवाब! इस चुनौती को प्रेरित करने वाले अश्शूर- बिलिन का उपयोग करके मेरे 10-बेटर से छोटा Å≠। :)

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

@ केविनक्रूजसेन: दिलचस्प। मुझे नहीं पता था कि एक अनशफल था। इस उदाहरण में यह मेरे संस्करण के समान ही है, लेकिन अनशफल 2 डी सरणियों पर आयाम बनाए रखता है।

— एमिग्ना

Answer 9

जावा (JDK) , 59 बाइट्स

a->{int c=0;for(;a[(1<<c)%(a.length-1|1)]>2;)c++;return c;}

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

31 से कम आकार या 31 पुनरावृत्तियों के साथ समाधान के साथ केवल सरणियों के लिए मज़बूती से काम करता है। अधिक सामान्य समाधान के लिए, 63 बाइट्स के साथ निम्न समाधान देखें:

a->{int i=1,c=0;for(;a[i]>2;c++)i=i*2%(a.length-1|1);return c;}

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

व्याख्या

एक राइफल में, अगली स्थिति पिछले एक बार के दो मोडुलो या तो लंबाई है अगर यह विषम या लंबाई है - 1 यदि यह भी है।

इसलिए मुझे इस फॉर्मूले का उपयोग करने वाले सभी सूचकांकों पर ध्यान देना है जब तक कि मुझे एरे में मान 2 नहीं मिल जाता।

क्रेडिट

• -8 बाइट्स केविन क्रूज़सेन को धन्यवाद । (पिछला एल्गोरिथ्म, सरणी का उपयोग करके)
• -5 बाइट्स अरनौल्ड की बदौलत ।

Comments

x.clone()इसके बजाय दो बार का उपयोग करके 163 बाइट्सA.copyOf(x,l) ।

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

64 बाइट्स

— अरनौलड

@ अरनल्ड धन्यवाद! मैं एक मुश्किल समय लगाना है कि "- 1 लंबाई अगर अजीब किसी और लंबाई" सरल करने के लिए कैसे था

— ओलिवर Grégoire

@Arnauld ओह! मेरा नया एल्गोरिथ्म वास्तव में आपके जैसा ही है ... और मैंने इसे खुद से निकालने में आधा घंटा बिताया ...

— ओलिवियर ग्राएगोइरे

अधिक सटीक रूप से, यह @nwellnhof द्वारा पाए गए मेरे मूल एल्गोरिथ्म में सुधार के बराबर है।

— अरनुलद

Answer 10

जे , 28 26 बाइट्स

जोनाह के लिए -2 बाइट्स धन्यवाद!

 1#@}.(\:2|#\)^:(2<1{])^:a:

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

शुक्र का एपीएल समाधान हो।

स्पष्टीकरण:

               ^:       ^:a:   while 
                 (2<1{])       the 1-st (zero-indexed) element is greater than 2   
     (        )                do the following and keep the intermediate results
          i.@#                 make a list form 0 to len-1
        2|                     find modulo 2 of each element
      /:                       sort the argument according the list of 0's and 1's
1  }.                          drop the first row of the result
 #@                            and take the length (how many rows -> steps)     

के (ngn / k) , 25 बाइट्स

सलाह के लिए और अपने कश्मीर दुभाषिया के लिए धन्यवाद!

{#1_{~2=x@1}{x@<2!!#x}\x}

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

Comments

अभिसरण-पुनरावृति , फिर एक को छोड़ें, और

— गिनें

@ngn। तो, मेरे जे समाधान के समान - मैं इसे बाद में कोशिश करूँगा, धन्यवाद!

— गैलेन इवानोव

1#@}.(\:2|#\)^:(2<1{])^:a:26 बाइट्स के लिए

— योना

@ जॉन धन्यवाद!

— गैलेन इवानोव

Answer 11

एपीएल (एनएआरएस), चार्ट्स 49, बाइट्स 98

{0{∧/¯1↓⍵≤1⌽⍵:⍺⋄(⍺+1)∇⍵[d],⍵[i∼d←↑¨i⊂⍨2∣i←⍳≢⍵]}⍵}

सबसे गहरे लूप में उपयोग क्यों करें, एक अलग-अलग जो कि nlog (n) होना चाहिए, जब हम एक रैखिक n का उपयोग कर सकते हैं? बस कुछ बाइट्स के लिए और अधिक? [[[⍵≡⍵] O (nlog n) और देखने के लिए प्रत्येक तत्व का सामना क्रम में ∧ / ↓1 ¯ ¯1⌽⍵ O (n) परीक्षण का उपयोग करके होता है:

  f←{0{∧/¯1↓⍵≤1⌽⍵:⍺⋄(⍺+1)∇⍵[d],⍵[i∼d←↑¨i⊂⍨2∣i←⍳≢⍵]}⍵}
  f ,1
0
  f 1 2 3
0
  f 1,9,8,7,6,5,4,3,2,10
3
  f 1,3,5,7,9,11,13,15,17,19,2,4,6,8,10,12,14,16,18,20
17

Comments

मैंने पहली बार किसी को वर्णों और बाइट्स के बीच अंतर करते देखा है seen। यूनिकोड वर्णों को देखने पर यह हमेशा मुझे परेशान करता है और वे दावा करते हैं कि यह प्रति चरित्र एक बाइट है। यह This एक बाइट नहीं है!

— Kerndog73

@ Kerndog73 सभी संख्या है, लेकिन APL में लगता है कि वर्ण संख्या नहीं हैं ... (वे एवी सरणी में तत्व

— लगते हैं

Answer 12

रूबी , 42 बाइट्स

f=->d,r=1{d[r]<3?0:1+f[d,r*2%(1|~-d.max)]}

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

किस तरह:

सरणी के अंदर नंबर 2 के लिए खोजें: यदि यह दूसरी स्थिति में है, तो डेक को फेरबदल नहीं किया गया है, अन्यथा उन स्थितियों की जांच करें जहां क्रमिक फेरबदल इसे डाल देंगे।

Answer 13

आर , 70 72 बाइट्स

x=scan();i=0;while(any(x>sort(x))){x=c(x[y<-seq(x)%%2>0],x[!y]);i=i+1};i

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

अब शून्य फेरबदल मामले को संभालता है।

Comments

@ user2390246 उचित बिंदु। तदनुसार समायोजित

— निक कैनेडी

Answer 14

सी (जीसीसी) 64 63 बाइट्स

Nwellnhof से -1 बाइट

i,r;f(c,v)int*v;{for(i=r=1;v[i]>2;++r)i=i*2%(c-1|1);return~-r;}

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

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

---

सी (जीसीसी) 162 बाइट्स

a[999],b[999],i,r,o;f(c,v)int*v;{for(r=0;o=1;++r){for(i=c;i--;(i&1?b:a)[i/2]=v[i])o=(v[i]>v[i-1]|!i)&o;if(o)return r;for(i+=o=c+1;i--;)v[i]=i<o/2?a[i]:b[i-o/2];}}

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

a[999],b[999],i,r,o; //pre-declare variables
f(c,v)int*v;{ //argument list
    for(r=0;o=1;++r){ //major loop, reset o (ordered) to true at beginning, increment number of shuffles at end
        for(i=c;i--;(i&1?b:a)[i/2]=v[i]) //loop through v, split into halves a/b as we go
            o=(v[i]>v[i-1]|!i)&o; //if out of order set o (ordered) to false
        if(o) //if ordered
            return r; //return number of shuffles
        //note that i==-1 at this point
        for(i+=o=c+1;i--;)//set i=c and o=c+1, loop through v
            v[i]=i<o/2?a[i]:b[i-o/2];//set first half of v to a, second half to b
    }
}

Answer 15

आर, 85 बाइट्स

s=scan();u=sort(s);k=0;while(any(u[seq(s)]!=s)){k=k+1;u=as.vector(t(matrix(u,,2)))};k

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

व्याख्या

स्टूपिड (जानवर बल) विधि, कार्ड # 2 का पालन करने से बहुत कम सुरुचिपूर्ण है।

इनपुट को अनशफ्ल करने के बजाय sहम एक सॉर्ट किए गए वेक्टर से शुरू करते हैं uजिसे हम उत्तरोत्तर फेरबदल करते हैं जब तक कि यह समान न हो s। यह 2-कॉलम मैट्रिक्स में एक विषम-लंबाई वेक्टर को मोड़ने के कारण इनपुट की विषम लंबाई के लिए चेतावनी देता है (लेकिन फेरबदल की गिनती अभी भी सही है); उस स्थिति में, R में, अनुपलब्ध डेटा बिंदु इनपुट के पहले तत्व के पुनर्चक्रण से भरा हुआ है।

यदि हम एक वेक्टर प्रदान करते हैं तो लूप कभी भी समाप्त नहीं होगा जो कि अप्रभावित नहीं हो सकता है।

परिशिष्ट: आप एक बाइट को बचाते हैं यदि इसके बजाय अनशफ्लिंग करते हैं। ऊपर दिए गए उत्तर के विपरीत, इसके साथ स्थानांतरित करने की कोई आवश्यकता नहीं है t(), हालांकि, ऑर्डर byrow=TRUEकरना यही कारण है कि इसमें Tदिखाई देता है matrix()।

आर , 84 बाइट्स

s=scan();u=sort(s);k=0;while(any(s[seq(u)]!=u)){k=k+1;s=as.vector(matrix(s,,2,T))};k

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

Comments

मैंने आपके शीर्षक को ठीक करने और परीक्षण मामलों के लिए एक टीआईओ-लिंक जोड़ने की स्वतंत्रता ली (इसके आधार पर अन्य आर उत्तर के ) के , और आपके उत्तर के रूप में आपके उत्तर के कार्यों का सत्यापन भी किया, इसलिए मेरे से +1 और पीपीसीजी में आपका स्वागत है! :)

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

Answer 16

पावरशेल , 116 114 108 84 78 बाइट्स

-24 बाइट्स के लिए धन्यवाद एग्री आउटलोफर के समाधान ।

-6 बाइट्स mazzy के लिए धन्यवाद ।

param($a)for(;$a[1]-2){$n++;$t=@{};$a|%{$t[$j++%2]+=,$_};$a=$t.0+$t.1;$j=0}+$n

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

Comments

आप थोड़ा और अधिक बचा सकते हैं: इसे ऑनलाइन आज़माएं!

— माज़ी

@ मिज्जी, आप फिर से सही हो गए :) धन्यवाद

— आंद्रेई ओडेगो

Answer 17

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 62 बाइट्स

c=0;While[Sort[a]!=a,a=a[[1;;-1;;2]]~Join~a[[2;;-1;;2]];c++];c

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

व्याख्या

इनपुट सूची है a। जब तक वे मेल नहीं खाते, तब तक यह अप्रकाशित और छांटे गए सूची के साथ तुलना की जाती है।

Answer 18

लाल , 87 79 78 बाइट्स

func[b][c: 0 while[b/2 > 2][c: c + 1 b: append extract b 2 extract next b 2]c]

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

Answer 19

पर्ल 5 -pa , 77 बाइट्स

map{push@{$_%2},$_}0..$#F;$_=0;++$_,@s=sort{$a-$b}@F=@F[@0,@1]while"@F"ne"@s"

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

Answer 20

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

L?SIb0hys%L2>Bb1
y

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

-2 धन्यवाद @ आउटरीग्राफर को।

स्क्रिप्ट में दो लाइन हैं: पहला एक फ़ंक्शन को परिभाषित करता है y, दूसरी लाइन yमें निहित Q(मूल्यांकित स्टड) तर्क होता है।

L?SIb0hys%L2>Bb1
L                function y(b)
 ?               if...
  SIb            the Invariant b == sort(b) holds
     0           return 0
      h          otherwise increment...
       y         ...the return of a recursive call with:
             B   the current argument "bifurcated", an array of:
              b   - the original argument
            >  1  - same with the head popped off
          L      map...
         % 2     ...take only every 2nd value in each array
        s         and concat them back together

¹

Answer 21

पॉवरशेल , 62 71 70 66 बाइट्स

+9 बाइट्स जब टेस्ट मामलों में तत्वों की संख्या के साथ जोड़ा जाता है।

-1 बाइट स्प्लैटिंग के साथ।

-4 बाइट्स: के साथ अभिव्यक्ति लपेट $i, $jएक नया गुंजाइश के लिए।

for($a=$args;$a[1]-2;$a=&{($a|?{++$j%2})+($a|?{$i++%2})}){$n++}+$n

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

Answer 22

जाप , १३ ११ १० बाइट्स

एक टेस्ट ड्राइव के लिए मेरी चमकदार, नई , बहुत -कार्य-में-प्रगति दुभाषिया लेना।

ÅÎÍ©ÒßUñÏu

इसे आज़माएं या सभी परीक्षण मामलों को चलाएं

ÅÎÍ©ÒßUñÏu     :Implicit input of integer array U
Å              :Slice the first element off U
 Î             :Get the first element
  Í            :Subtract from 2
   ©           :Logical AND with
    Ò          :  Negation of bitwise NOT of
     ß         :  A recursive call to the programme with input
      Uñ       :    U sorted
        Ï      :    By 0-based indices
         u     :    Modulo 2

Comments

यह दुभाषिया सुपर कूल दिखता है।

— पुनरावर्ती

Answer 23

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

f=lambda x:x[1]-2and 1+f(x[::2]+x[1::2])  # 1-based
f=lambda x:x[1]-1and 1+f(x[::2]+x[1::2])  # 0-based

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

मुझे पृष्ठ को अधिक बार रीफ़्रेश करने की आवश्यकता है: एरिक आउटोलॉफ़र के संपादन को एक समान चाल में करने से चूक गए =