Weisen Sie den 8 Eckpunkten eines Würfels nach Belieben die Nummern 0 bis 7 zu. Jedem Vertex muss genau eine Nummer zugewiesen werden.

Beispielsweise könnten Ihre Eckpunkte folgendermaßen zugewiesen werden:

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

Schreiben Sie ein Programm, das eine ganze Zahl von 0 bis 5 annimmt. Jede dieser 6 Zahlen ist auf beliebige Weise genau einer Fläche Ihres Würfels zugeordnet. Wenn eine dieser Zahlen eingegeben wird, müssen die 4 Scheitelpunktnummern der zugeordneten Fläche in einem 2 × 2-stelligen Quadrat stdout gedruckt werden. Das Gesicht ist von außerhalb des Würfels geradeaus zu betrachten. Alle 4 Gesichtsrotationen sind gültig.

Wenn beispielsweise 0 der Vorderseite des obigen Beispielwürfels zugeordnet ist, ist dies eine gültige Ausgabe für die Eingabe 0:

42
67

Das Gesicht kann bei jeder 90 ° -Drehung betrachtet werden, so dass diese auch gültig sind:

27
46

76
24

64
72

Diese Ausgabe (und ihre Rotationen) sind ungültig , da sie von der falschen Seite des Gesichts aus betrachtet werden:

24
76

Die gleiche Idee gilt für alle anderen Gesichter. Wenn z. B. 1 mit der Rückseite verknüpft ist, kann die Eingabe 1zu einer Ausgabe führen 13[newline]05(und 31[newline]50ist ungültig).

Die eigentliche Herausforderung besteht also darin, die Scheitelpunktnummern und -rotationen so auszuwählen, dass die Übersetzung der Eingabe in die 4 Scheitelpunktnummern einfach und kurz ist.

Der kürzeste Code in Bytes gewinnt. Tiebreaker ist früherer Beitrag. ( Handy-Byte-Zähler. )

Anmerkungen

• Sie können eine Funktion anstelle eines Programms schreiben. Es sollte eine Ganzzahl von 0 bis 5 sein und die 2 × 2-stellige Rasterzeichenfolge ausgeben oder zurückgeben.
• Nehmen Sie Eingaben von stdin, der Befehlszeile oder der Funktion arg entgegen. Sie können davon ausgehen, dass die Eingabe gültig ist.
• Die Ausgabe kann optional eine nachgestellte Newline enthalten.
• Teilen Sie uns unbedingt den von Ihnen gewählten Scheitelpunkt und die gewählte Fläche mit.

CJam, 23 16 Bytes

Es gibt wahrscheinlich eine elegante mathematische Lösung für dieses Problem. Aber ich habe keine Ahnung, wie ich eine finden soll, also ist es eine super komprimierte Hardcodierung!

Ich habe einen gefunden! Nun, es ist keine klassisch elegante mathematische Lösung, da sie bitweise Operationen verwendet, aber sie ist vollständig formelhaft.

li_o1^_p_6|o3+6%

Probieren Sie es online aus.

Cube-Layout

  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  

Erläuterung

Meine alte Antwort hat den Würfel bereits so angelegt, dass jedes Gesicht mit seiner ersten Scheitelpunktnummer (oben links) beschrieben werden kann, die der Gesichtsnummer entspricht. Aber ich wollte in der Lage sein, mehr Scheitelpunktzahlen unter Verwendung der Gesichtsnummer zu berechnen. Irgendwann kam mir die Idee, dass ich mit dem Fuß in die Tür gekommen bin, um die zweite Scheitelpunktnummer (oben links) als die Gesichtsnummer XOR 1 zu berechnen Mit dem oben gezeigten Layout und den folgenden Formeln kann ich jede Scheitelpunktnummer für ein Gesicht nganz genau berechnen :

• Oben links: n
• Oben rechts: n^1
• Unten links: (n^1)|6
• Unten rechts: ((n^1)+3)%6

Als Referenz reproduziere ich hier die Ausgabe für jedes Gesicht im gewünschten Layout:

Face:      0     1     2     3     4     5

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

Das ganze Programm läuft also darauf hinaus, die Eingabeflächen-Nummer zu lesen und diese Werte der Reihe nach zu erzeugen, allerdings mit leicht unterschiedlicher Drucklogik für verschiedene Scheitelpunkte. Beachten Sie, dass, da jeder Scheitelpunkt nach dem ersten mit einer Basis von beginnt n^1, ich diesen nur einmal berechnen muss, wodurch die Logik noch weiter komprimiert wird.

