दिए गए तत्वों की सूची के सभी संयोजनों को क्रमित करें

Question

एक कोड बनाएं जो एक सूची और एक नंबर को इनपुट के रूप में लेता है, और संख्या की लंबाई के साथ सभी संभव संयोजनों को उत्पन्न करता है। उदाहरण के लिए, सूची {0,1} और नंबर 2 के साथ :

00
01
10
11

आपके प्रोग्राम को सूची में दो या अधिक बार वर्णों की अपेक्षा नहीं करनी है, जैसे {0,0,0,0,0,1,1,5,5,5}

सुनिश्चित करें कि आप सूची के क्रम में छांटे गए संयोजन को प्रिंट करते हैं:

सूची {0,1} और नंबर 5 के साथ (मेरे कुछ कोड से उत्पन्न, जो जीतने के लिए बहुत लंबा रास्ता है):

00000
00001
00010
00011
00100
00101
00110
00111
01000
01001
01010
01011
01100
01101
01110
01111
10000
10001
10010
10011
10100
10101
10110
10111
11000
11001
11010
11011
11100
11101
11110
11111

लेकिन सूची {1,0} और नंबर 2 के साथ :

11
10
01
00

जैसा कि आप देख सकते हैं, उलट सूची का अर्थ है उलट क्रम।

संरचना पर एक नज़र डालें, यह एक पेड़ की तरह है।

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

Comments

मुझे लगा कि यह डुप्लिकेट होगा, लेकिन मैं

— लुइस मेंडो

यदि इनपुट सूची को अलग नहीं किया जाता है तो छँटाई कैसे काम करती है?

— JAD

@ जारको मैं मान सकता हूँ कि इनपुट के सूचकांकों के गुच्छे आउटपुट में छंटे हुए हैं

— लुइस मेंडो

@ ब्रैड, डिफ़ॉल्ट उत्तर हाँ है जब तक कि ओपी ने कुछ और नहीं कहा।

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

मुझे समझ नहीं आया ... एक उपयोगकर्ता नाम के रूप में अपने नाम का उपयोग करने में क्या गलत है?

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

Answer 1

जेली , 1 बाइट

ṗ

TryItOnline

कार्टेसियन पावर बिल्ट-इन परमाणु, एक डाईएडिक लिंक के रूप में लेफ्ट तर्क आइटम के साथ और दलील काउंट द काउंट, या फुल प्रोग्राम विथ द लेट द आइटम और दूसरा तर्क काउंट।

Comments

एक बाइट! यह हल हो गया!

— LMD

तुम्हें पता है क्या, मैं एक शून्य बाइट जवाब प्रस्तुत करने वाला हूँ! जावा में! आप कैसे हैं, हुह पसंद है? :) (गंभीरता से, हालांकि। अच्छी गोल्फिंग।)

— OldBunny2800

Answer 2

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

(mapM id.).replicate

उपयोग निर्वासन:

*Main> ( (mapM id.).replicate )  2 "01" 
["00","01","10","11"]
*Main> ( (mapM id.).replicate )  2 "10" 
["11","10","01","00"]

replicateबनाता है n2 पैरामीटर की प्रतियां और mapM idसंयोजन बनाता है। Btw, के mapM idरूप में ही है sequence, लेकिन 1 बाइट कम है।

Answer 3

MATL , 2 बाइट्स

Z^

कार्टेशियन पावर बिलिन ...

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

Answer 4

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

^F

एक प्रोग्राम जो फॉर्म में इनपुट लेता है list,numberऔर सूची की सूची प्रिंट करता है।

परीक्षण सूट

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

^F   Program. Input: Q
^FQ  Implicit input fill
 F   Fold
^    repeated Cartesian power
  Q  over Q
     Implicitly print

Comments

यह इसे हल करने के लिए लगता है, लेकिन शायद कोई और एक बाइट के साथ ऐसा करने में सक्षम है?

— LMD

हां, किसी और ने जीता (जेली, एक बाइट) लेकिन अच्छा समाधान, वैसे भी

— LMD

Answer 5

पर्ल 6 , 15 बाइट्स

{[X] @^a xx$^b}

स्पष्टीकरण:

{[X] @^a xx$^b}

{             } # bare block lambda

     @^a        # declare first parameter as Positional
           $^b  # declare second parameter
         xx     # list repeat ｢@a｣, ｢$b｣ times

# at this point given ｢ (0,1), 5 ｣
# ((0 1) (0 1) (0 1) (0 1) (0 1))

 [ ]            # list reduce
  X             #    using cross meta-operator

# results in a list of lists
# ((0 0 0 0 0)
#  (0 0 0 0 1)
#  (0 0 0 1 0)
#  (0 0 0 1 1)
#  (0 0 1 0 0)
#  (0 0 1 0 1)
#  ...
#  (1 1 1 1 1))

