Atribua os números de 0 a 7 aos 8 vértices de um cubo da maneira que desejar. Exatamente um número deve ser atribuído a cada vértice.

Por exemplo, seus vértices podem ser atribuídos assim:

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

Escreva um programa que inclua um número inteiro de 0 a 5. Cada um desses 6 números está associado a exatamente uma face do seu cubo da maneira que desejar. Quando um desses números é inserido, os 4 números de vértices da face associada devem ser impressos em stdout em um quadrado de 2 × 2 dígitos. O rosto deve ser visto diretamente de fora do cubo. Todas as 4 rotações da face são válidas.

Por exemplo, se 0 estiver associado à face frontal do cubo de exemplo acima, isso seria uma saída válida para entrada 0:

42
67

A face pode ser vista a qualquer rotação de 90 °, portanto, estas também são válidas:

27
46

76
24

64
72

Esta saída (e suas rotações) não são válidas , pois são visualizadas do lado errado da face:

24
76

A mesma idéia se aplica a todas as outras faces. por exemplo, se 1 estiver associado à face traseira, a entrada 1poderá produzir saída 13[newline]05(e 31[newline]50seria inválida).

Portanto, o verdadeiro desafio é escolher seus números e rotações de vértices, de modo que a conversão da entrada em seus quatro números seja fácil e curta.

O código mais curto em bytes vence. O desempatador é um post anterior. ( Contador de bytes acessíveis ) .

Notas

• Você pode escrever uma função em vez de um programa. Ele deve levar um número inteiro de 0 a 5 e imprimir ou retornar a cadeia de grade de 2 × 2 dígitos.
• Obtenha entrada de stdin, linha de comando ou função arg. Você pode assumir que a entrada é válida.
• A saída pode opcionalmente ter uma nova linha à direita.
• Não deixe de nos dizer o número do vértice e do rosto que você escolheu.

CJam, 23 16 bytes

Provavelmente existe uma solução matemática elegante para esse problema. Mas eu não tenho idéia de como encontrar um, então é um código super compactado!

Eu encontrei um! Bem, não é uma solução matemática classicamente elegante, pois usa operações bit a bit, mas é totalmente fórmula.

li_o1^_p_6|o3+6%

Experimente online.

Layout do 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  

Explicação

Minha resposta antiga já expôs o cubo de forma que cada face possa ser descrita com seu primeiro número de vértice (canto superior esquerdo) igual ao número da face. Mas eu queria poder calcular mais números de vértices usando o número da face. Em algum momento, tive a idéia de colocar meu pé na porta, para calcular o segundo número de vértice (canto superior esquerdo) como o número de face XOR 1. E depois de um tempo de tentativa e erro, consegui surgir com o layout mostrado acima e as fórmulas abaixo que permitem calcular de forma sucinta todos os números de vértices de um rosto n:

• Superior esquerdo: n
• Canto superior direito: n^1
• Inferior esquerdo: (n^1)|6
• Canto inferior direito: ((n^1)+3)%6

Para referência, reproduzirei a saída de cada face no layout desejado aqui:

Face:      0     1     2     3     4     5

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

Portanto, todo o programa se resume a ler o número da face de entrada e produzir esses valores em ordem, embora com uma lógica de impressão ligeiramente diferente para vértices diferentes. Observe que, como todo vértice após o primeiro começa com uma base de n^1, eu só preciso calcular isso uma vez, o que compacta a lógica ainda mais.

Pelo bem da posteridade, e porque acho que ainda era uma abordagem muito boa, aqui está minha antiga resposta.

CJam, 23 bytes

Provavelmente existe uma solução matemática elegante para esse problema. Mas eu não tenho idéia de como encontrar um, então é um código super compactado!

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

Experimente online.

Layout do 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  

Explicação

A abordagem básica empregada é codificar os vértices para cada face no menor espaço possível. De maneira semelhante à solução de conversão básica do Optimizer, isso trata a lista de vértices como um número octal compactado como dados de caracteres ASCII. Mas é aí que as semelhanças terminam para abrir caminho para novas otimizações!

Aqui estão as três principais otimizações que fiz para a solução "ingênua":

