एक दूसरे के बगल में लगातार दो पूर्णांक के साथ एक क्रमचय दें

18

चुनौती

पूर्णांक n , 4 को देखते हुए, पूर्णांक के एक क्रमचय का उत्पादन [0, n-1] इस संपत्ति के साथ कि कोई दो लगातार पूर्णांक (पूर्ण अंतर के साथ पूर्णांक) एक दूसरे के बगल में नहीं हैं।

उदाहरण

  • 4 → [1, 3, 0, 2]
  • 5 → [0, 2, 4, 1, 3]
  • 6 → [0, 2, 4, 1, 3, 5]
  • 7 → [0, 2, 4, 1, 5, 3, 6]

आप इसके बजाय 1-अनुक्रमण का उपयोग कर सकते हैं ( [0, n-1] के बजाय पूर्णांक [1, n] का उपयोग कर सकते हैं )।

आपका कोड बहुपद में n में चलना चाहिए , इसलिए आप सभी क्रमपरिवर्तन की कोशिश नहीं कर सकते हैं और हर एक का परीक्षण कर सकते हैं।

code-golf  restricted-complexity 
— अनुश
स्रोत
जब आप कहते हैं "आउटपुट एक क्रमचय", तो क्या आपका मतलब सूची के रूप में है? या हम एक फ़ंक्शन का निर्माण कर सकते हैं जो क्रमचय मानचित्रण को लागू करता है?
— xnor
@xnor इसे कुछ मानव पठनीय रूप में आउटपुट किया जाना चाहिए। मुझे बिल्कुल परवाह नहीं है कि कैसे।
— अनुष
चाहेंगे [[1,3],[0,2]]एक स्वीकार्य उत्पादन प्रारूप हो सकता है?
— झबरा
@ शागि यह महान नहीं है। क्या इसका मतलब 1,3,0,2 है?
— अनुष
— पीटर टेलर

जवाबों:

31

जेली , 3 2 बाइट्स

ḂÞ

अपने LSB द्वारा पूर्णांक को [1, ..., n] में भेजता है।

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

— डेनिस
स्रोत
वाह! बहुत शानदार है।
— अनुष
2
"एलएसबी द्वारा क्रमबद्ध करें" का अर्थ है कि हर दूसरा शुरू में चलता है, लेकिन क्या जेली की परिभाषा की आवश्यकता है कि प्रत्येक आधे में संख्या अपने मूल क्रम में बनी रहे? यदि नहीं, तो 100 (4) 101 (5) के बगल में हो सकता है और फिर भी "एलएसबी द्वारा क्रमबद्ध" हो सकता है। आपके कोड में खराबी नहीं है, लेकिन शायद वर्णन करने वाली टिप्पणी पूर्ण नहीं है?
— WGroleau
1
@Groleau हाँ, Þस्थिर प्रकार, क्योंकि यह पायथन sortedफ़ंक्शन का उपयोग करके कार्यान्वित किया जाता है , जो स्थिर होने की गारंटी है ।
— user202729
3
एल्गोरिथ्म छोटे आकार की तुलना में मेरे लिए अधिक प्रभावशाली है, इसकी चतुराई में। तुम भी कर सकते हो, मुझे लगता है, बिट ऑर्डर को उल्टा करो, सॉर्ट करो, और इसे वापस उल्टा करो।
— WGroleau
4
केवल 65536 अलग-अलग दो बाइट जेली कार्यक्रम हो सकते हैं। यह आश्चर्यजनक है कि उन लोगों में से कई पीपीपीसी चुनौतियों का जवाब देने के लिए बाहर निकले।
— अनुष
8

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

lambda n:[*range(1,n,2),*range(0,n,2)]

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

यह O(n)समय में चलता है ।

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

— DJMcMayhem
स्रोत
सबसे तेज पुरस्कार के विजेता! :)
— अनुश
सबसे तेज़ दौड़ रहा है, या पहले पोस्ट किया गया है?
— WGroleau
2
@Groleau पहले पोस्ट किया गया।
— user202729
6

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

f n का एक कार्य है जो उचित रूप से आदेशित सूची देता है। मैं 1-इंडेक्सिंग विकल्प का उपयोग कर रहा हूं।

f n=[2,4..n]++[1,3..n]
— Penguino
स्रोत
6