say {[X] $^a xx$^b}( (0,1), 2 ); # ((0 0) (0 1) (1 0) (1 1))
say {[X] $^a xx$^b}( (1,0), 2 ); # ((1 1) (1 0) (0 1) (0 0))
say {[X] $^a xx$^b}( (0,1,2), 2 );
# ((0 0) (0 1) (0 2) (1 0) (1 1) (1 2) (2 0) (2 1) (2 2))

put {[X] $^a xx$^b}( (0,1), 5 )».join;
# 00000 00001 00010 00011 00100 00101 00110 00111 01000 01001 01010 01011 01100 01101 01110 01111 10000 10001 10010 10011 10100 10101 10110 10111 11000 11001 11010 11011 11100 11101 11110 11111

Comments

अगर वे कभी पर्ल 6 की आधिकारिक रिलीज के बाद से रडको की रिहाई के लिए अपग्रेड करते हैं तो आप इसे आइडोन पर चला पाएंगे ।

— ब्रैड गिल्बर्ट b2gills 21

Answer 6

जावास्क्रिप्ट (फ़ायरफ़ॉक्स 30+), 55 बाइट्स

f=(a,n)=>n?[for(b of a)for(c of f(a,n-1))[b,...c]]:[[]]

मैं 99% निश्चित हूं कि जावास्क्रिप्ट में इस बारे में जाने का सबसे अच्छा तरीका है।

Answer 7

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

कोड + -nlध्वज के 28 बाइट्स ।

$"=",";say for glob"{@F}"x<>

इसे चलाने के लिए:

perl -alE '$"=",";say for glob"{@F}"x<>' <<< "1 0
2"

मुझे लगता है कि इनपुट को संख्याओं की सूची के रूप में लेना पर्ल के लिए तर्कसंगत है। हालांकि, अगर हम कुछ फंतासी की अनुमति देते हैं, और कोष्ठक और अल्पविराम के साथ इनपुट लेते हैं (जैसा कि प्रश्न में दिखाया गया है), हम 20 बाइट्स तक जा सकते हैं :

perl -nlE 'say for glob$_ x<>' <<< "{1,0}
2"

