Resolve conflict: keep main version of collaboration/learning_goals.md

.github/PULL_REQUEST_TEMPLATE.md

@@ -54,8 +54,10 @@ about: A template PR for code review with a checklist
 
 - [ ] The function's name describes it's behavior
 - [ ] The function's name matches the file name
+  - _It's ok to have extra helper functions if necessary, like with mergesort_
 - [ ] The function has correct type annotations
-- [ ] The function is not called in the function file
+- [ ] The function is not called at the top level of the function file 
+  - _Recursive solutions **can** call the function from **inside** the function body_
 
 ## Strategy
 
@@ -67,7 +69,7 @@ about: A template PR for code review with a checklist
 
 ### Don'ts
 
-- [ ] The function's strategy _is not_ described in the documentation
+- [ ] The function's strategy _is not_ described in any docstrings or tests
 - [ ] Comments explain the _strategy_, **not** the _implementation_
 - [ ] The function _does not_ have more comments than code
   - If it does, consider finding a new strategy or a simpler implementation

README.md

@@ -0,0 +1,66 @@
+# ZeroThroughTen 🚀
+
+Welcome to **ZeroThroughTen**,  
+a dynamic group of passionate learners united by a shared enthusiasm for coding, collaboration, and creative problem-solving. 🌟 Together, we transform challenges into stepping stones for growth, innovation, and success. 💡
+
+At ZeroThroughTen, every contribution matters, every voice is heard, and every member is an integral part of our journey. We believe in learning, growing, and achieving **as a team**—where the strength of one enhances the power of all. 🤝
+
+---
+
+## ✨ **About Us**
+
+We are **ZeroThroughTen**, a group of enthusiastic problem-solvers driven by curiosity, creativity, and a commitment to mastering programming skills. We don't just solve problems—we redefine them, turning challenges into opportunities to build impactful and meaningful solutions. 🚀
+
+Our group thrives on collaboration, where every idea adds value and every challenge is tackled together. Whether it’s debugging code, brainstorming new ideas, or building innovative solutions, we’re here to **shine brighter, together. 🌈**
+
+---
+
+## 🛠️ **Our Mission**
+
+- **Learn and Grow**: Sharpen programming and problem-solving skills through hands-on collaboration and experimentation.
+- **Collaborate to Innovate**: Build impactful projects while fostering a culture of open communication and shared knowledge.
+- **Master the Tools**: Enhance familiarity with GitHub workflows, version control, and best coding practices.
+- **Support Each Other**: Cultivate an inclusive and inspiring team environment where every member feels valued.
+
+---
+
+## 🔗 **Communication Channels**
+
+- **Slack**: Daily updates, task discussions, and real-time collaboration.  
+- **Weekly Meetings**: Thursdays at 7:00 PM CET (Central European Time) on Zoom.  
+- **GitHub**: Central hub for code contributions, pull requests, and documentation.  
+
+> Remember, teamwork is the heart of ZeroThroughTen! 💬
+
+---
+
+## 🧩 **Our Values**
+
+1. **Collaboration**: Together, we achieve more.  
+2. **Respect**: Every idea matters, every voice counts.  
+3. **Curiosity**: Always stay curious, always stay creative.  
+4. **Accountability**: Take ownership of your tasks while supporting your teammates.  
+5. **Excellence**: Strive for clean, efficient, and impactful solutions.  
+
+---
+
+## 📝 **Our Goals**
+
+- Build a collaborative project where every member contributes meaningfully.  
+- Learn to review and improve code collaboratively.  
+- Explore new tools, frameworks, and technologies together.  
+- Develop solutions that are innovative, efficient, and impactful.  
+
+---
+
+## 🎉 **Acknowledgments**
+
+A huge **shoutout** to every member of **ZeroThroughTen** for their dedication, hard work, and creativity. 💪  
+Each step we take, each line of code we write, brings us closer to our goals—**one breakthrough at a time. 🌟**
+
+Let’s continue to learn, grow, and shine together. ✨  
+**Remember, from zero through ten, the possibilities are infinite. 🔢**
+
+---
+
+Stay curious. Stay creative. Keep coding. 🚀

collaboration/README.md

@@ -1,11 +1,11 @@
 # Collaboration
 
-## Group “ET6-foundations-group-10”
+## Group “ZeroThroughTen”
 
