İşiniz n>0girdi olarak bir tamsayıyı alacak ve nboyutlu hiper küpün kenarlarının bir listesini çıkaracak bir işlev veya program yazmak olacaktır . Grafik teorisinde bir kenar, birbirine bağlı olan 2-nokta köşesi (veya isterseniz köşeler) olarak tanımlanır.

örnek 1

A 1 boyutlu hiperküp bir çizgidir ve iki kesişim noktası, biz arayacak özellikleri ave b.

Bu nedenle, çıktı:

[[a, b]]

ÖRNEK 2

4 boyutlu hiper küp (veya tesseract) 32 kenardan oluşur ve grafiği şöyle görünür

ve çıktı şöyle görünebilir

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

kurallar

• Köşeleri, ad benzersiz olduğu sürece istediğiniz şekilde adlandırabilirsiniz.
• Kenarlar yönlendirilmemiştir, yani [a, b]ve [b, a]aynı kenar olarak kabul edilir.
• Çıktınız yinelenen kenarlar içermemelidir.
• Çıktı herhangi bir makul formatta olabilir.
• Standart boşluklar yasaktır.

puanlama

En kısa kod kazanır.

Jöle, 13 bayt

ạ/S’
2ṗœc2ÇÐḟ

Burada deneyin. Giriş 3için çıktı:

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

Umarım [1, 1, 1]vs. iyi bir “isim” dir.

açıklama

İlk satır, bir çift kenardaki bir "yüklem" dir: [A, B] ạ/S’eşittir sum(abs(A - B)) - 1, sıfır (yanlış-y) iff'dir Ave Btam olarak bir koordinatta farklılık gösterir.

İkinci satır ana programdır:

• 2ṗ(Kartezyen gücü [1, 2]) ile tüm kenarları oluşturun .
• Kullanarak tüm olası çiftleri alın œc2(değiştirmeden iki büyüklükteki kombinasyonlar).
• Yalnızca daha önce tanımlanan yüklemi karşılayan öğeleri saklayın ( ÐḟÇ).

Python 2, 54 56 62 bayt

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

Python, set öğelerinin yıkanabilir olmasını gerektirmesi dışında, yinelenen kenarlar bir dizi set yapılarak kaldırılır, böylece bir tuple dönüştürülürler. Setleri unutmayın {a,b}ve {b,a}aynı tuplea eşit ve dönüştürme vardır. xsot ile 2 bayt kaydedildi n<<n.

Set dizeleri OK çıkış biçimiyse bu 49 bayta kadar kesilebilir

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

hangi çıktı verir

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]

İlk olarak, çözümün eski bir sürümüne bakalım.

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

Aralıktaki her sayı [0,2^n), n-bit ikili dizeleri tarafından verilen koordinatlara sahip bir tepe noktasına karşılık gelir . Köşelere, tek bir bitte farklılık gösterirlerse, yani biri diğerinden 2'lik bir güç xorbe edilerek elde edilirse bitişiktir.

Bu anonim işlev, her tepe noktasını ve her bit konumunu çevirerek mümkün olan tüm kenarları üretir. Bir kenarı her iki yönde de kopyalamaktan kaçınmak için, yalnızca 1'ler 0'lara çevrilir.

Daha golfed çözümde, kkodlama hem için kullanılır ive jüzeri k=n*i+jolan, (i,j)olarak elde edilebilir (k/n,k%n). Bu, anlamada bir döngü kazandırır. Yetkileri doğru operatör önceliğine sahip olacak 2şekilde yapılır 1<<.

Her bir köşe çiftini üretmenin ve biraz ayrı olup olmadıklarını kontrol etmenin alternatif bir yaklaşımı daha uzun görünüyor (70 bayt):

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

Mathematica, 48 24 bayt

EdgeList@*HypercubeGraph

Sadece anonim işlevler yerleşik kullanır.

JavaScript (SpiderMonkey 30+), 69 64 bayt

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

Bu, @ xnor'ın Python 2 çözümünün bir bağlantı noktası olarak başladı, ancak tek bir döngü kullanmak için kodu yeniden yazarak 9 bayt kaydedebildim. Düzenleme: i@ xnor'ın şimdi tek bir döngü kullanan güncellenmiş çözümüne göre, başka bir şekilde bölünerek 5 bayt daha kaydetti .

MATL , 20 bayt

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

Bu , dilin / derleyicinin geçerli sürümüyle (14.0.0) çalışır .

Çevrimiçi deneyin!

açıklama

Bu, @ xnor'un cevabı ile hemen hemen aynı fikri kullanır .

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 bayt

fq1.aT.c^U2Q2

Giriş 3'teki çıkış :

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

Açıklama:

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 bayt

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