स्पष्टीकरण: glob पर्ल में प्रारंभिक उद्देश्य फ़ाइलनामों के माध्यम से सूची और पुनरावृति है, लेकिन जब इसके तर्क में घुंघराले कोष्ठक होते हैं, तो यह प्रत्येक ब्रैकेट समूह के एक तत्व से बने संयोजनों को उत्पन्न करता है।
-aइनपुट पर रिक्त स्थान के लिए ऑटोसप्लिट करें, और परिणाम को @Fसरणी के अंदर रखें ।
$"सूची विभाजक है: यह स्ट्रिंग के अंदर सूची के तत्वों के बीच डाला गया विभाजक है। हम इसे सेट करते हैं ,, इसलिए "{@F"}उत्पादन होता है {.,.}(यदि @F0 और 1 होता है)।
फिर xस्ट्रिंग पुनरावृत्ति ऑपरेटर है (और <>इनपुट की एक पंक्ति प्राप्त करता है)।
और अंत में, तत्वों say forद्वारा बनाई गई सूची के माध्यम से पुनरावृत्त करता है globऔर तत्वों को प्रिंट करता है।

Answer 8

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

Tuples

जेली से भी बदतर :(

प्रयोग

Tuples[{0, 1}, 5]

{{0, 0, 0, 0, 0}, {0, 0, 0, 0, 1}, {0, 0, 0, 1, 0}, {0, 0, 0, 1, 1}, {0, 0, 1, 0, 0}, {0, 0, 1, 0, 1}, {0, 0, 1, 1, 0}, {0, 0, 1, 1, 1}, {0, 1, 0, 0, 0}, {0, 1, 0, 0, 1}, {0, 1, 0, 1, 0}, {0, 1, 0, 1, 1}, {0, 1, 1, 0, 0}, {0, 1, 1, 0, 1}, {0, 1, 1, 1, 0}, {0, 1, 1, 1, 1}, {1, 0, 0, 0, 0}, {1, 0, 0, 0, 1}, {1, 0, 0, 1, 0}, {1, 0, 0, 1, 1}, {1, 0, 1, 0, 0}, {1, 0, 1, 0, 1}, {1, 0, 1, 1, 0}, {1, 0, 1, 1, 1}, {1, 1, 0, 0, 0}, {1, 1, 0, 0, 1}, {1, 1, 0, 1, 0}, {1, 1, 0, 1, 1}, {1, 1, 1, 0, 0}, {1, 1, 1, 0, 1}, {1, 1, 1, 1, 0}, {1, 1, 1, 1, 1}}

Answer 9

पायथन, 57 बाइट्स

from itertools import*
lambda o,n:list(product(*([o]*n)))

repl.it

वस्तुओं की एक सूची, oऔर एक गिनती लेने के लिए, nऔर संयोजन की एक सूची लौटा है।

Answer 10

शुद्ध बैश, 36

printf -vv %$2s
eval echo ${v// /$1}

कमांड-लाइन परिमों द्वारा इनपुट - सूची ब्रेसों में अल्पविराम से अलग की गई सूची है, उदाहरण के लिए:

./elemcombo.sh "{0,1}" 2

ध्यान दें कि इनपुट सूची को उद्धृत करने की आवश्यकता है ताकि कॉलिंग शेल का विस्तार बहुत जल्दी न हो।

Ideone ।

Comments

यह काम नहीं लगता है।

— Ipor Sircer

यह केवल इनपुट n बार दोहराता है, सभी संभावित संयोजनों को प्रिंट नहीं करता है।

— इपोर सिरसर

@IporSircer मैंने आवश्यक इनपुट प्रारूप को स्पष्ट किया। क्या अब वह आपके लिए काम करता है?

— डिजिटल ट्रॉमा

bash a.sh "{0,1}" 2-> {0,1}{0,1}(संस्करण 4.4.5 (1)

— -release

@IporSircer ऐसा लगता है कि TIO शायद आर्ग्स को एक एक्वीव () या इसी तरह के कॉल में डाल रहा है। उद्धरण केवल तभी आवश्यक होते हैं जब कॉलिंग शेल को ब्रेस के विस्तार से रोकने के लिए स्क्रिप्ट को किसी अन्य शेल से कॉल किया जाता है। I TIO मामला, सूची को उद्धरण की आवश्यकता नहीं है। tio.run/nexus/…

— डिजिटल ट्रॉमा

Answer 11

आर , 53 45 बाइट्स

function(x,n)rev(expand.grid(rep(list(x),n)))

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

rev अनुरोध किए गए सटीक क्रम के अनुरूप है (जो वास्तव में समस्या के लिए आवश्यक नहीं लगता) और 5 बाइट्स जोड़ता है।

Comments

बस revके लिए 45 बाइट्स :)

— Jayce

दिमाग पर मैट्रिक्स था और परिणाम को भूल गया वास्तव में एक सूची (डेटा फ्रेम) थी।

— एन जी एम

Answer 12

रैकेट 123 बाइट्स

(let p((s "")(l(map number->string(sort l <))))
(if(= n(string-length s))(displayln s)(for((i l))(p(string-append s i)l))))

Ungolfed:

(define(f l n)
  (let loop ((s "")
             (l (map number->string (sort l <))))
    (if (= n (string-length s))
        (displayln s)
        (for ((i l))
          (loop (string-append s i) l)))))

परिक्षण:

(f '(0 1) 2)
(f '(0 1) 3)
(f '(0 1) 5)

आउटपुट:

00
01
10
11

000
001
010
011
100
101
110
111

00000
00001
00010
00011
00100
00101
00110
00111
01000
01001
01010
01011
01100
01101
01110
01111
10000
10001
10010
10011
10100
10101
10110
10111
11000
11001
11010
11011
11100
11101
11110
11111

Answer 13

PHP, 109 बाइट्स

for($o=$a=array_slice($argv,2);--$argv[1];$o=$c,$c=[])foreach($a as$n)foreach($o as$s)$c[]=$n.$s;print_r($o);

लंबाई को पहले तर्क के रूप में और सूची को आगे के तर्कों के रूप में लेता है।
उपयोग की तरह:

php -r "for($o=$a=array_slice($argv,2);--$argv[1];$o=$c,$c=[])foreach($a as$n)foreach($o as$s)$c[]=$n.$s;print_r($o);" 5 0 1

यदि लंबाई 0 के लिए कहा जाए तो "मेमोरी से बाहर" घातक त्रुटि में चलेगा।

Comments

आपको लम्बाई 0.

— LMD

Answer 14

05AB1E , 2 1 बाइट एस

ã

-1 बाईट थैंक्स टू @ इनिग्मा ।

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

इनपुट के रूप में number\nlist, सूचियों की सूची के रूप में आउटपुट।

स्पष्टीकरण:

     # Implicit input `a`, `b`
ã    # Take the Cartesian product of list `b` repeated `a` times

Comments

आप Iयहाँ की जरूरत नहीं है।

— एमिग्ना

@Emigna आह बिल्कुल। मेरे पास Iइसलिए था क्योंकि मैं शुरू में यह जानने की कोशिश कर रहा था कि एकाधिक इनपुट कैसे होंगे और संख्या और सूची उलट थी। Iवहाँ रखने के लिए बहुत बेवकूफ .. धन्यवाद!

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