Coordinate di output dei vertici di un cubo. Quindi, genera un elenco di dodici triangoli che copriranno il cubo, ogni triangolo essendo un elenco di tre indici di vertice, orientati in modo coerente. L'output deve essere una stringa ASCII di numeri decimali distinti. Questo golf non ha input. Il vincitore è il minor numero di personaggi, in cui il set di caratteri è Unicode.
Per un esempio, considera un cubo 1x1x1 messo all'angolo con 0,0,0. Gli otto vertici del cubo possono essere descritti dalle seguenti coordinate xyz su una griglia cartesiana 3d:
x y z = (0,0,1) (1,0,1) (1,1,1) (0,1,1) (0,0,0) (1,0,0) (1,1,0) (0,1,0)
A ciascun vertice può essere assegnato un indice: x y z->index: 0 0 1->0, 1 0 1->1, 1 1 1->2, 0 1 1->3, 0 0 0->4, 1 0 0->5, 1 1 0->6, 0 1 0->7
Ora considera la faccia superiore, i vertici indicizzati da zero a tre. I due triangoli di copertura possono essere descritti da tre indici ciascuno:
[0,1,2] [2,3,0]
Ecco un'immagine di questa faccia superiore, vista dall'alto del cubo:
3_____2
| /|
| / |
| / |
| / |
0_____1
Ed ecco una vista da un angolo.
3____2
/ __-/|
0/_`__1 |
| | /6
|____|/
4 5
Nota che l'orientamento, o "avvolgimento", di entrambi questi triangoli è "antiorario" se visto dall'esterno del cubo guardando direttamente la faccia in questione (immagina di visitare ciascun vertice come elencato, va in senso antiorario). Ora immagina che sia fatto per tutti e sei i lati del cubo.
vertices: (0,0,1) (1,0,1) (1,1,1) (0,1,1) (0,0,0) (1,0,0) (1,1,0) (0,1,0)
triangles as indices: [0,1,2], [2,3,0], [6,5,4], [4,7,6],
[5,2,1], [2,5,6], [0,3,4], [4,3,7], [2,6,3], [3,6,7], [0,4,1], [1,4,5]
È possibile produrre qualsiasi dimensione del cubo situata in qualsiasi coordinata. Puoi numerare e ordinare le coordinate del vertice come preferisci. Gli indici possono essere basati su 0 o su 1. L'orientamento del triangolo può essere orario o antiorario se visto dall'esterno del cubo, purché sia coerente per tutti i triangoli.
L'output può essere formattato come desiderato, purché ciascun numero decimale ASCII sia separato da almeno un carattere ASCII non numerico. Ad esempio, l'esempio sopra potrebbe anche essere prodotto come segue:
0 0 1 1 0 1 1 1 1 0 1 1 0 0 0 1 0 0 1 1 0 0 1 0
0 1 2 2 3 0 6 5 4 4 7 6 5 2 1 2 5 6 0 3 4 4 3 7 2 6 3 3 6 7 0 4 1 1 4 5
Questo golf è ispirato a vari sistemi e formati grafici 3D, tra cui OpenGL, OBJ, OFF, AMF, CGAL, ecc. Questo golf è simile al golf degli Hobby di Calvin chiamato Output a Face on a Cube numerato , la grande differenza è che hai bisogno per generare tu stesso le coordinate xyz dei vertici e per generare gli indici dei triangoli. Grazie per aver letto.
L'ispirazione per utente qui è un programma di validazione "helper" in python2 (non golfy) che stamperà "ok" o "non ok" per i dati di output del test nelle variabili vertstr e idxstr. Non funziona perfettamente ... ma può rilevare alcuni errori.
Modifica: errore di battitura corretto nell'esempio e bug nel codice di convalida.
#vertstr = '0 0 0 0 0 1 0 1 0 0 1 1 1 0 0 1 0 1 1 1 0 1 1 1'
#idxstr = '1 2 0 2 1 3 7 5 6 4 6 5 2 4 0 4 2 6 7 3 5 1 5 3 4 1 0 1 4 5 7 6 3 2 3 6'
vertstr = '0 0 1 1 0 1 1 1 1 0 1 1 0 0 0 1 0 0 1 1 0 0 1 0'
idxstr = '0 1 2 2 3 0 6 5 4 4 7 6 5 2 1 2 5 6 0 3 4 4 3 7 2 6 3 3 6 7 0 4 1 1 4 5'
classe vettoriale:
def __init __ (self, v):
self.x, self.y, self.z = v [0], v [1], v [2]
def __add __ (self, v):
return Vector ([self.x + vx, self.y + vy, self.z + vz])
def __sub __ (self, v):
return Vector ([self.xv.x, self.yv.y, self.zv.z])
def __str __ (self):
return str (self.x) + ',' + str (self.y) + ',' + str (self.z)
def cross (v1, v2):
x = v1.y * v2.z-v2.y * v1.z
z = v1.x * v2.y-v2.x * v1.y
y = v1.z * v2.x-v2.z * v1.x
return Vector ([x, y, z])
# http://mathforum.org/library/drmath/view/55343.html & http://sympy.org
def winding (v1, v2, v3, obs):
x1, y1, z1, x2, y2, z2, x3, y3, z3, x4, Y4, z4 = v1.x, v1.y, v1.z, v2.x, v2.y, v2.z, v3. x, v3.y, v3.z, obs.x, obs.y, obs.z
d = x1 * (y2 * z3 - y2 * z4 - y3 * z2 + y3 * z4 + y4 * z2 - y4 * z3)
d = d + y1 * (- x2 * z3 + x2 * z4 + x3 * z2 - x3 * z4 - x4 * z2 + x4 * z3)
d = d + z1 * (x2 * y3 - x2 * y4 - x3 * y2 + x3 * y4 + x4 * y2 - x4 * y3)
d = d - x2 * y3 * z4 + x2 * y4 * z3 + x3 * y2 * z4 - x3 * y4 * z2 - x4 * y2 * z3 + x4 * y3 * z2
ritorno d
def normals (v1, v2, v3):
va = v2-v1
vb = v3-v2
vc = v1-v3
n1 = croce (va, vb)
n2 = croce (vb, vc)
n3 = croce (vc, va)
return [n1, n2, n3]
def triplify (str):
nums, triple = [], []
per num in str.split (''): nums + = [int (num)]
per i nell'intervallo (0, len (nums), 3):
triple + = [[nums [i], nums [i + 1], nums [i + 2]]]
triple di ritorno
verts = triplify (vertstr)
indici = triplifica (idxstr)
nsum = Vector ([0,0,0])
windsum = 0
xs, ys, zs = [], [], []
per v in verts:
xs + = [v [0]]
ys + = [v [1]]
zs + = [v [2]]
#print xs, ys, zs, len (xs)
centro = Vector (float [(sum (xs)) / len (xs), galleggiante (sum (ys)) / len (ys), galleggiante (sum (zs)) / len (zs)])
per triangolo in indici:
v1 = Vector (verts [triangle [0]])
v2 = Vector (verts [triangle [1]])
v3 = Vector (verts [triangle [2]])
norme = normali (v1, v2, v3)
stampa v1, v2, v3, norme [0], norme [1], norme [2]
per n nelle norme:
nsum + = n
w = avvolgimento (v1, v2, v3, centro)
stampa 'avvolgimento', w
se w <0: windsum- = 1
elif w> 0: windsum + = 1
if abs (windsum) == 12: stampa 'winding ok'
altro: stampa 'avvolgimento non ok'
if (nsum.x == 0 e nsum.y == 0 e nsum.z == 0): stampa 'normal sum ok'
altrimenti: stampa 'somma normale non ok'