Gán các số từ 0 đến 7 cho 8 đỉnh của một khối theo bất kỳ cách nào bạn muốn. Chính xác một số phải được gán cho mỗi đỉnh.

Ví dụ: các đỉnh của bạn có thể được chỉ định như thế này:

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

Viết chương trình lấy số nguyên từ 0 đến 5. Mỗi 6 số này được liên kết với chính xác một mặt của khối lập phương của bạn theo bất kỳ cách nào bạn muốn. Khi một trong những số này là đầu vào, 4 số đỉnh của mặt được liên kết phải được in ra thiết bị xuất chuẩn trong một hình vuông 2 × 2 chữ số. Khuôn mặt sẽ được nhìn thẳng từ bên ngoài khối lập phương. Tất cả 4 xoay mặt là hợp lệ.

Ví dụ: nếu 0 được liên kết với mặt trước của khối ví dụ ở trên, thì đây sẽ là đầu ra hợp lệ cho đầu vào 0:

42
67

Khuôn mặt có thể được xem ở bất kỳ góc quay 90 ° nào, vì vậy những khuôn mặt này cũng hợp lệ:

27
46

76
24

64
72

Đầu ra này (và các phép quay của nó) không hợp lệ , vì chúng được nhìn từ phía sai của khuôn mặt:

24
76

Ý tưởng tương tự áp dụng cho tất cả các khuôn mặt khác. ví dụ: nếu 1 được liên kết với mặt sau, thì đầu vào 1có thể tạo ra đầu ra 13[newline]05(và 31[newline]50sẽ không hợp lệ).

Vì vậy, thách thức thực sự là chọn số đỉnh và phép quay của bạn sao cho việc dịch đầu vào thành 4 số đỉnh của nó rất dễ dàng và ngắn.

Mã ngắn nhất tính bằng byte thắng. Tiebreaker là bài trước. ( Bộ đếm byte tiện dụng. )

Ghi chú

• Bạn có thể viết một hàm thay vì một chương trình. Nó sẽ lấy một số nguyên từ 0 đến 5 và in hoặc trả về chuỗi lưới 2 × 2 chữ số.
• Lấy đầu vào từ stdin, dòng lệnh hoặc hàm arg. Bạn có thể cho rằng đầu vào là hợp lệ.
• Đầu ra có thể tùy chọn có một dòng mới.
• Hãy chắc chắn cho chúng tôi biết số đỉnh và số mặt bạn đã chọn.

CJam, 23 16 byte

Có lẽ có một giải pháp toán học tao nhã cho vấn đề này. Nhưng tôi không biết làm thế nào để tìm một cái, vì vậy nó siêu mã hóa cứng!

Tôi tìm thấy một! Chà, nó không phải là một giải pháp toán học thanh lịch cổ điển vì nó sử dụng các phép toán bitwise, nhưng nó hoàn toàn có công thức.

li_o1^_p_6|o3+6%

Hãy thử trực tuyến.

Bố trí khối

  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  

Giải trình

Câu trả lời cũ của tôi đã đặt ra khối lập phương sao cho mỗi mặt có thể được mô tả bằng số đỉnh đầu tiên (trên cùng bên trái) bằng số mặt. Nhưng tôi muốn có thể tính toán nhiều số đỉnh hơn bằng cách sử dụng số mặt. Vào một lúc nào đó, tôi nảy ra ý tưởng đưa chân vào cửa, để tính số đỉnh thứ hai (trên cùng bên trái) là số mặt XOR 1. Và sau một thời gian dùng thử và lỗi, tôi đã tìm được với bố cục được hiển thị ở trên và các công thức dưới đây cho phép tôi tính toán mọi số đỉnh cho một khuôn mặt nkhá ngắn gọn:

• Trên cùng bên trái: n
• Trên cùng bên phải: n^1
• Dưới cùng bên trái: (n^1)|6
• Góc phải ở phía dưới: ((n^1)+3)%6

Để tham khảo, tôi sẽ tái tạo đầu ra cho mỗi mặt theo bố cục mong muốn ở đây:

Face:      0     1     2     3     4     5

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

Vì vậy, toàn bộ chương trình chỉ cần đọc số mặt đầu vào và tạo ra các giá trị này theo thứ tự, mặc dù với logic in hơi khác nhau cho các đỉnh khác nhau. Lưu ý rằng, bởi vì mọi đỉnh sau lần đầu tiên bắt đầu bằng một cơ sở n^1, tôi chỉ cần tính toán một lần, điều này sẽ thu gọn logic hơn nữa.

