0 ile 7 arasındaki sayıları bir küpün 8 köşesine istediğiniz şekilde atayın. Her tepe noktasına tam olarak bir sayı atanmalıdır.

Örneğin, köşeleriniz şu şekilde atanabilir:

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

0'dan 5'e kadar bir tamsayı alan bir program yazın. Bu 6 sayının her biri, küpünüzün tam olarak bir yüzü ile istediğiniz şekilde ilişkilendirilir. Bu sayılardan biri girildiğinde, ilişkili yüzün 4 tepe noktası numarası, 2 × 2 basamaklı basamakta stdout'a yazdırılmalıdır. Yüz, küpün dışından düz olarak görülmelidir. 4 yüz rotasyonunun tümü geçerlidir.

Örneğin, 0, yukarıdaki örnek küpün ön yüzü ile ilişkiliyse, bu giriş için geçerli bir çıktı olur 0:

42
67

Yüz herhangi bir 90 ° döndürmede görüntülenebilir, bu nedenle bunlar da geçerlidir:

27
46

76
24

64
72

Bu çıktı (ve dönüşleri) , yüzün yanlış tarafından görüntülendiğinden geçerli değildir :

24
76

Aynı fikir diğer tüm yüzler için de geçerlidir. Örneğin, 1 arka yüzle ilişkiliyse, girdi 1çıktı üretebilir 13[newline]05(ve 31[newline]50geçersiz olur).

Yani asıl zorluk, tepe noktası sayılarını ve rotasyonlarını seçerek girdiyi 4 tepe noktasına çevirmek kolay ve kısa olacaktır.

Bayt cinsinden en kısa kod kazanır. Tiebreaker daha önceki gönderi. ( Kullanışlı bayt sayacı. )

notlar

• Program yerine bir işlev yazabilirsiniz. 0 ile 5 arasında bir tamsayı almalı ve 2 × 2 basamaklı ızgara dizesini yazdırmalı veya döndürmelidir.
• Stdin, komut satırı veya işlev arg'dan girdi alın. Girişin geçerli olduğunu varsayabilirsiniz.
• Çıktı isteğe bağlı olarak bir satırsonu satırına sahip olabilir.
• Seçtiğiniz tepe ve yüz numaralarını bize bildirdiğinizden emin olun.

CJam, 23 16 bayt

Muhtemelen bu probleme zarif bir matematiksel çözüm var. Ama nasıl bulacağına dair hiçbir fikrim yok, bu yüzden süper sıkıştırılmış sert kodlama!

Bir tane buldum! Bitsel işlemleri kullandığı için klasik olarak zarif bir matematiksel çözüm değil, ancak tamamen formülü.

li_o1^_p_6|o3+6%

Çevrimiçi deneyin.

Küp düzeni

  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  

açıklama

Eski cevabım küpü zaten her yüzün yüz numarasına eşit olan ilk (sol üst) köşe numarasıyla tanımlanabilecek şekilde ortaya koydu. Ama yüz numarasını kullanarak daha fazla köşe noktası sayısı hesaplamak istedim. Bir noktada, ikinci (üst sol) köşe numarasını XOR 1 yüz numarası olarak hesaplamak için ayağımı kapıya getiren bir fikir buldum. Ve bir süre deneme yanılma sonrasında ortaya çıkmayı başardım yukarıda gösterilen düzen ve bir yüzün her köşe numarasını noldukça kısa bir şekilde hesaplamamı sağlayan aşağıdaki formüller ile :

• Sol üst: n
• Sağ üst: n^1
• Sol alt: (n^1)|6
• Sağ alt: ((n^1)+3)%6

Referans olarak, burada istenen düzende her yüz için çıktıyı yeniden oluşturacağım:

Face:      0     1     2     3     4     5

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

Bu nedenle, tüm program, giriş köşesi numarasını okumak ve bu değerleri sırayla üretmek, farklı köşeler için biraz farklı baskı mantığına rağmen geliyor. İlkinden sonraki her tepe noktası bir tabanla başladığından n^1, mantığı daha da sıkıştıran sadece bir kez hesaplamam gerektiğini unutmayın.

