Tetapkan angka 0 hingga 7 hingga 8 simpul kubus dengan cara apa pun yang Anda inginkan. Tepat satu nomor harus ditetapkan untuk setiap titik.

Misalnya, simpul Anda mungkin ditugaskan seperti ini:

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

Tulis program yang menggunakan bilangan bulat dari 0 hingga 5. Masing-masing dari 6 angka ini dikaitkan dengan tepat satu sisi kubus Anda dengan cara apa pun yang Anda suka. Ketika salah satu dari angka-angka ini adalah input, 4 nomor titik dari wajah yang terkait harus dicetak ke stdout dalam 2 × 2 kuadrat digit. Wajah harus dilihat langsung dari luar kubus. Semua 4 rotasi wajah valid.

Misalnya, jika 0 dikaitkan dengan permukaan depan contoh kubus di atas, maka ini akan menjadi output yang valid untuk input 0:

42
67

Wajah dapat dilihat pada rotasi 90 °, jadi ini juga berlaku:

27
46

76
24

64
72

Output ini (dan rotasinya) tidak valid , karena dilihat dari sisi wajah yang salah:

24
76

Gagasan yang sama berlaku untuk semua wajah lainnya. misalnya jika 1 dikaitkan dengan permukaan belakang, maka input 1mungkin menghasilkan output 13[newline]05(dan 31[newline]50akan menjadi tidak valid).

Jadi tantangan sebenarnya adalah memilih nomor dan rotasi titik Anda sehingga menerjemahkan input ke dalam 4 angka titiknya mudah dan pendek.

Kode terpendek dalam byte menang. Tiebreaker adalah posting sebelumnya. ( Penghitung byte berguna. )

Catatan

• Anda dapat menulis fungsi alih-alih program. Ini harus mengambil bilangan bulat dari 0 hingga 5 dan mencetak atau mengembalikan string grid 2 × 2 digit.
• Ambil input dari stdin, baris perintah, atau fungsi arg. Anda dapat menganggap input valid.
• Output secara opsional dapat memiliki baris tambahan.
• Pastikan untuk memberi tahu kami titik dan nomor wajah yang Anda pilih.

CJam, 23 16 byte

Mungkin ada solusi matematika yang elegan untuk masalah ini. Tapi saya tidak tahu bagaimana menemukannya, jadi sangat sulit mengkodekan pengkodean!

Saya menemukan satu! Yah, ini bukan solusi matematis yang elegan karena menggunakan operasi bitwise, tetapi sepenuhnya formula.

li_o1^_p_6|o3+6%

Cobalah online.

Tata letak kubus

  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  

Penjelasan

Jawaban lama saya sudah meletakkan kubus sedemikian rupa sehingga setiap wajah dapat digambarkan dengan nomor simpul pertama (kiri atas) sama dengan nomor wajah. Tetapi saya ingin dapat menghitung lebih banyak nomor titik menggunakan nomor wajah. Pada titik tertentu, saya muncul dengan ide yang membuat kaki saya di pintu, untuk menghitung nomor simpul kedua (atas-kiri) sebagai nomor wajah XOR 1. Dan setelah beberapa saat coba-coba, saya berhasil muncul dengan tata letak yang ditunjukkan di atas dan rumus di bawah ini yang memungkinkan saya menghitung setiap jumlah titik untuk wajah dengan ncukup ringkas:

• Kiri atas: n
• Kanan atas: n^1
• Kiri bawah: (n^1)|6
• Kanan bawah: ((n^1)+3)%6

Untuk referensi, saya akan mereproduksi output untuk setiap wajah dalam tata letak yang diinginkan di sini:

Face:      0     1     2     3     4     5

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

Jadi seluruh program hanya membaca nomor wajah input dan menghasilkan nilai-nilai ini secara berurutan, meskipun dengan logika pencetakan yang sedikit berbeda untuk simpul yang berbeda. Perhatikan bahwa, karena setiap simpul setelah yang pertama dimulai dengan basis n^1, saya hanya perlu menghitungnya sekali, yang memadatkan logika lebih jauh.

