Activité pratique

def argmax (lst: list[int]) -> int:
    
    """
        This function returns the index of the maximum value occurring in a list of values.
        In case of an empty list, it returns -1.
        If the maximum value occurs multiple times, the index of the first occurrence is returned.
        In:
            * lst: The list of values.
        Out:
            * The index of the first occurrence of the maximum value, or -1.
    """

    # This whole function is equivalent to:
    # return lst.index(max(lst))
    # We detail the algorithm for pedagocical purpose

    # If not found
    if lst is None or len(lst) == 0:
        return -1
    
    # Otherwise, iterate on contents to find max
    max_val = lst[0]
    max_index = 0
    for i, v in enumerate(lst):
        if v > max_val:
            max_val = v
            max_index = i
    return max_index

# Needed imports
import unittest
from argmax import argmax



# Define a class for unit tests
class TestArgmax (unittest.TestCase):

    # Here, we define a method with a simple test
    # You will have to write new tests, possibly in new methods
    def test_argmax_standardcase (self):
        self.assertEqual(1, argmax([1, 5, 3, 4, 2, 0]))
        self.assertEqual(0, argmax([8, 5]))
        self.assertEqual(1, argmax([-2, 9]))

    def test_argmax_none (self):        
        self.assertEqual(-1, argmax(None))
    
    def test_argmax_empty (self):
        self.assertEqual(-1, argmax([]))
    
    def test_argmax_multiple_max (self):
        self.assertEqual(2, argmax([1, 3, 5, 5, 2, 5]))



# Run the tests
if __name__ == '__main__':
    _ = unittest.main(argv=[""], verbosity=2, exit=False)

# Needed imports
import unittest
from isleap import is_leap



class TestIsLeap (unittest.TestCase):

    def test_negative_value (self):
        self.assertFalse(is_leap(-1000))

    def test_even_not_divisivle_by_4 (self):
        self.assertFalse(is_leap(2018))
        self.assertFalse(is_leap(2026))

    def test_divisible_by_4_and_by_100_and_not_by_400 (self):
        self.assertFalse(is_leap(1900))
        self.assertFalse(is_leap(2100))

    def test_divisible_by_4_and_not_by_100 (self):
        self.assertTrue(is_leap(2008))
        self.assertTrue(is_leap(2024))

    def test_divisible_by_400 (self):
        self.assertTrue(is_leap(1600))
        self.assertTrue(is_leap(2000))



# Run the tests
if __name__ == '__main__':
    _ = unittest.main(argv=[""], verbosity=2, exit=False)  

def is_leap (year: int) -> bool:
    
    """
        This function takes a year as input and returns True if the year is a leap year, False otherwise.
        An additional constraint is that the year must be greater than 0, otherwise the function will return False.
        In:
            * year: The year to be checked.
        Out:
            * True if year is a leap year, False otherwise.
    """
    
    if year >= 0:  
        if year % 4 == 0:
            if year % 100 == 0:
                return year % 400 == 0
                # since the year is divisible by 100, 
                # it must also be divisible by 400 to be a leap year     
            else:
                # divisible by 4 and not by 100
                return True
        else:
            # not divisible by 4
            return False
    else:
        # negative years are not leap years
        return False

"""
A class to check if a password is strong.
There are 5 rules to check if a password is strong:
1. Must contain at least 8 characters.
2. Must contain at least one uppercase letter.
3. Must contain at least one lowercase letter.
4. Must contain at least one number.
5. Must contain at least one special character (from `!@#$%^&*()`).
"""

special_chars = "!@#$%^&*()"


def check_len(password: str) -> bool:
    """Check if the password has at least 8 characters.

    Parameters:
        password (str): The password

    Returns:
        bool: True, if password contains at least 8 characters, False otherwise
    """
    return len(password) >= 8


def check_uppercase(password: str) -> bool:
    """
    Check if the password has at least one uppercase letter.
    :param password: str, the password
    :return: bool, True if the password has at least one uppercase letter, False otherwise
    """
    return any(char.isupper() for char in password)


def check_lowercase(password: str) -> bool:
    """
    Check if the password has at least one lowercase letter.
    :param password: str, the password
    :return: bool, True if the password has at least one lowercase letter, False otherwise
    """
    return any(char.islower() for char in password)


