Attribuez les chiffres de 0 à 7 aux 8 sommets d'un cube comme vous le souhaitez. Un seul numéro doit être attribué à chaque sommet.

Par exemple, vos sommets peuvent être affectés comme ceci:

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

Écrivez un programme qui accepte un entier de 0 à 5. Chacun de ces 6 nombres est associé à exactement une face de votre cube de la manière que vous voulez. Lorsqu'un de ces nombres est entré, les 4 nombres de sommets de la face associée doivent être imprimés sur stdout dans un carré de 2 × 2 chiffres. Le visage doit être vu directement de l'extérieur du cube. Les 4 rotations de visage sont valides.

Par exemple, si 0 est associé à la face avant de l'exemple de cube ci-dessus, alors ce serait une sortie valide pour l'entrée 0:

42
67

Le visage peut être visualisé à n'importe quelle rotation de 90 °, ils sont donc également valables:

27
46

76
24

64
72

Cette sortie (et ses rotations) ne sont pas valides , car elles sont vues du mauvais côté du visage:

24
76

La même idée s'applique à tous les autres visages. Par exemple, si 1 est associé à la face arrière, l'entrée 1peut produire une sortie 13[newline]05(et 31[newline]50ne sera pas valide).

Le véritable défi consiste donc à choisir vos nombres de sommets et vos rotations de sorte que la traduction de l'entrée en ses 4 nombres de sommets soit facile et courte.

Le code le plus court en octets gagne. Tiebreaker est un post antérieur. ( Compteur d'octets pratique. )

Remarques

• Vous pouvez écrire une fonction au lieu d'un programme. Il doit prendre un entier de 0 à 5 et imprimer ou renvoyer la chaîne de grille à 2 × 2 chiffres.
• Prenez l'entrée de stdin, de la ligne de commande ou de la fonction arg. Vous pouvez supposer que la saisie est valide.
• La sortie peut éventuellement avoir une nouvelle ligne de fin.
• Assurez-vous de nous indiquer les nombres de sommets et de faces que vous avez choisis.

CJam, 23 16 octets

Il existe probablement une élégante solution mathématique à ce problème. Mais je ne sais pas comment en trouver un, donc c'est un codage dur super compressé!

J'en ai trouvé un! Eh bien, ce n'est pas une solution mathématique classique élégante car elle utilise des opérations au niveau du bit, mais elle est entièrement formule.

li_o1^_p_6|o3+6%

Essayez-le en ligne.

Disposition du cube

  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  

Explication

Mon ancienne réponse disposait déjà le cube de telle sorte que chaque face peut être décrite avec son premier numéro de sommet (en haut à gauche) égal au numéro de face. Mais je voulais pouvoir calculer plus de nombres de sommets en utilisant le nombre de faces. À un moment donné, j'ai eu l'idée de mettre le pied dans la porte, de calculer le deuxième nombre de sommets (en haut à gauche) comme le numéro de face XOR 1. Et après un certain temps d'essais et d'erreurs, j'ai réussi à trouver avec la disposition ci-dessus et les formules ci-dessous qui me permettent de calculer chaque nombre de sommets pour un visage de nmanière assez succincte:

• En haut à gauche: n
• En haut à droite: n^1
• En bas à gauche: (n^1)|6
• En bas à droite: ((n^1)+3)%6

Pour référence, je vais reproduire la sortie pour chaque face dans la disposition souhaitée ici:

Face:      0     1     2     3     4     5

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

Donc, tout le programme se résume à lire le numéro de face d'entrée et à produire ces valeurs dans l'ordre, bien qu'avec une logique d'impression légèrement différente pour différents sommets. Notez que, parce que chaque sommet après le premier commence par une base de n^1, je n'ai besoin de le calculer qu'une seule fois, ce qui compacte encore plus la logique.

Pour la postérité, et parce que je pense que c'était encore une assez bonne approche, voici mon ancienne réponse.

CJam, 23 octets

Il existe probablement une élégante solution mathématique à ce problème. Mais je ne sais pas comment en trouver un, donc c'est un codage dur super compressé!

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

Essayez-le en ligne.

Disposition du cube

  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  

Explication

L'approche de base utilisée consiste à coder en dur les sommets de chaque face dans le moins d'espace possible. De la même manière que la solution de conversion de base d'Optimizer, celle-ci traite la liste de sommets comme un nombre octal compressé en données de caractères ASCII. Mais c'est là que s'arrêtent les similitudes pour faire place à de nouvelles optimisations!

Voici les trois principales optimisations que j'ai apportées à la solution "naïve":

• Disposez le cube de sorte que chaque face puisse être décrite avec son numéro de face comme premier numéro de sommet. En regardant ma disposition de cube comme présenté ci-dessus, on peut voir que le nombre de sommets en haut à gauche de chaque face est égal au nombre de faces. Cela me permet de coder six sommets de moins au prix d'avoir à réimprimer l'entrée, ce qui s'avère économiser un octet.
• Emballez les données de sommet dans une chaîne pour laquelle chaque "caractère" a un maximum supérieur à 256. Comme ce maximum dépasse 256, la longueur de la chaîne diminue lentement, mais il devient de plus en plus probable qu'un "caractère" dépasse 256 et soit ne fait donc plus partie du jeu de caractères ASCII à 1 octet. J'ai donc écrit un programme qui essaie d'encoder les données de sommets dans chaque base de 256 à 1000, avec lequel j'ai trouvé environ 10 bases qui économisent un octet de données de caractères par rapport à la base 256. J'ai choisi 487, car cela a aussi la belle propriété qui la chaîne résultante est entièrement composée de caractères ASCII imprimables.
• Mélangé avec la première optimisation, produisez la sortie de manière asymétrique. L'approche habituelle dans CJam serait de formater les données de sommet comme une liste à 2 éléments de listes à 2 éléments, d'insérer une nouvelle ligne au milieu et de laisser la sortie être implicitement imprimée. Mais j'imprime plutôt le premier sommet (égal au numéro de la face d'entrée) avec un opérateur qui n'ajoute pas de nouvelle ligne, récupère la liste à 3 éléments des autres sommets, saisis le sommet suivant et l'imprime avec un opérateur qui ajoute une nouvelle ligne et laissez les deux autres sommets être implicitement imprimés. Cela économise un octet.

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

