Coordenadas de salida de los vértices de un cubo. Luego, emite una lista de doce triángulos que cubrirán el cubo, cada triángulo es una lista de tres índices de vértices, orientados consistentemente. La salida debe ser una cadena ASCII de números decimales distintos. Este golf no tiene entrada. El ganador es la menor cantidad de caracteres, donde el conjunto de caracteres es Unicode.
Por ejemplo, considere un cubo 1x1x1 arrinconado a 0,0,0. Los ocho vértices del cubo se pueden describir mediante las siguientes coordenadas xyz en una cuadrícula 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 cada vértice se le puede dar un índice: 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
Ahora considere la cara superior, vértices indexados de cero a tres. Los dos triángulos de cobertura se pueden describir mediante tres índices cada uno:
[0,1,2] [2,3,0]
Aquí hay una foto de esta cara superior, vista desde arriba del cubo:
3_____2
| /|
| / |
| / |
| / |
0_____1
Y aquí hay una vista desde un ángulo.
3____2
/ __-/|
0/_`__1 |
| | /6
|____|/
4 5
Tenga en cuenta que la orientación, o 'devanado', de ambos triángulos es 'en sentido contrario a las agujas del reloj' cuando se ve desde 'fuera' del cubo mirando directamente a la cara en cuestión (imagine visitar cada vértice como se indica, va en sentido antihorario). Ahora imagine esto hecho para los seis lados 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]
Puede generar cualquier tamaño de cubo ubicado en cualquier coordenada. Puede numerar y ordenar las coordenadas de vértice como lo desee. Los índices pueden estar basados en 0 o en 1. La orientación del triángulo puede ser en sentido horario o antihorario cuando se ve desde fuera del cubo, siempre que sea consistente para todos los triángulos.
La salida se puede formatear como desee, siempre que cada número decimal ASCII esté separado por al menos un carácter ASCII no numérico. Por ejemplo, el ejemplo anterior también se puede generar de la siguiente manera:
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
Este golf está inspirado en varios sistemas y formatos de gráficos en 3D, incluidos OpenGL, OBJ, OFF, AMF, CGAL, etc. Este golf es similar al golf de Calvin's Hobbies llamado Output a Face on a Numbered Cube , la gran diferencia es que usted necesita para generar las coordenadas xyz de los vértices y generar índices de triángulos. Gracias por leer.
Por inspiración del usuario, aquí hay un programa de validación "auxiliar" en python2 (no apto para golf) que imprimirá 'ok' o 'not ok' para datos de salida de prueba en las variables vertstr e idxstr. No funciona perfectamente ... pero puede detectar algunos errores.
Editar: error tipográfico fijo en el ejemplo y errores en el código de validación.
#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'
Vector de clase:
def __init __ (self, v):
self.x, self.y, self.z = v [0], v [1], v [2]
def __add __ (self, v):
Vector de retorno ([self.x + vx, self.y + vy, self.z + vz])
def __sub __ (self, v):
Vector de retorno ([self.xv.x, self.yv.y, self.zv.z])
def __str __ (self):
return str (self.x) + ',' + str (self.y) + ',' + str (self.z)
cruz cruzada (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
Vector de retorno ([x, y, z])
# http://mathforum.org/library/drmath/view/55343.html y http://sympy.org
devanado def (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
volver d
def normales (v1, v2, v3):
va = v2-v1
vb = v3-v2
vc = v1-v3
n1 = cruz (va, vb)
n2 = cruz (vb, vc)
n3 = cruz (vc, va)
volver [n1, n2, n3]
def triplify (str):
nums, triples = [], []
para num en str.split (''): nums + = [int (num)]
para i en rango (0, len (nums), 3):
triples + = [[nums [i], nums [i + 1], nums [i + 2]]]
triples de regreso
verts = triplify (vertstr)
índices = triplificar (idxstr)
nsum = Vector ([0,0,0])
Windsum = 0
xs, ys, zs = [], [], []
para v en verts:
xs + = [v [0]]
ys + = [v [1]]
zs + = [v [2]]
#print xs, ys, zs, len (xs)
centro = Vector ([float (sum (xs)) / len (xs), float (sum (ys)) / len (ys), float (sum (zs)) / len (zs)])
para triángulo en índices:
v1 = Vector (verts [triángulo [0]])
v2 = Vector (verts [triángulo [1]])
v3 = Vector (verts [triángulo [2]])
normas = normales (v1, v2, v3)
imprimir v1, v2, v3, normas [0], normas [1], normas [2]
para n en las normas:
nsum + = n
w = devanado (v1, v2, v3, centro)
imprimir 'bobinado', w
si w <0: windsum- = 1
elif w> 0: viento + = 1
if abs (windsum) == 12: imprime 'bobinado ok'
más: imprima 'bobinado no está bien'
if (nsum.x == 0 y nsum.y == 0 y nsum.z == 0): imprime 'suma normal ok'
de lo contrario: imprima 'suma normal no está bien'