Assegna i numeri da 0 a 7 agli 8 vertici di un cubo nel modo che preferisci. È necessario assegnare esattamente un numero a ciascun vertice.

Ad esempio, i vertici potrebbero essere assegnati in questo modo:

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

Scrivi un programma che includa un numero intero compreso tra 0 e 5. Ciascuno di questi 6 numeri è associato esattamente a una faccia del cubo nel modo che preferisci. Quando viene inserito uno di questi numeri, i 4 numeri dei vertici della faccia associata devono essere stampati su stdout in un quadrato di 2 × 2 cifre. La faccia deve essere vista direttamente dall'esterno del cubo. Tutte le 4 rotazioni della faccia sono valide.

Ad esempio, se 0 è associato alla faccia anteriore del cubo di esempio sopra, questo sarebbe un output valido per l'input 0:

42
67

La faccia può essere visualizzata a qualsiasi rotazione di 90 °, quindi sono validi anche:

27
46

76
24

64
72

Questo output (e le sue rotazioni) non sono validi , poiché sono visualizzati dal lato sbagliato della faccia:

24
76

La stessa idea si applica a tutte le altre facce. ad es. se 1 è associato alla faccia posteriore, l'input 1potrebbe produrre output 13[newline]05(e non 31[newline]50sarebbe valido).

Quindi la vera sfida è scegliere i numeri dei vertici e le rotazioni in modo tale che tradurre l'ingresso nei suoi 4 numeri dei vertici sia facile e breve.

Vince il codice più breve in byte. Tiebreaker è post precedente. ( Pratico contatore di byte. )

Appunti

• È possibile scrivere una funzione anziché un programma. Dovrebbe richiedere un numero intero compreso tra 0 e 5 e stampare o restituire la stringa della griglia di 2 × 2 cifre.
• Accetta input da stdin, dalla riga di comando o dalla funzione arg. Si può presumere che l'input sia valido.
• L'output può facoltativamente avere una nuova riga finale.
• Assicurati di dirci il vertice e il numero di facce che hai scelto.

CJam, 23 16 byte

Probabilmente esiste un'elegante soluzione matematica a questo problema. Ma non ho idea di come trovarne uno, quindi è una codifica hard super compressa!

Ne ho trovato uno! Bene, non è una soluzione matematica classicamente elegante in quanto utilizza operazioni bit per bit, ma è interamente di formula.

li_o1^_p_6|o3+6%

Provalo online.

Layout del cubo

  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  

Spiegazione

La mia vecchia risposta disponeva già il cubo in modo tale che ogni faccia potesse essere descritta con il suo primo numero di vertice (in alto a sinistra) uguale al numero della faccia. Ma volevo essere in grado di calcolare più numeri di vertice usando il numero di faccia. Ad un certo punto, mi è venuta l'idea che ha messo il piede nella porta, per calcolare il secondo numero di vertice (in alto a sinistra) come il numero di faccia XOR 1. E dopo un po 'di tentativi ed errori, sono riuscito a venire con il layout mostrato sopra e le formule sottostanti che mi permettono di calcolare ogni numero di vertice per una faccia in modo nabbastanza succinto:

• In alto a sinistra: n
• In alto a destra: n^1
• In basso a sinistra: (n^1)|6
• In basso a destra: ((n^1)+3)%6

Per riferimento, riprodurrò qui l'output per ogni faccia nel layout desiderato:

Face:      0     1     2     3     4     5

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

Quindi l'intero programma si limita a leggere il numero della faccia di input e a produrre questi valori in ordine, anche se con una logica di stampa leggermente diversa per vertici diversi. Si noti che, poiché ogni vertice dopo il primo inizia con una base di n^1, ho bisogno di calcolarlo solo una volta, il che compatta ulteriormente la logica.

Per amor dei posteri, e poiché penso che fosse ancora un approccio piuttosto valido, ecco la mia vecchia risposta.

CJam, 23 byte

Probabilmente esiste un'elegante soluzione matematica a questo problema. Ma non ho idea di come trovarne uno, quindi è una codifica hard super compressa!

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

Provalo online.

Layout del cubo

  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  

Spiegazione

L'approccio di base impiegato è quello di codificare i vertici per ciascuna faccia nel minor spazio possibile. Analogamente alla soluzione di conversione base di Optimizer, questa tratta l'elenco dei vertici come un numero ottale compresso come dati di caratteri ASCII. Ma è qui che finiscono le somiglianze per far posto a ulteriori ottimizzazioni!

Ecco le tre ottimizzazioni chiave che ho apportato alla soluzione "ingenua":

