लेक्सिकोग्राफ़िक रूप से क्रमबद्ध क्रम में प्रीपेन्ड-अपेंडेड क्रमपरिवर्तन का सेट उत्पन्न करें

Question

निम्नलिखित प्रक्रिया द्वारा उत्पन्न की जा सकने वाली संख्याओं का क्रमपरिवर्तन करने के लिए लंबाई के पूर्व -क्रम-परिशिष्ट अनुक्रम को परिभाषित करें :n1, 2, ..., n

• नंबर से शुरू करें 1।

• से प्रत्येक संख्या के 2लिए n, इस संख्या को अनुक्रम की शुरुआत या अंत में रखें (या तो इसे पूर्व निर्धारित करें या इसे जोड़ दें, इसलिए अनुक्रम का नाम)।

उदाहरण के लिए, यह लंबाई 4 का प्रीपेन्ड-अपेंडेंस अनुक्रम उत्पन्न करने का एक वैध तरीका है:

1
21     [beginning]
213    [end]
2134   [end]

आपका काम एक प्रोग्राम या समारोह है कि एक नंबर ले जाएगा निर्माण करने के लिए है nसे 3करने के लिए 30इनपुट के रूप में, और प्रिंट या लंबाई के सभी आगे जोड़ते-संलग्न दृश्यों लौट nऊपर 9 प्रतिनिधित्व किया जाएगा lexicographical क्रम में (आप तार और नहीं सूची, संख्या outputting रहे हैं अगर पत्र के रूप में a-u, स्ट्रिंग की लंबाई को संरक्षित करने के लिए)। उदाहरण के लिए, यह वह क्रम है n = 4:

1234  [RRR]
2134  [LRR]
3124  [RLR]
3214  [LLR]
4123  [RRL]
4213  [LRL]
4312  [RLL]
4321  [LLL]

सामान्य तौर पर, लंबाई के 2 ^n-1 प्रीपेन्ड-अपेंड परमुटेशन होते हैं n।

आप अपने कोड में अपनी भाषा में किसी भी अंतर्निहित छँटाई कार्यों का उपयोग नहीं कर सकते हैं। किसी भी भाषा में ऐसा करने वाला सबसे छोटा कार्यक्रम जीत जाता है।

Comments

मैं आउटपुट स्वरूप की आवश्यकता का प्रशंसक नहीं हूं, विशेष रूप से अक्षरों में रूपांतरण a-u। क्या हम केवल संख्याओं की सूची तैयार कर सकते हैं?

— xnor

आप कुछ समय के बाद उत्तर को स्वीकार करना चाहते हैं क्योंकि कुछ लोग किसी प्रश्न का उत्तर नहीं देते हैं यदि उसके पास एक स्वीकृत उत्तर है।

— ऑप्टिमाइज़र

तो आपके पास गलत उत्तर है ..

— ऑप्टिमाइज़र

FryAmTheEggman ने अपना संपादन संपादित करने से 21 मिनट पहले अपना उत्तर पोस्ट किया।

— जो जेड

@Optimizer मुझे नहीं लगता कि यह सबसे अजीब तरीका है - FryAmTheEggman का जवाब 19 बाइट्स 21 मिनट पहले तुम्हारा था। यह इसे जल्द से जल्द पोस्ट करने वाला सबसे छोटा उत्तर बनाता है।

— जो जेड

Answer 1

CJam, 22 20 19 17 बाइट्स

]]l~{)f+_1fm>|}/p

कोड विस्तार :

]]                   "Put [[]] onto stack. What we will do with this array of array is";
                     "that in each iteration below, we will first append the next";
                     "number to all present arrays, then copy all the arrays and";
                     "move the last element to first in the copy";
  l~                 "Read input number. Lets call it N";
    {         }/     "Run this code block N times ranging from 0 to N - 1";
     )f+             "Since the number on stack starts from 0, add 1 to it and append";
                     "it to all arrays in the array of array beginning with [[]]";
        _1fm>        "Copy the array of array and move last element from all arrays";
                     "to their beginning";
             |       "Take set union of the two arrays, thus joining them and eliminating";
                     "duplicates. Since we started with and empty array and started adding";
                     "numbers from 1 instead of 2, [1] would have appeared twice if we had";
                     "simply done a concat";
                p    "Print the array of arrays";

