31

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

[1, 2, 3, 4, 5]

उदहारण के लिए

सरणी को उल्टा करें। अब हमारी सरणी है
```
[5, 4, 3, 2, 1]
```
प्रत्येक जोड़ी को पुन: क्रमबद्ध (स्वैप) करें । हमारी सूची में 2 जोड़े हैं: [5, 4]और [3, 2]। दुर्भाग्य से, हम 1एक जोड़ी में समूह नहीं बना सकते हैं , इसलिए हम इसे स्वयं छोड़ देंगे। प्रत्येक जोड़ी को स्वैप करने के बाद, नया सरणी है:
```
[4, 5, 2, 3, 1]
```
चरण 1 और 2 को तब तक दोहराएं जब तक हम मूल सरणी पर वापस नहीं आ जाते। यहां अगले 4 चरण दिए गए हैं:
```
Step 2:
Start:          [4, 5, 2, 3, 1]
Reversed:       [1, 3, 2, 5, 4]
Pairs Swapped:  [3, 1, 5, 2, 4]

Step 3:
Start:          [3, 1, 5, 2, 4]
Reversed:       [4, 2, 5, 1, 3]
Pairs Swapped:  [2, 4, 1, 5, 3]

Step 4:
Start:          [2, 4, 1, 5, 3]
Reversed:       [3, 5, 1, 4, 2]
Pairs Swapped:  [5, 3, 4, 1, 2]

Step 5:
Start:          [5, 3, 4, 1, 2]
Reversed:       [2, 1, 4, 3, 5]
Pairs Swapped:  [1, 2, 3, 4, 5]

# No more steps needed because we are back to the original array
```
यदि सूची की लंबाई, n विषम है, तो मूल सरणी पर लौटने के लिए हमेशा n कदम उठाएंगे। यदि n सम है, तो मूल सरणी पर वापस जाने के लिए हमेशा 2 चरण होंगे, जब तक n 2 नहीं है, इस स्थिति में इसे 1 चरण लगेगा (क्योंकि उलट और स्वैप करना एक ही बात है)।

आज के लिए आपका काम (आपको इसे स्वीकार करना चाहिए) मनमाने ढंग से लंबाई की सूची के लिए चरणों के इस सेट की कल्पना करना है। आपको एक प्रोग्राम या फ़ंक्शन लिखना चाहिए जो इनपुट के रूप में एक एकल सकारात्मक पूर्णांक n लेता है , और यह सूची के लिए चरणों का सेट करता है [1, n]। आपको प्रत्येक मध्यवर्ती चरण को रास्ते में आउटपुट करना होगा, चाहे इसका अर्थ है कि प्रत्येक चरण को प्रिंट करना, या उन सभी को चरणों की सूची के रूप में वापस करना। मैं आउटपुट प्रारूप के बारे में बहुत चुस्त नहीं हूँ, जब तक कि यह स्पष्ट है कि आप हर कदम पैदा कर रहे हैं। इसका मतलब है (उदाहरण के लिए) इनमें से कोई भी:

STDOUT की सूची के रूप में हर कदम का आउटपुट
सूचियों की सूची वापस करना
प्रत्येक चरण के स्ट्रिंग निरूपण की सूची लौटाते हुए
मैट्रिक्स को वापस करना / आउटपुट करना

स्वीकार्य होगा।

आपको मूल सरणी को भी आउटपुट करना होगा, चाहे वह अंत में आए या शुरुआत में आपके ऊपर हो। (तकनीकी रूप से, दोनों सही हैं)

आपको 2 के बजाय 1 कदम उठाने के 2 के किनारे मामले को संभालना होगा , इसलिए कृपया सुनिश्चित करें कि आपका समाधान 2 के इनपुट के साथ काम करता है (और 1 एक और संभावित किनारे का मामला है)।

हमेशा की तरह, यह कोड-गोल्फ है , इसलिए मानक खामियां लागू होती हैं, और अपने समाधान को अपनी पसंद की भाषा में किसी अन्य की तुलना में कम करने की कोशिश करें (या किसी अन्य भाषा को हरा देने की कोशिश करें जो आमतौर पर आपकी तुलना में कम है यदि आप महसूस कर रहे हैं एक चुनौती के लिए)।

परीक्षण IO

1: 
[1]


2: 
[1, 2]


3: 
[2, 3, 1]
[3, 1, 2]
[1, 2, 3]


