Python

Les développeurs ont du talent #1 – Objets en Python

Résolution du challenge en Python : création d’objets, constructeurs, méthodes, et utilisation de la fonction sorted

→ Corrigé du Challenge : Attaque des Titans

Premier corrigé d’une nouvelle série ! Le code est produit par un développeur ou une développeuse qui s’entraine et progresse avec Tainix ! Tu as réalisé un challenge et tu es fièr.e de ton code ? Envoie le nous, nous en sélectionnerons quelques uns que nous publierons sur le site.

Voici donc un corrigé en Python du challenge Avancé de l’Attaque des Titans, réalisé par Paul, étudiant à l’EFREI.

Au programme de ce corrigé :

  • Utilisation d’objets
    • Constructeurs
    • Méthodes (override ou pas)
  • Utilisation de la fonction « sorted » sur un objet, donc utilisation d’une fonction lambda.

Pour réaliser un challenge avec Python, réfère toi à la documentation.

#!/bin/python
from Game import Game

# Ta key
player_key = ''
# Le code du challenge
engine_code = 'ATTACK_OF_TITANS'

class Habitation :
    #
    #   Une habitation est caractérisé par : Sa hauteur, sa distance
    #
    def __init__(self, habitation : str) -> None:
        hauteur, distance = habitation.split(";")
        self.hauteur = int(hauteur)
        self.distance = int(distance)

    def __str__(self) -> str:
        return f"||| Hauteur = {self.hauteur} | Distance = {self.distance} |||"

class Titan:
    #
    #   Un titan est caractérisé par : Sa taille, sa vitesse, ses PV
    #
    def __init__(self, titan : str) -> None:
        taille, vitesse, pv = titan.split(";")
        self.taille = int(taille)
        self.vitesse = int(vitesse)
        self.pv = int(pv)
    
    def __str__(self) -> str:
        return f"||| Taille = {self.taille} | Vitesse = {self.vitesse} | PV = {self.pv=} |||"

    def degats(self, habitation : Habitation) -> tuple[int] :
        # Methode pour calculer les dégats infligés à un titan en fonction du batiment et pour décrémenter ses PV
        if self.taille < habitation.hauteur :
            puissance = (habitation.hauteur - self.taille) * 10 + habitation.distance*2 - self.vitesse
            gazConsomme = habitation.hauteur - self.taille + habitation.distance
        else :
            puissance = abs(habitation.hauteur - self.taille) * 5 + habitation.distance*2 - self.vitesse
            gazConsomme = abs(habitation.hauteur - self.taille + habitation.distance)
        self.pv -= puissance
        if(self.pv<=0):
            return (gazConsomme, 101)
        else : return (gazConsomme, 1)

def calculScore(titans : list[str], habitations : list[str], gaz : int):
    # Ininitialisation des listes et variables
    listTitans = sorted([Titan(titan) for titan in titans],key=lambda x: x.taille, reverse=True)
    listHabitations = sorted([Habitation(habitation) for habitation in habitations], key=lambda x: x.hauteur)
    actualTitan, actualHabitation = 0, None

    # Determiner le premier batiment
    for n,habitation in enumerate(listHabitations):
        if habitation.hauteur > listTitans[actualTitan].taille : actualHabitation = n; break
    if actualHabitation == None:
        actualHabitation = len(listHabitations)-1
    
    # Enlever le gaz relatif au premier batiment
    gaz -= listHabitations[actualHabitation].hauteur

    points=0
    # Faire tant qu'il reste du gaz
    while gaz >= 0 :
        # Si le titan n'est pas mort, utilisation de la méthode "degats" et récupération de la quantité de gaz utilisé et du nombre de points marqués
        if(listTitans[actualTitan].pv > 0):
            g, p = listTitans[actualTitan].degats(listHabitations[actualHabitation])
            gaz -= g
            if gaz > 0 : points += p
        else:
            # Si c'était le dernier titan, on range le gaz (fin de la boucle)
            if actualTitan == len(listTitans)-1 : gaz = -1
            else:
                # Sinon, on passe au titan suivant, et on change de batiment
                actualTitan+=1
                ancienHabitation = actualHabitation
                actualHabitation = None
                for n,habitation in enumerate(listHabitations):
                    if habitation.hauteur > listTitans[actualTitan].taille : actualHabitation = n; break
                if actualHabitation == None:
                    actualHabitation = len(listHabitations)-1
                # Si le nouveau batiment n'est pas le même que celui qu'on vient de quitter, on ajuste la quantité de gaz
                if ancienHabitation != actualHabitation : gaz -= abs(listHabitations[actualHabitation].hauteur-listHabitations[ancienHabitation].hauteur)
    return points
        

def main():
    game = Game(player_key, engine_code)
    data = game.input()

    response = calculScore(data['titans'], data['habitations'], data['gaz']) 

    # Permet d'envoyer la reponse du challenge
    game.output({'data': response})


main()

Qui a codé ce superbe contenu ?


Ta newsletter chaque mois

Corrigés, challenges, actualités, veille technique... aucun spam.