def solve(): print("Les coordonnées du vecteur u(x; y; z) sont :") x1 = int_input("x = ") print("La coordonnée en y est l'inconnue") z1 = int_input("z = ") print("Les coordonnées du vecteur v(x; y; z) sont :") x2 = int_input("x = ") y2 = int_input("y = ") z2 = int_input("z = ") y1 = Fraction(float(-(x1 * x2) - (z1 * z2)) / float(y2)).limit_denominator() print(f"La coordonnée en y doit être égale à {y1}")
def solve(): print( "Les coefficients de l'équation paramétrique donnée ax + by + cz + d = 0 sont :" ) a = int_input("a = ") b = int_input("b = ") c = int_input("c = ") d = int_input("d = ") print("Les coordonnées du point A sont :") Ax = int_input("Ax = ") Ay = int_input("Ay = ") Az = int_input("Az = ") print("Les coordonnées du point B sont :") Bx = int_input("Bx = ") By = int_input("By = ") Bz = int_input("Bz = ") # Calcul des coordonnées du vecteur AB ABx = Bx - Ax ABy = By - Ay ABz = Bz - Az # Vérifions si les points de la droite sont tous les deux inclus dans le plan is_a_in_plane = a * Ax + b * Ay + c * Az + d == 0 is_b_in_plane = a * Bx + b * By + c * Bz + d == 0 if (is_a_in_plane and is_b_in_plane): print("(AB) est incluse dans le plan") else: # Calcul du produit scalaire entre le vecteur normal au plan et le vecteur AB scalar_product = a * ABx + b * ABy + c * ABz # Vérification du parallélisme de (AB) au plan if (scalar_product == 0): print("(AB) est parallèle au plan") else: # La droite (AB) est sécante au plan print("(AB) est sécante au plan") # Calculons le point d'intersection t = ((-a * Ax) + (-b * Ay) + (-c * Az) + (-d)) / ((a * ABx) + (b * ABy) + (c * ABz)) Mx = Fraction(ABx * t + Ax).limit_denominator() My = Fraction(ABy * t + Ay).limit_denominator() Mz = Fraction(ABz * t + Az).limit_denominator() print( f"Le point d'intersection du plan et de la droite (AB) est M({Mx}; {My}; {Mz})" ) # Vérifions si (AB) et le plan sont orthogonaux if (ABx == 0 or ABy == 0 or ABz == 0): print("(AB) et le plan NE sont PAS orthogonaux") else: if ((a / ABx) == (b / ABy) == (c / ABz)): print("(AB) et le plan sont orthogonaux") else: print("(AB) et le plan NE sont PAS orthogonaux")
def solve(): print( "Les coefficients de la première équation ax + by + cz = d du système sont :" ) a1 = int_input("a = ") b1 = int_input("b = ") c1 = int_input("c = ") d1 = int_input("d = ") print( "Les coefficients de la deuxième équation ax + by + cz = d du système sont :" ) a2 = int_input("a = ") b2 = int_input("b = ") c2 = int_input("c = ") d2 = int_input("d = ") # Cas du plan if ((a1 / a2) == (b1 / b2) == (c1 / c2) == (d1 / d2)): print( f"Les équations sont équivalentes, le système représente donc un plan de vecteur normal n({a1}; {b1}; {c1})" ) # Cas de la droite else: # La droite a pour vecteur directeur un vecteur perpendiculaire au deux vecteurs normaux (produit vectoriel) vector_product = np.cross((a1, b1, c1), (a2, b2, c2)) print( f"Les équations sont différentes, le système représente donc une droite (ou l'ensemble vide)" ) print( f"Un vecteur directeur de cette droite est u({str(vector_product).replace(' ', '; ')[1:-1]})" )
def solve(): print( "Les coefficients de l'équation paramétrique donnée ax + by + cz + d = 0 sont :" ) a = int_input("a = ") b = int_input("b = ") c = int_input("c = ") d = int_input("d = ") print("Les coordonnées du point A sont :") ax = int_input("Ax = ") ay = int_input("Ay = ") az = int_input("Az = ") print("Les coordonnées du point B sont :") bx = int_input("Bx = ") by = int_input("By = ") bz = int_input("Bz = ") AB = np.array([bx - ax, by - ay, bz - az]) # Vérifions si les points de la droite sont tous les deux inclus dans le plan a_in_plane = a * ax + b * ay + c * az + d == 0 b_in_plane = a * bx + b * by + c * bz + d == 0 if (a_in_plane and b_in_plane): print("(AB) est incluse dans le plan") else: # Calcul du produit scalaire entre le vecteur normal au plan et le vecteur AB scalar_product = a * AB[0] + b * AB[1] + c * AB[2] # Vérification du parallélisme de (AB) au plan if (scalar_product == 0): print("(AB) est parallèle au plan") else: # La droite (AB) est sécante au plan print("(AB) est sécante au plan") # Calculons le point d'intersection t = ((-a * ax) + (-b * ay) + (-c * az) + (-d)) / ((a * AB[0]) + (b * AB[1]) + (c * AB[2])) Mx = Fraction(AB[0] * t + ax).limit_denominator() My = Fraction(AB[1] * t + ay).limit_denominator() Mz = Fraction(AB[2] * t + az).limit_denominator() print( f"Le point d'intersection du plan et de la droite (AB) est M({Mx}; {My}; {Mz})" ) # Vérifions si (AB) et le plan sont orthogonaux if (AB[0] == 0 or AB[1] == 0 or AB[2] == 0): print("(AB) et le plan NE sont PAS orthogonaux") else: if ((a / AB[0]) == (b / AB[1]) == (c / AB[2])): print("(AB) et le plan sont orthogonaux") else: print("(AB) et le plan NE sont PAS orthogonaux")
def solve(): print("La question est p(x ≤ t)") t = int_input("t = ") print(f"La probabilité p(x ≤ {t}) est égale à 1-e^(-{t}a)") print( "\nEntrez la valeur maximale que peut prendre la probabilité p, dans le dernier paragraphe (c'est un nombre décimal)" ) m = float_input("m = ") print( f"L'intervalle est ]0; ln({Fraction(- m + 1).limit_denominator()})/(-{t})]" )
def solve(): print("La question est :") print("\t1. P(X ≤ a)") print("\t2. P(X ≥ a)") choix = 0 while not choix in [1, 2]: choix = int_input("1 ou 2 ? ") a = fraction_input("a = ") p = fraction_input("Entrez la valeur de la probabilité P : ") if choix == 1: result = f"ln({- p + 1})/({- a})" else: result = f"ln({p})/({- a})" print(f"\nLa paramètre λ est égal à {result}")
def solve(): print("Les constantes pour chacune des coordonnées de l'équation paramétrique de la droite (d) sont :") print("La constante de la coordonnée en x est l'inconnue") ya = int_input("y = a + bt, dans ce cas a = ") za = int_input("z = a + bt, dans ce cas a = ") print("Les coefficients pour chacune des coordonnées de l'équation paramétrique de la droite (d) sont :") xb = int_input("x = a + bt, dans ce cas b = ") yb = int_input(f"y = {ya} + bt, dans ce cas b = ") zb = int_input(f"z = {za} + bt, dans ce cas b = ") print("Les coordonnées du point M sont :") mx = int_input("Mx = ") my = int_input("My = ") mz = int_input("Mz = ") t = (my - ya) / yb xa = Fraction(-xb * t + mx).limit_denominator() print(f"La constante inconnue en x doit être égale à {xa}")
def solve(): p = fraction_input("Entrez le paramètre de la loi exponentielle : ") print("La question est :") print("\t1. P(X ≤ a)") print("\t2. P(X ≥ a)") choix = 0 while not choix in [1, 2]: choix = int_input("1 ou 2 ? ") a = fraction_input("a = ") exponent = Fraction(-p * a).limit_denominator() if choix == 1: result = f"1 - e^({exponent})" else: result = f"e^({exponent})" print(f"\nLa probabilité P est de {result}")
def solve(): print("Entrez les bornes de l'intervalle [a; b] :") a = float_input("a = ") b = float_input("b = ") print("La question est :") print("\t1. P(X ≤ y)") print("\t2. P(X ≥ y)") choix = 0 while not choix in [1, 2]: choix = int_input("1 ou 2 ? ") y = float_input("y = ") if choix == 1: result = Fraction(abs(y - a) * (1 / (b - a))).limit_denominator() else: result = Fraction(abs(b - y) * (1 / (b - a))).limit_denominator() print(f"\nLa probabilité P est de {result}")
def solve(): print("Les coordonnées du point A sont :") ax = int_input("Ax = ") ay = int_input("Ay = ") az = int_input("Az = ") print("Les coordonnées du vecteur normal n(x; y; z) sont :") a = Fraction(int_input("Nx = ")).limit_denominator() b = Fraction(int_input("Ny = ")).limit_denominator() c = Fraction(int_input("Nz = ")).limit_denominator() d = Fraction(-(a * ax) - (b * ay) - (c * az)).limit_denominator() print(f"Une équation cartésienne de P est {a} x + {b} y + {c} z + {d} = 0")
def solve(): print("Les coordonnées du point A sont :") ax = int_input("Ax = ") ay = int_input("Ay = ") az = int_input("Az = ") print("Les coordonnées du point B sont :") bx = int_input("Bx = ") by = int_input("By = ") bz = int_input("Bz = ") print("Les coordonnées du point C sont :") cx = int_input("Cx = ") cy = int_input("Cy = ") cz = int_input("Cz = ") AB = np.array([bx - ax, by - ay, bz - az]) AC = np.array([cx - ax, cy - ay, cz - az]) vector_product = np.cross(AB, AC) a = Fraction(vector_product[0]).limit_denominator() b = Fraction(vector_product[1]).limit_denominator() c = Fraction(vector_product[2]).limit_denominator() d = Fraction(-(a * ax) - (b * ay) - (c * az)).limit_denominator() print(f"Une équation cartésienne de P est {a} x + {b} y + {c} z + {d} = 0")
def solve(): print("Les coordonnées du point A sont :") Ax = int_input("Ax = ") Ay = int_input("Ay = ") Az = int_input("Az = ") print("Les coordonnées du point B sont :") Bx = int_input("Bx = ") By = int_input("By = ") Bz = int_input("Bz = ") print("Les coordonnées du point C sont :") Cx = int_input("Cx = ") Cy = int_input("Cy = ") Cz = int_input("Cz = ") AB = np.array([Bx - Ax, By - Ay, Bz - Az]) AC = np.array([Cx - Ax, Cy - Ay, Cz - Az]) vector_product = np.cross(AB, AC) a = Fraction(vector_product[0]).limit_denominator() b = Fraction(vector_product[1]).limit_denominator() c = Fraction(vector_product[2]).limit_denominator() d = Fraction(-(a * Ax) - (b * Ay) - (c * Az)).limit_denominator() print(f"Une équation cartésienne de P est {a} x + {b} y + {c} z + {d} = 0")
def solve(): print("Les coordonnées du point M sont :") Mx = int_input("Mx = ") My = int_input("My = ") Mz = int_input("Mz = ") print( "Les coefficients pour chacune des coordonnées de l'équation paramétrique de la droite (d) sont :" ) Xb = int_input("x = a + bt, dans ce cas b = ") Yb = int_input("y = a + bt, dans ce cas b = ") Zb = int_input("z = a + bt, dans ce cas b = ") print( "Les constantes pour chacune des coordonnées de l'équation paramétrique de la droite (d) sont :" ) print("La constante de la coordonnée en x est l'inconnue") Ya = int_input(f"y = a + {Yb}t, dans ce cas a = ") Za = int_input(f"z = a + {Zb}t, dans ce cas a = ") t = (My - Ya) / Yb Xa = Fraction(-Xb * t + Mx).limit_denominator() print(f"La constante inconnue en x doit être égale à {Xa}")
def solve(): print("X suit la loi normale N(u, o) :") u = float_input("u = ") o = float_input("o = ") norm = normale.normale(u, o) print("La question est :") print("\t1. P(X ≤ a)") print("\t2. P(X ≥ a)") choix = 0 while not choix in [1, 2]: choix = int_input("1 ou 2 ? ") a = float_input("a = ") if choix == 1: p = round(norm.p_X_inf(a), 4) print(f"\nP(X ≤ {a}) = {p}") else: p = round(norm.p_X_sup(a), 4) print(f"\nP(X ≥ {a}) = {p}")
def solve(): print("Entrez les valeurs définissant la fonction f(x) = m*x^p :") m = fraction_input("m = ") p = int_input("p = ") print("Entrez les bornes de l'intervalle [a; b] dans lequel se situe X :") a = fraction_input("a = ") b = fraction_input("b = ") def F(x): return Fraction((m / (p + 1)) * pow(x, (p + 1))).limit_denominator() p_a = F(b) - F(a) print(f"La probabilité que X prenne ses valeurs dans [{a}; {b}] est {round(float(p_a), 4)}") print( f"\nEntrez les bornes de l'intervalle [u; v] dans lequel se situe X sachant qu'il appartient à l'intervalle [{a}; {b}] :") u = fraction_input("u = ") v = fraction_input("v = ") p_b = F(v) - F(u) result = p_b / p_a print(f"La probabilité P est de {round(float(result), 4)}")
def solve(): for i in range(4): print(f"\tCouple n°{i + 1}") print("Les coordonnées du vecteur normal u(x; y; z) sont :") x1 = int_input("x = ") y1 = int_input("y = ") z1 = int_input("z = ") print("Les coordonnées du vecteur normal v(x; y; z) sont :") x2 = int_input("x = ") y2 = int_input("y = ") z2 = int_input("z = ") scalar_product = np.dot((x1, y1, z1), (x2, y2, z2)) if scalar_product == 0: print("Les deux plans sont orthogonaux") else: print("Les deux plans NE sont PAS orthogonaux")
def solve(): print( "Les constantes pour chacune des coordonnées de l'équation paramétrique de la droite D sont :" ) x1a = int_input("x = a + bt, dans ce cas a = ") y1a = int_input("y = a + bt, dans ce cas a = ") z1a = int_input("z = a + bt, dans ce cas a = ") print( "Les coefficients pour chacune des coordonnées de l'équation paramétrique de la droite D sont :" ) x1b = int_input(f"x = {x1a} + bt, dans ce cas b = ") y1b = int_input(f"y = {y1a} + bt, dans ce cas b = ") z1b = int_input(f"z = {z1a} + bt, dans ce cas b = ") print( "Les constantes pour chacune des coordonnées de l'équation paramétrique de la droite D' sont :" ) x2a = int_input("x = a + bt, dans ce cas a = ") y2a = int_input("y = a + bt, dans ce cas a = ") z2a = int_input("z = a + bt, dans ce cas a = ") print( "Les coefficients pour chacune des coordonnées de l'équation paramétrique de la droite D' sont :" ) x2b = int_input(f"x = {x2a} + bt, dans ce cas b = ") y2b = int_input(f"y = {y2a} + bt, dans ce cas b = ") z2b = int_input(f"z = {z2a} + bt, dans ce cas b = ") # On résout le système d'équations linéaires. m1 = np.array([[x1b, -x2b], [y1b - z1b, -y2b + z2b]]) m2 = np.array([(x2a - x1a), (y2a - y1a - z2a + z1a)]) t1 = np.linalg.solve(m1, m2)[0] # On calcule les coordonnées du point d'intersection. x = Fraction(x1b * t1 + x1a).limit_denominator() y = Fraction(y1b * t1 + y1a).limit_denominator() z = Fraction(z1b * t1 + z1a).limit_denominator() print(f"Le point d'intersection des deux droites est M({x}; {y}; {z})")
# Recherche d'une nouvelle mise à jour. check_for_updates = True if check_for_updates: update_info_url = "https://yougi3.github.io/Kwyk-Solver/update_info.json" update_info = updater.get_update_info(update_info_url) if update_info is not None: update_version = update_info["version"] if (update_version.strip() != version.strip()): print( f"\n! Une nouvelle mise à jour est disponible (version {update_version})." ) if input("Souhaitez-vous la télécharger et l'installer ? (o/N) : " ).strip().lower() == "o": updater.download_and_install(update_info["url"]) else: print("Mise à jour ignorée.") supported_ex = (260, 20110, 20116, 20118, 20119, 20124, 20128, 20129, 28036, 28037) while True: print(f"\nExercices supportés : {str(supported_ex)[1:-1]}") ex = int_input("Entrez le numéro de l'exercice : ") if ex in supported_ex: print() exec(f"from solvers import solver_{ex}") exec(f"solver_{ex}.solve()") else: print("Exercice non supporté par le solveur.")
def solve(): print("Les coordonnées du point A sont :") ax = int_input("Ax = ") ay = int_input("Ay = ") az = int_input("Az = ") print("Les coordonnées du point B sont :") bx = int_input("Bx = ") by = int_input("By = ") bz = int_input("Bz = ") print("Les coordonnées du point C sont :") cx = int_input("Cx = ") cy = int_input("Cy = ") cz = int_input("Cz = ") print("Les coordonnées du point D sont :") dx = int_input("Dx = ") dy = int_input("Dy = ") dz = int_input("Dz = ") AB = np.array([bx - ax, by - ay, bz - az]) CD = np.array([dx - cx, dy - cy, dz - cz]) m1 = np.array([[AB[0], -CD[0]], [AB[1] - AB[2], -CD[1] - (-CD[2])]]) m2 = np.array([(cx - ax), ((cy - ay) - (cz - az))]) t1 = np.linalg.solve(m1, m2)[0] x = Fraction(AB[0] * t1 + ax).limit_denominator() y = Fraction(AB[1] * t1 + ay).limit_denominator() z = Fraction(AB[2] * t1 + az).limit_denominator() print(f"Le point d'intersection des deux droites est M({x}; {y}; {z})")
def solve(): print( "Les constantes pour chacune des coordonnées de l'équation paramétrique de la droite D sont :" ) Xa1 = int_input("x = a + bt, dans ce cas a = ") Ya1 = int_input("y = a + bt, dans ce cas a = ") Za1 = int_input("z = a + bt, dans ce cas a = ") print( "Les coefficients pour chacune des coordonnées de l'équation paramétrique de la droite D sont :" ) Xb1 = int_input(f"x = {Xa1} + bt, dans ce cas b = ") Yb1 = int_input(f"y = {Ya1} + bt, dans ce cas b = ") Zb1 = int_input(f"z = {Za1} + bt, dans ce cas b = ") print( "Les constantes pour chacune des coordonnées de l'équation paramétrique de la droite D' sont :" ) Xa2 = int_input("x = a + bt, dans ce cas a = ") Ya2 = int_input("y = a + bt, dans ce cas a = ") Za2 = int_input("z = a + bt, dans ce cas a = ") print( "Les coefficients pour chacune des coordonnées de l'équation paramétrique de la droite D' sont :" ) Xb2 = int_input(f"x = {Xa2} + bt, dans ce cas b = ") Yb2 = int_input(f"y = {Ya2} + bt, dans ce cas b = ") Zb2 = int_input(f"z = {Za2} + bt, dans ce cas b = ") # On résout le système d'équations linéaires. m1 = np.array([[Xb1, -Xb2], [Yb1 - Zb1, -Yb2 + Zb2]]) m2 = np.array([(Xa2 - Xa1), (Ya2 - Ya1 - Za2 + Za1)]) t1 = np.linalg.solve(m1, m2)[0] # On calcule les coordonnées du point d'intersection. x = Fraction(Xb1 * t1 + Xa1).limit_denominator() y = Fraction(Yb1 * t1 + Ya1).limit_denominator() z = Fraction(Zb1 * t1 + Za1).limit_denominator() print(f"Le point d'intersection des deux droites est M({x}; {y}; {z})")
def solve(): print("Les coordonnées du point A sont :") Ax = int_input("Ax = ") Ay = int_input("Ay = ") Az = int_input("Az = ") print("Les coordonnées du point B sont :") Bx = int_input("Bx = ") By = int_input("By = ") Bz = int_input("Bz = ") print("Les coordonnées du point C sont :") Cx = int_input("Cx = ") Cy = int_input("Cy = ") Cz = int_input("Cz = ") print("Les coordonnées du point D sont :") Dx = int_input("Dx = ") Dy = int_input("Dy = ") Dz = int_input("Dz = ") AB = np.array([Bx - Ax, By - Ay, Bz - Az]) CD = np.array([Dx - Cx, Dy - Cy, Dz - Cz]) m1 = np.array([[AB[0], -CD[0]], [AB[1] - AB[2], -CD[1] - (-CD[2])]]) m2 = np.array([(Cx - Ax), ((Cy - Ay) - (Cz - Az))]) t1 = np.linalg.solve(m1, m2)[0] x = Fraction(AB[0] * t1 + Ax).limit_denominator() y = Fraction(AB[1] * t1 + Ay).limit_denominator() z = Fraction(AB[2] * t1 + Az).limit_denominator() print(f"Le point d'intersection des deux droites est M({x}; {y}; {z})")
solvers_directory_path = f"{os.curdir}/solvers/" # Affichage de la liste des exercices supportés en se basant sur les fichiers # présents dans le dossier 'solvers'. supported_ex = [] solver_filename_pattern = "solver_([0123456789]+).py" for file in os.listdir(solvers_directory_path): solver_filename_match = re.match(solver_filename_pattern, file) if solver_filename_match: # On récupère le numéro de l'exercice, celui-ci étant inclus dans # le nom du fichier. supported_ex.append(int(solver_filename_match.group(1))) # On trie la liste dans l'ordre croissant et on l'affiche à l'utilisateur. supported_ex.sort() print( f"\nExercices supportés : {rreplace(str(supported_ex), ',', ' et', 1)[1:-1]}." ) while True: print(f"\n{'-' * (len(prompt) - 1)}\n") ex = int_input(prompt) if ex in supported_ex: print() try: exec(f"from solvers import solver_{ex}") exec(f"solver_{ex}.solve()") except Exception as e: print(f"\n(!) Une erreur est survenue : {str(e)}.") else: print("\n(!) Exercice non supporté par le solveur.")