Asigne los números del 0 al 7 a los 8 vértices de un cubo de la forma que desee. Se debe asignar exactamente un número a cada vértice.

Por ejemplo, sus vértices podrían asignarse así:

  3-----1
 /|    /|
4-----2 |
| |   | |
| 5---|-0
|/    |/
6-----7

Escriba un programa que tome un número entero de 0 a 5. Cada uno de estos 6 números está asociado con exactamente una cara de su cubo de la manera que desee. Cuando se ingresa uno de estos números, los 4 números de vértice de la cara asociada deben imprimirse en stdout en un cuadrado de 2x2 dígitos. La cara se debe ver directamente desde afuera del cubo. Las 4 rotaciones de la cara son válidas.

Por ejemplo, si 0 está asociado con la cara frontal del cubo de ejemplo anterior, entonces esta sería una salida válida para la entrada 0:

42
67

La cara se puede ver en cualquier rotación de 90 °, por lo que también son válidos:

27
46

76
24

64
72

Esta salida (y sus rotaciones) no son válidas , ya que se ven desde el lado equivocado de la cara:

24
76

La misma idea se aplica a todas las otras caras. por ejemplo, si 1 está asociado con la cara posterior, entonces la entrada 1puede producir salida 13[newline]05(y 31[newline]50sería inválida).

Entonces, el verdadero desafío es elegir sus números de vértice y rotaciones de tal manera que traducir la entrada a sus 4 números de vértice sea fácil y corto.

El código más corto en bytes gana. Tiebreaker es una publicación anterior. ( Práctico contador de bytes ) .

Notas

• Puede escribir una función en lugar de un programa. Debe tomar un número entero de 0 a 5 e imprimir o devolver la cadena de cuadrícula de 2 × 2 dígitos.
• Tome la entrada de stdin, línea de comando o función arg. Puede suponer que la entrada es válida.
• La salida puede tener opcionalmente una nueva línea final.
• Asegúrese de decirnos los números de vértice y cara que eligió.

CJam, 23 16 bytes

Probablemente haya una solución matemática elegante para este problema. Pero no tengo idea de cómo encontrar uno, ¡así que es una codificación dura super comprimida!

¡Encontré uno! Bueno, no es una solución matemática clásica y elegante, ya que utiliza operaciones bit a bit, pero es completamente formulada.

li_o1^_p_6|o3+6%

Pruébalo en línea.

Diseño de cubo

  4-----7          4-----7          3-----2
 /|    /|         /  0  /|         /  3  /|
1-----0 |        1-----0 |        6-----5 |
| |   | |        |     |2|        |     |4|
| 5---|-2        |  1  | 2        |  5  | 7
|/    |/         |     |/         |     |/ 
6-----3          6-----3          1-----4  

Explicación

Mi respuesta anterior ya presentaba el cubo de tal manera que cada cara puede describirse con su primer número de vértice (superior izquierdo) igual al número de la cara. Pero quería poder calcular más números de vértice usando el número de la cara. En algún momento, se me ocurrió la idea de meter el pie en la puerta, para calcular el segundo número de vértice (arriba a la izquierda) como el número de cara XOR 1. Y después de un tiempo de prueba y error, logré aparecer con el diseño que se muestra arriba y las fórmulas a continuación que me permiten calcular cada número de vértice para una cara de manera nbastante sucinta:

• Arriba a la izquierda: n
• Parte superior derecha: n^1
• Abajo a la izquierda: (n^1)|6
• Abajo a la derecha: ((n^1)+3)%6

Como referencia, reproduciré la salida para cada cara en el diseño deseado aquí:

Face:      0     1     2     3     4     5

Vertices:  01    10    23    32    45    54
           74    63    70    65    72    61

Entonces, todo el programa se reduce a leer el número de entrada y producir estos valores en orden, aunque con una lógica de impresión ligeramente diferente para diferentes vértices. Tenga en cuenta que, dado que cada vértice después del primero comienza con una base de n^1, solo necesito calcular eso una vez, lo que compacta aún más la lógica.

Por el bien de la posteridad, y porque creo que todavía era un enfoque bastante bueno, aquí está mi vieja respuesta.

