Przypisz cyfry od 0 do 7 do 8 wierzchołków sześcianu w dowolny sposób. Dokładnie jeden numer musi być przypisany do każdego wierzchołka.

Na przykład twoje wierzchołki mogą być przypisane w następujący sposób:

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

Napisz program, który przyjmuje liczbę całkowitą od 0 do 5. Każda z tych 6 liczb jest powiązana z dokładnie jedną ścianą sześcianu w dowolny sposób. Po wprowadzeniu jednej z tych liczb, 4 numery wierzchołków powiązanej powierzchni muszą być wydrukowane w formacie stdout w kwadracie cyfr 2 × 2. Twarzą należy patrzeć prosto z zewnątrz sześcianu. Wszystkie 4 obroty twarzy są prawidłowe.

Na przykład, jeśli 0 jest skojarzone z przednią powierzchnią przykładowego sześcianu powyżej, to byłby to prawidłowy wynik dla danych wejściowych 0:

42
67

Twarz można oglądać przy dowolnym obrocie o 90 °, więc są one również ważne:

27
46

76
24

64
72

Ten wynik (i jego obroty) są niepoprawne , ponieważ są oglądane z niewłaściwej strony twarzy:

24
76

Ten sam pomysł dotyczy wszystkich innych twarzy. np. jeśli 1 jest powiązany z tylną ścianą, wówczas dane wejściowe 1mogą generować dane wyjściowe 13[newline]05(i 31[newline]50byłyby nieprawidłowe).

Tak więc prawdziwym wyzwaniem jest wybranie liczb i rotacji wierzchołków, tak aby przekształcenie danych wejściowych na 4 liczby wierzchołków było łatwe i krótkie.

Najkrótszy kod w bajtach wygrywa. Tiebreaker jest wcześniejszym postem. ( Poręczny licznik bajtów. )

Notatki

• Możesz napisać funkcję zamiast programu. Powinien przyjąć liczbę całkowitą od 0 do 5 i wydrukować lub zwrócić 2 × 2-cyfrowy ciąg siatki.
• Weź dane wejściowe ze stdin, wiersza poleceń lub funkcji arg. Możesz założyć, że dane wejściowe są prawidłowe.
• Wyjście może opcjonalnie mieć końcowy znak nowej linii.
• Podaj nam wybrane przez siebie numery wierzchołków i twarzy.

CJam, 23 16 bajtów

Prawdopodobnie istnieje eleganckie matematyczne rozwiązanie tego problemu. Ale nie mam pojęcia, jak je znaleźć, więc jest to bardzo skompresowane kodowanie!

Znalazłem jedno! Cóż, nie jest to klasycznie eleganckie rozwiązanie matematyczne, ponieważ wykorzystuje operacje bitowe, ale ma całkowicie formułę.

li_o1^_p_6|o3+6%

Wypróbuj online.

Układ kostki

  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  

Wyjaśnienie

Moja stara odpowiedź już ułożyła sześcian w taki sposób, że każdą twarz można opisać za pomocą pierwszego (lewego górnego) numeru wierzchołka równego numerowi twarzy. Ale chciałem móc obliczyć więcej liczb wierzchołków przy użyciu numeru twarzy. W pewnym momencie wpadłem na pomysł, który postawił mi stopę w drzwiach, aby obliczyć drugi (lewy górny) numer wierzchołka jako numer twarzy XOR 1. I po pewnym czasie prób i błędów udało mi się wymyślić z powyższym układem i poniższymi wzorami, które pozwalają mi zwięźle obliczyć każdą liczbę wierzchołków dla twarzy n:

• Lewy górny: n
• W prawym górnym rogu: n^1
• Na dole po lewej: (n^1)|6
• Prawy dolny: ((n^1)+3)%6

W celach informacyjnych odtworzę wynik dla każdej twarzy w pożądanym układzie tutaj:

Face:      0     1     2     3     4     5

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

Cały program sprowadza się więc do odczytu wejściowej liczby twarzy i generowania tych wartości w kolejności, choć z nieco inną logiką drukowania dla różnych wierzchołków. Zauważ, że ponieważ każdy wierzchołek po pierwszym zaczyna się od podstawy n^1, muszę go tylko obliczyć raz, co jeszcze bardziej upraszcza logikę.

