Concevoir un système décisionnel à plusieurs niveaux pour déterminer les critères d’éligibilité à une bourse.

Question

Concevez un système de prise de décision à plusieurs niveaux en utilisant des instructions if-else qui peuvent être utilisées pour déterminer les critères d'éligibilité à une bourse. Le système doit prendre en compte plusieurs facteurs tels que les notes, les activités parascolaires et les besoins financiers.

Processus de pensée

Pour concevoir un système décisionnel à plusieurs niveaux permettant de déterminer l'éligibilité aux bourses en fonction des notes, des activités parascolaires et des besoins financiers, vous avez besoin d'une approche structurée pour évaluer et attribuer les montants des bourses. Voici une explication étape par étape de la façon de créer un système de prise de décision à l'aide d'instructions if-else :

Critères de décision en matière de bourse

• Condition financière : détermine le degré de besoin financier de l'étudiant.
• Activités parascolaires : mesure la participation en dehors du milieu universitaire.
• Notes : reflète les performances académiques.

Logique de décision en matière de bourses d'études

• Déterminer les besoins financiers : vérifiez si l'étudiant appartient aux catégories de besoins financiers élevés, moyens ou faibles.
• Évaluez la participation parascolaire : dans chaque catégorie de besoins financiers, vérifiez le degré d'activité de l'élève dans les activités parascolaires.
• Évaluez les notes : enfin, évaluez les notes de l'étudiant pour décider du montant exact de la bourse.

Montants des bourses

• Besoins élevés, activités parascolaires élevées, notes élevées : bourse maximale.
• Besoin élevé, parascolaire moyen, notes moyennes : bourse modérée.
• Besoins élevés, activités extrascolaires faibles, notes faibles : bourse minimale.
• Besoin moyen, parascolaire élevé, notes élevées : bourse substantielle.
• Besoin moyen, parascolaire moyen, notes moyennes : bourse modérée.
• Besoin moyen, parascolaire faible, notes faibles : bourse minimale.
• Faible besoin, parascolaire élevé, notes élevées : bourse modérée.
• Faible besoin, parascolaire moyen, notes moyennes : petite bourse.
• Faible besoin, faibles activités extrascolaires, faibles notes : pas de bourse.

Solution

def scholarship(financial_cond, extra_act, grades):
    if financial_cond >=80:
        if extra_act >=80:
            if grades >=80:
                return 5000
            if grades>= 60 and grades <80:
                return 3000
            if grades>= 40 and grades <60:
                return 2000
        if extra_act >= 60 and extra_act < 80:
            if grades >=80:
                return 4000
            if grades>= 60 and grades <80:
                return 2000
            if grades>= 40 and grades <60:
                return 1000
        if extra_act >= 40 and extra_act <60:
            if grades >=80:
                return 3000
            if grades>= 60 and grades <80:
                return 1000
            if grades>= 40 and grades <60:
                return 000
    if financial_cond >=60 and financial_cond <80:
        if extra_act >=80:
            if grades >=80:
                return 4000
            if grades>= 60 and grades <80:
                return 2000
            if grades>= 40 and grades <60:
                return 1000
        if extra_act >= 60 and extra_act < 80:
            if grades >=80:
                return 3000
            if grades>= 60 and grades <80:
                return 1000
            if grades>= 40 and grades <60:
                return 0000
        if extra_act >= 40 and extra_act <60:
            if grades >=80:
                return 2000
            if grades>= 60 and grades <80:
                return 0000
            if grades>= 40 and grades <60:
                return 000
    if financial_cond >= 40 and financial_cond <60:
        if extra_act >=80:
            if grades >=80:
                return 3000
            if grades>= 60 and grades <80:
                return 1000
            if grades>= 40 and grades <60:
                return 000
        if extra_act >= 60 and extra_act < 80:
            if grades >=80:
                return 2000
            if grades>= 60 and grades <80:
                return 000
            if grades>= 40 and grades <60:
                return 000
        if extra_act >= 40 and extra_act <60:
            if grades >=80:
                return 1000
            if grades>= 60 and grades <80:
                return 000
            if grades>= 40 and grades <60:
                return 000
    else:
        return 0