4: 
[3, 4, 1, 2]
[1, 2, 3, 4]


5: 
[4, 5, 2, 3, 1]
[3, 1, 5, 2, 4]
[2, 4, 1, 5, 3]
[5, 3, 4, 1, 2]
[1, 2, 3, 4, 5]


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


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

और अच्छे उपाय के लिए, यहाँ एक विशाल परीक्षण मामला है:

27: 
[26, 27, 24, 25, 22, 23, 20, 21, 18, 19, 16, 17, 14, 15, 12, 13, 10, 11, 8, 9, 6, 7, 4, 5, 2, 3, 1]
[3, 1, 5, 2, 7, 4, 9, 6, 11, 8, 13, 10, 15, 12, 17, 14, 19, 16, 21, 18, 23, 20, 25, 22, 27, 24, 26]
[24, 26, 22, 27, 20, 25, 18, 23, 16, 21, 14, 19, 12, 17, 10, 15, 8, 13, 6, 11, 4, 9, 2, 7, 1, 5, 3]
[5, 3, 7, 1, 9, 2, 11, 4, 13, 6, 15, 8, 17, 10, 19, 12, 21, 14, 23, 16, 25, 18, 27, 20, 26, 22, 24]
[22, 24, 20, 26, 18, 27, 16, 25, 14, 23, 12, 21, 10, 19, 8, 17, 6, 15, 4, 13, 2, 11, 1, 9, 3, 7, 5]
[7, 5, 9, 3, 11, 1, 13, 2, 15, 4, 17, 6, 19, 8, 21, 10, 23, 12, 25, 14, 27, 16, 26, 18, 24, 20, 22]
[20, 22, 18, 24, 16, 26, 14, 27, 12, 25, 10, 23, 8, 21, 6, 19, 4, 17, 2, 15, 1, 13, 3, 11, 5, 9, 7]
[9, 7, 11, 5, 13, 3, 15, 1, 17, 2, 19, 4, 21, 6, 23, 8, 25, 10, 27, 12, 26, 14, 24, 16, 22, 18, 20]
[18, 20, 16, 22, 14, 24, 12, 26, 10, 27, 8, 25, 6, 23, 4, 21, 2, 19, 1, 17, 3, 15, 5, 13, 7, 11, 9]
[11, 9, 13, 7, 15, 5, 17, 3, 19, 1, 21, 2, 23, 4, 25, 6, 27, 8, 26, 10, 24, 12, 22, 14, 20, 16, 18]
[16, 18, 14, 20, 12, 22, 10, 24, 8, 26, 6, 27, 4, 25, 2, 23, 1, 21, 3, 19, 5, 17, 7, 15, 9, 13, 11]
[13, 11, 15, 9, 17, 7, 19, 5, 21, 3, 23, 1, 25, 2, 27, 4, 26, 6, 24, 8, 22, 10, 20, 12, 18, 14, 16]
[14, 16, 12, 18, 10, 20, 8, 22, 6, 24, 4, 26, 2, 27, 1, 25, 3, 23, 5, 21, 7, 19, 9, 17, 11, 15, 13]
[15, 13, 17, 11, 19, 9, 21, 7, 23, 5, 25, 3, 27, 1, 26, 2, 24, 4, 22, 6, 20, 8, 18, 10, 16, 12, 14]
[12, 14, 10, 16, 8, 18, 6, 20, 4, 22, 2, 24, 1, 26, 3, 27, 5, 25, 7, 23, 9, 21, 11, 19, 13, 17, 15]
[17, 15, 19, 13, 21, 11, 23, 9, 25, 7, 27, 5, 26, 3, 24, 1, 22, 2, 20, 4, 18, 6, 16, 8, 14, 10, 12]
[10, 12, 8, 14, 6, 16, 4, 18, 2, 20, 1, 22, 3, 24, 5, 26, 7, 27, 9, 25, 11, 23, 13, 21, 15, 19, 17]
[19, 17, 21, 15, 23, 13, 25, 11, 27, 9, 26, 7, 24, 5, 22, 3, 20, 1, 18, 2, 16, 4, 14, 6, 12, 8, 10]
[8, 10, 6, 12, 4, 14, 2, 16, 1, 18, 3, 20, 5, 22, 7, 24, 9, 26, 11, 27, 13, 25, 15, 23, 17, 21, 19]
[21, 19, 23, 17, 25, 15, 27, 13, 26, 11, 24, 9, 22, 7, 20, 5, 18, 3, 16, 1, 14, 2, 12, 4, 10, 6, 8]
[6, 8, 4, 10, 2, 12, 1, 14, 3, 16, 5, 18, 7, 20, 9, 22, 11, 24, 13, 26, 15, 27, 17, 25, 19, 23, 21]
[23, 21, 25, 19, 27, 17, 26, 15, 24, 13, 22, 11, 20, 9, 18, 7, 16, 5, 14, 3, 12, 1, 10, 2, 8, 4, 6]
[4, 6, 2, 8, 1, 10, 3, 12, 5, 14, 7, 16, 9, 18, 11, 20, 13, 22, 15, 24, 17, 26, 19, 27, 21, 25, 23]
[25, 23, 27, 21, 26, 19, 24, 17, 22, 15, 20, 13, 18, 11, 16, 9, 14, 7, 12, 5, 10, 3, 8, 1, 6, 2, 4]
[2, 4, 1, 6, 3, 8, 5, 10, 7, 12, 9, 14, 11, 16, 13, 18, 15, 20, 17, 22, 19, 24, 21, 26, 23, 27, 25]
[27, 25, 26, 23, 24, 21, 22, 19, 20, 17, 18, 15, 16, 13, 14, 11, 12, 9, 10, 7, 8, 5, 6, 3, 4, 1, 2]
[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]

