Công việc của bạn sẽ được để viết một hàm hay một chương trình, sẽ có một số nguyên n>0như là đầu vào và đầu ra một danh sách các cạnh của nchiều hypercube . Trong lý thuyết đồ thị, một cạnh được định nghĩa là 2 đỉnh của các đỉnh (hoặc các góc, nếu bạn thích), được kết nối.

ví dụ 1

Một hypercube 1 chiều là một dòng và có hai đỉnh, chúng ta sẽ gọi avà b.

Do đó, đầu ra sẽ là:

[[a, b]]

Ví dụ 2

Hypercube 4 chiều (hoặc tesseract) bao gồm 32 cạnh và biểu đồ của nó trông như thế này

và đầu ra có thể trông như thế này

[[a, b], [a, c], [a, e], [a, i], [b, d], [b, f], [b, j], [c, d], [c, g], [c, k], [d, h], [d, l], [e, f], [e, g], [e, m], [f, h], [f, n], [g, h], [g, o], [h, p], [i, j], [i, k], [i, m], [j, l], [j, n], [k, l], [k, o], [l, p], [m, n], [m, o], [n, p], [o, p]]

Quy tắc

• Bạn có thể đặt tên cho các đỉnh theo bất kỳ cách nào bạn thích, miễn là tên đó là duy nhất.
• Các cạnh là vô hướng, tức là [a, b]và [b, a]được coi là cùng một cạnh.
• Đầu ra của bạn không được chứa các cạnh trùng lặp.
• Đầu ra có thể ở bất kỳ định dạng hợp lý.
• Sơ hở tiêu chuẩn bị cấm.

Chấm điểm

Mã ngắn nhất sẽ thắng.

Thạch, 13 byte

ạ/S’
2ṗœc2ÇÐḟ

Hãy thử nó ở đây. Đối với đầu vào 3, đầu ra là:

[[[1, 1, 1], [1, 1, 2]],
 [[1, 1, 1], [1, 2, 1]],
 [[1, 1, 1], [2, 1, 1]],
 [[1, 1, 2], [1, 2, 2]],
 [[1, 1, 2], [2, 1, 2]],
 [[1, 2, 1], [1, 2, 2]],
 [[1, 2, 1], [2, 2, 1]],
 [[1, 2, 2], [2, 2, 2]],
 [[2, 1, 1], [2, 1, 2]],
 [[2, 1, 1], [2, 2, 1]],
 [[2, 1, 2], [2, 2, 2]],
 [[2, 2, 1], [2, 2, 2]]]

Tôi hy vọng [1, 1, 1]vv là một cái tên ổn.

Giải trình

Dòng đầu tiên là một biến vị ngữ của người Viking trên một cặp cạnh: [A, B] ạ/S’bằng sum(abs(A - B)) - 1, bằng 0 (false-y) iff Avà Bkhác nhau về chính xác một tọa độ.

Dòng thứ hai là chương trình chính:

• Tạo tất cả các cạnh với 2ṗ(sức mạnh của Cartesian [1, 2]).
• Nhận tất cả các cặp có thể bằng cách sử dụng œc2(kết hợp kích thước hai mà không cần thay thế).
• Chỉ giữ các phần tử thỏa mãn vị ngữ được xác định trước đó ( ÐḟÇ).

Python 2, 54 56 62 byte

lambda n:{tuple({k/n,k/n^1<<k%n})for k in range(n<<n)}

Các cạnh trùng lặp được loại bỏ bằng cách tạo một tập hợp các tập hợp, ngoại trừ Python yêu cầu các phần tử tập hợp có thể băm được, do đó chúng được chuyển đổi thành một bộ dữ liệu. Lưu ý rằng các bộ {a,b}và {b,a}bằng nhau và chuyển đổi sang cùng một bộ. xsot lưu 2 byte với n<<n.

Điều này có thể được cắt giảm xuống 49 byte nếu chuỗi tập hợp có định dạng đầu ra OK

lambda n:{`{k/n,k/n^1<<k%n}`for k in range(n<<n)}

cung cấp đầu ra như

set(['set([1, 3])', 'set([2, 3])', 'set([0, 2])', 'set([0, 1])'])