यह कैसे काम करता है :

यह कोड का डिबग संस्करण है:

]]l~ed{)edf+ed_ed1fm>ed|ed}/edp

आइए देखें कि यह इनपुट के लिए कैसे काम करता है 3:

[[[]] 3]                                 "]]l~"            "Empty array of array and input";
[[[]] 1]                                 "{)"              "First iteration, increment 0";
[[[1]]]                                  "{)f+"            "Append it to all sub arrays";
[[[1]] [[1]]]                            "{)f+_"           "Copy the final array of array";
[[[1]] [[1]]]                            "{)f+_1fm>"       "shift last element of each";
                                                           "sub array to the beginning";
[[[1]]]                                  "{)f+_1fm>|}"     "Take set based union";
[[[1]] 2]                                "{)"              "2nd iteration. Repeat";
[[[1 2]]]                                "{)f+"
[[[1 2]] [[1 2]]]                        "{)f+_";
[[[1 2]] [[2 1]]]                        "{)f+_1fm>";
[[[1 2] [2 1]]]                          "{)f+_1fm>|}";
[[[1 2] [2 1]] 3]                        "{)";
[[[1 2 3] [2 1 3]]]                      "{)f+"
[[[1 2 3] [2 1 3]] [[1 2 3] [2 1 3]]]    "{)f+_";
[[[1 2 3] [2 1 3]] [[3 1 2] [3 2 1]]]    "{)f+_1fm>";
[[[1 2 3] [2 1 3] [3 1 2] [3 2 1]]]      "{)f+_1fm>|}";
[[[1 2 3] [2 1 3] [3 1 2] [3 2 1]]]      "{)f+_1fm>|}/";

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

Answer 2

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

f 1=[[1]]
f n=(\x->map(++[n])x++map(n:)x)$f$n-1

Comments

सूची बोध पर स्विच करने से कुछ बाइट्स बचते हैं: f n=[[n:x,x++[n]]|x<-f$n-1]>>=id(कोड-गोल्फर्स कॉनैट फ़ंक्शन का उपयोग करके >>=id)।

— नीमी

@ निमि लेकिन इसके गलत क्रम में r

— गर्व हैस्केलर

@proudhaskeller: ओह डियर, कल्पना को ध्यान से नहीं पढ़ा। मैंने इसे ठीक करने की कोशिश की और @ alephalpha के संस्करण के समान लंबाई के सभी चार अलग-अलग तरीके पाए, इसलिए मैं सुधार की पेशकश नहीं कर सकता। f n=[x++[n]|x<-f$n-1]++[n:x|x<-f$n-1], f n=map(++[n])(f$n-1)++[n:x|x<-f$n-1], f n=map(++[n])(f$n-1)++map(n:)(f$n-1),f n=(++[n])#n++(n:)#n;p#i=map p$f$i-1

— nimi

Answer 3

अजगर 2, 68

f=lambda n:[[1]]*(n<2)or[x*b+[n]+x*-b for b in[1,-1]for x in f(n-1)]

संख्याओं की सूची की सूची को आउटपुट करता है।

एक पुनरावर्ती समाधान। के लिए n==1, उत्पादन [[1]]। अन्यथा, nसभी (n-1)-permutations के प्रारंभ या अंत में जोड़ें। प्रीपेडिंग क्रमांकन के मुकाबले क्रमिक रूप से बाद में होता है, इसलिए क्रमबद्धता क्रमबद्ध रहती है।