मज़ा गोल्फ है!

code-golf array-manipulation

— DJMcMayhem
स्रोत

6

क्या फ्रंट में ओरिजिनल रेंज जेनरेट करना ठीक है?

— हाइपरएन्यूट्रीनो

1

मुझे लगता है कि उदाहरण में अंतिम पंक्ति में कोई त्रुटि है। यह होना चाहिए 1 2 3 4 5, नहीं 1 2 4 3 5।

— स्टीवी ग्रिफिन

2

क्या कोई भी इस बात की पुष्टि कर सकता है कि प्रक्रिया के आरंभ और अंत में तत्व 0 केवल 1 कभी होगा?

— रॉबर्टो ग्राहम

1

@RobertoGraham मेरे पास एक पायथन लिपि है जो सत्यापित करती है कि array[0]प्रक्रिया के प्रारंभ और अंत में केवल 1 होगा n = 999। पैटर्न को देखने से ऐसा लगता है कि हर विषम n के लिए , पहला तत्व 1, n-1, 3, n - 3, 5, n - 5, 7...ऊपर तक जाता है n - 2, 3, n, 1, जो हमेशा n कदम उठाएगा। मुझे कोई कारण नहीं दिखता कि यह पैटर्न बड़े n के साथ बदले ।

— DJMcMayhem

3

अगर हम यह साबित करना चाहते हैं कि अवधि n है जब n विषम है, तो संभवतः यह ट्रैक करना आसान है कि तत्व 1 कहां जाता है: यह पथ का अनुसरण करता है 1, n, 2, n-2, 4, n-4, 6, n-6, 8, n-8, ...और प्रेरण द्वारा यह दिखाना आसान है कि एक स्थिति x पर एक तत्व एक कदम के बाद nx पर चला जाता है , और अजीब स्थिति में एक तत्व x करने के लिए ले जाता है एन-x + 2 । इसलिए यदि n = 2k + 1 है , तो 2k के बाद 1-चरण 2k पर होगा , और अगले चरण पर n-2k = 1 होगा ।

— मिशा लावरोव

16

टीआई-बेसिक (83 श्रृंखला), 58 57 54 बाइट्स (104 अक्षर)