ऑक्टेव , 17 बाइट्स

@(x)[2:2:x,1:2:x]

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

यह कई अन्य लोगों के समान दृष्टिकोण का उपयोग करता है। कॉनक्लूजन दो वैक्टर, एक समावेशी रेंज में सभी सम संख्या के साथ 2 ... x , और समावेशी रेंज 1 ... x में सभी विषम संख्याएँ । वाक्यविन्यास काफी स्पष्ट होना चाहिए, इसलिए मैं यह नहीं समझाऊंगा।

— स्टीवी ग्रिफिन
स्रोत
1
में 3और 2एक दूसरे के बगल में नहीं हैं f(4)?
— पाजोंक
उफ़… तय। उसी बाइट की गिनती। :-)
— स्टेवी ग्रिफिन
5

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

f=
n=>[...Array(i=n)].map(_=>(i+--i)%(n|1))
<input type=number min=4 oninput=o.textContent=f(+this.value).join`\n`><pre id=o>
स्निपेट का विस्तार करें

संपादित करें: @Annauld के लिए 1 बाइट धन्यवाद सहेजा गया।

— नील
स्रोत
5

गैया , 2 बाइट्स

r∫

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

यह केवल (स्थिर) ∫ रेंज में पूर्णांकों orts [1, इनपुट] उनके पा द्वारा आर ity।

— मिस्टर एक्सकोडर
स्रोत
जेली पर समान टिप्पणी: क्या एल्गोरिथ्म या भाषा की परिभाषा यह गारंटी देती है कि दोनों अपने मूल क्रम में बने हुए हैं?
— WGroleau
@WGroleau हां, गैया में, सॉर्ट मेटा-ऑपरेटर स्थिर है।
— श्री एक्सकोडर
5

आर , 39 36 35 बाइट्स

function(x)c(seq(2,x,2),seq(1,x,2))

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

— एन जी एम
स्रोत
विषम संख्याओं के लिए एक अनुगामी NA है।
— JayCe
— JayCe
पत्नी का दोष। मुझे ठीक करने से पहले हमें अपनी बाइक की सवारी पर जाना था। लेकिन आपने कुछ बाइट्स का मुंडन भी किया।
— एन जी एम
हाँ, मुझे बुरा लगा कि आप बाइट्स जोड़ने के लिए कह रहे हैं तो मुझे कुछ हटाने का तरीका खोजना पड़ा ... यह अच्छी तरह से काम किया।
— JayCe
1
— Giuseppe
4

जाप, 4 बाइट्स

तुम भी बदल सकते uके साथ vएक अलग आदेश प्राप्त करने के लिए।

õ ñu

कोशिश करो

या, यदि हम 2 सरणियों के एक सरणी को अलग कर सकते हैं:

õ ó

कोशिश करो

— झबरा
स्रोत
तकनीकी रूप से दूसरा एक अल्पविराम द्वारा अलग किए गए नंबरों की एक सूची 4उत्पन्न करता है; ;-) दोनों ही दुर्भाग्य से विफल होते हैं ; आप बदलकर पहले वाले को ठीक कर सकते हैंu करने के लिए vया oकरने के लिए õ।
— ETHproductions
3

गणितज्ञ, 50 -> 47 -> 42 बाइट्स

p = Join[Range[2, #, 2], Range[1, #, 2]] &

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

दो गुना गुना अनुकूलन क्षमता की ओर इशारा करने के लिए user202729 को धन्यवाद दें [शामिल हों] फ्लैटन के [] और शुद्ध कार्यों का उपयोग करने के लिए प्रेरित करें।

मैं दो टिप्पणियां जोड़ना चाहूंगा।

1) ओपी के अनुरोध के अनुसार n> = 4 के लिए कोई गिरती या बढ़ती उत्तराधिकार के साथ एक विशिष्ट क्रमांकन का निर्माण करना काफी सरल है।

इसमें दो लगातार सूची शामिल हैं।

यहां तक ​​कि n के लिए ये हैं:
list1 = (2,4, ..., n / 2)
list2 = (1,3, ..., n 2-2)

विषम n के लिए हमारे पास:
list1 = (2,4, ..., तल [n / 2])
सूची 2 = (1,3, ..., तल [n / 2])

इस "एल्गोरिथ्म" के लिए बस एक निर्णय होना चाहिए (n सम या विषम), बाकी सिर्फ n संख्या लिख ​​रहा है।

शीर्ष पर एक संभावित गणितीय समाधान प्रदान किया जाता है।

2) एक संबंधित प्रश्न यह है कि n के कार्य के रूप में इस तरह के कई क्रम कितने हैं।

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

