Geben Sie ein Gesicht auf einem nummerierten Würfel aus

19

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.
code-golf geometry Calvins Hobbys
quelle

Antworten:

17

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.
Runer112
quelle
2
Ich habe Permutationen als einen eleganten mathematischen Ansatz ausprobiert und es ist ausführlicher als eine harte Kodierung ohne Ihre Optimierungen.
Peter Taylor
Ihre neueste Antwort ist brillant. Ich denke, Sie hätten es als separate Antwort veröffentlichen sollen, da es sich um einen völlig anderen Ansatz handelt und eine weitere Aufwertung verdient. Grundsätzlich haben Sie den gleichen Würfel wie meine C-Antwort, aber mit den ersten drei geraden Ecken, die um eine Stelle verschoben wurden. Ich kann nicht glauben, dass ich etwas verpasst habe 6+n%2 --> 6|n(das habe ich bereits in meine Ruby-Antwort aufgenommen.) Beachten Sie, dass Sie durch Ausführen der Transformation n --> n^1für die Gesichter Ihre Formeln vereinfachen könnten, obwohl ich davon ausgehe, dass Sie sie gewinnen , wenn Sie sie verwerfen nund weitermachen n^1nicht helfen, Ihre Gäste.
Level River St
@steveverrill Danke für das Lob! Ich habe im Chat gefragt, ob ich dies als eine völlig neue Antwort posten soll, aber es gab keinen Konsens, also habe ich es nicht getan. Ich war definitiv zufrieden mit mir selbst, als mir klar wurde, dass eine sorgfältige Bestellung der nund n^1Paare um den Würfel es mir ermöglichen würde, einen anderen Scheitelpunkt mit just zu berechnen |6. Und ich habe diese n --> n^1Transformation nicht gesehen , was definitiv Sinn macht. Aber Sie haben zu Recht vermutet, dass sich dies nicht auf meine Punktzahl auswirkt, und ich werde es wahrscheinlich so lassen, wie es ist.
Runer112
Ich habe Ihre XOR-Idee in meine Ruby-Antwort aufgenommen. Es gibt eine Ersparnis von 10 (zusätzlich zu den 2 für 6+n%2 --> 6|n) Ich hoffe, es macht Ihnen nichts aus. Ich habe die n --> n^1Transformation für die Gesichter verwendet, sodass meine letzte Revision dieselben Ausgaben wie Ihre liefert, jedoch mit unterschiedlichen Eingaben. Übrigens, ich denke nicht, dass Bit-Operationen unelegant sind, es hängt alles davon ab, wie Sie sie verwenden!
Level River St
1
1 Zeichen kürzer in GolfScript:~.1^..n@6|@3+6%
Peter Taylor
14

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
Level River St
quelle
5
+1 Dies ist die Art eleganter mathematischer Lösung, die ich mir vorgestellt habe. Leider ist es in C implementiert ...
Runer112
1
@ Runer112 Danke. Leider ist C die Sprache, die ich am besten kenne. Ich lerne Ruby, aber ich bin immer noch ein Anfänger. Ruby sollte in der Lage sein, diese Punktzahl zu knacken, aber wahrscheinlich nicht mit Cjam konkurrieren. Vielleicht werde ich später in Ruby schreiben, oder einfach nur ein paar kleineren Verbesserungen meiner C Antwort finden (zum Beispiel durch eine Änderung c%6an c%=6und Drehen des Gesichts , so dass es zuerst kommt, soll es möglich sein , einige Modul Berechnungen zu eliminieren.) Eine andere Sache mit heißt zu experimentieren Verschiebt man die Gesichtsbezeichnung um eine Stelle, so bekomme ich n-1,n,n+1statt n,n+1,n+2.
Level River St
@steveverrill du deklarierst bereits nglobal, also könntest du ein paar Bytes sparen, indem du es höher deklarierst, ändere die Signatur auf f()? Oder betrachten wir hier nur die fFunktion?
Dwcanillas
@ Dwcanillas "You may write a function instead of a program"also zähle ich nur die Funktion. Auf jeden Fall war dies nur ein Proof of Concept in der Sprache, die ich am besten kenne. Ich bin mehr daran interessiert, meine Ruby-Antwort zu verkürzen, die von Anfang an viel kürzer war als diese.
Level River St
8

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
PhiNotPi
quelle
+1: Obwohl ich finde, dass Ihr Code nicht zu entziffern ist, ist es schön zu sehen, wie dies in einer Golfsprache abschneidet. Sieht so aus, als wären Sie derzeit auf dem 3. Platz, hinter 2 Antworten von CJam: Peter Taylor und Runer 112.
Level River St
Jetzt ist es ein solider zweiter Platz, aber ich sehe nicht voraus, dass es CJam schlagen wird.
PhiNotPi
6

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)),:))
fehlerhaft
quelle
5

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

Optimierer
quelle
4

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.

Peter Taylor
quelle
4

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)

Code-Snippet anzeigen

edc65
quelle
1
Wenn Sie ES6- Vorlagenzeichenfolgen verwenden , können Sie stattdessen aktuelle Zeilenumbrüche verwenden \n, wodurch 8 Byte eingespart werden sollten.
NinjaBearMonkey
Sie müssen anstelle von Anführungszeichen für Vorlagenzeichenfolgen Häkchen verwenden.
NinjaBearMonkey
Richtig, so habe ich es tatsächlich getestet.
edc65
4

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
Level River St
quelle
Ich glaube, Sie können die Funktion verkürzen, indem Sie Lambdas verwenden. Dadurch ->(x){...code...}bleibt Ihre Funktionsdefinition 4 Zeichen kürzer. Sie müssen es dann einer Variablen zuweisen, um es zu verwenden, und es mit #call
rorlork
@rcrmn danke, du hast recht, f=->(c){print(c^1,c,"\n",6|c,(c+3)%6)}läuft und ist 2 Zeichen kürzer (4 Zeichen kürzer, wenn ich das weglasse f=). Ich bin mir nicht sicher, ob es fair ist, darauf zu verzichten, f=aber die Frage besagt nicht, dass die Funktion nicht anonym sein kann. Was ich merkwürdig finde, ist, dass diese Syntax völlig anders ist als die für Anfänger gezeigte Syntax, bei der der übergebene Parameter in geschweiften Klammern steht:f=lambda{|c|print(c^1,c,"\n",6|c,(c+3)%6)}
Level River St
Dies ist ein Lambda-Literal. Und in der Tat finde ich es immer schwierig, eine Referenz zu finden, wenn ich mich an die Syntax erinnern muss ...
rorlork
3

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.

Digitales Trauma
quelle
1

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]

algorithmshark
quelle
Die Ergebnisse für 1, 4 und 5 scheinen umgekehrt zu sein
Digitales Trauma
0

> <> (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.
randomra
quelle