Der Nachwelt zuliebe und weil ich es immer noch für einen ziemlich guten Ansatz halte, hier meine alte Antwort.

CJam, 23 Bytes

Es gibt wahrscheinlich eine elegante mathematische Lösung für dieses Problem. Aber ich habe keine Ahnung, wie ich eine finden soll.

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

Probieren Sie es online aus.

Cube-Layout

  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  

Erläuterung

Der grundlegende Ansatz besteht darin, die Scheitelpunkte für jede Fläche auf engstem Raum fest zu codieren. Ähnlich wie bei der Basisumwandlungslösung von Optimizer wird die Scheitelpunktliste als Oktalzahl behandelt, die als ASCII-Zeichendaten gepackt ist. Aber hier enden die Gemeinsamkeiten, um weiteren Optimierungen Platz zu machen!

Hier sind die drei wichtigsten Optimierungen, die ich an der "naiven" Lösung vorgenommen habe:

• Legen Sie den Würfel so aus, dass jede Fläche mit ihrer Flächennummer als erste Scheitelpunktnummer beschrieben werden kann. Betrachtet man mein Würfel-Layout wie oben dargestellt, so sieht man, dass die Scheitelpunktnummer oben links für jede Fläche gleich der Flächennummer ist. Auf diese Weise kann ich sechs Scheitelpunkte weniger codieren, wenn ich die Eingabe zurückdrucken muss, wodurch ein Byte gespart wird.
• Packen Sie die Vertex-Daten in eine Zeichenfolge, für die jedes "Zeichen" ein Maximum größer als 256 hat. Wenn dieses Maximum über 256 hinaus ansteigt, nimmt die Länge der Zeichenfolge langsam ab, es wird jedoch immer wahrscheinlicher, dass eines der "Zeichen" 256 überschreitet und dies auch ist daher nicht mehr Bestandteil des 1-Byte-ASCII-Zeichensatzes. Also habe ich ein Programm geschrieben, das versucht, die Vertex-Daten in jeder Basis von 256 bis 1000 zu codieren. Dabei habe ich ungefähr 10 Basen gefunden, die ein Byte Zeichendaten im Vergleich zur Basis 256 speichern. Ich habe 487 gewählt, da dies auch die nette Eigenschaft hat, dass Die resultierende Zeichenfolge besteht vollständig aus druckbarem ASCII.
• Vermischt mit der ersten Optimierung wird die Ausgabe asymetrisch erzeugt. Der übliche Ansatz in CJam besteht darin, die Scheitelpunktdaten als Liste mit 2 Elementen aus Listen mit 2 Elementen zu formatieren, eine neue Zeile in die Mitte einzufügen und die Ausgabe implizit drucken zu lassen. Aber ich drucke stattdessen den ersten Scheitelpunkt (gleich der Eingabeflächen-Nummer) mit einem Operator, der keine neue Zeile hinzufügt, rufe die 3-Element-Liste der anderen Scheitelpunkte ab, nehme den nächsten Scheitelpunkt und drucke ihn mit einem Operator, der eine neue Zeile hinzufügt eine neue Zeile, und lassen Sie die anderen beiden Eckpunkte implizit gedruckt werden. Das spart ein 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 im Testprogramm

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

Erläuterung

Meine Würfelnummerierung sieht im aufgeklappten Zustand folgendermaßen aus:

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

Die linke obere Ecke hat die gleiche Nummer wie das Gesicht.

Die untere rechte Ecke hat eine Nummer (n+2)%6

Bei ungeraden ist ndie rechte obere Ecke (n+1)%6und die linke untere Ecke6

Denn auch ndie obere rechte Ecke ist 7und die untere linke ist(n+1)%6

Das Programm zeigt die ungeraden Zahlen wie gezeigt und die geraden Zahlen um 180 Grad gedreht an. Dies bedeutet, dass die obere rechte Ecke immer (n+1)%6und die untere linke immer ist (n+1)%2+6. Invertieren nund n+2ist einfacher (dies geschieht durch Setzen c=n+1und Verwenden dzum Addieren oder Subtrahieren 1oder -1nach Bedarf).

Ausgabe

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

Im Gegensatz zu vielen fortgeschritteneren Golfsprachen verfügt Element nicht über einen Komprimierungsoperator, sodass die Kürze der Lösung eng mit dem genauen verwendeten Nummerierungsschema verknüpft ist. Nach einigen Experimenten habe ich ein neues Nummerierungsschema erstellt, mit dem die Eckpunkte nur mit einfachen Rechenoperationen berechnet werden können.

  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  