• Disporre il cubo in modo tale che ogni faccia possa essere descritta con il suo numero di faccia come primo numero di vertice. Osservando il layout del mio cubo come presentato sopra, si può vedere che il numero di vertice in alto a sinistra di ogni faccia è uguale al numero di faccia. Questo mi permette di codificare sei vertici in meno al costo di dover stampare di nuovo l'input, che risulta salvare un byte.
• Raggruppa i dati del vertice in una stringa per la quale ogni "carattere" ha un massimo maggiore di 256. Man mano che questo massimo aumenta oltre i 256, la lunghezza della stringa diminuisce lentamente, ma diventa sempre più probabile che uno qualsiasi dei "caratteri" superi 256 e sia quindi non fa più parte del set di caratteri ASCII a 1 byte. Così ho scritto un programma che prova a codificare i dati del vertice in ogni base da 256 a 1000, con il quale ho trovato circa 10 basi che salvano un byte di dati carattere rispetto alla base 256. Ho scelto 487, in quanto ha anche la bella proprietà che la stringa risultante è interamente costituita da ASCII stampabile.
• Mescolato con la prima ottimizzazione, produce l'output asimmetricamente. L'approccio usuale in CJam sarebbe quello di formattare i dati del vertice come un elenco di 2 elementi di elenchi di 2 elementi, inserire una nuova riga nel mezzo e lasciare che l'output venga stampato implicitamente. Ma invece stampo il primo vertice (uguale al numero della faccia di input) con un operatore che non aggiunge una nuova riga, recupero l'elenco di 3 elementi degli altri vertici, afferro il vertice successivo e lo stampo con un operatore che aggiunge una nuova riga e lasciare che gli altri due vertici vengano stampati implicitamente. Questo salva un 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);}

Non registrato nel programma di 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);
}

Spiegazione

La mia numerazione dei cubi, quando aperta, si presenta così:

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

L'angolo in alto a sinistra ha lo stesso numero della faccia.

L'angolo in basso a destra ha un numero (n+2)%6

Per dispari nl'angolo in alto a destra è (n+1)%6e l' angolo in basso a sinistra è6

Perché anche nl'angolo in alto a destra è 7e quello in basso a sinistra è(n+1)%6

Il programma visualizza i numeri dispari come mostrato e i numeri pari ruotati di 180 gradi. Ciò significa che l'angolo in alto a destra è sempre (n+1)%6e quello in basso a sinistra è sempre (n+1)%2+6. Inversione ned n+2è più semplice (si fa impostando c=n+1e usando dper aggiungere o sottrarre 1o -1se necessario.)

Produzione

$ ./a
0
21
70

$ ./a
1
12
63

$ ./a
2
43
72

$ ./a
3
34
65

$ ./a
4
05
74

$ ./a
5
50
61

Elemento, 18

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

A differenza di molti linguaggi di golf più avanzati, Element non ha un operatore di compressione, quindi la brevità della soluzione è strettamente legata all'esatto schema di numerazione utilizzato. Dopo alcune sperimentazioni, ho creato un nuovo schema di numerazione che consente di calcolare i vertici usando solo semplici operazioni aritmetiche.

  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  

L'angolo in alto a sinistra è 6 se pari e 7 se dispari. L'angolo in alto a destra è il numero di faccia stesso. In basso a sinistra è il numero del volto, più 2, mod 6. In basso a destra è 5 meno il numero del volto.

Ecco una spiegazione del codice.

_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

Ecco gli output per ciascuna delle facce:

0
60
25

1
71
34

2
62
43

3
73
52

4
64
01

5
75
10

Ottava, 108 100 68 50 byte

Naturalmente c'è un modo di farlo in modo molto più elegante dei miei precedenti approcci, il semplice hardcoding. Sono stupito di come Octave sia molto più adatta a codegolf di Matlab =)

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

Disposizione:

(Scusa, ho dimenticato di aggiungere questo.)

Layout del cubo

  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  

Vecchie versioni:

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

Versioni ancora più vecchie:

Questo farà davvero un array 2x2x2 e quindi sceglierà una "fetta". Facciamo una permutazione di matrice 3d e ogni volta scegliamo la fetta superiore o inferiore. (Questo non funziona in matlab a causa dell'indicizzazione di un'espressione piuttosto che di una matrice) Sono sicuro che ci sarebbero modi più diretti per farlo che sarebbero più brevi.

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 (o 26) byte

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

che può anche essere compresso utilizzando la conversione di base in una versione di 26 byte .

Suppone che il cubo sia come:

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

con facce simili

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

Provalo online qui

CJam (25 byte)

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

Questo contiene un carattere non stampabile e una scheda (che sarà alterata dal software StackExchange), quindi in formato xxd:

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

Demo online

Cubo:

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

Questo è puro hard-coding, con i vertici del cubo selezionati per massimizzare la compressibilità di base. Decodifico in numeri a 2 cifre, quindi nessuno di essi può iniziare con 0. Neanche io voglio iniziare con 7, poiché questo spinge la seconda base troppo in alto. Pertanto 0 e 7 devono essere su una diagonale lunga. Voglio che un bordo 10 vada per primo per ridurre il valore che sto codificando. A parte questo, c'è una buona quantità di flessibilità senza cambiare il conteggio dei byte.

