From 15115b4c52bfda0d1cca9fa1155beecbb873ec35 Mon Sep 17 00:00:00 2001
From: yctct <yctct@yctct.com>
Date: Sun, 7 Jun 2026 08:59:04 +0200
Subject: First commit, add all files

---
 py03/ex0/ft_command_quest.py       | 23 ++++++++++
 py03/ex1/ft_score_analytics.py     | 61 +++++++++++++++++++++++++
 py03/ex2/ft_coordinate_system.py   | 61 +++++++++++++++++++++++++
 py03/ex3/ft_achievement_tracker.py | 94 ++++++++++++++++++++++++++++++++++++++
 py03/ex4/ft_inventory_system.py    | 83 +++++++++++++++++++++++++++++++++
 py03/ex5/ft_data_stream.py         | 50 ++++++++++++++++++++
 py03/ex6/ft_data_alchemist.py      | 33 +++++++++++++
 7 files changed, 405 insertions(+)
 create mode 100755 py03/ex0/ft_command_quest.py
 create mode 100755 py03/ex1/ft_score_analytics.py
 create mode 100755 py03/ex2/ft_coordinate_system.py
 create mode 100755 py03/ex3/ft_achievement_tracker.py
 create mode 100755 py03/ex4/ft_inventory_system.py
 create mode 100755 py03/ex5/ft_data_stream.py
 create mode 100755 py03/ex6/ft_data_alchemist.py

(limited to 'py03')