Vì lợi ích của hậu thế, và vì tôi nghĩ đó vẫn là một cách tiếp cận khá hay, đây là câu trả lời cũ của tôi.

CJam, 23 byte

Có lẽ có một giải pháp toán học tao nhã cho vấn đề này. Nhưng tôi không biết làm thế nào để tìm một cái, vì vậy nó siêu mã hóa cứng!

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

Hãy thử trực tuyến.

Bố trí khối

  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  

Giải trình

Cách tiếp cận cơ bản được sử dụng là mã hóa các đỉnh cho mỗi mặt trong càng ít không gian càng tốt. Tương tự như giải pháp chuyển đổi cơ sở của Trình tối ưu hóa, điều này coi danh sách đỉnh là số bát phân được đóng gói dưới dạng dữ liệu ký tự ASCII. Nhưng đó là về nơi tương tự kết thúc để nhường chỗ cho tối ưu hóa hơn nữa!

Dưới đây là ba tối ưu hóa chính mà tôi đã thực hiện cho giải pháp "ngây thơ":

• Bố trí khối lập phương sao cho mỗi mặt có thể được mô tả với số mặt của nó là số đỉnh đầu tiên. Nhìn vào bố cục khối của tôi như được trình bày ở trên, người ta có thể thấy rằng số đỉnh trên cùng bên trái của mỗi mặt bằng với số mặt. Điều này cho phép tôi mã hóa sáu đỉnh ít hơn với chi phí phải in lại đầu vào, hóa ra là để tiết kiệm một byte.
• Đóng gói dữ liệu đỉnh vào một chuỗi mà mỗi "ký tự" có giá trị lớn nhất lớn hơn 256. Khi mức tối đa này tăng lên vượt quá 256, độ dài của chuỗi giảm dần, nhưng ngày càng có khả năng bất kỳ "ký tự" nào vượt quá 256 và do đó không còn là một phần của bộ ký tự ASCII 1 byte. Vì vậy, tôi đã viết một chương trình thử mã hóa dữ liệu đỉnh trong mọi cơ sở từ 256 đến 1000, trong đó tôi tìm thấy khoảng 10 cơ sở lưu một byte dữ liệu ký tự so với cơ sở 256. Tôi đã chọn 487, vì nó cũng có thuộc tính tốt chuỗi kết quả bao gồm hoàn toàn ASCII có thể in được.
• Trộn với tối ưu hóa đầu tiên, tạo ra đầu ra không đối xứng. Cách tiếp cận thông thường trong CJam sẽ là định dạng dữ liệu đỉnh như một danh sách 2 phần tử của danh sách 2 phần tử, chèn một dòng mới vào giữa và để đầu ra được in ngầm. Nhưng thay vào đó, tôi in đỉnh đầu tiên (bằng số mặt đầu vào) bằng toán tử không thêm dòng mới, truy xuất danh sách 3 phần tử của các đỉnh khác, lấy đỉnh tiếp theo và in bằng toán tử có thêm toán tử một dòng mới và để hai đỉnh còn lại được in ngầm. Điều này tiết kiệm một 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 trong chương trình thử nghiệm

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

Giải trình

Đánh số khối của tôi, khi mở ra, trông như thế này:

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

Góc trên bên trái có cùng số với khuôn mặt.

Góc dưới bên phải có số (n+2)%6

Đối với lẻ ngóc trên bên phải là (n+1)%6và phía dưới bên trái là6

Đối với ngay cả ngóc trên bên phải là 7và phía dưới bên trái là(n+1)%6

Chương trình hiển thị các số lẻ như được hiển thị và các số chẵn xoay 180 độ. Điều này có nghĩa là góc trên bên phải luôn luôn (n+1)%6và góc dưới bên trái luôn luôn (n+1)%2+6. Đảo ngược nvà n+2dễ dàng hơn (nó được thực hiện bằng cách cài đặt c=n+1và sử dụng dđể thêm hoặc bớt 1hoặc -1khi cần thiết.)

Đầu ra

$ ./a
0
21
70

$ ./a
1
12
63

$ ./a
2
43
72

$ ./a
3
34
65

$ ./a
4
05
74

$ ./a
5
50
61

Yếu tố, 18

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