a[0] = a[1] = 1; a[2] = a[3] = 0;
a[n_] := a[n] = (n + 1)*a[n - 1] - (n - 2)*a[n - 2] - (n - 5)*a[n - 3] + (n - 3)*a[n - 4]

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

उदाहरण:

a[#] & /@ Range[4, 12]

{2, 14, 90, 646, 5242, 47622, ​​479306, 5296790, 63779034}

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

N = 4 के लिए 2 हैं: {{2,4,1,3}, {3,1,4,2}}

N = 5 के लिए 14 हैं: {{1,3,5,2,4}, {1,4,2,5,3}, {2,4,1,3,5}, {2,4 1,5,3} {2,5,3,1,4} {3,1,4,2,5} {3,1,5,2,4} {3,5,1, 4,2}, {3,5,2,4,1} {4,1,3,5,2} {4,2,5,1,3} {4,2,5,3, 1} {5,2,4,1,3} {5,3,1,4,2}}

इन क्रमपरिवर्तन की संख्या (n) शीघ्रता से बढ़ती है: 2, 14, 90, 646, 5242, 47622, ​​479306, 5296790, 63779034, ...

बड़े n के लिए अनुपात a (n) / n! लगता है कि सीमा 1 / e ^ 2 = 0.135335 के पास है ... मेरे पास कोई सख्त सबूत नहीं है लेकिन यह संख्यात्मक प्रमाणों से एक अनुमान है। आप कार्यक्रम को ऑनलाइन चलाने की कोशिश करके इसका परीक्षण कर सकते हैं।

उपरोक्त कार्यक्रम (नीचे दिए गए संदर्भ के आधार पर) इन संख्याओं की गणना करता है।

आप OEIS: A002464 पर संबंधित अनुक्रम में अधिक जानकारी प्राप्त कर सकते हैं । हर्ट्ज़स्प्रंग की समस्या: प्रत्येक पंक्ति और स्तंभ में 1 के साथ, एक n X n बोर्ड पर n गैर-हमलावर राजाओं की व्यवस्था करने के तरीके। बढ़ती या गिरती उत्तराधिकार के बिना लंबाई n के क्रमपरिवर्तन की संख्या।

— डॉ। वोल्फगैंग हिंट्ज़
स्रोत
@ स्टीवी ग्रिफिन जैसा कि मैं यहां नया हूं, कृपया और अधिक विस्तार से बताएं कि आपका क्या मतलब है। अपनी पहली टिप्पणी में मैंने एक एल्गोरिथ्म और एक कोड प्रदान किया है जो बहुपद समय में समस्या को हल करता है। इसलिए इसे चुनौती का हल माना जाना चाहिए। दूसरा भाग दिलचस्प समस्या का विस्तार करता है। इसलिए इसे एक टिप्पणी के रूप में माना जाना चाहिए।
— डॉ। वोल्फगैंग हिंटज़े
मैंने आपके सबमिशन को थोड़ा संशोधित करने की स्वतंत्रता ली, इसलिए आपका गणित कोड सबसे ऊपर है। कोड-गोल्फ चुनौतियों के साथ वास्तविक कोड (कम से कम संभव) प्रदान करना अनिवार्य है। जिस तरह से मैंने इसे प्रारूपित किया है वह एक गणितीय उत्तर बन जाता है जैसा कि आप शायद इसे करने का इरादा रखते हैं, और फिर भी इसके नीचे आपकी मूल व्याख्या है। यदि आपको लगता है कि कुछ गायब है या मैंने गलत तरीके से आपके प्रारंभिक उत्तर को संपादित किया है, तो इसे स्वयं संपादित करने के लिए स्वतंत्र महसूस करें। PPCG में आपका स्वागत है! :)
— केविन क्रूज़सेन
@ केविन क्रूज़सेन आपका गर्मजोशी से स्वागत और मेरे भोलेपन के संपादन के लिए बहुत-बहुत धन्यवाद। मैंने अब दूसरी टिप्पणी के लिए एक गणितज्ञ कार्यक्रम जोड़ा है। जो कि सबसे शायद लेग आर्टिस नहीं है। सबसे अधिक मुझे नहीं पता कि अच्छा "ऑनलाइन प्रयास करें" लिंक कैसे बनाया जाता है।
— डॉ। वोल्फगैंग हिंटज
किसी भी लिंक का उपयोग करके बनाया जा सकता है [some text](the_link)। विशेष रूप से "ऑनलाइन कोशिश करें" लिंक के लिए, वेबसाइट https://tio.run/ जो हमारे बहुत ही @Dennis द्वारा होस्ट की जा रही है, में सभी प्रकार की प्रोग्रामिंग भाषाओं के लिंक हैं। वोल्फ्राम भाषा (गणितज्ञ) उनमें से एक है। शीर्ष पर आप कोड को चलाने के लिए प्ले बटन पर क्लिक कर सकते हैं, या हाइपरलिंक बटन को कॉपी करने के लिए "इसे ऑनलाइन आज़माएं।" (markup-) लिंक। और आप अपने कोड को वास्तविक "कोड" (आपके सबमिशन) में विभाजित कर सकते हैं, एक (कई) मुद्रण के लिए एक वैकल्पिक हेडर / फुटर के साथ।
— केविन क्रूज़सेन
मेरे कुछ गलत टिप्पणी के लिए माफी, और उसके बाद उत्तर की कमी! उत्तर समीक्षा कतार में दिखाई दिया, और मैंने प्रारूपण के कारण कोड को नोटिस नहीं किया। यह असामान्य नहीं है कि नए उपयोगकर्ता चुनौतियों का "रोचक अवलोकन" करते हैं, बिना इसका वास्तविक उत्तर दिए। हालांकि यह अच्छे विश्वास में किया गया है, यह साइट के बारे में नहीं है। मुझे लगा कि यह ऐसा जवाब था। मुझे आपकी टिप्पणी पर प्रतिक्रिया देनी चाहिए थी, लेकिन मैं जल्दी में था और एक नई टिप्पणी नहीं लिख सकता था, इसलिए इसके बजाय मैंने बस पुराने को हटा दिया। क्षमा याचना! और साइट पर आपका स्वागत है! मुझे आशा है कि आप चारों ओर चिपकेंगे! :)
— स्टीवी ग्रिफिन
2

