diff --git a/README.md b/README.md
index e69de29bb..2c2a7c791 100644
--- a/README.md
+++ b/README.md
@@ -0,0 +1,126 @@
+# MIT Avatars
+
+![Team Work](assets/team-work.jpg)
+
+Welcome to the **MIT Avatars** repository! This is where our group collaborates,
+learns, and grows together by solving Python challenges, sharing knowledge, and
+developing innovative coding solutions.
+
+---
+
+## 👥 Meet the Team
+
+We’re a group of passionate and diverse learners united by a love for coding and
+problem-solving. Here's a brief introduction to our team members:
+
+- **Aseel 🎯**  
+  *Fun Fact:* "I love playing Sudoku—it’s like a workout for my brain!"
+
+- **Ameen 🏉**  
+  *Fun Fact:* "I am a professional rugby player. I play professional rugby nationally
+  in Lebanon and represent Palestine internationally."
+
+- **Maria ✈️**  
+  *Fun Fact:* "I love traveling as much as I love food – the only difference
+   is, one fills my passport and the other fills my stomach!"
+
+- **Muhannad 🧑🏻‍💻**  
+  *Fun Fact:* "When I feel lost in the maze of learning, I just hit the 'code' button
+  because nothing finds the way like programming!"
+
+- **Maher 🛣️**  
+  *Fun Fact:* "I really like playing rugby."
+
+- **Malak ❇️**  
+  *Fun Fact:* "I look for purpose in almost everything I do."
+
+- **Abdulrahman 🕊**  
+  *Fun Fact:* "I'm a medical student who codes and leads teams—blending science,
+   tech, and leadership in a unique way! I also love cats."
+
+---
+
+## 📌 Purpose of this Repository
+
+This repository is our collaborative space for:
+
+- 📝 **Sharing Python challenges:** Post interesting problems and work together
+  on solutions.
+- 💡 **Collaborating on innovative solutions:** Share diverse approaches and
+  refine them.
+- 📚 **Documenting our learning journey:** Note lessons learned and best practices.
+
+---
+
+## 🚀 Getting Started
+
+Here’s how to get involved and contribute:
+
+### 1️⃣ Fork the Repository
+
+Click the **Fork** button at the top-right of this page to create your copy of
+the repository.
+
+### 2️⃣ Create an Issue
+
+Navigate to the **Issues** tab and submit an issue describing the challenge.
+
+### 3️⃣ Work on the Challenge
+
+Clone the repository to your local machine using:
+
+```bash
+git clone https://github.com/YOUR-USERNAME/ET6-foundations-group-17.git
+```
+
+Create a new branch for your work:
+
+```bash
+git checkout -b feature/your-feature-name
+```
+
+### 4️⃣ Submit Your Work
+
+Push your changes to the branch:
+
+```bash
+git add .
+git commit -m "Description of changes"
+git push origin feature/your-feature-name
+```
+
+Finally, open a pull request and wait for feedback from your team.
+
+---
+
+## 🌟 Code of Conduct
+
+To foster a welcoming and collaborative environment:
+
+- Be respectful and constructive in your feedback.
+- Share knowledge and support each other.
+- Embrace diversity in ideas and approaches.
+
+---
+
+## 🛠️ Tech Stack
+
+This repository uses:
+
+- **Python:** Our primary programming language for solving challenges.
+- **Git/GitHub:** For version control and collaboration.
+
+---
+
+## 🎯 Goals
+
+As the MIT Avatars, we aim to:
+
+- Strengthen our problem-solving skills.
+- Enhance our Python proficiency.
+- Build a supportive and creative learning community.
+- Make it to the MIT program as a team.
+
+🔗 **Group Repository:**  
+Check out our repository:  
+[MIT-Emerging-Talent/ET6-foundations-group-17](https://github.com/MIT-Emerging-Talent/ET6-foundations-group-17)
diff --git a/assets/team-work.jpg b/assets/team-work.jpg
new file mode 100644
index 000000000..83f556c56
Binary files /dev/null and b/assets/team-work.jpg differ
diff --git a/collaboration/README.md b/collaboration/README.md
index 20889b951..dbeba4a57 100644
--- a/collaboration/README.md
+++ b/collaboration/README.md
@@ -1,5 +1,110 @@
 # Collaboration
 
-<!-- group norms summary -->
+## Group Norms
 
-<!-- group norms list -->
+Group norms are the shared values, rules, and expectations that guide our
+behavior, communication, and interactions within the team. By establishing clear
+norms, we aim to create an inclusive, productive, and collaborative environment
+where every member feels valued and empowered. Our team thrives on openness,
+respect, and the shared belief that collaboration makes us stronger.
+
+## Core Principles
+
+### Respect and Inclusivity
+
+- Acknowledge and appreciate the diverse backgrounds, perspectives, and
+contributions of all team members.
+- Foster a safe space for open expression, where constructive feedback is
+encouraged, and differing opinions are welcomed.
+
+### Clear Communication
+
+- Use clear, concise, and respectful language in all communications.
+- Prioritize active listening during discussions and avoid interrupting others.
+- Clarify misunderstandings promptly and assume good intentions when
+interpreting messages.
+
+### Collaboration and Teamwork
+
+- Share responsibilities and ensure equitable participation in tasks.
+- Support each other by sharing knowledge, offering help, and celebrating
+achievements.
+- Commit to resolving conflicts constructively and collaboratively.
+
+### Accountability and Commitment
+
+- Take responsibility for completing assigned tasks on time and to the best of
+your ability.
+- Communicate proactively about challenges or delays to ensure transparency.
+- Honor commitments made to the group and follow through on agreements.
+
+### Adaptability and Growth
+
+- Be open to feedback and willing to make improvements based on team discussions
+- Embrace flexibility in adapting to new tools, workflows, or ideas introduced
+by the group.
+- Commit to ongoing learning and professional development as a team.
+
+## Norms in Practice
+
+### Communication Norms
+
+- Utilize team communication platforms (e.g., Slack, GitHub, Whatsapp, or email)
+for updates, questions, and discussions.
+- Maintain professionalism in all written and verbal interactions.
+- Schedule regular check-ins or stand-ups to monitor progress and address
+concerns.
+
+### Collaboration Norms
+
+- Use shared tools like GitHub for version control, task assignments, and
+documentation.
+- Follow branch naming conventions and adhere to agreed processes for code
+reviews.
+- Complete the collaboration/retrospective.md document at the end of the project
+to reflect on successes and areas for improvement.
+
+### Conflict Resolution
+
+- Approach conflicts with a mindset of dialogue rather than debate.
+- Use "I" statements to express concerns constructively (e.g., "I feel X when Y
+happens").
+- Seek input from the group or a mediator if conflicts cannot be resolved
+independently.
+
+### Meeting Norms
+
+- Start and end meetings on time, with a clear agenda and objectives.
+- Ensure everyone has an opportunity to speak and contribute.
+- Summarize key takeaways and action items at the end of each meeting.
+
+### Inclusion Norms
+
+- Be mindful of language barriers or time zone differences when scheduling
+meetings or assigning tasks.
+- Rotate leadership roles for tasks or meetings to ensure equitable
+participation.
+- Celebrate cultural diversity by sharing customs, holidays, or traditions
+during appropriate occasions.
+
+### Group Norms Summary
+
+- Feedback is given constructively, aiming to improve ideas rather than
+criticize individuals.
+- We communicate transparently and ensure all intentions are clear, fostering
+trust among the team.
+- If someone doesn’t have an answer, they openly admit it, and we work together
+to find solutions.
+- Concerns or ideas are raised immediately, ensuring smooth progress without
+unnecessary delays.
+- Every contribution is valuable, and all ideas are treated with respect and
+consideration.
+- Personal attacks are off-limits; we engage respectfully, focusing on ideas
+rather than people.
+
+## Ongoing Evolution
+
+Group norms are not static. We commit to revisiting and updating these norms
+based on feedback, changing circumstances, and lessons learned from our
+collaborative experiences. By aligning with these norms, we aim to foster a
+supportive team culture that enables high performance and mutual growth.
diff --git a/collaboration/communication.md b/collaboration/communication.md
index 484652e0f..04088a940 100644
--- a/collaboration/communication.md
+++ b/collaboration/communication.md
@@ -1,54 +1,63 @@
-<!--
-    this template is for inspiration, feel free to change it however you like!
-
-    Careful! be sure to protect your privacy when filling out this document
-        everything you write here will be public
-        so share only what you are comfortable sharing online
-        you can share the rest in confidence with you group by another channel
--->
-
 # Communication
 
-______________________________________________________________________
-
 ## Communication Schedule
 
-| Day | How | The topic of discussion | | --- | :-: | ----------------------- |
-| | | |
+| Date | Day | How  | The topic of discussion |
+|-----------|------------|------|--------------|
+| Dec. 20th ✅ | Friday | Zoom meeting | Getting to know team members |
+| Dec. 23rd ✅ | Monday | Google Meet | Collaboratively exploring the group repo.|
+| Dec. 26th ✅ | Thursday | Google Meet |Collaboration folder and its files|
+| Jan. 2nd ✅ | Thursday | Google Meet | Final meeting for the collaboration folder|
+| Jan. 4th ✅ | Saturday | Zoom Online Meeting | Problems Delivery |
+| Jan. 6th ✅ | Monday | GitHub | Review Session |
+| Jan. 8th ✅| Wednesday | GitHub | Challenges Delivery Deadline |
+| Jan. 9th ✅| Tuesday  | GitHub | Reviews Deadline |
+| Jan. 11th | Saturday | Zoom Online Meeting | Retrospective |
 
 ## Communication Channels
 
-how often will we get in touch on each channel, and what we will discuss there:
-
-- **Issues**:
-- **Pull Requests**:
-- **Slack/Discord**:
-- **Video Calls**:
+How often will we get in touch on each channel, and what we will discuss there:
 
-______________________________________________________________________
+- **Issues**:  Used as needed to track tasks, discuss challenges, or document ideas.
+ Team members should also check for updates on a daily basis.
+- **Pull Requests**: Created whenever code is ready for review. All team members
+ should aim to review PRs within 24-48 hours.
+- **Slack/WhatsApp**: Active daily for quick updates, questions, and informal discussions.
+- **Video Calls**: Scheduled every 3 days to discuss progress, address blockers,
+ and align on upcoming tasks.
 
 ## Availability
 
 ### Availability for calling/messaging
 
-| Day | Monday | Tuesday | Wednesday | Thursday | Friday | Saturday | Sunday | |
------- | :----: | :-----: | :-------: | :------: | :----: | :------: | :----: |
-| _name_ | | | | | | | |
+| Name/Day | Sunday | Monday | Tuesday | Wednesday| Thursday | Friday | Saturday|
+|--------------|--------|---------|----------|----------|--------|-------|------|
+| Malak Battatt| 5-8PM| 5-8PM | 5-8PM | 5-8PM |3-6PM | 2-4PM| 2-5PM |
+| Abdulrahman Alsir| 7-9PM| 2-5PM | 4-8PM | 7-9PM | 7-9PM | 6-8PM | 6-8PM |
+| Ameen Agha| 2-6PM| 2-6PM | 2-6PM | 2-6PM | 2-6PM | 2-6PM| 2-6PM|
+| Aseel AbuKmail| 7-10PM| 2-5PM | 5-8PM | 5-7PM | 7-9PM | 6-10PM | 6-8PM |
+| Maher Assaf | 4-7PM| 4-7PM | 6-7PM | 7-8PM | 7-9PM | 6-8PM | 6-8PM |
+| Maria Roufail | 4-7PM| 4-7PM | 6-7PM | 7-8PM | 7-9PM | 6-8PM | 6-8PM |
+| Muhannad Assaf | 4-7PM| 4-7PM | 6-7PM | 7-8PM | 7-9PM | 6-8PM | 6-8PM |
+| Rouaa Hamzah | 4-7PM| 4-7PM | 4-7PM | 4-7PM | 7-9PM | 7-9PM| 7-9PM|
 
 ### How many hours everyone has per day
 
-- name: _5h_;
-- name: _6h_;
-- name: _5h_;
-- name: _4h_;
-- name: _3h_;
+- Malak Battatt: _~2-4h_;
+- Abdulrahman Alsir: _~2-4h_;
+- Ameen Agha: _~2-4h_;
+- Aseel AbuKmail: _~2-4h_;
+- Maher: _~2h_;
+- Maria: _~2h_;
+- Muhannad: _~2h_;
+- Rouaa: _~2h_;
 
 ## Asking for Help
 
 There's a fine line between confidently learning from your mistakes, and
-stubbornly getting no where. Here is a general guide for when to ask for help
+stubbornly getting nowhere. Here is a general guide for when to ask for help
 based on how long you've been stuck on the same problem:
 
 1. _0 -> 30 min_: Try on your own
-1. _30 -> 60 min_: Ask your group for help
-1. _60+ min_: Tag your coaches in Slack or GitHub
+2. _30 -> 60 min_: Ask your group for help
+3. _60+ min_: Tag your coaches in Slack or GitHub
diff --git a/collaboration/constraints.md b/collaboration/constraints.md
index 24079505c..ead4ac343 100644
--- a/collaboration/constraints.md
+++ b/collaboration/constraints.md
@@ -2,29 +2,47 @@
 
 # Constraints
 
-Some boundaries around our project.
-
-## External
-
-<!--
-  constraints coming from the outside that your team has no control over:
-  - project deadlines
-  - number of unit tests required to pass a code review
-  - technologies (sometimes a client will tell you what to use)
-  - power or connectivity
-  - ...
--->
+## External Constraints
+
+- **Deadline:** The project must be finished by January 10th.
+- **Connectivity Issues:** Limited internet access affects some teammates,
+especially during peak hours.
+- **Holiday Availability:** Team members celebrating Christmas may have fewer
+hours to contribute this week.
+- **Time Zone Differences:** Team members located in different time zones may
+face scheduling conflicts.
+- **Resource Limitations:** Access to high-performance computers or specific
+software licenses may be restricted for some members.
+- **Childcare Responsibilities:** Some team members need to take care of their children.
 
 ## Internal: Involuntary
 
-<!--
-  constraints that come from within your team, and you have no control over:
-  - each of your individual skill levels
-  - amount of time available to work on the project
--->
+- **Students:** Managing their time between this project and their final exams.
+- **GitHub Workflows:** Some team members are new to GitHub workflows and may
+need extra guidance.
+- **English Fluency:** Limited fluency in English among some members might make
+it harder to express complex ideas or provide detailed feedback during
+discussions.
+- **Team Composition:** Uneven distribution of technical skills among team
+members may create bottlenecks for specific tasks.
+- **Health and Well-being:** Some members may have personal health issues or
+responsibilities that could affect their availability.
+- **Knowledge Gaps:** Some team members may lack experience with certain tools
+  or frameworks required for the project, leading to delays.
 
 ## Internal: Voluntary
 
+- Agreed Coding Standards and Conventions (Naming conventions, Comment style)
+- Code Review Checklist for the Project Repository
+- Number of Hours Team Members Want to Spend Working
+- Limiting the Scope to specific design choices (e.g., only using black and
+white colors)
+- **Communication Protocols:**
+The team has agreed to use specific tools (e.g., Slack, Zoom) for coordination
+and discussions.
+- **Review Policies:**
+Each pull request must be reviewed by at least two members before merging.
+
 <!--
   constraints that your team decided on to help scope the project. they may include:
   - coding style & conventions
diff --git a/collaboration/learning_goals.md b/collaboration/learning_goals.md
index 11c583d2b..83ac5fd2d 100644
--- a/collaboration/learning_goals.md
+++ b/collaboration/learning_goals.md
@@ -1,5 +1,53 @@
 # Learning Goals
 
-## Collective
+## Collective Goals
 
-## Individual
+### Technical Skills
+
+- **Learn Python:** Strengthen foundational and advanced Python skills through
+ practical application.
+- **GitHub Expertise:** Gain hands-on experience with GitHub's features for
+ collaboration, version control, and code review.
+- **Visual Studio Code:** Use Visual Studio Code efficiently for coding,
+ debugging, and managing repositories.
+
+### Human Skills
+
+- **Collaboration:** Foster teamwork through effective and respectful group interactions.
+- **Communication:** Practice clear and constructive communication during code
+ reviews and discussions.
+- **Time Management:** Develop strategies to manage deadlines and balance responsibilities
+ within the group.
+- **Problem-Solving:** Apply structured approaches to troubleshoot and debug code
+ effectively.
+- **Cultural Integration:** Embrace diverse perspectives and learn to work in a
+ multicultural environment.
+- **Non-Formal Education:** Leverage peer learning to improve technical and soft
+ skills.
+
+## Individual Goals
+
+Each team member will focus on one or more personal objectives, which can include:
+
+- Reviewing and strengthening previously studied data structures and algorithms.
+- Learning new data structures, algorithms, or programming paradigms.
+- Practicing new programming language features and incorporating them into solutions.
+- Writing more complete, readable, and well-documented solutions.
+- Increasing efficiency in coding and problem-solving processes.
+- Developing expertise in code review by engaging in iterative feedback cycles.
+- Gaining confidence in explaining technical decisions and code logic to peers.
+
+## Project-Specific Objectives
+
+- **Master the GitHub code review process:** Including creating and reviewing
+ pull requests, labeling issues, and maintaining a project board.
+- **Continuous Integration (CI):** Build familiarity with CI tools and learn to
+ address CI check failures effectively.
+- **Best Practices:** Improve adherence to best practices such as using helpful
+ branch naming conventions and completing retrospective documentation.
+
+---
+
+By documenting and pursuing these goals, we aim to ensure that each group member
+ maximizes their learning outcomes while contributing to a successful and
+ collaborative project.
diff --git a/notes/README.md b/notes/README.md
index 17e0f0ded..35b6fa306 100644
--- a/notes/README.md
+++ b/notes/README.md
@@ -1 +1,15 @@
 # Notes
+
+## Abdulrahman Ali
+
+- For the number sort challenge, I uploaded the file via file upload because I
+was facing electricity shortage and I had to use my phone to upload the file.
+- All the recent updates were done via CLI since the power is partially back and
+I have access to a laptop right now.
+- The same goes for the other challenges I uploaded via file upload and when I
+got my laptop back I updated the files via CLI.
+- I updated the functions and test files of some of our team members because
+they kept failing the CI checks and this affected all other team members and we
+needed to complete our project on time but these issues were keeping us from
+commiting any new changes to the repository because they will keep failing the
+CI checks.
diff --git a/solutions/chicken_nugget_fun_solution.py b/solutions/chicken_nugget_fun_solution.py
new file mode 100644
index 000000000..cfba29f48
--- /dev/null
+++ b/solutions/chicken_nugget_fun_solution.py
@@ -0,0 +1,19 @@
+import random
+
+
+def chicken_nugget_fun():
+    print("Welcome to the Chicken Nugget Fun Zone!")
+
+    nugget_facts = [
+        "Chicken nuggets were invented in the 1950s by Robert C. Baker!",
+        "The world record for eating chicken nuggets is 746 grams in 3 minutes!",
+        "McDonald's nuggets come in four shapes: bell, bow-tie, ball, and boot.",
+        "Try making homemade nuggets with chicken, breadcrumbs, and spices!",
+        "Some people dip chicken nuggets in honey—have you tried it?",
+        "Chicken nuggets are eaten by millions around the world every day!",
+        "Sweet chili sauce makes chicken nuggets extra tasty!",
+        "You can even make plant-based chicken nuggets now!",
+    ]
+
+    random_fact = random.choice(nugget_facts)
+    print(f"Here's your nugget fun: {random_fact}")
diff --git a/solutions/chocolate_distribution.py b/solutions/chocolate_distribution.py
new file mode 100644
index 000000000..d4cbe0761
--- /dev/null
+++ b/solutions/chocolate_distribution.py
@@ -0,0 +1,38 @@
+def minimize_chocolate_difference(chocolates, k):
+    """
+    Function to distribute chocolates to minimize the difference between the maximum
+    and minimum chocolates received.
+
+    Parameters:
+    chocolates (list): List of integers representing chocolates in packets.
+    k (int): Number of students.
+
+    Returns:
+    int: The minimized difference between the maximum and minimum chocolates received.
+    """
+    if k == 0 or len(chocolates) == 0:
+        return 0
+
+    if len(chocolates) < k:
+        return -1  # Not enough packets for the students
+
+    # Sort the packets
+    chocolates.sort()
+
+    # Initialize the minimum difference
+    min_diff = float("inf")
+
+    # Find the smallest difference for a group of k packets
+    for i in range(len(chocolates) - k + 1):
+        diff = chocolates[i + k - 1] - chocolates[i]
+        min_diff = min(min_diff, diff)
+
+    return min_diff
+
+
+# Example usage
+if __name__ == "__main__":
+    chocolates = [12, 4, 7, 9, 2, 23, 25, 41, 30, 40, 28, 42, 30, 44, 48, 43, 50]
+    k = 7
+    result = minimize_chocolate_difference(chocolates, k)
+    print(f"Minimum difference is {result}")
diff --git a/solutions/is_palindrome.py b/solutions/is_palindrome.py
new file mode 100644
index 000000000..b45aae0a8
--- /dev/null
+++ b/solutions/is_palindrome.py
@@ -0,0 +1,37 @@
+"""
+A module to check if a given string is a palindrome.
+
+Module contents:
+    - is_palindrome: checks if a string reads the same forwards and backwards.
+
+Created on 03-01-25
+
+"""
+
+
+def is_palindrome(input_string: str) -> bool:
+    """
+    Checks if a string is a palindrome.
+
+    Parameters:
+        input_string (str): The string to be checked.
+
+    Returns:
+        bool: True if the string is a palindrome, False otherwise.
+
+    Raises:
+        TypeError: If the input is not a string.
+
+    Examples:
+        >>> is_palindrome("madam")
+        True
+
+        >>> is_palindrome("hello")
+        False
+
+        >>> is_palindrome("")
+        True
+    """
+    if not isinstance(input_string, str):
+        raise TypeError("Input must be a string.")
+    return input_string == input_string[::-1]
diff --git a/solutions/mirror_words_challenge.py b/solutions/mirror_words_challenge.py
new file mode 100644
index 000000000..bd81759eb
--- /dev/null
+++ b/solutions/mirror_words_challenge.py
@@ -0,0 +1,52 @@
+import re
+
+
+def mirror_words(sentence: str) -> str:
+    """
+    Reverses each word in a given sentence while maintaining the order of the words.
+    Punctuation marks at the end of words are correctly handled, ensuring they remain
+    in place.
+
+    Args:
+        sentence (str): The sentence to be processed. It can contain words, punctuation,
+        spaces, numbers, and special characters.
+    Returns:
+        str: A new string where each word is reversed, but the word order, punctuation,
+        numbers, and special characters remain unchanged.
+
+    Example:
+        >>> mirror_words("Hello world!")
+        'olleH dlrow!'
+
+        >>> mirror_words("Python is fun")
+        'nohtyP si nuf'
+
+        >>> mirror_words("Keep calm & code on.")
+        'peeK mlac & edoc .no'
+
+    Raises:
+        TypeError: If the input is not a string.
+
+    Note:
+    This function processes each word individually, reversing only the characters
+    in the word while leaving punctuation, numbers, and special characters
+    unchanged.
+
+    """
+    if not isinstance(sentence, str):
+        raise TypeError("Input must be a string")
+
+    # Split the sentence into words
+    words = sentence.split()
+
+    mirrored_words_list = []  # List to store the mirrored words
+    for word in words:
+        # Match the word and any punctuation at the end
+        match = re.match(r"([a-zA-Z]+)([^a-zA-Z]*)", word)
+        if match:
+            # Reverse the word and keep punctuation at the end without reversing it
+            mirrored_words_list.append(match.group(1)[::-1] + match.group(2))
+        else:
+            mirrored_words_list.append(word)
+
+    return " ".join(mirrored_words_list)
diff --git a/solutions/number_sort.py b/solutions/number_sort.py
new file mode 100644
index 000000000..387be7559
--- /dev/null
+++ b/solutions/number_sort.py
@@ -0,0 +1,52 @@
+"""
+A module for sorting a list of numbers using a custom implementation of the Bubble Sort algorithm.
+
+Module contents:
+    - sort: sorts a list of numbers in ascending order using the Bubble Sort algorithm.
+    - main loop: collects user input until 9 numbers are provided and sorts them.
+
+Created on 03-01-25
+@author: Abdulrahman Ali + Cody
+"""
+
+
+def sort(list_of_num: list) -> list:
+    """
+    Sorts a list of numbers in ascending order using the Bubble Sort algorithm.
+
+    Parameters:
+        list_of_num (list): A list of numbers to be sorted.
+
+    Returns:
+        list: The sorted list of numbers.
+
+    Raises:
+        TypeError: If the input is not a list.
+        ValueError: If any element in the list is not a number (int or float).
+
+    Strategy:
+        The function iterates through the list of numbers and compares each element with the next.
+        If the current element is greater than the next, the elements are swapped.
+        This process is repeated until the list is sorted in ascending order.
+
+    Examples:
+        >>> sort([4, 2, 7, 1])
+        [1, 2, 4, 7]
+
+        >>> sort([10, -5, 3, 0])
+        [-5, 0, 3, 10]
+
+        >>> sort([1, 2, 3, 4])
+        [1, 2, 3, 4]
+    """
+    if not isinstance(list_of_num, list):
+        raise TypeError("Input must be a list.")
+
+    if not all(isinstance(x, (int, float)) for x in list_of_num):
+        raise ValueError("All elements in the list must be numbers.")
+
+    for i in range(len(list_of_num) - 1):
+        for j in range(len(list_of_num) - 1 - i):
+            if list_of_num[j] > list_of_num[j + 1]:
+                list_of_num[j], list_of_num[j + 1] = list_of_num[j + 1], list_of_num[j]
+    return list_of_num
diff --git a/solutions/prime_filter_challenge.py b/solutions/prime_filter_challenge.py
new file mode 100644
index 000000000..4b1fa248f
--- /dev/null
+++ b/solutions/prime_filter_challenge.py
@@ -0,0 +1,42 @@
+import math
+from typing import List
+
+
+def prime_filter(numbers: List[int]) -> List[int]:
+    """
+    Filters out all non-prime numbers from a given list of integers.
+
+    Args:
+        numbers (list of int): A list of integers to be processed.
+
+    Returns:
+        list of int: A new list containing only the prime numbers, maintaining the original order.
+
+    Example:
+        >>> prime_filter([2, 3, 4, 5, 6, 7])
+        [2, 3, 5, 7]
+
+        >>> prime_filter([10, 15, 17, 19, 20])
+        [17, 19]
+
+    Raises:
+        TypeError: If the input is not a list of integers.
+        ValueError: If the list contains a non-integer element.
+    """
+
+    if not isinstance(numbers, list):
+        raise TypeError("Input must be a list of integers.")
+
+    if not all(isinstance(i, int) for i in numbers):
+        raise ValueError("All elements in the list must be integers.")
+
+    def is_prime(n: int) -> bool:
+        """Helper function to check if a number is prime."""
+        if n <= 1:
+            return False
+        for i in range(2, int(math.sqrt(n)) + 1):
+            if n % i == 0:
+                return False
+        return True
+
+    return [num for num in numbers if is_prime(num)]
diff --git a/solutions/rock_paper_scissor.py b/solutions/rock_paper_scissor.py
new file mode 100644
index 000000000..eda534b2b
--- /dev/null
+++ b/solutions/rock_paper_scissor.py
@@ -0,0 +1,65 @@
+"""
+A module for playing a game of Rock-Paper-Scissors.
+
+Module contents:
+    - play_round: Simulates a round of Rock-Paper-Scissors where the user competes
+    against the computer.
+
+Created on 31-12-24
+Updated on 09-01-25
+@author: Abdulrahman Ali (Reviewed by Cody)
+"""
+
+import random
+
+OPTIONS: list[str] = ["rock", "paper", "scissors"]
+
+
+def play_round(user_input: str) -> str:
+    """
+    Simulates a round of Rock-Paper-Scissors with the computer.
+
+    Parameters:
+        user_input (str): The user's move ('rock', 'paper', or 'scissors').
+
+    Returns:
+        str: A string describing the result of the round and the computer's choice.
+
+    Raises:
+        TypeError: If user_input is not a string or is empty.
+        ValueError: If user_input is not one of the valid options.
+
+    Examples:
+        >>> play_round('rock')
+        'win! Computer's choice: scissors'
+
+        >>> play_round('paper')
+        'lose! Computer's choice: scissors'
+
+        >>> play_round('scissors')
+        'draw! Computer's choice: scissors'
+
+        >>> play_round('invalid')
+        Traceback (most recent call last):
+        ...
+        ValueError: Invalid input. Choose one of: rock, paper, scissors.
+    """
+    if not isinstance(user_input, str) or not user_input.strip():
+        raise TypeError("Input must be a non-empty string.")
+
+    user_input = user_input.strip().lower()
+    if user_input not in OPTIONS:
+        raise ValueError(f"Invalid input. Choose one of: {', '.join(OPTIONS)}.")
+
+    computer_pick = random.choice(OPTIONS)
+
+    if user_input == computer_pick:
+        return f"draw! Computer's choice: {computer_pick}"
+    elif (
+        (user_input == "rock" and computer_pick == "scissors")
+        or (user_input == "paper" and computer_pick == "rock")
+        or (user_input == "scissors" and computer_pick == "paper")
+    ):
+        return f"win! Computer's choice: {computer_pick}"
+    else:
+        return f"lose! Computer's choice: {computer_pick}"
diff --git a/solutions/tests/test_chicken_nugget_fun.py b/solutions/tests/test_chicken_nugget_fun.py
new file mode 100644
index 000000000..b49058269
--- /dev/null
+++ b/solutions/tests/test_chicken_nugget_fun.py
@@ -0,0 +1,50 @@
+import sys
+import unittest
+from io import StringIO
+from pathlib import Path
+
+sys.path.append(str(Path(__file__).parent.parent))
+
+from chicken_nugget_fun_solution import chicken_nugget_fun
+
+
+class TestChickenNuggetFun(unittest.TestCase):
+    """Test cases for the `chicken_nugget_fun` function."""
+
+    def test_output(self):
+        """Test if the output contains a valid chicken nugget fact."""
+        # Backup original stdout
+        original_stdout = sys.stdout
+        sys.stdout = StringIO()
+
+        try:
+            # Run the function
+            chicken_nugget_fun()
+
+            # Get the output
+            output = sys.stdout.getvalue()
+
+            # Check if the output contains a nugget fact
+            self.assertTrue(
+                any(
+                    fact in output
+                    for fact in [
+                        "Chicken nuggets were invented",
+                        "The world record for eating chicken nuggets",
+                        "McDonald's nuggets come in four shapes",
+                        "Try making homemade nuggets",
+                        "Some people dip chicken nuggets in honey",
+                        "Chicken nuggets are eaten by millions",
+                        "Sweet chili sauce makes chicken nuggets extra tasty",
+                        "You can even make plant-based chicken nuggets",
+                    ]
+                ),
+                "Output did not contain a valid chicken nugget fact.",
+            )
+        finally:
+            # Restore original stdout
+            sys.stdout = original_stdout
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/solutions/tests/test_chocolate_distribution.py b/solutions/tests/test_chocolate_distribution.py
new file mode 100644
index 000000000..9e1a0ad4a
--- /dev/null
+++ b/solutions/tests/test_chocolate_distribution.py
@@ -0,0 +1,54 @@
+import unittest
+import sys
+from pathlib import Path
+
+sys.path.append(str(Path(__file__).parent.parent))
+from chocolate_distribution import minimize_chocolate_difference
+
+
+class TestMinimizeChocolateDifference(unittest.TestCase):
+    def test_valid_case(self):
+        """Test a valid case with enough packets and students."""
+        chocolates = [12, 4, 7, 9, 2, 23, 25, 41, 30, 40, 28, 42, 30, 44, 48, 43, 50]
+        k = 7
+        result = minimize_chocolate_difference(chocolates, k)
+        self.assertEqual(result, 10)
+
+    def test_not_enough_packets(self):
+        """Test the case where there are fewer packets than students."""
+        chocolates = [1, 2, 3]
+        k = 5
+        result = minimize_chocolate_difference(chocolates, k)
+        self.assertEqual(result, -1)
+
+    def test_empty_chocolates_list(self):
+        """Test the case where the chocolates list is empty."""
+        chocolates = []
+        k = 3
+        result = minimize_chocolate_difference(chocolates, k)
+        self.assertEqual(result, 0)
+
+    def test_zero_students(self):
+        """Test the case where the number of students is zero."""
+        chocolates = [10, 20, 30]
+        k = 0
+        result = minimize_chocolate_difference(chocolates, k)
+        self.assertEqual(result, 0)
+
+    def test_single_packet(self):
+        """Test the case with only one packet and one student."""
+        chocolates = [42]
+        k = 1
+        result = minimize_chocolate_difference(chocolates, k)
+        self.assertEqual(result, 0)
+
+    def test_minimized_difference(self):
+        """Test a generic case to validate the minimized difference calculation."""
+        chocolates = [7, 3, 2, 4, 9, 12, 56]
+        k = 3
+        result = minimize_chocolate_difference(chocolates, k)
+        self.assertEqual(result, 2)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/solutions/tests/test_is_palindrome.py b/solutions/tests/test_is_palindrome.py
new file mode 100644
index 000000000..19b316da5
--- /dev/null
+++ b/solutions/tests/test_is_palindrome.py
@@ -0,0 +1,50 @@
+"""
+Test module for the is_palindrome function.
+
+Test categories:
+    - Standard cases: typical strings to verify palindrome status
+    - Edge cases: empty string, single-character strings
+    - Defensive tests: invalid input types
+
+Created on 03-01-25
+Updated on 10-01-25
+
+"""
+
+import unittest
+import sys
+from pathlib import Path
+
+sys.path.append(str(Path(__file__).parent.parent))
+from is_palindrome import is_palindrome
+
+
+class TestIsPalindrome(unittest.TestCase):
+    def test_palindrome(self):
+        """Test for a string that is a palindrome."""
+        result = is_palindrome("madam")
+        self.assertTrue(result)
+
+    def test_non_palindrome(self):
+        """Test for a string that is not a palindrome."""
+        result = is_palindrome("hello")
+        self.assertFalse(result)
+
+    def test_empty_string(self):
+        """Test for an empty string."""
+        result = is_palindrome("")
+        self.assertTrue(result)
+
+    def test_single_character(self):
+        """Test for a single-character string."""
+        result = is_palindrome("a")
+        self.assertTrue(result)
+
+    def test_invalid_input_type(self):
+        """Test for invalid input types."""
+        with self.assertRaises(TypeError):
+            is_palindrome(12345)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/solutions/tests/test_mirror_words_challenge.py b/solutions/tests/test_mirror_words_challenge.py
new file mode 100644
index 000000000..59a0b0348
--- /dev/null
+++ b/solutions/tests/test_mirror_words_challenge.py
@@ -0,0 +1,60 @@
+import unittest
+
+from ..mirror_words_challenge import mirror_words
+
+
+class TestMirrorWords(unittest.TestCase):
+    """Tests for mirror_words function"""
+
+    # Standard test cases
+    def test_mirror_words_regular_sentence(self):
+        """It should mirror each word in a regular sentence while maintaining word order"""
+        actual = mirror_words("Hello world!")
+        expected = "olleH dlrow!"
+        self.assertEqual(actual, expected)
+
+    def test_mirror_words_single_word(self):
+        """It should reverse a single word in a sentence"""
+        actual = mirror_words("Python")
+        expected = "nohtyP"
+        self.assertEqual(actual, expected)
+
+    def test_mirror_words_with_punctuation(self):
+        """It should handle words with punctuation marks"""
+        actual = mirror_words("Python is fun")
+        expected = "nohtyP si nuf"
+        self.assertEqual(actual, expected)
+
+    # Edge cases
+    def test_empty_sentence(self):
+        """It should return an empty string for an empty sentence"""
+        actual = mirror_words("")
+        expected = ""
+        self.assertEqual(actual, expected)
+
+    def test_single_character(self):
+        """It should return the single character unchanged"""
+        actual = mirror_words("A")
+        expected = "A"
+        self.assertEqual(actual, expected)
+
+    def test_sentence_with_special_characters(self):
+        """It should handle sentences with special characters correctly"""
+        actual = mirror_words("!@# $%^ &*()")
+        expected = "!@# $%^ &*()"
+        self.assertEqual(actual, expected)
+
+    # Defensive test cases
+    def test_non_string_input(self):
+        """It should raise TypeError for non-string input"""
+        with self.assertRaises(TypeError):
+            mirror_words(12345)
+
+    def test_input_with_mixed_data_types(self):
+        """It should raise TypeError for input with mixed types"""
+        with self.assertRaises(TypeError):
+            mirror_words(["Hello", "world!"])
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/solutions/tests/test_number_sort.py b/solutions/tests/test_number_sort.py
new file mode 100644
index 000000000..f1cb6aea8
--- /dev/null
+++ b/solutions/tests/test_number_sort.py
@@ -0,0 +1,112 @@
+"""
+Test module for the sort function in the custom Bubble Sort implementation.
+Contains tests for standard cases, edge cases, and defensive assertions.
+
+Test categories:
+    - Standard cases: typical lists of numbers to verify sorting correctness
+    - Edge cases: empty lists, single-element lists, duplicate values
+    - Defensive tests: invalid input types, assertions
+
+Created on 03-01-25
+Updated on 10-01-25
+Author: Cody (Reviewed By Abdulrahman)
+"""
+
+import unittest
+import sys
+from pathlib import Path
+
+sys.path.append(str(Path(__file__).parent.parent))
+from number_sort import sort
+
+
+class TestBubbleSort(unittest.TestCase):
+    """
+    Test cases for the custom Bubble Sort function.
+    """
+
+    def test_standard_case(self):
+        """Test for a typical list of unsorted numbers."""
+        result = sort([4, 2, 7, 1, 9, 5])
+        expected = [1, 2, 4, 5, 7, 9]
+        self.assertEqual(result, expected)
+
+    def test_reverse_order(self):
+        """Test for a list in reverse order."""
+        result = sort([10, 9, 8, 7, 6, 5])
+        expected = [5, 6, 7, 8, 9, 10]
+        self.assertEqual(result, expected)
+
+    def test_sorted_input(self):
+        """Test for a list that is already sorted."""
+        result = sort([1, 2, 3, 4, 5])
+        expected = [1, 2, 3, 4, 5]
+        self.assertEqual(result, expected)
+
+    def test_single_element(self):
+        """Test for a list with a single element."""
+        result = sort([42])
+        expected = [42]
+        self.assertEqual(result, expected)
+
+    def test_empty_list(self):
+        """Test for an empty list."""
+        result = sort([])
+        expected = []
+        self.assertEqual(result, expected)
+
+    def test_duplicates(self):
+        """Test for a list with duplicate numbers."""
+        result = sort([4, 2, 7, 2, 5, 4])
+        expected = [2, 2, 4, 4, 5, 7]
+        self.assertEqual(result, expected)
+
+    def test_negative_numbers(self):
+        """Test for a list with negative numbers."""
+        result = sort([-3, -1, -4, -2])
+        expected = [-4, -3, -2, -1]
+        self.assertEqual(result, expected)
+
+    def test_mixed_numbers(self):
+        """Test for a list with a mix of positive and negative numbers."""
+        result = sort([-2, 3, 0, -1, 4])
+        expected = [-2, -1, 0, 3, 4]
+        self.assertEqual(result, expected)
+
+    def test_invalid_input_type(self):
+        """Test for invalid input where the argument is not a list."""
+        with self.assertRaises(TypeError):
+            sort("not_a_list")
+
+    def test_non_numeric_elements(self):
+        """Test for a list with non-numeric elements."""
+        with self.assertRaises(ValueError):
+            sort([1, "a", 3])
+
+    def test_large_numbers(self):
+        """Test for lists with very large numbers."""
+        result = sort([10**6, -(10**6), 0])
+        expected = [-(10**6), 0, 10**6]
+        self.assertEqual(result, expected)
+
+    def test_very_large_numbers(self):
+        """Test sorting numbers in the millions range."""
+        result = sort([2000000, 1000000, 3000000])
+        expected = [1000000, 2000000, 3000000]
+        self.assertEqual(result, expected)
+
+    def test_very_small_numbers(self):
+        """Test sorting very small decimal numbers."""
+        result = sort([0.0001, 0.0003, 0.0002])
+        expected = [0.0001, 0.0002, 0.0003]
+        self.assertEqual(result, expected)
+
+    def test_wide_range_numbers(self):
+        """Test sorting numbers with very different magnitudes."""
+        result = sort([1000000, 0.001, 1, 10000])
+        expected = [0.001, 1, 10000, 1000000]
+        self.assertEqual(result, expected)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/solutions/tests/test_prime_filter_challenge.py b/solutions/tests/test_prime_filter_challenge.py
new file mode 100644
index 000000000..739e96836
--- /dev/null
+++ b/solutions/tests/test_prime_filter_challenge.py
@@ -0,0 +1,72 @@
+"""
+Test module for filter_primes function.
+Contains correct tests to help identify bugs in the implementation.
+
+Test categories:
+    - Standard cases: Lists with various integers, both prime and non-prime.
+    - Edge cases: Empty lists, lists with only non-prime numbers.
+    - Defensive cases: Invalid inputs (e.g., non-list types, mixed data types).
+
+Created on 2025-01-05
+Author: Aseel AbuKmail
+"""
+
+import unittest
+from ..prime_filter_challenge import prime_filter
+
+
+class TestPrimeFilter(unittest.TestCase):
+    """Tests for prime_filter function"""
+
+    # Standard test cases
+    def test_prime_filter_regular_list(self):
+        """It should return a list containing only prime numbers"""
+        actual = prime_filter([2, 3, 4, 5, 6, 7])
+        expected = [2, 3, 5, 7]
+        self.assertEqual(actual, expected)
+
+    def test_prime_filter_with_negative_numbers(self):
+        """It should return a list of primes, ignoring negative numbers"""
+        actual = prime_filter([-2, -3, 4, 5, 6, -7])
+        expected = [5]
+        self.assertEqual(actual, expected)
+
+    def test_prime_filter_with_no_primes(self):
+        """It should return an empty list if there are no primes"""
+        actual = prime_filter([4, 6, 8, 10])
+        expected = []
+        self.assertEqual(actual, expected)
+
+    # Edge cases
+    def test_empty_list(self):
+        """It should return an empty list for an empty input list"""
+        actual = prime_filter([])
+        expected = []
+        self.assertEqual(actual, expected)
+
+    def test_single_number(self):
+        """It should return a list with the single number if it's prime, or empty if not"""
+        actual = prime_filter([7])
+        expected = [7]
+        self.assertEqual(actual, expected)
+
+    def test_list_with_only_non_prime_numbers(self):
+        """It should return an empty list if all numbers are non-prime"""
+        actual = prime_filter([1, 4, 6, 8])
+        expected = []
+        self.assertEqual(actual, expected)
+
+    # Defensive test cases
+    def test_non_list_input(self):
+        """It should raise TypeError for non-list input"""
+        with self.assertRaises(TypeError):
+            prime_filter(12345)
+
+    def test_input_with_mixed_data_types(self):
+        """It should raise ValueError for input with mixed types"""
+        with self.assertRaises(ValueError):
+            prime_filter([2, "3", 5])
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/solutions/tests/test_rock_paper_scissor.py b/solutions/tests/test_rock_paper_scissor.py
new file mode 100644
index 000000000..be9d15595
--- /dev/null
+++ b/solutions/tests/test_rock_paper_scissor.py
@@ -0,0 +1,139 @@
+"""
+Test module for play_round function in the Rock-Paper-Scissors game.
+Contains tests for standard cases, edge cases, and defensive assertions.
+
+Test categories:
+    - Standard cases: typical user inputs and expected game results
+    - Edge cases: empty input, invalid input, and quitting the game
+    - Defensive tests: wrong input types, assertions
+
+Created on 31-12-24
+Updated on 09-01-25
+Author: Abdulrahman Ali + Cody
+"""
+
+import unittest
+import random
+import sys
+from pathlib import Path
+
+sys.path.append(str(Path(__file__).parent.parent))
+from rock_paper_scissor import play_round
+
+
+class TestPlayRound(unittest.TestCase):
+    """Test suite for the play_round function in the Rock-Paper-Scissors game."""
+
+    def test_rock_beats_scissors(self):
+        """Test rock wins against scissors."""
+        random.choice = lambda options: "scissors"
+        self.assertEqual(play_round("rock"), "win! Computer's choice: scissors")
+
+    def test_paper_beats_rock(self):
+        """Test paper wins against rock."""
+        random.choice = lambda options: "rock"
+        self.assertEqual(play_round("paper"), "win! Computer's choice: rock")
+
+    def test_scissors_beats_paper(self):
+        """Test scissors wins against paper."""
+        random.choice = lambda options: "paper"
+        self.assertEqual(play_round("scissors"), "win! Computer's choice: paper")
+
+    def test_rock_loses_to_paper(self):
+        """Test rock loses to paper."""
+        random.choice = lambda options: "paper"
+        self.assertEqual(play_round("rock"), "lose! Computer's choice: paper")
+
+    def test_paper_loses_to_scissors(self):
+        """Test paper loses to scissors."""
+        random.choice = lambda options: "scissors"
+        self.assertEqual(play_round("paper"), "lose! Computer's choice: scissors")
+
+    def test_scissors_loses_to_rock(self):
+        """Test scissors loses to rock."""
+        random.choice = lambda options: "rock"
+        self.assertEqual(play_round("scissors"), "lose! Computer's choice: rock")
+
+    def test_rock_draws_with_rock(self):
+        """Test rock draws with rock."""
+        random.choice = lambda options: "rock"
+        self.assertEqual(play_round("rock"), "draw! Computer's choice: rock")
+
+    def test_paper_draws_with_paper(self):
+        """Test paper draws with paper."""
+        random.choice = lambda options: "paper"
+        self.assertEqual(play_round("paper"), "draw! Computer's choice: paper")
+
+    def test_scissors_draws_with_scissors(self):
+        """Test scissors draws with scissors."""
+        random.choice = lambda options: "scissors"
+        self.assertEqual(play_round("scissors"), "draw! Computer's choice: scissors")
+
+    def test_uppercase_input(self):
+        """Test uppercase input handling."""
+        random.choice = lambda options: "rock"
+        self.assertEqual(play_round("ROCK"), "draw! Computer's choice: rock")
+
+    def test_mixed_case_input(self):
+        """Test mixed case input handling."""
+        random.choice = lambda options: "rock"
+        self.assertEqual(play_round("RoCk"), "draw! Computer's choice: rock")
+
+    def test_leading_whitespace(self):
+        """Test leading whitespace handling."""
+        random.choice = lambda options: "rock"
+        self.assertEqual(play_round(" rock"), "draw! Computer's choice: rock")
+
+    def test_trailing_whitespace(self):
+        """Test trailing whitespace handling."""
+        random.choice = lambda options: "rock"
+        self.assertEqual(play_round("rock "), "draw! Computer's choice: rock")
+
+    def test_empty_input(self):
+        """Test empty input raises AssertionError."""
+        with self.assertRaises(TypeError):
+            play_round("")
+
+    def test_invalid_word_input(self):
+        """Test invalid word input raises ValueError."""
+        with self.assertRaises(ValueError):
+            play_round("invalid")
+
+    def test_integer_input(self):
+        """Test integer input raises TypeError."""
+        with self.assertRaises(TypeError):
+            play_round(123)
+
+    def test_float_input(self):
+        """Test float input raises TypeError."""
+        with self.assertRaises(TypeError):
+            play_round(1.23)
+
+    def test_list_input(self):
+        """Test list input raises TypeError."""
+        with self.assertRaises(TypeError):
+            play_round(["rock"])
+
+    def test_dict_input(self):
+        """Test dict input raises TypeError."""
+        with self.assertRaises(TypeError):
+            play_round({"choice": "rock"})
+
+    def test_none_input(self):
+        """Test None input raises TypeError."""
+        with self.assertRaises(TypeError):
+            play_round(None)
+
+    def test_boolean_input(self):
+        """Test boolean input raises TypeError."""
+        with self.assertRaises(TypeError):
+            play_round(True)
+
+    def test_special_chars_input(self):
+        """Test input with special characters raises ValueError."""
+        with self.assertRaises(ValueError):
+            play_round("rock!")
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/solutions/tests/test_tic_tac_toe_game.py b/solutions/tests/test_tic_tac_toe_game.py
new file mode 100644
index 000000000..ebd44f198
--- /dev/null
+++ b/solutions/tests/test_tic_tac_toe_game.py
@@ -0,0 +1,53 @@
+import unittest
+from unittest.mock import patch
+from io import StringIO
+import sys
+from pathlib import Path
+
+sys.path.append(str(Path(__file__).parent.parent))
+
+# Assume the main Tic-Tac-Toe functions are imported from the main file
+from tic_tac_toe_game import check_winner, is_full, tic_tac_toe
+
+
+class TestTicTacToe(unittest.TestCase):
+    def test_check_winner_rows(self):
+        board = [["X", "X", "X"], ["O", " ", "O"], [" ", " ", " "]]
+        self.assertEqual(check_winner(board), "X")
+
+    def test_check_winner_columns(self):
+        board = [["X", "O", " "], ["X", "O", " "], ["X", " ", " "]]
+        self.assertEqual(check_winner(board), "X")
+
+    def test_check_winner_diagonals(self):
+        board = [["X", "O", "O"], [" ", "X", " "], [" ", " ", "X"]]
+        self.assertEqual(check_winner(board), "X")
+
+    def test_is_full_true(self):
+        board = [["X", "O", "X"], ["O", "X", "O"], ["O", "X", "O"]]
+        self.assertTrue(is_full(board))
+
+    def test_is_full_false(self):
+        board = [["X", "O", "X"], ["O", " ", "O"], ["O", "X", "O"]]
+        self.assertFalse(is_full(board))
+
+    @patch("builtins.input", side_effect=["0 0", "0 1", "1 1", "0 2", "2 2"])
+    @patch("sys.stdout", new_callable=StringIO)
+    def test_tic_tac_toe_win(self, mock_stdout, mock_input):
+        tic_tac_toe()
+        output = mock_stdout.getvalue()
+        self.assertIn("Player X wins!", output)
+
+    @patch(
+        "builtins.input",
+        side_effect=["0 0", "0 1", "0 2", "1 1", "1 0", "1 2", "2 1", "2 0", "2 2"],
+    )
+    @patch("sys.stdout", new_callable=StringIO)
+    def test_tic_tac_toe_tie(self, mock_stdout, mock_input):
+        tic_tac_toe()
+        output = mock_stdout.getvalue()
+        self.assertIn("It's a tie!", output)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/solutions/tests/test_travel_planner_fun.py b/solutions/tests/test_travel_planner_fun.py
new file mode 100644
index 000000000..deb0925df
--- /dev/null
+++ b/solutions/tests/test_travel_planner_fun.py
@@ -0,0 +1,33 @@
+import unittest
+import sys
+from pathlib import Path
+
+sys.path.append(str(Path(__file__).parent.parent))
+from travel_planner_fun_solution import TravelPlanner
+
+
+class TestTravelPlanner(unittest.TestCase):
+    def setUp(self):
+        self.planner = TravelPlanner()
+
+    def test_generate_destination(self):
+        destination = self.planner.generate_destination()
+        self.assertIn(destination, self.planner.destinations)
+
+    def test_generate_activity(self):
+        activity = self.planner.generate_activity()
+        self.assertIn(activity, self.planner.activities)
+
+    def test_generate_travel_tip(self):
+        tip = self.planner.generate_travel_tip()
+        self.assertIn(tip, self.planner.tips)
+
+    def test_plan_trip(self):
+        trip = self.planner.plan_trip()
+        self.assertIn(trip["destination"], self.planner.destinations)
+        self.assertIn(trip["activity"], self.planner.activities)
+        self.assertIn(trip["tip"], self.planner.tips)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/solutions/tic_tac_toe_game.py b/solutions/tic_tac_toe_game.py
new file mode 100644
index 000000000..a214b119f
--- /dev/null
+++ b/solutions/tic_tac_toe_game.py
@@ -0,0 +1,78 @@
+def print_board(board):
+    for row in board:
+        print(" | ".join(row))
+        print("-" * 9)
+
+
+def check_winner(board):
+    # Check rows
+    for row in board:
+        if row[0] == row[1] == row[2] and row[0] != " ":
+            return row[0]
+
+    # Check columns
+    for col in range(3):
+        if board[0][col] == board[1][col] == board[2][col] and board[0][col] != " ":
+            return board[0][col]
+
+    # Check diagonals
+    if board[0][0] == board[1][1] == board[2][2] and board[0][0] != " ":
+        return board[0][0]
+    if board[0][2] == board[1][1] == board[2][0] and board[0][2] != " ":
+        return board[0][2]
+
+    return None
+
+
+def is_full(board):
+    return all(cell != " " for row in board for cell in row)
+
+
+def tic_tac_toe():
+    board = [[" " for _ in range(3)] for _ in range(3)]
+    players = ["X", "O"]
+    turn = 0
+
+    print("Welcome to Tic-Tac-Toe!")
+    print_board(board)
+
+    while True:
+        current_player = players[turn % 2]
+        print(f"Player {current_player}'s turn.")
+
+        try:
+            row, col = map(
+                int,
+                input(
+                    "Enter row and column (0, 1, or 2 separated by a space): "
+                ).split(),
+            )
+        except ValueError:
+            print("Invalid input. Please enter two numbers separated by a space.")
+            continue
+
+        if not (0 <= row < 3 and 0 <= col < 3):
+            print("Invalid position. Please enter numbers between 0 and 2.")
+            continue
+
+        if board[row][col] != " ":
+            print("Position already taken. Choose another.")
+            continue
+
+        board[row][col] = current_player
+        print_board(board)
+
+        winner = check_winner(board)
+        if winner:
+            print(f"Player {winner} wins!")
+            break
+
+        if is_full(board):
+            print("It's a tie!")
+            break
+
+        turn += 1
+
+
+if __name__ == "__main__":
+    tic_tac_toe()
diff --git a/solutions/travel_planner_fun_solution.py b/solutions/travel_planner_fun_solution.py
new file mode 100644
index 000000000..f5cfb0e53
--- /dev/null
+++ b/solutions/travel_planner_fun_solution.py
@@ -0,0 +1,77 @@
+import random
+from random import choice
+
+
+class TravelPlanner:
+    def __init__(self):
+        random.seed()
+        self.destinations = [
+            "Paris, France",
+            "Kyoto, Japan",
+            "Machu Picchu, Peru",
+            "Cape Town, South Africa",
+            "New York City, USA",
+            "Santorini, Greece",
+            "Cairo, Egypt",
+            "Sydney, Australia",
+            "Reykjavik, Iceland",
+            "Bali, Indonesia",
+        ]
+        self.activities = [
+            "exploring ancient ruins",
+            "dining at a Michelin-star restaurant",
+            "taking a hot air balloon ride",
+            "relaxing on a pristine beach",
+            "hiking through breathtaking trails",
+            "shopping in local markets",
+            "attending a cultural festival",
+            "snorkeling with vibrant marine life",
+            "enjoying a scenic train ride",
+            "visiting world-class museums",
+        ]
+        self.tips = [
+            "Always pack a portable charger!",
+            "Learn a few phrases in the local language to impress locals.",
+            "Carry a reusable water bottle to stay hydrated.",
+            "Don't forget travel insurance—it's a lifesaver!",
+            "Try street food—it's often the tastiest and cheapest option.",
+            "Keep a digital and physical copy of your passport.",
+            "Research local customs to avoid awkward situations.",
+            "Pack light—you'll thank yourself later.",
+            "Wake up early to enjoy tourist spots without crowds.",
+            "Always have some local currency on hand for small purchases.",
+        ]
+
+    def generate_destination(self):
+        return choice(self.destinations)
+
+    def generate_activity(self):
+        return choice(self.activities)
+
+    def generate_travel_tip(self):
+        return choice(self.tips)
+
+    def plan_trip(self):
+        destination = self.generate_destination()
+        activity = self.generate_activity()
+        tip = self.generate_travel_tip()
+
+        return {"destination": destination, "activity": activity, "tip": tip}
+
+
+def main():
+    print("Welcome to the Automated Travel Planner! \U0001f30d")
+    print("Sit back and relax while we plan your next dream trip.\n")
+
+    planner = TravelPlanner()
+    trip = planner.plan_trip()
+
+    print(f"\U0001f4cd Destination: {trip['destination']}")
+    print(f"\U0001f3c3 Activity: {trip['activity']}")
+    print(f"\U0001f4d6 Travel Tip: {trip['tip']}\n")
+
+    print("Your virtual getaway is ready! Safe travels! \U0001f30f")
+
+
+if __name__ == "__main__":
+    main()