financial_cond = float(input('Enter financial condition in 1 to 100 '))
extrac_act = float(input('Enter the extracurricular participation in 1 to 100 '))
grades= float(input('Enter the grades of the student '))

print(scholarship(financial_cond, extrac_act, grades))

Autres idées

1

financial_cond = float(input('Enter financial condition in 1 to 100 '))
extrac_act = float(input('Enter the extracurricular participation in 1 to 100 '))
grades= float(input('Enter the grades of the student '))
def scholarship():
    if financial_cond >= 80 and extrac_act >= 80 and grades >= 80:
        return 10000
    elif financial_cond >= 80 and extrac_act >= 80 and grades >= 60 and grades <80:
        return 5000
    elif financial_cond >= 80 and extrac_act >= 80 and grades >= 40 and grades < 60:
        return 2000
    elif financial_cond >= 80 and extrac_act >= 60 and extrac_act < 80 and grades >= 80:
        return 5000
    elif financial_cond >=80 and extrac_act >=60 and extrac_act < 80 and grades >= 60 and grades < 80:
        return 2000
    elif financial_cond >= 80 and extrac_act >=50 and extrac_act < 60 and grades >= 60 and grades < 80:
        return 1000
    elif financial_cond >= 60 and financial_cond < 80 and extrac_act >= 80 and grades >=80:
        return 5000
    elif financial_cond >=60 and financial_cond < 80 and extrac_act >=60 and extrac_act < 80 and grades >= 80:
        return 2000
    elif financial_cond >=60 and financial_cond < 80 and extrac_act >= 60 and extrac_act < 80 and grades >= 60 and grades < 80:
        return 1000
    else:
        return 0

scholarship()

Raisons du rejet :

1. Portée et redondance : la fonction bourse() ne prend pas de paramètres, elle s'appuie donc sur des variables globales (financial_cond, extrac_act, notes) qui sont saisies directement. Cette conception est moins modulaire et peut entraîner des problèmes de maintenance et de test du code.
2. Chevauchement et ambiguïté : certaines conditions se chevauchent ou sont redondantes. Par exemple, plusieurs branches elif vérifient des conditions similaires avec de légères différences dans les seuils ou les plages, ce qui peut rendre la logique confuse et sujette aux erreurs.
3. Complexité logique : l'utilisation de plusieurs instructions elif avec des conditions qui se chevauchent crée une structure complexe difficile à suivre. On ne sait pas immédiatement quelle condition sera vraie et quel sera le résultat final dans divers scénarios.

2

def scholarship(financial_cond, extra_act, grades):
    if financial_cond >= 80:
        return high_financial(extra_act, grades)
    elif financial_cond >= 60:
        return medium_financial(extra_act, grades)
    elif financial_cond >= 40:
        return low_financial(extra_act, grades)
    else:
        return 0

def high_financial(extra_act, grades):
    if extra_act >= 80:
        if grades >= 80:
            return 5000
        elif grades >= 60:
            return 3000
        elif grades >= 40:
            return 2000
    elif extra_act >= 60:
        if grades >= 80:
            return 4000
        elif grades >= 60:
            return 2000
        elif grades >= 40:
            return 1000
    elif extra_act >= 40:
        if grades >= 80:
            return 3000
        elif grades >= 60:
            return 1000
        elif grades >= 40:
            return 0

def medium_financial(extra_act, grades):
    if extra_act >= 80:
        if grades >= 80:
            return 4000
        elif grades >= 60:
            return 2000
        elif grades >= 40:
            return 1000
    elif extra_act >= 60:
        if grades >= 80:
            return 3000
        elif grades >= 60:
            return 1000
        elif grades >= 40:
            return 0
    elif extra_act >= 40:
        if grades >= 80:
            return 2000
        elif grades >= 60:
            return 0
        elif grades >= 40:
            return 0

def low_financial(extra_act, grades):
    if extra_act >= 80:
        if grades >= 80:
            return 3000
        elif grades >= 60:
            return 1000
        elif grades >= 40:
            return 0
    elif extra_act >= 60:
        if grades >= 80:
            return 2000
        elif grades >= 60:
            return 0
        elif grades >= 40:
            return 0
    elif extra_act >= 40:
        if grades >= 80:
            return 1000
        elif grades >= 60:
            return 0
        elif grades >= 40:
            return 0