Die obere linke Ecke ist 6 wenn gerade und 7 wenn ungerade. Die obere rechte Ecke ist die Gesichtsnummer. Unten links ist die Gesichtsnummer plus 2, Mod 6. Unten rechts ist 5 minus die Gesichtsnummer.

Hier ist eine Erklärung des Codes.

_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

Hier sind die Ausgaben für jedes der Gesichter:

0
60
25

1
71
34

2
62
43

3
73
52

4
64
01

5
75
10

Oktave, 108 100 68 50 Bytes

Natürlich gibt es eine Methode, die eleganter ist als meine vorherigen Ansätze, einfache Hardcodierung. Ich bin erstaunt, wie gut Octave für Codegolf geeignet ist als Matlab =)

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

Layout:

(Entschuldigung, ich habe vergessen, dies hinzuzufügen.)

Cube-Layout

  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  

Alte Versionen:

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

Noch ältere Versionen:

Dies wird wirklich ein 2x2x2-Array erzeugen und dann ein 'Slice' auswählen. Wir führen eine 3D-Matrix-Permutation durch und wählen jedes Mal die obere oder untere Schicht aus. (Diese Methode funktioniert nicht in Matlab, da ein Ausdruck anstelle einer Matrix indiziert wird.) Ich bin sicher, dass es direktere Methoden gibt, die kürzer wären.

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 (oder 26) Bytes

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

Das kann auch komprimiert werden, indem die Basis in eine 26-Byte-Version konvertiert wird .

Nimmt an, dass der Würfel wie folgt aussieht:

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

mit Gesichtern wie

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

Probieren Sie es hier online aus

CJam (25 Bytes)

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

Dieser enthält ein nicht druckbares Zeichen und einen Tabulator (der von der StackExchange-Software entstellt wird), also im xxd-Format:

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

Online-Demo

Würfel:

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

Dies ist reine Hardcodierung, wobei die Würfelscheitelpunkte ausgewählt werden, um die Basiskomprimierbarkeit zu maximieren. Ich decodiere zu 2-stelligen Zahlen, so dass keine mit 0 beginnen kann. Ich möchte auch nicht, dass jede mit 7 beginnt, da dies die zweite Basis zu hoch drückt. Daher müssen 0 und 7 eine lange Diagonale haben. Ich möchte, dass zuerst eine 10-Kante gesetzt wird, um den Wert zu verringern, den ich codiere. Davon abgesehen gibt es ein gutes Maß an Flexibilität, ohne die Byteanzahl zu ändern.

Ich bin ein wenig enttäuscht, dass es nach dem Entfernen des ersten Zeichens aus der magischen Zeichenfolge erforderlich ist, es in ein int umzuwandeln, bevor es als Basis für die Basiskonvertierung verwendet wird. Hoffentlich werden zukünftige Versionen von CJam dieses Byte speichern, obwohl es zu spät sein wird, dies hier auszunutzen.

JavaScript (ES6), 53 62

Bearbeiten Speichere 8 Bytes mit Hilfe von Template-Strings, danke @NinjaBearMonkey. Beachten Sie, dass die Zeilenumbrüche in Anführungszeichen von Bedeutung sind und nicht reduziert werden können.

Kann in Javascript nicht klug sein, es ist zu wortreich.

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

Ausgabe 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

Schauen Sie sich das Snippet an, um die Nummernzuordnungen zu überprüfen ( das hat Spaß gemacht)

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

Vielen Dank an @rcrmn für den Vorschlag, ein Lambda zu verwenden, um 4 Bytes zu sparen. Ich war mir nicht sicher, ob ich es anonym lassen sollte, aber es scheint hier auf Meta diskutiert worden zu sein und entschied, dass dies in Ordnung war.

Hier ist es als 40-Byte-Funktion, zum Vergleich mit meiner Rev 0 Ruby-Antwort, auch unten (Original C-Antwort ist in einem separaten Beitrag.)

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

Weitere Inspiration von Runer112: Dies beruht auf einer Änderung des Nummerierungsschemas, das in seiner letzten (16 Byte!) Antwort verwendet wurde. Ein direkter Port von PhiNotPis Schema würde die gleiche Punktzahl ergeben.

Wenn Sie die Nummerierung von Rev 0 um einen Schritt verschieben und alles XOR 1 nehmen, erhalten Sie den folgenden Würfel:

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

Ausgabe

0
10
63