:seq(I,I,1,Ans→A
:Ans→B
:Repeat prod(Ans=ᶫB
:ᶫB→C
:int(⁻Ans/2→D
:SortD(ᶫC,ᶫA
:SortD(ᶫD,ᶫA
:Pause ᶫA
:End

व्याख्या

में इनपुट लेता है Ans(उदाहरण के लिए, 5:prgmNAMEआकार पाँच की सूची का उपयोग करने के लिए लिखें )।

दिए गए आकार की तीन सहायक सूचियाँ बनाता है (जो कि ᶫBप्रत्येक चरण से बनाई गई हैं ): ᶫB = ᶫC = {1,2,3,4,5,...}और ᶫD = {-1,-1,-2,-2,-3,...}। प्रत्येक चरण में, क्रमबद्ध ᶫCऔर ᶫDअवरोही क्रम में, उसी क्रमपरिवर्तन को लागू करना ᶫA। के मामले में ᶫC, यह उलट जाता है ᶫA, और के मामले में ᶫD, यह आसन्न जोड़े को स्वैप करता है क्योंकि टीआई-बेसिक वास्तव में बेवकूफ चयन प्रकार कार्यान्वयन का उपयोग करता है SortD(जिसके लिए संभवतः समान तत्वों के रूप में कई पुन: उपयोग करता है। जब फिर ᶫAसे बराबर होता है ᶫB, तो हम रुक जाते हैं।

नहीं, गंभीरता से, उनके अंतर्निहित सॉर्टिंग एल्गोरिथ्म TI-Basic दुभाषिया के साथ मेरी दूसरी सबसे बड़ी शिकायत है। (मेरी सबसे बड़ी शिकायत यह है कि कितने नेस्टेड लूप इंटरप्रेटर को धीमा कर देते हैं, चूंकि लूप डेटा एक स्टैक में संग्रहीत होता है, लेकिन स्टैक गलत छोर से उगाया जाता है, इसलिए कैलकुलेटर को हर बार एक तत्व को धक्का देने पर पूरे स्टैक को स्थानांतरित करना पड़ता है या पॉपप।) लेकिन इस बार, यह सुविधाजनक है।

-1 बाइट: Pauseयह उस मूल्य को संग्रहीत करता है जिसे यह प्रिंट कर रहा है Ans, जो कि संदर्भ से छोटा है ᶫA।

-3 बाइट्स: इनपुट लें Ans

— मिशा लावरोव
स्रोत

चयन प्रकार के साथ बहुत बढ़िया चाल!

— Riking

7

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

RµUs2UFµÐĿ

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

व्याख्या

RµUs2UFµÐĿ  Main link
R           Generate the range
        ÐĿ  While the results are unique (collecting results)
 µUs2UFµ    Reverse and reorder
  U         Reverse
   s        Slice non-overlapping into length
    2       2
     U      Reverse (automatically vectorizes to depth 1)
      F     Flatten

ध्यान दें

मूल सीमा को तो जरूरत है अंत में, संलग्न होने के लिए ṙ112 बाइट्स के लिए कोड के लिए।

— HyperNeutrino
स्रोत

वैकल्पिक दृष्टिकोण, एक ही बाइट गिनती

— डीजेएमकेम

@DJMcMayhem कूल, अच्छा!

— हाइपरनेत्रिनो

5

05AB1E , 13 11 बाइट्स

LIGÂ2ôí˜})Ù

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

व्याख्या

L             # range [1 ... input]
 IG           # input-1 times do:
   Â          # bifurcate
    2ô        # split into pieces of 2
      í       # reverse each
       ˜      # flatten
        }     # end loop
         )    # wrap stack in a list
          Ù   # remove duplicates

— Emigna
स्रोत

4

जावास्क्रिप्ट (ईएस 6), 89 85

4 बाइट्स संपादित करें thx @JustinMariner को बचाया

इस तथ्य का उपयोग करना कि जब कोई तत्व सही जगह पर है, तो सभी तत्व हैं।

n=>{for(l=[];n;l[n-1]=n--);while(alert(l=l.reverse().map((x,i)=>l[i^1]||x)),l[0]-1);}

कम गोल्फ वाला

n => {
  for(l=[], i=0; i<n; l[i] = ++i);
  while( alert(l=l.reverse().map( (x,i) => l[i^1] || x)),
         l[0]-1);
}

परीक्षा

var F=
n=>{for(l=[];n;l[n-1]=n--);while(alert(l=l.reverse().map((x,i)=>l[i^1]||x)),l[0]-1);}

alert=x=>console.log(x+'') // to avoid popup stress

function update() {
  F(+I.value);
} 

update()

<input type=number id=I value=1 min=1 oninput='update()'>

स्निपेट का विस्तार करें

— edc65
स्रोत

मुझे लगता है कि आप अपने रेंज-बिल्डिंग लूप को छोटा कर सकते हैं for(l=[];n;l[n-1]=n--); , इसे ऑनलाइन आज़माएं! ।

— जस्टिन मैरिनर

@JustinMariner वाह पीछे, महान! धन्यवाद

— edc65

3

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

(h=Range@#;W={};For[i=1,i<=#,i++,s=Reverse@h;AppendTo[W,h=Join[f=Flatten[Reverse/@Partition[s,{2}]],s~Complement~f]];s=h];DeleteDuplicates@W)&

— J42161217
स्रोत

3

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

f=(n,a=[...Array(n)],b=a.map((x,i)=>n-((x?x-1:i)^1)||1))=>b[0]>1?b+`
`+f(n,b):b

प्रत्येक चरण के लिए एक सूची आउटपुट करता है।

ध्यान दें कि हमें गेंद को लुढ़काने के लिए सरणी को इनिशियलाइज़ करने की आवश्यकता नहीं है। यदि असंवैधानिक ( xअपरिभाषित है), तो हम iपहला कदम करने के लिए सरणी के सूचकांकों (पैरामीटर ) का उपयोग कर सकते हैं :

b=a.map((x,i)=>n-((x?x-1:i)^1)||1)

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

कोड स्निपेट दिखाएं

f=(n,a=[...Array(n)],b=a.map((x,i)=>n-((x?x-1:i)^1)||1))=>b[0]>1?b+`
`+f(n,b):b

console.log(f(1));
console.log(f(2));
console.log(f(3));
console.log(f(4));
console.log(f(5));
console.log(f(7));
console.log(f(27));

स्निपेट का विस्तार करें

— रिक हिचकॉक
स्रोत

3

आर, 109 95 94 79 74 62 बाइट्स

यदि तथ्य यह है कि कोड वास्तविक समाधान के शीर्ष पर चेतावनी फेंकता है (यदि कोई चेतावनी n1, 3 चेतावनी है तो nभी औरn चेतावनी अगर nविषम है) एक मुद्दा नहीं है, तो निम्न पिछले समाधान के समान काम करता है, वेक्टर के लिए धन्यवाद रीसाइक्लिंग:

n=scan();m=1:n;w=0:n+2*1:0;while(print(m<-rev(m)[w[w<=n]])-1)n

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

फिर से धन्यवाद एक अतिरिक्त 12 बाइट्स के @Giuseppe !

पिछला, 94 बाइट्स पर चेतावनी-कम समाधान:

n=scan();m=s=1:n;while(any(print(m<-rev(m)[c(if(n>1)2:1+rep(seq(0,n-2,2),e=2),n[n%%2])])!=s))n

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

109 बाइट्स पर मूल समाधान :

n=scan();m=s=1:n;repeat{cat(m<-rev(m)[c(t(embed(s,min(n,2))[!!s[-n]%%2,]),n[n%%2])],"\n");if(all(m==s))break}

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

— plannapus
स्रोत

1

88 बाइट्स - printअपना तर्क देता है ताकि हम यहां इसका लाभ उठा सकें। मुझे नहीं लगता कि मैंने encodeपहले कभी देखा है ; यह अनुक्रमण का एक साफ तरीका है!

— Giuseppe

धन्यवाद! हालांकि मुझे इसे थोड़ा और लंबा करने की आवश्यकता होगी क्योंकि यह काम नहीं करता है अगर n = 1 अब तक।

— प्लेनैपस

ओह, मुझे लगता है कि नोटिस नहीं किया था ... की जगह 2में embedसाथ min(n,2)?

— ग्यूसेप

1

जब तक आप कुछ भी नहीं करते तब तक आप केवल लूप के nबदले रख सकते हैं । :){}n

— Giuseppe

1

प्रभावशाली सुधार !!! -4 बाइट्स के लिए 0:n+2*1:0समान है 1+0:n+c(1,-1)। -1 बाइट के any(print(...) != s)बराबर है any(print(...)-s)। Aaand अगर हम यह साबित कर सकते हैं कि m[1]==1केवल एल्गोरिथ्म के अंत में, तो हम ड्रॉप कर सकते हैं any, इसलिए हम प्राप्त करते हैं while(print(...)-1)और हम निकाल सकते हैं s, इसलिए हमें 62 बाइट्स मिलते हैं,n=scan();m=1:n;w=0:n+2*1:0;while(print(m<-rev(m)[w[w<=n]])-1)n

— Giuseppe

3

जाप , 20 18 15 12 बाइट्स

õ
£=ò2n)ÔcÃâ

इसे आज़माएं ( -Rकेवल विज़ुअलाइज़ेशन उद्देश्यों के लिए ध्वज)

1 बाइट ETHproductions के लिए धन्यवाद बचा लिया।

               :Implicit input of integer U
õ              :Range [1,U]
\n             :Reassign to U
£              :Map
  ò            :  Partitions
   2           :    Of length 2
    n          :    Starting from the end
     )         :  End partition
      Ô        :  Reverse
       c       :  Flatten
 =             :  Reassign to U
        Ã      :End map
         â     :Deduplicate

