您可以根据需要将数字0到7分配给多维数据集的8个顶点。必须为每个顶点分配一个确切的数字。

例如，您的顶点可能像这样分配：

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

编写一个使用0到5之间的整数的程序。这6个数字中的每个数字都以您喜欢的任何方式与立方体的一个面相关联。输入这些数字之一时，必须将相关面的4个顶点数字以2×2平方的数字打印到标准输出。该面应从立方体外部直接观看。所有4个面旋转都是有效的。

例如，如果0与上面的示例多维数据集的正面相关联，则这将是input的有效输出0：

42
67

可以在任何90°旋转角度下观看人脸，因此这些也是有效的：

27
46

76
24

64
72

此输出（及其旋转）无效，因为它们是从人脸的错误侧面看的：

24
76

同样的想法也适用于所有其他面孔。例如，如果1与背面相关联，则输入1可能会产生输出13[newline]05（并且31[newline]50将是无效的）。

因此，真正的挑战是选择顶点数和旋转度，以便将输入转换为其4个顶点数既简单又简短。

以字节为单位的最短代码获胜。Tiebreaker是较早的帖子。（方便的字节计数器。）

笔记

• 您可以编写函数而不是程序。它应该是0到5之间的整数，并打印或返回2×2位数的网格字符串。
• 从标准输入，命令行或函数arg中获取输入。您可以假设输入有效。
• 输出可以选择包含尾随换行符。
• 请务必告诉我们您选择的顶点和面数。

CJam，23个16字节

对于这个问题可能有一个优雅的数学解决方案。但是我不知道如何找到一个，所以它是超级压缩硬编码！

我找到一个！嗯，这不是经典的优雅数学解决方案，因为它使用按位运算，但完全是公式化的。

li_o1^_p_6|o3+6%

在线尝试。

立方体布局

  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  

说明

我以前的答案已经安排好了立方体，以便可以用等于该面号的第一个（左上）顶点号描述每个面。但是我希望能够使用面数来计算更多的顶点数。在某个时候，我想出了一个主意，将第二个（左上）顶点数计算为面数XOR1。经过反复试验，我设法上了楼。上面显示的布局和下面的公式使我能够非常简洁地计算面的每个顶点数n：

• 左上方： n
• 右上： n^1
• 左下方： (n^1)|6
• 右下： ((n^1)+3)%6

作为参考，我将在此处按所需布局重现每个面孔的输出：

Face:      0     1     2     3     4     5

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

因此，尽管对于不同的顶点，打印逻辑略有不同，但整个程序只能读取输入的面数并按顺序生成这些值。请注意，因为第一个顶点之后的每个顶点都以的底数开始n^1，所以我只需要计算一次，就可以进一步压缩逻辑。

为了后代的缘故，并且因为我认为这仍然是一个很好的方法，所以这是我的旧答案。

CJam，23个字节

对于这个问题可能有一个优雅的数学解决方案。但是我不知道如何找到一个，所以它是超级压缩硬编码！

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

在线尝试。

立方体布局

  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  

说明

所采用的基本方法是在尽可能小的空间内对每个面的顶点进行硬编码。与Optimizer的基本转换解决方案类似，此操作将顶点列表视为打包为ASCII字符数据的八进制数。但这就是相似之处结束的地方，以便进一步优化！

这是我对“天真”解决方案所做的三个关键优化：

• 布置多维数据集，以便可以使用其面号作为第一个顶点号来描述每个面。查看上面显示的我的多维数据集布局，可以看到每个面的左上角顶点号等于面号。这使我可以减少六个顶点的编码，而必须将输入打印回去，从而节省了一个字节。
• 将顶点数据打包到一个字符串中，每个“字符”的最大值都大于256。随着该最大值增加到256以上，字符串的长度会缓慢减小，但是任何一个“字符”都超过256且变得越来越大的可能性就越来越大。因此，不再是1字节ASCII字符集的一部分。因此，我编写了一个程序，尝试对从256到1000的每个基数中的顶点数据进行编码，与之相比，我发现大约10个基数与256基数相比节省了一个字节的字符数据。我选择487，因为它还具有以下优点：结果字符串完全由可打印的ASCII组成。
• 与第一个优化混合，不对称地产生输出。CJam中通常的方法是将顶点数据格式化为2元素列表的2元素列表，在中间插入换行符，然后隐式打印输出。但是我改为使用不添加换行符的运算符打印第一个顶点（等于输入面号），检索其他顶点的3元素列表，获取下一个顶点，然后使用确实添加了一个运算符的操作符进行打印换行，然后隐式打印其他两个顶点。这样可以节省一个字节。

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

取消测试程序

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

说明

展开后，我的多维数据集编号如下所示：

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

左上角的编号与脸部相同。

右下角有数字 (n+2)%6

对于奇数n，右上角是(n+1)%6，左下角是6

即使n是右上角是7，而左下角是(n+1)%6

程序显示如图所示的奇数，并将偶数旋转180度。这意味着右上角始终是，左下角始终(n+1)%6是(n+1)%2+6。反转n并且n+2更容易（通过设置c=n+1并使用d加法或减法1或-1根据需要来完成）。

输出量

$ ./a
0
21
70

$ ./a
1
12
63

$ ./a
2
43
72

$ ./a
3
34
65

$ ./a
4
05
74

$ ./a
5
50
61

元素18

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

