31

एक फेरबदल एक तकनीक है जिसका इस्तेमाल अक्सर जादूगर एक डेक को "फेरबदल" करने के लिए करते हैं। फ़ार फेरबदल करने के लिए आप पहले डेक को 2 बराबर हिस्सों में काटते हैं फिर आप दो हिस्सों को इंटरलेव करते हैं। उदाहरण के लिए

[1 2 3 4 5 6 7 8]

फेर फेर फेर है

[1 5 2 6 3 7 4 8]

इसे कितनी भी बार दोहराया जा सकता है। दिलचस्प रूप से पर्याप्त है, अगर आप इसे पर्याप्त बार दोहराते हैं, तो आप हमेशा मूल सरणी पर वापस आ जाएंगे। उदाहरण के लिए:

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

ध्यान दें कि 1 तल पर रहता है और 8 शीर्ष पर रहता है। जो इसे बाहरी फेरबदल बनाता है । यह एक महत्वपूर्ण अंतर है।

चुनौती

पूर्णांक A के एक सरणी , और एक नंबर N को देखते हुए , N Faro फेरबदल के बाद सरणी का उत्पादन करता है । ए में दोहराया या नकारात्मक तत्व शामिल हो सकते हैं, लेकिन इसमें हमेशा तत्वों की संख्या होगी। आप मान सकते हैं कि सरणी खाली नहीं होगी। आप यह भी मान सकते हैं कि एन एक गैर-नकारात्मक पूर्णांक होगा, हालांकि यह 0. हो सकता है। आप इन इनपुट को किसी भी उचित तरीके से ले सकते हैं। बाइट्स जीत में सबसे छोटा जवाब!

परीक्षण IO:

#N, A,                                              Output
1,  [1, 2, 3, 4, 5, 6, 7, 8]                        [1, 5, 2, 6, 3, 7, 4, 8]
2,  [1, 2, 3, 4, 5, 6, 7, 8]                        [1, 3, 5, 7, 2, 4, 6, 8]
7,  [-23, -37, 52, 0, -6, -7, -8, 89]               [-23, -6, -37, -7, 52, -8, 0, 89]
0,  [4, 8, 15, 16, 23, 42]                          [4, 8, 15, 16, 23, 42]
11, [10, 11, 8, 15, 13, 13, 19, 3, 7, 3, 15, 19]    [10, 19, 11, 3, 8, 7, 15, 3, 13, 15, 13, 19]

और, एक बड़े पैमाने पर परीक्षण का मामला:

23, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100]

उत्पादन करना चाहिए:

[1, 30, 59, 88, 18, 47, 76, 6, 35, 64, 93, 23, 52, 81, 11, 40, 69, 98, 28, 57, 86, 16, 45, 74, 4, 33, 62, 91, 21, 50, 79, 9, 38, 67, 96, 26, 55, 84, 14, 43, 72, 2, 31, 60, 89, 19, 48, 77, 7, 36, 65, 94, 24, 53, 82, 12, 41, 70, 99, 29, 58, 87, 17, 46, 75, 5, 34, 63, 92, 22, 51, 80, 10, 39, 68, 97, 27, 56, 85, 15, 44, 73, 3, 32, 61, 90, 20, 49, 78, 8, 37, 66, 95, 25, 54, 83, 13, 42, 71, 100]

code-golf permutations card-games code-golf graphical-output random code-golf image-processing color code-golf primes code-golf math arithmetic combinatorics decision-problem code-golf sequence number-theory binary code-golf number-theory set-theory code-golf hashing code-golf game card-games code-golf ascii-art code-golf arithmetic array-manipulation jelly code-golf string array-manipulation code-golf sorting code-challenge code-golf number date binary code-golf arithmetic code-golf math number linear-algebra polynomials code-golf ascii-art code-golf grid decision-problem code-golf string combinatorics code-golf string kolmogorov-complexity arithmetic date code-golf number data-structures code-golf ascii-art kolmogorov-complexity code-golf string ascii-art code-golf ascii-art kolmogorov-complexity code-golf array-manipulation

— DJMcMayhem
स्रोत

क्या सरणी में शून्य तत्व हो सकते हैं?

— लीक नून

@LeakyNun हम कहेंगे कि नहीं, आपको शून्य तत्वों को संभालने की आवश्यकता नहीं है।

— DJMcMayhem

सम्बंधित। सम्बंधित। सम्बंधित।

— मार्टिन एंडर

05AB1E , 5 बाइट्स

कोड:

F2äø˜