Gelecek kuşak için ve hala çok iyi bir yaklaşım olduğunu düşündüğüm için, işte eski cevabım.

CJam, 23 bayt

Muhtemelen bu probleme zarif bir matematiksel çözüm var. Ama nasıl bulacağına dair hiçbir fikrim yok, bu yüzden süper sıkıştırılmış sert kodlama!

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

Çevrimiçi deneyin.

Küp düzeni

  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  

açıklama

Kullanılan temel yaklaşım, her bir yüz için köşeleri mümkün olduğunca az alanda kodlamaktır. Optimizer'ın temel dönüştürme çözümüne benzer şekilde, tepe noktası listesine ASCII karakter verisi olarak paketlenmiş bir sekizli sayı gibi davranılır. Ancak bu, benzerliklerin daha fazla optimizasyon için yol açtığı yerdir!

"Saf" çözüm için yaptığım üç temel optimizasyon:

• Küpü, her bir yüzün yüz numarası ile ilk köşe numarası olarak tanımlanabilecek şekilde yerleştirin. Yukarıda gösterildiği gibi küp düzenime bakıldığında, her yüzün sol üst köşe numarasının yüz numarasına eşit olduğu görülebilir. Bu, girdiyi geri yazdırmak zorunda kalmadan, daha az altı köşeyi kodlamama izin veriyor, bu da bir bayt kaydetmek için çıkıyor.
• Köşe verisini, her bir "karakterin" maksimum 256'dan büyük olduğu bir dizeye paketleyin. Bu maksimum 256'yı geçtikçe, dizenin uzunluğu yavaş yavaş azalır, ancak herhangi bir "karakterin" 256'yı aşması ve böylece artık 1 baytlık ASCII karakter kümesinin bir parçası değildir. Bu nedenle, 256 ile 1000 arasındaki her bazdaki köşe verilerini kodlamaya çalışan bir program yazdım, bununla birlikte 256 karakterlik bir veri verisini taban 256'ya kıyasla kaydeden yaklaşık 10 baz buldum. 487'yi seçtim, elde edilen dize tamamen yazdırılabilir ASCII'den oluşur.
• İlk optimizasyonla karıştırıldığında, çıktıyı asimetrik olarak üretin. CJam'daki genel yaklaşım, köşe verilerini 2 elemanlı listelerin 2 elemanlı bir listesi olarak biçimlendirmek, ortasına bir satırsonu eklemek ve çıktının dolaylı olarak yazdırılmasını sağlamak olacaktır. Ama bunun yerine ilk köşeyi (giriş yüzü numarasına eşit) yeni satır eklemeyen bir operatörle yazdırıyorum, diğer köşelerin 3 elemanlı listesini alıyorum, bir sonraki köşeyi yakalayıp ekleyen bir operatörle yazdırıyorum ve diğer iki köşenin örtülü olarak yazdırılmasına izin verin. Bu bir bayt tasarrufu sağlar.

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

Test programında yönlendirilmemiş

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

açıklama

Küp numaralandırmam, açıldığında şöyle görünür:

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

Sol üst köşede yüzle aynı sayı vardır.

Sağ alt köşede sayı var (n+2)%6

Tek niçin sağ üst köşe (n+1)%6ve sol alt6

Hatta nsağ üst köşede 7ve sol alt köşede(n+1)%6

Program gösterildiği gibi tek sayıları gösterir ve çift sayılar 180 derece döndürülür. Bu, sağ üst köşenin her zaman (n+1)%6ve sol alt kısmın her zaman olduğu anlamına gelir (n+1)%2+6. Tersine çevrilebilir nve n+2daha kolaydır ( toplama veya çıkarma veya gerektiği gibi ayarlanarak c=n+1ve kullanılır .)d1-1

Çıktı

$ ./a
0
21
70

$ ./a
1
12
63

$ ./a
2
43
72

$ ./a
3
34
65

$ ./a
4
05
74

$ ./a
5
50
61

Öğe, 18

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

Birçok daha gelişmiş golf dilinin aksine, Element'in bir sıkıştırma operatörü yoktur, bu nedenle çözümün kısalığı, kullanılan kesin numaralandırma şemasına oldukça yakındır. Bazı deneylerden sonra, yalnızca basit aritmetik işlemler kullanılarak köşelerin hesaplanmasını sağlayan yeni bir numaralandırma şeması oluşturdum.

  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  

