किसी सरणी के तत्वों के बीच सभी गैर-ऑर्डर किए गए जोड़े

Question

कार्य:

एक सरणी के तत्वों के बीच सभी संभावित जोड़े के साथ एक सरणी लौटें ।

उदाहरण

से a=["a", "b", "c", "d"];वापसी b=[["a","b"],["a","c"],["a","d"],["b","c"],["b","d"],["c","d"]]।

जोड़े किसी भी क्रम में हो सकते हैं जब तक कि सभी संभव संयोजनों को शामिल किया जाता है और स्पष्ट रूप ["b","d"]से समान है ["d","b"]।

इनपुट

वर्ग से वर्णों से बना अद्वितीय स्ट्रिंग तत्वों की सरणी [a-z]।

उत्पादन

इनपुट सरणी के तत्वों के सभी संभावित जोड़े युक्त 2d सरणी।

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

input=["a","b","c"];
//output=[["a","b"],["a","c"],["b","c"]]

input=["a","b","c","d","e"];
//output=[["a","b"],["a","c"],["a","d"],["a","e"],["b","c"],["b","d"],["b","e"],["c","d"],["c","e"],["d","e"]]

नोट: मुझे इस चुनौती का डुप्लिकेट नहीं मिला । यदि कोई है, तो मुझे प्रश्न ड्रॉप करने के लिए टिप्पणी के साथ सतर्क करें।

Comments

मैं स्पष्ट नहीं हूं कि क्या होता है जब इनपुट मान दोहराते हैं या क्रमबद्ध क्रम में नहीं होते हैं। कुछ और सामान्य परीक्षण मामलों में मदद मिलेगी।

— xnor

@ Adám नहीं एक डुबकी, जिसमें 2 सूचियाँ शामिल हैं।

— श्री Xcoder

यह समस्या स्वयं के साथ एक तत्व की जोड़ी को बाहर करती है, अधिक nonduplicate को सोखती है।

— कैलक्यूलेटरफल

@xnor havent ने मूल्यों को दोहराने के बारे में सोचा क्योंकि काम पर मेरी मूल समस्या व्यक्तियों के एक अद्वितीय सेट के साथ करना था। मुझे लगता है कि मुझे एक शर्त के रूप में विशिष्टता जोड़नी चाहिए?

— अलेक्जेंड्रोसा

@ अलेक्जेंड्रोसोवा यूनीकनेस ठीक होगी। क्या ["c","b","a"]लौटना चाहिए ?

— xnor

Answer 1

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

Œc

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

Comments

तुम मुझे निंजा - ÇK€Yपाद में कुछ की तरह का उपयोग कर उत्पादन प्रिंट ।

— जोनाथन एलन

@JonathanAllan ओह, धन्यवाद!

— हाइपरनेत्रिनो

Answer 2

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

f(a:b)=map((,)a)b++f b
f _=[]

इसे ऑनलाइन आज़माएं! उदाहरण उपयोग: f ["a","b","c"]पैदावार [("a","b"),("a","c"),("b","c")]।

---

ध्वज के साथ इसे -XTupleSections27 बाइट्स तक छोटा किया जा सकता है, हालांकि ध्वज को गिनने की आवश्यकता होगी:

f(a:b)=map(a,)b++f b
f _=[]

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

Comments

मुझे लगता है कि आप इस मामले को संशोधित करके एक बाइट बचा सकते हैं f l=l।

— क्रिटज़फ़िट्ज़

@Kritzefitz मुझे डर है कि यह काम नहीं करेगा क्योंकि दो खाली सूचियों का एक अलग प्रकार है, इसलिए हास्केल का प्रकार चेकर शिकायत करेगा।

— लैकोनी

अच्छी बात। मैंने ऐसा नहीं सोचा था।

— क्रिट्ज़फ़िट्ज़

Answer 3

मैथेमेटिका, 14 बाइट्स

#~Subsets~{2}&

इनपुट

[{"ए", "बी", "सी"}]

Comments

