diff --git a/.markdownlint.yml b/.markdownlint.yml
index ee6205f5c..b637e5b1d 100644
--- a/.markdownlint.yml
+++ b/.markdownlint.yml
@@ -1,3 +1,7 @@
 ignore:
   - venv
   - .github
+
+MD013:
+  line_length: 500
+  ignore_urls: true
diff --git a/.vscode/settings.json b/.vscode/settings.json
index 5a90e202f..87ad2d7d7 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -113,5 +113,14 @@
   },
 
   // Enable/disable update table of contents on save
-  "markdown.extension.toc.updateOnSave": false
+  "markdown.extension.toc.updateOnSave": false,
+  "cSpell.words": [
+    "Versity"
+  ],
+  "githubPullRequests.ignoredPullRequestBranches": [
+    "main"
+  ],
+  "[python]": {
+    "editor.defaultFormatter": "ms-python.black-formatter"
+  }
 }
diff --git a/README.md b/README.md
index e69de29bb..8605cf81e 100644
--- a/README.md
+++ b/README.md
@@ -0,0 +1,5 @@
+# PyVersity
+
+******
+
+welcome to Pyversity main repository
diff --git a/collaboration/README.md b/collaboration/README.md
index 20889b951..3cf130140 100644
--- a/collaboration/README.md
+++ b/collaboration/README.md
@@ -2,4 +2,53 @@
 
 <!-- group norms summary -->
 
+## Summary
+
+Our group values respect, collaboration, and inclusivity by fostering a safe space,
+valuing diverse perspectives,
+and being punctual and prepared. We follow standardized coding practices, ensure
+thorough testing,
+and use pull requests for repository management. Committed to learning and growth,
+we support each other, respond promptly to queries, and resolve conflicts fairly
+through voting.
+
 <!-- group norms list -->
+
+## Finalized Norms
+
+### Respect
+
+* Be respectful and considerate when providing feedback or suggestions.
+* We must communicate respectfully to build trust.
+* We will value each other's time by being prepared and punctual. (Waiting time
+for every meeting will be 5 minutes).
+* Respecting everyone’s cultural/emotional background.
+* We will value each other’s diverse perspectives and create a safe, collaborative
+space.
+
+### Standardization
+
+* Follow the agreed upon coding standards and guidelines (e.g., naming conventions,
+indentations, comments).
+* Provide descriptive commit messages summarizing the changes.
+* Perform testing when applicable and document any test cases; ensure all tests pass
+before creating or merging a pull request.
+* Never push directly to the main branch; always create a pull request.
+
+### Team’s Learning
+
+* Group members must think about the whole team’s improvement and practice good
+leadership.
+* We will actively assist and support each other to overcome challenges and
+achieve success together.
+
+### Availability
+
+* Respond to queries or comments within 24-48 hours whenever possible.
+* Every member should answer questions of the member asked on Slack or
+WhatsApp if they have the answer and do not leave it for others.
+
+### Conflict resolution
+
+* Every member will have equal rights. If there is any conflict, it should be
+resolved within the group through voting.
diff --git a/collaboration/communication.md b/collaboration/communication.md
index 484652e0f..85fa6acac 100644
--- a/collaboration/communication.md
+++ b/collaboration/communication.md
@@ -14,16 +14,26 @@ ______________________________________________________________________
 ## Communication Schedule
 
 | Day | How | The topic of discussion | | --- | :-: | ----------------------- |
-| | | |
+| 21st Dec | Zoom | How to proceed with the group project? |
+| 25th Dec | Zoom | Progress and Discussions on Solutions |
+| 7th Jan | Zoom | Finalization |
+| 8th Jan | Zoom | Merging |
 
 ## Communication Channels
 
-how often will we get in touch on each channel, and what we will discuss there:
+We shall have weekly/bi-weekly meetings on slcka/zoom to discuss any issues and progress.
 
 - **Issues**:
+<https://github.com/MIT-Emerging-Talent/ET6-foundations-group-29/issues/3>
+<https://github.com/MIT-Emerging-Talent/ET6-foundations-group-29/issues/10>
+<https://github.com/MIT-Emerging-Talent/ET6-foundations-group-29/issues/2>
+
 - **Pull Requests**:
-- **Slack/Discord**:
-- **Video Calls**:
+<https://github.com/MIT-Emerging-Talent/ET6-foundations-group-29/pull/9>
+<https://github.com/MIT-Emerging-Talent/ET6-foundations-group-29/pull/8>
+<https://github.com/MIT-Emerging-Talent/ET6-foundations-group-29/pull/7>
+<https://github.com/MIT-Emerging-Talent/ET6-foundations-group-29/pull/5>
+<https://github.com/MIT-Emerging-Talent/ET6-foundations-group-29/pull/1>
 
 ______________________________________________________________________
 
@@ -33,15 +43,21 @@ ______________________________________________________________________
 
 | Day | Monday | Tuesday | Wednesday | Thursday | Friday | Saturday | Sunday | |
 ------ | :----: | :-----: | :-------: | :------: | :----: | :------: | :----: |
-| _name_ | | | | | | | |
+| Muqaddas | No | No | No | No | Yes | No | Yes |
+| Nilofar | No | Yes | No | No | Yes | No | Yes |
+| Shagun | No | No | No | No | Yes | No | Yes |
+| Anik | No | No | No | No | Yes | No | Yes |
+| Momtaz | No | No | No | No | Yes | No | Yes |
+| M. Ahmed | No | No | No | No | Yes | No | Yes |
 
 ### How many hours everyone has per day
 
-- name: _5h_;
-- name: _6h_;
-- name: _5h_;
-- name: _4h_;
-- name: _3h_;
+- Muqaddas: _1.5h_;
+- Shagun: _2h_;
+- Nilofar: _2h_;
+- Anik: _2h_;
+- M. Ahmed: _2h_;
+- Momtaz: _2h_;
 
 ## Asking for Help
 