Demi anak cucu, dan karena saya pikir itu masih pendekatan yang cukup bagus, inilah jawaban lama saya.

CJam, 23 byte

Mungkin ada solusi matematika yang elegan untuk masalah ini. Tapi saya tidak tahu bagaimana menemukannya, jadi sangat sulit mengkodekan pengkodean!

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

Cobalah online.

Tata letak kubus

  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  

Penjelasan

Pendekatan dasar yang digunakan adalah mengkodekan simpul untuk setiap wajah dalam ruang sesedikit mungkin. Sama halnya dengan solusi konversi basis Optimizer, ini memperlakukan daftar simpul sebagai angka oktal yang dikemas sebagai data karakter ASCII. Tapi di situlah kesamaan berakhir untuk memberi jalan bagi optimasi lebih lanjut!

Berikut adalah tiga kunci optimasi yang saya buat untuk solusi "naif":

• Letakkan kubus sedemikian rupa sehingga setiap wajah dapat digambarkan dengan nomor wajahnya sebagai nomor simpul pertama. Melihat tata letak kubus saya seperti yang disajikan di atas, orang dapat melihat bahwa nomor simpul atas-kiri dari setiap wajah sama dengan nomor wajah. Ini memungkinkan saya untuk mengkodekan enam simpul lebih sedikit dengan biaya harus mencetak input kembali, yang ternyata menghemat satu byte.
• Kemas data verteks ke dalam string yang masing-masing "karakter" memiliki maksimum lebih besar dari 256. Karena maksimum ini meningkat melampaui 256, panjang string perlahan-lahan menurun, tetapi semakin besar kemungkinan satu "karakter" melebihi 256 dan dengan demikian tidak lagi bagian dari set karakter ASCII 1-byte. Jadi saya menulis sebuah program yang mencoba menyandikan data titik di setiap basis dari 256 hingga 1000, dengan yang saya temukan sekitar 10 basis yang menyimpan satu byte data karakter dibandingkan dengan basis 256. Saya memilih 487, karena itu juga memiliki properti bagus yang string yang dihasilkan seluruhnya terdiri dari ASCII yang dapat dicetak.
• Dicampur dengan optimasi pertama, menghasilkan output secara asimetris. Pendekatan yang biasa dilakukan di CJam adalah memformat data vertex sebagai daftar 2-elemen dari daftar 2-elemen, menyisipkan baris baru di tengah, dan membiarkan hasilnya dicetak secara implisit. Tapi saya malah mencetak simpul pertama (sama dengan nomor wajah masukan) dengan operator yang tidak menambahkan baris baru, mengambil daftar 3-elemen dari simpul lain, ambil simpul berikutnya dan mencetaknya dengan operator yang menambahkan baris baru, dan biarkan dua simpul lainnya dicetak secara implisit. Ini menghemat satu 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);}

Tidak terkurung dalam program uji

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

Penjelasan

Penomoran kubus saya, saat dibuka, terlihat seperti ini:

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

Pojok kiri atas memiliki nomor yang sama dengan wajah.

Pojok kanan bawah memiliki nomor (n+2)%6

Untuk aneh nsudut kanan atas adalah (n+1)%6dan kiri bawah6

Bahkan nsudut kanan atas 7dan kiri bawah(n+1)%6

Program ini menampilkan angka ganjil seperti yang ditunjukkan dan angka genap diputar 180 derajat. Ini berarti sudut kanan atas selalu (n+1)%6dan kiri bawah selalu (n+1)%2+6. Pembalikan ndan n+2lebih mudah (dilakukan dengan mengatur c=n+1dan menggunakan duntuk menambah atau mengurangi 1atau -1sesuai kebutuhan.)

Keluaran

$ ./a
0
21
70

$ ./a
1
12
63

$ ./a
2
43
72

$ ./a
3
34
65

$ ./a
4
05
74

$ ./a
5
50
61

Elemen, 18

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