def check_number(password: str) -> bool:
    """
    Check if the password has at least one number.
    :param password: str, the password
    :return: bool, True if the password has at least one number, False otherwise
    """
    return any(char.isdigit() for char in password)


def check_special_char(password: str) -> bool:
    """
    Check if the password has at least one special character.
    :param password: str, the password
    :return: bool, True if the password has at least one special character, False otherwise
    """
    return any(char in special_chars for char in password)


def is_strong(password: str) -> bool:
    """
    Check if the password is strong.
    To be strong, the password must satisfy the 5 rules.
    :param password: str, the password
    :return: bool, True if the password is strong, False otherwise
    """
    return all([
        check_len(password),
        check_uppercase(password),
        check_lowercase(password),
        check_number(password),
        check_special_char(password)
    ])


if __name__ == '__main__':
    password = "StrongPassword123!"
    print(is_strong(password))

import unittest

import strongpassword as sp

class StrongPasswordTestCase(unittest.TestCase):

    def test_check_len(self):
        self.assertFalse(sp.check_len("1234567"))
        self.assertTrue(sp.check_len("12345678"))

    def test_check_uppercase(self):
        self.assertFalse(sp.check_uppercase("abcdefgh"))
        self.assertTrue(sp.check_uppercase("abcDefgh"))

    def test_check_lowercase(self):
        self.assertFalse(sp.check_lowercase("ABCDEFGH"))
        self.assertTrue(sp.check_lowercase("abcDEFGH"))

    def test_check_number(self):
        self.assertFalse(sp.check_number("abcdefgh"))
        self.assertTrue(sp.check_number("abc12345"))

    def test_check_special_char(self):
        self.assertFalse(sp.check_special_char("abcdefgh"))
        self.assertTrue(sp.check_special_char("abc!@#$%"))

    def test_is_strong(self):
        self.assertFalse(sp.is_strong("1234567"))
        self.assertFalse(sp.is_strong("abcdefgh"))
        self.assertFalse(sp.is_strong("abc12345"))
        self.assertFalse(sp.is_strong("abc!@#$%"))
        self.assertTrue(sp.is_strong("abcD123!"))

if __name__ == '__main__':
    unittest.main()

"""
Takuzu is a binary puzzle game.
The objective is to fill a nxn grid with 0s and 1s according to the following rules:
1. Each row and column must contain an equal number of 0s and 1s.
2. No more than two consecutive similar numbers are allowed.
3. Each pair of rows is different, and each pair of columns is different.
The game is won when the grid is filled according to the rules.
This class provides a method to check if a grid is valid.
"""

def check_is_square(grid: list[list[int]]) -> bool:
    """
    Checks if the grid is square, that is, it has the same number of rows and columns.
    :return: bool, True if the grid is square, False otherwise
    """
    return all(len(row) == len(grid) for row in grid)


def check_only_0s_and_1s(grid: list[list[int]]) -> bool:
    """
    Checks if the grid contains only 0s and 1s.
    :return: bool, True if the grid contains only 0s and 1s, False otherwise
    """
    return all(all(cell in [0, 1] for cell in row) for row in grid)


def check_number_of_0s_and_1s(seq: list[int]) -> bool:
    """
    Checks if the sequence satisfies the first rule of Takuzu,
    that is, each row and column must contain an equal number of 0s and 1s.
    :return: bool, True if the sequence satisfies the rule, False otherwise
    """
    return seq.count(0) == seq.count(1)


def check_no_more_than_two_similar_numbers_consecutive(seq: list[int]) -> bool:
    """
    Checks if the sequence satisfies the second rule of Takuzu,
    that is, no more than two consecutive similar numbers are allowed.
    :return: bool, True if the sequence satisfies the rule, False otherwise
    """
    return all(seq[i] != seq[i + 1] or seq[i] != seq[i + 2] for i in range(len(seq) - 2))


def check_uniqueness(seq1: list[int], seq2: list[int]) -> bool:
    """
    Checks if pair of rows (resp. columns) is different. 
    This helps verifying the 3rd rule of Takuzu.
    :param seq1: list[int], the first sequence
    :param seq2: list[int], the second sequence
    :return: bool, True if the sequences are unique, False otherwise
    """
    return seq1 != seq2


