एक सरणी के एकल स्वैप

19

से प्रेरित होकर से लिया स्टैक ओवरफ़्लो पर एक सवाल ।

चुनौती

पूर्णांक को देखते हुए n>1, सभी सरणियों को आउटपुट करता है जो सरणी में बिल्कुल दो प्रविष्टियों को स्वैप करके प्राप्त किया जा सकता है [1, 2, ..., n]।

सरणियों को किसी भी क्रम में उत्पादित किया जा सकता है।

आप [0, 1, ..., n-1](1-आधारित) के बजाय (0-आधारित) का लगातार उपयोग कर सकते हैं [1, 2, ..., n]।

अतिरिक्त नियम

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

इनपुट 2आउटपुट देता है (1-आधारित माना जाता है)

2 1

इनपुट 3आउटपुट देता है (ध्यान दें कि तीन सरणियाँ किसी भी क्रम में हो सकती हैं)

1 3 2
2 1 3
3 2 1

इनपुट 4आउटपुट देता है

1 2 4 3
1 3 2 4
1 4 3 2
2 1 3 4
3 2 1 4
4 2 3 1

इनपुट 7आउटपुट देता है

1 2 3 4 5 7 6
1 2 3 4 6 5 7
1 2 3 4 7 6 5
1 2 3 5 4 6 7
1 2 3 6 5 4 7
1 2 3 7 5 6 4
1 2 4 3 5 6 7
1 2 5 4 3 6 7
1 2 6 4 5 3 7
1 2 7 4 5 6 3
1 3 2 4 5 6 7
1 4 3 2 5 6 7
1 5 3 4 2 6 7
1 6 3 4 5 2 7
1 7 3 4 5 6 2
2 1 3 4 5 6 7
3 2 1 4 5 6 7
4 2 3 1 5 6 7
5 2 3 4 1 6 7
6 2 3 4 5 1 7
7 2 3 4 5 6 1
code-golf  number  combinatorics  integer 
— लुइस मेंडो
स्रोत
Oeis.org/A211369 प्लस एक (या दो अगर 0-इंडेक्सिंग) द्वारा दिए गए अनुक्रमितों पर प्रविष्टियां लंबाई n के सभी क्रमपरिवर्तन की क्रमबद्ध सूची में हैं।
— जोनाथन एलन
5
मैं [0 ... n-1]बनाम के लचीलेपन की सराहना करता हूं [1 ... n]! मैं हमेशा थोड़ा परेशान महसूस करता हूं, 1+क्योंकि मुझे जीरो-इंडेक्स पर काम करना पड़ता है ।
— कोल

जवाबों:

3

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

ŒcżU$y€R

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

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

ŒcżU$y€R  Main link. Argument: n

Œc        Take all 2-combinations of [1, ..., n].
  żU$     Zip the result with the reversed pairs.
       R  Range; yield [1, ..., n].
     y€   For each [[i, j], [j, i]] in the result to the left, yield the result to
          the right, with i replaced by j and vice versa.
— डेनिस
स्रोत
वास्तव में क्या करता yहै? यह हमेशा मेरे लिए थोड़ा रहस्य की बात रही है।
— केयर्ड सिक्काहिंगाहिंग
यह प्रतिस्थापन करता है। उदाहरण के लिए, [1,2],[4,3]y1,2,3प्रत्येक 1 को [1, 2, 3] में 4 के साथ और प्रत्येक 2 को 3 के साथ बदल देता है ।
— डेनिस
8

आर , 54 बाइट्स

function(n)combn(n,2,function(x){z=1:n
z[x]=rev(x)
z})

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

एक मैट्रिक्स लौटाता है जहां प्रत्येक कॉलम एक क्रमचय है।

combn(n,k)kसूची से आकार के सभी संयोजनों को उत्पन्न करता है n, या 1:nयदि nएक पूर्णांक है। यह वैकल्पिक FUNरूप से परिणामी संयोजनों पर लागू होने के लिए एक फ़ंक्शन लेता है । तो हम एक फ़ंक्शन लिखते हैं जो स्वैप करता है और स्वैप की गई सूची को लौटाता है। परिणाम तब सभी एक में जमा होते हैं array, जो इस मामले में 2-आयामी है और इसलिए एक मैट्रिक्स है।

— ग्यूसेप
स्रोत
5

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