diff --git a/collaboration/constraints.md b/collaboration/constraints.md
index 24079505c..4921eb646 100644
--- a/collaboration/constraints.md
+++ b/collaboration/constraints.md
@@ -6,6 +6,8 @@ Some boundaries around our project.
 
 ## External
 
+The project must be completed by 8th Jan 2025.
+
 <!--
   constraints coming from the outside that your team has no control over:
   - project deadlines
@@ -17,6 +19,7 @@ Some boundaries around our project.
 
 ## Internal: Involuntary
 
+Team members have varying levels of experience with Python, requiring additional time for learning.
 <!--
   constraints that come from within your team, and you have no control over:
   - each of your individual skill levels
@@ -25,6 +28,9 @@ Some boundaries around our project.
 
 ## Internal: Voluntary
 
+Every pull request must pass a peer code review before merging.
+Agree to use GitHub for version control and task management.
+
 <!--
   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..53123b848 100644
--- a/collaboration/learning_goals.md
+++ b/collaboration/learning_goals.md
@@ -2,4 +2,22 @@
 
 ## Collective
 
+The collective learning goals for a beginner group learning Python include
+understanding basic syntax, data types, and control structures, along
+with practicing functions, loops, and error handling. Learners
+will also explore data structures, file handling, and an
+introduction to object-oriented programming to build a solid foundation for coding.
+
 ## Individual
+
+Muqaddas: To learn new data science skills.
+
+Nilofar: To learn about github and how the coding collaboration works.
+
+Shagun: To learn how to effectively collaborate and documentation.
+
+Anik: To learn unit testing and predictive testing.
+
+Momtaz: Learning how to collaborate as a team, working on the same project together.
+
+M. Ahmed: To learn how to use GitHub as a team.
diff --git a/collaboration/retrospective.md b/collaboration/retrospective.md
index 74e18813b..d8422aa30 100644
--- a/collaboration/retrospective.md
+++ b/collaboration/retrospective.md
@@ -4,20 +4,63 @@
 
 ## Stop Doing
 
+Spending too much time trying to figure
+things out on my own without asking for help sooner.
+Overthinking small tasks instead of
+just starting and learning along the way.
+
 ## Continue Doing
 
+Working step by step and focusing on
+one part of the task at a time.
+Asking my teammates for advice and
+reviewing their work to learn from them.
+Using GitHub features like branches
+and pull requests to stay organized.
+
 ## Start Doing
 
+Practicing math and coding challenges
+more often so I can solve them faster in the future.
+Writing down notes about what I’m
+learning so I can remember it for next time.
+Paying more attention to small
+details in documentation and instructions.
+
 ## Lessons Learned
 
+I realized that working in a team
+helps a lot, especially when I don’t know something.
+GitHub tools like pull requests and
+labels are very useful once you understand how to use them.
+Breaking the project into small steps
+makes everything easier and less stressful.
+
 ______________________________________________________________________
 
 ## Strategy vs. Board
 
 ### What parts of your plan went as expected?
 
+I was able to clone the repository,
+create my branch, and push my code.
+Submitting a pull request and reviewing
+others’ work was smooth and worked as planned.
+
 ### What parts of your plan did not work out?
 
+Some of the math problems were harder than
+I expected, and I had to spend extra time on them.
+I didn’t fully understand the CI checks at
+first, so fixing errors took more time.
+
 ### Did you need to add things that weren't in your strategy?
 
+Yes, I had to look up tutorials on GitHub
+features like labeling pull requests and managing CI errors.
+
 ### Or remove extra steps?