Không giống như nhiều ngôn ngữ chơi gôn tiên tiến hơn, Element không có toán tử nén, do đó, tính ngắn gọn của giải pháp được liên kết khá chặt chẽ với sơ đồ đánh số chính xác được sử dụng. Sau một số thử nghiệm, tôi đã tạo ra một sơ đồ đánh số mới cho phép các đỉnh được tính toán chỉ bằng các phép tính số học đơn giản.

  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  

Góc trên bên trái là 6 nếu chẵn và 7 nếu lẻ. Góc trên bên phải là số mặt. Phía dưới bên trái là số mặt, cộng với 2, mod 6. Phía dưới bên phải là 5 trừ đi số mặt.

Dưới đây là một lời giải thích của mã.

_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

Dưới đây là kết quả đầu ra cho mỗi khuôn mặt:

0
60
25

1
71
34

2
62
43

3
73
52

4
64
01

5
75
10

Octave, 108 100 68 50 byte

Tất nhiên đó là một cách để làm nó thanh lịch hơn so với cách tiếp cận trước đây của tôi, mã hóa đơn giản. Tôi ngạc nhiên về cách Octave phù hợp với codegolf hơn Matlab =)

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

Bố trí:

(Xin lỗi, tôi quên thêm cái này.)

Bố trí khối

  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  

Phiên bản cũ:

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

Các phiên bản cũ hơn:

Điều này thực sự sẽ tạo ra một mảng 2x2x2 và sau đó chọn một 'lát'. Chúng tôi thực hiện hoán vị ma trận 3d và mỗi lần chọn lát trên cùng hoặc dưới cùng. (Cái này không hoạt động trong MATLAB vì lập chỉ mục của một biểu thức chứ không phải là ma trận) Tôi chắc chắn sẽ có nhiều cách trực tiếp hơn để làm nó sẽ ngắn hơn.

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 (hoặc 26) byte

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

cũng có thể được nén bằng cách sử dụng chuyển đổi cơ sở thành phiên bản 26 byte .

Giả sử khối lập phương giống như:

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

với khuôn mặt như

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

Dùng thử trực tuyến tại đây

CJam (25 byte)

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

Điều này chứa một ký tự không thể in và một tab (sẽ được xử lý bằng phần mềm StackExchange), do đó, ở định dạng xxd:

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

Bản demo trực tuyến

Khối lập phương:

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

Đây là mã hóa thuần túy, với các đỉnh hình khối được chọn để tối đa hóa khả năng nén cơ sở. Tôi giải mã thành các số có 2 chữ số, vì vậy không ai trong số chúng có thể bắt đầu bằng 0. Tôi cũng không muốn bắt đầu bằng 7, vì điều đó đẩy cơ sở thứ hai quá cao. Do đó 0 và 7 phải nằm trên một đường chéo dài. Tôi muốn một cạnh 10 đi trước để giảm giá trị tôi đang mã hóa. Ngoài ra, có một số lượng linh hoạt hợp lý mà không thay đổi số byte.

Tôi hơi thất vọng vì đã xuất hiện nhân vật đầu tiên từ chuỗi ma thuật, cần phải chuyển nó thành int trước khi sử dụng nó làm cơ sở cho chuyển đổi cơ sở. Hy vọng rằng các phiên bản tương lai của CJam sẽ lưu byte đó, mặc dù sẽ quá muộn để khai thác điều đó ở đây.

JavaScript (ES6), 53 62

Chỉnh sửa Lưu 8 byte bằng chuỗi mẫu, thx @NinjaBearMonkey. Hãy coi chừng, các dòng mới bên trong trích dẫn là đáng kể và không thể được thu gọn.

Không thể thông minh trong Javascript, nó quá dài dòng.

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

Đầu ra 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

Xem đoạn trích để xác định các hiệp hội số ( đó là niềm vui)

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

Cảm ơn @rcrmn đã đề xuất sử dụng lambda để lưu 4 byte. Tôi không chắc chắn về việc để nó ẩn danh nhưng có vẻ như đã được thảo luận về meta ở đây và quyết định điều này là ổn.

Đây là hàm 40 byte, để so sánh với câu trả lời Rev 0 Ruby của tôi, cũng ở bên dưới (Câu trả lời C gốc nằm trong một bài riêng biệt.)

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

Cảm hứng thêm từ Runer112: Điều này phụ thuộc vào việc sửa đổi sơ đồ đánh số được sử dụng trong câu trả lời mới nhất (16 byte!) Của anh ấy. Một cổng trực tiếp của sơ đồ PhiNotPi's sẽ cho cùng số điểm.

