Retourne une liste de ces 3 nombres (notez qu'usuellement on renverrait plutôt un tuple, qu'on étudiera la semaine prochaine) """ # on peut tout faire avec la bibliothèque standard nb_lines = string.count('\n') nb_words = len(string.split()) nb_bytes = len(string) return [nb_lines, nb_words, nb_bytes] # @END@ wc_inputs = ( Args('''Python is a programming language that lets you work quickly and integrate systems more effectively.'''), Args(''), Args('abc'), Args('abc \t'), Args('a bc \t'), Args(' \tabc \n'), Args(" ".join("abcdefg") + "\n"), Args('''The Zen of Python, by Tim Peters Beautiful is better than ugly. Explicit is better than implicit. Simple is better than complex. Complex is better than complicated. Flat is better than nested. Sparse is better than dense.
here we have decided to allow for comparison with a regular number """ if isinstance(other, (bool, int, float)): return self == Quaternion(other, 0, 0, 0) elif isinstance(other, complex): return self == Quaternion(other.real, other.imag, 0, 0) elif isinstance(other, Quaternion): return self.implem == other.implem else: return False # @END@ quaternion_scenarios = [ ClassScenario( Args(1, 0, 0, 0), ClassExpression('INSTANCE == 1'), ), ClassScenario( Args(0, 1, 0, 0), ClassExpression('''# attention ici j c'est en fait notre i INSTANCE == 1j'''), ), ClassScenario( Args(-1, 0, 0, 0), ClassExpression( 'CLASS(0, 1, 0, 0) * CLASS(0, 1, 0, 0) == INSTANCE' ), ClassExpression( 'CLASS(0, 0, 1, 0) * CLASS(0, 0, 1, 0) == INSTANCE' ),
# ne marche pas car on n'a pas les deux arguments requis # par doubler_premier_kwds # # et pour écrire, disons doubler_permier3, qui marcherait aussi comme cela # il faudrait faire une hypothèse sur le nom du premier argument... # @END@ def add3(x, y=0, z=0): return x + y + z def mul3(x=1, y=1, z=1): return x * y * z doubler_premier_kwds_inputs = [ Args(add3, 1, 2, 3), Args(add3, 1, 2, z=3), Args(add3, 1, y=2, z=3), # Args(add3, x=1, y=2, z=3), Args(mul3, 1, 2, 3), Args(mul3, 1, 2, z=3), Args(mul3, 1, y=2, z=3), # Args(mul3, x=1, y=2, z=3), ] # remettre les datasets de doubler_premier doubler_premier_kwds_inputs \ += [ arg_obj for arg_obj in doubler_premier_inputs if arg_obj.args[0] == distance ]
from nbautoeval import ExerciseFunction, Args from nbautoeval import CallRenderer, PPrintRenderer def composantes_a(xA,yA,xB,yB): ax=xB-xA ay=yB-yA return(ax,ay) def soustraction_a_b(ax,ay,bx,by): cx=ax-bx cy=ay-by return(cx,cy) inputs_composantes_a = [ Args(15,10,20,15),Args(12,5,22,10),Args(5,5,10,10),Args(5,5,5,10),Args(15,10,23,10),Args(15,15,10,12),Args(20,10,15,15) ] inputs_soustraction_a_b = [ Args(15,10,20,15),Args(12,5,22,10),Args(5,5,10,10),Args(5,5,5,10),Args(15,10,23,10),Args(15,15,10,12),Args(20,10,15,15) ] exo_composantes_a = ExerciseFunction( composantes_a, inputs_composantes_a, # show function name in leftmost column call_renderer=CallRenderer(show_function=True), # use pprint to format results result_renderer=PPrintRenderer(width=20), font_size="90%",
return sum( # ici sum(x) fait la somme des tirages des dés sum(x) == target for x in product(range(1, sides + 1), repeat=nb_dice)) # @END@ def dice_ko(target, nb_dice=2, nb_sides=6): return nb_sides**(nb_dice - 1) SIDES = 5 dice_inputs = [ Args(7), Args(2), Args(20, nb_sides=10), Args(3, nb_dice=3), Args(4, nb_dice=3), Args(50, nb_dice=8), Args(28, nb_dice=8), ] + [ Args(target, nb_sides=SIDES, nb_dice=3) for target in range(3, 3 * SIDES + 1) ] exo_dice = ExerciseFunctionNumpy( dice, dice_inputs, nb_examples=5,
from nbautoeval import Args, ExerciseFunction, PPrintCallRenderer # @BEG@ name=longest_gap def longest_gap(liste): result = 0 begins = {} for index, item in enumerate(liste): if item not in begins: begins[item] = index else: result = max(result, index - begins[item]) return result # @END@ inputs = [ Args([1, 2, 3, 1, 4, 10, 4, 3, -1, 4]), Args(["yes", "no", None, "yes", "no"]), Args([1, 2, 3, 4]), ] exo_longest_gap = ExerciseFunction( longest_gap, inputs, nb_examples=0, call_renderer=PPrintCallRenderer(width=45), )
stack.append(function(left, right)) else: # error: unknown op return 'error-syntax' if len(stack) == 0: return 'error-empty-stack' elif len(stack) > 1: return 'error-unfinished' return stack.pop() # @END@ inputs = [ Args("20 40 + 10 *"), Args(" 20 40 + 10 * "), Args("20 6 6 + /"), Args("20 18 -6 + /"), Args("10 -3 /"), Args("10 +"), Args("10 20 30 +"), Args("10 20 30 oops"), Args("40 20 / 10 +"), Args("40 20 - 10 +"), Args("+"), Args("10 20 30 + - /"), ] exo_postfix_eval = ExerciseFunction( postfix_eval,
C'est plus court, mais on passe du temps à se convaincre que ça fonctionne bien comme demandé """ # si on n'aime pas les boucles sans fin # on peut faire aussi comme ceci while b: a, b = b, a % b return a # @END@ def pgcd_ko(a, b): return a % b inputs_pgcd = [ Args(0, 0), Args(0, 1), Args(1, 0), Args(15, 10), Args(10, 15), Args(3, 10), Args(10, 3), Args(10, 1), Args(1, 10), ] 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) ]
first = args[0] remains = args[1:] return func(2 * first, *remains) # @END@ doubler_premier_inputs = [] from operator import add from operator import mul from .exo_distance import distance # pour l'exemple on choisit les 3 premiers inputs # avec des fonctions différentes for i in (1, 3, 5): doubler_premier_inputs.append(Args(add, i, 4)) doubler_premier_inputs.append(Args(mul, i, 4)) doubler_premier_inputs.insert(2, Args(distance, 1.5, 4.)) doubler_premier_inputs.insert(3, Args(distance, 2.0, 4., 4., 4.)) exo_doubler_premier = ExerciseFunction( doubler_premier, doubler_premier_inputs, nb_examples=4, call_renderer=CallRenderer(show_function=False), ) def doubler_premier_ko(f, first, *args): return f(3 * first, *args)
compare_all_inputs = [] # factoriel from operator import mul def fact(n): "une version de factoriel à base de reduce" return reduce(mul, range(1, n + 1), 1) from math import factorial fact_inputs = [0, 1, 5] compare_all_inputs.append(Args(fact, factorial, fact_inputs)) def broken_fact(n): return 0 if n <= 0 \ else 1 if n == 1 \ else n*fact(n-1) compare_all_inputs.append(Args(broken_fact, factorial, fact_inputs)) #################### the exercice instance exo_compare_all = ExerciseFunction( compare_all, compare_all_inputs, nb_examples=2,
if sum(sample) == target: count += 1 return count # @END@ def dice_ko(target, nb_dice=2, sides=6): return sides**(nb_dice - 1) SIDES = 5 dice_inputs = [ Args(7), Args(2), Args(20, sides=10), Args(3, nb_dice=3), Args(4, nb_dice=3), Args(50, nb_dice=8), ] + [ Args(target, sides=SIDES, nb_dice=3) for target in range(3, 3 * SIDES + 1) ] exo_dice = ExerciseFunctionNumpy( dice, dice_inputs, nb_examples=5, )
def _get_celsius(self): # celsius + KELVIN = kelvin return self._kelvin - self.KELVIN def _set_celsius(self, celsius): self.kelvin = celsius + self.KELVIN celsius = property(_get_celsius, _set_celsius) # @END@ temperature_scenarios = [ # build and display an instance ClassScenario( Args(), ClassExpression("INSTANCE.kelvin"), ClassExpression("INSTANCE.celsius"), ), ClassScenario( Args(kelvin=0), ClassExpression("INSTANCE.kelvin"), ClassExpression("INSTANCE.celsius"), ), ClassScenario( Args(celsius=0), ClassExpression("INSTANCE.kelvin"), ClassExpression("INSTANCE.celsius"), ), ClassScenario( Args(kelvin=0),
for i in range(0, 19, 1): assert t1[i] < t1[i+1], "il y a des éléments du tableau qui ne sont pas insérés par ordre croissant" return "Bravo ! je crois que vous avez réussi" ########## step 2 # You need to provide datasets # This is expected to be a list of Args instances # each one describes all the arguments to be passed # to the function # in this particular case we define 2 input sets, so # the correction will have 2 meaningful rows # inputs_creation = [ Args(2, 1, 10), Args(5, 1, 10), Args(1, 1, 10) ] inputs_ajout = [ Args([1, 2], 3), Args(["toto", "tata"], "titi"), Args([0], 1) ] inputs_miroir = [ Args([1, 2]), Args(["toto", "tata"]), Args([0]), Args(["anticonstitutionnellement"]),
10): decimal -= 2 * Roman.isymbols[previous] else: return nan decimal += Roman.isymbols[r] previous = r except KeyError: return nan else: return decimal # @END@ roman_scenarios = [ ClassScenario(Args(2020), ), ClassScenario( Args('MMXX'), ClassExpression("INSTANCE == CLASS(2020)"), ), ClassScenario( Args('MMXIX'), ClassExpression("INSTANCE + CLASS(19) == CLASS(2038)"), ClassExpression("INSTANCE - CLASS('MCMXCIX') == CLASS(20)"), ), ClassScenario(Args(5000), ), ClassScenario( Args(5000), ClassExpression("INSTANCE == CLASS(5000)"), ), ClassScenario(
def get_frags_number(df): PandasTools.ChangeMoleculeRendering(renderer='String') New_column = pd.DataFrame({ 'Frags_number': [len(Chem.rdmolops.GetMolFrags(mol)) for mol in df['ROMol']] }) New_column = New_column.set_index(df.index) return New_column df_meds = PandasTools.LoadSDF( './data/meds.sdf', isomericSmiles=True).drop(columns=['molecule_synonyms']) df_meds = df_meds[df_meds['molecule_type'] == 'Small molecule'] inputs_frags_number = [ Args(df_meds[['ROMol']].head()), Args(df_meds[['ROMol']]) ] exo_frags_number = ExerciseFunctionPandas(get_frags_number, inputs_frags_number, call_renderer=PPrintCallRenderer( show_function=False, css_properties={ 'word-wrap': 'break-word', 'max-width': '40em' }, )) # ________________________________________________________________________________
# en utilisant la méthode dot sur les tableaux return column.dot(column.T) # remarquez qu'on aurait pu faire aussi bien # return np.dot(column, column.T) # @END@ def xixj_ko(*args): # presque ça mais sans le reshape array = np.array(args) return array.T @ array inputs_xixj = [ Args(1), Args(1, 2), Args(1, 2, 4), Args(1, 0, 4), Args(8, 4, 2), Args(0, 1, 2, 4, 8), Args(1, 1j, -1, -1j), ] exo_xixj = ExerciseFunctionNumpy( xixj, inputs_xixj, nb_examples=3, )
{'n': 'Forbes', 'p': 'Bob'}, {'n': 'Martin', 'p': 'Jeanneot'}, {'n': 'Martin', 'p': 'Jean', 'p2': 'Paul'}, {'n': 'Forbes', 'p': 'Charlie'}, {'n': 'Martin', 'p': 'Jean', 'p2': 'Pierre'}, {'n': 'Dupont', 'p': 'Alexandre'}, {'n': 'Dupont', 'p': 'Laura', 'p2': 'Marie'}, {'n': 'Forbes', 'p': 'John'}, {'n': 'Martin', 'p': 'Jean'}, {'n': 'Dupont', 'p': 'Alex', 'p2': 'Pierre'}]] inputs_tri_custom = [ Args(input) for input in inputs ] exo_tri_custom = ExerciseFunction( tri_custom, inputs_tri_custom, call_renderer=PPrintCallRenderer(width=24), result_renderer=PPrintRenderer(width=30), font_size='small', ) def tri_custom_ko(liste): sort(liste) return liste
def correction(self, student_decode_zen): args_obj = Args(this) self.datasets = [ args_obj ] return ExerciseFunction.correction(self, student_decode_zen)
"renvoie True si un des deux arguments divise l'autre" # on n'a pas encore vu les opérateurs logiques, mais # on peut aussi faire tout simplement comme ça # sans faire de if du tout return a % b == 0 or b % a == 0 # @END@ def divisible_ko(a, b): return a % b == 0 inputs_divisible = [ 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 = ExerciseFunction(divisible, inputs_divisible)
# @BEG@ name=carre more=ter def carre_ter(ligne): # On extrait toutes les valeurs séparées par des points- # virgules, on les nettoie avec la méthode strip # et on stocke le résultat dans une liste liste_valeurs = [t.strip() for t in ligne.split(';')] # Il ne reste plus qu'à calculer les carrés pour les # valeurs valides (non vides) et les remettre dans une str return ":".join([str(int(v)**2) for v in liste_valeurs if v]) # @END@ inputs_carre = [ Args("1;2;3"), Args(" 2 ; 5;6;"), Args("; 12 ; -23;\t60; 1\t"), Args("; -12 ; ; -23; 1 ;;\t"), ] exo_carre = ExerciseFunction(carre, inputs_carre, nb_examples=0, call_renderer=PPrintCallRenderer( show_function=False, width=40)) def carre_ko(s): return ":".join(str(i**2) for i in (int(token) for token in s.split(';')))
# @END@ def comptage_ko(in_filename, out_filename): with open(in_filename) as in_file: with open(out_filename, 'w') as out_file: for lineno, line in enumerate(in_file): out_file.write(f"{lineno}:{len(line.split())}:" f"{len(line)}:{line}") # on passe ceci à ExerciseFunction donc pas besoin de rajouter les **keywords comptage_args = [ Args('data/romeo_and_juliet.txt', 'romeo_and_juliet.out'), Args('data/lorem_ipsum.txt', 'lorem_ipsum.out'), Args('data/une_charogne_unicode.txt', 'une_charogne_unicode.out'), ] class ExoComptage(ExerciseFunction): def correction(self, student_comptage): # call the decorator on the student code return ExerciseFunction.correction( self, exercice_compliant(student_comptage)) # on recherche les noms des fichers d'entrée et de sortie # à utiliser pour l'exemple (ou le debug, on prend le même) # associés au premier jeu de données (self.datasets[0]) # et là-dedans il nous faut regarder dans .args qui va contenir
# @END@ # @BEG@ name=read_set more=bis # on peut aussi utiliser une compréhension d'ensemble # (voir semaine 5); ça se présente comme # une compréhension de liste mais on remplace # les [] par des {} def read_set_bis(filename): with open(filename) as feed: return {line.strip() for line in feed} # @END@ read_set_inputs = [ Args("data/setref1.txt"), Args("data/setref2.txt"), ] exo_read_set = ExerciseFunction( read_set, read_set_inputs, result_renderer=PPrintRenderer(width=25), ) # @BEG@ name=search_in_set # ici aussi on suppose que les fichiers existent def search_in_set(filename_reference, filename): """ cherche les mots-lignes de filename parmi ceux
# Calculate distance matrix for fingerprint list def Tanimoto_distance_matrix(fp_list): dissimilarity_matrix = [] for i in range(1, len(fp_list)): similarities = DataStructs.BulkTanimotoSimilarity( fp_list[i], fp_list[:i]) # Since we need a distance matrix, calculate 1-x for every element in similarity matrix for sim in similarities: dissimilarity_matrix.append(1 - sim) return dissimilarity_matrix inputs_tan_dist_mat = [ Args(fingerprints_str[0:3]), Args(fingerprints_str[0:1000]) ] exo_tan_dist_mat = ExerciseFunction(Tanimoto_distance_matrix_from_str, inputs_tan_dist_mat, call_renderer=PPrintCallRenderer( show_function=False, css_properties={ 'word-wrap': 'break-word', 'max-width': '40em' }, )) def ClusterFps_from_str(fp_list_str, cutoff=0.2):
# le broadcasting c'est magique parfois # car avec cette méthode on peut multiplier # dans n'importe quel ordre ! # ce qui fait que ceci marche ausi ! # return column * column.T # @END@ def xixj_ko(*args): # presque ça mais sans le reshape array = np.array(args) return array.T @ array inputs_xixj = [ Args(1), Args(1, 2), Args(1, 2, 4), Args(1, 0, 4), Args(8, 4, 2), Args(0, 1, 2, 4, 8), ] exo_xixj = ExerciseFunctionNumpy( xixj, inputs_xixj, nb_examples=3, )
Idem mais avec une expression génératrice """ # on n'a pas encore vu cette forme - cf Semaine 5 # mais pour vous donner un avant-goût d'une expression # génératrice: # on peut faire aussi comme ceci # observez l'absence de crochets [] # la différence c'est juste qu'on ne # construit pas la liste des carrés, # car on n'en a pas besoin # et donc un itérateur nous suffit return math.sqrt(sum(x**2 for x in args)) # @END@ distance_inputs = [ Args(), Args(1), Args(1, 1), Args(1, 1, 1), Args(1, 1, 1, 1), Args(*range(10)), ] exo_distance = ExerciseFunction(distance, distance_inputs, nb_examples=3) def distance_ko(*args): return sum([x**2 for x in args])
def correction(self, student_diff, extended=extended, abbreviated=abbreviated): self.datasets = [Args(extended, abbreviated).clone('deep')] return ExerciseFunction.correction(self, student_diff)
while index > 26: index = (index - 1) // 26 # idem ici bien sûr result = int_to_char(index) + result return result # @END@ z = 26 zz = 26**2 + 26 zzz = 26**3 + 26**2 + 26 numeric_inputs = ( 1, 15, z, z+1, zz-1, zz, zz+1, zz+2, zzz-1, zzz, zzz+1, zzz+2, 26**2-1, 30_000, 100_000, 1_000_000, ) # l'objet Args permet de capturer les arguments # pour un appel à la fonction spreadsheet_inputs = [Args(n) for n in numeric_inputs] exo_spreadsheet = ExerciseFunction( spreadsheet, spreadsheet_inputs, nb_examples=7, ) def spreadsheet_ko(n): if 1 <= n <= 26: return int_to_char(n) else: return spreadsheet_ko(n//26) + int_to_char(n)
def intersect_ko(A, B): A_vals = {v for k, v in A} B_vals = {v for k, v in B} return A_vals & B_vals intersect_inputs = [] A1 = { (12, 'douze'), (10, 'dixA'), (8, 'huit'), } B1 = { (5, 'cinq'), (10, 'dixB'), (15, 'quinze'), } intersect_inputs.append(Args(A1, B1)) A2 = {(1, 'unA'), (2, 'deux'), (3, 'troisA')} B2 = {(1, 'unB'), (2, 'deux'), (4, 'quatreB')} intersect_inputs.append(Args(A2, B2)) exo_intersect = ExerciseFunction( intersect, intersect_inputs, nb_examples=2, call_renderer=PPrintCallRenderer(width=20), )
(50_001, 150_000, 40), (150_001, math.inf, 45), ) def taxes_ter(income): due = 0 for floor, ceiling, rate in TaxRate2: due += (min(income, ceiling) - floor + 1) * rate / 100 if income <= ceiling: return int(due) def taxes_ko(income): return (income - 12_500) * 20 / 100 taxes_values = [ 0, 50_000, 12_500, 5_000, 16_500, 30_000, 100_000, 150_000, 200_000, 12_504 ] taxes_inputs = [Args(v) for v in taxes_values] exo_taxes = ExerciseFunction(taxes, taxes_inputs, nb_examples=3) if __name__ == '__main__': for value in taxes_values: tax = taxes(value) print(f"{value} -> {tax}")
return f"{prenom}.{nom} ({rang_ieme})" # @END@ ########## def libelle_ko(ligne): try: nom, prenom, rang = ligne.split(',') return f"{prenom}.{nom} ({rang})" except: 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, "), Args("John, Smith, , , , 3"), ] exo_libelle = ExerciseFunction( libelle, inputs_libelle, nb_examples=0, )