Su tarea es generar un gráfico con 54 vértices, cada uno corresponde a una faceta en el cubo de Rubik. Hay un borde entre dos vértices si las facetas correspondientes comparten un lado.

Reglas

• Puede elegir generar una lista de adyacencia, matriz de adyacencia, lista de bordes o cualquier formato razonable para representar un gráfico en un algoritmo. (Un gráfico visual legible por un humano generalmente no es un formato razonable en un algoritmo en la mayoría de los casos).
• Puede hacer que cada vértice sea adyacente a sí mismo o ninguno adyacente a sí mismo.
• Puede incluir ambas direcciones para cada borde (contar una o dos veces para los bucles automáticos), o generar exactamente una vez para cada borde, pero no mezclar las formas.
• Puede renumerar los vértices, omitir algunos números o incluso usar etiquetas que no sean números para los vértices de la forma que desee. También debe publicar la numeración si no es obvio, para que otros puedan verificar su respuesta de manera más fácil.
• Este es el código de golf. El código más corto en bytes gana.

Salida de ejemplo

Esta es la numeración de vértices utilizada en el ejemplo:

          0  1  2
          3  4  5
          6  7  8
 9 10 11 18 19 20 27 28 29 36 37 38
12 13 14 21 22 23 30 31 32 39 40 41
15 16 17 24 25 26 33 34 35 42 43 44
         45 46 47
         48 49 50
         51 52 53

Salida como una lista de adyacencia (el número de vértice antes de cada lista es opcional):

0 [1 3 9 38]
1 [2 4 0 37]
2 [29 5 1 36]
3 [4 6 10 0]
4 [5 7 3 1]
5 [28 8 4 2]
6 [7 18 11 3]
7 [8 19 6 4]
8 [27 20 7 5]
9 [10 12 38 0]
10 [11 13 9 3]
11 [18 14 10 6]
12 [13 15 41 9]
13 [14 16 12 10]
14 [21 17 13 11]
15 [16 51 44 12]
16 [17 48 15 13]
17 [24 45 16 14]
18 [19 21 11 6]
19 [20 22 18 7]
20 [27 23 19 8]
21 [22 24 14 18]
22 [23 25 21 19]
23 [30 26 22 20]
24 [25 45 17 21]
25 [26 46 24 22]
26 [33 47 25 23]
27 [28 30 20 8]
28 [29 31 27 5]
29 [36 32 28 2]
30 [31 33 23 27]
31 [32 34 30 28]
32 [39 35 31 29]
33 [34 47 26 30]
34 [35 50 33 31]
35 [42 53 34 32]
36 [37 39 29 2]
37 [38 40 36 1]
38 [9 41 37 0]
39 [40 42 32 36]
40 [41 43 39 37]
41 [12 44 40 38]
42 [43 53 35 39]
43 [44 52 42 40]
44 [15 51 43 41]
45 [46 48 17 24]
46 [47 49 45 25]
47 [33 50 46 26]
48 [49 51 16 45]
49 [50 52 48 46]
50 [34 53 49 47]
51 [52 44 15 48]
52 [53 43 51 49]
53 [35 42 52 50]

APL (Dyalog Classic) , 34 30 bytes

-4 gracias a jimmy23013

4≥+/¨|∘.-⍨,(⍳3)∘.⌽7 ¯1∘.,○⍳3 3

Pruébalo en línea!

genera una matriz de adyacencia con cada vértice adyacente a sí mismo

⍳3 3 generar una matriz de (0 0)(0 1)(0 2)(1 0)(1 1)(1 2)(2 0)(2 1)(2 2)

○ multiplicar todo por π

7 ¯1∘., anteponer 7 o -1 en todas las formas posibles

(⍳3)∘.⌽ rotar coord triples por 0 1 2 pasos en todas las formas posibles

+/¨|∘.-⍨, calcular la distancia de Manhattan entre cada par

4≥ no debe ser mayor que 4 para las facetas vecinas

Ruby , 79 bytes

54.times{|i|p [(i%6<5?i+1:i+18-i/6%3*7)%54,(i+=i%18<12?6:[18-i%6*7,3].max)%54]}

Pruébalo en línea!

Imprime una representación de un gráfico unidireccional, como una lista de los vértices a la derecha y debajo de cada vértice, como se muestra en el siguiente mapa.

 0  1  2  3  4  5   
 6  7  8  9 10 11   
