19

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ó.

code-golf geometry Pasatiempos de Calvin
fuente

17

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.

Runer112
fuente

2

Intenté las permutaciones como un enfoque matemático elegante y es más detallado que la codificación sin sus optimizaciones.

Peter Taylor

Tu última respuesta es brillante. Creo que debería haberlo publicado como una respuesta separada, ya que es un enfoque completamente diferente y merece otro voto positivo. Básicamente tienes el mismo cubo que mi respuesta C pero con las primeras tres esquinas iguales cambió de lugar. No puedo creer que me haya perdido 6+n%2 --> 6|n(ya lo he incorporado a mi respuesta de Ruby). Tenga en cuenta que al realizar la transformación n --> n^1en las caras, podría simplificar sus fórmulas, aunque supongo que a medida que descarta ny continúa n^1ganando No ayudo a su puntaje.

Level River St

@steveverrill Gracias por los elogios! Pregunté en el chat si debería publicar esto como una respuesta completamente nueva, pero no hubo consenso, así que no lo hice. Definitivamente estaba satisfecho conmigo mismo cuando me di cuenta de que ordenar cuidadosamente los pares ny n^1alrededor del cubo me permitiría calcular otro vértice con solo |6. Y no vi esa n --> n^1transformación, lo que definitivamente tiene sentido. Pero usted supuso correctamente que en realidad no afectaría mi puntaje, por lo que probablemente lo dejaré tal como está.

Runer112

Seguí adelante e incorporé tu idea XOR en mi respuesta de Ruby. Da un ahorro de 10 (además de los 2 para 6+n%2 --> 6|n) Espero que no te importe. Utilicé la n --> n^1transformación en las caras, por lo que mi última revisión ofrece los mismos resultados que la suya, pero con diferentes entradas. Por cierto, no creo que las operaciones de bits sean poco elegantes, ¡todo depende de cómo las uses!

Level River St

1

1 char más corto en GolfScript:~.1^..n@6|@3+6%

Peter Taylor

14

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

Level River St
fuente

55

+1 Este es el tipo de solución matemática elegante que estaba imaginando. Desafortunadamente, se implementa en C ...

Runer112

1

@ Runer112 Gracias. Desafortunadamente, C es el lenguaje que mejor conozco. Estoy aprendiendo Ruby pero todavía soy un principiante. Ruby debería poder aplastar este puntaje, pero probablemente no competir con Cjam. Tal vez voy a publicar en Ruby después, o simplemente encontrar algunas pequeñas mejoras en mi C respuesta (por ejemplo, cambiando c%6a c%=6y girando la cara por lo que ocurra primero, debería ser posible eliminar algunos cálculos de módulo.) Otra cosa a experimentar con IS desplazando el etiquetado de la cara por un lugar, así que obtengo en n-1,n,n+1lugar de n,n+1,n+2.

Level River St

@steveverrill ya está declarando nglobal, por lo que podría guardar unos pocos bytes declarándolo más alto, cambie la firma a f()? ¿O solo estamos viendo la ffunción aquí?

dwcanillas

@dwcanillas, "You may write a function instead of a program"así que solo estoy contando la función. En cualquier caso, esto fue solo una prueba de concepto en el lenguaje con el que estoy más familiarizado. Estoy más interesado en acortar mi respuesta de Ruby, que desde el principio ya era mucho más corta que esta.

Level River St

8

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:

PhiNotPi
fuente

+1: Aunque considero que su código es indescifrable, es bueno ver cómo esto puntúa en un lenguaje de golf. Parece que actualmente estás en el tercer lugar conjunto, detrás de 2 respuestas de CJam: Peter Taylor y Runer 112.

Level River St

Ahora está en un segundo lugar sólido, pero no preveo que gane a CJam.

PhiNotPi

6

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)),:))

falla
fuente

5

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í

Optimizador
fuente

4

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í.

Peter Taylor
fuente

4

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)

Mostrar fragmento de código

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>

Expandir fragmento

edc65
fuente

1

Si usa cadenas de plantilla ES6 , puede usar caracteres de nueva línea reales en lugar de \n, lo que debería ahorrar 8 bytes.

NinjaBearMonkey

Debe usar marcas de graduación `en lugar de comillas para las cadenas de plantilla.

NinjaBearMonkey

Correcto, así es como lo probé de hecho.

edc65

4

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

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:

Level River St
fuente

Creo que puede acortar la función usando lambdas: lo ->(x){...code...}que deja la definición de su función 4 caracteres más corta. Luego debe asignarlo a una variable para usarlo, y llamarlo con #call

rorlork

@rcrmn gracias, tienes razón, f=->(c){print(c^1,c,"\n",6|c,(c+3)%6)}corre y es 2 caracteres más corto (4 caracteres más corto si omito el f=). No estoy seguro de si es justo omitirlo, f=pero la pregunta no dice que la función no puede ser anónima. Lo que me parece extraño es que esta sintaxis es totalmente diferente de la sintaxis que se muestra a los principiantes, que tiene el parámetro pasado dentro de las llaves:f=lambda{|c|print(c^1,c,"\n",6|c,(c+3)%6)}

Level River St

Esto es lo que se llama un lambda literal. Y, de hecho, siempre me resulta difícil encontrar una referencia cuando necesito recordar la sintaxis ...

rorlork

3

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).

Trauma digital
fuente

1

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]

Algoritmo de tiburón
fuente

Los resultados para 1, 4 y 5 parecen estar invertidos

Digital Trauma

0

> <> (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.

randomra
fuente

Salida de una cara en un cubo numerado

Notas

Respuestas:

CJam, 23 16 bytes

Diseño de cubo

Explicación

CJam, 23 bytes

Diseño de cubo

Explicación

C, 69

Elemento, 18

Octava, 108 100 68 50 bytes

Diseño:

Diseño de cubo

Versiones antiguas:

CJam, 31 28 (o 26) bytes

CJam (25 bytes)

JavaScript (ES6), 53 62

Ruby Rev 1, 40 36

Ruby Rev 0, 56 52 50

Pyth, 30

Python, 109

Pure Bash, 130

J - 26 bytes

> <> (Pescado) , 38 bytes