lambda n:[(k/n,k/n^1<<k%n)for k in range(n*2**n)if k/n&1<<k%n]

Trước tiên, hãy xem xét một phiên bản cũ hơn của giải pháp.

lambda n:[(i,i^2**j)for i in range(2**n)for j in range(n)if i&2**j]

Mỗi số trong khoảng [0,2^n)tương ứng với một đỉnh có tọa độ được cho bởi các nchuỗi nhị phân -bit của nó . Để các đỉnh được liền kề nếu chúng khác nhau trong một bit, tức là nếu một cái được lấy từ cái kia bằng cách xor-ing có công suất là 2.

Hàm ẩn danh này tạo ra tất cả các cạnh có thể bằng cách lấy mọi đỉnh và mọi vị trí bit để lật. Để tránh trùng lặp một cạnh theo cả hai hướng, chỉ 1 giây được lật thành 0.

Trong giải pháp nhiều gôn hơn, kđược sử dụng để mã hóa cả ivà jthông qua k=n*i+j, từ đó (i,j)có thể được trích xuất dưới dạng (k/n,k%n). Điều này tiết kiệm một vòng lặp trong sự hiểu biết. Sức mạnh của2 được thực hiện như 1<<có quyền ưu tiên toán tử.

Một cách tiếp cận khác là tạo từng cặp đỉnh và kiểm tra xem chúng có cách nhau một chút có vẻ dài hơn không (70 byte):

lambda n:[(i,x)for i in range(2**n)for x in range(i)if(i^x)&(i^x)-1<1] 

Toán học, 48 24 byte

EdgeList@*HypercubeGraph

Chỉ là một chức năng ẩn danh sử dụng tích hợp.

JavaScript (SpiderMonkey 30+), 69 64 byte

n=>[for(i of Array(n<<n).keys())if(i/n&(j=1<<i%n))[i/n^j,i/n^0]]

Điều này bắt đầu như một cổng của giải pháp Python 2 của @ xnor nhưng tôi đã có thể lưu 9 byte bằng cách viết lại mã để sử dụng một vòng lặp. Chỉnh sửa: Đã lưu thêm 5 byte bằng cách chia itheo cách khác, như giải pháp cập nhật của mỗi @ xnor, hiện cũng sử dụng một vòng lặp.

MATL , 20 byte

2i^:qt!Z~Zltk=XR2#fh

Điều này hoạt động với phiên bản hiện tại (14.0.0) của ngôn ngữ / trình biên dịch.

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

Giải trình

Điều này sử dụng ít nhiều cùng một ý tưởng như câu trả lời của @ xnor .

2i^    % take input n and compute 2^n
:q     % range [0,1,...,2^n-1] (row vector)
t!     % duplicate, transpose into a column vector
Z~     % bitwise XOR with broadcast
Zl     % binary logarithm
tk     % duplicate and round down
=      % true if equal, i.e. for powers of 2
XR     % upper triangular part, above diagonal
2#f    % row and index columns of nonzero values
h      % concatenate vertically

Bình thường, 13 byte

fq1.aT.c^U2Q2

Đầu ra trên đầu vào 3 :

[[[0, 0, 0], [0, 0, 1]], [[0, 0, 0], [0, 1, 0]], [[0, 0, 0], [1, 0, 0]], [[0, 0, 1], [0, 1, 1]], [[0, 0, 1], [1, 0, 1]], [[0, 1, 0], [0, 1, 1]], [[0, 1, 0], [1, 1, 0]], [[0, 1, 1], [1, 1, 1]], [[1, 0, 0], [1, 0, 1]], [[1, 0, 0], [1, 1, 0]], [[1, 0, 1], [1, 1, 1]], [[1, 1, 0], [1, 1, 1]]]

Giải trình:

fq1.aT.c^U2Q2
                  Implicit: input = Q
        ^U2Q      All Q entry lists made from [0, 1].
      .c    2     All 2 element combinations of them.
f                 Filter them on
   .aT            The length of the vector
 q1               Equaling 1.

Python 2: 59 byte

lambda n:[(a,a|1<<l)for a in range(2**n)for l in range(n)if~a&1<<l]