CJam, 23 bytes

Probablemente haya una solución matemática elegante para este problema. Pero no tengo idea de cómo encontrar uno, ¡así que es una codificación dura super comprimida!

"pÜ×ñè¨"487b8b3/ri_o=~p

Pruébalo en línea.

Diseño de cubo

  0-----7          0-----7          3-----6
 /|    /|         /  0  /|         /  3  /|
1-----2 |        1-----2 |        4-----5 |
| |   | |        |     |2|        |     |5|
| 5---|-6        |  1  | 6        |  4  | 7
|/    |/         |     |/         |     |/ 
4-----3          4-----3          1-----0  

Explicación

El enfoque básico empleado es codificar los vértices de cada cara en el menor espacio posible. De manera similar a la solución de conversión de base de Optimizer, trata la lista de vértices como un número octal empaquetado como datos de caracteres ASCII. ¡Pero ahí es donde terminan las similitudes para dar paso a nuevas optimizaciones!

Aquí están las tres optimizaciones clave que hice a la solución "ingenua":

• Diseñe el cubo de modo que cada cara pueda describirse con su número de cara como el primer número de vértice. Mirando el diseño de mi cubo como se presentó anteriormente, uno puede ver que el número de vértice superior izquierdo de cada cara es igual al número de cara. Esto me permite codificar seis vértices menos a costa de tener que volver a imprimir la entrada, lo que resulta para guardar un byte.
• Empaquete los datos del vértice en una cadena para la cual cada "carácter" tenga un máximo mayor que 256. A medida que este máximo aumenta más allá de 256, la longitud de la cadena disminuye lentamente, pero es cada vez más probable que cualquier "carácter" exceda 256 y sea por lo tanto, ya no forma parte del conjunto de caracteres ASCII de 1 byte. Así que escribí un programa que intenta codificar los datos de vértice en cada base de 256 a 1000, con los que encontré unas 10 bases que ahorran un byte de datos de caracteres en comparación con la base 256. Elegí 487, ya que también tiene la buena propiedad que la cadena resultante consiste completamente en ASCII imprimible.
• Mezclado con la primera optimización, produce la salida de forma asimétrica. El enfoque habitual en CJam sería formatear los datos de vértice como una lista de 2 elementos de listas de 2 elementos, insertar una nueva línea en el medio y dejar que la salida se imprima implícitamente. Pero, en cambio, imprimo el primer vértice (igual al número de entrada) con un operador que no agrega una nueva línea, recupero la lista de 3 elementos de los otros vértices, tomo el siguiente vértice e imprimo con un operador que agrega una nueva línea y deje que los otros dos vértices se impriman implícitamente. Esto ahorra un byte.

C, 69

f(c){int d=c++%2*2-1;printf("%d%d\n%d%d",(c-d)%6,c%6,c%2+6,(c+d)%6);}

Sin golf en el programa de prueba

f(c){
 int d=c++%2*2-1;
 printf("%d%d\n%d%d",(c-d)%6,c%6,c%2+6,(c+d)%6);
}

int n;
main(){
  scanf("%d",&n);
  f(n);
}

Explicación

Mi numeración de cubos, cuando está desplegada, se ve así:

0---7
|   |
| 0 |
|   |
1---2---7 
|   |   |
| 1 | 2 |
|   |   |
6---3---4---7
    |   |   |
    | 3 | 4 |
    |   |   |
    6---5---0
        |   |
        | 5 |
        |   |
        6---1

La esquina superior izquierda tiene el mismo número que la cara.

La esquina inferior derecha tiene número (n+2)%6

Por extraño, nla esquina superior derecha es (n+1)%6y la esquina inferior izquierda es6

Porque incluso nla esquina superior derecha es 7y la esquina inferior izquierda es(n+1)%6

El programa muestra los números impares como se muestra y los números pares giraron 180 grados. Esto significa que la esquina superior derecha es siempre (n+1)%6y la esquina inferior izquierda es siempre (n+1)%2+6. Invertir ny n+2es más fácil (se hace configurando c=n+1y usando dpara sumar o restar 1o -1según sea necesario).

Salida

$ ./a
0
21
70