स्पष्टीकरण, इनपुट: N, array:

F      # Do the following N times
 2ä    # Split the array into 2 pieces
   ø   # Zip
    ˜  # Deep flatten

CP-1252 एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं! ।

— अदनान
स्रोत

1

अरे, मैं बहुत धीमा था!

— जॉर्ज गिब्सन

19

vim, 62 59 54

qrma50%mb:norm@q<cr>ggqOjdd'apjma'b@q<esc>0"qDJ<C-a>D@"i@r<esc>xxdd@"

वाह। यह संभवतः हैकैस्ट चीज है जिसे मैंने PPCG के लिए लिखा है, और वह कुछ कह रही है।

इनपुट को एन के रूप में लिया जाता है पहली पंक्ति पर सरणी के तत्वों के बाद, प्रत्येक अपनी लाइन पर।

qr         first, we're going to record the contents of the @r macro. this is
             the macro which does the faro-shuffle operation.
  ma       set the mark 'a at the beginning of the file
  50%      move to the 50% point of the file (i.e. halfway down)
  mb       set another mark here
  :norm@q  evaluate the recursive macro @q. we'll get to what that does later,
             but the interesting part here is that it's :norm@q instead of @q.
             this is because a recursive macro terminates at the end of the
             file, which means when @q terminates, @r would also abort, which
             would make calling it with a count impossible. running @q under
             :norm prevents this.
  gg       move back to the top of the file for the next iteration
q          end recording
O          now we're inserting contents of the @q macro, the recursive part
             we can't record it directly because it's destructive
  j        move to line directly below mark 'b (which was just set before @q)
  dd       delete this line and bring it...
  'ap      up after mark 'a (which starts on line 1, bringing the N/2th line
             directly below line 1, aka line 2)
  jma      replace mark 'a one line below this so that the next time we call
             'ap, the line from the second half is interleaved with the lines
             from the first half
  'b       jump back to mark 'b (remember, 'b is the last line of the first
             half of the file, originally reached via 50%)
  @q       call ourselves, causing the macro to run until hitting EOF
0"qD       delete this into register "q
J          delete the empty line that remains
<C-a>      here's another interesting bit: we want to run @r N times. but 0@r
             means "go to column 0, and then run @r once." so we have to
             increment the input number...
D@"        and then *that* many times...
  i@r        insert @r...
xx         ... and finally, delete two characters, which is the extra @r from
             the increment
dd         delete the sequence of @rs into the "" register...
@"         and run it!

मैंने वास्तव में इस उत्तर को लिखते समय कई विम बग पाए:

रिकॉर्डिंग मैक्रोज़ अन्य मैक्रोज़ के भीतर संभव नहीं है (जब अपने पाठ को मैन्युअल रूप से सेट करते हैं, तो नहीं q) या :*mapएस के भीतर ।
:let @a='<C-v><cr>'<cr>i<C-r>a जो भी आर्कषक कारण है, उसके लिए दो नई सुर्खियां, एक नहीं।

मैं बाद में उन लोगों की जांच कर सकता हूं।

3 बाइट्स के लिए डॉ ग्रीन एग्स और हैम डीजे के लिए धन्यवाद !

— Doorknob
स्रोत

4

यह सुंदर और भयावह है। मैं शायद यह करने के लिए पर्याप्त धैर्य नहीं है। :Pइसके अलावा, आप ऐसा करके 2 बाइट्स से दूर ले सकता है "rckके बजाय vgg"rc, और आप एक और 5 बंद करके ले जा सकते हैं dw@"i@r<esc>के बजायAA@R<C-v><esc><esc>0D@"

— DJMcMayhem

@DrGreenEggsand HamDDJ पहले ऐसा नहीं कर सकता क्योंकि यह एक अनुगामी न्यूलाइन को पकड़ लेता है, लेकिन यह दूसरा अनुकूलन कार्य करता है। धन्यवाद!

— दरवाज़े

7

अजगर 2, 59 बाइट्स

def f(n,L):exec"l=len(L)/2;L=(L+L[1:]*~-l)[::l];"*n;print L

एक अलग दृष्टिकोण, अन्य पायथन उत्तरों की तुलना में थोड़ा लंबा। केवल तत्वों की सकारात्मक संख्या के लिए काम करता है।

उदाहरण के लिए 1, [1,2,3,4,5,6,7,8], एरे को लें और len(L)/2-1खुद को पहले तत्व माइनस की प्रतियों को जोड़ दें , जैसे

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