+
+I simplified things by focusing only on the steps
+needed to complete the assignment and skipping
+any unnecessary experiments with GitHub.
diff --git a/solutions/SumList.py b/solutions/SumList.py
new file mode 100644
index 000000000..6d914df98
--- /dev/null
+++ b/solutions/SumList.py
@@ -0,0 +1,26 @@
+"""
+Author: @arvidon
+Created on: jan 7 2025.
+"""
+
+
+def SumList(numbers):
+    """
+    The SumList function takes a list of numbers as input and returns the sum of all the elements in the list.
+    It utilizes Python's built-in sum() function to calculate the sum of the numbers.
+
+    PARAMETERS:
+    numbers (List of int or float): A list containing numerical values (either integers or floating-point numbers)
+    that need to be summed up.
+
+    RETURN VALUES:
+    int or float: The sum of the values in the numbers list. The return type will depend on the types of numbers in the list.
+    """
+    # Return the sum of all numbers in the list
+    return sum(numbers)
+
+
+# Example usage
+numbers = [1, 2, 3, 4, 5]
+result = SumList(numbers)
+print(f"The sum of the list is: {result}")
diff --git a/solutions/__init__.py b/solutions/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/solutions/add_numbers.py b/solutions/add_numbers.py
new file mode 100644
index 000000000..9d66c6fc6
--- /dev/null
+++ b/solutions/add_numbers.py
@@ -0,0 +1,25 @@
+"""
+A module for adding two numbers
+
+Created on 11 1 2025
+@author: momtaz-yaqubi
+"""
+
+
+def add_numbers(a, b):
+    """
+    Adds two numbers together.
+
+    Parameters:
+        a (int, float): The first number to add.
+        b (int, float): The second number to add.
+
+    Returns:
+        int, float: The result of adding `a` and `b`.
+
+    Raises:
+        TypeError: If either `a` or `b` is not a number.
+    """
+    if not isinstance(a, (int, float)) or not isinstance(b, (int, float)):
+        raise TypeError("Both arguments must be numbers")
+    return a + b
diff --git a/solutions/arith_prog.py b/solutions/arith_prog.py
new file mode 100644
index 000000000..a75602ab7
--- /dev/null
+++ b/solutions/arith_prog.py
@@ -0,0 +1,53 @@
+"""
+A module that that generates an arithmetic progression (AP).
+
+Module contents:
+  - generate_arithmetic_progression generates an arithmetic progression
+
+Created on 11/25/2024
+@author: Anik Kumar Adhikary
+"""
+
+
+def generate_arithmetic_progression(start, difference, terms):
+    """
+    It generates an arithmetic progression given a start value,
+    a difference, and the number of terms.
+
+    Parameters:
+    - start (int/float): The first term of the AP.
+    - difference (int/float): The common difference between terms.
+    - terms (int): The number of terms to generate.
+
+    Returns:
+    - list: A list containing the arithmetic progression
+
+    Example:
+    >>> generate_arithmetic_progression(2, 3, 5)
+    [2,5,8,11,14]
+
+    Explanation:
+    start = 2
+
+    difference = 3
+
+    terms = 5
+
+    The range generates the sequence 0, 1, 2, 3, 4.
+
+    For each value of i, we calculate start + i * difference:
+
+    For i = 0: 2 + 0 * 3 = 2
+    For i = 1: 2 + 1 * 3 = 5
+    For i = 2: 2 + 2 * 3 = 8
+    For i = 3: 2 + 3 * 3 = 11
+    For i = 4: 2 + 4 * 3 = 14
+
+    The result is [2, 5, 8, 11, 14], and this is returned by the function
+    """
+    # A concise way to create a list in Python
+    return [start + i * difference for i in range(terms)]
+
+
+# Expression: start + i * difference; gives the value of the nth term, starting from the first term
+# Iteration: for i in range(terms); generates a sequence of numbers from 0 to terms-1
diff --git a/solutions/bank.py b/solutions/bank.py
new file mode 100644
index 000000000..970cafa37
--- /dev/null
+++ b/solutions/bank.py
@@ -0,0 +1,79 @@
+"""
+A module for checking the value of a greeting.
+
+Module contents:
+    - main: Gets user input and prints the value based on the greeting.
+    - value: Determines the value of the greeting based on certain conditions.
+Created on: 1st Jan 2025
+@author: arvidon
+
+"""
+
+
+def main():
+    """
+    Main function to get user input and print the value based on the greeting.
+
+    This function prompts the user for a greeting and then determines and prints
+    the value associated with that greeting using the `value` function.
+
+    Created on 28-12-2024
+    Author: Arvidon
+
+    Examples:
+        >>> main()
+        Greetings: hello
+        0
+        >>> main()
+        Greetings: hi
+        20
+        >>> main()
+        Greetings: hey
+        20
+    """
+    greeting: str = input("Greetings: ")  # Get user input as a string
+    print(value(greeting))  # Call the value function and print its result
+
+
+def value(greeting: str) -> int:
+    """
+    Determine the value of a greeting based on certain conditions.
+
+    This function returns an integer value based on the provided greeting. If
+    the greeting contains the word "hello", the value is 0. If the first
+    character of the greeting is "h", the value is 20. Otherwise, the value
+    is 100.
+
+    Parameters:
+        greeting (str): The greeting input by the user.
+
+    Returns:
+        int: The value of the greeting based on specific conditions.
+            - 0 if "hello" is in the greeting.
+            - 20 if the first character of the greeting is "h".
+            - 100 for all other cases.
+
+    Examples:
+        >>> value("hello")
+        0
+        >>> value("hi")
+        20
+        >>> value("hey")
+        20
+        >>> value("goodbye")
+        100
+    """
+    greeting = (
+        greeting.lower()
+    )  # Convert the greeting to lowercase for case-insensitivity
+
+    if "hello" in greeting:
+        return 0
+    elif greeting[0] == "h":  # Check if the first character is 'h'
+        return 20
+    else:
+        return 100
+
+
+if __name__ == "__main__":
+    main()
diff --git a/solutions/bmi_calculator.py b/solutions/bmi_calculator.py
new file mode 100644
index 000000000..ca6f4c6e2
--- /dev/null
+++ b/solutions/bmi_calculator.py
@@ -0,0 +1,21 @@
+def calculate_bmi(weight, height):
+    """
+    This function calculates the Body Mass Index (BMI) based on weight (in kilograms)
+    and height (in meters).
+    :param weight: float
+    :param height: float
+    :return: str
+    """
+    if height <= 0 or weight <= 0:
+        return "Invalid input. Height and weight must be greater than zero."
+
+    bmi = weight / (height**2)
+
+    if bmi < 18.5:
+        return f"Underweight (BMI: {bmi:.2f})"
+    elif 18.5 <= bmi < 24.9:
+        return f"Normal weight (BMI: {bmi:.2f})"
+    elif 25 <= bmi < 29.9:
+        return f"Overweight (BMI: {bmi:.2f})"
+    else:
+        return f"Obesity (BMI: {bmi:.2f})"
diff --git a/solutions/find_largest_number.py b/solutions/find_largest_number.py
new file mode 100644
index 000000000..7a96f94f7
--- /dev/null
+++ b/solutions/find_largest_number.py
@@ -0,0 +1,11 @@
+"""Function to Find the Largest Number
+@author: msrak
+"""
+
+
+def largest_number(numbers):
+    return max(numbers)
+
+
+numbers = [1, 2, 3, 4, 21, 12, 8]
+print(f"This is the largest number {largest_number(numbers)}")
diff --git a/solutions/is_fibonacci.py b/solutions/is_fibonacci.py
new file mode 100644
index 000000000..3a1e8bdd4
--- /dev/null
+++ b/solutions/is_fibonacci.py
@@ -0,0 +1,35 @@
+"""
+A module that that generates an arithmetic progression (AP).
+
+Module contents:
+  - generate_arithmetic_progression generates an arithmetic progression
+
+Created on 01/09/2025
+@author: Anik Kumar Adhikary
+"""
+
+import math
+
+
+def is_fibonacci_number(n: int) -> bool:
+    """
+    Checks whether a given number is a Fibonacci number.
+
+    A number is a Fibonacci number if and only if one or both of
+    (5 * n^2 + 4) or (5 * n^2 - 4) is a perfect square.
+
+    Args:
+        n (int): The number to check.
+
+    Returns:
+        bool: True if the number is a Fibonacci number, False otherwise.
+    """
+    if n < 0:
+        return False
+
+    def is_perfect_square(x: int) -> bool:
+        s = int(math.sqrt(x))
+        return s * s == x
+
+    # Check both conditions
+    return is_perfect_square(5 * n * n + 4) or is_perfect_square(5 * n * n - 4)
diff --git a/solutions/is_palindrome.py b/solutions/is_palindrome.py
new file mode 100644
index 000000000..3e103910a
--- /dev/null
+++ b/solutions/is_palindrome.py
@@ -0,0 +1,36 @@
+"""
+A module for checking if a string is a palindrome.
+
+Module contents:
+    - is_palindrome: checks whether a string is a palindrome.
+
+Created on 27 12 2024
+@author: muqaddas96
+"""
+
+
+def is_palindrome(text: str) -> bool:
+    """Check if a string is a palindrome.
+
+    Parameters:
+        text: str, the input string to check
+
+    Returns -> bool: True if the text is a palindrome, False otherwise
+
+    Raises:
+        AssertionError: if the argument is not a string
+
+    >>> is_palindrome("racecar")
+    True
+    >>> is_palindrome("hello")
+    False
+    >>> is_palindrome("A man a plan a canal Panama")
+    True
+    """
+    assert isinstance(text, str), "input must be a string"
+
+    # Remove spaces and convert to lowercase
+    normalized_text = "".join(text.split()).lower()
+
+    # Check if it reads the same forward and backward
+    return normalized_text == normalized_text[::-1]
diff --git a/solutions/missing_number.py b/solutions/missing_number.py
new file mode 100644
index 000000000..8d9efd224
--- /dev/null
+++ b/solutions/missing_number.py
@@ -0,0 +1,41 @@
+"""
+A module to find the missing number from a range of numbers.
+
+Module contents:
+    - find_missing_number: returns the missing number from the given array.
+
+Created on 11th Jan 2025
+@author: muqaddas96
+"""
+
+
+def missing_number(nums: list[int]) -> int:
+    """Find the missing number from an array of distinct integers.
+
+    Parameters:
+        nums (list[int]): List of integers from the range 0 to n.
+
+    Returns:
+        int: The missing number.
+
+    Raises:
+        AssertionError: If nums is not a list or contains invalid values.
+
+    Examples:
+    >>> find_missing_number([3, 0, 1])
+    2
+    >>> find_missing_number([0, 1])
+    2
+    >>> find_missing_number([9,6,4,2,3,5,7,0,1])
+    8
+    >>> find_missing_number([0])
+    1
+    """
+    assert isinstance(nums, list), "Input must be a list."
+    assert all(isinstance(num, int) for num in nums), "List elements must be integers."
+    assert len(nums) == len(set(nums)), "List must contain distinct integers."
+
+    n = len(nums)
+    expected_sum = n * (n + 1) // 2  # Sum of 0 to n
+    actual_sum = sum(nums)
+    return expected_sum - actual_sum
diff --git a/solutions/plates.py b/solutions/plates.py
new file mode 100644
index 000000000..98435105c
--- /dev/null
+++ b/solutions/plates.py
@@ -0,0 +1,72 @@
+def main():
+    """
+
+    Created On: 2025-01-01
+    Author: @arvidon
+
+
+    Main function that takes user input and checks if the input is a valid license plate.
+    It calls the `is_valid` function to determine whether the provided text follows the required format.
+
+    The format is:
+    - Must start with at least two letters.
+    - Length of the plate should be between 2 and 6 characters.
+    - No numbers in between the plate, and the first number must not be '0'.
+    - The plate must be alphanumeric.
+    """
+    # Prompt the user to input a license plate string
+    text = input("Text: ")
+
+    # Check if the license plate string is valid
+    if is_valid(text):
+        print("True")
+    else:
+        print("False")
+
+
+def is_valid(s):
+    """
+    Validates a license plate string based on several conditions:
+    1. The plate must start with at least two letters.
+    2. The length of the plate must be between 2 and 6 characters.
+    3. The first number (if any) must not be '0'.
+    4. Numbers should not appear between letters.
+    5. The plate should only contain alphanumeric characters (letters and numbers).
+
+    Args:
+        s (str): The license plate string to be validated.
+
+    Returns:
+        bool: True if the plate is valid, False otherwise.
+    """
+    # Plates should start with at least two letters
+    if len(s) < 2 or not s[:2].isalpha():
+        return False
+
+    # The length of the plate should be between 2 and 6 characters
+    if len(s) < 2 or len(s) > 6:
+        return False
+
+    # The first number (if any) should not be 0, and there should be no numbers in between
+    temp = 0
+    for i in range(3):
+        if s[(len(s) - 1) - i].isalpha():
+            if s[(len(s) - i - 1) - 1].isnumeric():
+                temp += 1
+    if temp > 0:
+        return False
+    if temp == 0:
+        for j in range(len(s) - 1):
+            if s[j].isalpha():
+                if s[j + 1] == "0":
+                    return False
+
+    # The plate should contain only alphanumeric characters
+    if not s.isalnum():
+        return False
+
+    return True
+
+
+if __name__ == "__main__":
+    main()
diff --git a/solutions/reverse.py b/solutions/reverse.py
new file mode 100644
index 000000000..fed39c714
--- /dev/null
+++ b/solutions/reverse.py
@@ -0,0 +1,19 @@
+"""
+A function that reverses a string
+
+Created on 11 1 2025
+@author: momtaz-yaqubi
+"""
+
+
+def reverse_string(s: str) -> str:
+    """
+    Reverses the given string.
+
+    Args:
+    s (str): The input string to be reversed.
+
+    Returns:
+    str: The reversed string.
+    """
+    return s[::-1]
diff --git a/solutions/tests/__init__.py b/solutions/tests/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/solutions/tests/nilofar_solution.py b/solutions/tests/nilofar_solution.py
new file mode 100644
index 000000000..cfb0f6715
--- /dev/null
+++ b/solutions/tests/nilofar_solution.py
@@ -0,0 +1,63 @@
+"""
+nilfersolution.py
+
+Solution for BMI calculation.
+
+This script defines the `calculate_bmi` function, which calculates the Body Mass Index (BMI)
+given weight (in kilograms) and height (in meters). It also categorizes the BMI into one of
+the following categories:
+- Underweight
+- Normal weight
+- Overweight
+- Obesity
+
+Author: [Your Name]
+Date: [Today's Date]
+"""
+
+
+def calculate_bmi(weight, height):
+    """
+    Calculate the Body Mass Index (BMI) and categorize it.
+
+    Args:
+        weight (float): The weight of the person in kilograms.
+        height (float): The height of the person in meters.
+
+    Returns:
+        str: A message indicating the BMI value and its category.
+             Returns an error message for invalid input.
+
+    Examples:
+        >>> calculate_bmi(45, 1.7)
+        'Underweight (BMI: 15.57)'
+        >>> calculate_bmi(68, 1.75)
+        'Normal weight (BMI: 22.20)'
+        >>> calculate_bmi(-45, 1.7)
+        'Invalid input. Height and weight must be greater than zero.'
+    """
+    # Validate input: weight and height must be positive
+    if weight <= 0 or height <= 0:
+        return "Invalid input. Height and weight must be greater than zero."
+
+    # Calculate BMI
+    bmi = weight / (height**2)
+
+    # Determine BMI category
+    if bmi < 18.5:
+        category = "Underweight"
+    elif 18.5 <= bmi < 24.9:
+        category = "Normal weight"
+    elif 25 <= bmi < 29.9:
+        category = "Overweight"
+    else:
+        category = "Obesity"
+
+    # Format BMI to two decimal places
+    return f"{category} (BMI: {bmi:.2f})"
+
+
+# Example usage (uncomment the following lines to test):
+# print(calculate_bmi(45, 1.7))  # Output: 'Underweight (BMI: 15.57)'
+# print(calculate_bmi(68, 1.75))  # Output: 'Normal weight (BMI: 22.20)'
+# print(calculate_bmi(-45, 1.7))  # Output: 'Invalid input. Height and weight must be greater than zero.'
diff --git a/solutions/tests/test_SumList.py b/solutions/tests/test_SumList.py
new file mode 100644
index 000000000..7cf18fd5d
--- /dev/null
+++ b/solutions/tests/test_SumList.py
@@ -0,0 +1,15 @@
+from solutions.SumList import SumList
+
+
+def test_SumList() -> None:
+    """
+    Tests the many CornerCases of the SumList function including negative integers,
+    empty list, floats, zero at the beginning, single two digit number.
+    """
+    assert SumList([1, 2, 3, 4, 5]) == 15
+    assert SumList([10]) == 10
+    assert SumList([-1, -2, -3, -4, -5]) == -15
+    assert SumList([1.5, 2.5, 3.0]) == 7.0
+    assert SumList([1, 2.5, -3, 4.5]) == 5.0
+    assert SumList([0, 1, 2, 3]) == 6
+    assert SumList([]) == 0
diff --git a/solutions/tests/test_add_numbers.py b/solutions/tests/test_add_numbers.py
new file mode 100644
index 000000000..aa6a2a289
--- /dev/null
+++ b/solutions/tests/test_add_numbers.py
@@ -0,0 +1,37 @@
+import unittest
+from solutions.add_numbers import add_numbers
+
+
+class TestAddNumbers(unittest.TestCase):
+    """class of test cases"""
+
+    def test_add_positive_numbers(self):
+        """
+        Test adding two positive numbers.
+
+        This test ensures that the function correctly adds two positive integers
+        and returns the expected result.
+        """
+        self.assertEqual(add_numbers(2, 3), 5)
+
+    def test_add_negative_numbers(self):
+        """
+        Test adding two negative numbers.
+
+        This test checks that the function handles negative numbers correctly
+        and returns the correct sum.
+        """
+        self.assertEqual(add_numbers(-1, -1), -2)
+
+    def test_add_zero(self):
+        """
+        Test adding two zero values.
+
+        This test confirms that the function returns zero when both inputs
+        are zero.
+        """
+        self.assertEqual(add_numbers(0, 0), 0)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/solutions/tests/test_arith_prog.py b/solutions/tests/test_arith_prog.py
new file mode 100644
index 000000000..a62acb82a
--- /dev/null
+++ b/solutions/tests/test_arith_prog.py
@@ -0,0 +1,38 @@
+"""unittest code verifies the behavior of the function generate_arithmetic_progression"""
+
+import unittest
+
+from solutions.arith_prog import generate_arithmetic_progression
+
+
+class TestArithmeticProgression(unittest.TestCase):
+    """To test the function generate_arithmetic_progression"""
+
+    def test_positive_difference(self):
+        """Tests a common positive difference with multiple terms"""
+        result = generate_arithmetic_progression(2, 3, 5)
+        self.assertEqual(result, [2, 5, 8, 11, 14])
+
+    def test_negative_difference(self):
+        """Tests a negative common difference"""
+        result = generate_arithmetic_progression(10, -2, 5)
+        self.assertEqual(result, [10, 8, 6, 4, 2])
+
+    def test_zero_difference(self):
+        """Checks if the function handles a zero difference correctly"""
+        result = generate_arithmetic_progression(7, 0, 4)
+        self.assertEqual(result, [7, 7, 7, 7])
+
+    def test_float_values(self):
+        """Ensures the function works with floating-point values"""
+        result = generate_arithmetic_progression(1.5, 0.5, 4)
+        self.assertEqual(result, [1.5, 2.0, 2.5, 3.0])
+
+    def test_no_terms(self):
+        """Checks the behavior when the number of terms is zero"""
+        result = generate_arithmetic_progression(3, 2, 0)
+        self.assertEqual(result, [])
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/solutions/tests/test_bank.py b/solutions/tests/test_bank.py
new file mode 100644
index 000000000..de63dbc1d
--- /dev/null
+++ b/solutions/tests/test_bank.py
@@ -0,0 +1,32 @@
+from solutions.bank import value
+
+
+def test_hello() -> None:
+    """
+    Test the 'value' function with the input 'hello' and 'HELLO'.
+
+    This test verifies that both lowercase and uppercase 'hello' return the expected
+    value of 0.
+    """
+    assert value("hello") == 0  # 'hello' should return 0
+    assert value("HELLO") == 0  # 'HELLO' should return 0, case-insensitive
+
+
+def test_h() -> None:
+    """
+    Test the 'value' function with the input 'hippy'.
+
+    This test checks that the word 'hippy' returns the correct value of 20.
+    """
+    assert value("hippy") == 20  # 'hippy' should return 20
+
+
+def test_something() -> None:
+    """
+    Test the 'value' function with the input 'bank' and 'jungkook'.
+
+    This test verifies that the words 'bank' and 'jungkook' both return the expected
+    value of 100.
+    """
+    assert value("bank") == 100  # 'bank' should return 100
+    assert value("jungkook") == 100  # 'jungkook' should return 100
diff --git a/solutions/tests/test_bmi_calculator.py b/solutions/tests/test_bmi_calculator.py
new file mode 100644
index 000000000..eb68b5e32
--- /dev/null
+++ b/solutions/tests/test_bmi_calculator.py
@@ -0,0 +1,77 @@
+"""
+test_nikzad_bmi.py
+
+Unit tests for the BMI calculation function `calculate_bmi` from `nilfersolution`.
+
+This script uses the `unittest` framework to validate the correctness of the
+BMI calculation function across different scenarios, including:
+- Underweight
+- Normal weight
+- Overweight
+- Obesity
+- Invalid inputs
+
+Author: (Nilofar Nikzad)
+Date: [Jan 12,2025]
+"""
+
+import unittest
+from solutions.bmi_calculator import (
+    calculate_bmi,
+)  # Import the function from the solution file
+
+
+class TestBMICalculator(unittest.TestCase):
+    """
+    Unit test class for testing the `calculate_bmi` function.
+    """
+
+    def test_underweight(self):
+        """
+        Test case for the underweight category.
+        """
+        result = calculate_bmi(45, 1.7)
+        self.assertEqual(result, "Underweight (BMI: 15.57)")
+
+    def test_normal_weight(self):
+        """
+        Test case for the normal weight category.
+        """
+        result = calculate_bmi(68, 1.75)
+        self.assertEqual(result, "Normal weight (BMI: 22.20)")
+
+    def test_overweight(self):
+        """
+        Test case for the overweight category.
+        """
+        result = calculate_bmi(80, 1.7)
+        self.assertEqual(result, "Overweight (BMI: 27.68)")
+
+    def test_obesity(self):
+        """
+        Test case for the obesity category.
+        """
+        result = calculate_bmi(95, 1.6)
+        self.assertEqual(result, "Obesity (BMI: 37.11)")
+
+    def test_invalid_input(self):
+        """
+        Test cases for invalid input scenarios.
+        The function should return an appropriate error message
+        when height or weight is less than or equal to zero.
+        """
+        result_negative_weight = calculate_bmi(-45, 1.7)
+        self.assertEqual(
+            result_negative_weight,
+            "Invalid input. Height and weight must be greater than zero.",
+        )
+
+        result_zero_height = calculate_bmi(50, 0)
+        self.assertEqual(
+            result_zero_height,
+            "Invalid input. Height and weight must be greater than zero.",
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/solutions/tests/test_is_fibonacci.py b/solutions/tests/test_is_fibonacci.py
new file mode 100644
index 000000000..5c4fdcbcc
--- /dev/null
+++ b/solutions/tests/test_is_fibonacci.py
@@ -0,0 +1,56 @@
+"""unittest code verifies the behavior of is_fibonacci_number to
+check whether a number is fibonaaci number or not"""
+
+import unittest
+
+from solutions.is_fibonacci import is_fibonacci_number
+
+
+class TestIsFibonacciNumber(unittest.TestCase):
+    """Test the is_fibonacci_number function"""
+
+    def test_fibonacci_numbers(self):
+        """Test known Fibonacci numbers"""
+        self.assertTrue(is_fibonacci_number(0))
+        self.assertTrue(is_fibonacci_number(1))
+        self.assertTrue(is_fibonacci_number(2))
+        self.assertTrue(is_fibonacci_number(3))
+        self.assertTrue(is_fibonacci_number(5))
+        self.assertTrue(is_fibonacci_number(8))
+        self.assertTrue(is_fibonacci_number(13))
+        self.assertTrue(is_fibonacci_number(21))
+        self.assertTrue(is_fibonacci_number(34))
+        self.assertTrue(is_fibonacci_number(144))
+
+    def test_non_fibonacci_numbers(self):
+        """Test non-Fibonacci numbers"""
+        # Test non-Fibonacci numbers
+        self.assertFalse(is_fibonacci_number(4))
+        self.assertFalse(is_fibonacci_number(6))
+        self.assertFalse(is_fibonacci_number(7))
+        self.assertFalse(is_fibonacci_number(9))
+        self.assertFalse(is_fibonacci_number(10))
+        self.assertFalse(is_fibonacci_number(11))
+        self.assertFalse(is_fibonacci_number(15))
+        self.assertFalse(is_fibonacci_number(20))
+
+    def test_negative_numbers(self):
+        """Test negative numbers"""
+        self.assertFalse(is_fibonacci_number(-1))
+        self.assertFalse(is_fibonacci_number(-5))
+        self.assertFalse(is_fibonacci_number(-8))
+
+    def test_large_fibonacci_numbers(self):
+        """Test larger Fibonacci numbers"""
+        # Test larger Fibonacci numbers
+        self.assertTrue(is_fibonacci_number(233))
+        self.assertTrue(is_fibonacci_number(377))
+
+    def test_large_non_fibonacci_numbers(self):
+        """Test larger non-Fibonacci numbers"""
+        self.assertFalse(is_fibonacci_number(300))
+        self.assertFalse(is_fibonacci_number(400))
+
+
+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..8954398e8
--- /dev/null
+++ b/solutions/tests/test_is_palindrome.py
@@ -0,0 +1,39 @@
+import unittest
+from solutions.is_palindrome import is_palindrome
+
+
+class TestIsPalindrome(unittest.TestCase):
+    """Test the is_palindrome function"""
+
+    def test_empty_string(self):
+        """It should return True for an empty string"""
+        self.assertTrue(is_palindrome(""))
+
+    def test_single_character(self):
+        """It should return True for a single character"""
+        self.assertTrue(is_palindrome("a"))
+
+    def test_palindrome(self):
+        """It should return True for a valid palindrome"""
+        self.assertTrue(is_palindrome("racecar"))
+
+    def test_non_palindrome(self):
+        """It should return False for a non-palindrome"""
+        self.assertFalse(is_palindrome("hello"))
+
+    def test_palindrome_with_spaces(self):
+        """It should ignore spaces and check for palindrome"""
+        self.assertTrue(is_palindrome("A man a plan a canal Panama"))
+
+    def test_palindrome_with_mixed_case(self):
+        """It should ignore case and check for palindrome"""
+        self.assertTrue(is_palindrome("RaceCar"))
+
+    def test_not_string(self):
+        """It should raise AssertionError for non-string input"""
+        with self.assertRaises(AssertionError):
+            is_palindrome(123)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/solutions/tests/test_missing_number.py b/solutions/tests/test_missing_number.py
new file mode 100644
index 000000000..cd3a42381
--- /dev/null
+++ b/solutions/tests/test_missing_number.py
@@ -0,0 +1,62 @@
+import unittest
+from solutions.missing_number import missing_number
+
+
+class TestMissingNumber(unittest.TestCase):
+    """
+    Test cases for the `missing_number` function, which finds the missing number
+    in an array of distinct integers ranging from 0 to n.
+    """
+
+    def test_single_missing_number(self):
+        """
+        Test a case where the input array has a single missing number.
+        Example: Input [3, 0, 1] should return 2.
+        """
+        self.assertEqual(missing_number([3, 0, 1]), 2)
+
+    def test_missing_last_number(self):
+        """
+        Test a case where the last number in the range is missing.
+        Example: Input [0, 1, 2] should return 3.
+        """
+        self.assertEqual(missing_number([0, 1, 2]), 3)
+
+    def test_missing_first_number(self):
+        """
+        Test a case where the first number in the range is missing.
+        Example: Input [1, 2] should return 0.
+        """
+        self.assertEqual(missing_number([1, 2]), 0)
+
+    def test_empty_array(self):
+        """
+        Test the edge case where the input array is empty.
+        Example: Input [] should return 0.
+        """
+        self.assertEqual(missing_number([]), 0)
+
+    def test_large_array(self):
+        """
+        Test a case with a larger array to ensure the function works with big inputs.
+        Example: Input [0, 1, 3, 4] should return 2.
+        """
+        self.assertEqual(missing_number([0, 1, 3, 4]), 2)
+
+    def test_single_element_zero(self):
+        """
+        Test a single-element array where the only element is 0.
+        Example: Input [0] should return 1.
+        """
+        self.assertEqual(missing_number([0]), 1)
+
+    def test_single_element_one(self):
+        """
+        Test a single-element array where the only element is 1.
+        Example: Input [1] should return 0.
+        """
+        self.assertEqual(missing_number([1]), 0)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/solutions/tests/test_plates.py b/solutions/tests/test_plates.py
new file mode 100644
index 000000000..85da75a23
--- /dev/null
+++ b/solutions/tests/test_plates.py
@@ -0,0 +1,58 @@
+from solutions.plates import is_valid
+
+
+def test_normal():
+    """
+    Test case for valid license plates
+    """
+    assert (
+        is_valid("CS50") is True
+    )  # Starts with two letters, followed by numbers, valid format
+    assert is_valid("JK") is True  # Only two letters, valid format
+
+
+def test_len():
+    """
+    Test case for invalid license plates that exceed the length limit.
+    """
+    assert is_valid("whatisthis") is False  # Plate exceeds 6 characters, invalid
+
+
+def test_zero_between():
+    """
+    Test cases where numbers (particularly '0') appear inappropriately between letters.
+    """
+    assert is_valid("hi0012") is False  # '0' appears in between letters, invalid
+    assert is_valid("xz4yz0") is False  # '0' appears after letters, invalid
+
+
+def test_capital():
+    """
+    Test cases for valid license plates with uppercase letters and numbers.
+    """
+    assert is_valid("AB1900") is True  # Starts with letters, then numbers, valid format
+    assert is_valid("COOKIE") is True  # Only letters, valid format
+
+
+def test_firstnum_zero():
+    """
+    Test case where the first number is '0', which is invalid.
+    """
+    assert is_valid("0CS90") is False  # Starts with '0', invalid
+
+
+def test_no_punctuation():
+    """
+    Test cases where the plate includes invalid punctuation characters.
+    """
+    assert is_valid("xx,.&!") is False  # Contains punctuation, invalid
+    assert is_valid(".kook12!") is False  # Contains punctuation, invalid
+
+
+def test_first_two_alpha():
+    """
+    Test cases where the first two characters are not letters or are invalid.
+    """
+    assert is_valid("s1hag") is False  # First character is a number, invalid
+    assert is_valid("00nod") is False  # Starts with '0', invalid
+    assert is_valid("8805") is False  # Does not start with letters, invalid
diff --git a/solutions/tests/test_reverse.py b/solutions/tests/test_reverse.py
new file mode 100644
index 000000000..040b13e51
--- /dev/null
+++ b/solutions/tests/test_reverse.py
@@ -0,0 +1,33 @@
+import unittest
+from solutions.reverse import reverse_string
+
+
+class TestReverseString(unittest.TestCase):
+    """
+    Test class for the reverse_string function.
+    This class contains test cases to validate the functionality of the reverse_string function.
+    """
+
+    def test_reverse_basic(self):
+        """
+        Test case for a basic string reversal.
+        """
+        self.assertEqual(reverse_string("hello"), "olleh")
+
+    def test_reverse_empty(self):
+        """
+        Test case for an empty string.
+        The expected output is an empty string.
+        """
+        self.assertEqual(reverse_string(""), "")
+
+    def test_reverse_single_character(self):
+        """
+        Test case for a string with a single character.
+        The expected output is the same single character.
+        """
+        self.assertEqual(reverse_string("a"), "a")
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/solutions/tests/test_water_intake_solution.py b/solutions/tests/test_water_intake_solution.py
new file mode 100644
index 000000000..45fd15810
--- /dev/null
+++ b/solutions/tests/test_water_intake_solution.py
@@ -0,0 +1,27 @@
+import unittest
+from solutions.water_intake_solution import calculate_water_intake
+
+
+class TestWaterIntakeCalculator(unittest.TestCase):
+    """To test the calculate_water_intake function."""
+
+    def test_low_activity_temperate(self):
+        """Test for low activity in temperate climate."""
+        self.assertEqual(
+            calculate_water_intake(70, 30),
+            "Recommended daily water intake: 2.67 liters",
+        )
+
+    def test_moderate_activity_hot(self):
+        """Test for moderate activity in hot climate."""
+        self.assertEqual(
+            calculate_water_intake(50, 60),
+            "Recommended daily water intake: 2.37 liters",
+        )
+
+    def test_invalid_weight(self):
+        """Test for invalid weight input."""
+        self.assertEqual(
+            calculate_water_intake(-70, 30),
+            "Invalid input. Weight and activity minutes must be greater than zero.",
+        )
diff --git a/solutions/water_intake_solution.py b/solutions/water_intake_solution.py
new file mode 100644
index 000000000..94786f175
--- /dev/null
+++ b/solutions/water_intake_solution.py
@@ -0,0 +1,55 @@
+"""
+water_solution.py
+
+Solution for determining daily water intake based on weight and activity level.
+
+This script defines the calculate_water_intake function, which calculates the recommended daily
+water intake in liters for a person based on their weight (in kilograms) and activity level (in minutes).
+The function adjusts water intake based on exercise time.
+
+Author: Nilofar Nikzad
+Date: January 12, 2025
+"""
+
+
+def calculate_water_intake(weight, activity_minutes):
+    """
+    Calculate the recommended daily water intake based on weight and activity level.
+
+    Args:
+        weight (float): The weight of the person in kilograms.
+        activity_minutes (float): The daily physical activity time in minutes.
+
+    Returns:
+        str: A message indicating the recommended daily water intake in liters.
+             Returns an error message for invalid input.
+
+    Examples:
+        >>> calculate_water_intake(70, 30)
+        'Recommended daily water intake: 2.85 liters'
+        >>> calculate_water_intake(50, 60)
+        'Recommended daily water intake: 2.60 liters'
+        >>> calculate_water_intake(-70, 30)
+        'Invalid input. Weight and activity minutes must be greater than zero.'
+    """
+    # Validate input: weight and activity_minutes must be positive
+    if weight <= 0 or activity_minutes < 0:
+        return "Invalid input. Weight and activity minutes must be greater than zero."
+
+    # Base water requirement: 0.033 liters per kg of body weight
+    base_water_intake = weight * 0.033
+
+    # Additional water requirement: 0.012 liters per minute of physical activity
+    additional_water_intake = activity_minutes * 0.012
+
+    # Total water intake
+    total_water_intake = base_water_intake + additional_water_intake
+
+    # Format result to two decimal places
+    return f"Recommended daily water intake: {total_water_intake:.2f} liters"
+
+
+# Example usage (uncomment the following lines to test):
+# print(calculate_water_intake(70, 30))  # Output: 'Recommended daily water intake: 2.85 liters'
+# print(calculate_water_intake(50, 60))  # Output: 'Recommended daily water intake: 2.60 liters'
+# print(calculate_water_intake(-70, 30))  # Output: 'Invalid input. Weight and activity minutes must be greater than zero.'