$ ./a
1
12
63

$ ./a
2
43
72

$ ./a
3
34
65

$ ./a
4
05
74

$ ./a
5
50
61

Elemento, 18

_4:2%6+``2+6%`-5+`

A diferencia de muchos lenguajes de golf más avanzados, Element no tiene un operador de compresión, por lo que la brevedad de la solución está estrechamente vinculada al esquema de numeración exacto utilizado. Después de experimentar un poco, he creado un nuevo esquema de numeración que permite calcular los vértices utilizando solo operaciones aritméticas simples.

  1-----0          1-----0          2-----5
 /|    /|         /  4  /|         /  3  /|
4-----6 |        4-----6 |        3-----7 |
| |   | |        |     |0|        |     |5|
| 7---|-5        |  2  | 5        |  1  | 0
|/    |/         |     |/         |     |/ 
3-----2          3-----2          4-----1  

La esquina superior izquierda es 6 si es par y 7 si es impar. La esquina superior derecha es el número de la cara en sí. La parte inferior izquierda es el número de la cara, más 2, mod 6. La parte inferior derecha es 5 menos el número de la cara.

Aquí hay una explicación del código.

_4:2%6+``2+6%`-5+`
_4:                    take input and make several copies of it
   2%6+`               take face #, mod 2, add 6, and output
        `              output input, which already has the newline attached
         2+6%`         take face #, add 2, mod 6, and output
              -5+`     negate face #, add 5, and output

Aquí están las salidas para cada una de las caras:

0
60
25

1
71
34

2
62
43

3
73
52

4
64
01

5
75
10

Octava, 108 100 68 50 bytes

Por supuesto, hay una manera de hacerlo mucho más elegante que mis enfoques anteriores, simple codificación. Me sorprende cómo Octave es mucho más adecuado para codegolf que Matlab =)

f=@(n)['040201375767';'261345154623'](:,2*n+(1:2))

Diseño:

(Lo siento, olvidé agregar esto)

Diseño de cubo

  1-----5          1-----5          6-----7
 /|    /|         /  2  /|         /  5  /|
0-----4 |        0-----4 |        2-----3 |
| |   | |        |     |4|        |     |3|
| 3---|-7        |  0  | 7        |  1  | 5
|/    |/         |     |/         |     |/ 
2-----6          2-----6          0-----1  

Versiones antiguas:

f=@(n)[0 4 0 2 0 1 3 7 5 7 6 7;2 6 1 3 4 5 1 5 4 6 2 3](:,2*n+(1:2))

Incluso versiones anteriores:

Esto realmente va a hacer una matriz de 2x2x2 y luego elegir un 'corte'. Hacemos una permutación de matriz 3d y cada vez elegimos el corte superior o inferior. (Este no funciona en matlab debido a la indexación de una expresión en lugar de una matriz) Estoy seguro de que habría formas más directas de hacerlo que serían más cortas.

f=@(n)squeeze(permute(reshape(0:7,2,2,2),circshift((1:3)',n))(n=fix(n/3)+1,circshift((1:2)',n-1),:))

f=@(n)squeeze(permute(reshape(0:7,2,2,2),circshift((1:3)',n))(floor(n/3)+1,circshift((1:2)',floor(n/3)),:))

CJam, 31 28 (o 26) bytes

8,2/W%_1m<]z[D75K46]2/+ri=N*

que también se puede comprimir mediante la conversión de base en una versión de 26 bytes .

Asume que el cubo es como:

  7-----1
 /|    /|
5-----3 |
| |   | |
| 6---|-0
|/    |/
4-----2

con caras como

  7-----1      .-----.      .-----.      .-----.
 /  4  /|     /  4  /|     /  4  /|     /  0  /|
5-----3 |    .-----. |    .-----. |    .-----. |
|     |2|    |     |1|    |     |0|    |     |5|
|  1  | 0    |  0  | .    |  3  | .    |  3  | .
|     |/     |     |/     |     |/     |     |/ 
4-----2      .-----.      .-----.      .-----.    

Pruébalo en línea aquí

CJam (25 bytes)