r/.{#->#2,#2->#}&@@@Subsets[r=Range@#,{2}]&

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

स्पष्टीकरण: आकार 2 के Subsets[Range@#,{2}]सभी सबसेट उत्पन्न करता है {1,2,...,n}, फिर प्रत्येक सबसेट के लिए, /.सूची में उन दो चीजों को स्वैप करता है {1,2,...,n}।

यह दृष्टिकोण अन्य सबमिशनों में से कई के समान निराशाजनक है, लेकिन यहां 3 अतिरिक्त बाइट्स के लिए मैथमेटिका के लिए अधिक अद्वितीय है:

r~Permute~Cycles@{#}&/@Subsets[r=Range@#,{2}]&

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

— पेड़ नहीं
स्रोत
2
इससे भी अधिक मुहावरेदार गणितज्ञ समाधान होगा ReplaceList[Range@#,{a___,b_,c___,d_,e___}:>{a,d,c,b,e}]&। मुझे यह पसंद है कि यह कितना सरल है (या यह सीधे समस्या को कैसे एनकोड करता है), लेकिन दुर्भाग्य से पैटर्न मिलान वाक्यविन्यास इतना क्रियात्मक है कि यह 57 बाइट्स तक समाप्त होता है।
— मार्टिन एंडर
5

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

g n|b<-[1..n]=[[last$k:[j|k==i]++[i|k==j]|k<-b]|i<-b,j<-b,j<i]

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

i<-b                -- loop 'i' through [1..n]
     j<-b           -- loop 'j' through [1..n]
          j<i       -- consider only cases where j<i 
 [            k<-b] -- make a list by looping 'k' through [1..n] 
  last              -- pick
          [i|k==j]  -- 'i' if k==j
       [j|k==i]     -- 'j' if k==i
     k              -- 'k' else
— nimi
स्रोत
4

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

f 0=[]
f x=map(++[x])(f$x-1)++[[1..y-1]++x:[y+1..x-1]++[y]|y<-[1..x-1]]

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

यह वर्तमान संख्या को अंतिम के सभी क्रमपरिवर्तन के अंत में जोड़ता है और फिर उन सभी स्वैप की गणना करता है जिसमें नई संख्या शामिल होती है।

— गेहूं का जादूगर
स्रोत
4

MATL , 12 बाइट्स

:2XN!"G:@tP(

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

            %implicit input, say, 4
:           %range, stack is {[1,2,3,4]}
2           %push 2
XN          %nchoosek, compute all combinations of [1,2,3,4] taken 2 at a time
            %this results in a matrix where each row is a combination, i.e.,
            %[1, 2;
              1, 3;
              1, 4;
              2, 3;
              2, 4;
              3, 4]
!           %transpose, because "for" iterates over columns
"           %begin for loop
G:          %push input and range, stack is now [1,2,3,4]
@t          %push "for" index (the column), say, [1;2], twice
P           %flip array, so stack is now: {[1,2,3,4],[1;2],[2;1]}
(           %assignment index, sets [1,2,3,4]([1;2])=[2;1],
            %resulting in [2,1,3,4]
            %implicit end of loop, implicit end of program, print the stack implicitly.

— ग्यूसेप
स्रोत
1
2 बाइट्स मैं परीक्षण मामलों को उत्पन्न करने के लिए उपयोग किए जाने वाले कोड से कम है, और अधिक संयोग से :-):
— लुइस
@LuisMendo आपने परीक्षण मामलों को कैसे उत्पन्न किया? मुझे चिंता थी कि मेरा आदेश लंबा नहीं था, क्योंकि वह समान नहीं था!
— Giuseppe
1
मैंने इस्तेमाल किया :tY@wy=~!s2=Y)। Rahnema1 के ऑक्टेव उत्तर के रूप में एक ही दृष्टिकोण, मुझे लगता है
— लुइस मेंडो
3

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

@(n)(p=perms(k=1:n))(sum(p~=k,2)==2,:)

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

1: n के सभी क्रमपरिवर्तन उत्पन्न करता है और उन लोगों से चयन करता है जिनके पास 1: n से भिन्न दो तत्व हैं।

— rahnema1
स्रोत
2

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

प्रिंट 0-अनुक्रमित सरणियाँ।

n=>(a=[...Array(n).keys()]).map(i=>a.map(j=>i>j&&alert(a.map(k=>k-i?k-j?k:i:j))))

डेमो

alert()console.log()उपयोगकर्ता-मित्रता के लिए इस स्निपेट में बदल दिया गया है।

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

— Arnauld
स्रोत
2

क्लीन , 90 82 बाइट्स

import StdEnv
$n#n=[1..n]
=tl(removeDup[[if(c<>b)if(c<>a)c b a\\c<-n]\\b<-n,a<-n])

यह 80 बाइट्स में किया जा सकता है, लेकिन यह हास्केल उत्तरों के प्रत्यक्ष अनुवाद में बदल जाता है।

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

— Οurous
स्रोत
2

05AB1E , 15 9 बाइट्स

LœʒD{αĀO<

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

व्याख्या

L            # push range [1 ... input]
 œ           # get all permutations
  ʒ          # filter, keep only elements that are true when
     α       # absolute value is taken with
   D{        # a sorted copy
      Ā      # each non-zero value in the resulting array is converted to 1
       O     # the array is summed
        <    # and the sum is decremented
— Emigna
स्रोत
2

रूबी , 55 53 बाइट्स

->n{n.times{|x|x.times{|y|(w=*0...n)[w[x]=y]=x;p w}}}

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

0-आधारित समाधान

यहाँ चाल यह है कि आंतरिक लूप हमेशा एक चलना छोड़ देता है: पहली बार जब यह बिल्कुल निष्पादित नहीं होता है, तो केवल एक बार दूसरे पास पर, और इसी तरह।

मैं 55 बाइट्स से खुश था जब तक कि मैंने नहीं देखा कि आर 54 तक नीचे गिरा हो सकता है, इसलिए मुझे इसे 53 पर लाना पड़ा।

— जीबी
स्रोत
लचीली आउटपुट बाधाओं का बहुत चालाक उपयोग।
— अनीहेड्रॉन
1

अजगर, 9 बाइट्स

t{.rLQ*=U

प्रदर्शन

दो मूल्यों को स्वैप करने का सबसे आसान तरीका उपयोग करना है .r, जो कि पायथ का रोटरी अनुवाद फ़ंक्शन है। .r<list>[A, B]की सभी घटनाओं स्वैप जाएगा Aऔर Bमें list।

इसलिए, के लिए अनुवाद समारोह लगाने से UQसे, सूची 0के लिए n-1सूची में अलग नंबरों से प्रत्येक दो तत्व की सूची के साथ, हम वांछित आउटपुट उत्पन्न होगा। Qइनपुट है, nऔर Uरेंज फ़ंक्शन है।

ऐसा करने का आसान तरीका होगा:

.rLUQ.cUQ2

.cUQ2रेंज में विभिन्न तत्वों के सभी 2 तत्व संयोजन उत्पन्न करता है, और उन पर और सूची .rLUQमें .rफ़ंक्शन को मैप करता है UQ।

हालाँकि, यह 10 बाइट्स होगा।

बनाने के बजाय .cUQ2, विशिष्ट क्रमबद्ध जोड़े, हम सभी जोड़े बना सकते हैं *=U। यह अंतर्निहित रूप से बराबर है *=UQQ। ओवरराइट करके शुरू होता है Qके साथ UQ, फिर की कार्तीय उत्पाद लेने UQऔर UQ। यह सीमा में सभी जोड़ियों को आवश्यक रूप से आदेशित या अलग नहीं करता है।

.rLQप्रत्येक सूची का उपयोग करके स्वैप। याद रखें कि Qअब से सूची के बराबर 0करने के लिए n-1, नहीं n।

क्योंकि जोड़े का आदेश नहीं दिया गया था, डुप्लिकेट हैं। {डुप्लिकेट निकालता है। क्योंकि जोड़े अलग नहीं थे, अपरिवर्तित सूची मौजूद है। यह सूची हमेशा कटौती के बाद पहली होगी, क्योंकि {पहली उपस्थिति के क्रम को बरकरार रखता है और अपरिवर्तित सूची को घुमाकर निर्मित किया जाता है [0,0]। tपहले तत्व को हटाता है, स्वैप की वांछित सूची देता है।

— isaacg
स्रोत
1

अजगर, 11 बाइट्स

fq2snVTUQ.p

इसे ऑनलाइन आज़माएं
isaacg के दृष्टिकोण जितना छोटा नहीं है, लेकिन पोस्ट करने के लिए पर्याप्त भिन्न है।

व्याख्या

fq2snVTUQ.p
         .pQ  Take the permutations of the (implicit) range [0,...,input].
f     T       Filter to get the permutations...
   snV UQ     ... where the number of differences with [0,...,input]...
 q2           ... is 2.
1

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

n->{String r="";for(int i=0,j,k;i++<n;)for(j=i;j++<n;r+="\n")for(k=0;k++<n;)r+=k!=i?k!=j?k:i:j;return r;}

मैं कठोर हूँ .. महीनों में कोड-गोल्फ नहीं किया गया .. @Steadybox C उत्तर को पोर्ट करना समाप्त कर दिया गया .. शायद कुछ और गोल्फ हो सकता है।

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

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

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

-12 बाइट्स यूनीहेड्रॉन के लिए धन्यवाद।

->n{(r=1..n).map{|x|r.map{|y|r.map{|i|i==x ?y:i==y ?x:i}}}.flatten(1).uniq[1,n]}

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

मेरे मन में एक दृष्टिकोण था कि किसी कारण से रूबी के लिए सबसे अच्छा अनुवाद किया ... मैं वास्तव में रूबी को नहीं जानता ...

— totallyhuman
स्रोत
मैंने इसे outgolfed किया: codegolf.stackexchange.com/a/152652/21830 । माफ़ करना!
— यूनीहेड्रॉन
माफी मांगने की कोई जरूरत नहीं है! मुझे लगता है कि मैं ज्यादातर पीपीसीजी उपयोगकर्ताओं के लिए बोलता हूं जब मैं कहता हूं कि प्रतियोगिता वही है जो पीपीसीजी को शांत करती है।
— अमानवीय
1
अपने कोड के लिए, 1. आप 1..nएक-चर चर को असाइन कर सकते हैं और इसे फिर से उपयोग कर सकते हैं (अलग-अलग स्टेटमेंट्स के साथ न्यूक्लियर या सेमीकोलन), 2. दो शब्दों में कोष्ठक के बिना करें: i==x ?y:i==y ?x:i(ध्यान दें कि मेरे पास संभावित खंभे को अलग करने के लिए रिक्त स्थान हैं) ) और 3. के uniq[1,n]बदले uniq[1..-1]।
— अनहाइड्रोन
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.