def grid_checker(grid: list[list[int]]) -> bool:
    """
    Checks if the grid is valid according to the rules of 
    The three rules are:
    1. Each row and column must contain an equal number of 0s and 1s.
    2. No more than two similar numbers adjacent to each other are allowed.
    3. Each pair of rows is different, and each pair of columns is different.
    :param grid: list[list[int]], the grid to be checked
    :return: bool, True if the grid is valid, False otherwise
    """
    if not check_is_square(grid):
        return False
    if not check_only_0s_and_1s(grid):
        return False
    for row in grid:
        if not check_number_of_0s_and_1s(row):
            return False
        if not check_no_more_than_two_similar_numbers_consecutive(row):
            return False
    for col in range(len(grid)):
        if not check_number_of_0s_and_1s([grid[row][col] for row in range(len(grid))]):
            return False
        if not check_no_more_than_two_similar_numbers_consecutive(
                [grid[row][col] for row in range(len(grid))]):
            return False
    for i in range(len(grid)):
        for j in range(i + 1, len(grid)):
            if not check_uniqueness(grid[i], grid[j]):
                return False
            if not check_uniqueness([grid[row][i] for row in range(len(grid))],
                                            [grid[row][j] for row in range(len(grid))]):
                return False
    return True


if __name__ == '__main__':
    grid = [[0, 1, 1, 0], [1, 0, 0, 1], [0, 0, 1, 1], [1, 1, 0, 0]]
    print(grid_checker(grid))

import unittest

from takuzu import *

class TakuzuTestCase(unittest.TestCase):

    def test_check_is_square(self):
        self.assertTrue(check_is_square([[0, 1], [1, 0]]))
        self.assertFalse(check_is_square([[0, 1], [1, 0], [1, 1]]))
        self.assertFalse(check_is_square([[0, 1], [1, 0, 1]]))

    def test_check_only_0s_and_1s(self):
        self.assertTrue(check_only_0s_and_1s([[0, 1], [1, 0]]))
        self.assertFalse(check_only_0s_and_1s([[0, 1], [1, 2]]))

    def test_check_number_of_0s_and_1s(self):
        self.assertTrue(check_number_of_0s_and_1s([0, 1, 0, 1]))
        self.assertFalse(check_number_of_0s_and_1s([0, 1, 0, 0]))
        self.assertFalse(check_number_of_0s_and_1s([0, 1, 0, 1, 1]))

    def test_check_no_more_than_two_similar_numbers_consecutive(self):
        self.assertTrue(check_no_more_than_two_similar_numbers_consecutive([0, 1, 0, 1]))
        self.assertFalse(check_no_more_than_two_similar_numbers_consecutive([0, 1, 0, 0, 0]))
        self.assertFalse(check_no_more_than_two_similar_numbers_consecutive([0, 1, 0, 1, 1, 1]))

    def test_check_uniqueness(self):
        self.assertTrue(check_uniqueness([0, 1, 0, 1], [1, 0, 1, 0]))
        self.assertFalse(check_uniqueness([0, 1, 0, 1], [0, 1, 0, 1]))

    def test_grid_checker(self):
        self.assertTrue(grid_checker([[0, 1], [1, 0]]))
        self.assertFalse(grid_checker([[0, 1], [1, 0], [1, 1]]))
        self.assertFalse(grid_checker([[0, 1], [1, 2]]))
        self.assertFalse(grid_checker([[0, 1], [1, 0, 1]]))
        self.assertFalse(grid_checker([[0, 1, 0, 0], [1, 0, 1, 1], [0, 1, 0, 1], [1, 0, 1, 0]]))

if __name__ == '__main__':
    unittest.main()

import random


