सम्मिलन प्रकार उलटा

Question

उद्देश्य

मूल स्क्रैम्बल सूची उत्पन्न करें, उन आंदोलनों से जो एक सम्मिलन सॉर्ट इसे सॉर्ट करने के लिए करेंगे। मूल सूची से सभी नंबरों को होगा 0करने के लिए N-1(सम्मिलित) जहां Nइनपुट के का आकार है।

इनपुट

सूची को सॉर्ट करने के लिए आवश्यक चाल वाली एक सूची। प्रत्येक मान उसकी सही स्थिति में होने के लिए मूल (तले हुए) संख्या द्वारा विस्थापित स्लॉट की मात्रा का प्रतिनिधित्व करता है, ध्यान रखें कि यह प्रक्रिया बाएं से दाएं है। इनपुट सूची में
मान (0-अनुक्रमित) स्थिति के iबीच 0और iसमावेशी होगा।
आपको अमान्य इनपुट को संभालने की आवश्यकता नहीं है, इस मामले में कोई भी व्यवहार स्वीकार्य है (क्रैश, अनंत लूप, आदि)।

उत्पादन

तले हुए सूची

कदम-दर-कदम कदमों को उत्पन्न करने के लिए

Scrambled List | Moves to sort
[4,0,2,1,3,5]  | [0, , , , , ] #4 stay in place
[4,0,2,1,3,5]  | [0,1, , , , ] #0 is moved 1 slot to the left
[0,4,2,1,3,5]  | [0,1,1, , , ] #2 is moved 1 slot
[0,2,4,1,3,5]  | [0,1,1,2, , ] #1 is moved 2 slot
[0,1,2,4,3,5]  | [0,1,1,2,1, ] #3 is moved 1 slot
[0,1,2,3,4,5]  | [0,1,1,2,1,0] #5 is in the right place already
[0,1,2,3,4,5]

इसलिए, इनपुट के लिए [0,1,1,2,1,0]आपके प्रोग्राम को आउटपुट की आवश्यकता है [4,0,2,1,3,5]।
ध्यान रखें कि हलकों की स्थिति अंतिम सूची में क्रमबद्ध नहीं है, लेकिन क्रमबद्ध खंड में (बोल्ड खंड)

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

[0,0,0] -> [0,1,2]
[0,1,0,1] -> [1,0,3,2]
[0,0,0,0,0,5] -> [1,2,3,4,5,0]
[0,1,2,3] -> [3,2,1,0]
[0,1,1,1] -> [3,0,1,2]
[0,1,1,2,1,0] -> [4,0,2,1,3,5]

जीतना

यह कोड-गोल्फ है , इसलिए सबसे छोटा उत्तर जीतता है।

Comments

क्या कार्यक्रम भी इनपुट के रूप में सूची की लंबाई ले सकता है?

— mbomb007

@ mbomb007 नप।

— रॉड

क्या हम इसके बजाय (n-1) चरणों का उपयोग कर सकते हैं? पहला अनावश्यक है, क्योंकि यह हमेशा शून्य है।

— जीबी

@GB यकीन है, जब तक आउटपुट सही है, आप किसी भी एल्गोरिथ्म का उपयोग कर सकते हैं

— रॉड

Answer 1

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

L!_UÆ¡$œ?J’U

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

व्याख्या

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

L!_UÆ¡$œ?J’U
   U           Reverse {the input}
    Æ¡         and convert from base factorial to integer;
  _   $        subtract that from
L!             the factorial of the length of {the input};
       œ?      then take the nth permutation of
         J     [1,2,...,l], where l is the length of {the input},
          ’    subtract 1 from every elevent,
           U   and reverse it

आधार तथ्य के मामले में, हम देख सकते हैं कि सूची का पहला तत्व 0 होना चाहिए, दूसरा 0 या 1 हो सकता है, तीसरा 0/1/2 होना चाहिए, और इसी तरह। इस प्रकार, हमें अपने तत्वों को आधार रूपांतरण के लिए सामान्य लेखन क्रम में लाने के लिए इनपुट को उल्टा करना होगा।

इसके अतिरिक्त, फैक्टरियल रूपांतरण और क्रमपरिवर्तन क्रम के साथ मेल खाने के लिए क्रमांकन जो कि सम्मिलन प्रकार का उपयोग करता है, के साथ मेल खाने के लिए, हमें दो समायोजन करने की आवश्यकता है: क्रमपरिवर्तन के क्रम को उलट देना और आउटपुट सूची के क्रम को उलट देना। आउटपुट सूची को उलटना आसान है, केवल Uकार्यक्रम के अंत में आवश्यकता होती है । क्रमपरिवर्तन के अनुक्रम को उलटने के लिए, हम इनपुट लंबाई के भाज्य से घटाते हैं (यह काम करता है क्योंकि आधार भाज्य 0 से लंबाई (लंबाई -1) में एक संख्या पैदा करता है, जबकि क्रमपरिवर्तन 1 से लंबाई तक जेली द्वारा क्रमांकित किए जाते हैं! , एक अंतर्निहित ऑफ-बाय-वन का निर्माण करना, जो ऑफ-बाय-वन को रद्द कर देता है जो आपको आम तौर पर एक फैक्टरियल से क्रमचय सूचकांक को घटाते समय मिलता है)।