Sol üst köşe çift ise 6, tek ise 7'dir. Sağ üst köşe yüz numarasının kendisidir. Sol alt yüz numarası artı 2, mod 6'dır. Sağ alt 5 eksi yüz numarasıdır.

İşte kodun bir açıklaması.

_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

Yüzlerin her biri için çıktılar:

0
60
25

1
71
34

2
62
43

3
73
52

4
64
01

5
75
10

Octave, 108 , 100 68 50 bayt

Tabii ki önceki yaklaşımlarımdan daha zarif yapmanın bir yolu, düz kodlama. Oktav'ın Codelabolf için Matlab = 'den daha uygun olması nasıl şaşırdım?)

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

Yerleşim:

(Üzgünüm, eklemeyi unuttum.)

Küp düzeni

  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  

Eski versiyonlar:

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

Daha eski Sürümler:

Bu gerçekten 2x2x2'lik bir dizi oluşturacak ve daha sonra bir 'dilim' seçecek. Bir 3d matris permütasyonu yapıyoruz ve her seferinde üst veya alt dilimi seçiyoruz. (Bu, bir matris yerine bir ifadenin indekslenmesi nedeniyle matlab'da çalışmaz) Eminim, daha kısa olacak daha doğrudan yapmanın yolları olacaktır.

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 (veya 26) bayt

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

26 baytlık bir sürüme temel dönüştürme kullanılarak da sıkıştırılabilir .

Küpün aşağıdaki gibi olduğunu varsayar:

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

yüzleri gibi

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

Buradan çevrimiçi deneyin

CJam (25 bayt)

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

Bu, yazdırılamayan bir karakter ve (StackExchange yazılımı tarafından yönetilecek) bir sekme içerir, bu nedenle xxd biçiminde:

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

Çevrimiçi demo

Küp:

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

Bu, taban sıkıştırılabilirliğini en üst düzeye çıkarmak için küp köşeleri seçilen saf sert kodlamadır. 2 basamaklı sayıları çözerim, böylece hiçbiri 0 ile başlayamaz. Ben de 7 ile başlamak istemiyorum, çünkü bu ikinci üssü çok yukarı itiyor. Bu nedenle 0 ve 7 uzun bir diyagonal üzerinde olmalıdır. Ben kodlama değeri azaltmak için ilk 10 kenar gitmek istiyorum. Bunun dışında bayt sayısını değiştirmeden makul miktarda esneklik var.

Sihirli dizeden ilk karakteri çıkardıktan sonra, temel dönüşüm için bir temel olarak kullanmadan önce bir int'e atmak gerektiğinden biraz hayal kırıklığına uğradım. Umarım gelecekteki CJam sürümleri bu baytı kurtaracaktır, ancak burada kullanmak için çok geç olacaktır.

JavaScript (ES6), 53 62

Düzenle Şablon dizeleri, 8x @NinjaBearMonkey kullanarak 8 bayt kaydedin. Dikkat edin, tırnak içindeki yeni satırlar önemlidir ve daraltılamaz.

Javascript'te zekice olamaz, çok ayrıntılı.

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

Çıktı 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

Numara ilişkilendirmeleri (veify için ön bilgi bu eğlenceliydi)

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

4 byte tasarruf etmek için lambda kullanmayı önerdiği için @rcrmn'a teşekkürler. Anonim bırakarak emin değildi ama meta burada tartışıldı ve bu Tamam olduğuna karar vermiş gibi görünüyor .

Burada 40 baytlık bir işlev olarak, Rev 0 Ruby cevabımla karşılaştırmak için, aşağıda da var (Orijinal C cevabı ayrı bir gönderide.)

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

Runer112'den daha fazla ilham: Bu, en son (16 bayt!) Cevabında kullanılan numaralandırma şemasında bir modifikasyona dayanıyor. PhiNotPi'nin planının doğrudan limanı aynı puanı verecektir.

Numaralandırmayı Rev 0 turundan bir adım kaydırarak ve her şeyi XOR 1 alarak, aşağıdaki küpü elde ederiz:

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