12 13 14 15 16 17   
         18 19 20 21 22 23
         24 25 26 27 28 29
         30 31 32 33 34 35
                  36 37 38 39 40 41
                  42 43 44 45 46 47 
                  48 49 50 51 52 53

Python 2.7, 145

def p(n):l=(3-n%2*6,n/6%3*2-2,n/18*2-2);k=n/2%3;return l[k:]+l[:k]
r=range(54)
x=[[sum((x-y)**2for x,y in zip(p(i),p(j)))<5for i in r]for j in r]

Pruébalo en línea!

Define una matriz de adyacencia xcomo una lista de listas de valores booleanos. Las facetas cuentan como adyacentes a sí mismas.

p(n)calcula las coordenadas del centro de la enésima faceta de un cubo de 3x3x3 cuyas facetas tienen 2 unidades de ancho. La adyacencia se determina probando si 2 facetas tienen una distancia cuadrada por debajo de 5 (las facetas adyacentes tienen una distancia cuadrada como máximo 4, las facetas no adyacentes tienen una distancia cuadrada de al menos 6).

Carbón , 48 bytes

Ｆ⁷Ｆ⁷Ｆ⁷⊞υ⟦ικλ⟧≔Φυ⁼Φ﹪ι⁶¬﹪λ²⟦⁰⟧υＩＥυΦＬυ⁼²ΣＥ§υλ↔⁻ν§ιξ

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

Ｆ⁷Ｆ⁷Ｆ⁷⊞υ⟦ικλ⟧

Genere todos los conjuntos de coordenadas tridimensionales en el rango [0..6]de cada dimensión.

≔Φυ⁼Φ﹪ι⁶¬﹪λ²⟦⁰⟧υ

Mantener sólo esas coordenadas que son centros de 2x2cuadrados en una de las caras x=0, y=0, z=0, x=6, y=6, z=6.

ＩＥυΦＬυ⁼²ΣＥ§υλ↔⁻ν§ιξ

Para cada coordenada, imprima los índices de esas coordenadas cuya distancia en taxi es 2.

Los vértices se numeran de la siguiente manera:

         33 34 35
         21 22 23
          9 10 11
36 24 12  0  1  2 13 25 37 47 46 45
38 26 14  3  4  5 15 27 39 50 49 48
40 28 16  6  7  8 17 29 41 53 52 51
         18 19 20
         30 31 32
         42 43 44

Wolfram Language 190 bytes

Lo siguiente devuelve todos los bordes del gráfico en términos de las coordenadas reales (asumiendo que cada mini-cubo tiene 2 unidades en el borde y el cubo de Rubik tiene su vértice inferior izquierdo en el origen).

t=Table;h[a_,b_,c_]:=t[{x,y,z},{a,1,5,2},{b,1,5,2},{c,0,6,6}];Partition[Sort[a=Cases[DeleteCases[Tuples[Flatten[{h[x,z,y],h[y,z,x],h[x,y,z]},3],{2}],{x_,x_}],x_/;ManhattanDistance@@x==2]],4]

