main.py

# rendu de Quentin Hartman (aka BiocheH sur les commit) (pseudo GitHub)

from itertools import chain
import matplotlib.pyplot as plt


class TabletteChocolat:
    def __init__(self, m: int, n: int):
        '''
        On instancie une tablette en fonction de sa taille m*n
        '''
        if not (isinstance(m, int) and isinstance(n, int)):
            raise TypeError('given values must be integers')
        self.m = m
        self.n = n

    def __str__(self) -> str:
        return 'Tablette de chocolat de ' + str(self.m) + 'x' + str(self.n)
    # __repr__ n'est pas surchargé car à priori dans notre cas __str__ suffit

    def __getitem__(self, item) -> int:
        if item == 0:
            return self.m
        elif item == 1:
            return self.n
        else :
            raise IndexError('can only take 0 or 1 as argument')

    def coups_possibles(self):
        '''
        renvoie un générateur des coups possibles
        '''
        result = []
        for i in range(1, self.m):
            result.append((i, 0))
        for j in range(1, self.n):
            result.append((0, j))
        return chain(result)

    def est_possible(self, couple: tuple) -> bool:
        '''
        renvoie si oui ou non un coup est possible sur la tablette courante
        '''
        return couple in list(self.coups_possibles())

    def coupe(self, couple: tuple):
        '''
        renvoie la tablette qui résulte de la coupe donnée sur la tablette courante
        '''
        return TabletteChocolat(self.m - couple[0], self.n - couple[1])

    def plot(self):
        '''
        affiche la tablette courante
        '''
        plt.gca().set_aspect('equal')
        plt.axis('off')
        plt.fill([0, self.n, self.n, 0], [0, 0, self.m, self.m], color='#D5B799')
        for i in range(self.n):
            for j in range(self.m):
                plt.plot([i+0.1, i+0.9, i+0.9, i+0.1, i+0.1], [j+0.1, j+0.1, j+0.9, j+0.9, j+0.1], color='#554739')
        plt.fill([self.n-0.9, self.n-0.1, self.n-0.1, self.n-0.9], [0.1, 0.1, 0.9, 0.9], color='#554739')
        plt.show()

    def demander_coup(self):
        coup = ''
        taille_coupe = -1
        while not coup in ['l', 'c']:
            print('il faut choisir quoi couper :')
            if self.m > 1 and self.n > 1:
                coup = str(input('Couper des lignes (l) ou des colonnes (c) ? '))
            elif self.m == 1 and self.n == 1:
                print('on ne peut couper plus rien couper')
                return self
            elif self.n == 1:
                coup = 'l'
                print('on ne peut couper plus que des lignes')
            elif self.m == 1:
                coup = 'c'
                print('on ne peut couper plus que des colonnes')
        if coup == 'c':
            print('voici les coups possibles : ', ', '.join(str(i) + ' colonnes' for i in range(1, self.n)))
            while not 1 <= taille_coupe <= self.n-1:
                taille_coupe = int(input('combien de colonnes couper ? '))
            return self.coupe((0, taille_coupe))
        if coup == 'l':
            print('voici les coups possibles : ', ', '.join(str(i) + ' lignes' for i in range(1, self.m)))
            while not 1 <= taille_coupe <= self.m-1:
                taille_coupe = int(input('combien de lignes couper ? '))
            return self.coupe((taille_coupe, 0))


def jouer(m: int,  n: int):
    plateau = TabletteChocolat(m, n)
    while not (plateau[0] == 1 and plateau[1] == 1):
        plateau.plot()
        plateau = plateau.demander_coup()
    print('Game Over !')
    plateau.plot()


'''
QUESTION 13 :
On remarque que la personne qui coupe la tablette pour qu'elle soit carrée va gagner : 
effectivement, si Ursula coupe à chaque tour la tablette pour qu'elle soit carrée, alors elle finira par la
couper pour qu'elle soit de taille 1x1, et donc Delinda perdra. Le seul moyen qu'elle perde est donc que la tablette
soit carrée dès le début et que Delinda suive la même stratégie.
On peut donc générer la liste des tablettes entre 1*1 et m*n tq Ursula gagne ou Delinda gagne (si les deux jouent de
façon parfaite)
'''


def tablettes_gagnantes_pour_Ursula(m: int, n: int):
    tablettes = []
    for i in range(1, m+1):
        for j in range(1, n+1):
            if i != j:
                tablettes.append((i, j))
    return tablettes


# Liste des tests effectués :

A = TabletteChocolat(1, 2)  # q1, q2
B = TabletteChocolat(4, 8)
print(A)  # q3
print(B)
print(list(B.coups_possibles()))  # q4
print(B.coups_possibles())
print(B.est_possible((3, 0)))  # q5
print(B.est_possible((3, 2)))
print(B.coupe((0, 5)))  # q6
print(B.coupe((2, 0)))
#B.plot()  # q7
#B.demander_coup().plot()  # q8, q9
print(tablettes_gagnantes_pour_Ursula(8, 6))  # technically q12
jouer(5, 5)  # q10