Tâche:

Renvoie un tableau avec toutes les paires possibles entre les éléments d'un tableau.

Exemple

De a=["a", "b", "c", "d"];retour b=[["a","b"],["a","c"],["a","d"],["b","c"],["b","d"],["c","d"]].

Les paires peuvent être dans n'importe quel ordre tant que toutes les combinaisons possibles sont incluses et sont évidemment ["b","d"]les mêmes ["d","b"].

Contribution

Tableau d'éléments de chaîne uniques composés de caractères de la classe [a-z].

Production

Tableau 2D contenant toutes les paires possibles d'éléments du tableau d'entrée.

Cas de test

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

Remarque: je n'ai pas pu trouver de doublon pour ce défi. S'il y en a un, alerte-moi avec un commentaire pour laisser tomber la question.

Gelée , 2 octets

Œc

Essayez-le en ligne!

Haskell , 29 octets

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

Essayez-le en ligne! Exemple d'utilisation: f ["a","b","c"]rendements [("a","b"),("a","c"),("b","c")].

Avec l'indicateur, -XTupleSectionscela peut être raccourci à 27 octets, mais l'indicateur devrait être compté:

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

Essayez-le en ligne!

Mathematica, 14 octets

#~Subsets~{2}&

contribution

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

Haskell, 25 octets

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

Essayez-le en ligne!

Outer ( x) et inner ( y) parcourent la liste d'entrée et ne conservent la paire (x,y)que si x < y.

05AB1E , 3 octets

Code:

æ2ù

Utilise l' encodage 05AB1E . Essayez-le en ligne!

Explication:

æ      # 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

Prend entrée dans le formulaire

abcd

et sorties comme

ad
ac
ab
bd
bc
cd

Explication

Tout d'abord, AX<esc>ajoute un Xà l'entrée afin de gérer une entrée à 2 longueurs, ce qui est nécessaire pour des raisons qui deviendront claires sous peu.

Vient ensuite la première macro récursive, du formulaire qq...@qq@q. (Enregistrez la macro q, réexécutez-la à la fin, terminez l'enregistrement, puis exécutez-la une fois.) Dans le corps de la macro, Ypduplique la ligne en cours, lsort de la macro si la ligne contient maintenant un caractère et Xsupprime le premier caractère de la ligne. Cela a pour résultat final de produire

abcdX
abcX
abX
aX
X
X

Ignorant le Xs pour l'instant, tout ce que nous avons à faire est de nous transformer abcdX, par exemple, en ab / ac / ad / aX. Ceci est réalisé avec la deuxième macro récursive, qr...@rq.

Dans cette macro, nous dupliquons d'abord la ligne ( Yp), puis supprimons tout sauf les deux premiers caractères en déplaçant les deux vers la droite ( ll) et en les supprimant à la fin de la ligne ( D). Puisque le curseur est maintenant sur le deuxième caractère de la ligne, kxsupprimera le deuxième caractère de la ligne précédente, qui se trouve être celui qui vient d'être apparié avec le premier caractère de la ligne. Ce processus est ensuite répété en recommençant depuis le début de la ligne ( h) autant de fois que nécessaire en raison de la nature récursive de la macro.

Il suffit maintenant d'exécuter la macro sur chaque ligne, ce qui peut être réalisé avec :g/./norm@r(je ne sais pas pourquoi cela se comporte différemment :%norm@r, mais il suffit de dire que cette dernière ne fonctionne pas comme prévu.) Les lignes avec Xsont supprimées avec :g/X/d, et les lignes vides à l'extrémité gauche à la suite de la construction de la rmacro sont nettoyées avec dG.

Octave, 23 octets

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

Essayez-le en ligne!

Python 3 , 44 octets

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

Essayez-le en ligne!

Prend l'entrée comme paramètres de fonction individuels.

Brachylog , 5 octets

{⊇Ċ}ᶠ

Essayez-le en ligne!

Comment ça fonctionne

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

combn(scan(,''),2)

lit la liste depuis stdin, retourne une matrice où les colonnes sont des paires.

Essayez-le en ligne!

Python, 53 octets

2 octets enregistrés grâce à @CalculatorFeline

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

Essayez-le en ligne!

Octave , 49 48 octets

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

Fonction anonyme qui évite la fonction intégrée ( nchoosek).

Essayez-le en ligne!

Explication

x+j*x'utilise la radiodiffusion pour construire une matrice de nombres complexes où les parties réelles et imaginaires sont toutes des paires de points de code de l'entrée x.

y=triu(...,1)conserve la partie triangulaire supérieure à l'exclusion de la diagonale, ce qui rend le reste des éléments nul. Le résultat est affecté à la variable y.

y=(...)(~~y)conserve les éléments non nuls sous la forme d'un vecteur de colonne, qui est affecté à la variable y.

imag(...)et real(...)extraire les parties réelles et imaginaires.

[... ... ''] reconvertit en char pour construire la sortie.

Pari / GP , 34 octets

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

Essayez-le en ligne!

Python ≥ 2,7, 55 octets

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

repl.it!

Perl 6 , 17 octets

*.combinations(2)

Ouf, c'est un long nom de méthode.

Scala, 17 octets

_.combinations(2)

Pyth , 7 4 octets

^{-3 octets grâce à Leaky Nun !}

.cQ2

Essayez-le en ligne!

Rubis , 38 34 24 octets

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

Merci Seims pour l'idée d'avoir économisé 10 octets.

Essayez-le en ligne!

JavaScript ES6, 52 octets

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

S'il y en avait un flatMapqui économiserait beaucoup d'octets.

Python , 55 octets

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

Essayez-le en ligne!

Plus long que les autres réponses Python, mais il utilise une technique différente, donc je pense que cela vaut la peine d'être publié.

Japt , 2 octets

à2

Testez-le ( -Qindicateur à des fins de visualisation uniquement)

Python, 64 octets

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

Octave, 38 octets

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

Une autre réponse pour éviter le nchoosekintégré.

Essayez-le en ligne!

Clojure, 42 octets

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

Renvoie un ensemble d'ensembles :)

Python, 74 octets

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

Javascript (ES 5), de 108 à 78 octets

Je poste ma réponse aujourd'hui mais je promets évidemment de ne pas accepter ma propre réponse:

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 octets

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

Essayez-le en ligne!

Explication

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