— झबरा
स्रोत

अभी के रूप में, मेरा मानना है कि w ò mwहो सकता हैò2n)w

— ETHproductions

ऊँ, अच्छा, धन्यवाद, @ETHproductions। पब में चलने के बारे में इसलिए मैं सुबह में उस पर उचित नज़र रखूंगा। '

— शैगी

2

भूसी , 9 बाइट्स

U¡ȯṁ↔C2↔ḣ

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

            -- implicit input N                 |  3
         ḣ  -- list [1..N]                      | [1,2,3]
 ¡(     )   -- iterate the following function,  | [[1,2,3],[2,3,1],[3,1,2],[1,2,3],...
U           -- until the first repetition:      | [[1,2,3],[2,3,1],[3,1,2]]
       ↔    --   reverse                        |   [3,2,1]
     C2     --   cut into two                   |   [[3,2],[1]]
   ṁ↔       --   reverse each pair & flatten    |   [2,3,1]

— ბიმო
स्रोत

2

रूबी , 64 57 52 50 बाइट्स

->x{(s=*w=1..x).map{s=w.map{|y|s[-y^1]||s[0]}}|[]}

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

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

पहले सीमा बनाएं, फिर क्रमपरिवर्तन x बार दोहराएं: एक नकारात्मक सूचकांक का उपयोग करें, लेकिन अंतिम बिट फ्लिप करें, इसलिए हमें अनुक्रम -2, -1, -4, -3 मिलेगा ... यदि x सम है, तो यह समाप्त हो जाएगा ठीक है, नहीं तो हम शेष तत्व को अंत में जोड़ देंगे। अंतिम चरण: दोहराया सरणियों को फ़िल्टर करें (इसलिए हम सभी मामलों को कवर करते हैं: x = 1, x = 2, विषम और सम संख्याएँ)

— जीबी
स्रोत

2

हास्केल, 75 74 बाइट्स

g(a:b:c)=b:a:g c
g x=x
h=g.reverse
0!x|x<[2]=[x]|1<2=x:0!h x
p n=0!h[1..n]

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

gजोड़ी-वार स्वैप, hसिंगल स्टेप (रिवर्स + रीऑर्डर), !बार-बार लागू होता हैh (और मध्यवर्ती परिणाम एकत्र करता है) जब तक कि ऑर्डर बहाल नहीं हो जाता। नोट: !अतिरिक्त लेकिन अप्रयुक्त अतिरिक्त पैरामीटर लेता है0 बस इसे एक इन्फिक्स ऑपरेटर बनाने के लिए। मुख्य कार्य pइसे शुरू करता है।

संपादित करें: एक बाइट के लिए @Angs के लिए धन्यवाद।

— nimi
स्रोत

2

0!xf xबाइट बचाने के बजाय - इसे ऑनलाइन आज़माएं!

— आंग्स

1

जावा 8, 215 214 बाइट्स

import java.util.*;n->{Stack a=new Stack(),t;int i=0;for(;i<n;a.add(++i));t=(Stack)a.clone();Collections x=null;for(i=0;i<1|!a.equals(t);System.out.println(t))for(x.reverse(t),i=0;i<n;i++)if(i<n-1)x.swap(t,i,++i);}

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

स्पष्टीकरण:

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

import java.util.*;           // Required import for Stack and Collections

n->{                          // Method with integer parameter and no return-type
  Stack a=new Stack(),        //  Original List
        t;                    //  Copy-List
  int i=0;                    //  Index-integer, starting at 0
  for(;i<n;a.add(++i));       //  Fill the original list with the integers
  t=(Stack)a.clone();         //  Make a copy of the List
  Collections x=null;         //  Static `Collections` to reduce bytes
  for(i=0;                    //  Reset index `i` to 0
      i<1                     //  Loop (1) as long as `i` is 0 (the first iteration),
      |!a.equals(t);          //  or the input array is not equal to the copy
      System.out.println(t))  //    After every iteration: print the modified List
    for(x.reverse(t),         //   Reverse the copied List
        i=0;                  //   Reset `i` to 0
        i<n;                  //   Inner loop (2) over the List
        i++)                  //     After every iteration: increase `i` by 1 again
      if(i<n-1)               //    Unless it's the last item in the List:
        x.swap(t,i,++i);      //     Swap the items at indexes `i` and `i+1` 
                              //     (by increasing `i` by 1 first with `++i`)
                              //   End of inner loop (2) (implicit / single-line body)
                              //  End of loop (1) (implicit / single-line body)
}                             // End of method

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

1

जावा (ओपनजेडके 8) , 257 245 243 226 206 205 बाइट्स

n->{int i=0,k,t[]=new int[n];while(i<n)t[i]=++i;do{for(i=0;i<n/2;t[i]=t[n+~i],t[n+~i++]=k)k=t[i];for(k=1;k<n;t[k]=t[--k],t[k]=i,k+=3)i=t[k];System.out.println(java.util.Arrays.toString(t));}while(t[0]>1);}

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

— रॉबर्टो ग्राहम
स्रोत

1

n->{java.util.Arrays x=null;int i=0,k,f,a[]=new int[n],t[]=new int[n];for(;i<n;a[i]=t[i]=++i);do{for(f=0;f<n/2;k=t[f],t[f]=t[n+~f],t[n+~f++]=k);for(k=1;k<n;t[k]=t[--k],t[k]=f,k+=3)f=t[k];System.out.println(x.toString(t));}while(!x.equals(a,t));}

( 245 बाइट्स ) परिवर्तनों का सारांश java.util.Arrays x=null;:; n-f-1को n+~f; लूप के कोष्ठक हटा दिए गए; 2x बदल दिया k-1करने के लिए --k(और भी बदल k+=2करने के लिए k+=3इस बेअसर करने के लिए।

— केविन Cruijssen

और आप दो और बाइट्स को हटाकर ,fऔर फिर से उपयोग करके बचा सकते हैं i।

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

अच्छा, आपने इसे बहुत सुधार लिया है! अब आप मेरे जावा उत्तर से भी कम हैं। :) आप एक और बाइट को गोल्फ में बदल for(i=0;i<n/2;k=t[i],t[i]=t[n+~i],t[n+~i++]=k);सकते हैंfor(i=0;i<n/2;t[i]=t[n+~i],t[n+~i++]=k)k=t[i];

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

1

MATL , 17 बाइट्स

:`tP2ePXz!tG:-a]x

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

व्याख्या

:       % Implicit input: n. Push [1 2 ... n]
`       % Do...while
  t     %   Duplicate
  P     %   Reverse
  2e    %   Reshape into a 2-row matrix. A final 0 is added if needed
  P     %   Reverse each column
  Xz    %   Nonzero entries (i.e. remove final 0 if present). Gives a column vector
  !     %   Transpose into a row
  t     %   Duplicate
  G:    %   Push [1 2 ... n] again
  -     %   Subtract element-wise
  a     %   Any. Gives true if there is at least a nonzero value
]       % End. Go to next iteration if top of the stack is true.  So the loop ends
        % when [1 2 ... n] has been found again