(* output *)
{{{{0,1,1},{0,1,3}},{{0,1,1},{0,3,1}},{{0,1,1},{1,0,1}},{{0,1,1},{1,1,0}}},{{{0,1,3},{0,1,1}},{{0,1,3},{0,1,5}},{{0,1,3},{0,3,3}},{{0,1,3},{1,0,3}}},{{{0,1,5},{0,1,3}},{{0,1,5},{0,3,5}},{{0,1,5},{1,0,5}},{{0,1,5},{1,1,6}}},{{{0,3,1},{0,1,1}},{{0,3,1},{0,3,3}},{{0,3,1},{0,5,1}},{{0,3,1},{1,3,0}}},{{{0,3,3},{0,1,3}},{{0,3,3},{0,3,1}},{{0,3,3},{0,3,5}},{{0,3,3},{0,5,3}}},{{{0,3,5},{0,1,5}},{{0,3,5},{0,3,3}},{{0,3,5},{0,5,5}},{{0,3,5},{1,3,6}}},{{{0,5,1},{0,3,1}},{{0,5,1},{0,5,3}},{{0,5,1},{1,5,0}},{{0,5,1},{1,6,1}}},{{{0,5,3},{0,3,3}},{{0,5,3},{0,5,1}},{{0,5,3},{0,5,5}},{{0,5,3},{1,6,3}}},{{{0,5,5},{0,3,5}},{{0,5,5},{0,5,3}},{{0,5,5},{1,5,6}},{{0,5,5},{1,6,5}}},{{{1,0,1},{0,1,1}},{{1,0,1},{1,0,3}},{{1,0,1},{1,1,0}},{{1,0,1},{3,0,1}}},{{{1,0,3},{0,1,3}},{{1,0,3},{1,0,1}},{{1,0,3},{1,0,5}},{{1,0,3},{3,0,3}}},{{{1,0,5},{0,1,5}},{{1,0,5},{1,0,3}},{{1,0,5},{1,1,6}},{{1,0,5},{3,0,5}}},{{{1,1,0},{0,1,1}},{{1,1,0},{1,0,1}},{{1,1,0},{1,3,0}},{{1,1,0},{3,1,0}}},{{{1,1,6},{0,1,5}},{{1,1,6},{1,0,5}},{{1,1,6},{1,3,6}},{{1,1,6},{3,1,6}}},{{{1,3,0},{0,3,1}},{{1,3,0},{1,1,0}},{{1,3,0},{1,5,0}},{{1,3,0},{3,3,0}}},{{{1,3,6},{0,3,5}},{{1,3,6},{1,1,6}},{{1,3,6},{1,5,6}},{{1,3,6},{3,3,6}}},{{{1,5,0},{0,5,1}},{{1,5,0},{1,3,0}},{{1,5,0},{1,6,1}},{{1,5,0},{3,5,0}}},{{{1,5,6},{0,5,5}},{{1,5,6},{1,3,6}},{{1,5,6},{1,6,5}},{{1,5,6},{3,5,6}}},{{{1,6,1},{0,5,1}},{{1,6,1},{1,5,0}},{{1,6,1},{1,6,3}},{{1,6,1},{3,6,1}}},{{{1,6,3},{0,5,3}},{{1,6,3},{1,6,1}},{{1,6,3},{1,6,5}},{{1,6,3},{3,6,3}}},{{{1,6,5},{0,5,5}},{{1,6,5},{1,5,6}},{{1,6,5},{1,6,3}},{{1,6,5},{3,6,5}}},{{{3,0,1},{1,0,1}},{{3,0,1},{3,0,3}},{{3,0,1},{3,1,0}},{{3,0,1},{5,0,1}}},{{{3,0,3},{1,0,3}},{{3,0,3},{3,0,1}},{{3,0,3},{3,0,5}},{{3,0,3},{5,0,3}}},{{{3,0,5},{1,0,5}},{{3,0,5},{3,0,3}},{{3,0,5},{3,1,6}},{{3,0,5},{5,0,5}}},{{{3,1,0},{1,1,0}},{{3,1,0},{3,0,1}},{{3,1,0},{3,3,0}},{{3,1,0},{5,1,0}}},{{{3,1,6},{1,1,6}},{{3,1,6},{3,0,5}},{{3,1,6},{3,3,6}},{{3,1,6},{5,1,6}}},{{{3,3,0},{1,3,0}},{{3,3,0},{3,1,0}},{{3,3,0},{3,5,0}},{{3,3,0},{5,3,0}}},{{{3,3,6},{1,3,6}},{{3,3,6},{3,1,6}},{{3,3,6},{3,5,6}},{{3,3,6},{5,3,6}}},{{{3,5,0},{1,5,0}},{{3,5,0},{3,3,0}},{{3,5,0},{3,6,1}},{{3,5,0},{5,5,0}}},{{{3,5,6},{1,5,6}},{{3,5,6},{3,3,6}},{{3,5,6},{3,6,5}},{{3,5,6},{5,5,6}}},{{{3,6,1},{1,6,1}},{{3,6,1},{3,5,0}},{{3,6,1},{3,6,3}},{{3,6,1},{5,6,1}}},{{{3,6,3},{1,6,3}},{{3,6,3},{3,6,1}},{{3,6,3},{3,6,5}},{{3,6,3},{5,6,3}}},{{{3,6,5},{1,6,5}},{{3,6,5},{3,5,6}},{{3,6,5},{3,6,3}},{{3,6,5},{5,6,5}}},{{{5,0,1},{3,0,1}},{{5,0,1},{5,0,3}},{{5,0,1},{5,1,0}},{{5,0,1},{6,1,1}}},{{{5,0,3},{3,0,3}},{{5,0,3},{5,0,1}},{{5,0,3},{5,0,5}},{{5,0,3},{6,1,3}}},{{{5,0,5},{3,0,5}},{{5,0,5},{5,0,3}},{{5,0,5},{5,1,6}},{{5,0,5},{6,1,5}}},{{{5,1,0},{3,1,0}},{{5,1,0},{5,0,1}},{{5,1,0},{5,3,0}},{{5,1,0},{6,1,1}}},{{{5,1,6},{3,1,6}},{{5,1,6},{5,0,5}},{{5,1,6},{5,3,6}},{{5,1,6},{6,1,5}}},{{{5,3,0},{3,3,0}},{{5,3,0},{5,1,0}},{{5,3,0},{5,5,0}},{{5,3,0},{6,3,1}}},{{{5,3,6},{3,3,6}},{{5,3,6},{5,1,6}},{{5,3,6},{5,5,6}},{{5,3,6},{6,3,5}}},{{{5,5,0},{3,5,0}},{{5,5,0},{5,3,0}},{{5,5,0},{5,6,1}},{{5,5,0},{6,5,1}}},{{{5,5,6},{3,5,6}},{{5,5,6},{5,3,6}},{{5,5,6},{5,6,5}},{{5,5,6},{6,5,5}}},{{{5,6,1},{3,6,1}},{{5,6,1},{5,5,0}},{{5,6,1},{5,6,3}},{{5,6,1},{6,5,1}}},{{{5,6,3},{3,6,3}},{{5,6,3},{5,6,1}},{{5,6,3},{5,6,5}},{{5,6,3},{6,5,3}}},{{{5,6,5},{3,6,5}},{{5,6,5},{5,5,6}},{{5,6,5},{5,6,3}},{{5,6,5},{6,5,5}}},{{{6,1,1},{5,0,1}},{{6,1,1},{5,1,0}},{{6,1,1},{6,1,3}},{{6,1,1},{6,3,1}}},{{{6,1,3},{5,0,3}},{{6,1,3},{6,1,1}},{{6,1,3},{6,1,5}},{{6,1,3},{6,3,3}}},{{{6,1,5},{5,0,5}},{{6,1,5},{5,1,6}},{{6,1,5},{6,1,3}},{{6,1,5},{6,3,5}}},{{{6,3,1},{5,3,0}},{{6,3,1},{6,1,1}},{{6,3,1},{6,3,3}},{{6,3,1},{6,5,1}}},{{{6,3,3},{6,1,3}},{{6,3,3},{6,3,1}},{{6,3,3},{6,3,5}},{{6,3,3},{6,5,3}}},{{{6,3,5},{5,3,6}},{{6,3,5},{6,1,5}},{{6,3,5},{6,3,3}},{{6,3,5},{6,5,5}}},{{{6,5,1},{5,5,0}},{{6,5,1},{5,6,1}},{{6,5,1},{6,3,1}},{{6,5,1},{6,5,3}}},{{{6,5,3},{5,6,3}},{{6,5,3},{6,3,3}},{{6,5,3},{6,5,1}},{{6,5,3},{6,5,5}}},{{{6,5,5},{5,5,6}},{{6,5,5},{5,6,5}},{{6,5,5},{6,3,5}},{{6,5,5},{6,5,3}}}}

