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,
)
# 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,
)
# une solution qui NE MARCHE PAS pour les tailles paires
def checkers_ko_2(size, corner_0_0=True):
return np.array([(i + corner_0_0) % 2 for i in range(size * size)],
dtype=np.int_).reshape(size, size)
# faux parce qu'on ignore corner_0_0
# voir aussi si la correction est contente avec des float
def checkers_ko(size, ignored=True):
result = np.ones(shape=(size, size), dtype=float)
# on remplit les cases blanches en deux fois
result[1::2, 0::2] = 0
result[0::2, 1::2] = 0
return result
checkers_inputs = [
Args(3),
Args(3, False),
Args(1),
Args(2),
Args(4),
]
exo_checkers = ExerciseFunctionNumpy(
checkers,
checkers_inputs,
nb_examples=2,
)
def matdiag_3(liste):
"""
bon maintenant qu'on s'est bien creusé les méninges
pour le faire à la main, il se trouve qu'il y a
- bien sûr - une fonction pour ça dans numpy
"""
return np.diag(liste)
# @END@
def matdiag_ko(liste):
# presque ça mais sans le reshape
n = len(liste)
return np.zeros((n, n))
inputs_matdiag = [
Args([1]),
Args([1, 2j]),
Args([1, 2.5, 4]),
Args([0, 1, 2, 4, 8]),
]
exo_matdiag = ExerciseFunctionNumpy(
matdiag,
inputs_matdiag,
nb_examples=3,
)
"""
Une approche discutable
"""
# à la Fortran; ça n'est pas forcément
# la bonne approche ici bien sûr
# mais si un élève a des envies de benchmarking...
result = np.zeros(shape=(lines, columns), dtype=int)
for i in range(lines):
for j in range(columns):
result[i, j] = 100 * i + 10 * j + offset
return result
# @END@
def hundreds_ko(lines, columns, offset):
result = np.ones(shape=(lines, columns), dtype=float)
return result
hundreds_inputs = [
Args(2, 4, 0),
Args(3, 3, 1),
]
exo_hundreds = ExerciseFunctionNumpy(
hundreds,
hundreds_inputs,
nb_examples=2,
)
"""
# Je vous laisse vous convaincre que ça fonctionne aussi
# en utilisant le broadcasting
# pour s'économiser une transposition explicite
return (lambda x: x + x[:, np.newaxis])(taille -
np.abs(range(-taille, taille + 1)))
# @END@
def stairs_ko(taille):
n = 2 * taille + 1
ix, iy = np.indices((n, n), dtype=np.float)
return ((taille - 1) + 2 * taille -
(np.abs(ix - taille) + np.abs(iy - taille)))
stairs_inputs = [
Args(1),
Args(2),
Args(3),
Args(4),
]
exo_stairs = ExerciseFunctionNumpy(
stairs,
stairs_inputs,
nb_examples=2,
)