"ñRXµ  roM~"(ib65b2/q~=N*

Contiene un carácter no imprimible y una pestaña (que será manipulada por el software StackExchange), por lo que en formato xxd:

0000000: 22f1 5258 1fb5 0972 6f4d 7e22 2869 6236  ".RX...roM~"(ib6
0000010: 3562 322f 717e 3d4e 2a                   5b2/q~=N*

Demostración en línea

Cubo:

  1-----0        Faces:
 /|    /|        10 46
4-----6 |        14 37
| |   | |        20 31
| 3---|-2        23 57
|/    |/         56 20
7-----5          57 64

Esto es pura codificación, con los vértices del cubo seleccionados para maximizar la compresibilidad base. Decodifico a números de 2 dígitos, por lo que ninguno de ellos puede comenzar con 0. Tampoco quiero que ninguno comience con 7, ya que eso empuja la segunda base demasiado alto. Por lo tanto, 0 y 7 deben estar en una diagonal larga. Quiero que un borde 10 vaya primero para reducir el valor que estoy codificando. Aparte de eso, hay una buena cantidad de flexibilidad sin cambiar el recuento de bytes.

Estoy un poco decepcionado de que después de haber sacado el primer personaje de la cadena mágica, es necesario lanzarlo a un int antes de usarlo como base para la conversión de base. Esperemos que las futuras versiones de CJam guarden ese byte, aunque será demasiado tarde para explotarlo aquí.

JavaScript (ES6), 53 62

Editar Guardar 8 bytes usando cadenas de plantilla, thx @NinjaBearMonkey. Cuidado, las nuevas líneas entre comillas son significativas y no se pueden contraer.

No puede ser inteligente en Javascript, es demasiado detallado.

f=n=>`01
23
45
67
01
31
5702
64`.substr(n-4?n*3:20,5)

Salida for(i=0;i<6;i++)console.log(f(i),i)

01
23
0

23
45
1

45
67
2

67
01
3

02
64
4

31
57
5

Vea el fragmento para verificar las asociaciones numéricas ( eso fue divertido)

function P3D(x,y,z) {
    this.x = x;this.y = y;this.z = z;
    this.rotateX = angle => {
        var rad = angle * Math.PI / 180,
        cosa = Math.cos(rad),sina = Math.sin(rad),
        y = this.y * cosa - this.z * sina,
        z = this.y * sina + this.z * cosa
        return new P3D(this.x, y, z)
    }
    this.rotateY = angle => {
        var rad = angle * Math.PI / 180,
        cosa = Math.cos(rad), sina = Math.sin(rad),
        z = this.z * cosa - this.x * sina,
        x = this.z * sina + this.x * cosa
        return new P3D(x,this.y, z)
    }
    this.rotateZ = angle => {
        var rad = angle * Math.PI / 180,
        cosa = Math.cos(rad), sina = Math.sin(rad),
        x = this.x * cosa - this.y * sina,
        y = this.x * sina + this.y * cosa
        return new P3D(x, y, this.z)
    }
    this.project = (viewWidth, viewHeight, fov, viewDistance) => {
        var factor = fov / (viewDistance + this.z),
        x = this.x * factor + viewWidth / 2,
        y = this.y * factor + viewHeight / 2
        return new P3D(x, y, this.z)
    }
}
 
var vx = [
    new P3D(-1,1,-1),
    new P3D(1,1,-1),
    new P3D(-1,-1,-1),
    new P3D(1,-1,-1),
    new P3D(-1,-1,1),
    new P3D(1,-1,1),
    new P3D(-1,1,1),
    new P3D(1,1,1),
];
// Define the vx that compose each of the 6 faces. These numbers are
// indices to the vertex list defined above.

var faces = [[0,1,3,2],[2,3,5,4],[4,5,7,6],[6,7,1,0],[0,2,4,6],[1,3,5,7]]

faces.map((f,i)=>{
    var mx=vx[f[0]].x+vx[f[1]].x+vx[f[2]].x+vx[f[3]].x,
    my=vx[f[0]].y+vx[f[1]].y+vx[f[2]].y+vx[f[3]].y,
    mz=vx[f[0]].z+vx[f[1]].z+vx[f[2]].z+vx[f[3]].z
    vx[i+10]=new P3D(mx/4, my/4, mz/4)
    f[4]=i
    f[5]=i+10
})

var angle = 0;

var ctx = CV.getContext("2d");

setInterval(loop,33)
 
function loop() {
    ctx.fillStyle = "#fff"
    ctx.fillRect(0,0,400,200);
    ctx.font = "20px Arial"
    angle += 2
    
    var t = vx.map(v=>
        v
        .rotateX(angle).rotateY(-angle).rotateZ(-angle)
        .project(400,200,128,3)
    )
    
  
    ctx.strokeStyle = "#f00"
    t.forEach((v,i)=>i<8?ctx.strokeText(i,v.x,v.y):0)

    ctx.strokeStyle = "#428"
    ctx.beginPath()
    faces.forEach(f=>(                         
        ctx.moveTo(t[f[0]].x,t[f[0]].y),
        ctx.lineTo(t[f[1]].x,t[f[1]].y),
        ctx.lineTo(t[f[2]].x,t[f[2]].y),
        ctx.lineTo(t[f[3]].x,t[f[3]].y),
        ctx.lineTo(t[f[0]].x,t[f[0]].y),
        ctx.strokeText(f[4],t[f[5]].x,t[f[5]].y)
    ))
    ctx.closePath(),
    ctx.stroke()
}

<canvas id=CV width=400 height=200></canvas>

Ruby Rev 1, 40 36

->(c){print(c^1,c,"\n",6|c,(c+3)%6)}

Gracias a @rcrmn por sugerir usar un lambda para guardar 4 bytes. No estaba seguro de dejarlo en el anonimato, pero parece que se discutió en meta aquí y decidí que estaba bien.

Aquí es como una función de 40 bytes, para comparar con mi respuesta Rev 0 Ruby, también a continuación (la respuesta original C está en una publicación separada).

def f(c)print(c^1,c,"\n",6|c,(c+3)%6)end

Más inspiración de Runer112: esto se basa en una modificación del esquema de numeración utilizado en su última respuesta (¡16 bytes!). Un puerto directo del esquema de PhiNotPi daría el mismo puntaje.

Al cambiar la numeración de Rev 0 alrededor de un paso, y tomando todo XOR 1, obtenemos el siguiente cubo:

4---7
|   |
| 1 |
|   |
1---0---7
|   |   |
| 0 | 3 |
|   |   |
6---3---2---7
    |   |   |
    | 2 | 5 |
    |   |   |
    6---5---4
        |   |
        | 4 |
        |   |
        6---1

Salida

0
10
63

1
01
74

2
32
65

3
23
70

4
54
61

5
45
72

Ruby Rev 0, 56 52 50

Guardado 4 bytes mediante la eliminación innecesaria ()%6de c-dy otro 2 (inspirado por runer112) por 6+c%2 --> 6|c.

La puntuación es para la función, que es solo la primera línea. Soy nuevo en Ruby y me sorprende no poder encontrar una forma más corta que 12 caracteres (11 más nueva línea) para obtener un número de entrada de usuario en n. Como resultado, hacer una función en lugar de un programa ahorra 1 byte.

def f(c)d=c%2*2-1;print((c+d)%6,c,"\n",c|6,c-d)end

n=gets.to_i
f(n)

Este es un puerto de mi respuesta C. En C, el %operador devuelve un valor negativo con un número negativo. En Ruby siempre devuelve un valor positivo, por lo que no es necesario agregar 1 a c. Como resultado, es ventajoso cambiar la numeración de las caras por 1 de la siguiente manera:

0---7
|   |
| 1 |
|   |
1---2---7 
|   |   |
| 2 | 3 |
|   |   |
6---3---4---7
    |   |   |
    | 4 | 5 |
    |   |   |
    6---5---0
        |   |
        | 0 |
        |   |
        6---1

Con la nueva numeración de caras, el programa imprime los pares como se muestra arriba y las probabilidades giran 180 grados:

1
21
70

2
12
63

3
43
72

4
34
65

5
05
74

0
50
61

Pyth, 30

Gracias @Jakube por 2 bytes.

Jc2jkfx>Q2!.&T^2%Q3U8jb?_J%Q2J

Pruébalo aquí

Se aceptarán gentilmente los consejos de golf de expertos en pyth. En particular, creo que la sección de salida podría tener algunas mejoras.

Puerto de la siguiente pitón: ...

Python, 109

Q=input()
s=''.join(map(str,filter(lambda v:(Q<3)^(v&(1<<Q%3)>0),range(8))))
print s[1-Q%2::2],'\n',s[Q%2::2]

... que es un puerto de

Pure Bash, 130

Para fines de explicación:

for v in {0..7};{
if(($1/3));then((v&(1<<$1%3)))&&a+=$v
else((v&(1<<$1%3)))||a+=$v
fi
}
i=$[$1%2*2]
echo "${a:i:2+i}
${a:2-i:4-i}"

Los vértices del cubo se numeran así:

  4-----5
 /|    /|
0-----1 |
| |   | |
| 6---|-7
|/    |/
2-----3

Y las caras están numeradas así:

Face  Vertices  Swap
   0  0,2,4,6
   1  0,1,4,5   x
   2  0,1,2,3
   3  1,3,5,7   x
   4  2,3,6,7
   5  4,5,6,7   x

La Swapcolumna indica que el orden de los vértices debe cambiarse en la salida.

El algoritmo comienza con todos los vértices {0..7}. Los vértices se eliminan según los bits establecidos en los números de vértice:

• Para las caras 0,1 y 2, los vértices con los bits 1,2 o 3 borrados respectivamente se mantienen
• Para las caras 3,4 y 5, los vértices con bits 1,2 o 3 establecidos respectivamente se mantienen

Los vértices "guardados" se agregan a una cadena. La cadena es caracteres de salida 0,1 y luego 2,3 o viceversa, dependiendo de si se establece la bandera de intercambio (número de cara mod 2).

J - 26 bytes

Función que toma el número de la cara como argumento y devuelve la cuadrícula de dígitos.

0{.@":"0@{0&(|:|.)&(i.3#2)

Estamos usando el siguiente cubo:

  4-----5    Face numbers:
 /|    /|     0 - front
0-----1 |     1 - top
| |   | |     2 - left
| 6---|-7     3 - back
|/    |/      4 - bottom
2-----3       5 - right

Ejemplo (pruébelo usted mismo en tryj.tk ):

   0{.@":"0@{0&(|:|.)&(i.3#2) 3         NB. inline
76
54
   f =: 0{.@":"0@{0&(|:|.)&(i.3#2)      NB. named
   f each 0 1 2 3 4 5                   NB. all results
+--+--+--+--+--+--+
|01|40|64|76|37|13|
|23|51|20|54|26|57|
+--+--+--+--+--+--+

El pan y la mantequilla es 0&(|:|.). Este es un verbo que invierte y gira el cubo de tal manera que visita cada cara cuando se aplica de forma iterativa, que es lo que hacemos usando el argumento de entrada. Los vértices del cubo son generados por i.3#2, así que lo usamos como punto de partida y tomamos la cara frontal 0...{cuando terminamos.

Imprimir los dígitos como una cadena cuesta 8 caracteres: {.@":"0@si se nos permitiera simplemente devolver una matriz, es un ahorro de 8 caracteres completos. [comienza a agitar los puños y al agarre indiscernible]

> <> (Pescado) , 38 bytes

'/ =/2= 28"H5'a@i-!
noan~\;
~>:?!^1-@~

Cada salida se almacena como dos filas de 2 dígitos. Las filas se almacenan como códigos de acceso en la cadena '/ =/2= 28"H'(excepto la fila 10que se agrega después de la cadena como a). El primer carácter ( / = 47) se usa para redirigir el flujo del programa en la segunda interacción.

Los 2*(53-n)elementos superiores se descartan (donde n es el código de acceso del número de entrada) y los siguientes dos códigos se imprimen con una nueva línea entre ellos.

Diseño:

  3-----2
 /|    /|
4-----7 |
| |   | |
| 5---|-0
|/    |/
6-----1      0 1 2 3 4 5 sides are top front bottom back left right respectively.