C

A

B

F

D

F

C

A

D

A

B

C

D

F

E

b

c

d

e

f

a

B

A

B

Azulejo

Composición

Texto

Mosaico

Paralelogramos

Texto

Se rota 180º el hexágono (simetría central) alrededor del punto rojo. El decágono resultante tesela por traslación.

Se refleja con desplazamiento el hexágono según la dirección, sentido y distancia indicado por uno de los vectores.
Después, se rotan 180º ambos hexágonos alrededor del punto rojo. La figura resultante tesela por traslación. 

Se rota sucesivas veces 120º el hexágono alrededor del punto rojo (vértice A).
El dodecágono resultante tesela por traslación.

Azulejo en general con forma romboide. Celda primitiva 1/2, grupo 222 (p2).

Azulejo en general con forma rectangular. Celda primitiva 1/4, grupo 22x (pgg).
Las líneas rojas indican las direcciones de las reflexiones desplazadas.

Azulejo con forma diamantina (hexagonal). Celda primitiva 1/3, grupo 333 (p3).
La celda primitiva se sitúa en el centro del diamante (tercio del hexágono regular).

A=C=E=120º

a=b, c=d, e=f

A+B+D=360º

A+B+C=360º

a=d

E

b

c

d

e

f

a

E

b

c

d

e

f

a

A

B

C

D

A

C

E

a=d, c=e

AUTOCORRECCIÓN

Nº respuestas que faltan:

Nº respuestas repetidas:

Nº respuestas correctas:

tipotipo = 1 (slider from 1 to 3, step 1)
Cp3 = (7.92, 0.8200000000000001)
Ap3 = (4.14, -0.02)
Bp3 = (6.96, -0.34)
Fp3 = Rotate(Bp3, 120°, Ap3)
Dp3 = Rotate(Bp3, 240°, Cp3)
L = Midpoint(Fp3, Dp3)
L' = Rotate(L, 30°, Dp3)
b = Line(Dp3, L')
a = LineBisector(Fp3, Dp3)
M = Intersect(a, b)
c = Ray(M, L)
d = Circle(M, Fp3)
Fp2 = (4.18, 3.56)
Cp2 = (8.66, 0.68)
Ap2 = (3.7, 0.42)
Dp2 = Point(Circle[Cp2, abs(Fp2 - Ap2)])
Ap1 = (4, -0.08)
Bp1 = (7.48, -0.44)
Cp1 = (8.94, 0.86)
Dp1 = (8.540000000000001, 3.1)
Fp1: Ap1 + Dp1 - Cp1
Ep1 = (7.32, 3.86)
polígono1a, bp1, cp1, dp1, ep1, fp1, ap1 = Polygon(Ap1, Bp1, Cp1, Dp1, Ep1, Fp1)
D_1 = Midpoint(bp1)
Bp2 = (7.04, -0.38)
α2A = Angle(Bp2, Ap2, Fp2)
α2B = Angle(Cp2, Bp2, Ap2)
Ep2a = Rotate(Cp2, α2A + α2B, Dp2)
azulejo = true
composición = false
textoComposición = false
mosaico = false
paralelogramos = false
tipo: round(tipotipo)
textoParalelogramos = false
n = 3
Tp4 = 0
e = 2.718281828459045
A1 = NaN
A2 = NaN
A3 = NaN
Ep2: Dp2 + ((Ep2a - Dp2) / abs(Ep2a - Dp2) * abs(Cp2 - Bp2))
polígono2a, bp2, cp2, dp2, ep2, fp2, ap2 = Polygon(Ap2, Bp2, Cp2, Dp2, Ep2, Fp2)
Ep3 = Intersect(d, c)
polígono3a, bp3, cp3, dp3, ep3, fp3, ap3 = Polygon(Ap3, Bp3, Cp3, Dp3, Ep3, Fp3)
Ap1' = Mirror(Ap1, D_1)
Bp1' = Mirror(Bp1, D_1)
Cp1' = Mirror(Cp1, D_1)
Dp1' = Mirror(Dp1, D_1)
Ep1' = Mirror(Ep1, D_1)
Fp1' = Mirror(Fp1, D_1)
polígono1b, bp1', cp1', dp1', ep1', fp1', ap1' = Polygon(Ap1', Bp1', Cp1', Dp1', Ep1', Fp1')
v1 = Vector(Ep1', Dp1)
u1 = Vector(Bp1', Cp1)
pent1a = Sequence(Sequence[Polygon[Ap1 + (s * u1) + (t * v1), Bp1 + (s * u1) + (t * v1), Cp1 + (s * u1) + (t * v1), Dp1 + (s * u1) + (t * v1), Ep1 + (s * u1) + (t * v1), Fp1 + (s * u1) + (t * v1)], s, (-n), n], t, (-n), n)
pent1b = Sequence(Sequence[Polygon[Ap1' + (s * u1) + (t * v1), Bp1' + (s * u1) + (t * v1), Cp1' + (s * u1) + (t * v1), Dp1' + (s * u1) + (t * v1), Ep1' + (s * u1) + (t * v1), Fp1' + (s * u1) + (t * v1)], s, (-n), n], t, (-n), n)
α1A = Angle(Bp1, Ap1, Fp1)
α1B = Angle(Cp1, Bp1, Ap1)
α1C = Angle(Dp1, Cp1, Bp1)
α = Angle(Bp1', Ap1', Fp1')
β = Angle(Fp1', Ap1', Cp1)
lista1: {Polygon[(40, 5.35), (-4, 5.35), (-4, 8), (40, 8)]}
paralelas1: {Sequence[Line[D_1 + (s * u1) - (u1 + v1) / 2, D_1 + (s * u1) + v1 - (u1 + v1) / 2], s, (-((4 * n))), (4 * n)], Sequence[Line[D_1 + (s * v1) - (u1 + v1) / 2, D_1 + (s * v1) + u1 - (u1 + v1) / 2], s, (-((4 * n))), (4 * n)]}
celda1: {Polygon[D_1 + u1 / 2, D_1 - v1 / 2 + u1 / 2, D_1 - u1 / 2 - v1 / 2, D_1 - u1 / 2], Segment[D_1 - u1 / 2, D_1 + u1 / 2]}
α2D = Angle(Ep2, Dp2, Cp2)
D = Midpoint(bp2)
Ap2' = Mirror(Ap2, D)
Bp2' = Mirror(Bp2, D)
Cp2'_1 = Mirror(Cp2, D)
Dp2' = Mirror(Dp2, D)
Ep2' = Mirror(Ep2, D)
Fp2' = Mirror(Fp2, D)
polígono2b, bp2', cp2', dp2', ep2', fp2', ap2' = Polygon(Ap2', Bp2', Cp2'_1, Dp2', Ep2', Fp2')
Ap2'' = Mirror(Ap2', cp2)
Ap2'''_1 = Rotate(Bp2, (-Angle[Dp2, Ep2, Fp2]), Cp2)
C: Cp2 + ((Ap2'' - Cp2) / abs(Ap2'' - Cp2) * fp2)
E: Cp2 + ((Ap2'''_1 - Cp2) / abs(Ap2'' - Cp2) * fp2)
Cp2'_2 = Rotate(Cp2, (-Angle[Ep2, Fp2, Ap2]), E)
F: E + ((Cp2'_2 - E) / abs(Cp2'_2 - E) * ap2)
FA2 = 0
E'_1 = Rotate(E, (-Angle[Fp2, Ap2, Bp2]), F)
G: F + ((E'_1 - F) / abs(E'_1 - F) * bp2)
polígono2c, fp2'_1, ap2'', cp2_1, e_1, f, g = Polygon(Fp2', Ap2'', Cp2, E, F, G)
H = Midpoint(f)
Fp2''_1 = Mirror(Fp2', H)
Ap2'''_2 = Mirror(Ap2'', H)
Cp2'_3 = Mirror(Cp2, H)
E'_2 = Mirror(E, H)
F'_1 = Mirror(F, H)
G'_1 = Mirror(G, H)
polígono2o, fp2'', ap2''', cp2'_1, e', f', g' = Polygon(Fp2''_1, Ap2'''_2, Cp2'_3, E'_2, F'_1, G'_1)
v2 = Vector(E'_2, Cp2)
u2 = Vector(Dp2', G'_1)
pent2a = Sequence(Sequence[Polygon[Ap2 + (s * u2) + (t * v2), Bp2 + (s * u2) + (t * v2), Cp2 + (s * u2) + (t * v2), Dp2 + (s * u2) + (t * v2), Ep2 + (s * u2) + (t * v2), Fp2 + (s * u2) + (t * v2)], s, (-n), n], t, (-n), n)
pent2b = Sequence(Sequence[Polygon[Ap2' + (s * u2) + (t * v2), Bp2' + (s * u2) + (t * v2), Cp2'_1 + (s * u2) + (t * v2), Dp2' + (s * u2) + (t * v2), Ep2' + (s * u2) + (t * v2), Fp2' + (s * u2) + (t * v2)], s, (-n), n], t, (-n), n)
pent2c = Sequence(Sequence[Polygon[Fp2' + (s * u2) + (t * v2), Ap2'' + (s * u2) + (t * v2), Cp2 + (s * u2) + (t * v2), E + (s * u2) + (t * v2), F + (s * u2) + (t * v2), G + (s * u2) + (t * v2)], s, (-n), n], t, (-n), n)
pent2d = Sequence(Sequence[Polygon[Fp2''_1 + (s * u2) + (t * v2), Ap2'''_2 + (s * u2) + (t * v2), Cp2'_3 + (s * u2) + (t * v2), E'_2 + (s * u2) + (t * v2), F'_1 + (s * u2) + (t * v2), G'_1 + (s * u2) + (t * v2)], s, (-n), n], t, (-n), n)
Fp2''' = Translate(Fp2''_1, v2)
I = Translate(Ap2'''_2, v2)
J = Translate(Cp2'_3, v2)
E'' = Translate(E'_2, v2)
F'' = Translate(F'_1, v2)
G'' = Translate(G'_1, v2)
polígono2d, fp2''', i, j, e'', f'', g'' = Polygon(Fp2''', I, J, E'', F'', G'')
K = Midpoint(f'')
γ = Angle(Bp2', Ap2'', Fp2')
δ = Angle(Fp2', Ap2'', E'')
paralelas2: {Sequence[Line[D + (s * u2) - (u2 + v2) / 2, D + (s * u2) + v2 - (u2 + v2) / 2], s, (-((4 * n))), (4 * n)], Sequence[Line[D + (s * v2) - (u2 + v2) / 2, D + (s * v2) + u2 - (u2 + v2) / 2], s, (-((4 * n))), (4 * n)]}
B = Midpoint(f)
ε = Angle(Bp3, Ap3, Fp3)
ζ = Angle(Dp3, Cp3, Bp3)
η = Angle(Fp3, Ep3, Dp3)
Ap3'_1 = Rotate(Ap3, 120°, Ap3)
Bp3'_1 = Rotate(Bp3, 120°, Ap3)
Cp3'_1 = Rotate(Cp3, 120°, Ap3)
Dp3'_1 = Rotate(Dp3, 120°, Ap3)
Ep3'_1 = Rotate(Ep3, 120°, Ap3)
Fp3'_1 = Rotate(Fp3, 120°, Ap3)
polígono3b, ap3', bp3', cp3', dp3', ep3', fp3' = Polygon(Ap3'_1, Bp3'_1, Cp3'_1, Dp3'_1, Ep3'_1, Fp3'_1)
Ap3' = Rotate(Ap3, 240°, Ap3'_1)
Bp3' = Rotate(Bp3, 240°, Ap3'_1)
Cp3' = Rotate(Cp3, 240°, Ap3'_1)
Dp3' = Rotate(Dp3, 240°, Ap3'_1)
Ep3' = Rotate(Ep3, 240°, Ap3'_1)
Fp3' = Rotate(Fp3, 240°, Ap3'_1)
polígono3c, ap3'_1, bp3'_1, cp3'_1, dp3'_1, ep3'_1, fp3'_1 = Polygon(Ap3', Bp3', Cp3', Dp3', Ep3', Fp3')
u3 = Vector(Bp3', Dp3)
v3 = Vector(Dp3'_1, Fp3')
pent3a = Sequence(Sequence[Polygon[Ap3 + (s * u3) + (t * v3), Bp3 + (s * u3) + (t * v3), Cp3 + (s * u3) + (t * v3), Dp3 + (s * u3) + (t * v3), Ep3 + (s * u3) + (t * v3), Fp3 + (s * u3) + (t * v3)], s, (-n), n], t, (-n), n)
pent3c = Sequence(Sequence[Polygon[Ap3' + (s * u3) + (t * v3), Bp3' + (s * u3) + (t * v3), Cp3' + (s * u3) + (t * v3), Dp3' + (s * u3) + (t * v3), Ep3' + (s * u3) + (t * v3), Fp3' + (s * u3) + (t * v3)], s, (-n), n], t, (-n), n)
pent3b = Sequence(Sequence[Polygon[Ap3'_1 + (s * u3) + (t * v3), Bp3'_1 + (s * u3) + (t * v3), Cp3'_1 + (s * u3) + (t * v3), Dp3'_1 + (s * u3) + (t * v3), Ep3'_1 + (s * u3) + (t * v3), Fp3'_1 + (s * u3) + (t * v3)], s, (-n), n], t, (-n), n)
paralelas3: {Sequence[Line[Ap3 + (s * u3) - (u3 + v3) / 3, Ap3 + (s * u3) + v3 - (u3 + v3) / 3], s, (-((4 * n))), (4 * n)], Sequence[Line[Ap3 + (s * v3) - (u3 + v3) / 3, Ap3 + (s * v3) + u3 - (u3 + v3) / 3], s, (-((4 * n))), (4 * n)]}
θ = Angle(Bp3'_1, Ap3', Bp3')
ι = Angle(Bp3', Ap3', Fp3')
AAA: Ap3
CCC: Cp3
EEE: Ep3'
FFF: Ep3
soluciones: {3, 2, 1}
respuestas1: {A1, A2, A3}
respuestas2 = KeepIf(x > 0, respuestas1)
respuestas3 = Union(respuestas2, {})
respuestasCorrectas = Sequence(If[Element[respuestas1, k] ≟ Element[soluciones, k], 1, 0], k, 1, 3)
respuestasPuntuación = Sum(respuestasCorrectas)
C6: 3 - Length[respuestas2]
C7: Length[respuestas2] - Length[respuestas3]
C8 = If(C6 ≟ 0 ∧ C7 ≟ 0, "" + respuestasPuntuación, "- - -")
desliza2: {Line[D + v2 / 4 - u2 / 4, D + v2 / 4 - u2 / 4 - u2], Line[D + v2 / 4 + u2 / 4, D + v2 / 4 + u2 / 4 - v2]}
celda2: {Polygon[D, D + v2 / 2, D + u2 / 2 + v2 / 2, D + u2 / 2], Segment[D - u2 / 2, D + u2 / 2], Segment[D - v2 / 2, D + v2 / 2]}
lista2: {Vector[D + v2 / 4 + u2 / 4, D + v2 / 4 + u2 / 4 - u2 / 2], Vector[D + v2 / 4 + u2 / 4, D + v2 / 4 + u2 / 4 - v2 / 2]}
Fp2'' = Mirror(Fp2', D)
Ap2''' = Mirror(Ap2'', D)
Cp2' = Mirror(Cp2, D)
E' = Mirror(E, D)
F' = Mirror(F, D)
G' = Mirror(G, D)
polígono2c', fp2''_1, ap2'''_1, cp2'_2, e'_1, f'_1, g'_1 = Polygon(Fp2'', Ap2''', Cp2', E', F', G')
A = Midpoint(f'_1)
Aq = Object("Ap" + tipo)
Bq = Object("Bp" + tipo)
Cq = Object("Cp" + tipo)
Dq = Object("Dp" + tipo)
Eq = Object("Ep" + tipo)
Fq = Object("Fp" + tipo)
qAB = Segment(Aq, Bq)
qBC = Segment(Bq, Cq)
qCD = Segment(Cq, Dq)
qDE = Segment(Dq, Eq)
qEF = Segment(Eq, Fq)
qFA = Segment(Fq, Aq)
listaCompleja: {Intersect[qAB, qCD], Intersect[qAB, qDE], Intersect[qAB, qEF], Intersect[qBC, qDE], Intersect[qBC, qEF], Intersect[qBC, qFA], Intersect[qCD, qEF], Intersect[qCD, qFA], Intersect[qDE, qFA]}
listaCompleja2 = Sequence(Defined[Element[listaCompleja, k]], k, 1, 9)
listaCompleja3 = Sum(listaCompleja2)
αqA = Angle(Bq, Aq, Fq)
αqB = Angle(Cq, Bq, Aq)
αqC = Angle(Dq, Cq, Bq)
αqD = Angle(Eq, Dq, Cq)
αqE = Angle(Fq, Eq, Dq)
αqF = Angle(Aq, Fq, Eq)
listaImposible: {¬Defined[αqA], ¬Defined[αqB], ¬Defined[αqC], ¬Defined[αqD], ¬Defined[αqE]}
listaImposible2 = Sum(listaImposible)
testImposible = If(listaImposible2 ≟ 0, false, true)
testComplejo = If(listaCompleja3 ≟ 0, false, true)
testCóncavo = If((αqA > 180°) ∨ (αqB > 180°) ∨ (αqC > 180°) ∨ (αqD > 180°) ∨ (αqE > 180°) ∨ (αqF > 180°), true, false)
testAviso = If(testComplejo ∨ testCóncavo ∨ testImposible, true, false)
texto5 = If(testImposible, "POSICIÓN FUERA DE LOS LÍMITES POSIBLES PARA CONSTRUIR ESTE TIPO", If[testComplejo, "AVISO: HEXÁGONO COMPLEJO", "AVISO: HEXÁGONO CÓNCAVO"])
celda3: {Polygon[Ep3, Ap3, Ep3', Cp3], Segment[Ep3, Ap3], Segment[Ap3, Ep3'], Segment[Ep3', Cp3], Segment[Cp3, Ep3], Segment[Ap3, Ap3 + Ap3 - Cp3], Segment[Cp3, Cp3 + Cp3 - Ap3]}
textoTipo: "T i p o    " + (floor(tipo))