"बुलियन" bएन्कोड करता है कि क्या [n]शुरू या अंत में रखा जाए । दरअसल, हम शेष सूची xको अभिव्यक्ति में स्थानांतरित करते हैं x*b+[n]+x*-b। के bरूप में लाना -1या 1उपेक्षा करके फ्लिप का उपयोग करने देता है, क्योंकि एक सूची को गुणा करके -1खाली सूची है।

Answer 4

अजगर, १ ९

usCm,+dH+HdGr2hQ]]1

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

यह एक पूर्ण कार्यक्रम है जो स्टड से इनपुट लेता है।

यह xnor के समाधान के लिए एक समान तरीके से काम करता है, लेकिन मानों को थोड़ा बाहर करता है, इसलिए उन्हें पुन: व्यवस्थित करना होगा। प्रत्येक स्तर पर क्या होता है कि मूल्यों की प्रत्येक पिछली सूची में नए मूल्य अंत में और शुरुआत में जोड़े जाते हैं और ये प्रत्येक 2-ट्यूपल में लिपटे होते हैं जो एक सूची में एक साथ लिपटे होते हैं। उदाहरण के लिए, पहला कदम यह करता है:

[[1]]
[([1,2], [2,1])]

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

2-> 3 दिखाने वाले चरण:

([1,2], [2,1])
[([1,2,3],[3,1,2]),([2,1,3],[3,2,1])]
([1,2,3],[2,1,3],[3,1,2],[3,2,1])

Answer 5

मैथेमेटिका, 57 54 49 बाइट्स

f@1={{1}};f@n_:=#@n/@f[n-1]&/@Append~Join~Prepend

उदाहरण:

f[4]

{{1, 2, 3, 4}, {2, 1, 3, 4}, {3, 1, 2, 4}, {3, 2, 1, 4}, {4, 1, 2, 3} , {४, २, १, ३}, {४, ३, १, २}, {४, ३, २, १}}

Answer 6

जे, 26 बाइट्स

   0|:<:((,,.,~)1+#)@[&0,.@1:

   (0|:<:((,,.,~)1+#)@[&0,.@1:) 3
1 2 3
2 1 3
3 1 2
3 2 1

1-बाइट सुधार FUZxxl के लिए धन्यवाद ।

Comments

स्थानापन्न ,.के लिए ,"1एक चरित्र के लिए।

— फ़ूजएक्सएक्सएल

Answer 7

Pyth, 34 33 31 29

मूल रूप से xnor के पायथन जवाब का अनुवाद । मैं अभी भी पायथ के साथ महान नहीं हूं, इसलिए सुधार सुझावों का स्वागत है।

yपूर्णांकों की सूची की सूची वापस करने के लिए एक फ़ंक्शन को परिभाषित करता है ।

L?]]1<b2smm++*kdb*k_dy-b1,1_1

अपडेट: सहेजे गए 2 बाइट्स FryAmTheEggman की बदौलत ।

स्पष्टीकरण:

L                                  define a function y with argument b that returns
 ?*]]1<b2                          [[1]] if b < 2 else
         s                         sum(
          m                        map(lambda d:
           m                       map(lambda k:
            ++*kdb*k_d             k*d + [b] + k*-d
                      y-b1         , y(b - 1))
                          ,1_1)    , (1, -1))

Comments

कुछ pyth सामान: -b1हो सकता है tb, [1_1)हो सकता है ,1_1(हालांकि तुम सिर्फ पास ब्रैकेट ड्रॉप कर सकते हैं के रूप में आप केवल, गिनती करने के लिए समारोह बनाने के लिए आवश्यक बाइट की जरूरत है, भले ही आप इसे बंद किए बिना इसे कहते हैं सक्षम नहीं होगा), और आप bएक सूची में लपेटने की आवश्यकता नहीं है क्योंकि एक सूची में एक इंट में जोड़ते समय अजगर स्वचालित रूप से सूची में परिवर्तित हो जाता है।

— FryAmTheEggman