@JonathanAllan के सहयोग से जेली , 9 बाइट्स

UÆ¡Nœ?J’U

कार्यक्रम का यह संस्करण बहुत समान है, लेकिन क्रमपरिवर्तन के क्रम को उलटने की एक अलग विधि का उपयोग करता है; बस के साथ इनपुट की उपेक्षा करना रिवर्स ऑर्डर में उपचार Nकरने के लिए पर्याप्त है œ?। इसके अलावा, यह पिछले कार्यक्रम के लिए समान रूप से काम करता है।

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

Comments

O_O क्या टोना है ?

— DLosc

ओह अच्छा - मुझे पता था कि मेरे Æ¡और œ?परमाणु इसके लिए काम करेंगे (मैंने पहले ही उन्हें इस चुनौती के लिए इस्तेमाल करने की कोशिश शुरू कर दी थी - मैं इतना करीब था, बस L!वहां की जरूरत थी )।

— जोनाथन एलन

बहुत बढ़िया कोड!

— ग्रेग मार्टिन

वास्तव में, आप इसे 9 बाइट्स में कर सकते हैं UÆ¡Nœ?L’Uक्योंकि मैंने कार्यान्वित किया œ?(और समान) मॉड्यूलर रूप से कार्य करने के लिए (जैसे कि वे जेली सूचियों का उपयोग कर रहे थे)। Nनकारात्मक मूल्य के साथ में सिर्फ अनुक्रमित। नोट: मैंने इसे बदल दिया Jहै L- यह सिर्फ इसलिए है क्योंकि एक नंबर दिया गया है जो किसी भी तरह से अंडर-द-हुड बनाता है)।

— जोनाथन एलन

Answer 2

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

