ECRIRE DANS LA CASE A1 L'ABSCISSE DE L'ENTREE

ECRIRE DANS A2 L'ORDONNEE DE CE POINT (ANIMAUX)

QUEL POINT A LA MÊME ORDONNEE QUE LE POINT CHOCS?
ECRIRE LE POINT DANS LA CASE A3

DEPLACER LA CROIX ROUGE SUIVANTE SUR LE PLAN
TELLE QUE ENTREE-CHOCS-PIZZA ET CETTE CROIX FORMENT 
UN RECTANGLE.

DEPLACER LE POINT SUIVANT POUR QUE SES COORDONNEES
SOIENT OPPOSEES A CELLES DU POINT GYROTOUR.

ADDITIONNEZ 1 A L'ABSCISSE. 
MULTIPLIEZ LE RESULTAT PAS L'ORDONNEE.
VOUS OBTENEZ L'OPPOSE DE L'ABSCISSE D'UN POINT.
NOTEZ SON NOM EN A4.

COMBIEN DE POINTS ONT UNE ORDONNEE 
INFERIEURE A CELLE DE CE POINT?
NOTEZ CE NOMBRE EN A5.

VOUS AVEZ OBTENU LE NOM EN MINIMOYS D'UN
CELEBRE MATHEMATICIEN.
POUR TROUVER SON NOM, IL VOUS FAUT CONNAÎTRE
L'ALPHABET MINIMOYS : 
ECRIVEZ LA DIFFERENCE DE L'ORDONNEE PAR
L'ABSCISSE EN A6 PUIS LE NOM TROUVE EN A7.

BIENVENUE A LA RECHERCHE DU SECRET D'ARTHUR.
POUR RESOUDRE CETTE ENIGME, IL TE FAUDRA
TE DEPLACER DANS LE FUTUROSCOPE, DE L'ENTREE
JUSQU'A ARTHUR EN REPONDANT A QUELQUES QUESTIONS.
BONNE CHANCE! Déplacez Arthur (en bas à gauche) 
de l'Entrée (1) à Arthur (8).

1

2

3

4

5

6

7

8

ENTREE = (-8, -5)
CITE = Point(xAxis)
MONSTRES = (4, 2)
ARTHUR = (7, 2)
GYROTOUR = (1, 3)
CHOCS = (-8, 1)
ANIMAUX = (-10, -1)
PIZZA = (-4, 1)
c = Circle(ANIMAUX, 0.25)
d = Circle(ENTREE, 0.25)
e = Circle(CHOCS, 0.25)
f = Circle(PIZZA, 0.25)
g = Circle(GYROTOUR, 0.25)
h = Circle(CITE, 0.25)
k = Circle(MONSTRES, 0.25)
p = Circle(ARTHUR, 0.25)
M = (-9, -6)
L_1: {}
A = (0.02, -6.2)
B = (0, -8)
C = (13, -8)
D = (12.96, -6.2)
E = (13, -5)
F = (9, -5)
G = (9, -6)
H = Point(yAxis)
poly1, a, b, c_1, d_1, e_1, f_1, g_1, h_1 = Polygon(A, B, C, D, E, F, G, H)
I = (-4, -5)
poly2, chocs, pizza, i, entree = Polygon(CHOCS, PIZZA, I, ENTREE)
Z = (3.7, -7.5200000000000005)
J = (-4, -5)
K = (-1, -3)
L = (10.96, -7.2)
N = Intersect(xAxis, yAxis)
j = Segment(GYROTOUR, N)
l = Segment(N, K)
A7 = 0
A1 = 0
A2 = 0
A3 = 0
A4 = 0
A5 = 0
O = (-5, 3)
P = (-6, -1)
Q = (6, 0)
R = (4, 3)
poly3, o, p_1, q, r = Polygon(O, P, Q, R)
S = (-9, -6)
T = (-7, -4)
U = (5.7, -3.96)
V = (5.74, 1)
W = (-7, 1)
poly4, t, u, v, w = Polygon(T, U, V, W)
A6 = 0

