🐍 Python Weekly Coding Challenge - The tournament of kingdoms

[mecodeatlas]

This is the second of four challenges designed to test and improve your Python skills. Each week, you'll tackle a new problem focusing on logic, data manipulation, and efficiency. Engage with others, share your ideas, and collaborate to find creative solutions—this is a space to learn and grow together! 🚀

General rules

• Project sharing: Personal projects are not allowed. Only solutions related to the challenges can be shared.
• Programming language: Challenges must be solved exclusively in Python (version 3.6 or later).
• Code quality: Your code should be well-structured, readable, and include explanatory comments.
• Submission: Solutions must be submitted until the end of each week, following the provided instructions. Please, share the link to the repository containing the challenge solved.

Evaluation criteria (Total: 100 points)

• Correctness (40 points): Does the solution meet the challenge requirements and produce the expected results?
• Efficiency (20 points): Is the code optimized in terms of time and resource usage, especially for large inputs?
• Readability & Idiomatic (20 points): Is the code clear, well-organized, and following Python’s PEP 8 style guide?
• Documentation (10 points): Does the code include useful and explanatory comments?
• Creativity (10 points): Does the solution showcase innovative approaches or optimizations?

Now, let’s dive into the first challenge! 🔥

The tournament of kingdoms

In a medieval world, several kingdoms compete in an annual tournament.
You have been assigned to develop a system that calculates each kingdom’s score based on battle results.

Objective

Create a program that processes battle results and generates a ranking table for the kingdoms.

Input & Output

Input: A list of tuples, where each tuple contains Kingdom A’s name, Kingdom A’s score, Kingdom B’s name, and Kingdom B’s score.

Example:

battles = [
    ("Northern Kingdom", 3, "Southern Kingdom", 1),
    ("Eastern Kingdom", 2, "Western Kingdom", 2),
    ("Northern Kingdom", 1, "Eastern Kingdom", 2)
]

Expected Output:

Eastern Kingdom: 4 points
Northern Kingdom: 3 points
Western Kingdom: 1 point
Southern Kingdom: 0 points

Rules

• Each victory is worth 3 points.
• Each draw is worth 1 point for each kingdom.
• A loss does not add any points.
• The position is 1-based (i.e., counting starts from 1)

Difficulty levels

• Basic: Up to 4 kingdoms and 3 battles.
• Intermediate: Up to 6 kingdoms and 6 battles.
• Advanced: Up to 8 kingdoms and 10 battles, with data input via CSV file.

Good luck :)

Guidelines

• I have read and understood this category's guidelines before making this post.

[YuheshPandian]

My solution

code:

# This function returns the list of kindoms battling
def create_kingdoms_list(battles: list):
    list_of_kingdoms_battling: set = set()

    for battle in battles:
        # The ranging skips every score of the kingdoms
        for kingdom in battle[0:3:2]:
            list_of_kingdoms_battling.add(kingdom)

    return list_of_kingdoms_battling


# This function returns a empty score card of all kingdoms with the points won by them as 0
def create_score_card(kingdoms_list):
    kingdoms_score: dict = {}
    for kingdom in kingdoms_list:
        kingdoms_score[kingdom] = 0
    return kingdoms_score


# This function sorts a dictionary based on the values i.e the points won by each kingdom
def sort_dictionary(dictionary):
    return dict(sorted(dictionary.items(), key=lambda item: item[1], reverse=True))


# This function returns the dictionary of kingdoms and the total points won by them in the tournamet
def check_for_winners(battles, scores_of_kingdoms):
    for battle in battles:
        kingdomA, kingdomA_score = battle[0], battle[1]
        kingdomB, kingdomB_score = battle[2], battle[3]
        if kingdomA_score > kingdomB_score:
            scores_of_kingdoms[kingdomA] += 3
        elif kingdomA_score == kingdomB_score:
            scores_of_kingdoms[kingdomA] += 1
            scores_of_kingdoms[kingdomB] += 1
        else:
            scores_of_kingdoms[kingdomB] += 3

    return scores_of_kingdoms