Permute[Range[l=Length@#]-1,(c=Cycles@{#}&)@{}©##&@@c[i-0~Range~#[[i]]]~Table~{i,l,1,-1}]&

शुद्ध फ़ंक्शन इनपुट के रूप में nonnegative पूर्णांक की एक सूची ले रहा है और nonnegative पूर्णांक की एक सूची लौटाता है। उपरोक्त कोड में एक है ©, जो गलत है: यह 3-बाइट के प्रतीक U + F3DE के लिए एक प्लेसहोल्डर है, जो गणितज्ञ इसमें एक डॉट के साथ एक सर्कल का प्रतिनिधित्व करता है, और जो क्रमपरिवर्तन की संरचना का प्रतिनिधित्व करता है।

c=Cycles@{#}&एक फ़ंक्शन को परिभाषित करता है जो Cyclesएक क्रमपरिवर्तन का प्रतिनिधित्व करने वाले ऑब्जेक्ट में पूर्णांकों की सूची को परिवर्तित करता है; उदाहरण के लिए, c[{3,4}]एक सूची के तत्वों 3 और 4 स्वैपिंग स्वैपिंग तत्व है। c[i-0~Range~#[[i]]]~Table~{i,l,1,-1}]इनपुट सूची लेता है और प्रविष्टि प्रकार को पूर्ववत करने के लिए आवश्यक क्रमचय उत्पन्न करता है। फिर c@{}©##&@@इन सभी क्रमपरिवर्तन को एक साथ पहचान पहचान के साथ शुरू करता है c@{}। अंत में, Permute[Range[l=Length@#]-1,...]उपयुक्त लंबाई की 0-अनुक्रमित सूची में इस क्रमपरिवर्तन को लागू करता है।

Comments

क्या कोई निर्मित में ?! निश्चित रूप से ...

— जोनाथन एलन

@{#}&)@{}©##&@@भयानक लगता है।

— यति

Answer 3

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

10 बाइट बचाने के लिए क्रैजोर को धन्यवाद

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

a=input();b=range(len(a));print[b.pop(j-a[j])for j in b[::-1]][::-1]

रिवर्स में चाल उत्पन्न करके काम करता है

Comments

वो 66 करो! कैसे के बारे में: a=input();b=range(len(a));print[b.pop(j-a[j]) for j in b[::-1]][::-1]। सूची समझें ftw!

— फुआज

@Krazor आपके पास एक ऐसी जगह है जिसे पहले हटाया जा सकता था for, इसलिए यह सुनिश्चित करें कि मैं 65 का अनुमान

— लगाऊं

@Krazor सूची समझ से बाहर निकला काफी काम नहीं किया, लेकिन मुझे b [:: - 1] का उपयोग करने का विचार पसंद आया!

— गणित नशेड़ी

बिल्कुल नहीं? मैंने मोबाइल से टिप्पणी की, शायद मैंने कुछ गलत किया है। कौन सा हिस्सा काम नहीं करता है? मेरे लिए, इसने सही ढंग से व्याख्या की और सभी परीक्षण मामलों को पूरा किया।

— फियाज

@Krazor ओह हूप्स, नो यू आर राइट। मैं वह हूं जिसने परीक्षण करते समय इसे गलत समझा।

— गणित नशेड़ी

Answer 4

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

a=>a.reverse(b=[...a.keys()]).map(o=>+b.splice(~o,1)).reverse()

अनायास इनपुट और आउटपुट दोनों गलत क्रम में हैं। संपादित करें: @Annauld के लिए 4 बाइट्स सहेजे गए। सहेजे गए 2 बाइट्स @ETHproductions के लिए धन्यवाद।

Comments

मैं अभी भी एक बेहतर तरीका खोजने की कोशिश कर रहा था लेकिन आप बहुत तेज थे। अच्छा है!

— अरनौलद

आपको जरूरत नहीं है i, क्या आपको?

— अरनौलड

@ अरनल्ड जाहिर नहीं। मैंने पायथन उत्तर को समझने की कोशिश करके शुरुआत की, और मैंने केवल यह देखा है कि यह वास्तव में उपयोग नहीं करता है i...

— नील

आसान -2:o=>+b.splice(~o,1)

— ETHproductions

Answer 5

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

सहेजे गए 2 बाइट्स ETHproductions के लिए धन्यवाद

m=>(a=m.map((_,i)=>j=i)).map(_=>a.splice(j,0,+a.splice(j-m[j--],1)))&&a

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

let f =

m=>(a=m.map((_,i)=>j=i)).map(_=>a.splice(j,0,+a.splice(j-m[j--],1)))&&a

console.log(JSON.stringify(f([0,0,0])));       // -> [0,1,2]
console.log(JSON.stringify(f([0,1,0,1])));     // -> [1,0,3,2]
console.log(JSON.stringify(f([0,0,0,0,0,5]))); // -> [1,2,3,4,5,0]
console.log(JSON.stringify(f([0,1,2,3])));     // -> [3,2,1,0]
console.log(JSON.stringify(f([0,1,1,1])));     // -> [3,0,1,2]
console.log(JSON.stringify(f([0,1,1,2,1,0]))); // -> [4,0,2,1,3,5]

Comments

एक ही समय में लंबाई और सीमा प्राप्त करने का अच्छा तरीका। मैं सुझाव देने वाला था a=m.map(_=>j++,j=0), लेकिन यह वही लंबाई है और मुझे यकीन है कि आप पहले ही इसे आज़मा चुके हैं।

— ETHproductions

@ETHproductions आप सही हैं: मैंने इसे भी आजमाया है। :-) (यह ध्यान देने योग्य है कि इस बराबर नहीं है लायक हो सकता है: इस स्थापित करेगा jकरने a.lengthके बजाय a.length-1और की आवश्यकता होगी a.splice(--j,0,a.splice(j-m[j],1)[0]))

— Arnauld

हे, मैं भी उस के बारे में सोचा था, लेकिन मुझे नहीं लगा कि यह ध्यान देने योग्य है क्योंकि यह समान लंबाई है

— ETHproductions

आसान -2:+a.splice(j-m[j--],1)

— ETHproductions

Answer 6

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

f x|n<-length x-1=reverse x#[n,n-1..0]
(n:r)#l=r#(take n l++drop(n+1)l)++[l!!n]
x#l=x

इसे ऑनलाइन आज़माएं!उदाहरण उपयोग: f [0,1,1,2,1,0]पैदावार [4,0,2,1,3,5]।

f xफ़ंक्शन #को सूची में xउलट और एक सूची के साथ कॉल करता है [length x - 1, length x - 2, ... , 0]। (n:r)#lप्रदर्शन रिवर्स प्रविष्टि प्रकार रिकर्सिवली लेने के द्वारा nसे बाहर वें तत्व lहै, जहां l!!nपैदावार nवें तत्व और take n l++drop(n+1)lपैदावार सूची lके साथ nहटा दिया वें तत्व।

Comments

हास्केल, इतना सुंदर।

— FMaz

Answer 7

पर्ल, 61 बाइट्स

@o=@p=0..@ARGV-1;splice@o,$_,0,splice@o,$_-pop,1for reverse@p

आउटपुट @ एओ में समाप्त होता है। कमांड लाइन तर्क के रूप में इनपुट सरणी के साथ उदाहरण:

perl -le'@o=@p=0..@ARGV-1;splice@o,$_,0,splice@o,$_-pop,1for reverse@p;print@o' 0 1 1 2 1 0
402135

Answer 8

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

->l{(w=l.size).times{l.insert(l.shift+w-=1,w)};l}

सूची के अंदर जगह में "रिवर्स सम्मिलन" करता है, सबसे बड़ी संख्या के साथ शुरू होता है।