x       % Delete top of the stack (which is [1 2  ... n]). Implicit display

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

1

स्टैक्स , 17 बाइट्स

âΩÄ─g╫B♥C╛♠ƒ?|πcD

इसे चलाएं और डीबग करें

व्याख्या

RX~Wr2/{r+}Fc|uPcx=C      # Full program, unpacked, implicit input
RX~                       # Create range, save to X register, pop back to input stack
   W                      # Start while loop until truthy value
    r                     # reverse array
     2/                   # Split into groups of 2
      {r+}F               # Loop through each set and reverse each
           c              # Copy top value
            |u            # Convert to string representation of array
              P           # Pop top value off
               cx=        # Copy top value, get value of x register, compare to top value
                  C       # If top value is truthy, cancel block and end

इससे पहले कि मैं अपने ब्राउज़र को अब और नहीं करना चाहता था, इससे पहले 399 तक परीक्षण किया गया, यह काम करता है।

— मल्टी
स्रोत

0

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

f=(n,a=[...Array(n)].map((_,i)=>i+1),r=[],b=a.map((_,i)=>a[n+~(i^1)]||a[0]))=>b.some((e,i)=>e>b[i+1],r.push(b))?f(n,b,r):r

r.push(a)r.push(b)मूल क्रमांकन सामने रखने के बजाय इस्तेमाल किया जा सकता है ।