Non testé dans le programme de test

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

Explication

Ma numérotation des cubes, une fois dépliée, ressemble à ceci:

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

Le coin supérieur gauche a le même numéro que le visage.

Le coin inférieur droit a un numéro (n+2)%6

Pour impair, nle coin supérieur droit est (n+1)%6et le coin inférieur gauche est6

Car même nle coin supérieur droit est 7et le coin inférieur gauche est(n+1)%6

Le programme affiche les nombres impairs comme indiqué et les nombres pairs ont pivoté de 180 degrés. Cela signifie que le coin supérieur droit est toujours (n+1)%6et le coin inférieur gauche est toujours (n+1)%2+6. Inverser net n+2est plus facile (cela se fait en définissant c=n+1et en utilisant dpour ajouter ou soustraire 1ou -1si nécessaire.)

Production

$ ./a
0
21
70

$ ./a
1
12
63

$ ./a
2
43
72

$ ./a
3
34
65

$ ./a
4
05
74

$ ./a
5
50
61

Élément, 18

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

Contrairement à de nombreux langages de golf plus avancés, Element ne possède pas d'opérateur de compression, de sorte que la brièveté de la solution est liée assez étroitement au schéma de numérotation exact utilisé. Après quelques expérimentations, j'ai créé un nouveau schéma de numérotation qui permet de calculer les sommets en utilisant uniquement des opérations arithmétiques simples.

  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  

Le coin supérieur gauche est 6 s'il est pair et 7 s'il est impair. Le coin supérieur droit est le numéro de visage lui-même. Le coin inférieur gauche est le numéro du visage, plus 2, le mod 6. Le coin inférieur droit est 5 moins le numéro du visage.

Voici une explication du code.

_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

Voici les sorties pour chacune des faces:

0
60
25

1
71
34

2
62
43

3
73
52

4
64
01

5
75
10

Octave, 108 100 68 50 octets

Bien sûr, il existe un moyen de le faire beaucoup plus élégant que mes approches précédentes, le codage en dur simple. Je suis étonné de voir comment Octave est bien plus adapté au codegolf qu'à Matlab =)

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

Disposition:

(Désolé, j'ai oublié d'ajouter ceci.)

Disposition du cube

  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  

Anciennes versions:

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

Versions encore plus anciennes:

