def valeurs_apbamb(nombre_min, nombre_max): # renvoie un tuple contenant ((3,-5),(3,+5))
a = valeur_alea(nombre_min, nombre_max)
b = valeur_alea(nombre_min, nombre_max)
if random.randrange(2):
return ((a, -b), (a, b))
else:
return ((a, b), (a, -b))
def valeurs_type5(nombre_min, nombre_max): # renvoie les valeurs pour obtenir a²-(bx+c)²
a = (0, valeur_alea(nombre_min, nombre_max))
b = (valeur_alea(nombre_min, nombre_max), valeur_alea(nombre_min, nombre_max))
if random.randrange(2) == 0: # le nombre est en premier
return (a, b)
else:
return (b, a)
def valeurs_apbamb(pyromax): # renvoie un tuple contenant ((3,-5),(3,+5))
a = valeur_alea(-pyromax, pyromax)
b = valeur_alea(-pyromax, pyromax)
if randrange(2) == 0:
return ((a, b), (-a, b))
else:
return ((a, b), (a, -b))
def Fraction(parametre):
question = u"Compléter :"
exo = []
cor = []
#Génération des nombres
n = d = 1
while n == d:
n = valeur_alea(parametre[0], parametre[1])
d = valeur_alea(parametre[0], parametre[1])
c = random.randrange(2, 11)
#Construction
cas = random.randrange(2)
if cas:
enonce = [n, d, n * c, d * c]
solution = [n, d, n * c, d * c]
else:
enonce = [n * c, d * c, n, d]
solution = [n * c, d * c, n, d]
trou = random.randrange(4)
enonce[trou] = "\\ldots"
solution[trou] = "\\boxed{%s}" % solution[trou]
if cas:
solution.insert(2, c)
solution.insert(1, c)
else:
solution.insert(4, c)
solution.insert(3, c)
#Affichage
exo.append("$$\\dfrac{%s}{%s}=\\dfrac{%s}{%s}$$" % tuple(enonce))
if cas:
cor.append("$$\\dfrac{%s_{(\\times %s)}}{%s_{(\\times %s)}}=\\dfrac{%s}{%s}$$" % tuple(solution))
else:
cor.append("$$\\dfrac{%s}{%s}=\\dfrac{%s_{(\\times %s)}}{%s_{(\\times %s)}}$$" % tuple(solution))
return (exo, cor, question)
def valeur_fraction(nombre_min, nombre_max):
n = valeur_alea( nombre_min, nombre_max)
d = valeur_alea( nombre_min, nombre_max)
while pgcd( n , d ) == 1:
n = valeur_alea( nombre_min, nombre_max)
d = valeur_alea( nombre_min, nombre_max)
fr = Fractions(n, d)
return fr
def valeurs_facto(nombre_min, nombre_max):
while True:
a = valeur_alea(nombre_min, nombre_max)
b = valeur_alea(nombre_min, nombre_max)
c = valeur_alea(nombre_min, nombre_max)
l = [0, a, b, c]
if abs(l[1]) != 1:
break #Pour qu'il y ait quelque chose à développer.
return ((l[0], l[1]), (l[2], l[3]))
def valeurs_distr(nombre_min, nombre_max): # renvoie in tuple contenant ((a,b),(c,d)) avec a != c ou b != d (en valeur absolue) et a, b, c ou d nul.
while True:
a = valeur_alea(nombre_min, nombre_max)
b = valeur_alea(nombre_min, nombre_max)
c = valeur_alea(nombre_min, nombre_max)
l = [a, b, c]
l.insert(random.randrange(4), 0)
if abs(l[1]) != 1 and abs(l[3]) != 1:
break #Pour qu'il y ait quelque chose à développer.
return ((l[0], l[1]), (l[2], l[3]))
def valeur_decimal(nombre_min, nombre_max):
n = valeur_alea( nombre_min, nombre_max)
longueur_n = len(str(n))
d = 10 ** random.randrange(longueur_n-1, longueur_n+3)
while pgcd( n , d ) == 1:
n = valeur_alea( nombre_min, nombre_max)
longueur_n = len(str(n))
d = 10 ** random.randrange(longueur_n-1, longueur_n+3)
fr = Fractions(n, d)
return float(n)/d, fr
def valeurs_distr(nombre_min, nombre_max):
while True:
a = valeur_alea(nombre_min, nombre_max)
b = valeur_alea(nombre_min, nombre_max)
c = valeur_alea(nombre_min, nombre_max)
l = [a, b, c]
l.insert(random.randrange(0, 4, 2), 0)
if abs(l[1]) != 1 and abs(l[3]) != 1:
break #Pour qu'il y ait quelque chose à développer.
return ((l[0], l[1]), (l[2], l[3]))
def valeurs_type0(nombre_min, nombre_max): # renvoie les valeurs pour obtenir un facteur commun et un facteur 1
a = ((valeur_alea(nombre_min, nombre_max), valeur_alea(nombre_min, nombre_max)), (valeur_alea(nombre_min, nombre_max), valeur_alea(nombre_min, nombre_max)))
while a[0] == a[1]: # on refuse un carre
a = ((valeur_alea(nombre_min, nombre_max), valeur_alea(nombre_min, nombre_max)), (valeur_alea(nombre_min, nombre_max), valeur_alea(nombre_min, nombre_max)))
b = (a[random.randrange(2)], (0, 1))
if random.randrange(2) == 1: # le 1 est dans le deuxieme terme
return (a, b, random.randrange(2), random.randrange(2))
else:
return (b, a, random.randrange(2), random.randrange(2))
def valeurs_type3(nombre_min, nombre_max): # renvoie les valeurs pour obtenir un facteur commun au carre
a = ((valeur_alea(nombre_min, nombre_max), valeur_alea(nombre_min, nombre_max)), (valeur_alea(nombre_min, nombre_max), valeur_alea(nombre_min, nombre_max)))
while a[0] == a[1]: # on refuse un carre
a = ((valeur_alea(nombre_min, nombre_max), valeur_alea(nombre_min, nombre_max)), (valeur_alea(nombre_min, nombre_max), valeur_alea(nombre_min, nombre_max)))
if random.randrange(2) == 0:
b = (a[0], a[0])
else:
b = (a[1], a[1])
if random.randrange(2) == 0: # le carre est en premier
return (b, a, 0, random.randrange(2))
else:
return (a, b, random.randrange(2), 0)
def valeurs_somme_prod(): # cree 3 fractions et un tuple de signes (+,*)
while True:
(base1, base2) = (valeur_alea(-13, 13), valeur_alea(-13, 13))
lepgcd = pgcd(base1, base2)
(base1, base2) = (base1 // lepgcd, base2 // lepgcd)
if base1 != 1 and base2 != 1:
break
(n2, d2) = (base1 * valeur_alea(-10, 10), abs(base2 * valeur_alea(2, 10)))
lepgcd = pgcd(n2, d2)
(n2, d2) = (n2 // lepgcd, d2 // lepgcd)
(n3, d3) = (base2 * valeur_alea(-10, 10), abs(base1 * valeur_alea(2, 10)))
lepgcd = pgcd(n3, d3)
(n3, d3) = (n3 // lepgcd, d3 // lepgcd)
(n1, d1) = (base1 * valeur_alea(-10, 10), abs(pgcd(d2, base2 * valeur_alea(2, 10))))
lepgcd = pgcd(n1, d1)
(n1, d1) = (n1 // lepgcd, d1 // lepgcd)
if randrange(2) == 0:
s1 = "+"
else:
s1 = "-"
if randrange(2) == 0:
s2 = "*"
else:
s2 = ":"
if s2 == "*":
return ((n1, d1), (n2, d2), (n3, d3), (s1, s2))
else:
return ((n1, d1), (n2, d2), (d3, n3), (s1, s2))
def def_vals():
lexp = [0, 1, 2, 0, 1, 2]
expr = []
for i in range(6):
a = valeur_alea(-10, 10)
e = lexp.pop(randrange(len(lexp)))
expr.append([a, "x", e])
return expr
def def_vals2():
expr = []
loper = ["+", "-", "\\times", "+", "-", "\\times", "+", "-"]
for i in range(8):
a = valeur_alea(-10, 10)
e = randrange(3)
o = loper.pop(randrange(len(loper)))
expr.append([a, "x", e, o])
return expr
def def_vals3():
expr = []
lsgn = ["+", "-", "+", "-"]
for i in range(9):
if i % 3 == 0:
sgn = lsgn.pop(randrange(len(lsgn)))
if i > 0 or sgn == "-":
expr.append(sgn)
expr.append(" (")
elif i % 3 == 1:
a = valeur_alea(-10, 10)
e = randrange(3)
expr.append([a, "x", e])
else:
a = valeur_alea(-10, 10)
e = randrange(3)
while e == expr[-1][2]:
e = randrange(3)
expr.append([a, "x", e])
expr.append(") ")
return expr
def valeurs_prod_parenth(): # cree 3 fractions et un tuple de signes (*,+)
while True:
(base1, base2) = (valeur_alea(2, 13), valeur_alea(2, 13))
lepgcd = pgcd(base1, base2)
(base1, base2) = (base1 // lepgcd, base2 // lepgcd)
if base1 != 1 and base2 != 1:
break
while True:
n2 = valeur_alea(-13, 13)
lepgcd = pgcd(n2, base1)
if lepgcd == 1:
break
while True:
n3 = valeur_alea(-13, 13)
lepgcd = pgcd(n3, base2)
if lepgcd == 1:
break
while True:
(n1, d1) = (valeur_alea(-10, 10), valeur_alea(2, 10))
lepgcd = pgcd(n1, d1)
if lepgcd != n1 and lepgcd != d1:
break
(n1, d1) = (n1 // lepgcd, d1 // lepgcd)
if randrange(2) == 0:
s1 = "*"
else:
s1 = ":"
if randrange(2) == 0:
s2 = "+"
else:
s2 = "-"
return ((n1, d1), (n2, base1), (n3, base2), (s1, s2))
def valeurs_calcul_distr(nombre_min, nombre_max):
cpt = 0
while True:
cpt += 1
# generation de 2 nombres
nombre1 = valeur_alea(nombre_min, nombre_max)
nombre2 = valeur_alea(nombre_min, nombre_max)
# arrondi au premier chiffre et distance à cet arrondi
nombre1_arrondi = int(round( nombre1 , min( 1 - len(str(abs(nombre1))), -1) ))
nombre1_distance = nombre1 - nombre1_arrondi
nombre2_arrondi = int(round( nombre2 , min( 1 - len(str(abs(nombre2))), -1) ))
nombre2_distance = nombre2 - nombre2_arrondi
# on choisit de décomposer le nombre qui à la plus petite distance non nulle
if abs(nombre1_distance) <= abs(nombre2_distance) and abs(nombre1_distance)!= 0 and abs(nombre1)>=10 and abs(nombre2)!= 1:
l = [ nombre1_arrondi, nombre1_distance, 0, nombre2 ]
break
elif abs(nombre1_distance) > abs(nombre2_distance) and abs(nombre2_distance)!= 0 and abs(nombre2)>=10 and abs(nombre1)!= 1:
l = [ 0, nombre1, nombre2_arrondi, nombre2_distance ]
break
elif cpt > 50:
l = [ 0, nombre1, 0, nombre2 ]
break
return ((l[0], l[1]), (l[2], l[3]))
def valeurs_type2(nombre_min, nombre_max): # renvoie les valeurs pour obtenir un facteur commun.
a = ((valeur_alea(nombre_min, nombre_max), valeur_alea(nombre_min, nombre_max)), (valeur_alea(nombre_min, nombre_max), valeur_alea(nombre_min, nombre_max)))
while a[0] == a[1]: # on refuse un carre
a = ((valeur_alea(nombre_min, nombre_max), valeur_alea(nombre_min, nombre_max)), (valeur_alea(nombre_min, nombre_max), valeur_alea(nombre_min, nombre_max)))
if random.randrange(2) == 0:
while True:
b = (a[random.randrange(2)], (valeur_alea(nombre_min, nombre_max), valeur_alea(nombre_min, nombre_max)))
if b[0] != b[1]:
break
else:
while True:
b = ((valeur_alea(nombre_min, nombre_max), valeur_alea(nombre_min, nombre_max)), a[random.randrange(2)])
if b[0] != b[1]:
break
(nega, negb) = (random.randrange(2), random.randrange(2))
return (a, b, nega, negb)
def valeurs_equation(nombre_min, nombre_max): # renvoie in tuple contenant ((a,b),(c,d)) avec a != c ou b != d (en valeur absolue)
a = valeur_alea(nombre_min, nombre_max)
b = valeur_alea(nombre_min, nombre_max)
c = valeur_alea(nombre_min, nombre_max)
d = valeur_alea(nombre_min, nombre_max)
while abs(a) == abs(c) and abs(b) == abs(d):
c = valeur_alea(nombre_min, nombre_max)
d = valeur_alea(nombre_min, nombre_max)
return ((a, b), (c, d))
def valeurs_dbldistr(pyromax): # renvoie in tuple contenant ((a,b),(c,d)) avec a != c ou b != d (en valeur absolue)
a = valeur_alea(-pyromax, pyromax)
b = valeur_alea(-pyromax, pyromax)
c = valeur_alea(-pyromax, pyromax)
d = valeur_alea(-pyromax, pyromax)
while abs(a) == abs(c) and abs(b) == abs(d):
c = valeur_alea(-pyromax, pyromax)
d = valeur_alea(-pyromax, pyromax)
return ((a, b), (c, d))
def def_vals4():
expr = []
for i in range(9):
a = valeur_alea(-10, 10)
e = randrange(3)
if i % 3 == 0:
expr.append([a, "x", e])
expr.append(" \,(")
elif i % 3 == 1:
expr.append([a, "x", e])
else:
while e == expr[-1][2]:
e = randrange(3)
expr.append([a, "x", e])
expr.append(") ")
return expr
def def_vals5():
expr = []
for i in range(8):
a = valeur_alea(-10, 10)
e = randrange(3)
if i % 2 == 0:
if i % 4 == 0:
expr.append(" (")
else:
expr.append(" \,(")
expr.append([a, "x", e])
else:
while e == expr[-1][2]:
e = randrange(3)
expr.append([a, "x", e])
expr.append(") ")
if i == 3:
expr.append(["+", "+", "-"].pop(randrange(3)))
return expr
def valeurs_quotient_frac(): # cree 4 fractions et un tuple de signes (+,+)
while True:
(n1, d1) = (valeur_alea(-10, 10), valeur_alea(2, 10))
lepgcd = pgcd(n1, d1)
if lepgcd != n1 and lepgcd != d1:
break
(n1, d1) = (n1 // lepgcd, d1 // lepgcd)
while True:
(n3, d3) = (valeur_alea(-10, 10), valeur_alea(2, 10))
lepgcd = pgcd(n3, d3)
if lepgcd != n3 and lepgcd != d3:
break
(n3, d3) = (n3 // lepgcd, d3 // lepgcd)
(n2, n4) = (valeur_alea(1, 10), valeur_alea(1, 10))
if randrange(2) == 0:
s1 = "+"
else:
s1 = "-"
if randrange(2) == 0:
s2 = "+"
else:
s2 = "-"
return ((n1, d1), (n2, 1), (n3, d3), (n4, 1), (s1, s2))
def valeurs_apb2(pyromax): # renvoie un tuple contenant ((3,5),(3,5))
a = valeur_alea(1, pyromax)
b = valeur_alea(1, pyromax)
return ((a, b), (a, b))
def valeur_quotient(nombre_min, nombre_max):
(a, b) = (valeur_alea(nombre_min, nombre_max), valeur_alea(nombre_min, nombre_max))
while pgcd(a, b) == b:
(a, b) = (valeur_alea(nombre_min, nombre_max), valeur_alea(nombre_min, nombre_max))
return (a // pgcd(a, b), b // pgcd(a, b))
def valeur_relatif(nombre_min, nombre_max):
(a, b) = (valeur_alea(nombre_min, nombre_max), 1 )
return (a, b)
def valeur_expression_trinome(nombre_min, nombre_max):
(a, b, c) = (valeur_alea(nombre_min, nombre_max), valeur_alea(nombre_min, nombre_max), valeur_alea(nombre_min, nombre_max))
return ((a, b, c))
def valeurs_amb2(nombre_min, nombre_max): # renvoie un tuple contenant ((3,-5),(3,-5))
a = valeur_alea(nombre_min, nombre_max)
b = valeur_alea(-nombre_max, -nombre_min)
return ((a, b), (a, b))
def valeurs_puissances(): # renvoie un tuple contenant les valeurs pour les deux exercices sur les puissances
from math import floor, log10
(max, emax) = (10, 2)
while True:
(b1, b2) = (valeur_alea(2, max), valeur_alea(2, max))
(b1, b2) = (b1 / pgcd(b1, b2), b2 / pgcd(b1, b2))
if b1 != 1 and b2 != 1:
break
while True:
(n1, n2) = ((b1 * valeur_alea(2, max)) * 10 ** randrange(-emax,
emax), (b2 * valeur_alea(2, max)) * 10 ** randrange(-emax,
emax))
n3 = ((b1 * b2) * choice((2, 4, 5, 8))) * 10 ** randrange(-emax,
emax)
if int(floor(log10(((n1 * n2) * 1.) / n3))) != 0 and n1 != 1 and \
n2 != 1 and n3 != 1:
break
(e1, e2, e3, e4) = (valeur_alea(-10, 10), valeur_alea(-10, 10),
valeur_alea(2, 10), valeur_alea(2, 5))
a = verifie_type((n1, n2, n3, e1, e2, e3, e4))
while True:
(b1, b2) = (valeur_alea(2, max), valeur_alea(2, max))
(b1, b2) = (b1 / pgcd(b1, b2), b2 / pgcd(b1, b2))
if b1 != 1 and b2 != 1:
break
(n1, n2) = ((b1 * valeur_alea(2, max)) * 10 ** randrange(-emax, emax +
1), (b2 * valeur_alea(2, max)) * 10 ** randrange(-emax,
emax + 1))
n3 = ((b1 * b2) * choice((1, 2, 4, 5, 8))) * 10 ** randrange(-emax,
emax + 1)
(e1, e2, e3, e4) = (valeur_alea(-10, 10), valeur_alea(-10, 10),
valeur_alea(-10, -2), valeur_alea(2, 5))
b = verifie_type((n1, n2, n3, e1, e2, e3, e4))
return (a, b)
def valeurs_amb2(pyromax): # renvoie un tuple contenant ((3,-5),(3-5))
a = valeur_alea(1, pyromax)
b = valeur_alea(-pyromax, -1)
return ((a, b), (a, b))