श्वेत रिक्ति , 161 बाइट्स

यहाँ आधिकारिक, अप्रमाणित सबमिशन है: इसे ऑनलाइन आज़माएं!

push_0   
read_n	
		push_0   
retreive_n			push_1  		
subtract	   dup_and_out[ 
 	
 	]label_s'
   
'push_2  		 
subtract	   dup[ 
 ]jump_next_if_neg:
		  
:dup_and_out[ 
 	
 	]else_jump_back:
 
 
:label_ss'
    
'push_0   
retreive_n			push_2  		 
subtract	   dup_and_out[ 
 	
 	]dup[ 
 ]jump_next:
 
    
:label_ssss'
      
'push_2  		 
subtract	   dup[ 
 ]jump_end_if_neg:
		   
:dup_and_out[ 
 	
 	]else_jump_back:
 
    
:label_sss'
     
'end

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

मैंने कुछ बाइट्स का बलिदान किया ताकि कार्यक्रम बिना किसी त्रुटि के निष्पादित हो जाए, मेरा मानना ​​है कि मैं लगभग 7-8 बाइट्स खो सकता था, और यह अभी भी सही ढंग से आउटपुट करेगा, लेकिन यह त्रुटि संदेश भी आउटपुट करेगा, और कोई भी ऐसा नहीं चाहता है।

पूर्ण बाइट स्पष्टीकरण:

[Space][Space][Space][N]                   Push a 0 on the stack
[Tab][Tab][N][Tab][Tab][Tab][Tab]          Read input value and store in heap
[Space][Space][Space][N]                   Push a 0 on the stack again
[Tab][Tab][Tab]                            Retrieve the value from the heap
[Space][Space][Tab][Tab][N]                Push a -1 on the stack
[Tab][Space][Space][Space]                 Add -1 to value
[Space][N][Space]                          Duplicate 
[Tab][N][Space][Tab]                       Output
[N][Space][Space][Space][N]                Set First Label
[Space][Space][Tab][Tab][Space][N]         Push a -2 on the stack
[Tab][Space][Space][Space]                 Subtract 2 from value
[Space][N][Space]                          Duplicate
[N][Tab][Tab][Space][Space][N]             If negative, jump to second label
[Space][N][Space]                          Duplicate
[Tab][N][Space][Tab]                       Output
[N][Space][N][Space][N]                    Jump back to first label
[N][Space][Space][Space][Space][N]         Set Second Label
[Space][Space][Space][N]                   Push a 0 on the stack
[Tab][Tab][Tab]                            Retrieve input value from heap again
[Space][Space][Tab][Tab][Space][N]         Push a -2 on the stack
[Tab][Space][Space][Space]                 This time, Add a -2 to the value
[Space][N][Space]                          Duplicate
[Tab][N][Space][Tab]                       Output
[Space][N][Space]                          Duplicate
[N][Space][N][Space][Tab][N]               Jump to third label
[N][Space][Space][Space][Tab][N]           Set third label
[Space][Space][Tab][Tab][Space][N]         Push a -2 on the stack
[Tab][Space][Space][Space]                 Subtract 2 from value
[Space][N][Space]                          Duplicate
[N][Tab][Tab][Space][Space][Space][N]      Jump to end if negative
[Space][N][Space]                          Duplicate
[Tab][N][Space][Tab]                       Output
[N][Space][N][Space][Tab][N]               Jump back to third label
[N][Space][Space][Space][Space][Space][N]  Set fourth label/end
[N][N][N]                                  Terminate
— X1M4L
स्रोत
गोल्फ के लिए कुछ चीजें: एक बाइट को बचाने के लिए push_0, read_STDIN_as_int, push_0, retrieveहो सकता push_0, duplicate_0, read_STDIN_as_int, retrieveहै। और पहला लेबल एक खाली के NSSNबजाय NSSSN(और फिर दूसरा लेबल हो सकता है NSSSN; तीसरा NSSTN; और चौथा NSSSSN)। यह 8 बाइट्स को भी बचाना चाहिए। इसके अलावा, आप पहले को हटा सकते हैं Jump_to_third_labelक्योंकि आपके पास Set_third_labelपहले से ही नीचे का अधिकार है। कुल में: 140 बाइट्स ; (या टिप्पणियों के साथ: इसे ऑनलाइन आज़माएं ।) -3 बाइट्स यदि आप NNNबाहर निकालते हैं ।
— केविन क्रूज़सेन
1

गोल> <> , 14 बाइट्स

FL:2%Z}:3=?$|B

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

उदाहरण पूर्ण कार्यक्रम और यह कैसे काम करता है

1AGIE;GDlR~
FL:2%Z}:3=?$|B

1AG          Register row 1 as function G
   IE;       Take number input; halt on EOF
      GD     Call G and print the stack
        lR~  Empty the stack
             Repeat indefinitely

F           |   Repeat n times...
 L              Push loop counter (0..n-1)
  :2%Z}         If even, move to bottom of the stack
       :3=?$    If top == 3, swap top two
                  This is activated only once to make [2 0 3 1]
             B  Return
— bubbler
स्रोत
1

जावा 8, 56 बाइट्स

n->{for(int i=n;i>0;)System.out.println((i+--i)%(n|1));}

पोर्ट @Neil का जावास्क्रिप्ट (ES6) उत्तर ।

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

पुराने 66 बाइट्स उत्तर:

n->{String[]r={"",""};for(;n-->0;)r[n%2]+=n+" ";return r[0]+r[1];}

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

स्पष्टीकरण:

n->{                  // Method with integer parameter and String return-type
  String[]r={"",""};  //  Result-Strings, both starting empty
  for(;n-->0;)        //  Loop in the range (n, 0]
    r[i%2]+=i+" ";    //   Append `i` and a space to one of the two result-Strings,
                      //   depending on if it is even (first) or odd (second)
  return r[0]+r[1];}  //  Return the two result-Strings appended to each other
— केविन क्रूज़सेन
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.