11

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.

code-golf array-manipulation combinatorics

— alexandros84
source

2

Je ne sais pas ce qui se passe lorsque les valeurs d'entrée se répètent ou ne sont pas triées. Des cas de test plus généraux pourraient y aider.

— xnor

@ Adám Pas un dupe, cela implique d'avoir 2 listes.

— M. Xcoder

Ce problème exclut l'appariement d'un élément avec lui-même, donc plus non dupliqué.

— CalculatorFeline

@xnor n'a pas pensé à répéter des valeurs parce que mon problème d'origine au travail concernait un ensemble unique de personnes. Je suppose que je devrais ajouter l'unicité comme condition?

— alexandros84

@ alexandros84 L'unicité serait bien. Qu'est-ce qui devrait ["c","b","a"]revenir?

— 2017

5

Gelée , 2 octets

Œc

Essayez-le en ligne!

— HyperNeutrino
source

Vous me ninja - imprimez la sortie en utilisant quelque chose comme ÇK€Ydans le pied de page.

— Jonathan Allan

@JonathanAllan Oh, merci!

— HyperNeutrino

8

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!

— Laikoni
source

Je pense que vous pouvez enregistrer un octet en modifiant le cas be f l=l.

— Kritzefitz

@Kritzefitz Je crains que cela ne fonctionne pas car les deux listes vides ont un type différent, le vérificateur de type de Haskell se plaindra.

— Laikoni

Bon point. Je n'y ai pas pensé.

— Kritzefitz

6

Mathematica, 14 octets

#~Subsets~{2}&

contribution

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

— J42161217
source

J'allais le faire :(

— CalculatorFeline

6

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.

— nimi
source

5

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

— Adnan
source

5

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.

— Poignée de porte
source

Très bonne réponse. Il me faudra du temps pour le traverser.

— alexandros84

4

Octave, 23 octets

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

Essayez-le en ligne!

— rahnema1
source

4

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.

— ovs
source

4

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

— Leaky Nun
source

3

R , 18 octets

combn(scan(,''),2)

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

Essayez-le en ligne!

— Giuseppe
source

3

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!

— Uriel
source

1

a[i+1:]peut êtrea[:i]

— CalculatorFeline

Le fait d'avoir un nom d'utilisateur long facilite les commentaires courts en mentionnant simplement l'utilisateur susmentionné.

— CalculatorFeline

3

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.

— Luis Mendo
source

Agréable! L'ensemble du défi est vraiment intéressant. Il m'a fallu environ une heure et demie pour trouver mon code es5 (présenté ci-dessous). Je suis heureux que cela ait généré tant de réponses intéressantes ..

— alexandros84

3

Pari / GP , 34 octets

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

Essayez-le en ligne!

— alephalpha
source

2

Python ≥ 2,7, 55 octets

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

repl.it!

— M. Xcoder
source

2

Perl 6 , 17 octets

*.combinations(2)

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

— Sean
source

2

Scala, 17 octets

_.combinations(2)

— musicman523
source

2

Pyth , 7 4 octets

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

.cQ2

Essayez-le en ligne!

— notjagan
source

1

.cQ2?

— Leaky Nun

@LeakyNun J'aurais pu jurer qu'il y avait une fonction qui faisait exactement ce dont ce défi avait besoin, mais je ne l'ai vu .Cqu'en parcourant la liste. Belle prise!

— notjagan

2

Rubis , 38 34 24 octets

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

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

Essayez-le en ligne!

— GB
source

1

->x{x.combination(2).to_a}enregistre quelques octets :)

— Seims

1

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.

— Downgoat
source

Hé belle réponse! consultez ma réponse es5 pendant que j'étudie la vôtre si vous le souhaitez. tout commentaire sera apprécié (haha positif / constructif)

— alexandros84

1

Les compréhensions de tableaux de Firefox 30 peuvent simuler une carte plate, par exemple a=>[for(x of[...a])for(y of(a.shift(),a))[x,y]].

— Neil

@Neil, une syntaxe vraiment avancée là-bas ... Je dois google au moins trois choses pour commencer à comprendre votre expression. À savoir l'opérateur de propagation, qu'est-ce que les compréhensions de tableau et quel est le [x, y] à la fin (je n'ai toujours pas trouvé de réponse à cela).

— alexandros84

1

@ alexandros84 À [x,y]la fin, c'est le bit facile, c'est juste un tableau littéral.

— Neil

1

De plus, l'opérateur de propagation n'est là que pour copier le tableau, car je le mute à l'intérieur de la boucle.

— Neil

1

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é.

— musicman523
source

Je n'ai pas le temps de vérifier, j'espère que la technique est vraiment différente car j'ai voté positivement.

— alexandros84

Je pense que c'est une approche très similaire à la réponse Python 3 de @ ovs.

— Neil

1

Japt , 2 octets

à2

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

— Hirsute
source

1

Python, 64 octets

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

— Joel Cornett
source

1

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!

— rahnema1
source

1

Clojure, 42 octets

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

Renvoie un ensemble d'ensembles :)

— NikoNyrh
source

1

Python, 74 octets

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

— Oren
source

1

Bienvenue chez PPCG! Vous pouvez jouer au golf: 1) remplacer les noms de variable à 2 caractères par 1 caractère 2) supprimer les espaces inutiles 3) il s'agit d'un extrait, vous devez en faire un lambda, une fonction ou un programme complet

— Erik the Outgolfer

Golf 10 octets: 64 octets

— M. Xcoder

1

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

— alexandros84
source

1

Bienvenue chez PPCG; nous nous attendons à ce que les soumissions soient traitées, y compris la suppression des espaces inutiles

— HyperNeutrino

Ty. Je me demandais aussi ceci: aurais-je dû inclure l'entrée x =; a = []; dans ma réponse ou non? Je vais éditer demain.

— alexandros84

Vous pouvez soit simplement soumettre une fonction ou faire un programme complet. Depuis que vous l'utilisez a, vous devez le définir, mais vous pouvez faire une fonction de x.

— HyperNeutrino

beaucoup mieux maintenant @HyperNeutrino.

— alexandros84

1

Je pense que vous pouvez exclure certains points-virgules et la ligne vide pour économiser de l'espace. Je pense aussi que vous pouvez changer for(i=n+1;i<(x.length);i++)pour for(i=n;++i<x.length;). De même, vous pouvez passer n<(x.length-1);n++àn++<x.length-1

— musicman523

0

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

— miles
source

Toutes les paires non ordonnées entre les éléments d'un tableau

Gelée , 2 octets

Haskell , 29 octets

Mathematica, 14 octets

Haskell, 25 octets

05AB1E , 3 octets

Code:

Explication:

vim, 50 48

Explication

Octave, 23 octets

Python 3 , 44 octets

Brachylog , 5 octets

Comment ça fonctionne

R , 18 octets

Python, 53 octets

Octave , 49 48 octets

Explication

Pari / GP , 34 octets

Python ≥ 2,7, 55 octets

Perl 6 , 17 octets

Scala, 17 octets

Pyth , 7 4 octets

Rubis , 38 34 24 octets

JavaScript ES6, 52 octets

Python , 55 octets

Japt , 2 octets

Python, 64 octets

Octave, 38 octets

Clojure, 42 octets

Python, 74 octets

Javascript (ES 5), de 108 à 78 octets

J , 17 octets

Explication