Tidak seperti banyak bahasa golf yang lebih maju, Element tidak memiliki operator kompresi, sehingga singkatnya solusi ini terkait erat dengan skema penomoran yang tepat digunakan. Setelah beberapa percobaan, saya telah membuat skema penomoran baru yang memungkinkan simpul untuk dihitung hanya menggunakan operasi aritmatika sederhana.

  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  

Sudut kiri atas adalah 6 jika genap dan 7 jika aneh. Pojok kanan atas adalah nomor wajah itu sendiri. Kiri bawah adalah nomor wajah, ditambah 2, mod 6. Kanan bawah adalah 5 minus nomor wajah.

Berikut ini penjelasan kodenya.

_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

Berikut adalah output untuk masing-masing wajah:

0
60
25

1
71
34

2
62
43

3
73
52

4
64
01

5
75
10

Oktaf, 108 100 68 50 byte

Tentu saja ada cara melakukannya dengan cara yang lebih elegan dari pendekatan saya sebelumnya, hardcoding biasa. Saya kagum bagaimana Octave jauh lebih cocok untuk codegolf daripada Matlab =)

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

Tata letak:

(Maaf, saya lupa menambahkan ini.)

Tata letak kubus

  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  

Versi lama:

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

Versi yang lebih lama:

Ini benar-benar akan membuat array 2x2x2 dan kemudian memilih 'slice'. Kami melakukan permutasi matriks 3d dan setiap kali memilih irisan atas atau bawah. (Yang ini tidak bekerja di matlab karena pengindeksan ekspresi daripada matriks) Saya yakin akan ada cara yang lebih langsung untuk melakukannya yang akan lebih pendek.

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 (atau 26) byte

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

yang juga dapat dikompres menggunakan konversi basis ke versi 26 byte .

Mengasumsikan kubus seperti:

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

dengan wajah seperti

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

Cobalah online di sini

CJam (25 byte)

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

Ini berisi karakter yang tidak dapat dicetak dan tab (yang akan hancur oleh perangkat lunak StackExchange), sehingga dalam format xxd:

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

Demo online

Kubus:

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

Ini murni hard-coding, dengan simpul kubus dipilih untuk memaksimalkan kompresibilitas dasar. Saya mendekodekan ke angka 2 digit, sehingga tidak ada yang bisa mulai dengan 0. Saya juga tidak ingin ada yang memulai dengan 7, karena itu mendorong basis kedua terlalu tinggi. Karena itu 0 dan 7 harus berada di diagonal panjang. Saya ingin 10 edge pergi dulu untuk mengurangi nilai yang saya encoding. Selain itu, ada cukup banyak fleksibilitas tanpa mengubah jumlah byte.

Saya sedikit kecewa karena telah mengeluarkan karakter pertama dari string ajaib, perlu untuk melemparkannya ke int sebelum menggunakannya sebagai basis untuk konversi basis. Semoga versi CJam yang akan datang akan menghemat byte itu, meskipun akan terlambat untuk mengeksploitasinya di sini.

JavaScript (ES6), 53 62

Edit Simpan 8 byte menggunakan string template, thx @NinjaBearMonkey. Hati-hati, baris baru di dalam tanda kutip signifikan dan tidak dapat diciutkan.

Tidak bisa pintar dalam Javascript, terlalu bertele-tele.

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

Keluaran 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

Lihat potongan untuk veify asosiasi nomor ( yang menyenangkan)

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

Terima kasih kepada @rcrmn karena menyarankan menggunakan lambda untuk menghemat 4 byte. Saya tidak yakin tentang meninggalkannya secara anonim tetapi tampaknya telah dibahas pada meta di sini dan memutuskan ini tidak masalah.

Ini dia sebagai fungsi 40-byte, untuk perbandingan dengan jawaban Rev 0 Ruby saya, juga di bawah ini (jawaban C asli ada di pos terpisah.)

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

Inspirasi lebih lanjut dari Runer112: Ini bergantung pada modifikasi skema penomoran yang digunakan dalam jawaban terbarunya (16 byte!). Port langsung skema PhiNotPi akan memberikan skor yang sama.