मैं ऐसा करने जा रहा था :(

— कैलक्यूलेटरफैनलाइन

Answer 4

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

f l=[(x,y)|x<-l,y<-l,x<y]

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

आउटर ( x) और इनर ( y) लूप इनपुट सूची के माध्यम से और जोड़े को (x,y)केवल तभी रखें x < y।

Answer 5

05AB1E , 3 बाइट्स

कोड:

æ2ù

05AB1E एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं!

स्पष्टीकरण:

æ      # Powerset of the input
 2ù    # Keep the items of length two

Answer 6

विम, ५० ४ 48

AX<esc>qqYplX@qq@qqrYpllDkxh@rq:g/./norm@r<cr>:g/X/d<cr>dG

फॉर्म में इनपुट लेता है

abcd

और आउटपुट के रूप में

ad
ac
ab
bd
bc
cd

व्याख्या

सबसे पहले, 2-लंबाई इनपुट को संभालने के लिए इनपुट को AX<esc>जोड़ता है X, जो उन कारणों के लिए आवश्यक है जो शीघ्र ही स्पष्ट हो जाएंगे।

फिर फॉर्म का पहला पुनरावर्ती मैक्रो आता है qq...@qq@q। (रिकॉर्ड मैक्रो q, अपने आप को फिर से अंत में चलाएं, रिकॉर्डिंग समाप्त करें, फिर एक बार स्वयं चलाएं।) मैक्रो के शरीर में, Ypवर्तमान लाइन को डुप्लिकेट करता है, lयदि मैक्रो अब एक वर्ण लंबा है, और मैक्रो Xको हटाता है लाइन में पहला चरित्र। यह उत्पादन का अंतिम परिणाम है

abcdX
abcX
abX
aX
X
X

Xअभी के लिए s को अनदेखा करना , हम सभी को करना है abcdX, उदाहरण के लिए, बारी है ab / ac / ad / aX। यह दूसरी पुनरावर्ती मैक्रो साथ हासिल की है qr...@rq।

इस मैक्रो में, हम पहले लाइन ( Yp) को डुप्लिकेट करते हैं , फिर दाहिने दो ( ll) और लाइन के अंत तक डिलीट करके (पहले दो अक्षर) सब कुछ हटा देते हैं D। चूँकि कर्सर अब लाइन के दूसरे चारकटर पर है, kxपिछली लाइन से दूसरे वर्ण को हटा देगा, जो कि ऐसा होता है जो लाइन पर पहले वर्ण के साथ जोड़ा गया था। यह प्रक्रिया तब रेखा की शुरुआत से फिर से शुरू हो रही है ( h) मैक्रो की पुनरावर्ती प्रकृति के कारण जितनी बार आवश्यक हो।

यह अब हर लाइन पर मैक्रो को चलाने की बात है, जिसे हासिल किया जा सकता है :g/./norm@r(मुझे यकीन नहीं है कि यह अलग तरह से व्यवहार करता है :%norm@r, लेकिन यह कहने के लिए पर्याप्त है, बाद वाला काम नहीं करता है।) के साथ लाइनों Xको हटा दिया जाता है :g/X/d। और rमैक्रो के निर्माण के परिणामस्वरूप बायीं ओर खाली लाइनों को साफ किया जाता है dG।

Comments

बहुत बढ़िया जवाब। मुझे इसके माध्यम से जाने के लिए समय लगेगा।

— अलेक्जेंड्रोसा

Answer 7

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

@(s)[nchoosek(+s,2) '']

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

Answer 8

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

f=lambda k,*s:[*s]and[[k,x]for x in s]+f(*s)

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

व्यक्तिगत फ़ंक्शन मापदंडों के रूप में इनपुट लेता है।

Answer 9

ब्रेकीलॉग , 5 बाइट्स

{⊇Ċ}ᶠ

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

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

{⊇Ċ}ᶠ
    ᶠ   find all the possible outputs of the following predicate
 ⊇          the output is an ordered subset of the input
  Ċ         the output is a list with two elements

Answer 10

आर , 18 बाइट्स

combn(scan(,''),2)

स्टड से सूची पढ़ता है, एक मैट्रिक्स लौटाता है जहां कॉलम जोड़े हैं।

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

Answer 11

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

2 बाइट्स @CalculatorFeline की बदौलत बच गए

lambda a:[(x,y)for i,x in enumerate(a)for y in a[:i]]

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

Comments

a[i+1:]हो सकता हैa[:i]

— कैलक्यूलेटरफलाइन

एक लंबे उपयोगकर्ता नाम के बाद केवल पूर्वोक्त उपयोगकर्ता का उल्लेख करके छोटी टिप्पणियों को आसान बनाता है।

— कैलक्यूलेटरफल

Answer 12

ऑक्टेव , 49 48 बाइट्स

@(x)[imag(y=(y=triu(x+j*x',1))(~~y)) real(y) '']

बेनामी फ़ंक्शन जो अंतर्निहित ( nchoosek) से बचा जाता है ।

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

व्याख्या

x+j*x'जटिल संख्याओं का एक मैट्रिक्स बनाने के लिए प्रसारण का उपयोग करता है जहां वास्तविक और काल्पनिक भाग इनपुट से कोड पॉइंट के सभी जोड़े हैं x।

y=triu(...,1)ऊपरी त्रिकोणीय भाग को विकर्ण को छोड़कर, शेष तत्वों को शून्य बनाता है। परिणाम चर को सौंपा गया है y।

y=(...)(~~y)नॉनज़रो तत्वों को कॉलम वेक्टर के रूप में बनाए रखता है, जिसे चर के लिए सौंपा गया है y।

imag(...)और real(...)वास्तविक और काल्पनिक भागों को निकालें।

[... ... ''] आउटपुट बनाने के लिए वापस char में कनवर्ट करता है।

Comments

अच्छा! पूरी चुनौती वास्तव में दिलचस्प है। यह मेरे es5 कोड (नीचे चित्रित) के साथ आने में मुझे लगभग एक घंटे का समय लगा। मुझे खुशी है कि इसने कई दिलचस्प जवाब दिए ..

— alexandros84

Answer 13

परी / जीपी , 34 बाइट्स

a->concat([[[x,y]|y<-a,x<y]|x<-a])

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

Answer 14

पायथन th 2.7, 55 बाइट्स

lambda l:list(combinations(l,2))
from itertools import*

repl.it!

Answer 15

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

*.combinations(2)

वाह, यह एक लंबी विधि का नाम है।

Answer 16

स्काला, 17 बाइट्स

_.combinations(2)

Answer 17

अजगर , 7 4 बाइट्स

^{-3 बाइट्स लीक लियुन को धन्यवाद !}

.cQ2

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

Comments

.cQ2?

— लीक नून

@LeakyNun मैं शपथ ले सकता था कि एक ऐसा समारोह था जो वास्तव में इस चुनौती की आवश्यकता थी, लेकिन मैंने केवल .Cसूची के माध्यम से देखा । अच्छा पकड़ा!

— नटजगन

Answer 18

रूबी , 38 34 24 बाइट्स

->x{[*x.combination(2)]}

इस विचार के लिए धन्यवाद कि 10 बाइट्स बचाए गए।

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

Comments

->x{x.combination(2).to_a}की बचत होती है कुछ बाइट्स :)

— सिम्स

Answer 19

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

a=>a.map((x,i)=>a.slice(0,i).map(y=>[x,y])).slice(1)

अगर ऐसा flatMapहोता तो बहुत सारे बाइट्स बच जाते।

Comments

अरे अच्छा जवाब! अगर मैं तुम्हारा अध्ययन करूँ तो मेरा es5 उत्तर देखें। किसी भी प्रतिक्रिया की सराहना की जाएगी (सकारात्मक / रचनात्मक हाहा)

— अलेक्जेंड्रोसा

फ़ायरफ़ॉक्स 30 की सरणी समझ किसी फ्लैट मैप को अनुकरण कर सकती है, जैसे a=>[for(x of[...a])for(y of(a.shift(),a))[x,y]]।

— नील

@ नहीं, कुछ वास्तव में उन्नत वाक्यविन्यास है ... मुझे आपकी अभिव्यक्ति को समझने के लिए कम से कम तीन चीजों को Google करना होगा। मुख्य रूप से फैला हुआ ऑपरेटर, सरणी की समझ क्या है और अंत में [x, y] क्या है (अभी भी उस पर उत्तर मिला है)।

— अलेक्जेंड्रोसा

@ alexandros84 [x,y]अंत में आसान बिट है, यह सिर्फ एक सरणी शाब्दिक है।

— नील

इसके अलावा प्रसार ऑपरेटर केवल सरणी को कॉपी करने के लिए है, क्योंकि मैं इसे लूप के अंदर बदल रहा हूं।

— नील

Answer 20

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

f=lambda s:[(s[0],j)for j in s[1:]]+f(s[1:])if s else[]

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

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

Comments

मुझे जाँचने का समय नहीं है, मुझे आशा है कि वास्तव में अलग-अलग तकनीकें हैं जिनके कारण मैंने उत्थान किया है।

— अलेक्जेंड्रोसा

मुझे लगता है कि यह @ ओव्स पायथन 3 उत्तर के लिए एक समान दृष्टिकोण है।

— नील

Answer 21

जाप , 2 बाइट्स

à2

इसका परीक्षण करें ( -Qकेवल विज़ुअलाइज़ेशन उद्देश्यों के लिए ध्वज)

Answer 22

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

f=lambda a:sum((list(zip(a, a[i:]))for i in range(1,len(a))),[])

Answer 23

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

@(s)s([[x y]=find(s|s'),y](y<x,[2 1]))

nchoosekबिल्ट-इन से बचने का एक और जवाब ।

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

Answer 24

क्लोजर, 42 बाइट्स

#(set(for[i % j(remove #{i}%)](set[i j])))

सेट का एक सेट देता है :)

Answer 25

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

f=lambda a:[(c,d) for i,c in enumerate(a) for j,d in enumerate(a) if i<j]

Comments

PPCG में आपका स्वागत है! आप इसे गोल्फ कर सकते हैं: 1) 2-चर चर नामों को 1-चार 2 के साथ बदलें) अनावश्यक व्हाट्सएप को हटा दें 3) यह एक स्निपेट है, आपको इसे लैम्ब्डा, फंक्शन या पूर्ण कार्यक्रम में बनाने की आवश्यकता है

— एरिक आउटगोला

10 बाइट्स से गोल्फिंग: 64 बाइट्स

— मिस्टर एक्सकोडर

Answer 26

जावास्क्रिप्ट (ईएस 5), 108 से 78 बाइट्स तक

मैं आज अपना जवाब पोस्ट करता हूं लेकिन मैं स्पष्ट रूप से अपना जवाब स्वीकार नहीं करने का वादा करता हूं:

x=input;
a=[];

for(n=0;n<(x.length-1);n++){for(i=n+1;i<(x.length);i++){a.push([x[n],x[i]]);}}

Comments

PPCG में आपका स्वागत है; हम उम्मीद करते हैं कि अनावश्यक

— गोरेपन

Ty। मैं यह भी सोच रहा था: क्या मुझे x = इनपुट शामिल करना चाहिए था; एक = []; मेरे उत्तर में या नहीं? मैं कल संपादित करूँगा।

— अलेक्जेंड्रोसा

आप या तो केवल एक फ़ंक्शन सबमिट कर सकते हैं या एक पूर्ण कार्यक्रम कर सकते हैं। चूंकि आप उपयोग करते हैं a, इसलिए आपको इसे परिभाषित करने की आवश्यकता है, लेकिन आप इसका एक कार्य कर सकते हैं x।

— हाइपरएनुट्रिनो

बहुत बेहतर अब @HyperNeutrino।

— अलेक्जेंड्रोसा

मुझे लगता है कि आप कुछ स्थान बचाने के लिए कुछ अर्धविराम और खाली पंक्ति को बाहर कर सकते हैं। मैं भी लगता है कि आप बदल सकते हैं for(i=n+1;i<(x.length);i++)करने के लिए for(i=n;++i<x.length;)। इसी तरह, आप बदल सकते हैं n<(x.length-1);n++करने के लिएn++<x.length-1

— musicman523

Answer 27

जे , 17 बाइट्स

({~$#:I.@,)#\</#\

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

व्याख्या

({~$#:I.@,)#\</#\  Input: string S
               #\  Get the length of each prefix of S
           #\      Get the length of each prefix of S again
             </    Test using greater than (<) between each
         ,         Flatten
      I.@          Find the indices where the value is 1
   $               Shape of that table
    #:             Convert the indices to the base represented by the shape
 {~                Index into S at those values