Tool: Orthocentre
Sélectionner 3 points
Input: A, B, C
Output: D

poly1, c, a, b = Polygon(A, B, C)
d = OrthogonalLine(B, b)
e = OrthogonalLine(A, a)
D = Intersect(d, e)

Tool: Cercle circonscrit (command Cerclecirconscrit)
Sélectionner 3 points
Input: A, B, C
Output: f

poly1, c, a, b = Polygon(A, B, C)
d = LineBisector(c)
e = LineBisector(b)
D = Intersect(d, e)
f = Circle(D, B)

Tool: Cercle inscrit (command Cinscrit)
Sélectionner 3 points
Input: A, B, C
Output: k

poly1, c, a, b = Polygon(A, B, C)
f = AngularBisector(C, A, B)
h = AngularBisector(A, B, C)
D = Intersect(f, h)
i = OrthogonalLine(D, c)
I = Intersect(c, i)
k = Circle(D, I)

Tool: Centre de gravité (command CentreGravité)
Sélectionner 3 points
Input: A, B, C
Output: L

J = Midpoint(B, C)
K = Midpoint(A, C)
p = Segment(A, J)
q = Segment(B, K)
L = Intersect(p, q)

Tool: Polynome 2nd degré (command Polyn2)
Polynome 2nd degré sur 3 points
Input: A, B, C
Output: p_2

p_2 = Polynomial((x - x(B)) * (x - x(C)) / (x(A) - x(B)) / (x(A) - x(C)) * y(A) + (x - x(A)) * (x - x(C)) / (x(B) - x(A)) / (x(B) - x(C)) * y(B) + (x - x(A)) * (x - x(B)) / (x(C) - x(A)) / (x(C) - x(B)) * y(C))

Tool: Polynome 3ème degré (command Polyn3)
Polynome 3ème degré sur 4 points
Input: A, B, C, D
Output: p_3

p_3 = Polynomial((x - x(B)) * (x - x(C)) * (x - x(D)) / ((x(A) - x(B)) * (x(A) - x(C)) * (x(A) - x(D))) * y(A) + (x - x(A)) * (x - x(C)) * (x - x(D)) / ((x(B) - x(A)) * (x(B) - x(C)) * (x(B) - x(D))) * y(B) + (x - x(A)) * (x - x(B)) * (x - x(D)) / ((x(C) - x(A)) * (x(C) - x(B)) * (x(C) - x(D))) * y(C) + (x - x(A)) * (x - x(B)) * (x - x(C)) / ((x(D) - x(A)) * (x(D) - x(B)) * (x(D) - x(C))) * y(D))

Tool: Orthocentre (command Orthocentre1)
Sélectionner 3 points
Input: A, B, C
Output: D

poly1, c, a, b = Polygon(A, B, C)
d = OrthogonalLine(B, b)
e = OrthogonalLine(A, a)
D = Intersect(d, e)

Tool: Cercle circonscrit (command Cerclecirconscrit1)
Sélectionner 3 points
Input: A, B, C
Output: f

poly1, c, a, b = Polygon(A, B, C)
d = LineBisector(c)
e = LineBisector(b)
D = Intersect(d, e)
f = Circle(D, B)

Tool: Cercle inscrit (command Cinscrit1)
Sélectionner 3 points
Input: A, B, C
Output: k

poly1, c, a, b = Polygon(A, B, C)
f = AngularBisector(C, A, B)
h = AngularBisector(A, B, C)
D = Intersect(f, h)
i = OrthogonalLine(D, c)
I = Intersect(c, i)
k = Circle(D, I)

Tool: Centre de gravité (command CentreGravité1)
Sélectionner 3 points
Input: A, B, C
Output: L

J = Midpoint(B, C)
K = Midpoint(A, C)
p = Segment(A, J)
q = Segment(B, K)
L = Intersect(p, q)

Tool: Polynome 2nd degré (command Polyn21)
Polynome 2nd degré sur 3 points
Input: A, B, C
Output: p_2