Sono leggermente deluso dal fatto che dopo aver estratto il primo personaggio dalla stringa magica, è necessario lanciarlo su un int prima di usarlo come base per la conversione di base. Speriamo che le versioni future di CJam salveranno quel byte, anche se sarà troppo tardi per sfruttarlo qui.

JavaScript (ES6), 53 62

Modifica Salva 8 byte utilizzando le stringhe del modello, grazie a @NinjaBearMonkey. Attenzione, le nuove righe tra virgolette sono significative e non possono essere compresse.

Non può essere intelligente in Javascript, è troppo dettagliato.

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

Produzione 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

Vedere il frammento di veify le associazioni numero ( che è stato divertente)

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

Grazie a @rcrmn per aver suggerito di usare un lambda per salvare 4 byte. Non ero sicuro di lasciarlo anonimo, ma sembra essere stato discusso su meta qui e deciso che andava bene.

Qui è come una funzione di 40 byte, per il confronto con la mia risposta Ruby Rev 0, anche di seguito (la risposta C originale è in un post separato.)

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

Ulteriore ispirazione da Runer112: Questo si basa su una modifica dello schema di numerazione utilizzato nella sua ultima risposta (16 byte!). Un porto diretto dello schema di PhiNotPi darebbe lo stesso punteggio.

Spostando la numerazione da Rev 0 in giro di un passo e prendendo tutto XOR 1, otteniamo il cubo seguente:

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

Produzione

0
10
63

1
01
74

2
32
65

3
23
70

4
54
61

5
45
72

Ruby Rev 0, 56 52 50

Salvato 4 byte rimuovendo inutili ()%6da c-de altri 2 (ispirato a runer112) da 6+c%2 --> 6|c.

Il punteggio è per la funzione, che è solo la prima riga. Sono nuovo di Ruby e sono sorpreso di non riuscire a trovare un modo più breve di 12 caratteri (11 più newline) per ottenere un numero di input dell'utente in n. Di conseguenza, facendo una funzione anziché un programma si salva 1 byte.

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)

Questa è una porta della mia risposta C. In C, l' %operatore restituisce un valore negativo con un numero negativo. In Ruby restituisce sempre un valore positivo, quindi non è necessario aggiungere 1 a c. Di conseguenza, è vantaggioso spostare la numerazione delle facce di 1 come di seguito:

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

Con la nuova numerazione facciale, il programma stampa i pari come mostrato sopra e le probabilità ruotate di 180 gradi:

1
21
70

2
12
63

3
43
72

4
34
65

5
05
74

0
50
61

Pyth, 30

Grazie @Jakube per 2 byte.

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

Provalo qui.

I consigli sul golf degli esperti di Pyth saranno ben accetti. In particolare, penso che la sezione di output potrebbe presentare alcuni miglioramenti.

Porta del seguente pitone: ...

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]

... che è un porto di

Pure Bash, 130

Ai fini della spiegazione:

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

I vertici del cubo sono numerati così:

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

E le facce sono numerate così:

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

Il Swap colonna indica che l'ordine dei vertici deve essere commutato nell'output.

L'algoritmo inizia con tutti i vertici {0..7}. I vertici vengono eliminati in base ai bit impostati nei numeri di vertice:

• Per le facce 0,1 e 2, vengono mantenuti i vertici con i bit 1,2 o 3 rispettivamente eliminati
• Per le facce 3,4 e 5, i vertici con i bit 1,2 o 3 impostati rispettivamente vengono mantenuti

I vertici "mantenuti" vengono aggiunti a una stringa. La stringa emette caratteri 0,1 quindi 2,3 o viceversa, a seconda che sia impostato il flag di scambio (numero di faccia mod 2).

J - 26 byte

Funzione che accetta il numero di faccia come argomento e restituisce la griglia di cifre.

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

Stiamo usando il seguente cubo:

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

Esempio (provalo tu stesso su 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|
+--+--+--+--+--+--+

Il pane e il burro sono 0&(|:|.). Questo è un verbo che inverte e ruota il cubo in modo tale da visitare ogni faccia quando viene applicato in modo iterativo, che è ciò che facciamo usando l'argomento input. I vertici del cubo sono generati da i.3#2, quindi lo usiamo come punto di partenza e prendiamo la faccia frontale0...{ quando abbiamo finito .

Stampare le cifre come stringa costa 8 caratteri: {.@":"0@se ci fosse permesso di restituire semplicemente un array, si risparmia 8 caratteri interi. [inizia il pugno tremante e il grip indiscernibile]

> <> (Pesce) , 38 byte

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

Ogni output è memorizzato come due righe di 2 cifre. Le righe sono memorizzate come caratteri nella stringa '/ =/2= 28"H'(tranne la riga 10che viene aggiunta dopo la stringa come a). Il primo personaggio (/ = 47 ) viene utilizzato per reindirizzare il flusso del programma sulla seconda interazione.

Gli 2*(53-n)elementi in cima vengono scartati (dove n è il codice di identificazione del numero di input) e i due codici successivi vengono stampati con una nuova riga tra.

Disposizione:

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