diff --git a/py03/ex0/ft_command_quest.py b/py03/ex0/ft_command_quest.py
new file mode 100755
index 0000000..af568f5
--- /dev/null
+++ b/py03/ex0/ft_command_quest.py
@@ -0,0 +1,23 @@
+#!/usr/bin/env python3
+# print(str(sys.argv))
+
+import sys
+
+
+def print_argv():
+    print(f"Program name: {sys.argv[0]}")
+    if not sys.argv[1:]:
+        print("No argument provided!")
+    else:
+        arg_received = len(sys.argv) - 1
+        print(f"Arguments received: {arg_received}")
+        index = 1
+        for arg in sys.argv[1:]:
+            print(f"Argument {index}: {arg}")
+            index += 1
+    print(f"Total arguments: {len(sys.argv)}")
+
+
+if __name__ == "__main__":
+    print("=== Command Quest ===")
+    print_argv()
diff --git a/py03/ex1/ft_score_analytics.py b/py03/ex1/ft_score_analytics.py
new file mode 100755
index 0000000..71210fb
--- /dev/null
+++ b/py03/ex1/ft_score_analytics.py
@@ -0,0 +1,61 @@
+#!/usr/bin/env python3
+
+import sys
+
+
+def create_list():
+    list_scores = []
+    for arg in sys.argv[1:]:
+        try:
+            list_scores.append(int(arg))
+        except ValueError:
+            print(f"Skipped '{arg}'")
+    if not list_scores:
+        for arg in sys.argv[1:]:
+            print(f"Invalid parameter: '{arg}'")
+        raise ValueError("No scores provided. Usage "
+                         "./ft_score_analytics.py <score1> <score2> etc")
+    return list_scores
+
+
+def check_argument_given():
+    if not sys.argv[1:]:
+        raise ValueError("No scores provided. Usage "
+                         "./ft_score_analytics.py <score1> <score2> etc")
+
+
+def score_processed(list_scores):
+    print('Scores processed: ', list_scores)
+
+
+def compute_total_score(scores):
+    total_score = 0
+    for score in scores:
+        total_score += int(score)
+    return total_score
+
+
+def score_analytics(scores):
+    score_processed(scores)
+    total_player = len(scores)
+    print(f'Total player: {total_player}')
+    total_score = compute_total_score(scores)
+    print(f'Total score: {total_score}')
+    average_score = total_score / total_player
+    print(f'Average score: {round(average_score, 2)}')
+    highest_score = max(scores)
+    print(f'Highest score: {highest_score}')
+    lowest_score = min(scores)
+    print(f'Lowest score: {lowest_score}')
+    score_range = max(scores) - min(scores)
+    print(f'Score range: {score_range}')
+
+
+if __name__ == "__main__":
+    print('=== Player Score Analytics ===')
+    try:
+        check_argument_given()
+        scores = create_list()
+        score_analytics(scores)
+    except ValueError as err:
+        print(err)
diff --git a/py03/ex2/ft_coordinate_system.py b/py03/ex2/ft_coordinate_system.py
new file mode 100755
index 0000000..f0daea1
--- /dev/null
+++ b/py03/ex2/ft_coordinate_system.py
@@ -0,0 +1,61 @@
+#!/usr/bin/env python3
+
+import math
+
+
+class InvalidSyntax(Exception):
+    def __init__(self, message="Invalid syntax"):
+        self.message = message
+        super().__init__(self.message)
+
+
+def get_player_pos():
+    while True:
+        try:
+            pos = input("Enter new coordinates"
+                        "as floats in format 'x, y, z': ")
+            split_pos = pos.split(',')
+            if len(split_pos) != 3:
+                raise InvalidSyntax()
+            try:
+                for element in split_pos:
+                    float(element)
+            except ValueError:
+                print(f"Error on parameter '{element}':"
+                      f"could not convert string to float '{element}'")
+            # break because of True loop
+            else:
+                break
+        except InvalidSyntax as err:
+            print(err)
+    return pos
+
+
+def print_info_pos_one(pos):
+    split_pos: tuple[float, ...] = tuple((float(x) for x in pos.split(",")))
+    (x1, y1, z1) = split_pos
+    print(f"It includes: X={x1}, Y={y1}, Z={z1}")
+    x2 = y2 = z2 = 0
+    distance_to_center = math.sqrt((x2-x1)**2 + (y2-y1)**2 + (z2-z1)**2)
+    print(f"Distance to the center: {round(distance_to_center, 4)}")
+
+
+def compute_distance_btw_pos(str_one, str_two):
+    pos_one: tuple[float, ...] = tuple((float(x) for x in str_one.split(",")))
+    (x1, y1, z1) = pos_one
+    pos_two: tuple[float, ...] = tuple((float(x) for x in str_two.split(",")))
+    (x2, y2, z2) = pos_two
+    distance_btw_two = math.sqrt((x2-x1)**2 + (y2-y1)**2 + (z2-z1)**2)
+    print(f"Distance between the two sets of coordinates: "
+          f"{round(distance_btw_two, 4)}")
+
+
+if __name__ == "__main__":
+    print("=== Game Coordinate System ===")
+    pos_one = get_player_pos()
+    print(f"Got a first tuple: ({pos_one})")
+    print_info_pos_one(pos_one)
+    print()
+    print("Get a second set of coordinates")
+    pos_two = get_player_pos()
+    compute_distance_btw_pos(pos_one, pos_two)
diff --git a/py03/ex3/ft_achievement_tracker.py b/py03/ex3/ft_achievement_tracker.py
new file mode 100755
index 0000000..81e9c15
--- /dev/null
+++ b/py03/ex3/ft_achievement_tracker.py
@@ -0,0 +1,94 @@
+#!/usr/bin/env python3
+# https://www.freecodecamp.org/learn/python-v9/review-dictionaries-and-sets/review-dictionaries-and-sets
+
+import random
+
+
+class Player:
+    def __init__(self, name: str, achievements: set[str]):
+        self.name = name
+        self.achievements = achievements
+
+
+def gen_player_achievements(player: str, achievements: set[str]):
+    pa = set()
+    list_ach = list(achievements)
+    for _ in range(9):
+        achievement = random.choice(list_ach)
+        pa.add(achievement)
+    return pa
+
+
+if __name__ == "__main__":
+    print("=== Achievement Tracker System ===")
+    achievements = {'Crafting Genius',
+                    'World Savior',
+                    'Master Explorer',
+                    'Collector Supreme',
+                    'Untouchable',
+                    'Boss Slayer',
+                    'Strategist',
+                    'Unstoppable',
+                    'Speed Runner',
+                    'Survivor',
+                    'Treasure Hunter',
+                    'First Steps',
+                    'Sharp Mind'}
+    print()
+    black_for = '\033[0;30m'
+    pink_bak = '\033[48;5;205m'
+    stp_color = '\033[0m'
+    # print players' achievement(s)
+    players_list: list[str] = ['Alice', 'Bob', 'Charlie', 'Dylan']
+    players = []
+    i = 0
+    for player in players_list:
+        players.append(Player(player,
+                       gen_player_achievements(player, achievements)))
+        print(f"{black_for}{pink_bak}Player {players[i].name}:"
+              f"{stp_color} {players[i].achievements}")
+        i += 1
+    print()
+    union = players[0].achievements.union(players[1].achievements,
+                                          players[2].achievements,
+                                          players[3].achievements)
+    print(f"{black_for}{pink_bak}All distinct achievements:"
+          f"{stp_color} {union}")
+    print()
+    common_achievements = players[0].achievements.intersection(
+                        players[1].achievements,
+                        players[2].achievements,
+                        players[3].achievements)
+    print(f"{black_for}{pink_bak}Common achievements:"
+          f"{stp_color} {common_achievements}")
+    print()
+    # print players' unique achievement(s)
+    print("Only", players[0].name, "has: ",
+          players[0].achievements.difference(players[1].achievements,
+          players[2].achievements,
+          players[3].achievements))
+    print("Only", players[1].name, "has: ",
+          players[1].achievements.difference(players[0].achievements,
+          players[2].achievements,
+          players[3].achievements))
+    print("Only", players[2].name, "has: ",
+          players[2].achievements.difference(players[1].achievements,
+          players[0].achievements,
+          players[3].achievements))
+    print("Only", players[3].name, "has: ",
+          players[3].achievements.difference(players[1].achievements,
+          players[2].achievements,
+          players[0].achievements))
+    print()
+    # print what each player is missing
+    i = 0
+    # iterate through the list of string
+    for player in players_list:
+        missing = set()
+        for key in achievements:
+            # check players' achievement in list of instances
+            if key not in players[i].achievements:
+                missing.add(key)
+        print(f"{black_for}{pink_bak}{players[i].name}"
+              f" is missing\033[0m {missing}")
+        i += 1
diff --git a/py03/ex4/ft_inventory_system.py b/py03/ex4/ft_inventory_system.py
new file mode 100755
index 0000000..104652a
--- /dev/null
+++ b/py03/ex4/ft_inventory_system.py
@@ -0,0 +1,83 @@
+#!/usr/bin/env python3
+# https://www.freecodecamp.org/learn/python-v9/review-dictionaries-and-sets/review-dictionaries-and-sets
+
+import sys
+
+
+def ft():
+    print("=== Inventory System Analysis ===")
+    # check for when there are no params given
+    if len(sys.argv) < 2:
+        print("Enter items following this format: <item_name>:<quantity>")
+        return
+    # initialize dictionary
+    inventory = {}
+    # init list to check for duplicates
+    seen = []
+    for arg in sys.argv[1:]:
+        try:
+            item, quantity = arg.split(':')
+            # print redundant item.s
+            if item in seen:
+                print(f"Redundant item '{item}' - discaring")
+            else:
+                seen.append(item)
+            try:
+                # check that quantities are int
+                int(quantity)
+                if int(quantity) < 0:
+                    raise ValueError("quantity cannot be negative")
+            except ValueError as err:
+                print(f"Quantity error for '{item}': {err}")
+            else:
+                # populate dict
+                inventory[item] = quantity
+        except ValueError:
+            print(f"Error - invalid parameter '{arg.rstrip()}'")
+            if arg == sys.argv[-1] and arg == sys.argv[1]:
+                return
+    # check for when there are many invalid param and no valid params
+    if not seen:
+        return
+    if not inventory:
+        return
+    print(f"Got inventory: {inventory}")
+    item_list = []
+    for item in inventory.keys():
+        item_list.append(item)
+    print(f"Item list: {item_list}")
+    total_quantity = 0
+    for quantity in inventory.values():
+        total_quantity += int(quantity)
+    print(f"Total quantity for the "
+          f"{len(inventory.values())} items: {total_quantity}")
+    # compute percentages
+    for key in inventory:
+        per_of_total = round(100 * (int(inventory[key]) / total_quantity), 1)
+        print(f"Item {key} represents {per_of_total}%")
+    # look for item with max quantity
+    max_value = 0
+    max_key = item_list[0]
+    for key in inventory:
+        if max_value == 0:
+            max_value = int(inventory[key])
+        if int(inventory[key]) > max_value:
+            max_value = int(inventory[key])
+            max_key = key
+    print(f"Item most abundant: {max_key} with quantity {max_value}")
+    # look for item with min quantity
+    min_value = 0
+    min_key = item_list[0]
+    for key in inventory:
+        if min_value == 0:
+            min_value = int(inventory[key])
+        if int(inventory[key]) < min_value:
+            min_value = int(inventory[key])
+            min_key = key
+    print(f"Item least abundant: {min_key} with quantity {min_value}")
+    inventory.update({'magic item': '1'})
+    print(inventory)
+
+
+if __name__ == "__main__":
+    ft()
diff --git a/py03/ex5/ft_data_stream.py b/py03/ex5/ft_data_stream.py
new file mode 100755
index 0000000..b2b0aa6
--- /dev/null
+++ b/py03/ex5/ft_data_stream.py
@@ -0,0 +1,50 @@
+#!/usr/bin/env python3
+# https://www.geeksforgeeks.org/python/how-to-yield-values-from-list-in-python/
+
+import random
+
+players = ['john', 'yaya', 'elise', 'niko']
+actions = ['jump', 'walk', 'run', 'swim']
+
+
+def gen_event(players, actions):
+    player = random.choice(players)
+    action = random.choice(actions)
+    yield player, action
+
+
+# print 1,000 events
+for event in range(1000):
+    # gen_event() returns a 'generator'
+    g = gen_event(players, actions)
+    # create a tuple
+    event_tuple = tuple(next(g))
+    # unpack the tuple
+    (player, action) = event_tuple
+    print(f"Event {event}: Player {player} did {action}")
+print()
+
+# create a list of 10 tuples
+events = []
+for i in range(10):
+    g = gen_event(players, actions)
+    event_tuple = tuple(next(g))
+    events.append(event_tuple)
+print(f"Build a list of 10 events: {events}")
+print()
+
+
+# consume list
+def consume_event(events, nb_events):
+    for i in range(nb_events):
+        ran = random.choice(events)
+        events.remove(ran)
+        yield ran
+
+
+nb_events = len(events)
+
+
+for event in consume_event(events, nb_events):
+    print(f"Got event from list: {event}")
+    print(f"Remains in list: {events}")
diff --git a/py03/ex6/ft_data_alchemist.py b/py03/ex6/ft_data_alchemist.py
new file mode 100755
index 0000000..c1d5794
--- /dev/null
+++ b/py03/ex6/ft_data_alchemist.py
@@ -0,0 +1,33 @@
+#!/usr/bin/env python3
+
+import random
+
+print("=== Game Data Alchemist ===")
+mixed = ['Alice', 'bob', 'Charlie', 'dylan',
+         'Emma', 'Gregory', 'john', 'kevin', 'Liam']
+print("Initial list of player:", mixed)
+print()
+all_cap = [name.capitalize() for name in mixed]
+print("New list with all names capitalized", all_cap)
+print()
+cap_only = [name.capitalize() for name in mixed if name == name.title()]
+print("New list of capitalized names only", cap_only)
+print()
+# for name in all_cap:
+#     score = random.randint(1,300)
+#     d[name] = score
+d = {name: random.randint(1, 300) for name in all_cap}
+print("Score dict;", d)
+print()
+total_score = sum(d[name] for name in d)
+nb_names = len(all_cap)
+average = round(total_score / nb_names, 2)
+print("Score average is:", average)
+print()
+# ahigher = {}
+# for name in d:
+#     if d[name] > average:
+#         ahigher[name] = d[name]
+# print(ahigher)
+higher = {name: d[name] for name in d if d[name] > average}
+print("High scores:", higher)
-- 
cgit v1.2.3