def __init__(self, connue, composite):
# on appelle ExerciceFunction.__init__ pour remplir tous les champs
# mais self.datasets sera en fait rempli plus tard
# une petite clôture..
def target(inconnue):
return composite
ExerciceFunction.__init__(
self, target, None,
render_name = False,
column_headers = ("inconnue",
"composite",
"connue + inconnue + connue"
)
)
self.connue = connue
self.composite = composite
# si a est impair et b est pair
elif a % 2 != 0 and b % 2 == 0:
return (a - 1) * b
# sinon - c'est que a et b sont impairs
else:
return a * a - b * b
# @END@
def dispatch1_ko(a, b, *args):
return a * a + b * b
exo_dispatch1 = ExerciceFunction(dispatch1, inputs_dispatch1)
####################
samples_A = [(2, 4, 6), [2, 4, 6]]
samples_B = [{6, 8, 10}]
inputs_dispatch2 = [
Args(a, b, A, B) for a, A in zip(range(3, 5), samples_A)
for b in range(7, 10) for B in samples_B
]
# @BEG@ name=dispatch2
def dispatch2(a, b, A, B):
"""dispatch2 comme spécifié"""
# les deux cas de la diagonale \
# -*- coding: utf-8 -*-
from exercice_function import ExerciceFunction
from args import Args
#
# example how to use
#
# @BEG@ week=0 sequence=0 name=curve
def curve(a, b):
return a ** 2 + 3 * a * b + 12
# @END@
inputs_curve = [Args(0,1),
Args(0,2),
Args(0,3),
Args(0,4),
Args(1,2),
Args(1,3),
Args(1,4),
Args(1,5),
]
exo_curve = ExerciceFunction(
curve, inputs_curve)
exo_curve_name = ExerciceFunction(
curve, inputs_curve, render_name=True)
def correction(self, student_decode_zen):
args_obj = Args(this)
self.datasets = [args_obj]
return ExerciceFunction.correction(self, student_decode_zen)
return None
inputs_libelle = [
Args("Joseph, Dupont, 4"),
Args("Jean"),
Args("Jules , Durand, 1"),
Args(" Ted, Mosby, 2,"),
Args(" Jacques , Martin, 3 \t"),
Args("Sheldon, Cooper ,5, "),
Args("\t John, Doe\t, "),
]
exo_libelle = ExerciceFunction(
libelle,
inputs_libelle,
exemple_how_many=0,
render_name=False,
)
##############################
# @BEG@ name=carre
def carre(s):
# on enlève les espaces et les tabulations
s = s.replace(' ', '').replace('\t', '')
# la ligne suivante fait le plus gros du travail
# d'abord on appelle split() pour découper selon les ';'
# dans le cas où on a des ';' en trop, on obtient dans le
# résultat du split un 'token' vide, que l'on ignore
# ici avec le clause 'if token'
# enfin on convertit tous les tokens restants en entiers avec int()
def aplatir_ko(conteneurs):
return conteneurs
aplatir_inputs = [
Args([]),
Args([(1, )]),
Args(([1], )),
Args([(0, 6, 2), [1, ('a', 4), 5]]),
Args(([1, [2, 3]], ('a', 'b', 'c'))),
Args(([1, 6], ('c', 'b'), [2, 3])),
Args(((1, [2, 3]), [], ('a'), ['b', 'c'])),
]
exo_aplatir = ExerciceFunction(aplatir, aplatir_inputs, exemple_how_many=0)
##############################
# @BEG@ name=alternat
def alternat(l1, l2):
"renvoie une liste des éléments pris un sur deux dans l1 et dans l2"
# pour réaliser l'alternance on peut combiner zip avec aplatir
# telle qu'on vient de la réaliser
return aplatir(zip(l1, l2))
# @END@
alternat_inputs = [
Args((1, 2), ('a', 'b')),
Args(10, 30),
Args(10, -30),
Args(-10, 30),
Args(-10, -30),
Args(8, 12),
Args(12, -8),
Args(-12, 8),
Args(-12, -8),
Args(10, 1),
Args(30, 10),
Args(30, -10),
Args(-30, 10),
Args(-30, -10),
]
exo_divisible = ExerciceFunction(
divisible, inputs_divisible)
####################
# @BEG@ name=spam
def spam(liste):
"""
Prend en argument une liste, et retourne la liste modifiée:
* taille paire: on intervertit les deux premiers éléments
* taille impaire, on retire le dernier élément
"""
# si la liste est vide il n'y a rien à faire
if not liste:
pass
# si la liste est de taille paire
elif len(liste) % 2 == 0:
# on intervertit les deux premiers éléments
min(liste),
)
from random import randint
def numbers_input():
length = randint(3,6)
result = []
for i in xrange(length):
result.append(randint(5, 15))
return result
numbers_inputs = [Args(numbers_input()) for i in xrange (3)]
exo_numbers = ExerciceFunction(
numbers, numbers_inputs,
layout_args = (30, 25, 25) )
##############################
# @BEG@ name=compare
def compare(f, g, entrees):
"""
retourne une liste de booléens, un par entree dans entrees
qui indique si f(entree) == g(entree)
"""
# on vérifie pour chaque entrée si f et g retournent
# des résultats égaux avec ==
# et on assemble le tout avec une comprehension de liste
return [f(entree) == g(entree) for entree in entrees]
# @END@
def correction(self, student_merge,
extended=extended, abbreviated=abbreviated):
self.datasets = [Args(extended, abbreviated)]
return ExerciceFunction.correction(self, student_merge)
def correction(self, student_index, bateaux=abbreviated):
self.datasets = [Args(bateaux)]
return ExerciceFunction.correction(self, student_index)
def correction(self,
student_merge,
extended=extended,
abbreviated=abbreviated):
self.datasets = [Args(extended, abbreviated)]
return ExerciceFunction.correction(self, student_merge)
def correction(self, student_index, bateaux=abbreviated):
self.datasets = [Args(bateaux)]
return ExerciceFunction.correction(self, student_index)
def correction(self, student_comptage):
# call the decorator on the student code
return ExerciceFunction.correction(
self, exercice_compliant(student_comptage))
# @END@
def liste_P_ko(liste):
return [P(liste[0])]
inputs_liste_P = [
Args(range(5)),
Args(range(-7, 8, 2)),
Args([-100, 0, 100]),
]
exo_liste_P = ExerciceFunction(
liste_P,
inputs_liste_P,
)
####################
# @BEG@ name=multi_tri
def multi_tri(listes):
"""
trie toutes les sous-listes
et retourne listes
"""
for liste in listes:
# sort fait un effet de bord
liste.sort()
# et on retourne la liste de départ
return listes
def correction(self,
student_diff,
extended=extended,
abbreviated=abbreviated):
self.datasets = [Args(extended, abbreviated).clone('deep')]
return ExerciceFunction.correction(self, student_diff)
def correction(self, student_diff, extended=extended, abbreviated=abbreviated):
self.datasets = [Args(extended, abbreviated).clone('deep')]
return ExerciceFunction.correction(self, student_diff)
def distance_ko(*args):
return sum([x**2 for x in args])
distance_inputs = [
Args(),
Args(1),
Args(1, 1),
Args(1, 1, 1),
Args(1, 1, 1, 1),
Args(*range(10)),
]
exo_distance = ExerciceFunction(distance, distance_inputs, exemple_how_many=3)
##############################
# @BEG@ name=doubler_premier
def doubler_premier(f, first, *args):
"""
renvoie le résultat de la fonction f appliquée sur
f(2 * first, *args)
"""
# une fois qu'on a écrit la signature on a presque fini le travail
# en effet on a isolé la fonction, son premier argument, et le reste
# des arguments
# il ne reste qu'à appeler f, après avoir doublé first
return f(2 * first, *args)
def correction(self, student_decode_zen):
args_obj = Args(this)
self.datasets = [ args_obj ]
return ExerciceFunction.correction(self, student_decode_zen)
return b
# sinon on passe à l'itération suivante
a, b = b, r
# @END@
# xxx à publier ?
# le code proposé par un étudiant, et qui serait en mesure de gérer
# le cas b=0 qui semble-t-il provoque un ZeroDivisionError
# à voir aussi: l'inversion des deux entrées est probablement inutile
def pgcd_ter(a, b):
if b > a:
a, b = b, a
while b:
a, b = b, a % b
return a
def pgcd_ko(a, b):
return a % b
inputs_pgcd = [
Args(36 * 2**i * 3**j * 5**k, 36 * 2**j * 3**k * 5**i) for i in range(3)
for j in range(3) for k in range(2)
]
exo_pgcd = ExerciceFunction(pgcd, inputs_pgcd)
def correction(self, inconnue):
# dans notre cas il n'y a qu'un seul jeu d'entrées
self.datasets = [ Args(inconnue) ]
def check(inconnue):
return self.connue + inconnue + self.connue
return ExerciceFunction.correction(self, check)
def correction(self, student_comptage):
# call the decorator on the student code
return ExerciceFunction.correction(self, exercice_compliant(student_comptage))