financial_cond = float(input('Enter financial condition in 1 to 100: '))
extra_act = float(input('Enter the extracurricular participation in 1 to 100: '))
grades = float(input('Enter the grades of the student: '))

print(scholarship(financial_cond, extra_act, grades))

Raisons du rejet :

1. Redondance du code : la logique de détermination des bourses est répétée dans différentes catégories de besoins financiers (high_financial, medium_financial, low_financial), conduisant à un code redondant. Cela pourrait être simplifié pour éviter les répétitions et réduire les risques d'incohérences.
2. Complexité des appels de fonction : les appels de fonction imbriqués et les multiples couches de conditions rendent le code plus difficile à suivre et à maintenir. La séparation en différentes fonctions est bonne pour la modularité mais peut être excessive et déroutante en raison du nombre de conditions imbriquées.
3. Montants des bourses incohérents : La logique de décision concernant les montants des bourses entre différents niveaux de besoins financiers n'est pas toujours cohérente, ce qui entraîne une confusion potentielle quant aux raisons pour lesquelles certains montants de bourses sont accordés en fonction de conditions spécifiques.

3

grades = float(input("Enter the applicant's GPA : "))
extracurriculars = int(input("Enter the number of extracurricular activities: "))
financial_need = input("Is there a financial need? (yes/no): ").strip().lower()

eligible = True

grade_thresholds = [3.5, 3.0, 2.5] 
scholarship_level = None

for threshold in grade_thresholds:
    if grades >= threshold:
        if threshold == 3.5:
            scholarship_level = "Full Scholarship"
        elif threshold == 3.0:
            scholarship_level = "Partial Scholarship"
        elif threshold == 2.5:
            scholarship_level = "Basic Scholarship"
        break
else:
    eligible = False
    print("Applicant does not meet the minimum grade requirement.")

if eligible:
    extracurricular_threshold = 2  # Minimum number of activities required
    if extracurriculars < extracurricular_threshold:
        eligible = False
        print("Applicant does not meet the extracurricular activities requirement.")

if eligible:
    while financial_need not in ['yes', 'no']:
        financial_need = input("Please enter 'yes' or 'no' for financial need: ").strip().lower()

    if financial_need == 'no':
        scholarship_level = "Merit-based Scholarship"  # Adjust the scholarship type based on no financial need

if eligible:
    print(f"The applicant is eligible for the {scholarship_level}.")
else:
    print("The applicant is not eligible for the scholarship.")

Raisons du rejet

1. Simplification excessive : l'approche est trop simpliste car elle ne prend pas en compte une série de conditions mais utilise plutôt un seuil unique pour les notes et une vérification binaire des besoins financiers. Cela pourrait négliger des nuances importantes dans la détermination de l’éligibilité et du montant des bourses.
2. Valeurs codées en dur : les niveaux de bourses d'études sont codés en dur sur la base de la moyenne cumulative et d'une vérification binaire des besoins financiers sans tenir compte d'autres facteurs comme le niveau d'implication parascolaire ou des évaluations plus granulaires des besoins financiers.
3. Gestion des interactions : la boucle de gestion de la saisie des besoins financiers pourrait potentiellement provoquer une boucle infinie si l'utilisateur ne saisit pas « oui » ou « non » (bien que la boucle infinie puisse être un problème rare dans la pratique, il s'agit d'un défaut potentiel ).

Raisons du choix de la solution et défauts potentiels de celle-ci

Passons en revue la solution proposée et analysons les raisons de son choix ainsi que les défauts potentiels :

Solution proposée