Dla potomności, a ponieważ uważam, że było to całkiem dobre podejście, oto moja stara odpowiedź.

CJam, 23 bajty

Prawdopodobnie istnieje eleganckie matematyczne rozwiązanie tego problemu. Ale nie mam pojęcia, jak je znaleźć, więc jest to super skompresowane kodowanie!

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

Wypróbuj online.

Układ kostki

  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  

Wyjaśnienie

Podstawowym zastosowanym podejściem jest sztywne kodowanie wierzchołków dla każdej twarzy na możliwie jak najmniejszej przestrzeni. Podobnie do podstawowego rozwiązania konwersji Optimizera, traktuje listę wierzchołków jako liczbę ósemkową upakowaną jako dane znakowe ASCII. Ale na tym kończą się podobieństwa, aby zrobić miejsce na dalsze optymalizacje!

Oto trzy kluczowe optymalizacje, które wprowadziłem do „naiwnego” rozwiązania:

• Rozłóż sześcian w taki sposób, aby każdą ścianę można opisać za pomocą numeru ściany jako pierwszego numeru wierzchołka. Patrząc na mój układ kostki, jak pokazano powyżej, widać, że lewy górny numer wierzchołka każdej powierzchni jest równy numerowi powierzchni. To pozwala mi zakodować sześć mniej wierzchołków kosztem konieczności wydrukowania danych wejściowych z powrotem, co okazuje się, aby zaoszczędzić bajt.
• Spakuj dane wierzchołków do łańcucha, dla którego każdy „znak” ma maksimum większe niż 256. Gdy to maksimum wzrasta powyżej 256, długość łańcucha powoli maleje, ale staje się coraz bardziej prawdopodobne, że dowolny „znak” przekracza 256 i jest dlatego nie jest już częścią 1-bajtowego zestawu znaków ASCII. Napisałem więc program, który próbuje zakodować dane wierzchołków w każdej bazie od 256 do 1000, przy pomocy których znalazłem około 10 zasad, które zapisują jeden bajt danych znakowych w porównaniu do bazy 256. Wybrałem 487, ponieważ ma to również fajną właściwość: wynikowy ciąg składa się całkowicie z drukowalnego ASCII.
• W połączeniu z pierwszą optymalizacją produkuje się asymetrycznie. Zwykłym podejściem w CJam byłoby sformatowanie danych wierzchołków jako 2-elementowej listy 2-elementowej listy, wstawienie nowego wiersza na środku i pozwolenie na wydrukowanie danych wyjściowych. Zamiast tego drukuję pierwszy wierzchołek (równy wejściowej liczbie ścian) za pomocą operatora, który nie dodaje nowego wiersza, pobieram 3-elementową listę pozostałych wierzchołków, chwytam następny wierzchołek i drukuję go za pomocą operatora, który dodaje nowa linia i pozwól, aby pozostałe dwa wierzchołki zostały wydrukowane niejawnie. To oszczędza bajt.

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

Niegolfowany w programie testowym

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

Wyjaśnienie

Po rozłożeniu numeracja kostki wygląda następująco:

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

Lewy górny róg ma ten sam numer co twarz.

Prawy dolny róg ma numer (n+2)%6

Dla nieparzystych nprawy górny róg jest, (n+1)%6a lewy dolny -6

Bo nawet nprawy górny róg jest, 7a dolny lewy jest(n+1)%6

Program wyświetla liczby nieparzyste, jak pokazano, a liczby parzyste zostały obrócone o 180 stopni. Oznacza to, że prawy górny róg jest zawsze, (n+1)%6a lewy dolny zawsze (n+1)%2+6. Odwracanie ni n+2jest łatwiejsze (odbywa się to przez ustawienie c=n+1i użycie ddo dodawania lub odejmowania 1lub -1w razie potrzeby).

Wynik