Dengan menggeser penomoran dari putaran 0 putaran satu langkah, dan mengambil semuanya XOR 1, kita mendapatkan kubus berikut:

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

Keluaran

0
10
63

1
01
74

2
32
65

3
23
70

4
54
61

5
45
72

Ruby Rev 0, 56 52 50

Disimpan 4 byte dengan menghapus yang tidak perlu ()%6dari c-ddan 2 lainnya (terinspirasi oleh runer112) oleh 6+c%2 --> 6|c.

Skor untuk fungsi, yang hanya merupakan baris pertama. Saya baru di Ruby dan saya terkejut saya tidak dapat menemukan cara yang lebih pendek dari 12 karakter (11 ditambah baris baru) untuk mendapatkan nomor input pengguna ke n. Akibatnya, melakukan fungsi alih-alih program menghemat 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)

Ini adalah port jawaban C saya. Dalam C, %operator mengembalikan nilai negatif dengan angka negatif. Di Ruby itu selalu mengembalikan nilai positif, jadi tidak perlu menambahkan 1 c. Akibatnya, menguntungkan untuk mengubah penomoran wajah dengan 1 seperti di bawah ini:

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

Dengan penomoran wajah yang baru, program mencetak rata seperti ditunjukkan di atas dan peluang diputar hingga 180 derajat:

1
21
70

2
12
63

3
43
72

4
34
65

5
05
74

0
50
61

Pyth, 30

Terima kasih @ Jakube untuk 2 byte.

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

Coba di sini.

Saran bermain golf dari para ahli pyth akan diterima dengan ramah. Secara khusus saya pikir bagian output mungkin memiliki beberapa peningkatan.

Port python berikut: ...

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]

... yang merupakan pelabuhan

Pure Bash, 130

Untuk keperluan penjelasan:

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

Simpul kubus diberi nomor sebagai berikut:

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

Dan wajah-wajah diberi nomor sebagai berikut:

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

The Swapkolom menunjukkan urutan simpul harus diaktifkan dalam output.

Algoritma dimulai dengan semua simpul {0..7}. Verteks dihilangkan sesuai dengan bit yang diatur dalam angka verteks:

• Untuk wajah 0,1 dan 2, masing-masing simpul dengan bit 1,2 atau 3 dibersihkan
• Untuk wajah 3,4 dan 5, masing-masing simpul dengan set bit 1,2 atau 3 disimpan

Verteks "disimpan" ditambahkan ke string. String adalah output chars 0,1 kemudian 2,3 atau sebaliknya, tergantung pada apakah flag swap (face number mod 2) diatur.

J - 26 byte

Berfungsi mengambil nomor muka sebagai argumen dan mengembalikan grid angka.

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

Kami menggunakan kubus berikut:

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

Contoh (coba sendiri di 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|
+--+--+--+--+--+--+

Roti dan mentega itu 0&(|:|.). Ini adalah kata kerja yang membalik dan memutar kubus sedemikian rupa untuk mengunjungi setiap wajah ketika diterapkan secara iteratif, yang kami lakukan dengan menggunakan argumen input. Vertikal dari kubus dihasilkan oleh i.3#2, jadi kami menggunakannya sebagai titik awal, dan mengambil wajah depan 0...{ketika kita selesai.

Mencetak digit sebagai string menghabiskan 8 karakter: {.@":"0@Jika kami diizinkan untuk mengembalikan array, itu berarti penghematan 8 karakter secara keseluruhan. [Memulai dengan tangan gemetar dan mencekam tak terlihat]

> <> (Ikan) , 38 byte

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

Setiap output disimpan sebagai dua baris 2 digit. Baris disimpan sebagai kode dalam string '/ =/2= 28"H'(kecuali baris 10yang ditambahkan setelah string sebagai a). Karakter pertama (/ = 47 ) digunakan untuk mengarahkan aliran program pada interaksi kedua.

2*(53-n)Elemen atas dibuang (di mana n adalah kode karakter dari nomor input) dan dua kode berikutnya dicetak dengan baris baru di antaranya.

Tata letak:

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