Ваше завдання полягатиме в тому, щоб написати функцію або програму, яка буде приймати ціле число n>0як вхід і виводити список ребер n-вимірного гіперкуба . У теорії графів край визначається як 2-ма вершини вершин (або кутів, якщо вам більше зручно), які пов'язані між собою.

Приклад 1

1-мірний гіперкуб - це лінія і містить дві вершини, які ми будемо називати aі b.

Тому вихід буде:

[[a, b]]

Приклад 2

4-мірний гіперкуб (або тессеракт) складається з 32 ребер і його графік виглядає приблизно так

і вихід може виглядати так

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

Правила

• Ви можете називати вершини будь-яким способом, доки ім'я є унікальним.
• Краї неорієнтовані, тобто [a, b]і [b, a]вважаються однаковими краями.
• Ваш вихід не повинен містити повторюваних країв.
• Вихід може бути у будь-якому розумному форматі.
• Стандартні лазівки заборонені.

Оцінка балів

Найкоротший код виграє.

Желе, 13 байт

ạ/S’
2ṗœc2ÇÐḟ

Спробуйте тут. Для введення 3вихід:

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

Я сподіваюся, що [1, 1, 1]ін. Це добре "ім'я".

Пояснення

Перший рядок - це "предикат" на парі ребер: [A, B] ạ/S’дорівнює sum(abs(A - B)) - 1, що дорівнює нулю (false-y) iff Aі Bвідрізняється рівно однією координатою.

Другий рядок - основна програма:

• Створити всі ребра за допомогою 2ṗ(декартової сили [1, 2]).
• Отримайте всі можливі пари за допомогою œc2(комбінації розміру два без заміни).
• Зберігайте лише елементи, що задовольняють присудок, визначений раніше ( ÐḟÇ).

Python 2, 54 56 62 байт

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

Повторювані краї видаляються набором наборів, за винятком того, що Python вимагає, щоб елементи набору були хешированными, тому вони перетворюються на кортежі. Зверніть увагу, що множини {a,b}і {b,a}рівні, і перетворюються в один кортеж. xsot збережено 2 байти за допомогою n<<n.

Це може бути скорочено до 49 байт, якщо рядки наборів мають вихідний формат OK

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

що дає вихід

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]

Спочатку розглянемо старішу версію рішення.

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

Кожне число в проміжку [0,2^n)відповідає вершині з координатами, заданими її nбітовими двійковими рядками. До вершин примикають, якщо вони різняться в одному біті, тобто якщо одна отримана від іншої шляхом вирівнювання потужності 2.

Ця анонімна функція генерує всі можливі ребра, приймаючи кожну вершину та кожне бітове положення для перегортання. Щоб уникнути дублювання краю в обох напрямках, лише 1 перевернуті на 0.

У більш гольф-рішенні kвикористовується для кодування обох iі jчерез k=n*i+j, з яких (i,j)можна витягнути як (k/n,k%n). Це економить цикл у розумінні. Повноваження 2надаються 1<<правильним пріоритетом оператора.

Альтернативний підхід для генерації кожної пари вершин і перевірки, чи вони трохи розгорнуті, здається довше (70 байт):

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

Математика, 48 24 байти

EdgeList@*HypercubeGraph

Просто анонімна функція, яка використовує вбудовані модулі.

JavaScript (SpiderMonkey 30+), 69 64 байт

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

Це почалося як порт рішення Python 2 @ xnor, але мені вдалося зберегти 9 байт, переписавши код для використання одного циклу. Редагувати. Збережено ще 5 байт, розділивши iнавпаки, відповідно до оновленого рішення @ xnor, яке тепер також використовує один цикл.

MATL , 20 байт

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

Це працює з поточною версією (14.0.0) мови / компілятора.

Спробуйте в Інтернеті!

Пояснення

Тут використовується більш-менш та сама ідея, що і у відповіді @ 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

Pyth, 13 байт

fq1.aT.c^U2Q2

Вихід на вхід 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]]]

Пояснення:

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.

Пітон 2: 59 байт

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