19

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.

code-golf geometry Loisirs de Calvin
la source

17

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.

Runer112
la source

2

J'ai essayé les permutations comme une approche mathématique élégante et c'est plus verbeux que le codage en dur sans vos optimisations.

Peter Taylor

Votre dernière réponse est brillante. Je pense que vous auriez dû le poster comme une réponse séparée car c'est une approche complètement différente et digne d'un autre vote positif. Fondamentalement, vous avez le même cube que ma réponse C, mais avec les trois premiers coins pairs décalés d'une place. Je ne peux pas croire que j'ai raté 6+n%2 --> 6|n(j'ai déjà incorporé cela dans ma réponse Ruby.) Notez qu'en effectuant la transformation n --> n^1sur les visages, vous pourriez simplifier vos formules, bien que je suppose que lorsque vous vous en débarrassez net continuez avec n^1cela, vous avez gagné 't aider votre score.

Level River St

@steveverrill Merci pour les éloges! J'ai demandé dans le chat si je devais poster ceci comme une réponse entièrement nouvelle, mais il n'y avait pas de consensus donc je ne l'ai pas fait. J'étais vraiment content de moi quand j'ai réalisé que commander soigneusement les paires net n^1autour du cube me permettrait de calculer un autre sommet avec juste |6. Et je n'ai pas vu cette n --> n^1transformation, ce qui a vraiment du sens. Mais vous avez correctement supposé que cela n'affecterait pas réellement mon score, alors je vais probablement le laisser tel quel.

Runer112

Je suis allé de l'avant et j'ai intégré votre idée XOR dans ma réponse Ruby. Cela donne une économie de 10 (en plus des 2 pour 6+n%2 --> 6|n) J'espère que cela ne vous dérange pas. J'ai utilisé la n --> n^1transformation sur les visages, donc ma dernière révision donne les mêmes sorties que la vôtre, mais avec des entrées différentes. BTW, je ne pense pas que les opérations sur les bits soient inélégantes, tout dépend de la façon dont vous les utilisez!

Level River St

1

1 caractère plus court dans 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);}

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

Level River St
la source

5

+1 C'est le genre de solution mathématique élégante que j'imaginais. Malheureusement, il est implémenté en C ...

Runer112

1

@ Runer112 Merci. Malheureusement, C est le langage que je connais le mieux. J'apprends Ruby mais je suis encore débutant. Ruby devrait être en mesure de battre ce score, mais probablement pas rivaliser avec Cjam. Peut - être que je vais poster sur Ruby plus tard, ou tout simplement trouver quelques améliorations mineures à ma réponse C (par exemple en changeant c%6à c%=6et faire tourner le visage il vient d' abord, il devrait être possible d'éliminer certains calculs du module.) Une autre chose à expérimenter est - déplacer l'étiquetage du visage d'un endroit, donc je reçois à la n-1,n,n+1place de n,n+1,n+2.

Level River St

@steveverrill vous déclarez déjà nglobal, vous pouvez donc économiser quelques octets en le déclarant plus haut, changer la signature en f()? Ou regardons-nous seulement la ffonction ici?

dwcanillas

@dwcanillas "You may write a function instead of a program"donc je ne compte que la fonction. En tout cas, ce n'était qu'une preuve de concept dans la langue que je connais le mieux. Je suis plus intéressé à raccourcir ma réponse Ruby, qui était déjà beaucoup plus courte au départ.

Level River St

8

É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:

PhiNotPi
la source

+1: Bien que je trouve votre code indéchiffrable, il est agréable de voir comment cela se traduit dans un langage de golf. On dirait que vous êtes actuellement en 3e position commune, derrière 2 réponses CJam: Peter Taylor et Runer 112.

Level River St

Maintenant, c'est une solide deuxième place, mais je ne pense pas qu'il bat CJam.

PhiNotPi

6

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

flawr
la source

5

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

Optimiseur
la source

4

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.

Peter Taylor
la source

4

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)

Afficher l'extrait de code

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>

Développer l'extrait

edc65
la source

1

Si vous utilisez des chaînes de modèle ES6 , vous pouvez utiliser des caractères de nouvelle ligne actifs au lieu de \n, ce qui devrait économiser 8 octets.

NinjaBearMonkey

Vous devez utiliser des graduations `au lieu de guillemets pour les chaînes de modèle.

NinjaBearMonkey

C'est comme ça que je l'ai testé en fait.

edc65

4

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

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:

Level River St
la source

Je crois que vous pouvez raccourcir la fonction en utilisant lambdas: ->(x){...code...}ce qui laisse votre définition de fonction 4 caractères plus courte. Vous devez ensuite l'assigner à une variable pour l'utiliser, et l'appeler avec #call

rorlork

@rcrmn merci, vous avez raison, f=->(c){print(c^1,c,"\n",6|c,(c+3)%6)}s'exécute et est 2 caractères plus court (4 caractères plus court si j'omets le f=). Je ne sais pas s'il est juste d'omettre f=mais la question ne dit pas que la fonction ne peut pas être anonyme. Ce que je trouve étrange, c'est que cette syntaxe est totalement différente de la syntaxe montrée aux débutants, qui a le paramètre passé à l'intérieur des accolades:f=lambda{|c|print(c^1,c,"\n",6|c,(c+3)%6)}

Level River St

C'est ce qu'on appelle un littéral lambda. Et en effet, j'ai toujours du mal à trouver une référence quand j'ai besoin de me souvenir de la syntaxe ...

rorlork

3

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.

Traumatisme numérique
la source

1

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]

algorithmshark
la source

Les résultats pour 1, 4 et 5 semblent être inversés

Digital Trauma

0

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

randomra
la source

Sortie d'une face sur un cube numéroté

Remarques

Réponses:

CJam, 23 16 octets

Disposition du cube

Explication

CJam, 23 octets

Disposition du cube

Explication

C, 69

Élément, 18

Octave, 108 100 68 50 octets

Disposition:

Disposition du cube

Anciennes versions:

CJam, 31 28 (ou 26) octets

CJam (25 octets)

JavaScript (ES6), 53 62

Ruby Rév.1, 40 36

Ruby Rév.0, 56 52 50

Pyth, 30

Python, 109

Pure Bash, 130

J - 26 octets

> <> (Poisson) , 38 octets