El trabajo de generar los puntos en cada faceta externa se realiza mediante la función h,. Se debe llamar 3 veces para generar los puntos en x = 0, x = 6; y = 0, y = 6; y z = 0, z = 6.

Cada punto de faceta que esté a una distancia de Manhattan de 2 unidades de otra se conectará al punto respectivo.

Podemos mostrar los bordes del gráfico visualmente de la siguiente manera; aes la lista de bordes del gráfico que se representan a continuación como flechas.

Graphics3D[{Arrowheads[.02],Arrow/@a},Boxed->False,Axes-> True]

A continuación se muestra el cubo de Rubik, los puntos en las facetas externas y los 8 bordes del gráfico.

Los puntos rojos se encuentran en las facetas en y = 0 e y = 6; los puntos azules y grises están en facetas en x = 6 yx = 0, respectivamente; los puntos negros están en las facetas en z = 6 y z = 0.

Óxido - 278 bytes

fn main(){let mut v=vec![];for x in vec![-2,0,2]{for y in vec![-2,0,2]{for z in vec![-2,2]{v.push([-1,z,x,y]);v.push([0,x,y,z]);v.push([1,x,z,y]);}}}for r in 0..54{print!("\n{} ",r);for s in 0..54{if (0..4).map(|n|v[r][n]-v[s][n]).map(|d|d*d).sum::<i32>()<5{print!("{} ",s)}}}}

