Aufgabe:

Gibt ein Array mit allen möglichen Paaren zwischen den Elementen eines Arrays zurück.

Beispiel

Von der a=["a", "b", "c", "d"];Rückkehr b=[["a","b"],["a","c"],["a","d"],["b","c"],["b","d"],["c","d"]].

Paare können in beliebiger Reihenfolge sein, solange alle möglichen Kombinationen enthalten sind und natürlich ["b","d"]gleich sind ["d","b"].

Eingang

Array eindeutiger Zeichenfolgenelemente, die aus Zeichen der Klasse bestehen [a-z].

Ausgabe

2d-Array, das alle möglichen Paare von Elementen des Eingabearrays enthält.

Testfälle

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"]]

Hinweis: Ich konnte kein Duplikat für diese Herausforderung finden. Wenn es einen gibt, benachrichtige mich mit einem Kommentar, um die Frage fallen zu lassen.

Gelee , 2 Bytes

Œc

Probieren Sie es online aus!

Haskell , 29 Bytes

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

Probieren Sie es online aus! Anwendungsbeispiel: f ["a","b","c"]Ausbeuten [("a","b"),("a","c"),("b","c")].

Mit dem Flag -XTupleSectionskann dies auf 27 Bytes verkürzt werden, das Flag müsste jedoch gezählt werden:

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

Probieren Sie es online aus!

Mathematica, 14 Bytes

#~Subsets~{2}&

Eingang

[{"a", "b", "c"}]

Haskell, 25 Bytes

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

Probieren Sie es online aus!

Outer ( x) und Inner ( y) durchlaufen die Eingabeliste und behalten das Paar (x,y)nur bei x < y.

05AB1E , 3 Bytes

Code:

æ2ù

Verwendet die 05AB1E- Codierung. Probieren Sie es online aus!

Erläuterung:

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

vim, 50 48

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

Nimmt Eingaben in das Formular vor

abcd

und Ausgänge als

ad
ac
ab
bd
bc
cd

Erläuterung

Erstens AX<esc>hängt eine Xmit dem Eingang , um 2längig Eingang zu handhaben , die aus Gründen notwendig ist , die klar in Kürze werden werden.

Dann kommt das erste rekursive Makro der Form qq...@qq@q. (Makro qaufzeichnen, am Ende erneut ausführen, die Aufzeichnung beenden und dann einmal selbst ausführen.) YpDupliziert im Hauptteil des Makros die aktuelle Zeile, lbricht aus dem Makro aus, wenn die Zeile jetzt ein Zeichen lang ist, und Xlöscht die erstes Zeichen in der Zeile. Dies hat das Endergebnis der Produktion

abcdX
abcX
abX
aX
X
X

Wenn Xwir das s vorerst ignorieren , müssen wir uns zum abcdXBeispiel nur in verwandeln ab / ac / ad / aX. Dies wird mit dem zweiten rekursiven Makro erreicht qr...@rq.

In diesem Makro duplizieren wir zuerst die Zeile ( Yp) und löschen dann alles außer den ersten beiden Zeichen, indem wir zwei ( ll) nach rechts bewegen und bis zum Ende der Zeile ( D) löschen . Da sich der Cursor jetzt auf dem zweiten Zeichen der Zeile befindet, kxwird das zweite Zeichen aus der vorherigen Zeile gelöscht, das zufällig mit dem ersten Zeichen in der Zeile gepaart wurde. Dieser Vorgang wird dann haufgrund der rekursiven Natur des Makros so oft wie nötig ab dem Anfang der Zeile ( ) wiederholt .

Es geht jetzt nur noch darum, das Makro in jeder Zeile auszuführen, was mit erreicht werden kann :g/./norm@r(Ich bin nicht sicher, warum sich dies anders verhält als :%norm@r, aber es reicht zu sagen, dass letzteres nicht wie beabsichtigt funktioniert.) Zeilen mit Xwerden gelöscht mit :g/X/d, und die Leerzeilen am Ende links als Ergebnis der Konstruktion des rMakros werden mit bereinigt dG.

Oktave, 23 Bytes

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

Probieren Sie es online aus!

Python 3 , 44 Bytes

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

Probieren Sie es online aus!

Nimmt die Eingabe als einzelne Funktionsparameter auf.

Brachylog , 5 Bytes

{⊇Ċ}ᶠ

Probieren Sie es online aus!

Wie es funktioniert

{⊇Ċ}ᶠ
    ᶠ   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

R , 18 Bytes

combn(scan(,''),2)

liest die Liste von stdin und gibt eine Matrix zurück, in der die Spalten Paare sind.

Probieren Sie es online aus!

Python, 53 Bytes

2 Bytes dank @CalculatorFeline gespeichert

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

Probieren Sie es online aus!

Oktave , 49 48 Bytes

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

Anonyme Funktion, die das eingebaute ( nchoosek) vermeidet .

Probieren Sie es online aus!

Erläuterung

x+j*x'verwendet Broadcasting, um eine Matrix komplexer Zahlen zu erstellen, bei der der Real- und der Imaginärteil alle Paare von Codepunkten aus der Eingabe sind x.

y=triu(...,1)Hält den oberen dreieckigen Teil ohne die Diagonale, sodass der Rest der Elemente Null ist. Das Ergebnis wird der Variablen zugeordnet y.

y=(...)(~~y)behält die Nicht-Null-Elemente in Form eines Spaltenvektors bei, der der Variablen zugewiesen ist y.

imag(...)und real(...)extrahieren Sie die Real- und Imaginärteile.

[... ... ''] konvertiert zurück in char, um die Ausgabe zu erstellen.

Pari / GP , 34 Bytes

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

Probieren Sie es online aus!

Python ≥ 2,7, 55 Bytes

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

repl.it!

Perl 6 , 17 Bytes

*.combinations(2)

Puh, das ist ein langer Methodenname.

Scala, 17 Bytes

_.combinations(2)

Pyth , 7 4 Bytes

^{-3 Bytes dank Leaky Nun !}

.cQ2

Probieren Sie es online aus!

Ruby , 38 34 24 Bytes

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

Danke Seims für die Idee, die 10 Bytes gespart hat.

Probieren Sie es online aus!

JavaScript ES6, 52 Bytes

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

Wenn es so etwas flatMapgäbe, würde das viele Bytes sparen.

Python , 55 Bytes

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

Probieren Sie es online aus!

Länger als andere Python-Antworten, aber es verwendet eine andere Technik, daher denke ich, dass es sich lohnt, etwas zu posten.

Japt , 2 Bytes

à2

Testen Sie es ( -QFlag nur zu Visualisierungszwecken)

Python, 64 Bytes

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

Oktave, 38 Bytes

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

Eine weitere Antwort, um nchoosekEinbauten zu vermeiden .

Probieren Sie es online aus!

Clojure, 42 Bytes

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

Gibt eine Reihe von Mengen zurück :)

Python, 74 Bytes

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

Javascript (ES 5), von 108 bis 78 Bytes

Ich poste meine Antwort heute, aber ich verspreche offensichtlich, meine eigene Antwort nicht zu akzeptieren:

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]]);}}

J , 17 Bytes

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

Probieren Sie es online aus!

Erläuterung

({~$#: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