• Disponha o cubo de forma que cada face possa ser descrita com seu número de face como o primeiro número de vértice. Observando meu layout de cubo, como apresentado acima, é possível ver que o número do vértice no canto superior esquerdo de cada face é igual ao número da face. Isso me permite codificar seis menos vértices ao custo de imprimir a entrada novamente, o que acaba salvando um byte.
• Empacote os dados do vértice em uma cadeia de caracteres para a qual cada "caractere" tenha um máximo maior que 256. Como esse máximo aumenta além de 256, o comprimento da cadeia diminui lentamente, mas torna-se cada vez mais provável que qualquer "caractere" exceda 256 e é portanto, não faz mais parte do conjunto de caracteres ASCII de 1 byte. Então, escrevi um programa que tenta codificar os dados de vértices em todas as bases, de 256 a 1000, com os quais encontrei cerca de 10 bases que salvam um byte de dados de caracteres em comparação com a base 256. Escolhi 487, pois também possui a propriedade nice a sequência resultante consiste inteiramente em ASCII imprimível.
• Misturado com a primeira otimização, produza a saída assimetricamente. A abordagem usual no CJam seria formatar os dados do vértice como uma lista de 2 elementos, inserir uma nova linha no meio e deixar a saída ser impressa implicitamente. Mas, em vez disso, imprimo o primeiro vértice (igual ao número da face de entrada) com um operador que não adiciona uma nova linha, recupero a lista de 3 elementos dos outros vértices, agarro o próximo vértice e imprimo-o com um operador que adiciona uma nova linha e deixe que os outros dois vértices sejam impressos implicitamente. Isso economiza um 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);}

Ungolfed in program program

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);
}

Explicação

Minha numeração de cubo, quando desdobrada, fica assim:

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

O canto superior esquerdo tem o mesmo número que o rosto.

O canto inferior direito tem o número (n+2)%6

Para ímpar, no canto superior direito é (n+1)%6e o canto inferior esquerdo é6

Até mesmo no canto superior direito é 7e o canto inferior esquerdo é(n+1)%6

O programa exibe os números ímpares, como mostrado, e os números pares, girados 180 graus. Isso significa que o canto superior direito é sempre (n+1)%6e o canto inferior esquerdo é sempre (n+1)%2+6. Inverter ne n+2é mais fácil (isso é feito configurando c=n+1e usando dpara adicionar ou subtrair 1ou -1conforme necessário.)

Resultado

$ ./a
0
21
70

$ ./a
1
12
63

$ ./a
2
43
72

$ ./a
3
34
65

$ ./a
4
05
74

$ ./a
5
50
61

Element, 18

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

Diferentemente de muitas linguagens de golfe mais avançadas, a Element não possui um operador de compactação, portanto a brevidade da solução está intimamente ligada ao esquema de numeração exato usado. Após algumas experiências, criei um novo esquema de numeração que permite que os vértices sejam computados usando apenas operações 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  

O canto superior esquerdo é 6 se for par e 7 se for ímpar. O canto superior direito é o próprio número da face. O canto inferior esquerdo é o número da face, mais 2, mod 6. O canto inferior direito é 5 menos o número da face.

Aqui está uma explicação do 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

Aqui estão as saídas para cada uma das faces:

0
60
25

1
71
34

2
62
43

3
73
52

4
64
01

5
75
10

Oitava, 108 100 68 50 bytes

É claro que existe uma maneira de fazê-lo de maneira muito mais elegante do que minhas abordagens anteriores, simples codificação. Estou surpreso como o Octave é muito mais adequado para codegolf do que o Matlab =)

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

Layout:

(Desculpe, esqueci de adicionar isso.)

Layout do 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  

Versões antigas:

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

Versões ainda mais antigas:

Isso realmente criará uma matriz 2x2x2 e depois escolherá uma 'fatia'. Fazemos uma permutação de matriz 3d e sempre escolhemos a fatia superior ou inferior. (Este não funciona no matlab por causa da indexação de uma expressão, e não de uma matriz). Tenho certeza de que haveria maneiras mais diretas de fazê-lo, que seriam mais curtas.

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 (ou 26) bytes

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

que também pode ser compactado usando a conversão base em uma versão de 26 bytes .

Assume que o cubo seja como:

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

com rostos como

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

Experimente online aqui

CJam (25 bytes)

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

Ele contém um caractere não imprimível e uma guia (que será confinada pelo software StackExchange), portanto no formato xxd:

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

Demonstração online

Cubo:

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

É pura codificação, com os vértices do cubo selecionados para maximizar a compressibilidade da base. Decodifico para números de 2 dígitos, para que nenhum deles comece com 0. Também não quero que comece com 7, pois isso eleva a segunda base muito alto. Portanto, 0 e 7 devem estar em uma diagonal longa. Quero que uma borda 10 seja a primeira a reduzir o valor que estou codificando. Fora isso, há uma boa quantidade de flexibilidade sem alterar a contagem de bytes.

Estou um pouco decepcionado por ter retirado o primeiro caractere da sequência mágica, é necessário convertê-lo em um int antes de usá-lo como base para a conversão de base. Esperamos que versões futuras do CJam salvem esse byte, embora seja tarde demais para explorá-lo aqui.