-The group is focused on professional communication in developing the _**''“ET6-foundations-group-10”**_ project to implement the _Foundations Track_ syllabus of the [_MIT Emerging Talent_](https://emergingtalent.mit.edu/) program.
+The group is focused on professional communication in developing the _**“ZeroThroughTen”**_ project to implement the _Foundations Track_ syllabus of the [_MIT Emerging Talent_](https://emergingtalent.mit.edu/) program.
 
 ### Norms of the group
 
-1. We try to communicate on a professional level on issues related to the project  “ET6-foundations-group-10” development and implementation of the Foundations Track syllabus of the MIT Emerging Talent program. We do not touch on issues of personal characteristics, religious beliefs, political views, or level of competence.
-2. We communicate asynchronously using Slack and GitHub tools, so our communication needs to be documented and other group members can view the subject of the communication, the discussion itself, and the results of the communication.
+1. We try to communicate on a professional level on the issues related to the project development and implementation according to the Foundations Track syllabus of the MIT Emerging Talent program. We do not touch on issues of personal characteristics, religious beliefs, political views, or level of competence.
+2. We communicate asynchronously using Slack and GitHub tools, so our communication needs to be documented to allow other group members to view the subject of the communication, the discussion itself, and the results of the communication.
 3. All group meetings are scheduled in advance so that other group members can organize their time. All group communication is documented. Personal communication can take place online.

collaboration/learning_goals.md

@@ -0,0 +1,37 @@
+# Learning Goals
+
+## Group Objectives
+
+The primary goal of our group is to enhance our understanding and practical skills in software development by working collaboratively on exercises. Each member brings unique objectives, and we aim to create a supportive environment where these individual goals can be achieved.
+
+## Collective
+
+1. **Enhance Problem-Solving Skills**: Apply data structures (DSs) and algorithms to solve complex problems effectively.
+2. **Learn and Practice New Techniques**: Explore new programming language features and techniques to improve code quality.
+3. **Focus on Readability and Documentation**: Develop solutions that are well-documented, clear, and maintainable.
+4. **Improve Development Speed**: Practice strategies to write and debug code faster, aiming for efficiency.
+5. **Collaborative Code Reviews**: Engage in multiple review cycles to learn from feedback and refine solutions collaboratively.
+
+---
+
+## Individual
+
+### Emre Biyik
+
+- Review data structures and algorithms studied previously.
+- Focus on writing more complete and readable solutions.
+- Gain deeper experience with version control tools like Git and GitHub, especially in team projects.
+
+### Oleksandr Maksymikhin
+
+- Study the Python programming language.
+- Improve skills for participation in group projects using the version control system GitHub.
+- Investigate the functionality of GitHub (Issues, Project Board, Actions, CI/CD).
+
+---
+
+## Group Approach
+
+- Regularly review and reflect on progress towards these goals during meetings.
+- Support each other in achieving individual and shared objectives through collaborative exercises.
+- Use tools like GitHub Issues and Project Boards to ensure visibility and accountability.

collaboration/retrospective.md

@@ -1,23 +1,77 @@
-<!-- this template is for inspiration, feel free to change it however you like! -->
-
 # Retrospective
 
+> “Regardless of what we discover, we understand and truly believe that everyone  
+> did the best job they could, given what they knew at the time, their skills  
+> and abilities, the resources available, and the situation at hand.”  
+>
+> - [Norm Kerth](http://www.amazon.com/Project-Retrospectives-Handbook-Reviews-Dorset-ebook/dp/B00DY3KQJU/ref=tmm_kin_swatch_0?_encoding=UTF8&sr=&qid=)
+
+---
+
 ## Stop Doing
 
+- **Challenges Faced:**
+  - Initial difficulties in understanding the complete GitHub workflow.
+  - Errors during the push process from local machines to GitHub, such as merge conflicts or incomplete changes.
+  - Limited initial familiarity with GitHub’s collaborative features, leading to delays in resolving issues.
+
+*Takeaway:* Invest more time in understanding GitHub tools and workflows at the start of the project to minimize errors and delays.
+
+---
+
 ## Continue Doing
 
+- **What Worked Well:**
+  - Collaborative problem-solving improved over time, especially during CI/CD checks and error resolution.
+  - Regular document reviews and feedback fostered team learning and improved overall quality.
+  - Clear documentation and communication in Slack channels helped the team address challenges effectively.
+
+*Takeaway:* Continue building on strong collaboration and communication practices.
+
+---
+
 ## Start Doing
 
+- **New Ideas for Future Projects:**
+  - Document the step-by-step GitHub workflow for all team members to refer to during the project.
+  - Establish a shared resource for documenting common errors and solutions (e.g., troubleshooting merge conflicts or CI errors).
+  - Schedule regular review sessions to identify errors earlier in the project lifecycle.
+
+*Takeaway:* Implement these strategies to ensure a smoother and more efficient workflow in future projects.
+
+---
+
 ## Lessons Learned
 
-______________________________________________________________________
+- Working on the GitHub Team Project provided invaluable insights into:
+  - Pushing updates from local machines to GitHub and managing version control.
+  - Troubleshooting challenges like merge conflicts, rough draft errors, and CI/CD issues.
+  - Reviewing, commenting, and improving code collaboratively.
+  - Observing the step-by-step lifecycle of a project, from initiation to finalization.
+  - The importance of effective communication and documentation in ensuring project success.
+
+These lessons enhanced both technical and collaboration skills, laying the foundation for better teamwork in future projects.
+
+---
 
 ## Strategy vs. Board
 
-### What parts of your plan went as expected?
+- **What parts of your plan went as expected?**  
+  - GitHub collaboration improved over time with regular communication and troubleshooting.
+  - Document reviews and feedback loops were successfully implemented.  
+
+- **What parts of your plan did not work out?**  
+  - Early misunderstandings of GitHub workflows caused delays.  
+
+- **Did you need to add things that weren't in your strategy?**  
+  - Yes, additional time and resources were allocated for troubleshooting and learning GitHub features.  
 
-### What parts of your plan did not work out?
+- **Or remove extra steps?**  
+  - Simplifying the review and feedback process helped focus on key areas.
 
-### Did you need to add things that weren't in your strategy?
+---
 
-### Or remove extra steps?
+This retrospective reflects the challenges, achievements, and lessons learned during the GitHub Team Project.  
+The project provided an invaluable opportunity to see a software development process in its entirety, from local pushes to collaborative reviews and debugging.  
+Moving forward, these experiences will guide us in delivering even more efficient and successful projects.  
+Thank you all for your dedication and effort!

solutions/README.md

@@ -1 +1,21 @@
 # Solutions
+
+## Palindrome Checker
+
+This module checks if a given string is a palindrome. A palindrome reads the same backward as forward, ignoring case and spaces.
+
+### How to Use
+
+1. Run the `is_palindrome.py` file to use the function.
+2. Use `test_is_palindrome.py` to test the functionality.
+
+#### Examples
+
+```python
+>>> from is_palindrome import is_palindrome
+>>> is_palindrome("level")
+True
+>>> is_palindrome("hello")
+False
+>>> is_palindrome("A man a plan a canal Panama")
+True

solutions/ascending_order_18/ascending_order.py

@@ -0,0 +1,32 @@
+"""this is a solution for the ascending order problem."""
+
+
+def sort_numbers(num_list):
+    """
+    Sorts a list of numbers in ascending order.
+
+    Args:
+        num_list (list): A list of numbers (integers or floats).
+
+    Returns:
+        list: A new list containing the numbers sorted in ascending order.
+    """
+    return sorted(num_list)
+
+
+def get_input():
+    """
+    Takes a comma-separated string input from the user
+    converts it to a list of numbers, and sorts them.
+
+    Returns:
+        list: A sorted list of numbers.
+    """
+    user_input = input("Enter a list of numbers separated by commas: ")
+    num_list = [int(num.strip()) for num in user_input.split(",")]
+    return sort_numbers(num_list)
+
+
+if __name__ == "__main__":
+    sorted_list = get_input()
+    print(f"Sorted list: {sorted_list}")

solutions/bubble_sort.py

@@ -0,0 +1,72 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+A module for sorting collection using bubble sort algorithm.
+Processed types: int, float, str, bool
+
+Module contents:
+    - bubble_sort: sort the collection in ascending order.
+
+Created on 2024-01-02
+Author: Oleksandr Maksymikhin
+"""
+
+from typing import TypeVar
+
+T = TypeVar("T", int, float, str, bool)
+
+
+# def bubble_sort(input_collection: list[int]) -> list[int]:
+def bubble_sort(input_collection: list[T]) -> list[T]:
+    """Sort collection using bubble sort algorithm.
+
+    Sort elements in collection by swapping and moving larger elements to the end of collection.
+
+    Parameters:
+      input_collection: list[T], collection of unsorted data with data types (T): int, float, str, bool.
+
+    Returns -> list[T], collection of sorted elements with data types (T): int, float, str, bool.
+
+    Raises:
+      AssertionError: if input is not a collection.
+      AssertionError: if collection contains elements of different data types (non-homogeneous).
+
+    Examples:
+    >>> bubble_sort([1])
+    [1]
+    >>> bubble_sort([1, 3, 2])
+    [1, 2, 3]
+    >>> bubble_sort([3, 2, 100500, 1])
+    [1, 2, 3, 100500]
+    """
+
+    # defensive assertion to check that input is a collection list
+    assert isinstance(input_collection, list), "Input is not a collection"
+
+    # defensive assertion to check that collection is homogeneous
+    assert all(
+        isinstance(item, type(input_collection[0])) for item in input_collection
+    ), "Input collection is not homogeneous"
+
+    # copy collection to avoid side effect
+    collection = input_collection.copy()
+    # define collection length
+    collection_length = len(collection)
+    # first loop to traverse the collection
+    for current_item_index in range(collection_length):
+        # flag to break if the last run didn't swap any item
+        already_sorted = True
+        # second loop to compare/swap item with adjacent one
+        for swap_index in range(collection_length - current_item_index - 1):
+            # swap items if the next adjacent item is smaller
+            if collection[swap_index] > collection[swap_index + 1]:
+                (collection[swap_index], collection[swap_index + 1]) = (
+                    collection[swap_index + 1],
+                    collection[swap_index],
+                )
+                already_sorted = False
+        # break loop if the last run didn't swap any item
+        if already_sorted:
+            break
+    # return sorted collection
+    return collection