# This function returns the ranking table for the tornament in sorted manner
def generate_ranking_table(battles: list):

    kingdoms: set = create_kingdoms_list(battles)

    scores_of_kingdoms = create_score_card(kingdoms)

    return sort_dictionary(check_for_winners(battles, scores_of_kingdoms))


battles = [
    ("Northern Kingdom", 3, "Southern Kingdom", 1),
    ("Eastern Kingdom", 2, "Western Kingdom", 2),
    ("Northern Kingdom", 1, "Eastern Kingdom", 2),
]


ranking_table = generate_ranking_table(battles)

# This code snippet prints the ranking table in the requested manner
for item in ranking_table.items():
    print(item[0], ":", item[1], "points")

My approach for the problem:

1. Extract Kingdoms

   • Create an empty set to store unique kingdom names.
   • Loop through each battle:
     • Add the first and third elements (kingdom names) to the set.

2. Initialize Scorecard

   • Create a dictionary where each kingdom's score is set to 0.

3. Calculate Scores

   • Loop through each battle:
     • Compare the scores of the two kingdoms:
       • If the first kingdom has a higher score, add 3 points to it.
       • If the scores are equal, add 1 point to both kingdoms.
       • Otherwise, add 3 points to the second kingdom.

4. Sort Kingdoms by Score

   • Sort the dictionary in descending order based on points.

5. Display Rankings

   • Loop through the sorted dictionary and print each kingdom's name with its points.

[nate-browne]

Fun little problem. Here's how I did it:

Files

manager.py

from collections import defaultdict
from typing import List, NamedTuple, DefaultDict


class BattlesInput(NamedTuple):
    kingdom_A: str
    score_A: int
    kingdom_B: str
    score_B: int


class TournamentManager(object):

    def __init__(self):
        self.team_dict: DefaultDict[str, int] = defaultdict(int)

    def _calculate_winner(self, battle: BattlesInput) -> None:

        if battle.score_A == battle.score_B:  # draw = 1 point per kingdom
            self.team_dict[battle.kingdom_A] += 1
            self.team_dict[battle.kingdom_B] += 1
        elif battle.score_A > battle.score_B:  # kingdom A wins
            self.team_dict[battle.kingdom_A] += 3
            self.team_dict[battle.kingdom_B] += 0
        else:  # kingdom B wins
            self.team_dict[battle.kingdom_B] += 3
            self.team_dict[battle.kingdom_A] += 0

    def run_tournament(self, battles: List[BattlesInput]) -> None:
        for battle in battles:
            self._calculate_winner(battle)

    def print_results(self) -> None:
        f_s = '{0}: {1} points'
        # ensure that we're getting the results sorted in descending order according to points totals
        for kingdom, score in sorted(self.team_dict.items(), key=lambda val: val[1], reverse=True):
            if score == 1:
                print(f_s[:-1].format(kingdom, score))
            else:
                print(f_s.format(kingdom, score))

main.py

#!/usr/bin/env python3

import csv
from sys import argv, stderr, exit
from typing import List

from manager import BattlesInput, TournamentManager


if __name__ == '__main__':
    scores: List[BattlesInput] = []

    tm = TournamentManager()

    if len(argv) != 2:  # treat this like we want to handle a file
        print("File needed to parse", file=stderr)
        exit(1)

    filename = argv[1]

    with open(filename, 'r') as infile:
        reader = csv.reader(infile)
        next(reader)
        for row in reader:
            row = [ent.lstrip() for ent in row]
            scores.append(BattlesInput(
                kingdom_A=row[0],
                score_A=int(row[1]),
                kingdom_B=row[2],
                score_B=int(row[3])
            ))
    tm.run_tournament(scores)
    tm.print_results()

The goal was to keep the code for the scorecard as minimal as possible, which I think I was able to do in the class in manager.py. The main.py file is what would be run passing in a CSV to be parsed, such as

Kingdom A, Score A, Kingdom B, Score B
Northern Kingdom,3,Southern Kingdom,1
Eastern Kingdom,2,Western Kingdom,2
Northern Kingdom,1,Eastern Kingdom,2