p_2 = Polynomial((x - x(B)) * (x - x(C)) / (x(A) - x(B)) / (x(A) - x(C)) * y(A) + (x - x(A)) * (x - x(C)) / (x(B) - x(A)) / (x(B) - x(C)) * y(B) + (x - x(A)) * (x - x(B)) / (x(C) - x(A)) / (x(C) - x(B)) * y(C))

Tool: Polynome 3ème degré (command Polyn31)
Polynome 3ème degré sur 4 points
Input: A, B, C, D
Output: p_3

p_3 = Polynomial((x - x(B)) * (x - x(C)) * (x - x(D)) / ((x(A) - x(B)) * (x(A) - x(C)) * (x(A) - x(D))) * y(A) + (x - x(A)) * (x - x(C)) * (x - x(D)) / ((x(B) - x(A)) * (x(B) - x(C)) * (x(B) - x(D))) * y(B) + (x - x(A)) * (x - x(B)) * (x - x(D)) / ((x(C) - x(A)) * (x(C) - x(B)) * (x(C) - x(D))) * y(C) + (x - x(A)) * (x - x(B)) * (x - x(C)) / ((x(D) - x(A)) * (x(D) - x(B)) * (x(D) - x(C))) * y(D))

Tool: triangle équilatéral (se) (command triangleéquilatéralse)
Input: A, B
Output: C, a, b, c

a = Segment(A, B)
C = Rotate(B, 60.0*°, A)
b = Segment(C, A)
c = Segment(C, B)

Tool: triangle isocèle (se) (command triangleisocèlese)
Input: A, B
Output: C, a, b, c

a = Segment(A, B)
C = Point(Circle[A, a])
b = Segment(A, C)
c = Segment(B, C)

Tool: triangle rectangle (se) (command trianglerectanglese)
Input: A, B
Output: C, a, b, c

a = Segment(A, B)
C = Point(OrthogonalLine[B, Line[A, B]])
b = Segment(B, C)
c = Segment(C, A)

Tool: triangle rectangle isocèle (se) (command trianglerectangleisocèlese)
Input: A, B
Output: C, a, b, c

a = Segment(A, B)
C = Rotate(B, 90.0*°, A)
b = Segment(C, A)
c = Segment(C, B)

Tool: carré (se) (command carrése)
Input: A, B
Output: C, D, a, b, c, d

a = Segment(A, B)
C = Rotate(A, 270.0*°, B)
D = Rotate(B, 90.0*°, A)
b = Segment(B, C)
c = Segment(C, D)
d = Segment(D, A)

Tool: rectangle (se) (command rectanglese)
Input: A, B
Output: C, D, a, b, c, d

a = Segment(A, B)
C = Point(OrthogonalLine[A, Line[A, B]])
b = Segment(C, A)
D = Intersect(OrthogonalLine[C, Line[A, C]], OrthogonalLine[B, Line[A, B]])
c = Segment(C, D)
d = Segment(D, B)

Tool: parallélogramme (se) (command parallélogrammese)
Input: A, B, C
Output: D, a, b, c, d

a = Segment(A, B)
b = Segment(B, C)
D = Point(A, Vector[Vector[B, C]])
c = Segment(A, D)
d = Segment(D, C)

Tool: losange (se) (command losangese)
Input: A, B
Output: C, D, a, b, c, d

a = Segment(A, B)
C = Point(Circle[B, a])
b = Segment(B, C)
D = Point(A, Vector[Vector[B, C]])
c = Segment(A, D)
d = Segment(D, C)

Tool: pavage triangle (command pavagetriangle)
Input: A, B
Output: poly1, C, a, b, c

poly1, a, b, c, C = Polygon(A, B, 3.0)

Tool: pavage carré (command pavagecarré)
Input: D, E
Output: poly2, F, G, d, e, f, g

poly2, d, e, f, g, F, G = Polygon(D, E, 4.0)

Tool: pavage pentagone (command pavagepentagone)
Input: H, I
Output: poly3, J, K, L, h, i, j, k, l