फिर हर len(L)/2वें तत्व को लें।

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

— Sp3000
स्रोत

6

पायथन, 68 57 बाइट्स

f=lambda n,x:n and f(n-1,sum(zip(x,x[len(x)/2:]),()))or x

11 बाइट बंद करने के लिए @ Sp3000 को धन्यवाद!

Ideone पर इसका परीक्षण करें ।

— डेनिस
स्रोत

6

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

0!a=a
n!a|s<-length a=(n-1)![a!!mod(div(s*i+i)2)s|i<-[0..s-1]]

बता दें कि s = 2 · t सूची का आकार है। मैं नई सूची का वें तत्व लेने के द्वारा प्राप्त किया जाता है पुरानी सूची के मई के तत्व, शून्य अनुक्रमित, सापेक्ष रों ।

प्रमाण: यदि i = 2 · k सम है, तो

और अगर i = 2 · k + 1 विषम है, तो

इस प्रकार अनुक्रमण के लिए उपयोग किए जाने वाले मान 0, t , 1, t + 1, 2, t + 2, हैं ...

— लिन
स्रोत

5

जे - 12 बाइट्स

Adverb (!) बाईं ओर फेरबदल की संख्या और दाईं ओर फेरबदल करने के लिए सरणी।

/:#/:@$0,#^:

J पार्सर में टैक्स्ट क्रिया विशेषण लिखने के नियम हैं , लेकिन उनकी बहुत कम पूर्वता है: यदि आप क्रियाओं की एक ट्रेन को एक तर्क के रूप में उपयोग करना चाहते हैं, तो आप कोष्ठक के अन्यथा आवश्यक सेट को छोड़ सकते हैं। तो ऊपर वास्तव में कम है (/:#/:@$0,#)^:, जो कि एक क्रिया विशेषण के रूप में बाईं ओर फेरबदल की संख्या लेता है, और फिर दाईं ओर फेरबदल करने के लिए सरणी लेने वाला एक विराट कार्य बन जाता है।

इसने कहा, हम निम्न प्रकार से फेरबदल करते हैं। #सरणी की लंबाई है, इसलिए 0,#एक दो तत्व सूची है: 0 इसके बाद कुछ नॉनजरो। फिर यह #/:@$बताता है कि इनपुट सरणी के रूप में लंबे समय तक एक सूची में है, और अपनी तरह का वेक्टर लेता है ।

किसी सूची का सॉर्ट वेक्टर सूची को सॉर्ट करने के तरीके के बारे में जानकारी है: सबसे छोटे तत्व का (0-आधारित) invdex, इसके बाद अगले-सबसे छोटे का सूचकांक, और इसी तरह। उदाहरण के लिए, इस प्रकार का वेक्टर 0 1 0 1 ...होगा 0 2 4 ... 1 3 5 ...।

यदि J अब इस तरह के वेक्टर को सॉर्ट करने के लिए थे, तो यह इसे फेरबदल करेगा; लेकिन यह तुच्छ होगा, क्योंकि हम 0 1 2 3 ...वापस आ जाएंगे । तो हम इनपुट एरे को सॉर्ट करने के लिए डाइएडिक/: का उपयोग करते हैं जैसे कि वह थे 0 2 4 ... 1 3 5 ... , जो कि फ़ार-शफ़ल करता है।

नीचे दिए गए उदाहरण। Tryj.tk पर इसे स्वयं आज़माएं !

   1 (/:#/:@$0,#^:) 1 2 3 4 5 6 7 8
1 5 2 6 3 7 4 8

   f =: /:#/:@$0,#^:

   2  f  1 2 3 4 5 6 7 8
1 3 5 7 2 4 6 8

   7  f  _23 _37 52 0 _6 _7 _8 89   NB. "negative 1" is spelled _1
_23 _6 _37 _7 52 _8 0 89

   1  f  0 0 0 0 1 1 1              NB. odd-length lists
0 1 0 1 0 1 0

— algorithmshark
स्रोत

5

पायथ - 8 7 बाइट्स

@issacg के लिए 1 बाइट का धन्यवाद सहेजा गया

usCc2GE

इसे यहाँ ऑनलाइन आज़माएँ ।

— Maltysen
स्रोत

2

हम्म ... जेली जवाब में कुछ गलत होना चाहिए अगर पायल ने जेली को पीटा।

— लीक नून

2

इनपुट ऑर्डर को स्वैप करें और Qएक बाइट को बचाने के लिए निकालें । अगर पेली ने पियथ की पिटाई की तो पाइथ के जवाब में कुछ गड़बड़ होनी चाहिए। :)

— isaacg

@ आइसाकग डारन, शपथ ले सकता था कि मैंने पहले कोशिश की थी। वह काम क्यों करता है? uतयशुदा बिंदु के साथ उस हुक को डिफ़ॉल्ट पर नहीं होना चाहिए और निश्चित बिंदु पर नहीं करना चाहिए ?

— माल्टसेन

@ मैलेटेन आप सही कह रहे हैं, मुझे लगता है कि यह केवल एक परीक्षण मामले पर काम करने के लिए हुआ जो मैंने कोशिश की। उसके लिए माफ़ करना।

— इसहाक

@LeakyNun को @ डेनिस और धन्यवाद @issacg , Pyth और जेली अब बराबर (7 बाइट्स) कर रहे हैं। ; डी

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

3

जेली, ९ by बाइट्स

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

œs2ZFð¡

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

व्याख्या

œs2ZFð¡  Main dyadic chain. Arguments: x,y
      ¡  Repeat the following y time:
œs2          Split into two.
   Z         Transpose.
    F        Flatten.

पिछला 9-बाइट संस्करण:

œs2ZF
Ç⁴¡

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

— लीक नन
स्रोत

2

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

(n,a)=>[...a].map((e,i)=>a[(i<<n)%~-a.length||i]=e)

जगह में इनपुट सरणी को संशोधित करता है और मूल सरणी की एक प्रति लौटाता है। यदि यह अस्वीकार्य है, &&aतो संशोधित सरणी वापस करने के लिए प्रत्यय लगाया जा सकता है। केवल nजावास्क्रिप्ट के पूर्णांक अंकगणितीय की सीमाओं के कारण छोटे मूल्यों के लिए काम करता है । 61 60 बाइट पुनरावर्ती संस्करण जो n@ लिन के फार्मूले के आधार पर बड़े पैमाने पर काम करता है:

f=(n,a,l=a.length)=>n?f(n-1,a.map((_,i)=>a[(i*-~l>>1)%l])):a

— नील
स्रोत

2

MATL , 11 बाइट्स

w:"tn2/e!1e

@ सुधार के लिए @ डेनिस का धन्यवाद

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

व्याख्या

w         % Take the two inputs N and A. Swap them
:         % Generate [1 2 ... N]
"         % Repeat N times
  tn2/    %   Duplicate A. Number of elements divided by 2
  e       %   Reshape to that number of rows
  !       %   Transpose
  1e      %   Reshape to one row
          % End (implicit)
          % Display (implicit)

— लुइस मेंडो
स्रोत

क्यों wजरूरी है?

— डेविड

@ डेविड वह करेक्शन था। इसके बिना, एन = 0 के लिए लूप में प्रवेश नहीं किया जाता है और दूसरा इनपुट नहीं लिया जाता है

— लुइस मेंडो

आह कि गुस्सा आ रहा है!

— डेविड

2

जे, २२ 19 17 बाइट्स

3 बाइट्स @ गैरेथ के लिए धन्यवाद ।

2 बाइट्स @algorithmshark को धन्यवाद ।

-:@#({.,@,.}.)]^:

प्रयोग

>> f =: -:@#({.,@,.}.)]^:
>> 2 f 1 2 3 4 5 6 7 8
<< 1 3 5 7 2 4 6 8

कहा पे >>STDIN है और <<STDOUT है।

पिछला 22-बाइट संस्करण:

({~[:,/@|:@i.2,-:@#)^:

प्रयोग

>> f =: ({~[:,/@|:@i.2,-:@#)^:
>> 2 f 1 2 3 4 5 6 7 8
<< 1 3 5 7 2 4 6 8

जहाँ >>STDIN है और <<STDOUT है।

— लीक नन
स्रोत

वजह से जम्मू की पार्स करने के नियम , आप 2 वर्ण के लिए बाहरी कोष्ठक छोड़ सकते हैं।

— एल्गोरिदमार्क

18 बाइट्स के{~2,@|:@i.@,-:@#^: लिए ट्रांसपोज़्ड इंडेक्स का उपयोग करके वैकल्पिक ।

— मील

एक अन्य विकल्प का उपयोग करता है 17 बाइट्स भी[:,@|:]]\~_2%~#^:

— मील

@ माइलिस का मानना है कि ,@|:@$~2,-:@#^:15 बाइट्स के लिए काम करता है

— योना

1

गणितज्ञ 44 बाइट्स

4 बाइट के साथ @ मीलों के लिए धन्यवाद बचा।

Riffle@@TakeDrop[#,Length@#/2]&~Nest~##&

Riffle @@ TakeDrop[#, Length@#/2] &~Nest~## &[list, nShuffles]सूची को दो समान उपखंडों में विभाजित करता है और Riffleउन्हें फेरबदल करता है।

 Riffle @@ TakeDrop[#, Length@#/2] &~Nest~## &[Range@8, 1]

{, 5, 5, 2, 6, 3, 7, 4, 8}

Riffle @@ TakeDrop[#, Length@#/2] &~Nest~## &[Range@100, 23]

{1, 30, 59, 88, 18, 47, 76, 6, 35, 64, 93, 23, 52, 81, 11, 40, 69, 98, 28, 57, 86, 16, 45, 74, 4 , 33, 62, 91, 21, 50, 79, 9, 38, 67, 96, 26, 55, 84, 14, 43, 72, 2, 31, 60, 89, 19, 48, 77, 7, 36 , 65, 94, 24, 53, 82, 12, 41, 70, 99, 29, 58, 87, 87, 17, 46, 75, 5, 34, 63, 92, 22, 80, 10, 39, 68 , 97, 27, 56, 85, 15, 44, 73, 3, 32, 61, 90, 20, 49, 78, 8, 37, 66, 95, 25, 54, 83, 13, 42, 71, 100 }

— DavidC
स्रोत

का उपयोग करते हुए TakeDropहम एक समाधान का उपयोग कर प्राप्त कर सकते हैं 40 बाइट्स के रूप में Riffle@@TakeDrop[#,Length@#/2]&~Nest~##&करते हुए भी अनुक्रम लेने ##के लिए अतिरिक्त तर्क के रूप में पार्स किया जा सकता Nest।

— मील

@miles। का बहुत अच्छा उपयोग TakeDrop। और ##अनुक्रम सम्मिलित करने के लिए उपयोग करना बेहतर है ।

— डेविड C

1

एपीएल, 23 21 चरस

({⊃,/⍵(↑,¨↓)⍨2÷⍨⍴⍵}⍣N)A

धारणा के बिना (डेनिस के लिए धन्यवाद) और 1 चार छोटी:

({{∊,⌿2(2÷⍨≢⍵)⍴⍵}⍣⎕)⎕

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

— user2070206
स्रोत

1

जावा, 109 बाइट्स

int[]f(int[]a,int n){for(int x,q=a.length,d[];0<n--;a=d){d=new int[q];for(x=0;x<q;x++)d[(2*x+2*x/q)%q]=a[x];}return a;}

स्पष्टीकरण: जब वे फ़ारो फेरबदल होते हैं तो तत्व कैसे चलते हैं, इसका एक पैटर्न है:

x को मूल सूचकांक होने दें

आज्ञा देना नए सूचकांक हो

आज्ञा देना L लंबाई सरणी की लंबाई है

y डबल x है
यदि x L के आधे से अधिक या बराबर है तो वेतन वृद्धि y है
सरणी के सीमा के भीतर y रखें

या कोड के रूप में: y=(2*x+x/(L/2))%L

यह मान लेता है कि संकेत 0 पर शुरू होता है। यहाँ आगे बताया गया कोड है:

int[] faroShuffle( int[] array, int numberOfShuffles ) {
    //repeat the faro shuffle n times
    for( int index, length=array.length, destination[]; 0<numberOfShuffles--; array=destination ) {
        //new array to copy over the elements
        destination=new int[length];
        //copy the elements into the new array
        for( index=0; index<length; index++ )
            destination[(2*index+2*index/length)%length]=array[index];
        //at the end of each loop, copy the reference to the new array and use it going forward
    }
    return array;
}

परीक्षण मामलों के लिए विचारधारा देखें

— जैक अम्मो
स्रोत

मुझे पता है कि यह एक वर्ष से अधिक हो गया है, लेकिन आप कुछ हिस्सों को गोल्फ कर सकते हैं: void f(int[]a,int n){for(int x,q=a.length,d[];0<n--;a=d)for(d=new int[q],x=0;x<q;)d[(2*x+2*x/q)%q]=a[x++];}( 107 बाइट्स - आपका वर्तमान उत्तर 119 बीडब्ल्यूटी है, 109 नहीं, इसलिए -12 बाइट्स)। चूंकि आप इनपुट सरणी को संशोधित करते हैं, इसलिए इसे वापस करने की कोई आवश्यकता नहीं है, इसलिए आप इसे बाइट्स को कम करने के लिए शून्य में बदल सकते हैं। ओह, और यदि आप एक जावा 8 लैम्ब्डा को करीने से परिवर्तित करते हैं तो आप इसे और भी छोटा बना सकते हैं: a->n->{for(int x,q=a.length,d[];0<n--;a=d){d=new int[q];for(x=0;x<q;x++)d[(2*x+2*x/q)%q]=a[x];}}( 96 बाइट्स )

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

1

जूलिया, 45 42 बाइट्स

a\n=n>0?reshape(a,endof(a)÷2,2)'[:]\~-n:a

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

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

हम (पुनः) \इस कार्य के लिए बाइनरी ऑपरेटर को परिभाषित करते हैं । आज्ञा देना एक सरणी और n एक गैर नकारात्मक पूर्णांक।

यदि n पॉजिटिव है, तो हम एरे को फेरबदल करते हैं। इसे लंबाई (a) two 2 पंक्तियों और दो स्तंभों के मैट्रिक्स में बदलकर प्राप्त किया जाता है । 'परिणामी मैट्रिक्स को स्थानांतरित करता है, दो पंक्तियों का निर्माण करता है, फिर परिणाम को समतल करता है[:] । चूंकि जूलिया कॉलम-मेजर ऑर्डर में मैट्रीस को स्टोर करता है, इसलिए यह दो पंक्तियों को मिलाता है।

बाद में, हम \फेरबदल ए और एन - 1 ( ~-n) के साथ तर्क के रूप में पुन: कॉल करते हैं, इस प्रकार अतिरिक्त फेरबदल करते हैं। एक बार n 0 तक पहुंचने के , हम a का वर्तमान मान लौटाते हैं ।

— डेनिस
स्रोत

0

Pyke, 7 बाइट्स

VDlec,s

यहाँ कोशिश करो!

V       - Repeat N times:
 D      -  a,b = a (2nd arg first time round)
  le    -  b = len(b)//2
    c   -  a = chunk(a,b)
     ,  -  a = zip(*a)
      s -  a = sum(a, [])

— नीला
स्रोत

0

दरअसल, 15 बाइट्स

`;l½≈@│t)HZ♂i`n

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

स्पष्टीकरण:

`;l½≈@│t)HZ♂i`n
`            `n  do the following n times:
 ;l½≈              push half the length of the array
     @             swap
      │            duplicate entire stack
       t)H         last L//2 elements, first L//2 elements
          Z♂i      zip, flatten each element

— मेगो
स्रोत

0

प्रोलॉग, 116 बाइट्स

a([],[[],[]]).
a([H,I|T],[[H|U],[I|V]]):-a(T,[U,V]).
f(X,0,X).
f(X,N,Y):-N>0,M is N-1,f(X,M,Z),a(Z,[A,B]),append(A,B,Y).

प्रयोग

?- f([1,2,3,4,5,6,7,8],2,X).
X = [1, 5, 2, 6, 3, 7, 4, 8] ;
false.

— लीक नन
स्रोत

0

पर्ल 5 `-lan` , 52 बाइट्स

$a=<>;@F=map@F[$_,@F/2+$_],0..$#F/2while$a--;say"@F"

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

— Xcali
स्रोत

0

PHP, 98 बाइट्स

function($a,$n){while($n--)for($z=count($a)/2;$z;)array_splice($a,$z--,0,array_pop($a));return$a;}

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

— टाइटस
स्रोत

फ़ार एक फेरबदल

चुनौती

परीक्षण IO:

05AB1E , 5 बाइट्स

vim, 62 59 54

अजगर 2, 59 बाइट्स

पायथन, 68 57 बाइट्स

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

जे - 12 बाइट्स

पायथ - 8 7 बाइट्स

जेली, ९ by बाइट्स

व्याख्या

पिछला 9-बाइट संस्करण:

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

MATL , 11 बाइट्स

व्याख्या

जे, २२ 19 17 बाइट्स

प्रयोग

पिछला 22-बाइट संस्करण:

प्रयोग

गणितज्ञ 44 बाइट्स

एपीएल, 23 21 चरस

जावा, 109 बाइट्स

जूलिया, 45 42 बाइट्स

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

Pyke, 7 बाइट्स

दरअसल, 15 बाइट्स

प्रोलॉग, 116 बाइट्स

प्रयोग

पर्ल 5 -lan , 52 बाइट्स

PHP, 98 बाइट्स

पर्ल 5 `-lan` , 52 बाइट्स