Çıktı

0
10
63

1
01
74

2
32
65

3
23
70

4
54
61

5
45
72

Ruby Rev 0, 56 52 50

Gereksiz kaldırarak 4 bayt Kaydedilen ()%6gelen c-dve başka bir 2 ile (runer112 esinlenerek)6+c%2 --> 6|c .

Skor sadece ilk satır olan fonksiyon içindir. Ruby'de yeniyim ve n'ye bir kullanıcı giriş numarası almak için 12 karakterden (11 artı yeni satır) daha kısa bir yol bulamadığım için şaşırdım. Sonuç olarak, program yerine bir işlev yapmak 1 bayt tasarruf sağlar.

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)

Bu C cevabımın bir limanı. C'de, %operatör negatif bir sayı ile negatif bir değer döndürür. Ruby'de her zaman pozitif bir değer döndürür, bu yüzden 1 eklemeye gerek yoktur c. Sonuç olarak, yüzlerin numaralandırmasını aşağıdaki gibi 1 kaydırmak avantajlıdır:

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

Yeni yüz numaralandırmasıyla, program yukarıda gösterilen şekilde kanıtları yazdırır ve olasılıklar 180 derece döndürülür:

1
21
70

2
12
63

3
43
72

4
34
65

5
05
74

0
50
61

Pyth, 30

@ Jakube 2 bayt için teşekkürler.

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

Burada deneyin.

Pyth uzmanlarının golf tavsiyeleri nezaketle kabul edilecektir. Özellikle çıktı bölümünün bazı iyileştirmeler olabileceğini düşünüyorum.

Aşağıdaki pitonun limanı: ...

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]

... limanı olan

Saf Bash, 130

Açıklama amacıyla:

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

Küp köşeleri şu şekilde numaralandırılmıştır:

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

Ve yüzler bu şekilde numaralandırılmıştır:

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

SwapKolon köşelerin sırası çıkış anahtarlamalı gösterir.

Algoritma tüm köşe noktaları {0..7} ile başlar. Köşeler, köşe numaralarında ayarlanan bitlere göre elimine edilir:

• 0,1 ve 2 yüzleri için, sırasıyla 1,2 veya 3 bitli köşeler korunur
• 3,4 ve 5 yüzleri için, sırasıyla 1,2 veya 3 bitli köşeler korunur

"Tutulan" köşeler bir dizeye eklenir. Dize, takas bayrağının (yüz numarası mod 2) ayarlanıp ayarlanmadığına bağlı olarak 0,1 ve sonra 2,3 çıkış karakterlerinden oluşur.

J - 26 bayt

Yüz numarasını bağımsız değişken olarak alma ve basamak ızgarasını döndürme işlevi.

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

Aşağıdaki küpü kullanıyoruz:

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

Örnek ( tryj.tk adresinde kendiniz deneyin ):

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

Ekmek ve tereyağı 0&(|:|.). Bu, küpü yinelemeli olarak uygulandığında her yüzü ziyaret edecek şekilde tersine çeviren ve döndüren bir fiildir, giriş argümanını kullanarak bunu yaparız. Küpün köşeleri tarafından oluşturulur i.3#2, bu yüzden bunu başlangıç ​​noktası olarak kullanırız ve ön yüzü alırız0...{ işimiz bittiğinde alırız.

Basamakları dize olarak yazdırmak 8 karakterdir: {.@":"0@Bir diziyi döndürmemize izin verilirse, bu 8 tam karakter tasarrufu sağlar. [yumruk titremeye ve ayırt edilemez tutuşa başlar]

> <> (Balık) , 38 bayt

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

Her çıkış iki adet 2 basamaklı satır olarak kaydedilir. Satırlar dizede charcodes olarak saklanır '/ =/2= 28"H'( dizeden 10sonra eklenmiş satır hariç a). İlk karakter (/ = 47 ), ikinci etkileşime program akışını yönlendirmek için kullanılır.

Üstteki 2*(53-n)elemanlar atılır (burada n, giriş numarasının kodudur) ve sonraki iki kod arasında yeni satır ile yazdırılır.

Yerleşim:

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