poly3, h, i, j, k, l, J, K, L = Polygon(H, I, 5.0)

Tool: pavage héxagone (command pavagehéxagone)
Input: M, N
Output: poly4, O, P, Q, R, m, n, o, p, q, r

poly4, m, n, o, p, q, r, O, P, Q, R = Polygon(M, N, 6.0)

Tool: pavage héptagone (command pavagehéptagone)
Input: S, T
Output: poly5, U, V, W, Z, A1, s, t, u, v, w, z, a1

poly5, s, t, u, v, w, z, a1, U, V, W, Z, A1 = Polygon(S, T, 7.0)

Tool: pavage octogone (command pavageoctogone)
Input: B1, C1
Output: poly6, D1, E1, F1, G1, H1, I1, b1, c1, d1, e1, f1, g1, h1, i1

poly6, b1, c1, d1, e1, f1, g1, h1, i1, D1, E1, F1, G1, H1, I1 = Polygon(B1, C1, 8.0)

Tool: pavage nonagone (command pavagenonagone)
Input: J1, K1
Output: poly7, L1, M1, N1, O1, P1, Q1, R1, j1, k1, l1, m1, n1, o1, p1, q1, r1

poly7, j1, k1, l1, m1, n1, o1, p1, q1, r1, L1, M1, N1, O1, P1, Q1, R1 = Polygon(J1, K1, 9.0)

Tool: pavage décagone (command pavagedécagone)
Input: S1, T1
Output: poly8, U1, V1, W1, Z1, A2, B2, C2, D2, s1, t1, u1, v1, w1, z1, a2, b2, c2, d2

poly8, s1, t1, u1, v1, w1, z1, a2, b2, c2, d2, U1, V1, W1, Z1, A2, B2, C2, D2 = Polygon(S1, T1, 10.0)

Tool: pavage endécagone (command pavageendécagone)
Input: E2, F2
Output: poly9, G2, H2, I2, J2, K2, L2, M2, N2, O2, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2

poly9, e2, f2, g2, h2, i2, j2, k2, l2, m2, n2, o2, G2, H2, I2, J2, K2, L2, M2, N2, O2 = Polygon(E2, F2, 11.0)

Tool: pavage héxagone (command pavagehéxagon)
Input: M, N
Output: poly4, O, P, Q, R, m, n, o, p, q, r

poly4, m, n, o, p, q, r, O, P, Q, R = Polygon(M, N, 6.0)

Tool: Guide âne (command Guideâne)
Input: A, B, C
Output: a, D, E, F, G, H, I, J, K, L, M, N, b, c, d, e, f, g, h, i, j, k, l, m

a = Line(A, B)
b = Line(C, a)
D = Translate(C, Vector[Vector[B, C]])
c = Line(D, b)
E = Translate(D, Vector[Vector[B, C]])
d = Line(E, c)
F = Translate(E, Vector[Vector[B, C]])
G = Translate(F, Vector[Vector[B, C]])
H = Translate(G, Vector[Vector[B, C]])
e = Line(F, d)
f = Line(G, e)
g = Line(H, f)
I = Translate(H, Vector[Vector[B, C]])
J = Translate(I, Vector[Vector[B, C]])
K = Translate(J, Vector[Vector[B, C]])
h = Line(I, g)
i = Line(J, h)
j = Line(K, i)
L = Translate(K, Vector[Vector[B, C]])
M = Translate(L, Vector[Vector[B, C]])
N = Translate(M, Vector[Vector[B, C]])
k = Line(L, j)
l = Line(M, j)
m = Line(N, l)

Tool: pavage dodécagone (command pavagedodécagone)
Input: P2, Q2
Output: poly10, R2, S2, T2, U2, V2, W2, Z2, A3, B3, C3, p2, q2, r2, s2, t2, u2, v2, w2, z2, a3, b3, c3

poly10, p2, q2, r2, s2, t2, u2, v2, w2, z2, a3, b3, c3, R2, S2, T2, U2, V2, W2, Z2, A3, B3, C3 = Polygon(P2, Q2, 12.0)