JavaScript (ES6), 53 62

Editar Salve 8 bytes usando seqüências de caracteres de modelo, thx @NinjaBearMonkey. Cuidado, as novas linhas entre aspas são significativas e não podem ser recolhidas.

Não pode ser inteligente em Javascript, é muito detalhado.

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

Resultado 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

Veja o snippet para veicular as associações numéricas ( isso foi 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>

Rubi Rev 1, 40 36

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

Obrigado a @rcrmn por sugerir o uso de um lambda para economizar 4 bytes. Eu não tinha certeza de deixá-lo anônimo, mas parece ter sido discutido na meta aqui e decidido que isso estava OK.

Aqui está como uma função de 40 bytes, para comparação com a minha resposta Rev 0 Ruby, também abaixo (a resposta C original está em um post separado.)

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

Mais inspiração do Runer112: Isso depende de uma modificação do esquema de numeração usado em sua resposta mais recente (16 bytes!). Uma porta direta do esquema do PhiNotPi daria a mesma pontuação.

Alterando a numeração do Rev 0 em uma etapa e executando tudo o XOR 1, obtemos o seguinte cubo:

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

Resultado

0
10
63

1
01
74

2
32
65

3
23
70

4
54
61

5
45
72

Ruby Rev 0, 56 52 50

Salvo 4 bytes por remoção unnecesary ()%6do c-de outro 2 (inspirado runer112) por 6+c%2 --> 6|c.

A pontuação é para a função, que é apenas a primeira linha. Sou novo em Ruby e estou surpreso por não encontrar uma maneira menor que 12 caracteres (11 mais nova linha) para inserir um número de entrada do usuário em n. Como resultado, executar uma função em vez de um programa economiza 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)

Esta é uma porta da minha resposta C. Em C, o %operador retorna um valor negativo com um número negativo. No Ruby, ele sempre retorna um valor positivo; portanto, não há necessidade de adicionar 1 a c. Como resultado, é vantajoso alterar a numeração das faces por 1, conforme abaixo:

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

Com a nova numeração de faces, o programa imprime os pares, como mostrado acima, e as chances rodam 180 graus:

1
21
70

2
12
63

3
43
72

4
34
65

5
05
74

0
50
61

Pyth, 30

Obrigado @Jakube por 2 bytes.

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

Experimente aqui.

Os conselhos de especialistas em golfe serão gentilmente aceitos. Em particular, acho que a seção de saída pode ter algumas melhorias.

Porta do seguinte python: ...

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 é um porto de

Pure Bash, 130

Para fins de explicação:

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}"

Os vértices do cubo são numerados assim:

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

E os rostos são numerados assim:

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

A Swapcoluna indica que a ordem dos vértices deve ser alternada na saída.

O algoritmo começa com todos os vértices {0..7}. Os vértices são eliminados de acordo com os bits definidos nos números dos vértices:

• Para as faces 0,1 e 2, os vértices com os bits 1,2 ou 3 limpos respectivamente são mantidos
• Para as faces 3,4 e 5, os vértices com os bits 1,2 ou 3 definidos respectivamente são mantidos

Os vértices "mantidos" são anexados a uma sequência. A string é caracteres de saída 0,1 e 2,3 ou vice-versa, dependendo se o sinalizador de troca (número da face mod 2) está definido.

J - 26 bytes

Função tomando o número da face como argumento e retornando a grade de dígitos.

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

Estamos usando o seguinte cubo:

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

Exemplo (tente você mesmo em 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|
+--+--+--+--+--+--+

O pão com manteiga é 0&(|:|.). Este é um verbo que inverte e gira o cubo de forma a visitar todas as faces quando aplicadas iterativamente, que é o que fazemos usando o argumento de entrada. Os vértices do cubo são gerados por i.3#2, portanto, usamos isso como ponto de partida e assumimos a face frontal 0...{quando terminamos.

Imprimir os dígitos como uma string custa 8 caracteres: {.@":"0@se pudéssemos simplesmente devolver uma matriz, isso economizaria 8 caracteres inteiros. [começa a tremer os punhos e o aperto indiscernível]

> <> (Peixe) , 38 bytes

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

Cada saída é armazenada como duas linhas de 2 dígitos. As linhas são armazenadas como códigos na string '/ =/2= 28"H'(exceto a linha 10que é anexada após a string comoa ). O primeiro caractere ( / = 47) é usado para redirecionar o fluxo do programa na segunda interação.

O topo 2*(53-n) elementos são descartados (onde n é o código do número de entrada) e os próximos dois códigos são impressos com uma nova linha no meio.

Layout:

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