Cela va vraiment faire un tableau 2x2x2 puis choisir une «tranche». Nous effectuons une permutation matricielle 3D et choisissons à chaque fois la tranche supérieure ou inférieure. (Celui-ci ne fonctionne pas dans matlab à cause de l'indexation d'une expression plutôt que d'une matrice) Je suis sûr qu'il y aurait des façons plus directes de le faire qui seraient plus courtes.

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 (ou 26) octets

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

qui peut également être compressé en utilisant la conversion de base en une version de 26 octets .

Suppose que le cube ressemble à:

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

avec des visages comme

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

Essayez-le en ligne ici

CJam (25 octets)

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

Celui-ci contient un caractère non imprimable et un onglet (qui sera modifié par le logiciel StackExchange), donc au format xxd:

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

Démo en ligne

Cube:

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

Il s'agit d'un codage en dur pur, les sommets du cube étant sélectionnés pour maximiser la compressibilité de base. Je décode en nombres à 2 chiffres, donc aucun d'entre eux ne peut commencer par 0. Je ne veux pas non plus commencer par 7, car cela pousse la deuxième base trop haut. Par conséquent, 0 et 7 doivent être sur une longue diagonale. Je veux qu'un bord de 10 passe en premier pour réduire la valeur que j'encode. En dehors de cela, il y a une bonne quantité de flexibilité sans changer le nombre d'octets.

Je suis légèrement déçu qu'ayant sorti le premier caractère de la chaîne magique, il est nécessaire de le convertir en entier avant de l'utiliser comme base pour la conversion de base. Espérons que les futures versions de CJam enregistreront cet octet, bien qu'il soit trop tard pour l'exploiter ici.

JavaScript (ES6), 53 62

Modifier Enregistrer 8 octets à l'aide de chaînes de modèle, thx @NinjaBearMonkey. Attention, les sauts de ligne à l'intérieur des guillemets sont importants et ne peuvent pas être réduits.

Impossible d'être intelligent en Javascript, c'est trop verbeux.

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

Production 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

Voir l'extrait de veify les associations (nombre qui était amusant)

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 Rév.1, 40 36

->(c){print(c^1,c,"\n",6|c,(c+3)%6)}

Merci à @rcrmn d'avoir suggéré d'utiliser un lambda pour économiser 4 octets. Je n'étais pas sûr de le laisser anonyme, mais il semble avoir été discuté sur meta ici et décidé que c'était OK.

Ici, il s'agit d'une fonction de 40 octets, pour comparaison avec ma réponse Rub 0 Rev, également ci-dessous (la réponse d'origine C est dans un article séparé.)

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

Inspiration supplémentaire de Runer112: Cela repose sur une modification du schéma de numérotation utilisé dans sa dernière réponse (16 octets!). Un port direct du schéma de PhiNotPi donnerait le même score.

En décalant la numérotation de Rev 0 d'une étape et en prenant tout XOR 1, nous obtenons le cube suivant:

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

Production

0
10
63

1
01
74

2
32
65

3
23
70

4
54
61

5
45
72

Ruby Rév.0, 56 52 50

Enregistré 4 octets en supprimant les inutiles ()%6de c-det 2 autres (inspiré par runer112) par6+c%2 --> 6|c .

Le score correspond à la fonction, qui n'est que la première ligne. Je suis nouveau sur Ruby et je suis surpris de ne pas trouver un moyen plus court que 12 caractères (11 plus la nouvelle ligne) pour obtenir un numéro d'entrée utilisateur en n. Par conséquent, faire une fonction au lieu d'un programme économise 1 octet.

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)

Ceci est un port de ma réponse C. En C, l' %opérateur renvoie une valeur négative avec un nombre négatif. Dans Ruby, il renvoie toujours une valeur positive, il n'est donc pas nécessaire d'ajouter 1 à c. Par conséquent, il est avantageux de décaler la numérotation des faces de 1 comme ci-dessous:

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

Avec la nouvelle numérotation des visages, le programme imprime les égalités comme indiqué ci-dessus et les cotes ont pivoté de 180 degrés:

1
21
70

2
12
63

3
43
72

4
34
65

5
05
74

0
50
61

Pyth, 30

Merci @Jakube pour 2 octets.

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

Essayez-le ici.

Les conseils de golf d'experts pyth seront gracieusement acceptés. En particulier, je pense que la section de sortie pourrait avoir quelques améliorations.

Port du python suivant: ...

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]

... qui est un port de

Pure Bash, 130

Aux fins d'explication:

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

Les sommets du cube sont numérotés ainsi:

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

Et les visages sont numérotés ainsi:

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

La Swapcolonne indique que l'ordre des sommets doit être commuté dans la sortie.

L'algorithme commence avec tous les sommets {0..7}. Les sommets sont éliminés en fonction des bits définis dans les nombres de sommets:

• Pour les faces 0,1 et 2, les sommets avec les bits 1,2 ou 3 effacés respectivement sont conservés
• Pour les faces 3,4 et 5, les sommets avec respectivement les bits 1,2 ou 3 sont conservés

Les sommets "conservés" sont ajoutés à une chaîne. La chaîne est sortie en caractères 0,1 puis 2,3 ou vice versa, selon que le drapeau de swap (numéro de visage mod 2) est défini.

J - 26 octets

Fonction prenant le numéro de visage comme argument et renvoyant la grille de chiffres.

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

Nous utilisons le cube suivant:

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

Exemple (essayez vous-même sur 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|
+--+--+--+--+--+--+

Le pain et le beurre sont 0&(|:|.). Il s'agit d'un verbe qui inverse et fait pivoter le cube de manière à visiter chaque visage lorsqu'il est appliqué de manière itérative, ce que nous faisons en utilisant l'argument d'entrée. Les sommets du cube sont générés par i.3#2, nous utilisons donc cela comme point de départ et prenons la face avant0...{ lorsque nous avons terminé.

L'impression des chiffres sous forme de chaîne coûte 8 caractères: {.@":"0@si nous pouvions simplement renvoyer un tableau, cela représente une économie de 8 caractères entiers. [commence à serrer le poing et à saisir de façon indiscernable]

> <> (Poisson) , 38 octets

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

Chaque sortie est stockée sur deux lignes à 2 chiffres. Les lignes sont stockées sous forme de codes de caractères dans la chaîne '/ =/2= 28"H'(sauf la ligne 10qui est ajoutée après la chaîne en tant que a). Le premier caractère (/ = 47 ) est utilisé pour rediriger le flux du programme lors de la deuxième interaction.

Les 2*(53-n)éléments supérieurs sont supprimés (où n est le code de caractère du numéro d'entrée) et les deux codes suivants sont imprimés avec une nouvelle ligne entre.

Disposition:

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