— नील
स्रोत

0

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

यह थोड़ा लंबा लगता है :(

f n|x<-[1..n]=x:takeWhile(/=x)(tail$iterate((r=<<).g.r)x)
r=reverse
g[]=[]
g x=take 2x:g(drop 2x)

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

स्पष्टीकरण / Ungolfed

-- starting with x, accumulate the results of repeatedly
-- applying the function permute
f n = x : takeWhile (/=x) (tail $ iterate permute x)
  where x = [1..n]
        -- reverse, cut2, reverse each pair & flatten
        permute = concatMap reverse . cut2 . reverse

-- recursively transform a list into groups of 2
cut2 [] = []
cut2 xs = take 2 xs : g (drop 2 xs)

— ბიმო
स्रोत

0

स्टैक किया गया , 42 बाइट्स

[~>[rev 2#<$revflatmap]periodsteps behead]

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

बिलिन का उपयोग करके दिए गए परिवर्तन को पूरा करता है periodsteps। हालाँकि, यह बिल्टिन सभी तत्वों को लौटाता है, जिसमें इनपुट की सीमा इसके पहले और अंतिम तत्वों के रूप में शामिल होती है। इसलिए हम सूची में शीर्ष पर लौट रहे हैं, लेकिन पहला तत्व है।

— कोनोर ओ ब्रायन
स्रोत

0

AWK , 123 बाइट्स

बहुत तंग नहीं है, लेकिन यह सबसे अच्छा मैं के साथ आ सकता है।

{for(N=$1;N>$i=++i;);for(;n++<(i%2?i:i>2?2:1);){for(k=0;k++<i;)K[k]=(z=i-k+(k-1)%2*2)?$z:$1;for(k=0;k++<N;){$k=K[k]}print}}

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

— रॉबर्ट बेन्सन
स्रोत

0

अजगर 2 , 165 159 138 81 बाइट्स

x=input()+1
b=a=range(1,x)
while b:b=[b[x-min(x,i+1^1)]for i in a];print b;b*=a<b

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

-20 बाइट्स @ChasBrown को धन्यवाद । (आह, मैंने विस्तारित स्लाइसिंग सिंटैक्स के बारे में पूरी चुनौती दी)

वाह! गोल्फस्टॉर्म (-57 बाइट्स)! इयान गोडेल, टीश, और जोनाथन फ्रीच को धन्यवाद।

— fireflame241
स्रोत

इसके बजाय list(reversed(a))कोशिश करें a[::-1]।

— चास ब्राउन

' '*[2-(x<3),x][x%2]

— tsh

132 बाइट्स

1

88 बाइट्स

— tsh

1

@tsh [b,0][b==a]-> b*(a!=b)।

— जोनाथन फ्रेच

0

जावास्क्रिप्ट, 136 बाइट्स

(n)=>{for(a=[],i=0;i<n;a[i]=++i);for(j=0;j<(n&1?n:2);j++){a.reverse();for(i=0;i<a.length-1;i += 2)m=a[i],a[i]=a[i+1],a[i+1]=m;alert(a)}}

— tjespe
स्रोत

थ्री 'आर: रिवर्स, रीऑर्डर, रिपीट

परीक्षण IO

टीआई-बेसिक (83 श्रृंखला), 58 57 54 बाइट्स (104 अक्षर)

व्याख्या

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

व्याख्या

ध्यान दें

05AB1E , 13 11 बाइट्स

जावास्क्रिप्ट (ईएस 6), 89 85

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

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

आर, 109 95 94 79 74 62 बाइट्स

जाप , 20 18 15 12 बाइट्स

भूसी , 9 बाइट्स

रूबी , 64 57 52 50 बाइट्स

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

हास्केल, 75 74 बाइट्स

जावा 8, 215 214 बाइट्स

जावा (ओपनजेडके 8) , 257 245 243 226 206 205 बाइट्स

MATL , 17 बाइट्स

व्याख्या

स्टैक्स , 17 बाइट्स

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

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

स्पष्टीकरण / Ungolfed

स्टैक किया गया , 42 बाइट्स

AWK , 123 बाइट्स

अजगर 2 , 165 159 138 81 बाइट्स

जावास्क्रिप्ट, 136 बाइट्स