Probar en play.rust-lang.org

Esto es grande, pero el código más pequeño para un lenguaje compilado (hasta ahora). Crea una lista de adyacencia. Es muy similar a la respuesta de python deboard_box pero quería ver si Quaternions podría funcionar.

Paso 1: Construya 54 Cuaterniones, cada uno representando una sola faceta.

Paso 2: para cada Quaternion, enumere todos los demás Quaternions con Quadrance (también conocido como distancia al cuadrado, también conocido como norma al cuadrado de la diferencia) <= 4.

Los cuaterniones se construyen así: los vectores imaginarios ijk son puntos en el caparazón de una cuadrícula, de -2, -2, -2 a 2,2,2, paso 2. La parte real w siempre es -1, 0 o 1, de modo que las facetas en lados opuestos del cubo tienen la misma parte real, pero los lados adyacentes tienen partes reales diferentes. La parte real permite distinguir diferentes 'lados' del cubo a través del cálculo.

Numeración de cuaterniones (vista 3d pseudo isométrica de un cubo):

   ->i  ^j  \k

                  -2,+2,+2   +0,+2,+2  +2,+2,+2
                  -2,+0,+2   +0,+0,+2  +2,+0,+2
                  -2,-2,+2   +0,-2,+2  +2,-2,+2
                       w=0

   -2,+2,+2       -2 +2 +2   +0 +2 +2   +2 +2 +2     +2,+2,+2
   -2,+0,+2                                          +2,+0,+2
   -2,-2,+2       -2 -2 +2   +0 -2 +2   +2 -2 +2     +2,-2,+2

     -2,+2,+0       -2 +2 +0   +0 +2 +0   +2 +2 +0     +2,+2,+0
     -2,+0,+0                                          +2,+0,+0
     -2,-2,+0       -2 -2 +0   +0 -2 +0   +2 -2 +0     +2,-2,+0

       -2,+2,-2       -2 +2 -2   +0 +2 -2   +2 +2 -2     +2,+2,-2
       -2,+0,-2             w=1                          +2,+0,-2
       -2,-2,-2       -2 -2 -2   +0 -2 -2   +2 -2 -2     +2,-2,-2
           w=-1             w=1                              w=-1

                       -2,+2,-2   +0,+2,-2  +2,+2,-2
                       -2,+0,-2   +0,+0,-2  +2,+0,-2
                       -2,-2,-2   +0,-2,-2  +2,-2,-2
                            w=0

Numeración indexada (cubo desplegado):

                    16 34 52
                    10 28 46
                     4 22 40
         48 30 12   14 32 50  15 33 51
         42 24  6    8 26 44   9 27 45
         36 18  0    2 20 38   3 21 39
                     1 19 37
                     7 25 43
                    13 31 49
                     5 23 41
                    11 29 47
                    17 35 53

JavaScript (ES6, navegador), 153 bytes

for(F=n=>(A=[n%9/3|0,n%3]).splice(n/18,0,(n/9&1)*3-.5)&&A,i=0;i<54;i++)for([a,b,c]=F(i),j=0;j<54;Math.hypot(a-d,b-e,c-f)>1||alert([i,j]),j++)[d,e,f]=F(j)

Pruébalo en línea!

Esto se modifica para reducir 5 bytes haciendo que los mismos puntos sean adyacentes, es decir $||\mathbf{A-B}||\leq1$.

JavaScript (ES6, navegador), 158 bytes

for(F=n=>(A=[n%9/3|0,n%3]).splice(n/18,0,(n/9&1)*3-.5)&&A,i=0;i<54;i++)for([a,b,c]=F(i),j=0;j<54;Math.hypot(a-d,b-e,c-f)>1||i-j&&alert([i,j]),j++)[d,e,f]=F(j)

Pruébalo en línea! (simula alertcon console.log)

Asigna el centro de las 54 facetas al espacio tridimensional y calcula si $0<||\mathbf{A-B}||\leq1$por cada par de puntos. Emite todos los bordes dirigidos como pares de números [a, b]. El mapa de vértices es

47 50 53
46 49 52
45 48 51
20 23 26 11 14 17 35 32 29  8  5  2 
19 22 25 10 13 16 34 31 28  7  4  1 
18 21 24  9 12 15 33 30 27  6  3  0 
36 39 42
37 40 43
38 41 44