class Mastermind:
    """
    Classe représentant le jeu Mastermind.
    Mastermind est un jeu où le joueur doit deviner un code secret composé de 4 chiffres entre 1 et 6.
    Le joueur dispose de 10 tentatives pour deviner le code et gagne s'il réussit à le trouver en moins de 10 essais.
    À chaque tentative, le jeu retourne un tuple de 2 nombres entre 0 et 4.
    Les indices sont les suivants :
    - Le premier chiffre indique le nombre de chiffres corrects à la bonne position
    - Le second chiffre indique le nombre de chiffres corrects mais à la mauvaise position
    Remarque : S'il y a des couleurs en double dans la proposition, elles ne peuvent pas toutes recevoir un indice sauf
    si elles correspondent au même nombre de couleurs en double dans le code secret.
    """

    def __init__(self, chances: int = 10, nb_digits: int = 4, nb_colors: int = 6):
        """
        Initialise le jeu Mastermind avec un code secret.
        :param chances: int, le nombre de chances dont dispose le joueur pour deviner le code. Par défaut 10.
        :param nb_digits: int, le nombre de chiffres dans le code. Par défaut 4.
        :param nb_colors: int, le nombre de couleurs (ou chiffres) pouvant être utilisés dans le code. Par défaut 6.
        """
        self.__nb_digits__ = nb_digits
        self.__nb_colors__ = nb_colors
        self.__code__ = [random.randint(1, nb_colors) for _ in range(nb_digits)]
        self.__chances__ = chances

    def set_code(self, code: list[int]):
        """
        Définit le code secret. Cette méthode est utile à des fins de test.
        Elle appelle la méthode check_code pour valider le code.
        :param code: list[int], le code secret
        :raise ValueError: si le code est invalide
        """
        if self.check_code(code):
            self.__code__ = code
        else:
            raise ValueError(
                f"Invalid code. Please enter {self.__nb_digits__} numbers between 1 and {self.__nb_colors__}.")

    def check_code(self, code: list[int]) -> bool:
        """
        Vérifie si le code est valide.
        :param code: list[int], le code à vérifier
        :return: bool, True si le code est valide, False sinon
        """
        # BEGIN SOLUTION
        return len(code) == self.__nb_digits__ and all(1 <= x <= self.__nb_colors__ for x in code)
        # END SOLUTION

    @staticmethod
    def provide_hints(code: list[int], guess: list[int]) -> tuple[int, int]:
        """
        Après chaque proposition du joueur, le jeu renverra un couple de nombres entre 0 et 4.
        Les indices sont les suivants :
        - Le premier chiffre indique le nombre de chiffres corrects à la bonne position
        - Le second chiffre indique le nombre de chiffres corrects mais à la mauvaise position
        Remarque : S'il y a des couleurs en double dans la proposition, elles ne peuvent pas toutes recevoir un indice sauf
        si elles correspondent au même nombre de couleurs en double dans le code secret.
        :param code: list[int], le code secret
        :param guess: list[int], la proposition du joueur
        :return: tuple[int, int], les indices
        """
        # BEGIN SOLUTION
        nb_correct = 0
        nb_misplaced = 0
        i = 0
        # travailler sur des copies pour éviter de modifier les listes originales
        code = code.copy()
        guess = guess.copy()
        # D'abord, compte le nombre de chiffres corrects à la bonne position
        while i < len(code):
            if code[i] == guess[i]:
                nb_correct += 1
                code.pop(i)
                guess.pop(i)
            else:
                i += 1
        # Ensuite, compte le nombre de chiffres corrects mais à la mauvaise position
        i = 0
        while i < len(code):
            if guess[i] in code:
                nb_misplaced += 1
                code.remove(guess[i])
                guess.pop(i)
            else:
                i += 1

        return nb_correct, nb_misplaced
        # END SOLUTION

    def evaluate_guess(self, guess: list[int]) -> tuple[bool, int, int]:
        """
        Evalue la proposition du joueur et renvoie les indices.
        :param guess: list[int], la proposition
        :return: tuple[bool, int, int], le résultat de la proposition et les indices
        """
        # BEGIN SOLUTION
        self.__chances__ -= 1
        nb_correct, nb_misplaced = self.provide_hints(self.__code__, guess)
        success = self.is_right_answer((nb_correct, nb_misplaced))
        return success, nb_correct, nb_misplaced
        # END SOLUTION

    def is_right_answer(self, hints: tuple[int, int]) -> bool:
        """
        Check if the guess is the right answer.
        Instead of checking the guess, the hints are provided as input.
        :return: bool, True if the hints are (4,0), False otherwise
        """
        # BEGIN SOLUTION
        return hints == (self.__nb_digits__, 0)
        # END SOLUTION

    def has_remaining_attempts(self) -> bool:
        """
        Check if the player has remaining attempts.
        :return: bool, True if the player has remaining attempts, False otherwise
        """
        # BEGIN SOLUTION
        return self.__chances__ > 0
        # END SOLUTION