$ ./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+`

W przeciwieństwie do wielu bardziej zaawansowanych języków golfowych, Element nie ma operatora kompresji, więc zwięzłość rozwiązania jest ściśle związana z zastosowanym dokładnym schematem numeracji. Po kilku eksperymentach stworzyłem nowy schemat numeracji, który umożliwia obliczanie wierzchołków przy użyciu prostych operacji arytmetycznych.

  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  

Lewy górny róg to 6, jeśli parzysty i 7, jeśli nieparzysty. Prawy górny róg to sam numer twarzy. Lewy dolny róg to numer twarzy plus 2, mod 6. Dolny prawy róg to 5 minus numer twarzy.

Oto wyjaśnienie kodu.

_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

Oto wyniki dla każdej z twarzy:

0
60
25

1
71
34

2
62
43

3
73
52

4
64
01

5
75
10

Oktawa, 108 100 68 50 bajtów

Oczywiście jest to sposób na zrobienie tego o wiele bardziej elegancki niż moje poprzednie podejście, zwykłe twarde kodowanie. Dziwi mnie, jak Octave jest bardziej odpowiedni dla codegolfa niż Matlab =)

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

Układ:

(Przepraszam, zapomniałem to dodać).

Układ kostki

  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  

Stare wersje:

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

Nawet starsze wersje:

To naprawdę zrobi tablicę 2x2x2, a następnie wybierze „plasterek”. Wykonujemy permutację macierzy 3D i za każdym razem wybieramy górny lub dolny wycinek. (Ten nie działa w Matlabie z powodu indeksowania wyrażenia, a nie macierzy). Jestem pewien, że byłyby bardziej bezpośrednie sposoby, które byłyby krótsze.

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 (lub 26) bajtów

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

który można również skompresować za pomocą konwersji podstawowej do wersji 26-bajtowej .

Zakłada, że ​​sześcian jest podobny do:

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

z twarzami takimi jak

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

Wypróbuj online tutaj

CJam (25 bajtów)

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

Zawiera znak niedrukowalny i zakładkę (która zostanie zniekształcona przez oprogramowanie StackExchange), więc w formacie xxd:

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

Demo online

Sześcian:

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

Jest to czyste kodowanie, z wybranymi wierzchołkami sześcianu, aby zmaksymalizować ściśliwość podstawy. Dekoduję na liczby dwucyfrowe, więc żadna z nich nie może zaczynać się od 0. Nie chcę też, aby liczba zaczynała się od 7, ponieważ przesuwa to drugą podstawę zbyt wysoko. Dlatego 0 i 7 muszą znajdować się na długiej przekątnej. Chcę, aby pierwsza krawędź 10 poszła pierwsza, aby zmniejszyć wartość, którą koduję. Poza tym istnieje duża elastyczność bez zmiany liczby bajtów.

Jestem nieco rozczarowany, że po wyjęciu pierwszej postaci z magicznego sznurka, konieczne jest rzucenie go na int, zanim użyje się go jako podstawy do konwersji bazy. Mam nadzieję, że przyszłe wersje CJam uratują ten bajt, chociaż będzie za późno, aby go tutaj wykorzystać.

JavaScript (ES6), 53 62

Edytuj Zapisz 8 bajtów za pomocą ciągów szablonów, dzięki @NinjaBearMonkey. Uwaga, nowe znaki w cudzysłowie są znaczące i nie można ich zwinąć.

Nie może być sprytny w Javascript, jest zbyt gadatliwy.

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

Wynik 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

Zobacz fragment do veify skojarzenia numer ( to było zabawne)

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

Dzięki @rcrmn za sugestię użycia lambda do zapisania 4 bajtów. Nie byłam pewna, czy zostawię to anonimowe, ale wydaje się, że omawiano ją tutaj na meta i zdecydowałem, że to OK.

Tutaj jest to funkcja 40-bajtowa, dla porównania z moją odpowiedzią Ruby Rev 0, również poniżej (Oryginalna odpowiedź C jest w osobnym poście).

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

Dalsze inspiracje z Runer112: Opiera się to na modyfikacji schematu numeracji zastosowanej w jego najnowszej (16 bajtowej!) Odpowiedzi. Bezpośredni port programu PhiNotPi dałby ten sam wynik.

Przesuwając numerację z Rev 0 rundy o jeden krok i biorąc wszystko XOR 1, otrzymujemy następującą kostkę:

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

Wynik

0
10
63

1
01
74

2
32
65

3
23
70

4
54
61

5
45
72

Ruby Rev 0, 56 52 50

Zapisano 4 bajty, usuwając niepotrzebne ()%6zc-d i kolejne 2 (inspirowany runer112) o 6+c%2 --> 6|c.

Wynik dotyczy funkcji, która jest tylko pierwszą linią. Jestem nowy w Ruby i dziwi mnie, że nie mogę znaleźć krótszej drogi niż 12 znaków (11 plus nowa linia), aby wprowadzić numer wejściowy użytkownika w n. W rezultacie wykonanie funkcji zamiast programu pozwala zaoszczędzić 1 bajt.

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)

To jest port mojej odpowiedzi C. W C %operator zwraca wartość ujemną z liczbą ujemną. W Ruby zawsze zwraca wartość dodatnią, więc nie ma potrzeby dodawania 1 do c. W rezultacie korzystne jest przesunięcie numeracji twarzy o 1, jak poniżej:

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

Dzięki nowej numeracji twarzy program drukuje wyrównania, jak pokazano powyżej, a szanse zostały obrócone o 180 stopni:

1
21
70

2
12
63

3
43
72

4
34
65

5
05
74

0
50
61

Pyth, 30

Dzięki @Jakube za 2 bajty.

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

Wypróbuj tutaj.

Porady golfistów od ekspertów pyta będą mile widziane. W szczególności myślę, że sekcja wyników może zawierać pewne ulepszenia.

Port następującego 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]

... który jest portem

Pure Bash, 130

W celu wyjaśnienia:

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

Wierzchołki sześcianu są ponumerowane w ten sposób:

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

A twarze są ponumerowane w ten sposób:

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 SwapKolumnie podana jest kolejność, w wierzchołkach powinien być włączony na wyjściu.

Algorytm zaczyna się od wszystkich wierzchołków {0..7}. Wierzchołki są eliminowane zgodnie z bitami ustawionymi w liczbach wierzchołków:

• Dla powierzchni 0,1 i 2 zachowane są wierzchołki z bitami odpowiednio 1,2 lub 3
• Dla ścian 3,4 i 5 zachowane są wierzchołki z bitami odpowiednio 1,2 lub 3

„Zachowane” wierzchołki są dołączane do łańcucha. Łańcuch jest znakami wyjściowymi 0,1, a następnie 2,3 lub odwrotnie, w zależności od tego, czy ustawiona jest flaga wymiany (numer twarzy mod 2).

J - 26 bajtów

Funkcja przyjmuje numer twarzy jako argument i zwraca siatkę cyfr.

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

Używamy następującej kostki:

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

Przykład (spróbuj sam na 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|
+--+--+--+--+--+--+

Chleb i masło są 0&(|:|.). Jest to czasownik, który odwraca i obraca kostkę w taki sposób, aby odwiedzać każdą twarz po iteracyjnym zastosowaniu, co robimy za pomocą argumentu wejściowego. Wierzchołki sześcianu są generowane przez i.3#2, więc używamy tego jako punktu początkowego i bierzemy przednią powierzchnię0...{ gdy skończymy.

Drukowanie cyfr w postaci łańcucha kosztuje 8 znaków: {.@":"0@Jeśli pozwolono nam po prostu zwrócić tablicę, oznacza to oszczędność 8 całych znaków. [zaczyna się trząść pięścią i chwytać za niedostrzegalne]

> <> (Ryby) , 38 bajtów

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

Każde wyjście jest przechowywane jako dwa 2-cyfrowe wiersze. Wiersze są przechowywane jako ciągi znaków '/ =/2= 28"H'(oprócz wiersza)10 który jest dołączany po ciągu jako a). Pierwszy znak (/ = 47 ) służy do przekierowania przepływu programu podczas drugiej interakcji.

Szczyt 2*(53-n) elementy są odrzucane (gdzie n jest kodem znaku liczby wejściowej), a kolejne dwa kody są drukowane z nową linią między.

Układ:

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