def scholarship(financial_cond, extra_act, grades):
    if financial_cond >=80:
        if extra_act >=80:
            if grades >=80:
                return 5000
            elif grades >= 60:
                return 3000
            elif grades >= 40:
                return 2000
        elif extra_act >= 60:
            if grades >=80:
                return 4000
            elif grades >= 60:
                return 2000
            elif grades >= 40:
                return 1000
        elif extra_act >= 40:
            if grades >=80:
                return 3000
            elif grades >= 60:
                return 1000
            elif grades >= 40:
                return 0
    elif financial_cond >=60:
        if extra_act >=80:
            if grades >=80:
                return 4000
            elif grades >= 60:
                return 2000
            elif grades >= 40:
                return 1000
        elif extra_act >= 60:
            if grades >=80:
                return 3000
            elif grades >= 60:
                return 1000
            elif grades >= 40:
                return 0
        elif extra_act >= 40:
            if grades >=80:
                return 2000
            elif grades >= 60:
                return 0
            elif grades >= 40:
                return 0
    elif financial_cond >= 40:
        if extra_act >=80:
            if grades >=80:
                return 3000
            elif grades >= 60:
                return 1000
            elif grades >= 40:
                return 0
        elif extra_act >= 60:
            if grades >=80:
                return 2000
            elif grades >= 60:
                return 0
            elif grades >= 40:
                return 0
        elif extra_act >= 40:
            if grades >=80:
                return 1000
            elif grades >= 60:
                return 0
            elif grades >= 40:
                return 0
    else:
        return 0

financial_cond = float(input('Enter financial condition in 1 to 100 '))
extra_act = float(input('Enter the extracurricular participation in 1 to 100 '))
grades = float(input('Enter the grades of the student '))

print(scholarship(financial_cond, extra_act, grades))

Raisons de la sélection

1. Approche structurée : la solution utilise un processus décisionnel à plusieurs niveaux qui évalue systématiquement la situation financière, les activités parascolaires et les notes. Cette approche structurée permet une méthode claire et organisée pour déterminer l'éligibilité aux bourses.

2. Évaluation détaillée : La solution couvre une gamme de conditions avec des seuils spécifiques en matière de besoins financiers, d'implication parascolaire et de résultats académiques, fournissant un cadre détaillé pour l'attribution des montants des bourses.

3. Modularité : En séparant les différents niveaux de besoins financiers et en évaluant d'autres critères au sein de ces niveaux, la solution introduit une structure modulaire plus facile à gérer et à mettre à jour.

4. Chemin de décision clair : Les déclarations if-else imbriquées créent un chemin de décision clair, rendant explicite quelles conditions conduisent à quels montants de bourse.

Défauts potentiels

1. Redondance et complexité : Le code contient beaucoup de redondance. Par exemple, les contrôles des notes et des activités extrascolaires sont répétés plusieurs fois. Cette redondance augmente la complexité du code et le rend plus difficile à maintenir et à comprendre.

2. Duplication de code : La logique de prise de décision pour chaque plage de Financial_cond a des modèles similaires mais avec des seuils légèrement différents. Cette duplication pourrait être évitée en consolidant la logique commune et en réduisant les blocs de code répétitifs.

3. Valeurs codées en dur : Les montants et seuils des bourses sont codés en dur, ce qui les rend peu flexibles. Si les critères ou les montants doivent changer, le code doit être mis à jour manuellement. L'utilisation d'un fichier de configuration ou de constantes améliorerait la flexibilité.

4. Manque de validation des entrées : Le code ne valide pas les entrées pour garantir qu'elles se situent dans les plages ou les types attendus. Par exemple, Financial_cond, extra_act et grades devraient être compris entre 1 et 100, mais le code ne l'applique ni ne le valide.

5. Edge Cases : La solution ne gère pas les cas Edge de manière robuste. Par exemple, si Financial_cond, extra_act ou grades correspondent exactement aux valeurs limites (par exemple, exactement 40, 60 ou 80), la gestion est quelque peu ambiguë. Une gestion plus claire des cas limites rendrait la logique de décision plus précise.

6. Aucun retour ni explication : La solution ne fournit que le montant de la bourse et n'explique pas pourquoi un certain montant a été accordé. L'ajout de commentaires ou d'une explication pourrait améliorer la compréhension et la transparence des utilisateurs.

Pouvez-vous améliorer la solution proposée selon les normes modernes ? [Astuce : refactorisez la redondance, implémentez la validation des entrées, utilisez des constantes et améliorez les commentaires des utilisateurs]

Solution avancée sur : https://insightshub.in/design-a-multi-tier-decision-making-system-to-determine-the-eligibility-criteria-for-a-scholarship/#h-advanced- solution

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!