与许多更高级的高尔夫语言不同，Element没有压缩运算符，因此解决方案的简洁性与所使用的精确编号方案紧密相关。经过一些试验，我创建了一个新的编号方案，该方案仅使用简单的算术运算即可计算顶点。

  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  

左上角为6（偶数）和7（奇数）。右上角是面部编号本身。左下角是面部编号，加上2，模数6。右下角是5减去面部编号。

这是代码的说明。

_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

这是每个面孔的输出：

0
60
25

1
71
34

2
62
43

3
73
52

4
64
01

5
75
10

倍频程108 100 68 50字节

当然，这是一种比我以前的纯硬编码方式更优雅的方式。我很惊讶Octave比Matlab更适合Codegolf =）

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

布局：

（对不起，我忘了添加。）

立方体布局

  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  

旧版本：

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

甚至旧版本：

这真的是要制作一个2x2x2数组，然后选择一个“切片”。我们进行3D矩阵排列，每次选择顶部或底部切片。（由于在表达式中而不是在矩阵中建立索引，因此该方法在matlab中不起作用）我敢肯定会有更直接的方法可以使它更短。

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（或26）字节

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

也可以使用基本转换将其压缩为26字节的版本。

假设多维数据集如下所示：

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

像

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

在这里在线尝试

CJam（25字节）

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

它包含一个不可打印的字符和一个选项卡（将由StackExchange软件处理），因此为xxd格式：

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

在线演示

立方体：

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

这是纯粹的硬编码，选择了立方顶点以最大化基础可压缩性。我解码为2位数字，所以它们都不能以0开头。我也不希望任何一个都以7开头，因为这会使第二个底数过高。因此，0和7必须在长对角线上。我想先减少10个边缘以减少编码的值。除此之外，在不更改字节数的情况下具有相当大的灵活性。

我有点失望的是，从魔术字符串中弹出了第一个字符之后，有必要在将其用作基础转换的基础之前将其转换为int。希望将来的CJam版本可以保存该字节，尽管现在在这里利用该字节为时已晚。

JavaScript（ES6），53 62

使用模板字符串thx @NinjaBearMonkey 编辑“保存8个字节”。当心，引号内的换行符很重要，不能折叠。

用Java语言不能太聪明，太冗长了。

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

输出量 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

查看代码段以验证数字关联（这很有趣）

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第1版 1，40 36

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

感谢@rcrmn建议使用lambda保存4个字节。我不知道离开它匿名，但它似乎在元被讨论这里决定，这是确定。

这是一个40字节的函数，用于与下面的我的Rev 0 Ruby答案进行比较（原始C答案在另一篇文章中。）

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

Runer112的进一步启示：这依赖于他最新的答案（16字节！）中使用的编号方案的修改。直接移植PhiNotPi的方案将得到相同的分数。

通过将版本0的编号移动一级，然后对所有内容进行XOR 1，我们得到以下多维数据集：

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

输出量

0
10
63

1
01
74

2
32
65

3
23
70

4
54
61

5
45
72

Ruby版本0、56 52 50

通过去除unnecesary保存4个字节()%6从c-d与另一个2（由runer112启发）通过6+c%2 --> 6|c。

分数是针对该功能的，仅是第一行。我是Ruby的新手，我很惊讶我找不到比12个字符（11个加换行符）短的方式来将用户输入数字输入n。结果，执行功能而不是程序可以节省1个字节。

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)

这是我的C答案的端口。在C中，%运算符返回带有负数的负值。在Ruby中，它总是返回一个正值，因此无需在上加1 c。因此，如下将面的编号移位1是有利的：

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

使用新的面部编号，程序将打印出偶数，如上图所示，并且赔率旋转了180度：

1
21
70

2
12
63

3
43
72

4
34
65

5
05
74

0
50
61

珀斯，30岁

感谢@Jakube 2个字节。

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

在这里尝试。

pyth专家的高尔夫建议将被接受。我特别认为输出部分可能会有一些改进。

以下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]

...是

纯重打击130

为了说明的目的：

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

立方体顶点的编号如下：

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

面部编号如下：

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

的 Swap列指示应在输出中切换顶点的顺序。

该算法从所有顶点{0..7}开始。根据顶点编号中设置的位消除顶点：

• 对于面0,1和2，保留分别清除了位1,2或3的顶点
• 对于面3,4和5，保留分别设置了位1,2或3的顶点

“保留的”顶点将附加到字符串。根据是否设置了交换标志（面号为mod 2），字符串的输出字符为0，1，然后为2，3，反之亦然。

J-26个字节

以面号为参数并返回数字网格的函数。

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

我们正在使用以下多维数据集：

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

示例（在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|
+--+--+--+--+--+--+

面包和黄油是0&(|:|.)。这是一个动词，它使多维数据集反转和旋转，以使得在迭代应用时可以访问每个面孔，这就是我们使用输入参数进行的操作。立方体的顶点由生成i.3#2，因此我们将其用作起点，并取正面0...{在完成后。

将数字打印为字符串需要花费8个字符：{.@":"0@如果允许我们简单地返回一个数组，则可以节省8个完整字符。[开始握拳和听不清]

> <>（鱼），38字节

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

每个输出都存储为两个两位数的行。这些行以字符代码形式存储在字符串中'/ =/2= 28"H'（行10末尾附加为的行除外a）。第一个字符（/ = 47）用于在第二次交互时重定向程序流。

顶端 2*(53-n)元素被舍弃（其中n是输入数字的字符代码），接下来的两个代码之间用换行符打印。

布局：

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