1
01
74

2
32
65

3
23
70

4
54
61

5
45
72

Ruby Rev 0, 56 52 50

Gespeicherte 4 Bytes von unnötigem Entfernen ()%6von c-dund weiteren 2 (inspiriert von runer112) durch6+c%2 --> 6|c .

Punktzahl ist für die Funktion, die nur die erste Zeile ist. Ich bin neu in Ruby und ich bin überrascht, dass ich keinen kürzeren Weg als 12 Zeichen (11 plus Zeilenvorschub) finde, um eine Benutzereingabenummer in n zu bekommen. Wenn Sie also eine Funktion anstelle eines Programms ausführen, wird 1 Byte gespart.

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)

Dies ist ein Port meiner C-Antwort. In C gibt der %Operator einen negativen Wert mit einer negativen Zahl zurück. In Ruby wird immer ein positiver Wert zurückgegeben, sodass keine 1 hinzugefügt werden muss c. Infolgedessen ist es vorteilhaft, die Nummerierung der Flächen wie folgt um 1 zu verschieben:

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

Mit der neuen Gesichtsnummerierung druckt das Programm die Abschlüsse wie oben gezeigt und die Gewinnchancen werden um 180 Grad gedreht:

1
21
70

2
12
63

3
43
72

4
34
65

5
05
74

0
50
61

Pyth, 30

Danke @Jakube für 2 Bytes.

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

Probieren Sie es hier aus.

Golftipps von Pyth-Experten werden gerne entgegengenommen. Insbesondere denke ich, dass der Ausgabebereich einige Verbesserungen haben könnte.

Port des folgenden Pythons: ...

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]

... das ist ein Hafen von

Pure Bash, 130

Zum Zwecke der Erklärung:

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

Die Würfelscheitelpunkte sind folgendermaßen nummeriert:

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

Und die Gesichter sind folgendermaßen nummeriert:

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

Das Swap Spalte gibt an, in welcher Reihenfolge die Eckpunkte in der Ausgabe umgeschaltet werden sollen.

Der Algorithmus beginnt mit allen Eckpunkten {0..7}. Scheitelpunkte werden gemäß den in den Scheitelpunktnummern festgelegten Bits entfernt:

• Für die Flächen 0,1 und 2 werden Scheitelpunkte mit gelöschten Bits 1,2 bzw. 3 beibehalten
• Für die Flächen 3, 4 und 5 werden Scheitelpunkte mit gesetzten Bits 1, 2 bzw. 3 beibehalten

Die "beibehaltenen" Eckpunkte werden an eine Zeichenfolge angehängt. Die Zeichenfolge wird je nachdem, ob das Swap-Flag (Face-Nummer Mod 2) gesetzt ist, als Zeichen 0, 1, 2, 3 oder umgekehrt ausgegeben.

J - 26 Bytes

Funktion, die die Gesichtsnummer als Argument nimmt und das Ziffernraster zurückgibt.

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

Wir verwenden den folgenden Würfel:

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

Beispiel (versuchen Sie es selbst bei 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|
+--+--+--+--+--+--+

Das Brot und die Butter ist 0&(|:|.). Dies ist ein Verb, das den Würfel so umkehrt und dreht, dass bei iterativer Anwendung jedes Gesicht aufgerufen wird. Dies geschieht mit dem Eingabeargument. Die Scheitelpunkte des Würfels werden von generiert i.3#2, daher verwenden wir diesen als Ausgangspunkt und nehmen die Vorderseite, 0...{wenn wir fertig sind.

Das Drucken der Ziffern als Zeichenfolge kostet 8 Zeichen: {.@":"0@Wenn wir einfach ein Array zurückgeben könnten, wären dies 8 ganze Zeichen. [Fängt an, mit der Faust zu zittern und nicht wahrzunehmen]

> <> (Fisch) , 38 Bytes

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

Jede Ausgabe wird in zwei zweistelligen Zeilen gespeichert. Die Zeilen werden als Zeichencodes in der Zeichenfolge gespeichert '/ =/2= 28"H'(mit Ausnahme der Zeile, 10die nach der Zeichenfolge als angehängt wird a). Das erste Zeichen (/ = 47 ) wird verwendet, um den Programmfluss bei der zweiten Interaktion umzuleiten.

Die Spitze 2*(53-n) Elemente werden verworfen (wobei n der Zeichencode der eingegebenen Nummer ist) und die nächsten beiden Codes werden mit einem Zeilenumbruch zwischen gedruckt.

Layout:

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