Bài tập:

Trả về một mảng với tất cả các cặp có thể giữa các phần tử của một mảng.

Thí dụ

Từ a=["a", "b", "c", "d"];trở về b=[["a","b"],["a","c"],["a","d"],["b","c"],["b","d"],["c","d"]].

Các cặp có thể theo bất kỳ thứ tự nào miễn là tất cả các kết hợp có thể được bao gồm và rõ ràng ["b","d"]là giống nhau ["d","b"].

Đầu vào

Mảng các phần tử chuỗi duy nhất bao gồm các ký tự từ lớp [a-z].

Đầu ra

Mảng 2d chứa tất cả các cặp phần tử của mảng đầu vào có thể.

Các trường hợp thử nghiệm

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

Lưu ý: Tôi không thể tìm thấy bản sao cho thử thách này. Nếu có, hãy cảnh báo tôi bằng một bình luận để bỏ câu hỏi.

Thạch , 2 byte

Œc

Hãy thử trực tuyến!

Haskell , 29 byte

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

Hãy thử trực tuyến! Ví dụ sử dụng: f ["a","b","c"]sản lượng [("a","b"),("a","c"),("b","c")].

Với cờ -XTupleSectionsnày, có thể rút ngắn xuống còn 27 byte, tuy nhiên cờ sẽ cần được tính:

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

Hãy thử trực tuyến!

Toán học, 14 byte

#~Subsets~{2}&

đầu vào

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

Haskell, 25 byte

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

Hãy thử trực tuyến!

Vòng lặp ngoài ( x) và bên trong ( y) thông qua danh sách đầu vào và chỉ giữ cặp (x,y)nếu x < y.

05AB1E , 3 byte

Mã số:

æ2ù

Sử dụng mã hóa 05AB1E . Hãy thử trực tuyến!

Giải trình:

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

Đưa đầu vào theo mẫu

abcd

và đầu ra như

ad
ac
ab
bd
bc
cd

Giải trình

Đầu tiên, AX<esc>gắn thêm một Xđầu vào để xử lý đầu vào 2 chiều dài, điều này cần thiết vì những lý do sẽ sớm trở nên rõ ràng.

Sau đó đến macro đệ quy đầu tiên, của mẫu qq...@qq@q. (Ghi macro q, tự chạy lại ở cuối, kết thúc ghi, sau đó tự chạy một lần.) Trong phần thân của macro, Ypsao chép dòng hiện tại, lthoát khỏi macro nếu dòng này dài một ký tự và Xxóa nhân vật đầu tiên trong dòng. Điều này có kết quả cuối cùng của sản xuất

abcdX
abcX
abX
aX
X
X

Bỏ qua các Xs bây giờ, tất cả những gì chúng ta phải làm là biến abcdX, ví dụ, thành ab / ac / ad / aX. Điều này đạt được với macro đệ quy thứ hai qr...@rq,.

Trong macro này, trước tiên, chúng tôi nhân đôi dòng ( Yp), sau đó xóa mọi thứ trừ hai ký tự đầu tiên bằng cách di chuyển sang phải hai ( ll) và xóa đến cuối dòng ( D). Vì con trỏ hiện đang ở trên charcater thứ hai của dòng, kxsẽ xóa ký tự thứ hai khỏi dòng trước đó, đây là ký tự vừa được ghép với ký tự đầu tiên trên dòng. Quá trình này sau đó được lặp lại bắt đầu lại từ đầu dòng ( h) nhiều lần khi cần thiết do tính chất đệ quy của macro.

Bây giờ chỉ là vấn đề chạy macro trên mọi dòng, có thể đạt được :g/./norm@r(Tôi không chắc tại sao điều này lại hoạt động khác :%norm@r, nhưng đủ để nói, cái sau không hoạt động như dự định.) Các dòng Xbị xóa :g/X/d, và các dòng trống ở cuối bên trái là kết quả của việc xây dựng rmacro được làm sạch với dG.

Octave, 23 byte

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

Hãy thử trực tuyến!

Python 3 , 44 byte

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

Hãy thử trực tuyến!

Lấy đầu vào là các tham số chức năng cá nhân.

Brachylog , 5 byte

{⊇Ċ}ᶠ

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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

combn(scan(,''),2)

đọc danh sách từ stdin, trả về một ma trận trong đó các cột là cặp.

Hãy thử trực tuyến!

Python, 53 byte

Lưu 2 byte nhờ @CalculatorFeline

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

Hãy thử trực tuyến!

Octave , 49 48 byte

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

Hàm ẩn danh tránh tích hợp ( nchoosek).

Hãy thử trực tuyến!

Giải trình

x+j*x'sử dụng phát sóng để xây dựng một ma trận gồm các số phức trong đó phần thực và phần ảo là tất cả các cặp điểm mã từ đầu vào x.

y=triu(...,1)giữ phần tam giác trên không bao gồm đường chéo, làm cho các phần tử còn lại bằng không. Kết quả được gán cho biến y.

y=(...)(~~y)giữ lại các phần tử khác 0 ở dạng vectơ cột, được gán cho biến y.

imag(...)và real(...)trích xuất các phần thực và tưởng tượng.

[... ... ''] chuyển đổi trở lại char để xây dựng đầu ra.

Pari / GP , 34 byte

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

Hãy thử trực tuyến!

Python ≥ 2.7, 55 byte

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

thay thế

Perl 6 , 17 byte

*.combinations(2)

Whew, đó là một tên phương pháp dài.

Scala, 17 byte

_.combinations(2)

Bình thường , 7 4 byte

^{-3 byte nhờ Leaky Nun !}

.cQ2

Hãy thử trực tuyến!

Ruby , 38 34 24 byte

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

Cảm ơn Seims cho ý tưởng đã lưu 10 byte.

Hãy thử trực tuyến!

JavaScript ES6, 52 byte

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

Nếu có như thế flatMapsẽ tiết kiệm rất nhiều byte.

Python , 55 byte

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

Hãy thử trực tuyến!

Dài hơn các câu trả lời Python khác, nhưng nó sử dụng một kỹ thuật khác nên tôi nghĩ nó đáng để đăng.

Japt , 2 byte

à2

Kiểm tra nó ( -Qcờ cho mục đích trực quan hóa)

Python, 64 byte

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

Octave, 38 byte

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

Một câu trả lời khác để tránh tích nchoosekhợp.

Hãy thử trực tuyến!

Clojure, 42 byte

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

Trả về một bộ các bộ :)

Python, 74 byte

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

Javascript (ES 5), từ 108 đến 78 byte

Tôi đăng câu trả lời của mình ngày hôm nay nhưng rõ ràng tôi hứa sẽ không chấp nhận câu trả lời của riêng tôi:

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 byte

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

Hãy thử trực tuyến!

Giải trình

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