मैं मैन्युअल रूप से दूसरा नक्शा खत्म करके कई बाइट्स को बचाने का एक तरीका लेकर आया था [1,-1]। मैं बाइट्स को हार्डकोड में से कुछ को बचा सकता हूं, खासकर जब आप तर्क को सरल बनाते हैं। मुझे मिलता हैL?]]1<b2sCm,+db+bdytb

— FryAmTheEggman

@FryAmTheEggman आप वास्तव में अपने खुद के जवाब के रूप में जोड़ना चाह सकते हैं। यह सिर्फ कमाल है।

— पुरकाकूदरी

ठीक है, मैं पोस्ट करने से पहले सीजेएम को हराने की कोशिश करना चाहता था लेकिन मुझे लगता है कि जिप ट्रिक इसे पोस्ट करने की योग्यता के लिए काफी दिलचस्प है। पाइथ के साथ शुभकामनाएँ;)

— फ्राईमईएग्गमैन

Answer 8

शुद्ध बैश, 103

मैं उम्मीद कर रहा था:

a=1..1
for i in {2..9} {a..u};{
((++c<$1))||break
a={${a// /,}}
a=`eval echo $a$i $i$a`
}
echo ${a%%.*}

Answer 9

जावास्क्रिप्ट (ईएस 6) 73 80

@ ऑप्टिमाइज़र के अच्छे समाधान का जावास्क्रिप्ट कार्यान्वयन।

पुनरावर्ती (73):

R=(n,i=1,r=[[1]])=>++i>n?r:r.map(e=>r.push([i,...e])+e.push(i))&&R(n,i,r)

Iterative (74):

F=n=>(i=>{for(r=[[1]];++i<=n;)r.map(e=>r.push([i,...e])+e.push(i))})(1)||r

फ़ायरफ़ॉक्स / फायरबग कंसोल में टेस्ट करें

R(4)

[[१, २, ३, ४], [२, १, ३, ४], [३, १, २, ४], [३, २, १, ४], [४, १, २, ३] , [४, २, १, ३], [४, ३, १, २], [४, ३, २, १]]

Answer 10

मेरा जावा समाधान:

public static void main(String[] args) {
    listPrependAppend(4);
}

private static void listPrependAppend(int n) {
    int total = (int) Math.pow(2, n - 1);
    int ps;
    boolean append;
    String sequence;
    String pattern;

    for (int num = 0; num < total; num++) {
        sequence = "";
        pattern = "";
        append = false;
        ps = num;
        for (int pos = 1; pos < n + 1; pos++) {
            sequence = append ? (pos + sequence) : (sequence + pos);
            append = (ps & 0x01) == 0x01;
            ps = ps >> 1;
            if (pos < n) {
                pattern += append ? "L" : "R";
            }
        }
        System.out.format("%s\t[%s]%n", sequence, pattern);
    }
}

Comments

ओह फार्क, अब अन्य उत्तरों को देखने के बाद मैं देखता हूं कि आप सबसे छोटे उत्तर के बारे में क्या सोचते हैं।

— ब्रेट रायन

जबकि आपका समाधान सम्मानजनक, संक्षिप्त और अपने आप में अच्छी तरह से प्रस्तुत किया गया है, आप सही हैं कि यह हाथ में समस्या के लिए काफी उम्मीदवार नहीं है।

— जो Z.

@BrettRyan आप अनावश्यक व्हाट्सएप को हटाकर और एक-चर चर नामों का उपयोग करके अपने कोड को बहुत कम कर सकते हैं। आप भी falseकुछ इस तरह से बदल सकते हैं 5<4।

— प्रोग्रामफॉक्स

धन्यवाद दोस्तों। यह कोड चुनौतियों में भाग लेने का मेरा पहला प्रयास था। मैं बस कुछ प्रोग्रामिंग चुनौतियों की तलाश में था और सबसे छोटा समाधान पाने के लिए लक्ष्य का एहसास नहीं था। :) मुझे भाग लेने देने के लिए धन्यवाद।

— ब्रेट रायन