Bằng cách thay đổi cách đánh số từ Rev 0 vòng một bước và lấy mọi thứ XOR 1, chúng ta sẽ có được khối lập phương sau:

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

Đầu ra

0
10
63

1
01
74

2
32
65

3
23
70

4
54
61

5
45
72

Ruby Rev 0, 56 52 50

Lưu 4 byte bằng cách loại bỏ unnecesary ()%6từ c-dvà 2 khác (lấy cảm hứng từ runer112) bởi 6+c%2 --> 6|c.

Điểm là cho chức năng, đó chỉ là dòng đầu tiên. Tôi mới sử dụng Ruby và tôi rất ngạc nhiên, tôi không thể tìm thấy một cách ngắn hơn 12 ký tự (11 dòng mới) để lấy số đầu vào của người dùng vào n. Kết quả là, thực hiện một chức năng thay vì một chương trình tiết kiệm 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)

Đây là một cổng của câu trả lời C của tôi. Trong C, %toán tử trả về giá trị âm với số âm. Trong Ruby, nó luôn trả về giá trị dương, do đó không cần thêm 1 vào c. Do đó, thuận lợi là thay đổi cách đánh số của các khuôn mặt theo 1 như sau:

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

Với cách đánh số khuôn mặt mới, chương trình sẽ in các evens như được hiển thị ở trên và tỷ lệ cược xoay qua 180 độ:

1
21
70

2
12
63

3
43
72

4
34
65

5
05
74

0
50
61

Bình thường, 30

Cảm ơn @Jakube cho 2 byte.

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

Hãy thử nó ở đây.

Lời khuyên chơi golf từ các chuyên gia pyth sẽ được chấp nhận một cách ân cần. Đặc biệt tôi nghĩ rằng phần đầu ra có thể có một số cải tiến.

Cổng của con trăn sau: ...

Con trăn, 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]

... đó là một cảng của

Bash tinh khiết, 130

Đối với mục đích giải thích:

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

Các đỉnh khối được đánh số như vậy:

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

Và các khuôn mặt được đánh số như vậy:

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

Các Swapcột chỉ ra thứ tự của các đỉnh nên được chuyển trong đầu ra.

Thuật toán bắt đầu với tất cả các đỉnh {0..7}. Các đỉnh được loại bỏ theo các bit được đặt trong các số đỉnh:

• Đối với các mặt 0,1 và 2, các đỉnh có bit 1,2 hoặc 3 bị xóa tương ứng được giữ
• Đối với các mặt 3,4 và 5, các đỉnh có bit 1,2 hoặc 3 được đặt tương ứng được giữ

Các đỉnh "được giữ" được gắn vào một chuỗi. Chuỗi là ký tự đầu ra 0,1 rồi 2,3 hoặc ngược lại, tùy thuộc vào việc cờ hoán đổi (số mặt mod 2) được đặt.

J - 26 byte

Hàm lấy số mặt làm đối số và trả về lưới các chữ số.

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

Chúng tôi đang sử dụng khối sau:

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

Ví dụ (tự thử tại 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|
+--+--+--+--+--+--+

Bánh mì và bơ là 0&(|:|.). Đây là một động từ đảo ngược và xoay khối lập phương như cách truy cập vào mọi khuôn mặt khi được áp dụng lặp đi lặp lại, đó là những gì chúng ta làm bằng cách sử dụng đối số đầu vào. Các đỉnh của khối được tạo bởi i.3#2, vì vậy chúng tôi sử dụng nó làm điểm bắt đầu và lấy mặt trước 0...{khi chúng ta hoàn thành.

In các chữ số dưới dạng một chuỗi có giá 8 ký tự: {.@":"0@Nếu chúng ta được phép trả về một mảng, thì đó là tiết kiệm 8 ký tự. [bắt đầu rung lắc và nắm chặt không thể nhận ra]

> <> (Cá) , 38 byte

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

Mỗi đầu ra được lưu trữ dưới dạng hai hàng có 2 chữ số. Các hàng được lưu trữ dưới dạng mã trong chuỗi '/ =/2= 28"H'(ngoại trừ hàng 10được nối sau chuỗi dưới dạng a). Ký tự đầu tiên ( / = 47) được sử dụng để chuyển hướng luồng chương trình trên tương tác thứ hai.

Các 2*(53-n)phần tử trên cùng bị loại bỏ (trong đó n là mã số của số đầu vào) và hai mã tiếp theo được in với một dòng mới ở giữa.

Bố trí:

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